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