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