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