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