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