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