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