Home | History | Annotate | Download | only in android 
      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 
     23 
     24 namespace media {
     25 
     26 MediaSourcePlayer::MediaSourcePlayer(
     27     int player_id,
     28     MediaPlayerManager* manager,
     29     const RequestMediaResourcesCB& request_media_resources_cb,
     30     const ReleaseMediaResourcesCB& release_media_resources_cb,
     31     scoped_ptr<DemuxerAndroid> demuxer,
     32     const GURL& frame_url)
     33     : MediaPlayerAndroid(player_id,
     34                          manager,
     35                          request_media_resources_cb,
     36                          release_media_resources_cb,
     37                          frame_url),
     38       demuxer_(demuxer.Pass()),
     39       pending_event_(NO_EVENT_PENDING),
     40       playing_(false),
     41       clock_(&default_tick_clock_),
     42       doing_browser_seek_(false),
     43       pending_seek_(false),
     44       drm_bridge_(NULL),
     45       cdm_registration_id_(0),
     46       is_waiting_for_key_(false),
     47       is_waiting_for_audio_decoder_(false),
     48       is_waiting_for_video_decoder_(false),
     49       weak_factory_(this) {
     50   audio_decoder_job_.reset(new AudioDecoderJob(
     51       base::Bind(&DemuxerAndroid::RequestDemuxerData,
     52                  base::Unretained(demuxer_.get()),
     53                  DemuxerStream::AUDIO),
     54       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
     55                  weak_factory_.GetWeakPtr())));
     56   video_decoder_job_.reset(new VideoDecoderJob(
     57       base::Bind(&DemuxerAndroid::RequestDemuxerData,
     58                  base::Unretained(demuxer_.get()),
     59                  DemuxerStream::VIDEO),
     60       base::Bind(request_media_resources_cb_, player_id),
     61       base::Bind(release_media_resources_cb_, player_id),
     62       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
     63                  weak_factory_.GetWeakPtr())));
     64   demuxer_->Initialize(this);
     65   clock_.SetMaxTime(base::TimeDelta());
     66   weak_this_ = weak_factory_.GetWeakPtr();
     67 }
     68 
     69 MediaSourcePlayer::~MediaSourcePlayer() {
     70   Release();
     71   DCHECK_EQ(!drm_bridge_, !cdm_registration_id_);
     72   if (drm_bridge_) {
     73     drm_bridge_->UnregisterPlayer(cdm_registration_id_);
     74     cdm_registration_id_ = 0;
     75   }
     76 }
     77 
     78 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
     79   DVLOG(1) << __FUNCTION__;
     80   if (!video_decoder_job_->SetVideoSurface(surface.Pass()))
     81     return;
     82   // Retry video decoder creation.
     83   RetryDecoderCreation(false, true);
     84 }
     85 
     86 void MediaSourcePlayer::ScheduleSeekEventAndStopDecoding(
     87     base::TimeDelta seek_time) {
     88   DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ")";
     89   DCHECK(!IsEventPending(SEEK_EVENT_PENDING));
     90 
     91   pending_seek_ = false;
     92 
     93   clock_.SetTime(seek_time, seek_time);
     94 
     95   if (audio_decoder_job_->is_decoding())
     96     audio_decoder_job_->StopDecode();
     97   if (video_decoder_job_->is_decoding())
     98     video_decoder_job_->StopDecode();
     99 
    100   SetPendingEvent(SEEK_EVENT_PENDING);
    101   ProcessPendingEvents();
    102 }
    103 
    104 void MediaSourcePlayer::BrowserSeekToCurrentTime() {
    105   DVLOG(1) << __FUNCTION__;
    106 
    107   DCHECK(!IsEventPending(SEEK_EVENT_PENDING));
    108   doing_browser_seek_ = true;
    109   ScheduleSeekEventAndStopDecoding(GetCurrentTime());
    110 }
    111 
    112 bool MediaSourcePlayer::Seekable() {
    113   // If the duration TimeDelta, converted to milliseconds from microseconds,
    114   // is >= 2^31, then the media is assumed to be unbounded and unseekable.
    115   // 2^31 is the bound due to java player using 32-bit integer for time
    116   // values at millisecond resolution.
    117   return duration_ <
    118          base::TimeDelta::FromMilliseconds(std::numeric_limits<int32>::max());
    119 }
    120 
    121 void MediaSourcePlayer::Start() {
    122   DVLOG(1) << __FUNCTION__;
    123 
    124   playing_ = true;
    125 
    126   bool request_fullscreen = IsProtectedSurfaceRequired();
    127 #if defined(VIDEO_HOLE)
    128   // Skip to request fullscreen when hole-punching is used.
    129   request_fullscreen = request_fullscreen &&
    130       !manager()->ShouldUseVideoOverlayForEmbeddedEncryptedVideo();
    131 #endif  // defined(VIDEO_HOLE)
    132   if (request_fullscreen)
    133     manager()->RequestFullScreen(player_id());
    134 
    135   StartInternal();
    136 }
    137 
    138 void MediaSourcePlayer::Pause(bool is_media_related_action) {
    139   DVLOG(1) << __FUNCTION__;
    140 
    141   // Since decoder jobs have their own thread, decoding is not fully paused
    142   // until all the decoder jobs call MediaDecoderCallback(). It is possible
    143   // that Start() is called while the player is waiting for
    144   // MediaDecoderCallback(). In that case, decoding will continue when
    145   // MediaDecoderCallback() is called.
    146   playing_ = false;
    147   start_time_ticks_ = base::TimeTicks();
    148 }
    149 
    150 bool MediaSourcePlayer::IsPlaying() {
    151   return playing_;
    152 }
    153 
    154 int MediaSourcePlayer::GetVideoWidth() {
    155   return video_decoder_job_->width();
    156 }
    157 
    158 int MediaSourcePlayer::GetVideoHeight() {
    159   return video_decoder_job_->height();
    160 }
    161 
    162 void MediaSourcePlayer::SeekTo(base::TimeDelta timestamp) {
    163   DVLOG(1) << __FUNCTION__ << "(" << timestamp.InSecondsF() << ")";
    164 
    165   if (IsEventPending(SEEK_EVENT_PENDING)) {
    166     DCHECK(doing_browser_seek_) << "SeekTo while SeekTo in progress";
    167     DCHECK(!pending_seek_) << "SeekTo while SeekTo pending browser seek";
    168 
    169     // There is a browser seek currently in progress to obtain I-frame to feed
    170     // a newly constructed video decoder. Remember this real seek request so
    171     // it can be initiated once OnDemuxerSeekDone() occurs for the browser seek.
    172     pending_seek_ = true;
    173     pending_seek_time_ = timestamp;
    174     return;
    175   }
    176 
    177   doing_browser_seek_ = false;
    178   ScheduleSeekEventAndStopDecoding(timestamp);
    179 }
    180 
    181 base::TimeDelta MediaSourcePlayer::GetCurrentTime() {
    182   return clock_.Elapsed();
    183 }
    184 
    185 base::TimeDelta MediaSourcePlayer::GetDuration() {
    186   return duration_;
    187 }
    188 
    189 void MediaSourcePlayer::Release() {
    190   DVLOG(1) << __FUNCTION__;
    191 
    192   is_surface_in_use_ = false;
    193   audio_decoder_job_->ReleaseDecoderResources();
    194   video_decoder_job_->ReleaseDecoderResources();
    195 
    196   // Prevent player restart, including job re-creation attempts.
    197   playing_ = false;
    198 
    199   decoder_starvation_callback_.Cancel();
    200 }
    201 
    202 void MediaSourcePlayer::SetVolume(double volume) {
    203   audio_decoder_job_->SetVolume(volume);
    204 }
    205 
    206 bool MediaSourcePlayer::IsSurfaceInUse() const {
    207   return is_surface_in_use_;
    208 }
    209 
    210 bool MediaSourcePlayer::CanPause() {
    211   return Seekable();
    212 }
    213 
    214 bool MediaSourcePlayer::CanSeekForward() {
    215   return Seekable();
    216 }
    217 
    218 bool MediaSourcePlayer::CanSeekBackward() {
    219   return Seekable();
    220 }
    221 
    222 bool MediaSourcePlayer::IsPlayerReady() {
    223   return audio_decoder_job_ || video_decoder_job_;
    224 }
    225 
    226 void MediaSourcePlayer::StartInternal() {
    227   DVLOG(1) << __FUNCTION__;
    228   // If there are pending events, wait for them finish.
    229   if (pending_event_ != NO_EVENT_PENDING)
    230     return;
    231 
    232   // When we start, we'll have new demuxed data coming in. This new data could
    233   // be clear (not encrypted) or encrypted with different keys. So
    234   // |is_waiting_for_key_| condition may not be true anymore.
    235   is_waiting_for_key_ = false;
    236 
    237   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
    238   ProcessPendingEvents();
    239 }
    240 
    241 void MediaSourcePlayer::OnDemuxerConfigsAvailable(
    242     const DemuxerConfigs& configs) {
    243   DVLOG(1) << __FUNCTION__;
    244   DCHECK(!HasAudio() && !HasVideo());
    245   duration_ = configs.duration;
    246   clock_.SetDuration(duration_);
    247 
    248   audio_decoder_job_->SetDemuxerConfigs(configs);
    249   video_decoder_job_->SetDemuxerConfigs(configs);
    250   OnDemuxerConfigsChanged();
    251 }
    252 
    253 void MediaSourcePlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
    254   DVLOG(1) << __FUNCTION__ << "(" << data.type << ")";
    255   DCHECK_LT(0u, data.access_units.size());
    256   CHECK_GE(1u, data.demuxer_configs.size());
    257 
    258   if (data.type == DemuxerStream::AUDIO)
    259     audio_decoder_job_->OnDataReceived(data);
    260   else if (data.type == DemuxerStream::VIDEO)
    261     video_decoder_job_->OnDataReceived(data);
    262 }
    263 
    264 void MediaSourcePlayer::OnDemuxerDurationChanged(base::TimeDelta duration) {
    265   duration_ = duration;
    266   clock_.SetDuration(duration_);
    267 }
    268 
    269 void MediaSourcePlayer::OnMediaCryptoReady() {
    270   DCHECK(!drm_bridge_->GetMediaCrypto().is_null());
    271   drm_bridge_->SetMediaCryptoReadyCB(base::Closure());
    272 
    273   // Retry decoder creation if the decoders are waiting for MediaCrypto.
    274   RetryDecoderCreation(true, true);
    275 }
    276 
    277 void MediaSourcePlayer::SetCdm(BrowserCdm* cdm) {
    278   // Currently we don't support DRM change during the middle of playback, even
    279   // if the player is paused.
    280   // TODO(qinmin): support DRM change after playback has started.
    281   // http://crbug.com/253792.
    282   if (GetCurrentTime() > base::TimeDelta()) {
    283     VLOG(0) << "Setting DRM bridge after playback has started. "
    284             << "This is not well supported!";
    285   }
    286 
    287   if (drm_bridge_) {
    288     NOTREACHED() << "Currently we do not support resetting CDM.";
    289     return;
    290   }
    291 
    292   // Only MediaDrmBridge will be set on MediaSourcePlayer.
    293   drm_bridge_ = static_cast<MediaDrmBridge*>(cdm);
    294 
    295   cdm_registration_id_ = drm_bridge_->RegisterPlayer(
    296       base::Bind(&MediaSourcePlayer::OnKeyAdded, weak_this_),
    297       base::Bind(&MediaSourcePlayer::OnCdmUnset, weak_this_));
    298 
    299   audio_decoder_job_->SetDrmBridge(drm_bridge_);
    300   video_decoder_job_->SetDrmBridge(drm_bridge_);
    301 
    302   if (drm_bridge_->GetMediaCrypto().is_null()) {
    303     drm_bridge_->SetMediaCryptoReadyCB(
    304         base::Bind(&MediaSourcePlayer::OnMediaCryptoReady, weak_this_));
    305     return;
    306   }
    307 
    308   // If the player is previously waiting for CDM, retry decoder creation.
    309   RetryDecoderCreation(true, true);
    310 }
    311 
    312 void MediaSourcePlayer::OnDemuxerSeekDone(
    313     base::TimeDelta actual_browser_seek_time) {
    314   DVLOG(1) << __FUNCTION__;
    315 
    316   ClearPendingEvent(SEEK_EVENT_PENDING);
    317   if (IsEventPending(PREFETCH_REQUEST_EVENT_PENDING))
    318     ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
    319 
    320   if (pending_seek_) {
    321     DVLOG(1) << __FUNCTION__ << "processing pending seek";
    322     DCHECK(doing_browser_seek_);
    323     pending_seek_ = false;
    324     SeekTo(pending_seek_time_);
    325     return;
    326   }
    327 
    328   // It is possible that a browser seek to I-frame had to seek to a buffered
    329   // I-frame later than the requested one due to data removal or GC. Update
    330   // player clock to the actual seek target.
    331   if (doing_browser_seek_) {
    332     DCHECK(actual_browser_seek_time != kNoTimestamp());
    333     base::TimeDelta seek_time = actual_browser_seek_time;
    334     // A browser seek must not jump into the past. Ideally, it seeks to the
    335     // requested time, but it might jump into the future.
    336     DCHECK(seek_time >= GetCurrentTime());
    337     DVLOG(1) << __FUNCTION__ << " : setting clock to actual browser seek time: "
    338              << seek_time.InSecondsF();
    339     clock_.SetTime(seek_time, seek_time);
    340     audio_decoder_job_->SetBaseTimestamp(seek_time);
    341   } else {
    342     DCHECK(actual_browser_seek_time == kNoTimestamp());
    343   }
    344 
    345   base::TimeDelta current_time = GetCurrentTime();
    346   // TODO(qinmin): Simplify the logic by using |start_presentation_timestamp_|
    347   // to preroll media decoder jobs. Currently |start_presentation_timestamp_|
    348   // is calculated from decoder output, while preroll relies on the access
    349   // unit's timestamp. There are some differences between the two.
    350   preroll_timestamp_ = current_time;
    351   if (HasAudio())
    352     audio_decoder_job_->BeginPrerolling(preroll_timestamp_);
    353   if (HasVideo())
    354     video_decoder_job_->BeginPrerolling(preroll_timestamp_);
    355 
    356   if (!doing_browser_seek_)
    357     manager()->OnSeekComplete(player_id(), current_time);
    358 
    359   ProcessPendingEvents();
    360 }
    361 
    362 void MediaSourcePlayer::UpdateTimestamps(
    363     base::TimeDelta current_presentation_timestamp,
    364     base::TimeDelta max_presentation_timestamp) {
    365   clock_.SetTime(current_presentation_timestamp, max_presentation_timestamp);
    366   manager()->OnTimeUpdate(player_id(), GetCurrentTime());
    367 }
    368 
    369 void MediaSourcePlayer::ProcessPendingEvents() {
    370   DVLOG(1) << __FUNCTION__ << " : 0x" << std::hex << pending_event_;
    371   // Wait for all the decoding jobs to finish before processing pending tasks.
    372   if (video_decoder_job_->is_decoding()) {
    373     DVLOG(1) << __FUNCTION__ << " : A video job is still decoding.";
    374     return;
    375   }
    376 
    377   if (audio_decoder_job_->is_decoding()) {
    378     DVLOG(1) << __FUNCTION__ << " : An audio job is still decoding.";
    379     return;
    380   }
    381 
    382   if (IsEventPending(PREFETCH_DONE_EVENT_PENDING)) {
    383     DVLOG(1) << __FUNCTION__ << " : PREFETCH_DONE still pending.";
    384     return;
    385   }
    386 
    387   if (IsEventPending(SEEK_EVENT_PENDING)) {
    388     DVLOG(1) << __FUNCTION__ << " : Handling SEEK_EVENT";
    389     ClearDecodingData();
    390     audio_decoder_job_->SetBaseTimestamp(GetCurrentTime());
    391     demuxer_->RequestDemuxerSeek(GetCurrentTime(), doing_browser_seek_);
    392     return;
    393   }
    394 
    395   if (IsEventPending(DECODER_CREATION_EVENT_PENDING)) {
    396     // Don't continue if one of the decoder is not created.
    397     if (is_waiting_for_audio_decoder_ || is_waiting_for_video_decoder_)
    398       return;
    399     ClearPendingEvent(DECODER_CREATION_EVENT_PENDING);
    400   }
    401 
    402   if (IsEventPending(PREFETCH_REQUEST_EVENT_PENDING)) {
    403     DVLOG(1) << __FUNCTION__ << " : Handling PREFETCH_REQUEST_EVENT.";
    404     int count = (AudioFinished() ? 0 : 1) + (VideoFinished() ? 0 : 1);
    405 
    406     // It is possible that all streams have finished decode, yet starvation
    407     // occurred during the last stream's EOS decode. In this case, prefetch is a
    408     // no-op.
    409     ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
    410     if (count == 0)
    411       return;
    412 
    413     SetPendingEvent(PREFETCH_DONE_EVENT_PENDING);
    414     base::Closure barrier = BarrierClosure(
    415         count, base::Bind(&MediaSourcePlayer::OnPrefetchDone, weak_this_));
    416 
    417     if (!AudioFinished())
    418       audio_decoder_job_->Prefetch(barrier);
    419 
    420     if (!VideoFinished())
    421       video_decoder_job_->Prefetch(barrier);
    422 
    423     return;
    424   }
    425 
    426   DCHECK_EQ(pending_event_, NO_EVENT_PENDING);
    427 
    428   // Now that all pending events have been handled, resume decoding if we are
    429   // still playing.
    430   if (playing_)
    431     StartInternal();
    432 }
    433 
    434 void MediaSourcePlayer::MediaDecoderCallback(
    435     bool is_audio, MediaCodecStatus status,
    436     base::TimeDelta current_presentation_timestamp,
    437     base::TimeDelta max_presentation_timestamp) {
    438   DVLOG(1) << __FUNCTION__ << ": " << is_audio << ", " << status;
    439 
    440   // TODO(xhwang): Drop IntToString() when http://crbug.com/303899 is fixed.
    441   if (is_audio) {
    442     TRACE_EVENT_ASYNC_END1("media",
    443                            "MediaSourcePlayer::DecodeMoreAudio",
    444                            audio_decoder_job_.get(),
    445                            "MediaCodecStatus",
    446                            base::IntToString(status));
    447   } else {
    448     TRACE_EVENT_ASYNC_END1("media",
    449                            "MediaSourcePlayer::DecodeMoreVideo",
    450                            video_decoder_job_.get(),
    451                            "MediaCodecStatus",
    452                            base::IntToString(status));
    453   }
    454 
    455   // Let tests hook the completion of this decode cycle.
    456   if (!decode_callback_for_testing_.is_null())
    457     base::ResetAndReturn(&decode_callback_for_testing_).Run();
    458 
    459   bool is_clock_manager = is_audio || !HasAudio();
    460 
    461   if (is_clock_manager)
    462     decoder_starvation_callback_.Cancel();
    463 
    464   if (status == MEDIA_CODEC_ERROR) {
    465     DVLOG(1) << __FUNCTION__ << " : decode error";
    466     Release();
    467     manager()->OnError(player_id(), MEDIA_ERROR_DECODE);
    468     return;
    469   }
    470 
    471   DCHECK(!IsEventPending(PREFETCH_DONE_EVENT_PENDING));
    472 
    473   // Let |SEEK_EVENT_PENDING| (the highest priority event outside of
    474   // |PREFETCH_DONE_EVENT_PENDING|) preempt output EOS detection here. Process
    475   // any other pending events only after handling EOS detection.
    476   if (IsEventPending(SEEK_EVENT_PENDING)) {
    477     ProcessPendingEvents();
    478     return;
    479   }
    480 
    481   if ((status == MEDIA_CODEC_OK || status == MEDIA_CODEC_INPUT_END_OF_STREAM) &&
    482       is_clock_manager && current_presentation_timestamp != kNoTimestamp()) {
    483     UpdateTimestamps(current_presentation_timestamp,
    484                      max_presentation_timestamp);
    485   }
    486 
    487   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
    488     PlaybackCompleted(is_audio);
    489 
    490   if (pending_event_ != NO_EVENT_PENDING) {
    491     ProcessPendingEvents();
    492     return;
    493   }
    494 
    495   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
    496     return;
    497 
    498   if (!playing_) {
    499     if (is_clock_manager)
    500       clock_.Pause();
    501     return;
    502   }
    503 
    504   if (status == MEDIA_CODEC_NO_KEY) {
    505     is_waiting_for_key_ = true;
    506     return;
    507   }
    508 
    509   // If the status is MEDIA_CODEC_STOPPED, stop decoding new data. The player is
    510   // in the middle of a seek or stop event and needs to wait for the IPCs to
    511   // come.
    512   if (status == MEDIA_CODEC_STOPPED)
    513     return;
    514 
    515   if (is_clock_manager) {
    516     // If we have a valid timestamp, start the starvation callback. Otherwise,
    517     // reset the |start_time_ticks_| so that the next frame will not suffer
    518     // from the decoding delay caused by the current frame.
    519     if (current_presentation_timestamp != kNoTimestamp())
    520       StartStarvationCallback(current_presentation_timestamp,
    521                               max_presentation_timestamp);
    522     else
    523       start_time_ticks_ = base::TimeTicks::Now();
    524   }
    525 
    526   if (is_audio)
    527     DecodeMoreAudio();
    528   else
    529     DecodeMoreVideo();
    530 }
    531 
    532 void MediaSourcePlayer::DecodeMoreAudio() {
    533   DVLOG(1) << __FUNCTION__;
    534   DCHECK(!audio_decoder_job_->is_decoding());
    535   DCHECK(!AudioFinished());
    536 
    537   if (audio_decoder_job_->Decode(
    538       start_time_ticks_,
    539       start_presentation_timestamp_,
    540       base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_, true))) {
    541     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio",
    542                              audio_decoder_job_.get());
    543     return;
    544   }
    545 
    546   is_waiting_for_audio_decoder_ = true;
    547   if (!IsEventPending(DECODER_CREATION_EVENT_PENDING))
    548     SetPendingEvent(DECODER_CREATION_EVENT_PENDING);
    549 }
    550 
    551 void MediaSourcePlayer::DecodeMoreVideo() {
    552   DVLOG(1) << __FUNCTION__;
    553   DCHECK(!video_decoder_job_->is_decoding());
    554   DCHECK(!VideoFinished());
    555 
    556   if (video_decoder_job_->Decode(
    557       start_time_ticks_,
    558       start_presentation_timestamp_,
    559       base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_,
    560                  false))) {
    561     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreVideo",
    562                              video_decoder_job_.get());
    563     return;
    564   }
    565 
    566   // If the decoder is waiting for iframe, trigger a browser seek.
    567   if (!video_decoder_job_->next_video_data_is_iframe()) {
    568     BrowserSeekToCurrentTime();
    569     return;
    570   }
    571 
    572   is_waiting_for_video_decoder_ = true;
    573   if (!IsEventPending(DECODER_CREATION_EVENT_PENDING))
    574     SetPendingEvent(DECODER_CREATION_EVENT_PENDING);
    575 }
    576 
    577 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) {
    578   DVLOG(1) << __FUNCTION__ << "(" << is_audio << ")";
    579 
    580   if (AudioFinished() && VideoFinished()) {
    581     playing_ = false;
    582     clock_.Pause();
    583     start_time_ticks_ = base::TimeTicks();
    584     manager()->OnPlaybackComplete(player_id());
    585   }
    586 }
    587 
    588 void MediaSourcePlayer::ClearDecodingData() {
    589   DVLOG(1) << __FUNCTION__;
    590   audio_decoder_job_->Flush();
    591   video_decoder_job_->Flush();
    592   start_time_ticks_ = base::TimeTicks();
    593 }
    594 
    595 bool MediaSourcePlayer::HasVideo() {
    596   return video_decoder_job_->HasStream();
    597 }
    598 
    599 bool MediaSourcePlayer::HasAudio() {
    600   return audio_decoder_job_->HasStream();
    601 }
    602 
    603 bool MediaSourcePlayer::AudioFinished() {
    604   return audio_decoder_job_->OutputEOSReached() || !HasAudio();
    605 }
    606 
    607 bool MediaSourcePlayer::VideoFinished() {
    608   return video_decoder_job_->OutputEOSReached() || !HasVideo();
    609 }
    610 
    611 void MediaSourcePlayer::OnDecoderStarved() {
    612   DVLOG(1) << __FUNCTION__;
    613   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
    614   ProcessPendingEvents();
    615 }
    616 
    617 void MediaSourcePlayer::StartStarvationCallback(
    618     base::TimeDelta current_presentation_timestamp,
    619     base::TimeDelta max_presentation_timestamp) {
    620   // 20ms was chosen because it is the typical size of a compressed audio frame.
    621   // Anything smaller than this would likely cause unnecessary cycling in and
    622   // out of the prefetch state.
    623   const base::TimeDelta kMinStarvationTimeout =
    624       base::TimeDelta::FromMilliseconds(20);
    625 
    626   base::TimeDelta current_timestamp = GetCurrentTime();
    627   base::TimeDelta timeout;
    628   if (HasAudio()) {
    629     timeout = max_presentation_timestamp - current_timestamp;
    630   } else {
    631     DCHECK(current_timestamp <= current_presentation_timestamp);
    632 
    633     // For video only streams, fps can be estimated from the difference
    634     // between the previous and current presentation timestamps. The
    635     // previous presentation timestamp is equal to current_timestamp.
    636     // TODO(qinmin): determine whether 2 is a good coefficient for estimating
    637     // video frame timeout.
    638     timeout = 2 * (current_presentation_timestamp - current_timestamp);
    639   }
    640 
    641   timeout = std::max(timeout, kMinStarvationTimeout);
    642 
    643   decoder_starvation_callback_.Reset(
    644       base::Bind(&MediaSourcePlayer::OnDecoderStarved, weak_this_));
    645   base::MessageLoop::current()->PostDelayedTask(
    646       FROM_HERE, decoder_starvation_callback_.callback(), timeout);
    647 }
    648 
    649 bool MediaSourcePlayer::IsProtectedSurfaceRequired() {
    650   return video_decoder_job_->is_content_encrypted() &&
    651       drm_bridge_ && drm_bridge_->IsProtectedSurfaceRequired();
    652 }
    653 
    654 void MediaSourcePlayer::OnPrefetchDone() {
    655   DVLOG(1) << __FUNCTION__;
    656   DCHECK(!audio_decoder_job_->is_decoding());
    657   DCHECK(!video_decoder_job_->is_decoding());
    658 
    659   // A previously posted OnPrefetchDone() could race against a Release(). If
    660   // Release() won the race, we should no longer have decoder jobs.
    661   // TODO(qinmin/wolenetz): Maintain channel state to not double-request data
    662   // or drop data received across Release()+Start(). See http://crbug.com/306314
    663   // and http://crbug.com/304234.
    664   if (!IsEventPending(PREFETCH_DONE_EVENT_PENDING)) {
    665     DVLOG(1) << __FUNCTION__ << " : aborting";
    666     return;
    667   }
    668 
    669   ClearPendingEvent(PREFETCH_DONE_EVENT_PENDING);
    670 
    671   if (pending_event_ != NO_EVENT_PENDING) {
    672     ProcessPendingEvents();
    673     return;
    674   }
    675 
    676   if (!playing_)
    677     return;
    678 
    679   start_time_ticks_ = base::TimeTicks::Now();
    680   start_presentation_timestamp_ = GetCurrentTime();
    681   if (!clock_.IsPlaying())
    682     clock_.Play();
    683 
    684   if (!AudioFinished())
    685     DecodeMoreAudio();
    686 
    687   if (!VideoFinished())
    688     DecodeMoreVideo();
    689 }
    690 
    691 void MediaSourcePlayer::OnDemuxerConfigsChanged() {
    692   manager()->OnMediaMetadataChanged(
    693       player_id(), duration_, GetVideoWidth(), GetVideoHeight(), true);
    694 }
    695 
    696 const char* MediaSourcePlayer::GetEventName(PendingEventFlags event) {
    697   // Please keep this in sync with PendingEventFlags.
    698   static const char* kPendingEventNames[] = {
    699     "PREFETCH_DONE",
    700     "SEEK",
    701     "DECODER_CREATION",
    702     "PREFETCH_REQUEST",
    703   };
    704 
    705   int mask = 1;
    706   for (size_t i = 0; i < arraysize(kPendingEventNames); ++i, mask <<= 1) {
    707     if (event & mask)
    708       return kPendingEventNames[i];
    709   }
    710 
    711   return "UNKNOWN";
    712 }
    713 
    714 bool MediaSourcePlayer::IsEventPending(PendingEventFlags event) const {
    715   return pending_event_ & event;
    716 }
    717 
    718 void MediaSourcePlayer::SetPendingEvent(PendingEventFlags event) {
    719   DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")";
    720   DCHECK_NE(event, NO_EVENT_PENDING);
    721   DCHECK(!IsEventPending(event));
    722 
    723   pending_event_ |= event;
    724 }
    725 
    726 void MediaSourcePlayer::ClearPendingEvent(PendingEventFlags event) {
    727   DVLOG(1) << __FUNCTION__ << "(" << GetEventName(event) << ")";
    728   DCHECK_NE(event, NO_EVENT_PENDING);
    729   DCHECK(IsEventPending(event)) << GetEventName(event);
    730 
    731   pending_event_ &= ~event;
    732 }
    733 
    734 void MediaSourcePlayer::RetryDecoderCreation(bool audio, bool video) {
    735   if (audio)
    736     is_waiting_for_audio_decoder_ = false;
    737   if (video)
    738     is_waiting_for_video_decoder_ = false;
    739   if (IsEventPending(DECODER_CREATION_EVENT_PENDING))
    740     ProcessPendingEvents();
    741 }
    742 
    743 void MediaSourcePlayer::OnKeyAdded() {
    744   DVLOG(1) << __FUNCTION__;
    745   if (!is_waiting_for_key_)
    746     return;
    747 
    748   is_waiting_for_key_ = false;
    749   if (playing_)
    750     StartInternal();
    751 }
    752 
    753 void MediaSourcePlayer::OnCdmUnset() {
    754   DVLOG(1) << __FUNCTION__;
    755   // TODO(xhwang): Support detachment of CDM. This will be needed when we start
    756   // to support setMediaKeys(0) (see http://crbug.com/330324), or when we
    757   // release MediaDrm when the video is paused, or when the device goes to
    758   // sleep (see http://crbug.com/272421).
    759   NOTREACHED() << "CDM detachment not supported.";
    760   DCHECK(drm_bridge_);
    761   audio_decoder_job_->SetDrmBridge(NULL);
    762   video_decoder_job_->SetDrmBridge(NULL);
    763   drm_bridge_ = NULL;
    764 }
    765 
    766 }  // namespace media
    767