Switch LiveAudio to source provider solution.

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/strings/string_util.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
+#include "content/renderer/media/webrtc_local_audio_source_provider.h"
 #include "content/renderer/media/webrtc_local_audio_track.h"
+#include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/sample_rates.h"
+#include "media/base/audio_hardware_config.h"
 
 namespace content {
 
 namespace {
 
 // Supported hardware sample rates for input and output sides.
 #if defined(OS_WIN) || defined(OS_MACOSX)
 // media::GetAudioInputHardwareSampleRate() asks the audio layer
 // for its current sample rate (set by the user) on Windows and Mac OS X.
 // The listed rates below adds restrictions and WebRtcAudioDeviceImpl::Init()
 // will fail if the user selects any rate outside these ranges.
 const int kValidInputRates[] = {96000, 48000, 44100, 32000, 16000, 8000};
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
 const int kValidInputRates[] = {48000, 44100};
 #elif defined(OS_ANDROID)
 const int kValidInputRates[] = {48000, 44100};
 #else
 const int kValidInputRates[] = {44100};
 #endif
 
-int GetBufferSizeForSampleRate(int sample_rate) {
-  int buffer_size = 0;
-#if defined(OS_WIN) || defined(OS_MACOSX)
-  // Use a buffer size of 10ms.
-  buffer_size = (sample_rate / 100);
-#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.
-  buffer_size = 2 * sample_rate / 100;
-#elif defined(OS_ANDROID)
-  // TODO(leozwang): Tune and adjust buffer size on Android.
-    buffer_size = 2 * sample_rate / 100;
-#endif
-  return buffer_size;
-}
-
 }  // namespace
 
-// This is a temporary audio buffer with parameters used to send data to
-// callbacks.
-class WebRtcAudioCapturer::ConfiguredBuffer :
-    public base::RefCounted<WebRtcAudioCapturer::ConfiguredBuffer> {
- public:
-  ConfiguredBuffer() {}
-
-  bool Initialize(int sample_rate,
-                  media::ChannelLayout channel_layout) {
-    int buffer_size = GetBufferSizeForSampleRate(sample_rate);
-    DVLOG(1) << "Using WebRTC input buffer size: " << buffer_size;
-
-    media::AudioParameters::Format format =
-        media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
-
-    // bits_per_sample is always 16 for now.
-    int bits_per_sample = 16;
-    int channels = ChannelLayoutToChannelCount(channel_layout);
-    params_.Reset(format, channel_layout, channels, 0,
-        sample_rate, bits_per_sample, buffer_size);
-    buffer_.reset(new int16[params_.frames_per_buffer() * params_.channels()]);
-
-    return true;
-  }
-
-  int16* buffer() const { return buffer_.get(); }
-  const media::AudioParameters& params() const { return params_; }
-
- private:
-  ~ConfiguredBuffer() {}
-  friend class base::RefCounted<WebRtcAudioCapturer::ConfiguredBuffer>;
-
-  scoped_ptr<int16[]> buffer_;
-
-  // Cached values of utilized audio parameters.
-  media::AudioParameters params_;
-};
-
 // Reference counted container of WebRtcLocalAudioTrack delegate.
 class WebRtcAudioCapturer::TrackOwner
     : public base::RefCountedThreadSafe<WebRtcAudioCapturer::TrackOwner> {
  public:
   explicit TrackOwner(WebRtcLocalAudioTrack* track)
       : delegate_(track) {}
 
-  void CaptureData(const int16* audio_data,
-                   int number_of_channels,
-                   int number_of_frames,
-                   int audio_delay_milliseconds,
-                   int volume,
-                   bool key_pressed) {
+  void Capture(media::AudioBus* audio_source,
+               int audio_delay_milliseconds,
+               double volume,
+               bool key_pressed) {
     base::AutoLock lock(lock_);
     if (delegate_) {
-      delegate_->CaptureData(audio_data,
-                             number_of_channels,
-                             number_of_frames,
-                             audio_delay_milliseconds,
-                             volume,
-                             key_pressed);
+      delegate_->Capture(audio_source,
+                         audio_delay_milliseconds,
+                         volume,
+                         key_pressed);
     }
   }
 
   void SetCaptureFormat(const media::AudioParameters& params) {
     base::AutoLock lock(lock_);
     if (delegate_)
       delegate_->SetCaptureFormat(params);
   }
 
   void Reset() {
@@ skipping 29 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TrackOwner);
 };
 
 // static
 scoped_refptr<WebRtcAudioCapturer> WebRtcAudioCapturer::CreateCapturer() {
   scoped_refptr<WebRtcAudioCapturer> capturer = new WebRtcAudioCapturer();
   return capturer;
 }
 
-bool WebRtcAudioCapturer::Reconfigure(int sample_rate,
+void WebRtcAudioCapturer::Reconfigure(int sample_rate,
                                       media::ChannelLayout channel_layout) {
-  scoped_refptr<ConfiguredBuffer> new_buffer(new ConfiguredBuffer());
-  if (!new_buffer->Initialize(sample_rate, channel_layout))
-    return false;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  int buffer_size = GetBufferSize(sample_rate);
+  DVLOG(1) << "Using WebRTC input buffer size: " << buffer_size;
+
+  media::AudioParameters::Format format =
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY;
+
+  // bits_per_sample is always 16 for now.
+  int bits_per_sample = 16;
+  media::AudioParameters params(format, channel_layout, sample_rate,
+                                bits_per_sample, buffer_size);
 
   TrackList tracks;
   {
     base::AutoLock auto_lock(lock_);
-
-    buffer_ = new_buffer;
     tracks = tracks_;
+    params_ = params;
   }
 
   // Tell all audio_tracks which format we use.
   for (TrackList::const_iterator it = tracks.begin();
        it != tracks.end(); ++it)
-    (*it)->SetCaptureFormat(new_buffer->params());
-
-  return true;
+    (*it)->SetCaptureFormat(params);
 }
 
 bool WebRtcAudioCapturer::Initialize(int render_view_id,
                                      media::ChannelLayout channel_layout,
                                      int sample_rate,
                                      int session_id,
                                      const std::string& device_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK_GE(render_view_id, 0);
   DVLOG(1) << "WebRtcAudioCapturer::Initialize()";
 
   DVLOG(1) << "Audio input hardware channel layout: " << channel_layout;
   UMA_HISTOGRAM_ENUMERATION("WebRTC.AudioInputChannelLayout",
                             channel_layout, media::CHANNEL_LAYOUT_MAX);
 
+  render_view_id_ = render_view_id;
   session_id_ = session_id;
   device_id_ = device_id;
+
   if (render_view_id == -1) {

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

this should never happen now that you've added the above dcheck, right?

[no longer working on chromium, 2013/09/10 12:43:15]

This happens and is needed for testing cases. Also it might be a valid case for
extension without a proper render view.

-    // This capturer is used by WebAudio, return true without creating a
-    // default capturing source. WebAudio will inject its own source via
-    // SetCapturerSource() at a later state.
-    DCHECK(device_id.empty());
+    // Return true here to allow injecting a new source via SetCapturerSource()
+    // at a later state.
     return true;
   }
 
   // Verify that the reported input channel configuration is supported.
   if (channel_layout != media::CHANNEL_LAYOUT_MONO &&
       channel_layout != media::CHANNEL_LAYOUT_STEREO) {
     DLOG(ERROR) << channel_layout
                 << " is not a supported input channel configuration.";
     return false;
   }
@@ skipping 10 matching lines @@
   // 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;
   }
 
-  if (!Reconfigure(sample_rate, channel_layout))
-    return false;
+  Reconfigure(sample_rate, channel_layout);
 
   // Create and configure the default audio capturing source. The |source_|
   // will be overwritten if an external client later calls SetCapturerSource()
   // providing an alternative media::AudioCapturerSource.
   SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
                     channel_layout,
                     static_cast<float>(sample_rate));
 
   return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer()
     : source_(NULL),
       running_(false),
       agc_is_enabled_(false),
+      render_view_id_(-1),
       session_id_(0),
-      volume_(0) {
+      volume_(0),
+      source_provider_(new WebRtcLocalAudioSourceProvider()),
+      peer_connection_mode_(false) {
+  DCHECK(source_provider_.get());
   DVLOG(1) << "WebRtcAudioCapturer::WebRtcAudioCapturer()";
 }
 
 WebRtcAudioCapturer::~WebRtcAudioCapturer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(tracks_.empty());
   DCHECK(!running_);
   DVLOG(1) << "WebRtcAudioCapturer::~WebRtcAudioCapturer()";
 }
 
 void WebRtcAudioCapturer::AddTrack(WebRtcLocalAudioTrack* track) {
   DCHECK(track);
   DVLOG(1) << "WebRtcAudioCapturer::AddTrack()";
 
   // Start the source if the first audio track is connected to the capturer.
   // Start() will do nothing if the capturer has already been started.
   Start();
 
   base::AutoLock auto_lock(lock_);
   // Verify that |track| is not already added to the list.
   DCHECK(std::find_if(tracks_.begin(), tracks_.end(),
                       TrackOwner::TrackWrapper(track)) == tracks_.end());
 
-  if (buffer_.get()) {
-    track->SetCaptureFormat(buffer_->params());
-  }
-
+  track->SetCaptureFormat(params_);
   tracks_.push_back(new WebRtcAudioCapturer::TrackOwner(track));
 }
 
 void WebRtcAudioCapturer::RemoveTrack(WebRtcLocalAudioTrack* track) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   bool stop_source = false;
   {
     base::AutoLock auto_lock(lock_);
     // Get iterator to the first element for which WrapsSink(track) returns
@@ skipping 17 matching lines @@
 }
 
 void WebRtcAudioCapturer::SetCapturerSource(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
     float sample_rate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
            << "sample_rate=" << sample_rate << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
-  scoped_refptr<ConfiguredBuffer> current_buffer;
   bool restart_source = false;
   {
     base::AutoLock auto_lock(lock_);
     if (source_.get() == source.get())
       return;
 
     source_.swap(old_source);
     source_ = source;
-    current_buffer = buffer_;
 
     // Reset the flag to allow starting the new source.
     restart_source = running_;
     running_ = false;
   }
 
-  const bool no_default_audio_source_exists = !current_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.get() || no_default_audio_source_exists) {
-    DVLOG(1) << "New capture source will now be utilized.";
-    if (old_source.get())
-      old_source->Stop();
+  DVLOG(1) << "New capture source will now be utilized.";

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

s/utilized/used
suggest "Switching to a new capture source."

[no longer working on chromium, 2013/09/10 12:43:15]

Done.

+  if (old_source.get())
+    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.
-    if (!Reconfigure(sample_rate, channel_layout)) {
-      return;
-    } else {
-      // The buffer has been reconfigured.  Update |current_buffer|.
-      base::AutoLock auto_lock(lock_);
-      current_buffer = buffer_;
-    }
-  }
+  // 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.
+  Reconfigure(sample_rate, channel_layout);
 
-  if (source.get()) {
-    // Make sure to grab the new parameters in case they were reconfigured.
-    source->Initialize(current_buffer->params(), this, session_id_);
-  }
+  // Make sure to grab the new parameters in case they were reconfigured.
+  media::AudioParameters params = audio_parameters();
+  source_provider_->Initialize(params);
+  if (source.get())
+    source->Initialize(params, this, session_id_);
 
   if (restart_source)
     Start();
 }
 
+void WebRtcAudioCapturer::EnablePeerConnectionMode() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "EnablePeerConnectionMode";
+  // Do nothing if the native mode has been enabled.

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

s/the native mode/peer connection mode
(or just remove the comment)

[no longer working on chromium, 2013/09/10 12:43:15]

Done.

+  if (peer_connection_mode_)
+    return;
+
+  DLOG(WARNING) << "EnablePeerConnectionMode";

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

Remove?

[no longer working on chromium, 2013/09/10 12:43:15]

Done.

+  peer_connection_mode_ = true;
+
+  {
+    base::AutoLock auto_lock(lock_);
+    // Simply return if there is no existing source or the |render_view_id_| is
+    // not valid.
+    if (!source_.get() || render_view_id_== -1)
+      return;
+  }
+
+  // Create a new audio stream as source which will open the hardware using
+  // WebRtc native buffer size.
+  media::AudioParameters params = audio_parameters();
+  SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id_),

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

