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