media_source_player.cc revision eb525c5499e34cc9c4b825d6d9e75bb07cc06ace
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 "base/android/jni_android.h" 8#include "base/android/jni_string.h" 9#include "base/basictypes.h" 10#include "base/bind.h" 11#include "base/lazy_instance.h" 12#include "base/logging.h" 13#include "base/message_loop.h" 14#include "base/threading/thread.h" 15#include "media/base/android/media_codec_bridge.h" 16#include "media/base/android/media_drm_bridge.h" 17#include "media/base/android/media_player_manager.h" 18#include "media/base/audio_timestamp_helper.h" 19 20namespace { 21 22// Timeout value for media codec operations. Because the first 23// DequeInputBuffer() can take about 150 milliseconds, use 250 milliseconds 24// here. See b/9357571. 25const int kMediaCodecTimeoutInMicroseconds = 250000; 26 27// Use 16bit PCM for audio output. Keep this value in sync with the output 28// format we passed to AudioTrack in MediaCodecBridge. 29const int kBytesPerAudioOutputSample = 2; 30 31class DecoderThread : public base::Thread { 32 public: 33 virtual ~DecoderThread() {} 34 protected: 35 DecoderThread(const char* name) : base::Thread(name) { Start(); } 36}; 37 38class AudioDecoderThread : public DecoderThread { 39 public: 40 AudioDecoderThread() : DecoderThread("MediaSource_AudioDecoderThread") {} 41}; 42 43class VideoDecoderThread : public DecoderThread { 44 public: 45 VideoDecoderThread() : DecoderThread("MediaSource_VideoDecoderThread") {} 46}; 47 48// TODO(qinmin): Check if it is tolerable to use worker pool to handle all the 49// decoding tasks so that we don't need the global threads here. 50// http://crbug.com/245750 51base::LazyInstance<AudioDecoderThread>::Leaky 52 g_audio_decoder_thread = LAZY_INSTANCE_INITIALIZER; 53 54base::LazyInstance<VideoDecoderThread>::Leaky 55 g_video_decoder_thread = LAZY_INSTANCE_INITIALIZER; 56 57} 58 59namespace media { 60 61MediaDecoderJob::MediaDecoderJob( 62 const scoped_refptr<base::MessageLoopProxy>& decoder_loop, 63 MediaCodecBridge* media_codec_bridge, 64 bool is_audio) 65 : ui_loop_(base::MessageLoopProxy::current()), 66 decoder_loop_(decoder_loop), 67 media_codec_bridge_(media_codec_bridge), 68 needs_flush_(false), 69 is_audio_(is_audio), 70 weak_this_(this), 71 is_decoding_(false) { 72} 73 74MediaDecoderJob::~MediaDecoderJob() {} 75 76// Class for managing audio decoding jobs. 77class AudioDecoderJob : public MediaDecoderJob { 78 public: 79 virtual ~AudioDecoderJob() {} 80 81 static AudioDecoderJob* Create( 82 const AudioCodec audio_codec, int sample_rate, int channel_count, 83 const uint8* extra_data, size_t extra_data_size, jobject media_crypto); 84 85 private: 86 AudioDecoderJob(MediaCodecBridge* media_codec_bridge); 87}; 88 89// Class for managing video decoding jobs. 90class VideoDecoderJob : public MediaDecoderJob { 91 public: 92 virtual ~VideoDecoderJob() {} 93 94 static VideoDecoderJob* Create( 95 const VideoCodec video_codec, const gfx::Size& size, jobject surface, 96 jobject media_crypto); 97 98 private: 99 VideoDecoderJob(MediaCodecBridge* media_codec_bridge); 100}; 101 102void MediaDecoderJob::Decode( 103 const MediaPlayerHostMsg_ReadFromDemuxerAck_Params::AccessUnit& unit, 104 const base::TimeTicks& start_time_ticks, 105 const base::TimeDelta& start_presentation_timestamp, 106 const MediaDecoderJob::DecoderCallback& callback) { 107 DCHECK(!is_decoding_); 108 DCHECK(ui_loop_->BelongsToCurrentThread()); 109 is_decoding_ = true; 110 decoder_loop_->PostTask(FROM_HERE, base::Bind( 111 &MediaDecoderJob::DecodeInternal, base::Unretained(this), unit, 112 start_time_ticks, start_presentation_timestamp, needs_flush_, 113 callback)); 114 needs_flush_ = false; 115} 116 117void MediaDecoderJob::DecodeInternal( 118 const MediaPlayerHostMsg_ReadFromDemuxerAck_Params::AccessUnit& unit, 119 const base::TimeTicks& start_time_ticks, 120 const base::TimeDelta& start_presentation_timestamp, 121 bool needs_flush, 122 const MediaDecoderJob::DecoderCallback& callback) { 123 if (needs_flush) 124 media_codec_bridge_->Reset(); 125 base::TimeDelta timeout = base::TimeDelta::FromMicroseconds( 126 kMediaCodecTimeoutInMicroseconds); 127 int input_buf_index = media_codec_bridge_->DequeueInputBuffer(timeout); 128 if (input_buf_index == MediaCodecBridge::INFO_MEDIA_CODEC_ERROR) { 129 ui_loop_->PostTask(FROM_HERE, base::Bind( 130 callback, DECODE_FAILED, start_presentation_timestamp, 0, false)); 131 return; 132 } 133 // TODO(qinmin): skip frames if video is falling far behind. 134 if (input_buf_index >= 0) { 135 if (unit.end_of_stream || unit.data.empty()) { 136 media_codec_bridge_->QueueEOS(input_buf_index); 137 } else if (unit.key_id.empty()){ 138 media_codec_bridge_->QueueInputBuffer( 139 input_buf_index, &unit.data[0], unit.data.size(), unit.timestamp); 140 } else { 141 if (unit.iv.empty() || unit.subsamples.empty()) { 142 LOG(ERROR) << "The access unit doesn't have iv or subsamples while it " 143 << "has key IDs!"; 144 ui_loop_->PostTask(FROM_HERE, base::Bind( 145 callback, DECODE_FAILED, start_presentation_timestamp, 0, false)); 146 return; 147 } 148 media_codec_bridge_->QueueSecureInputBuffer( 149 input_buf_index, &unit.data[0], unit.data.size(), 150 reinterpret_cast<const uint8*>(&unit.key_id[0]), unit.key_id.size(), 151 reinterpret_cast<const uint8*>(&unit.iv[0]), unit.iv.size(), 152 &unit.subsamples[0], unit.subsamples.size(), unit.timestamp); 153 } 154 } 155 156 size_t offset = 0; 157 size_t size = 0; 158 base::TimeDelta presentation_timestamp; 159 bool end_of_stream = false; 160 DecodeStatus decode_status = DECODE_SUCCEEDED; 161 162 int outputBufferIndex = media_codec_bridge_->DequeueOutputBuffer( 163 timeout, &offset, &size, &presentation_timestamp, &end_of_stream); 164 switch (outputBufferIndex) { 165 case MediaCodecBridge::INFO_OUTPUT_BUFFERS_CHANGED: 166 media_codec_bridge_->GetOutputBuffers(); 167 break; 168 case MediaCodecBridge::INFO_OUTPUT_FORMAT_CHANGED: 169 // TODO(qinmin): figure out what we should do if format changes. 170 break; 171 case MediaCodecBridge::INFO_TRY_AGAIN_LATER: 172 decode_status = DECODE_TRY_AGAIN_LATER; 173 break; 174 case MediaCodecBridge::INFO_MEDIA_CODEC_ERROR: 175 decode_status = DECODE_FAILED; 176 break; 177 default: 178 DCHECK_LE(0, outputBufferIndex); 179 if (size == 0 && end_of_stream) 180 break; 181 base::TimeDelta time_to_render; 182 DCHECK(!start_time_ticks.is_null()); 183 if (!is_audio_) { 184 time_to_render = presentation_timestamp - (base::TimeTicks::Now() - 185 start_time_ticks + start_presentation_timestamp); 186 } 187 if (time_to_render >= base::TimeDelta()) { 188 base::MessageLoop::current()->PostDelayedTask( 189 FROM_HERE, 190 base::Bind(&MediaDecoderJob::ReleaseOutputBuffer, 191 weak_this_.GetWeakPtr(), outputBufferIndex, size, 192 presentation_timestamp, end_of_stream, callback), 193 time_to_render); 194 } else { 195 // TODO(qinmin): The codec is lagging behind, need to recalculate the 196 // |start_presentation_timestamp_| and |start_time_ticks_|. 197 DVLOG(1) << (is_audio_ ? "audio " : "video ") 198 << "codec is lagging behind :" << time_to_render.InMicroseconds(); 199 ReleaseOutputBuffer(outputBufferIndex, size, presentation_timestamp, 200 end_of_stream, callback); 201 } 202 return; 203 } 204 ui_loop_->PostTask(FROM_HERE, base::Bind( 205 callback, decode_status, start_presentation_timestamp, 0, end_of_stream)); 206} 207 208void MediaDecoderJob::ReleaseOutputBuffer( 209 int outputBufferIndex, size_t size, 210 const base::TimeDelta& presentation_timestamp, 211 bool end_of_stream, const MediaDecoderJob::DecoderCallback& callback) { 212 // TODO(qinmin): Refactor this function. Maybe AudioDecoderJob should provide 213 // its own ReleaseOutputBuffer(). 214 if (is_audio_) { 215 static_cast<AudioCodecBridge*>(media_codec_bridge_.get())->PlayOutputBuffer( 216 outputBufferIndex, size); 217 } 218 media_codec_bridge_->ReleaseOutputBuffer(outputBufferIndex, !is_audio_); 219 ui_loop_->PostTask(FROM_HERE, base::Bind( 220 callback, DECODE_SUCCEEDED, presentation_timestamp, is_audio_ ? size : 0, 221 end_of_stream)); 222} 223 224void MediaDecoderJob::OnDecodeCompleted() { 225 DCHECK(ui_loop_->BelongsToCurrentThread()); 226 is_decoding_ = false; 227} 228 229void MediaDecoderJob::Flush() { 230 // Do nothing, flush when the next Decode() happens. 231 needs_flush_ = true; 232} 233 234void MediaDecoderJob::Release() { 235 // If |decoding_| is false, there is nothing running on the decoder thread. 236 // So it is safe to delete the MediaDecoderJob on the UI thread. However, 237 // if we post a task to the decoder thread to delete object, then we cannot 238 // immediately pass the surface to a new MediaDecoderJob instance because 239 // the java surface is still owned by the old object. New decoder creation 240 // will be blocked on the UI thread until the previous decoder gets deleted. 241 // This introduces extra latency during config changes, and makes the logic in 242 // MediaSourcePlayer more complicated. 243 // 244 // TODO(qinmin): Figure out the logic to passing the surface to a new 245 // MediaDecoderJob instance after the previous one gets deleted on the decoder 246 // thread. 247 if (is_decoding_ && !decoder_loop_->BelongsToCurrentThread()) { 248 DCHECK(ui_loop_->BelongsToCurrentThread()); 249 decoder_loop_->DeleteSoon(FROM_HERE, this); 250 } else { 251 delete this; 252 } 253} 254 255VideoDecoderJob* VideoDecoderJob::Create( 256 const VideoCodec video_codec, const gfx::Size& size, jobject surface, 257 jobject media_crypto) { 258 scoped_ptr<VideoCodecBridge> codec(VideoCodecBridge::Create(video_codec)); 259 if (codec->Start(video_codec, size, surface, media_crypto)) 260 return new VideoDecoderJob(codec.release()); 261 return NULL; 262} 263 264VideoDecoderJob::VideoDecoderJob(MediaCodecBridge* media_codec_bridge) 265 : MediaDecoderJob(g_video_decoder_thread.Pointer()->message_loop_proxy(), 266 media_codec_bridge, 267 false) {} 268 269AudioDecoderJob* AudioDecoderJob::Create( 270 const AudioCodec audio_codec, 271 int sample_rate, 272 int channel_count, 273 const uint8* extra_data, 274 size_t extra_data_size, 275 jobject media_crypto) { 276 scoped_ptr<AudioCodecBridge> codec(AudioCodecBridge::Create(audio_codec)); 277 if (codec->Start(audio_codec, sample_rate, channel_count, extra_data, 278 extra_data_size, true, media_crypto)) { 279 return new AudioDecoderJob(codec.release()); 280 } 281 return NULL; 282} 283 284AudioDecoderJob::AudioDecoderJob(MediaCodecBridge* media_codec_bridge) 285 : MediaDecoderJob(g_audio_decoder_thread.Pointer()->message_loop_proxy(), 286 media_codec_bridge, 287 true) {} 288 289MediaSourcePlayer::MediaSourcePlayer( 290 int player_id, 291 MediaPlayerManager* manager) 292 : MediaPlayerAndroid(player_id, manager), 293 pending_event_(NO_EVENT_PENDING), 294 seek_request_id_(0), 295 width_(0), 296 height_(0), 297 audio_codec_(kUnknownAudioCodec), 298 video_codec_(kUnknownVideoCodec), 299 num_channels_(0), 300 sampling_rate_(0), 301 audio_finished_(true), 302 video_finished_(true), 303 playing_(false), 304 is_audio_encrypted_(false), 305 is_video_encrypted_(false), 306 clock_(&default_tick_clock_), 307 reconfig_audio_decoder_(false), 308 reconfig_video_decoder_(false), 309 audio_access_unit_index_(0), 310 video_access_unit_index_(0), 311 waiting_for_audio_data_(false), 312 waiting_for_video_data_(false), 313 sync_decoder_jobs_(true), 314 weak_this_(this), 315 drm_bridge_(NULL) { 316} 317 318MediaSourcePlayer::~MediaSourcePlayer() { 319 Release(); 320} 321 322void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) { 323 surface_ = surface.Pass(); 324 pending_event_ |= SURFACE_CHANGE_EVENT_PENDING; 325 if (pending_event_ & SEEK_EVENT_PENDING) { 326 // Waiting for the seek to finish. 327 return; 328 } 329 // Setting a new surface will require a new MediaCodec to be created. 330 // Request a seek so that the new decoder will decode an I-frame first. 331 // Or otherwise, the new MediaCodec might crash. See b/8950387. 332 pending_event_ |= SEEK_EVENT_PENDING; 333 ProcessPendingEvents(); 334} 335 336bool MediaSourcePlayer::Seekable() { 337 // If the duration TimeDelta, converted to milliseconds from microseconds, 338 // is >= 2^31, then the media is assumed to be unbounded and unseekable. 339 // 2^31 is the bound due to java player using 32-bit integer for time 340 // values at millisecond resolution. 341 return duration_ < 342 base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>::max()); 343} 344 345void MediaSourcePlayer::Start() { 346 playing_ = true; 347 348 StartInternal(); 349} 350 351void MediaSourcePlayer::Pause() { 352 // Since decoder jobs have their own thread, decoding is not fully paused 353 // until all the decoder jobs call MediaDecoderCallback(). It is possible 354 // that Start() is called while the player is waiting for 355 // MediaDecoderCallback(). In that case, decoding will continue when 356 // MediaDecoderCallback() is called. 357 playing_ = false; 358 start_time_ticks_ = base::TimeTicks(); 359} 360 361bool MediaSourcePlayer::IsPlaying() { 362 return playing_; 363} 364 365int MediaSourcePlayer::GetVideoWidth() { 366 return width_; 367} 368 369int MediaSourcePlayer::GetVideoHeight() { 370 return height_; 371} 372 373void MediaSourcePlayer::SeekTo(base::TimeDelta timestamp) { 374 clock_.SetTime(timestamp, timestamp); 375 if (audio_timestamp_helper_) 376 audio_timestamp_helper_->SetBaseTimestamp(timestamp); 377 pending_event_ |= SEEK_EVENT_PENDING; 378 ProcessPendingEvents(); 379} 380 381base::TimeDelta MediaSourcePlayer::GetCurrentTime() { 382 return clock_.Elapsed(); 383} 384 385base::TimeDelta MediaSourcePlayer::GetDuration() { 386 return duration_; 387} 388 389void MediaSourcePlayer::Release() { 390 ClearDecodingData(); 391 audio_decoder_job_.reset(); 392 video_decoder_job_.reset(); 393 reconfig_audio_decoder_ = false; 394 reconfig_video_decoder_ = false; 395 playing_ = false; 396 pending_event_ = NO_EVENT_PENDING; 397 surface_ = gfx::ScopedJavaSurface(); 398 ReleaseMediaResourcesFromManager(); 399} 400 401void MediaSourcePlayer::SetVolume(float leftVolume, float rightVolume) { 402} 403 404bool MediaSourcePlayer::CanPause() { 405 return Seekable(); 406} 407 408bool MediaSourcePlayer::CanSeekForward() { 409 return Seekable(); 410} 411 412bool MediaSourcePlayer::CanSeekBackward() { 413 return Seekable(); 414} 415 416bool MediaSourcePlayer::IsPlayerReady() { 417 return audio_decoder_job_ || video_decoder_job_; 418} 419 420void MediaSourcePlayer::StartInternal() { 421 // If there are pending events, wait for them finish. 422 if (pending_event_ != NO_EVENT_PENDING) 423 return; 424 425 // Create decoder jobs if they are not created 426 ConfigureAudioDecoderJob(); 427 ConfigureVideoDecoderJob(); 428 429 430 // If one of the decoder job is not ready, do nothing. 431 if ((HasAudio() && !audio_decoder_job_) || 432 (HasVideo() && !video_decoder_job_)) { 433 return; 434 } 435 436 audio_finished_ = false; 437 video_finished_ = false; 438 sync_decoder_jobs_ = true; 439 SyncAndStartDecoderJobs(); 440} 441 442void MediaSourcePlayer::DemuxerReady( 443 const MediaPlayerHostMsg_DemuxerReady_Params& params) { 444 duration_ = base::TimeDelta::FromMilliseconds(params.duration_ms); 445 width_ = params.video_size.width(); 446 height_ = params.video_size.height(); 447 num_channels_ = params.audio_channels; 448 sampling_rate_ = params.audio_sampling_rate; 449 audio_codec_ = params.audio_codec; 450 video_codec_ = params.video_codec; 451 audio_extra_data_ = params.audio_extra_data; 452 is_audio_encrypted_ = params.is_audio_encrypted; 453 is_video_encrypted_ = params.is_video_encrypted; 454 clock_.SetDuration(duration_); 455 audio_timestamp_helper_.reset(new AudioTimestampHelper( 456 kBytesPerAudioOutputSample * num_channels_, sampling_rate_)); 457 audio_timestamp_helper_->SetBaseTimestamp(GetCurrentTime()); 458 OnMediaMetadataChanged(duration_, width_, height_, true); 459 if (pending_event_ & CONFIG_CHANGE_EVENT_PENDING) { 460 if (reconfig_audio_decoder_) 461 ConfigureAudioDecoderJob(); 462 463 // If there is a pending surface change, we can merge it with the config 464 // change. 465 if (reconfig_video_decoder_) { 466 pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING; 467 ConfigureVideoDecoderJob(); 468 } 469 pending_event_ &= ~CONFIG_CHANGE_EVENT_PENDING; 470 if (playing_) 471 StartInternal(); 472 } 473} 474 475void MediaSourcePlayer::ReadFromDemuxerAck( 476 const MediaPlayerHostMsg_ReadFromDemuxerAck_Params& params) { 477 DCHECK_LT(0u, params.access_units.size()); 478 if (params.type == DemuxerStream::AUDIO) 479 waiting_for_audio_data_ = false; 480 else 481 waiting_for_video_data_ = false; 482 483 // If there is a pending seek request, ignore the data from the chunk demuxer. 484 // The data will be requested later when OnSeekRequestAck() is called. 485 if (pending_event_ & SEEK_EVENT_PENDING) 486 return; 487 488 if (params.type == DemuxerStream::AUDIO) { 489 DCHECK_EQ(0u, audio_access_unit_index_); 490 received_audio_ = params; 491 } else { 492 DCHECK_EQ(0u, video_access_unit_index_); 493 received_video_ = params; 494 } 495 496 if (pending_event_ != NO_EVENT_PENDING || !playing_) 497 return; 498 499 if (sync_decoder_jobs_) { 500 SyncAndStartDecoderJobs(); 501 return; 502 } 503 504 if (params.type == DemuxerStream::AUDIO) 505 DecodeMoreAudio(); 506 else 507 DecodeMoreVideo(); 508} 509 510void MediaSourcePlayer::DurationChanged(const base::TimeDelta& duration) { 511 duration_ = duration; 512 clock_.SetDuration(duration_); 513} 514 515void MediaSourcePlayer::SetDrmBridge(MediaDrmBridge* drm_bridge) { 516 if (!is_audio_encrypted_ && !is_video_encrypted_) 517 return; 518 519 // Currently we don't support DRM change during the middle of playback, even 520 // if the player is paused. 521 // TODO(qinmin): support DRM change after playback has started. 522 // http://crbug.com/253792. 523 DCHECK(!audio_decoder_job_ || !audio_decoder_job_->is_decoding()); 524 DCHECK(!video_decoder_job_ || !video_decoder_job_->is_decoding()); 525 DCHECK_EQ(0u, audio_access_unit_index_); 526 DCHECK_EQ(0u, video_access_unit_index_); 527 528 drm_bridge_ = drm_bridge; 529 530 if (playing_) 531 StartInternal(); 532} 533 534void MediaSourcePlayer::OnSeekRequestAck(unsigned seek_request_id) { 535 // Do nothing until the most recent seek request is processed. 536 if (seek_request_id_ != seek_request_id) 537 return; 538 pending_event_ &= ~SEEK_EVENT_PENDING; 539 OnSeekComplete(); 540 ProcessPendingEvents(); 541} 542 543void MediaSourcePlayer::UpdateTimestamps( 544 const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes) { 545 if (audio_output_bytes > 0) { 546 audio_timestamp_helper_->AddBytes(audio_output_bytes); 547 clock_.SetMaxTime(audio_timestamp_helper_->GetTimestamp()); 548 } else { 549 clock_.SetMaxTime(presentation_timestamp); 550 } 551 552 OnTimeUpdated(); 553} 554 555void MediaSourcePlayer::ProcessPendingEvents() { 556 // Wait for all the decoding jobs to finish before processing pending tasks. 557 if ((audio_decoder_job_ && audio_decoder_job_->is_decoding()) || 558 (video_decoder_job_ && video_decoder_job_->is_decoding())) { 559 return; 560 } 561 562 if (pending_event_ & SEEK_EVENT_PENDING) { 563 ClearDecodingData(); 564 manager()->OnMediaSeekRequest( 565 player_id(), GetCurrentTime(), ++seek_request_id_); 566 return; 567 } 568 569 start_time_ticks_ = base::TimeTicks(); 570 if (pending_event_ & CONFIG_CHANGE_EVENT_PENDING) { 571 DCHECK(reconfig_audio_decoder_ || reconfig_video_decoder_); 572 manager()->OnMediaConfigRequest(player_id()); 573 return; 574 } 575 576 if (pending_event_ & SURFACE_CHANGE_EVENT_PENDING) { 577 video_decoder_job_.reset(); 578 ConfigureVideoDecoderJob(); 579 pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING; 580 } 581 582 if (playing_) 583 StartInternal(); 584} 585 586void MediaSourcePlayer::MediaDecoderCallback( 587 bool is_audio, MediaDecoderJob::DecodeStatus decode_status, 588 const base::TimeDelta& presentation_timestamp, size_t audio_output_bytes, 589 bool end_of_stream) { 590 if (is_audio && audio_decoder_job_) 591 audio_decoder_job_->OnDecodeCompleted(); 592 if (!is_audio && video_decoder_job_) 593 video_decoder_job_->OnDecodeCompleted(); 594 595 if (is_audio) 596 decoder_starvation_callback_.Cancel(); 597 598 if (decode_status == MediaDecoderJob::DECODE_FAILED) { 599 Release(); 600 OnMediaError(MEDIA_ERROR_DECODE); 601 return; 602 } else if (decode_status == MediaDecoderJob::DECODE_SUCCEEDED) { 603 if (is_audio) 604 audio_access_unit_index_++; 605 else 606 video_access_unit_index_++; 607 } 608 609 if (pending_event_ != NO_EVENT_PENDING) { 610 ProcessPendingEvents(); 611 return; 612 } 613 614 if (is_audio || !HasAudio()) 615 UpdateTimestamps(presentation_timestamp, audio_output_bytes); 616 617 if (end_of_stream) { 618 PlaybackCompleted(is_audio); 619 return; 620 } 621 622 if (!playing_) { 623 if (is_audio || !HasAudio()) 624 clock_.Pause(); 625 return; 626 } 627 628 if (sync_decoder_jobs_) { 629 SyncAndStartDecoderJobs(); 630 return; 631 } 632 633 base::TimeDelta current_timestamp = GetCurrentTime(); 634 if (is_audio) { 635 base::TimeDelta timeout = 636 audio_timestamp_helper_->GetTimestamp() - current_timestamp; 637 StartStarvationCallback(timeout); 638 if (!HasAudioData()) 639 RequestAudioData(); 640 else 641 DecodeMoreAudio(); 642 return; 643 } 644 645 if (!HasAudio()) { 646 DCHECK(current_timestamp <= presentation_timestamp); 647 // For video only streams, fps can be estimated from the difference 648 // between the previous and current presentation timestamps. The 649 // previous presentation timestamp is equal to current_timestamp. 650 // TODO(qinmin): determine whether 2 is a good coefficient for estimating 651 // video frame timeout. 652 StartStarvationCallback(2 * (presentation_timestamp - current_timestamp)); 653 } 654 if (!HasVideoData()) 655 RequestVideoData(); 656 else 657 DecodeMoreVideo(); 658} 659 660void MediaSourcePlayer::DecodeMoreAudio() { 661 DCHECK(!audio_decoder_job_->is_decoding()); 662 DCHECK(HasAudioData()); 663 664 if (DemuxerStream::kConfigChanged == 665 received_audio_.access_units[audio_access_unit_index_].status) { 666 // Wait for demuxer ready message. 667 reconfig_audio_decoder_ = true; 668 pending_event_ |= CONFIG_CHANGE_EVENT_PENDING; 669 received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params(); 670 audio_access_unit_index_ = 0; 671 ProcessPendingEvents(); 672 return; 673 } 674 675 audio_decoder_job_->Decode( 676 received_audio_.access_units[audio_access_unit_index_], 677 start_time_ticks_, start_presentation_timestamp_, 678 base::Bind(&MediaSourcePlayer::MediaDecoderCallback, 679 weak_this_.GetWeakPtr(), true)); 680} 681 682void MediaSourcePlayer::DecodeMoreVideo() { 683 DCHECK(!video_decoder_job_->is_decoding()); 684 DCHECK(HasVideoData()); 685 686 if (DemuxerStream::kConfigChanged == 687 received_video_.access_units[video_access_unit_index_].status) { 688 // Wait for demuxer ready message. 689 reconfig_video_decoder_ = true; 690 pending_event_ |= CONFIG_CHANGE_EVENT_PENDING; 691 received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params(); 692 video_access_unit_index_ = 0; 693 ProcessPendingEvents(); 694 return; 695 } 696 697 video_decoder_job_->Decode( 698 received_video_.access_units[video_access_unit_index_], 699 start_time_ticks_, start_presentation_timestamp_, 700 base::Bind(&MediaSourcePlayer::MediaDecoderCallback, 701 weak_this_.GetWeakPtr(), false)); 702} 703 704void MediaSourcePlayer::PlaybackCompleted(bool is_audio) { 705 if (is_audio) 706 audio_finished_ = true; 707 else 708 video_finished_ = true; 709 710 if ((!HasAudio() || audio_finished_) && (!HasVideo() || video_finished_)) { 711 playing_ = false; 712 clock_.Pause(); 713 start_time_ticks_ = base::TimeTicks(); 714 OnPlaybackComplete(); 715 } 716} 717 718void MediaSourcePlayer::ClearDecodingData() { 719 if (audio_decoder_job_) 720 audio_decoder_job_->Flush(); 721 if (video_decoder_job_) 722 video_decoder_job_->Flush(); 723 start_time_ticks_ = base::TimeTicks(); 724 received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params(); 725 received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params(); 726 audio_access_unit_index_ = 0; 727 video_access_unit_index_ = 0; 728 waiting_for_audio_data_ = false; 729 waiting_for_video_data_ = false; 730} 731 732bool MediaSourcePlayer::HasVideo() { 733 return kUnknownVideoCodec != video_codec_; 734} 735 736bool MediaSourcePlayer::HasAudio() { 737 return kUnknownAudioCodec != audio_codec_; 738} 739 740void MediaSourcePlayer::ConfigureAudioDecoderJob() { 741 if (!HasAudio()) { 742 audio_decoder_job_.reset(); 743 return; 744 } 745 746 // Create audio decoder job only if config changes. 747 if (audio_decoder_job_ && !reconfig_audio_decoder_) 748 return; 749 750 base::android::ScopedJavaLocalRef<jobject> media_codec; 751 if (is_audio_encrypted_) { 752 if (drm_bridge_) { 753 media_codec = drm_bridge_->GetMediaCrypto(); 754 // TODO(qinmin): currently we assume MediaCrypto is available whenever 755 // MediaDrmBridge is constructed. This will change if we want to support 756 // more general uses cases of EME. 757 DCHECK(!media_codec.is_null()); 758 } else { 759 // Don't create the decoder job if |drm_bridge_| is not set, 760 // so StartInternal() will not proceed. 761 LOG(INFO) << "MediaDrmBridge is not available when creating decoder " 762 << "for encrypted audio stream."; 763 return; 764 } 765 } 766 767 audio_decoder_job_.reset(AudioDecoderJob::Create( 768 audio_codec_, sampling_rate_, num_channels_, &audio_extra_data_[0], 769 audio_extra_data_.size(), media_codec.obj())); 770 771 if (audio_decoder_job_) 772 reconfig_audio_decoder_ = false; 773} 774 775void MediaSourcePlayer::ConfigureVideoDecoderJob() { 776 if (!HasVideo() || surface_.IsSurfaceEmpty()) { 777 video_decoder_job_.reset(); 778 return; 779 } 780 781 // Create video decoder job only if config changes. 782 if (video_decoder_job_ && !reconfig_video_decoder_) 783 return; 784 785 base::android::ScopedJavaLocalRef<jobject> media_codec; 786 if (is_video_encrypted_) { 787 if (drm_bridge_) { 788 media_codec = drm_bridge_->GetMediaCrypto(); 789 DCHECK(!media_codec.is_null()); 790 } else { 791 LOG(INFO) << "MediaDrmBridge is not available when creating decoder " 792 << "for encrypted video stream."; 793 return; 794 } 795 } 796 797 // Release the old VideoDecoderJob first so the surface can get released. 798 // Android does not allow 2 MediaCodec instances use the same surface. 799 video_decoder_job_.reset(); 800 // Create the new VideoDecoderJob. 801 video_decoder_job_.reset(VideoDecoderJob::Create( 802 video_codec_, gfx::Size(width_, height_), surface_.j_surface().obj(), 803 media_codec.obj())); 804 if (video_decoder_job_) 805 reconfig_video_decoder_ = false; 806 807 // Inform the fullscreen view the player is ready. 808 // TODO(qinmin): refactor MediaPlayerBridge so that we have a better way 809 // to inform ContentVideoView. 810 OnMediaMetadataChanged(duration_, width_, height_, true); 811} 812 813void MediaSourcePlayer::OnDecoderStarved() { 814 sync_decoder_jobs_ = true; 815} 816 817void MediaSourcePlayer::StartStarvationCallback( 818 const base::TimeDelta& timeout) { 819 decoder_starvation_callback_.Reset( 820 base::Bind(&MediaSourcePlayer::OnDecoderStarved, 821 weak_this_.GetWeakPtr())); 822 base::MessageLoop::current()->PostDelayedTask( 823 FROM_HERE, decoder_starvation_callback_.callback(), timeout); 824} 825 826void MediaSourcePlayer::SyncAndStartDecoderJobs() { 827 // For streams with both audio and video, send the request for video too. 828 // However, don't wait for the response so that we won't have lots of 829 // noticeable pauses in the audio. Video will sync with audio by itself. 830 if (HasVideo() && !HasVideoData()) { 831 RequestVideoData(); 832 if (!HasAudio()) 833 return; 834 } 835 if (HasAudio() && !HasAudioData()) { 836 RequestAudioData(); 837 return; 838 } 839 start_time_ticks_ = base::TimeTicks::Now(); 840 start_presentation_timestamp_ = GetCurrentTime(); 841 if (!clock_.IsPlaying()) 842 clock_.Play(); 843 if (HasAudioData() && !audio_decoder_job_->is_decoding()) 844 DecodeMoreAudio(); 845 if (HasVideoData() && !video_decoder_job_->is_decoding()) 846 DecodeMoreVideo(); 847 sync_decoder_jobs_ = false; 848} 849 850void MediaSourcePlayer::RequestAudioData() { 851 DCHECK(HasAudio()); 852 853 if (waiting_for_audio_data_) 854 return; 855 856 manager()->OnReadFromDemuxer(player_id(), DemuxerStream::AUDIO); 857 received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params(); 858 audio_access_unit_index_ = 0; 859 waiting_for_audio_data_ = true; 860} 861 862void MediaSourcePlayer::RequestVideoData() { 863 DCHECK(HasVideo()); 864 if (waiting_for_video_data_) 865 return; 866 867 manager()->OnReadFromDemuxer(player_id(), DemuxerStream::VIDEO); 868 received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params(); 869 video_access_unit_index_ = 0; 870 waiting_for_video_data_ = true; 871} 872 873bool MediaSourcePlayer::HasAudioData() const { 874 return audio_access_unit_index_ < received_audio_.access_units.size(); 875} 876 877bool MediaSourcePlayer::HasVideoData() const { 878 return video_access_unit_index_ < received_video_.access_units.size(); 879} 880 881} // namespace media 882