Since you're no longer under the lock, is it possible that a source could have
been set between here and where the lock was released?
If you only ever change the value of source_ and render_view_id_ on this thread
(i.e. the same thread as you use the thread checker on), then this is ok, but if
not, then you need to hold the lock while you do the check as well as assign new
values.

[no longer working on chromium, 2013/09/10 12:43:15]

SetCapturerSource() can't be called under a lock since it is using lock inside
inside the method.
The concern is not a problem here since SetCapturerSource() will only be called
in the one thread with thread check.

+                    params.channel_layout(),
+                    static_cast<float>(params.sample_rate()));

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

why are we using float for the sample rate?

[no longer working on chromium, 2013/09/10 12:43:15]

Just chatted with Henrik on this, it is simply someone wants it to be float.
We should change it back to int in a separate CL.

+}
+
 void WebRtcAudioCapturer::Start() {
   DVLOG(1) << "WebRtcAudioCapturer::Start()";
   base::AutoLock auto_lock(lock_);
   if (running_)
     return;
 
   // Start the data source, i.e., start capturing data from the current source.
   // Note that, the source does not have to be a microphone.
   if (source_.get()) {
     // We need to set the AGC control before starting the stream.
@@ skipping 60 matching lines @@
 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
   // We have a special situation on Linux where the microphone volume can be
   // "higher than maximum". The input volume slider in the sound preference
   // allows the user to set a scaling that is higher than 100%. It means that
   // even if the reported maximum levels is N, the actual microphone level can
   // go up to 1.5x*N and that corresponds to a normalized |volume| of 1.5x.
   DCHECK_LE(volume, 1.6);
 #endif
 
   TrackList tracks;
-  scoped_refptr<ConfiguredBuffer> buffer_ref_while_calling;
+  int current_volume = 0;
   {
     base::AutoLock auto_lock(lock_);
     if (!running_)
       return;
 
     // Map internal volume range of [0.0, 1.0] into [0, 255] used by the
     // webrtc::VoiceEngine. webrtc::VoiceEngine will handle the case when the
     // volume is higher than 255.
     volume_ = static_cast<int>((volume * MaxVolume()) + 0.5);
-
-    // Copy the stuff we will need to local variables. In particular, we grab
-    // a reference to the buffer so we can ensure it stays alive even if the
-    // buffer is reconfigured while we are calling back.
-    buffer_ref_while_calling = buffer_;
+    current_volume = volume_;
     tracks = tracks_;
   }
 
-  int bytes_per_sample =
-      buffer_ref_while_calling->params().bits_per_sample() / 8;
-
-  // Interleave, scale, and clip input to int and store result in
-  // a local byte buffer.
-  audio_source->ToInterleaved(audio_source->frames(), bytes_per_sample,
-                              buffer_ref_while_calling->buffer());
+  // Deliver captured data to source provider, which stores the data into FIFO
+  // for WebAudio to fetch.
+  source_provider_->DeliverData(audio_source, audio_delay_milliseconds,
+                                current_volume, key_pressed);
 
   // Feed the data to the tracks.
   for (TrackList::const_iterator it = tracks.begin();
        it != tracks.end();
        ++it) {
-    (*it)->CaptureData(buffer_ref_while_calling->buffer(),
-                       audio_source->channels(),
-                       audio_source->frames(),
-                       audio_delay_milliseconds,
-                       volume,
-                       key_pressed);
+    (*it)->Capture(audio_source, audio_delay_milliseconds,
+                   current_volume, key_pressed);
   }
 }
 
 void WebRtcAudioCapturer::OnCaptureError() {
   NOTIMPLEMENTED();
 }
 
 media::AudioParameters WebRtcAudioCapturer::audio_parameters() const {
   base::AutoLock auto_lock(lock_);
-  // |buffer_| can be NULL when SetCapturerSource() or Initialize() has not
-  // been called.
-  return buffer_.get() ? buffer_->params() : media::AudioParameters();
+  return params_;
+}
+
+WebKit::WebAudioSourceProvider*
+WebRtcAudioCapturer::AudioSourceProvider() const {
+  return source_provider_.get();

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

since we never change the value of source_provider_, let's make it a const
member variable in the header.

[no longer working on chromium, 2013/09/10 12:43:15]

Done with changing the source_provider_ to be const
scoped_ptr<WebRtcLocalAudioSourceProvider>

+}
+
+int WebRtcAudioCapturer::GetBufferSize(int sample_rate) const {
+#if defined(OS_ANDROID)
+  // TODO(leozwang): Tune and adjust buffer size on Android.
+  return (2 * sample_rate / 100);
+#endif
+DLOG(WARNING) << "GetBufferSize " << peer_connection_mode_;

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

remove?

[no longer working on chromium, 2013/09/10 12:43:15]

Done.

+  if (peer_connection_mode_) {

[tommi (sloooow) - chröme, 2013/09/06 11:20:30]

before checking this, should we grab the lock?  (or dcheck that we're always on
the same thread when we touch this variable?)

[no longer working on chromium, 2013/09/10 12:43:15]

Done with adding a thread check.

+    // WebRtc is running at a buffer size of 10ms data. Use a multiple of 10ms
+    // as the buffer size to achieve the best performance for WebRtc.
+    return (sample_rate / 100);
+  }
+
+  // Use the native hardware buffer size.
+  media::AudioHardwareConfig* hardware_config =
+      RenderThreadImpl::current()->GetAudioHardwareConfig();
+  return hardware_config->GetInputBufferSize();
 }
 
 }  // namespace content