| /* |
| * 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. |
| */ |
| |
| // OpenMAX AL MediaPlayer command-line player |
| |
| #include <assert.h> |
| #include <pthread.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <fcntl.h> |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <OMXAL/OpenMAXAL.h> |
| #include <OMXAL/OpenMAXAL_Android.h> |
| #include "nativewindow.h" |
| |
| #define MPEG2TS_PACKET_SIZE 188 // MPEG-2 transport stream packet size in bytes |
| #define PACKETS_PER_BUFFER 20 // Number of MPEG-2 transport stream packets per buffer |
| |
| #define NB_BUFFERS 2 // Number of buffers in Android buffer queue |
| |
| // MPEG-2 transport stream packet |
| typedef struct { |
| char data[MPEG2TS_PACKET_SIZE]; |
| } MPEG2TS_Packet; |
| |
| // Globals shared between main thread and buffer queue callback |
| MPEG2TS_Packet *packets; |
| size_t totalPackets; // total number of packets in input file |
| size_t numPackets; // number of packets to play, defaults to totalPackets - firstPacket |
| size_t curPacket; // current packet index |
| size_t discPacket; // discontinuity packet index, defaults to no discontinuity requested |
| size_t afterDiscPacket; // packet index to switch to after the discontinuity |
| size_t firstPacket; // first packet index to be played, defaults to zero |
| size_t lastPacket; // last packet index to be played |
| size_t formatPacket; // format change packet index, defaults to no format change requested |
| XAmillisecond seekPos = XA_TIME_UNKNOWN; // seek to this position initially |
| int pauseMs = -1; // pause after this many ms into playback |
| XAboolean forceCallbackFailure = XA_BOOLEAN_FALSE; // force callback failures occasionally |
| XAboolean sentEOS = XA_BOOLEAN_FALSE; // whether we have enqueued EOS yet |
| |
| // These are extensions to OpenMAX AL 1.0.1 values |
| |
| #define PREFETCHSTATUS_UNKNOWN ((XAuint32) 0) |
| #define PREFETCHSTATUS_ERROR ((XAuint32) (-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; |
| XAuint32 prefetch_status = PREFETCHSTATUS_UNKNOWN; |
| |
| /* used to detect errors likely to have occured when the OpenMAX AL 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 \ |
| (XA_PREFETCHEVENT_STATUSCHANGE | XA_PREFETCHEVENT_FILLLEVELCHANGE) |
| |
| // stream event change callback |
| void streamEventChangeCallback(XAStreamInformationItf caller __unused, XAuint32 eventId, |
| XAuint32 streamIndex, void *pEventData, void *pContext) |
| { |
| // context parameter is specified as NULL and is unused here |
| assert(NULL == pContext); |
| switch (eventId) { |
| case XA_STREAMCBEVENT_PROPERTYCHANGE: |
| printf("XA_STREAMCBEVENT_PROPERTYCHANGE on stream index %u, pEventData %p\n", streamIndex, |
| pEventData); |
| break; |
| default: |
| printf("Unknown stream event ID %u\n", eventId); |
| break; |
| } |
| } |
| |
| // prefetch status callback |
| void prefetchStatusCallback(XAPrefetchStatusItf caller, void *pContext, XAuint32 event) |
| { |
| // pContext is unused here, so we pass NULL |
| assert(pContext == NULL); |
| XApermille level = 0; |
| XAresult result; |
| result = (*caller)->GetFillLevel(caller, &level); |
| assert(XA_RESULT_SUCCESS == result); |
| XAuint32 status; |
| result = (*caller)->GetPrefetchStatus(caller, &status); |
| assert(XA_RESULT_SUCCESS == result); |
| if (event & XA_PREFETCHEVENT_FILLLEVELCHANGE) { |
| printf("PrefetchEventCallback: Buffer fill level is = %d\n", level); |
| } |
| if (event & XA_PREFETCHEVENT_STATUSCHANGE) { |
| printf("PrefetchEventCallback: Prefetch Status is = %u\n", status); |
| } |
| XAuint32 new_prefetch_status; |
| if ((PREFETCHEVENT_ERROR_CANDIDATE == (event & PREFETCHEVENT_ERROR_CANDIDATE)) |
| && (level == 0) && (status == XA_PREFETCHSTATUS_UNDERFLOW)) { |
| printf("PrefetchEventCallback: Error while prefetching data, exiting\n"); |
| new_prefetch_status = PREFETCHSTATUS_ERROR; |
| } else if (event == XA_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); |
| } |
| |
| // playback event callback |
| void playEventCallback(XAPlayItf caller, void *pContext, XAuint32 event) |
| { |
| // pContext is unused here, so we pass NULL |
| assert(NULL == pContext); |
| |
| XAresult result; |
| XAmillisecond position; |
| result = (*caller)->GetPosition(caller, &position); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| if (XA_PLAYEVENT_HEADATEND & event) { |
| printf("XA_PLAYEVENT_HEADATEND current position=%u ms\n", position); |
| } |
| |
| if (XA_PLAYEVENT_HEADATNEWPOS & event) { |
| printf("XA_PLAYEVENT_HEADATNEWPOS current position=%u ms\n", position); |
| } |
| |
| if (XA_PLAYEVENT_HEADATMARKER & event) { |
| printf("XA_PLAYEVENT_HEADATMARKER current position=%u ms\n", position); |
| } |
| } |
| |
| // Android buffer queue callback |
| XAresult bufferQueueCallback( |
| XAAndroidBufferQueueItf caller, |
| void *pCallbackContext, |
| void *pBufferContext __unused, |
| void *pBufferData __unused, |
| XAuint32 dataSize __unused, |
| XAuint32 dataUsed __unused, |
| const XAAndroidBufferItem *pItems __unused, |
| XAuint32 itemsLength __unused) |
| { |
| XAPlayItf playerPlay = (XAPlayItf) pCallbackContext; |
| // enqueue the .ts data directly from mapped memory, so ignore the empty buffer pBufferData |
| if (curPacket <= lastPacket) { |
| static const XAAndroidBufferItem discontinuity = {XA_ANDROID_ITEMKEY_DISCONTINUITY, 0, {}}; |
| static const XAAndroidBufferItem eos = {XA_ANDROID_ITEMKEY_EOS, 0, {}}; |
| static const XAAndroidBufferItem formatChange = {XA_ANDROID_ITEMKEY_FORMAT_CHANGE, 0, {}}; |
| const XAAndroidBufferItem *items; |
| XAuint32 itemSize; |
| // compute number of packets to be enqueued in this buffer |
| XAuint32 packetsThisBuffer = lastPacket - curPacket; |
| if (packetsThisBuffer > PACKETS_PER_BUFFER) { |
| packetsThisBuffer = PACKETS_PER_BUFFER; |
| } |
| // last packet? this should only happen once |
| if (curPacket == lastPacket) { |
| if (sentEOS) { |
| printf("buffer completion callback after EOS\n"); |
| return XA_RESULT_SUCCESS; |
| } |
| printf("sending EOS\n"); |
| items = &eos; |
| itemSize = sizeof(eos); |
| sentEOS = XA_BOOLEAN_TRUE; |
| // discontinuity requested? |
| } else if (curPacket == discPacket) { |
| printf("sending discontinuity at packet %zu, then resuming at packet %zu\n", discPacket, |
| afterDiscPacket); |
| items = &discontinuity; |
| itemSize = sizeof(discontinuity); |
| curPacket = afterDiscPacket; |
| // format change requested? |
| } else if (curPacket == formatPacket) { |
| printf("sending format change"); |
| items = &formatChange; |
| itemSize = sizeof(formatChange); |
| // pure data with no items |
| } else { |
| items = NULL; |
| itemSize = 0; |
| } |
| XAresult result; |
| // enqueue the optional data and optional items; there is always at least one or the other |
| assert(packetsThisBuffer > 0 || itemSize > 0); |
| result = (*caller)->Enqueue(caller, NULL, &packets[curPacket], |
| sizeof(MPEG2TS_Packet) * packetsThisBuffer, items, itemSize); |
| assert(XA_RESULT_SUCCESS == result); |
| curPacket += packetsThisBuffer; |
| // display position periodically |
| if (curPacket % 1000 == 0) { |
| XAmillisecond position; |
| result = (*playerPlay)->GetPosition(playerPlay, &position); |
| assert(XA_RESULT_SUCCESS == result); |
| printf("Position after enqueueing packet %zu: %u ms\n", curPacket, position); |
| } |
| } |
| if (forceCallbackFailure && (curPacket % 1230 == 0)) { |
| return (XAresult) curPacket; |
| } else { |
| return XA_RESULT_SUCCESS; |
| } |
| } |
| |
| // convert a domain type to string |
| static const char *domainToString(XAuint32 domain) |
| { |
| switch (domain) { |
| case 0: // FIXME There's a private declaration '#define XA_DOMAINTYPE_CONTAINER 0' in src/data.h |
| // but we don't have access to it. Plan to file a bug with Khronos about this symbol. |
| return "media container"; |
| #define _(x) case x: return #x; |
| _(XA_DOMAINTYPE_AUDIO) |
| _(XA_DOMAINTYPE_VIDEO) |
| _(XA_DOMAINTYPE_IMAGE) |
| _(XA_DOMAINTYPE_TIMEDTEXT) |
| _(XA_DOMAINTYPE_MIDI) |
| _(XA_DOMAINTYPE_VENDOR) |
| _(XA_DOMAINTYPE_UNKNOWN) |
| #undef _ |
| default: |
| return "unknown"; |
| } |
| } |
| |
| // main program |
| int main(int argc, char **argv) |
| { |
| const char *prog = argv[0]; |
| int i; |
| |
| XAboolean abq = XA_BOOLEAN_FALSE; // use AndroidBufferQueue, default is URI |
| XAboolean looping = XA_BOOLEAN_FALSE; |
| for (i = 1; i < argc; ++i) { |
| const char *arg = argv[i]; |
| if (arg[0] != '-') |
| break; |
| switch (arg[1]) { |
| case 'a': |
| abq = XA_BOOLEAN_TRUE; |
| break; |
| case 'c': |
| forceCallbackFailure = XA_BOOLEAN_TRUE; |
| break; |
| case 'd': |
| discPacket = atoi(&arg[2]); |
| break; |
| case 'D': |
| afterDiscPacket = atoi(&arg[2]); |
| break; |
| case 'f': |
| firstPacket = atoi(&arg[2]); |
| break; |
| case 'F': |
| formatPacket = atoi(&arg[2]); |
| break; |
| case 'l': |
| looping = XA_BOOLEAN_TRUE; |
| break; |
| case 'n': |
| numPackets = atoi(&arg[2]); |
| break; |
| case 'p': |
| pauseMs = atoi(&arg[2]); |
| break; |
| case 's': |
| seekPos = atoi(&arg[2]); |
| break; |
| default: |
| fprintf(stderr, "%s: unknown option %s\n", prog, arg); |
| break; |
| } |
| } |
| |
| // check that exactly one URI was specified |
| if (argc - i != 1) { |
| fprintf(stderr, "usage: %s [-a] [-c] [-d#] [-D#] [-f#] [-F#] [-l] [-n#] [-p#] [-s#] uri\n", |
| prog); |
| fprintf(stderr, " -a Use Android buffer queue to supply data, default is URI\n"); |
| fprintf(stderr, " -c Force callback to return an error randomly, for debugging only\n"); |
| fprintf(stderr, " -d# Packet index to insert a discontinuity, default is none\n"); |
| fprintf(stderr, " -D# Packet index to switch to after the discontinuity\n"); |
| fprintf(stderr, " -f# First packet index, defaults to 0\n"); |
| fprintf(stderr, " -F# Packet index to insert a format change, default is none\n"); |
| fprintf(stderr, " -l Enable looping, for URI only\n"); |
| fprintf(stderr, " -n# Number of packets to enqueue\n"); |
| fprintf(stderr, " -p# Pause playback for 5 seconds after this many milliseconds\n"); |
| fprintf(stderr, " -s# Seek position in milliseconds, for URI only\n"); |
| return EXIT_FAILURE; |
| } |
| const char *uri = argv[i]; |
| |
| // for AndroidBufferQueue, interpret URI as a filename and open |
| int fd = -1; |
| if (abq) { |
| fd = open(uri, O_RDONLY); |
| if (fd < 0) { |
| perror(uri); |
| goto close; |
| } |
| int ok; |
| struct stat statbuf; |
| ok = fstat(fd, &statbuf); |
| if (ok < 0) { |
| perror(uri); |
| goto close; |
| } |
| if (!S_ISREG(statbuf.st_mode)) { |
| fprintf(stderr, "%s: not an ordinary file\n", uri); |
| goto close; |
| } |
| void *ptr; |
| ptr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, (off_t) 0); |
| if (ptr == MAP_FAILED) { |
| perror(uri); |
| goto close; |
| } |
| size_t filelen = statbuf.st_size; |
| if ((filelen % MPEG2TS_PACKET_SIZE) != 0) { |
| fprintf(stderr, "%s: warning file length %zu is not a multiple of %d\n", uri, filelen, |
| MPEG2TS_PACKET_SIZE); |
| } |
| packets = (MPEG2TS_Packet *) ptr; |
| totalPackets = filelen / MPEG2TS_PACKET_SIZE; |
| printf("%s has %zu total packets\n", uri, totalPackets); |
| if (firstPacket >= totalPackets) { |
| fprintf(stderr, "-f%zu ignored\n", firstPacket); |
| firstPacket = 0; |
| } |
| if (numPackets == 0) { |
| numPackets = totalPackets - firstPacket; |
| } else if (firstPacket + numPackets > totalPackets) { |
| fprintf(stderr, "-n%zu ignored\n", numPackets); |
| numPackets = totalPackets - firstPacket; |
| } |
| lastPacket = firstPacket + numPackets; |
| if (discPacket != 0 && (discPacket < firstPacket || discPacket >= lastPacket)) { |
| fprintf(stderr, "-d%zu ignored\n", discPacket); |
| discPacket = 0; |
| } |
| if (afterDiscPacket < firstPacket || afterDiscPacket >= lastPacket) { |
| fprintf(stderr, "-D%zu ignored\n", afterDiscPacket); |
| afterDiscPacket = 0; |
| } |
| if (formatPacket != 0 && (formatPacket < firstPacket || formatPacket >= lastPacket)) { |
| fprintf(stderr, "-F%zu ignored\n", formatPacket); |
| formatPacket = 0; |
| } |
| } |
| |
| ANativeWindow *nativeWindow; |
| |
| XAresult result; |
| XAObjectItf engineObject; |
| |
| // create engine |
| result = xaCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL); |
| assert(XA_RESULT_SUCCESS == result); |
| result = (*engineObject)->Realize(engineObject, XA_BOOLEAN_FALSE); |
| assert(XA_RESULT_SUCCESS == result); |
| XAEngineItf engineEngine; |
| result = (*engineObject)->GetInterface(engineObject, XA_IID_ENGINE, &engineEngine); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // create output mix |
| XAObjectItf outputMixObject; |
| result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, NULL, NULL); |
| assert(XA_RESULT_SUCCESS == result); |
| result = (*outputMixObject)->Realize(outputMixObject, XA_BOOLEAN_FALSE); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // configure media source |
| XADataLocator_URI locUri; |
| locUri.locatorType = XA_DATALOCATOR_URI; |
| locUri.URI = (XAchar *) uri; |
| XADataFormat_MIME fmtMime; |
| fmtMime.formatType = XA_DATAFORMAT_MIME; |
| if (abq) { |
| fmtMime.mimeType = (XAchar *) XA_ANDROID_MIME_MP2TS; |
| fmtMime.containerType = XA_CONTAINERTYPE_MPEG_TS; |
| } else { |
| fmtMime.mimeType = NULL; |
| fmtMime.containerType = XA_CONTAINERTYPE_UNSPECIFIED; |
| } |
| XADataLocator_AndroidBufferQueue locABQ; |
| locABQ.locatorType = XA_DATALOCATOR_ANDROIDBUFFERQUEUE; |
| locABQ.numBuffers = NB_BUFFERS; |
| XADataSource dataSrc; |
| if (abq) { |
| dataSrc.pLocator = &locABQ; |
| } else { |
| dataSrc.pLocator = &locUri; |
| } |
| dataSrc.pFormat = &fmtMime; |
| |
| // configure audio sink |
| XADataLocator_OutputMix locOM; |
| locOM.locatorType = XA_DATALOCATOR_OUTPUTMIX; |
| locOM.outputMix = outputMixObject; |
| XADataSink audioSnk; |
| audioSnk.pLocator = &locOM; |
| audioSnk.pFormat = NULL; |
| |
| // configure video sink |
| nativeWindow = getNativeWindow(); |
| XADataLocator_NativeDisplay locND; |
| locND.locatorType = XA_DATALOCATOR_NATIVEDISPLAY; |
| locND.hWindow = nativeWindow; |
| locND.hDisplay = NULL; |
| XADataSink imageVideoSink; |
| imageVideoSink.pLocator = &locND; |
| imageVideoSink.pFormat = NULL; |
| |
| // create media player |
| XAObjectItf playerObject; |
| XAInterfaceID ids[4] = {XA_IID_STREAMINFORMATION, XA_IID_PREFETCHSTATUS, XA_IID_SEEK, |
| XA_IID_ANDROIDBUFFERQUEUESOURCE}; |
| XAboolean req[4] = {XA_BOOLEAN_TRUE, XA_BOOLEAN_TRUE, XA_BOOLEAN_FALSE, XA_BOOLEAN_TRUE}; |
| result = (*engineEngine)->CreateMediaPlayer(engineEngine, &playerObject, &dataSrc, NULL, |
| &audioSnk, nativeWindow != NULL ? &imageVideoSink : NULL, NULL, NULL, abq ? 4 : 3, ids, |
| req); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // realize the player |
| result = (*playerObject)->Realize(playerObject, XA_BOOLEAN_FALSE); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // get the play interface |
| XAPlayItf playerPlay; |
| result = (*playerObject)->GetInterface(playerObject, XA_IID_PLAY, &playerPlay); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| if (abq) { |
| |
| // get the Android buffer queue interface |
| XAAndroidBufferQueueItf playerAndroidBufferQueue; |
| result = (*playerObject)->GetInterface(playerObject, XA_IID_ANDROIDBUFFERQUEUESOURCE, |
| &playerAndroidBufferQueue); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // register the buffer queue callback |
| result = (*playerAndroidBufferQueue)->RegisterCallback(playerAndroidBufferQueue, |
| bufferQueueCallback, (void *) playerPlay); |
| assert(XA_RESULT_SUCCESS == result); |
| result = (*playerAndroidBufferQueue)->SetCallbackEventsMask(playerAndroidBufferQueue, |
| XA_ANDROIDBUFFERQUEUEEVENT_PROCESSED); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // set the player's state to paused, to start prefetching |
| printf("start early prefetch\n"); |
| result = (*playerPlay)->SetPlayState(playerPlay, XA_PLAYSTATE_PAUSED); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // enqueue the initial buffers until buffer queue is full |
| XAuint32 packetsThisBuffer; |
| for (curPacket = firstPacket; curPacket < lastPacket; curPacket += packetsThisBuffer) { |
| // handle the unlikely case of a very short .ts |
| packetsThisBuffer = lastPacket - curPacket; |
| if (packetsThisBuffer > PACKETS_PER_BUFFER) { |
| packetsThisBuffer = PACKETS_PER_BUFFER; |
| } |
| result = (*playerAndroidBufferQueue)->Enqueue(playerAndroidBufferQueue, NULL, |
| &packets[curPacket], MPEG2TS_PACKET_SIZE * packetsThisBuffer, NULL, 0); |
| if (XA_RESULT_BUFFER_INSUFFICIENT == result) { |
| printf("Enqueued initial %zu packets in %zu buffers\n", curPacket - firstPacket, |
| (curPacket - firstPacket + PACKETS_PER_BUFFER - 1) / PACKETS_PER_BUFFER); |
| break; |
| } |
| assert(XA_RESULT_SUCCESS == result); |
| } |
| |
| } |
| |
| // get the stream information interface |
| XAStreamInformationItf playerStreamInformation; |
| result = (*playerObject)->GetInterface(playerObject, XA_IID_STREAMINFORMATION, |
| &playerStreamInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // register the stream event change callback |
| result = (*playerStreamInformation)->RegisterStreamChangeCallback(playerStreamInformation, |
| streamEventChangeCallback, NULL); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // get the prefetch status interface |
| XAPrefetchStatusItf playerPrefetchStatus; |
| result = (*playerObject)->GetInterface(playerObject, XA_IID_PREFETCHSTATUS, |
| &playerPrefetchStatus); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // register prefetch status callback |
| result = (*playerPrefetchStatus)->RegisterCallback(playerPrefetchStatus, prefetchStatusCallback, |
| NULL); |
| assert(XA_RESULT_SUCCESS == result); |
| result = (*playerPrefetchStatus)->SetCallbackEventsMask(playerPrefetchStatus, |
| XA_PREFETCHEVENT_FILLLEVELCHANGE | XA_PREFETCHEVENT_STATUSCHANGE); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // get the seek interface for seeking and/or looping |
| if (looping || seekPos != XA_TIME_UNKNOWN) { |
| XASeekItf playerSeek; |
| result = (*playerObject)->GetInterface(playerObject, XA_IID_SEEK, &playerSeek); |
| assert(XA_RESULT_SUCCESS == result); |
| if (seekPos != XA_TIME_UNKNOWN) { |
| result = (*playerSeek)->SetPosition(playerSeek, seekPos, XA_SEEKMODE_ACCURATE); |
| if (XA_RESULT_FEATURE_UNSUPPORTED == result) { |
| fprintf(stderr, "-s%u (seek to initial position) is unsupported\n", seekPos); |
| } else { |
| assert(XA_RESULT_SUCCESS == result); |
| } |
| } |
| if (looping) { |
| result = (*playerSeek)->SetLoop(playerSeek, XA_BOOLEAN_TRUE, (XAmillisecond) 0, |
| XA_TIME_UNKNOWN); |
| if (XA_RESULT_FEATURE_UNSUPPORTED) { |
| fprintf(stderr, "-l (looping) is unsupported\n"); |
| } else { |
| assert(XA_RESULT_SUCCESS == result); |
| } |
| } |
| } |
| |
| // register play event callback |
| result = (*playerPlay)->RegisterCallback(playerPlay, playEventCallback, NULL); |
| assert(XA_RESULT_SUCCESS == result); |
| result = (*playerPlay)->SetCallbackEventsMask(playerPlay, |
| XA_PLAYEVENT_HEADATEND | XA_PLAYEVENT_HEADATMARKER | XA_PLAYEVENT_HEADATNEWPOS); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // set a marker |
| result = (*playerPlay)->SetMarkerPosition(playerPlay, 5000); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // set position update period |
| result = (*playerPlay)->SetPositionUpdatePeriod(playerPlay, 2000); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // get the position before prefetch |
| XAmillisecond position; |
| result = (*playerPlay)->GetPosition(playerPlay, &position); |
| assert(XA_RESULT_SUCCESS == result); |
| printf("Position before prefetch: %u ms\n", position); |
| |
| // get the duration before prefetch |
| XAmillisecond duration; |
| result = (*playerPlay)->GetDuration(playerPlay, &duration); |
| assert(XA_RESULT_SUCCESS == result); |
| if (XA_TIME_UNKNOWN == duration) |
| printf("Duration before prefetch: unknown as expected\n"); |
| else |
| printf("Duration before prefetch: %.1f (surprise!)\n", duration / 1000.0f); |
| |
| // set the player's state to paused, to start prefetching |
| printf("start prefetch\n"); |
| result = (*playerPlay)->SetPlayState(playerPlay, XA_PLAYSTATE_PAUSED); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // wait for prefetch status callback to indicate either sufficient data or error |
| 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; |
| } |
| |
| // get the position after prefetch |
| result = (*playerPlay)->GetPosition(playerPlay, &position); |
| assert(XA_RESULT_SUCCESS == result); |
| printf("Position after prefetch: %u ms\n", position); |
| |
| // get duration again, now it should be known for the file source or unknown for TS |
| result = (*playerPlay)->GetDuration(playerPlay, &duration); |
| assert(XA_RESULT_SUCCESS == result); |
| if (duration == XA_TIME_UNKNOWN) { |
| printf("Duration after prefetch: unknown (expected for TS, unexpected for file)\n"); |
| } else { |
| printf("Duration after prefetch: %u ms (expected for file, unexpected for TS)\n", duration); |
| } |
| |
| // query for media container information |
| result = (*playerStreamInformation)->QueryMediaContainerInformation(playerStreamInformation, |
| NULL); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| XAMediaContainerInformation mediaContainerInformation; |
| // this verifies it is filling in all the fields |
| memset(&mediaContainerInformation, 0x55, sizeof(XAMediaContainerInformation)); |
| result = (*playerStreamInformation)->QueryMediaContainerInformation(playerStreamInformation, |
| &mediaContainerInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf("Media container information:\n"); |
| printf(" containerType = %u\n", mediaContainerInformation.containerType); |
| printf(" mediaDuration = %u\n", mediaContainerInformation.mediaDuration); |
| printf(" numStreams = %u\n", mediaContainerInformation.numStreams); |
| |
| // Now query for each the streams. Note that stream indices go up to and including |
| // mediaContainerInformation.numStreams, because stream 0 is the container itself, |
| // while stream 1 to mediaContainerInformation.numStreams are the contained streams. |
| XAuint32 streamIndex; |
| for (streamIndex = 0; streamIndex <= mediaContainerInformation.numStreams; ++streamIndex) { |
| XAuint32 domain; |
| XAuint16 nameSize; |
| XAchar name[64]; |
| printf("stream[%u]:\n", streamIndex); |
| if (streamIndex == 0) { |
| result = (*playerStreamInformation)->QueryStreamType(playerStreamInformation, |
| streamIndex, &domain); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &mediaContainerInformation); |
| //assert(XA_RESULT_PARAMETER_INVALID == result); |
| nameSize = sizeof(name); |
| result = (*playerStreamInformation)->QueryStreamName(playerStreamInformation, |
| streamIndex, &nameSize, name); |
| //assert(XA_RESULT_PARAMETER_INVALID == result); |
| continue; |
| } |
| result = (*playerStreamInformation)->QueryStreamType(playerStreamInformation, streamIndex, |
| NULL); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| domain = 12345; |
| result = (*playerStreamInformation)->QueryStreamType(playerStreamInformation, streamIndex, |
| &domain); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" QueryStreamType: domain = 0x%X (%s)\n", domain, domainToString(domain)); |
| nameSize = sizeof(name); |
| result = (*playerStreamInformation)->QueryStreamName(playerStreamInformation, streamIndex, |
| &nameSize, name); |
| #if 0 |
| assert(XA_RESULT_SUCCESS == result); |
| assert(sizeof(name) >= nameSize); |
| if (sizeof(name) != nameSize) { |
| assert('\0' == name[nameSize]); |
| } |
| printf(" QueryStreamName: nameSize=%u, name=\"%.*s\"\n", nameSize, nameSize, name); |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, NULL); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| #endif |
| |
| printf(" QueryStreamInformation:\n"); |
| switch (domain) { |
| #if 0 |
| case 0: // FIXME container |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &mediaContainerInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" containerType = %u (1=unspecified)\n", |
| mediaContainerInformation.containerType); |
| printf(" mediaDuration = %u\n", mediaContainerInformation.mediaDuration); |
| printf(" numStreams = %u\n", mediaContainerInformation.numStreams); |
| break; |
| #endif |
| case XA_DOMAINTYPE_AUDIO: { |
| XAAudioStreamInformation audioStreamInformation; |
| memset(&audioStreamInformation, 0x55, sizeof(XAAudioStreamInformation)); |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &audioStreamInformation); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| printf(" codecId = %u\n", audioStreamInformation.codecId); |
| printf(" channels = %u\n", audioStreamInformation.channels); |
| printf(" sampleRate = %u\n", audioStreamInformation.sampleRate); |
| printf(" bitRate = %u\n", audioStreamInformation.bitRate); |
| printf(" langCountry = \"%s\"\n", audioStreamInformation.langCountry); |
| printf(" duration = %u\n", audioStreamInformation.duration); |
| } break; |
| case XA_DOMAINTYPE_VIDEO: { |
| XAVideoStreamInformation videoStreamInformation; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &videoStreamInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" codecId = %u\n", videoStreamInformation.codecId); |
| printf(" width = %u\n", videoStreamInformation.width); |
| printf(" height = %u\n", videoStreamInformation.height); |
| printf(" frameRate = %u\n", videoStreamInformation.frameRate); |
| printf(" bitRate = %u\n", videoStreamInformation.bitRate); |
| printf(" duration = %u\n", videoStreamInformation.duration); |
| } break; |
| case XA_DOMAINTYPE_IMAGE: { |
| XAImageStreamInformation imageStreamInformation; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &imageStreamInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" codecId = %u\n", imageStreamInformation.codecId); |
| printf(" width = %u\n", imageStreamInformation.width); |
| printf(" height = %u\n", imageStreamInformation.height); |
| printf(" presentationDuration = %u\n", imageStreamInformation.presentationDuration); |
| } break; |
| case XA_DOMAINTYPE_TIMEDTEXT: { |
| XATimedTextStreamInformation timedTextStreamInformation; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &timedTextStreamInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" layer = %u\n", timedTextStreamInformation.layer); |
| printf(" width = %u\n", timedTextStreamInformation.width); |
| printf(" height = %u\n", timedTextStreamInformation.height); |
| printf(" tx = %u\n", timedTextStreamInformation.tx); |
| printf(" ty = %u\n", timedTextStreamInformation.ty); |
| printf(" bitrate = %u\n", timedTextStreamInformation.bitrate); |
| printf(" langCountry = \"%s\"\n", timedTextStreamInformation.langCountry); |
| printf(" duration = %u\n", timedTextStreamInformation.duration); |
| } break; |
| case XA_DOMAINTYPE_MIDI: { |
| XAMIDIStreamInformation midiStreamInformation; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &midiStreamInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" channels = %u\n", midiStreamInformation.channels); |
| printf(" tracks = %u\n", midiStreamInformation.tracks); |
| printf(" bankType = %u\n", midiStreamInformation.bankType); |
| printf(" langCountry = \"%s\"\n", midiStreamInformation.langCountry); |
| printf(" duration = %u\n", midiStreamInformation.duration); |
| } break; |
| case XA_DOMAINTYPE_VENDOR: { |
| XAVendorStreamInformation vendorStreamInformation; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &vendorStreamInformation); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" VendorStreamInfo = %p\n", vendorStreamInformation.VendorStreamInfo); |
| } break; |
| case XA_DOMAINTYPE_UNKNOWN: { |
| // "It is not possible to query Information for streams identified as |
| // XA_DOMAINTYPE_UNKNOWN, any attempt to do so shall return a result of |
| // XA_RESULT_CONTENT_UNSUPPORTED." |
| char big[256]; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &big); |
| assert(XA_RESULT_CONTENT_UNSUPPORTED == result); |
| } break; |
| default: |
| break; |
| } |
| |
| } |
| // Try one more stream index beyond the valid range |
| XAuint32 domain; |
| result = (*playerStreamInformation)->QueryStreamType(playerStreamInformation, streamIndex, |
| &domain); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| XATimedTextStreamInformation big; |
| result = (*playerStreamInformation)->QueryStreamInformation(playerStreamInformation, |
| streamIndex, &big); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| |
| printf("QueryActiveStreams:\n"); |
| result = (*playerStreamInformation)->QueryActiveStreams(playerStreamInformation, NULL, NULL); |
| assert(XA_RESULT_PARAMETER_INVALID == result); |
| XAuint32 numStreams1 = 0x12345678; |
| result = (*playerStreamInformation)->QueryActiveStreams(playerStreamInformation, &numStreams1, |
| NULL); |
| assert(XA_RESULT_SUCCESS == result); |
| printf(" numStreams = %u\n", numStreams1); |
| XAboolean *activeStreams = calloc(numStreams1 + 1, sizeof(XAboolean)); |
| assert(NULL != activeStreams); |
| printf(" active stream(s) ="); |
| XAuint32 numStreams2 = numStreams1; |
| result = (*playerStreamInformation)->QueryActiveStreams(playerStreamInformation, &numStreams2, |
| activeStreams); |
| assert(XA_RESULT_SUCCESS == result); |
| assert(numStreams2 == numStreams1); |
| for (streamIndex = 0; streamIndex <= numStreams1; ++streamIndex) { |
| if (activeStreams[streamIndex]) |
| printf(" %u", streamIndex); |
| } |
| printf("\n"); |
| |
| // SetActiveStream is untested |
| |
| // start playing |
| printf("starting to play\n"); |
| result = (*playerPlay)->SetPlayState(playerPlay, XA_PLAYSTATE_PLAYING); |
| assert(XA_RESULT_SUCCESS == result); |
| |
| // continue playing until end of media |
| for (;;) { |
| XAuint32 status; |
| result = (*playerPlay)->GetPlayState(playerPlay, &status); |
| assert(XA_RESULT_SUCCESS == result); |
| if (status == XA_PLAYSTATE_PAUSED) |
| break; |
| assert(status == XA_PLAYSTATE_PLAYING); |
| usleep(100000); |
| if (pauseMs >= 0) { |
| result = (*playerPlay)->GetPosition(playerPlay, &position); |
| assert(XA_RESULT_SUCCESS == result); |
| if ((int) position >= pauseMs) { |
| printf("Pausing for 5 seconds at position %u\n", position); |
| result = (*playerPlay)->SetPlayState(playerPlay, XA_PLAYSTATE_PAUSED); |
| assert(XA_RESULT_SUCCESS == result); |
| sleep(5); |
| // FIXME clear ABQ queue here |
| result = (*playerPlay)->SetPlayState(playerPlay, XA_PLAYSTATE_PLAYING); |
| assert(XA_RESULT_SUCCESS == result); |
| pauseMs = -1; |
| } |
| } |
| } |
| |
| // wait a bit more in case of additional callbacks |
| printf("end of media\n"); |
| sleep(3); |
| |
| // get final position |
| result = (*playerPlay)->GetPosition(playerPlay, &position); |
| assert(XA_RESULT_SUCCESS == result); |
| printf("Position at end: %u ms\n", position); |
| |
| // get duration again, now it should be known |
| result = (*playerPlay)->GetDuration(playerPlay, &duration); |
| assert(XA_RESULT_SUCCESS == result); |
| if (duration == XA_TIME_UNKNOWN) { |
| printf("Duration at end: unknown\n"); |
| } else { |
| printf("Duration at end: %u ms\n", duration); |
| } |
| |
| destroyRes: |
| |
| // destroy the player |
| (*playerObject)->Destroy(playerObject); |
| |
| // destroy the output mix |
| (*outputMixObject)->Destroy(outputMixObject); |
| |
| // destroy the engine |
| (*engineObject)->Destroy(engineObject); |
| |
| #if 0 |
| if (nativeWindow != NULL) { |
| ANativeWindow_release(nativeWindow); |
| } |
| #endif |
| |
| close: |
| if (fd >= 0) { |
| (void) close(fd); |
| } |
| |
| disposeNativeWindow(); |
| |
| return EXIT_SUCCESS; |
| } |
