Add chromium support for MediaStreamAudioDestinationNode

content/renderer/media/webrtc_audio_capturer.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/webrtc_audio_capturer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 82 matching lines @@
   base::AutoLock auto_lock(lock_);
   for (SinkList::iterator it = sinks_.begin(); it != sinks_.end(); ++it) {
     if (sink == *it) {
       sinks_.erase(it);
       break;
     }
   }
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
-    const scoped_refptr<media::AudioCapturerSource>& source) {
+    const scoped_refptr<media::AudioCapturerSource>& source,
+    media::ChannelLayout channel_layout,
+    float sample_rate) {
   DVLOG(1) <<  "SetCapturerSource()";
   scoped_refptr<media::AudioCapturerSource> old_source;
   {
     base::AutoLock auto_lock(lock_);
     if (source_ == source)
       return;
 
     source_.swap(old_source);
     source_ = source;
   }
 
   // Detach the old source from normal recording.
-  if (old_source)
+  if (old_source) {
     old_source->Stop();
 
+    // Dispatch the new parameters both to the
+    // sink(s) and to the new source. The idea is to get rid of any dependency
+    // of the microphone parameters which are used as base otherwise.
+
+    // henrika:

[henrika (OOO until Aug 14), 2013/01/08 09:52:27]

Guess we could clean up here now. Also, I did not spend any on the locking in my
first proposal. Guess it needs some attention as well.

[Chris Rogers, 2013/01/14 23:12:14]

Done.

+    // I guess we could add this info to AudioCapturerSource to enable a
+    // query here. E.g.:
+    // source->ModifyAudioParameters(&params_);
+    //
+    // crogers: we could do as you suggest, but instead I've modified
+    // SetCapturerSource() to take the |channel_layout| and |sample_rate|.
+    // Neither solution seems that great, since we just end up calling
+    // source->Initialize(params_, this, this);
+    // anyway, but we have to do something...
+
+    params_.Reset(params_.format(),

[henrika (OOO until Aug 14), 2013/01/08 09:52:27]

I had anticipated that the sample rate would be the rate of the (file) source,
i.e., 44.1 in our example. It now seems like you use the native hardware rate
and resample the source to this rate; correct?

I guess that works as well, but in any case, the hard-coded size of 440 must be
modified (se below). I have tried it using 44.1, 48 and 96 on my Win 7 machine
and it works well.


int buffer_size = GetBufferSizeForSampleRate(sample_rate);
if (!buffer_size) {
  DLOG(ERROR) << "Unsupported platform";
  return;
}

params_.Reset(params_.format(),
              channel_layout,
              sample_rate,
              16,  // this value is not really used
              buffer_size); <<<==========

[Chris Rogers, 2013/01/14 23:12:14]

The sample-rate will generally be the hardware sample-rate (what the WebAudio
AudioContext uses for all processing).  All <audio> tags and AudioBuffers are
internally already sample-rate converted to this hardware sample-rate in WebKit.

I've fixed the code as you suggest to account for the sample-rate when computing
|buffer_size|.

+                  channel_layout,
+                  sample_rate,
+                  16,  // this value is not really used
+                  440); // requires knowledge about WebRTC @ 10ms

[henrika (OOO until Aug 14), 2013/01/07 10:14:28]

Chris, what range of sample rates can we expect from WebAudio? WebRTC does not
support ant rate. As an example, a rate of 11025 or 22050 will fail.

[Chris Rogers, 2013/01/14 23:12:14]

It will be the hardware sample-rate that the AudioContext uses.  This is
normally the same as what the rest of WebRTC uses, as I understand.

+
+    buffer_.reset(new int16[params_.frames_per_buffer() * params_.channels()]);
+
+    for (SinkList::const_iterator it = sinks_.begin();
+         it != sinks_.end(); ++it) {
+      (*it)->SetCaptureFormat(params_);
+    }
+  }
+
   if (source)
     source->Initialize(params_, this, this);
 }
 
 void WebRtcAudioCapturer::SetStopCallback(
     const base::Closure& on_device_stopped_cb) {
   DVLOG(1) <<  "WebRtcAudioCapturer::SetStopCallback()";
   base::AutoLock auto_lock(lock_);
   on_device_stopped_cb_ = on_device_stopped_cb;
 }
@@ skipping 76 matching lines @@
     return false;
   }
 
   params_.Reset(format, channel_layout, sample_rate, 16, buffer_size);
 
   buffer_.reset(new int16[params_.frames_per_buffer() * params_.channels()]);
 
   // Create and configure the default audio capturing source. The |source_|
   // will be overwritten if the client call the source calls
   // SetCapturerSource().
-  SetCapturerSource(AudioDeviceFactory::NewInputDevice());
+  SetCapturerSource(
+      AudioDeviceFactory::NewInputDevice(), channel_layout, sample_rate);
 
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
                             channel_layout, media::CHANNEL_LAYOUT_MAX);
 
   return true;
 }
 
 void WebRtcAudioCapturer::ProvideInput(media::AudioBus* dest) {
   base::AutoLock auto_lock(lock_);
   DCHECK(loopback_fifo_.get() != NULL);
@@ skipping 144 matching lines @@
   // Inform the local renderer about the stopped device.
   // The renderer can then save resources by not asking for more data from
   // the stopped source. We are on the IO thread but the callback task will
   // be posted on the message loop of the main render thread thanks to
   // usage of BindToLoop() when the callback was initialized.
   if (!on_device_stopped_cb_.is_null())
     on_device_stopped_cb_.Run();
 }
 
 }  // namespace content