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