Decouple 'give me more data' and 'rendered end of stream' audio callbacks.

content/renderer/media/audio_renderer_impl.cc

 // Copyright (c) 2012 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 "content/renderer/media/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_buffers_state.h"
 #include "media/audio/audio_util.h"
 #include "media/base/filter_host.h"
 
+using base::subtle::AtomicWord;
+
 // We define GetBufferSizeForSampleRate() instead of using
 // GetAudioHardwareBufferSize() in audio_util because we're using
 // the AUDIO_PCM_LINEAR flag, instead of AUDIO_PCM_LOW_LATENCY,
 // which the audio_util functions assume.
 //
 // See: http://code.google.com/p/chromium/issues/detail?id=103627
 // for a more detailed description of the subtleties.
 static size_t GetBufferSizeForSampleRate(int sample_rate) {
   // kNominalBufferSize has been tested on Windows, Mac OS X, and Linux
   // using the low-latency audio codepath (SyncSocket implementation)
   // with the AUDIO_PCM_LINEAR flag.
   const size_t kNominalBufferSize = 2048;
 
   if (sample_rate <= 48000)
     return kNominalBufferSize;
   else if (sample_rate <= 96000)
     return kNominalBufferSize * 2;
   return kNominalBufferSize * 4;
 }
 
 AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
     : AudioRendererBase(),
       bytes_per_second_(0),
       stopped_(false),
       sink_(sink),
-      is_initialized_(false) {
+      is_initialized_(false),
+      ended_event_scheduled_(false),
+      io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
+      stream_id_(0) {
 }
 
 AudioRendererImpl::~AudioRendererImpl() {
 }
 
 base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
   if (bytes_per_second_) {
     return base::TimeDelta::FromMicroseconds(
         base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second_);
   }
   return base::TimeDelta();
 }
 
 void AudioRendererImpl::UpdateEarliestEndTime(int bytes_filled,
                                               base::TimeDelta request_delay,
                                               base::Time time_now) {
   if (bytes_filled != 0) {
     base::TimeDelta predicted_play_time = ConvertToDuration(bytes_filled);
     float playback_rate = GetPlaybackRate();
     if (playback_rate != 1.0f) {
       predicted_play_time = base::TimeDelta::FromMicroseconds(
           static_cast<int64>(ceil(predicted_play_time.InMicroseconds() *
                                   playback_rate)));
     }
-    earliest_end_time_ =
+    set_earliest_end_time(
         std::max(earliest_end_time_,
-                 time_now + request_delay + predicted_play_time);
+                 time_now + request_delay + predicted_play_time));
   }
 }
 
 bool AudioRendererImpl::OnInitialize(int bits_per_channel,
                                      ChannelLayout channel_layout,
                                      int sample_rate) {
   // We use the AUDIO_PCM_LINEAR flag because AUDIO_PCM_LOW_LATENCY
   // does not currently support all the sample-rates that we require.
   // Please see: http://code.google.com/p/chromium/issues/detail?id=103627
   // for more details.
@@ skipping 84 matching lines @@
 }
 
 void AudioRendererImpl::SetVolume(float volume) {
   if (stopped_)
     return;
   DCHECK(sink_.get());
   sink_->SetVolume(volume);
 }
 
 void AudioRendererImpl::DoPlay() {
-  earliest_end_time_ = base::Time::Now();
+  set_earliest_end_time(base::Time::Now());
+  ended_event_scheduled_ = false;
   DCHECK(sink_.get());
   sink_->Play();
 }
 
 void AudioRendererImpl::DoPause() {
+  ++stream_id_;
   DCHECK(sink_.get());
   sink_->Pause(false);
 }
 
 void AudioRendererImpl::DoSeek() {
-  earliest_end_time_ = base::Time::Now();
+  set_earliest_end_time(base::Time::Now());
+  ended_event_scheduled_ = false;
+  ++stream_id_;
 
   // Pause and flush the stream when we seek to a new location.
   DCHECK(sink_.get());
   sink_->Pause(true);
 }
 
 size_t AudioRendererImpl::Render(const std::vector<float*>& audio_data,
                                  size_t number_of_frames,
                                  size_t audio_delay_milliseconds) {
   if (stopped_ || GetPlaybackRate() == 0.0f) {
     // Output silence if stopped.
     for (size_t i = 0; i < audio_data.size(); ++i)
-      memset(audio_data[i], 0, sizeof(float) * number_of_frames);
+      memset(audio_data[i], 0, sizeof(audio_data[i][0]) * number_of_frames);
     return 0;
   }
 
   // Adjust the playback delay.
   base::TimeDelta request_delay =
       base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
 
   // Finally we need to adjust the delay according to playback rate.
   if (GetPlaybackRate() != 1.0f) {
     request_delay = base::TimeDelta::FromMicroseconds(
@@ skipping 21 matching lines @@
                                     channels,
                                     channel_index,
                                     bytes_per_frame / channels,
                                     filled_frames);
 
     // If FillBuffer() didn't give us enough data then zero out the remainder.
     if (filled_frames < number_of_frames) {
       int frames_to_zero = number_of_frames - filled_frames;
       memset(audio_data[channel_index] + filled_frames,
              0,
-             sizeof(float) * frames_to_zero);
+             sizeof(audio_data[channel_index][0]) * frames_to_zero);
     }
   }
   return filled_frames;
 }
 
 void AudioRendererImpl::OnError() {
   host()->DisableAudioRenderer();
 }
 
+int64 AudioRendererImpl::OnRenderEndOfStreamDelay() {
+  return (earliest_end_time() - base::Time::Now()).InMilliseconds();
+}
+
 void AudioRendererImpl::OnRenderEndOfStream() {
-  // TODO(enal): schedule callback instead of polling.
-  if (base::Time::Now() >= earliest_end_time_)
+  if (!ended_event_scheduled_) {
+    ended_event_scheduled_ = true;
+    int64 delay_ms = OnRenderEndOfStreamDelay();
+    if (delay_ms <= 0) {
+      DoSignalEndOfStream(stream_id_);
+    } else {
+      io_message_loop_proxy_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&AudioRendererImpl::DoSignalEndOfStream, this, stream_id_),
+          delay_ms);
+    }
+  }
+}
+
+void AudioRendererImpl::DoSignalEndOfStream(AtomicWord stream_id) {
+  // There is no way to cancel delayed task if we paused or seeked after task
+  // was scheduled, use stream id to catch such case.
+  if (stream_id == stream_id_)
     SignalEndOfStream();
 }