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