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