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