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