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