Ensures that WebRTC works for device selection using a different sample rate than default

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 26 matching lines @@
   int buffer_size = 0;
 #if defined(OS_WIN) || defined(OS_MACOSX)
   // Use different buffer sizes depending on the current hardware sample rate.
   if (sample_rate == 44100) {
     // We do run at 44.1kHz at the actual audio layer, but ask for frames
     // at 44.0kHz to ensure that we can feed them to the webrtc::VoiceEngine.
     buffer_size = 440;
   } else {
     buffer_size = (sample_rate / 100);
     DCHECK_EQ(buffer_size * 100, sample_rate) <<
-        "Sample rate not supported. Should have been caught in Init().";
+        "Sample rate not supported";
   }
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
   // Based on tests using the current ALSA implementation in Chrome, we have
   // found that the best combination is 20ms on the input side and 10ms on the
   // output side.
   // TODO(henrika): It might be possible to reduce the input buffer
   // size and reduce the delay even more.
   buffer_size = 2 * sample_rate / 100;
 #endif
 
   return buffer_size;
 }
 
 // static
 scoped_refptr<WebRtcAudioCapturer> WebRtcAudioCapturer::CreateCapturer() {
   scoped_refptr<WebRtcAudioCapturer> capturer = new  WebRtcAudioCapturer();
-  if (capturer->Initialize())
-    return capturer;
+  return capturer;
+}
 
