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