1 /* 2 * Copyright (C) 2011 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 /* AAC ADTS Decode Test 18 19 First run the program from shell: 20 # slesTestDecodeAac /sdcard/myFile.adts 21 22 Expected output: 23 OpenSL ES test slesTestDecodeAac: decodes a file containing AAC ADTS data 24 Player created 25 Player realized 26 Enqueueing initial empty buffers to receive decoded PCM data 0 1 27 Enqueueing initial full buffers of encoded ADTS data 0 1 28 Starting to decode 29 Frame counters: encoded=4579 decoded=4579 30 31 These use adb on host to retrieve the decoded file: 32 % adb pull /sdcard/myFile.adts.raw myFile.raw 33 34 How to examine the output with Audacity: 35 Project / Import raw data 36 Select myFile.raw file, then click Open button 37 Choose these options: 38 Signed 16-bit PCM 39 Little-endian 40 1 Channel (Mono) / 2 Channels (Stereo) based on the PCM information obtained when decoding 41 Sample rate based on the PCM information obtained when decoding 42 Click Import button 43 44 */ 45 46 #define QUERY_METADATA 47 48 #include <assert.h> 49 #include <stdlib.h> 50 #include <stdio.h> 51 #include <string.h> 52 #include <unistd.h> 53 #include <sys/time.h> 54 #include <fcntl.h> 55 #include <pthread.h> 56 #include <sys/mman.h> 57 #include <sys/stat.h> 58 #include <unistd.h> 59 #include <cpustats/CentralTendencyStatistics.h> 60 61 #include <SLES/OpenSLES.h> 62 #include <SLES/OpenSLES_Android.h> 63 64 /* Explicitly requesting SL_IID_ANDROIDBUFFERQUEUE and SL_IID_ANDROIDSIMPLEBUFFERQUEUE 65 * on the AudioPlayer object for decoding, and 66 * SL_IID_METADATAEXTRACTION for retrieving the format of the decoded audio. 67 */ 68 #define NUM_EXPLICIT_INTERFACES_FOR_PLAYER 4 69 70 /* Number of decoded samples produced by one AAC frame; defined by the standard */ 71 #define SAMPLES_PER_AAC_FRAME 1024 72 /* Size of the encoded AAC ADTS buffer queue */ 73 #define NB_BUFFERS_IN_ADTS_QUEUE 2 // 2 to 4 is typical 74 75 /* Size of the decoded PCM buffer queue */ 76 #define NB_BUFFERS_IN_PCM_QUEUE 2 // 2 to 4 is typical 77 /* Size of each PCM buffer in the queue */ 78 #define BUFFER_SIZE_IN_BYTES (2*sizeof(short)*SAMPLES_PER_AAC_FRAME) 79 80 /* Local storage for decoded PCM audio data */ 81 int8_t pcmData[NB_BUFFERS_IN_PCM_QUEUE * BUFFER_SIZE_IN_BYTES]; 82 83 /* destination for decoded data */ 84 static FILE* outputFp; 85 86 #ifdef QUERY_METADATA 87 /* metadata key index for the PCM format information we want to retrieve */ 88 static int channelCountKeyIndex = -1; 89 static int sampleRateKeyIndex = -1; 90 static int bitsPerSampleKeyIndex = -1; 91 static int containerSizeKeyIndex = -1; 92 static int channelMaskKeyIndex = -1; 93 static int endiannessKeyIndex = -1; 94 /* size of the struct to retrieve the PCM format metadata values: the values we're interested in 95 * are SLuint32, but it is saved in the data field of a SLMetadataInfo, hence the larger size. 96 * Note that this size is queried and displayed at l.XXX for demonstration/test purposes. 97 * */ 98 #define PCM_METADATA_VALUE_SIZE 32 99 /* we only want to query / display the PCM format once */ 100 static bool formatQueried = false; 101 #endif 102 103 /* to signal to the test app that the end of the encoded ADTS stream has been reached */ 104 bool eos = false; 105 bool endOfEncodedStream = false; 106 107 void *ptr; 108 unsigned char *frame; 109 size_t filelen; 110 size_t encodedFrames = 0; 111 size_t encodedSamples = 0; 112 size_t decodedFrames = 0; 113 size_t decodedSamples = 0; 114 size_t totalEncodeCompletions = 0; // number of Enqueue completions received 115 CentralTendencyStatistics frameStats; 116 size_t pauseFrame = 0; // pause after this many decoded frames, zero means don't pause 117 SLboolean createRaw = SL_BOOLEAN_TRUE; // whether to create a .raw file containing PCM data 118 119 /* constant to identify a buffer context which is the end of the stream to decode */ 120 static const int kEosBufferCntxt = 1980; // a magic value we can compare against 121 122 /* protects shared variables */ 123 pthread_mutex_t eosLock = PTHREAD_MUTEX_INITIALIZER; 124 pthread_cond_t eosCondition = PTHREAD_COND_INITIALIZER; 125 126 // These are extensions to OpenMAX AL 1.0.1 values 127 128 #define PREFETCHSTATUS_UNKNOWN ((SLuint32) 0) 129 #define PREFETCHSTATUS_ERROR ((SLuint32) (-1)) 130 131 // Mutex and condition shared with main program to protect prefetch_status 132 133 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 134 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; 135 SLuint32 prefetch_status = PREFETCHSTATUS_UNKNOWN; 136 137 /* used to detect errors likely to have occured when the OpenSL ES framework fails to open 138 * a resource, for instance because a file URI is invalid, or an HTTP server doesn't respond. 139 */ 140 #define PREFETCHEVENT_ERROR_CANDIDATE \ 141 (SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE) 142 143 //----------------------------------------------------------------- 144 /* Exits the application if an error is encountered */ 145 #define ExitOnError(x) ExitOnErrorFunc(x,__LINE__) 146 147 void ExitOnErrorFunc( SLresult result , int line) 148 { 149 if (SL_RESULT_SUCCESS != result) { 150 fprintf(stderr, "Error code %u encountered at line %d, exiting\n", result, line); 151 exit(EXIT_FAILURE); 152 } 153 } 154 155 //----------------------------------------------------------------- 156 /* Callback for "prefetch" events, here used to detect audio resource opening errors */ 157 void PrefetchEventCallback(SLPrefetchStatusItf caller, void *pContext, SLuint32 event) 158 { 159 // pContext is unused here, so we pass NULL 160 assert(pContext == NULL); 161 SLpermille level = 0; 162 SLresult result; 163 result = (*caller)->GetFillLevel(caller, &level); 164 ExitOnError(result); 165 SLuint32 status; 166 result = (*caller)->GetPrefetchStatus(caller, &status); 167 ExitOnError(result); 168 printf("prefetch level=%d status=0x%x event=%d\n", level, status, event); 169 SLuint32 new_prefetch_status; 170 if ((PREFETCHEVENT_ERROR_CANDIDATE == (event & PREFETCHEVENT_ERROR_CANDIDATE)) 171 && (level == 0) && (status == SL_PREFETCHSTATUS_UNDERFLOW)) { 172 printf("PrefetchEventCallback: Error while prefetching data, exiting\n"); 173 new_prefetch_status = PREFETCHSTATUS_ERROR; 174 } else if (event == SL_PREFETCHEVENT_STATUSCHANGE) { 175 new_prefetch_status = status; 176 } else { 177 return; 178 } 179 int ok; 180 ok = pthread_mutex_lock(&mutex); 181 assert(ok == 0); 182 prefetch_status = new_prefetch_status; 183 ok = pthread_cond_signal(&cond); 184 assert(ok == 0); 185 ok = pthread_mutex_unlock(&mutex); 186 assert(ok == 0); 187 } 188 189 //----------------------------------------------------------------- 190 /* Structure for passing information to callback function */ 191 typedef struct CallbackCntxt_ { 192 #ifdef QUERY_METADATA 193 SLMetadataExtractionItf metaItf; 194 #endif 195 SLPlayItf playItf; 196 SLint8* pDataBase; // Base address of local audio data storage 197 SLint8* pData; // Current address of local audio data storage 198 } CallbackCntxt; 199 200 // used to notify when SL_PLAYEVENT_HEADATEND event is received 201 static pthread_mutex_t head_mutex = PTHREAD_MUTEX_INITIALIZER; 202 static pthread_cond_t head_cond = PTHREAD_COND_INITIALIZER; 203 static SLboolean head_atend = SL_BOOLEAN_FALSE; 204 205 //----------------------------------------------------------------- 206 /* Callback for SLPlayItf through which we receive the SL_PLAYEVENT_HEADATEND event */ 207 void PlayCallback(SLPlayItf caller, void *pContext __unused, SLuint32 event) { 208 SLmillisecond position; 209 SLresult res = (*caller)->GetPosition(caller, &position); 210 ExitOnError(res); 211 if (event & SL_PLAYEVENT_HEADATMARKER) { 212 printf("SL_PLAYEVENT_HEADATMARKER position=%u ms\n", position); 213 } 214 if (event & SL_PLAYEVENT_HEADATNEWPOS) { 215 printf("SL_PLAYEVENT_HEADATNEWPOS position=%u ms\n", position); 216 } 217 if (event & SL_PLAYEVENT_HEADATEND) { 218 printf("SL_PLAYEVENT_HEADATEND position=%u ms, all decoded data has been received\n", 219 position); 220 pthread_mutex_lock(&head_mutex); 221 head_atend = SL_BOOLEAN_TRUE; 222 pthread_cond_signal(&head_cond); 223 pthread_mutex_unlock(&head_mutex); 224 } 225 } 226 227 //----------------------------------------------------------------- 228 /* Callback for AndroidBufferQueueItf through which we supply ADTS buffers */ 229 SLresult AndroidBufferQueueCallback( 230 SLAndroidBufferQueueItf caller, 231 void *pCallbackContext __unused, /* input */ 232 void *pBufferContext, /* input */ 233 void *pBufferData __unused, /* input */ 234 SLuint32 dataSize __unused, /* input */ 235 SLuint32 dataUsed __unused, /* input */ 236 const SLAndroidBufferItem *pItems __unused, /* input */ 237 SLuint32 itemsLength __unused /* input */) 238 { 239 // mutex on all global variables 240 pthread_mutex_lock(&eosLock); 241 SLresult res; 242 243 // for demonstration purposes: 244 // verify what type of information was enclosed in the processed buffer 245 if (NULL != pBufferContext) { 246 if (&kEosBufferCntxt == pBufferContext) { 247 fprintf(stdout, "EOS was processed\n"); 248 } 249 } 250 251 ++totalEncodeCompletions; 252 if (endOfEncodedStream) { 253 // we continue to receive acknowledgement after each buffer was processed 254 if (pBufferContext == (void *) &kEosBufferCntxt) { 255 printf("Received EOS completion after EOS\n"); 256 } else if (pBufferContext == NULL) { 257 printf("Received ADTS completion after EOS\n"); 258 } else { 259 fprintf(stderr, "Received acknowledgement after EOS with unexpected context %p\n", 260 pBufferContext); 261 } 262 } else if (filelen == 0) { 263 // signal EOS to the decoder rather than just starving it 264 printf("Enqueue EOS: encoded frames=%zu, decoded frames=%zu\n", encodedFrames, 265 decodedFrames); 266 printf("You should now see %u ADTS completion%s followed by 1 EOS completion\n", 267 NB_BUFFERS_IN_ADTS_QUEUE - 1, NB_BUFFERS_IN_ADTS_QUEUE != 2 ? "s" : ""); 268 SLAndroidBufferItem msgEos; 269 msgEos.itemKey = SL_ANDROID_ITEMKEY_EOS; 270 msgEos.itemSize = 0; 271 // EOS message has no parameters, so the total size of the message is the size of the key 272 // plus the size of itemSize, both SLuint32 273 res = (*caller)->Enqueue(caller, (void *)&kEosBufferCntxt /*pBufferContext*/, 274 NULL /*pData*/, 0 /*dataLength*/, 275 &msgEos /*pMsg*/, 276 sizeof(SLuint32)*2 /*msgLength*/); 277 ExitOnError(res); 278 endOfEncodedStream = true; 279 // verify that we are at start of an ADTS frame 280 } else if (!(filelen < 7 || frame[0] != 0xFF || (frame[1] & 0xF0) != 0xF0)) { 281 if (pBufferContext != NULL) { 282 fprintf(stderr, "Received acknowledgement before EOS with unexpected context %p\n", 283 pBufferContext); 284 } 285 unsigned framelen = ((frame[3] & 3) << 11) | (frame[4] << 3) | (frame[5] >> 5); 286 if (framelen <= filelen) { 287 // push more data to the queue 288 res = (*caller)->Enqueue(caller, NULL /*pBufferContext*/, 289 frame, framelen, NULL, 0); 290 ExitOnError(res); 291 frame += framelen; 292 filelen -= framelen; 293 ++encodedFrames; 294 encodedSamples += SAMPLES_PER_AAC_FRAME; 295 frameStats.sample(framelen); 296 } else { 297 fprintf(stderr, 298 "partial ADTS frame at EOF discarded; offset=%zu, framelen=%u, filelen=%zu\n", 299 frame - (unsigned char *) ptr, framelen, filelen); 300 frame += filelen; 301 filelen = 0; 302 } 303 } else { 304 fprintf(stderr, "corrupt ADTS frame encountered; offset=%zu, filelen=%zu\n", 305 frame - (unsigned char *) ptr, filelen); 306 frame += filelen; 307 filelen = 0; 308 } 309 pthread_mutex_unlock(&eosLock); 310 311 return SL_RESULT_SUCCESS; 312 } 313 314 //----------------------------------------------------------------- 315 /* Callback for decoding buffer queue events */ 316 void DecPlayCallback( 317 SLAndroidSimpleBufferQueueItf queueItf, 318 void *pContext) 319 { 320 // mutex on all global variables 321 pthread_mutex_lock(&eosLock); 322 323 CallbackCntxt *pCntxt = (CallbackCntxt*)pContext; 324 325 /* Save the decoded data to output file */ 326 if (outputFp != NULL && fwrite(pCntxt->pData, 1, BUFFER_SIZE_IN_BYTES, outputFp) 327 < BUFFER_SIZE_IN_BYTES) { 328 fprintf(stderr, "Error writing to output file"); 329 } 330 331 /* Re-enqueue the now empty buffer */ 332 SLresult res; 333 res = (*queueItf)->Enqueue(queueItf, pCntxt->pData, BUFFER_SIZE_IN_BYTES); 334 ExitOnError(res); 335 336 /* Increase data pointer by buffer size, with circular wraparound */ 337 pCntxt->pData += BUFFER_SIZE_IN_BYTES; 338 if (pCntxt->pData >= pCntxt->pDataBase + (NB_BUFFERS_IN_PCM_QUEUE * BUFFER_SIZE_IN_BYTES)) { 339 pCntxt->pData = pCntxt->pDataBase; 340 } 341 342 // Note: adding a sleep here or any sync point is a way to slow down the decoding, or 343 // synchronize it with some other event, as the OpenSL ES framework will block until the 344 // buffer queue callback return to proceed with the decoding. 345 346 #ifdef QUERY_METADATA 347 /* Example: query of the decoded PCM format */ 348 if (!formatQueried) { 349 /* memory to receive the PCM format metadata */ 350 union { 351 SLMetadataInfo pcmMetaData; 352 char withData[PCM_METADATA_VALUE_SIZE]; 353 } u; 354 res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, sampleRateKeyIndex, 355 PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res); 356 // Note: here we could verify the following: 357 // u.pcmMetaData->encoding == SL_CHARACTERENCODING_BINARY 358 // u.pcmMetaData->size == sizeof(SLuint32) 359 // but the call was successful for the PCM format keys, so those conditions are implied 360 printf("sample rate = %d\n", *((SLuint32*)u.pcmMetaData.data)); 361 res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, channelCountKeyIndex, 362 PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res); 363 printf("channel count = %d\n", *((SLuint32*)u.pcmMetaData.data)); 364 res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, bitsPerSampleKeyIndex, 365 PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res); 366 printf("bits per sample = %d bits\n", *((SLuint32*)u.pcmMetaData.data)); 367 res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, containerSizeKeyIndex, 368 PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res); 369 printf("container size = %d bits\n", *((SLuint32*)u.pcmMetaData.data)); 370 res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, channelMaskKeyIndex, 371 PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res); 372 printf("channel mask = 0x%X (0x3=front left | front right, 0x4=front center)\n", 373 *((SLuint32*)u.pcmMetaData.data)); 374 res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, endiannessKeyIndex, 375 PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res); 376 printf("endianness = %d (1=big, 2=little)\n", *((SLuint32*)u.pcmMetaData.data)); 377 formatQueried = true; 378 } 379 #endif 380 381 ++decodedFrames; 382 decodedSamples += SAMPLES_PER_AAC_FRAME; 383 384 /* Periodically ask for position and duration */ 385 if ((decodedFrames % 1000 == 0) || endOfEncodedStream) { 386 SLmillisecond position; 387 res = (*pCntxt->playItf)->GetPosition(pCntxt->playItf, &position); 388 ExitOnError(res); 389 SLmillisecond duration; 390 res = (*pCntxt->playItf)->GetDuration(pCntxt->playItf, &duration); 391 ExitOnError(res); 392 if (duration == SL_TIME_UNKNOWN) { 393 printf("After %zu encoded %zu decoded frames: position is %u ms, duration is " 394 "unknown as expected\n", 395 encodedFrames, decodedFrames, position); 396 } else { 397 printf("After %zu encoded %zu decoded frames: position is %u ms, duration is " 398 "surprisingly %u ms\n", 399 encodedFrames, decodedFrames, position, duration); 400 } 401 } 402 403 if (endOfEncodedStream && decodedSamples >= encodedSamples) { 404 eos = true; 405 pthread_cond_signal(&eosCondition); 406 } 407 pthread_mutex_unlock(&eosLock); 408 } 409 410 //----------------------------------------------------------------- 411 412 /* Decode an audio path by opening a file descriptor on that path */ 413 void TestDecToBuffQueue( SLObjectItf sl, const char *path, int fd) 414 { 415 // check what kind of object it is 416 int ok; 417 struct stat statbuf; 418 ok = fstat(fd, &statbuf); 419 if (ok < 0) { 420 perror(path); 421 return; 422 } 423 424 // verify that's it is a file 425 if (!S_ISREG(statbuf.st_mode)) { 426 fprintf(stderr, "%s: not an ordinary file\n", path); 427 return; 428 } 429 430 // map file contents into memory to make it easier to access the ADTS frames directly 431 ptr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, (off_t) 0); 432 if (ptr == MAP_FAILED) { 433 perror(path); 434 return; 435 } 436 frame = (unsigned char *) ptr; 437 filelen = statbuf.st_size; 438 439 // create PCM .raw file 440 if (createRaw) { 441 size_t len = strlen((const char *) path); 442 char* outputPath = (char*) malloc(len + 4 + 1); // save room to concatenate ".raw" 443 if (NULL == outputPath) { 444 ExitOnError(SL_RESULT_RESOURCE_ERROR); 445 } 446 memcpy(outputPath, path, len + 1); 447 strcat(outputPath, ".raw"); 448 outputFp = fopen(outputPath, "w"); 449 if (NULL == outputFp) { 450 // issue an error message, but continue the decoding anyway 451 perror(outputPath); 452 } 453 free(outputPath); 454 } else { 455 outputFp = NULL; 456 } 457 458 SLresult res; 459 SLEngineItf EngineItf; 460 461 /* Objects this application uses: one audio player */ 462 SLObjectItf player; 463 464 /* Interfaces for the audio player */ 465 SLPlayItf playItf; 466 #ifdef QUERY_METADATA 467 /* to retrieve the decoded PCM format */ 468 SLMetadataExtractionItf mdExtrItf; 469 #endif 470 /* to retrieve the PCM samples */ 471 SLAndroidSimpleBufferQueueItf decBuffQueueItf; 472 /* to queue the AAC data to decode */ 473 SLAndroidBufferQueueItf aacBuffQueueItf; 474 /* for prefetch status */ 475 SLPrefetchStatusItf prefetchItf; 476 477 SLboolean required[NUM_EXPLICIT_INTERFACES_FOR_PLAYER]; 478 SLInterfaceID iidArray[NUM_EXPLICIT_INTERFACES_FOR_PLAYER]; 479 480 /* Get the SL Engine Interface which is implicit */ 481 res = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void*)&EngineItf); 482 ExitOnError(res); 483 484 /* Initialize arrays required[] and iidArray[] */ 485 unsigned int i; 486 for (i=0 ; i < NUM_EXPLICIT_INTERFACES_FOR_PLAYER ; i++) { 487 required[i] = SL_BOOLEAN_FALSE; 488 iidArray[i] = SL_IID_NULL; 489 } 490 491 /* ------------------------------------------------------ */ 492 /* Configuration of the player */ 493 494 /* Request the AndroidSimpleBufferQueue interface */ 495 required[0] = SL_BOOLEAN_TRUE; 496 iidArray[0] = SL_IID_ANDROIDSIMPLEBUFFERQUEUE; 497 /* Request the AndroidBufferQueue interface */ 498 required[1] = SL_BOOLEAN_TRUE; 499 iidArray[1] = SL_IID_ANDROIDBUFFERQUEUESOURCE; 500 /* Request the PrefetchStatus interface */ 501 required[2] = SL_BOOLEAN_TRUE; 502 iidArray[2] = SL_IID_PREFETCHSTATUS; 503 #ifdef QUERY_METADATA 504 /* Request the MetadataExtraction interface */ 505 required[3] = SL_BOOLEAN_TRUE; 506 iidArray[3] = SL_IID_METADATAEXTRACTION; 507 #endif 508 509 /* Setup the data source for queueing AAC buffers of ADTS data */ 510 SLDataLocator_AndroidBufferQueue loc_srcAbq = { 511 SL_DATALOCATOR_ANDROIDBUFFERQUEUE /*locatorType*/, 512 NB_BUFFERS_IN_ADTS_QUEUE /*numBuffers*/}; 513 SLDataFormat_MIME format_srcMime = { 514 SL_DATAFORMAT_MIME /*formatType*/, 515 SL_ANDROID_MIME_AACADTS /*mimeType*/, 516 SL_CONTAINERTYPE_RAW /*containerType*/}; 517 SLDataSource decSource = {&loc_srcAbq /*pLocator*/, &format_srcMime /*pFormat*/}; 518 519 /* Setup the data sink, a buffer queue for buffers of PCM data */ 520 SLDataLocator_AndroidSimpleBufferQueue loc_destBq = { 521 SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE/*locatorType*/, 522 NB_BUFFERS_IN_PCM_QUEUE /*numBuffers*/ }; 523 524 /* declare we're decoding to PCM, the parameters after that need to be valid, 525 but are ignored, the decoded format will match the source */ 526 SLDataFormat_PCM format_destPcm = { /*formatType*/ SL_DATAFORMAT_PCM, /*numChannels*/ 1, 527 /*samplesPerSec*/ SL_SAMPLINGRATE_8, /*pcm.bitsPerSample*/ SL_PCMSAMPLEFORMAT_FIXED_16, 528 /*/containerSize*/ 16, /*channelMask*/ SL_SPEAKER_FRONT_LEFT, 529 /*endianness*/ SL_BYTEORDER_LITTLEENDIAN }; 530 SLDataSink decDest = {&loc_destBq /*pLocator*/, &format_destPcm /*pFormat*/}; 531 532 /* Create the audio player */ 533 res = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &decSource, &decDest, 534 #ifdef QUERY_METADATA 535 NUM_EXPLICIT_INTERFACES_FOR_PLAYER, 536 #else 537 NUM_EXPLICIT_INTERFACES_FOR_PLAYER - 1, 538 #endif 539 iidArray, required); 540 ExitOnError(res); 541 printf("Player created\n"); 542 543 /* Realize the player in synchronous mode. */ 544 res = (*player)->Realize(player, SL_BOOLEAN_FALSE); 545 ExitOnError(res); 546 printf("Player realized\n"); 547 548 /* Get the play interface which is implicit */ 549 res = (*player)->GetInterface(player, SL_IID_PLAY, (void*)&playItf); 550 ExitOnError(res); 551 552 /* Enable callback when position passes through a marker (SL_PLAYEVENT_HEADATMARKER) */ 553 res = (*playItf)->SetMarkerPosition(playItf, 5000); 554 ExitOnError(res); 555 556 /* Enable callback for periodic position updates (SL_PLAYEVENT_HEADATNEWPOS) */ 557 res = (*playItf)->SetPositionUpdatePeriod(playItf, 3000); 558 ExitOnError(res); 559 560 /* Use the play interface to set up a callback for the SL_PLAYEVENT_HEAD* events */ 561 res = (*playItf)->SetCallbackEventsMask(playItf, 562 SL_PLAYEVENT_HEADATMARKER | SL_PLAYEVENT_HEADATNEWPOS | SL_PLAYEVENT_HEADATEND); 563 ExitOnError(res); 564 res = (*playItf)->RegisterCallback(playItf, PlayCallback /*callback*/, NULL /*pContext*/); 565 ExitOnError(res); 566 567 /* Get the position before prefetch; should be zero */ 568 SLmillisecond position; 569 res = (*playItf)->GetPosition(playItf, &position); 570 ExitOnError(res); 571 if (position == 0) { 572 printf("The position before prefetch is zero as expected\n"); 573 } else if (position == SL_TIME_UNKNOWN) { 574 printf("That's surprising the position before prefetch is unknown"); 575 } else { 576 printf("That's surprising the position before prefetch is %u ms\n", position); 577 } 578 579 /* Get the duration before prefetch; should be unknown */ 580 SLmillisecond duration; 581 res = (*playItf)->GetDuration(playItf, &duration); 582 ExitOnError(res); 583 if (duration == SL_TIME_UNKNOWN) { 584 printf("The duration before prefetch is unknown as expected\n"); 585 } else { 586 printf("That's surprising the duration before prefetch is %u ms\n", duration); 587 } 588 589 /* Get the buffer queue interface which was explicitly requested */ 590 res = (*player)->GetInterface(player, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, (void*)&decBuffQueueItf); 591 ExitOnError(res); 592 593 /* Get the Android buffer queue interface which was explicitly requested */ 594 res = (*player)->GetInterface(player, SL_IID_ANDROIDBUFFERQUEUESOURCE, (void*)&aacBuffQueueItf); 595 ExitOnError(res); 596 597 /* Get the prefetch status interface which was explicitly requested */ 598 res = (*player)->GetInterface(player, SL_IID_PREFETCHSTATUS, (void*)&prefetchItf); 599 ExitOnError(res); 600 601 #ifdef QUERY_METADATA 602 /* Get the metadata extraction interface which was explicitly requested */ 603 res = (*player)->GetInterface(player, SL_IID_METADATAEXTRACTION, (void*)&mdExtrItf); 604 ExitOnError(res); 605 #endif 606 607 /* ------------------------------------------------------ */ 608 /* Initialize the callback and its context for the buffer queue of the decoded PCM */ 609 CallbackCntxt sinkCntxt; 610 sinkCntxt.playItf = playItf; 611 #ifdef QUERY_METADATA 612 sinkCntxt.metaItf = mdExtrItf; 613 #endif 614 sinkCntxt.pDataBase = (int8_t*)&pcmData; 615 sinkCntxt.pData = sinkCntxt.pDataBase; 616 res = (*decBuffQueueItf)->RegisterCallback(decBuffQueueItf, DecPlayCallback, &sinkCntxt); 617 ExitOnError(res); 618 619 /* Enqueue buffers to map the region of memory allocated to store the decoded data */ 620 printf("Enqueueing initial empty buffers to receive decoded PCM data"); 621 for(i = 0 ; i < NB_BUFFERS_IN_PCM_QUEUE ; i++) { 622 printf(" %d", i); 623 res = (*decBuffQueueItf)->Enqueue(decBuffQueueItf, sinkCntxt.pData, BUFFER_SIZE_IN_BYTES); 624 ExitOnError(res); 625 sinkCntxt.pData += BUFFER_SIZE_IN_BYTES; 626 if (sinkCntxt.pData >= sinkCntxt.pDataBase + 627 (NB_BUFFERS_IN_PCM_QUEUE * BUFFER_SIZE_IN_BYTES)) { 628 sinkCntxt.pData = sinkCntxt.pDataBase; 629 } 630 } 631 printf("\n"); 632 633 /* ------------------------------------------------------ */ 634 /* Initialize the callback for prefetch errors, if we can't open the resource to decode */ 635 res = (*prefetchItf)->RegisterCallback(prefetchItf, PrefetchEventCallback, NULL); 636 ExitOnError(res); 637 res = (*prefetchItf)->SetCallbackEventsMask(prefetchItf, PREFETCHEVENT_ERROR_CANDIDATE); 638 ExitOnError(res); 639 640 /* Initialize the callback for the Android buffer queue of the encoded data */ 641 res = (*aacBuffQueueItf)->RegisterCallback(aacBuffQueueItf, AndroidBufferQueueCallback, NULL); 642 ExitOnError(res); 643 644 /* Enqueue the content of our encoded data before starting to play, 645 we don't want to starve the player initially */ 646 printf("Enqueueing initial full buffers of encoded ADTS data"); 647 for (i=0 ; i < NB_BUFFERS_IN_ADTS_QUEUE ; i++) { 648 if (filelen < 7 || frame[0] != 0xFF || (frame[1] & 0xF0) != 0xF0) { 649 printf("\ncorrupt ADTS frame encountered; offset %zu bytes\n", 650 frame - (unsigned char *) ptr); 651 // Note that prefetch will detect this error soon when it gets a premature EOF 652 break; 653 } 654 unsigned framelen = ((frame[3] & 3) << 11) | (frame[4] << 3) | (frame[5] >> 5); 655 printf(" %d (%u bytes)", i, framelen); 656 res = (*aacBuffQueueItf)->Enqueue(aacBuffQueueItf, NULL /*pBufferContext*/, 657 frame, framelen, NULL, 0); 658 ExitOnError(res); 659 frame += framelen; 660 filelen -= framelen; 661 ++encodedFrames; 662 encodedSamples += SAMPLES_PER_AAC_FRAME; 663 frameStats.sample(framelen); 664 } 665 printf("\n"); 666 667 #ifdef QUERY_METADATA 668 /* ------------------------------------------------------ */ 669 /* Get and display the metadata key names for the decoder */ 670 // This is for test / demonstration purposes only where we discover the key and value sizes 671 // of a PCM decoder. An application that would want to directly get access to those values 672 // can make assumptions about the size of the keys and their matching values (all SLuint32), 673 // but it should not make assumptions about the key indices as these are subject to change. 674 // Note that we don't get the metadata values yet; that happens in the first decode callback. 675 SLuint32 itemCount; 676 res = (*mdExtrItf)->GetItemCount(mdExtrItf, &itemCount); 677 ExitOnError(res); 678 printf("itemCount=%u\n", itemCount); 679 SLuint32 keySize, valueSize; 680 SLMetadataInfo *keyInfo, *value; 681 for(i=0 ; i<itemCount ; i++) { 682 keyInfo = NULL; keySize = 0; 683 value = NULL; valueSize = 0; 684 res = (*mdExtrItf)->GetKeySize(mdExtrItf, i, &keySize); 685 ExitOnError(res); 686 res = (*mdExtrItf)->GetValueSize(mdExtrItf, i, &valueSize); 687 ExitOnError(res); 688 keyInfo = (SLMetadataInfo*) malloc(keySize); 689 if (NULL != keyInfo) { 690 res = (*mdExtrItf)->GetKey(mdExtrItf, i, keySize, keyInfo); 691 ExitOnError(res); 692 printf("key[%d] size=%d, name=%s \tvalue size=%d encoding=0x%X langCountry=%s\n", 693 i, keyInfo->size, keyInfo->data, valueSize, keyInfo->encoding, 694 keyInfo->langCountry); 695 /* find out the key index of the metadata we're interested in */ 696 if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_NUMCHANNELS)) { 697 channelCountKeyIndex = i; 698 } else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_SAMPLERATE)) { 699 sampleRateKeyIndex = i; 700 } else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE)) { 701 bitsPerSampleKeyIndex = i; 702 } else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_CONTAINERSIZE)) { 703 containerSizeKeyIndex = i; 704 } else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_CHANNELMASK)) { 705 channelMaskKeyIndex = i; 706 } else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_ENDIANNESS)) { 707 endiannessKeyIndex = i; 708 } else { 709 printf("Unknown key %s ignored\n", (char *)keyInfo->data); 710 } 711 free(keyInfo); 712 } 713 } 714 if (channelCountKeyIndex != -1) { 715 printf("Key %s is at index %d\n", 716 ANDROID_KEY_PCMFORMAT_NUMCHANNELS, channelCountKeyIndex); 717 } else { 718 fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_NUMCHANNELS); 719 } 720 if (sampleRateKeyIndex != -1) { 721 printf("Key %s is at index %d\n", 722 ANDROID_KEY_PCMFORMAT_SAMPLERATE, sampleRateKeyIndex); 723 } else { 724 fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_SAMPLERATE); 725 } 726 if (bitsPerSampleKeyIndex != -1) { 727 printf("Key %s is at index %d\n", 728 ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE, bitsPerSampleKeyIndex); 729 } else { 730 fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE); 731 } 732 if (containerSizeKeyIndex != -1) { 733 printf("Key %s is at index %d\n", 734 ANDROID_KEY_PCMFORMAT_CONTAINERSIZE, containerSizeKeyIndex); 735 } else { 736 fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_CONTAINERSIZE); 737 } 738 if (channelMaskKeyIndex != -1) { 739 printf("Key %s is at index %d\n", 740 ANDROID_KEY_PCMFORMAT_CHANNELMASK, channelMaskKeyIndex); 741 } else { 742 fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_CHANNELMASK); 743 } 744 if (endiannessKeyIndex != -1) { 745 printf("Key %s is at index %d\n", 746 ANDROID_KEY_PCMFORMAT_ENDIANNESS, endiannessKeyIndex); 747 } else { 748 fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_ENDIANNESS); 749 } 750 #endif 751 752 // set the player's state to paused, to start prefetching 753 printf("Setting play state to PAUSED\n"); 754 res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PAUSED); 755 ExitOnError(res); 756 757 // wait for prefetch status callback to indicate either sufficient data or error 758 printf("Awaiting prefetch complete\n"); 759 pthread_mutex_lock(&mutex); 760 while (prefetch_status == PREFETCHSTATUS_UNKNOWN) { 761 pthread_cond_wait(&cond, &mutex); 762 } 763 pthread_mutex_unlock(&mutex); 764 if (prefetch_status == PREFETCHSTATUS_ERROR) { 765 fprintf(stderr, "Error during prefetch, exiting\n"); 766 goto destroyRes; 767 } 768 printf("Prefetch is complete\n"); 769 770 /* ------------------------------------------------------ */ 771 /* Start decoding */ 772 printf("Starting to decode\n"); 773 res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING); 774 ExitOnError(res); 775 776 /* Decode until the end of the stream is reached */ 777 printf("Awaiting notification that all encoded buffers have been enqueued\n"); 778 pthread_mutex_lock(&eosLock); 779 while (!eos) { 780 if (pauseFrame > 0) { 781 if (decodedFrames >= pauseFrame) { 782 pauseFrame = 0; 783 printf("Pausing after decoded frame %zu for 10 seconds\n", decodedFrames); 784 pthread_mutex_unlock(&eosLock); 785 res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PAUSED); 786 ExitOnError(res); 787 sleep(10); 788 printf("Resuming\n"); 789 res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING); 790 ExitOnError(res); 791 pthread_mutex_lock(&eosLock); 792 } else { 793 pthread_mutex_unlock(&eosLock); 794 usleep(10*1000); 795 pthread_mutex_lock(&eosLock); 796 } 797 } else { 798 pthread_cond_wait(&eosCondition, &eosLock); 799 } 800 } 801 pthread_mutex_unlock(&eosLock); 802 printf("All encoded buffers have now been enqueued, but there's still more to do\n"); 803 804 /* This just means done enqueueing; there may still more data in decode queue! */ 805 pthread_mutex_lock(&head_mutex); 806 while (!head_atend) { 807 pthread_cond_wait(&head_cond, &head_mutex); 808 } 809 pthread_mutex_unlock(&head_mutex); 810 printf("Decode is now finished\n"); 811 812 pthread_mutex_lock(&eosLock); 813 printf("Frame counters: encoded=%zu decoded=%zu\n", encodedFrames, decodedFrames); 814 printf("Sample counters: encoded=%zu decoded=%zu\n", encodedSamples, decodedSamples); 815 printf("Total encode completions received: actual=%zu, expected=%zu\n", 816 totalEncodeCompletions, encodedFrames+1/*EOS*/); 817 pthread_mutex_unlock(&eosLock); 818 819 /* Get the final position and duration */ 820 res = (*playItf)->GetPosition(playItf, &position); 821 ExitOnError(res); 822 res = (*playItf)->GetDuration(playItf, &duration); 823 ExitOnError(res); 824 if (duration == SL_TIME_UNKNOWN) { 825 printf("The final position is %u ms, duration is unknown\n", position); 826 } else { 827 printf("The final position is %u ms, duration is %u ms\n", position, duration); 828 } 829 830 printf("Frame length statistics:\n"); 831 printf(" n = %u frames\n", frameStats.n()); 832 printf(" mean = %.1f bytes\n", frameStats.mean()); 833 printf(" minimum = %.1f bytes\n", frameStats.minimum()); 834 printf(" maximum = %.1f bytes\n", frameStats.maximum()); 835 printf(" stddev = %.1f bytes\n", frameStats.stddev()); 836 837 /* ------------------------------------------------------ */ 838 /* End of decoding */ 839 840 destroyRes: 841 /* Destroy the AudioPlayer object */ 842 (*player)->Destroy(player); 843 844 if (outputFp != NULL) { 845 fclose(outputFp); 846 } 847 848 // unmap the ADTS AAC file from memory 849 ok = munmap(ptr, statbuf.st_size); 850 if (0 != ok) { 851 perror(path); 852 } 853 } 854 855 //----------------------------------------------------------------- 856 int main(int argc, char* const argv[]) 857 { 858 SLresult res; 859 SLObjectItf sl; 860 861 printf("OpenSL ES test %s: decodes a file containing AAC ADTS data\n", argv[0]); 862 863 if (argc != 2) { 864 printf("Usage: \t%s source_file\n", argv[0]); 865 printf("Example: \"%s /sdcard/myFile.adts\n", argv[0]); 866 exit(EXIT_FAILURE); 867 } 868 869 // open pathname of encoded ADTS AAC file to get a file descriptor 870 int fd; 871 fd = open(argv[1], O_RDONLY); 872 if (fd < 0) { 873 perror(argv[1]); 874 return EXIT_FAILURE; 875 } 876 877 SLEngineOption EngineOption[] = { 878 {(SLuint32) SL_ENGINEOPTION_THREADSAFE, (SLuint32) SL_BOOLEAN_TRUE} 879 }; 880 881 res = slCreateEngine( &sl, 1, EngineOption, 0, NULL, NULL); 882 ExitOnError(res); 883 884 /* Realizing the SL Engine in synchronous mode. */ 885 res = (*sl)->Realize(sl, SL_BOOLEAN_FALSE); 886 ExitOnError(res); 887 888 TestDecToBuffQueue(sl, argv[1], fd); 889 890 /* Shutdown OpenSL ES */ 891 (*sl)->Destroy(sl); 892 893 // close the file 894 (void) close(fd); 895 896 return EXIT_SUCCESS; 897 } 898
