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