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