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