1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // Test audio player configurations with URI data source and MIME data format
18
19 #include <assert.h>
20 #include <math.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24
25 #include <SLES/OpenSLES.h>
26 #ifdef ANDROID
27 #include <SLES/OpenSLES_Android.h>
28 #endif
29
main(int argc,char ** argv)30 int main(int argc, char **argv)
31 {
32 if (argc != 2) {
33 fprintf(stderr, "usage: %s URI\n", argv[0]);
34 return EXIT_FAILURE;
35 }
36
37 SLresult result;
38 SLObjectItf engineObject;
39
40 // create engine
41 result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
42 assert(SL_RESULT_SUCCESS == result);
43 SLEngineItf engineEngine;
44 result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
45 assert(SL_RESULT_SUCCESS == result);
46 result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
47 assert(SL_RESULT_SUCCESS == result);
48
49 // create output mix
50 SLObjectItf outputMixObject;
51 result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, NULL, NULL);
52 assert(SL_RESULT_SUCCESS == result);
53 result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
54 assert(SL_RESULT_SUCCESS == result);
55
56 // configure audio source
57 SLDataLocator_URI loc_uri;
58 loc_uri.locatorType = SL_DATALOCATOR_URI;
59 loc_uri.URI = (SLchar *) argv[1];
60 SLDataFormat_MIME format_mime;
61 format_mime.formatType = SL_DATAFORMAT_MIME;
62 format_mime.mimeType = NULL;
63 format_mime.containerType = SL_CONTAINERTYPE_UNSPECIFIED;
64 SLDataSource audioSrc;
65 audioSrc.pLocator = &loc_uri;
66 audioSrc.pFormat = &format_mime;
67
68 // configure audio sink
69 SLDataLocator_OutputMix loc_outmix;
70 loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
71 loc_outmix.outputMix = outputMixObject;
72 SLDataSink audioSnk;
73 audioSnk.pLocator = &loc_outmix;
74 audioSnk.pFormat = NULL;
75
76 // create audio player, requesting a buffer queue interface
77 SLuint32 numInterfaces = 1;
78 SLInterfaceID ids[1];
79 SLboolean req[1];
80 ids[0] = SL_IID_BUFFERQUEUE;
81 req[0] = SL_BOOLEAN_TRUE;
82 SLObjectItf playerObject;
83 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
84 &audioSnk, numInterfaces, ids, req);
85 assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
86 assert(NULL == playerObject);
87 #ifdef ANDROID
88 ids[0] = SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
89 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
90 &audioSnk, numInterfaces, ids, req);
91 assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
92 assert(NULL == playerObject);
93 #endif
94
95 // create audio player, without requesting a buffer queue interface
96 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audioSrc,
97 &audioSnk, 0, NULL, NULL);
98 assert(SL_RESULT_SUCCESS == result);
99
100 // realize the player
101 result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
102 assert(SL_RESULT_SUCCESS == result);
103
104 // get the play interface
105 SLPlayItf playerPlay;
106 result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
107 assert(SL_RESULT_SUCCESS == result);
108
109 // get the buffer queue interface
110 SLBufferQueueItf playerBufferQueue;
111 result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &playerBufferQueue);
112 assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
113 assert(NULL == playerBufferQueue);
114 #ifdef ANDROID
115 SLAndroidSimpleBufferQueueItf playerAndroidSimpleBufferQueue;
116 result = (*playerObject)->GetInterface(playerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
117 &playerAndroidSimpleBufferQueue);
118 assert(SL_RESULT_FEATURE_UNSUPPORTED == result);
119 assert(NULL == playerAndroidSimpleBufferQueue);
120 #endif
121
122 // get the player duration
123 SLmillisecond duration;
124 result = (*playerPlay)->GetDuration(playerPlay, &duration);
125 assert(SL_RESULT_SUCCESS == result);
126 if (SL_TIME_UNKNOWN == duration)
127 printf("Duration: unknown\n");
128 else
129 printf("Duration: %.1f\n", duration / 1000.0f);
130
131 // set the player's state to playing
132 result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING);
133 assert(SL_RESULT_SUCCESS == result);
134
135 // wait for the playback to finish
136 for (;;) {
137 SLuint32 playState;
138 result = (*playerPlay)->GetPlayState(playerPlay, &playState);
139 assert(SL_RESULT_SUCCESS == result);
140 if (SL_PLAYSTATE_PLAYING != playState) {
141 break;
142 }
143 usleep(10000);
144 }
145
146 // get the player duration
147 result = (*playerPlay)->GetDuration(playerPlay, &duration);
148 assert(SL_RESULT_SUCCESS == result);
149 if (SL_TIME_UNKNOWN == duration)
150 printf("Duration: unknown\n");
151 else
152 printf("Duration: %.1f\n", duration / 1000.0f);
153
154 // destroy audio player
155 (*playerObject)->Destroy(playerObject);
156
157 // destroy output mix
158 (*outputMixObject)->Destroy(outputMixObject);
159
160 // destroy engine
161 (*engineObject)->Destroy(engineObject);
162
163 return EXIT_SUCCESS;
164 }
165