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