Determine the audible state in MediaSourcePlayer

media/base/android/media_source_player.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/android/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 176 matching lines @@
 void MediaSourcePlayer::Release() {
   DVLOG(1) << __FUNCTION__;
 
   audio_decoder_job_->ReleaseDecoderResources();
   video_decoder_job_->ReleaseDecoderResources();
 
   // Prevent player restart, including job re-creation attempts.
   playing_ = false;
 
   decoder_starvation_callback_.Cancel();
+
+  SetAudible(false);
   DetachListener();
 }
 
 void MediaSourcePlayer::SetVolume(double volume) {
   audio_decoder_job_->SetVolume(volume);
 }
 
 bool MediaSourcePlayer::CanPause() {
   return Seekable();
 }
@@ skipping 24 matching lines @@
   AttachListener(NULL);
 
   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::OnDemuxerConfigsAvailable(
     const DemuxerConfigs& configs) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!HasAudio() && !HasVideo());
+
   duration_ = configs.duration;
 
   audio_decoder_job_->SetDemuxerConfigs(configs);
   video_decoder_job_->SetDemuxerConfigs(configs);
   OnDemuxerConfigsChanged();
 }
 
 void MediaSourcePlayer::OnDemuxerDataAvailable(const DemuxerData& data) {
   DVLOG(1) << __FUNCTION__ << "(" << data.type << ")";
   DCHECK_LT(0u, data.access_units.size());
@@ skipping 141 matching lines @@
 
   if (IsEventPending(DECODER_CREATION_EVENT_PENDING)) {
     // Don't continue if one of the decoder is not created.
     if (is_waiting_for_audio_decoder_ || is_waiting_for_video_decoder_)
       return;
     ClearPendingEvent(DECODER_CREATION_EVENT_PENDING);
   }
 
   if (IsEventPending(PREFETCH_REQUEST_EVENT_PENDING)) {
     DVLOG(1) << __FUNCTION__ << " : Handling PREFETCH_REQUEST_EVENT.";
+
     int count = (AudioFinished() ? 0 : 1) + (VideoFinished() ? 0 : 1);
 
     // It is possible that all streams have finished decode, yet starvation
     // occurred during the last stream's EOS decode. In this case, prefetch is a
     // no-op.
     ClearPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
     if (count == 0)
       return;
 
     SetPendingEvent(PREFETCH_DONE_EVENT_PENDING);
@@ skipping 74 matching lines @@
     PlaybackCompleted(is_audio);
     if (is_clock_manager)
       interpolator_.StopInterpolating();
   }
 
   if (pending_event_ != NO_EVENT_PENDING) {
     ProcessPendingEvents();
     return;
   }
 
-  if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
+  if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
+    if (is_audio)
+      SetAudible(false);
     return;
+  }
 
   if (!playing_) {
     if (is_clock_manager)
       interpolator_.StopInterpolating();
+
+    if (is_audio)
+      SetAudible(false);
     return;
   }
 
   if (status == MEDIA_CODEC_NO_KEY) {
     if (key_added_while_decode_pending_) {
       DVLOG(2) << __FUNCTION__ << ": Key was added during decoding.";
       ResumePlaybackAfterKeyAdded();
     } else {

[qinmin, 2015/03/24 21:38:37]

we need setAudible(false) here too

[Tima Vaisburd, 2015/03/24 22:24:50]

Done.

       is_waiting_for_key_ = true;
       manager()->OnWaitingForDecryptionKey(player_id());
     }
     return;
   }
 
   // If |key_added_while_decode_pending_| is true and both audio and video
   // decoding succeeded, we should clear |key_added_while_decode_pending_| here.
   // But that would add more complexity into this function. If we don't clear it
   // here, the worst case would be we call ResumePlaybackAfterKeyAdded() when
   // we don't really have a new key. This should rarely happen and the
   // performance impact should be pretty small.
   // TODO(qinmin/xhwang): This class is complicated because we handle both audio
   // and video in one file. If we separate them, we should be able to remove a
   // lot of duplication.
 
   // If the status is MEDIA_CODEC_ABORT, stop decoding new data. The player is
   // in the middle of a seek or stop event and needs to wait for the IPCs to
   // come.
-  if (status == MEDIA_CODEC_ABORT)
+  if (status == MEDIA_CODEC_ABORT) {
+    if (is_audio)
+      SetAudible(false);
     return;
+  }
 
   if (prerolling_ && IsPrerollFinished(is_audio)) {
     if (IsPrerollFinished(!is_audio)) {
       prerolling_ = false;
       StartInternal();
     }
     return;
   }
 
+  // We successfully decoded a frame and going to the next one.
+  // Set the audible state.
+  if (is_audio) {
+    bool is_audible = !prerolling_ && audio_decoder_job_->GetVolume() > 0;
+    SetAudible(is_audible);
+  }
+
   if (is_clock_manager) {
     // If we have a valid timestamp, start the starvation callback. Otherwise,
     // reset the |start_time_ticks_| so that the next frame will not suffer
     // from the decoding delay caused by the current frame.
     if (current_presentation_timestamp != kNoTimestamp())
       StartStarvationCallback(current_presentation_timestamp,
                               max_presentation_timestamp);
     else
       start_time_ticks_ = base::TimeTicks::Now();
   }
@@ skipping 91 matching lines @@
 bool MediaSourcePlayer::AudioFinished() {
   return audio_decoder_job_->OutputEOSReached() || !HasAudio();
 }
 
 bool MediaSourcePlayer::VideoFinished() {
   return video_decoder_job_->OutputEOSReached() || !HasVideo();
 }
 
 void MediaSourcePlayer::OnDecoderStarved() {
   DVLOG(1) << __FUNCTION__;
+
+  if (HasAudio()) {
+    // If the starvation timer fired but there are no encoded frames
+    // in the queue we believe the demuxer (i.e. renderer process) froze.
+    if (!audio_decoder_job_->HasData()) {

[qinmin, 2015/03/24 21:38:37]

no {} needed

[Tima Vaisburd, 2015/03/24 22:24:50]

Done.

+      SetAudible(false);
+    }
+  }
+
   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::StartStarvationCallback(
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
   // 20ms was chosen because it is the typical size of a compressed audio frame.
   // Anything smaller than this would likely cause unnecessary cycling in and
   // out of the prefetch state.
@@ skipping 155 matching lines @@
   // support setMediaKeys(0) (see http://crbug.com/330324), or when we release
   // MediaDrm when the video is paused, or when the device goes to sleep (see
   // http://crbug.com/272421).
   audio_decoder_job_->SetDrmBridge(NULL);
   video_decoder_job_->SetDrmBridge(NULL);
   cdm_registration_id_ = 0;
   drm_bridge_ = NULL;
 }
 
 }  // namespace media