NuPlayer.cpp revision 9737d3497f6ef8bf6a1083aabd8a03569944795d 
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    bool hasAudio = (mSource->getFormat(true /* audio */) != NULL);
1346    bool hasVideo = (mSource->getFormat(false /* audio */) != NULL);
1347    if (!hasAudio && !hasVideo) {
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(!hasAudio, "no metadata for audio source");  // video only stream
1355
1356    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1357
1358    audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
1359    if (mAudioSink != NULL) {
1360        streamType = mAudioSink->getAudioStreamType();
1361    }
1362
1363    mOffloadAudio =
1364        canOffloadStream(audioMeta, hasVideo, 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    int32_t err = OK;
1701    inputFormat->findInt32("err", &err);
1702    if (err == -EWOULDBLOCK) {
1703        ALOGW("Video meta is not available yet!");
1704        return;
1705    }
1706    if (err != OK) {
1707        ALOGW("Something is wrong with video meta!");
1708        return;
1709    }
1710
1711    int32_t displayWidth, displayHeight;
1712    if (outputFormat != NULL) {
1713        int32_t width, height;
1714        CHECK(outputFormat->findInt32("width", &width));
1715        CHECK(outputFormat->findInt32("height", &height));
1716
1717        int32_t cropLeft, cropTop, cropRight, cropBottom;
1718        CHECK(outputFormat->findRect(
1719                    "crop",
1720                    &cropLeft, &cropTop, &cropRight, &cropBottom));
1721
1722        displayWidth = cropRight - cropLeft + 1;
1723        displayHeight = cropBottom - cropTop + 1;
1724
1725        ALOGV("Video output format changed to %d x %d "
1726             "(crop: %d x %d @ (%d, %d))",
1727             width, height,
1728             displayWidth,
1729             displayHeight,
1730             cropLeft, cropTop);
1731    } else {
1732        CHECK(inputFormat->findInt32("width", &displayWidth));
1733        CHECK(inputFormat->findInt32("height", &displayHeight));
1734
1735        ALOGV("Video input format %d x %d", displayWidth, displayHeight);
1736    }
1737
1738    // Take into account sample aspect ratio if necessary:
1739    int32_t sarWidth, sarHeight;
1740    if (inputFormat->findInt32("sar-width", &sarWidth)
1741            && inputFormat->findInt32("sar-height", &sarHeight)) {
1742        ALOGV("Sample aspect ratio %d : %d", sarWidth, sarHeight);
1743
1744        displayWidth = (displayWidth * sarWidth) / sarHeight;
1745
1746        ALOGV("display dimensions %d x %d", displayWidth, displayHeight);
1747    } else {
1748        int32_t width, height;
1749        if (inputFormat->findInt32("display-width", &width)
1750                && inputFormat->findInt32("display-height", &height)
1751                && width > 0 && height > 0
1752                && displayWidth > 0 && displayHeight > 0) {
1753            if (displayHeight * (int64_t)width / height > (int64_t)displayWidth) {
1754                displayHeight = (int32_t)(displayWidth * (int64_t)height / width);
1755            } else {
1756                displayWidth = (int32_t)(displayHeight * (int64_t)width / height);
1757            }
1758            ALOGV("Video display width and height are overridden to %d x %d",
1759                 displayWidth, displayHeight);
1760        }
1761    }
1762
1763    int32_t rotationDegrees;
1764    if (!inputFormat->findInt32("rotation-degrees", &rotationDegrees)) {
1765        rotationDegrees = 0;
1766    }
1767
1768    if (rotationDegrees == 90 || rotationDegrees == 270) {
1769        int32_t tmp = displayWidth;
1770        displayWidth = displayHeight;
1771        displayHeight = tmp;
1772    }
1773
1774    notifyListener(
1775            MEDIA_SET_VIDEO_SIZE,
1776            displayWidth,
1777            displayHeight);
1778}
1779
1780void NuPlayer::notifyListener(int msg, int ext1, int ext2, const Parcel *in) {
1781    if (mDriver == NULL) {
1782        return;
1783    }
1784
1785    sp<NuPlayerDriver> driver = mDriver.promote();
1786
1787    if (driver == NULL) {
1788        return;
1789    }
1790
1791    driver->notifyListener(msg, ext1, ext2, in);
1792}
1793
1794void NuPlayer::flushDecoder(bool audio, bool needShutdown) {
1795    ALOGV("[%s] flushDecoder needShutdown=%d",
1796          audio ? "audio" : "video", needShutdown);
1797
1798    const sp<DecoderBase> &decoder = getDecoder(audio);
1799    if (decoder == NULL) {
1800        ALOGI("flushDecoder %s without decoder present",
1801             audio ? "audio" : "video");
1802        return;
1803    }
1804
1805    // Make sure we don't continue to scan sources until we finish flushing.
1806    ++mScanSourcesGeneration;
1807    if (mScanSourcesPending) {
1808        if (!needShutdown) {
1809            mDeferredActions.push_back(
1810                    new SimpleAction(&NuPlayer::performScanSources));
1811        }
1812        mScanSourcesPending = false;
1813    }
1814
1815    decoder->signalFlush();
1816
1817    FlushStatus newStatus =
1818        needShutdown ? FLUSHING_DECODER_SHUTDOWN : FLUSHING_DECODER;
1819
1820    mFlushComplete[audio][false /* isDecoder */] = (mRenderer == NULL);
1821    mFlushComplete[audio][true /* isDecoder */] = false;
1822    if (audio) {
1823        ALOGE_IF(mFlushingAudio != NONE,
1824                "audio flushDecoder() is called in state %d", mFlushingAudio);
1825        mFlushingAudio = newStatus;
1826    } else {
1827        ALOGE_IF(mFlushingVideo != NONE,
1828                "video flushDecoder() is called in state %d", mFlushingVideo);
1829        mFlushingVideo = newStatus;
1830    }
1831}
1832
1833void NuPlayer::queueDecoderShutdown(
1834        bool audio, bool video, const sp<AMessage> &reply) {
1835    ALOGI("queueDecoderShutdown audio=%d, video=%d", audio, video);
1836
1837    mDeferredActions.push_back(
1838            new FlushDecoderAction(
1839                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1840                video ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE));
1841
1842    mDeferredActions.push_back(
1843            new SimpleAction(&NuPlayer::performScanSources));
1844
1845    mDeferredActions.push_back(new PostMessageAction(reply));
1846
1847    processDeferredActions();
1848}
1849
1850status_t NuPlayer::setVideoScalingMode(int32_t mode) {
1851    mVideoScalingMode = mode;
1852    if (mSurface != NULL) {
1853        status_t ret = native_window_set_scaling_mode(mSurface.get(), mVideoScalingMode);
1854        if (ret != OK) {
1855            ALOGE("Failed to set scaling mode (%d): %s",
1856                -ret, strerror(-ret));
1857            return ret;
1858        }
1859    }
1860    return OK;
1861}
1862
1863status_t NuPlayer::getTrackInfo(Parcel* reply) const {
1864    sp<AMessage> msg = new AMessage(kWhatGetTrackInfo, this);
1865    msg->setPointer("reply", reply);
1866
1867    sp<AMessage> response;
1868    status_t err = msg->postAndAwaitResponse(&response);
1869    return err;
1870}
1871
1872status_t NuPlayer::getSelectedTrack(int32_t type, Parcel* reply) const {
1873    sp<AMessage> msg = new AMessage(kWhatGetSelectedTrack, this);
1874    msg->setPointer("reply", reply);
1875    msg->setInt32("type", type);
1876
1877    sp<AMessage> response;
1878    status_t err = msg->postAndAwaitResponse(&response);
1879    if (err == OK && response != NULL) {
1880        CHECK(response->findInt32("err", &err));
1881    }
1882    return err;
1883}
1884
1885status_t NuPlayer::selectTrack(size_t trackIndex, bool select, int64_t timeUs) {
1886    sp<AMessage> msg = new AMessage(kWhatSelectTrack, this);
1887    msg->setSize("trackIndex", trackIndex);
1888    msg->setInt32("select", select);
1889    msg->setInt64("timeUs", timeUs);
1890
1891    sp<AMessage> response;
1892    status_t err = msg->postAndAwaitResponse(&response);
1893
1894    if (err != OK) {
1895        return err;
1896    }
1897
1898    if (!response->findInt32("err", &err)) {
1899        err = OK;
1900    }
1901
1902    return err;
1903}
1904
1905status_t NuPlayer::getCurrentPosition(int64_t *mediaUs) {
1906    sp<Renderer> renderer = mRenderer;
1907    if (renderer == NULL) {
1908        return NO_INIT;
1909    }
1910
1911    return renderer->getCurrentPosition(mediaUs);
1912}
1913
1914void NuPlayer::getStats(Vector<sp<AMessage> > *mTrackStats) {
1915    CHECK(mTrackStats != NULL);
1916
1917    mTrackStats->clear();
1918    if (mVideoDecoder != NULL) {
1919        mTrackStats->push_back(mVideoDecoder->getStats());
1920    }
1921    if (mAudioDecoder != NULL) {
1922        mTrackStats->push_back(mAudioDecoder->getStats());
1923    }
1924}
1925
1926sp<MetaData> NuPlayer::getFileMeta() {
1927    return mSource->getFileFormatMeta();
1928}
1929
1930float NuPlayer::getFrameRate() {
1931    sp<MetaData> meta = mSource->getFormatMeta(false /* audio */);
1932    if (meta == NULL) {
1933        return 0;
1934    }
1935    int32_t rate;
1936    if (!meta->findInt32(kKeyFrameRate, &rate)) {
1937        // fall back to try file meta
1938        sp<MetaData> fileMeta = getFileMeta();
1939        if (fileMeta == NULL) {
1940            ALOGW("source has video meta but not file meta");
1941            return -1;
1942        }
1943        int32_t fileMetaRate;
1944        if (!fileMeta->findInt32(kKeyFrameRate, &fileMetaRate)) {
1945            return -1;
1946        }
1947        return fileMetaRate;
1948    }
1949    return rate;
1950}
1951
1952void NuPlayer::schedulePollDuration() {
1953    sp<AMessage> msg = new AMessage(kWhatPollDuration, this);
1954    msg->setInt32("generation", mPollDurationGeneration);
1955    msg->post();
1956}
1957
1958void NuPlayer::cancelPollDuration() {
1959    ++mPollDurationGeneration;
1960}
1961
1962void NuPlayer::processDeferredActions() {
1963    while (!mDeferredActions.empty()) {
1964        // We won't execute any deferred actions until we're no longer in
1965        // an intermediate state, i.e. one more more decoders are currently
1966        // flushing or shutting down.
1967
1968        if (mFlushingAudio != NONE || mFlushingVideo != NONE) {
1969            // We're currently flushing, postpone the reset until that's
1970            // completed.
1971
1972            ALOGV("postponing action mFlushingAudio=%d, mFlushingVideo=%d",
1973                  mFlushingAudio, mFlushingVideo);
1974
1975            break;
1976        }
1977
1978        sp<Action> action = *mDeferredActions.begin();
1979        mDeferredActions.erase(mDeferredActions.begin());
1980
1981        action->execute(this);
1982    }
1983}
1984
1985void NuPlayer::performSeek(int64_t seekTimeUs, MediaPlayerSeekMode mode) {
1986    ALOGV("performSeek seekTimeUs=%lld us (%.2f secs), mode=%d",
1987          (long long)seekTimeUs, seekTimeUs / 1E6, mode);
1988
1989    if (mSource == NULL) {
1990        // This happens when reset occurs right before the loop mode
1991        // asynchronously seeks to the start of the stream.
1992        LOG_ALWAYS_FATAL_IF(mAudioDecoder != NULL || mVideoDecoder != NULL,
1993                "mSource is NULL and decoders not NULL audio(%p) video(%p)",
1994                mAudioDecoder.get(), mVideoDecoder.get());
1995        return;
1996    }
1997    mPreviousSeekTimeUs = seekTimeUs;
1998    mSource->seekTo(seekTimeUs, mode);
1999    ++mTimedTextGeneration;
2000
2001    // everything's flushed, continue playback.
2002}
2003
2004void NuPlayer::performDecoderFlush(FlushCommand audio, FlushCommand video) {
2005    ALOGV("performDecoderFlush audio=%d, video=%d", audio, video);
2006
2007    if ((audio == FLUSH_CMD_NONE || mAudioDecoder == NULL)
2008            && (video == FLUSH_CMD_NONE || mVideoDecoder == NULL)) {
2009        return;
2010    }
2011
2012    if (audio != FLUSH_CMD_NONE && mAudioDecoder != NULL) {
2013        flushDecoder(true /* audio */, (audio == FLUSH_CMD_SHUTDOWN));
2014    }
2015
2016    if (video != FLUSH_CMD_NONE && mVideoDecoder != NULL) {
2017        flushDecoder(false /* audio */, (video == FLUSH_CMD_SHUTDOWN));
2018    }
2019}
2020
2021void NuPlayer::performReset() {
2022    ALOGV("performReset");
2023
2024    CHECK(mAudioDecoder == NULL);
2025    CHECK(mVideoDecoder == NULL);
2026
2027    cancelPollDuration();
2028
2029    ++mScanSourcesGeneration;
2030    mScanSourcesPending = false;
2031
2032    if (mRendererLooper != NULL) {
2033        if (mRenderer != NULL) {
2034            mRendererLooper->unregisterHandler(mRenderer->id());
2035        }
2036        mRendererLooper->stop();
2037        mRendererLooper.clear();
2038    }
2039    mRenderer.clear();
2040    ++mRendererGeneration;
2041
2042    if (mSource != NULL) {
2043        mSource->stop();
2044
2045        Mutex::Autolock autoLock(mSourceLock);
2046        mSource.clear();
2047    }
2048
2049    if (mDriver != NULL) {
2050        sp<NuPlayerDriver> driver = mDriver.promote();
2051        if (driver != NULL) {
2052            driver->notifyResetComplete();
2053        }
2054    }
2055
2056    mStarted = false;
2057    mPrepared = false;
2058    mResetting = false;
2059    mSourceStarted = false;
2060}
2061
2062void NuPlayer::performScanSources() {
2063    ALOGV("performScanSources");
2064
2065    if (!mStarted) {
2066        return;
2067    }
2068
2069    if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
2070        postScanSources();
2071    }
2072}
2073
2074void NuPlayer::performSetSurface(const sp<Surface> &surface) {
2075    ALOGV("performSetSurface");
2076
2077    mSurface = surface;
2078
2079    // XXX - ignore error from setVideoScalingMode for now
2080    setVideoScalingMode(mVideoScalingMode);
2081
2082    if (mDriver != NULL) {
2083        sp<NuPlayerDriver> driver = mDriver.promote();
2084        if (driver != NULL) {
2085            driver->notifySetSurfaceComplete();
2086        }
2087    }
2088}
2089
2090void NuPlayer::performResumeDecoders(bool needNotify) {
2091    if (needNotify) {
2092        mResumePending = true;
2093        if (mVideoDecoder == NULL) {
2094            // if audio-only, we can notify seek complete now,
2095            // as the resume operation will be relatively fast.
2096            finishResume();
2097        }
2098    }
2099
2100    if (mVideoDecoder != NULL) {
2101        // When there is continuous seek, MediaPlayer will cache the seek
2102        // position, and send down new seek request when previous seek is
2103        // complete. Let's wait for at least one video output frame before
2104        // notifying seek complete, so that the video thumbnail gets updated
2105        // when seekbar is dragged.
2106        mVideoDecoder->signalResume(needNotify);
2107    }
2108
2109    if (mAudioDecoder != NULL) {
2110        mAudioDecoder->signalResume(false /* needNotify */);
2111    }
2112}
2113
2114void NuPlayer::finishResume() {
2115    if (mResumePending) {
2116        mResumePending = false;
2117        notifyDriverSeekComplete();
2118    }
2119}
2120
2121void NuPlayer::notifyDriverSeekComplete() {
2122    if (mDriver != NULL) {
2123        sp<NuPlayerDriver> driver = mDriver.promote();
2124        if (driver != NULL) {
2125            driver->notifySeekComplete();
2126        }
2127    }
2128}
2129
2130void NuPlayer::onSourceNotify(const sp<AMessage> &msg) {
2131    int32_t what;
2132    CHECK(msg->findInt32("what", &what));
2133
2134    switch (what) {
2135        case Source::kWhatInstantiateSecureDecoders:
2136        {
2137            if (mSource == NULL) {
2138                // This is a stale notification from a source that was
2139                // asynchronously preparing when the client called reset().
2140                // We handled the reset, the source is gone.
2141                break;
2142            }
2143
2144            sp<AMessage> reply;
2145            CHECK(msg->findMessage("reply", &reply));
2146            status_t err = onInstantiateSecureDecoders();
2147            reply->setInt32("err", err);
2148            reply->post();
2149            break;
2150        }
2151
2152        case Source::kWhatPrepared:
2153        {
2154            if (mSource == NULL) {
2155                // This is a stale notification from a source that was
2156                // asynchronously preparing when the client called reset().
2157                // We handled the reset, the source is gone.
2158                break;
2159            }
2160
2161            int32_t err;
2162            CHECK(msg->findInt32("err", &err));
2163
2164            if (err != OK) {
2165                // shut down potential secure codecs in case client never calls reset
2166                mDeferredActions.push_back(
2167                        new FlushDecoderAction(FLUSH_CMD_SHUTDOWN /* audio */,
2168                                               FLUSH_CMD_SHUTDOWN /* video */));
2169                processDeferredActions();
2170            } else {
2171                mPrepared = true;
2172            }
2173
2174            sp<NuPlayerDriver> driver = mDriver.promote();
2175            if (driver != NULL) {
2176                // notify duration first, so that it's definitely set when
2177                // the app received the "prepare complete" callback.
2178                int64_t durationUs;
2179                if (mSource->getDuration(&durationUs) == OK) {
2180                    driver->notifyDuration(durationUs);
2181                }
2182                driver->notifyPrepareCompleted(err);
2183            }
2184
2185            break;
2186        }
2187
2188        case Source::kWhatFlagsChanged:
2189        {
2190            uint32_t flags;
2191            CHECK(msg->findInt32("flags", (int32_t *)&flags));
2192
2193            sp<NuPlayerDriver> driver = mDriver.promote();
2194            if (driver != NULL) {
2195                if ((flags & NuPlayer::Source::FLAG_CAN_SEEK) == 0) {
2196                    driver->notifyListener(
2197                            MEDIA_INFO, MEDIA_INFO_NOT_SEEKABLE, 0);
2198                }
2199                driver->notifyFlagsChanged(flags);
2200            }
2201
2202            if ((mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2203                    && (!(flags & Source::FLAG_DYNAMIC_DURATION))) {
2204                cancelPollDuration();
2205            } else if (!(mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2206                    && (flags & Source::FLAG_DYNAMIC_DURATION)
2207                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
2208                schedulePollDuration();
2209            }
2210
2211            mSourceFlags = flags;
2212            break;
2213        }
2214
2215        case Source::kWhatVideoSizeChanged:
2216        {
2217            sp<AMessage> format;
2218            CHECK(msg->findMessage("format", &format));
2219
2220            updateVideoSize(format);
2221            break;
2222        }
2223
2224        case Source::kWhatBufferingUpdate:
2225        {
2226            int32_t percentage;
2227            CHECK(msg->findInt32("percentage", &percentage));
2228
2229            notifyListener(MEDIA_BUFFERING_UPDATE, percentage, 0);
2230            break;
2231        }
2232
2233        case Source::kWhatPauseOnBufferingStart:
2234        {
2235            // ignore if not playing
2236            if (mStarted) {
2237                ALOGI("buffer low, pausing...");
2238
2239                mPausedForBuffering = true;
2240                onPause();
2241            }
2242            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_START, 0);
2243            break;
2244        }
2245
2246        case Source::kWhatResumeOnBufferingEnd:
2247        {
2248            // ignore if not playing
2249            if (mStarted) {
2250                ALOGI("buffer ready, resuming...");
2251
2252                mPausedForBuffering = false;
2253
2254                // do not resume yet if client didn't unpause
2255                if (!mPausedByClient) {
2256                    onResume();
2257                }
2258            }
2259            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_END, 0);
2260            break;
2261        }
2262
2263        case Source::kWhatCacheStats:
2264        {
2265            int32_t kbps;
2266            CHECK(msg->findInt32("bandwidth", &kbps));
2267
2268            notifyListener(MEDIA_INFO, MEDIA_INFO_NETWORK_BANDWIDTH, kbps);
2269            break;
2270        }
2271
2272        case Source::kWhatSubtitleData:
2273        {
2274            sp<ABuffer> buffer;
2275            CHECK(msg->findBuffer("buffer", &buffer));
2276
2277            sendSubtitleData(buffer, 0 /* baseIndex */);
2278            break;
2279        }
2280
2281        case Source::kWhatTimedMetaData:
2282        {
2283            sp<ABuffer> buffer;
2284            if (!msg->findBuffer("buffer", &buffer)) {
2285                notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2286            } else {
2287                sendTimedMetaData(buffer);
2288            }
2289            break;
2290        }
2291
2292        case Source::kWhatTimedTextData:
2293        {
2294            int32_t generation;
2295            if (msg->findInt32("generation", &generation)
2296                    && generation != mTimedTextGeneration) {
2297                break;
2298            }
2299
2300            sp<ABuffer> buffer;
2301            CHECK(msg->findBuffer("buffer", &buffer));
2302
2303            sp<NuPlayerDriver> driver = mDriver.promote();
2304            if (driver == NULL) {
2305                break;
2306            }
2307
2308            int posMs;
2309            int64_t timeUs, posUs;
2310            driver->getCurrentPosition(&posMs);
2311            posUs = (int64_t) posMs * 1000ll;
2312            CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2313
2314            if (posUs < timeUs) {
2315                if (!msg->findInt32("generation", &generation)) {
2316                    msg->setInt32("generation", mTimedTextGeneration);
2317                }
2318                msg->post(timeUs - posUs);
2319            } else {
2320                sendTimedTextData(buffer);
2321            }
2322            break;
2323        }
2324
2325        case Source::kWhatQueueDecoderShutdown:
2326        {
2327            int32_t audio, video;
2328            CHECK(msg->findInt32("audio", &audio));
2329            CHECK(msg->findInt32("video", &video));
2330
2331            sp<AMessage> reply;
2332            CHECK(msg->findMessage("reply", &reply));
2333
2334            queueDecoderShutdown(audio, video, reply);
2335            break;
2336        }
2337
2338        case Source::kWhatDrmNoLicense:
2339        {
2340            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_DRM_NO_LICENSE);
2341            break;
2342        }
2343
2344        default:
2345            TRESPASS();
2346    }
2347}
2348
2349void NuPlayer::onClosedCaptionNotify(const sp<AMessage> &msg) {
2350    int32_t what;
2351    CHECK(msg->findInt32("what", &what));
2352
2353    switch (what) {
2354        case NuPlayer::CCDecoder::kWhatClosedCaptionData:
2355        {
2356            sp<ABuffer> buffer;
2357            CHECK(msg->findBuffer("buffer", &buffer));
2358
2359            size_t inbandTracks = 0;
2360            if (mSource != NULL) {
2361                inbandTracks = mSource->getTrackCount();
2362            }
2363
2364            sendSubtitleData(buffer, inbandTracks);
2365            break;
2366        }
2367
2368        case NuPlayer::CCDecoder::kWhatTrackAdded:
2369        {
2370            notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2371
2372            break;
2373        }
2374
2375        default:
2376            TRESPASS();
2377    }
2378
2379
2380}
2381
2382void NuPlayer::sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex) {
2383    int32_t trackIndex;
2384    int64_t timeUs, durationUs;
2385    CHECK(buffer->meta()->findInt32("trackIndex", &trackIndex));
2386    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2387    CHECK(buffer->meta()->findInt64("durationUs", &durationUs));
2388
2389    Parcel in;
2390    in.writeInt32(trackIndex + baseIndex);
2391    in.writeInt64(timeUs);
2392    in.writeInt64(durationUs);
2393    in.writeInt32(buffer->size());
2394    in.writeInt32(buffer->size());
2395    in.write(buffer->data(), buffer->size());
2396
2397    notifyListener(MEDIA_SUBTITLE_DATA, 0, 0, &in);
2398}
2399
2400void NuPlayer::sendTimedMetaData(const sp<ABuffer> &buffer) {
2401    int64_t timeUs;
2402    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2403
2404    Parcel in;
2405    in.writeInt64(timeUs);
2406    in.writeInt32(buffer->size());
2407    in.writeInt32(buffer->size());
2408    in.write(buffer->data(), buffer->size());
2409
2410    notifyListener(MEDIA_META_DATA, 0, 0, &in);
2411}
2412
2413void NuPlayer::sendTimedTextData(const sp<ABuffer> &buffer) {
2414    const void *data;
2415    size_t size = 0;
2416    int64_t timeUs;
2417    int32_t flag = TextDescriptions::IN_BAND_TEXT_3GPP;
2418
2419    AString mime;
2420    CHECK(buffer->meta()->findString("mime", &mime));
2421    CHECK(strcasecmp(mime.c_str(), MEDIA_MIMETYPE_TEXT_3GPP) == 0);
2422
2423    data = buffer->data();
2424    size = buffer->size();
2425
2426    Parcel parcel;
2427    if (size > 0) {
2428        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2429        int32_t global = 0;
2430        if (buffer->meta()->findInt32("global", &global) && global) {
2431            flag |= TextDescriptions::GLOBAL_DESCRIPTIONS;
2432        } else {
2433            flag |= TextDescriptions::LOCAL_DESCRIPTIONS;
2434        }
2435        TextDescriptions::getParcelOfDescriptions(
2436                (const uint8_t *)data, size, flag, timeUs / 1000, &parcel);
2437    }
2438
2439    if ((parcel.dataSize() > 0)) {
2440        notifyListener(MEDIA_TIMED_TEXT, 0, 0, &parcel);
2441    } else {  // send an empty timed text
2442        notifyListener(MEDIA_TIMED_TEXT, 0, 0);
2443    }
2444}
2445////////////////////////////////////////////////////////////////////////////////
2446
2447sp<AMessage> NuPlayer::Source::getFormat(bool audio) {
2448    sp<MetaData> meta = getFormatMeta(audio);
2449
2450    if (meta == NULL) {
2451        return NULL;
2452    }
2453
2454    sp<AMessage> msg = new AMessage;
2455
2456    if(convertMetaDataToMessage(meta, &msg) == OK) {
2457        return msg;
2458    }
2459    return NULL;
2460}
2461
2462void NuPlayer::Source::notifyFlagsChanged(uint32_t flags) {
2463    sp<AMessage> notify = dupNotify();
2464    notify->setInt32("what", kWhatFlagsChanged);
2465    notify->setInt32("flags", flags);
2466    notify->post();
2467}
2468
2469void NuPlayer::Source::notifyVideoSizeChanged(const sp<AMessage> &format) {
2470    sp<AMessage> notify = dupNotify();
2471    notify->setInt32("what", kWhatVideoSizeChanged);
2472    notify->setMessage("format", format);
2473    notify->post();
2474}
2475
2476void NuPlayer::Source::notifyPrepared(status_t err) {
2477    sp<AMessage> notify = dupNotify();
2478    notify->setInt32("what", kWhatPrepared);
2479    notify->setInt32("err", err);
2480    notify->post();
2481}
2482
2483void NuPlayer::Source::notifyInstantiateSecureDecoders(const sp<AMessage> &reply) {
2484    sp<AMessage> notify = dupNotify();
2485    notify->setInt32("what", kWhatInstantiateSecureDecoders);
2486    notify->setMessage("reply", reply);
2487    notify->post();
2488}
2489
2490void NuPlayer::Source::onMessageReceived(const sp<AMessage> & /* msg */) {
2491    TRESPASS();
2492}
2493
2494}  // namespace android
2495