You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
898 lines
35 KiB
898 lines
35 KiB
/*
|
|
* Copyright (C) 2011 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/* AAC ADTS Decode Test
|
|
|
|
First run the program from shell:
|
|
# slesTestDecodeAac /sdcard/myFile.adts
|
|
|
|
Expected output:
|
|
OpenSL ES test slesTestDecodeAac: decodes a file containing AAC ADTS data
|
|
Player created
|
|
Player realized
|
|
Enqueueing initial empty buffers to receive decoded PCM data 0 1
|
|
Enqueueing initial full buffers of encoded ADTS data 0 1
|
|
Starting to decode
|
|
Frame counters: encoded=4579 decoded=4579
|
|
|
|
These use adb on host to retrieve the decoded file:
|
|
% adb pull /sdcard/myFile.adts.raw myFile.raw
|
|
|
|
How to examine the output with Audacity:
|
|
Project / Import raw data
|
|
Select myFile.raw file, then click Open button
|
|
Choose these options:
|
|
Signed 16-bit PCM
|
|
Little-endian
|
|
1 Channel (Mono) / 2 Channels (Stereo) based on the PCM information obtained when decoding
|
|
Sample rate based on the PCM information obtained when decoding
|
|
Click Import button
|
|
|
|
*/
|
|
|
|
#define QUERY_METADATA
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/time.h>
|
|
#include <fcntl.h>
|
|
#include <pthread.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <cpustats/CentralTendencyStatistics.h>
|
|
|
|
#include <SLES/OpenSLES.h>
|
|
#include <SLES/OpenSLES_Android.h>
|
|
|
|
/* Explicitly requesting SL_IID_ANDROIDBUFFERQUEUE and SL_IID_ANDROIDSIMPLEBUFFERQUEUE
|
|
* on the AudioPlayer object for decoding, and
|
|
* SL_IID_METADATAEXTRACTION for retrieving the format of the decoded audio.
|
|
*/
|
|
#define NUM_EXPLICIT_INTERFACES_FOR_PLAYER 4
|
|
|
|
/* Number of decoded samples produced by one AAC frame; defined by the standard */
|
|
#define SAMPLES_PER_AAC_FRAME 1024
|
|
/* Size of the encoded AAC ADTS buffer queue */
|
|
#define NB_BUFFERS_IN_ADTS_QUEUE 2 // 2 to 4 is typical
|
|
|
|
/* Size of the decoded PCM buffer queue */
|
|
#define NB_BUFFERS_IN_PCM_QUEUE 2 // 2 to 4 is typical
|
|
/* Size of each PCM buffer in the queue */
|
|
#define BUFFER_SIZE_IN_BYTES (2*sizeof(short)*SAMPLES_PER_AAC_FRAME)
|
|
|
|
/* Local storage for decoded PCM audio data */
|
|
int8_t pcmData[NB_BUFFERS_IN_PCM_QUEUE * BUFFER_SIZE_IN_BYTES];
|
|
|
|
/* destination for decoded data */
|
|
static FILE* outputFp;
|
|
|
|
#ifdef QUERY_METADATA
|
|
/* metadata key index for the PCM format information we want to retrieve */
|
|
static int channelCountKeyIndex = -1;
|
|
static int sampleRateKeyIndex = -1;
|
|
static int bitsPerSampleKeyIndex = -1;
|
|
static int containerSizeKeyIndex = -1;
|
|
static int channelMaskKeyIndex = -1;
|
|
static int endiannessKeyIndex = -1;
|
|
/* size of the struct to retrieve the PCM format metadata values: the values we're interested in
|
|
* are SLuint32, but it is saved in the data field of a SLMetadataInfo, hence the larger size.
|
|
* Note that this size is queried and displayed at l.XXX for demonstration/test purposes.
|
|
* */
|
|
#define PCM_METADATA_VALUE_SIZE 32
|
|
/* we only want to query / display the PCM format once */
|
|
static bool formatQueried = false;
|
|
#endif
|
|
|
|
/* to signal to the test app that the end of the encoded ADTS stream has been reached */
|
|
bool eos = false;
|
|
bool endOfEncodedStream = false;
|
|
|
|
void *ptr;
|
|
unsigned char *frame;
|
|
size_t filelen;
|
|
size_t encodedFrames = 0;
|
|
size_t encodedSamples = 0;
|
|
size_t decodedFrames = 0;
|
|
size_t decodedSamples = 0;
|
|
size_t totalEncodeCompletions = 0; // number of Enqueue completions received
|
|
CentralTendencyStatistics frameStats;
|
|
size_t pauseFrame = 0; // pause after this many decoded frames, zero means don't pause
|
|
SLboolean createRaw = SL_BOOLEAN_TRUE; // whether to create a .raw file containing PCM data
|
|
|
|
/* constant to identify a buffer context which is the end of the stream to decode */
|
|
static const int kEosBufferCntxt = 1980; // a magic value we can compare against
|
|
|
|
/* protects shared variables */
|
|
pthread_mutex_t eosLock = PTHREAD_MUTEX_INITIALIZER;
|
|
pthread_cond_t eosCondition = PTHREAD_COND_INITIALIZER;
|
|
|
|
// These are extensions to OpenMAX AL 1.0.1 values
|
|
|
|
#define PREFETCHSTATUS_UNKNOWN ((SLuint32) 0)
|
|
#define PREFETCHSTATUS_ERROR ((SLuint32) (-1))
|
|
|
|
// Mutex and condition shared with main program to protect prefetch_status
|
|
|
|
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
|
|
SLuint32 prefetch_status = PREFETCHSTATUS_UNKNOWN;
|
|
|
|
/* used to detect errors likely to have occured when the OpenSL ES framework fails to open
|
|
* a resource, for instance because a file URI is invalid, or an HTTP server doesn't respond.
|
|
*/
|
|
#define PREFETCHEVENT_ERROR_CANDIDATE \
|
|
(SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE)
|
|
|
|
//-----------------------------------------------------------------
|
|
/* Exits the application if an error is encountered */
|
|
#define ExitOnError(x) ExitOnErrorFunc(x,__LINE__)
|
|
|
|
void ExitOnErrorFunc( SLresult result , int line)
|
|
{
|
|
if (SL_RESULT_SUCCESS != result) {
|
|
fprintf(stderr, "Error code %u encountered at line %d, exiting\n", result, line);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
/* Callback for "prefetch" events, here used to detect audio resource opening errors */
|
|
void PrefetchEventCallback(SLPrefetchStatusItf caller, void *pContext, SLuint32 event)
|
|
{
|
|
// pContext is unused here, so we pass NULL
|
|
assert(pContext == NULL);
|
|
SLpermille level = 0;
|
|
SLresult result;
|
|
result = (*caller)->GetFillLevel(caller, &level);
|
|
ExitOnError(result);
|
|
SLuint32 status;
|
|
result = (*caller)->GetPrefetchStatus(caller, &status);
|
|
ExitOnError(result);
|
|
printf("prefetch level=%d status=0x%x event=%d\n", level, status, event);
|
|
SLuint32 new_prefetch_status;
|
|
if ((PREFETCHEVENT_ERROR_CANDIDATE == (event & PREFETCHEVENT_ERROR_CANDIDATE))
|
|
&& (level == 0) && (status == SL_PREFETCHSTATUS_UNDERFLOW)) {
|
|
printf("PrefetchEventCallback: Error while prefetching data, exiting\n");
|
|
new_prefetch_status = PREFETCHSTATUS_ERROR;
|
|
} else if (event == SL_PREFETCHEVENT_STATUSCHANGE) {
|
|
new_prefetch_status = status;
|
|
} else {
|
|
return;
|
|
}
|
|
int ok;
|
|
ok = pthread_mutex_lock(&mutex);
|
|
assert(ok == 0);
|
|
prefetch_status = new_prefetch_status;
|
|
ok = pthread_cond_signal(&cond);
|
|
assert(ok == 0);
|
|
ok = pthread_mutex_unlock(&mutex);
|
|
assert(ok == 0);
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
/* Structure for passing information to callback function */
|
|
typedef struct CallbackCntxt_ {
|
|
#ifdef QUERY_METADATA
|
|
SLMetadataExtractionItf metaItf;
|
|
#endif
|
|
SLPlayItf playItf;
|
|
SLint8* pDataBase; // Base address of local audio data storage
|
|
SLint8* pData; // Current address of local audio data storage
|
|
} CallbackCntxt;
|
|
|
|
// used to notify when SL_PLAYEVENT_HEADATEND event is received
|
|
static pthread_mutex_t head_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
static pthread_cond_t head_cond = PTHREAD_COND_INITIALIZER;
|
|
static SLboolean head_atend = SL_BOOLEAN_FALSE;
|
|
|
|
//-----------------------------------------------------------------
|
|
/* Callback for SLPlayItf through which we receive the SL_PLAYEVENT_HEADATEND event */
|
|
void PlayCallback(SLPlayItf caller, void *pContext __unused, SLuint32 event) {
|
|
SLmillisecond position;
|
|
SLresult res = (*caller)->GetPosition(caller, &position);
|
|
ExitOnError(res);
|
|
if (event & SL_PLAYEVENT_HEADATMARKER) {
|
|
printf("SL_PLAYEVENT_HEADATMARKER position=%u ms\n", position);
|
|
}
|
|
if (event & SL_PLAYEVENT_HEADATNEWPOS) {
|
|
printf("SL_PLAYEVENT_HEADATNEWPOS position=%u ms\n", position);
|
|
}
|
|
if (event & SL_PLAYEVENT_HEADATEND) {
|
|
printf("SL_PLAYEVENT_HEADATEND position=%u ms, all decoded data has been received\n",
|
|
position);
|
|
pthread_mutex_lock(&head_mutex);
|
|
head_atend = SL_BOOLEAN_TRUE;
|
|
pthread_cond_signal(&head_cond);
|
|
pthread_mutex_unlock(&head_mutex);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
/* Callback for AndroidBufferQueueItf through which we supply ADTS buffers */
|
|
SLresult AndroidBufferQueueCallback(
|
|
SLAndroidBufferQueueItf caller,
|
|
void *pCallbackContext __unused, /* input */
|
|
void *pBufferContext, /* input */
|
|
void *pBufferData __unused, /* input */
|
|
SLuint32 dataSize __unused, /* input */
|
|
SLuint32 dataUsed __unused, /* input */
|
|
const SLAndroidBufferItem *pItems __unused, /* input */
|
|
SLuint32 itemsLength __unused /* input */)
|
|
{
|
|
// mutex on all global variables
|
|
pthread_mutex_lock(&eosLock);
|
|
SLresult res;
|
|
|
|
// for demonstration purposes:
|
|
// verify what type of information was enclosed in the processed buffer
|
|
if (NULL != pBufferContext) {
|
|
if (&kEosBufferCntxt == pBufferContext) {
|
|
fprintf(stdout, "EOS was processed\n");
|
|
}
|
|
}
|
|
|
|
++totalEncodeCompletions;
|
|
if (endOfEncodedStream) {
|
|
// we continue to receive acknowledgement after each buffer was processed
|
|
if (pBufferContext == (void *) &kEosBufferCntxt) {
|
|
printf("Received EOS completion after EOS\n");
|
|
} else if (pBufferContext == NULL) {
|
|
printf("Received ADTS completion after EOS\n");
|
|
} else {
|
|
fprintf(stderr, "Received acknowledgement after EOS with unexpected context %p\n",
|
|
pBufferContext);
|
|
}
|
|
} else if (filelen == 0) {
|
|
// signal EOS to the decoder rather than just starving it
|
|
printf("Enqueue EOS: encoded frames=%zu, decoded frames=%zu\n", encodedFrames,
|
|
decodedFrames);
|
|
printf("You should now see %u ADTS completion%s followed by 1 EOS completion\n",
|
|
NB_BUFFERS_IN_ADTS_QUEUE - 1, NB_BUFFERS_IN_ADTS_QUEUE != 2 ? "s" : "");
|
|
SLAndroidBufferItem msgEos;
|
|
msgEos.itemKey = SL_ANDROID_ITEMKEY_EOS;
|
|
msgEos.itemSize = 0;
|
|
// EOS message has no parameters, so the total size of the message is the size of the key
|
|
// plus the size of itemSize, both SLuint32
|
|
res = (*caller)->Enqueue(caller, (void *)&kEosBufferCntxt /*pBufferContext*/,
|
|
NULL /*pData*/, 0 /*dataLength*/,
|
|
&msgEos /*pMsg*/,
|
|
sizeof(SLuint32)*2 /*msgLength*/);
|
|
ExitOnError(res);
|
|
endOfEncodedStream = true;
|
|
// verify that we are at start of an ADTS frame
|
|
} else if (!(filelen < 7 || frame[0] != 0xFF || (frame[1] & 0xF0) != 0xF0)) {
|
|
if (pBufferContext != NULL) {
|
|
fprintf(stderr, "Received acknowledgement before EOS with unexpected context %p\n",
|
|
pBufferContext);
|
|
}
|
|
unsigned framelen = ((frame[3] & 3) << 11) | (frame[4] << 3) | (frame[5] >> 5);
|
|
if (framelen <= filelen) {
|
|
// push more data to the queue
|
|
res = (*caller)->Enqueue(caller, NULL /*pBufferContext*/,
|
|
frame, framelen, NULL, 0);
|
|
ExitOnError(res);
|
|
frame += framelen;
|
|
filelen -= framelen;
|
|
++encodedFrames;
|
|
encodedSamples += SAMPLES_PER_AAC_FRAME;
|
|
frameStats.sample(framelen);
|
|
} else {
|
|
fprintf(stderr,
|
|
"partial ADTS frame at EOF discarded; offset=%zu, framelen=%u, filelen=%zu\n",
|
|
frame - (unsigned char *) ptr, framelen, filelen);
|
|
frame += filelen;
|
|
filelen = 0;
|
|
}
|
|
} else {
|
|
fprintf(stderr, "corrupt ADTS frame encountered; offset=%zu, filelen=%zu\n",
|
|
frame - (unsigned char *) ptr, filelen);
|
|
frame += filelen;
|
|
filelen = 0;
|
|
}
|
|
pthread_mutex_unlock(&eosLock);
|
|
|
|
return SL_RESULT_SUCCESS;
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
/* Callback for decoding buffer queue events */
|
|
void DecPlayCallback(
|
|
SLAndroidSimpleBufferQueueItf queueItf,
|
|
void *pContext)
|
|
{
|
|
// mutex on all global variables
|
|
pthread_mutex_lock(&eosLock);
|
|
|
|
CallbackCntxt *pCntxt = (CallbackCntxt*)pContext;
|
|
|
|
/* Save the decoded data to output file */
|
|
if (outputFp != NULL && fwrite(pCntxt->pData, 1, BUFFER_SIZE_IN_BYTES, outputFp)
|
|
< BUFFER_SIZE_IN_BYTES) {
|
|
fprintf(stderr, "Error writing to output file");
|
|
}
|
|
|
|
/* Re-enqueue the now empty buffer */
|
|
SLresult res;
|
|
res = (*queueItf)->Enqueue(queueItf, pCntxt->pData, BUFFER_SIZE_IN_BYTES);
|
|
ExitOnError(res);
|
|
|
|
/* Increase data pointer by buffer size, with circular wraparound */
|
|
pCntxt->pData += BUFFER_SIZE_IN_BYTES;
|
|
if (pCntxt->pData >= pCntxt->pDataBase + (NB_BUFFERS_IN_PCM_QUEUE * BUFFER_SIZE_IN_BYTES)) {
|
|
pCntxt->pData = pCntxt->pDataBase;
|
|
}
|
|
|
|
// Note: adding a sleep here or any sync point is a way to slow down the decoding, or
|
|
// synchronize it with some other event, as the OpenSL ES framework will block until the
|
|
// buffer queue callback return to proceed with the decoding.
|
|
|
|
#ifdef QUERY_METADATA
|
|
/* Example: query of the decoded PCM format */
|
|
if (!formatQueried) {
|
|
/* memory to receive the PCM format metadata */
|
|
union {
|
|
SLMetadataInfo pcmMetaData;
|
|
char withData[PCM_METADATA_VALUE_SIZE];
|
|
} u;
|
|
res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, sampleRateKeyIndex,
|
|
PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res);
|
|
// Note: here we could verify the following:
|
|
// u.pcmMetaData->encoding == SL_CHARACTERENCODING_BINARY
|
|
// u.pcmMetaData->size == sizeof(SLuint32)
|
|
// but the call was successful for the PCM format keys, so those conditions are implied
|
|
printf("sample rate = %d\n", *((SLuint32*)u.pcmMetaData.data));
|
|
res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, channelCountKeyIndex,
|
|
PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res);
|
|
printf("channel count = %d\n", *((SLuint32*)u.pcmMetaData.data));
|
|
res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, bitsPerSampleKeyIndex,
|
|
PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res);
|
|
printf("bits per sample = %d bits\n", *((SLuint32*)u.pcmMetaData.data));
|
|
res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, containerSizeKeyIndex,
|
|
PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res);
|
|
printf("container size = %d bits\n", *((SLuint32*)u.pcmMetaData.data));
|
|
res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, channelMaskKeyIndex,
|
|
PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res);
|
|
printf("channel mask = 0x%X (0x3=front left | front right, 0x4=front center)\n",
|
|
*((SLuint32*)u.pcmMetaData.data));
|
|
res = (*pCntxt->metaItf)->GetValue(pCntxt->metaItf, endiannessKeyIndex,
|
|
PCM_METADATA_VALUE_SIZE, &u.pcmMetaData); ExitOnError(res);
|
|
printf("endianness = %d (1=big, 2=little)\n", *((SLuint32*)u.pcmMetaData.data));
|
|
formatQueried = true;
|
|
}
|
|
#endif
|
|
|
|
++decodedFrames;
|
|
decodedSamples += SAMPLES_PER_AAC_FRAME;
|
|
|
|
/* Periodically ask for position and duration */
|
|
if ((decodedFrames % 1000 == 0) || endOfEncodedStream) {
|
|
SLmillisecond position;
|
|
res = (*pCntxt->playItf)->GetPosition(pCntxt->playItf, &position);
|
|
ExitOnError(res);
|
|
SLmillisecond duration;
|
|
res = (*pCntxt->playItf)->GetDuration(pCntxt->playItf, &duration);
|
|
ExitOnError(res);
|
|
if (duration == SL_TIME_UNKNOWN) {
|
|
printf("After %zu encoded %zu decoded frames: position is %u ms, duration is "
|
|
"unknown as expected\n",
|
|
encodedFrames, decodedFrames, position);
|
|
} else {
|
|
printf("After %zu encoded %zu decoded frames: position is %u ms, duration is "
|
|
"surprisingly %u ms\n",
|
|
encodedFrames, decodedFrames, position, duration);
|
|
}
|
|
}
|
|
|
|
if (endOfEncodedStream && decodedSamples >= encodedSamples) {
|
|
eos = true;
|
|
pthread_cond_signal(&eosCondition);
|
|
}
|
|
pthread_mutex_unlock(&eosLock);
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
|
|
/* Decode an audio path by opening a file descriptor on that path */
|
|
void TestDecToBuffQueue( SLObjectItf sl, const char *path, int fd)
|
|
{
|
|
// check what kind of object it is
|
|
int ok;
|
|
struct stat statbuf;
|
|
ok = fstat(fd, &statbuf);
|
|
if (ok < 0) {
|
|
perror(path);
|
|
return;
|
|
}
|
|
|
|
// verify that's it is a file
|
|
if (!S_ISREG(statbuf.st_mode)) {
|
|
fprintf(stderr, "%s: not an ordinary file\n", path);
|
|
return;
|
|
}
|
|
|
|
// map file contents into memory to make it easier to access the ADTS frames directly
|
|
ptr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, (off_t) 0);
|
|
if (ptr == MAP_FAILED) {
|
|
perror(path);
|
|
return;
|
|
}
|
|
frame = (unsigned char *) ptr;
|
|
filelen = statbuf.st_size;
|
|
|
|
// create PCM .raw file
|
|
if (createRaw) {
|
|
size_t len = strlen((const char *) path);
|
|
char* outputPath = (char*) malloc(len + 4 + 1); // save room to concatenate ".raw"
|
|
if (NULL == outputPath) {
|
|
ExitOnError(SL_RESULT_RESOURCE_ERROR);
|
|
}
|
|
memcpy(outputPath, path, len + 1);
|
|
strcat(outputPath, ".raw");
|
|
outputFp = fopen(outputPath, "w");
|
|
if (NULL == outputFp) {
|
|
// issue an error message, but continue the decoding anyway
|
|
perror(outputPath);
|
|
}
|
|
free(outputPath);
|
|
} else {
|
|
outputFp = NULL;
|
|
}
|
|
|
|
SLresult res;
|
|
SLEngineItf EngineItf;
|
|
|
|
/* Objects this application uses: one audio player */
|
|
SLObjectItf player;
|
|
|
|
/* Interfaces for the audio player */
|
|
SLPlayItf playItf;
|
|
#ifdef QUERY_METADATA
|
|
/* to retrieve the decoded PCM format */
|
|
SLMetadataExtractionItf mdExtrItf;
|
|
#endif
|
|
/* to retrieve the PCM samples */
|
|
SLAndroidSimpleBufferQueueItf decBuffQueueItf;
|
|
/* to queue the AAC data to decode */
|
|
SLAndroidBufferQueueItf aacBuffQueueItf;
|
|
/* for prefetch status */
|
|
SLPrefetchStatusItf prefetchItf;
|
|
|
|
SLboolean required[NUM_EXPLICIT_INTERFACES_FOR_PLAYER];
|
|
SLInterfaceID iidArray[NUM_EXPLICIT_INTERFACES_FOR_PLAYER];
|
|
|
|
/* Get the SL Engine Interface which is implicit */
|
|
res = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void*)&EngineItf);
|
|
ExitOnError(res);
|
|
|
|
/* Initialize arrays required[] and iidArray[] */
|
|
unsigned int i;
|
|
for (i=0 ; i < NUM_EXPLICIT_INTERFACES_FOR_PLAYER ; i++) {
|
|
required[i] = SL_BOOLEAN_FALSE;
|
|
iidArray[i] = SL_IID_NULL;
|
|
}
|
|
|
|
/* ------------------------------------------------------ */
|
|
/* Configuration of the player */
|
|
|
|
/* Request the AndroidSimpleBufferQueue interface */
|
|
required[0] = SL_BOOLEAN_TRUE;
|
|
iidArray[0] = SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
|
|
/* Request the AndroidBufferQueue interface */
|
|
required[1] = SL_BOOLEAN_TRUE;
|
|
iidArray[1] = SL_IID_ANDROIDBUFFERQUEUESOURCE;
|
|
/* Request the PrefetchStatus interface */
|
|
required[2] = SL_BOOLEAN_TRUE;
|
|
iidArray[2] = SL_IID_PREFETCHSTATUS;
|
|
#ifdef QUERY_METADATA
|
|
/* Request the MetadataExtraction interface */
|
|
required[3] = SL_BOOLEAN_TRUE;
|
|
iidArray[3] = SL_IID_METADATAEXTRACTION;
|
|
#endif
|
|
|
|
/* Setup the data source for queueing AAC buffers of ADTS data */
|
|
SLDataLocator_AndroidBufferQueue loc_srcAbq = {
|
|
SL_DATALOCATOR_ANDROIDBUFFERQUEUE /*locatorType*/,
|
|
NB_BUFFERS_IN_ADTS_QUEUE /*numBuffers*/};
|
|
SLDataFormat_MIME format_srcMime = {
|
|
SL_DATAFORMAT_MIME /*formatType*/,
|
|
SL_ANDROID_MIME_AACADTS /*mimeType*/,
|
|
SL_CONTAINERTYPE_RAW /*containerType*/};
|
|
SLDataSource decSource = {&loc_srcAbq /*pLocator*/, &format_srcMime /*pFormat*/};
|
|
|
|
/* Setup the data sink, a buffer queue for buffers of PCM data */
|
|
SLDataLocator_AndroidSimpleBufferQueue loc_destBq = {
|
|
SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE/*locatorType*/,
|
|
NB_BUFFERS_IN_PCM_QUEUE /*numBuffers*/ };
|
|
|
|
/* declare we're decoding to PCM, the parameters after that need to be valid,
|
|
but are ignored, the decoded format will match the source */
|
|
SLDataFormat_PCM format_destPcm = { /*formatType*/ SL_DATAFORMAT_PCM, /*numChannels*/ 1,
|
|
/*samplesPerSec*/ SL_SAMPLINGRATE_8, /*pcm.bitsPerSample*/ SL_PCMSAMPLEFORMAT_FIXED_16,
|
|
/*/containerSize*/ 16, /*channelMask*/ SL_SPEAKER_FRONT_LEFT,
|
|
/*endianness*/ SL_BYTEORDER_LITTLEENDIAN };
|
|
SLDataSink decDest = {&loc_destBq /*pLocator*/, &format_destPcm /*pFormat*/};
|
|
|
|
/* Create the audio player */
|
|
res = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &decSource, &decDest,
|
|
#ifdef QUERY_METADATA
|
|
NUM_EXPLICIT_INTERFACES_FOR_PLAYER,
|
|
#else
|
|
NUM_EXPLICIT_INTERFACES_FOR_PLAYER - 1,
|
|
#endif
|
|
iidArray, required);
|
|
ExitOnError(res);
|
|
printf("Player created\n");
|
|
|
|
/* Realize the player in synchronous mode. */
|
|
res = (*player)->Realize(player, SL_BOOLEAN_FALSE);
|
|
ExitOnError(res);
|
|
printf("Player realized\n");
|
|
|
|
/* Get the play interface which is implicit */
|
|
res = (*player)->GetInterface(player, SL_IID_PLAY, (void*)&playItf);
|
|
ExitOnError(res);
|
|
|
|
/* Enable callback when position passes through a marker (SL_PLAYEVENT_HEADATMARKER) */
|
|
res = (*playItf)->SetMarkerPosition(playItf, 5000);
|
|
ExitOnError(res);
|
|
|
|
/* Enable callback for periodic position updates (SL_PLAYEVENT_HEADATNEWPOS) */
|
|
res = (*playItf)->SetPositionUpdatePeriod(playItf, 3000);
|
|
ExitOnError(res);
|
|
|
|
/* Use the play interface to set up a callback for the SL_PLAYEVENT_HEAD* events */
|
|
res = (*playItf)->SetCallbackEventsMask(playItf,
|
|
SL_PLAYEVENT_HEADATMARKER | SL_PLAYEVENT_HEADATNEWPOS | SL_PLAYEVENT_HEADATEND);
|
|
ExitOnError(res);
|
|
res = (*playItf)->RegisterCallback(playItf, PlayCallback /*callback*/, NULL /*pContext*/);
|
|
ExitOnError(res);
|
|
|
|
/* Get the position before prefetch; should be zero */
|
|
SLmillisecond position;
|
|
res = (*playItf)->GetPosition(playItf, &position);
|
|
ExitOnError(res);
|
|
if (position == 0) {
|
|
printf("The position before prefetch is zero as expected\n");
|
|
} else if (position == SL_TIME_UNKNOWN) {
|
|
printf("That's surprising the position before prefetch is unknown");
|
|
} else {
|
|
printf("That's surprising the position before prefetch is %u ms\n", position);
|
|
}
|
|
|
|
/* Get the duration before prefetch; should be unknown */
|
|
SLmillisecond duration;
|
|
res = (*playItf)->GetDuration(playItf, &duration);
|
|
ExitOnError(res);
|
|
if (duration == SL_TIME_UNKNOWN) {
|
|
printf("The duration before prefetch is unknown as expected\n");
|
|
} else {
|
|
printf("That's surprising the duration before prefetch is %u ms\n", duration);
|
|
}
|
|
|
|
/* Get the buffer queue interface which was explicitly requested */
|
|
res = (*player)->GetInterface(player, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, (void*)&decBuffQueueItf);
|
|
ExitOnError(res);
|
|
|
|
/* Get the Android buffer queue interface which was explicitly requested */
|
|
res = (*player)->GetInterface(player, SL_IID_ANDROIDBUFFERQUEUESOURCE, (void*)&aacBuffQueueItf);
|
|
ExitOnError(res);
|
|
|
|
/* Get the prefetch status interface which was explicitly requested */
|
|
res = (*player)->GetInterface(player, SL_IID_PREFETCHSTATUS, (void*)&prefetchItf);
|
|
ExitOnError(res);
|
|
|
|
#ifdef QUERY_METADATA
|
|
/* Get the metadata extraction interface which was explicitly requested */
|
|
res = (*player)->GetInterface(player, SL_IID_METADATAEXTRACTION, (void*)&mdExtrItf);
|
|
ExitOnError(res);
|
|
#endif
|
|
|
|
/* ------------------------------------------------------ */
|
|
/* Initialize the callback and its context for the buffer queue of the decoded PCM */
|
|
CallbackCntxt sinkCntxt;
|
|
sinkCntxt.playItf = playItf;
|
|
#ifdef QUERY_METADATA
|
|
sinkCntxt.metaItf = mdExtrItf;
|
|
#endif
|
|
sinkCntxt.pDataBase = (int8_t*)&pcmData;
|
|
sinkCntxt.pData = sinkCntxt.pDataBase;
|
|
res = (*decBuffQueueItf)->RegisterCallback(decBuffQueueItf, DecPlayCallback, &sinkCntxt);
|
|
ExitOnError(res);
|
|
|
|
/* Enqueue buffers to map the region of memory allocated to store the decoded data */
|
|
printf("Enqueueing initial empty buffers to receive decoded PCM data");
|
|
for(i = 0 ; i < NB_BUFFERS_IN_PCM_QUEUE ; i++) {
|
|
printf(" %d", i);
|
|
res = (*decBuffQueueItf)->Enqueue(decBuffQueueItf, sinkCntxt.pData, BUFFER_SIZE_IN_BYTES);
|
|
ExitOnError(res);
|
|
sinkCntxt.pData += BUFFER_SIZE_IN_BYTES;
|
|
if (sinkCntxt.pData >= sinkCntxt.pDataBase +
|
|
(NB_BUFFERS_IN_PCM_QUEUE * BUFFER_SIZE_IN_BYTES)) {
|
|
sinkCntxt.pData = sinkCntxt.pDataBase;
|
|
}
|
|
}
|
|
printf("\n");
|
|
|
|
/* ------------------------------------------------------ */
|
|
/* Initialize the callback for prefetch errors, if we can't open the resource to decode */
|
|
res = (*prefetchItf)->RegisterCallback(prefetchItf, PrefetchEventCallback, NULL);
|
|
ExitOnError(res);
|
|
res = (*prefetchItf)->SetCallbackEventsMask(prefetchItf, PREFETCHEVENT_ERROR_CANDIDATE);
|
|
ExitOnError(res);
|
|
|
|
/* Initialize the callback for the Android buffer queue of the encoded data */
|
|
res = (*aacBuffQueueItf)->RegisterCallback(aacBuffQueueItf, AndroidBufferQueueCallback, NULL);
|
|
ExitOnError(res);
|
|
|
|
/* Enqueue the content of our encoded data before starting to play,
|
|
we don't want to starve the player initially */
|
|
printf("Enqueueing initial full buffers of encoded ADTS data");
|
|
for (i=0 ; i < NB_BUFFERS_IN_ADTS_QUEUE ; i++) {
|
|
if (filelen < 7 || frame[0] != 0xFF || (frame[1] & 0xF0) != 0xF0) {
|
|
printf("\ncorrupt ADTS frame encountered; offset %zu bytes\n",
|
|
frame - (unsigned char *) ptr);
|
|
// Note that prefetch will detect this error soon when it gets a premature EOF
|
|
break;
|
|
}
|
|
unsigned framelen = ((frame[3] & 3) << 11) | (frame[4] << 3) | (frame[5] >> 5);
|
|
printf(" %d (%u bytes)", i, framelen);
|
|
res = (*aacBuffQueueItf)->Enqueue(aacBuffQueueItf, NULL /*pBufferContext*/,
|
|
frame, framelen, NULL, 0);
|
|
ExitOnError(res);
|
|
frame += framelen;
|
|
filelen -= framelen;
|
|
++encodedFrames;
|
|
encodedSamples += SAMPLES_PER_AAC_FRAME;
|
|
frameStats.sample(framelen);
|
|
}
|
|
printf("\n");
|
|
|
|
#ifdef QUERY_METADATA
|
|
/* ------------------------------------------------------ */
|
|
/* Get and display the metadata key names for the decoder */
|
|
// This is for test / demonstration purposes only where we discover the key and value sizes
|
|
// of a PCM decoder. An application that would want to directly get access to those values
|
|
// can make assumptions about the size of the keys and their matching values (all SLuint32),
|
|
// but it should not make assumptions about the key indices as these are subject to change.
|
|
// Note that we don't get the metadata values yet; that happens in the first decode callback.
|
|
SLuint32 itemCount;
|
|
res = (*mdExtrItf)->GetItemCount(mdExtrItf, &itemCount);
|
|
ExitOnError(res);
|
|
printf("itemCount=%u\n", itemCount);
|
|
SLuint32 keySize, valueSize;
|
|
SLMetadataInfo *keyInfo, *value;
|
|
for(i=0 ; i<itemCount ; i++) {
|
|
keyInfo = NULL; keySize = 0;
|
|
value = NULL; valueSize = 0;
|
|
res = (*mdExtrItf)->GetKeySize(mdExtrItf, i, &keySize);
|
|
ExitOnError(res);
|
|
res = (*mdExtrItf)->GetValueSize(mdExtrItf, i, &valueSize);
|
|
ExitOnError(res);
|
|
keyInfo = (SLMetadataInfo*) malloc(keySize);
|
|
if (NULL != keyInfo) {
|
|
res = (*mdExtrItf)->GetKey(mdExtrItf, i, keySize, keyInfo);
|
|
ExitOnError(res);
|
|
printf("key[%d] size=%d, name=%s \tvalue size=%d encoding=0x%X langCountry=%s\n",
|
|
i, keyInfo->size, keyInfo->data, valueSize, keyInfo->encoding,
|
|
keyInfo->langCountry);
|
|
/* find out the key index of the metadata we're interested in */
|
|
if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_NUMCHANNELS)) {
|
|
channelCountKeyIndex = i;
|
|
} else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_SAMPLERATE)) {
|
|
sampleRateKeyIndex = i;
|
|
} else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE)) {
|
|
bitsPerSampleKeyIndex = i;
|
|
} else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_CONTAINERSIZE)) {
|
|
containerSizeKeyIndex = i;
|
|
} else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_CHANNELMASK)) {
|
|
channelMaskKeyIndex = i;
|
|
} else if (!strcmp((char*)keyInfo->data, ANDROID_KEY_PCMFORMAT_ENDIANNESS)) {
|
|
endiannessKeyIndex = i;
|
|
} else {
|
|
printf("Unknown key %s ignored\n", (char *)keyInfo->data);
|
|
}
|
|
free(keyInfo);
|
|
}
|
|
}
|
|
if (channelCountKeyIndex != -1) {
|
|
printf("Key %s is at index %d\n",
|
|
ANDROID_KEY_PCMFORMAT_NUMCHANNELS, channelCountKeyIndex);
|
|
} else {
|
|
fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_NUMCHANNELS);
|
|
}
|
|
if (sampleRateKeyIndex != -1) {
|
|
printf("Key %s is at index %d\n",
|
|
ANDROID_KEY_PCMFORMAT_SAMPLERATE, sampleRateKeyIndex);
|
|
} else {
|
|
fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_SAMPLERATE);
|
|
}
|
|
if (bitsPerSampleKeyIndex != -1) {
|
|
printf("Key %s is at index %d\n",
|
|
ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE, bitsPerSampleKeyIndex);
|
|
} else {
|
|
fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE);
|
|
}
|
|
if (containerSizeKeyIndex != -1) {
|
|
printf("Key %s is at index %d\n",
|
|
ANDROID_KEY_PCMFORMAT_CONTAINERSIZE, containerSizeKeyIndex);
|
|
} else {
|
|
fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_CONTAINERSIZE);
|
|
}
|
|
if (channelMaskKeyIndex != -1) {
|
|
printf("Key %s is at index %d\n",
|
|
ANDROID_KEY_PCMFORMAT_CHANNELMASK, channelMaskKeyIndex);
|
|
} else {
|
|
fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_CHANNELMASK);
|
|
}
|
|
if (endiannessKeyIndex != -1) {
|
|
printf("Key %s is at index %d\n",
|
|
ANDROID_KEY_PCMFORMAT_ENDIANNESS, endiannessKeyIndex);
|
|
} else {
|
|
fprintf(stderr, "Unable to find key %s\n", ANDROID_KEY_PCMFORMAT_ENDIANNESS);
|
|
}
|
|
#endif
|
|
|
|
// set the player's state to paused, to start prefetching
|
|
printf("Setting play state to PAUSED\n");
|
|
res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PAUSED);
|
|
ExitOnError(res);
|
|
|
|
// wait for prefetch status callback to indicate either sufficient data or error
|
|
printf("Awaiting prefetch complete\n");
|
|
pthread_mutex_lock(&mutex);
|
|
while (prefetch_status == PREFETCHSTATUS_UNKNOWN) {
|
|
pthread_cond_wait(&cond, &mutex);
|
|
}
|
|
pthread_mutex_unlock(&mutex);
|
|
if (prefetch_status == PREFETCHSTATUS_ERROR) {
|
|
fprintf(stderr, "Error during prefetch, exiting\n");
|
|
goto destroyRes;
|
|
}
|
|
printf("Prefetch is complete\n");
|
|
|
|
/* ------------------------------------------------------ */
|
|
/* Start decoding */
|
|
printf("Starting to decode\n");
|
|
res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING);
|
|
ExitOnError(res);
|
|
|
|
/* Decode until the end of the stream is reached */
|
|
printf("Awaiting notification that all encoded buffers have been enqueued\n");
|
|
pthread_mutex_lock(&eosLock);
|
|
while (!eos) {
|
|
if (pauseFrame > 0) {
|
|
if (decodedFrames >= pauseFrame) {
|
|
pauseFrame = 0;
|
|
printf("Pausing after decoded frame %zu for 10 seconds\n", decodedFrames);
|
|
pthread_mutex_unlock(&eosLock);
|
|
res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PAUSED);
|
|
ExitOnError(res);
|
|
sleep(10);
|
|
printf("Resuming\n");
|
|
res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING);
|
|
ExitOnError(res);
|
|
pthread_mutex_lock(&eosLock);
|
|
} else {
|
|
pthread_mutex_unlock(&eosLock);
|
|
usleep(10*1000);
|
|
pthread_mutex_lock(&eosLock);
|
|
}
|
|
} else {
|
|
pthread_cond_wait(&eosCondition, &eosLock);
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&eosLock);
|
|
printf("All encoded buffers have now been enqueued, but there's still more to do\n");
|
|
|
|
/* This just means done enqueueing; there may still more data in decode queue! */
|
|
pthread_mutex_lock(&head_mutex);
|
|
while (!head_atend) {
|
|
pthread_cond_wait(&head_cond, &head_mutex);
|
|
}
|
|
pthread_mutex_unlock(&head_mutex);
|
|
printf("Decode is now finished\n");
|
|
|
|
pthread_mutex_lock(&eosLock);
|
|
printf("Frame counters: encoded=%zu decoded=%zu\n", encodedFrames, decodedFrames);
|
|
printf("Sample counters: encoded=%zu decoded=%zu\n", encodedSamples, decodedSamples);
|
|
printf("Total encode completions received: actual=%zu, expected=%zu\n",
|
|
totalEncodeCompletions, encodedFrames+1/*EOS*/);
|
|
pthread_mutex_unlock(&eosLock);
|
|
|
|
/* Get the final position and duration */
|
|
res = (*playItf)->GetPosition(playItf, &position);
|
|
ExitOnError(res);
|
|
res = (*playItf)->GetDuration(playItf, &duration);
|
|
ExitOnError(res);
|
|
if (duration == SL_TIME_UNKNOWN) {
|
|
printf("The final position is %u ms, duration is unknown\n", position);
|
|
} else {
|
|
printf("The final position is %u ms, duration is %u ms\n", position, duration);
|
|
}
|
|
|
|
printf("Frame length statistics:\n");
|
|
printf(" n = %u frames\n", frameStats.n());
|
|
printf(" mean = %.1f bytes\n", frameStats.mean());
|
|
printf(" minimum = %.1f bytes\n", frameStats.minimum());
|
|
printf(" maximum = %.1f bytes\n", frameStats.maximum());
|
|
printf(" stddev = %.1f bytes\n", frameStats.stddev());
|
|
|
|
/* ------------------------------------------------------ */
|
|
/* End of decoding */
|
|
|
|
destroyRes:
|
|
/* Destroy the AudioPlayer object */
|
|
(*player)->Destroy(player);
|
|
|
|
if (outputFp != NULL) {
|
|
fclose(outputFp);
|
|
}
|
|
|
|
// unmap the ADTS AAC file from memory
|
|
ok = munmap(ptr, statbuf.st_size);
|
|
if (0 != ok) {
|
|
perror(path);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
int main(int argc, char* const argv[])
|
|
{
|
|
SLresult res;
|
|
SLObjectItf sl;
|
|
|
|
printf("OpenSL ES test %s: decodes a file containing AAC ADTS data\n", argv[0]);
|
|
|
|
if (argc != 2) {
|
|
printf("Usage: \t%s source_file\n", argv[0]);
|
|
printf("Example: \"%s /sdcard/myFile.adts\n", argv[0]);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// open pathname of encoded ADTS AAC file to get a file descriptor
|
|
int fd;
|
|
fd = open(argv[1], O_RDONLY);
|
|
if (fd < 0) {
|
|
perror(argv[1]);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
SLEngineOption EngineOption[] = {
|
|
{(SLuint32) SL_ENGINEOPTION_THREADSAFE, (SLuint32) SL_BOOLEAN_TRUE}
|
|
};
|
|
|
|
res = slCreateEngine( &sl, 1, EngineOption, 0, NULL, NULL);
|
|
ExitOnError(res);
|
|
|
|
/* Realizing the SL Engine in synchronous mode. */
|
|
res = (*sl)->Realize(sl, SL_BOOLEAN_FALSE);
|
|
ExitOnError(res);
|
|
|
|
TestDecToBuffQueue(sl, argv[1], fd);
|
|
|
|
/* Shutdown OpenSL ES */
|
|
(*sl)->Destroy(sl);
|
|
|
|
// close the file
|
|
(void) close(fd);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|