NuPlayer.cpp revision 7e34bf5af26f8752d4786d3098740cdf51e2438f 
1/*
2 * Copyright (C) 2010 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 LOG_NDEBUG 0
18#define LOG_TAG "NuPlayer"
19#include <utils/Log.h>
20
21#include "NuPlayer.h"
22
23#include "HTTPLiveSource.h"
24#include "NuPlayerCCDecoder.h"
25#include "NuPlayerDecoder.h"
26#include "NuPlayerDecoderBase.h"
27#include "NuPlayerDecoderPassThrough.h"
28#include "NuPlayerDriver.h"
29#include "NuPlayerRenderer.h"
30#include "NuPlayerSource.h"
31#include "RTSPSource.h"
32#include "StreamingSource.h"
33#include "GenericSource.h"
34#include "TextDescriptions.h"
35
36#include "ATSParser.h"
37
38#include <cutils/properties.h>
39
40#include <media/AudioResamplerPublic.h>
41#include <media/AVSyncSettings.h>
42#include <media/MediaCodecBuffer.h>
43
44#include <media/stagefright/foundation/hexdump.h>
45#include <media/stagefright/foundation/ABuffer.h>
46#include <media/stagefright/foundation/ADebug.h>
47#include <media/stagefright/foundation/AMessage.h>
48#include <media/stagefright/MediaBuffer.h>
49#include <media/stagefright/MediaDefs.h>
50#include <media/stagefright/MediaErrors.h>
51#include <media/stagefright/MetaData.h>
52
53#include <gui/IGraphicBufferProducer.h>
54#include <gui/Surface.h>
55
56#include "avc_utils.h"
57
58#include "ESDS.h"
59#include <media/stagefright/Utils.h>
60
61namespace android {
62
63struct NuPlayer::Action : public RefBase {
64    Action() {}
65
66    virtual void execute(NuPlayer *player) = 0;
67
68private:
69    DISALLOW_EVIL_CONSTRUCTORS(Action);
70};
71
72struct NuPlayer::SeekAction : public Action {
73    explicit SeekAction(int64_t seekTimeUs)
74        : mSeekTimeUs(seekTimeUs) {
75    }
76
77    virtual void execute(NuPlayer *player) {
78        player->performSeek(mSeekTimeUs);
79    }
80
81private:
82    int64_t mSeekTimeUs;
83
84    DISALLOW_EVIL_CONSTRUCTORS(SeekAction);
85};
86
87struct NuPlayer::ResumeDecoderAction : public Action {
88    explicit ResumeDecoderAction(bool needNotify)
89        : mNeedNotify(needNotify) {
90    }
91
92    virtual void execute(NuPlayer *player) {
93        player->performResumeDecoders(mNeedNotify);
94    }
95
96private:
97    bool mNeedNotify;
98
99    DISALLOW_EVIL_CONSTRUCTORS(ResumeDecoderAction);
100};
101
102struct NuPlayer::SetSurfaceAction : public Action {
103    explicit SetSurfaceAction(const sp<Surface> &surface)
104        : mSurface(surface) {
105    }
106
107    virtual void execute(NuPlayer *player) {
108        player->performSetSurface(mSurface);
109    }
110
111private:
112    sp<Surface> mSurface;
113
114    DISALLOW_EVIL_CONSTRUCTORS(SetSurfaceAction);
115};
116
117struct NuPlayer::FlushDecoderAction : public Action {
118    FlushDecoderAction(FlushCommand audio, FlushCommand video)
119        : mAudio(audio),
120          mVideo(video) {
121    }
122
123    virtual void execute(NuPlayer *player) {
124        player->performDecoderFlush(mAudio, mVideo);
125    }
126
127private:
128    FlushCommand mAudio;
129    FlushCommand mVideo;
130
131    DISALLOW_EVIL_CONSTRUCTORS(FlushDecoderAction);
132};
133
134struct NuPlayer::PostMessageAction : public Action {
135    explicit PostMessageAction(const sp<AMessage> &msg)
136        : mMessage(msg) {
137    }
138
139    virtual void execute(NuPlayer *) {
140        mMessage->post();
141    }
142
143private:
144    sp<AMessage> mMessage;
145
146    DISALLOW_EVIL_CONSTRUCTORS(PostMessageAction);
147};
148
149// Use this if there's no state necessary to save in order to execute
150// the action.
151struct NuPlayer::SimpleAction : public Action {
152    typedef void (NuPlayer::*ActionFunc)();
153
154    explicit SimpleAction(ActionFunc func)
155        : mFunc(func) {
156    }
157
158    virtual void execute(NuPlayer *player) {
159        (player->*mFunc)();
160    }
161
162private:
163    ActionFunc mFunc;
164
165    DISALLOW_EVIL_CONSTRUCTORS(SimpleAction);
166};
167
168////////////////////////////////////////////////////////////////////////////////
169
170NuPlayer::NuPlayer(pid_t pid)
171    : mUIDValid(false),
172      mPID(pid),
173      mSourceFlags(0),
174      mOffloadAudio(false),
175      mAudioDecoderGeneration(0),
176      mVideoDecoderGeneration(0),
177      mRendererGeneration(0),
178      mPreviousSeekTimeUs(0),
179      mAudioEOS(false),
180      mVideoEOS(false),
181      mScanSourcesPending(false),
182      mScanSourcesGeneration(0),
183      mPollDurationGeneration(0),
184      mTimedTextGeneration(0),
185      mFlushingAudio(NONE),
186      mFlushingVideo(NONE),
187      mResumePending(false),
188      mVideoScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW),
189      mPlaybackSettings(AUDIO_PLAYBACK_RATE_DEFAULT),
190      mVideoFpsHint(-1.f),
191      mStarted(false),
192      mPrepared(false),
193      mResetting(false),
194      mSourceStarted(false),
195      mPaused(false),
196      mPausedByClient(true),
197      mPausedForBuffering(false) {
198    clearFlushComplete();
199}
200
201NuPlayer::~NuPlayer() {
202}
203
204void NuPlayer::setUID(uid_t uid) {
205    mUIDValid = true;
206    mUID = uid;
207}
208
209void NuPlayer::setDriver(const wp<NuPlayerDriver> &driver) {
210    mDriver = driver;
211}
212
213void NuPlayer::setDataSourceAsync(const sp<IStreamSource> &source) {
214    sp<AMessage> msg = new AMessage(kWhatSetDataSource, this);
215
216    sp<AMessage> notify = new AMessage(kWhatSourceNotify, this);
217
218    msg->setObject("source", new StreamingSource(notify, source));
219    msg->post();
220}
221
222static bool IsHTTPLiveURL(const char *url) {
223    if (!strncasecmp("http://", url, 7)
224            || !strncasecmp("https://", url, 8)
225            || !strncasecmp("file://", url, 7)) {
226        size_t len = strlen(url);
227        if (len >= 5 && !strcasecmp(".m3u8", &url[len - 5])) {
228            return true;
229        }
230
231        if (strstr(url,"m3u8")) {
232            return true;
233        }
234    }
235
236    return false;
237}
238
239void NuPlayer::setDataSourceAsync(
240        const sp<IMediaHTTPService> &httpService,
241        const char *url,
242        const KeyedVector<String8, String8> *headers) {
243
244    sp<AMessage> msg = new AMessage(kWhatSetDataSource, this);
245    size_t len = strlen(url);
246
247    sp<AMessage> notify = new AMessage(kWhatSourceNotify, this);
248
249    sp<Source> source;
250    if (IsHTTPLiveURL(url)) {
251        source = new HTTPLiveSource(notify, httpService, url, headers);
252    } else if (!strncasecmp(url, "rtsp://", 7)) {
253        source = new RTSPSource(
254                notify, httpService, url, headers, mUIDValid, mUID);
255    } else if ((!strncasecmp(url, "http://", 7)
256                || !strncasecmp(url, "https://", 8))
257                    && ((len >= 4 && !strcasecmp(".sdp", &url[len - 4]))
258                    || strstr(url, ".sdp?"))) {
259        source = new RTSPSource(
260                notify, httpService, url, headers, mUIDValid, mUID, true);
261    } else {
262        sp<GenericSource> genericSource =
263                new GenericSource(notify, mUIDValid, mUID);
264        // Don't set FLAG_SECURE on mSourceFlags here for widevine.
265        // The correct flags will be updated in Source::kWhatFlagsChanged
266        // handler when  GenericSource is prepared.
267
268        status_t err = genericSource->setDataSource(httpService, url, headers);
269
270        if (err == OK) {
271            source = genericSource;
272        } else {
273            ALOGE("Failed to set data source!");
274        }
275    }
276    msg->setObject("source", source);
277    msg->post();
278}
279
280void NuPlayer::setDataSourceAsync(int fd, int64_t offset, int64_t length) {
281    sp<AMessage> msg = new AMessage(kWhatSetDataSource, this);
282
283    sp<AMessage> notify = new AMessage(kWhatSourceNotify, this);
284
285    sp<GenericSource> source =
286            new GenericSource(notify, mUIDValid, mUID);
287
288    status_t err = source->setDataSource(fd, offset, length);
289
290    if (err != OK) {
291        ALOGE("Failed to set data source!");
292        source = NULL;
293    }
294
295    msg->setObject("source", source);
296    msg->post();
297}
298
299void NuPlayer::setDataSourceAsync(const sp<DataSource> &dataSource) {
300    sp<AMessage> msg = new AMessage(kWhatSetDataSource, this);
301    sp<AMessage> notify = new AMessage(kWhatSourceNotify, this);
302
303    sp<GenericSource> source = new GenericSource(notify, mUIDValid, mUID);
304    status_t err = source->setDataSource(dataSource);
305
306    if (err != OK) {
307        ALOGE("Failed to set data source!");
308        source = NULL;
309    }
310
311    msg->setObject("source", source);
312    msg->post();
313}
314
315void NuPlayer::prepareAsync() {
316    (new AMessage(kWhatPrepare, this))->post();
317}
318
319void NuPlayer::setVideoSurfaceTextureAsync(
320        const sp<IGraphicBufferProducer> &bufferProducer) {
321    sp<AMessage> msg = new AMessage(kWhatSetVideoSurface, this);
322
323    if (bufferProducer == NULL) {
324        msg->setObject("surface", NULL);
325    } else {
326        msg->setObject("surface", new Surface(bufferProducer, true /* controlledByApp */));
327    }
328
329    msg->post();
330}
331
332void NuPlayer::setAudioSink(const sp<MediaPlayerBase::AudioSink> &sink) {
333    sp<AMessage> msg = new AMessage(kWhatSetAudioSink, this);
334    msg->setObject("sink", sink);
335    msg->post();
336}
337
338void NuPlayer::start() {
339    (new AMessage(kWhatStart, this))->post();
340}
341
342status_t NuPlayer::setPlaybackSettings(const AudioPlaybackRate &rate) {
343    // do some cursory validation of the settings here. audio modes are
344    // only validated when set on the audiosink.
345     if ((rate.mSpeed != 0.f && rate.mSpeed < AUDIO_TIMESTRETCH_SPEED_MIN)
346            || rate.mSpeed > AUDIO_TIMESTRETCH_SPEED_MAX
347            || rate.mPitch < AUDIO_TIMESTRETCH_SPEED_MIN
348            || rate.mPitch > AUDIO_TIMESTRETCH_SPEED_MAX) {
349        return BAD_VALUE;
350    }
351    sp<AMessage> msg = new AMessage(kWhatConfigPlayback, this);
352    writeToAMessage(msg, rate);
353    sp<AMessage> response;
354    status_t err = msg->postAndAwaitResponse(&response);
355    if (err == OK && response != NULL) {
356        CHECK(response->findInt32("err", &err));
357    }
358    return err;
359}
360
361status_t NuPlayer::getPlaybackSettings(AudioPlaybackRate *rate /* nonnull */) {
362    sp<AMessage> msg = new AMessage(kWhatGetPlaybackSettings, this);
363    sp<AMessage> response;
364    status_t err = msg->postAndAwaitResponse(&response);
365    if (err == OK && response != NULL) {
366        CHECK(response->findInt32("err", &err));
367        if (err == OK) {
368            readFromAMessage(response, rate);
369        }
370    }
371    return err;
372}
373
374status_t NuPlayer::setSyncSettings(const AVSyncSettings &sync, float videoFpsHint) {
375    sp<AMessage> msg = new AMessage(kWhatConfigSync, this);
376    writeToAMessage(msg, sync, videoFpsHint);
377    sp<AMessage> response;
378    status_t err = msg->postAndAwaitResponse(&response);
379    if (err == OK && response != NULL) {
380        CHECK(response->findInt32("err", &err));
381    }
382    return err;
383}
384
385status_t NuPlayer::getSyncSettings(
386        AVSyncSettings *sync /* nonnull */, float *videoFps /* nonnull */) {
387    sp<AMessage> msg = new AMessage(kWhatGetSyncSettings, this);
388    sp<AMessage> response;
389    status_t err = msg->postAndAwaitResponse(&response);
390    if (err == OK && response != NULL) {
391        CHECK(response->findInt32("err", &err));
392        if (err == OK) {
393            readFromAMessage(response, sync, videoFps);
394        }
395    }
396    return err;
397}
398
399void NuPlayer::pause() {
400    (new AMessage(kWhatPause, this))->post();
401}
402
403void NuPlayer::resetAsync() {
404    sp<Source> source;
405    {
406        Mutex::Autolock autoLock(mSourceLock);
407        source = mSource;
408    }
409
410    if (source != NULL) {
411        // During a reset, the data source might be unresponsive already, we need to
412        // disconnect explicitly so that reads exit promptly.
413        // We can't queue the disconnect request to the looper, as it might be
414        // queued behind a stuck read and never gets processed.
415        // Doing a disconnect outside the looper to allows the pending reads to exit
416        // (either successfully or with error).
417        source->disconnect();
418    }
419
420    (new AMessage(kWhatReset, this))->post();
421}
422
423void NuPlayer::seekToAsync(int64_t seekTimeUs, bool needNotify) {
424    sp<AMessage> msg = new AMessage(kWhatSeek, this);
425    msg->setInt64("seekTimeUs", seekTimeUs);
426    msg->setInt32("needNotify", needNotify);
427    msg->post();
428}
429
430
431void NuPlayer::writeTrackInfo(
432        Parcel* reply, const sp<AMessage>& format) const {
433    if (format == NULL) {
434        ALOGE("NULL format");
435        return;
436    }
437    int32_t trackType;
438    if (!format->findInt32("type", &trackType)) {
439        ALOGE("no track type");
440        return;
441    }
442
443    AString mime;
444    if (!format->findString("mime", &mime)) {
445        // Java MediaPlayer only uses mimetype for subtitle and timedtext tracks.
446        // If we can't find the mimetype here it means that we wouldn't be needing
447        // the mimetype on the Java end. We still write a placeholder mime to keep the
448        // (de)serialization logic simple.
449        if (trackType == MEDIA_TRACK_TYPE_AUDIO) {
450            mime = "audio/";
451        } else if (trackType == MEDIA_TRACK_TYPE_VIDEO) {
452            mime = "video/";
453        } else {
454            ALOGE("unknown track type: %d", trackType);
455            return;
456        }
457    }
458
459    AString lang;
460    if (!format->findString("language", &lang)) {
461        ALOGE("no language");
462        return;
463    }
464
465    reply->writeInt32(2); // write something non-zero
466    reply->writeInt32(trackType);
467    reply->writeString16(String16(mime.c_str()));
468    reply->writeString16(String16(lang.c_str()));
469
470    if (trackType == MEDIA_TRACK_TYPE_SUBTITLE) {
471        int32_t isAuto, isDefault, isForced;
472        CHECK(format->findInt32("auto", &isAuto));
473        CHECK(format->findInt32("default", &isDefault));
474        CHECK(format->findInt32("forced", &isForced));
475
476        reply->writeInt32(isAuto);
477        reply->writeInt32(isDefault);
478        reply->writeInt32(isForced);
479    }
480}
481
482void NuPlayer::onMessageReceived(const sp<AMessage> &msg) {
483    switch (msg->what()) {
484        case kWhatSetDataSource:
485        {
486            ALOGV("kWhatSetDataSource");
487
488            CHECK(mSource == NULL);
489
490            status_t err = OK;
491            sp<RefBase> obj;
492            CHECK(msg->findObject("source", &obj));
493            if (obj != NULL) {
494                Mutex::Autolock autoLock(mSourceLock);
495                mSource = static_cast<Source *>(obj.get());
496            } else {
497                err = UNKNOWN_ERROR;
498            }
499
500            CHECK(mDriver != NULL);
501            sp<NuPlayerDriver> driver = mDriver.promote();
502            if (driver != NULL) {
503                driver->notifySetDataSourceCompleted(err);
504            }
505            break;
506        }
507
508        case kWhatPrepare:
509        {
510            mSource->prepareAsync();
511            break;
512        }
513
514        case kWhatGetTrackInfo:
515        {
516            sp<AReplyToken> replyID;
517            CHECK(msg->senderAwaitsResponse(&replyID));
518
519            Parcel* reply;
520            CHECK(msg->findPointer("reply", (void**)&reply));
521
522            size_t inbandTracks = 0;
523            if (mSource != NULL) {
524                inbandTracks = mSource->getTrackCount();
525            }
526
527            size_t ccTracks = 0;
528            if (mCCDecoder != NULL) {
529                ccTracks = mCCDecoder->getTrackCount();
530            }
531
532            // total track count
533            reply->writeInt32(inbandTracks + ccTracks);
534
535            // write inband tracks
536            for (size_t i = 0; i < inbandTracks; ++i) {
537                writeTrackInfo(reply, mSource->getTrackInfo(i));
538            }
539
540            // write CC track
541            for (size_t i = 0; i < ccTracks; ++i) {
542                writeTrackInfo(reply, mCCDecoder->getTrackInfo(i));
543            }
544
545            sp<AMessage> response = new AMessage;
546            response->postReply(replyID);
547            break;
548        }
549
550        case kWhatGetSelectedTrack:
551        {
552            status_t err = INVALID_OPERATION;
553            if (mSource != NULL) {
554                err = OK;
555
556                int32_t type32;
557                CHECK(msg->findInt32("type", (int32_t*)&type32));
558                media_track_type type = (media_track_type)type32;
559                ssize_t selectedTrack = mSource->getSelectedTrack(type);
560
561                Parcel* reply;
562                CHECK(msg->findPointer("reply", (void**)&reply));
563                reply->writeInt32(selectedTrack);
564            }
565
566            sp<AMessage> response = new AMessage;
567            response->setInt32("err", err);
568
569            sp<AReplyToken> replyID;
570            CHECK(msg->senderAwaitsResponse(&replyID));
571            response->postReply(replyID);
572            break;
573        }
574
575        case kWhatSelectTrack:
576        {
577            sp<AReplyToken> replyID;
578            CHECK(msg->senderAwaitsResponse(&replyID));
579
580            size_t trackIndex;
581            int32_t select;
582            int64_t timeUs;
583            CHECK(msg->findSize("trackIndex", &trackIndex));
584            CHECK(msg->findInt32("select", &select));
585            CHECK(msg->findInt64("timeUs", &timeUs));
586
587            status_t err = INVALID_OPERATION;
588
589            size_t inbandTracks = 0;
590            if (mSource != NULL) {
591                inbandTracks = mSource->getTrackCount();
592            }
593            size_t ccTracks = 0;
594            if (mCCDecoder != NULL) {
595                ccTracks = mCCDecoder->getTrackCount();
596            }
597
598            if (trackIndex < inbandTracks) {
599                err = mSource->selectTrack(trackIndex, select, timeUs);
600
601                if (!select && err == OK) {
602                    int32_t type;
603                    sp<AMessage> info = mSource->getTrackInfo(trackIndex);
604                    if (info != NULL
605                            && info->findInt32("type", &type)
606                            && type == MEDIA_TRACK_TYPE_TIMEDTEXT) {
607                        ++mTimedTextGeneration;
608                    }
609                }
610            } else {
611                trackIndex -= inbandTracks;
612
613                if (trackIndex < ccTracks) {
614                    err = mCCDecoder->selectTrack(trackIndex, select);
615                }
616            }
617
618            sp<AMessage> response = new AMessage;
619            response->setInt32("err", err);
620
621            response->postReply(replyID);
622            break;
623        }
624
625        case kWhatPollDuration:
626        {
627            int32_t generation;
628            CHECK(msg->findInt32("generation", &generation));
629
630            if (generation != mPollDurationGeneration) {
631                // stale
632                break;
633            }
634
635            int64_t durationUs;
636            if (mDriver != NULL && mSource->getDuration(&durationUs) == OK) {
637                sp<NuPlayerDriver> driver = mDriver.promote();
638                if (driver != NULL) {
639                    driver->notifyDuration(durationUs);
640                }
641            }
642
643            msg->post(1000000ll);  // poll again in a second.
644            break;
645        }
646
647        case kWhatSetVideoSurface:
648        {
649
650            sp<RefBase> obj;
651            CHECK(msg->findObject("surface", &obj));
652            sp<Surface> surface = static_cast<Surface *>(obj.get());
653
654            ALOGD("onSetVideoSurface(%p, %s video decoder)",
655                    surface.get(),
656                    (mSource != NULL && mStarted && mSource->getFormat(false /* audio */) != NULL
657                            && mVideoDecoder != NULL) ? "have" : "no");
658
659            // Need to check mStarted before calling mSource->getFormat because NuPlayer might
660            // be in preparing state and it could take long time.
661            // When mStarted is true, mSource must have been set.
662            if (mSource == NULL || !mStarted || mSource->getFormat(false /* audio */) == NULL
663                    // NOTE: mVideoDecoder's mSurface is always non-null
664                    || (mVideoDecoder != NULL && mVideoDecoder->setVideoSurface(surface) == OK)) {
665                performSetSurface(surface);
666                break;
667            }
668
669            mDeferredActions.push_back(
670                    new FlushDecoderAction(FLUSH_CMD_FLUSH /* audio */,
671                                           FLUSH_CMD_SHUTDOWN /* video */));
672
673            mDeferredActions.push_back(new SetSurfaceAction(surface));
674
675            if (obj != NULL || mAudioDecoder != NULL) {
676                if (mStarted) {
677                    // Issue a seek to refresh the video screen only if started otherwise
678                    // the extractor may not yet be started and will assert.
679                    // If the video decoder is not set (perhaps audio only in this case)
680                    // do not perform a seek as it is not needed.
681                    int64_t currentPositionUs = 0;
682                    if (getCurrentPosition(&currentPositionUs) == OK) {
683                        mDeferredActions.push_back(
684                                new SeekAction(currentPositionUs));
685                    }
686                }
687
688                // If there is a new surface texture, instantiate decoders
689                // again if possible.
690                mDeferredActions.push_back(
691                        new SimpleAction(&NuPlayer::performScanSources));
692            }
693
694            // After a flush without shutdown, decoder is paused.
695            // Don't resume it until source seek is done, otherwise it could
696            // start pulling stale data too soon.
697            mDeferredActions.push_back(
698                    new ResumeDecoderAction(false /* needNotify */));
699
700            processDeferredActions();
701            break;
702        }
703
704        case kWhatSetAudioSink:
705        {
706            ALOGV("kWhatSetAudioSink");
707
708            sp<RefBase> obj;
709            CHECK(msg->findObject("sink", &obj));
710
711            mAudioSink = static_cast<MediaPlayerBase::AudioSink *>(obj.get());
712            break;
713        }
714
715        case kWhatStart:
716        {
717            ALOGV("kWhatStart");
718            if (mStarted) {
719                // do not resume yet if the source is still buffering
720                if (!mPausedForBuffering) {
721                    onResume();
722                }
723            } else {
724                onStart();
725            }
726            mPausedByClient = false;
727            break;
728        }
729
730        case kWhatConfigPlayback:
731        {
732            sp<AReplyToken> replyID;
733            CHECK(msg->senderAwaitsResponse(&replyID));
734            AudioPlaybackRate rate /* sanitized */;
735            readFromAMessage(msg, &rate);
736            status_t err = OK;
737            if (mRenderer != NULL) {
738                // AudioSink allows only 1.f and 0.f for offload mode.
739                // For other speed, switch to non-offload mode.
740                if (mOffloadAudio && ((rate.mSpeed != 0.f && rate.mSpeed != 1.f)
741                        || rate.mPitch != 1.f)) {
742                    int64_t currentPositionUs;
743                    if (getCurrentPosition(&currentPositionUs) != OK) {
744                        currentPositionUs = mPreviousSeekTimeUs;
745                    }
746
747                    // Set mPlaybackSettings so that the new audio decoder can
748                    // be created correctly.
749                    mPlaybackSettings = rate;
750                    if (!mPaused) {
751                        mRenderer->pause();
752                    }
753                    restartAudio(
754                            currentPositionUs, true /* forceNonOffload */,
755                            true /* needsToCreateAudioDecoder */);
756                    if (!mPaused) {
757                        mRenderer->resume();
758                    }
759                }
760
761                err = mRenderer->setPlaybackSettings(rate);
762            }
763            if (err == OK) {
764                if (rate.mSpeed == 0.f) {
765                    onPause();
766                    mPausedByClient = true;
767                    // save all other settings (using non-paused speed)
768                    // so we can restore them on start
769                    AudioPlaybackRate newRate = rate;
770                    newRate.mSpeed = mPlaybackSettings.mSpeed;
771                    mPlaybackSettings = newRate;
772                } else { /* rate.mSpeed != 0.f */
773                    mPlaybackSettings = rate;
774                    if (mStarted) {
775                        // do not resume yet if the source is still buffering
776                        if (!mPausedForBuffering) {
777                            onResume();
778                        }
779                    } else if (mPrepared) {
780                        onStart();
781                    }
782
783                    mPausedByClient = false;
784                }
785            }
786
787            if (mVideoDecoder != NULL) {
788                sp<AMessage> params = new AMessage();
789                params->setFloat("playback-speed", mPlaybackSettings.mSpeed);
790                mVideoDecoder->setParameters(params);
791            }
792
793            sp<AMessage> response = new AMessage;
794            response->setInt32("err", err);
795            response->postReply(replyID);
796            break;
797        }
798
799        case kWhatGetPlaybackSettings:
800        {
801            sp<AReplyToken> replyID;
802            CHECK(msg->senderAwaitsResponse(&replyID));
803            AudioPlaybackRate rate = mPlaybackSettings;
804            status_t err = OK;
805            if (mRenderer != NULL) {
806                err = mRenderer->getPlaybackSettings(&rate);
807            }
808            if (err == OK) {
809                // get playback settings used by renderer, as it may be
810                // slightly off due to audiosink not taking small changes.
811                mPlaybackSettings = rate;
812                if (mPaused) {
813                    rate.mSpeed = 0.f;
814                }
815            }
816            sp<AMessage> response = new AMessage;
817            if (err == OK) {
818                writeToAMessage(response, rate);
819            }
820            response->setInt32("err", err);
821            response->postReply(replyID);
822            break;
823        }
824
825        case kWhatConfigSync:
826        {
827            sp<AReplyToken> replyID;
828            CHECK(msg->senderAwaitsResponse(&replyID));
829
830            ALOGV("kWhatConfigSync");
831            AVSyncSettings sync;
832            float videoFpsHint;
833            readFromAMessage(msg, &sync, &videoFpsHint);
834            status_t err = OK;
835            if (mRenderer != NULL) {
836                err = mRenderer->setSyncSettings(sync, videoFpsHint);
837            }
838            if (err == OK) {
839                mSyncSettings = sync;
840                mVideoFpsHint = videoFpsHint;
841            }
842            sp<AMessage> response = new AMessage;
843            response->setInt32("err", err);
844            response->postReply(replyID);
845            break;
846        }
847
848        case kWhatGetSyncSettings:
849        {
850            sp<AReplyToken> replyID;
851            CHECK(msg->senderAwaitsResponse(&replyID));
852            AVSyncSettings sync = mSyncSettings;
853            float videoFps = mVideoFpsHint;
854            status_t err = OK;
855            if (mRenderer != NULL) {
856                err = mRenderer->getSyncSettings(&sync, &videoFps);
857                if (err == OK) {
858                    mSyncSettings = sync;
859                    mVideoFpsHint = videoFps;
860                }
861            }
862            sp<AMessage> response = new AMessage;
863            if (err == OK) {
864                writeToAMessage(response, sync, videoFps);
865            }
866            response->setInt32("err", err);
867            response->postReply(replyID);
868            break;
869        }
870
871        case kWhatScanSources:
872        {
873            int32_t generation;
874            CHECK(msg->findInt32("generation", &generation));
875            if (generation != mScanSourcesGeneration) {
876                // Drop obsolete msg.
877                break;
878            }
879
880            mScanSourcesPending = false;
881
882            ALOGV("scanning sources haveAudio=%d, haveVideo=%d",
883                 mAudioDecoder != NULL, mVideoDecoder != NULL);
884
885            bool mHadAnySourcesBefore =
886                (mAudioDecoder != NULL) || (mVideoDecoder != NULL);
887            bool rescan = false;
888
889            // initialize video before audio because successful initialization of
890            // video may change deep buffer mode of audio.
891            if (mSurface != NULL) {
892                if (instantiateDecoder(false, &mVideoDecoder) == -EWOULDBLOCK) {
893                    rescan = true;
894                }
895            }
896
897            // Don't try to re-open audio sink if there's an existing decoder.
898            if (mAudioSink != NULL && mAudioDecoder == NULL) {
899                if (instantiateDecoder(true, &mAudioDecoder) == -EWOULDBLOCK) {
900                    rescan = true;
901                }
902            }
903
904            if (!mHadAnySourcesBefore
905                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
906                // This is the first time we've found anything playable.
907
908                if (mSourceFlags & Source::FLAG_DYNAMIC_DURATION) {
909                    schedulePollDuration();
910                }
911            }
912
913            status_t err;
914            if ((err = mSource->feedMoreTSData()) != OK) {
915                if (mAudioDecoder == NULL && mVideoDecoder == NULL) {
916                    // We're not currently decoding anything (no audio or
917                    // video tracks found) and we just ran out of input data.
918
919                    if (err == ERROR_END_OF_STREAM) {
920                        notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
921                    } else {
922                        notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
923                    }
924                }
925                break;
926            }
927
928            if (rescan) {
929                msg->post(100000ll);
930                mScanSourcesPending = true;
931            }
932            break;
933        }
934
935        case kWhatVideoNotify:
936        case kWhatAudioNotify:
937        {
938            bool audio = msg->what() == kWhatAudioNotify;
939
940            int32_t currentDecoderGeneration =
941                (audio? mAudioDecoderGeneration : mVideoDecoderGeneration);
942            int32_t requesterGeneration = currentDecoderGeneration - 1;
943            CHECK(msg->findInt32("generation", &requesterGeneration));
944
945            if (requesterGeneration != currentDecoderGeneration) {
946                ALOGV("got message from old %s decoder, generation(%d:%d)",
947                        audio ? "audio" : "video", requesterGeneration,
948                        currentDecoderGeneration);
949                sp<AMessage> reply;
950                if (!(msg->findMessage("reply", &reply))) {
951                    return;
952                }
953
954                reply->setInt32("err", INFO_DISCONTINUITY);
955                reply->post();
956                return;
957            }
958
959            int32_t what;
960            CHECK(msg->findInt32("what", &what));
961
962            if (what == DecoderBase::kWhatInputDiscontinuity) {
963                int32_t formatChange;
964                CHECK(msg->findInt32("formatChange", &formatChange));
965
966                ALOGV("%s discontinuity: formatChange %d",
967                        audio ? "audio" : "video", formatChange);
968
969                if (formatChange) {
970                    mDeferredActions.push_back(
971                            new FlushDecoderAction(
972                                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
973                                audio ? FLUSH_CMD_NONE : FLUSH_CMD_SHUTDOWN));
974                }
975
976                mDeferredActions.push_back(
977                        new SimpleAction(
978                                &NuPlayer::performScanSources));
979
980                processDeferredActions();
981            } else if (what == DecoderBase::kWhatEOS) {
982                int32_t err;
983                CHECK(msg->findInt32("err", &err));
984
985                if (err == ERROR_END_OF_STREAM) {
986                    ALOGV("got %s decoder EOS", audio ? "audio" : "video");
987                } else {
988                    ALOGV("got %s decoder EOS w/ error %d",
989                         audio ? "audio" : "video",
990                         err);
991                }
992
993                mRenderer->queueEOS(audio, err);
994            } else if (what == DecoderBase::kWhatFlushCompleted) {
995                ALOGV("decoder %s flush completed", audio ? "audio" : "video");
996
997                handleFlushComplete(audio, true /* isDecoder */);
998                finishFlushIfPossible();
999            } else if (what == DecoderBase::kWhatVideoSizeChanged) {
1000                sp<AMessage> format;
1001                CHECK(msg->findMessage("format", &format));
1002
1003                sp<AMessage> inputFormat =
1004                        mSource->getFormat(false /* audio */);
1005
1006                setVideoScalingMode(mVideoScalingMode);
1007                updateVideoSize(inputFormat, format);
1008            } else if (what == DecoderBase::kWhatShutdownCompleted) {
1009                ALOGV("%s shutdown completed", audio ? "audio" : "video");
1010                if (audio) {
1011                    mAudioDecoder.clear();
1012                    ++mAudioDecoderGeneration;
1013
1014                    CHECK_EQ((int)mFlushingAudio, (int)SHUTTING_DOWN_DECODER);
1015                    mFlushingAudio = SHUT_DOWN;
1016                } else {
1017                    mVideoDecoder.clear();
1018                    ++mVideoDecoderGeneration;
1019
1020                    CHECK_EQ((int)mFlushingVideo, (int)SHUTTING_DOWN_DECODER);
1021                    mFlushingVideo = SHUT_DOWN;
1022                }
1023
1024                finishFlushIfPossible();
1025            } else if (what == DecoderBase::kWhatResumeCompleted) {
1026                finishResume();
1027            } else if (what == DecoderBase::kWhatError) {
1028                status_t err;
1029                if (!msg->findInt32("err", &err) || err == OK) {
1030                    err = UNKNOWN_ERROR;
1031                }
1032
1033                // Decoder errors can be due to Source (e.g. from streaming),
1034                // or from decoding corrupted bitstreams, or from other decoder
1035                // MediaCodec operations (e.g. from an ongoing reset or seek).
1036                // They may also be due to openAudioSink failure at
1037                // decoder start or after a format change.
1038                //
1039                // We try to gracefully shut down the affected decoder if possible,
1040                // rather than trying to force the shutdown with something
1041                // similar to performReset(). This method can lead to a hang
1042                // if MediaCodec functions block after an error, but they should
1043                // typically return INVALID_OPERATION instead of blocking.
1044
1045                FlushStatus *flushing = audio ? &mFlushingAudio : &mFlushingVideo;
1046                ALOGE("received error(%#x) from %s decoder, flushing(%d), now shutting down",
1047                        err, audio ? "audio" : "video", *flushing);
1048
1049                switch (*flushing) {
1050                    case NONE:
1051                        mDeferredActions.push_back(
1052                                new FlushDecoderAction(
1053                                    audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1054                                    audio ? FLUSH_CMD_NONE : FLUSH_CMD_SHUTDOWN));
1055                        processDeferredActions();
1056                        break;
1057                    case FLUSHING_DECODER:
1058                        *flushing = FLUSHING_DECODER_SHUTDOWN; // initiate shutdown after flush.
1059                        break; // Wait for flush to complete.
1060                    case FLUSHING_DECODER_SHUTDOWN:
1061                        break; // Wait for flush to complete.
1062                    case SHUTTING_DOWN_DECODER:
1063                        break; // Wait for shutdown to complete.
1064                    case FLUSHED:
1065                        // Widevine source reads must stop before releasing the video decoder.
1066                        if (!audio && mSource != NULL && mSourceFlags & Source::FLAG_SECURE) {
1067                            mSource->stop();
1068                            mSourceStarted = false;
1069                        }
1070                        getDecoder(audio)->initiateShutdown(); // In the middle of a seek.
1071                        *flushing = SHUTTING_DOWN_DECODER;     // Shut down.
1072                        break;
1073                    case SHUT_DOWN:
1074                        finishFlushIfPossible();  // Should not occur.
1075                        break;                    // Finish anyways.
1076                }
1077                notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
1078            } else {
1079                ALOGV("Unhandled decoder notification %d '%c%c%c%c'.",
1080                      what,
1081                      what >> 24,
1082                      (what >> 16) & 0xff,
1083                      (what >> 8) & 0xff,
1084                      what & 0xff);
1085            }
1086
1087            break;
1088        }
1089
1090        case kWhatRendererNotify:
1091        {
1092            int32_t requesterGeneration = mRendererGeneration - 1;
1093            CHECK(msg->findInt32("generation", &requesterGeneration));
1094            if (requesterGeneration != mRendererGeneration) {
1095                ALOGV("got message from old renderer, generation(%d:%d)",
1096                        requesterGeneration, mRendererGeneration);
1097                return;
1098            }
1099
1100            int32_t what;
1101            CHECK(msg->findInt32("what", &what));
1102
1103            if (what == Renderer::kWhatEOS) {
1104                int32_t audio;
1105                CHECK(msg->findInt32("audio", &audio));
1106
1107                int32_t finalResult;
1108                CHECK(msg->findInt32("finalResult", &finalResult));
1109
1110                if (audio) {
1111                    mAudioEOS = true;
1112                } else {
1113                    mVideoEOS = true;
1114                }
1115
1116                if (finalResult == ERROR_END_OF_STREAM) {
1117                    ALOGV("reached %s EOS", audio ? "audio" : "video");
1118                } else {
1119                    ALOGE("%s track encountered an error (%d)",
1120                         audio ? "audio" : "video", finalResult);
1121
1122                    notifyListener(
1123                            MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, finalResult);
1124                }
1125
1126                if ((mAudioEOS || mAudioDecoder == NULL)
1127                        && (mVideoEOS || mVideoDecoder == NULL)) {
1128                    notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
1129                }
1130            } else if (what == Renderer::kWhatFlushComplete) {
1131                int32_t audio;
1132                CHECK(msg->findInt32("audio", &audio));
1133
1134                if (audio) {
1135                    mAudioEOS = false;
1136                } else {
1137                    mVideoEOS = false;
1138                }
1139
1140                ALOGV("renderer %s flush completed.", audio ? "audio" : "video");
1141                if (audio && (mFlushingAudio == NONE || mFlushingAudio == FLUSHED
1142                        || mFlushingAudio == SHUT_DOWN)) {
1143                    // Flush has been handled by tear down.
1144                    break;
1145                }
1146                handleFlushComplete(audio, false /* isDecoder */);
1147                finishFlushIfPossible();
1148            } else if (what == Renderer::kWhatVideoRenderingStart) {
1149                notifyListener(MEDIA_INFO, MEDIA_INFO_RENDERING_START, 0);
1150            } else if (what == Renderer::kWhatMediaRenderingStart) {
1151                ALOGV("media rendering started");
1152                notifyListener(MEDIA_STARTED, 0, 0);
1153            } else if (what == Renderer::kWhatAudioTearDown) {
1154                int32_t reason;
1155                CHECK(msg->findInt32("reason", &reason));
1156                ALOGV("Tear down audio with reason %d.", reason);
1157                if (reason == Renderer::kDueToTimeout && !(mPaused && mOffloadAudio)) {
1158                    // TimeoutWhenPaused is only for offload mode.
1159                    ALOGW("Receive a stale message for teardown.");
1160                    break;
1161                }
1162                int64_t positionUs;
1163                if (!msg->findInt64("positionUs", &positionUs)) {
1164                    positionUs = mPreviousSeekTimeUs;
1165                }
1166
1167                restartAudio(
1168                        positionUs, reason == Renderer::kForceNonOffload /* forceNonOffload */,
1169                        reason != Renderer::kDueToTimeout /* needsToCreateAudioDecoder */);
1170            }
1171            break;
1172        }
1173
1174        case kWhatMoreDataQueued:
1175        {
1176            break;
1177        }
1178
1179        case kWhatReset:
1180        {
1181            ALOGV("kWhatReset");
1182
1183            mResetting = true;
1184
1185            mDeferredActions.push_back(
1186                    new FlushDecoderAction(
1187                        FLUSH_CMD_SHUTDOWN /* audio */,
1188                        FLUSH_CMD_SHUTDOWN /* video */));
1189
1190            mDeferredActions.push_back(
1191                    new SimpleAction(&NuPlayer::performReset));
1192
1193            processDeferredActions();
1194            break;
1195        }
1196
1197        case kWhatSeek:
1198        {
1199            int64_t seekTimeUs;
1200            int32_t needNotify;
1201            CHECK(msg->findInt64("seekTimeUs", &seekTimeUs));
1202            CHECK(msg->findInt32("needNotify", &needNotify));
1203
1204            ALOGV("kWhatSeek seekTimeUs=%lld us, needNotify=%d",
1205                    (long long)seekTimeUs, needNotify);
1206
1207            if (!mStarted) {
1208                // Seek before the player is started. In order to preview video,
1209                // need to start the player and pause it. This branch is called
1210                // only once if needed. After the player is started, any seek
1211                // operation will go through normal path.
1212                // Audio-only cases are handled separately.
1213                onStart(seekTimeUs);
1214                if (mStarted) {
1215                    onPause();
1216                    mPausedByClient = true;
1217                }
1218                if (needNotify) {
1219                    notifyDriverSeekComplete();
1220                }
1221                break;
1222            }
1223
1224            mDeferredActions.push_back(
1225                    new FlushDecoderAction(FLUSH_CMD_FLUSH /* audio */,
1226                                           FLUSH_CMD_FLUSH /* video */));
1227
1228            mDeferredActions.push_back(
1229                    new SeekAction(seekTimeUs));
1230
1231            // After a flush without shutdown, decoder is paused.
1232            // Don't resume it until source seek is done, otherwise it could
1233            // start pulling stale data too soon.
1234            mDeferredActions.push_back(
1235                    new ResumeDecoderAction(needNotify));
1236
1237            processDeferredActions();
1238            break;
1239        }
1240
1241        case kWhatPause:
1242        {
1243            onPause();
1244            mPausedByClient = true;
1245            break;
1246        }
1247
1248        case kWhatSourceNotify:
1249        {
1250            onSourceNotify(msg);
1251            break;
1252        }
1253
1254        case kWhatClosedCaptionNotify:
1255        {
1256            onClosedCaptionNotify(msg);
1257            break;
1258        }
1259
1260        default:
1261            TRESPASS();
1262            break;
1263    }
1264}
1265
1266void NuPlayer::onResume() {
1267    if (!mPaused || mResetting) {
1268        ALOGD_IF(mResetting, "resetting, onResume discarded");
1269        return;
1270    }
1271    mPaused = false;
1272    if (mSource != NULL) {
1273        mSource->resume();
1274    } else {
1275        ALOGW("resume called when source is gone or not set");
1276    }
1277    // |mAudioDecoder| may have been released due to the pause timeout, so re-create it if
1278    // needed.
1279    if (audioDecoderStillNeeded() && mAudioDecoder == NULL) {
1280        instantiateDecoder(true /* audio */, &mAudioDecoder);
1281    }
1282    if (mRenderer != NULL) {
1283        mRenderer->resume();
1284    } else {
1285        ALOGW("resume called when renderer is gone or not set");
1286    }
1287}
1288
1289status_t NuPlayer::onInstantiateSecureDecoders() {
1290    status_t err;
1291    if (!(mSourceFlags & Source::FLAG_SECURE)) {
1292        return BAD_TYPE;
1293    }
1294
1295    if (mRenderer != NULL) {
1296        ALOGE("renderer should not be set when instantiating secure decoders");
1297        return UNKNOWN_ERROR;
1298    }
1299
1300    // TRICKY: We rely on mRenderer being null, so that decoder does not start requesting
1301    // data on instantiation.
1302    if (mSurface != NULL) {
1303        err = instantiateDecoder(false, &mVideoDecoder);
1304        if (err != OK) {
1305            return err;
1306        }
1307    }
1308
1309    if (mAudioSink != NULL) {
1310        err = instantiateDecoder(true, &mAudioDecoder);
1311        if (err != OK) {
1312            return err;
1313        }
1314    }
1315    return OK;
1316}
1317
1318void NuPlayer::onStart(int64_t startPositionUs) {
1319    if (!mSourceStarted) {
1320        mSourceStarted = true;
1321        mSource->start();
1322    }
1323    if (startPositionUs > 0) {
1324        performSeek(startPositionUs);
1325        if (mSource->getFormat(false /* audio */) == NULL) {
1326            return;
1327        }
1328    }
1329
1330    mOffloadAudio = false;
1331    mAudioEOS = false;
1332    mVideoEOS = false;
1333    mStarted = true;
1334    mPaused = false;
1335
1336    uint32_t flags = 0;
1337
1338    if (mSource->isRealTime()) {
1339        flags |= Renderer::FLAG_REAL_TIME;
1340    }
1341
1342    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1343    ALOGV_IF(audioMeta == NULL, "no metadata for audio source");  // video only stream
1344    audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
1345    if (mAudioSink != NULL) {
1346        streamType = mAudioSink->getAudioStreamType();
1347    }
1348
1349    sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
1350
1351    mOffloadAudio =
1352        canOffloadStream(audioMeta, (videoFormat != NULL), mSource->isStreaming(), streamType)
1353                && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
1354    if (mOffloadAudio) {
1355        flags |= Renderer::FLAG_OFFLOAD_AUDIO;
1356    }
1357
1358    sp<AMessage> notify = new AMessage(kWhatRendererNotify, this);
1359    ++mRendererGeneration;
1360    notify->setInt32("generation", mRendererGeneration);
1361    mRenderer = new Renderer(mAudioSink, notify, flags);
1362    mRendererLooper = new ALooper;
1363    mRendererLooper->setName("NuPlayerRenderer");
1364    mRendererLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
1365    mRendererLooper->registerHandler(mRenderer);
1366
1367    status_t err = mRenderer->setPlaybackSettings(mPlaybackSettings);
1368    if (err != OK) {
1369        mSource->stop();
1370        mSourceStarted = false;
1371        notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
1372        return;
1373    }
1374
1375    float rate = getFrameRate();
1376    if (rate > 0) {
1377        mRenderer->setVideoFrameRate(rate);
1378    }
1379
1380    if (mVideoDecoder != NULL) {
1381        mVideoDecoder->setRenderer(mRenderer);
1382    }
1383    if (mAudioDecoder != NULL) {
1384        mAudioDecoder->setRenderer(mRenderer);
1385    }
1386
1387    postScanSources();
1388}
1389
1390void NuPlayer::onPause() {
1391    if (mPaused) {
1392        return;
1393    }
1394    mPaused = true;
1395    if (mSource != NULL) {
1396        mSource->pause();
1397    } else {
1398        ALOGW("pause called when source is gone or not set");
1399    }
1400    if (mRenderer != NULL) {
1401        mRenderer->pause();
1402    } else {
1403        ALOGW("pause called when renderer is gone or not set");
1404    }
1405}
1406
1407bool NuPlayer::audioDecoderStillNeeded() {
1408    // Audio decoder is no longer needed if it's in shut/shutting down status.
1409    return ((mFlushingAudio != SHUT_DOWN) && (mFlushingAudio != SHUTTING_DOWN_DECODER));
1410}
1411
1412void NuPlayer::handleFlushComplete(bool audio, bool isDecoder) {
1413    // We wait for both the decoder flush and the renderer flush to complete
1414    // before entering either the FLUSHED or the SHUTTING_DOWN_DECODER state.
1415
1416    mFlushComplete[audio][isDecoder] = true;
1417    if (!mFlushComplete[audio][!isDecoder]) {
1418        return;
1419    }
1420
1421    FlushStatus *state = audio ? &mFlushingAudio : &mFlushingVideo;
1422    switch (*state) {
1423        case FLUSHING_DECODER:
1424        {
1425            *state = FLUSHED;
1426            break;
1427        }
1428
1429        case FLUSHING_DECODER_SHUTDOWN:
1430        {
1431            *state = SHUTTING_DOWN_DECODER;
1432
1433            ALOGV("initiating %s decoder shutdown", audio ? "audio" : "video");
1434            if (!audio) {
1435                // Widevine source reads must stop before releasing the video decoder.
1436                if (mSource != NULL && mSourceFlags & Source::FLAG_SECURE) {
1437                    mSource->stop();
1438                    mSourceStarted = false;
1439                }
1440            }
1441            getDecoder(audio)->initiateShutdown();
1442            break;
1443        }
1444
1445        default:
1446            // decoder flush completes only occur in a flushing state.
1447            LOG_ALWAYS_FATAL_IF(isDecoder, "decoder flush in invalid state %d", *state);
1448            break;
1449    }
1450}
1451
1452void NuPlayer::finishFlushIfPossible() {
1453    if (mFlushingAudio != NONE && mFlushingAudio != FLUSHED
1454            && mFlushingAudio != SHUT_DOWN) {
1455        return;
1456    }
1457
1458    if (mFlushingVideo != NONE && mFlushingVideo != FLUSHED
1459            && mFlushingVideo != SHUT_DOWN) {
1460        return;
1461    }
1462
1463    ALOGV("both audio and video are flushed now.");
1464
1465    mFlushingAudio = NONE;
1466    mFlushingVideo = NONE;
1467
1468    clearFlushComplete();
1469
1470    processDeferredActions();
1471}
1472
1473void NuPlayer::postScanSources() {
1474    if (mScanSourcesPending) {
1475        return;
1476    }
1477
1478    sp<AMessage> msg = new AMessage(kWhatScanSources, this);
1479    msg->setInt32("generation", mScanSourcesGeneration);
1480    msg->post();
1481
1482    mScanSourcesPending = true;
1483}
1484
1485void NuPlayer::tryOpenAudioSinkForOffload(
1486        const sp<AMessage> &format, const sp<MetaData> &audioMeta, bool hasVideo) {
1487    // Note: This is called early in NuPlayer to determine whether offloading
1488    // is possible; otherwise the decoders call the renderer openAudioSink directly.
1489
1490    status_t err = mRenderer->openAudioSink(
1491            format, true /* offloadOnly */, hasVideo, AUDIO_OUTPUT_FLAG_NONE, &mOffloadAudio);
1492    if (err != OK) {
1493        // Any failure we turn off mOffloadAudio.
1494        mOffloadAudio = false;
1495    } else if (mOffloadAudio) {
1496        sendMetaDataToHal(mAudioSink, audioMeta);
1497    }
1498}
1499
1500void NuPlayer::closeAudioSink() {
1501    mRenderer->closeAudioSink();
1502}
1503
1504void NuPlayer::restartAudio(
1505        int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder) {
1506    if (mAudioDecoder != NULL) {
1507        mAudioDecoder->pause();
1508        mAudioDecoder.clear();
1509        ++mAudioDecoderGeneration;
1510    }
1511    if (mFlushingAudio == FLUSHING_DECODER) {
1512        mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
1513        mFlushingAudio = FLUSHED;
1514        finishFlushIfPossible();
1515    } else if (mFlushingAudio == FLUSHING_DECODER_SHUTDOWN
1516            || mFlushingAudio == SHUTTING_DOWN_DECODER) {
1517        mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
1518        mFlushingAudio = SHUT_DOWN;
1519        finishFlushIfPossible();
1520        needsToCreateAudioDecoder = false;
1521    }
1522    if (mRenderer == NULL) {
1523        return;
1524    }
1525    closeAudioSink();
1526    mRenderer->flush(true /* audio */, false /* notifyComplete */);
1527    if (mVideoDecoder != NULL) {
1528        mRenderer->flush(false /* audio */, false /* notifyComplete */);
1529    }
1530
1531    performSeek(currentPositionUs);
1532
1533    if (forceNonOffload) {
1534        mRenderer->signalDisableOffloadAudio();
1535        mOffloadAudio = false;
1536    }
1537    if (needsToCreateAudioDecoder) {
1538        instantiateDecoder(true /* audio */, &mAudioDecoder, !forceNonOffload);
1539    }
1540}
1541
1542void NuPlayer::determineAudioModeChange(const sp<AMessage> &audioFormat) {
1543    if (mSource == NULL || mAudioSink == NULL) {
1544        return;
1545    }
1546
1547    if (mRenderer == NULL) {
1548        ALOGW("No renderer can be used to determine audio mode. Use non-offload for safety.");
1549        mOffloadAudio = false;
1550        return;
1551    }
1552
1553    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1554    sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
1555    audio_stream_type_t streamType = mAudioSink->getAudioStreamType();
1556    const bool hasVideo = (videoFormat != NULL);
1557    const bool canOffload = canOffloadStream(
1558            audioMeta, hasVideo, mSource->isStreaming(), streamType)
1559                    && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
1560    if (canOffload) {
1561        if (!mOffloadAudio) {
1562            mRenderer->signalEnableOffloadAudio();
1563        }
1564        // open audio sink early under offload mode.
1565        tryOpenAudioSinkForOffload(audioFormat, audioMeta, hasVideo);
1566    } else {
1567        if (mOffloadAudio) {
1568            mRenderer->signalDisableOffloadAudio();
1569            mOffloadAudio = false;
1570        }
1571    }
1572}
1573
1574status_t NuPlayer::instantiateDecoder(
1575        bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange) {
1576    // The audio decoder could be cleared by tear down. If still in shut down
1577    // process, no need to create a new audio decoder.
1578    if (*decoder != NULL || (audio && mFlushingAudio == SHUT_DOWN)) {
1579        return OK;
1580    }
1581
1582    sp<AMessage> format = mSource->getFormat(audio);
1583
1584    if (format == NULL) {
1585        return UNKNOWN_ERROR;
1586    } else {
1587        status_t err;
1588        if (format->findInt32("err", &err) && err) {
1589            return err;
1590        }
1591    }
1592
1593    format->setInt32("priority", 0 /* realtime */);
1594
1595    if (!audio) {
1596        AString mime;
1597        CHECK(format->findString("mime", &mime));
1598
1599        sp<AMessage> ccNotify = new AMessage(kWhatClosedCaptionNotify, this);
1600        if (mCCDecoder == NULL) {
1601            mCCDecoder = new CCDecoder(ccNotify);
1602        }
1603
1604        if (mSourceFlags & Source::FLAG_SECURE) {
1605            format->setInt32("secure", true);
1606        }
1607
1608        if (mSourceFlags & Source::FLAG_PROTECTED) {
1609            format->setInt32("protected", true);
1610        }
1611
1612        float rate = getFrameRate();
1613        if (rate > 0) {
1614            format->setFloat("operating-rate", rate * mPlaybackSettings.mSpeed);
1615        }
1616    }
1617
1618    if (audio) {
1619        sp<AMessage> notify = new AMessage(kWhatAudioNotify, this);
1620        ++mAudioDecoderGeneration;
1621        notify->setInt32("generation", mAudioDecoderGeneration);
1622
1623        if (checkAudioModeChange) {
1624            determineAudioModeChange(format);
1625        }
1626        if (mOffloadAudio) {
1627            mSource->setOffloadAudio(true /* offload */);
1628
1629            const bool hasVideo = (mSource->getFormat(false /*audio */) != NULL);
1630            format->setInt32("has-video", hasVideo);
1631            *decoder = new DecoderPassThrough(notify, mSource, mRenderer);
1632        } else {
1633            mSource->setOffloadAudio(false /* offload */);
1634
1635            *decoder = new Decoder(notify, mSource, mPID, mRenderer);
1636        }
1637    } else {
1638        sp<AMessage> notify = new AMessage(kWhatVideoNotify, this);
1639        ++mVideoDecoderGeneration;
1640        notify->setInt32("generation", mVideoDecoderGeneration);
1641
1642        *decoder = new Decoder(
1643                notify, mSource, mPID, mRenderer, mSurface, mCCDecoder);
1644
1645        // enable FRC if high-quality AV sync is requested, even if not
1646        // directly queuing to display, as this will even improve textureview
1647        // playback.
1648        {
1649            char value[PROPERTY_VALUE_MAX];
1650            if (property_get("persist.sys.media.avsync", value, NULL) &&
1651                    (!strcmp("1", value) || !strcasecmp("true", value))) {
1652                format->setInt32("auto-frc", 1);
1653            }
1654        }
1655    }
1656    (*decoder)->init();
1657    (*decoder)->configure(format);
1658
1659    // allocate buffers to decrypt widevine source buffers
1660    if (!audio && (mSourceFlags & Source::FLAG_SECURE)) {
1661        Vector<sp<MediaCodecBuffer> > inputBufs;
1662        CHECK_EQ((*decoder)->getInputBuffers(&inputBufs), (status_t)OK);
1663
1664        Vector<MediaBuffer *> mediaBufs;
1665        for (size_t i = 0; i < inputBufs.size(); i++) {
1666            const sp<MediaCodecBuffer> &buffer = inputBufs[i];
1667            MediaBuffer *mbuf = new MediaBuffer(buffer->data(), buffer->size());
1668            mediaBufs.push(mbuf);
1669        }
1670
1671        status_t err = mSource->setBuffers(audio, mediaBufs);
1672        if (err != OK) {
1673            for (size_t i = 0; i < mediaBufs.size(); ++i) {
1674                mediaBufs[i]->release();
1675            }
1676            mediaBufs.clear();
1677            ALOGE("Secure source didn't support secure mediaBufs.");
1678            return err;
1679        }
1680    }
1681
1682    if (!audio) {
1683        sp<AMessage> params = new AMessage();
1684        float rate = getFrameRate();
1685        if (rate > 0) {
1686            params->setFloat("frame-rate-total", rate);
1687        }
1688
1689        sp<MetaData> fileMeta = getFileMeta();
1690        if (fileMeta != NULL) {
1691            int32_t videoTemporalLayerCount;
1692            if (fileMeta->findInt32(kKeyTemporalLayerCount, &videoTemporalLayerCount)
1693                    && videoTemporalLayerCount > 0) {
1694                params->setInt32("temporal-layer-count", videoTemporalLayerCount);
1695            }
1696        }
1697
1698        if (params->countEntries() > 0) {
1699            (*decoder)->setParameters(params);
1700        }
1701    }
1702    return OK;
1703}
1704
1705void NuPlayer::updateVideoSize(
1706        const sp<AMessage> &inputFormat,
1707        const sp<AMessage> &outputFormat) {
1708    if (inputFormat == NULL) {
1709        ALOGW("Unknown video size, reporting 0x0!");
1710        notifyListener(MEDIA_SET_VIDEO_SIZE, 0, 0);
1711        return;
1712    }
1713
1714    int32_t displayWidth, displayHeight;
1715    if (outputFormat != NULL) {
1716        int32_t width, height;
1717        CHECK(outputFormat->findInt32("width", &width));
1718        CHECK(outputFormat->findInt32("height", &height));
1719
1720        int32_t cropLeft, cropTop, cropRight, cropBottom;
1721        CHECK(outputFormat->findRect(
1722                    "crop",
1723                    &cropLeft, &cropTop, &cropRight, &cropBottom));
1724
1725        displayWidth = cropRight - cropLeft + 1;
1726        displayHeight = cropBottom - cropTop + 1;
1727
1728        ALOGV("Video output format changed to %d x %d "
1729             "(crop: %d x %d @ (%d, %d))",
1730             width, height,
1731             displayWidth,
1732             displayHeight,
1733             cropLeft, cropTop);
1734    } else {
1735        CHECK(inputFormat->findInt32("width", &displayWidth));
1736        CHECK(inputFormat->findInt32("height", &displayHeight));
1737
1738        ALOGV("Video input format %d x %d", displayWidth, displayHeight);
1739    }
1740
1741    // Take into account sample aspect ratio if necessary:
1742    int32_t sarWidth, sarHeight;
1743    if (inputFormat->findInt32("sar-width", &sarWidth)
1744            && inputFormat->findInt32("sar-height", &sarHeight)) {
1745        ALOGV("Sample aspect ratio %d : %d", sarWidth, sarHeight);
1746
1747        displayWidth = (displayWidth * sarWidth) / sarHeight;
1748
1749        ALOGV("display dimensions %d x %d", displayWidth, displayHeight);
1750    }
1751
1752    int32_t rotationDegrees;
1753    if (!inputFormat->findInt32("rotation-degrees", &rotationDegrees)) {
1754        rotationDegrees = 0;
1755    }
1756
1757    if (rotationDegrees == 90 || rotationDegrees == 270) {
1758        int32_t tmp = displayWidth;
1759        displayWidth = displayHeight;
1760        displayHeight = tmp;
1761    }
1762
1763    notifyListener(
1764            MEDIA_SET_VIDEO_SIZE,
1765            displayWidth,
1766            displayHeight);
1767}
1768
1769void NuPlayer::notifyListener(int msg, int ext1, int ext2, const Parcel *in) {
1770    if (mDriver == NULL) {
1771        return;
1772    }
1773
1774    sp<NuPlayerDriver> driver = mDriver.promote();
1775
1776    if (driver == NULL) {
1777        return;
1778    }
1779
1780    driver->notifyListener(msg, ext1, ext2, in);
1781}
1782
1783void NuPlayer::flushDecoder(bool audio, bool needShutdown) {
1784    ALOGV("[%s] flushDecoder needShutdown=%d",
1785          audio ? "audio" : "video", needShutdown);
1786
1787    const sp<DecoderBase> &decoder = getDecoder(audio);
1788    if (decoder == NULL) {
1789        ALOGI("flushDecoder %s without decoder present",
1790             audio ? "audio" : "video");
1791        return;
1792    }
1793
1794    // Make sure we don't continue to scan sources until we finish flushing.
1795    ++mScanSourcesGeneration;
1796    if (mScanSourcesPending) {
1797        if (!needShutdown) {
1798            mDeferredActions.push_back(
1799                    new SimpleAction(&NuPlayer::performScanSources));
1800        }
1801        mScanSourcesPending = false;
1802    }
1803
1804    decoder->signalFlush();
1805
1806    FlushStatus newStatus =
1807        needShutdown ? FLUSHING_DECODER_SHUTDOWN : FLUSHING_DECODER;
1808
1809    mFlushComplete[audio][false /* isDecoder */] = (mRenderer == NULL);
1810    mFlushComplete[audio][true /* isDecoder */] = false;
1811    if (audio) {
1812        ALOGE_IF(mFlushingAudio != NONE,
1813                "audio flushDecoder() is called in state %d", mFlushingAudio);
1814        mFlushingAudio = newStatus;
1815    } else {
1816        ALOGE_IF(mFlushingVideo != NONE,
1817                "video flushDecoder() is called in state %d", mFlushingVideo);
1818        mFlushingVideo = newStatus;
1819    }
1820}
1821
1822void NuPlayer::queueDecoderShutdown(
1823        bool audio, bool video, const sp<AMessage> &reply) {
1824    ALOGI("queueDecoderShutdown audio=%d, video=%d", audio, video);
1825
1826    mDeferredActions.push_back(
1827            new FlushDecoderAction(
1828                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1829                video ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE));
1830
1831    mDeferredActions.push_back(
1832            new SimpleAction(&NuPlayer::performScanSources));
1833
1834    mDeferredActions.push_back(new PostMessageAction(reply));
1835
1836    processDeferredActions();
1837}
1838
1839status_t NuPlayer::setVideoScalingMode(int32_t mode) {
1840    mVideoScalingMode = mode;
1841    if (mSurface != NULL) {
1842        status_t ret = native_window_set_scaling_mode(mSurface.get(), mVideoScalingMode);
1843        if (ret != OK) {
1844            ALOGE("Failed to set scaling mode (%d): %s",
1845                -ret, strerror(-ret));
1846            return ret;
1847        }
1848    }
1849    return OK;
1850}
1851
1852status_t NuPlayer::getTrackInfo(Parcel* reply) const {
1853    sp<AMessage> msg = new AMessage(kWhatGetTrackInfo, this);
1854    msg->setPointer("reply", reply);
1855
1856    sp<AMessage> response;
1857    status_t err = msg->postAndAwaitResponse(&response);
1858    return err;
1859}
1860
1861status_t NuPlayer::getSelectedTrack(int32_t type, Parcel* reply) const {
1862    sp<AMessage> msg = new AMessage(kWhatGetSelectedTrack, this);
1863    msg->setPointer("reply", reply);
1864    msg->setInt32("type", type);
1865
1866    sp<AMessage> response;
1867    status_t err = msg->postAndAwaitResponse(&response);
1868    if (err == OK && response != NULL) {
1869        CHECK(response->findInt32("err", &err));
1870    }
1871    return err;
1872}
1873
1874status_t NuPlayer::selectTrack(size_t trackIndex, bool select, int64_t timeUs) {
1875    sp<AMessage> msg = new AMessage(kWhatSelectTrack, this);
1876    msg->setSize("trackIndex", trackIndex);
1877    msg->setInt32("select", select);
1878    msg->setInt64("timeUs", timeUs);
1879
1880    sp<AMessage> response;
1881    status_t err = msg->postAndAwaitResponse(&response);
1882
1883    if (err != OK) {
1884        return err;
1885    }
1886
1887    if (!response->findInt32("err", &err)) {
1888        err = OK;
1889    }
1890
1891    return err;
1892}
1893
1894status_t NuPlayer::getCurrentPosition(int64_t *mediaUs) {
1895    sp<Renderer> renderer = mRenderer;
1896    if (renderer == NULL) {
1897        return NO_INIT;
1898    }
1899
1900    return renderer->getCurrentPosition(mediaUs);
1901}
1902
1903void NuPlayer::getStats(Vector<sp<AMessage> > *mTrackStats) {
1904    CHECK(mTrackStats != NULL);
1905
1906    mTrackStats->clear();
1907    if (mVideoDecoder != NULL) {
1908        mTrackStats->push_back(mVideoDecoder->getStats());
1909    }
1910    if (mAudioDecoder != NULL) {
1911        mTrackStats->push_back(mAudioDecoder->getStats());
1912    }
1913}
1914
1915sp<MetaData> NuPlayer::getFileMeta() {
1916    return mSource->getFileFormatMeta();
1917}
1918
1919float NuPlayer::getFrameRate() {
1920    sp<MetaData> meta = mSource->getFormatMeta(false /* audio */);
1921    if (meta == NULL) {
1922        return 0;
1923    }
1924    int32_t rate;
1925    if (!meta->findInt32(kKeyFrameRate, &rate)) {
1926        // fall back to try file meta
1927        sp<MetaData> fileMeta = getFileMeta();
1928        if (fileMeta == NULL) {
1929            ALOGW("source has video meta but not file meta");
1930            return -1;
1931        }
1932        int32_t fileMetaRate;
1933        if (!fileMeta->findInt32(kKeyFrameRate, &fileMetaRate)) {
1934            return -1;
1935        }
1936        return fileMetaRate;
1937    }
1938    return rate;
1939}
1940
1941void NuPlayer::schedulePollDuration() {
1942    sp<AMessage> msg = new AMessage(kWhatPollDuration, this);
1943    msg->setInt32("generation", mPollDurationGeneration);
1944    msg->post();
1945}
1946
1947void NuPlayer::cancelPollDuration() {
1948    ++mPollDurationGeneration;
1949}
1950
1951void NuPlayer::processDeferredActions() {
1952    while (!mDeferredActions.empty()) {
1953        // We won't execute any deferred actions until we're no longer in
1954        // an intermediate state, i.e. one more more decoders are currently
1955        // flushing or shutting down.
1956
1957        if (mFlushingAudio != NONE || mFlushingVideo != NONE) {
1958            // We're currently flushing, postpone the reset until that's
1959            // completed.
1960
1961            ALOGV("postponing action mFlushingAudio=%d, mFlushingVideo=%d",
1962                  mFlushingAudio, mFlushingVideo);
1963
1964            break;
1965        }
1966
1967        sp<Action> action = *mDeferredActions.begin();
1968        mDeferredActions.erase(mDeferredActions.begin());
1969
1970        action->execute(this);
1971    }
1972}
1973
1974void NuPlayer::performSeek(int64_t seekTimeUs) {
1975    ALOGV("performSeek seekTimeUs=%lld us (%.2f secs)",
1976          (long long)seekTimeUs,
1977          seekTimeUs / 1E6);
1978
1979    if (mSource == NULL) {
1980        // This happens when reset occurs right before the loop mode
1981        // asynchronously seeks to the start of the stream.
1982        LOG_ALWAYS_FATAL_IF(mAudioDecoder != NULL || mVideoDecoder != NULL,
1983                "mSource is NULL and decoders not NULL audio(%p) video(%p)",
1984                mAudioDecoder.get(), mVideoDecoder.get());
1985        return;
1986    }
1987    mPreviousSeekTimeUs = seekTimeUs;
1988    mSource->seekTo(seekTimeUs);
1989    ++mTimedTextGeneration;
1990
1991    // everything's flushed, continue playback.
1992}
1993
1994void NuPlayer::performDecoderFlush(FlushCommand audio, FlushCommand video) {
1995    ALOGV("performDecoderFlush audio=%d, video=%d", audio, video);
1996
1997    if ((audio == FLUSH_CMD_NONE || mAudioDecoder == NULL)
1998            && (video == FLUSH_CMD_NONE || mVideoDecoder == NULL)) {
1999        return;
2000    }
2001
2002    if (audio != FLUSH_CMD_NONE && mAudioDecoder != NULL) {
2003        flushDecoder(true /* audio */, (audio == FLUSH_CMD_SHUTDOWN));
2004    }
2005
2006    if (video != FLUSH_CMD_NONE && mVideoDecoder != NULL) {
2007        flushDecoder(false /* audio */, (video == FLUSH_CMD_SHUTDOWN));
2008    }
2009}
2010
2011void NuPlayer::performReset() {
2012    ALOGV("performReset");
2013
2014    CHECK(mAudioDecoder == NULL);
2015    CHECK(mVideoDecoder == NULL);
2016
2017    cancelPollDuration();
2018
2019    ++mScanSourcesGeneration;
2020    mScanSourcesPending = false;
2021
2022    if (mRendererLooper != NULL) {
2023        if (mRenderer != NULL) {
2024            mRendererLooper->unregisterHandler(mRenderer->id());
2025        }
2026        mRendererLooper->stop();
2027        mRendererLooper.clear();
2028    }
2029    mRenderer.clear();
2030    ++mRendererGeneration;
2031
2032    if (mSource != NULL) {
2033        mSource->stop();
2034
2035        Mutex::Autolock autoLock(mSourceLock);
2036        mSource.clear();
2037    }
2038
2039    if (mDriver != NULL) {
2040        sp<NuPlayerDriver> driver = mDriver.promote();
2041        if (driver != NULL) {
2042            driver->notifyResetComplete();
2043        }
2044    }
2045
2046    mStarted = false;
2047    mPrepared = false;
2048    mResetting = false;
2049    mSourceStarted = false;
2050}
2051
2052void NuPlayer::performScanSources() {
2053    ALOGV("performScanSources");
2054
2055    if (!mStarted) {
2056        return;
2057    }
2058
2059    if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
2060        postScanSources();
2061    }
2062}
2063
2064void NuPlayer::performSetSurface(const sp<Surface> &surface) {
2065    ALOGV("performSetSurface");
2066
2067    mSurface = surface;
2068
2069    // XXX - ignore error from setVideoScalingMode for now
2070    setVideoScalingMode(mVideoScalingMode);
2071
2072    if (mDriver != NULL) {
2073        sp<NuPlayerDriver> driver = mDriver.promote();
2074        if (driver != NULL) {
2075            driver->notifySetSurfaceComplete();
2076        }
2077    }
2078}
2079
2080void NuPlayer::performResumeDecoders(bool needNotify) {
2081    if (needNotify) {
2082        mResumePending = true;
2083        if (mVideoDecoder == NULL) {
2084            // if audio-only, we can notify seek complete now,
2085            // as the resume operation will be relatively fast.
2086            finishResume();
2087        }
2088    }
2089
2090    if (mVideoDecoder != NULL) {
2091        // When there is continuous seek, MediaPlayer will cache the seek
2092        // position, and send down new seek request when previous seek is
2093        // complete. Let's wait for at least one video output frame before
2094        // notifying seek complete, so that the video thumbnail gets updated
2095        // when seekbar is dragged.
2096        mVideoDecoder->signalResume(needNotify);
2097    }
2098
2099    if (mAudioDecoder != NULL) {
2100        mAudioDecoder->signalResume(false /* needNotify */);
2101    }
2102}
2103
2104void NuPlayer::finishResume() {
2105    if (mResumePending) {
2106        mResumePending = false;
2107        notifyDriverSeekComplete();
2108    }
2109}
2110
2111void NuPlayer::notifyDriverSeekComplete() {
2112    if (mDriver != NULL) {
2113        sp<NuPlayerDriver> driver = mDriver.promote();
2114        if (driver != NULL) {
2115            driver->notifySeekComplete();
2116        }
2117    }
2118}
2119
2120void NuPlayer::onSourceNotify(const sp<AMessage> &msg) {
2121    int32_t what;
2122    CHECK(msg->findInt32("what", &what));
2123
2124    switch (what) {
2125        case Source::kWhatInstantiateSecureDecoders:
2126        {
2127            if (mSource == NULL) {
2128                // This is a stale notification from a source that was
2129                // asynchronously preparing when the client called reset().
2130                // We handled the reset, the source is gone.
2131                break;
2132            }
2133
2134            sp<AMessage> reply;
2135            CHECK(msg->findMessage("reply", &reply));
2136            status_t err = onInstantiateSecureDecoders();
2137            reply->setInt32("err", err);
2138            reply->post();
2139            break;
2140        }
2141
2142        case Source::kWhatPrepared:
2143        {
2144            if (mSource == NULL) {
2145                // This is a stale notification from a source that was
2146                // asynchronously preparing when the client called reset().
2147                // We handled the reset, the source is gone.
2148                break;
2149            }
2150
2151            int32_t err;
2152            CHECK(msg->findInt32("err", &err));
2153
2154            if (err != OK) {
2155                // shut down potential secure codecs in case client never calls reset
2156                mDeferredActions.push_back(
2157                        new FlushDecoderAction(FLUSH_CMD_SHUTDOWN /* audio */,
2158                                               FLUSH_CMD_SHUTDOWN /* video */));
2159                processDeferredActions();
2160            } else {
2161                mPrepared = true;
2162            }
2163
2164            sp<NuPlayerDriver> driver = mDriver.promote();
2165            if (driver != NULL) {
2166                // notify duration first, so that it's definitely set when
2167                // the app received the "prepare complete" callback.
2168                int64_t durationUs;
2169                if (mSource->getDuration(&durationUs) == OK) {
2170                    driver->notifyDuration(durationUs);
2171                }
2172                driver->notifyPrepareCompleted(err);
2173            }
2174
2175            break;
2176        }
2177
2178        case Source::kWhatFlagsChanged:
2179        {
2180            uint32_t flags;
2181            CHECK(msg->findInt32("flags", (int32_t *)&flags));
2182
2183            sp<NuPlayerDriver> driver = mDriver.promote();
2184            if (driver != NULL) {
2185                if ((flags & NuPlayer::Source::FLAG_CAN_SEEK) == 0) {
2186                    driver->notifyListener(
2187                            MEDIA_INFO, MEDIA_INFO_NOT_SEEKABLE, 0);
2188                }
2189                driver->notifyFlagsChanged(flags);
2190            }
2191
2192            if ((mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2193                    && (!(flags & Source::FLAG_DYNAMIC_DURATION))) {
2194                cancelPollDuration();
2195            } else if (!(mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2196                    && (flags & Source::FLAG_DYNAMIC_DURATION)
2197                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
2198                schedulePollDuration();
2199            }
2200
2201            mSourceFlags = flags;
2202            break;
2203        }
2204
2205        case Source::kWhatVideoSizeChanged:
2206        {
2207            sp<AMessage> format;
2208            CHECK(msg->findMessage("format", &format));
2209
2210            updateVideoSize(format);
2211            break;
2212        }
2213
2214        case Source::kWhatBufferingUpdate:
2215        {
2216            int32_t percentage;
2217            CHECK(msg->findInt32("percentage", &percentage));
2218
2219            notifyListener(MEDIA_BUFFERING_UPDATE, percentage, 0);
2220            break;
2221        }
2222
2223        case Source::kWhatPauseOnBufferingStart:
2224        {
2225            // ignore if not playing
2226            if (mStarted) {
2227                ALOGI("buffer low, pausing...");
2228
2229                mPausedForBuffering = true;
2230                onPause();
2231            }
2232            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_START, 0);
2233            break;
2234        }
2235
2236        case Source::kWhatResumeOnBufferingEnd:
2237        {
2238            // ignore if not playing
2239            if (mStarted) {
2240                ALOGI("buffer ready, resuming...");
2241
2242                mPausedForBuffering = false;
2243
2244                // do not resume yet if client didn't unpause
2245                if (!mPausedByClient) {
2246                    onResume();
2247                }
2248            }
2249            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_END, 0);
2250            break;
2251        }
2252
2253        case Source::kWhatCacheStats:
2254        {
2255            int32_t kbps;
2256            CHECK(msg->findInt32("bandwidth", &kbps));
2257
2258            notifyListener(MEDIA_INFO, MEDIA_INFO_NETWORK_BANDWIDTH, kbps);
2259            break;
2260        }
2261
2262        case Source::kWhatSubtitleData:
2263        {
2264            sp<ABuffer> buffer;
2265            CHECK(msg->findBuffer("buffer", &buffer));
2266
2267            sendSubtitleData(buffer, 0 /* baseIndex */);
2268            break;
2269        }
2270
2271        case Source::kWhatTimedMetaData:
2272        {
2273            sp<ABuffer> buffer;
2274            if (!msg->findBuffer("buffer", &buffer)) {
2275                notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2276            } else {
2277                sendTimedMetaData(buffer);
2278            }
2279            break;
2280        }
2281
2282        case Source::kWhatTimedTextData:
2283        {
2284            int32_t generation;
2285            if (msg->findInt32("generation", &generation)
2286                    && generation != mTimedTextGeneration) {
2287                break;
2288            }
2289
2290            sp<ABuffer> buffer;
2291            CHECK(msg->findBuffer("buffer", &buffer));
2292
2293            sp<NuPlayerDriver> driver = mDriver.promote();
2294            if (driver == NULL) {
2295                break;
2296            }
2297
2298            int posMs;
2299            int64_t timeUs, posUs;
2300            driver->getCurrentPosition(&posMs);
2301            posUs = (int64_t) posMs * 1000ll;
2302            CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2303
2304            if (posUs < timeUs) {
2305                if (!msg->findInt32("generation", &generation)) {
2306                    msg->setInt32("generation", mTimedTextGeneration);
2307                }
2308                msg->post(timeUs - posUs);
2309            } else {
2310                sendTimedTextData(buffer);
2311            }
2312            break;
2313        }
2314
2315        case Source::kWhatQueueDecoderShutdown:
2316        {
2317            int32_t audio, video;
2318            CHECK(msg->findInt32("audio", &audio));
2319            CHECK(msg->findInt32("video", &video));
2320
2321            sp<AMessage> reply;
2322            CHECK(msg->findMessage("reply", &reply));
2323
2324            queueDecoderShutdown(audio, video, reply);
2325            break;
2326        }
2327
2328        case Source::kWhatDrmNoLicense:
2329        {
2330            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_DRM_NO_LICENSE);
2331            break;
2332        }
2333
2334        default:
2335            TRESPASS();
2336    }
2337}
2338
2339void NuPlayer::onClosedCaptionNotify(const sp<AMessage> &msg) {
2340    int32_t what;
2341    CHECK(msg->findInt32("what", &what));
2342
2343    switch (what) {
2344        case NuPlayer::CCDecoder::kWhatClosedCaptionData:
2345        {
2346            sp<ABuffer> buffer;
2347            CHECK(msg->findBuffer("buffer", &buffer));
2348
2349            size_t inbandTracks = 0;
2350            if (mSource != NULL) {
2351                inbandTracks = mSource->getTrackCount();
2352            }
2353
2354            sendSubtitleData(buffer, inbandTracks);
2355            break;
2356        }
2357
2358        case NuPlayer::CCDecoder::kWhatTrackAdded:
2359        {
2360            notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2361
2362            break;
2363        }
2364
2365        default:
2366            TRESPASS();
2367    }
2368
2369
2370}
2371
2372void NuPlayer::sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex) {
2373    int32_t trackIndex;
2374    int64_t timeUs, durationUs;
2375    CHECK(buffer->meta()->findInt32("trackIndex", &trackIndex));
2376    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2377    CHECK(buffer->meta()->findInt64("durationUs", &durationUs));
2378
2379    Parcel in;
2380    in.writeInt32(trackIndex + baseIndex);
2381    in.writeInt64(timeUs);
2382    in.writeInt64(durationUs);
2383    in.writeInt32(buffer->size());
2384    in.writeInt32(buffer->size());
2385    in.write(buffer->data(), buffer->size());
2386
2387    notifyListener(MEDIA_SUBTITLE_DATA, 0, 0, &in);
2388}
2389
2390void NuPlayer::sendTimedMetaData(const sp<ABuffer> &buffer) {
2391    int64_t timeUs;
2392    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2393
2394    Parcel in;
2395    in.writeInt64(timeUs);
2396    in.writeInt32(buffer->size());
2397    in.writeInt32(buffer->size());
2398    in.write(buffer->data(), buffer->size());
2399
2400    notifyListener(MEDIA_META_DATA, 0, 0, &in);
2401}
2402
2403void NuPlayer::sendTimedTextData(const sp<ABuffer> &buffer) {
2404    const void *data;
2405    size_t size = 0;
2406    int64_t timeUs;
2407    int32_t flag = TextDescriptions::IN_BAND_TEXT_3GPP;
2408
2409    AString mime;
2410    CHECK(buffer->meta()->findString("mime", &mime));
2411    CHECK(strcasecmp(mime.c_str(), MEDIA_MIMETYPE_TEXT_3GPP) == 0);
2412
2413    data = buffer->data();
2414    size = buffer->size();
2415
2416    Parcel parcel;
2417    if (size > 0) {
2418        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2419        int32_t global = 0;
2420        if (buffer->meta()->findInt32("global", &global) && global) {
2421            flag |= TextDescriptions::GLOBAL_DESCRIPTIONS;
2422        } else {
2423            flag |= TextDescriptions::LOCAL_DESCRIPTIONS;
2424        }
2425        TextDescriptions::getParcelOfDescriptions(
2426                (const uint8_t *)data, size, flag, timeUs / 1000, &parcel);
2427    }
2428
2429    if ((parcel.dataSize() > 0)) {
2430        notifyListener(MEDIA_TIMED_TEXT, 0, 0, &parcel);
2431    } else {  // send an empty timed text
2432        notifyListener(MEDIA_TIMED_TEXT, 0, 0);
2433    }
2434}
2435////////////////////////////////////////////////////////////////////////////////
2436
2437sp<AMessage> NuPlayer::Source::getFormat(bool audio) {
2438    sp<MetaData> meta = getFormatMeta(audio);
2439
2440    if (meta == NULL) {
2441        return NULL;
2442    }
2443
2444    sp<AMessage> msg = new AMessage;
2445
2446    if(convertMetaDataToMessage(meta, &msg) == OK) {
2447        return msg;
2448    }
2449    return NULL;
2450}
2451
2452void NuPlayer::Source::notifyFlagsChanged(uint32_t flags) {
2453    sp<AMessage> notify = dupNotify();
2454    notify->setInt32("what", kWhatFlagsChanged);
2455    notify->setInt32("flags", flags);
2456    notify->post();
2457}
2458
2459void NuPlayer::Source::notifyVideoSizeChanged(const sp<AMessage> &format) {
2460    sp<AMessage> notify = dupNotify();
2461    notify->setInt32("what", kWhatVideoSizeChanged);
2462    notify->setMessage("format", format);
2463    notify->post();
2464}
2465
2466void NuPlayer::Source::notifyPrepared(status_t err) {
2467    sp<AMessage> notify = dupNotify();
2468    notify->setInt32("what", kWhatPrepared);
2469    notify->setInt32("err", err);
2470    notify->post();
2471}
2472
2473void NuPlayer::Source::notifyInstantiateSecureDecoders(const sp<AMessage> &reply) {
2474    sp<AMessage> notify = dupNotify();
2475    notify->setInt32("what", kWhatInstantiateSecureDecoders);
2476    notify->setMessage("reply", reply);
2477    notify->post();
2478}
2479
2480void NuPlayer::Source::onMessageReceived(const sp<AMessage> & /* msg */) {
2481    TRESPASS();
2482}
2483
2484}  // namespace android
2485