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