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 program to record from default audio input and playback to default audio output. 18 // It will generate feedback (Larsen effect) if played through on-device speakers, 19 // or acts as a delay if played through headset. 20 21 #include <SLES/OpenSLES.h> 22 #include <SLES/OpenSLES_Android.h> 23 #include <assert.h> 24 #include <pthread.h> 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <unistd.h> 29 30 #define ASSERT_EQ(x, y) do { if ((x) == (y)) ; else { fprintf(stderr, "0x%x != 0x%x\n", \ 31 (unsigned) (x), (unsigned) (y)); assert((x) == (y)); } } while (0) 32 33 // default values 34 static SLuint32 rxBufCount = 2; // -r# 35 static SLuint32 txBufCount = 2; // -t# 36 static SLuint32 bufSizeInFrames = 512; // -f# 37 static SLuint32 channels = 1; // -c# 38 static SLuint32 sampleRate = 44100; // -s# 39 static SLuint32 exitAfterSeconds = 60; // -e# 40 static SLuint32 freeBufCount = 0; // calculated 41 static SLuint32 bufSizeInBytes = 0; // calculated 42 43 // Storage area for the buffer queues 44 static char **rxBuffers; 45 static char **txBuffers; 46 static char **freeBuffers; 47 48 // Buffer indices 49 static SLuint32 rxFront; // oldest recording 50 static SLuint32 rxRear; // next to be recorded 51 static SLuint32 txFront; // oldest playing 52 static SLuint32 txRear; // next to be played 53 static SLuint32 freeFront; // oldest free 54 static SLuint32 freeRear; // next to be freed 55 56 static SLAndroidSimpleBufferQueueItf recorderBufferQueue; 57 static SLBufferQueueItf playerBufferQueue; 58 59 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 60 61 // Called after audio recorder fills a buffer with data 62 static void recorderCallback(SLAndroidSimpleBufferQueueItf caller, void *context) 63 { 64 SLresult result; 65 66 pthread_mutex_lock(&mutex); 67 68 // We should only be called when a recording buffer is done 69 assert(rxFront <= rxBufCount); 70 assert(rxRear <= rxBufCount); 71 assert(rxFront != rxRear); 72 char *buffer = rxBuffers[rxFront]; 73 74 // Remove buffer from record queue 75 if (++rxFront > rxBufCount) { 76 rxFront = 0; 77 } 78 79 // Enqueue the just-filled buffer for the player 80 result = (*playerBufferQueue)->Enqueue(playerBufferQueue, buffer, bufSizeInBytes); 81 if (SL_RESULT_SUCCESS == result) { 82 83 // There was room in the play queue, update our model of it 84 assert(txFront <= txBufCount); 85 assert(txRear <= txBufCount); 86 SLuint32 txRearNext = txRear+1; 87 if (txRearNext > txBufCount) { 88 txRearNext = 0; 89 } 90 assert(txRearNext != txFront); 91 txBuffers[txRear] = buffer; 92 txRear = txRearNext; 93 94 } else { 95 96 // Here if record has a filled buffer to play, but play queue is full. 97 assert(SL_RESULT_BUFFER_INSUFFICIENT == result); 98 write(1, "?", 1); 99 100 // We could either try again later, or discard. For now we discard and re-use buffer. 101 // Enqueue this same buffer for the recorder to fill again. 102 result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, buffer, bufSizeInBytes); 103 ASSERT_EQ(SL_RESULT_SUCCESS, result); 104 105 // Update our model of the record queue 106 SLuint32 rxRearNext = rxRear+1; 107 if (rxRearNext > rxBufCount) { 108 rxRearNext = 0; 109 } 110 assert(rxRearNext != rxFront); 111 rxBuffers[rxRear] = buffer; 112 rxRear = rxRearNext; 113 114 } 115 116 pthread_mutex_unlock(&mutex); 117 } 118 119 120 // Called after audio player empties a buffer of data 121 static void playerCallback(SLBufferQueueItf caller, void *context) 122 { 123 SLresult result; 124 125 pthread_mutex_lock(&mutex); 126 127 // Get the buffer that just finished playing 128 assert(txFront <= txBufCount); 129 assert(txRear <= txBufCount); 130 assert(txFront != txRear); 131 char *buffer = txBuffers[txFront]; 132 if (++txFront > txBufCount) { 133 txFront = 0; 134 } 135 136 // First try to enqueue the free buffer for recording 137 result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, buffer, bufSizeInBytes); 138 if (SL_RESULT_SUCCESS == result) { 139 140 // There was room in the record queue, update our model of it 141 assert(rxFront <= rxBufCount); 142 assert(rxRear <= rxBufCount); 143 SLuint32 rxRearNext = rxRear+1; 144 if (rxRearNext > rxBufCount) { 145 rxRearNext = 0; 146 } 147 assert(rxRearNext != rxFront); 148 rxBuffers[rxRear] = buffer; 149 rxRear = rxRearNext; 150 151 } else { 152 153 // Here if record queue is full 154 assert(SL_RESULT_BUFFER_INSUFFICIENT == result); 155 156 // Instead enqueue the free buffer on the free queue 157 assert(freeFront <= freeBufCount); 158 assert(freeRear <= freeBufCount); 159 SLuint32 freeRearNext = freeRear+1; 160 if (freeRearNext > freeBufCount) { 161 freeRearNext = 0; 162 } 163 // There must always be room in the free queue 164 assert(freeRearNext != freeFront); 165 freeBuffers[freeRear] = buffer; 166 freeRear = freeRearNext; 167 168 } 169 170 pthread_mutex_unlock(&mutex); 171 } 172 173 // Main program 174 int main(int argc, char **argv) 175 { 176 // process command-line options 177 int i; 178 for (i = 1; i < argc; ++i) { 179 char *arg = argv[i]; 180 if (arg[0] != '-') { 181 break; 182 } 183 // -r# number of slots in receive buffer queue 184 if (!strncmp(arg, "-r", 2)) { 185 rxBufCount = atoi(&arg[2]); 186 if (rxBufCount < 1 || rxBufCount > 16) { 187 fprintf(stderr, "%s: unusual receive buffer queue size (%u buffers)\n", argv[0], 188 (unsigned) rxBufCount); 189 } 190 // -t# number of slots in transmit buffer queue 191 } else if (!strncmp(arg, "-t", 2)) { 192 txBufCount = atoi(&arg[2]); 193 if (txBufCount < 1 || txBufCount > 16) { 194 fprintf(stderr, "%s: unusual transmit buffer queue size (%u buffers)\n", argv[0], 195 (unsigned) txBufCount); 196 } 197 // -f# size of each buffer in frames 198 } else if (!strncmp(arg, "-f", 2)) { 199 bufSizeInFrames = atoi(&arg[2]); 200 if (bufSizeInFrames == 0) { 201 fprintf(stderr, "%s: unusual buffer size (%u frames)\n", argv[0], 202 (unsigned) bufSizeInFrames); 203 } 204 // -c1 mono or -c2 stereo 205 } else if (!strncmp(arg, "-c", 2)) { 206 channels = atoi(&arg[2]); 207 if (channels < 1 || channels > 2) { 208 fprintf(stderr, "%s: unusual channel count ignored (%u)\n", argv[0], 209 (unsigned) channels); 210 channels = 2; 211 } 212 // -s# sample rate in Hz 213 } else if (!strncmp(arg, "-s", 2)) { 214 sampleRate = atoi(&arg[2]); 215 switch (sampleRate) { 216 case 8000: 217 case 11025: 218 case 12000: 219 case 16000: 220 case 22050: 221 case 24000: 222 case 32000: 223 case 44100: 224 case 48000: 225 break; 226 default: 227 fprintf(stderr, "%s: unusual sample rate (%u Hz)\n", argv[0], 228 (unsigned) sampleRate); 229 break; 230 } 231 // -e# exit after this many seconds 232 } else if (!strncmp(arg, "-e", 2)) { 233 exitAfterSeconds = atoi(&arg[2]); 234 } else 235 fprintf(stderr, "%s: unknown option %s\n", argv[0], arg); 236 } 237 // no other arguments allowed 238 if (i < argc) { 239 fprintf(stderr, "usage: %s -r# -t# -f# -s# -c#\n", argv[0]); 240 fprintf(stderr, " -r# receive buffer queue count for microphone input, default 1\n"); 241 fprintf(stderr, " -t# transmit buffer queue count for speaker output, default 2\n"); 242 fprintf(stderr, " -f# number of frames per buffer, default 512\n"); 243 fprintf(stderr, " -s# sample rate in Hz, default 44100\n"); 244 fprintf(stderr, " -c1 mono\n"); 245 fprintf(stderr, " -c2 stereo, default\n"); 246 } 247 // compute total free buffers as -r plus -t 248 freeBufCount = rxBufCount + txBufCount; 249 // compute buffer size 250 bufSizeInBytes = channels * bufSizeInFrames * sizeof(short); 251 252 // Initialize free buffers 253 freeBuffers = (char **) calloc(freeBufCount+1, sizeof(char *)); 254 unsigned j; 255 for (j = 0; j < freeBufCount; ++j) { 256 freeBuffers[j] = (char *) malloc(bufSizeInBytes); 257 } 258 freeFront = 0; 259 freeRear = freeBufCount; 260 freeBuffers[j] = NULL; 261 262 // Initialize record queue 263 rxBuffers = (char **) calloc(rxBufCount+1, sizeof(char *)); 264 rxFront = 0; 265 rxRear = 0; 266 267 // Initialize play queue 268 txBuffers = (char **) calloc(txBufCount+1, sizeof(char *)); 269 txFront = 0; 270 txRear = 0; 271 272 SLresult result; 273 274 // create engine 275 SLObjectItf engineObject; 276 result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL); 277 ASSERT_EQ(SL_RESULT_SUCCESS, result); 278 result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE); 279 ASSERT_EQ(SL_RESULT_SUCCESS, result); 280 SLEngineItf engineEngine; 281 result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine); 282 ASSERT_EQ(SL_RESULT_SUCCESS, result); 283 284 // create output mix 285 SLObjectItf outputmixObject; 286 result = (*engineEngine)->CreateOutputMix(engineEngine, &outputmixObject, 0, NULL, NULL); 287 ASSERT_EQ(SL_RESULT_SUCCESS, result); 288 result = (*outputmixObject)->Realize(outputmixObject, SL_BOOLEAN_FALSE); 289 ASSERT_EQ(SL_RESULT_SUCCESS, result); 290 291 // create an audio player with buffer queue source and output mix sink 292 SLDataSource audiosrc; 293 SLDataSink audiosnk; 294 SLDataFormat_PCM pcm; 295 SLDataLocator_OutputMix locator_outputmix; 296 SLDataLocator_BufferQueue locator_bufferqueue_tx; 297 locator_bufferqueue_tx.locatorType = SL_DATALOCATOR_BUFFERQUEUE; 298 locator_bufferqueue_tx.numBuffers = txBufCount; 299 locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX; 300 locator_outputmix.outputMix = outputmixObject; 301 pcm.formatType = SL_DATAFORMAT_PCM; 302 pcm.numChannels = channels; 303 pcm.samplesPerSec = sampleRate * 1000; 304 pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16; 305 pcm.containerSize = 16; 306 pcm.channelMask = channels == 1 ? SL_SPEAKER_FRONT_CENTER : 307 (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT); 308 pcm.endianness = SL_BYTEORDER_LITTLEENDIAN; 309 audiosrc.pLocator = &locator_bufferqueue_tx; 310 audiosrc.pFormat = &pcm; 311 audiosnk.pLocator = &locator_outputmix; 312 audiosnk.pFormat = NULL; 313 SLObjectItf playerObject = NULL; 314 SLObjectItf recorderObject = NULL; 315 SLInterfaceID ids_tx[1] = {SL_IID_BUFFERQUEUE}; 316 SLboolean flags_tx[1] = {SL_BOOLEAN_TRUE}; 317 result = (*engineEngine)->CreateAudioPlayer(engineEngine, &playerObject, &audiosrc, &audiosnk, 318 1, ids_tx, flags_tx); 319 if (SL_RESULT_CONTENT_UNSUPPORTED == result) { 320 fprintf(stderr, "Could not create audio player (result %x), check sample rate\n", result); 321 goto cleanup; 322 } 323 ASSERT_EQ(SL_RESULT_SUCCESS, result); 324 result = (*playerObject)->Realize(playerObject, SL_BOOLEAN_FALSE); 325 ASSERT_EQ(SL_RESULT_SUCCESS, result); 326 SLPlayItf playerPlay; 327 result = (*playerObject)->GetInterface(playerObject, SL_IID_PLAY, &playerPlay); 328 ASSERT_EQ(SL_RESULT_SUCCESS, result); 329 result = (*playerObject)->GetInterface(playerObject, SL_IID_BUFFERQUEUE, &playerBufferQueue); 330 ASSERT_EQ(SL_RESULT_SUCCESS, result); 331 result = (*playerBufferQueue)->RegisterCallback(playerBufferQueue, playerCallback, NULL); 332 ASSERT_EQ(SL_RESULT_SUCCESS, result); 333 result = (*playerPlay)->SetPlayState(playerPlay, SL_PLAYSTATE_PLAYING); 334 ASSERT_EQ(SL_RESULT_SUCCESS, result); 335 336 // Create an audio recorder with microphone device source and buffer queue sink. 337 // The buffer queue as sink is an Android-specific extension. 338 339 SLDataLocator_IODevice locator_iodevice; 340 SLDataLocator_AndroidSimpleBufferQueue locator_bufferqueue_rx; 341 locator_iodevice.locatorType = SL_DATALOCATOR_IODEVICE; 342 locator_iodevice.deviceType = SL_IODEVICE_AUDIOINPUT; 343 locator_iodevice.deviceID = SL_DEFAULTDEVICEID_AUDIOINPUT; 344 locator_iodevice.device = NULL; 345 audiosrc.pLocator = &locator_iodevice; 346 audiosrc.pFormat = NULL; 347 locator_bufferqueue_rx.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE; 348 locator_bufferqueue_rx.numBuffers = rxBufCount; 349 audiosnk.pLocator = &locator_bufferqueue_rx; 350 audiosnk.pFormat = &pcm; 351 { 352 SLInterfaceID ids_rx[1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE}; 353 SLboolean flags_rx[1] = {SL_BOOLEAN_TRUE}; 354 result = (*engineEngine)->CreateAudioRecorder(engineEngine, &recorderObject, &audiosrc, 355 &audiosnk, 1, ids_rx, flags_rx); 356 if (SL_RESULT_SUCCESS != result) { 357 fprintf(stderr, "Could not create audio recorder (result %x), " 358 "check sample rate and channel count\n", result); 359 goto cleanup; 360 } 361 } 362 ASSERT_EQ(SL_RESULT_SUCCESS, result); 363 result = (*recorderObject)->Realize(recorderObject, SL_BOOLEAN_FALSE); 364 ASSERT_EQ(SL_RESULT_SUCCESS, result); 365 SLRecordItf recorderRecord; 366 result = (*recorderObject)->GetInterface(recorderObject, SL_IID_RECORD, &recorderRecord); 367 ASSERT_EQ(SL_RESULT_SUCCESS, result); 368 result = (*recorderObject)->GetInterface(recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, 369 &recorderBufferQueue); 370 ASSERT_EQ(SL_RESULT_SUCCESS, result); 371 result = (*recorderBufferQueue)->RegisterCallback(recorderBufferQueue, recorderCallback, NULL); 372 ASSERT_EQ(SL_RESULT_SUCCESS, result); 373 374 // Enqueue some empty buffers for the recorder 375 for (j = 0; j < rxBufCount; ++j) { 376 377 // allocate a free buffer 378 assert(freeFront != freeRear); 379 char *buffer = freeBuffers[freeFront]; 380 if (++freeFront > freeBufCount) { 381 freeFront = 0; 382 } 383 384 // put on record queue 385 SLuint32 rxRearNext = rxRear + 1; 386 if (rxRearNext > rxBufCount) { 387 rxRearNext = 0; 388 } 389 assert(rxRearNext != rxFront); 390 rxBuffers[rxRear] = buffer; 391 rxRear = rxRearNext; 392 result = (*recorderBufferQueue)->Enqueue(recorderBufferQueue, 393 buffer, bufSizeInBytes); 394 ASSERT_EQ(SL_RESULT_SUCCESS, result); 395 } 396 397 // Kick off the recorder 398 result = (*recorderRecord)->SetRecordState(recorderRecord, SL_RECORDSTATE_RECORDING); 399 ASSERT_EQ(SL_RESULT_SUCCESS, result); 400 401 // Wait patiently 402 do { 403 usleep(1000000); 404 write(1, ".", 1); 405 SLBufferQueueState playerBQState; 406 result = (*playerBufferQueue)->GetState(playerBufferQueue, &playerBQState); 407 ASSERT_EQ(SL_RESULT_SUCCESS, result); 408 SLAndroidSimpleBufferQueueState recorderBQState; 409 result = (*recorderBufferQueue)->GetState(recorderBufferQueue, &recorderBQState); 410 ASSERT_EQ(SL_RESULT_SUCCESS, result); 411 } while (--exitAfterSeconds); 412 413 // Tear down the objects and exit 414 cleanup: 415 if (NULL != playerObject) { 416 (*playerObject)->Destroy(playerObject); 417 } 418 if (NULL != recorderObject) { 419 (*recorderObject)->Destroy(recorderObject); 420 } 421 (*outputmixObject)->Destroy(outputmixObject); 422 (*engineObject)->Destroy(engineObject); 423 424 return EXIT_SUCCESS; 425 } 426