-  return NULL;
+bool WebRtcAudioCapturer::Initialize(media::ChannelLayout channel_layout,
+                                     int sample_rate) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(!sinks_.empty());
+  DVLOG(1) << "WebRtcAudioCapturer::Initialize()";
+
+  media::AudioParameters::Format format =
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
+
+  DVLOG(1) << "Audio input hardware channel layout: " << channel_layout;
+  UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
+                            channel_layout, media::CHANNEL_LAYOUT_MAX);
+
+  DVLOG(1) << "Audio input hardware sample rate: " << sample_rate;
+  UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputSampleRate",
+                            sample_rate, media::kUnexpectedAudioSampleRate);
+
+  // Verify that the reported input hardware sample rate is supported
+  // on the current platform.
+  if (std::find(&kValidInputRates[0],
+                &kValidInputRates[0] + arraysize(kValidInputRates),
+                sample_rate) ==
+          &kValidInputRates[arraysize(kValidInputRates)]) {
+    DLOG(ERROR) << sample_rate << " is not a supported input rate.";
+    return false;

[Chris Evans, 2013/01/23 09:39:04]

I see that sample_rate is carefully validated in this function, but
channel_layout is not? Seems inconsistent.

[henrika (OOO until Aug 14), 2013/01/23 10:25:40]

Good point. Will improve before committing. Thanks. 

+  }
+
+  int buffer_size = GetBufferSizeForSampleRate(sample_rate);
+
+  // Configure audio parameters for the default source.
+  params_.Reset(format, channel_layout, sample_rate, 16, buffer_size);
+
+  // Tell all sinks which format we use.
+  for (SinkList::const_iterator it = sinks_.begin();
+    it != sinks_.end(); ++it) {
+      (*it)->SetCaptureFormat(params_);
+  }
+
+  buffer_.reset(new int16[params_.frames_per_buffer() * params_.channels()]);
+
+  // Create and configure the default audio capturing source. The |source_|
+  // will be overwritten if an external client later calls SetCapturerSource()
+  // providing an alternaive media::AudioCapturerSource.
+  SetCapturerSource(AudioDeviceFactory::NewInputDevice(),
+                    channel_layout,
+                    static_cast<float>(sample_rate));
+
+  return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer()
     : source_(NULL),
       running_(false),
       buffering_(false) {
+  DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
 
 WebRtcAudioCapturer::~WebRtcAudioCapturer() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(sinks_.empty());
   DCHECK(!loopback_fifo_);
+  DVLOG(1) << "WebRtcAudioCapturer::~WebRtcAudioCapturer()";
 }
 
 void WebRtcAudioCapturer::AddCapturerSink(WebRtcAudioCapturerSink* sink) {
-  {
-    base::AutoLock auto_lock(lock_);
-    DCHECK(std::find(sinks_.begin(), sinks_.end(), sink) == sinks_.end());
-    sinks_.push_back(sink);
-  }
-
-  // Tell the |sink| which format we use.
-  sink->SetCaptureFormat(params_);
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "WebRtcAudioCapturer::AddCapturerSink()";
+  base::AutoLock auto_lock(lock_);
+  DCHECK(std::find(sinks_.begin(), sinks_.end(), sink) == sinks_.end());
+  sinks_.push_back(sink);
 }
 
 void WebRtcAudioCapturer::RemoveCapturerSink(WebRtcAudioCapturerSink* sink) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "WebRtcAudioCapturer::RemoveCapturerSink()";
   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,
     media::ChannelLayout channel_layout,
     float sample_rate) {
-  DVLOG(1) <<  "SetCapturerSource()";
+  DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
+           << "sample_rate=" << sample_rate << ")";
   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) {
-    old_source->Stop();
+  const bool no_default_audio_source_exists = !buffer_.get();
+
+  // Detach the old source from normal recording or perform first-time
+  // initialization if Initialize() has never been called. For the second
+  // case, the caller is not "taking over an ongoing session" but instead
+  // "taking control over a new session".
+  if (old_source || no_default_audio_source_exists) {
+    DVLOG(1) << "New capture source will now be utilized.";
+    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 would normally be used by default.
 
     int buffer_size = GetBufferSizeForSampleRate(sample_rate);
     if (!buffer_size) {
       DLOG(ERROR) << "Unsupported sample-rate: " << sample_rate;
       return;
     }
@@ skipping 11 matching lines @@
       (*it)->SetCaptureFormat(params_);
     }
   }
 
   if (source)
     source->Initialize(params_, this, this);
 }
 
 void WebRtcAudioCapturer::SetStopCallback(
     const base::Closure& on_device_stopped_cb) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) <<  "WebRtcAudioCapturer::SetStopCallback()";
   base::AutoLock auto_lock(lock_);
   on_device_stopped_cb_ = on_device_stopped_cb;
 }
 
 void WebRtcAudioCapturer::PrepareLoopback() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) <<  "WebRtcAudioCapturer::PrepareLoopback()";
   base::AutoLock auto_lock(lock_);
   DCHECK(!loopback_fifo_);
 
   // TODO(henrika): we could add a more dynamic solution here but I prefer
   // a fixed size combined with bad audio at overflow. The alternative is
   // that we start to build up latency and that can be more difficult to
   // detect. Tests have shown that the FIFO never contains more than 2 or 3
   // audio frames but I have selected a max size of ten buffers just
   // in case since these tests were performed on a 16 core, 64GB Win 7
   // machine. We could also add some sort of error notifier in this area if
   // the FIFO overflows.
   loopback_fifo_.reset(new media::AudioFifo(params_.channels(),
                        10 * params_.frames_per_buffer()));
   buffering_ = true;
 }
 
 void WebRtcAudioCapturer::CancelLoopback() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) <<  "WebRtcAudioCapturer::CancelLoopback()";
   base::AutoLock auto_lock(lock_);
   buffering_ = false;
   if (loopback_fifo_.get() != NULL) {
     loopback_fifo_->Clear();
     loopback_fifo_.reset();
   }
 }
 
 void WebRtcAudioCapturer::PauseBuffering() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) <<  "WebRtcAudioCapturer::PauseBuffering()";
   base::AutoLock auto_lock(lock_);
   buffering_ = false;
 }
 
 void WebRtcAudioCapturer::ResumeBuffering() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) <<  "WebRtcAudioCapturer::ResumeBuffering()";
   base::AutoLock auto_lock(lock_);
   if (buffering_)
     return;
   if (loopback_fifo_.get() != NULL)
     loopback_fifo_->Clear();
   buffering_ = true;
 }
 
