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 43 matching lines @@
                  weak_factory_.GetWeakPtr())));
   video_decoder_job_.reset(new VideoDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::VIDEO),
       base::Bind(request_media_resources_cb_, player_id),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
                  weak_factory_.GetWeakPtr())));
   demuxer_->Initialize(this);
   interpolator_.SetUpperBound(base::TimeDelta());
+  audible_state_idle_period_ = base::TimeDelta::FromMilliseconds(1000);
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
   DCHECK_EQ(!drm_bridge_, !cdm_registration_id_);
   if (drm_bridge_) {
     drm_bridge_->UnregisterPlayer(cdm_registration_id_);
     cdm_registration_id_ = 0;
   }
@@ skipping 113 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();
+  audible_audio_stopped_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 155 matching lines @@
 
   MediaDecoderJob::MediaDecoderJobStatus status = audio_decoder_job_->Decode(
       start_time_ticks_,
       start_presentation_timestamp_,
       base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_, true));
 
   switch (status) {
     case MediaDecoderJob::STATUS_SUCCESS:
       TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSourcePlayer::DecodeMoreAudio",
                                audio_decoder_job_.get());
+      UpdateAudibleStatus();
       break;
     case MediaDecoderJob::STATUS_KEY_FRAME_REQUIRED:
       NOTREACHED();
       break;
     case MediaDecoderJob::STATUS_FAILURE:
       is_waiting_for_audio_decoder_ = true;
       if (!IsEventPending(DECODER_CREATION_EVENT_PENDING))
         SetPendingEvent(DECODER_CREATION_EVENT_PENDING);
       break;
   }
 }
 
+void MediaSourcePlayer::SetAudibleStateIdlePeriod(base::TimeDelta duration) {
+  audible_state_idle_period_ = duration;
+}
+
+void MediaSourcePlayer::UpdateAudibleStatus() {

[qinmin, 2015/03/19 23:34:23]

I don't think we really need a timer for this. We can just wait for the decoder
callback and update the audible status. 
If we really want to be very accurate, we need to monitor the number of
remaining bytes in the AudioTrack object, rather than using a timer. 
For example, if the AudioDecoder is blocked on the AudioTrack while writing a
large chunk of data, the timer may expire and signal an idle state. However,
that is not really true since there are data in the AudioTrack

+  SetAudible(audio_decoder_job_->GetVolume() > 0);
+
+  audible_audio_stopped_callback_.Cancel();
+
+  audible_audio_stopped_callback_.Reset(
+      base::Bind(&MediaSourcePlayer::SetAudible, weak_this_, false));
+
+  DCHECK(audible_state_idle_period_ > base::TimeDelta());
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, audible_audio_stopped_callback_.callback(),
+      audible_state_idle_period_);
+}
+
 void MediaSourcePlayer::DecodeMoreVideo() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(!video_decoder_job_->is_decoding());
   DCHECK(!VideoFinished());
 
   MediaDecoderJob::MediaDecoderJobStatus status = video_decoder_job_->Decode(
       start_time_ticks_,
       start_presentation_timestamp_,
       base::Bind(&MediaSourcePlayer::MediaDecoderCallback, weak_this_,
                  false));
@@ skipping 217 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