wilhelm/src/android/android_AudioSfDecoder.cpp

   1 /*
   2  * Copyright (C) 2011 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 //#define USE_LOG SLAndroidLogLevel_Verbose
  18
  19 #include "sles_allinclusive.h"
  20 #include "android/android_AudioSfDecoder.h"
  21
  22 #include <binder/IServiceManager.h>
  23 #include <media/stagefright/foundation/ADebug.h>
  24
  25
  26 #define SIZE_CACHED_HIGH_BYTES 1000000
  27 #define SIZE_CACHED_MED_BYTES   700000
  28 #define SIZE_CACHED_LOW_BYTES   400000
  29
  30 namespace android {
  31
  32 //--------------------------------------------------------------------------------------------------
  33 AudioSfDecoder::AudioSfDecoder(const AudioPlayback_Parameters* params) : GenericPlayer(params),
  34         mDataSource(0),
  35         mAudioSource(0),
  36         mAudioSourceStarted(false),
  37         mBitrate(-1),
  38         mDurationUsec(ANDROID_UNKNOWN_TIME),
  39         mDecodeBuffer(NULL),
  40         mSeekTimeMsec(0),
  41         // play event logic depends on the initial time being zero not ANDROID_UNKNOWN_TIME
  42         mLastDecodedPositionUs(0)
  43 {
  44     SL_LOGD("AudioSfDecoder::AudioSfDecoder()");
  45 }
  46
  47
  48 AudioSfDecoder::~AudioSfDecoder() {
  49     SL_LOGD("AudioSfDecoder::~AudioSfDecoder()");
  50 }
  51
  52
  53 void AudioSfDecoder::preDestroy() {
  54     GenericPlayer::preDestroy();
  55     SL_LOGD("AudioSfDecoder::preDestroy()");
  56     {
  57         Mutex::Autolock _l(mBufferSourceLock);
  58
  59         if (NULL != mDecodeBuffer) {
  60             mDecodeBuffer->release();
  61             mDecodeBuffer = NULL;
  62         }
  63
  64         if ((mAudioSource != 0) && mAudioSourceStarted) {
  65             mAudioSource->stop();
  66             mAudioSourceStarted = false;
  67         }
  68     }
  69 }
  70
  71
  72 //--------------------------------------------------
  73 void AudioSfDecoder::play() {
  74     SL_LOGD("AudioSfDecoder::play");
  75
  76     GenericPlayer::play();
  77     (new AMessage(kWhatDecode, id()))->post();
  78 }
  79
  80
  81 void AudioSfDecoder::getPositionMsec(int* msec) {
  82     int64_t timeUsec = getPositionUsec();
  83     if (timeUsec == ANDROID_UNKNOWN_TIME) {
  84         *msec = ANDROID_UNKNOWN_TIME;
  85     } else {
  86         *msec = timeUsec / 1000;
  87     }
  88 }
  89
  90
  91 //--------------------------------------------------
  92 uint32_t AudioSfDecoder::getPcmFormatKeyCount() const {
  93     return NB_PCMMETADATA_KEYS;
  94 }
  95
  96
  97 //--------------------------------------------------
  98 bool AudioSfDecoder::getPcmFormatKeySize(uint32_t index, uint32_t* pKeySize) {
  99     if (index >= NB_PCMMETADATA_KEYS) {
 100         return false;
 101     } else {
 102         *pKeySize = strlen(kPcmDecodeMetadataKeys[index]) +1;
 103         return true;
 104     }
 105 }
 106
 107
 108 //--------------------------------------------------
 109 bool AudioSfDecoder::getPcmFormatKeyName(uint32_t index, uint32_t keySize, char* keyName) {
 110     uint32_t actualKeySize;
 111     if (!getPcmFormatKeySize(index, &actualKeySize)) {
 112         return false;
 113     }
 114     if (keySize < actualKeySize) {
 115         return false;
 116     }
 117     strncpy(keyName, kPcmDecodeMetadataKeys[index], actualKeySize);
 118     return true;
 119 }
 120
 121
 122 //--------------------------------------------------
 123 bool AudioSfDecoder::getPcmFormatValueSize(uint32_t index, uint32_t* pValueSize) {
 124     if (index >= NB_PCMMETADATA_KEYS) {
 125         *pValueSize = 0;
 126         return false;
 127     } else {
 128         *pValueSize = sizeof(uint32_t);
 129         return true;
 130     }
 131 }
 132
 133
 134 //--------------------------------------------------
 135 bool AudioSfDecoder::getPcmFormatKeyValue(uint32_t index, uint32_t size, uint32_t* pValue) {
 136     uint32_t valueSize = 0;
 137     if (!getPcmFormatValueSize(index, &valueSize)) {
 138         return false;
 139     } else if (size != valueSize) {
 140         // this ensures we are accessing mPcmFormatValues with a valid size for that index
 141         SL_LOGE("Error retrieving metadata value at index %d: using size of %d, should be %d",
 142                 index, size, valueSize);
 143         return false;
 144     } else {
 145         android::Mutex::Autolock autoLock(mPcmFormatLock);
 146         *pValue = mPcmFormatValues[index];
 147         return true;
 148     }
 149 }
 150
 151
 152 //--------------------------------------------------
 153 // Event handlers
 154 //  it is strictly verboten to call those methods outside of the event loop
 155
 156 // Initializes the data and audio sources, and update the PCM format info
 157 // post-condition: upon successful initialization based on the player data locator
 158 //    GenericPlayer::onPrepare() was called
 159 //    mDataSource != 0
 160 //    mAudioSource != 0
 161 //    mAudioSourceStarted == true
 162 // All error returns from this method are via notifyPrepared(status) followed by "return".
 163 void AudioSfDecoder::onPrepare() {
 164     SL_LOGD("AudioSfDecoder::onPrepare()");
 165     Mutex::Autolock _l(mBufferSourceLock);
 166
 167     {
 168     android::Mutex::Autolock autoLock(mPcmFormatLock);
 169     // Initialize the PCM format info with the known parameters before the start of the decode
 170     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_BITSPERSAMPLE] = SL_PCMSAMPLEFORMAT_FIXED_16;
 171     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CONTAINERSIZE] = 16;
 172     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_ENDIANNESS] = SL_BYTEORDER_LITTLEENDIAN;
 173     //    initialization with the default values: they will be replaced by the actual values
 174     //      once the decoder has figured them out
 175     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = UNKNOWN_NUMCHANNELS;
 176     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = UNKNOWN_SAMPLERATE;
 177     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] = UNKNOWN_CHANNELMASK;
 178     }
 179
 180     //---------------------------------
 181     // Instantiate and initialize the data source for the decoder
 182     sp<DataSource> dataSource;
 183
 184     switch (mDataLocatorType) {
 185
 186     case kDataLocatorNone:
 187         SL_LOGE("AudioSfDecoder::onPrepare: no data locator set");
 188         notifyPrepared(MEDIA_ERROR_BASE);
 189         return;
 190
 191     case kDataLocatorUri:
 192         dataSource = DataSource::CreateFromURI(mDataLocator.uriRef);
 193         if (dataSource == NULL) {
 194             SL_LOGE("AudioSfDecoder::onPrepare(): Error opening %s", mDataLocator.uriRef);
 195             notifyPrepared(MEDIA_ERROR_BASE);
 196             return;
 197         }
 198         break;
 199
 200     case kDataLocatorFd:
 201     {
 202         // As FileSource unconditionally takes ownership of the fd and closes it, then
 203         // we have to make a dup for FileSource if the app wants to keep ownership itself
 204         int fd = mDataLocator.fdi.fd;
 205         if (mDataLocator.fdi.mCloseAfterUse) {
 206             mDataLocator.fdi.mCloseAfterUse = false;
 207         } else {
 208             fd = ::dup(fd);
 209         }
 210         dataSource = new FileSource(fd, mDataLocator.fdi.offset, mDataLocator.fdi.length);
 211         status_t err = dataSource->initCheck();
 212         if (err != OK) {
 213             notifyPrepared(err);
 214             return;
 215         }
 216         break;
 217     }
 218
 219     // AndroidBufferQueue data source is handled by a subclass,
 220     // which does not call up to this method.  Hence, the missing case.
 221     default:
 222         TRESPASS();
 223     }
 224
 225     //---------------------------------
 226     // Instantiate and initialize the decoder attached to the data source
 227     sp<MediaExtractor> extractor = MediaExtractor::Create(dataSource);
 228     if (extractor == NULL) {
 229         SL_LOGE("AudioSfDecoder::onPrepare: Could not instantiate extractor.");
 230         notifyPrepared(ERROR_UNSUPPORTED);
 231         return;
 232     }
 233
 234     ssize_t audioTrackIndex = -1;
 235     bool isRawAudio = false;
 236     for (size_t i = 0; i < extractor->countTracks(); ++i) {
 237         sp<MetaData> meta = extractor->getTrackMetaData(i);
 238
 239         const char *mime;
 240         CHECK(meta->findCString(kKeyMIMEType, &mime));
 241
 242         if (!strncasecmp("audio/", mime, 6)) {
 243             if (isSupportedCodec(mime)) {
 244                 audioTrackIndex = i;
 245
 246                 if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_RAW, mime)) {
 247                     isRawAudio = true;
 248                 }
 249                 break;
 250             }
 251         }
 252     }
 253
 254     if (audioTrackIndex < 0) {
 255         SL_LOGE("AudioSfDecoder::onPrepare: Could not find a supported audio track.");
 256         notifyPrepared(ERROR_UNSUPPORTED);
 257         return;
 258     }
 259
 260     sp<MediaSource> source = extractor->getTrack(audioTrackIndex);
 261     sp<MetaData> meta = source->getFormat();
 262
 263     // we can't trust the OMXCodec (if there is one) to issue a INFO_FORMAT_CHANGED so we want
 264     // to have some meaningful values as soon as possible.
 265     int32_t channelCount;
 266     bool hasChannelCount = meta->findInt32(kKeyChannelCount, &channelCount);
 267     int32_t sr;
 268     bool hasSampleRate = meta->findInt32(kKeySampleRate, &sr);
 269
 270     // first compute the duration
 271     off64_t size;
 272     int64_t durationUs;
 273     int32_t durationMsec;
 274     if (dataSource->getSize(&size) == OK
 275             && meta->findInt64(kKeyDuration, &durationUs)) {
 276         if (durationUs != 0) {
 277             mBitrate = size * 8000000ll / durationUs;  // in bits/sec
 278         } else {
 279             mBitrate = -1;
 280         }
 281         mDurationUsec = durationUs;
 282         durationMsec = durationUs / 1000;
 283     } else {
 284         mBitrate = -1;
 285         mDurationUsec = ANDROID_UNKNOWN_TIME;
 286         durationMsec = ANDROID_UNKNOWN_TIME;
 287     }
 288
 289     // then assign the duration under the settings lock
 290     {
 291         Mutex::Autolock _l(mSettingsLock);
 292         mDurationMsec = durationMsec;
 293     }
 294
 295     // the audio content is not raw PCM, so we need a decoder
 296     if (!isRawAudio) {
 297         OMXClient client;
 298         CHECK_EQ(client.connect(), (status_t)OK);
 299
 300         source = OMXCodec::Create(
 301                 client.interface(), meta, false /* createEncoder */,
 302                 source);
 303
 304         if (source == NULL) {
 305             SL_LOGE("AudioSfDecoder::onPrepare: Could not instantiate decoder.");
 306             notifyPrepared(ERROR_UNSUPPORTED);
 307             return;
 308         }
 309
 310         meta = source->getFormat();
 311     }
 312
 313
 314     if (source->start() != OK) {
 315         SL_LOGE("AudioSfDecoder::onPrepare: Failed to start source/decoder.");
 316         notifyPrepared(MEDIA_ERROR_BASE);
 317         return;
 318     }
 319
 320     //---------------------------------
 321     // The data source, and audio source (a decoder if required) are ready to be used
 322     mDataSource = dataSource;
 323     mAudioSource = source;
 324     mAudioSourceStarted = true;
 325
 326     if (!hasChannelCount) {
 327         CHECK(meta->findInt32(kKeyChannelCount, &channelCount));
 328     }
 329
 330     if (!hasSampleRate) {
 331         CHECK(meta->findInt32(kKeySampleRate, &sr));
 332     }
 333     // FIXME add code below once channel mask support is in, currently initialized to default
 334     //       value computed from the channel count
 335     //    if (!hasChannelMask) {
 336     //        CHECK(meta->findInt32(kKeyChannelMask, &channelMask));
 337     //    }
 338
 339     if (!wantPrefetch()) {
 340         SL_LOGV("AudioSfDecoder::onPrepare: no need to prefetch");
 341         // doesn't need prefetching, notify good to go
 342         mCacheStatus = kStatusHigh;
 343         mCacheFill = 1000;
 344         notifyStatus();
 345         notifyCacheFill();
 346     }
 347
 348     {
 349         android::Mutex::Autolock autoLock(mPcmFormatLock);
 350         mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = sr;
 351         mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = channelCount;
 352         mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] =
 353                 channelCountToMask(channelCount);
 354     }
 355
 356     // at this point we have enough information about the source to create the sink that
 357     // will consume the data
 358     createAudioSink();
 359
 360     // signal successful completion of prepare
 361     mStateFlags |= kFlagPrepared;
 362
 363     GenericPlayer::onPrepare();
 364     SL_LOGD("AudioSfDecoder::onPrepare() done, mStateFlags=0x%x", mStateFlags);
 365 }
 366
 367
 368 void AudioSfDecoder::onPause() {
 369     SL_LOGV("AudioSfDecoder::onPause()");
 370     GenericPlayer::onPause();
 371     pauseAudioSink();
 372 }
 373
 374
 375 void AudioSfDecoder::onPlay() {
 376     SL_LOGV("AudioSfDecoder::onPlay()");
 377     GenericPlayer::onPlay();
 378     startAudioSink();
 379 }
 380
 381
 382 void AudioSfDecoder::onSeek(const sp<AMessage> &msg) {
 383     SL_LOGV("AudioSfDecoder::onSeek");
 384     int64_t timeMsec;
 385     CHECK(msg->findInt64(WHATPARAM_SEEK_SEEKTIME_MS, &timeMsec));
 386
 387     Mutex::Autolock _l(mTimeLock);
 388     mStateFlags |= kFlagSeeking;
 389     mSeekTimeMsec = timeMsec;
 390     // don't set mLastDecodedPositionUs to ANDROID_UNKNOWN_TIME; getPositionUsec
 391     // ignores mLastDecodedPositionUs while seeking, and substitutes the seek goal instead
 392
 393     // nop for now
 394     GenericPlayer::onSeek(msg);
 395 }
 396
 397
 398 void AudioSfDecoder::onLoop(const sp<AMessage> &msg) {
 399     SL_LOGV("AudioSfDecoder::onLoop");
 400     int32_t loop;
 401     CHECK(msg->findInt32(WHATPARAM_LOOP_LOOPING, &loop));
 402
 403     if (loop) {
 404         //SL_LOGV("AudioSfDecoder::onLoop start looping");
 405         mStateFlags |= kFlagLooping;
 406     } else {
 407         //SL_LOGV("AudioSfDecoder::onLoop stop looping");
 408         mStateFlags &= ~kFlagLooping;
 409     }
 410
 411     // nop for now
 412     GenericPlayer::onLoop(msg);
 413 }
 414
 415
 416 void AudioSfDecoder::onCheckCache(const sp<AMessage> &msg) {
 417     //SL_LOGV("AudioSfDecoder::onCheckCache");
 418     bool eos;
 419     CacheStatus_t status = getCacheRemaining(&eos);
 420
 421     if (eos || status == kStatusHigh
 422             || ((mStateFlags & kFlagPreparing) && (status >= kStatusEnough))) {
 423         if (mStateFlags & kFlagPlaying) {
 424             startAudioSink();
 425         }
 426         mStateFlags &= ~kFlagBuffering;
 427
 428         SL_LOGV("AudioSfDecoder::onCheckCache: buffering done.");
 429
 430         if (mStateFlags & kFlagPreparing) {
 431             //SL_LOGV("AudioSfDecoder::onCheckCache: preparation done.");
 432             mStateFlags &= ~kFlagPreparing;
 433         }
 434
 435         if (mStateFlags & kFlagPlaying) {
 436             (new AMessage(kWhatDecode, id()))->post();
 437         }
 438         return;
 439     }
 440
 441     msg->post(100000);
 442 }
 443
 444
 445 void AudioSfDecoder::onDecode() {
 446     SL_LOGV("AudioSfDecoder::onDecode");
 447
 448     //-------------------------------- Need to buffer some more before decoding?
 449     bool eos;
 450     if (mDataSource == 0) {
 451         // application set play state to paused which failed, then set play state to playing
 452         return;
 453     }
 454
 455     if (wantPrefetch()
 456             && (getCacheRemaining(&eos) == kStatusLow)
 457             && !eos) {
 458         SL_LOGV("buffering more.");
 459
 460         if (mStateFlags & kFlagPlaying) {
 461             pauseAudioSink();
 462         }
 463         mStateFlags |= kFlagBuffering;
 464         (new AMessage(kWhatCheckCache, id()))->post(100000);
 465         return;
 466     }
 467
 468     if (!(mStateFlags & (kFlagPlaying | kFlagBuffering | kFlagPreparing))) {
 469         // don't decode if we're not buffering, prefetching or playing
 470         //SL_LOGV("don't decode: not buffering, prefetching or playing");
 471         return;
 472     }
 473
 474     //-------------------------------- Decode
 475     status_t err;
 476     MediaSource::ReadOptions readOptions;
 477     if (mStateFlags & kFlagSeeking) {
 478         assert(mSeekTimeMsec != ANDROID_UNKNOWN_TIME);
 479         readOptions.setSeekTo(mSeekTimeMsec * 1000);
 480     }
 481
 482     int64_t timeUsec = ANDROID_UNKNOWN_TIME;
 483     {
 484         Mutex::Autolock _l(mBufferSourceLock);
 485
 486         if (NULL != mDecodeBuffer) {
 487             // the current decoded buffer hasn't been rendered, drop it
 488             mDecodeBuffer->release();
 489             mDecodeBuffer = NULL;
 490         }
 491         if(!mAudioSourceStarted) {
 492             return;
 493         }
 494         err = mAudioSource->read(&mDecodeBuffer, &readOptions);
 495         if (err == OK) {
 496             // FIXME workaround apparent bug in AAC decoder: kKeyTime is 3 frames old if length is 0
 497             if (mDecodeBuffer->range_length() == 0) {
 498                 timeUsec = ANDROID_UNKNOWN_TIME;
 499             } else {
 500                 CHECK(mDecodeBuffer->meta_data()->findInt64(kKeyTime, &timeUsec));
 501             }
 502         } else {
 503             // errors are handled below
 504         }
 505     }
 506
 507     {
 508         Mutex::Autolock _l(mTimeLock);
 509         if (mStateFlags & kFlagSeeking) {
 510             mStateFlags &= ~kFlagSeeking;
 511             mSeekTimeMsec = ANDROID_UNKNOWN_TIME;
 512         }
 513         if (timeUsec != ANDROID_UNKNOWN_TIME) {
 514             // Note that though we've decoded this position, we haven't rendered it yet.
 515             // So a GetPosition called after this point will observe the advanced position,
 516             // even though the PCM may not have been supplied to the sink.  That's OK as
 517             // we don't claim to provide AAC frame-accurate (let alone sample-accurate) GetPosition.
 518             mLastDecodedPositionUs = timeUsec;
 519         }
 520     }
 521
 522     //-------------------------------- Handle return of decode
 523     if (err != OK) {
 524         bool continueDecoding = false;
 525         switch(err) {
 526             case ERROR_END_OF_STREAM:
 527                 if (0 < mDurationUsec) {
 528                     Mutex::Autolock _l(mTimeLock);
 529                     mLastDecodedPositionUs = mDurationUsec;
 530                 }
 531                 // handle notification and looping at end of stream
 532                 if (mStateFlags & kFlagPlaying) {
 533                     notify(PLAYEREVENT_ENDOFSTREAM, 1, true /*async*/);
 534                 }
 535                 if (mStateFlags & kFlagLooping) {
 536                     seek(0);
 537                     // kick-off decoding again
 538                     continueDecoding = true;
 539                 }
 540                 break;
 541             case INFO_FORMAT_CHANGED:
 542                 SL_LOGD("MediaSource::read encountered INFO_FORMAT_CHANGED");
 543                 // reconfigure output
 544                 {
 545                     Mutex::Autolock _l(mBufferSourceLock);
 546                     hasNewDecodeParams();
 547                 }
 548                 continueDecoding = true;
 549                 break;
 550             case INFO_DISCONTINUITY:
 551                 SL_LOGD("MediaSource::read encountered INFO_DISCONTINUITY");
 552                 continueDecoding = true;
 553                 break;
 554             default:
 555                 SL_LOGE("MediaSource::read returned error %d", err);
 556                 break;
 557         }
 558         if (continueDecoding) {
 559             if (NULL == mDecodeBuffer) {
 560                 (new AMessage(kWhatDecode, id()))->post();
 561                 return;
 562             }
 563         } else {
 564             return;
 565         }
 566     }
 567
 568     //-------------------------------- Render
 569     sp<AMessage> msg = new AMessage(kWhatRender, id());
 570     msg->post();
 571
 572 }
 573
 574
 575 void AudioSfDecoder::onMessageReceived(const sp<AMessage> &msg) {
 576     switch (msg->what()) {
 577         case kWhatDecode:
 578             onDecode();
 579             break;
 580
 581         case kWhatRender:
 582             onRender();
 583             break;
 584
 585         case kWhatCheckCache:
 586             onCheckCache(msg);
 587             break;
 588
 589         default:
 590             GenericPlayer::onMessageReceived(msg);
 591             break;
 592     }
 593 }
 594
 595 //--------------------------------------------------
 596 // Prepared state, prefetch status notifications
 597 void AudioSfDecoder::notifyPrepared(status_t prepareRes) {
 598     assert(!(mStateFlags & (kFlagPrepared | kFlagPreparedUnsuccessfully)));
 599     if (NO_ERROR == prepareRes) {
 600         // The "then" fork is not currently used, but is kept here to make it easier
 601         // to replace by a new signalPrepareCompletion(status) if we re-visit this later.
 602         mStateFlags |= kFlagPrepared;
 603     } else {
 604         mStateFlags |= kFlagPreparedUnsuccessfully;
 605     }
 606     // Do not call the superclass onPrepare to notify, because it uses a default error
 607     // status code but we can provide a more specific one.
 608     // GenericPlayer::onPrepare();
 609     notify(PLAYEREVENT_PREPARED, (int32_t)prepareRes, true /*async*/);
 610     SL_LOGD("AudioSfDecoder::onPrepare() done, mStateFlags=0x%x", mStateFlags);
 611 }
 612
 613
 614 void AudioSfDecoder::onNotify(const sp<AMessage> &msg) {
 615     notif_cbf_t notifyClient;
 616     void*       notifyUser;
 617     {
 618         android::Mutex::Autolock autoLock(mNotifyClientLock);
 619         if (NULL == mNotifyClient) {
 620             return;
 621         } else {
 622             notifyClient = mNotifyClient;
 623             notifyUser   = mNotifyUser;
 624         }
 625     }
 626     int32_t val;
 627     if (msg->findInt32(PLAYEREVENT_PREFETCHSTATUSCHANGE, &val)) {
 628         SL_LOGV("\tASfPlayer notifying %s = %d", PLAYEREVENT_PREFETCHSTATUSCHANGE, val);
 629         notifyClient(kEventPrefetchStatusChange, val, 0, notifyUser);
 630     }
 631     else if (msg->findInt32(PLAYEREVENT_PREFETCHFILLLEVELUPDATE, &val)) {
 632         SL_LOGV("\tASfPlayer notifying %s = %d", PLAYEREVENT_PREFETCHFILLLEVELUPDATE, val);
 633         notifyClient(kEventPrefetchFillLevelUpdate, val, 0, notifyUser);
 634     }
 635     else if (msg->findInt32(PLAYEREVENT_ENDOFSTREAM, &val)) {
 636         SL_LOGV("\tASfPlayer notifying %s = %d", PLAYEREVENT_ENDOFSTREAM, val);
 637         notifyClient(kEventEndOfStream, val, 0, notifyUser);
 638     }
 639     else {
 640         GenericPlayer::onNotify(msg);
 641     }
 642 }
 643
 644
 645 //--------------------------------------------------
 646 // Private utility functions
 647
 648 bool AudioSfDecoder::wantPrefetch() {
 649     if (mDataSource != 0) {
 650         return (mDataSource->flags() & DataSource::kWantsPrefetching);
 651     } else {
 652         // happens if an improper data locator was passed, if the media extractor couldn't be
 653         //  initialized, if there is no audio track in the media, if the OMX decoder couldn't be
 654         //  instantiated, if the source couldn't be opened, or if the MediaSource
 655         //  couldn't be started
 656         SL_LOGV("AudioSfDecoder::wantPrefetch() tries to access NULL mDataSource");
 657         return false;
 658     }
 659 }
 660
 661
 662 int64_t AudioSfDecoder::getPositionUsec() {
 663     Mutex::Autolock _l(mTimeLock);
 664     if (mStateFlags & kFlagSeeking) {
 665         return mSeekTimeMsec * 1000;
 666     } else {
 667         return mLastDecodedPositionUs;
 668     }
 669 }
 670
 671
 672 CacheStatus_t AudioSfDecoder::getCacheRemaining(bool *eos) {
 673     sp<NuCachedSource2> cachedSource =
 674         static_cast<NuCachedSource2 *>(mDataSource.get());
 675
 676     CacheStatus_t oldStatus = mCacheStatus;
 677
 678     status_t finalStatus;
 679     size_t dataRemaining = cachedSource->approxDataRemaining(&finalStatus);
 680     *eos = (finalStatus != OK);
 681
 682     CHECK_GE(mBitrate, 0);
 683
 684     int64_t dataRemainingUs = dataRemaining * 8000000ll / mBitrate;
 685     //SL_LOGV("AudioSfDecoder::getCacheRemaining: approx %.2f secs remaining (eos=%d)",
 686     //       dataRemainingUs / 1E6, *eos);
 687
 688     if (*eos) {
 689         // data is buffered up to the end of the stream, it can't get any better than this
 690         mCacheStatus = kStatusHigh;
 691         mCacheFill = 1000;
 692
 693     } else {
 694         if (mDurationUsec > 0) {
 695             // known duration:
 696
 697             //   fill level is ratio of how much has been played + how much is
 698             //   cached, divided by total duration
 699             uint32_t currentPositionUsec = getPositionUsec();
 700             if (currentPositionUsec == ANDROID_UNKNOWN_TIME) {
 701                 // if we don't know where we are, assume the worst for the fill ratio
 702                 currentPositionUsec = 0;
 703             }
 704             if (mDurationUsec > 0) {
 705                 mCacheFill = (int16_t) ((1000.0
 706                         * (double)(currentPositionUsec + dataRemainingUs) / mDurationUsec));
 707             } else {
 708                 mCacheFill = 0;
 709             }
 710             //SL_LOGV("cacheFill = %d", mCacheFill);
 711
 712             //   cache status is evaluated against duration thresholds
 713             if (dataRemainingUs > DURATION_CACHED_HIGH_MS*1000) {
 714                 mCacheStatus = kStatusHigh;
 715                 //ALOGV("high");
 716             } else if (dataRemainingUs > DURATION_CACHED_MED_MS*1000) {
 717                 //ALOGV("enough");
 718                 mCacheStatus = kStatusEnough;
 719             } else if (dataRemainingUs < DURATION_CACHED_LOW_MS*1000) {
 720                 //ALOGV("low");
 721                 mCacheStatus = kStatusLow;
 722             } else {
 723                 mCacheStatus = kStatusIntermediate;
 724             }
 725
 726         } else {
 727             // unknown duration:
 728
 729             //   cache status is evaluated against cache amount thresholds
 730             //   (no duration so we don't have the bitrate either, could be derived from format?)
 731             if (dataRemaining > SIZE_CACHED_HIGH_BYTES) {
 732                 mCacheStatus = kStatusHigh;
 733             } else if (dataRemaining > SIZE_CACHED_MED_BYTES) {
 734                 mCacheStatus = kStatusEnough;
 735             } else if (dataRemaining < SIZE_CACHED_LOW_BYTES) {
 736                 mCacheStatus = kStatusLow;
 737             } else {
 738                 mCacheStatus = kStatusIntermediate;
 739             }
 740         }
 741
 742     }
 743
 744     if (oldStatus != mCacheStatus) {
 745         notifyStatus();
 746     }
 747
 748     if (abs(mCacheFill - mLastNotifiedCacheFill) > mCacheFillNotifThreshold) {
 749         notifyCacheFill();
 750     }
 751
 752     return mCacheStatus;
 753 }
 754
 755
 756 void AudioSfDecoder::hasNewDecodeParams() {
 757
 758     if ((mAudioSource != 0) && mAudioSourceStarted) {
 759         sp<MetaData> meta = mAudioSource->getFormat();
 760
 761         int32_t channelCount;
 762         CHECK(meta->findInt32(kKeyChannelCount, &channelCount));
 763         int32_t sr;
 764         CHECK(meta->findInt32(kKeySampleRate, &sr));
 765
 766         // FIXME similar to onPrepare()
 767         {
 768             android::Mutex::Autolock autoLock(mPcmFormatLock);
 769             SL_LOGV("format changed: old sr=%d, channels=%d; new sr=%d, channels=%d",
 770                     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE],
 771                     mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS],
 772                     sr, channelCount);
 773             mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_NUMCHANNELS] = channelCount;
 774             mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_SAMPLERATE] = sr;
 775             mPcmFormatValues[ANDROID_KEY_INDEX_PCMFORMAT_CHANNELMASK] =
 776                     channelCountToMask(channelCount);
 777         }
 778         // there's no need to do a notify of PLAYEREVENT_CHANNEL_COUNT,
 779         // because the only listener is for volume updates, and decoders don't support that
 780     }
 781
 782     // alert users of those params
 783     updateAudioSink();
 784 }
 785
 786 static const char* const kPlaybackOnlyCodecs[] = { MEDIA_MIMETYPE_AUDIO_AMR_NB,
 787         MEDIA_MIMETYPE_AUDIO_AMR_WB };
 788 #define NB_PLAYBACK_ONLY_CODECS (sizeof(kPlaybackOnlyCodecs)/sizeof(kPlaybackOnlyCodecs[0]))
 789
 790 bool AudioSfDecoder::isSupportedCodec(const char* mime) {
 791     bool codecRequiresPermission = false;
 792     for (unsigned int i = 0 ; i < NB_PLAYBACK_ONLY_CODECS ; i++) {
 793         if (!strcasecmp(mime, kPlaybackOnlyCodecs[i])) {
 794             codecRequiresPermission = true;
 795             break;
 796         }
 797     }
 798     if (codecRequiresPermission) {
 799         // verify only the system can decode, for playback only
 800         return checkCallingPermission(
 801                 String16("android.permission.ALLOW_ANY_CODEC_FOR_PLAYBACK"));
 802     } else {
 803         return true;
 804     }
 805 }
 806
 807 } // namespace android