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