-bool WebRtcAudioCapturer::Initialize() {
-  DVLOG(1) << "WebRtcAudioCapturer::Initialize()";
-  // Ask the browser for the default audio input hardware sample-rate.
-  // This request is based on a synchronous IPC message.
-  // TODO(xians): we should ask for the native sample rate of a specific device.
-  int sample_rate = GetAudioInputSampleRate();
-  DVLOG(1) << "Audio input hardware sample rate: " << sample_rate;
-  UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputSampleRate",
-                            sample_rate, media::kUnexpectedAudioSampleRate);
-
-  // Verify that the reported input hardware sample rate is supported
-  // on the current platform.
-  if (std::find(&kValidInputRates[0],
-                &kValidInputRates[0] + arraysize(kValidInputRates),
-                sample_rate) ==
-          &kValidInputRates[arraysize(kValidInputRates)]) {
-    DLOG(ERROR) << sample_rate << " is not a supported input rate.";
-    return false;
-  }
-
-  // Ask the browser for the default number of audio input channels.
-  // This request is based on a synchronous IPC message.
-  // TODO(xians): we should ask for the layout of a specific device.
-  media::ChannelLayout channel_layout = GetAudioInputChannelLayout();
-  DVLOG(1) << "Audio input hardware channels: " << channel_layout;
-
-  media::AudioParameters::Format format =
-      media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
-  int buffer_size = GetBufferSizeForSampleRate(sample_rate);
-  if (!buffer_size) {
-    DLOG(ERROR) << "Unsupported platform";
-    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(), 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);
 
   if (!running_) {
     dest->Zero();
     return;
   }
 
   // Provide data by reading from the FIFO if the FIFO contains enough
   // to fulfill the request.
   if (loopback_fifo_->frames() >= dest->frames()) {
     loopback_fifo_->Consume(dest, 0, dest->frames());
   } else {
     dest->Zero();
     // This warning is perfectly safe if it happens for the first audio
     // frames. It should not happen in a steady-state mode.
-    DLOG(WARNING) << "WARNING: loopback FIFO is empty.";
+    DVLOG(2) << "WARNING: loopback FIFO is empty.";
   }
 }
 
 void WebRtcAudioCapturer::Start() {
   DVLOG(1) << "WebRtcAudioCapturer::Start()";
   base::AutoLock auto_lock(lock_);
   if (running_)
     return;
 
   // What Start() does is supposed to be very light, for example, posting a
@@ skipping 23 matching lines @@
     running_ = false;
   }
 
   if (source)
     source->Stop();
 }
 
 void WebRtcAudioCapturer::SetVolume(double volume) {
   DVLOG(1) << "WebRtcAudioCapturer::SetVolume()";
   base::AutoLock auto_lock(lock_);
-
   if (source_)
     source_->SetVolume(volume);
 }
 
 void WebRtcAudioCapturer::SetDevice(int session_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "WebRtcAudioCapturer::SetDevice(" << session_id << ")";
   base::AutoLock auto_lock(lock_);
   if (source_)
     source_->SetDevice(session_id);
 }
 
 void WebRtcAudioCapturer::SetAutomaticGainControl(bool enable) {
   base::AutoLock auto_lock(lock_);
   if (source_)
     source_->SetAutomaticGainControl(enable);
 }
 
 bool WebRtcAudioCapturer::IsInLoopbackMode() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   return (loopback_fifo_ != NULL);
 }
 
 void WebRtcAudioCapturer::Capture(media::AudioBus* audio_source,
                                   int audio_delay_milliseconds,
                                   double volume) {
   // This callback is driven by AudioInputDevice::AudioThreadCallback if
   // |source_| is AudioInputDevice, otherwise it is driven by client's
   // CaptureCallback.
@@ skipping 57 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