NuPlayer.cpp revision 41cd463de0e5d7fd5d1ac2b537226ab209529760 
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      mResetting(false),
192      mSourceStarted(false),
193      mPaused(false),
194      mPausedByClient(true),
195      mPendingBufferingFlag(PENDING_BUFFERING_FLAG_NONE),
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            if (mPendingBufferingFlag != PENDING_BUFFERING_FLAG_NONE) {
727                notifyListener(MEDIA_INFO, mPendingBufferingFlag, 0);
728                mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
729            }
730            break;
731        }
732
733        case kWhatConfigPlayback:
734        {
735            sp<AReplyToken> replyID;
736            CHECK(msg->senderAwaitsResponse(&replyID));
737            AudioPlaybackRate rate /* sanitized */;
738            readFromAMessage(msg, &rate);
739            status_t err = OK;
740            if (mRenderer != NULL) {
741                // AudioSink allows only 1.f and 0.f for offload mode.
742                // For other speed, switch to non-offload mode.
743                if (mOffloadAudio && ((rate.mSpeed != 0.f && rate.mSpeed != 1.f)
744                        || rate.mPitch != 1.f)) {
745                    int64_t currentPositionUs;
746                    if (getCurrentPosition(&currentPositionUs) != OK) {
747                        currentPositionUs = mPreviousSeekTimeUs;
748                    }
749
750                    // Set mPlaybackSettings so that the new audio decoder can
751                    // be created correctly.
752                    mPlaybackSettings = rate;
753                    if (!mPaused) {
754                        mRenderer->pause();
755                    }
756                    restartAudio(
757                            currentPositionUs, true /* forceNonOffload */,
758                            true /* needsToCreateAudioDecoder */);
759                    if (!mPaused) {
760                        mRenderer->resume();
761                    }
762                }
763
764                err = mRenderer->setPlaybackSettings(rate);
765            }
766            if (err == OK) {
767                if (rate.mSpeed == 0.f) {
768                    onPause();
769                    mPausedByClient = true;
770                    // save all other settings (using non-paused speed)
771                    // so we can restore them on start
772                    AudioPlaybackRate newRate = rate;
773                    newRate.mSpeed = mPlaybackSettings.mSpeed;
774                    mPlaybackSettings = newRate;
775                } else { /* rate.mSpeed != 0.f */
776                    onResume();
777                    mPausedByClient = false;
778                    mPlaybackSettings = rate;
779                }
780            }
781
782            if (mVideoDecoder != NULL) {
783                float rate = getFrameRate();
784                if (rate > 0) {
785                    sp<AMessage> params = new AMessage();
786                    params->setFloat("operating-rate", rate * mPlaybackSettings.mSpeed);
787                    mVideoDecoder->setParameters(params);
788                }
789            }
790
791            sp<AMessage> response = new AMessage;
792            response->setInt32("err", err);
793            response->postReply(replyID);
794            break;
795        }
796
797        case kWhatGetPlaybackSettings:
798        {
799            sp<AReplyToken> replyID;
800            CHECK(msg->senderAwaitsResponse(&replyID));
801            AudioPlaybackRate rate = mPlaybackSettings;
802            status_t err = OK;
803            if (mRenderer != NULL) {
804                err = mRenderer->getPlaybackSettings(&rate);
805            }
806            if (err == OK) {
807                // get playback settings used by renderer, as it may be
808                // slightly off due to audiosink not taking small changes.
809                mPlaybackSettings = rate;
810                if (mPaused) {
811                    rate.mSpeed = 0.f;
812                }
813            }
814            sp<AMessage> response = new AMessage;
815            if (err == OK) {
816                writeToAMessage(response, rate);
817            }
818            response->setInt32("err", err);
819            response->postReply(replyID);
820            break;
821        }
822
823        case kWhatConfigSync:
824        {
825            sp<AReplyToken> replyID;
826            CHECK(msg->senderAwaitsResponse(&replyID));
827
828            ALOGV("kWhatConfigSync");
829            AVSyncSettings sync;
830            float videoFpsHint;
831            readFromAMessage(msg, &sync, &videoFpsHint);
832            status_t err = OK;
833            if (mRenderer != NULL) {
834                err = mRenderer->setSyncSettings(sync, videoFpsHint);
835            }
836            if (err == OK) {
837                mSyncSettings = sync;
838                mVideoFpsHint = videoFpsHint;
839            }
840            sp<AMessage> response = new AMessage;
841            response->setInt32("err", err);
842            response->postReply(replyID);
843            break;
844        }
845
846        case kWhatGetSyncSettings:
847        {
848            sp<AReplyToken> replyID;
849            CHECK(msg->senderAwaitsResponse(&replyID));
850            AVSyncSettings sync = mSyncSettings;
851            float videoFps = mVideoFpsHint;
852            status_t err = OK;
853            if (mRenderer != NULL) {
854                err = mRenderer->getSyncSettings(&sync, &videoFps);
855                if (err == OK) {
856                    mSyncSettings = sync;
857                    mVideoFpsHint = videoFps;
858                }
859            }
860            sp<AMessage> response = new AMessage;
861            if (err == OK) {
862                writeToAMessage(response, sync, videoFps);
863            }
864            response->setInt32("err", err);
865            response->postReply(replyID);
866            break;
867        }
868
869        case kWhatScanSources:
870        {
871            int32_t generation;
872            CHECK(msg->findInt32("generation", &generation));
873            if (generation != mScanSourcesGeneration) {
874                // Drop obsolete msg.
875                break;
876            }
877
878            mScanSourcesPending = false;
879
880            ALOGV("scanning sources haveAudio=%d, haveVideo=%d",
881                 mAudioDecoder != NULL, mVideoDecoder != NULL);
882
883            bool mHadAnySourcesBefore =
884                (mAudioDecoder != NULL) || (mVideoDecoder != NULL);
885            bool rescan = false;
886
887            // initialize video before audio because successful initialization of
888            // video may change deep buffer mode of audio.
889            if (mSurface != NULL) {
890                if (instantiateDecoder(false, &mVideoDecoder) == -EWOULDBLOCK) {
891                    rescan = true;
892                }
893            }
894
895            // Don't try to re-open audio sink if there's an existing decoder.
896            if (mAudioSink != NULL && mAudioDecoder == NULL) {
897                if (instantiateDecoder(true, &mAudioDecoder) == -EWOULDBLOCK) {
898                    rescan = true;
899                }
900            }
901
902            if (!mHadAnySourcesBefore
903                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
904                // This is the first time we've found anything playable.
905
906                if (mSourceFlags & Source::FLAG_DYNAMIC_DURATION) {
907                    schedulePollDuration();
908                }
909            }
910
911            status_t err;
912            if ((err = mSource->feedMoreTSData()) != OK) {
913                if (mAudioDecoder == NULL && mVideoDecoder == NULL) {
914                    // We're not currently decoding anything (no audio or
915                    // video tracks found) and we just ran out of input data.
916
917                    if (err == ERROR_END_OF_STREAM) {
918                        notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
919                    } else {
920                        notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
921                    }
922                }
923                break;
924            }
925
926            if (rescan) {
927                msg->post(100000ll);
928                mScanSourcesPending = true;
929            }
930            break;
931        }
932
933        case kWhatVideoNotify:
934        case kWhatAudioNotify:
935        {
936            bool audio = msg->what() == kWhatAudioNotify;
937
938            int32_t currentDecoderGeneration =
939                (audio? mAudioDecoderGeneration : mVideoDecoderGeneration);
940            int32_t requesterGeneration = currentDecoderGeneration - 1;
941            CHECK(msg->findInt32("generation", &requesterGeneration));
942
943            if (requesterGeneration != currentDecoderGeneration) {
944                ALOGV("got message from old %s decoder, generation(%d:%d)",
945                        audio ? "audio" : "video", requesterGeneration,
946                        currentDecoderGeneration);
947                sp<AMessage> reply;
948                if (!(msg->findMessage("reply", &reply))) {
949                    return;
950                }
951
952                reply->setInt32("err", INFO_DISCONTINUITY);
953                reply->post();
954                return;
955            }
956
957            int32_t what;
958            CHECK(msg->findInt32("what", &what));
959
960            if (what == DecoderBase::kWhatInputDiscontinuity) {
961                int32_t formatChange;
962                CHECK(msg->findInt32("formatChange", &formatChange));
963
964                ALOGV("%s discontinuity: formatChange %d",
965                        audio ? "audio" : "video", formatChange);
966
967                if (formatChange) {
968                    mDeferredActions.push_back(
969                            new FlushDecoderAction(
970                                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
971                                audio ? FLUSH_CMD_NONE : FLUSH_CMD_SHUTDOWN));
972                }
973
974                mDeferredActions.push_back(
975                        new SimpleAction(
976                                &NuPlayer::performScanSources));
977
978                processDeferredActions();
979            } else if (what == DecoderBase::kWhatEOS) {
980                int32_t err;
981                CHECK(msg->findInt32("err", &err));
982
983                if (err == ERROR_END_OF_STREAM) {
984                    ALOGV("got %s decoder EOS", audio ? "audio" : "video");
985                } else {
986                    ALOGV("got %s decoder EOS w/ error %d",
987                         audio ? "audio" : "video",
988                         err);
989                }
990
991                mRenderer->queueEOS(audio, err);
992            } else if (what == DecoderBase::kWhatFlushCompleted) {
993                ALOGV("decoder %s flush completed", audio ? "audio" : "video");
994
995                handleFlushComplete(audio, true /* isDecoder */);
996                finishFlushIfPossible();
997            } else if (what == DecoderBase::kWhatVideoSizeChanged) {
998                sp<AMessage> format;
999                CHECK(msg->findMessage("format", &format));
1000
1001                sp<AMessage> inputFormat =
1002                        mSource->getFormat(false /* audio */);
1003
1004                updateVideoSize(inputFormat, format);
1005            } else if (what == DecoderBase::kWhatShutdownCompleted) {
1006                ALOGV("%s shutdown completed", audio ? "audio" : "video");
1007                if (audio) {
1008                    mAudioDecoder.clear();
1009                    ++mAudioDecoderGeneration;
1010
1011                    CHECK_EQ((int)mFlushingAudio, (int)SHUTTING_DOWN_DECODER);
1012                    mFlushingAudio = SHUT_DOWN;
1013                } else {
1014                    mVideoDecoder.clear();
1015                    ++mVideoDecoderGeneration;
1016
1017                    CHECK_EQ((int)mFlushingVideo, (int)SHUTTING_DOWN_DECODER);
1018                    mFlushingVideo = SHUT_DOWN;
1019                }
1020
1021                finishFlushIfPossible();
1022            } else if (what == DecoderBase::kWhatResumeCompleted) {
1023                finishResume();
1024            } else if (what == DecoderBase::kWhatError) {
1025                status_t err;
1026                if (!msg->findInt32("err", &err) || err == OK) {
1027                    err = UNKNOWN_ERROR;
1028                }
1029
1030                // Decoder errors can be due to Source (e.g. from streaming),
1031                // or from decoding corrupted bitstreams, or from other decoder
1032                // MediaCodec operations (e.g. from an ongoing reset or seek).
1033                // They may also be due to openAudioSink failure at
1034                // decoder start or after a format change.
1035                //
1036                // We try to gracefully shut down the affected decoder if possible,
1037                // rather than trying to force the shutdown with something
1038                // similar to performReset(). This method can lead to a hang
1039                // if MediaCodec functions block after an error, but they should
1040                // typically return INVALID_OPERATION instead of blocking.
1041
1042                FlushStatus *flushing = audio ? &mFlushingAudio : &mFlushingVideo;
1043                ALOGE("received error(%#x) from %s decoder, flushing(%d), now shutting down",
1044                        err, audio ? "audio" : "video", *flushing);
1045
1046                switch (*flushing) {
1047                    case NONE:
1048                        mDeferredActions.push_back(
1049                                new FlushDecoderAction(
1050                                    audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1051                                    audio ? FLUSH_CMD_NONE : FLUSH_CMD_SHUTDOWN));
1052                        processDeferredActions();
1053                        break;
1054                    case FLUSHING_DECODER:
1055                        *flushing = FLUSHING_DECODER_SHUTDOWN; // initiate shutdown after flush.
1056                        break; // Wait for flush to complete.
1057                    case FLUSHING_DECODER_SHUTDOWN:
1058                        break; // Wait for flush to complete.
1059                    case SHUTTING_DOWN_DECODER:
1060                        break; // Wait for shutdown to complete.
1061                    case FLUSHED:
1062                        // Widevine source reads must stop before releasing the video decoder.
1063                        if (!audio && mSource != NULL && mSourceFlags & Source::FLAG_SECURE) {
1064                            mSource->stop();
1065                            mSourceStarted = false;
1066                        }
1067                        getDecoder(audio)->initiateShutdown(); // In the middle of a seek.
1068                        *flushing = SHUTTING_DOWN_DECODER;     // Shut down.
1069                        break;
1070                    case SHUT_DOWN:
1071                        finishFlushIfPossible();  // Should not occur.
1072                        break;                    // Finish anyways.
1073                }
1074                notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
1075            } else {
1076                ALOGV("Unhandled decoder notification %d '%c%c%c%c'.",
1077                      what,
1078                      what >> 24,
1079                      (what >> 16) & 0xff,
1080                      (what >> 8) & 0xff,
1081                      what & 0xff);
1082            }
1083
1084            break;
1085        }
1086
1087        case kWhatRendererNotify:
1088        {
1089            int32_t requesterGeneration = mRendererGeneration - 1;
1090            CHECK(msg->findInt32("generation", &requesterGeneration));
1091            if (requesterGeneration != mRendererGeneration) {
1092                ALOGV("got message from old renderer, generation(%d:%d)",
1093                        requesterGeneration, mRendererGeneration);
1094                return;
1095            }
1096
1097            int32_t what;
1098            CHECK(msg->findInt32("what", &what));
1099
1100            if (what == Renderer::kWhatEOS) {
1101                int32_t audio;
1102                CHECK(msg->findInt32("audio", &audio));
1103
1104                int32_t finalResult;
1105                CHECK(msg->findInt32("finalResult", &finalResult));
1106
1107                if (audio) {
1108                    mAudioEOS = true;
1109                } else {
1110                    mVideoEOS = true;
1111                }
1112
1113                if (finalResult == ERROR_END_OF_STREAM) {
1114                    ALOGV("reached %s EOS", audio ? "audio" : "video");
1115                } else {
1116                    ALOGE("%s track encountered an error (%d)",
1117                         audio ? "audio" : "video", finalResult);
1118
1119                    notifyListener(
1120                            MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, finalResult);
1121                }
1122
1123                if ((mAudioEOS || mAudioDecoder == NULL)
1124                        && (mVideoEOS || mVideoDecoder == NULL)) {
1125                    notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0);
1126                }
1127            } else if (what == Renderer::kWhatFlushComplete) {
1128                int32_t audio;
1129                CHECK(msg->findInt32("audio", &audio));
1130
1131                if (audio) {
1132                    mAudioEOS = false;
1133                } else {
1134                    mVideoEOS = false;
1135                }
1136
1137                ALOGV("renderer %s flush completed.", audio ? "audio" : "video");
1138                if (audio && (mFlushingAudio == NONE || mFlushingAudio == FLUSHED
1139                        || mFlushingAudio == SHUT_DOWN)) {
1140                    // Flush has been handled by tear down.
1141                    break;
1142                }
1143                handleFlushComplete(audio, false /* isDecoder */);
1144                finishFlushIfPossible();
1145            } else if (what == Renderer::kWhatVideoRenderingStart) {
1146                notifyListener(MEDIA_INFO, MEDIA_INFO_RENDERING_START, 0);
1147            } else if (what == Renderer::kWhatMediaRenderingStart) {
1148                ALOGV("media rendering started");
1149                notifyListener(MEDIA_STARTED, 0, 0);
1150            } else if (what == Renderer::kWhatAudioTearDown) {
1151                int32_t reason;
1152                CHECK(msg->findInt32("reason", &reason));
1153                ALOGV("Tear down audio with reason %d.", reason);
1154                if (reason == Renderer::kDueToTimeout && !(mPaused && mOffloadAudio)) {
1155                    // TimeoutWhenPaused is only for offload mode.
1156                    ALOGW("Receive a stale message for teardown.");
1157                    break;
1158                }
1159                int64_t positionUs;
1160                if (!msg->findInt64("positionUs", &positionUs)) {
1161                    positionUs = mPreviousSeekTimeUs;
1162                }
1163
1164                restartAudio(
1165                        positionUs, reason == Renderer::kForceNonOffload /* forceNonOffload */,
1166                        reason != Renderer::kDueToTimeout /* needsToCreateAudioDecoder */);
1167            }
1168            break;
1169        }
1170
1171        case kWhatMoreDataQueued:
1172        {
1173            break;
1174        }
1175
1176        case kWhatReset:
1177        {
1178            ALOGV("kWhatReset");
1179
1180            mResetting = true;
1181
1182            mDeferredActions.push_back(
1183                    new FlushDecoderAction(
1184                        FLUSH_CMD_SHUTDOWN /* audio */,
1185                        FLUSH_CMD_SHUTDOWN /* video */));
1186
1187            mDeferredActions.push_back(
1188                    new SimpleAction(&NuPlayer::performReset));
1189
1190            processDeferredActions();
1191            break;
1192        }
1193
1194        case kWhatSeek:
1195        {
1196            int64_t seekTimeUs;
1197            int32_t needNotify;
1198            CHECK(msg->findInt64("seekTimeUs", &seekTimeUs));
1199            CHECK(msg->findInt32("needNotify", &needNotify));
1200
1201            ALOGV("kWhatSeek seekTimeUs=%lld us, needNotify=%d",
1202                    (long long)seekTimeUs, needNotify);
1203
1204            if (!mStarted) {
1205                // Seek before the player is started. In order to preview video,
1206                // need to start the player and pause it. This branch is called
1207                // only once if needed. After the player is started, any seek
1208                // operation will go through normal path.
1209                // Audio-only cases are handled separately.
1210                onStart(seekTimeUs);
1211                if (mStarted) {
1212                    onPause();
1213                    mPausedByClient = true;
1214                }
1215                if (needNotify) {
1216                    notifyDriverSeekComplete();
1217                }
1218                break;
1219            }
1220
1221            mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
1222
1223            mDeferredActions.push_back(
1224                    new FlushDecoderAction(FLUSH_CMD_FLUSH /* audio */,
1225                                           FLUSH_CMD_FLUSH /* video */));
1226
1227            mDeferredActions.push_back(
1228                    new SeekAction(seekTimeUs));
1229
1230            // After a flush without shutdown, decoder is paused.
1231            // Don't resume it until source seek is done, otherwise it could
1232            // start pulling stale data too soon.
1233            mDeferredActions.push_back(
1234                    new ResumeDecoderAction(needNotify));
1235
1236            processDeferredActions();
1237            break;
1238        }
1239
1240        case kWhatPause:
1241        {
1242            onPause();
1243            mPausedByClient = true;
1244            break;
1245        }
1246
1247        case kWhatSourceNotify:
1248        {
1249            onSourceNotify(msg);
1250            break;
1251        }
1252
1253        case kWhatClosedCaptionNotify:
1254        {
1255            onClosedCaptionNotify(msg);
1256            break;
1257        }
1258
1259        default:
1260            TRESPASS();
1261            break;
1262    }
1263}
1264
1265void NuPlayer::onResume() {
1266    if (!mPaused || mResetting) {
1267        ALOGD_IF(mResetting, "resetting, onResume discarded");
1268        return;
1269    }
1270    mPaused = false;
1271    if (mSource != NULL) {
1272        mSource->resume();
1273    } else {
1274        ALOGW("resume called when source is gone or not set");
1275    }
1276    // |mAudioDecoder| may have been released due to the pause timeout, so re-create it if
1277    // needed.
1278    if (audioDecoderStillNeeded() && mAudioDecoder == NULL) {
1279        instantiateDecoder(true /* audio */, &mAudioDecoder);
1280    }
1281    if (mRenderer != NULL) {
1282        mRenderer->resume();
1283    } else {
1284        ALOGW("resume called when renderer is gone or not set");
1285    }
1286}
1287
1288status_t NuPlayer::onInstantiateSecureDecoders() {
1289    status_t err;
1290    if (!(mSourceFlags & Source::FLAG_SECURE)) {
1291        return BAD_TYPE;
1292    }
1293
1294    if (mRenderer != NULL) {
1295        ALOGE("renderer should not be set when instantiating secure decoders");
1296        return UNKNOWN_ERROR;
1297    }
1298
1299    // TRICKY: We rely on mRenderer being null, so that decoder does not start requesting
1300    // data on instantiation.
1301    if (mSurface != NULL) {
1302        err = instantiateDecoder(false, &mVideoDecoder);
1303        if (err != OK) {
1304            return err;
1305        }
1306    }
1307
1308    if (mAudioSink != NULL) {
1309        err = instantiateDecoder(true, &mAudioDecoder);
1310        if (err != OK) {
1311            return err;
1312        }
1313    }
1314    return OK;
1315}
1316
1317void NuPlayer::onStart(int64_t startPositionUs) {
1318    if (!mSourceStarted) {
1319        mSourceStarted = true;
1320        mSource->start();
1321    }
1322    if (startPositionUs > 0) {
1323        performSeek(startPositionUs);
1324        if (mSource->getFormat(false /* audio */) == NULL) {
1325            return;
1326        }
1327    }
1328
1329    mOffloadAudio = false;
1330    mAudioEOS = false;
1331    mVideoEOS = false;
1332    mStarted = true;
1333
1334    uint32_t flags = 0;
1335
1336    if (mSource->isRealTime()) {
1337        flags |= Renderer::FLAG_REAL_TIME;
1338    }
1339
1340    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1341    ALOGV_IF(audioMeta == NULL, "no metadata for audio source");  // video only stream
1342    audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
1343    if (mAudioSink != NULL) {
1344        streamType = mAudioSink->getAudioStreamType();
1345    }
1346
1347    sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
1348
1349    mOffloadAudio =
1350        canOffloadStream(audioMeta, (videoFormat != NULL), mSource->isStreaming(), streamType)
1351                && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
1352    if (mOffloadAudio) {
1353        flags |= Renderer::FLAG_OFFLOAD_AUDIO;
1354    }
1355
1356    sp<AMessage> notify = new AMessage(kWhatRendererNotify, this);
1357    ++mRendererGeneration;
1358    notify->setInt32("generation", mRendererGeneration);
1359    mRenderer = new Renderer(mAudioSink, notify, flags);
1360    mRendererLooper = new ALooper;
1361    mRendererLooper->setName("NuPlayerRenderer");
1362    mRendererLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
1363    mRendererLooper->registerHandler(mRenderer);
1364
1365    status_t err = mRenderer->setPlaybackSettings(mPlaybackSettings);
1366    if (err != OK) {
1367        mSource->stop();
1368        mSourceStarted = false;
1369        notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
1370        return;
1371    }
1372
1373    float rate = getFrameRate();
1374    if (rate > 0) {
1375        mRenderer->setVideoFrameRate(rate);
1376    }
1377
1378    if (mVideoDecoder != NULL) {
1379        mVideoDecoder->setRenderer(mRenderer);
1380    }
1381    if (mAudioDecoder != NULL) {
1382        mAudioDecoder->setRenderer(mRenderer);
1383    }
1384
1385    postScanSources();
1386}
1387
1388void NuPlayer::onPause() {
1389    if (mPaused) {
1390        return;
1391    }
1392    mPaused = true;
1393    if (mSource != NULL) {
1394        mSource->pause();
1395    } else {
1396        ALOGW("pause called when source is gone or not set");
1397    }
1398    if (mRenderer != NULL) {
1399        mRenderer->pause();
1400    } else {
1401        ALOGW("pause called when renderer is gone or not set");
1402    }
1403}
1404
1405bool NuPlayer::audioDecoderStillNeeded() {
1406    // Audio decoder is no longer needed if it's in shut/shutting down status.
1407    return ((mFlushingAudio != SHUT_DOWN) && (mFlushingAudio != SHUTTING_DOWN_DECODER));
1408}
1409
1410void NuPlayer::handleFlushComplete(bool audio, bool isDecoder) {
1411    // We wait for both the decoder flush and the renderer flush to complete
1412    // before entering either the FLUSHED or the SHUTTING_DOWN_DECODER state.
1413
1414    mFlushComplete[audio][isDecoder] = true;
1415    if (!mFlushComplete[audio][!isDecoder]) {
1416        return;
1417    }
1418
1419    FlushStatus *state = audio ? &mFlushingAudio : &mFlushingVideo;
1420    switch (*state) {
1421        case FLUSHING_DECODER:
1422        {
1423            *state = FLUSHED;
1424            break;
1425        }
1426
1427        case FLUSHING_DECODER_SHUTDOWN:
1428        {
1429            *state = SHUTTING_DOWN_DECODER;
1430
1431            ALOGV("initiating %s decoder shutdown", audio ? "audio" : "video");
1432            if (!audio) {
1433                // Widevine source reads must stop before releasing the video decoder.
1434                if (mSource != NULL && mSourceFlags & Source::FLAG_SECURE) {
1435                    mSource->stop();
1436                    mSourceStarted = false;
1437                }
1438            }
1439            getDecoder(audio)->initiateShutdown();
1440            break;
1441        }
1442
1443        default:
1444            // decoder flush completes only occur in a flushing state.
1445            LOG_ALWAYS_FATAL_IF(isDecoder, "decoder flush in invalid state %d", *state);
1446            break;
1447    }
1448}
1449
1450void NuPlayer::finishFlushIfPossible() {
1451    if (mFlushingAudio != NONE && mFlushingAudio != FLUSHED
1452            && mFlushingAudio != SHUT_DOWN) {
1453        return;
1454    }
1455
1456    if (mFlushingVideo != NONE && mFlushingVideo != FLUSHED
1457            && mFlushingVideo != SHUT_DOWN) {
1458        return;
1459    }
1460
1461    ALOGV("both audio and video are flushed now.");
1462
1463    mFlushingAudio = NONE;
1464    mFlushingVideo = NONE;
1465
1466    clearFlushComplete();
1467
1468    processDeferredActions();
1469}
1470
1471void NuPlayer::postScanSources() {
1472    if (mScanSourcesPending) {
1473        return;
1474    }
1475
1476    sp<AMessage> msg = new AMessage(kWhatScanSources, this);
1477    msg->setInt32("generation", mScanSourcesGeneration);
1478    msg->post();
1479
1480    mScanSourcesPending = true;
1481}
1482
1483void NuPlayer::tryOpenAudioSinkForOffload(
1484        const sp<AMessage> &format, const sp<MetaData> &audioMeta, bool hasVideo) {
1485    // Note: This is called early in NuPlayer to determine whether offloading
1486    // is possible; otherwise the decoders call the renderer openAudioSink directly.
1487
1488    status_t err = mRenderer->openAudioSink(
1489            format, true /* offloadOnly */, hasVideo, AUDIO_OUTPUT_FLAG_NONE, &mOffloadAudio);
1490    if (err != OK) {
1491        // Any failure we turn off mOffloadAudio.
1492        mOffloadAudio = false;
1493    } else if (mOffloadAudio) {
1494        sendMetaDataToHal(mAudioSink, audioMeta);
1495    }
1496}
1497
1498void NuPlayer::closeAudioSink() {
1499    mRenderer->closeAudioSink();
1500}
1501
1502void NuPlayer::restartAudio(
1503        int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder) {
1504    if (mAudioDecoder != NULL) {
1505        mAudioDecoder->pause();
1506        mAudioDecoder.clear();
1507        ++mAudioDecoderGeneration;
1508    }
1509    if (mFlushingAudio == FLUSHING_DECODER) {
1510        mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
1511        mFlushingAudio = FLUSHED;
1512        finishFlushIfPossible();
1513    } else if (mFlushingAudio == FLUSHING_DECODER_SHUTDOWN
1514            || mFlushingAudio == SHUTTING_DOWN_DECODER) {
1515        mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
1516        mFlushingAudio = SHUT_DOWN;
1517        finishFlushIfPossible();
1518        needsToCreateAudioDecoder = false;
1519    }
1520    if (mRenderer == NULL) {
1521        return;
1522    }
1523    closeAudioSink();
1524    mRenderer->flush(true /* audio */, false /* notifyComplete */);
1525    if (mVideoDecoder != NULL) {
1526        mRenderer->flush(false /* audio */, false /* notifyComplete */);
1527    }
1528
1529    performSeek(currentPositionUs);
1530
1531    if (forceNonOffload) {
1532        mRenderer->signalDisableOffloadAudio();
1533        mOffloadAudio = false;
1534    }
1535    if (needsToCreateAudioDecoder) {
1536        instantiateDecoder(true /* audio */, &mAudioDecoder, !forceNonOffload);
1537    }
1538}
1539
1540void NuPlayer::determineAudioModeChange(const sp<AMessage> &audioFormat) {
1541    if (mSource == NULL || mAudioSink == NULL) {
1542        return;
1543    }
1544
1545    if (mRenderer == NULL) {
1546        ALOGW("No renderer can be used to determine audio mode. Use non-offload for safety.");
1547        mOffloadAudio = false;
1548        return;
1549    }
1550
1551    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1552    sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
1553    audio_stream_type_t streamType = mAudioSink->getAudioStreamType();
1554    const bool hasVideo = (videoFormat != NULL);
1555    const bool canOffload = canOffloadStream(
1556            audioMeta, hasVideo, mSource->isStreaming(), streamType)
1557                    && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
1558    if (canOffload) {
1559        if (!mOffloadAudio) {
1560            mRenderer->signalEnableOffloadAudio();
1561        }
1562        // open audio sink early under offload mode.
1563        tryOpenAudioSinkForOffload(audioFormat, audioMeta, hasVideo);
1564    } else {
1565        if (mOffloadAudio) {
1566            mRenderer->signalDisableOffloadAudio();
1567            mOffloadAudio = false;
1568        }
1569    }
1570}
1571
1572status_t NuPlayer::instantiateDecoder(
1573        bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange) {
1574    // The audio decoder could be cleared by tear down. If still in shut down
1575    // process, no need to create a new audio decoder.
1576    if (*decoder != NULL || (audio && mFlushingAudio == SHUT_DOWN)) {
1577        return OK;
1578    }
1579
1580    sp<AMessage> format = mSource->getFormat(audio);
1581
1582    if (format == NULL) {
1583        return UNKNOWN_ERROR;
1584    } else {
1585        status_t err;
1586        if (format->findInt32("err", &err) && err) {
1587            return err;
1588        }
1589    }
1590
1591    format->setInt32("priority", 0 /* realtime */);
1592
1593    if (!audio) {
1594        AString mime;
1595        CHECK(format->findString("mime", &mime));
1596
1597        sp<AMessage> ccNotify = new AMessage(kWhatClosedCaptionNotify, this);
1598        if (mCCDecoder == NULL) {
1599            mCCDecoder = new CCDecoder(ccNotify);
1600        }
1601
1602        if (mSourceFlags & Source::FLAG_SECURE) {
1603            format->setInt32("secure", true);
1604        }
1605
1606        if (mSourceFlags & Source::FLAG_PROTECTED) {
1607            format->setInt32("protected", true);
1608        }
1609
1610        float rate = getFrameRate();
1611        if (rate > 0) {
1612            format->setFloat("operating-rate", rate * mPlaybackSettings.mSpeed);
1613        }
1614    }
1615
1616    if (audio) {
1617        sp<AMessage> notify = new AMessage(kWhatAudioNotify, this);
1618        ++mAudioDecoderGeneration;
1619        notify->setInt32("generation", mAudioDecoderGeneration);
1620
1621        if (checkAudioModeChange) {
1622            determineAudioModeChange(format);
1623        }
1624        if (mOffloadAudio) {
1625            mSource->setOffloadAudio(true /* offload */);
1626
1627            const bool hasVideo = (mSource->getFormat(false /*audio */) != NULL);
1628            format->setInt32("has-video", hasVideo);
1629            *decoder = new DecoderPassThrough(notify, mSource, mRenderer);
1630        } else {
1631            mSource->setOffloadAudio(false /* offload */);
1632
1633            *decoder = new Decoder(notify, mSource, mPID, mRenderer);
1634        }
1635    } else {
1636        sp<AMessage> notify = new AMessage(kWhatVideoNotify, this);
1637        ++mVideoDecoderGeneration;
1638        notify->setInt32("generation", mVideoDecoderGeneration);
1639
1640        *decoder = new Decoder(
1641                notify, mSource, mPID, mRenderer, mSurface, mCCDecoder);
1642
1643        // enable FRC if high-quality AV sync is requested, even if not
1644        // directly queuing to display, as this will even improve textureview
1645        // playback.
1646        {
1647            char value[PROPERTY_VALUE_MAX];
1648            if (property_get("persist.sys.media.avsync", value, NULL) &&
1649                    (!strcmp("1", value) || !strcasecmp("true", value))) {
1650                format->setInt32("auto-frc", 1);
1651            }
1652        }
1653    }
1654    (*decoder)->init();
1655    (*decoder)->configure(format);
1656
1657    // allocate buffers to decrypt widevine source buffers
1658    if (!audio && (mSourceFlags & Source::FLAG_SECURE)) {
1659        Vector<sp<ABuffer> > inputBufs;
1660        CHECK_EQ((*decoder)->getInputBuffers(&inputBufs), (status_t)OK);
1661
1662        Vector<MediaBuffer *> mediaBufs;
1663        for (size_t i = 0; i < inputBufs.size(); i++) {
1664            const sp<ABuffer> &buffer = inputBufs[i];
1665            MediaBuffer *mbuf = new MediaBuffer(buffer->data(), buffer->size());
1666            mediaBufs.push(mbuf);
1667        }
1668
1669        status_t err = mSource->setBuffers(audio, mediaBufs);
1670        if (err != OK) {
1671            for (size_t i = 0; i < mediaBufs.size(); ++i) {
1672                mediaBufs[i]->release();
1673            }
1674            mediaBufs.clear();
1675            ALOGE("Secure source didn't support secure mediaBufs.");
1676            return err;
1677        }
1678    }
1679    return OK;
1680}
1681
1682void NuPlayer::updateVideoSize(
1683        const sp<AMessage> &inputFormat,
1684        const sp<AMessage> &outputFormat) {
1685    if (inputFormat == NULL) {
1686        ALOGW("Unknown video size, reporting 0x0!");
1687        notifyListener(MEDIA_SET_VIDEO_SIZE, 0, 0);
1688        return;
1689    }
1690
1691    int32_t displayWidth, displayHeight;
1692    if (outputFormat != NULL) {
1693        int32_t width, height;
1694        CHECK(outputFormat->findInt32("width", &width));
1695        CHECK(outputFormat->findInt32("height", &height));
1696
1697        int32_t cropLeft, cropTop, cropRight, cropBottom;
1698        CHECK(outputFormat->findRect(
1699                    "crop",
1700                    &cropLeft, &cropTop, &cropRight, &cropBottom));
1701
1702        displayWidth = cropRight - cropLeft + 1;
1703        displayHeight = cropBottom - cropTop + 1;
1704
1705        ALOGV("Video output format changed to %d x %d "
1706             "(crop: %d x %d @ (%d, %d))",
1707             width, height,
1708             displayWidth,
1709             displayHeight,
1710             cropLeft, cropTop);
1711    } else {
1712        CHECK(inputFormat->findInt32("width", &displayWidth));
1713        CHECK(inputFormat->findInt32("height", &displayHeight));
1714
1715        ALOGV("Video input format %d x %d", displayWidth, displayHeight);
1716    }
1717
1718    // Take into account sample aspect ratio if necessary:
1719    int32_t sarWidth, sarHeight;
1720    if (inputFormat->findInt32("sar-width", &sarWidth)
1721            && inputFormat->findInt32("sar-height", &sarHeight)) {
1722        ALOGV("Sample aspect ratio %d : %d", sarWidth, sarHeight);
1723
1724        displayWidth = (displayWidth * sarWidth) / sarHeight;
1725
1726        ALOGV("display dimensions %d x %d", displayWidth, displayHeight);
1727    }
1728
1729    int32_t rotationDegrees;
1730    if (!inputFormat->findInt32("rotation-degrees", &rotationDegrees)) {
1731        rotationDegrees = 0;
1732    }
1733
1734    if (rotationDegrees == 90 || rotationDegrees == 270) {
1735        int32_t tmp = displayWidth;
1736        displayWidth = displayHeight;
1737        displayHeight = tmp;
1738    }
1739
1740    notifyListener(
1741            MEDIA_SET_VIDEO_SIZE,
1742            displayWidth,
1743            displayHeight);
1744}
1745
1746void NuPlayer::notifyListener(int msg, int ext1, int ext2, const Parcel *in) {
1747    if (mDriver == NULL) {
1748        return;
1749    }
1750
1751    sp<NuPlayerDriver> driver = mDriver.promote();
1752
1753    if (driver == NULL) {
1754        return;
1755    }
1756
1757    driver->notifyListener(msg, ext1, ext2, in);
1758}
1759
1760void NuPlayer::flushDecoder(bool audio, bool needShutdown) {
1761    ALOGV("[%s] flushDecoder needShutdown=%d",
1762          audio ? "audio" : "video", needShutdown);
1763
1764    const sp<DecoderBase> &decoder = getDecoder(audio);
1765    if (decoder == NULL) {
1766        ALOGI("flushDecoder %s without decoder present",
1767             audio ? "audio" : "video");
1768        return;
1769    }
1770
1771    // Make sure we don't continue to scan sources until we finish flushing.
1772    ++mScanSourcesGeneration;
1773    if (mScanSourcesPending) {
1774        mDeferredActions.push_back(
1775                new SimpleAction(&NuPlayer::performScanSources));
1776        mScanSourcesPending = false;
1777    }
1778
1779    decoder->signalFlush();
1780
1781    FlushStatus newStatus =
1782        needShutdown ? FLUSHING_DECODER_SHUTDOWN : FLUSHING_DECODER;
1783
1784    mFlushComplete[audio][false /* isDecoder */] = (mRenderer == NULL);
1785    mFlushComplete[audio][true /* isDecoder */] = false;
1786    if (audio) {
1787        ALOGE_IF(mFlushingAudio != NONE,
1788                "audio flushDecoder() is called in state %d", mFlushingAudio);
1789        mFlushingAudio = newStatus;
1790    } else {
1791        ALOGE_IF(mFlushingVideo != NONE,
1792                "video flushDecoder() is called in state %d", mFlushingVideo);
1793        mFlushingVideo = newStatus;
1794    }
1795}
1796
1797void NuPlayer::queueDecoderShutdown(
1798        bool audio, bool video, const sp<AMessage> &reply) {
1799    ALOGI("queueDecoderShutdown audio=%d, video=%d", audio, video);
1800
1801    mDeferredActions.push_back(
1802            new FlushDecoderAction(
1803                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1804                video ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE));
1805
1806    mDeferredActions.push_back(
1807            new SimpleAction(&NuPlayer::performScanSources));
1808
1809    mDeferredActions.push_back(new PostMessageAction(reply));
1810
1811    processDeferredActions();
1812}
1813
1814status_t NuPlayer::setVideoScalingMode(int32_t mode) {
1815    mVideoScalingMode = mode;
1816    if (mSurface != NULL) {
1817        status_t ret = native_window_set_scaling_mode(mSurface.get(), mVideoScalingMode);
1818        if (ret != OK) {
1819            ALOGE("Failed to set scaling mode (%d): %s",
1820                -ret, strerror(-ret));
1821            return ret;
1822        }
1823    }
1824    return OK;
1825}
1826
1827status_t NuPlayer::getTrackInfo(Parcel* reply) const {
1828    sp<AMessage> msg = new AMessage(kWhatGetTrackInfo, this);
1829    msg->setPointer("reply", reply);
1830
1831    sp<AMessage> response;
1832    status_t err = msg->postAndAwaitResponse(&response);
1833    return err;
1834}
1835
1836status_t NuPlayer::getSelectedTrack(int32_t type, Parcel* reply) const {
1837    sp<AMessage> msg = new AMessage(kWhatGetSelectedTrack, this);
1838    msg->setPointer("reply", reply);
1839    msg->setInt32("type", type);
1840
1841    sp<AMessage> response;
1842    status_t err = msg->postAndAwaitResponse(&response);
1843    if (err == OK && response != NULL) {
1844        CHECK(response->findInt32("err", &err));
1845    }
1846    return err;
1847}
1848
1849status_t NuPlayer::selectTrack(size_t trackIndex, bool select, int64_t timeUs) {
1850    sp<AMessage> msg = new AMessage(kWhatSelectTrack, this);
1851    msg->setSize("trackIndex", trackIndex);
1852    msg->setInt32("select", select);
1853    msg->setInt64("timeUs", timeUs);
1854
1855    sp<AMessage> response;
1856    status_t err = msg->postAndAwaitResponse(&response);
1857
1858    if (err != OK) {
1859        return err;
1860    }
1861
1862    if (!response->findInt32("err", &err)) {
1863        err = OK;
1864    }
1865
1866    return err;
1867}
1868
1869status_t NuPlayer::getCurrentPosition(int64_t *mediaUs) {
1870    sp<Renderer> renderer = mRenderer;
1871    if (renderer == NULL) {
1872        return NO_INIT;
1873    }
1874
1875    return renderer->getCurrentPosition(mediaUs);
1876}
1877
1878void NuPlayer::getStats(Vector<sp<AMessage> > *mTrackStats) {
1879    CHECK(mTrackStats != NULL);
1880
1881    mTrackStats->clear();
1882    if (mVideoDecoder != NULL) {
1883        mTrackStats->push_back(mVideoDecoder->getStats());
1884    }
1885    if (mAudioDecoder != NULL) {
1886        mTrackStats->push_back(mAudioDecoder->getStats());
1887    }
1888}
1889
1890sp<MetaData> NuPlayer::getFileMeta() {
1891    return mSource->getFileFormatMeta();
1892}
1893
1894float NuPlayer::getFrameRate() {
1895    sp<MetaData> meta = mSource->getFormatMeta(false /* audio */);
1896    if (meta == NULL) {
1897        return 0;
1898    }
1899    int32_t rate;
1900    if (!meta->findInt32(kKeyFrameRate, &rate)) {
1901        // fall back to try file meta
1902        sp<MetaData> fileMeta = getFileMeta();
1903        if (fileMeta == NULL) {
1904            ALOGW("source has video meta but not file meta");
1905            return -1;
1906        }
1907        int32_t fileMetaRate;
1908        if (!fileMeta->findInt32(kKeyFrameRate, &fileMetaRate)) {
1909            return -1;
1910        }
1911        return fileMetaRate;
1912    }
1913    return rate;
1914}
1915
1916void NuPlayer::schedulePollDuration() {
1917    sp<AMessage> msg = new AMessage(kWhatPollDuration, this);
1918    msg->setInt32("generation", mPollDurationGeneration);
1919    msg->post();
1920}
1921
1922void NuPlayer::cancelPollDuration() {
1923    ++mPollDurationGeneration;
1924}
1925
1926void NuPlayer::processDeferredActions() {
1927    while (!mDeferredActions.empty()) {
1928        // We won't execute any deferred actions until we're no longer in
1929        // an intermediate state, i.e. one more more decoders are currently
1930        // flushing or shutting down.
1931
1932        if (mFlushingAudio != NONE || mFlushingVideo != NONE) {
1933            // We're currently flushing, postpone the reset until that's
1934            // completed.
1935
1936            ALOGV("postponing action mFlushingAudio=%d, mFlushingVideo=%d",
1937                  mFlushingAudio, mFlushingVideo);
1938
1939            break;
1940        }
1941
1942        sp<Action> action = *mDeferredActions.begin();
1943        mDeferredActions.erase(mDeferredActions.begin());
1944
1945        action->execute(this);
1946    }
1947}
1948
1949void NuPlayer::performSeek(int64_t seekTimeUs) {
1950    ALOGV("performSeek seekTimeUs=%lld us (%.2f secs)",
1951          (long long)seekTimeUs,
1952          seekTimeUs / 1E6);
1953
1954    if (mSource == NULL) {
1955        // This happens when reset occurs right before the loop mode
1956        // asynchronously seeks to the start of the stream.
1957        LOG_ALWAYS_FATAL_IF(mAudioDecoder != NULL || mVideoDecoder != NULL,
1958                "mSource is NULL and decoders not NULL audio(%p) video(%p)",
1959                mAudioDecoder.get(), mVideoDecoder.get());
1960        return;
1961    }
1962    mPreviousSeekTimeUs = seekTimeUs;
1963    mSource->seekTo(seekTimeUs);
1964    mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
1965    ++mTimedTextGeneration;
1966
1967    // everything's flushed, continue playback.
1968}
1969
1970void NuPlayer::performDecoderFlush(FlushCommand audio, FlushCommand video) {
1971    ALOGV("performDecoderFlush audio=%d, video=%d", audio, video);
1972
1973    if ((audio == FLUSH_CMD_NONE || mAudioDecoder == NULL)
1974            && (video == FLUSH_CMD_NONE || mVideoDecoder == NULL)) {
1975        return;
1976    }
1977
1978    if (audio != FLUSH_CMD_NONE && mAudioDecoder != NULL) {
1979        flushDecoder(true /* audio */, (audio == FLUSH_CMD_SHUTDOWN));
1980    }
1981
1982    if (video != FLUSH_CMD_NONE && mVideoDecoder != NULL) {
1983        flushDecoder(false /* audio */, (video == FLUSH_CMD_SHUTDOWN));
1984    }
1985}
1986
1987void NuPlayer::performReset() {
1988    ALOGV("performReset");
1989
1990    CHECK(mAudioDecoder == NULL);
1991    CHECK(mVideoDecoder == NULL);
1992
1993    cancelPollDuration();
1994
1995    ++mScanSourcesGeneration;
1996    mScanSourcesPending = false;
1997
1998    if (mRendererLooper != NULL) {
1999        if (mRenderer != NULL) {
2000            mRendererLooper->unregisterHandler(mRenderer->id());
2001        }
2002        mRendererLooper->stop();
2003        mRendererLooper.clear();
2004    }
2005    mRenderer.clear();
2006    ++mRendererGeneration;
2007
2008    if (mSource != NULL) {
2009        mSource->stop();
2010
2011        Mutex::Autolock autoLock(mSourceLock);
2012        mSource.clear();
2013    }
2014
2015    if (mDriver != NULL) {
2016        sp<NuPlayerDriver> driver = mDriver.promote();
2017        if (driver != NULL) {
2018            driver->notifyResetComplete();
2019        }
2020    }
2021
2022    mStarted = false;
2023    mResetting = false;
2024    mSourceStarted = false;
2025}
2026
2027void NuPlayer::performScanSources() {
2028    ALOGV("performScanSources");
2029
2030    if (!mStarted) {
2031        return;
2032    }
2033
2034    if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
2035        postScanSources();
2036    }
2037}
2038
2039void NuPlayer::performSetSurface(const sp<Surface> &surface) {
2040    ALOGV("performSetSurface");
2041
2042    mSurface = surface;
2043
2044    // XXX - ignore error from setVideoScalingMode for now
2045    setVideoScalingMode(mVideoScalingMode);
2046
2047    if (mDriver != NULL) {
2048        sp<NuPlayerDriver> driver = mDriver.promote();
2049        if (driver != NULL) {
2050            driver->notifySetSurfaceComplete();
2051        }
2052    }
2053}
2054
2055void NuPlayer::performResumeDecoders(bool needNotify) {
2056    if (needNotify) {
2057        mResumePending = true;
2058        if (mVideoDecoder == NULL) {
2059            // if audio-only, we can notify seek complete now,
2060            // as the resume operation will be relatively fast.
2061            finishResume();
2062        }
2063    }
2064
2065    if (mVideoDecoder != NULL) {
2066        // When there is continuous seek, MediaPlayer will cache the seek
2067        // position, and send down new seek request when previous seek is
2068        // complete. Let's wait for at least one video output frame before
2069        // notifying seek complete, so that the video thumbnail gets updated
2070        // when seekbar is dragged.
2071        mVideoDecoder->signalResume(needNotify);
2072    }
2073
2074    if (mAudioDecoder != NULL) {
2075        mAudioDecoder->signalResume(false /* needNotify */);
2076    }
2077}
2078
2079void NuPlayer::finishResume() {
2080    if (mResumePending) {
2081        mResumePending = false;
2082        notifyDriverSeekComplete();
2083    }
2084}
2085
2086void NuPlayer::notifyDriverSeekComplete() {
2087    if (mDriver != NULL) {
2088        sp<NuPlayerDriver> driver = mDriver.promote();
2089        if (driver != NULL) {
2090            driver->notifySeekComplete();
2091        }
2092    }
2093}
2094
2095void NuPlayer::onSourceNotify(const sp<AMessage> &msg) {
2096    int32_t what;
2097    CHECK(msg->findInt32("what", &what));
2098
2099    switch (what) {
2100        case Source::kWhatInstantiateSecureDecoders:
2101        {
2102            if (mSource == NULL) {
2103                // This is a stale notification from a source that was
2104                // asynchronously preparing when the client called reset().
2105                // We handled the reset, the source is gone.
2106                break;
2107            }
2108
2109            sp<AMessage> reply;
2110            CHECK(msg->findMessage("reply", &reply));
2111            status_t err = onInstantiateSecureDecoders();
2112            reply->setInt32("err", err);
2113            reply->post();
2114            break;
2115        }
2116
2117        case Source::kWhatPrepared:
2118        {
2119            if (mSource == NULL) {
2120                // This is a stale notification from a source that was
2121                // asynchronously preparing when the client called reset().
2122                // We handled the reset, the source is gone.
2123                break;
2124            }
2125
2126            int32_t err;
2127            CHECK(msg->findInt32("err", &err));
2128
2129            if (err != OK) {
2130                // shut down potential secure codecs in case client never calls reset
2131                mDeferredActions.push_back(
2132                        new FlushDecoderAction(FLUSH_CMD_SHUTDOWN /* audio */,
2133                                               FLUSH_CMD_SHUTDOWN /* video */));
2134                processDeferredActions();
2135            }
2136
2137            sp<NuPlayerDriver> driver = mDriver.promote();
2138            if (driver != NULL) {
2139                // notify duration first, so that it's definitely set when
2140                // the app received the "prepare complete" callback.
2141                int64_t durationUs;
2142                if (mSource->getDuration(&durationUs) == OK) {
2143                    driver->notifyDuration(durationUs);
2144                }
2145                driver->notifyPrepareCompleted(err);
2146            }
2147
2148            break;
2149        }
2150
2151        case Source::kWhatFlagsChanged:
2152        {
2153            uint32_t flags;
2154            CHECK(msg->findInt32("flags", (int32_t *)&flags));
2155
2156            sp<NuPlayerDriver> driver = mDriver.promote();
2157            if (driver != NULL) {
2158                if ((flags & NuPlayer::Source::FLAG_CAN_SEEK) == 0) {
2159                    driver->notifyListener(
2160                            MEDIA_INFO, MEDIA_INFO_NOT_SEEKABLE, 0);
2161                }
2162                driver->notifyFlagsChanged(flags);
2163            }
2164
2165            if ((mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2166                    && (!(flags & Source::FLAG_DYNAMIC_DURATION))) {
2167                cancelPollDuration();
2168            } else if (!(mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2169                    && (flags & Source::FLAG_DYNAMIC_DURATION)
2170                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
2171                schedulePollDuration();
2172            }
2173
2174            mSourceFlags = flags;
2175            break;
2176        }
2177
2178        case Source::kWhatVideoSizeChanged:
2179        {
2180            sp<AMessage> format;
2181            CHECK(msg->findMessage("format", &format));
2182
2183            updateVideoSize(format);
2184            break;
2185        }
2186
2187        case Source::kWhatBufferingUpdate:
2188        {
2189            int32_t percentage;
2190            CHECK(msg->findInt32("percentage", &percentage));
2191
2192            notifyListener(MEDIA_BUFFERING_UPDATE, percentage, 0);
2193            break;
2194        }
2195
2196        case Source::kWhatPauseOnBufferingStart:
2197        {
2198            // ignore if not playing
2199            if (mStarted) {
2200                ALOGI("buffer low, pausing...");
2201
2202                mPausedForBuffering = true;
2203                onPause();
2204            }
2205            // fall-thru
2206        }
2207
2208        case Source::kWhatBufferingStart:
2209        {
2210            if (mPausedByClient) {
2211                mPendingBufferingFlag = PENDING_BUFFERING_FLAG_START;
2212            } else {
2213                notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_START, 0);
2214                mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
2215            }
2216            break;
2217        }
2218
2219        case Source::kWhatResumeOnBufferingEnd:
2220        {
2221            // ignore if not playing
2222            if (mStarted) {
2223                ALOGI("buffer ready, resuming...");
2224
2225                mPausedForBuffering = false;
2226
2227                // do not resume yet if client didn't unpause
2228                if (!mPausedByClient) {
2229                    onResume();
2230                }
2231            }
2232            // fall-thru
2233        }
2234
2235        case Source::kWhatBufferingEnd:
2236        {
2237            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_END, 0);
2238            mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
2239            break;
2240        }
2241
2242        case Source::kWhatCacheStats:
2243        {
2244            int32_t kbps;
2245            CHECK(msg->findInt32("bandwidth", &kbps));
2246
2247            notifyListener(MEDIA_INFO, MEDIA_INFO_NETWORK_BANDWIDTH, kbps);
2248            break;
2249        }
2250
2251        case Source::kWhatSubtitleData:
2252        {
2253            sp<ABuffer> buffer;
2254            CHECK(msg->findBuffer("buffer", &buffer));
2255
2256            sendSubtitleData(buffer, 0 /* baseIndex */);
2257            break;
2258        }
2259
2260        case Source::kWhatTimedMetaData:
2261        {
2262            sp<ABuffer> buffer;
2263            if (!msg->findBuffer("buffer", &buffer)) {
2264                notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2265            } else {
2266                sendTimedMetaData(buffer);
2267            }
2268            break;
2269        }
2270
2271        case Source::kWhatTimedTextData:
2272        {
2273            int32_t generation;
2274            if (msg->findInt32("generation", &generation)
2275                    && generation != mTimedTextGeneration) {
2276                break;
2277            }
2278
2279            sp<ABuffer> buffer;
2280            CHECK(msg->findBuffer("buffer", &buffer));
2281
2282            sp<NuPlayerDriver> driver = mDriver.promote();
2283            if (driver == NULL) {
2284                break;
2285            }
2286
2287            int posMs;
2288            int64_t timeUs, posUs;
2289            driver->getCurrentPosition(&posMs);
2290            posUs = (int64_t) posMs * 1000ll;
2291            CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2292
2293            if (posUs < timeUs) {
2294                if (!msg->findInt32("generation", &generation)) {
2295                    msg->setInt32("generation", mTimedTextGeneration);
2296                }
2297                msg->post(timeUs - posUs);
2298            } else {
2299                sendTimedTextData(buffer);
2300            }
2301            break;
2302        }
2303
2304        case Source::kWhatQueueDecoderShutdown:
2305        {
2306            int32_t audio, video;
2307            CHECK(msg->findInt32("audio", &audio));
2308            CHECK(msg->findInt32("video", &video));
2309
2310            sp<AMessage> reply;
2311            CHECK(msg->findMessage("reply", &reply));
2312
2313            queueDecoderShutdown(audio, video, reply);
2314            break;
2315        }
2316
2317        case Source::kWhatDrmNoLicense:
2318        {
2319            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_DRM_NO_LICENSE);
2320            break;
2321        }
2322
2323        default:
2324            TRESPASS();
2325    }
2326}
2327
2328void NuPlayer::onClosedCaptionNotify(const sp<AMessage> &msg) {
2329    int32_t what;
2330    CHECK(msg->findInt32("what", &what));
2331
2332    switch (what) {
2333        case NuPlayer::CCDecoder::kWhatClosedCaptionData:
2334        {
2335            sp<ABuffer> buffer;
2336            CHECK(msg->findBuffer("buffer", &buffer));
2337
2338            size_t inbandTracks = 0;
2339            if (mSource != NULL) {
2340                inbandTracks = mSource->getTrackCount();
2341            }
2342
2343            sendSubtitleData(buffer, inbandTracks);
2344            break;
2345        }
2346
2347        case NuPlayer::CCDecoder::kWhatTrackAdded:
2348        {
2349            notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2350
2351            break;
2352        }
2353
2354        default:
2355            TRESPASS();
2356    }
2357
2358
2359}
2360
2361void NuPlayer::sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex) {
2362    int32_t trackIndex;
2363    int64_t timeUs, durationUs;
2364    CHECK(buffer->meta()->findInt32("trackIndex", &trackIndex));
2365    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2366    CHECK(buffer->meta()->findInt64("durationUs", &durationUs));
2367
2368    Parcel in;
2369    in.writeInt32(trackIndex + baseIndex);
2370    in.writeInt64(timeUs);
2371    in.writeInt64(durationUs);
2372    in.writeInt32(buffer->size());
2373    in.writeInt32(buffer->size());
2374    in.write(buffer->data(), buffer->size());
2375
2376    notifyListener(MEDIA_SUBTITLE_DATA, 0, 0, &in);
2377}
2378
2379void NuPlayer::sendTimedMetaData(const sp<ABuffer> &buffer) {
2380    int64_t timeUs;
2381    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2382
2383    Parcel in;
2384    in.writeInt64(timeUs);
2385    in.writeInt32(buffer->size());
2386    in.writeInt32(buffer->size());
2387    in.write(buffer->data(), buffer->size());
2388
2389    notifyListener(MEDIA_META_DATA, 0, 0, &in);
2390}
2391
2392void NuPlayer::sendTimedTextData(const sp<ABuffer> &buffer) {
2393    const void *data;
2394    size_t size = 0;
2395    int64_t timeUs;
2396    int32_t flag = TextDescriptions::IN_BAND_TEXT_3GPP;
2397
2398    AString mime;
2399    CHECK(buffer->meta()->findString("mime", &mime));
2400    CHECK(strcasecmp(mime.c_str(), MEDIA_MIMETYPE_TEXT_3GPP) == 0);
2401
2402    data = buffer->data();
2403    size = buffer->size();
2404
2405    Parcel parcel;
2406    if (size > 0) {
2407        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2408        int32_t global = 0;
2409        if (buffer->meta()->findInt32("global", &global) && global) {
2410            flag |= TextDescriptions::GLOBAL_DESCRIPTIONS;
2411        } else {
2412            flag |= TextDescriptions::LOCAL_DESCRIPTIONS;
2413        }
2414        TextDescriptions::getParcelOfDescriptions(
2415                (const uint8_t *)data, size, flag, timeUs / 1000, &parcel);
2416    }
2417
2418    if ((parcel.dataSize() > 0)) {
2419        notifyListener(MEDIA_TIMED_TEXT, 0, 0, &parcel);
2420    } else {  // send an empty timed text
2421        notifyListener(MEDIA_TIMED_TEXT, 0, 0);
2422    }
2423}
2424////////////////////////////////////////////////////////////////////////////////
2425
2426sp<AMessage> NuPlayer::Source::getFormat(bool audio) {
2427    sp<MetaData> meta = getFormatMeta(audio);
2428
2429    if (meta == NULL) {
2430        return NULL;
2431    }
2432
2433    sp<AMessage> msg = new AMessage;
2434
2435    if(convertMetaDataToMessage(meta, &msg) == OK) {
2436        return msg;
2437    }
2438    return NULL;
2439}
2440
2441void NuPlayer::Source::notifyFlagsChanged(uint32_t flags) {
2442    sp<AMessage> notify = dupNotify();
2443    notify->setInt32("what", kWhatFlagsChanged);
2444    notify->setInt32("flags", flags);
2445    notify->post();
2446}
2447
2448void NuPlayer::Source::notifyVideoSizeChanged(const sp<AMessage> &format) {
2449    sp<AMessage> notify = dupNotify();
2450    notify->setInt32("what", kWhatVideoSizeChanged);
2451    notify->setMessage("format", format);
2452    notify->post();
2453}
2454
2455void NuPlayer::Source::notifyPrepared(status_t err) {
2456    sp<AMessage> notify = dupNotify();
2457    notify->setInt32("what", kWhatPrepared);
2458    notify->setInt32("err", err);
2459    notify->post();
2460}
2461
2462void NuPlayer::Source::notifyInstantiateSecureDecoders(const sp<AMessage> &reply) {
2463    sp<AMessage> notify = dupNotify();
2464    notify->setInt32("what", kWhatInstantiateSecureDecoders);
2465    notify->setMessage("reply", reply);
2466    notify->post();
2467}
2468
2469void NuPlayer::Source::onMessageReceived(const sp<AMessage> & /* msg */) {
2470    TRESPASS();
2471}
2472
2473}  // namespace android
2474