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