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