NuPlayer.cpp revision a05f1e3a8eb80a0a9f19456aea357d6d8e405794 
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                int64_t positionUs;
1148                if (!msg->findInt64("positionUs", &positionUs)) {
1149                    positionUs = mPreviousSeekTimeUs;
1150                }
1151
1152                restartAudio(
1153                        positionUs, reason == Renderer::kForceNonOffload /* forceNonOffload */,
1154                        reason != Renderer::kDueToTimeout /* needsToCreateAudioDecoder */);
1155            }
1156            break;
1157        }
1158
1159        case kWhatMoreDataQueued:
1160        {
1161            break;
1162        }
1163
1164        case kWhatReset:
1165        {
1166            ALOGV("kWhatReset");
1167
1168            mResetting = true;
1169
1170            mDeferredActions.push_back(
1171                    new FlushDecoderAction(
1172                        FLUSH_CMD_SHUTDOWN /* audio */,
1173                        FLUSH_CMD_SHUTDOWN /* video */));
1174
1175            mDeferredActions.push_back(
1176                    new SimpleAction(&NuPlayer::performReset));
1177
1178            processDeferredActions();
1179            break;
1180        }
1181
1182        case kWhatSeek:
1183        {
1184            int64_t seekTimeUs;
1185            int32_t needNotify;
1186            CHECK(msg->findInt64("seekTimeUs", &seekTimeUs));
1187            CHECK(msg->findInt32("needNotify", &needNotify));
1188
1189            ALOGV("kWhatSeek seekTimeUs=%lld us, needNotify=%d",
1190                    (long long)seekTimeUs, needNotify);
1191
1192            if (!mStarted) {
1193                // Seek before the player is started. In order to preview video,
1194                // need to start the player and pause it. This branch is called
1195                // only once if needed. After the player is started, any seek
1196                // operation will go through normal path.
1197                // Audio-only cases are handled separately.
1198                onStart(seekTimeUs);
1199                if (mStarted) {
1200                    onPause();
1201                    mPausedByClient = true;
1202                }
1203                if (needNotify) {
1204                    notifyDriverSeekComplete();
1205                }
1206                break;
1207            }
1208
1209            mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
1210
1211            mDeferredActions.push_back(
1212                    new FlushDecoderAction(FLUSH_CMD_FLUSH /* audio */,
1213                                           FLUSH_CMD_FLUSH /* video */));
1214
1215            mDeferredActions.push_back(
1216                    new SeekAction(seekTimeUs));
1217
1218            // After a flush without shutdown, decoder is paused.
1219            // Don't resume it until source seek is done, otherwise it could
1220            // start pulling stale data too soon.
1221            mDeferredActions.push_back(
1222                    new ResumeDecoderAction(needNotify));
1223
1224            processDeferredActions();
1225            break;
1226        }
1227
1228        case kWhatPause:
1229        {
1230            onPause();
1231            mPausedByClient = true;
1232            break;
1233        }
1234
1235        case kWhatSourceNotify:
1236        {
1237            onSourceNotify(msg);
1238            break;
1239        }
1240
1241        case kWhatClosedCaptionNotify:
1242        {
1243            onClosedCaptionNotify(msg);
1244            break;
1245        }
1246
1247        default:
1248            TRESPASS();
1249            break;
1250    }
1251}
1252
1253void NuPlayer::onResume() {
1254    if (!mPaused || mResetting) {
1255        ALOGD_IF(mResetting, "resetting, onResume discarded");
1256        return;
1257    }
1258    mPaused = false;
1259    if (mSource != NULL) {
1260        mSource->resume();
1261    } else {
1262        ALOGW("resume called when source is gone or not set");
1263    }
1264    // |mAudioDecoder| may have been released due to the pause timeout, so re-create it if
1265    // needed.
1266    if (audioDecoderStillNeeded() && mAudioDecoder == NULL) {
1267        instantiateDecoder(true /* audio */, &mAudioDecoder);
1268    }
1269    if (mRenderer != NULL) {
1270        mRenderer->resume();
1271    } else {
1272        ALOGW("resume called when renderer is gone or not set");
1273    }
1274}
1275
1276status_t NuPlayer::onInstantiateSecureDecoders() {
1277    status_t err;
1278    if (!(mSourceFlags & Source::FLAG_SECURE)) {
1279        return BAD_TYPE;
1280    }
1281
1282    if (mRenderer != NULL) {
1283        ALOGE("renderer should not be set when instantiating secure decoders");
1284        return UNKNOWN_ERROR;
1285    }
1286
1287    // TRICKY: We rely on mRenderer being null, so that decoder does not start requesting
1288    // data on instantiation.
1289    if (mSurface != NULL) {
1290        err = instantiateDecoder(false, &mVideoDecoder);
1291        if (err != OK) {
1292            return err;
1293        }
1294    }
1295
1296    if (mAudioSink != NULL) {
1297        err = instantiateDecoder(true, &mAudioDecoder);
1298        if (err != OK) {
1299            return err;
1300        }
1301    }
1302    return OK;
1303}
1304
1305void NuPlayer::onStart(int64_t startPositionUs) {
1306    if (!mSourceStarted) {
1307        mSourceStarted = true;
1308        mSource->start();
1309    }
1310    if (startPositionUs > 0) {
1311        performSeek(startPositionUs);
1312        if (mSource->getFormat(false /* audio */) == NULL) {
1313            return;
1314        }
1315    }
1316
1317    mOffloadAudio = false;
1318    mAudioEOS = false;
1319    mVideoEOS = false;
1320    mStarted = true;
1321
1322    uint32_t flags = 0;
1323
1324    if (mSource->isRealTime()) {
1325        flags |= Renderer::FLAG_REAL_TIME;
1326    }
1327
1328    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1329    ALOGV_IF(audioMeta == NULL, "no metadata for audio source");  // video only stream
1330    audio_stream_type_t streamType = AUDIO_STREAM_MUSIC;
1331    if (mAudioSink != NULL) {
1332        streamType = mAudioSink->getAudioStreamType();
1333    }
1334
1335    sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
1336
1337    mOffloadAudio =
1338        canOffloadStream(audioMeta, (videoFormat != NULL), mSource->isStreaming(), streamType)
1339                && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
1340    if (mOffloadAudio) {
1341        flags |= Renderer::FLAG_OFFLOAD_AUDIO;
1342    }
1343
1344    sp<AMessage> notify = new AMessage(kWhatRendererNotify, this);
1345    ++mRendererGeneration;
1346    notify->setInt32("generation", mRendererGeneration);
1347    mRenderer = new Renderer(mAudioSink, notify, flags);
1348    mRendererLooper = new ALooper;
1349    mRendererLooper->setName("NuPlayerRenderer");
1350    mRendererLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
1351    mRendererLooper->registerHandler(mRenderer);
1352
1353    status_t err = mRenderer->setPlaybackSettings(mPlaybackSettings);
1354    if (err != OK) {
1355        mSource->stop();
1356        mSourceStarted = false;
1357        notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err);
1358        return;
1359    }
1360
1361    float rate = getFrameRate();
1362    if (rate > 0) {
1363        mRenderer->setVideoFrameRate(rate);
1364    }
1365
1366    if (mVideoDecoder != NULL) {
1367        mVideoDecoder->setRenderer(mRenderer);
1368    }
1369    if (mAudioDecoder != NULL) {
1370        mAudioDecoder->setRenderer(mRenderer);
1371    }
1372
1373    postScanSources();
1374}
1375
1376void NuPlayer::onPause() {
1377    if (mPaused) {
1378        return;
1379    }
1380    mPaused = true;
1381    if (mSource != NULL) {
1382        mSource->pause();
1383    } else {
1384        ALOGW("pause called when source is gone or not set");
1385    }
1386    if (mRenderer != NULL) {
1387        mRenderer->pause();
1388    } else {
1389        ALOGW("pause called when renderer is gone or not set");
1390    }
1391}
1392
1393bool NuPlayer::audioDecoderStillNeeded() {
1394    // Audio decoder is no longer needed if it's in shut/shutting down status.
1395    return ((mFlushingAudio != SHUT_DOWN) && (mFlushingAudio != SHUTTING_DOWN_DECODER));
1396}
1397
1398void NuPlayer::handleFlushComplete(bool audio, bool isDecoder) {
1399    // We wait for both the decoder flush and the renderer flush to complete
1400    // before entering either the FLUSHED or the SHUTTING_DOWN_DECODER state.
1401
1402    mFlushComplete[audio][isDecoder] = true;
1403    if (!mFlushComplete[audio][!isDecoder]) {
1404        return;
1405    }
1406
1407    FlushStatus *state = audio ? &mFlushingAudio : &mFlushingVideo;
1408    switch (*state) {
1409        case FLUSHING_DECODER:
1410        {
1411            *state = FLUSHED;
1412            break;
1413        }
1414
1415        case FLUSHING_DECODER_SHUTDOWN:
1416        {
1417            *state = SHUTTING_DOWN_DECODER;
1418
1419            ALOGV("initiating %s decoder shutdown", audio ? "audio" : "video");
1420            if (!audio) {
1421                // Widevine source reads must stop before releasing the video decoder.
1422                if (mSource != NULL && mSourceFlags & Source::FLAG_SECURE) {
1423                    mSource->stop();
1424                    mSourceStarted = false;
1425                }
1426            }
1427            getDecoder(audio)->initiateShutdown();
1428            break;
1429        }
1430
1431        default:
1432            // decoder flush completes only occur in a flushing state.
1433            LOG_ALWAYS_FATAL_IF(isDecoder, "decoder flush in invalid state %d", *state);
1434            break;
1435    }
1436}
1437
1438void NuPlayer::finishFlushIfPossible() {
1439    if (mFlushingAudio != NONE && mFlushingAudio != FLUSHED
1440            && mFlushingAudio != SHUT_DOWN) {
1441        return;
1442    }
1443
1444    if (mFlushingVideo != NONE && mFlushingVideo != FLUSHED
1445            && mFlushingVideo != SHUT_DOWN) {
1446        return;
1447    }
1448
1449    ALOGV("both audio and video are flushed now.");
1450
1451    mFlushingAudio = NONE;
1452    mFlushingVideo = NONE;
1453
1454    clearFlushComplete();
1455
1456    processDeferredActions();
1457}
1458
1459void NuPlayer::postScanSources() {
1460    if (mScanSourcesPending) {
1461        return;
1462    }
1463
1464    sp<AMessage> msg = new AMessage(kWhatScanSources, this);
1465    msg->setInt32("generation", mScanSourcesGeneration);
1466    msg->post();
1467
1468    mScanSourcesPending = true;
1469}
1470
1471void NuPlayer::tryOpenAudioSinkForOffload(const sp<AMessage> &format, bool hasVideo) {
1472    // Note: This is called early in NuPlayer to determine whether offloading
1473    // is possible; otherwise the decoders call the renderer openAudioSink directly.
1474
1475    status_t err = mRenderer->openAudioSink(
1476            format, true /* offloadOnly */, hasVideo, AUDIO_OUTPUT_FLAG_NONE, &mOffloadAudio);
1477    if (err != OK) {
1478        // Any failure we turn off mOffloadAudio.
1479        mOffloadAudio = false;
1480    } else if (mOffloadAudio) {
1481        sp<MetaData> audioMeta =
1482                mSource->getFormatMeta(true /* audio */);
1483        sendMetaDataToHal(mAudioSink, audioMeta);
1484    }
1485}
1486
1487void NuPlayer::closeAudioSink() {
1488    mRenderer->closeAudioSink();
1489}
1490
1491void NuPlayer::restartAudio(
1492        int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder) {
1493    if (mAudioDecoder != NULL) {
1494        mAudioDecoder->pause();
1495        mAudioDecoder.clear();
1496        ++mAudioDecoderGeneration;
1497    }
1498    if (mFlushingAudio == FLUSHING_DECODER) {
1499        mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
1500        mFlushingAudio = FLUSHED;
1501        finishFlushIfPossible();
1502    } else if (mFlushingAudio == FLUSHING_DECODER_SHUTDOWN
1503            || mFlushingAudio == SHUTTING_DOWN_DECODER) {
1504        mFlushComplete[1 /* audio */][1 /* isDecoder */] = true;
1505        mFlushingAudio = SHUT_DOWN;
1506        finishFlushIfPossible();
1507        needsToCreateAudioDecoder = false;
1508    }
1509    if (mRenderer == NULL) {
1510        return;
1511    }
1512    closeAudioSink();
1513    mRenderer->flush(true /* audio */, false /* notifyComplete */);
1514    if (mVideoDecoder != NULL) {
1515        mRenderer->flush(false /* audio */, false /* notifyComplete */);
1516    }
1517
1518    performSeek(currentPositionUs);
1519
1520    if (forceNonOffload) {
1521        mRenderer->signalDisableOffloadAudio();
1522        mOffloadAudio = false;
1523    }
1524    if (needsToCreateAudioDecoder) {
1525        instantiateDecoder(true /* audio */, &mAudioDecoder, !forceNonOffload);
1526    }
1527}
1528
1529void NuPlayer::determineAudioModeChange() {
1530    if (mSource == NULL || mAudioSink == NULL) {
1531        return;
1532    }
1533
1534    if (mRenderer == NULL) {
1535        ALOGW("No renderer can be used to determine audio mode. Use non-offload for safety.");
1536        mOffloadAudio = false;
1537        return;
1538    }
1539
1540    sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */);
1541    sp<AMessage> videoFormat = mSource->getFormat(false /* audio */);
1542    audio_stream_type_t streamType = mAudioSink->getAudioStreamType();
1543    const bool hasVideo = (videoFormat != NULL);
1544    const bool canOffload = canOffloadStream(
1545            audioMeta, hasVideo, mSource->isStreaming(), streamType)
1546                    && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f);
1547    if (canOffload) {
1548        if (!mOffloadAudio) {
1549            mRenderer->signalEnableOffloadAudio();
1550        }
1551        // open audio sink early under offload mode.
1552        sp<AMessage> format = mSource->getFormat(true /*audio*/);
1553        tryOpenAudioSinkForOffload(format, hasVideo);
1554    } else {
1555        if (mOffloadAudio) {
1556            mRenderer->signalDisableOffloadAudio();
1557            mOffloadAudio = false;
1558        }
1559    }
1560}
1561
1562status_t NuPlayer::instantiateDecoder(
1563        bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange) {
1564    // The audio decoder could be cleared by tear down. If still in shut down
1565    // process, no need to create a new audio decoder.
1566    if (*decoder != NULL || (audio && mFlushingAudio == SHUT_DOWN)) {
1567        return OK;
1568    }
1569
1570    sp<AMessage> format = mSource->getFormat(audio);
1571
1572    if (format == NULL) {
1573        return UNKNOWN_ERROR;
1574    } else {
1575        status_t err;
1576        if (format->findInt32("err", &err) && err) {
1577            return err;
1578        }
1579    }
1580
1581    format->setInt32("priority", 0 /* realtime */);
1582
1583    if (!audio) {
1584        AString mime;
1585        CHECK(format->findString("mime", &mime));
1586
1587        sp<AMessage> ccNotify = new AMessage(kWhatClosedCaptionNotify, this);
1588        if (mCCDecoder == NULL) {
1589            mCCDecoder = new CCDecoder(ccNotify);
1590        }
1591
1592        if (mSourceFlags & Source::FLAG_SECURE) {
1593            format->setInt32("secure", true);
1594        }
1595
1596        if (mSourceFlags & Source::FLAG_PROTECTED) {
1597            format->setInt32("protected", true);
1598        }
1599
1600        float rate = getFrameRate();
1601        if (rate > 0) {
1602            format->setFloat("operating-rate", rate * mPlaybackSettings.mSpeed);
1603        }
1604    }
1605
1606    if (audio) {
1607        sp<AMessage> notify = new AMessage(kWhatAudioNotify, this);
1608        ++mAudioDecoderGeneration;
1609        notify->setInt32("generation", mAudioDecoderGeneration);
1610
1611        if (checkAudioModeChange) {
1612            determineAudioModeChange();
1613        }
1614        if (mOffloadAudio) {
1615            mSource->setOffloadAudio(true /* offload */);
1616
1617            const bool hasVideo = (mSource->getFormat(false /*audio */) != NULL);
1618            format->setInt32("has-video", hasVideo);
1619            *decoder = new DecoderPassThrough(notify, mSource, mRenderer);
1620        } else {
1621            mSource->setOffloadAudio(false /* offload */);
1622
1623            *decoder = new Decoder(notify, mSource, mPID, mRenderer);
1624        }
1625    } else {
1626        sp<AMessage> notify = new AMessage(kWhatVideoNotify, this);
1627        ++mVideoDecoderGeneration;
1628        notify->setInt32("generation", mVideoDecoderGeneration);
1629
1630        *decoder = new Decoder(
1631                notify, mSource, mPID, mRenderer, mSurface, mCCDecoder);
1632
1633        // enable FRC if high-quality AV sync is requested, even if not
1634        // directly queuing to display, as this will even improve textureview
1635        // playback.
1636        {
1637            char value[PROPERTY_VALUE_MAX];
1638            if (property_get("persist.sys.media.avsync", value, NULL) &&
1639                    (!strcmp("1", value) || !strcasecmp("true", value))) {
1640                format->setInt32("auto-frc", 1);
1641            }
1642        }
1643    }
1644    (*decoder)->init();
1645    (*decoder)->configure(format);
1646
1647    // allocate buffers to decrypt widevine source buffers
1648    if (!audio && (mSourceFlags & Source::FLAG_SECURE)) {
1649        Vector<sp<ABuffer> > inputBufs;
1650        CHECK_EQ((*decoder)->getInputBuffers(&inputBufs), (status_t)OK);
1651
1652        Vector<MediaBuffer *> mediaBufs;
1653        for (size_t i = 0; i < inputBufs.size(); i++) {
1654            const sp<ABuffer> &buffer = inputBufs[i];
1655            MediaBuffer *mbuf = new MediaBuffer(buffer->data(), buffer->size());
1656            mediaBufs.push(mbuf);
1657        }
1658
1659        status_t err = mSource->setBuffers(audio, mediaBufs);
1660        if (err != OK) {
1661            for (size_t i = 0; i < mediaBufs.size(); ++i) {
1662                mediaBufs[i]->release();
1663            }
1664            mediaBufs.clear();
1665            ALOGE("Secure source didn't support secure mediaBufs.");
1666            return err;
1667        }
1668    }
1669    return OK;
1670}
1671
1672void NuPlayer::updateVideoSize(
1673        const sp<AMessage> &inputFormat,
1674        const sp<AMessage> &outputFormat) {
1675    if (inputFormat == NULL) {
1676        ALOGW("Unknown video size, reporting 0x0!");
1677        notifyListener(MEDIA_SET_VIDEO_SIZE, 0, 0);
1678        return;
1679    }
1680
1681    int32_t displayWidth, displayHeight;
1682    if (outputFormat != NULL) {
1683        int32_t width, height;
1684        CHECK(outputFormat->findInt32("width", &width));
1685        CHECK(outputFormat->findInt32("height", &height));
1686
1687        int32_t cropLeft, cropTop, cropRight, cropBottom;
1688        CHECK(outputFormat->findRect(
1689                    "crop",
1690                    &cropLeft, &cropTop, &cropRight, &cropBottom));
1691
1692        displayWidth = cropRight - cropLeft + 1;
1693        displayHeight = cropBottom - cropTop + 1;
1694
1695        ALOGV("Video output format changed to %d x %d "
1696             "(crop: %d x %d @ (%d, %d))",
1697             width, height,
1698             displayWidth,
1699             displayHeight,
1700             cropLeft, cropTop);
1701    } else {
1702        CHECK(inputFormat->findInt32("width", &displayWidth));
1703        CHECK(inputFormat->findInt32("height", &displayHeight));
1704
1705        ALOGV("Video input format %d x %d", displayWidth, displayHeight);
1706    }
1707
1708    // Take into account sample aspect ratio if necessary:
1709    int32_t sarWidth, sarHeight;
1710    if (inputFormat->findInt32("sar-width", &sarWidth)
1711            && inputFormat->findInt32("sar-height", &sarHeight)) {
1712        ALOGV("Sample aspect ratio %d : %d", sarWidth, sarHeight);
1713
1714        displayWidth = (displayWidth * sarWidth) / sarHeight;
1715
1716        ALOGV("display dimensions %d x %d", displayWidth, displayHeight);
1717    }
1718
1719    int32_t rotationDegrees;
1720    if (!inputFormat->findInt32("rotation-degrees", &rotationDegrees)) {
1721        rotationDegrees = 0;
1722    }
1723
1724    if (rotationDegrees == 90 || rotationDegrees == 270) {
1725        int32_t tmp = displayWidth;
1726        displayWidth = displayHeight;
1727        displayHeight = tmp;
1728    }
1729
1730    notifyListener(
1731            MEDIA_SET_VIDEO_SIZE,
1732            displayWidth,
1733            displayHeight);
1734}
1735
1736void NuPlayer::notifyListener(int msg, int ext1, int ext2, const Parcel *in) {
1737    if (mDriver == NULL) {
1738        return;
1739    }
1740
1741    sp<NuPlayerDriver> driver = mDriver.promote();
1742
1743    if (driver == NULL) {
1744        return;
1745    }
1746
1747    driver->notifyListener(msg, ext1, ext2, in);
1748}
1749
1750void NuPlayer::flushDecoder(bool audio, bool needShutdown) {
1751    ALOGV("[%s] flushDecoder needShutdown=%d",
1752          audio ? "audio" : "video", needShutdown);
1753
1754    const sp<DecoderBase> &decoder = getDecoder(audio);
1755    if (decoder == NULL) {
1756        ALOGI("flushDecoder %s without decoder present",
1757             audio ? "audio" : "video");
1758        return;
1759    }
1760
1761    // Make sure we don't continue to scan sources until we finish flushing.
1762    ++mScanSourcesGeneration;
1763    if (mScanSourcesPending) {
1764        mDeferredActions.push_back(
1765                new SimpleAction(&NuPlayer::performScanSources));
1766        mScanSourcesPending = false;
1767    }
1768
1769    decoder->signalFlush();
1770
1771    FlushStatus newStatus =
1772        needShutdown ? FLUSHING_DECODER_SHUTDOWN : FLUSHING_DECODER;
1773
1774    mFlushComplete[audio][false /* isDecoder */] = (mRenderer == NULL);
1775    mFlushComplete[audio][true /* isDecoder */] = false;
1776    if (audio) {
1777        ALOGE_IF(mFlushingAudio != NONE,
1778                "audio flushDecoder() is called in state %d", mFlushingAudio);
1779        mFlushingAudio = newStatus;
1780    } else {
1781        ALOGE_IF(mFlushingVideo != NONE,
1782                "video flushDecoder() is called in state %d", mFlushingVideo);
1783        mFlushingVideo = newStatus;
1784    }
1785}
1786
1787void NuPlayer::queueDecoderShutdown(
1788        bool audio, bool video, const sp<AMessage> &reply) {
1789    ALOGI("queueDecoderShutdown audio=%d, video=%d", audio, video);
1790
1791    mDeferredActions.push_back(
1792            new FlushDecoderAction(
1793                audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE,
1794                video ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE));
1795
1796    mDeferredActions.push_back(
1797            new SimpleAction(&NuPlayer::performScanSources));
1798
1799    mDeferredActions.push_back(new PostMessageAction(reply));
1800
1801    processDeferredActions();
1802}
1803
1804status_t NuPlayer::setVideoScalingMode(int32_t mode) {
1805    mVideoScalingMode = mode;
1806    if (mSurface != NULL) {
1807        status_t ret = native_window_set_scaling_mode(mSurface.get(), mVideoScalingMode);
1808        if (ret != OK) {
1809            ALOGE("Failed to set scaling mode (%d): %s",
1810                -ret, strerror(-ret));
1811            return ret;
1812        }
1813    }
1814    return OK;
1815}
1816
1817status_t NuPlayer::getTrackInfo(Parcel* reply) const {
1818    sp<AMessage> msg = new AMessage(kWhatGetTrackInfo, this);
1819    msg->setPointer("reply", reply);
1820
1821    sp<AMessage> response;
1822    status_t err = msg->postAndAwaitResponse(&response);
1823    return err;
1824}
1825
1826status_t NuPlayer::getSelectedTrack(int32_t type, Parcel* reply) const {
1827    sp<AMessage> msg = new AMessage(kWhatGetSelectedTrack, this);
1828    msg->setPointer("reply", reply);
1829    msg->setInt32("type", type);
1830
1831    sp<AMessage> response;
1832    status_t err = msg->postAndAwaitResponse(&response);
1833    if (err == OK && response != NULL) {
1834        CHECK(response->findInt32("err", &err));
1835    }
1836    return err;
1837}
1838
1839status_t NuPlayer::selectTrack(size_t trackIndex, bool select, int64_t timeUs) {
1840    sp<AMessage> msg = new AMessage(kWhatSelectTrack, this);
1841    msg->setSize("trackIndex", trackIndex);
1842    msg->setInt32("select", select);
1843    msg->setInt64("timeUs", timeUs);
1844
1845    sp<AMessage> response;
1846    status_t err = msg->postAndAwaitResponse(&response);
1847
1848    if (err != OK) {
1849        return err;
1850    }
1851
1852    if (!response->findInt32("err", &err)) {
1853        err = OK;
1854    }
1855
1856    return err;
1857}
1858
1859status_t NuPlayer::getCurrentPosition(int64_t *mediaUs) {
1860    sp<Renderer> renderer = mRenderer;
1861    if (renderer == NULL) {
1862        return NO_INIT;
1863    }
1864
1865    return renderer->getCurrentPosition(mediaUs);
1866}
1867
1868void NuPlayer::getStats(Vector<sp<AMessage> > *mTrackStats) {
1869    CHECK(mTrackStats != NULL);
1870
1871    mTrackStats->clear();
1872    if (mVideoDecoder != NULL) {
1873        mTrackStats->push_back(mVideoDecoder->getStats());
1874    }
1875    if (mAudioDecoder != NULL) {
1876        mTrackStats->push_back(mAudioDecoder->getStats());
1877    }
1878}
1879
1880sp<MetaData> NuPlayer::getFileMeta() {
1881    return mSource->getFileFormatMeta();
1882}
1883
1884float NuPlayer::getFrameRate() {
1885    sp<MetaData> meta = mSource->getFormatMeta(false /* audio */);
1886    if (meta == NULL) {
1887        return 0;
1888    }
1889    int32_t rate;
1890    if (!meta->findInt32(kKeyFrameRate, &rate)) {
1891        // fall back to try file meta
1892        sp<MetaData> fileMeta = getFileMeta();
1893        if (fileMeta == NULL) {
1894            ALOGW("source has video meta but not file meta");
1895            return -1;
1896        }
1897        int32_t fileMetaRate;
1898        if (!fileMeta->findInt32(kKeyFrameRate, &fileMetaRate)) {
1899            return -1;
1900        }
1901        return fileMetaRate;
1902    }
1903    return rate;
1904}
1905
1906void NuPlayer::schedulePollDuration() {
1907    sp<AMessage> msg = new AMessage(kWhatPollDuration, this);
1908    msg->setInt32("generation", mPollDurationGeneration);
1909    msg->post();
1910}
1911
1912void NuPlayer::cancelPollDuration() {
1913    ++mPollDurationGeneration;
1914}
1915
1916void NuPlayer::processDeferredActions() {
1917    while (!mDeferredActions.empty()) {
1918        // We won't execute any deferred actions until we're no longer in
1919        // an intermediate state, i.e. one more more decoders are currently
1920        // flushing or shutting down.
1921
1922        if (mFlushingAudio != NONE || mFlushingVideo != NONE) {
1923            // We're currently flushing, postpone the reset until that's
1924            // completed.
1925
1926            ALOGV("postponing action mFlushingAudio=%d, mFlushingVideo=%d",
1927                  mFlushingAudio, mFlushingVideo);
1928
1929            break;
1930        }
1931
1932        sp<Action> action = *mDeferredActions.begin();
1933        mDeferredActions.erase(mDeferredActions.begin());
1934
1935        action->execute(this);
1936    }
1937}
1938
1939void NuPlayer::performSeek(int64_t seekTimeUs) {
1940    ALOGV("performSeek seekTimeUs=%lld us (%.2f secs)",
1941          (long long)seekTimeUs,
1942          seekTimeUs / 1E6);
1943
1944    if (mSource == NULL) {
1945        // This happens when reset occurs right before the loop mode
1946        // asynchronously seeks to the start of the stream.
1947        LOG_ALWAYS_FATAL_IF(mAudioDecoder != NULL || mVideoDecoder != NULL,
1948                "mSource is NULL and decoders not NULL audio(%p) video(%p)",
1949                mAudioDecoder.get(), mVideoDecoder.get());
1950        return;
1951    }
1952    mPreviousSeekTimeUs = seekTimeUs;
1953    mSource->seekTo(seekTimeUs);
1954    mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
1955    ++mTimedTextGeneration;
1956
1957    // everything's flushed, continue playback.
1958}
1959
1960void NuPlayer::performDecoderFlush(FlushCommand audio, FlushCommand video) {
1961    ALOGV("performDecoderFlush audio=%d, video=%d", audio, video);
1962
1963    if ((audio == FLUSH_CMD_NONE || mAudioDecoder == NULL)
1964            && (video == FLUSH_CMD_NONE || mVideoDecoder == NULL)) {
1965        return;
1966    }
1967
1968    if (audio != FLUSH_CMD_NONE && mAudioDecoder != NULL) {
1969        flushDecoder(true /* audio */, (audio == FLUSH_CMD_SHUTDOWN));
1970    }
1971
1972    if (video != FLUSH_CMD_NONE && mVideoDecoder != NULL) {
1973        flushDecoder(false /* audio */, (video == FLUSH_CMD_SHUTDOWN));
1974    }
1975}
1976
1977void NuPlayer::performReset() {
1978    ALOGV("performReset");
1979
1980    CHECK(mAudioDecoder == NULL);
1981    CHECK(mVideoDecoder == NULL);
1982
1983    cancelPollDuration();
1984
1985    ++mScanSourcesGeneration;
1986    mScanSourcesPending = false;
1987
1988    if (mRendererLooper != NULL) {
1989        if (mRenderer != NULL) {
1990            mRendererLooper->unregisterHandler(mRenderer->id());
1991        }
1992        mRendererLooper->stop();
1993        mRendererLooper.clear();
1994    }
1995    mRenderer.clear();
1996    ++mRendererGeneration;
1997
1998    if (mSource != NULL) {
1999        mSource->stop();
2000
2001        mSource.clear();
2002    }
2003
2004    if (mDriver != NULL) {
2005        sp<NuPlayerDriver> driver = mDriver.promote();
2006        if (driver != NULL) {
2007            driver->notifyResetComplete();
2008        }
2009    }
2010
2011    mStarted = false;
2012    mResetting = false;
2013    mSourceStarted = false;
2014}
2015
2016void NuPlayer::performScanSources() {
2017    ALOGV("performScanSources");
2018
2019    if (!mStarted) {
2020        return;
2021    }
2022
2023    if (mAudioDecoder == NULL || mVideoDecoder == NULL) {
2024        postScanSources();
2025    }
2026}
2027
2028void NuPlayer::performSetSurface(const sp<Surface> &surface) {
2029    ALOGV("performSetSurface");
2030
2031    mSurface = surface;
2032
2033    // XXX - ignore error from setVideoScalingMode for now
2034    setVideoScalingMode(mVideoScalingMode);
2035
2036    if (mDriver != NULL) {
2037        sp<NuPlayerDriver> driver = mDriver.promote();
2038        if (driver != NULL) {
2039            driver->notifySetSurfaceComplete();
2040        }
2041    }
2042}
2043
2044void NuPlayer::performResumeDecoders(bool needNotify) {
2045    if (needNotify) {
2046        mResumePending = true;
2047        if (mVideoDecoder == NULL) {
2048            // if audio-only, we can notify seek complete now,
2049            // as the resume operation will be relatively fast.
2050            finishResume();
2051        }
2052    }
2053
2054    if (mVideoDecoder != NULL) {
2055        // When there is continuous seek, MediaPlayer will cache the seek
2056        // position, and send down new seek request when previous seek is
2057        // complete. Let's wait for at least one video output frame before
2058        // notifying seek complete, so that the video thumbnail gets updated
2059        // when seekbar is dragged.
2060        mVideoDecoder->signalResume(needNotify);
2061    }
2062
2063    if (mAudioDecoder != NULL) {
2064        mAudioDecoder->signalResume(false /* needNotify */);
2065    }
2066}
2067
2068void NuPlayer::finishResume() {
2069    if (mResumePending) {
2070        mResumePending = false;
2071        notifyDriverSeekComplete();
2072    }
2073}
2074
2075void NuPlayer::notifyDriverSeekComplete() {
2076    if (mDriver != NULL) {
2077        sp<NuPlayerDriver> driver = mDriver.promote();
2078        if (driver != NULL) {
2079            driver->notifySeekComplete();
2080        }
2081    }
2082}
2083
2084void NuPlayer::onSourceNotify(const sp<AMessage> &msg) {
2085    int32_t what;
2086    CHECK(msg->findInt32("what", &what));
2087
2088    switch (what) {
2089        case Source::kWhatInstantiateSecureDecoders:
2090        {
2091            if (mSource == NULL) {
2092                // This is a stale notification from a source that was
2093                // asynchronously preparing when the client called reset().
2094                // We handled the reset, the source is gone.
2095                break;
2096            }
2097
2098            sp<AMessage> reply;
2099            CHECK(msg->findMessage("reply", &reply));
2100            status_t err = onInstantiateSecureDecoders();
2101            reply->setInt32("err", err);
2102            reply->post();
2103            break;
2104        }
2105
2106        case Source::kWhatPrepared:
2107        {
2108            if (mSource == NULL) {
2109                // This is a stale notification from a source that was
2110                // asynchronously preparing when the client called reset().
2111                // We handled the reset, the source is gone.
2112                break;
2113            }
2114
2115            int32_t err;
2116            CHECK(msg->findInt32("err", &err));
2117
2118            if (err != OK) {
2119                // shut down potential secure codecs in case client never calls reset
2120                mDeferredActions.push_back(
2121                        new FlushDecoderAction(FLUSH_CMD_SHUTDOWN /* audio */,
2122                                               FLUSH_CMD_SHUTDOWN /* video */));
2123                processDeferredActions();
2124            }
2125
2126            sp<NuPlayerDriver> driver = mDriver.promote();
2127            if (driver != NULL) {
2128                // notify duration first, so that it's definitely set when
2129                // the app received the "prepare complete" callback.
2130                int64_t durationUs;
2131                if (mSource->getDuration(&durationUs) == OK) {
2132                    driver->notifyDuration(durationUs);
2133                }
2134                driver->notifyPrepareCompleted(err);
2135            }
2136
2137            break;
2138        }
2139
2140        case Source::kWhatFlagsChanged:
2141        {
2142            uint32_t flags;
2143            CHECK(msg->findInt32("flags", (int32_t *)&flags));
2144
2145            sp<NuPlayerDriver> driver = mDriver.promote();
2146            if (driver != NULL) {
2147                if ((flags & NuPlayer::Source::FLAG_CAN_SEEK) == 0) {
2148                    driver->notifyListener(
2149                            MEDIA_INFO, MEDIA_INFO_NOT_SEEKABLE, 0);
2150                }
2151                driver->notifyFlagsChanged(flags);
2152            }
2153
2154            if ((mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2155                    && (!(flags & Source::FLAG_DYNAMIC_DURATION))) {
2156                cancelPollDuration();
2157            } else if (!(mSourceFlags & Source::FLAG_DYNAMIC_DURATION)
2158                    && (flags & Source::FLAG_DYNAMIC_DURATION)
2159                    && (mAudioDecoder != NULL || mVideoDecoder != NULL)) {
2160                schedulePollDuration();
2161            }
2162
2163            mSourceFlags = flags;
2164            break;
2165        }
2166
2167        case Source::kWhatVideoSizeChanged:
2168        {
2169            sp<AMessage> format;
2170            CHECK(msg->findMessage("format", &format));
2171
2172            updateVideoSize(format);
2173            break;
2174        }
2175
2176        case Source::kWhatBufferingUpdate:
2177        {
2178            int32_t percentage;
2179            CHECK(msg->findInt32("percentage", &percentage));
2180
2181            notifyListener(MEDIA_BUFFERING_UPDATE, percentage, 0);
2182            break;
2183        }
2184
2185        case Source::kWhatPauseOnBufferingStart:
2186        {
2187            // ignore if not playing
2188            if (mStarted) {
2189                ALOGI("buffer low, pausing...");
2190
2191                mPausedForBuffering = true;
2192                onPause();
2193            }
2194            // fall-thru
2195        }
2196
2197        case Source::kWhatBufferingStart:
2198        {
2199            if (mPausedByClient) {
2200                mPendingBufferingFlag = PENDING_BUFFERING_FLAG_START;
2201            } else {
2202                notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_START, 0);
2203                mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
2204            }
2205            break;
2206        }
2207
2208        case Source::kWhatResumeOnBufferingEnd:
2209        {
2210            // ignore if not playing
2211            if (mStarted) {
2212                ALOGI("buffer ready, resuming...");
2213
2214                mPausedForBuffering = false;
2215
2216                // do not resume yet if client didn't unpause
2217                if (!mPausedByClient) {
2218                    onResume();
2219                }
2220            }
2221            // fall-thru
2222        }
2223
2224        case Source::kWhatBufferingEnd:
2225        {
2226            notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_END, 0);
2227            mPendingBufferingFlag = PENDING_BUFFERING_FLAG_NONE;
2228            break;
2229        }
2230
2231        case Source::kWhatCacheStats:
2232        {
2233            int32_t kbps;
2234            CHECK(msg->findInt32("bandwidth", &kbps));
2235
2236            notifyListener(MEDIA_INFO, MEDIA_INFO_NETWORK_BANDWIDTH, kbps);
2237            break;
2238        }
2239
2240        case Source::kWhatSubtitleData:
2241        {
2242            sp<ABuffer> buffer;
2243            CHECK(msg->findBuffer("buffer", &buffer));
2244
2245            sendSubtitleData(buffer, 0 /* baseIndex */);
2246            break;
2247        }
2248
2249        case Source::kWhatTimedMetaData:
2250        {
2251            sp<ABuffer> buffer;
2252            if (!msg->findBuffer("buffer", &buffer)) {
2253                notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2254            } else {
2255                sendTimedMetaData(buffer);
2256            }
2257            break;
2258        }
2259
2260        case Source::kWhatTimedTextData:
2261        {
2262            int32_t generation;
2263            if (msg->findInt32("generation", &generation)
2264                    && generation != mTimedTextGeneration) {
2265                break;
2266            }
2267
2268            sp<ABuffer> buffer;
2269            CHECK(msg->findBuffer("buffer", &buffer));
2270
2271            sp<NuPlayerDriver> driver = mDriver.promote();
2272            if (driver == NULL) {
2273                break;
2274            }
2275
2276            int posMs;
2277            int64_t timeUs, posUs;
2278            driver->getCurrentPosition(&posMs);
2279            posUs = (int64_t) posMs * 1000ll;
2280            CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2281
2282            if (posUs < timeUs) {
2283                if (!msg->findInt32("generation", &generation)) {
2284                    msg->setInt32("generation", mTimedTextGeneration);
2285                }
2286                msg->post(timeUs - posUs);
2287            } else {
2288                sendTimedTextData(buffer);
2289            }
2290            break;
2291        }
2292
2293        case Source::kWhatQueueDecoderShutdown:
2294        {
2295            int32_t audio, video;
2296            CHECK(msg->findInt32("audio", &audio));
2297            CHECK(msg->findInt32("video", &video));
2298
2299            sp<AMessage> reply;
2300            CHECK(msg->findMessage("reply", &reply));
2301
2302            queueDecoderShutdown(audio, video, reply);
2303            break;
2304        }
2305
2306        case Source::kWhatDrmNoLicense:
2307        {
2308            notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_DRM_NO_LICENSE);
2309            break;
2310        }
2311
2312        default:
2313            TRESPASS();
2314    }
2315}
2316
2317void NuPlayer::onClosedCaptionNotify(const sp<AMessage> &msg) {
2318    int32_t what;
2319    CHECK(msg->findInt32("what", &what));
2320
2321    switch (what) {
2322        case NuPlayer::CCDecoder::kWhatClosedCaptionData:
2323        {
2324            sp<ABuffer> buffer;
2325            CHECK(msg->findBuffer("buffer", &buffer));
2326
2327            size_t inbandTracks = 0;
2328            if (mSource != NULL) {
2329                inbandTracks = mSource->getTrackCount();
2330            }
2331
2332            sendSubtitleData(buffer, inbandTracks);
2333            break;
2334        }
2335
2336        case NuPlayer::CCDecoder::kWhatTrackAdded:
2337        {
2338            notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0);
2339
2340            break;
2341        }
2342
2343        default:
2344            TRESPASS();
2345    }
2346
2347
2348}
2349
2350void NuPlayer::sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex) {
2351    int32_t trackIndex;
2352    int64_t timeUs, durationUs;
2353    CHECK(buffer->meta()->findInt32("trackIndex", &trackIndex));
2354    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2355    CHECK(buffer->meta()->findInt64("durationUs", &durationUs));
2356
2357    Parcel in;
2358    in.writeInt32(trackIndex + baseIndex);
2359    in.writeInt64(timeUs);
2360    in.writeInt64(durationUs);
2361    in.writeInt32(buffer->size());
2362    in.writeInt32(buffer->size());
2363    in.write(buffer->data(), buffer->size());
2364
2365    notifyListener(MEDIA_SUBTITLE_DATA, 0, 0, &in);
2366}
2367
2368void NuPlayer::sendTimedMetaData(const sp<ABuffer> &buffer) {
2369    int64_t timeUs;
2370    CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2371
2372    Parcel in;
2373    in.writeInt64(timeUs);
2374    in.writeInt32(buffer->size());
2375    in.writeInt32(buffer->size());
2376    in.write(buffer->data(), buffer->size());
2377
2378    notifyListener(MEDIA_META_DATA, 0, 0, &in);
2379}
2380
2381void NuPlayer::sendTimedTextData(const sp<ABuffer> &buffer) {
2382    const void *data;
2383    size_t size = 0;
2384    int64_t timeUs;
2385    int32_t flag = TextDescriptions::IN_BAND_TEXT_3GPP;
2386
2387    AString mime;
2388    CHECK(buffer->meta()->findString("mime", &mime));
2389    CHECK(strcasecmp(mime.c_str(), MEDIA_MIMETYPE_TEXT_3GPP) == 0);
2390
2391    data = buffer->data();
2392    size = buffer->size();
2393
2394    Parcel parcel;
2395    if (size > 0) {
2396        CHECK(buffer->meta()->findInt64("timeUs", &timeUs));
2397        int32_t global = 0;
2398        if (buffer->meta()->findInt32("global", &global) && global) {
2399            flag |= TextDescriptions::GLOBAL_DESCRIPTIONS;
2400        } else {
2401            flag |= TextDescriptions::LOCAL_DESCRIPTIONS;
2402        }
2403        TextDescriptions::getParcelOfDescriptions(
2404                (const uint8_t *)data, size, flag, timeUs / 1000, &parcel);
2405    }
2406
2407    if ((parcel.dataSize() > 0)) {
2408        notifyListener(MEDIA_TIMED_TEXT, 0, 0, &parcel);
2409    } else {  // send an empty timed text
2410        notifyListener(MEDIA_TIMED_TEXT, 0, 0);
2411    }
2412}
2413////////////////////////////////////////////////////////////////////////////////
2414
2415sp<AMessage> NuPlayer::Source::getFormat(bool audio) {
2416    sp<MetaData> meta = getFormatMeta(audio);
2417
2418    if (meta == NULL) {
2419        return NULL;
2420    }
2421
2422    sp<AMessage> msg = new AMessage;
2423
2424    if(convertMetaDataToMessage(meta, &msg) == OK) {
2425        return msg;
2426    }
2427    return NULL;
2428}
2429
2430void NuPlayer::Source::notifyFlagsChanged(uint32_t flags) {
2431    sp<AMessage> notify = dupNotify();
2432    notify->setInt32("what", kWhatFlagsChanged);
2433    notify->setInt32("flags", flags);
2434    notify->post();
2435}
2436
2437void NuPlayer::Source::notifyVideoSizeChanged(const sp<AMessage> &format) {
2438    sp<AMessage> notify = dupNotify();
2439    notify->setInt32("what", kWhatVideoSizeChanged);
2440    notify->setMessage("format", format);
2441    notify->post();
2442}
2443
2444void NuPlayer::Source::notifyPrepared(status_t err) {
2445    sp<AMessage> notify = dupNotify();
2446    notify->setInt32("what", kWhatPrepared);
2447    notify->setInt32("err", err);
2448    notify->post();
2449}
2450
2451void NuPlayer::Source::notifyInstantiateSecureDecoders(const sp<AMessage> &reply) {
2452    sp<AMessage> notify = dupNotify();
2453    notify->setInt32("what", kWhatInstantiateSecureDecoders);
2454    notify->setMessage("reply", reply);
2455    notify->post();
2456}
2457
2458void NuPlayer::Source::onMessageReceived(const sp<AMessage> & /* msg */) {
2459    TRESPASS();
2460}
2461
2462}  // namespace android
2463