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 /* interactive buffer queue test program */
18
19 #ifdef ANDROID
20 #define USE_ANDROID_SIMPLE_BUFFER_QUEUE // change to #undef for compatibility testing
21 #endif
22
23 #include <assert.h>
24 #include <math.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <SLES/OpenSLES.h>
29 #ifdef USE_ANDROID_SIMPLE_BUFFER_QUEUE
30 #include <SLES/OpenSLES_Android.h>
31 #endif
32 #include "getch.h"
33
34 #ifdef USE_ANDROID_SIMPLE_BUFFER_QUEUE
35 #define DATALOCATOR_BUFFERQUEUE SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
36 #define IID_BUFFERQUEUE SL_IID_ANDROIDSIMPLEBUFFERQUEUE
37 #define BufferQueueItf SLAndroidSimpleBufferQueueItf
38 #define BufferQueueState SLAndroidSimpleBufferQueueState
39 #define INDEX index
40 #else
41 #define DATALOCATOR_BUFFERQUEUE SL_DATALOCATOR_BUFFERQUEUE
42 #define IID_BUFFERQUEUE SL_IID_BUFFERQUEUE
43 #define BufferQueueItf SLBufferQueueItf
44 #define BufferQueueState SLBufferQueueState
45 #define INDEX playIndex
46 #endif
47
48 #define checkResult(r) do { if ((r) != SL_RESULT_SUCCESS) fprintf(stderr, "error %d at %s:%d\n", \
49 (int) (r), __FILE__, __LINE__); } while (0)
50
51 typedef struct {
52 short left;
53 short right;
54 } frame_t;
55
56 #define SINE_FRAMES (44100*5)
57 frame_t sine[SINE_FRAMES];
58
59 #define SQUARE_FRAMES (44100*5)
60 frame_t square[SQUARE_FRAMES];
61
62 #define SAWTOOTH_FRAMES (44100*5)
63 frame_t sawtooth[SAWTOOTH_FRAMES];
64
65 #define HALF_FRAMES (44100*5)
66 frame_t half[HALF_FRAMES];
67
68 BufferQueueItf expectedCaller = NULL;
69 void *expectedContext = NULL;
70
callback(BufferQueueItf caller,void * context)71 static void callback(BufferQueueItf caller, void *context)
72 {
73 putchar('.');
74 if (caller != expectedCaller)
75 printf("caller %p expected %p\r\n", caller, expectedCaller);
76 if (context != expectedContext)
77 printf("context %p expected %p\r\n", context, expectedContext);
78 fflush(stdout);
79 }
80
main(int argc __unused,char ** argv __unused)81 int main(int argc __unused, char **argv __unused)
82 {
83 SLresult result;
84
85 // create engine
86 SLObjectItf engineObject;
87 result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
88 checkResult(result);
89 result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
90 checkResult(result);
91 SLEngineItf engineEngine;
92 result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
93 checkResult(result);
94
95 // create output mix
96 SLObjectItf outputmixObject;
97 result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL);
98 checkResult(result);
99 result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE);
100 checkResult(result);
101
102 // create audio player
103 SLDataSource audiosrc;
104 SLDataSink audiosnk;
105 SLDataFormat_PCM pcm;
106 SLDataLocator_OutputMix locator_outputmix;
107 SLDataLocator_BufferQueue locator_bufferqueue;
108 locator_bufferqueue.locatorType = DATALOCATOR_BUFFERQUEUE;
109 locator_bufferqueue.numBuffers = 255;
110 locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
111 locator_outputmix.outputMix = outputmixObject;
112 pcm.formatType = SL_DATAFORMAT_PCM;
113 pcm.numChannels = 2;
114 pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
115 pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
116 pcm.containerSize = 16;
117 pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
118 pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
119 audiosrc.pLocator = &locator_bufferqueue;
120 audiosrc.pFormat = &pcm;
121 audiosnk.pLocator = &locator_outputmix;
122 audiosnk.pFormat = NULL;
123 SLObjectItf playerObject;
124 SLInterfaceID ids[2] = {IID_BUFFERQUEUE, SL_IID_MUTESOLO};
125 SLboolean flags[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
126 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk,
127 2, ids, flags);
128 checkResult(result);
129 result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE);
130 checkResult(result);
131 SLPlayItf playerPlay;
132 result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay);
133 checkResult(result);
134 BufferQueueItf playerBufferqueue;
135 result = (*playerObject)->GetInterface(playerObject, IID_BUFFERQUEUE, &playerBufferqueue);
136 checkResult(result);
137 SLMuteSoloItf playerMuteSolo;
138 result = (*playerObject)->GetInterface(playerObject, SL_IID_MUTESOLO, &playerMuteSolo);
139 checkResult(result);
140 SLuint8 numChannels = 123;
141 result = (*playerMuteSolo)->GetNumChannels(playerMuteSolo, &numChannels);
142 assert(2 == numChannels);
143 SLuint32 state;
144 state = SL_PLAYSTATE_PLAYING;
145 result = (*playerPlay)->SetPlayState(playerPlay, state);
146 checkResult(result);
147
148 unsigned i;
149 float pi2 = 3.14*2;
150 float hz = 441;
151 float sr = 44100;
152 for (i = 0; i < SINE_FRAMES; ++i) {
153 sine[i].left = sin((float) (i / (sr / hz)) * pi2 ) * 32000.0;
154 sine[i].right = sine[i].left;
155 }
156 for (i = 0; i < SQUARE_FRAMES; ++i) {
157 square[i].left = (i % (unsigned) (sr / hz)) < 50 ? 32767 : -32768;
158 square[i].right = square[i].left;
159 }
160 for (i = 0; i < SAWTOOTH_FRAMES; ++i) {
161 sawtooth[i].left = ((((int) (i % (unsigned) (sr / hz))) - 50) / 100.0) * 60000.0 - 30000.0;
162 sawtooth[i].right = sawtooth[i].left;
163 }
164 for (i = 0; i < HALF_FRAMES; ++i) {
165 half[i].left = sine[i].left;
166 half[i].right = sawtooth[i].right / 2;
167 }
168
169 set_conio_terminal_mode();
170 int in_count = 0;
171 uintptr_t count = 0;
172 for (;;) {
173 usleep(10000);
174 if (kbhit()) {
175 frame_t *buffer;
176 unsigned size;
177 BufferQueueState bufqstate;
178 int ch = getch();
179 switch (ch) {
180 case '0' ... '9':
181 if (in_count) {
182 count = count * 10 + (ch - '0');
183 } else {
184 count = ch - '0';
185 in_count = 1;
186 }
187 continue;
188 case 'i':
189 buffer = sine;
190 size = sizeof(sine);
191 goto enqueue;
192 case 'q':
193 buffer = square;
194 size = sizeof(square);
195 goto enqueue;
196 case 'h':
197 buffer = half;
198 size = sizeof(half);
199 goto enqueue;
200 case 'r':
201 if (in_count) {
202 expectedCaller = playerBufferqueue;
203 expectedContext = (void *) count;
204 } else {
205 expectedCaller = NULL;
206 expectedContext = (void *) NULL;
207 }
208 result = (*playerBufferqueue)->RegisterCallback(playerBufferqueue, in_count ?
209 callback : NULL, expectedContext);
210 checkResult(result);
211 break;
212 case 'a':
213 buffer = sawtooth;
214 size = sizeof(sawtooth);
215 enqueue:
216 for (i = 0; i < (in_count ? count : 1); ++i) {
217 result = (*playerBufferqueue)->Enqueue(playerBufferqueue, buffer, size);
218 checkResult(result);
219 }
220 break;
221 case 'c':
222 result = (*playerBufferqueue)->Clear(playerBufferqueue);
223 checkResult(result);
224 putchar('\r');
225 result = (*playerBufferqueue)->GetState(playerBufferqueue, &bufqstate);
226 checkResult(result);
227 if (bufqstate.count != 0)
228 printf("\rcount=%u\r\n", (unsigned) bufqstate.count);
229 #if 0
230 putchar('\r');
231 putchar('\n');
232 #endif
233 fflush(stdout);
234 break;
235 case 'g':
236 result = (*playerBufferqueue)->GetState(playerBufferqueue, &bufqstate);
237 checkResult(result);
238 printf("\rplayIndex=%u\r\n", (unsigned) bufqstate.INDEX);
239 printf("count=%u\r\n", (unsigned) bufqstate.count);
240 break;
241 case 'p':
242 state = SL_PLAYSTATE_PAUSED;
243 goto setplaystate;
244 case 's':
245 state = SL_PLAYSTATE_STOPPED;
246 goto setplaystate;
247 case 'P':
248 state = SL_PLAYSTATE_PLAYING;
249 setplaystate:
250 result = (*playerPlay)->SetPlayState(playerPlay, state);
251 checkResult(result);
252 SLuint32 newstate;
253 result = (*playerPlay)->GetPlayState(playerPlay, &newstate);
254 checkResult(result);
255 if (newstate != state)
256 printf("\rSetPlayState(%u) -> GetPlayState(%u)\r\n", (unsigned) state,
257 (unsigned) newstate);
258 #if 0
259 putchar('\r');
260 putchar('\n');
261 fflush(stdout);
262 #endif
263 checkResult(result);
264 break;
265 case 'x':
266 goto out;
267 default:
268 putchar('?');
269 fflush(stdout);
270 break;
271 }
272 in_count = 0;
273 }
274 }
275
276 out:
277 (*playerObject)->Destroy(playerObject);
278 (*outputmixObject)->Destroy(outputmixObject);
279 (*engineObject)->Destroy(engineObject);
280 return EXIT_SUCCESS;
281 }
282