1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "media/base/android/media_source_player.h" 6 7 #include <limits> 8 9 #include "base/android/jni_android.h" 10 #include "base/android/jni_string.h" 11 #include "base/barrier_closure.h" 12 #include "base/basictypes.h" 13 #include "base/bind.h" 14 #include "base/callback_helpers.h" 15 #include "base/debug/trace_event.h" 16 #include "base/logging.h" 17 #include "base/strings/string_number_conversions.h" 18 #include "media/base/android/audio_decoder_job.h" 19 #include "media/base/android/media_drm_bridge.h" 20 #include "media/base/android/media_player_manager.h" 21 #include "media/base/android/video_decoder_job.h" 22 #include "media/base/audio_timestamp_helper.h" 23 #include "media/base/buffers.h" 24 25 namespace { 26 27 // Use 16bit PCM for audio output. Keep this value in sync with the output 28 // format we passed to AudioTrack in MediaCodecBridge. 29 const int kBytesPerAudioOutputSample = 2; 30 } 31 32 namespace media { 33 34 // static 35 bool MediaSourcePlayer::IsTypeSupported( 36 const std::vector<uint8>& scheme_uuid, 37 const std::string& security_level, 38 const std::string& container, 39 const std::vector<std::string>& codecs) { 40 if (!MediaDrmBridge::IsCryptoSchemeSupported(scheme_uuid, container)) { 41 DVLOG(1) << "UUID and container '" << container << "' not supported."; 42 return false; 43 } 44 45 if (!MediaDrmBridge::IsSecurityLevelSupported(scheme_uuid, security_level)) { 46 DVLOG(1) << "UUID and security level '" << security_level 47 << "' not supported."; 48 return false; 49 } 50 51 bool is_secure = MediaDrmBridge::IsSecureDecoderRequired(security_level); 52 for (size_t i = 0; i < codecs.size(); ++i) { 53 if (!MediaCodecBridge::CanDecode(codecs[i], is_secure)) { 54 DVLOG(1) << "Codec '" << codecs[i] << "' " 55 << (is_secure ? "in secure mode " : "") << "not supported."; 56 return false; 57 } 58 } 59 60 return true; 61 } 62 63 MediaSourcePlayer::MediaSourcePlayer( 64 int player_id, 65 MediaPlayerManager* manager, 66 scoped_ptr<DemuxerAndroid> demuxer) 67 : MediaPlayerAndroid(player_id, manager), 68 demuxer_(demuxer.Pass()), 69 pending_event_(NO_EVENT_PENDING), 70 width_(0), 71 height_(0), 72 audio_codec_(kUnknownAudioCodec), 73 video_codec_(kUnknownVideoCodec), 74 num_channels_(0), 75 sampling_rate_(0), 76 reached_audio_eos_(false), 77 reached_video_eos_(false), 78 playing_(false), 79 is_audio_encrypted_(false), 80 is_video_encrypted_(false), 81 volume_(-1.0), 82 clock_(&default_tick_clock_), 83 next_video_data_is_iframe_(true), 84 doing_browser_seek_(false), 85 pending_seek_(false), 86 reconfig_audio_decoder_(false), 87 reconfig_video_decoder_(false), 88 weak_this_(this), 89 drm_bridge_(NULL), 90 is_waiting_for_key_(false) { 91 demuxer_->Initialize(this); 92 clock_.SetMaxTime(base::TimeDelta()); 93 } 94 95 MediaSourcePlayer::~MediaSourcePlayer() { 96 Release(); 97 } 98 99 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) { 100 // For an empty surface, always pass it to the decoder job so that it 101 // can detach from the current one. Otherwise, don't pass an unprotected 102 // surface if the video content requires a protected one. 103 if (!surface.IsEmpty() && 104 IsProtectedSurfaceRequired() && !surface.is_protected()) { 105 return; 106 } 107 108 surface_ = surface.Pass(); 109 110 // If there is a pending surface change event, just wait for it to be 111 // processed. 112 if (IsEventPending(SURFACE_CHANGE_EVENT_PENDING)) 113 return; 114 115 // Eventual processing of surface change will take care of feeding the new 116 // video decoder initially with I-frame. See b/8950387. 117 SetPendingEvent(SURFACE_CHANGE_EVENT_PENDING); 118 119 // If seek is already pending, processing of the pending surface change 120 // event will occur in OnDemuxerSeekDone(). 121 if (IsEventPending(SEEK_EVENT_PENDING)) 122 return; 123 124 // If video config change is already pending, processing of the pending 125 // surface change event will occur in OnDemuxerConfigsAvailable(). 126 if (reconfig_video_decoder_ && IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) 127 return; 128 129 // Otherwise we need to trigger pending event processing now. 130 ProcessPendingEvents(); 131 } 132 133 void MediaSourcePlayer::ScheduleSeekEventAndStopDecoding( 134 const base::TimeDelta& seek_time) { 135 DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ")"; 136 DCHECK(!IsEventPending(SEEK_EVENT_PENDING)); 137 138 pending_seek_ = false; 139 140 clock_.SetTime(seek_time, seek_time); 141 if (audio_timestamp_helper_) 142 audio_timestamp_helper_->SetBaseTimestamp(seek_time); 143 144 if (audio_decoder_job_ && audio_decoder_job_->is_decoding()) 145 audio_decoder_job_->StopDecode(); 146 if (video_decoder_job_ && video_decoder_job_->is_decoding()) 147 video_decoder_job_->StopDecode(); 148 149 SetPendingEvent(SEEK_EVENT_PENDING); 150 ProcessPendingEvents(); 151 } 152 153 void MediaSourcePlayer::BrowserSeekToCurrentTime() { 154 DVLOG(1) << __FUNCTION__; 155 156 DCHECK(!IsEventPending(SEEK_EVENT_PENDING)); 157 doing_browser_seek_ = true; 158 ScheduleSeekEventAndStopDecoding(GetCurrentTime()); 159 } 160 161 bool MediaSourcePlayer::Seekable() { 162 // If the duration TimeDelta, converted to milliseconds from microseconds, 163 // is >= 2^31, then the media is assumed to be unbounded and unseekable. 164 // 2^31 is the bound due to java player using 32-bit integer for time 165 // values at millisecond resolution. 166 return duration_ < 167 base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>::max()); 168 } 169 170 void MediaSourcePlayer::Start() { 171 DVLOG(1) << __FUNCTION__; 172 173 playing_ = true; 174 175 if (IsProtectedSurfaceRequired()) 176 manager()->OnProtectedSurfaceRequested(player_id()); 177 178 StartInternal(); 179 } 180 181 void MediaSourcePlayer::Pause(bool is_media_related_action) { 182 DVLOG(1) << __FUNCTION__; 183 184 // Since decoder jobs have their own thread, decoding is not fully paused 185 // until all the decoder jobs call MediaDecoderCallback(). It is possible 186 // that Start() is called while the player is waiting for 187 // MediaDecoderCallback(). In that case, decoding will continue when 188 // MediaDecoderCallback() is called. 189 playing_ = false; 190 start_time_ticks_ = base::TimeTicks(); 191 } 192 193 bool MediaSourcePlayer::IsPlaying() { 194 return playing_; 195 } 196 197 int MediaSourcePlayer::GetVideoWidth() { 198 return width_; 199 } 200 201 int MediaSourcePlayer::GetVideoHeight() { 202 return height_; 203 } 204 205 void MediaSourcePlayer::SeekTo(const base::TimeDelta& timestamp) { 206 DVLOG(1) << __FUNCTION__ << "(" << timestamp.InSecondsF() << ")"; 207 208 if (IsEventPending(SEEK_EVENT_PENDING)) { 209 DCHECK(doing_browser_seek_) << "SeekTo while SeekTo in progress"; 210 DCHECK(!pending_seek_) << "SeekTo while SeekTo pending browser seek"; 211 212 // There is a browser seek currently in progress to obtain I-frame to feed 213 // a newly constructed video decoder. Remember this real seek request so 214 // it can be initiated once OnDemuxerSeekDone() occurs for the browser seek. 215 pending_seek_ = true; 216 pending_seek_time_ = timestamp; 217 return; 218 } 219 220 doing_browser_seek_ = false; 221 ScheduleSeekEventAndStopDecoding(timestamp); 222 } 223 224 base::TimeDelta MediaSourcePlayer::GetCurrentTime() { 225 return clock_.Elapsed(); 226 } 227 228 base::TimeDelta MediaSourcePlayer::GetDuration() { 229 return duration_; 230 } 231 232 void MediaSourcePlayer::Release() { 233 DVLOG(1) << __FUNCTION__; 234 235 // Allow pending seeks and config changes to survive this Release(). 236 // If previously pending a prefetch done event, or a job was still decoding, 237 // then at end of Release() we need to ProcessPendingEvents() to process any 238 // seek or config change that was blocked by the prefetch or decode. 239 // TODO(qinmin/wolenetz): Maintain channel state to not double-request data 240 // or drop data received across Release()+Start(). See http://crbug.com/306314 241 // and http://crbug.com/304234. 242 bool process_pending_events = false; 243 process_pending_events = IsEventPending(PREFETCH_DONE_EVENT_PENDING) || 244 (audio_decoder_job_ && audio_decoder_job_->is_decoding()) || 245 (video_decoder_job_ && video_decoder_job_->is_decoding()); 246 247 // Clear all the pending events except seeks and config changes. 248 pending_event_ &= (SEEK_EVENT_PENDING | CONFIG_CHANGE_EVENT_PENDING); 249 250 audio_decoder_job_.reset(); 251 ResetVideoDecoderJob(); 252 253 // Prevent job re-creation attempts in OnDemuxerConfigsAvailable() 254 reconfig_audio_decoder_ = false; 255 reconfig_video_decoder_ = false; 256 257 // Prevent player restart, including job re-creation attempts. 258 playing_ = false; 259 260 decoder_starvation_callback_.Cancel(); 261 surface_ = gfx::ScopedJavaSurface(); 262 manager()->ReleaseMediaResources(player_id()); 263 if (process_pending_events) { 264 DVLOG(1) << __FUNCTION__ << " : Resuming seek or config change processing"; 265 ProcessPendingEvents(); 266 } 267 } 268 269 void MediaSourcePlayer::SetVolume(double volume) { 270 volume_ = volume; 271 SetVolumeInternal(); 272 } 273 274 void MediaSourcePlayer::OnKeyAdded() { 275 DVLOG(1) << __FUNCTION__; 276 if (!is_waiting_for_key_) 277 return; 278 279 is_waiting_for_key_ = false; 280 if (playing_) 281 StartInternal(); 282 } 283 284 bool MediaSourcePlayer::CanPause() { 285 return Seekable(); 286 } 287 288 bool MediaSourcePlayer::CanSeekForward() { 289 return Seekable(); 290 } 291 292 bool MediaSourcePlayer::CanSeekBackward() { 293 return Seekable(); 294 } 295 296 bool MediaSourcePlayer::IsPlayerReady() { 297 return audio_decoder_job_ || video_decoder_job_; 298 } 299 300 void MediaSourcePlayer::StartInternal() { 301 DVLOG(1) << __FUNCTION__; 302 // If there are pending events, wait for them finish. 303 if (pending_event_ != NO_EVENT_PENDING) 304 return; 305 306 // When we start, we'll have new demuxed data coming in. This new data could 307 // be clear (not encrypted) or encrypted with different keys. So 308 // |is_waiting_for_key_| condition may not be true anymore. 309 is_waiting_for_key_ = false; 310 311 // Create decoder jobs if they are not created 312 ConfigureAudioDecoderJob(); 313 ConfigureVideoDecoderJob(); 314 315 // If one of the decoder job is not ready, do nothing. 316 if ((HasAudio() && !audio_decoder_job_) || 317 (HasVideo() && !video_decoder_job_)) { 318 return; 319 } 320 321 SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING); 322 ProcessPendingEvents(); 323 } 324 325 void MediaSourcePlayer::OnDemuxerConfigsAvailable( 326 const DemuxerConfigs& configs) { 327 DVLOG(1) << __FUNCTION__; 328 duration_ = base::TimeDelta::FromMilliseconds(configs.duration_ms); 329 clock_.SetDuration(duration_); 330 331 audio_codec_ = configs.audio_codec; 332 num_channels_ = configs.audio_channels; 333 sampling_rate_ = configs.audio_sampling_rate; 334 is_audio_encrypted_ = configs.is_audio_encrypted; 335 audio_extra_data_ = configs.audio_extra_data; 336 if (HasAudio()) { 337 DCHECK_GT(num_channels_, 0); 338 audio_timestamp_helper_.reset(new AudioTimestampHelper(sampling_rate_)); 339 audio_timestamp_helper_->SetBaseTimestamp(GetCurrentTime()); 340 } else { 341 audio_timestamp_helper_.reset(); 342 } 343 344 video_codec_ = configs.video_codec; 345 width_ = configs.video_size.width(); 346 height_ = configs.video_size.height(); 347 is_video_encrypted_ = configs.is_video_encrypted; 348 349 manager()->OnMediaMetadataChanged( 350 player_id(), duration_, width_, height_, true); 351 352 if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) { 353 if (reconfig_audio_decoder_) 354 ConfigureAudioDecoderJob(); 355 356 if (reconfig_video_decoder_) 357 ConfigureVideoDecoderJob(); 358 359 ClearPendingEvent(CONFIG_CHANGE_EVENT_PENDING); 360 361 // Resume decoding after the config change if we are still playing. 362 if (playing_) 363 StartInternal(); 364 } 365 } 366 367 void MediaSourcePlayer::OnDemuxerDataAvailable(const DemuxerData& data) { 368 DVLOG(1) << __FUNCTION__ << "(" << data.type << ")"; 369 DCHECK_LT(0u, data.access_units.size()); 370 if (data.type == DemuxerStream::AUDIO && audio_decoder_job_) { 371 audio_decoder_job_->OnDataReceived(data); 372 } else if (data.type == DemuxerStream::VIDEO) { 373 next_video_data_is_iframe_ = false; 374 if (video_decoder_job_) 375 video_decoder_job_->OnDataReceived(data); 376 } 377 } 378 379 void MediaSourcePlayer::OnDemuxerDurationChanged(base::TimeDelta duration) { 380 duration_ = duration; 381 clock_.SetDuration(duration_); 382 } 383 384 base::android::ScopedJavaLocalRef<jobject> MediaSourcePlayer::GetMediaCrypto() { 385 base::android::ScopedJavaLocalRef<jobject> media_crypto; 386 if (drm_bridge_) 387 media_crypto = drm_bridge_->GetMediaCrypto(); 388 return media_crypto; 389 } 390 391 void MediaSourcePlayer::OnMediaCryptoReady() { 392 DCHECK(!drm_bridge_->GetMediaCrypto().is_null()); 393 drm_bridge_->SetMediaCryptoReadyCB(base::Closure()); 394 395 if (playing_) 396 StartInternal(); 397 } 398 399 void MediaSourcePlayer::SetDrmBridge(MediaDrmBridge* drm_bridge) { 400 // Currently we don't support DRM change during the middle of playback, even 401 // if the player is paused. 402 // TODO(qinmin): support DRM change after playback has started. 403 // http://crbug.com/253792. 404 if (GetCurrentTime() > base::TimeDelta()) { 405 VLOG(0) << "Setting DRM bridge after playback has started. " 406 << "This is not well supported!"; 407 } 408 409 drm_bridge_ = drm_bridge; 410 411 if (drm_bridge_->GetMediaCrypto().is_null()) { 412 drm_bridge_->SetMediaCryptoReadyCB(base::Bind( 413 &MediaSourcePlayer::OnMediaCryptoReady, weak_this_.GetWeakPtr())); 414 return; 415 } 416 417 if (playing_) 418 StartInternal(); 419 } 420 421 void MediaSourcePlayer::OnDemuxerSeekDone( 422 const base::TimeDelta& actual_browser_seek_time) { 423 DVLOG(1) << __FUNCTION__; 424 425 ClearPendingEvent(SEEK_EVENT_PENDING); 426 if (IsEventPending(PREFETCH_REQUEST_EVENT_PENDING)) 427 ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING); 428 429 next_video_data_is_iframe_ = true; 430 431 if (pending_seek_) { 432 DVLOG(1) << __FUNCTION__ << "processing pending seek"; 433 DCHECK(doing_browser_seek_); 434 pending_seek_ = false; 435 SeekTo(pending_seek_time_); 436 return; 437 } 438 439 // It is possible that a browser seek to I-frame had to seek to a buffered 440 // I-frame later than the requested one due to data removal or GC. Update 441 // player clock to the actual seek target. 442 if (doing_browser_seek_) { 443 DCHECK(actual_browser_seek_time != kNoTimestamp()); 444 // A browser seek must not jump into the past. Ideally, it seeks to the 445 // requested time, but it might jump into the future. 446 DCHECK(actual_browser_seek_time >= GetCurrentTime()); 447 DVLOG(1) << __FUNCTION__ << " : setting clock to actual browser seek time: " 448 << actual_browser_seek_time.InSecondsF(); 449 clock_.SetTime(actual_browser_seek_time, actual_browser_seek_time); 450 if (audio_timestamp_helper_) 451 audio_timestamp_helper_->SetBaseTimestamp(actual_browser_seek_time); 452 } 453 454 reached_audio_eos_ = false; 455 reached_video_eos_ = false; 456 457 base::TimeDelta current_time = GetCurrentTime(); 458 // TODO(qinmin): Simplify the logic by using |start_presentation_timestamp_| 459 // to preroll media decoder jobs. Currently |start_presentation_timestamp_| 460 // is calculated from decoder output, while preroll relies on the access 461 // unit's timestamp. There are some differences between the two. 462 preroll_timestamp_ = current_time; 463 if (audio_decoder_job_) 464 audio_decoder_job_->BeginPrerolling(preroll_timestamp_); 465 if (video_decoder_job_) 466 video_decoder_job_->BeginPrerolling(preroll_timestamp_); 467 468 if (!doing_browser_seek_) 469 manager()->OnSeekComplete(player_id(), current_time); 470 471 ProcessPendingEvents(); 472 } 473 474 void MediaSourcePlayer::UpdateTimestamps( 475 const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes) { 476 base::TimeDelta new_max_time = presentation_timestamp; 477 478 if (audio_output_bytes > 0) { 479 audio_timestamp_helper_->AddFrames( 480 audio_output_bytes / (kBytesPerAudioOutputSample * num_channels_)); 481 new_max_time = audio_timestamp_helper_->GetTimestamp(); 482 } 483 484 clock_.SetMaxTime(new_max_time); 485 manager()->OnTimeUpdate(player_id(), GetCurrentTime()); 486 } 487 488 void MediaSourcePlayer::ProcessPendingEvents() { 489 DVLOG(1) << __FUNCTION__ << " : 0x" << std::hex << pending_event_; 490 // Wait for all the decoding jobs to finish before processing pending tasks. 491 if (video_decoder_job_ && video_decoder_job_->is_decoding()) { 492 DVLOG(1) << __FUNCTION__ << " : A video job is still decoding."; 493 return; 494 } 495 496 if (audio_decoder_job_ && audio_decoder_job_->is_decoding()) { 497 DVLOG(1) << __FUNCTION__ << " : An audio job is still decoding."; 498 return; 499 } 500 501 if (IsEventPending(PREFETCH_DONE_EVENT_PENDING)) { 502 DVLOG(1) << __FUNCTION__ << " : PREFETCH_DONE still pending."; 503 return; 504 } 505 506 if (IsEventPending(SEEK_EVENT_PENDING)) { 507 DVLOG(1) << __FUNCTION__ << " : Handling SEEK_EVENT"; 508 ClearDecodingData(); 509 demuxer_->RequestDemuxerSeek(GetCurrentTime(), doing_browser_seek_); 510 return; 511 } 512 513 start_time_ticks_ = base::TimeTicks(); 514 if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) { 515 DVLOG(1) << __FUNCTION__ << " : Handling CONFIG_CHANGE_EVENT."; 516 DCHECK(reconfig_audio_decoder_ || reconfig_video_decoder_); 517 demuxer_->RequestDemuxerConfigs(); 518 return; 519 } 520 521 if (IsEventPending(SURFACE_CHANGE_EVENT_PENDING)) { 522 DVLOG(1) << __FUNCTION__ << " : Handling SURFACE_CHANGE_EVENT."; 523 // Setting a new surface will require a new MediaCodec to be created. 524 ResetVideoDecoderJob(); 525 ConfigureVideoDecoderJob(); 526 527 // Return early if we can't successfully configure a new video decoder job 528 // yet. 529 if (HasVideo() && !video_decoder_job_) 530 return; 531 } 532 533 if (IsEventPending(PREFETCH_REQUEST_EVENT_PENDING)) { 534 DVLOG(1) << __FUNCTION__ << " : Handling PREFETCH_REQUEST_EVENT."; 535 DCHECK(audio_decoder_job_ || AudioFinished()); 536 DCHECK(video_decoder_job_ || VideoFinished()); 537 538 int count = (AudioFinished() ? 0 : 1) + (VideoFinished() ? 0 : 1); 539 540 // It is possible that all streams have finished decode, yet starvation 541 // occurred during the last stream's EOS decode. In this case, prefetch is a 542 // no-op. 543 ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING); 544 if (count == 0) 545 return; 546 547 SetPendingEvent(PREFETCH_DONE_EVENT_PENDING); 548 base::Closure barrier = BarrierClosure(count, base::Bind( 549 &MediaSourcePlayer::OnPrefetchDone, weak_this_.GetWeakPtr())); 550 551 if (!AudioFinished()) 552 audio_decoder_job_->Prefetch(barrier); 553 554 if (!VideoFinished()) 555 video_decoder_job_->Prefetch(barrier); 556 557 return; 558 } 559 560 DCHECK_EQ(pending_event_, NO_EVENT_PENDING); 561 562 // Now that all pending events have been handled, resume decoding if we are 563 // still playing. 564 if (playing_) 565 StartInternal(); 566 } 567 568 void MediaSourcePlayer::MediaDecoderCallback( 569 bool is_audio, MediaCodecStatus status, 570 const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes) { 571 DVLOG(1) << __FUNCTION__ << ": " << is_audio << ", " << status; 572 573 // TODO(xhwang): Drop IntToString() when http://crbug.com/303899 is fixed. 574 if (is_audio) { 575 TRACE_EVENT_ASYNC_END1("media", 576 "MediaSourcePlayer::DecodeMoreAudio", 577 audio_decoder_job_.get(), 578 "MediaCodecStatus", 579 base::IntToString(status)); 580 } else { 581 TRACE_EVENT_ASYNC_END1("media", 582 "MediaSourcePlayer::DecodeMoreVideo", 583 video_decoder_job_.get(), 584 "MediaCodecStatus", 585 base::IntToString(status)); 586 } 587 588 // Let tests hook the completion of this decode cycle. 589 if (!decode_callback_for_testing_.is_null()) 590 base::ResetAndReturn(&decode_callback_for_testing_).Run(); 591 592 bool is_clock_manager = is_audio || !HasAudio(); 593 594 if (is_clock_manager) 595 decoder_starvation_callback_.Cancel(); 596 597 if (status == MEDIA_CODEC_ERROR) { 598 DVLOG(1) << __FUNCTION__ << " : decode error"; 599 Release(); 600 manager()->OnError(player_id(), MEDIA_ERROR_DECODE); 601 return; 602 } 603 604 DCHECK(!IsEventPending(PREFETCH_DONE_EVENT_PENDING)); 605 606 // Let |SEEK_EVENT_PENDING| (the highest priority event outside of 607 // |PREFETCH_DONE_EVENT_PENDING|) preempt output EOS detection here. Process 608 // any other pending events only after handling EOS detection. 609 if (IsEventPending(SEEK_EVENT_PENDING)) { 610 ProcessPendingEvents(); 611 return; 612 } 613 614 if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) 615 PlaybackCompleted(is_audio); 616 617 if (pending_event_ != NO_EVENT_PENDING) { 618 ProcessPendingEvents(); 619 return; 620 } 621 622 if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) 623 return; 624 625 if (status == MEDIA_CODEC_OK && is_clock_manager && 626 presentation_timestamp != kNoTimestamp()) { 627 UpdateTimestamps(presentation_timestamp, audio_output_bytes); 628 } 629 630 if (!playing_) { 631 if (is_clock_manager) 632 clock_.Pause(); 633 return; 634 } 635 636 if (status == MEDIA_CODEC_NO_KEY) { 637 is_waiting_for_key_ = true; 638 return; 639 } 640 641 // If the status is MEDIA_CODEC_STOPPED, stop decoding new data. The player is 642 // in the middle of a seek or stop event and needs to wait for the IPCs to 643 // come. 644 if (status == MEDIA_CODEC_STOPPED) 645 return; 646 647 if (is_clock_manager) { 648 // If we have a valid timestamp, start the starvation callback. Otherwise, 649 // reset the |start_time_ticks_| so that the next frame will not suffer 650 // from the decoding delay caused by the current frame. 651 if (presentation_timestamp != kNoTimestamp()) 652 StartStarvationCallback(presentation_timestamp); 653 else 654 start_time_ticks_ = base::TimeTicks::Now(); 655 } 656 657 if (is_audio) { 658 DecodeMoreAudio(); 659 return; 660 } 661 662 DecodeMoreVideo(); 663 } 664 665 void MediaSourcePlayer::DecodeMoreAudio() { 666 DVLOG(1) << __FUNCTION__; 667 DCHECK(!audio_decoder_job_->is_decoding()); 668 DCHECK(!AudioFinished()); 669 670 if (audio_decoder_job_->Decode( 671 start_time_ticks_, start_presentation_timestamp_, base::Bind( 672 &MediaSourcePlayer::MediaDecoderCallback, 673 weak_this_.GetWeakPtr(), true))) { 674 TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio", 675 audio_decoder_job_.get()); 676 return; 677 } 678 679 // Failed to start the next decode. 680 // Wait for demuxer ready message. 681 DCHECK(!reconfig_audio_decoder_); 682 reconfig_audio_decoder_ = true; 683 684 // Config change may have just been detected on the other stream. If so, 685 // don't send a duplicate demuxer config request. 686 if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) { 687 DCHECK(reconfig_video_decoder_); 688 return; 689 } 690 691 SetPendingEvent(CONFIG_CHANGE_EVENT_PENDING); 692 ProcessPendingEvents(); 693 } 694 695 void MediaSourcePlayer::DecodeMoreVideo() { 696 DVLOG(1) << __FUNCTION__; 697 DCHECK(!video_decoder_job_->is_decoding()); 698 DCHECK(!VideoFinished()); 699 700 if (video_decoder_job_->Decode( 701 start_time_ticks_, start_presentation_timestamp_, base::Bind( 702 &MediaSourcePlayer::MediaDecoderCallback, 703 weak_this_.GetWeakPtr(), false))) { 704 TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreVideo", 705 video_decoder_job_.get()); 706 return; 707 } 708 709 // Failed to start the next decode. 710 // Wait for demuxer ready message. 711 712 // After this detection of video config change, next video data received 713 // will begin with I-frame. 714 next_video_data_is_iframe_ = true; 715 716 DCHECK(!reconfig_video_decoder_); 717 reconfig_video_decoder_ = true; 718 719 // Config change may have just been detected on the other stream. If so, 720 // don't send a duplicate demuxer config request. 721 if (IsEventPending(CONFIG_CHANGE_EVENT_PENDING)) { 722 DCHECK(reconfig_audio_decoder_); 723 return; 724 } 725 726 SetPendingEvent(CONFIG_CHANGE_EVENT_PENDING); 727 ProcessPendingEvents(); 728 } 729 730 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) { 731 DVLOG(1) << __FUNCTION__ << "(" << is_audio << ")"; 732 if (is_audio) 733 reached_audio_eos_ = true; 734 else 735 reached_video_eos_ = true; 736 737 if (AudioFinished() && VideoFinished()) { 738 playing_ = false; 739 clock_.Pause(); 740 start_time_ticks_ = base::TimeTicks(); 741 manager()->OnPlaybackComplete(player_id()); 742 } 743 } 744 745 void MediaSourcePlayer::ClearDecodingData() { 746 DVLOG(1) << __FUNCTION__; 747 if (audio_decoder_job_) 748 audio_decoder_job_->Flush(); 749 if (video_decoder_job_) 750 video_decoder_job_->Flush(); 751 start_time_ticks_ = base::TimeTicks(); 752 } 753 754 bool MediaSourcePlayer::HasVideo() { 755 return kUnknownVideoCodec != video_codec_; 756 } 757 758 bool MediaSourcePlayer::HasAudio() { 759 return kUnknownAudioCodec != audio_codec_; 760 } 761 762 bool MediaSourcePlayer::AudioFinished() { 763 return reached_audio_eos_ || !HasAudio(); 764 } 765 766 bool MediaSourcePlayer::VideoFinished() { 767 return reached_video_eos_ || !HasVideo(); 768 } 769 770 void MediaSourcePlayer::ConfigureAudioDecoderJob() { 771 if (!HasAudio()) { 772 audio_decoder_job_.reset(); 773 return; 774 } 775 776 // Create audio decoder job only if config changes. 777 if (audio_decoder_job_ && !reconfig_audio_decoder_) 778 return; 779 780 base::android::ScopedJavaLocalRef<jobject> media_crypto = GetMediaCrypto(); 781 if (is_audio_encrypted_ && media_crypto.is_null()) 782 return; 783 784 DCHECK(!audio_decoder_job_ || !audio_decoder_job_->is_decoding()); 785 786 DVLOG(1) << __FUNCTION__ << " : creating new audio decoder job"; 787 788 audio_decoder_job_.reset(AudioDecoderJob::Create( 789 audio_codec_, sampling_rate_, num_channels_, &audio_extra_data_[0], 790 audio_extra_data_.size(), media_crypto.obj(), 791 base::Bind(&DemuxerAndroid::RequestDemuxerData, 792 base::Unretained(demuxer_.get()), DemuxerStream::AUDIO))); 793 794 if (audio_decoder_job_) { 795 SetVolumeInternal(); 796 audio_decoder_job_->BeginPrerolling(preroll_timestamp_); 797 reconfig_audio_decoder_ = false; 798 } 799 } 800 801 void MediaSourcePlayer::ResetVideoDecoderJob() { 802 video_decoder_job_.reset(); 803 804 // Any eventual video decoder job re-creation will use the current |surface_|. 805 if (IsEventPending(SURFACE_CHANGE_EVENT_PENDING)) 806 ClearPendingEvent(SURFACE_CHANGE_EVENT_PENDING); 807 } 808 809 void MediaSourcePlayer::ConfigureVideoDecoderJob() { 810 if (!HasVideo() || surface_.IsEmpty()) { 811 ResetVideoDecoderJob(); 812 return; 813 } 814 815 // Create video decoder job only if config changes or we don't have a job. 816 if (video_decoder_job_ && !reconfig_video_decoder_) { 817 DCHECK(!IsEventPending(SURFACE_CHANGE_EVENT_PENDING)); 818 return; 819 } 820 821 DCHECK(!video_decoder_job_ || !video_decoder_job_->is_decoding()); 822 823 if (reconfig_video_decoder_) { 824 // No hack browser seek should be required. I-Frame must be next. 825 DCHECK(next_video_data_is_iframe_) << "Received video data between " 826 << "detecting video config change and reconfiguring video decoder"; 827 } 828 829 // If uncertain that video I-frame data is next and there is no seek already 830 // in process, request browser demuxer seek so the new decoder will decode 831 // an I-frame first. Otherwise, the new MediaCodec might crash. See b/8950387. 832 // Eventual OnDemuxerSeekDone() will trigger ProcessPendingEvents() and 833 // continue from here. 834 // TODO(wolenetz): Instead of doing hack browser seek, replay cached data 835 // since last keyframe. See http://crbug.com/304234. 836 if (!next_video_data_is_iframe_ && !IsEventPending(SEEK_EVENT_PENDING)) { 837 BrowserSeekToCurrentTime(); 838 return; 839 } 840 841 // Release the old VideoDecoderJob first so the surface can get released. 842 // Android does not allow 2 MediaCodec instances use the same surface. 843 ResetVideoDecoderJob(); 844 845 base::android::ScopedJavaLocalRef<jobject> media_crypto = GetMediaCrypto(); 846 if (is_video_encrypted_ && media_crypto.is_null()) 847 return; 848 849 DVLOG(1) << __FUNCTION__ << " : creating new video decoder job"; 850 851 // Create the new VideoDecoderJob. 852 bool is_secure = IsProtectedSurfaceRequired(); 853 video_decoder_job_.reset( 854 VideoDecoderJob::Create(video_codec_, 855 is_secure, 856 gfx::Size(width_, height_), 857 surface_.j_surface().obj(), 858 media_crypto.obj(), 859 base::Bind(&DemuxerAndroid::RequestDemuxerData, 860 base::Unretained(demuxer_.get()), 861 DemuxerStream::VIDEO))); 862 if (!video_decoder_job_) 863 return; 864 865 video_decoder_job_->BeginPrerolling(preroll_timestamp_); 866 reconfig_video_decoder_ = false; 867 868 // Inform the fullscreen view the player is ready. 869 // TODO(qinmin): refactor MediaPlayerBridge so that we have a better way 870 // to inform ContentVideoView. 871 manager()->OnMediaMetadataChanged( 872 player_id(), duration_, width_, height_, true); 873 } 874 875 void MediaSourcePlayer::OnDecoderStarved() { 876 DVLOG(1) << __FUNCTION__; 877 SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING); 878 ProcessPendingEvents(); 879 } 880 881 void MediaSourcePlayer::StartStarvationCallback( 882 const base::TimeDelta& presentation_timestamp) { 883 // 20ms was chosen because it is the typical size of a compressed audio frame. 884 // Anything smaller than this would likely cause unnecessary cycling in and 885 // out of the prefetch state. 886 const base::TimeDelta kMinStarvationTimeout = 887 base::TimeDelta::FromMilliseconds(20); 888 889 base::TimeDelta current_timestamp = GetCurrentTime(); 890 base::TimeDelta timeout; 891 if (HasAudio()) { 892 timeout = audio_timestamp_helper_->GetTimestamp() - current_timestamp; 893 } else { 894 DCHECK(current_timestamp <= presentation_timestamp); 895 896 // For video only streams, fps can be estimated from the difference 897 // between the previous and current presentation timestamps. The 898 // previous presentation timestamp is equal to current_timestamp. 899 // TODO(qinmin): determine whether 2 is a good coefficient for estimating 900 // video frame timeout. 901 timeout = 2 * (presentation_timestamp - current_timestamp); 902 } 903 904 timeout = std::max(timeout, kMinStarvationTimeout); 905 906 decoder_starvation_callback_.Reset( 907 base::Bind(&MediaSourcePlayer::OnDecoderStarved, 908 weak_this_.GetWeakPtr())); 909 base::MessageLoop::current()->PostDelayedTask( 910 FROM_HERE, decoder_starvation_callback_.callback(), timeout); 911 } 912 913 void MediaSourcePlayer::SetVolumeInternal() { 914 if (audio_decoder_job_ && volume_ >= 0) 915 audio_decoder_job_->SetVolume(volume_); 916 } 917 918 bool MediaSourcePlayer::IsProtectedSurfaceRequired() { 919 return is_video_encrypted_ && 920 drm_bridge_ && drm_bridge_->IsProtectedSurfaceRequired(); 921 } 922 923 void MediaSourcePlayer::OnPrefetchDone() { 924 DVLOG(1) << __FUNCTION__; 925 DCHECK(!audio_decoder_job_ || !audio_decoder_job_->is_decoding()); 926 DCHECK(!video_decoder_job_ || !video_decoder_job_->is_decoding()); 927 928 // A previously posted OnPrefetchDone() could race against a Release(). If 929 // Release() won the race, we should no longer have decoder jobs. 930 // TODO(qinmin/wolenetz): Maintain channel state to not double-request data 931 // or drop data received across Release()+Start(). See http://crbug.com/306314 932 // and http://crbug.com/304234. 933 if (!IsEventPending(PREFETCH_DONE_EVENT_PENDING)) { 934 DVLOG(1) << __FUNCTION__ << " : aborting"; 935 DCHECK(!audio_decoder_job_ && !video_decoder_job_); 936 return; 937 } 938 939 ClearPendingEvent(PREFETCH_DONE_EVENT_PENDING); 940 941 if (pending_event_ != NO_EVENT_PENDING) { 942 ProcessPendingEvents(); 943 return; 944 } 945 946 start_time_ticks_ = base::TimeTicks::Now(); 947 start_presentation_timestamp_ = GetCurrentTime(); 948 if (!clock_.IsPlaying()) 949 clock_.Play(); 950 951 if (!AudioFinished()) 952 DecodeMoreAudio(); 953 954 if (!VideoFinished()) 955 DecodeMoreVideo(); 956 } 957 958 const char* MediaSourcePlayer::GetEventName(PendingEventFlags event) { 959 static const char* kPendingEventNames[] = { 960 "SEEK", 961 "SURFACE_CHANGE", 962 "CONFIG_CHANGE", 963 "PREFETCH_REQUEST", 964 "PREFETCH_DONE", 965 }; 966 967 int mask = 1; 968 for (size_t i = 0; i < arraysize(kPendingEventNames); ++i, mask <<= 1) { 969 if (event & mask) 970 return kPendingEventNames[i]; 971 } 972 973 return "UNKNOWN"; 974 } 975 976 bool MediaSourcePlayer::IsEventPending(PendingEventFlags event) const { 977 return pending_event_ & event; 978 } 979 980 void MediaSourcePlayer::SetPendingEvent(PendingEventFlags event) { 981 DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")"; 982 DCHECK_NE(event, NO_EVENT_PENDING); 983 DCHECK(!IsEventPending(event)); 984 985 pending_event_ |= event; 986 } 987 988 void MediaSourcePlayer::ClearPendingEvent(PendingEventFlags event) { 989 DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")"; 990 DCHECK_NE(event, NO_EVENT_PENDING); 991 DCHECK(IsEventPending(event)) << GetEventName(event); 992 993 pending_event_ &= ~event; 994 } 995 996 } // namespace media 997
