Home | History | Annotate | Download | only in mimeUri
      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 #include <stdlib.h>
     18 #include <stdio.h>
     19 #include <unistd.h>
     20 #include <utils/threads.h>
     21 
     22 #include <SLES/OpenSLES.h>
     23 
     24 /* tolerance in ms for this test in time difference between reported position and time since
     25  * playback was requested to start. This is reasonable for a local file.
     26  */
     27 #define TIME_TOLERANCE_MS 600
     28 
     29 /* explicitly requesting SL_IID_VOLUME and SL_IID_PREFETCHSTATUS
     30  * on the AudioPlayer object */
     31 #define NUM_EXPLICIT_INTERFACES_FOR_PLAYER 2
     32 
     33 /* used to detect errors likely to have occured when the OpenSL ES framework fails to open
     34  * a resource, for instance because a file URI is invalid, or an HTTP server doesn't respond. */
     35 #define PREFETCHEVENT_ERROR_CANDIDATE \
     36         (SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE)
     37 
     38 /* to signal to the test app the end of the stream to decode has been reached */
     39 bool eos = false;
     40 android::Mutex eosLock;
     41 android::Condition eosCondition;
     42 
     43 //-----------------------------------------------------------------
     44 //* Exits the application if an error is encountered */
     45 #define CheckErr(x) ExitOnErrorFunc(x,__LINE__)
     46 
     47 void ExitOnErrorFunc( SLresult result , int line)
     48 {
     49     if (SL_RESULT_SUCCESS != result) {
     50         fprintf(stderr, "%u error code encountered at line %d, exiting\n", result, line);
     51         exit(EXIT_FAILURE);
     52     }
     53 }
     54 
     55 bool prefetchError = false;
     56 
     57 //-----------------------------------------------------------------
     58 void SignalEos() {
     59     android::Mutex::Autolock autoLock(eosLock);
     60     eos = true;
     61     eosCondition.signal();
     62 }
     63 
     64 //-----------------------------------------------------------------
     65 /* PrefetchStatusItf callback for an audio player */
     66 void PrefetchEventCallback( SLPrefetchStatusItf caller,  void *pContext, SLuint32 event)
     67 {
     68     SLpermille level = 0;
     69     SLresult res = (*caller)->GetFillLevel(caller, &level); CheckErr(res);
     70     SLuint32 status;
     71     //fprintf(stdout, "PrefetchEventCallback: received event %u\n", event);
     72     res = (*caller)->GetPrefetchStatus(caller, &status); CheckErr(res);
     73     if ((PREFETCHEVENT_ERROR_CANDIDATE == (event & PREFETCHEVENT_ERROR_CANDIDATE))
     74             && (level == 0) && (status == SL_PREFETCHSTATUS_UNDERFLOW)) {
     75         fprintf(stdout, "PrefetchEventCallback: Error while prefetching data, exiting\n");
     76         prefetchError = true;
     77         return;
     78     }
     79     if (event & SL_PREFETCHEVENT_FILLLEVELCHANGE) {
     80         fprintf(stdout, "PrefetchEventCallback: Buffer fill level is = %d\n", level);
     81     }
     82     if (event & SL_PREFETCHEVENT_STATUSCHANGE) {
     83         fprintf(stdout, "PrefetchEventCallback: Prefetch Status is = %u\n", status);
     84     }
     85 }
     86 
     87 
     88 //-----------------------------------------------------------------
     89 /* PlayItf callback for playback events */
     90 void PlayEventCallback(
     91         SLPlayItf caller,
     92         void *pContext,
     93         SLuint32 event)
     94 {
     95     SLmillisecond posMsec = SL_TIME_UNKNOWN;
     96     SLresult res;
     97     if (SL_PLAYEVENT_HEADATEND & event) {
     98         fprintf(stdout, "SL_PLAYEVENT_HEADATEND reached\n");
     99 #if 0
    100         res = (*caller)->GetPosition(caller, &posMsec); CheckErr(res);
    101         fprintf(stdout, "after getPosition in SL_PLAYEVENT_HEADATEND handler\n");
    102         if (posMsec == SL_TIME_UNKNOWN) {
    103             fprintf(stderr, "Error: position is SL_TIME_UNKNOWN at SL_PLAYEVENT_HEADATEND\n");
    104         } else {
    105             fprintf(stdout, "position is %d at SL_PLAYEVENT_HEADATEND\n", posMsec);
    106         }
    107         // FIXME compare position against duration
    108 #endif
    109         SignalEos();
    110     }
    111 
    112     if (SL_PLAYEVENT_HEADATNEWPOS & event) {
    113         res = (*caller)->GetPosition(caller, &posMsec); CheckErr(res);
    114         fprintf(stdout, "SL_PLAYEVENT_HEADATNEWPOS current position=%ums\n", posMsec);
    115     }
    116 
    117     if (SL_PLAYEVENT_HEADATMARKER & event) {
    118         res = (*caller)->GetPosition(caller, &posMsec); CheckErr(res);
    119         fprintf(stdout, "SL_PLAYEVENT_HEADATMARKER current position=%ums\n", posMsec);
    120     }
    121 }
    122 
    123 
    124 //-----------------------------------------------------------------
    125 
    126 /* Play some audio from a URI and regularly query the position */
    127 void TestGetPositionUri( SLObjectItf sl, const char* path)
    128 {
    129     SLEngineItf                EngineItf;
    130 
    131     SLint32                    numOutputs = 0;
    132     SLuint32                   deviceID = 0;
    133 
    134     SLresult                   res;
    135 
    136     SLDataSource               audioSource;
    137     SLDataLocator_URI          uri;
    138     SLDataFormat_MIME          mime;
    139 
    140     SLDataSink                 audioSink;
    141     SLDataLocator_OutputMix    locator_outputmix;
    142 
    143     SLObjectItf                player;
    144     SLPlayItf                  playItf;
    145     SLVolumeItf                volItf;
    146     SLPrefetchStatusItf        prefetchItf;
    147 
    148     SLObjectItf                OutputMix;
    149 
    150     /* variables for the duration and position tests */
    151     SLuint16      counter = 0;
    152     SLmillisecond posInMsec = SL_TIME_UNKNOWN;
    153     SLmillisecond durationInMsec = SL_TIME_UNKNOWN;
    154 
    155     SLboolean required[NUM_EXPLICIT_INTERFACES_FOR_PLAYER];
    156     SLInterfaceID iidArray[NUM_EXPLICIT_INTERFACES_FOR_PLAYER];
    157 
    158     /* Get the SL Engine Interface which is implicit */
    159     res = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void*)&EngineItf);
    160     CheckErr(res);
    161 
    162     /* Initialize arrays required[] and iidArray[] */
    163     for (int i=0 ; i < NUM_EXPLICIT_INTERFACES_FOR_PLAYER ; i++) {
    164         required[i] = SL_BOOLEAN_FALSE;
    165         iidArray[i] = SL_IID_NULL;
    166     }
    167 
    168     // Set arrays required[] and iidArray[] for VOLUME and PREFETCHSTATUS interface
    169     required[0] = SL_BOOLEAN_TRUE;
    170     iidArray[0] = SL_IID_VOLUME;
    171     required[1] = SL_BOOLEAN_TRUE;
    172     iidArray[1] = SL_IID_PREFETCHSTATUS;
    173     // Create Output Mix object to be used by player
    174     res = (*EngineItf)->CreateOutputMix(EngineItf, &OutputMix, 0,
    175             iidArray, required); CheckErr(res);
    176 
    177     // Realizing the Output Mix object in synchronous mode.
    178     res = (*OutputMix)->Realize(OutputMix, SL_BOOLEAN_FALSE);
    179     CheckErr(res);
    180 
    181     /* Setup the data source structure for the URI */
    182     uri.locatorType = SL_DATALOCATOR_URI;
    183     uri.URI         =  (SLchar*) path;
    184     mime.formatType    = SL_DATAFORMAT_MIME;
    185     mime.mimeType      = (SLchar*)NULL;
    186     mime.containerType = SL_CONTAINERTYPE_UNSPECIFIED;
    187 
    188     audioSource.pFormat      = (void *)&mime;
    189     audioSource.pLocator     = (void *)&uri;
    190 
    191     /* Setup the data sink structure */
    192     locator_outputmix.locatorType   = SL_DATALOCATOR_OUTPUTMIX;
    193     locator_outputmix.outputMix    = OutputMix;
    194     audioSink.pLocator           = (void *)&locator_outputmix;
    195     audioSink.pFormat            = NULL;
    196 
    197     /* Create the audio player */
    198     res = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &audioSource, &audioSink,
    199             NUM_EXPLICIT_INTERFACES_FOR_PLAYER, iidArray, required); CheckErr(res);
    200 
    201     /* Realizing the player in synchronous mode. */
    202     res = (*player)->Realize(player, SL_BOOLEAN_FALSE); CheckErr(res);
    203     fprintf(stdout, "URI example: after Realize\n");
    204 
    205     /* Get interfaces */
    206     res = (*player)->GetInterface(player, SL_IID_PLAY, (void*)&playItf);
    207     CheckErr(res);
    208 
    209     res = (*player)->GetInterface(player, SL_IID_VOLUME,  (void*)&volItf);
    210     CheckErr(res);
    211 
    212     res = (*player)->GetInterface(player, SL_IID_PREFETCHSTATUS, (void*)&prefetchItf);
    213     CheckErr(res);
    214     res = (*prefetchItf)->RegisterCallback(prefetchItf, PrefetchEventCallback, &prefetchItf);
    215     CheckErr(res);
    216     res = (*prefetchItf)->SetCallbackEventsMask(prefetchItf,
    217             SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE);
    218     CheckErr(res);
    219 
    220     /* Configure fill level updates every 5 percent */
    221     res = (*prefetchItf)->SetFillUpdatePeriod(prefetchItf, 50); CheckErr(res);
    222 
    223     /* Set up the player callback to get events during the decoding */
    224     res = (*playItf)->SetMarkerPosition(playItf, 2000);
    225     CheckErr(res);
    226     res = (*playItf)->SetPositionUpdatePeriod(playItf, 500);
    227     CheckErr(res);
    228     res = (*playItf)->SetCallbackEventsMask(playItf,
    229             SL_PLAYEVENT_HEADATMARKER | SL_PLAYEVENT_HEADATNEWPOS | SL_PLAYEVENT_HEADATEND);
    230     CheckErr(res);
    231     res = (*playItf)->RegisterCallback(playItf, PlayEventCallback, NULL);
    232     CheckErr(res);
    233 
    234     /* Set the player volume */
    235     res = (*volItf)->SetVolumeLevel( volItf, -300);
    236     CheckErr(res);
    237 
    238     /* Play the URI */
    239     /*     first cause the player to prefetch the data */
    240     fprintf(stdout, "Setting the player to PAUSED to cause it to prefetch the data\n");
    241     res = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PAUSED ); CheckErr(res);
    242 
    243     usleep(100 * 1000);
    244     /*     wait until there's data to play */
    245     SLuint32 prefetchStatus = SL_PREFETCHSTATUS_UNDERFLOW;
    246     SLuint32 timeOutIndex = 100; // 10s
    247     while ((prefetchStatus != SL_PREFETCHSTATUS_SUFFICIENTDATA) && (timeOutIndex > 0) &&
    248             !prefetchError) {
    249         usleep(100 * 1000);
    250         (*prefetchItf)->GetPrefetchStatus(prefetchItf, &prefetchStatus);
    251         timeOutIndex--;
    252     }
    253 
    254     if (timeOutIndex == 0 || prefetchError) {
    255         fprintf(stderr, "We're done waiting, failed to prefetch data in time, exiting\n");
    256         goto destroyRes;
    257     }
    258 
    259     /* Display duration */
    260     res = (*playItf)->GetDuration(playItf, &durationInMsec); CheckErr(res);
    261     if (durationInMsec == SL_TIME_UNKNOWN) {
    262         fprintf(stderr, "Error: Content duration is unknown after prefetch completed, exiting\n");
    263         goto destroyRes;
    264     } else {
    265         fprintf(stdout, "Content duration is %u ms (after prefetch completed)\n", durationInMsec);
    266     }
    267 
    268     fprintf(stdout, "Setting the player to PLAYING\n");
    269     res = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PLAYING ); CheckErr(res);
    270 
    271     /* Test GetPosition every second */
    272     while ((counter*1000) < durationInMsec) {
    273         counter++;
    274         usleep(1 * 1000 * 1000); //1s
    275         res = (*playItf)->GetPosition(playItf, &posInMsec); CheckErr(res);
    276         if (posInMsec == SL_TIME_UNKNOWN) {
    277             fprintf(stderr, "Error: position is SL_TIME_UNKNOWN %ds after start, exiting\n",
    278                     counter);
    279             goto destroyRes;
    280         } else {
    281             fprintf(stderr, "position is %dms %ds after start\n", posInMsec, counter);
    282         }
    283         // this test would probably deserve to be improved by relying on drift relative to
    284         // a clock, as the operations between two consecutive sleep() are taking time as well
    285         // and can add up
    286         if (((SLint32)posInMsec > (counter*1000 + TIME_TOLERANCE_MS)) ||
    287                 ((SLint32)posInMsec < (counter*1000 - TIME_TOLERANCE_MS))) {
    288             fprintf(stderr, "Error: position drifted too much, exiting\n");
    289             goto destroyRes;
    290         }
    291     }
    292 
    293     /* Play until the end of file is reached */
    294     {
    295         android::Mutex::Autolock autoLock(eosLock);
    296         while (!eos) {
    297             eosCondition.wait(eosLock);
    298         }
    299     }
    300     fprintf(stdout, "EOS signaled, stopping playback\n");
    301     res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_STOPPED); CheckErr(res);
    302 
    303 destroyRes:
    304 
    305     /* Destroy the player */
    306     fprintf(stdout, "Destroying the player\n");
    307     (*player)->Destroy(player);
    308 
    309     /* Destroy Output Mix object */
    310     (*OutputMix)->Destroy(OutputMix);
    311 }
    312 
    313 //-----------------------------------------------------------------
    314 int main(int argc, char* const argv[])
    315 {
    316     SLresult    res;
    317     SLObjectItf sl;
    318 
    319     fprintf(stdout, "OpenSL ES test %s: exercises SLPlayItf", argv[0]);
    320     fprintf(stdout, "and AudioPlayer with SLDataLocator_URI source / OutputMix sink\n");
    321     fprintf(stdout, "Plays a sound and requests position at various times\n\n");
    322 
    323     if (argc == 1) {
    324         fprintf(stdout, "Usage: %s path \n\t%s url\n", argv[0], argv[0]);
    325         fprintf(stdout, "Example: \"%s /sdcard/my.mp3\"  or \"%s file:///sdcard/my.mp3\"\n",
    326                 argv[0], argv[0]);
    327         exit(EXIT_FAILURE);
    328     }
    329 
    330     SLEngineOption EngineOption[] = {
    331             {(SLuint32) SL_ENGINEOPTION_THREADSAFE,
    332             (SLuint32) SL_BOOLEAN_TRUE}};
    333 
    334     res = slCreateEngine( &sl, 1, EngineOption, 0, NULL, NULL);
    335     CheckErr(res);
    336     /* Realizing the SL Engine in synchronous mode. */
    337     res = (*sl)->Realize(sl, SL_BOOLEAN_FALSE);
    338     CheckErr(res);
    339 
    340     TestGetPositionUri(sl, argv[1]);
    341 
    342     /* Shutdown OpenSL ES */
    343     (*sl)->Destroy(sl);
    344 
    345     return EXIT_SUCCESS;
    346 }
    347