NuPlayer.cpp revision 6d339f1f764bbd32e3381dae7bfa7c6c575bb493 
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    mScanSourcesPending = false;
1421
1422    decoder->signalFlush();
1423
1424    FlushStatus newStatus =
1425        needShutdown ? FLUSHING_DECODER_SHUTDOWN : FLUSHING_DECODER;
1426
1427    mFlushComplete[audio][false /* isDecoder */] = (mRenderer == NULL);
1428    mFlushComplete[audio][true /* isDecoder */] = false;
1429    if (audio) {
1430        ALOGE_IF(mFlushingAudio != NONE,
1431                "audio flushDecoder() is called in state %d", mFlushingAudio);
1432        mFlushingAudio = newStatus;
1433    } else {
1434        ALOGE_IF(mFlushingVideo != NONE,
1435                "video flushDecoder() is called in state %d", mFlushingVideo);
1436        mFlushingVideo = newStatus;
1437    }
1438}
1439
1440void NuPlayer::queueDecoderShutdown(
1441        bool audio, bool video, const sp<AMessage> &reply) {
1442    ALOGI("queueDecoderShutdown audio=%d, video=%d", audio, video);
1443
1444    mDeferredActions.push_back(
1445            new FlushDecoderAction(
1446                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1447                video ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE));
1448
1449    mDeferredActions.push_back(
1450            new SimpleAction(&NuPlayer::performScanSources));
1451
1452    mDeferredActions.push_back(new PostMessageAction(reply));
1453
1454    processDeferredActions();
1455}
1456
1457status_t NuPlayer::setVideoScalingMode(int32_t mode) {
1458    mVideoScalingMode = mode;
1459    if (mNativeWindow != NULL) {
1460        status_t ret = native_window_set_scaling_mode(
1461                mNativeWindow->getNativeWindow().get(), mVideoScalingMode);
1462        if (ret != OK) {
1463            ALOGE("Failed to set scaling mode (%d): %s",
1464                -ret, strerror(-ret));
1465            return ret;
1466        }
1467    }
1468    return OK;
1469}
1470
1471status_t NuPlayer::getTrackInfo(Parcel* reply) const {
1472    sp<AMessage> msg = new AMessage(kWhatGetTrackInfo, this);
1473    msg->setPointer("reply", reply);
1474
1475    sp<AMessage> response;
1476    status_t err = msg->postAndAwaitResponse(&response);
1477    return err;
1478}
1479
1480status_t NuPlayer::getSelectedTrack(int32_t type, Parcel* reply) const {
1481    sp<AMessage> msg = new AMessage(kWhatGetSelectedTrack, this);
1482    msg->setPointer("reply", reply);
1483    msg->setInt32("type", type);
1484
1485    sp<AMessage> response;
1486    status_t err = msg->postAndAwaitResponse(&response);
1487    if (err == OK && response != NULL) {
1488        CHECK(response->findInt32("err", &err));
1489    }
1490    return err;
1491}
1492
1493status_t NuPlayer::selectTrack(size_t trackIndex, bool select, int64_t timeUs) {
1494    sp<AMessage> msg = new AMessage(kWhatSelectTrack, this);
1495    msg->setSize("trackIndex", trackIndex);
1496    msg->setInt32("select", select);
1497    msg->setInt64("timeUs", timeUs);
1498
1499    sp<AMessage> response;
1500    status_t err = msg->postAndAwaitResponse(&response);
1501
1502    if (err != OK) {
1503        return err;
1504    }
1505
1506    if (!response->findInt32("err", &err)) {
1507        err = OK;
1508    }
1509
1510    return err;
1511}
1512
1513status_t NuPlayer::getCurrentPosition(int64_t *mediaUs) {
1514    sp<Renderer> renderer = mRenderer;
1515    if (renderer == NULL) {
1516        return NO_INIT;
1517    }
1518
1519    return renderer->getCurrentPosition(mediaUs);
1520}
1521
1522void NuPlayer::getStats(int64_t *numFramesTotal, int64_t *numFramesDropped) {
1523    sp<DecoderBase> decoder = getDecoder(false /* audio */);
1524    if (decoder != NULL) {
1525        decoder->getStats(numFramesTotal, numFramesDropped);
1526    } else {
1527        *numFramesTotal = 0;
1528        *numFramesDropped = 0;
1529    }
1530}
1531
1532sp<MetaData> NuPlayer::getFileMeta() {
1533    return mSource->getFileFormatMeta();
1534}
1535
1536void NuPlayer::schedulePollDuration() {
1537    sp<AMessage> msg = new AMessage(kWhatPollDuration, this);
1538    msg->setInt32("generation", mPollDurationGeneration);
1539    msg->post();
1540}
1541
1542void NuPlayer::cancelPollDuration() {
1543    ++mPollDurationGeneration;
1544}
1545
1546void NuPlayer::processDeferredActions() {
1547    while (!mDeferredActions.empty()) {
1548        // We won't execute any deferred actions until we're no longer in
1549        // an intermediate state, i.e. one more more decoders are currently
1550        // flushing or shutting down.
1551
1552        if (mFlushingAudio != NONE || mFlushingVideo != NONE) {
1553            // We're currently flushing, postpone the reset until that's
1554            // completed.
1555
1556            ALOGV("postponing action mFlushingAudio=%d, mFlushingVideo=%d",
1557                  mFlushingAudio, mFlushingVideo);
1558
1559            break;
1560        }
1561
1562        sp<Action> action = *mDeferredActions.begin();
1563        mDeferredActions.erase(mDeferredActions.begin());
1564
1565        action->execute(this);
1566    }
1567}
1568
1569void NuPlayer::performSeek(int64_t seekTimeUs, bool needNotify) {
1570    ALOGV("performSeek seekTimeUs=%lld us (%.2f secs), needNotify(%d)",
1571          (long long)seekTimeUs,
1572          seekTimeUs / 1E6,
1573          needNotify);
1574
1575    if (mSource == NULL) {
1576        // This happens when reset occurs right before the loop mode
1577        // asynchronously seeks to the start of the stream.
1578        LOG_ALWAYS_FATAL_IF(mAudioDecoder != NULL || mVideoDecoder != NULL,
1579                "mSource is NULL and decoders not NULL audio(%p) video(%p)",
1580                mAudioDecoder.get(), mVideoDecoder.get());
1581        return;
1582    }
1583    mSource->seekTo(seekTimeUs);
1584    ++mTimedTextGeneration;
1585
1586    // everything's flushed, continue playback.
1587}
1588
1589void NuPlayer::performDecoderFlush(FlushCommand audio, FlushCommand video) {
1590    ALOGV("performDecoderFlush audio=%d, video=%d", audio, video);
1591
1592    if ((audio == FLUSH_CMD_NONE || mAudioDecoder == NULL)
1593            && (video == FLUSH_CMD_NONE || mVideoDecoder == NULL)) {
1594        return;
1595    }
1596
1597    if (audio != FLUSH_CMD_NONE && mAudioDecoder != NULL) {
1598        flushDecoder(true /* audio */, (audio == FLUSH_CMD_SHUTDOWN));
1599    }
1600
1601    if (video != FLUSH_CMD_NONE && mVideoDecoder != NULL) {
1602        flushDecoder(false /* audio */, (video == FLUSH_CMD_SHUTDOWN));
1603    }
1604}
1605
1606void NuPlayer::performReset() {
1607    ALOGV("performReset");
1608
1609    CHECK(mAudioDecoder == NULL);
1610    CHECK(mVideoDecoder == NULL);
1611
1612    cancelPollDuration();
1613
1614    ++mScanSourcesGeneration;
1615    mScanSourcesPending = false;
1616
1617    if (mRendererLooper != NULL) {
1618        if (mRenderer != NULL) {
1619            mRendererLooper->unregisterHandler(mRenderer->id());
1620        }
1621        mRendererLooper->stop();
1622        mRendererLooper.clear();
1623    }
1624    mRenderer.clear();
1625    ++mRendererGeneration;
1626
1627    if (mSource != NULL) {
1628        mSource->stop();
1629
1630        mSource.clear();
1631    }
1632
1633    if (mDriver != NULL) {
1634        sp<NuPlayerDriver> driver = mDriver.promote();
1635        if (driver != NULL) {
1636            driver->notifyResetComplete();
1637        }
1638    }
1639
1640    mStarted = false;
1641}
1642
1643void NuPlayer::performScanSources() {
1644    ALOGV("performScanSources");
1645
1646    if (!mStarted) {
1647        return;
1648    }
1649
1650    if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
1651        postScanSources();
1652    }
1653}
1654
1655void NuPlayer::performSetSurface(const sp<NativeWindowWrapper> &wrapper) {
1656    ALOGV("performSetSurface");
1657
1658    mNativeWindow = wrapper;
1659
1660    // XXX - ignore error from setVideoScalingMode for now
1661    setVideoScalingMode(mVideoScalingMode);
1662
1663    if (mDriver != NULL) {
1664        sp<NuPlayerDriver> driver = mDriver.promote();
1665        if (driver != NULL) {
1666            driver->notifySetSurfaceComplete();
1667        }
1668    }
1669}
1670
1671void NuPlayer::performResumeDecoders(bool needNotify) {
1672    if (needNotify) {
1673        mResumePending = true;
1674        if (mVideoDecoder == NULL) {
1675            // if audio-only, we can notify seek complete now,
1676            // as the resume operation will be relatively fast.
1677            finishResume();
1678        }
1679    }
1680
1681    if (mVideoDecoder != NULL) {
1682        // When there is continuous seek, MediaPlayer will cache the seek
1683        // position, and send down new seek request when previous seek is
1684        // complete. Let's wait for at least one video output frame before
1685        // notifying seek complete, so that the video thumbnail gets updated
1686        // when seekbar is dragged.
1687        mVideoDecoder->signalResume(needNotify);
1688    }
1689
1690    if (mAudioDecoder != NULL) {
1691        mAudioDecoder->signalResume(false /* needNotify */);
1692    }
1693}
1694
1695void NuPlayer::finishResume() {
1696    if (mResumePending) {
1697        mResumePending = false;
1698        if (mDriver != NULL) {
1699            sp<NuPlayerDriver> driver = mDriver.promote();
1700            if (driver != NULL) {
1701                driver->notifySeekComplete();
1702            }
1703        }
1704    }
1705}
1706
1707void NuPlayer::onSourceNotify(const sp<AMessage> &msg) {
1708    int32_t what;
1709    CHECK(msg->findInt32("what", &what));
1710
1711    switch (what) {
1712        case Source::kWhatInstantiateSecureDecoders:
1713        {
1714            if (mSource == NULL) {
1715                // This is a stale notification from a source that was
1716                // asynchronously preparing when the client called reset().
1717                // We handled the reset, the source is gone.
1718                break;
1719            }
1720
1721            sp<AMessage> reply;
1722            CHECK(msg->findMessage("reply", &reply));
1723            status_t err = onInstantiateSecureDecoders();
1724            reply->setInt32("err", err);
1725            reply->post();
1726            break;
1727        }
1728
1729        case Source::kWhatPrepared:
1730        {
1731            if (mSource == NULL) {
1732                // This is a stale notification from a source that was
1733                // asynchronously preparing when the client called reset().
1734                // We handled the reset, the source is gone.
1735                break;
1736            }
1737
1738            int32_t err;
1739            CHECK(msg->findInt32("err", &err));
1740
1741            if (err != OK) {
1742                // shut down potential secure codecs in case client never calls reset
1743                mDeferredActions.push_back(
1744                        new FlushDecoderAction(FLUSH_CMD_SHUTDOWN /* audio */,
1745                                               FLUSH_CMD_SHUTDOWN /* video */));
1746                processDeferredActions();
1747            }
1748
1749            sp<NuPlayerDriver> driver = mDriver.promote();
1750            if (driver != NULL) {
1751                // notify duration first, so that it's definitely set when
1752                // the app received the "prepare complete" callback.
1753                int64_t durationUs;
1754                if (mSource->getDuration(&durationUs) == OK) {
1755                    driver->notifyDuration(durationUs);
1756                }
1757                driver->notifyPrepareCompleted(err);
1758            }
1759
1760            break;
1761        }
1762
1763        case Source::kWhatFlagsChanged:
1764        {
1765            uint32_t flags;
1766            CHECK(msg->findInt32("flags", (int32_t *)&flags));
1767
1768            sp<NuPlayerDriver> driver = mDriver.promote();
1769            if (driver != NULL) {
1770                if ((flags & NuPlayer::Source::FLAG_CAN_SEEK) == 0) {
1771                    driver->notifyListener(
1772                            MEDIA_INFO, MEDIA_INFO_NOT_SEEKABLE, 0);
1773                }
1774                driver->notifyFlagsChanged(flags);
1775            }
1776
1777            if ((mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
1778                    && (!(flags & Source::FLAG_DYNAMIC_DURATION))) {
1779                cancelPollDuration();
1780            } else if (!(mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
1781                    && (flags & Source::FLAG_DYNAMIC_DURATION)
1782                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
1783                schedulePollDuration();
1784            }
1785
1786            mSourceFlags = flags;
1787            break;
1788        }
1789
1790        case Source::kWhatVideoSizeChanged:
1791        {
1792            sp<AMessage> format;
1793            CHECK(msg->findMessage("format", &format));
1794
1795            updateVideoSize(format);
1796            break;
1797        }
1798
1799        case Source::kWhatBufferingUpdate:
1800        {
1801            int32_t percentage;
1802            CHECK(msg->findInt32("percentage", &percentage));
1803
1804            notifyListener(MEDIA_BUFFERING_UPDATE, percentage, 0);
1805            break;
1806        }
1807
1808        case Source::kWhatPauseOnBufferingStart:
1809        {
1810            // ignore if not playing
1811            if (mStarted && !mPausedByClient) {
1812                ALOGI("buffer low, pausing...");
1813
1814                onPause();
1815            }
1816            // fall-thru
1817        }
1818
1819        case Source::kWhatBufferingStart:
1820        {
1821            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_START, 0);
1822            break;
1823        }
1824
1825        case Source::kWhatResumeOnBufferingEnd:
1826        {
1827            // ignore if not playing
1828            if (mStarted && !mPausedByClient) {
1829                ALOGI("buffer ready, resuming...");
1830
1831                onResume();
1832            }
1833            // fall-thru
1834        }
1835
1836        case Source::kWhatBufferingEnd:
1837        {
1838            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_END, 0);
1839            break;
1840        }
1841
1842        case Source::kWhatCacheStats:
1843        {
1844            int32_t kbps;
1845            CHECK(msg->findInt32("bandwidth", &kbps));
1846
1847            notifyListener(MEDIA_INFO, MEDIA_INFO_NETWORK_BANDWIDTH, kbps);
1848            break;
1849        }
1850
1851        case Source::kWhatSubtitleData:
1852        {
1853            sp<ABuffer> buffer;
1854            CHECK(msg->findBuffer("buffer", &buffer));
1855
1856            sendSubtitleData(buffer, 0 /* baseIndex */);
1857            break;
1858        }
1859
1860        case Source::kWhatTimedMetaData:
1861        {
1862            sp<ABuffer> buffer;
1863            if (!msg->findBuffer("buffer", &buffer)) {
1864                notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
1865            } else {
1866                sendTimedMetaData(buffer);
1867            }
1868            break;
1869        }
1870
1871        case Source::kWhatTimedTextData:
1872        {
1873            int32_t generation;
1874            if (msg->findInt32("generation", &generation)
1875                    && generation != mTimedTextGeneration) {
1876                break;
1877            }
1878
1879            sp<ABuffer> buffer;
1880            CHECK(msg->findBuffer("buffer", &buffer));
1881
1882            sp<NuPlayerDriver> driver = mDriver.promote();
1883            if (driver == NULL) {
1884                break;
1885            }
1886
1887            int posMs;
1888            int64_t timeUs, posUs;
1889            driver->getCurrentPosition(&posMs);
1890            posUs = posMs * 1000;
1891            CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
1892
1893            if (posUs < timeUs) {
1894                if (!msg->findInt32("generation", &generation)) {
1895                    msg->setInt32("generation", mTimedTextGeneration);
1896                }
1897                msg->post(timeUs - posUs);
1898            } else {
1899                sendTimedTextData(buffer);
1900            }
1901            break;
1902        }
1903
1904        case Source::kWhatQueueDecoderShutdown:
1905        {
1906            int32_t audio, video;
1907            CHECK(msg->findInt32("audio", &audio));
1908            CHECK(msg->findInt32("video", &video));
1909
1910            sp<AMessage> reply;
1911            CHECK(msg->findMessage("reply", &reply));
1912
1913            queueDecoderShutdown(audio, video, reply);
1914            break;
1915        }
1916
1917        case Source::kWhatDrmNoLicense:
1918        {
1919            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_DRM_NO_LICENSE);
1920            break;
1921        }
1922
1923        default:
1924            TRESPASS();
1925    }
1926}
1927
1928void NuPlayer::onClosedCaptionNotify(const sp<AMessage> &msg) {
1929    int32_t what;
1930    CHECK(msg->findInt32("what", &what));
1931
1932    switch (what) {
1933        case NuPlayer::CCDecoder::kWhatClosedCaptionData:
1934        {
1935            sp<ABuffer> buffer;
1936            CHECK(msg->findBuffer("buffer", &buffer));
1937
1938            size_t inbandTracks = 0;
1939            if (mSource != NULL) {
1940                inbandTracks = mSource->getTrackCount();
1941            }
1942
1943            sendSubtitleData(buffer, inbandTracks);
1944            break;
1945        }
1946
1947        case NuPlayer::CCDecoder::kWhatTrackAdded:
1948        {
1949            notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
1950
1951            break;
1952        }
1953
1954        default:
1955            TRESPASS();
1956    }
1957
1958
1959}
1960
1961void NuPlayer::sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex) {
1962    int32_t trackIndex;
1963    int64_t timeUs, durationUs;
1964    CHECK(buffer->meta()->findInt32("trackIndex", &trackIndex));
1965    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
1966    CHECK(buffer->meta()->findInt64("durationUs", &durationUs));
1967
1968    Parcel in;
1969    in.writeInt32(trackIndex + baseIndex);
1970    in.writeInt64(timeUs);
1971    in.writeInt64(durationUs);
1972    in.writeInt32(buffer->size());
1973    in.writeInt32(buffer->size());
1974    in.write(buffer->data(), buffer->size());
1975
1976    notifyListener(MEDIA_SUBTITLE_DATA, 0, 0, &in);
1977}
1978
1979void NuPlayer::sendTimedMetaData(const sp<ABuffer> &buffer) {
1980    int64_t timeUs;
1981    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
1982
1983    Parcel in;
1984    in.writeInt64(timeUs);
1985    in.writeInt32(buffer->size());
1986    in.writeInt32(buffer->size());
1987    in.write(buffer->data(), buffer->size());
1988
1989    notifyListener(MEDIA_META_DATA, 0, 0, &in);
1990}
1991
1992void NuPlayer::sendTimedTextData(const sp<ABuffer> &buffer) {
1993    const void *data;
1994    size_t size = 0;
1995    int64_t timeUs;
1996    int32_t flag = TextDescriptions::LOCAL_DESCRIPTIONS;
1997
1998    AString mime;
1999    CHECK(buffer->meta()->findString("mime", &mime));
2000    CHECK(strcasecmp(mime.c_str(), MEDIA_MIMETYPE_TEXT_3GPP) == 0);
2001
2002    data = buffer->data();
2003    size = buffer->size();
2004
2005    Parcel parcel;
2006    if (size > 0) {
2007        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2008        flag |= TextDescriptions::IN_BAND_TEXT_3GPP;
2009        TextDescriptions::getParcelOfDescriptions(
2010                (const uint8_t *)data, size, flag, timeUs / 1000, &parcel);
2011    }
2012
2013    if ((parcel.dataSize() > 0)) {
2014        notifyListener(MEDIA_TIMED_TEXT, 0, 0, &parcel);
2015    } else {  // send an empty timed text
2016        notifyListener(MEDIA_TIMED_TEXT, 0, 0);
2017    }
2018}
2019////////////////////////////////////////////////////////////////////////////////
2020
2021sp<AMessage> NuPlayer::Source::getFormat(bool audio) {
2022    sp<MetaData> meta = getFormatMeta(audio);
2023
2024    if (meta == NULL) {
2025        return NULL;
2026    }
2027
2028    sp<AMessage> msg = new AMessage;
2029
2030    if(convertMetaDataToMessage(meta, &msg) == OK) {
2031        return msg;
2032    }
2033    return NULL;
2034}
2035
2036void NuPlayer::Source::notifyFlagsChanged(uint32_t flags) {
2037    sp<AMessage> notify = dupNotify();
2038    notify->setInt32("what", kWhatFlagsChanged);
2039    notify->setInt32("flags", flags);
2040    notify->post();
2041}
2042
2043void NuPlayer::Source::notifyVideoSizeChanged(const sp<AMessage> &format) {
2044    sp<AMessage> notify = dupNotify();
2045    notify->setInt32("what", kWhatVideoSizeChanged);
2046    notify->setMessage("format", format);
2047    notify->post();
2048}
2049
2050void NuPlayer::Source::notifyPrepared(status_t err) {
2051    sp<AMessage> notify = dupNotify();
2052    notify->setInt32("what", kWhatPrepared);
2053    notify->setInt32("err", err);
2054    notify->post();
2055}
2056
2057void NuPlayer::Source::notifyInstantiateSecureDecoders(const sp<AMessage> &reply) {
2058    sp<AMessage> notify = dupNotify();
2059    notify->setInt32("what", kWhatInstantiateSecureDecoders);
2060    notify->setMessage("reply", reply);
2061    notify->post();
2062}
2063
2064void NuPlayer::Source::onMessageReceived(const sp<AMessage> & /* msg */) {
2065    TRESPASS();
2066}
2067
2068}  // namespace android
2069