1 /*
2 * Copyright (C) 2012 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 "GenericSource"
19
20 #include "GenericSource.h"
21 #include "NuPlayerDrm.h"
22
23 #include "AnotherPacketSource.h"
24 #include <binder/IServiceManager.h>
25 #include <cutils/properties.h>
26 #include <datasource/PlayerServiceDataSourceFactory.h>
27 #include <datasource/PlayerServiceFileSource.h>
28 #include <datasource/HTTPBase.h>
29 #include <datasource/NuCachedSource2.h>
30 #include <media/DataSource.h>
31 #include <media/MediaBufferHolder.h>
32 #include <media/stagefright/MediaSource.h>
33 #include <android/IMediaExtractorService.h>
34 #include <media/IMediaHTTPService.h>
35 #include <media/stagefright/foundation/ABuffer.h>
36 #include <media/stagefright/foundation/ADebug.h>
37 #include <media/stagefright/foundation/AMessage.h>
38 #include <media/stagefright/InterfaceUtils.h>
39 #include <media/stagefright/FoundationUtils.h>
40 #include <media/stagefright/MediaBuffer.h>
41 #include <media/stagefright/MediaClock.h>
42 #include <media/stagefright/MediaDefs.h>
43 #include <media/stagefright/MediaExtractor.h>
44 #include <media/stagefright/MediaExtractorFactory.h>
45 #include <media/stagefright/MetaData.h>
46 #include <media/stagefright/Utils.h>
47
48 namespace android {
49
50 static const int kInitialMarkMs = 5000; // 5secs
51
52 //static const int kPausePlaybackMarkMs = 2000; // 2secs
53 static const int kResumePlaybackMarkMs = 15000; // 15secs
54
GenericSource(const sp<AMessage> & notify,bool uidValid,uid_t uid,const sp<MediaClock> & mediaClock)55 NuPlayer::GenericSource::GenericSource(
56 const sp<AMessage> ¬ify,
57 bool uidValid,
58 uid_t uid,
59 const sp<MediaClock> &mediaClock)
60 : Source(notify),
61 mAudioTimeUs(0),
62 mAudioLastDequeueTimeUs(0),
63 mVideoTimeUs(0),
64 mVideoLastDequeueTimeUs(0),
65 mPrevBufferPercentage(-1),
66 mPollBufferingGeneration(0),
67 mSentPauseOnBuffering(false),
68 mAudioDataGeneration(0),
69 mVideoDataGeneration(0),
70 mFetchSubtitleDataGeneration(0),
71 mFetchTimedTextDataGeneration(0),
72 mDurationUs(-1LL),
73 mAudioIsVorbis(false),
74 mIsSecure(false),
75 mIsStreaming(false),
76 mUIDValid(uidValid),
77 mUID(uid),
78 mMediaClock(mediaClock),
79 mBitrate(-1LL),
80 mPendingReadBufferTypes(0) {
81 ALOGV("GenericSource");
82 CHECK(mediaClock != NULL);
83
84 mBufferingSettings.mInitialMarkMs = kInitialMarkMs;
85 mBufferingSettings.mResumePlaybackMarkMs = kResumePlaybackMarkMs;
86 resetDataSource();
87 }
88
resetDataSource()89 void NuPlayer::GenericSource::resetDataSource() {
90 ALOGV("resetDataSource");
91
92 mHTTPService.clear();
93 {
94 Mutex::Autolock _l_d(mDisconnectLock);
95 mHttpSource.clear();
96 mDisconnected = false;
97 }
98 mUri.clear();
99 mUriHeaders.clear();
100 mSources.clear();
101 mFd.reset();
102 mOffset = 0;
103 mLength = 0;
104 mStarted = false;
105 mPreparing = false;
106
107 mIsDrmProtected = false;
108 mIsDrmReleased = false;
109 mIsSecure = false;
110 mMimes.clear();
111 }
112
setDataSource(const sp<IMediaHTTPService> & httpService,const char * url,const KeyedVector<String8,String8> * headers)113 status_t NuPlayer::GenericSource::setDataSource(
114 const sp<IMediaHTTPService> &httpService,
115 const char *url,
116 const KeyedVector<String8, String8> *headers) {
117 Mutex::Autolock _l(mLock);
118 ALOGV("setDataSource url: %s", url);
119
120 resetDataSource();
121
122 mHTTPService = httpService;
123 mUri = url;
124
125 if (headers) {
126 mUriHeaders = *headers;
127 }
128
129 // delay data source creation to prepareAsync() to avoid blocking
130 // the calling thread in setDataSource for any significant time.
131 return OK;
132 }
133
setDataSource(int fd,int64_t offset,int64_t length)134 status_t NuPlayer::GenericSource::setDataSource(
135 int fd, int64_t offset, int64_t length) {
136 Mutex::Autolock _l(mLock);
137 ALOGV("setDataSource %d/%lld/%lld (%s)", fd, (long long)offset, (long long)length, nameForFd(fd).c_str());
138
139 resetDataSource();
140
141 mFd.reset(dup(fd));
142 mOffset = offset;
143 mLength = length;
144
145 // delay data source creation to prepareAsync() to avoid blocking
146 // the calling thread in setDataSource for any significant time.
147 return OK;
148 }
149
setDataSource(const sp<DataSource> & source)150 status_t NuPlayer::GenericSource::setDataSource(const sp<DataSource>& source) {
151 Mutex::Autolock _l(mLock);
152 ALOGV("setDataSource (source: %p)", source.get());
153
154 resetDataSource();
155 {
156 Mutex::Autolock _l_d(mDisconnectLock);
157 mDataSource = source;
158 }
159 return OK;
160 }
161
getFileFormatMeta() const162 sp<MetaData> NuPlayer::GenericSource::getFileFormatMeta() const {
163 Mutex::Autolock _l(mLock);
164 return mFileMeta;
165 }
166
initFromDataSource()167 status_t NuPlayer::GenericSource::initFromDataSource() {
168 sp<IMediaExtractor> extractor;
169 sp<DataSource> dataSource;
170 {
171 Mutex::Autolock _l_d(mDisconnectLock);
172 dataSource = mDataSource;
173 }
174 CHECK(dataSource != NULL);
175
176 mLock.unlock();
177 // This might take long time if data source is not reliable.
178 extractor = MediaExtractorFactory::Create(dataSource, NULL);
179
180 if (extractor == NULL) {
181 ALOGE("initFromDataSource, cannot create extractor!");
182 mLock.lock();
183 return UNKNOWN_ERROR;
184 }
185
186 sp<MetaData> fileMeta = extractor->getMetaData();
187
188 size_t numtracks = extractor->countTracks();
189 if (numtracks == 0) {
190 ALOGE("initFromDataSource, source has no track!");
191 mLock.lock();
192 return UNKNOWN_ERROR;
193 }
194
195 mLock.lock();
196 mFileMeta = fileMeta;
197 if (mFileMeta != NULL) {
198 int64_t duration;
199 if (mFileMeta->findInt64(kKeyDuration, &duration)) {
200 mDurationUs = duration;
201 }
202 }
203
204 int32_t totalBitrate = 0;
205
206 mMimes.clear();
207
208 for (size_t i = 0; i < numtracks; ++i) {
209 sp<IMediaSource> track = extractor->getTrack(i);
210 if (track == NULL) {
211 continue;
212 }
213
214 sp<MetaData> meta = extractor->getTrackMetaData(i);
215 if (meta == NULL) {
216 ALOGE("no metadata for track %zu", i);
217 return UNKNOWN_ERROR;
218 }
219
220 const char *mime;
221 CHECK(meta->findCString(kKeyMIMEType, &mime));
222
223 ALOGV("initFromDataSource track[%zu]: %s", i, mime);
224
225 // Do the string compare immediately with "mime",
226 // we can't assume "mime" would stay valid after another
227 // extractor operation, some extractors might modify meta
228 // during getTrack() and make it invalid.
229 if (!strncasecmp(mime, "audio/", 6)) {
230 if (mAudioTrack.mSource == NULL) {
231 mAudioTrack.mIndex = i;
232 mAudioTrack.mSource = track;
233 mAudioTrack.mPackets =
234 new AnotherPacketSource(mAudioTrack.mSource->getFormat());
235
236 if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_VORBIS)) {
237 mAudioIsVorbis = true;
238 } else {
239 mAudioIsVorbis = false;
240 }
241
242 mMimes.add(String8(mime));
243 }
244 } else if (!strncasecmp(mime, "video/", 6)) {
245 if (mVideoTrack.mSource == NULL) {
246 mVideoTrack.mIndex = i;
247 mVideoTrack.mSource = track;
248 mVideoTrack.mPackets =
249 new AnotherPacketSource(mVideoTrack.mSource->getFormat());
250
251 // video always at the beginning
252 mMimes.insertAt(String8(mime), 0);
253 }
254 }
255
256 mSources.push(track);
257 int64_t durationUs;
258 if (meta->findInt64(kKeyDuration, &durationUs)) {
259 if (durationUs > mDurationUs) {
260 mDurationUs = durationUs;
261 }
262 }
263
264 int32_t bitrate;
265 if (totalBitrate >= 0 && meta->findInt32(kKeyBitRate, &bitrate)) {
266 totalBitrate += bitrate;
267 } else {
268 totalBitrate = -1;
269 }
270 }
271
272 ALOGV("initFromDataSource mSources.size(): %zu mIsSecure: %d mime[0]: %s", mSources.size(),
273 mIsSecure, (mMimes.isEmpty() ? "NONE" : mMimes[0].string()));
274
275 if (mSources.size() == 0) {
276 ALOGE("b/23705695");
277 return UNKNOWN_ERROR;
278 }
279
280 // Modular DRM: The return value doesn't affect source initialization.
281 (void)checkDrmInfo();
282
283 mBitrate = totalBitrate;
284
285 return OK;
286 }
287
getBufferingSettings(BufferingSettings * buffering)288 status_t NuPlayer::GenericSource::getBufferingSettings(
289 BufferingSettings* buffering /* nonnull */) {
290 {
291 Mutex::Autolock _l(mLock);
292 *buffering = mBufferingSettings;
293 }
294
295 ALOGV("getBufferingSettings{%s}", buffering->toString().string());
296 return OK;
297 }
298
setBufferingSettings(const BufferingSettings & buffering)299 status_t NuPlayer::GenericSource::setBufferingSettings(const BufferingSettings& buffering) {
300 ALOGV("setBufferingSettings{%s}", buffering.toString().string());
301
302 Mutex::Autolock _l(mLock);
303 mBufferingSettings = buffering;
304 return OK;
305 }
306
startSources()307 status_t NuPlayer::GenericSource::startSources() {
308 // Start the selected A/V tracks now before we start buffering.
309 // Widevine sources might re-initialize crypto when starting, if we delay
310 // this to start(), all data buffered during prepare would be wasted.
311 // (We don't actually start reading until start().)
312 //
313 // TODO: this logic may no longer be relevant after the removal of widevine
314 // support
315 if (mAudioTrack.mSource != NULL && mAudioTrack.mSource->start() != OK) {
316 ALOGE("failed to start audio track!");
317 return UNKNOWN_ERROR;
318 }
319
320 if (mVideoTrack.mSource != NULL && mVideoTrack.mSource->start() != OK) {
321 ALOGE("failed to start video track!");
322 return UNKNOWN_ERROR;
323 }
324
325 return OK;
326 }
327
getLastReadPosition()328 int64_t NuPlayer::GenericSource::getLastReadPosition() {
329 if (mAudioTrack.mSource != NULL) {
330 return mAudioTimeUs;
331 } else if (mVideoTrack.mSource != NULL) {
332 return mVideoTimeUs;
333 } else {
334 return 0;
335 }
336 }
337
isStreaming() const338 bool NuPlayer::GenericSource::isStreaming() const {
339 Mutex::Autolock _l(mLock);
340 return mIsStreaming;
341 }
342
~GenericSource()343 NuPlayer::GenericSource::~GenericSource() {
344 ALOGV("~GenericSource");
345 if (mLooper != NULL) {
346 mLooper->unregisterHandler(id());
347 mLooper->stop();
348 }
349 resetDataSource();
350 }
351
prepareAsync()352 void NuPlayer::GenericSource::prepareAsync() {
353 Mutex::Autolock _l(mLock);
354 ALOGV("prepareAsync: (looper: %d)", (mLooper != NULL));
355
356 if (mLooper == NULL) {
357 mLooper = new ALooper;
358 mLooper->setName("generic");
359 mLooper->start();
360
361 mLooper->registerHandler(this);
362 }
363
364 sp<AMessage> msg = new AMessage(kWhatPrepareAsync, this);
365 msg->post();
366 }
367
onPrepareAsync()368 void NuPlayer::GenericSource::onPrepareAsync() {
369 mDisconnectLock.lock();
370 ALOGV("onPrepareAsync: mDataSource: %d", (mDataSource != NULL));
371
372 // delayed data source creation
373 if (mDataSource == NULL) {
374 // set to false first, if the extractor
375 // comes back as secure, set it to true then.
376 mIsSecure = false;
377
378 if (!mUri.empty()) {
379 const char* uri = mUri.c_str();
380 String8 contentType;
381
382 if (!strncasecmp("http://", uri, 7) || !strncasecmp("https://", uri, 8)) {
383 sp<DataSource> httpSource;
384 mDisconnectLock.unlock();
385 httpSource = PlayerServiceDataSourceFactory::getInstance()
386 ->CreateMediaHTTP(mHTTPService);
387 if (httpSource == NULL) {
388 ALOGE("Failed to create http source!");
389 notifyPreparedAndCleanup(UNKNOWN_ERROR);
390 return;
391 }
392 mDisconnectLock.lock();
393
394 if (!mDisconnected) {
395 mHttpSource = httpSource;
396 }
397 }
398
399 mLock.unlock();
400 mDisconnectLock.unlock();
401 // This might take long time if connection has some issue.
402 sp<DataSource> dataSource = PlayerServiceDataSourceFactory::getInstance()
403 ->CreateFromURI(mHTTPService, uri, &mUriHeaders, &contentType,
404 static_cast<HTTPBase *>(mHttpSource.get()));
405 mDisconnectLock.lock();
406 mLock.lock();
407 if (!mDisconnected) {
408 mDataSource = dataSource;
409 }
410 } else {
411 if (property_get_bool("media.stagefright.extractremote", true) &&
412 !PlayerServiceFileSource::requiresDrm(
413 mFd.get(), mOffset, mLength, nullptr /* mime */)) {
414 sp<IBinder> binder =
415 defaultServiceManager()->getService(String16("media.extractor"));
416 if (binder != nullptr) {
417 ALOGD("FileSource remote");
418 sp<IMediaExtractorService> mediaExService(
419 interface_cast<IMediaExtractorService>(binder));
420 sp<IDataSource> source;
421 mediaExService->makeIDataSource(base::unique_fd(dup(mFd.get())), mOffset, mLength, &source);
422 ALOGV("IDataSource(FileSource): %p %d %lld %lld",
423 source.get(), mFd.get(), (long long)mOffset, (long long)mLength);
424 if (source.get() != nullptr) {
425 mDataSource = CreateDataSourceFromIDataSource(source);
426 } else {
427 ALOGW("extractor service cannot make data source");
428 }
429 } else {
430 ALOGW("extractor service not running");
431 }
432 }
433 if (mDataSource == nullptr) {
434 ALOGD("FileSource local");
435 mDataSource = new PlayerServiceFileSource(dup(mFd.get()), mOffset, mLength);
436 }
437 }
438
439 if (mDataSource == NULL) {
440 ALOGE("Failed to create data source!");
441 mDisconnectLock.unlock();
442 notifyPreparedAndCleanup(UNKNOWN_ERROR);
443 return;
444 }
445 }
446
447 if (mDataSource->flags() & DataSource::kIsCachingDataSource) {
448 mCachedSource = static_cast<NuCachedSource2 *>(mDataSource.get());
449 }
450
451 mDisconnectLock.unlock();
452
453 // For cached streaming cases, we need to wait for enough
454 // buffering before reporting prepared.
455 mIsStreaming = (mCachedSource != NULL);
456
457 // init extractor from data source
458 status_t err = initFromDataSource();
459
460 if (err != OK) {
461 ALOGE("Failed to init from data source!");
462 notifyPreparedAndCleanup(err);
463 return;
464 }
465
466 if (mVideoTrack.mSource != NULL) {
467 sp<MetaData> meta = getFormatMeta_l(false /* audio */);
468 sp<AMessage> msg = new AMessage;
469 err = convertMetaDataToMessage(meta, &msg);
470 if(err != OK) {
471 notifyPreparedAndCleanup(err);
472 return;
473 }
474 notifyVideoSizeChanged(msg);
475 }
476
477 notifyFlagsChanged(
478 // FLAG_SECURE will be known if/when prepareDrm is called by the app
479 // FLAG_PROTECTED will be known if/when prepareDrm is called by the app
480 FLAG_CAN_PAUSE |
481 FLAG_CAN_SEEK_BACKWARD |
482 FLAG_CAN_SEEK_FORWARD |
483 FLAG_CAN_SEEK);
484
485 finishPrepareAsync();
486
487 ALOGV("onPrepareAsync: Done");
488 }
489
finishPrepareAsync()490 void NuPlayer::GenericSource::finishPrepareAsync() {
491 ALOGV("finishPrepareAsync");
492
493 status_t err = startSources();
494 if (err != OK) {
495 ALOGE("Failed to init start data source!");
496 notifyPreparedAndCleanup(err);
497 return;
498 }
499
500 if (mIsStreaming) {
501 mCachedSource->resumeFetchingIfNecessary();
502 mPreparing = true;
503 schedulePollBuffering();
504 } else {
505 notifyPrepared();
506 }
507
508 if (mAudioTrack.mSource != NULL) {
509 postReadBuffer(MEDIA_TRACK_TYPE_AUDIO);
510 }
511
512 if (mVideoTrack.mSource != NULL) {
513 postReadBuffer(MEDIA_TRACK_TYPE_VIDEO);
514 }
515 }
516
notifyPreparedAndCleanup(status_t err)517 void NuPlayer::GenericSource::notifyPreparedAndCleanup(status_t err) {
518 if (err != OK) {
519 {
520 Mutex::Autolock _l_d(mDisconnectLock);
521 mDataSource.clear();
522 mHttpSource.clear();
523 }
524
525 mCachedSource.clear();
526
527 mBitrate = -1;
528 mPrevBufferPercentage = -1;
529 ++mPollBufferingGeneration;
530 }
531 notifyPrepared(err);
532 }
533
start()534 void NuPlayer::GenericSource::start() {
535 Mutex::Autolock _l(mLock);
536 ALOGI("start");
537
538 if (mAudioTrack.mSource != NULL) {
539 postReadBuffer(MEDIA_TRACK_TYPE_AUDIO);
540 }
541
542 if (mVideoTrack.mSource != NULL) {
543 postReadBuffer(MEDIA_TRACK_TYPE_VIDEO);
544 }
545
546 mStarted = true;
547 }
548
stop()549 void NuPlayer::GenericSource::stop() {
550 Mutex::Autolock _l(mLock);
551 mStarted = false;
552 }
553
pause()554 void NuPlayer::GenericSource::pause() {
555 Mutex::Autolock _l(mLock);
556 mStarted = false;
557 }
558
resume()559 void NuPlayer::GenericSource::resume() {
560 Mutex::Autolock _l(mLock);
561 mStarted = true;
562 }
563
disconnect()564 void NuPlayer::GenericSource::disconnect() {
565 sp<DataSource> dataSource, httpSource;
566 {
567 Mutex::Autolock _l_d(mDisconnectLock);
568 dataSource = mDataSource;
569 httpSource = mHttpSource;
570 mDisconnected = true;
571 }
572
573 if (dataSource != NULL) {
574 // disconnect data source
575 if (dataSource->flags() & DataSource::kIsCachingDataSource) {
576 static_cast<NuCachedSource2 *>(dataSource.get())->disconnect();
577 }
578 } else if (httpSource != NULL) {
579 static_cast<HTTPBase *>(httpSource.get())->disconnect();
580 }
581 }
582
feedMoreTSData()583 status_t NuPlayer::GenericSource::feedMoreTSData() {
584 return OK;
585 }
586
sendCacheStats()587 void NuPlayer::GenericSource::sendCacheStats() {
588 int32_t kbps = 0;
589 status_t err = UNKNOWN_ERROR;
590
591 if (mCachedSource != NULL) {
592 err = mCachedSource->getEstimatedBandwidthKbps(&kbps);
593 }
594
595 if (err == OK) {
596 sp<AMessage> notify = dupNotify();
597 notify->setInt32("what", kWhatCacheStats);
598 notify->setInt32("bandwidth", kbps);
599 notify->post();
600 }
601 }
602
onMessageReceived(const sp<AMessage> & msg)603 void NuPlayer::GenericSource::onMessageReceived(const sp<AMessage> &msg) {
604 Mutex::Autolock _l(mLock);
605 switch (msg->what()) {
606 case kWhatPrepareAsync:
607 {
608 onPrepareAsync();
609 break;
610 }
611 case kWhatFetchSubtitleData:
612 {
613 fetchTextData(kWhatSendSubtitleData, MEDIA_TRACK_TYPE_SUBTITLE,
614 mFetchSubtitleDataGeneration, mSubtitleTrack.mPackets, msg);
615 break;
616 }
617
618 case kWhatFetchTimedTextData:
619 {
620 fetchTextData(kWhatSendTimedTextData, MEDIA_TRACK_TYPE_TIMEDTEXT,
621 mFetchTimedTextDataGeneration, mTimedTextTrack.mPackets, msg);
622 break;
623 }
624
625 case kWhatSendSubtitleData:
626 {
627 sendTextData(kWhatSubtitleData, MEDIA_TRACK_TYPE_SUBTITLE,
628 mFetchSubtitleDataGeneration, mSubtitleTrack.mPackets, msg);
629 break;
630 }
631
632 case kWhatSendGlobalTimedTextData:
633 {
634 sendGlobalTextData(kWhatTimedTextData, mFetchTimedTextDataGeneration, msg);
635 break;
636 }
637 case kWhatSendTimedTextData:
638 {
639 sendTextData(kWhatTimedTextData, MEDIA_TRACK_TYPE_TIMEDTEXT,
640 mFetchTimedTextDataGeneration, mTimedTextTrack.mPackets, msg);
641 break;
642 }
643
644 case kWhatChangeAVSource:
645 {
646 int32_t trackIndex;
647 CHECK(msg->findInt32("trackIndex", &trackIndex));
648 const sp<IMediaSource> source = mSources.itemAt(trackIndex);
649
650 Track* track;
651 const char *mime;
652 media_track_type trackType, counterpartType;
653 sp<MetaData> meta = source->getFormat();
654 meta->findCString(kKeyMIMEType, &mime);
655 if (!strncasecmp(mime, "audio/", 6)) {
656 track = &mAudioTrack;
657 trackType = MEDIA_TRACK_TYPE_AUDIO;
658 counterpartType = MEDIA_TRACK_TYPE_VIDEO;;
659 } else {
660 CHECK(!strncasecmp(mime, "video/", 6));
661 track = &mVideoTrack;
662 trackType = MEDIA_TRACK_TYPE_VIDEO;
663 counterpartType = MEDIA_TRACK_TYPE_AUDIO;;
664 }
665
666
667 if (track->mSource != NULL) {
668 track->mSource->stop();
669 }
670 track->mSource = source;
671 track->mSource->start();
672 track->mIndex = trackIndex;
673 ++mAudioDataGeneration;
674 ++mVideoDataGeneration;
675
676 int64_t timeUs, actualTimeUs;
677 const bool formatChange = true;
678 if (trackType == MEDIA_TRACK_TYPE_AUDIO) {
679 timeUs = mAudioLastDequeueTimeUs;
680 } else {
681 timeUs = mVideoLastDequeueTimeUs;
682 }
683 readBuffer(trackType, timeUs, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */,
684 &actualTimeUs, formatChange);
685 readBuffer(counterpartType, -1, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */,
686 NULL, !formatChange);
687 ALOGV("timeUs %lld actualTimeUs %lld", (long long)timeUs, (long long)actualTimeUs);
688
689 break;
690 }
691
692 case kWhatSeek:
693 {
694 onSeek(msg);
695 break;
696 }
697
698 case kWhatReadBuffer:
699 {
700 onReadBuffer(msg);
701 break;
702 }
703
704 case kWhatPollBuffering:
705 {
706 int32_t generation;
707 CHECK(msg->findInt32("generation", &generation));
708 if (generation == mPollBufferingGeneration) {
709 onPollBuffering();
710 }
711 break;
712 }
713
714 default:
715 Source::onMessageReceived(msg);
716 break;
717 }
718 }
719
fetchTextData(uint32_t sendWhat,media_track_type type,int32_t curGen,const sp<AnotherPacketSource> & packets,const sp<AMessage> & msg)720 void NuPlayer::GenericSource::fetchTextData(
721 uint32_t sendWhat,
722 media_track_type type,
723 int32_t curGen,
724 const sp<AnotherPacketSource>& packets,
725 const sp<AMessage>& msg) {
726 int32_t msgGeneration;
727 CHECK(msg->findInt32("generation", &msgGeneration));
728 if (msgGeneration != curGen) {
729 // stale
730 return;
731 }
732
733 int32_t avail;
734 if (packets->hasBufferAvailable(&avail)) {
735 return;
736 }
737
738 int64_t timeUs;
739 CHECK(msg->findInt64("timeUs", &timeUs));
740
741 int64_t subTimeUs = 0;
742 readBuffer(type, timeUs, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */, &subTimeUs);
743
744 status_t eosResult;
745 if (!packets->hasBufferAvailable(&eosResult)) {
746 return;
747 }
748
749 if (msg->what() == kWhatFetchSubtitleData) {
750 subTimeUs -= 1000000LL; // send subtile data one second earlier
751 }
752 sp<AMessage> msg2 = new AMessage(sendWhat, this);
753 msg2->setInt32("generation", msgGeneration);
754 mMediaClock->addTimer(msg2, subTimeUs);
755 }
756
sendTextData(uint32_t what,media_track_type type,int32_t curGen,const sp<AnotherPacketSource> & packets,const sp<AMessage> & msg)757 void NuPlayer::GenericSource::sendTextData(
758 uint32_t what,
759 media_track_type type,
760 int32_t curGen,
761 const sp<AnotherPacketSource>& packets,
762 const sp<AMessage>& msg) {
763 int32_t msgGeneration;
764 CHECK(msg->findInt32("generation", &msgGeneration));
765 if (msgGeneration != curGen) {
766 // stale
767 return;
768 }
769
770 int64_t subTimeUs;
771 if (packets->nextBufferTime(&subTimeUs) != OK) {
772 return;
773 }
774
775 int64_t nextSubTimeUs = 0;
776 readBuffer(type, -1, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */, &nextSubTimeUs);
777
778 sp<ABuffer> buffer;
779 status_t dequeueStatus = packets->dequeueAccessUnit(&buffer);
780 if (dequeueStatus == OK) {
781 sp<AMessage> notify = dupNotify();
782 notify->setInt32("what", what);
783 notify->setBuffer("buffer", buffer);
784 notify->post();
785
786 if (msg->what() == kWhatSendSubtitleData) {
787 nextSubTimeUs -= 1000000LL; // send subtile data one second earlier
788 }
789 mMediaClock->addTimer(msg, nextSubTimeUs);
790 }
791 }
792
sendGlobalTextData(uint32_t what,int32_t curGen,sp<AMessage> msg)793 void NuPlayer::GenericSource::sendGlobalTextData(
794 uint32_t what,
795 int32_t curGen,
796 sp<AMessage> msg) {
797 int32_t msgGeneration;
798 CHECK(msg->findInt32("generation", &msgGeneration));
799 if (msgGeneration != curGen) {
800 // stale
801 return;
802 }
803
804 uint32_t textType;
805 const void *data;
806 size_t size = 0;
807 if (mTimedTextTrack.mSource->getFormat()->findData(
808 kKeyTextFormatData, &textType, &data, &size)) {
809 mGlobalTimedText = new ABuffer(size);
810 if (mGlobalTimedText->data()) {
811 memcpy(mGlobalTimedText->data(), data, size);
812 sp<AMessage> globalMeta = mGlobalTimedText->meta();
813 globalMeta->setInt64("timeUs", 0);
814 globalMeta->setString("mime", MEDIA_MIMETYPE_TEXT_3GPP);
815 globalMeta->setInt32("global", 1);
816 sp<AMessage> notify = dupNotify();
817 notify->setInt32("what", what);
818 notify->setBuffer("buffer", mGlobalTimedText);
819 notify->post();
820 }
821 }
822 }
823
getFormatMeta(bool audio)824 sp<MetaData> NuPlayer::GenericSource::getFormatMeta(bool audio) {
825 Mutex::Autolock _l(mLock);
826 return getFormatMeta_l(audio);
827 }
828
getFormatMeta_l(bool audio)829 sp<MetaData> NuPlayer::GenericSource::getFormatMeta_l(bool audio) {
830 sp<IMediaSource> source = audio ? mAudioTrack.mSource : mVideoTrack.mSource;
831
832 if (source == NULL) {
833 return NULL;
834 }
835
836 return source->getFormat();
837 }
838
dequeueAccessUnit(bool audio,sp<ABuffer> * accessUnit)839 status_t NuPlayer::GenericSource::dequeueAccessUnit(
840 bool audio, sp<ABuffer> *accessUnit) {
841 Mutex::Autolock _l(mLock);
842 // If has gone through stop/releaseDrm sequence, we no longer send down any buffer b/c
843 // the codec's crypto object has gone away (b/37960096).
844 // Note: This will be unnecessary when stop() changes behavior and releases codec (b/35248283).
845 if (!mStarted && mIsDrmReleased) {
846 return -EWOULDBLOCK;
847 }
848
849 Track *track = audio ? &mAudioTrack : &mVideoTrack;
850
851 if (track->mSource == NULL) {
852 return -EWOULDBLOCK;
853 }
854
855 status_t finalResult;
856 if (!track->mPackets->hasBufferAvailable(&finalResult)) {
857 if (finalResult == OK) {
858 postReadBuffer(
859 audio ? MEDIA_TRACK_TYPE_AUDIO : MEDIA_TRACK_TYPE_VIDEO);
860 return -EWOULDBLOCK;
861 }
862 return finalResult;
863 }
864
865 status_t result = track->mPackets->dequeueAccessUnit(accessUnit);
866
867 // start pulling in more buffers if cache is running low
868 // so that decoder has less chance of being starved
869 if (!mIsStreaming) {
870 if (track->mPackets->getAvailableBufferCount(&finalResult) < 2) {
871 postReadBuffer(audio? MEDIA_TRACK_TYPE_AUDIO : MEDIA_TRACK_TYPE_VIDEO);
872 }
873 } else {
874 int64_t durationUs = track->mPackets->getBufferedDurationUs(&finalResult);
875 // TODO: maxRebufferingMarkMs could be larger than
876 // mBufferingSettings.mResumePlaybackMarkMs
877 int64_t restartBufferingMarkUs =
878 mBufferingSettings.mResumePlaybackMarkMs * 1000LL / 2;
879 if (finalResult == OK) {
880 if (durationUs < restartBufferingMarkUs) {
881 postReadBuffer(audio? MEDIA_TRACK_TYPE_AUDIO : MEDIA_TRACK_TYPE_VIDEO);
882 }
883 if (track->mPackets->getAvailableBufferCount(&finalResult) < 2
884 && !mSentPauseOnBuffering && !mPreparing) {
885 mCachedSource->resumeFetchingIfNecessary();
886 sendCacheStats();
887 mSentPauseOnBuffering = true;
888 sp<AMessage> notify = dupNotify();
889 notify->setInt32("what", kWhatPauseOnBufferingStart);
890 notify->post();
891 }
892 }
893 }
894
895 if (result != OK) {
896 if (mSubtitleTrack.mSource != NULL) {
897 mSubtitleTrack.mPackets->clear();
898 mFetchSubtitleDataGeneration++;
899 }
900 if (mTimedTextTrack.mSource != NULL) {
901 mTimedTextTrack.mPackets->clear();
902 mFetchTimedTextDataGeneration++;
903 }
904 return result;
905 }
906
907 int64_t timeUs;
908 status_t eosResult; // ignored
909 CHECK((*accessUnit)->meta()->findInt64("timeUs", &timeUs));
910 if (audio) {
911 mAudioLastDequeueTimeUs = timeUs;
912 } else {
913 mVideoLastDequeueTimeUs = timeUs;
914 }
915
916 if (mSubtitleTrack.mSource != NULL
917 && !mSubtitleTrack.mPackets->hasBufferAvailable(&eosResult)) {
918 sp<AMessage> msg = new AMessage(kWhatFetchSubtitleData, this);
919 msg->setInt64("timeUs", timeUs);
920 msg->setInt32("generation", mFetchSubtitleDataGeneration);
921 msg->post();
922 }
923
924 if (mTimedTextTrack.mSource != NULL
925 && !mTimedTextTrack.mPackets->hasBufferAvailable(&eosResult)) {
926 sp<AMessage> msg = new AMessage(kWhatFetchTimedTextData, this);
927 msg->setInt64("timeUs", timeUs);
928 msg->setInt32("generation", mFetchTimedTextDataGeneration);
929 msg->post();
930 }
931
932 return result;
933 }
934
getDuration(int64_t * durationUs)935 status_t NuPlayer::GenericSource::getDuration(int64_t *durationUs) {
936 Mutex::Autolock _l(mLock);
937 *durationUs = mDurationUs;
938 return OK;
939 }
940
getTrackCount() const941 size_t NuPlayer::GenericSource::getTrackCount() const {
942 Mutex::Autolock _l(mLock);
943 return mSources.size();
944 }
945
getTrackInfo(size_t trackIndex) const946 sp<AMessage> NuPlayer::GenericSource::getTrackInfo(size_t trackIndex) const {
947 Mutex::Autolock _l(mLock);
948 size_t trackCount = mSources.size();
949 if (trackIndex >= trackCount) {
950 return NULL;
951 }
952
953 sp<AMessage> format = new AMessage();
954 sp<MetaData> meta = mSources.itemAt(trackIndex)->getFormat();
955 if (meta == NULL) {
956 ALOGE("no metadata for track %zu", trackIndex);
957 format->setInt32("type", MEDIA_TRACK_TYPE_UNKNOWN);
958 format->setString("mime", "application/octet-stream");
959 format->setString("language", "und");
960
961 return format;
962 }
963
964 const char *mime;
965 CHECK(meta->findCString(kKeyMIMEType, &mime));
966 format->setString("mime", mime);
967
968 int32_t trackType;
969 if (!strncasecmp(mime, "video/", 6)) {
970 trackType = MEDIA_TRACK_TYPE_VIDEO;
971 } else if (!strncasecmp(mime, "audio/", 6)) {
972 trackType = MEDIA_TRACK_TYPE_AUDIO;
973 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_TEXT_3GPP)) {
974 trackType = MEDIA_TRACK_TYPE_TIMEDTEXT;
975 } else {
976 trackType = MEDIA_TRACK_TYPE_UNKNOWN;
977 }
978 format->setInt32("type", trackType);
979
980 const char *lang;
981 if (!meta->findCString(kKeyMediaLanguage, &lang)) {
982 lang = "und";
983 }
984 format->setString("language", lang);
985
986 if (trackType == MEDIA_TRACK_TYPE_SUBTITLE) {
987 int32_t isAutoselect = 1, isDefault = 0, isForced = 0;
988 meta->findInt32(kKeyTrackIsAutoselect, &isAutoselect);
989 meta->findInt32(kKeyTrackIsDefault, &isDefault);
990 meta->findInt32(kKeyTrackIsForced, &isForced);
991
992 format->setInt32("auto", !!isAutoselect);
993 format->setInt32("default", !!isDefault);
994 format->setInt32("forced", !!isForced);
995 }
996
997 return format;
998 }
999
getSelectedTrack(media_track_type type) const1000 ssize_t NuPlayer::GenericSource::getSelectedTrack(media_track_type type) const {
1001 Mutex::Autolock _l(mLock);
1002 const Track *track = NULL;
1003 switch (type) {
1004 case MEDIA_TRACK_TYPE_VIDEO:
1005 track = &mVideoTrack;
1006 break;
1007 case MEDIA_TRACK_TYPE_AUDIO:
1008 track = &mAudioTrack;
1009 break;
1010 case MEDIA_TRACK_TYPE_TIMEDTEXT:
1011 track = &mTimedTextTrack;
1012 break;
1013 case MEDIA_TRACK_TYPE_SUBTITLE:
1014 track = &mSubtitleTrack;
1015 break;
1016 default:
1017 break;
1018 }
1019
1020 if (track != NULL && track->mSource != NULL) {
1021 return track->mIndex;
1022 }
1023
1024 return -1;
1025 }
1026
selectTrack(size_t trackIndex,bool select,int64_t timeUs)1027 status_t NuPlayer::GenericSource::selectTrack(size_t trackIndex, bool select, int64_t timeUs) {
1028 Mutex::Autolock _l(mLock);
1029 ALOGV("%s track: %zu", select ? "select" : "deselect", trackIndex);
1030
1031 if (trackIndex >= mSources.size()) {
1032 return BAD_INDEX;
1033 }
1034
1035 if (!select) {
1036 Track* track = NULL;
1037 if (mSubtitleTrack.mSource != NULL && trackIndex == mSubtitleTrack.mIndex) {
1038 track = &mSubtitleTrack;
1039 mFetchSubtitleDataGeneration++;
1040 } else if (mTimedTextTrack.mSource != NULL && trackIndex == mTimedTextTrack.mIndex) {
1041 track = &mTimedTextTrack;
1042 mFetchTimedTextDataGeneration++;
1043 }
1044 if (track == NULL) {
1045 return INVALID_OPERATION;
1046 }
1047 track->mSource->stop();
1048 track->mSource = NULL;
1049 track->mPackets->clear();
1050 return OK;
1051 }
1052
1053 const sp<IMediaSource> source = mSources.itemAt(trackIndex);
1054 sp<MetaData> meta = source->getFormat();
1055 const char *mime;
1056 CHECK(meta->findCString(kKeyMIMEType, &mime));
1057 if (!strncasecmp(mime, "text/", 5)) {
1058 bool isSubtitle = strcasecmp(mime, MEDIA_MIMETYPE_TEXT_3GPP);
1059 Track *track = isSubtitle ? &mSubtitleTrack : &mTimedTextTrack;
1060 if (track->mSource != NULL && track->mIndex == trackIndex) {
1061 return OK;
1062 }
1063 track->mIndex = trackIndex;
1064 if (track->mSource != NULL) {
1065 track->mSource->stop();
1066 }
1067 track->mSource = mSources.itemAt(trackIndex);
1068 track->mSource->start();
1069 if (track->mPackets == NULL) {
1070 track->mPackets = new AnotherPacketSource(track->mSource->getFormat());
1071 } else {
1072 track->mPackets->clear();
1073 track->mPackets->setFormat(track->mSource->getFormat());
1074
1075 }
1076
1077 if (isSubtitle) {
1078 mFetchSubtitleDataGeneration++;
1079 } else {
1080 mFetchTimedTextDataGeneration++;
1081 }
1082
1083 status_t eosResult; // ignored
1084 if (mSubtitleTrack.mSource != NULL
1085 && !mSubtitleTrack.mPackets->hasBufferAvailable(&eosResult)) {
1086 sp<AMessage> msg = new AMessage(kWhatFetchSubtitleData, this);
1087 msg->setInt64("timeUs", timeUs);
1088 msg->setInt32("generation", mFetchSubtitleDataGeneration);
1089 msg->post();
1090 }
1091
1092 sp<AMessage> msg2 = new AMessage(kWhatSendGlobalTimedTextData, this);
1093 msg2->setInt32("generation", mFetchTimedTextDataGeneration);
1094 msg2->post();
1095
1096 if (mTimedTextTrack.mSource != NULL
1097 && !mTimedTextTrack.mPackets->hasBufferAvailable(&eosResult)) {
1098 sp<AMessage> msg = new AMessage(kWhatFetchTimedTextData, this);
1099 msg->setInt64("timeUs", timeUs);
1100 msg->setInt32("generation", mFetchTimedTextDataGeneration);
1101 msg->post();
1102 }
1103
1104 return OK;
1105 } else if (!strncasecmp(mime, "audio/", 6) || !strncasecmp(mime, "video/", 6)) {
1106 bool audio = !strncasecmp(mime, "audio/", 6);
1107 Track *track = audio ? &mAudioTrack : &mVideoTrack;
1108 if (track->mSource != NULL && track->mIndex == trackIndex) {
1109 return OK;
1110 }
1111
1112 sp<AMessage> msg = new AMessage(kWhatChangeAVSource, this);
1113 msg->setInt32("trackIndex", trackIndex);
1114 msg->post();
1115 return OK;
1116 }
1117
1118 return INVALID_OPERATION;
1119 }
1120
seekTo(int64_t seekTimeUs,MediaPlayerSeekMode mode)1121 status_t NuPlayer::GenericSource::seekTo(int64_t seekTimeUs, MediaPlayerSeekMode mode) {
1122 ALOGV("seekTo: %lld, %d", (long long)seekTimeUs, mode);
1123 sp<AMessage> msg = new AMessage(kWhatSeek, this);
1124 msg->setInt64("seekTimeUs", seekTimeUs);
1125 msg->setInt32("mode", mode);
1126
1127 // Need to call readBuffer on |mLooper| to ensure the calls to
1128 // IMediaSource::read* are serialized. Note that IMediaSource::read*
1129 // is called without |mLock| acquired and MediaSource is not thread safe.
1130 sp<AMessage> response;
1131 status_t err = msg->postAndAwaitResponse(&response);
1132 if (err == OK && response != NULL) {
1133 CHECK(response->findInt32("err", &err));
1134 }
1135
1136 return err;
1137 }
1138
onSeek(const sp<AMessage> & msg)1139 void NuPlayer::GenericSource::onSeek(const sp<AMessage>& msg) {
1140 int64_t seekTimeUs;
1141 int32_t mode;
1142 CHECK(msg->findInt64("seekTimeUs", &seekTimeUs));
1143 CHECK(msg->findInt32("mode", &mode));
1144
1145 sp<AMessage> response = new AMessage;
1146 status_t err = doSeek(seekTimeUs, (MediaPlayerSeekMode)mode);
1147 response->setInt32("err", err);
1148
1149 sp<AReplyToken> replyID;
1150 CHECK(msg->senderAwaitsResponse(&replyID));
1151 response->postReply(replyID);
1152 }
1153
doSeek(int64_t seekTimeUs,MediaPlayerSeekMode mode)1154 status_t NuPlayer::GenericSource::doSeek(int64_t seekTimeUs, MediaPlayerSeekMode mode) {
1155 if (mVideoTrack.mSource != NULL) {
1156 ++mVideoDataGeneration;
1157
1158 int64_t actualTimeUs;
1159 readBuffer(MEDIA_TRACK_TYPE_VIDEO, seekTimeUs, mode, &actualTimeUs);
1160
1161 if (mode != MediaPlayerSeekMode::SEEK_CLOSEST) {
1162 seekTimeUs = std::max<int64_t>(0, actualTimeUs);
1163 }
1164 mVideoLastDequeueTimeUs = actualTimeUs;
1165 }
1166
1167 if (mAudioTrack.mSource != NULL) {
1168 ++mAudioDataGeneration;
1169 readBuffer(MEDIA_TRACK_TYPE_AUDIO, seekTimeUs, MediaPlayerSeekMode::SEEK_CLOSEST);
1170 mAudioLastDequeueTimeUs = seekTimeUs;
1171 }
1172
1173 if (mSubtitleTrack.mSource != NULL) {
1174 mSubtitleTrack.mPackets->clear();
1175 mFetchSubtitleDataGeneration++;
1176 }
1177
1178 if (mTimedTextTrack.mSource != NULL) {
1179 mTimedTextTrack.mPackets->clear();
1180 mFetchTimedTextDataGeneration++;
1181 }
1182
1183 ++mPollBufferingGeneration;
1184 schedulePollBuffering();
1185 return OK;
1186 }
1187
mediaBufferToABuffer(MediaBufferBase * mb,media_track_type trackType)1188 sp<ABuffer> NuPlayer::GenericSource::mediaBufferToABuffer(
1189 MediaBufferBase* mb,
1190 media_track_type trackType) {
1191 bool audio = trackType == MEDIA_TRACK_TYPE_AUDIO;
1192 size_t outLength = mb->range_length();
1193
1194 if (audio && mAudioIsVorbis) {
1195 outLength += sizeof(int32_t);
1196 }
1197
1198 sp<ABuffer> ab;
1199
1200 if (mIsDrmProtected) {
1201 // Modular DRM
1202 // Enabled for both video/audio so 1) media buffer is reused without extra copying
1203 // 2) meta data can be retrieved in onInputBufferFetched for calling queueSecureInputBuffer.
1204
1205 // data is already provided in the buffer
1206 ab = new ABuffer(NULL, mb->range_length());
1207 ab->meta()->setObject("mediaBufferHolder", new MediaBufferHolder(mb));
1208
1209 // Modular DRM: Required b/c of the above add_ref.
1210 // If ref>0, there must be an observer, or it'll crash at release().
1211 // TODO: MediaBuffer might need to be revised to ease such need.
1212 mb->setObserver(this);
1213 // Extra increment (since we want to keep mb alive and attached to ab beyond this function
1214 // call. This is to counter the effect of mb->release() towards the end.
1215 mb->add_ref();
1216
1217 } else {
1218 ab = new ABuffer(outLength);
1219 memcpy(ab->data(),
1220 (const uint8_t *)mb->data() + mb->range_offset(),
1221 mb->range_length());
1222 }
1223
1224 if (audio && mAudioIsVorbis) {
1225 int32_t numPageSamples;
1226 if (!mb->meta_data().findInt32(kKeyValidSamples, &numPageSamples)) {
1227 numPageSamples = -1;
1228 }
1229
1230 uint8_t* abEnd = ab->data() + mb->range_length();
1231 memcpy(abEnd, &numPageSamples, sizeof(numPageSamples));
1232 }
1233
1234 sp<AMessage> meta = ab->meta();
1235
1236 int64_t timeUs;
1237 CHECK(mb->meta_data().findInt64(kKeyTime, &timeUs));
1238 meta->setInt64("timeUs", timeUs);
1239
1240 if (trackType == MEDIA_TRACK_TYPE_VIDEO) {
1241 int32_t layerId;
1242 if (mb->meta_data().findInt32(kKeyTemporalLayerId, &layerId)) {
1243 meta->setInt32("temporal-layer-id", layerId);
1244 }
1245 }
1246
1247 if (trackType == MEDIA_TRACK_TYPE_TIMEDTEXT) {
1248 const char *mime;
1249 CHECK(mTimedTextTrack.mSource != NULL
1250 && mTimedTextTrack.mSource->getFormat()->findCString(kKeyMIMEType, &mime));
1251 meta->setString("mime", mime);
1252 }
1253
1254 int64_t durationUs;
1255 if (mb->meta_data().findInt64(kKeyDuration, &durationUs)) {
1256 meta->setInt64("durationUs", durationUs);
1257 }
1258
1259 if (trackType == MEDIA_TRACK_TYPE_SUBTITLE) {
1260 meta->setInt32("track-index", mSubtitleTrack.mIndex);
1261 }
1262
1263 uint32_t dataType; // unused
1264 const void *seiData;
1265 size_t seiLength;
1266 if (mb->meta_data().findData(kKeySEI, &dataType, &seiData, &seiLength)) {
1267 sp<ABuffer> sei = ABuffer::CreateAsCopy(seiData, seiLength);;
1268 meta->setBuffer("sei", sei);
1269 }
1270
1271 const void *mpegUserDataPointer;
1272 size_t mpegUserDataLength;
1273 if (mb->meta_data().findData(
1274 kKeyMpegUserData, &dataType, &mpegUserDataPointer, &mpegUserDataLength)) {
1275 sp<ABuffer> mpegUserData = ABuffer::CreateAsCopy(mpegUserDataPointer, mpegUserDataLength);
1276 meta->setBuffer("mpeg-user-data", mpegUserData);
1277 }
1278
1279 mb->release();
1280 mb = NULL;
1281
1282 return ab;
1283 }
1284
getDataGeneration(media_track_type type) const1285 int32_t NuPlayer::GenericSource::getDataGeneration(media_track_type type) const {
1286 int32_t generation = -1;
1287 switch (type) {
1288 case MEDIA_TRACK_TYPE_VIDEO:
1289 generation = mVideoDataGeneration;
1290 break;
1291 case MEDIA_TRACK_TYPE_AUDIO:
1292 generation = mAudioDataGeneration;
1293 break;
1294 case MEDIA_TRACK_TYPE_TIMEDTEXT:
1295 generation = mFetchTimedTextDataGeneration;
1296 break;
1297 case MEDIA_TRACK_TYPE_SUBTITLE:
1298 generation = mFetchSubtitleDataGeneration;
1299 break;
1300 default:
1301 break;
1302 }
1303
1304 return generation;
1305 }
1306
postReadBuffer(media_track_type trackType)1307 void NuPlayer::GenericSource::postReadBuffer(media_track_type trackType) {
1308 if ((mPendingReadBufferTypes & (1 << trackType)) == 0) {
1309 mPendingReadBufferTypes |= (1 << trackType);
1310 sp<AMessage> msg = new AMessage(kWhatReadBuffer, this);
1311 msg->setInt32("trackType", trackType);
1312 msg->post();
1313 }
1314 }
1315
onReadBuffer(const sp<AMessage> & msg)1316 void NuPlayer::GenericSource::onReadBuffer(const sp<AMessage>& msg) {
1317 int32_t tmpType;
1318 CHECK(msg->findInt32("trackType", &tmpType));
1319 media_track_type trackType = (media_track_type)tmpType;
1320 mPendingReadBufferTypes &= ~(1 << trackType);
1321 readBuffer(trackType);
1322 }
1323
readBuffer(media_track_type trackType,int64_t seekTimeUs,MediaPlayerSeekMode mode,int64_t * actualTimeUs,bool formatChange)1324 void NuPlayer::GenericSource::readBuffer(
1325 media_track_type trackType, int64_t seekTimeUs, MediaPlayerSeekMode mode,
1326 int64_t *actualTimeUs, bool formatChange) {
1327 Track *track;
1328 size_t maxBuffers = 1;
1329 switch (trackType) {
1330 case MEDIA_TRACK_TYPE_VIDEO:
1331 track = &mVideoTrack;
1332 maxBuffers = 8; // too large of a number may influence seeks
1333 break;
1334 case MEDIA_TRACK_TYPE_AUDIO:
1335 track = &mAudioTrack;
1336 maxBuffers = 64;
1337 break;
1338 case MEDIA_TRACK_TYPE_SUBTITLE:
1339 track = &mSubtitleTrack;
1340 break;
1341 case MEDIA_TRACK_TYPE_TIMEDTEXT:
1342 track = &mTimedTextTrack;
1343 break;
1344 default:
1345 TRESPASS();
1346 }
1347
1348 if (track->mSource == NULL) {
1349 return;
1350 }
1351
1352 if (actualTimeUs) {
1353 *actualTimeUs = seekTimeUs;
1354 }
1355
1356 MediaSource::ReadOptions options;
1357
1358 bool seeking = false;
1359 if (seekTimeUs >= 0) {
1360 options.setSeekTo(seekTimeUs, mode);
1361 seeking = true;
1362 }
1363
1364 const bool couldReadMultiple = (track->mSource->supportReadMultiple());
1365
1366 if (couldReadMultiple) {
1367 options.setNonBlocking();
1368 }
1369
1370 int32_t generation = getDataGeneration(trackType);
1371 for (size_t numBuffers = 0; numBuffers < maxBuffers; ) {
1372 Vector<MediaBufferBase *> mediaBuffers;
1373 status_t err = NO_ERROR;
1374
1375 sp<IMediaSource> source = track->mSource;
1376 mLock.unlock();
1377 if (couldReadMultiple) {
1378 err = source->readMultiple(
1379 &mediaBuffers, maxBuffers - numBuffers, &options);
1380 } else {
1381 MediaBufferBase *mbuf = NULL;
1382 err = source->read(&mbuf, &options);
1383 if (err == OK && mbuf != NULL) {
1384 mediaBuffers.push_back(mbuf);
1385 }
1386 }
1387 mLock.lock();
1388
1389 options.clearNonPersistent();
1390
1391 size_t id = 0;
1392 size_t count = mediaBuffers.size();
1393
1394 // in case track has been changed since we don't have lock for some time.
1395 if (generation != getDataGeneration(trackType)) {
1396 for (; id < count; ++id) {
1397 mediaBuffers[id]->release();
1398 }
1399 break;
1400 }
1401
1402 for (; id < count; ++id) {
1403 int64_t timeUs;
1404 MediaBufferBase *mbuf = mediaBuffers[id];
1405 if (!mbuf->meta_data().findInt64(kKeyTime, &timeUs)) {
1406 mbuf->meta_data().dumpToLog();
1407 track->mPackets->signalEOS(ERROR_MALFORMED);
1408 break;
1409 }
1410 if (trackType == MEDIA_TRACK_TYPE_AUDIO) {
1411 mAudioTimeUs = timeUs;
1412 } else if (trackType == MEDIA_TRACK_TYPE_VIDEO) {
1413 mVideoTimeUs = timeUs;
1414 }
1415
1416 queueDiscontinuityIfNeeded(seeking, formatChange, trackType, track);
1417
1418 sp<ABuffer> buffer = mediaBufferToABuffer(mbuf, trackType);
1419 if (numBuffers == 0 && actualTimeUs != nullptr) {
1420 *actualTimeUs = timeUs;
1421 }
1422 if (seeking && buffer != nullptr) {
1423 sp<AMessage> meta = buffer->meta();
1424 if (meta != nullptr && mode == MediaPlayerSeekMode::SEEK_CLOSEST
1425 && seekTimeUs > timeUs) {
1426 sp<AMessage> extra = new AMessage;
1427 extra->setInt64("resume-at-mediaTimeUs", seekTimeUs);
1428 meta->setMessage("extra", extra);
1429 }
1430 }
1431
1432 track->mPackets->queueAccessUnit(buffer);
1433 formatChange = false;
1434 seeking = false;
1435 ++numBuffers;
1436 }
1437 if (id < count) {
1438 // Error, some mediaBuffer doesn't have kKeyTime.
1439 for (; id < count; ++id) {
1440 mediaBuffers[id]->release();
1441 }
1442 break;
1443 }
1444
1445 if (err == WOULD_BLOCK) {
1446 break;
1447 } else if (err == INFO_FORMAT_CHANGED) {
1448 #if 0
1449 track->mPackets->queueDiscontinuity(
1450 ATSParser::DISCONTINUITY_FORMATCHANGE,
1451 NULL,
1452 false /* discard */);
1453 #endif
1454 } else if (err != OK) {
1455 queueDiscontinuityIfNeeded(seeking, formatChange, trackType, track);
1456 track->mPackets->signalEOS(err);
1457 break;
1458 }
1459 }
1460
1461 if (mIsStreaming
1462 && (trackType == MEDIA_TRACK_TYPE_VIDEO || trackType == MEDIA_TRACK_TYPE_AUDIO)) {
1463 status_t finalResult;
1464 int64_t durationUs = track->mPackets->getBufferedDurationUs(&finalResult);
1465
1466 // TODO: maxRebufferingMarkMs could be larger than
1467 // mBufferingSettings.mResumePlaybackMarkMs
1468 int64_t markUs = (mPreparing ? mBufferingSettings.mInitialMarkMs
1469 : mBufferingSettings.mResumePlaybackMarkMs) * 1000LL;
1470 if (finalResult == ERROR_END_OF_STREAM || durationUs >= markUs) {
1471 if (mPreparing || mSentPauseOnBuffering) {
1472 Track *counterTrack =
1473 (trackType == MEDIA_TRACK_TYPE_VIDEO ? &mAudioTrack : &mVideoTrack);
1474 if (counterTrack->mSource != NULL) {
1475 durationUs = counterTrack->mPackets->getBufferedDurationUs(&finalResult);
1476 }
1477 if (finalResult == ERROR_END_OF_STREAM || durationUs >= markUs) {
1478 if (mPreparing) {
1479 notifyPrepared();
1480 mPreparing = false;
1481 } else {
1482 sendCacheStats();
1483 mSentPauseOnBuffering = false;
1484 sp<AMessage> notify = dupNotify();
1485 notify->setInt32("what", kWhatResumeOnBufferingEnd);
1486 notify->post();
1487 }
1488 }
1489 }
1490 return;
1491 }
1492
1493 postReadBuffer(trackType);
1494 }
1495 }
1496
queueDiscontinuityIfNeeded(bool seeking,bool formatChange,media_track_type trackType,Track * track)1497 void NuPlayer::GenericSource::queueDiscontinuityIfNeeded(
1498 bool seeking, bool formatChange, media_track_type trackType, Track *track) {
1499 // formatChange && seeking: track whose source is changed during selection
1500 // formatChange && !seeking: track whose source is not changed during selection
1501 // !formatChange: normal seek
1502 if ((seeking || formatChange)
1503 && (trackType == MEDIA_TRACK_TYPE_AUDIO
1504 || trackType == MEDIA_TRACK_TYPE_VIDEO)) {
1505 ATSParser::DiscontinuityType type = (formatChange && seeking)
1506 ? ATSParser::DISCONTINUITY_FORMATCHANGE
1507 : ATSParser::DISCONTINUITY_NONE;
1508 track->mPackets->queueDiscontinuity(type, NULL /* extra */, true /* discard */);
1509 }
1510 }
1511
notifyBufferingUpdate(int32_t percentage)1512 void NuPlayer::GenericSource::notifyBufferingUpdate(int32_t percentage) {
1513 // Buffering percent could go backward as it's estimated from remaining
1514 // data and last access time. This could cause the buffering position
1515 // drawn on media control to jitter slightly. Remember previously reported
1516 // percentage and don't allow it to go backward.
1517 if (percentage < mPrevBufferPercentage) {
1518 percentage = mPrevBufferPercentage;
1519 } else if (percentage > 100) {
1520 percentage = 100;
1521 }
1522
1523 mPrevBufferPercentage = percentage;
1524
1525 ALOGV("notifyBufferingUpdate: buffering %d%%", percentage);
1526
1527 sp<AMessage> notify = dupNotify();
1528 notify->setInt32("what", kWhatBufferingUpdate);
1529 notify->setInt32("percentage", percentage);
1530 notify->post();
1531 }
1532
schedulePollBuffering()1533 void NuPlayer::GenericSource::schedulePollBuffering() {
1534 sp<AMessage> msg = new AMessage(kWhatPollBuffering, this);
1535 msg->setInt32("generation", mPollBufferingGeneration);
1536 // Enquires buffering status every second.
1537 msg->post(1000000LL);
1538 }
1539
onPollBuffering()1540 void NuPlayer::GenericSource::onPollBuffering() {
1541 status_t finalStatus = UNKNOWN_ERROR;
1542 int64_t cachedDurationUs = -1LL;
1543 ssize_t cachedDataRemaining = -1;
1544
1545 if (mCachedSource != NULL) {
1546 cachedDataRemaining = mCachedSource->approxDataRemaining(&finalStatus);
1547
1548 if (finalStatus == OK) {
1549 off64_t size;
1550 int64_t bitrate = 0LL;
1551 if (mDurationUs > 0 && mCachedSource->getSize(&size) == OK) {
1552 // |bitrate| uses bits/second unit, while size is number of bytes.
1553 bitrate = size * 8000000LL / mDurationUs;
1554 } else if (mBitrate > 0) {
1555 bitrate = mBitrate;
1556 }
1557 if (bitrate > 0) {
1558 cachedDurationUs = cachedDataRemaining * 8000000LL / bitrate;
1559 }
1560 }
1561 }
1562
1563 if (finalStatus != OK) {
1564 ALOGV("onPollBuffering: EOS (finalStatus = %d)", finalStatus);
1565
1566 if (finalStatus == ERROR_END_OF_STREAM) {
1567 notifyBufferingUpdate(100);
1568 }
1569
1570 if (mPreparing) {
1571 notifyPreparedAndCleanup(finalStatus == ERROR_END_OF_STREAM ? OK : finalStatus);
1572 mPreparing = false;
1573 } else if (mSentPauseOnBuffering) {
1574 sendCacheStats();
1575 mSentPauseOnBuffering = false;
1576 sp<AMessage> notify = dupNotify();
1577 notify->setInt32("what", kWhatResumeOnBufferingEnd);
1578 notify->post();
1579 }
1580 return;
1581 }
1582
1583 if (cachedDurationUs >= 0LL) {
1584 if (mDurationUs > 0LL) {
1585 int64_t cachedPosUs = getLastReadPosition() + cachedDurationUs;
1586 int percentage = 100.0 * cachedPosUs / mDurationUs;
1587 if (percentage > 100) {
1588 percentage = 100;
1589 }
1590
1591 notifyBufferingUpdate(percentage);
1592 }
1593
1594 ALOGV("onPollBuffering: cachedDurationUs %.1f sec", cachedDurationUs / 1000000.0f);
1595 }
1596
1597 schedulePollBuffering();
1598 }
1599
1600 // Modular DRM
prepareDrm(const uint8_t uuid[16],const Vector<uint8_t> & drmSessionId,sp<ICrypto> * outCrypto)1601 status_t NuPlayer::GenericSource::prepareDrm(
1602 const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId, sp<ICrypto> *outCrypto) {
1603 Mutex::Autolock _l(mLock);
1604 ALOGV("prepareDrm");
1605
1606 mIsDrmProtected = false;
1607 mIsDrmReleased = false;
1608 mIsSecure = false;
1609
1610 status_t status = OK;
1611 sp<ICrypto> crypto = NuPlayerDrm::createCryptoAndPlugin(uuid, drmSessionId, status);
1612 if (crypto == NULL) {
1613 ALOGE("prepareDrm: createCrypto failed. status: %d", status);
1614 return status;
1615 }
1616 ALOGV("prepareDrm: createCryptoAndPlugin succeeded for uuid: %s",
1617 DrmUUID::toHexString(uuid).string());
1618
1619 *outCrypto = crypto;
1620 // as long a there is an active crypto
1621 mIsDrmProtected = true;
1622
1623 if (mMimes.size() == 0) {
1624 status = UNKNOWN_ERROR;
1625 ALOGE("prepareDrm: Unexpected. Must have at least one track. status: %d", status);
1626 return status;
1627 }
1628
1629 // first mime in this list is either the video track, or the first audio track
1630 const char *mime = mMimes[0].string();
1631 mIsSecure = crypto->requiresSecureDecoderComponent(mime);
1632 ALOGV("prepareDrm: requiresSecureDecoderComponent mime: %s isSecure: %d",
1633 mime, mIsSecure);
1634
1635 // Checking the member flags while in the looper to send out the notification.
1636 // The legacy mDecryptHandle!=NULL check (for FLAG_PROTECTED) is equivalent to mIsDrmProtected.
1637 notifyFlagsChanged(
1638 (mIsSecure ? FLAG_SECURE : 0) |
1639 // Setting "protected screen" only for L1: b/38390836
1640 (mIsSecure ? FLAG_PROTECTED : 0) |
1641 FLAG_CAN_PAUSE |
1642 FLAG_CAN_SEEK_BACKWARD |
1643 FLAG_CAN_SEEK_FORWARD |
1644 FLAG_CAN_SEEK);
1645
1646 if (status == OK) {
1647 ALOGV("prepareDrm: mCrypto: %p (%d)", outCrypto->get(),
1648 (*outCrypto != NULL ? (*outCrypto)->getStrongCount() : 0));
1649 ALOGD("prepareDrm ret: %d ", status);
1650 } else {
1651 ALOGE("prepareDrm err: %d", status);
1652 }
1653 return status;
1654 }
1655
releaseDrm()1656 status_t NuPlayer::GenericSource::releaseDrm() {
1657 Mutex::Autolock _l(mLock);
1658 ALOGV("releaseDrm");
1659
1660 if (mIsDrmProtected) {
1661 mIsDrmProtected = false;
1662 // to prevent returning any more buffer after stop/releaseDrm (b/37960096)
1663 mIsDrmReleased = true;
1664 ALOGV("releaseDrm: mIsDrmProtected is reset.");
1665 } else {
1666 ALOGE("releaseDrm: mIsDrmProtected is already false.");
1667 }
1668
1669 return OK;
1670 }
1671
checkDrmInfo()1672 status_t NuPlayer::GenericSource::checkDrmInfo()
1673 {
1674 // clearing the flag at prepare in case the player is reused after stop/releaseDrm with the
1675 // same source without being reset (called by prepareAsync/initFromDataSource)
1676 mIsDrmReleased = false;
1677
1678 if (mFileMeta == NULL) {
1679 ALOGI("checkDrmInfo: No metadata");
1680 return OK; // letting the caller responds accordingly
1681 }
1682
1683 uint32_t type;
1684 const void *pssh;
1685 size_t psshsize;
1686
1687 if (!mFileMeta->findData(kKeyPssh, &type, &pssh, &psshsize)) {
1688 ALOGV("checkDrmInfo: No PSSH");
1689 return OK; // source without DRM info
1690 }
1691
1692 Parcel parcel;
1693 NuPlayerDrm::retrieveDrmInfo(pssh, psshsize, &parcel);
1694 ALOGV("checkDrmInfo: MEDIA_DRM_INFO PSSH size: %d Parcel size: %d objects#: %d",
1695 (int)psshsize, (int)parcel.dataSize(), (int)parcel.objectsCount());
1696
1697 if (parcel.dataSize() == 0) {
1698 ALOGE("checkDrmInfo: Unexpected parcel size: 0");
1699 return UNKNOWN_ERROR;
1700 }
1701
1702 // Can't pass parcel as a message to the player. Converting Parcel->ABuffer to pass it
1703 // to the Player's onSourceNotify then back to Parcel for calling driver's notifyListener.
1704 sp<ABuffer> drmInfoBuffer = ABuffer::CreateAsCopy(parcel.data(), parcel.dataSize());
1705 notifyDrmInfo(drmInfoBuffer);
1706
1707 return OK;
1708 }
1709
signalBufferReturned(MediaBufferBase * buffer)1710 void NuPlayer::GenericSource::signalBufferReturned(MediaBufferBase *buffer)
1711 {
1712 //ALOGV("signalBufferReturned %p refCount: %d", buffer, buffer->localRefcount());
1713
1714 buffer->setObserver(NULL);
1715 buffer->release(); // this leads to delete since that there is no observor
1716 }
1717
1718 } // namespace android
1719