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