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