Home | History | Annotate | Download | only in android
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "sles_allinclusive.h"
     18 #include "android_prompts.h"
     19 #include "android/android_AudioToCbRenderer.h"
     20 #include "android/android_StreamPlayer.h"
     21 #include "android/android_LocAVPlayer.h"
     22 #include "android/include/AacBqToPcmCbRenderer.h"
     23 
     24 #include <fcntl.h>
     25 #include <sys/stat.h>
     26 
     27 #include <system/audio.h>
     28 
     29 template class android::KeyedVector<SLuint32, android::AudioEffect* > ;
     30 
     31 #define KEY_STREAM_TYPE_PARAMSIZE  sizeof(SLint32)
     32 
     33 #define AUDIOTRACK_MIN_PLAYBACKRATE_PERMILLE  500
     34 #define AUDIOTRACK_MAX_PLAYBACKRATE_PERMILLE 2000
     35 
     36 #define MEDIAPLAYER_MIN_PLAYBACKRATE_PERMILLE AUDIOTRACK_MIN_PLAYBACKRATE_PERMILLE
     37 #define MEDIAPLAYER_MAX_PLAYBACKRATE_PERMILLE AUDIOTRACK_MAX_PLAYBACKRATE_PERMILLE
     38 
     39 //-----------------------------------------------------------------------------
     40 // FIXME this method will be absorbed into android_audioPlayer_setPlayState() once
     41 //       bufferqueue and uri/fd playback are moved under the GenericPlayer C++ object
     42 SLresult aplayer_setPlayState(const android::sp<android::GenericPlayer> &ap, SLuint32 playState,
     43         AndroidObjectState* pObjState) {
     44     SLresult result = SL_RESULT_SUCCESS;
     45     AndroidObjectState objState = *pObjState;
     46 
     47     switch (playState) {
     48      case SL_PLAYSTATE_STOPPED:
     49          SL_LOGV("setting GenericPlayer to SL_PLAYSTATE_STOPPED");
     50          ap->stop();
     51          break;
     52      case SL_PLAYSTATE_PAUSED:
     53          SL_LOGV("setting GenericPlayer to SL_PLAYSTATE_PAUSED");
     54          switch(objState) {
     55          case ANDROID_UNINITIALIZED:
     56              *pObjState = ANDROID_PREPARING;
     57              ap->prepare();
     58              break;
     59          case ANDROID_PREPARING:
     60              break;
     61          case ANDROID_READY:
     62              ap->pause();
     63              break;
     64          default:
     65              SL_LOGE(ERROR_PLAYERSETPLAYSTATE_INVALID_OBJECT_STATE_D, playState);
     66              result = SL_RESULT_INTERNAL_ERROR;
     67              break;
     68          }
     69          break;
     70      case SL_PLAYSTATE_PLAYING: {
     71          SL_LOGV("setting GenericPlayer to SL_PLAYSTATE_PLAYING");
     72          switch(objState) {
     73          case ANDROID_UNINITIALIZED:
     74              *pObjState = ANDROID_PREPARING;
     75              ap->prepare();
     76              // intended fall through
     77          case ANDROID_PREPARING:
     78              // intended fall through
     79          case ANDROID_READY:
     80              ap->play();
     81              break;
     82          default:
     83              SL_LOGE(ERROR_PLAYERSETPLAYSTATE_INVALID_OBJECT_STATE_D, playState);
     84              result = SL_RESULT_INTERNAL_ERROR;
     85              break;
     86          }
     87          }
     88          break;
     89      default:
     90          // checked by caller, should not happen
     91          SL_LOGE(ERROR_SHOULDNT_BE_HERE_S, "aplayer_setPlayState");
     92          result = SL_RESULT_INTERNAL_ERROR;
     93          break;
     94      }
     95 
     96     return result;
     97 }
     98 
     99 
    100 //-----------------------------------------------------------------------------
    101 // Callback associated with a AudioToCbRenderer of an SL ES AudioPlayer that gets its data
    102 // from a URI or FD, to write the decoded audio data to a buffer queue
    103 static size_t adecoder_writeToBufferQueue(const uint8_t *data, size_t size, CAudioPlayer* ap) {
    104     if (!android::CallbackProtector::enterCbIfOk(ap->mCallbackProtector)) {
    105         // it is not safe to enter the callback (the player is about to go away)
    106         return 0;
    107     }
    108     size_t sizeConsumed = 0;
    109     SL_LOGD("received %d bytes from decoder", size);
    110     slBufferQueueCallback callback = NULL;
    111     void * callbackPContext = NULL;
    112 
    113     // push decoded data to the buffer queue
    114     object_lock_exclusive(&ap->mObject);
    115 
    116     if (ap->mBufferQueue.mState.count != 0) {
    117         assert(ap->mBufferQueue.mFront != ap->mBufferQueue.mRear);
    118 
    119         BufferHeader *oldFront = ap->mBufferQueue.mFront;
    120         BufferHeader *newFront = &oldFront[1];
    121 
    122         uint8_t *pDest = (uint8_t *)oldFront->mBuffer + ap->mBufferQueue.mSizeConsumed;
    123         if (ap->mBufferQueue.mSizeConsumed + size < oldFront->mSize) {
    124             // room to consume the whole or rest of the decoded data in one shot
    125             ap->mBufferQueue.mSizeConsumed += size;
    126             // consume data but no callback to the BufferQueue interface here
    127             memcpy (pDest, data, size);
    128             sizeConsumed = size;
    129         } else {
    130             // push as much as possible of the decoded data into the buffer queue
    131             sizeConsumed = oldFront->mSize - ap->mBufferQueue.mSizeConsumed;
    132 
    133             // the buffer at the head of the buffer queue is full, update the state
    134             ap->mBufferQueue.mSizeConsumed = 0;
    135             if (newFront == &ap->mBufferQueue.mArray[ap->mBufferQueue.mNumBuffers + 1]) {
    136                 newFront = ap->mBufferQueue.mArray;
    137             }
    138             ap->mBufferQueue.mFront = newFront;
    139 
    140             ap->mBufferQueue.mState.count--;
    141             ap->mBufferQueue.mState.playIndex++;
    142             // consume data
    143             memcpy (pDest, data, sizeConsumed);
    144             // data has been copied to the buffer, and the buffer queue state has been updated
    145             // we will notify the client if applicable
    146             callback = ap->mBufferQueue.mCallback;
    147             // save callback data
    148             callbackPContext = ap->mBufferQueue.mContext;
    149         }
    150 
    151     } else {
    152         // no available buffers in the queue to write the decoded data
    153         sizeConsumed = 0;
    154     }
    155 
    156     object_unlock_exclusive(&ap->mObject);
    157     // notify client
    158     if (NULL != callback) {
    159         (*callback)(&ap->mBufferQueue.mItf, callbackPContext);
    160     }
    161 
    162     ap->mCallbackProtector->exitCb();
    163     return sizeConsumed;
    164 }
    165 
    166 
    167 //-----------------------------------------------------------------------------
    168 #define LEFT_CHANNEL_MASK  0x1 << 0
    169 #define RIGHT_CHANNEL_MASK 0x1 << 1
    170 
    171 void android_audioPlayer_volumeUpdate(CAudioPlayer* ap)
    172 {
    173     assert(ap != NULL);
    174 
    175     // the source's channel count, where zero means unknown
    176     SLuint8 channelCount = ap->mNumChannels;
    177 
    178     // whether each channel is audible
    179     bool leftAudibilityFactor, rightAudibilityFactor;
    180 
    181     // mute has priority over solo
    182     if (channelCount >= STEREO_CHANNELS) {
    183         if (ap->mMuteMask & LEFT_CHANNEL_MASK) {
    184             // left muted
    185             leftAudibilityFactor = false;
    186         } else {
    187             // left not muted
    188             if (ap->mSoloMask & LEFT_CHANNEL_MASK) {
    189                 // left soloed
    190                 leftAudibilityFactor = true;
    191             } else {
    192                 // left not soloed
    193                 if (ap->mSoloMask & RIGHT_CHANNEL_MASK) {
    194                     // right solo silences left
    195                     leftAudibilityFactor = false;
    196                 } else {
    197                     // left and right are not soloed, and left is not muted
    198                     leftAudibilityFactor = true;
    199                 }
    200             }
    201         }
    202 
    203         if (ap->mMuteMask & RIGHT_CHANNEL_MASK) {
    204             // right muted
    205             rightAudibilityFactor = false;
    206         } else {
    207             // right not muted
    208             if (ap->mSoloMask & RIGHT_CHANNEL_MASK) {
    209                 // right soloed
    210                 rightAudibilityFactor = true;
    211             } else {
    212                 // right not soloed
    213                 if (ap->mSoloMask & LEFT_CHANNEL_MASK) {
    214                     // left solo silences right
    215                     rightAudibilityFactor = false;
    216                 } else {
    217                     // left and right are not soloed, and right is not muted
    218                     rightAudibilityFactor = true;
    219                 }
    220             }
    221         }
    222 
    223     // channel mute and solo are ignored for mono and unknown channel count sources
    224     } else {
    225         leftAudibilityFactor = true;
    226         rightAudibilityFactor = true;
    227     }
    228 
    229     // compute volumes without setting
    230     const bool audibilityFactors[2] = {leftAudibilityFactor, rightAudibilityFactor};
    231     float volumes[2];
    232     android_player_volumeUpdate(volumes, &ap->mVolume, channelCount, ap->mAmplFromDirectLevel,
    233             audibilityFactors);
    234     float leftVol = volumes[0], rightVol = volumes[1];
    235 
    236     // set volume on the underlying media player or audio track
    237     if (ap->mAPlayer != 0) {
    238         ap->mAPlayer->setVolume(leftVol, rightVol);
    239     } else if (ap->mAudioTrack != 0) {
    240         ap->mAudioTrack->setVolume(leftVol, rightVol);
    241     }
    242 
    243     // changes in the AudioPlayer volume must be reflected in the send level:
    244     //  in SLEffectSendItf or in SLAndroidEffectSendItf?
    245     // FIXME replace interface test by an internal API once we have one.
    246     if (NULL != ap->mEffectSend.mItf) {
    247         for (unsigned int i=0 ; i<AUX_MAX ; i++) {
    248             if (ap->mEffectSend.mEnableLevels[i].mEnable) {
    249                 android_fxSend_setSendLevel(ap,
    250                         ap->mEffectSend.mEnableLevels[i].mSendLevel + ap->mVolume.mLevel);
    251                 // there's a single aux bus on Android, so we can stop looking once the first
    252                 // aux effect is found.
    253                 break;
    254             }
    255         }
    256     } else if (NULL != ap->mAndroidEffectSend.mItf) {
    257         android_fxSend_setSendLevel(ap, ap->mAndroidEffectSend.mSendLevel + ap->mVolume.mLevel);
    258     }
    259 }
    260 
    261 // Called by android_audioPlayer_volumeUpdate and android_mediaPlayer_volumeUpdate to compute
    262 // volumes, but setting volumes is handled by the caller.
    263 
    264 void android_player_volumeUpdate(float *pVolumes /*[2]*/, const IVolume *volumeItf, unsigned
    265 channelCount, float amplFromDirectLevel, const bool *audibilityFactors /*[2]*/)
    266 {
    267     assert(pVolumes != NULL);
    268     assert(volumeItf != NULL);
    269     // OK for audibilityFactors to be NULL
    270 
    271     bool leftAudibilityFactor, rightAudibilityFactor;
    272 
    273     // apply player mute factor
    274     // note that AudioTrack has mute() but not MediaPlayer, so it's easier to use volume
    275     // to mute for both rather than calling mute() for AudioTrack
    276 
    277     // player is muted
    278     if (volumeItf->mMute) {
    279         leftAudibilityFactor = false;
    280         rightAudibilityFactor = false;
    281     // player isn't muted, and channel mute/solo audibility factors are available (AudioPlayer)
    282     } else if (audibilityFactors != NULL) {
    283         leftAudibilityFactor = audibilityFactors[0];
    284         rightAudibilityFactor = audibilityFactors[1];
    285     // player isn't muted, and channel mute/solo audibility factors aren't available (MediaPlayer)
    286     } else {
    287         leftAudibilityFactor = true;
    288         rightAudibilityFactor = true;
    289     }
    290 
    291     // compute amplification as the combination of volume level and stereo position
    292     //   amplification (or attenuation) from volume level
    293     float amplFromVolLevel = sles_to_android_amplification(volumeItf->mLevel);
    294     //   amplification from direct level (changed in SLEffectSendtItf and SLAndroidEffectSendItf)
    295     float leftVol  = amplFromVolLevel * amplFromDirectLevel;
    296     float rightVol = leftVol;
    297 
    298     // amplification from stereo position
    299     if (volumeItf->mEnableStereoPosition) {
    300         // Left/right amplification (can be attenuations) factors derived for the StereoPosition
    301         float amplFromStereoPos[STEREO_CHANNELS];
    302         // panning law depends on content channel count: mono to stereo panning vs stereo balance
    303         if (1 == channelCount) {
    304             // mono to stereo panning
    305             double theta = (1000+volumeItf->mStereoPosition)*M_PI_4/1000.0f; // 0 <= theta <= Pi/2
    306             amplFromStereoPos[0] = cos(theta);
    307             amplFromStereoPos[1] = sin(theta);
    308         // channel count is 0 (unknown), 2 (stereo), or > 2 (multi-channel)
    309         } else {
    310             // stereo balance
    311             if (volumeItf->mStereoPosition > 0) {
    312                 amplFromStereoPos[0] = (1000-volumeItf->mStereoPosition)/1000.0f;
    313                 amplFromStereoPos[1] = 1.0f;
    314             } else {
    315                 amplFromStereoPos[0] = 1.0f;
    316                 amplFromStereoPos[1] = (1000+volumeItf->mStereoPosition)/1000.0f;
    317             }
    318         }
    319         leftVol  *= amplFromStereoPos[0];
    320         rightVol *= amplFromStereoPos[1];
    321     }
    322 
    323     // apply audibility factors
    324     if (!leftAudibilityFactor) {
    325         leftVol = 0.0;
    326     }
    327     if (!rightAudibilityFactor) {
    328         rightVol = 0.0;
    329     }
    330 
    331     // return the computed volumes
    332     pVolumes[0] = leftVol;
    333     pVolumes[1] = rightVol;
    334 }
    335 
    336 //-----------------------------------------------------------------------------
    337 void audioTrack_handleMarker_lockPlay(CAudioPlayer* ap) {
    338     //SL_LOGV("received event EVENT_MARKER from AudioTrack");
    339     slPlayCallback callback = NULL;
    340     void* callbackPContext = NULL;
    341 
    342     interface_lock_shared(&ap->mPlay);
    343     callback = ap->mPlay.mCallback;
    344     callbackPContext = ap->mPlay.mContext;
    345     interface_unlock_shared(&ap->mPlay);
    346 
    347     if (NULL != callback) {
    348         // getting this event implies SL_PLAYEVENT_HEADATMARKER was set in the event mask
    349         (*callback)(&ap->mPlay.mItf, callbackPContext, SL_PLAYEVENT_HEADATMARKER);
    350     }
    351 }
    352 
    353 //-----------------------------------------------------------------------------
    354 void audioTrack_handleNewPos_lockPlay(CAudioPlayer* ap) {
    355     //SL_LOGV("received event EVENT_NEW_POS from AudioTrack");
    356     slPlayCallback callback = NULL;
    357     void* callbackPContext = NULL;
    358 
    359     interface_lock_shared(&ap->mPlay);
    360     callback = ap->mPlay.mCallback;
    361     callbackPContext = ap->mPlay.mContext;
    362     interface_unlock_shared(&ap->mPlay);
    363 
    364     if (NULL != callback) {
    365         // getting this event implies SL_PLAYEVENT_HEADATNEWPOS was set in the event mask
    366         (*callback)(&ap->mPlay.mItf, callbackPContext, SL_PLAYEVENT_HEADATNEWPOS);
    367     }
    368 }
    369 
    370 
    371 //-----------------------------------------------------------------------------
    372 void audioTrack_handleUnderrun_lockPlay(CAudioPlayer* ap) {
    373     slPlayCallback callback = NULL;
    374     void* callbackPContext = NULL;
    375 
    376     interface_lock_shared(&ap->mPlay);
    377     callback = ap->mPlay.mCallback;
    378     callbackPContext = ap->mPlay.mContext;
    379     bool headStalled = (ap->mPlay.mEventFlags & SL_PLAYEVENT_HEADSTALLED) != 0;
    380     interface_unlock_shared(&ap->mPlay);
    381 
    382     if ((NULL != callback) && headStalled) {
    383         (*callback)(&ap->mPlay.mItf, callbackPContext, SL_PLAYEVENT_HEADSTALLED);
    384     }
    385 }
    386 
    387 
    388 //-----------------------------------------------------------------------------
    389 /**
    390  * post-condition: play state of AudioPlayer is SL_PLAYSTATE_PAUSED if setPlayStateToPaused is true
    391  *
    392  * note: a conditional flag, setPlayStateToPaused, is used here to specify whether the play state
    393  *       needs to be changed when the player reaches the end of the content to play. This is
    394  *       relative to what the specification describes for buffer queues vs the
    395  *       SL_PLAYEVENT_HEADATEND event. In the OpenSL ES specification 1.0.1:
    396  *        - section 8.12 SLBufferQueueItf states "In the case of starvation due to insufficient
    397  *          buffers in the queue, the playing of audio data stops. The player remains in the
    398  *          SL_PLAYSTATE_PLAYING state."
    399  *        - section 9.2.31 SL_PLAYEVENT states "SL_PLAYEVENT_HEADATEND Playback head is at the end
    400  *          of the current content and the player has paused."
    401  */
    402 void audioPlayer_dispatch_headAtEnd_lockPlay(CAudioPlayer *ap, bool setPlayStateToPaused,
    403         bool needToLock) {
    404     //SL_LOGV("ap=%p, setPlayStateToPaused=%d, needToLock=%d", ap, setPlayStateToPaused,
    405     //        needToLock);
    406     slPlayCallback playCallback = NULL;
    407     void * playContext = NULL;
    408     // SLPlayItf callback or no callback?
    409     if (needToLock) {
    410         interface_lock_exclusive(&ap->mPlay);
    411     }
    412     if (ap->mPlay.mEventFlags & SL_PLAYEVENT_HEADATEND) {
    413         playCallback = ap->mPlay.mCallback;
    414         playContext = ap->mPlay.mContext;
    415     }
    416     if (setPlayStateToPaused) {
    417         ap->mPlay.mState = SL_PLAYSTATE_PAUSED;
    418     }
    419     if (needToLock) {
    420         interface_unlock_exclusive(&ap->mPlay);
    421     }
    422     // enqueue callback with no lock held
    423     if (NULL != playCallback) {
    424 #ifndef USE_ASYNCHRONOUS_PLAY_CALLBACK
    425         (*playCallback)(&ap->mPlay.mItf, playContext, SL_PLAYEVENT_HEADATEND);
    426 #else
    427         SLresult result = EnqueueAsyncCallback_ppi(ap, playCallback, &ap->mPlay.mItf, playContext,
    428                 SL_PLAYEVENT_HEADATEND);
    429         if (SL_RESULT_SUCCESS != result) {
    430             ALOGW("Callback %p(%p, %p, SL_PLAYEVENT_HEADATEND) dropped", playCallback,
    431                     &ap->mPlay.mItf, playContext);
    432         }
    433 #endif
    434     }
    435 
    436 }
    437 
    438 
    439 //-----------------------------------------------------------------------------
    440 SLresult audioPlayer_setStreamType(CAudioPlayer* ap, SLint32 type) {
    441     SLresult result = SL_RESULT_SUCCESS;
    442     SL_LOGV("type %d", type);
    443 
    444     audio_stream_type_t newStreamType = ANDROID_DEFAULT_OUTPUT_STREAM_TYPE;
    445     switch(type) {
    446     case SL_ANDROID_STREAM_VOICE:
    447         newStreamType = AUDIO_STREAM_VOICE_CALL;
    448         break;
    449     case SL_ANDROID_STREAM_SYSTEM:
    450         newStreamType = AUDIO_STREAM_SYSTEM;
    451         break;
    452     case SL_ANDROID_STREAM_RING:
    453         newStreamType = AUDIO_STREAM_RING;
    454         break;
    455     case SL_ANDROID_STREAM_MEDIA:
    456         newStreamType = AUDIO_STREAM_MUSIC;
    457         break;
    458     case SL_ANDROID_STREAM_ALARM:
    459         newStreamType = AUDIO_STREAM_ALARM;
    460         break;
    461     case SL_ANDROID_STREAM_NOTIFICATION:
    462         newStreamType = AUDIO_STREAM_NOTIFICATION;
    463         break;
    464     default:
    465         SL_LOGE(ERROR_PLAYERSTREAMTYPE_SET_UNKNOWN_TYPE);
    466         result = SL_RESULT_PARAMETER_INVALID;
    467         break;
    468     }
    469 
    470     // stream type needs to be set before the object is realized
    471     // (ap->mAudioTrack is supposed to be NULL until then)
    472     if (SL_OBJECT_STATE_UNREALIZED != ap->mObject.mState) {
    473         SL_LOGE(ERROR_PLAYERSTREAMTYPE_REALIZED);
    474         result = SL_RESULT_PRECONDITIONS_VIOLATED;
    475     } else {
    476         ap->mStreamType = newStreamType;
    477     }
    478 
    479     return result;
    480 }
    481 
    482 
    483 //-----------------------------------------------------------------------------
    484 SLresult audioPlayer_getStreamType(CAudioPlayer* ap, SLint32 *pType) {
    485     SLresult result = SL_RESULT_SUCCESS;
    486 
    487     switch(ap->mStreamType) {
    488     case AUDIO_STREAM_VOICE_CALL:
    489         *pType = SL_ANDROID_STREAM_VOICE;
    490         break;
    491     case AUDIO_STREAM_SYSTEM:
    492         *pType = SL_ANDROID_STREAM_SYSTEM;
    493         break;
    494     case AUDIO_STREAM_RING:
    495         *pType = SL_ANDROID_STREAM_RING;
    496         break;
    497     case AUDIO_STREAM_DEFAULT:
    498     case AUDIO_STREAM_MUSIC:
    499         *pType = SL_ANDROID_STREAM_MEDIA;
    500         break;
    501     case AUDIO_STREAM_ALARM:
    502         *pType = SL_ANDROID_STREAM_ALARM;
    503         break;
    504     case AUDIO_STREAM_NOTIFICATION:
    505         *pType = SL_ANDROID_STREAM_NOTIFICATION;
    506         break;
    507     default:
    508         result = SL_RESULT_INTERNAL_ERROR;
    509         *pType = SL_ANDROID_STREAM_MEDIA;
    510         break;
    511     }
    512 
    513     return result;
    514 }
    515 
    516 
    517 //-----------------------------------------------------------------------------
    518 void audioPlayer_auxEffectUpdate(CAudioPlayer* ap) {
    519     if ((ap->mAudioTrack != 0) && (ap->mAuxEffect != 0)) {
    520         android_fxSend_attach(ap, true, ap->mAuxEffect, ap->mVolume.mLevel + ap->mAuxSendLevel);
    521     }
    522 }
    523 
    524 
    525 //-----------------------------------------------------------------------------
    526 /*
    527  * returns true if the given data sink is supported by AudioPlayer that doesn't
    528  *   play to an OutputMix object, false otherwise
    529  *
    530  * pre-condition: the locator of the audio sink is not SL_DATALOCATOR_OUTPUTMIX
    531  */
    532 bool audioPlayer_isSupportedNonOutputMixSink(const SLDataSink* pAudioSink) {
    533     bool result = true;
    534     const SLuint32 sinkLocatorType = *(SLuint32 *)pAudioSink->pLocator;
    535     const SLuint32 sinkFormatType = *(SLuint32 *)pAudioSink->pFormat;
    536 
    537     switch (sinkLocatorType) {
    538 
    539     case SL_DATALOCATOR_BUFFERQUEUE:
    540     case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE:
    541         if (SL_DATAFORMAT_PCM != sinkFormatType) {
    542             SL_LOGE("Unsupported sink format 0x%x, expected SL_DATAFORMAT_PCM",
    543                     (unsigned)sinkFormatType);
    544             result = false;
    545         }
    546         // it's no use checking the PCM format fields because additional characteristics
    547         // such as the number of channels, or sample size are unknown to the player at this stage
    548         break;
    549 
    550     default:
    551         SL_LOGE("Unsupported sink locator type 0x%x", (unsigned)sinkLocatorType);
    552         result = false;
    553         break;
    554     }
    555 
    556     return result;
    557 }
    558 
    559 
    560 //-----------------------------------------------------------------------------
    561 /*
    562  * returns the Android object type if the locator type combinations for the source and sinks
    563  *   are supported by this implementation, INVALID_TYPE otherwise
    564  */
    565 AndroidObjectType audioPlayer_getAndroidObjectTypeForSourceSink(CAudioPlayer *ap) {
    566 
    567     const SLDataSource *pAudioSrc = &ap->mDataSource.u.mSource;
    568     const SLDataSink *pAudioSnk = &ap->mDataSink.u.mSink;
    569     const SLuint32 sourceLocatorType = *(SLuint32 *)pAudioSrc->pLocator;
    570     const SLuint32 sinkLocatorType = *(SLuint32 *)pAudioSnk->pLocator;
    571     AndroidObjectType type = INVALID_TYPE;
    572 
    573     //--------------------------------------
    574     // Sink / source matching check:
    575     // the following source / sink combinations are supported
    576     //     SL_DATALOCATOR_BUFFERQUEUE                / SL_DATALOCATOR_OUTPUTMIX
    577     //     SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE   / SL_DATALOCATOR_OUTPUTMIX
    578     //     SL_DATALOCATOR_URI                        / SL_DATALOCATOR_OUTPUTMIX
    579     //     SL_DATALOCATOR_ANDROIDFD                  / SL_DATALOCATOR_OUTPUTMIX
    580     //     SL_DATALOCATOR_ANDROIDBUFFERQUEUE         / SL_DATALOCATOR_OUTPUTMIX
    581     //     SL_DATALOCATOR_ANDROIDBUFFERQUEUE         / SL_DATALOCATOR_BUFFERQUEUE
    582     //     SL_DATALOCATOR_URI                        / SL_DATALOCATOR_BUFFERQUEUE
    583     //     SL_DATALOCATOR_ANDROIDFD                  / SL_DATALOCATOR_BUFFERQUEUE
    584     //     SL_DATALOCATOR_URI                        / SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
    585     //     SL_DATALOCATOR_ANDROIDFD                  / SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
    586     switch (sinkLocatorType) {
    587 
    588     case SL_DATALOCATOR_OUTPUTMIX: {
    589         switch (sourceLocatorType) {
    590 
    591         //   Buffer Queue to AudioTrack
    592         case SL_DATALOCATOR_BUFFERQUEUE:
    593         case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE:
    594             type = AUDIOPLAYER_FROM_PCM_BUFFERQUEUE;
    595             break;
    596 
    597         //   URI or FD to MediaPlayer
    598         case SL_DATALOCATOR_URI:
    599         case SL_DATALOCATOR_ANDROIDFD:
    600             type = AUDIOPLAYER_FROM_URIFD;
    601             break;
    602 
    603         //   Android BufferQueue to MediaPlayer (shared memory streaming)
    604         case SL_DATALOCATOR_ANDROIDBUFFERQUEUE:
    605             type = AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE;
    606             break;
    607 
    608         default:
    609             SL_LOGE("Source data locator 0x%x not supported with SL_DATALOCATOR_OUTPUTMIX sink",
    610                     (unsigned)sourceLocatorType);
    611             break;
    612         }
    613         }
    614         break;
    615 
    616     case SL_DATALOCATOR_BUFFERQUEUE:
    617     case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE:
    618         switch (sourceLocatorType) {
    619 
    620         //   URI or FD decoded to PCM in a buffer queue
    621         case SL_DATALOCATOR_URI:
    622         case SL_DATALOCATOR_ANDROIDFD:
    623             type = AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE;
    624             break;
    625 
    626         //   AAC ADTS Android buffer queue decoded to PCM in a buffer queue
    627         case SL_DATALOCATOR_ANDROIDBUFFERQUEUE:
    628             type = AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE;
    629             break;
    630 
    631         default:
    632             SL_LOGE("Source data locator 0x%x not supported with SL_DATALOCATOR_BUFFERQUEUE sink",
    633                     (unsigned)sourceLocatorType);
    634             break;
    635         }
    636         break;
    637 
    638     default:
    639         SL_LOGE("Sink data locator 0x%x not supported", (unsigned)sinkLocatorType);
    640         break;
    641     }
    642 
    643     return type;
    644 }
    645 
    646 
    647 //-----------------------------------------------------------------------------
    648 /*
    649  * Callback associated with an SfPlayer of an SL ES AudioPlayer that gets its data
    650  * from a URI or FD, for prepare, prefetch, and play events
    651  */
    652 static void sfplayer_handlePrefetchEvent(int event, int data1, int data2, void* user) {
    653 
    654     // FIXME see similar code and comment in player_handleMediaPlayerEventNotifications
    655 
    656     if (NULL == user) {
    657         return;
    658     }
    659 
    660     CAudioPlayer *ap = (CAudioPlayer *)user;
    661     if (!android::CallbackProtector::enterCbIfOk(ap->mCallbackProtector)) {
    662         // it is not safe to enter the callback (the track is about to go away)
    663         return;
    664     }
    665     union {
    666         char c[sizeof(int)];
    667         int i;
    668     } u;
    669     u.i = event;
    670     SL_LOGV("sfplayer_handlePrefetchEvent(event='%c%c%c%c' (%d), data1=%d, data2=%d, user=%p) from "
    671             "SfAudioPlayer", u.c[3], u.c[2], u.c[1], u.c[0], event, data1, data2, user);
    672     switch(event) {
    673 
    674     case android::GenericPlayer::kEventPrepared: {
    675         SL_LOGV("Received GenericPlayer::kEventPrepared for CAudioPlayer %p", ap);
    676 
    677         // assume no callback
    678         slPrefetchCallback callback = NULL;
    679         void* callbackPContext;
    680         SLuint32 events;
    681 
    682         object_lock_exclusive(&ap->mObject);
    683 
    684         // mark object as prepared; same state is used for successful or unsuccessful prepare
    685         assert(ap->mAndroidObjState == ANDROID_PREPARING);
    686         ap->mAndroidObjState = ANDROID_READY;
    687 
    688         if (PLAYER_SUCCESS == data1) {
    689             // Most of successful prepare completion for ap->mAPlayer
    690             // is handled by GenericPlayer and its subclasses.
    691         } else {
    692             // SfPlayer prepare() failed prefetching, there is no event in SLPrefetchStatus to
    693             //  indicate a prefetch error, so we signal it by sending simultaneously two events:
    694             //  - SL_PREFETCHEVENT_FILLLEVELCHANGE with a level of 0
    695             //  - SL_PREFETCHEVENT_STATUSCHANGE with a status of SL_PREFETCHSTATUS_UNDERFLOW
    696             SL_LOGE(ERROR_PLAYER_PREFETCH_d, data1);
    697             if (IsInterfaceInitialized(&(ap->mObject), MPH_PREFETCHSTATUS)) {
    698                 ap->mPrefetchStatus.mLevel = 0;
    699                 ap->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW;
    700                 if (!(~ap->mPrefetchStatus.mCallbackEventsMask &
    701                         (SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE))) {
    702                     callback = ap->mPrefetchStatus.mCallback;
    703                     callbackPContext = ap->mPrefetchStatus.mContext;
    704                     events = SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE;
    705                 }
    706             }
    707         }
    708 
    709         object_unlock_exclusive(&ap->mObject);
    710 
    711         // callback with no lock held
    712         if (NULL != callback) {
    713             (*callback)(&ap->mPrefetchStatus.mItf, callbackPContext, events);
    714         }
    715 
    716     }
    717     break;
    718 
    719     case android::GenericPlayer::kEventPrefetchFillLevelUpdate : {
    720         if (!IsInterfaceInitialized(&(ap->mObject), MPH_PREFETCHSTATUS)) {
    721             break;
    722         }
    723         slPrefetchCallback callback = NULL;
    724         void* callbackPContext = NULL;
    725 
    726         // SLPrefetchStatusItf callback or no callback?
    727         interface_lock_exclusive(&ap->mPrefetchStatus);
    728         if (ap->mPrefetchStatus.mCallbackEventsMask & SL_PREFETCHEVENT_FILLLEVELCHANGE) {
    729             callback = ap->mPrefetchStatus.mCallback;
    730             callbackPContext = ap->mPrefetchStatus.mContext;
    731         }
    732         ap->mPrefetchStatus.mLevel = (SLpermille)data1;
    733         interface_unlock_exclusive(&ap->mPrefetchStatus);
    734 
    735         // callback with no lock held
    736         if (NULL != callback) {
    737             (*callback)(&ap->mPrefetchStatus.mItf, callbackPContext,
    738                     SL_PREFETCHEVENT_FILLLEVELCHANGE);
    739         }
    740     }
    741     break;
    742 
    743     case android::GenericPlayer::kEventPrefetchStatusChange: {
    744         if (!IsInterfaceInitialized(&(ap->mObject), MPH_PREFETCHSTATUS)) {
    745             break;
    746         }
    747         slPrefetchCallback callback = NULL;
    748         void* callbackPContext = NULL;
    749 
    750         // SLPrefetchStatusItf callback or no callback?
    751         object_lock_exclusive(&ap->mObject);
    752         if (ap->mPrefetchStatus.mCallbackEventsMask & SL_PREFETCHEVENT_STATUSCHANGE) {
    753             callback = ap->mPrefetchStatus.mCallback;
    754             callbackPContext = ap->mPrefetchStatus.mContext;
    755         }
    756         if (data1 >= android::kStatusIntermediate) {
    757             ap->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_SUFFICIENTDATA;
    758         } else if (data1 < android::kStatusIntermediate) {
    759             ap->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW;
    760         }
    761         object_unlock_exclusive(&ap->mObject);
    762 
    763         // callback with no lock held
    764         if (NULL != callback) {
    765             (*callback)(&ap->mPrefetchStatus.mItf, callbackPContext, SL_PREFETCHEVENT_STATUSCHANGE);
    766         }
    767         }
    768         break;
    769 
    770     case android::GenericPlayer::kEventEndOfStream: {
    771         audioPlayer_dispatch_headAtEnd_lockPlay(ap, true /*set state to paused?*/, true);
    772         if ((ap->mAudioTrack != 0) && (!ap->mSeek.mLoopEnabled)) {
    773             ap->mAudioTrack->stop();
    774         }
    775         }
    776         break;
    777 
    778     case android::GenericPlayer::kEventChannelCount: {
    779         object_lock_exclusive(&ap->mObject);
    780         if (UNKNOWN_NUMCHANNELS == ap->mNumChannels && UNKNOWN_NUMCHANNELS != data1) {
    781             ap->mNumChannels = data1;
    782             android_audioPlayer_volumeUpdate(ap);
    783         }
    784         object_unlock_exclusive(&ap->mObject);
    785         }
    786         break;
    787 
    788     case android::GenericPlayer::kEventPlay: {
    789         slPlayCallback callback = NULL;
    790         void* callbackPContext = NULL;
    791 
    792         interface_lock_shared(&ap->mPlay);
    793         callback = ap->mPlay.mCallback;
    794         callbackPContext = ap->mPlay.mContext;
    795         interface_unlock_shared(&ap->mPlay);
    796 
    797         if (NULL != callback) {
    798             SLuint32 event = (SLuint32) data1;  // SL_PLAYEVENT_HEAD*
    799 #ifndef USE_ASYNCHRONOUS_PLAY_CALLBACK
    800             // synchronous callback requires a synchronous GetPosition implementation
    801             (*callback)(&ap->mPlay.mItf, callbackPContext, event);
    802 #else
    803             // asynchronous callback works with any GetPosition implementation
    804             SLresult result = EnqueueAsyncCallback_ppi(ap, callback, &ap->mPlay.mItf,
    805                     callbackPContext, event);
    806             if (SL_RESULT_SUCCESS != result) {
    807                 ALOGW("Callback %p(%p, %p, 0x%x) dropped", callback,
    808                         &ap->mPlay.mItf, callbackPContext, event);
    809             }
    810 #endif
    811         }
    812         }
    813         break;
    814 
    815       case android::GenericPlayer::kEventErrorAfterPrepare: {
    816         SL_LOGV("kEventErrorAfterPrepare");
    817 
    818         // assume no callback
    819         slPrefetchCallback callback = NULL;
    820         void* callbackPContext = NULL;
    821 
    822         object_lock_exclusive(&ap->mObject);
    823         if (IsInterfaceInitialized(&ap->mObject, MPH_PREFETCHSTATUS)) {
    824             ap->mPrefetchStatus.mLevel = 0;
    825             ap->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW;
    826             if (!(~ap->mPrefetchStatus.mCallbackEventsMask &
    827                     (SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE))) {
    828                 callback = ap->mPrefetchStatus.mCallback;
    829                 callbackPContext = ap->mPrefetchStatus.mContext;
    830             }
    831         }
    832         object_unlock_exclusive(&ap->mObject);
    833 
    834         // FIXME there's interesting information in data1, but no API to convey it to client
    835         SL_LOGE("Error after prepare: %d", data1);
    836 
    837         // callback with no lock held
    838         if (NULL != callback) {
    839             (*callback)(&ap->mPrefetchStatus.mItf, callbackPContext,
    840                     SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE);
    841         }
    842 
    843       }
    844       break;
    845 
    846     case android::GenericPlayer::kEventHasVideoSize:
    847         //SL_LOGW("Unexpected kEventHasVideoSize");
    848         break;
    849 
    850     default:
    851         break;
    852     }
    853 
    854     ap->mCallbackProtector->exitCb();
    855 }
    856 
    857 
    858 //-----------------------------------------------------------------------------
    859 SLresult android_audioPlayer_checkSourceSink(CAudioPlayer *pAudioPlayer)
    860 {
    861     // verify that the locator types for the source / sink combination is supported
    862     pAudioPlayer->mAndroidObjType = audioPlayer_getAndroidObjectTypeForSourceSink(pAudioPlayer);
    863     if (INVALID_TYPE == pAudioPlayer->mAndroidObjType) {
    864         return SL_RESULT_PARAMETER_INVALID;
    865     }
    866 
    867     const SLDataSource *pAudioSrc = &pAudioPlayer->mDataSource.u.mSource;
    868     const SLDataSink *pAudioSnk = &pAudioPlayer->mDataSink.u.mSink;
    869 
    870     // format check:
    871     const SLuint32 sourceLocatorType = *(SLuint32 *)pAudioSrc->pLocator;
    872     const SLuint32 sinkLocatorType = *(SLuint32 *)pAudioSnk->pLocator;
    873     const SLuint32 sourceFormatType = *(SLuint32 *)pAudioSrc->pFormat;
    874     const SLuint32 sinkFormatType = *(SLuint32 *)pAudioSnk->pFormat;
    875 
    876     switch (sourceLocatorType) {
    877     //------------------
    878     //   Buffer Queues
    879     case SL_DATALOCATOR_BUFFERQUEUE:
    880     case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE:
    881         {
    882         SLDataLocator_BufferQueue *dl_bq = (SLDataLocator_BufferQueue *) pAudioSrc->pLocator;
    883 
    884         // Buffer format
    885         switch (sourceFormatType) {
    886         //     currently only PCM buffer queues are supported,
    887         case SL_DATAFORMAT_PCM: {
    888             SLDataFormat_PCM *df_pcm = (SLDataFormat_PCM *) pAudioSrc->pFormat;
    889             switch (df_pcm->numChannels) {
    890             case 1:
    891             case 2:
    892                 break;
    893             default:
    894                 // this should have already been rejected by checkDataFormat
    895                 SL_LOGE("Cannot create audio player: unsupported " \
    896                     "PCM data source with %u channels", (unsigned) df_pcm->numChannels);
    897                 return SL_RESULT_CONTENT_UNSUPPORTED;
    898             }
    899             switch (df_pcm->samplesPerSec) {
    900             case SL_SAMPLINGRATE_8:
    901             case SL_SAMPLINGRATE_11_025:
    902             case SL_SAMPLINGRATE_12:
    903             case SL_SAMPLINGRATE_16:
    904             case SL_SAMPLINGRATE_22_05:
    905             case SL_SAMPLINGRATE_24:
    906             case SL_SAMPLINGRATE_32:
    907             case SL_SAMPLINGRATE_44_1:
    908             case SL_SAMPLINGRATE_48:
    909                 break;
    910             case SL_SAMPLINGRATE_64:
    911             case SL_SAMPLINGRATE_88_2:
    912             case SL_SAMPLINGRATE_96:
    913             case SL_SAMPLINGRATE_192:
    914             default:
    915                 SL_LOGE("Cannot create audio player: unsupported sample rate %u milliHz",
    916                     (unsigned) df_pcm->samplesPerSec);
    917                 return SL_RESULT_CONTENT_UNSUPPORTED;
    918             }
    919             switch (df_pcm->bitsPerSample) {
    920             case SL_PCMSAMPLEFORMAT_FIXED_8:
    921             case SL_PCMSAMPLEFORMAT_FIXED_16:
    922                 break;
    923                 // others
    924             default:
    925                 // this should have already been rejected by checkDataFormat
    926                 SL_LOGE("Cannot create audio player: unsupported sample bit depth %u",
    927                         (SLuint32)df_pcm->bitsPerSample);
    928                 return SL_RESULT_CONTENT_UNSUPPORTED;
    929             }
    930             switch (df_pcm->containerSize) {
    931             case 8:
    932             case 16:
    933                 break;
    934                 // others
    935             default:
    936                 SL_LOGE("Cannot create audio player: unsupported container size %u",
    937                     (unsigned) df_pcm->containerSize);
    938                 return SL_RESULT_CONTENT_UNSUPPORTED;
    939             }
    940             // df_pcm->channelMask: the earlier platform-independent check and the
    941             //     upcoming check by sles_to_android_channelMaskOut are sufficient
    942             switch (df_pcm->endianness) {
    943             case SL_BYTEORDER_LITTLEENDIAN:
    944                 break;
    945             case SL_BYTEORDER_BIGENDIAN:
    946                 SL_LOGE("Cannot create audio player: unsupported big-endian byte order");
    947                 return SL_RESULT_CONTENT_UNSUPPORTED;
    948                 // native is proposed but not yet in spec
    949             default:
    950                 SL_LOGE("Cannot create audio player: unsupported byte order %u",
    951                     (unsigned) df_pcm->endianness);
    952                 return SL_RESULT_CONTENT_UNSUPPORTED;
    953             }
    954             } //case SL_DATAFORMAT_PCM
    955             break;
    956         case SL_DATAFORMAT_MIME:
    957         case XA_DATAFORMAT_RAWIMAGE:
    958             SL_LOGE("Cannot create audio player with buffer queue data source "
    959                 "without SL_DATAFORMAT_PCM format");
    960             return SL_RESULT_CONTENT_UNSUPPORTED;
    961         default:
    962             // invalid data format is detected earlier
    963             assert(false);
    964             return SL_RESULT_INTERNAL_ERROR;
    965         } // switch (sourceFormatType)
    966         } // case SL_DATALOCATOR_BUFFERQUEUE or SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE
    967         break;
    968     //------------------
    969     //   URI
    970     case SL_DATALOCATOR_URI:
    971         {
    972         SLDataLocator_URI *dl_uri = (SLDataLocator_URI *) pAudioSrc->pLocator;
    973         if (NULL == dl_uri->URI) {
    974             return SL_RESULT_PARAMETER_INVALID;
    975         }
    976         // URI format
    977         switch (sourceFormatType) {
    978         case SL_DATAFORMAT_MIME:
    979             break;
    980         case SL_DATAFORMAT_PCM:
    981         case XA_DATAFORMAT_RAWIMAGE:
    982             SL_LOGE("Cannot create audio player with SL_DATALOCATOR_URI data source without "
    983                 "SL_DATAFORMAT_MIME format");
    984             return SL_RESULT_CONTENT_UNSUPPORTED;
    985         } // switch (sourceFormatType)
    986         // decoding format check
    987         if ((sinkLocatorType != SL_DATALOCATOR_OUTPUTMIX) &&
    988                 !audioPlayer_isSupportedNonOutputMixSink(pAudioSnk)) {
    989             return SL_RESULT_CONTENT_UNSUPPORTED;
    990         }
    991         } // case SL_DATALOCATOR_URI
    992         break;
    993     //------------------
    994     //   File Descriptor
    995     case SL_DATALOCATOR_ANDROIDFD:
    996         {
    997         // fd is already non null
    998         switch (sourceFormatType) {
    999         case SL_DATAFORMAT_MIME:
   1000             break;
   1001         case SL_DATAFORMAT_PCM:
   1002             // FIXME implement
   1003             SL_LOGD("[ FIXME implement PCM FD data sources ]");
   1004             break;
   1005         case XA_DATAFORMAT_RAWIMAGE:
   1006             SL_LOGE("Cannot create audio player with SL_DATALOCATOR_ANDROIDFD data source "
   1007                 "without SL_DATAFORMAT_MIME or SL_DATAFORMAT_PCM format");
   1008             return SL_RESULT_CONTENT_UNSUPPORTED;
   1009         default:
   1010             // invalid data format is detected earlier
   1011             assert(false);
   1012             return SL_RESULT_INTERNAL_ERROR;
   1013         } // switch (sourceFormatType)
   1014         if ((sinkLocatorType != SL_DATALOCATOR_OUTPUTMIX) &&
   1015                 !audioPlayer_isSupportedNonOutputMixSink(pAudioSnk)) {
   1016             return SL_RESULT_CONTENT_UNSUPPORTED;
   1017         }
   1018         } // case SL_DATALOCATOR_ANDROIDFD
   1019         break;
   1020     //------------------
   1021     //   Stream
   1022     case SL_DATALOCATOR_ANDROIDBUFFERQUEUE:
   1023     {
   1024         switch (sourceFormatType) {
   1025         case SL_DATAFORMAT_MIME:
   1026         {
   1027             SLDataFormat_MIME *df_mime = (SLDataFormat_MIME *) pAudioSrc->pFormat;
   1028             if (NULL == df_mime) {
   1029                 SL_LOGE("MIME type null invalid");
   1030                 return SL_RESULT_CONTENT_UNSUPPORTED;
   1031             }
   1032             SL_LOGD("source MIME is %s", (char*)df_mime->mimeType);
   1033             switch(df_mime->containerType) {
   1034             case SL_CONTAINERTYPE_MPEG_TS:
   1035                 if (strcasecmp((char*)df_mime->mimeType, (const char *)XA_ANDROID_MIME_MP2TS)) {
   1036                     SL_LOGE("Invalid MIME (%s) for container SL_CONTAINERTYPE_MPEG_TS, expects %s",
   1037                             (char*)df_mime->mimeType, XA_ANDROID_MIME_MP2TS);
   1038                     return SL_RESULT_CONTENT_UNSUPPORTED;
   1039                 }
   1040                 break;
   1041             case SL_CONTAINERTYPE_RAW:
   1042             case SL_CONTAINERTYPE_AAC:
   1043                 if (strcasecmp((char*)df_mime->mimeType, (const char *)SL_ANDROID_MIME_AACADTS) &&
   1044                         strcasecmp((char*)df_mime->mimeType,
   1045                                 ANDROID_MIME_AACADTS_ANDROID_FRAMEWORK)) {
   1046                     SL_LOGE("Invalid MIME (%s) for container type %d, expects %s",
   1047                             (char*)df_mime->mimeType, df_mime->containerType,
   1048                             SL_ANDROID_MIME_AACADTS);
   1049                     return SL_RESULT_CONTENT_UNSUPPORTED;
   1050                 }
   1051                 break;
   1052             default:
   1053                 SL_LOGE("Cannot create player with SL_DATALOCATOR_ANDROIDBUFFERQUEUE data source "
   1054                                         "that is not fed MPEG-2 TS data or AAC ADTS data");
   1055                 return SL_RESULT_CONTENT_UNSUPPORTED;
   1056             }
   1057         }
   1058         break;
   1059         default:
   1060             SL_LOGE("Cannot create player with SL_DATALOCATOR_ANDROIDBUFFERQUEUE data source "
   1061                     "without SL_DATAFORMAT_MIME format");
   1062             return SL_RESULT_CONTENT_UNSUPPORTED;
   1063         }
   1064     }
   1065     break; // case SL_DATALOCATOR_ANDROIDBUFFERQUEUE
   1066     //------------------
   1067     //   Address
   1068     case SL_DATALOCATOR_ADDRESS:
   1069     case SL_DATALOCATOR_IODEVICE:
   1070     case SL_DATALOCATOR_OUTPUTMIX:
   1071     case XA_DATALOCATOR_NATIVEDISPLAY:
   1072     case SL_DATALOCATOR_MIDIBUFFERQUEUE:
   1073         SL_LOGE("Cannot create audio player with data locator type 0x%x",
   1074                 (unsigned) sourceLocatorType);
   1075         return SL_RESULT_CONTENT_UNSUPPORTED;
   1076     default:
   1077         SL_LOGE("Cannot create audio player with invalid data locator type 0x%x",
   1078                 (unsigned) sourceLocatorType);
   1079         return SL_RESULT_PARAMETER_INVALID;
   1080     }// switch (locatorType)
   1081 
   1082     return SL_RESULT_SUCCESS;
   1083 }
   1084 
   1085 
   1086 //-----------------------------------------------------------------------------
   1087 // Callback associated with an AudioTrack of an SL ES AudioPlayer that gets its data
   1088 // from a buffer queue. This will not be called once the AudioTrack has been destroyed.
   1089 static void audioTrack_callBack_pullFromBuffQueue(int event, void* user, void *info) {
   1090     CAudioPlayer *ap = (CAudioPlayer *)user;
   1091 
   1092     if (!android::CallbackProtector::enterCbIfOk(ap->mCallbackProtector)) {
   1093         // it is not safe to enter the callback (the track is about to go away)
   1094         return;
   1095     }
   1096 
   1097     void * callbackPContext = NULL;
   1098     switch(event) {
   1099 
   1100     case android::AudioTrack::EVENT_MORE_DATA: {
   1101         //SL_LOGV("received event EVENT_MORE_DATA from AudioTrack TID=%d", gettid());
   1102         slBufferQueueCallback callback = NULL;
   1103         slPrefetchCallback prefetchCallback = NULL;
   1104         void *prefetchContext = NULL;
   1105         SLuint32 prefetchEvents = SL_PREFETCHEVENT_NONE;
   1106         android::AudioTrack::Buffer* pBuff = (android::AudioTrack::Buffer*)info;
   1107 
   1108         // retrieve data from the buffer queue
   1109         interface_lock_exclusive(&ap->mBufferQueue);
   1110 
   1111         if (ap->mBufferQueue.mState.count != 0) {
   1112             //SL_LOGV("nbBuffers in queue = %u",ap->mBufferQueue.mState.count);
   1113             assert(ap->mBufferQueue.mFront != ap->mBufferQueue.mRear);
   1114 
   1115             BufferHeader *oldFront = ap->mBufferQueue.mFront;
   1116             BufferHeader *newFront = &oldFront[1];
   1117 
   1118             // declared as void * because this code supports both 8-bit and 16-bit PCM data
   1119             void *pSrc = (char *)oldFront->mBuffer + ap->mBufferQueue.mSizeConsumed;
   1120             if (ap->mBufferQueue.mSizeConsumed + pBuff->size < oldFront->mSize) {
   1121                 // can't consume the whole or rest of the buffer in one shot
   1122                 ap->mBufferQueue.mSizeConsumed += pBuff->size;
   1123                 // leave pBuff->size untouched
   1124                 // consume data
   1125                 // FIXME can we avoid holding the lock during the copy?
   1126                 memcpy (pBuff->raw, pSrc, pBuff->size);
   1127             } else {
   1128                 // finish consuming the buffer or consume the buffer in one shot
   1129                 pBuff->size = oldFront->mSize - ap->mBufferQueue.mSizeConsumed;
   1130                 ap->mBufferQueue.mSizeConsumed = 0;
   1131 
   1132                 if (newFront ==
   1133                         &ap->mBufferQueue.mArray
   1134                             [ap->mBufferQueue.mNumBuffers + 1])
   1135                 {
   1136                     newFront = ap->mBufferQueue.mArray;
   1137                 }
   1138                 ap->mBufferQueue.mFront = newFront;
   1139 
   1140                 ap->mBufferQueue.mState.count--;
   1141                 ap->mBufferQueue.mState.playIndex++;
   1142 
   1143                 // consume data
   1144                 // FIXME can we avoid holding the lock during the copy?
   1145                 memcpy (pBuff->raw, pSrc, pBuff->size);
   1146 
   1147                 // data has been consumed, and the buffer queue state has been updated
   1148                 // we will notify the client if applicable
   1149                 callback = ap->mBufferQueue.mCallback;
   1150                 // save callback data
   1151                 callbackPContext = ap->mBufferQueue.mContext;
   1152             }
   1153         } else { // empty queue
   1154             // signal no data available
   1155             pBuff->size = 0;
   1156 
   1157             // signal we're at the end of the content, but don't pause (see note in function)
   1158             audioPlayer_dispatch_headAtEnd_lockPlay(ap, false /*set state to paused?*/, false);
   1159 
   1160             // signal underflow to prefetch status itf
   1161             if (IsInterfaceInitialized(&(ap->mObject), MPH_PREFETCHSTATUS)) {
   1162                 ap->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_UNDERFLOW;
   1163                 ap->mPrefetchStatus.mLevel = 0;
   1164                 // callback or no callback?
   1165                 prefetchEvents = ap->mPrefetchStatus.mCallbackEventsMask &
   1166                         (SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE);
   1167                 if (SL_PREFETCHEVENT_NONE != prefetchEvents) {
   1168                     prefetchCallback = ap->mPrefetchStatus.mCallback;
   1169                     prefetchContext  = ap->mPrefetchStatus.mContext;
   1170                 }
   1171             }
   1172 
   1173             // stop the track so it restarts playing faster when new data is enqueued
   1174             ap->mAudioTrack->stop();
   1175         }
   1176         interface_unlock_exclusive(&ap->mBufferQueue);
   1177 
   1178         // notify client
   1179         if (NULL != prefetchCallback) {
   1180             assert(SL_PREFETCHEVENT_NONE != prefetchEvents);
   1181             // spec requires separate callbacks for each event
   1182             if (prefetchEvents & SL_PREFETCHEVENT_STATUSCHANGE) {
   1183                 (*prefetchCallback)(&ap->mPrefetchStatus.mItf, prefetchContext,
   1184                         SL_PREFETCHEVENT_STATUSCHANGE);
   1185             }
   1186             if (prefetchEvents & SL_PREFETCHEVENT_FILLLEVELCHANGE) {
   1187                 (*prefetchCallback)(&ap->mPrefetchStatus.mItf, prefetchContext,
   1188                         SL_PREFETCHEVENT_FILLLEVELCHANGE);
   1189             }
   1190         }
   1191         if (NULL != callback) {
   1192             (*callback)(&ap->mBufferQueue.mItf, callbackPContext);
   1193         }
   1194     }
   1195     break;
   1196 
   1197     case android::AudioTrack::EVENT_MARKER:
   1198         //SL_LOGI("received event EVENT_MARKER from AudioTrack");
   1199         audioTrack_handleMarker_lockPlay(ap);
   1200         break;
   1201 
   1202     case android::AudioTrack::EVENT_NEW_POS:
   1203         //SL_LOGI("received event EVENT_NEW_POS from AudioTrack");
   1204         audioTrack_handleNewPos_lockPlay(ap);
   1205         break;
   1206 
   1207     case android::AudioTrack::EVENT_UNDERRUN:
   1208         //SL_LOGI("received event EVENT_UNDERRUN from AudioTrack");
   1209         audioTrack_handleUnderrun_lockPlay(ap);
   1210         break;
   1211 
   1212     case android::AudioTrack::EVENT_BUFFER_END:
   1213     case android::AudioTrack::EVENT_LOOP_END:
   1214         // These are unexpected so fall through
   1215     default:
   1216         // FIXME where does the notification of SL_PLAYEVENT_HEADMOVING fit?
   1217         SL_LOGE("Encountered unknown AudioTrack event %d for CAudioPlayer %p", event,
   1218                 (CAudioPlayer *)user);
   1219         break;
   1220     }
   1221 
   1222     ap->mCallbackProtector->exitCb();
   1223 }
   1224 
   1225 
   1226 //-----------------------------------------------------------------------------
   1227 void android_audioPlayer_create(CAudioPlayer *pAudioPlayer) {
   1228 
   1229     // pAudioPlayer->mAndroidObjType has been set in android_audioPlayer_checkSourceSink()
   1230     // and if it was == INVALID_TYPE, then IEngine_CreateAudioPlayer would never call us
   1231     assert(INVALID_TYPE != pAudioPlayer->mAndroidObjType);
   1232 
   1233     // These initializations are in the same order as the field declarations in classes.h
   1234 
   1235     // FIXME Consolidate initializations (many of these already in IEngine_CreateAudioPlayer)
   1236     // mAndroidObjType: see above comment
   1237     pAudioPlayer->mAndroidObjState = ANDROID_UNINITIALIZED;
   1238     pAudioPlayer->mSessionId = android::AudioSystem::newAudioSessionId();
   1239 
   1240     // placeholder: not necessary yet as session ID lifetime doesn't extend beyond player
   1241     // android::AudioSystem::acquireAudioSessionId(pAudioPlayer->mSessionId);
   1242 
   1243     pAudioPlayer->mStreamType = ANDROID_DEFAULT_OUTPUT_STREAM_TYPE;
   1244 
   1245     // mAudioTrack
   1246     pAudioPlayer->mCallbackProtector = new android::CallbackProtector();
   1247     // mAPLayer
   1248     // mAuxEffect
   1249 
   1250     pAudioPlayer->mAuxSendLevel = 0;
   1251     pAudioPlayer->mAmplFromDirectLevel = 1.0f; // matches initial mDirectLevel value
   1252     pAudioPlayer->mDeferredStart = false;
   1253 
   1254     // This section re-initializes interface-specific fields that
   1255     // can be set or used regardless of whether the interface is
   1256     // exposed on the AudioPlayer or not
   1257 
   1258     switch (pAudioPlayer->mAndroidObjType) {
   1259     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   1260         pAudioPlayer->mPlaybackRate.mMinRate = AUDIOTRACK_MIN_PLAYBACKRATE_PERMILLE;
   1261         pAudioPlayer->mPlaybackRate.mMaxRate = AUDIOTRACK_MAX_PLAYBACKRATE_PERMILLE;
   1262         break;
   1263     case AUDIOPLAYER_FROM_URIFD:
   1264         pAudioPlayer->mPlaybackRate.mMinRate = MEDIAPLAYER_MIN_PLAYBACKRATE_PERMILLE;
   1265         pAudioPlayer->mPlaybackRate.mMaxRate = MEDIAPLAYER_MAX_PLAYBACKRATE_PERMILLE;
   1266         break;
   1267     default:
   1268         // use the default range
   1269         break;
   1270     }
   1271 
   1272 }
   1273 
   1274 
   1275 //-----------------------------------------------------------------------------
   1276 SLresult android_audioPlayer_setConfig(CAudioPlayer *ap, const SLchar *configKey,
   1277         const void *pConfigValue, SLuint32 valueSize) {
   1278 
   1279     SLresult result;
   1280 
   1281     assert(NULL != ap && NULL != configKey && NULL != pConfigValue);
   1282     if (strcmp((const char*)configKey, (const char*)SL_ANDROID_KEY_STREAM_TYPE) == 0) {
   1283 
   1284         // stream type
   1285         if (KEY_STREAM_TYPE_PARAMSIZE > valueSize) {
   1286             SL_LOGE(ERROR_CONFIG_VALUESIZE_TOO_LOW);
   1287             result = SL_RESULT_BUFFER_INSUFFICIENT;
   1288         } else {
   1289             result = audioPlayer_setStreamType(ap, *(SLuint32*)pConfigValue);
   1290         }
   1291 
   1292     } else {
   1293         SL_LOGE(ERROR_CONFIG_UNKNOWN_KEY);
   1294         result = SL_RESULT_PARAMETER_INVALID;
   1295     }
   1296 
   1297     return result;
   1298 }
   1299 
   1300 
   1301 //-----------------------------------------------------------------------------
   1302 SLresult android_audioPlayer_getConfig(CAudioPlayer* ap, const SLchar *configKey,
   1303         SLuint32* pValueSize, void *pConfigValue) {
   1304 
   1305     SLresult result;
   1306 
   1307     assert(NULL != ap && NULL != configKey && NULL != pValueSize);
   1308     if (strcmp((const char*)configKey, (const char*)SL_ANDROID_KEY_STREAM_TYPE) == 0) {
   1309 
   1310         // stream type
   1311         if (NULL == pConfigValue) {
   1312             result = SL_RESULT_SUCCESS;
   1313         } else if (KEY_STREAM_TYPE_PARAMSIZE > *pValueSize) {
   1314             SL_LOGE(ERROR_CONFIG_VALUESIZE_TOO_LOW);
   1315             result = SL_RESULT_BUFFER_INSUFFICIENT;
   1316         } else {
   1317             result = audioPlayer_getStreamType(ap, (SLint32*)pConfigValue);
   1318         }
   1319         *pValueSize = KEY_STREAM_TYPE_PARAMSIZE;
   1320 
   1321     } else {
   1322         SL_LOGE(ERROR_CONFIG_UNKNOWN_KEY);
   1323         result = SL_RESULT_PARAMETER_INVALID;
   1324     }
   1325 
   1326     return result;
   1327 }
   1328 
   1329 
   1330 // Called from android_audioPlayer_realize for a PCM buffer queue player
   1331 // to determine if it can use a fast track.
   1332 static bool canUseFastTrack(CAudioPlayer *pAudioPlayer)
   1333 {
   1334     assert(pAudioPlayer->mAndroidObjType == AUDIOPLAYER_FROM_PCM_BUFFERQUEUE);
   1335 
   1336     // no need to check the buffer queue size, application side
   1337     // double-buffering (and more) is not a requirement for using fast tracks
   1338 
   1339     // Check a blacklist of interfaces that are incompatible with fast tracks.
   1340     // The alternative, to check a whitelist of compatible interfaces, is
   1341     // more maintainable but is too slow.  As a compromise, in a debug build
   1342     // we use both methods and warn if they produce different results.
   1343     // In release builds, we only use the blacklist method.
   1344     // If a blacklisted interface is added after realization using
   1345     // DynamicInterfaceManagement::AddInterface,
   1346     // then this won't be detected but the interface will be ineffective.
   1347     bool blacklistResult = true;
   1348     static const unsigned blacklist[] = {
   1349         MPH_BASSBOOST,
   1350         MPH_EFFECTSEND,
   1351         MPH_ENVIRONMENTALREVERB,
   1352         MPH_EQUALIZER,
   1353         MPH_PLAYBACKRATE,
   1354         MPH_PRESETREVERB,
   1355         MPH_VIRTUALIZER,
   1356         MPH_ANDROIDEFFECT,
   1357         MPH_ANDROIDEFFECTSEND,
   1358         // FIXME The problem with a blacklist is remembering to add new interfaces here
   1359     };
   1360     for (unsigned i = 0; i < sizeof(blacklist)/sizeof(blacklist[0]); ++i) {
   1361         if (IsInterfaceInitialized(&pAudioPlayer->mObject, blacklist[i])) {
   1362             blacklistResult = false;
   1363             break;
   1364         }
   1365     }
   1366 #if LOG_NDEBUG == 0
   1367     bool whitelistResult = true;
   1368     static const unsigned whitelist[] = {
   1369         MPH_BUFFERQUEUE,
   1370         MPH_DYNAMICINTERFACEMANAGEMENT,
   1371         MPH_METADATAEXTRACTION,
   1372         MPH_MUTESOLO,
   1373         MPH_OBJECT,
   1374         MPH_PLAY,
   1375         MPH_PREFETCHSTATUS,
   1376         MPH_VOLUME,
   1377         MPH_ANDROIDCONFIGURATION,
   1378         MPH_ANDROIDSIMPLEBUFFERQUEUE,
   1379         MPH_ANDROIDBUFFERQUEUESOURCE,
   1380     };
   1381     for (unsigned mph = MPH_MIN; mph < MPH_MAX; ++mph) {
   1382         for (unsigned i = 0; i < sizeof(whitelist)/sizeof(whitelist[0]); ++i) {
   1383             if (mph == whitelist[i]) {
   1384                 goto compatible;
   1385             }
   1386         }
   1387         if (IsInterfaceInitialized(&pAudioPlayer->mObject, mph)) {
   1388             whitelistResult = false;
   1389             break;
   1390         }
   1391 compatible: ;
   1392     }
   1393     if (whitelistResult != blacklistResult) {
   1394         ALOGW("whitelistResult != blacklistResult");
   1395         // and use blacklistResult below
   1396     }
   1397 #endif
   1398     return blacklistResult;
   1399 }
   1400 
   1401 
   1402 //-----------------------------------------------------------------------------
   1403 // FIXME abstract out the diff between CMediaPlayer and CAudioPlayer
   1404 SLresult android_audioPlayer_realize(CAudioPlayer *pAudioPlayer, SLboolean async) {
   1405 
   1406     SLresult result = SL_RESULT_SUCCESS;
   1407     SL_LOGV("Realize pAudioPlayer=%p", pAudioPlayer);
   1408 
   1409     AudioPlayback_Parameters app;
   1410     app.sessionId = pAudioPlayer->mSessionId;
   1411     app.streamType = pAudioPlayer->mStreamType;
   1412 
   1413     switch (pAudioPlayer->mAndroidObjType) {
   1414 
   1415     //-----------------------------------
   1416     // AudioTrack
   1417     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   1418         {
   1419         // initialize platform-specific CAudioPlayer fields
   1420 
   1421         SLDataLocator_BufferQueue *dl_bq = (SLDataLocator_BufferQueue *)
   1422                 pAudioPlayer->mDynamicSource.mDataSource;
   1423         SLDataFormat_PCM *df_pcm = (SLDataFormat_PCM *)
   1424                 pAudioPlayer->mDynamicSource.mDataSource->pFormat;
   1425 
   1426         uint32_t sampleRate = sles_to_android_sampleRate(df_pcm->samplesPerSec);
   1427 
   1428         audio_output_flags_t policy;
   1429         if (canUseFastTrack(pAudioPlayer)) {
   1430             policy = AUDIO_OUTPUT_FLAG_FAST;
   1431         } else {
   1432             policy = AUDIO_OUTPUT_FLAG_NONE;
   1433         }
   1434 
   1435         pAudioPlayer->mAudioTrack = new android::AudioTrack(
   1436                 pAudioPlayer->mStreamType,                           // streamType
   1437                 sampleRate,                                          // sampleRate
   1438                 sles_to_android_sampleFormat(df_pcm->bitsPerSample), // format
   1439                 sles_to_android_channelMaskOut(df_pcm->numChannels, df_pcm->channelMask),
   1440                                                                      // channel mask
   1441                 0,                                                   // frameCount
   1442                 policy,                                              // flags
   1443                 audioTrack_callBack_pullFromBuffQueue,               // callback
   1444                 (void *) pAudioPlayer,                               // user
   1445                 0,     // FIXME find appropriate frame count         // notificationFrame
   1446                 pAudioPlayer->mSessionId);
   1447         android::status_t status = pAudioPlayer->mAudioTrack->initCheck();
   1448         if (status != android::NO_ERROR) {
   1449             SL_LOGE("AudioTrack::initCheck status %u", status);
   1450             result = SL_RESULT_CONTENT_UNSUPPORTED;
   1451             pAudioPlayer->mAudioTrack.clear();
   1452             return result;
   1453         }
   1454 
   1455         // initialize platform-independent CAudioPlayer fields
   1456 
   1457         pAudioPlayer->mNumChannels = df_pcm->numChannels;
   1458         pAudioPlayer->mSampleRateMilliHz = df_pcm->samplesPerSec; // Note: bad field name in SL ES
   1459 
   1460         // This use case does not have a separate "prepare" step
   1461         pAudioPlayer->mAndroidObjState = ANDROID_READY;
   1462         }
   1463         break;
   1464 
   1465     //-----------------------------------
   1466     // MediaPlayer
   1467     case AUDIOPLAYER_FROM_URIFD: {
   1468         pAudioPlayer->mAPlayer = new android::LocAVPlayer(&app, false /*hasVideo*/);
   1469         pAudioPlayer->mAPlayer->init(sfplayer_handlePrefetchEvent,
   1470                         (void*)pAudioPlayer /*notifUSer*/);
   1471 
   1472         switch (pAudioPlayer->mDataSource.mLocator.mLocatorType) {
   1473             case SL_DATALOCATOR_URI: {
   1474                 // The legacy implementation ran Stagefright within the application process, and
   1475                 // so allowed local pathnames specified by URI that were openable by
   1476                 // the application but were not openable by mediaserver.
   1477                 // The current implementation runs Stagefright (mostly) within mediaserver,
   1478                 // which runs as a different UID and likely a different current working directory.
   1479                 // For backwards compatibility with any applications which may have relied on the
   1480                 // previous behavior, we convert an openable file URI into an FD.
   1481                 // Note that unlike SL_DATALOCATOR_ANDROIDFD, this FD is owned by us
   1482                 // and so we close it as soon as we've passed it (via Binder dup) to mediaserver.
   1483                 const char *uri = (const char *)pAudioPlayer->mDataSource.mLocator.mURI.URI;
   1484                 if (!isDistantProtocol(uri)) {
   1485                     // don't touch the original uri, we may need it later
   1486                     const char *pathname = uri;
   1487                     // skip over an optional leading file:// prefix
   1488                     if (!strncasecmp(pathname, "file://", 7)) {
   1489                         pathname += 7;
   1490                     }
   1491                     // attempt to open it as a file using the application's credentials
   1492                     int fd = ::open(pathname, O_RDONLY);
   1493                     if (fd >= 0) {
   1494                         // if open is successful, then check to see if it's a regular file
   1495                         struct stat statbuf;
   1496                         if (!::fstat(fd, &statbuf) && S_ISREG(statbuf.st_mode)) {
   1497                             // treat similarly to an FD data locator, but
   1498                             // let setDataSource take responsibility for closing fd
   1499                             pAudioPlayer->mAPlayer->setDataSource(fd, 0, statbuf.st_size, true);
   1500                             break;
   1501                         }
   1502                         // we were able to open it, but it's not a file, so let mediaserver try
   1503                         (void) ::close(fd);
   1504                     }
   1505                 }
   1506                 // if either the URI didn't look like a file, or open failed, or not a file
   1507                 pAudioPlayer->mAPlayer->setDataSource(uri);
   1508                 } break;
   1509             case SL_DATALOCATOR_ANDROIDFD: {
   1510                 int64_t offset = (int64_t)pAudioPlayer->mDataSource.mLocator.mFD.offset;
   1511                 pAudioPlayer->mAPlayer->setDataSource(
   1512                         (int)pAudioPlayer->mDataSource.mLocator.mFD.fd,
   1513                         offset == SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE ?
   1514                                 (int64_t)PLAYER_FD_FIND_FILE_SIZE : offset,
   1515                         (int64_t)pAudioPlayer->mDataSource.mLocator.mFD.length);
   1516                 }
   1517                 break;
   1518             default:
   1519                 SL_LOGE(ERROR_PLAYERREALIZE_UNKNOWN_DATASOURCE_LOCATOR);
   1520                 break;
   1521         }
   1522 
   1523         }
   1524         break;
   1525 
   1526     //-----------------------------------
   1527     // StreamPlayer
   1528     case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: {
   1529         android::StreamPlayer* splr = new android::StreamPlayer(&app, false /*hasVideo*/,
   1530                 &pAudioPlayer->mAndroidBufferQueue, pAudioPlayer->mCallbackProtector);
   1531         pAudioPlayer->mAPlayer = splr;
   1532         splr->init(sfplayer_handlePrefetchEvent, (void*)pAudioPlayer);
   1533         }
   1534         break;
   1535 
   1536     //-----------------------------------
   1537     // AudioToCbRenderer
   1538     case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE: {
   1539         android::AudioToCbRenderer* decoder = new android::AudioToCbRenderer(&app);
   1540         pAudioPlayer->mAPlayer = decoder;
   1541         // configures the callback for the sink buffer queue
   1542         decoder->setDataPushListener(adecoder_writeToBufferQueue, pAudioPlayer);
   1543         // configures the callback for the notifications coming from the SF code
   1544         decoder->init(sfplayer_handlePrefetchEvent, (void*)pAudioPlayer);
   1545 
   1546         switch (pAudioPlayer->mDataSource.mLocator.mLocatorType) {
   1547         case SL_DATALOCATOR_URI:
   1548             decoder->setDataSource(
   1549                     (const char*)pAudioPlayer->mDataSource.mLocator.mURI.URI);
   1550             break;
   1551         case SL_DATALOCATOR_ANDROIDFD: {
   1552             int64_t offset = (int64_t)pAudioPlayer->mDataSource.mLocator.mFD.offset;
   1553             decoder->setDataSource(
   1554                     (int)pAudioPlayer->mDataSource.mLocator.mFD.fd,
   1555                     offset == SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE ?
   1556                             (int64_t)PLAYER_FD_FIND_FILE_SIZE : offset,
   1557                             (int64_t)pAudioPlayer->mDataSource.mLocator.mFD.length);
   1558             }
   1559             break;
   1560         default:
   1561             SL_LOGE(ERROR_PLAYERREALIZE_UNKNOWN_DATASOURCE_LOCATOR);
   1562             break;
   1563         }
   1564 
   1565         }
   1566         break;
   1567 
   1568     //-----------------------------------
   1569     // AacBqToPcmCbRenderer
   1570     case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE: {
   1571         android::AacBqToPcmCbRenderer* bqtobq = new android::AacBqToPcmCbRenderer(&app,
   1572                 &pAudioPlayer->mAndroidBufferQueue);
   1573         // configures the callback for the sink buffer queue
   1574         bqtobq->setDataPushListener(adecoder_writeToBufferQueue, pAudioPlayer);
   1575         pAudioPlayer->mAPlayer = bqtobq;
   1576         // configures the callback for the notifications coming from the SF code,
   1577         // but also implicitly configures the AndroidBufferQueue from which ADTS data is read
   1578         pAudioPlayer->mAPlayer->init(sfplayer_handlePrefetchEvent, (void*)pAudioPlayer);
   1579         }
   1580         break;
   1581 
   1582     //-----------------------------------
   1583     default:
   1584         SL_LOGE(ERROR_PLAYERREALIZE_UNEXPECTED_OBJECT_TYPE_D, pAudioPlayer->mAndroidObjType);
   1585         result = SL_RESULT_INTERNAL_ERROR;
   1586         break;
   1587     }
   1588 
   1589     // proceed with effect initialization
   1590     // initialize EQ
   1591     // FIXME use a table of effect descriptors when adding support for more effects
   1592     if (memcmp(SL_IID_EQUALIZER, &pAudioPlayer->mEqualizer.mEqDescriptor.type,
   1593             sizeof(effect_uuid_t)) == 0) {
   1594         SL_LOGV("Need to initialize EQ for AudioPlayer=%p", pAudioPlayer);
   1595         android_eq_init(pAudioPlayer->mSessionId, &pAudioPlayer->mEqualizer);
   1596     }
   1597     // initialize BassBoost
   1598     if (memcmp(SL_IID_BASSBOOST, &pAudioPlayer->mBassBoost.mBassBoostDescriptor.type,
   1599             sizeof(effect_uuid_t)) == 0) {
   1600         SL_LOGV("Need to initialize BassBoost for AudioPlayer=%p", pAudioPlayer);
   1601         android_bb_init(pAudioPlayer->mSessionId, &pAudioPlayer->mBassBoost);
   1602     }
   1603     // initialize Virtualizer
   1604     if (memcmp(SL_IID_VIRTUALIZER, &pAudioPlayer->mVirtualizer.mVirtualizerDescriptor.type,
   1605                sizeof(effect_uuid_t)) == 0) {
   1606         SL_LOGV("Need to initialize Virtualizer for AudioPlayer=%p", pAudioPlayer);
   1607         android_virt_init(pAudioPlayer->mSessionId, &pAudioPlayer->mVirtualizer);
   1608     }
   1609 
   1610     // initialize EffectSend
   1611     // FIXME initialize EffectSend
   1612 
   1613     return result;
   1614 }
   1615 
   1616 
   1617 //-----------------------------------------------------------------------------
   1618 /**
   1619  * Called with a lock on AudioPlayer, and blocks until safe to destroy
   1620  */
   1621 SLresult android_audioPlayer_preDestroy(CAudioPlayer *pAudioPlayer) {
   1622     SL_LOGD("android_audioPlayer_preDestroy(%p)", pAudioPlayer);
   1623     SLresult result = SL_RESULT_SUCCESS;
   1624 
   1625     bool disableCallbacksBeforePreDestroy;
   1626     switch (pAudioPlayer->mAndroidObjType) {
   1627     // Not yet clear why this order is important, but it reduces detected deadlocks
   1628     case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   1629         disableCallbacksBeforePreDestroy = true;
   1630         break;
   1631     // Use the old behavior for all other use cases until proven
   1632     // case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1633     default:
   1634         disableCallbacksBeforePreDestroy = false;
   1635         break;
   1636     }
   1637 
   1638     if (disableCallbacksBeforePreDestroy) {
   1639         object_unlock_exclusive(&pAudioPlayer->mObject);
   1640         if (pAudioPlayer->mCallbackProtector != 0) {
   1641             pAudioPlayer->mCallbackProtector->requestCbExitAndWait();
   1642         }
   1643         object_lock_exclusive(&pAudioPlayer->mObject);
   1644     }
   1645 
   1646     if (pAudioPlayer->mAPlayer != 0) {
   1647         pAudioPlayer->mAPlayer->preDestroy();
   1648     }
   1649     SL_LOGD("android_audioPlayer_preDestroy(%p) after mAPlayer->preDestroy()", pAudioPlayer);
   1650 
   1651     if (!disableCallbacksBeforePreDestroy) {
   1652         object_unlock_exclusive(&pAudioPlayer->mObject);
   1653         if (pAudioPlayer->mCallbackProtector != 0) {
   1654             pAudioPlayer->mCallbackProtector->requestCbExitAndWait();
   1655         }
   1656         object_lock_exclusive(&pAudioPlayer->mObject);
   1657     }
   1658 
   1659     return result;
   1660 }
   1661 
   1662 
   1663 //-----------------------------------------------------------------------------
   1664 SLresult android_audioPlayer_destroy(CAudioPlayer *pAudioPlayer) {
   1665     SLresult result = SL_RESULT_SUCCESS;
   1666     SL_LOGV("android_audioPlayer_destroy(%p)", pAudioPlayer);
   1667     switch (pAudioPlayer->mAndroidObjType) {
   1668 
   1669     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   1670         // We own the audio track for PCM buffer queue players
   1671         if (pAudioPlayer->mAudioTrack != 0) {
   1672             pAudioPlayer->mAudioTrack->stop();
   1673             // Note that there may still be another reference in post-unlock phase of SetPlayState
   1674             pAudioPlayer->mAudioTrack.clear();
   1675         }
   1676         break;
   1677 
   1678     case AUDIOPLAYER_FROM_URIFD:     // intended fall-through
   1679     case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE:    // intended fall-through
   1680     case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE: // intended fall-through
   1681     case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1682         pAudioPlayer->mAPlayer.clear();
   1683         break;
   1684     //-----------------------------------
   1685     default:
   1686         SL_LOGE(ERROR_PLAYERDESTROY_UNEXPECTED_OBJECT_TYPE_D, pAudioPlayer->mAndroidObjType);
   1687         result = SL_RESULT_INTERNAL_ERROR;
   1688         break;
   1689     }
   1690 
   1691     // placeholder: not necessary yet as session ID lifetime doesn't extend beyond player
   1692     // android::AudioSystem::releaseAudioSessionId(pAudioPlayer->mSessionId);
   1693 
   1694     pAudioPlayer->mCallbackProtector.clear();
   1695 
   1696     // explicit destructor
   1697     pAudioPlayer->mAudioTrack.~sp();
   1698     // note that SetPlayState(PLAYING) may still hold a reference
   1699     pAudioPlayer->mCallbackProtector.~sp();
   1700     pAudioPlayer->mAuxEffect.~sp();
   1701     pAudioPlayer->mAPlayer.~sp();
   1702 
   1703     return result;
   1704 }
   1705 
   1706 
   1707 //-----------------------------------------------------------------------------
   1708 SLresult android_audioPlayer_setPlaybackRateAndConstraints(CAudioPlayer *ap, SLpermille rate,
   1709         SLuint32 constraints) {
   1710     SLresult result = SL_RESULT_SUCCESS;
   1711     switch(ap->mAndroidObjType) {
   1712     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE: {
   1713         // these asserts were already checked by the platform-independent layer
   1714         assert((AUDIOTRACK_MIN_PLAYBACKRATE_PERMILLE <= rate) &&
   1715                 (rate <= AUDIOTRACK_MAX_PLAYBACKRATE_PERMILLE));
   1716         assert(constraints & SL_RATEPROP_NOPITCHCORAUDIO);
   1717         // get the content sample rate
   1718         uint32_t contentRate = sles_to_android_sampleRate(ap->mSampleRateMilliHz);
   1719         // apply the SL ES playback rate on the AudioTrack as a factor of its content sample rate
   1720         if (ap->mAudioTrack != 0) {
   1721             ap->mAudioTrack->setSampleRate(contentRate * (rate/1000.0f));
   1722         }
   1723         }
   1724         break;
   1725     case AUDIOPLAYER_FROM_URIFD: {
   1726         assert((MEDIAPLAYER_MIN_PLAYBACKRATE_PERMILLE <= rate) &&
   1727                         (rate <= MEDIAPLAYER_MAX_PLAYBACKRATE_PERMILLE));
   1728         assert(constraints & SL_RATEPROP_NOPITCHCORAUDIO);
   1729         // apply the SL ES playback rate on the GenericPlayer
   1730         if (ap->mAPlayer != 0) {
   1731             ap->mAPlayer->setPlaybackRate((int16_t)rate);
   1732         }
   1733         }
   1734         break;
   1735 
   1736     default:
   1737         SL_LOGE("Unexpected object type %d", ap->mAndroidObjType);
   1738         result = SL_RESULT_FEATURE_UNSUPPORTED;
   1739         break;
   1740     }
   1741     return result;
   1742 }
   1743 
   1744 
   1745 //-----------------------------------------------------------------------------
   1746 // precondition
   1747 //  called with no lock held
   1748 //  ap != NULL
   1749 //  pItemCount != NULL
   1750 SLresult android_audioPlayer_metadata_getItemCount(CAudioPlayer *ap, SLuint32 *pItemCount) {
   1751     if (ap->mAPlayer == 0) {
   1752         return SL_RESULT_PARAMETER_INVALID;
   1753     }
   1754     switch(ap->mAndroidObjType) {
   1755       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   1756       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1757         {
   1758             android::AudioSfDecoder* decoder =
   1759                     static_cast<android::AudioSfDecoder*>(ap->mAPlayer.get());
   1760             *pItemCount = decoder->getPcmFormatKeyCount();
   1761         }
   1762         break;
   1763       default:
   1764         *pItemCount = 0;
   1765         break;
   1766     }
   1767     return SL_RESULT_SUCCESS;
   1768 }
   1769 
   1770 
   1771 //-----------------------------------------------------------------------------
   1772 // precondition
   1773 //  called with no lock held
   1774 //  ap != NULL
   1775 //  pKeySize != NULL
   1776 SLresult android_audioPlayer_metadata_getKeySize(CAudioPlayer *ap,
   1777         SLuint32 index, SLuint32 *pKeySize) {
   1778     if (ap->mAPlayer == 0) {
   1779         return SL_RESULT_PARAMETER_INVALID;
   1780     }
   1781     SLresult res = SL_RESULT_SUCCESS;
   1782     switch(ap->mAndroidObjType) {
   1783       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   1784       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1785         {
   1786             android::AudioSfDecoder* decoder =
   1787                     static_cast<android::AudioSfDecoder*>(ap->mAPlayer.get());
   1788             SLuint32 keyNameSize = 0;
   1789             if (!decoder->getPcmFormatKeySize(index, &keyNameSize)) {
   1790                 res = SL_RESULT_PARAMETER_INVALID;
   1791             } else {
   1792                 // *pKeySize is the size of the region used to store the key name AND
   1793                 //   the information about the key (size, lang, encoding)
   1794                 *pKeySize = keyNameSize + sizeof(SLMetadataInfo);
   1795             }
   1796         }
   1797         break;
   1798       default:
   1799         *pKeySize = 0;
   1800         res = SL_RESULT_PARAMETER_INVALID;
   1801         break;
   1802     }
   1803     return res;
   1804 }
   1805 
   1806 
   1807 //-----------------------------------------------------------------------------
   1808 // precondition
   1809 //  called with no lock held
   1810 //  ap != NULL
   1811 //  pKey != NULL
   1812 SLresult android_audioPlayer_metadata_getKey(CAudioPlayer *ap,
   1813         SLuint32 index, SLuint32 size, SLMetadataInfo *pKey) {
   1814     if (ap->mAPlayer == 0) {
   1815         return SL_RESULT_PARAMETER_INVALID;
   1816     }
   1817     SLresult res = SL_RESULT_SUCCESS;
   1818     switch(ap->mAndroidObjType) {
   1819       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   1820       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1821         {
   1822             android::AudioSfDecoder* decoder =
   1823                     static_cast<android::AudioSfDecoder*>(ap->mAPlayer.get());
   1824             if ((size < sizeof(SLMetadataInfo) ||
   1825                     (!decoder->getPcmFormatKeyName(index, size - sizeof(SLMetadataInfo),
   1826                             (char*)pKey->data)))) {
   1827                 res = SL_RESULT_PARAMETER_INVALID;
   1828             } else {
   1829                 // successfully retrieved the key value, update the other fields
   1830                 pKey->encoding = SL_CHARACTERENCODING_UTF8;
   1831                 memcpy((char *) pKey->langCountry, "en", 3);
   1832                 pKey->size = strlen((char*)pKey->data) + 1;
   1833             }
   1834         }
   1835         break;
   1836       default:
   1837         res = SL_RESULT_PARAMETER_INVALID;
   1838         break;
   1839     }
   1840     return res;
   1841 }
   1842 
   1843 
   1844 //-----------------------------------------------------------------------------
   1845 // precondition
   1846 //  called with no lock held
   1847 //  ap != NULL
   1848 //  pValueSize != NULL
   1849 SLresult android_audioPlayer_metadata_getValueSize(CAudioPlayer *ap,
   1850         SLuint32 index, SLuint32 *pValueSize) {
   1851     if (ap->mAPlayer == 0) {
   1852         return SL_RESULT_PARAMETER_INVALID;
   1853     }
   1854     SLresult res = SL_RESULT_SUCCESS;
   1855     switch(ap->mAndroidObjType) {
   1856       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   1857       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1858         {
   1859             android::AudioSfDecoder* decoder =
   1860                     static_cast<android::AudioSfDecoder*>(ap->mAPlayer.get());
   1861             SLuint32 valueSize = 0;
   1862             if (!decoder->getPcmFormatValueSize(index, &valueSize)) {
   1863                 res = SL_RESULT_PARAMETER_INVALID;
   1864             } else {
   1865                 // *pValueSize is the size of the region used to store the key value AND
   1866                 //   the information about the value (size, lang, encoding)
   1867                 *pValueSize = valueSize + sizeof(SLMetadataInfo);
   1868             }
   1869         }
   1870         break;
   1871       default:
   1872           *pValueSize = 0;
   1873           res = SL_RESULT_PARAMETER_INVALID;
   1874           break;
   1875     }
   1876     return res;
   1877 }
   1878 
   1879 
   1880 //-----------------------------------------------------------------------------
   1881 // precondition
   1882 //  called with no lock held
   1883 //  ap != NULL
   1884 //  pValue != NULL
   1885 SLresult android_audioPlayer_metadata_getValue(CAudioPlayer *ap,
   1886         SLuint32 index, SLuint32 size, SLMetadataInfo *pValue) {
   1887     if (ap->mAPlayer == 0) {
   1888         return SL_RESULT_PARAMETER_INVALID;
   1889     }
   1890     SLresult res = SL_RESULT_SUCCESS;
   1891     switch(ap->mAndroidObjType) {
   1892       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   1893       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1894         {
   1895             android::AudioSfDecoder* decoder =
   1896                     static_cast<android::AudioSfDecoder*>(ap->mAPlayer.get());
   1897             pValue->encoding = SL_CHARACTERENCODING_BINARY;
   1898             memcpy((char *) pValue->langCountry, "en", 3); // applicable here?
   1899             SLuint32 valueSize = 0;
   1900             if ((size < sizeof(SLMetadataInfo)
   1901                     || (!decoder->getPcmFormatValueSize(index, &valueSize))
   1902                     || (!decoder->getPcmFormatKeyValue(index, size - sizeof(SLMetadataInfo),
   1903                             (SLuint32*)pValue->data)))) {
   1904                 res = SL_RESULT_PARAMETER_INVALID;
   1905             } else {
   1906                 pValue->size = valueSize;
   1907             }
   1908         }
   1909         break;
   1910       default:
   1911         res = SL_RESULT_PARAMETER_INVALID;
   1912         break;
   1913     }
   1914     return res;
   1915 }
   1916 
   1917 //-----------------------------------------------------------------------------
   1918 // preconditions
   1919 //  ap != NULL
   1920 //  mutex is locked
   1921 //  play state has changed
   1922 void android_audioPlayer_setPlayState(CAudioPlayer *ap) {
   1923 
   1924     SLuint32 playState = ap->mPlay.mState;
   1925     AndroidObjectState objState = ap->mAndroidObjState;
   1926 
   1927     switch(ap->mAndroidObjType) {
   1928     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   1929         switch (playState) {
   1930         case SL_PLAYSTATE_STOPPED:
   1931             SL_LOGV("setting AudioPlayer to SL_PLAYSTATE_STOPPED");
   1932             if (ap->mAudioTrack != 0) {
   1933                 ap->mAudioTrack->stop();
   1934             }
   1935             break;
   1936         case SL_PLAYSTATE_PAUSED:
   1937             SL_LOGV("setting AudioPlayer to SL_PLAYSTATE_PAUSED");
   1938             if (ap->mAudioTrack != 0) {
   1939                 ap->mAudioTrack->pause();
   1940             }
   1941             break;
   1942         case SL_PLAYSTATE_PLAYING:
   1943             SL_LOGV("setting AudioPlayer to SL_PLAYSTATE_PLAYING");
   1944             if (ap->mAudioTrack != 0) {
   1945                 // instead of ap->mAudioTrack->start();
   1946                 ap->mDeferredStart = true;
   1947             }
   1948             break;
   1949         default:
   1950             // checked by caller, should not happen
   1951             break;
   1952         }
   1953         break;
   1954 
   1955     case AUDIOPLAYER_FROM_URIFD:      // intended fall-through
   1956     case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE:     // intended fall-through
   1957     case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:  // intended fall-through
   1958     case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   1959         // FIXME report and use the return code to the lock mechanism, which is where play state
   1960         //   changes are updated (see object_unlock_exclusive_attributes())
   1961         aplayer_setPlayState(ap->mAPlayer, playState, &(ap->mAndroidObjState));
   1962         break;
   1963     default:
   1964         SL_LOGE(ERROR_PLAYERSETPLAYSTATE_UNEXPECTED_OBJECT_TYPE_D, ap->mAndroidObjType);
   1965         break;
   1966     }
   1967 }
   1968 
   1969 
   1970 //-----------------------------------------------------------------------------
   1971 // call when either player event flags, marker position, or position update period changes
   1972 void android_audioPlayer_usePlayEventMask(CAudioPlayer *ap) {
   1973     IPlay *pPlayItf = &ap->mPlay;
   1974     SLuint32 eventFlags = pPlayItf->mEventFlags;
   1975     /*switch(ap->mAndroidObjType) {
   1976     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:*/
   1977 
   1978     if (ap->mAPlayer != 0) {
   1979         assert(ap->mAudioTrack == 0);
   1980         ap->mAPlayer->setPlayEvents((int32_t) eventFlags, (int32_t) pPlayItf->mMarkerPosition,
   1981                 (int32_t) pPlayItf->mPositionUpdatePeriod);
   1982         return;
   1983     }
   1984 
   1985     if (ap->mAudioTrack == 0) {
   1986         return;
   1987     }
   1988 
   1989     if (eventFlags & SL_PLAYEVENT_HEADATMARKER) {
   1990         ap->mAudioTrack->setMarkerPosition((uint32_t)((((int64_t)pPlayItf->mMarkerPosition
   1991                 * sles_to_android_sampleRate(ap->mSampleRateMilliHz)))/1000));
   1992     } else {
   1993         // clear marker
   1994         ap->mAudioTrack->setMarkerPosition(0);
   1995     }
   1996 
   1997     if (eventFlags & SL_PLAYEVENT_HEADATNEWPOS) {
   1998          ap->mAudioTrack->setPositionUpdatePeriod(
   1999                 (uint32_t)((((int64_t)pPlayItf->mPositionUpdatePeriod
   2000                 * sles_to_android_sampleRate(ap->mSampleRateMilliHz)))/1000));
   2001     } else {
   2002         // clear periodic update
   2003         ap->mAudioTrack->setPositionUpdatePeriod(0);
   2004     }
   2005 
   2006     if (eventFlags & SL_PLAYEVENT_HEADATEND) {
   2007         // nothing to do for SL_PLAYEVENT_HEADATEND, callback event will be checked against mask
   2008     }
   2009 
   2010     if (eventFlags & SL_PLAYEVENT_HEADMOVING) {
   2011         // FIXME support SL_PLAYEVENT_HEADMOVING
   2012         SL_LOGD("[ FIXME: IPlay_SetCallbackEventsMask(SL_PLAYEVENT_HEADMOVING) on an "
   2013             "SL_OBJECTID_AUDIOPLAYER to be implemented ]");
   2014     }
   2015     if (eventFlags & SL_PLAYEVENT_HEADSTALLED) {
   2016         // nothing to do for SL_PLAYEVENT_HEADSTALLED, callback event will be checked against mask
   2017     }
   2018 
   2019 }
   2020 
   2021 
   2022 //-----------------------------------------------------------------------------
   2023 SLresult android_audioPlayer_getDuration(IPlay *pPlayItf, SLmillisecond *pDurMsec) {
   2024     CAudioPlayer *ap = (CAudioPlayer *)pPlayItf->mThis;
   2025     switch(ap->mAndroidObjType) {
   2026 
   2027       case AUDIOPLAYER_FROM_URIFD:  // intended fall-through
   2028       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE: {
   2029         int32_t durationMsec = ANDROID_UNKNOWN_TIME;
   2030         if (ap->mAPlayer != 0) {
   2031             ap->mAPlayer->getDurationMsec(&durationMsec);
   2032         }
   2033         *pDurMsec = durationMsec == ANDROID_UNKNOWN_TIME ? SL_TIME_UNKNOWN : durationMsec;
   2034         break;
   2035       }
   2036 
   2037       case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE: // intended fall-through
   2038       case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   2039       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   2040       default: {
   2041         *pDurMsec = SL_TIME_UNKNOWN;
   2042       }
   2043     }
   2044     return SL_RESULT_SUCCESS;
   2045 }
   2046 
   2047 
   2048 //-----------------------------------------------------------------------------
   2049 void android_audioPlayer_getPosition(IPlay *pPlayItf, SLmillisecond *pPosMsec) {
   2050     CAudioPlayer *ap = (CAudioPlayer *)pPlayItf->mThis;
   2051     switch(ap->mAndroidObjType) {
   2052 
   2053       case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   2054         if ((ap->mSampleRateMilliHz == UNKNOWN_SAMPLERATE) || (ap->mAudioTrack == 0)) {
   2055             *pPosMsec = 0;
   2056         } else {
   2057             uint32_t positionInFrames;
   2058             ap->mAudioTrack->getPosition(&positionInFrames);
   2059             *pPosMsec = ((int64_t)positionInFrames * 1000) /
   2060                     sles_to_android_sampleRate(ap->mSampleRateMilliHz);
   2061         }
   2062         break;
   2063 
   2064       case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE:    // intended fall-through
   2065       case AUDIOPLAYER_FROM_URIFD:
   2066       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   2067       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE: {
   2068         int32_t posMsec = ANDROID_UNKNOWN_TIME;
   2069         if (ap->mAPlayer != 0) {
   2070             ap->mAPlayer->getPositionMsec(&posMsec);
   2071         }
   2072         *pPosMsec = posMsec == ANDROID_UNKNOWN_TIME ? 0 : posMsec;
   2073         break;
   2074       }
   2075 
   2076       default:
   2077         *pPosMsec = 0;
   2078     }
   2079 }
   2080 
   2081 
   2082 //-----------------------------------------------------------------------------
   2083 SLresult android_audioPlayer_seek(CAudioPlayer *ap, SLmillisecond posMsec) {
   2084     SLresult result = SL_RESULT_SUCCESS;
   2085 
   2086     switch(ap->mAndroidObjType) {
   2087 
   2088       case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:      // intended fall-through
   2089       case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE:
   2090       case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   2091         result = SL_RESULT_FEATURE_UNSUPPORTED;
   2092         break;
   2093 
   2094       case AUDIOPLAYER_FROM_URIFD:                   // intended fall-through
   2095       case AUDIOPLAYER_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   2096         if (ap->mAPlayer != 0) {
   2097             ap->mAPlayer->seek(posMsec);
   2098         }
   2099         break;
   2100 
   2101       default:
   2102         break;
   2103     }
   2104     return result;
   2105 }
   2106 
   2107 
   2108 //-----------------------------------------------------------------------------
   2109 SLresult android_audioPlayer_loop(CAudioPlayer *ap, SLboolean loopEnable) {
   2110     SLresult result = SL_RESULT_SUCCESS;
   2111 
   2112     switch (ap->mAndroidObjType) {
   2113     case AUDIOPLAYER_FROM_URIFD:
   2114     // case AUDIOPLAY_FROM_URIFD_TO_PCM_BUFFERQUEUE:
   2115     //      would actually work, but what's the point?
   2116       if (ap->mAPlayer != 0) {
   2117         ap->mAPlayer->loop((bool)loopEnable);
   2118       }
   2119       break;
   2120     default:
   2121       result = SL_RESULT_FEATURE_UNSUPPORTED;
   2122       break;
   2123     }
   2124     return result;
   2125 }
   2126 
   2127 
   2128 //-----------------------------------------------------------------------------
   2129 SLresult android_audioPlayer_setBufferingUpdateThresholdPerMille(CAudioPlayer *ap,
   2130         SLpermille threshold) {
   2131     SLresult result = SL_RESULT_SUCCESS;
   2132 
   2133     switch (ap->mAndroidObjType) {
   2134       case AUDIOPLAYER_FROM_URIFD:
   2135         if (ap->mAPlayer != 0) {
   2136             ap->mAPlayer->setBufferingUpdateThreshold(threshold / 10);
   2137         }
   2138         break;
   2139 
   2140       default: {}
   2141     }
   2142 
   2143     return result;
   2144 }
   2145 
   2146 
   2147 //-----------------------------------------------------------------------------
   2148 void android_audioPlayer_bufferQueue_onRefilled_l(CAudioPlayer *ap) {
   2149     // the AudioTrack associated with the AudioPlayer receiving audio from a PCM buffer
   2150     // queue was stopped when the queue become empty, we restart as soon as a new buffer
   2151     // has been enqueued since we're in playing state
   2152     if (ap->mAudioTrack != 0) {
   2153         // instead of ap->mAudioTrack->start();
   2154         ap->mDeferredStart = true;
   2155     }
   2156 
   2157     // when the queue became empty, an underflow on the prefetch status itf was sent. Now the queue
   2158     // has received new data, signal it has sufficient data
   2159     if (IsInterfaceInitialized(&(ap->mObject), MPH_PREFETCHSTATUS)) {
   2160         // we wouldn't have been called unless we were previously in the underflow state
   2161         assert(SL_PREFETCHSTATUS_UNDERFLOW == ap->mPrefetchStatus.mStatus);
   2162         assert(0 == ap->mPrefetchStatus.mLevel);
   2163         ap->mPrefetchStatus.mStatus = SL_PREFETCHSTATUS_SUFFICIENTDATA;
   2164         ap->mPrefetchStatus.mLevel = 1000;
   2165         // callback or no callback?
   2166         SLuint32 prefetchEvents = ap->mPrefetchStatus.mCallbackEventsMask &
   2167                 (SL_PREFETCHEVENT_STATUSCHANGE | SL_PREFETCHEVENT_FILLLEVELCHANGE);
   2168         if (SL_PREFETCHEVENT_NONE != prefetchEvents) {
   2169             ap->mPrefetchStatus.mDeferredPrefetchCallback = ap->mPrefetchStatus.mCallback;
   2170             ap->mPrefetchStatus.mDeferredPrefetchContext  = ap->mPrefetchStatus.mContext;
   2171             ap->mPrefetchStatus.mDeferredPrefetchEvents   = prefetchEvents;
   2172         }
   2173     }
   2174 }
   2175 
   2176 
   2177 //-----------------------------------------------------------------------------
   2178 /*
   2179  * BufferQueue::Clear
   2180  */
   2181 SLresult android_audioPlayer_bufferQueue_onClear(CAudioPlayer *ap) {
   2182     SLresult result = SL_RESULT_SUCCESS;
   2183 
   2184     switch (ap->mAndroidObjType) {
   2185     //-----------------------------------
   2186     // AudioTrack
   2187     case AUDIOPLAYER_FROM_PCM_BUFFERQUEUE:
   2188         if (ap->mAudioTrack != 0) {
   2189             ap->mAudioTrack->flush();
   2190         }
   2191         break;
   2192     default:
   2193         result = SL_RESULT_INTERNAL_ERROR;
   2194         break;
   2195     }
   2196 
   2197     return result;
   2198 }
   2199 
   2200 
   2201 //-----------------------------------------------------------------------------
   2202 void android_audioPlayer_androidBufferQueue_clear_l(CAudioPlayer *ap) {
   2203     switch (ap->mAndroidObjType) {
   2204     case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE:
   2205       if (ap->mAPlayer != 0) {
   2206         android::StreamPlayer* splr = static_cast<android::StreamPlayer*>(ap->mAPlayer.get());
   2207         splr->appClear_l();
   2208       } break;
   2209     case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   2210       // nothing to do here, fall through
   2211     default:
   2212       break;
   2213     }
   2214 }
   2215 
   2216 void android_audioPlayer_androidBufferQueue_onRefilled_l(CAudioPlayer *ap) {
   2217     switch (ap->mAndroidObjType) {
   2218     case AUDIOPLAYER_FROM_TS_ANDROIDBUFFERQUEUE:
   2219       if (ap->mAPlayer != 0) {
   2220         android::StreamPlayer* splr = static_cast<android::StreamPlayer*>(ap->mAPlayer.get());
   2221         splr->queueRefilled();
   2222       } break;
   2223     case AUDIOPLAYER_FROM_ADTS_ABQ_TO_PCM_BUFFERQUEUE:
   2224       // FIXME this may require waking up the decoder if it is currently starved and isn't polling
   2225     default:
   2226       break;
   2227     }
   2228 }
   2229