Feed the render data to MediaStreamAudioProcessor and used AudioBus in render callback

content/renderer/media/webrtc_audio_device_impl.cc

 // Copyright 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 "content/renderer/media/webrtc_audio_device_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/win/windows_version.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_parameters.h"
 #include "media/audio/sample_rates.h"
 
 using media::AudioParameters;
 using media::ChannelLayout;
 
 namespace content {
 
 WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()
     : ref_count_(0),
       audio_transport_callback_(NULL),
       input_delay_ms_(0),
       output_delay_ms_(0),
       initialized_(false),
       playing_(false),
       recording_(false),
-      microphone_volume_(0) {
+      microphone_volume_(0),
+      render_buffer_size_(0) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::WebRtcAudioDeviceImpl()";
 }
 
 WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl() {
   DVLOG(1) << "WebRtcAudioDeviceImpl::~WebRtcAudioDeviceImpl()";
   DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
 }
 
 int32_t WebRtcAudioDeviceImpl::AddRef() {
@@ skipping 73 matching lines @@
   }
 
   return new_volume;
 }
 
 void WebRtcAudioDeviceImpl::OnSetFormat(
     const media::AudioParameters& params) {
   DVLOG(1) << "WebRtcAudioDeviceImpl::OnSetFormat()";
 }
 
-void WebRtcAudioDeviceImpl::RenderData(uint8* audio_data,
-                                       int number_of_channels,
-                                       int number_of_frames,
+void WebRtcAudioDeviceImpl::RenderData(media::AudioBus* audio_bus,
+                                       int sample_rate,
                                        int audio_delay_milliseconds) {
-  DCHECK_LE(number_of_frames, output_buffer_size());
+  if (!render_buffer_ ||

[miu, 2014/01/24 22:27:19]

You could simplify a lot here if render_buffer_ were a std::vector<int16>. 
These 5 lines of code would become one:

  render_buffer_.resize(audio_bus->frames() * audio_bus->channels());

+      render_buffer_size_ != (audio_bus->frames() * audio_bus->channels())) {
+    render_buffer_size_ = audio_bus->frames() * audio_bus->channels();
+    render_buffer_.reset(new int16[render_buffer_size_]);
+  }
+
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(audio_transport_callback_);
     // Store the reported audio delay locally.
     output_delay_ms_ = audio_delay_milliseconds;
   }
 
-  const int channels = number_of_channels;
-  DCHECK_LE(channels, output_channels());
-
-  int samples_per_sec = output_sample_rate();
-  int samples_per_10_msec = (samples_per_sec / 100);
-  int bytes_per_sample = output_audio_parameters_.bits_per_sample() / 8;
+  int samples_per_10_msec = (sample_rate / 100);
+  int bytes_per_sample = 2;

[miu, 2014/01/24 22:27:19]

Replace 2 with sizeof(int16).

[no longer working on chromium, 2014/01/27 17:09:33]

Done with changing it to sizeof(render_buffer_[0]);

   const int bytes_per_10_msec =
-      channels * samples_per_10_msec * bytes_per_sample;
-
-  uint32_t num_audio_samples = 0;
-  int accumulated_audio_samples = 0;
+      audio_bus->channels() * samples_per_10_msec * bytes_per_sample;
+  DCHECK_EQ(audio_bus->frames() % samples_per_10_msec, 0);
 
   // Get audio samples in blocks of 10 milliseconds from the registered
   // webrtc::AudioTransport source. Keep reading until our internal buffer
   // is full.
-  while (accumulated_audio_samples < number_of_frames) {
+  uint32_t num_audio_samples = 0;
+  int accumulated_audio_samples = 0;
+  int16* audio_data = render_buffer_.get();
+  while (accumulated_audio_samples < audio_bus->frames()) {
     // Get 10ms and append output to temporary byte buffer.
     audio_transport_callback_->NeedMorePlayData(samples_per_10_msec,
                                                 bytes_per_sample,
-                                                channels,
-                                                samples_per_sec,
+                                                audio_bus->channels(),
+                                                sample_rate,
                                                 audio_data,
                                                 num_audio_samples);
     accumulated_audio_samples += num_audio_samples;
     audio_data += bytes_per_10_msec;
   }
-}
 
-void WebRtcAudioDeviceImpl::SetRenderFormat(const AudioParameters& params) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  output_audio_parameters_ = params;
+  // De-interleave each channel and convert to 32-bit floating-point
+  // with nominal range -1.0 -> +1.0 to match the callback format.
+  audio_bus->FromInterleaved(render_buffer_.get(),
+                             audio_bus->frames(),
+                             bytes_per_sample);
+
+  // Pass the render data to the observers.
+  base::AutoLock auto_lock(lock_);
+  for (RenderDataObservers::const_iterator it = render_data_observers_.begin();
+       it != render_data_observers_.end(); ++it) {
+    (*it)->RenderData(audio_bus, sample_rate, audio_delay_milliseconds);
+  }
 }
 
 void WebRtcAudioDeviceImpl::RemoveAudioRenderer(WebRtcAudioRenderer* renderer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(renderer, renderer_);
   base::AutoLock auto_lock(lock_);
   renderer_ = NULL;
   playing_ = false;
 }
 
