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