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