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 //--------------------------------------------------------------------------------------------------
AudioSfDecoder(const AudioPlayback_Parameters * params)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
~AudioSfDecoder()47 AudioSfDecoder::~AudioSfDecoder() {
48 SL_LOGD("AudioSfDecoder::~AudioSfDecoder()");
49 }
50
51
preDestroy()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 //--------------------------------------------------
play()72 void AudioSfDecoder::play() {
73 SL_LOGD("AudioSfDecoder::play");
74
75 GenericPlayer::play();
76 (new AMessage(kWhatDecode, id()))->post();
77 }
78
79
getPositionMsec(int * msec)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 //--------------------------------------------------
getPcmFormatKeyCount() const91 uint32_t AudioSfDecoder::getPcmFormatKeyCount() const {
92 return NB_PCMMETADATA_KEYS;
93 }
94
95
96 //--------------------------------------------------
getPcmFormatKeySize(uint32_t index,uint32_t * pKeySize)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 //--------------------------------------------------
getPcmFormatKeyName(uint32_t index,uint32_t keySize,char * keyName)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 //--------------------------------------------------
getPcmFormatValueSize(uint32_t index,uint32_t * pValueSize)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 //--------------------------------------------------
getPcmFormatKeyValue(uint32_t index,uint32_t size,uint32_t * pValue)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".
onPrepare()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
onPause()357 void AudioSfDecoder::onPause() {
358 SL_LOGV("AudioSfDecoder::onPause()");
359 GenericPlayer::onPause();
360 pauseAudioSink();
361 }
362
363
onPlay()364 void AudioSfDecoder::onPlay() {
365 SL_LOGV("AudioSfDecoder::onPlay()");
366 GenericPlayer::onPlay();
367 startAudioSink();
368 }
369
370
onSeek(const sp<AMessage> & msg)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
onLoop(const sp<AMessage> & msg)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
onCheckCache(const sp<AMessage> & msg)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
onDecode()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
onMessageReceived(const sp<AMessage> & msg)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
notifyPrepared(status_t prepareRes)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
onNotify(const sp<AMessage> & msg)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
wantPrefetch()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
getPositionUsec()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
getCacheRemaining(bool * eos)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
hasNewDecodeParams()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
isSupportedCodec(const char * mime)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