@@ skipping 185 matching lines @@
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::MinMicrophoneVolume(uint32_t* min_volume) const {
   *min_volume = 0;
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoPlayoutIsAvailable(bool* available) const {
   DCHECK(initialized_);
-  *available = (output_channels() == 2);
+  *available = renderer_ ? (renderer_->channels() == 2) : false;

[miu, 2014/01/24 22:27:19]

For my own curiosity: What if renderer_->channels() is more than 2 (e.g., 5.1
sound)?

[no longer working on chromium, 2014/01/27 17:09:33]

The playout of the webrtc only supports mono and stereo so far.

   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::StereoRecordingIsAvailable(
     bool* available) const {
   DCHECK(initialized_);
   // TODO(xians): These kind of hardware methods do not make much sense since we
   // support multiple sources. Remove or figure out new APIs for such methods.
   scoped_refptr<WebRtcAudioCapturer> capturer(GetDefaultCapturer());
   if (!capturer.get())
@@ skipping 22 matching lines @@
   if (!capturer.get())
     return -1;
 
   *samples_per_sec = static_cast<uint32_t>(
       capturer->source_audio_parameters().sample_rate());
   return 0;
 }
 
 int32_t WebRtcAudioDeviceImpl::PlayoutSampleRate(
     uint32_t* samples_per_sec) const {
-  *samples_per_sec = static_cast<uint32_t>(output_sample_rate());
+  *samples_per_sec = renderer_ ? renderer_->sample_rate() : 0;
   return 0;
 }
 
 bool WebRtcAudioDeviceImpl::SetAudioRenderer(WebRtcAudioRenderer* renderer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(renderer);
 
   base::AutoLock auto_lock(lock_);
   if (renderer_.get())
     return false;
@@ skipping 32 matching lines @@
   // Use the last |capturer| which is from the latest getUserMedia call as
   // the default capture device.
   for (CapturerList::const_reverse_iterator iter = capturers_.rbegin();
        iter != capturers_.rend(); ++iter) {
     return *iter;
   }
 
   return NULL;
 }
 
+void WebRtcAudioDeviceImpl::AddRenderDataObserver(
+    WebRtcAudioRendererSource* observer) {
+  DCHECK(observer);
+  base::AutoLock auto_lock(lock_);
+  DCHECK(std::find(render_data_observers_.begin(),
+                   render_data_observers_.end(),
+                   observer) == render_data_observers_.end());
+  render_data_observers_.push_back(observer);
+}
+
+void WebRtcAudioDeviceImpl::RemoveRenderDataObserver(
+    WebRtcAudioRendererSource* observer) {
+  DCHECK(observer);
+  base::AutoLock auto_lock(lock_);
+  render_data_observers_.remove(observer);
+}
+
 bool WebRtcAudioDeviceImpl::GetAuthorizedDeviceInfoForAudioRenderer(
     int* session_id,
     int* output_sample_rate,
     int* output_frames_per_buffer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If there is no capturer or there are more than one open capture devices,
   // return false.
   if (capturers_.empty() || capturers_.size() > 1)
     return false;
 
   return GetDefaultCapturer()->GetPairedOutputParameters(
       session_id, output_sample_rate, output_frames_per_buffer);
 }
 
 }  // namespace content