move the APM to chrome.

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_audio_processing_wrapper.h"
 #include "content/renderer/media/webrtc_local_audio_track.h"
 #include "media/audio/sample_rates.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
@@ skipping 11 matching lines @@
 
 }  // namespace
 
 // Reference counted container of WebRtcLocalAudioTrack delegate.
 class WebRtcAudioCapturer::TrackOwner
     : public base::RefCountedThreadSafe<WebRtcAudioCapturer::TrackOwner> {
  public:
   explicit TrackOwner(WebRtcLocalAudioTrack* track)
       : delegate_(track) {}
 
-  void Capture(media::AudioBus* audio_source,
-               int audio_delay_milliseconds,
-               double volume,
-               bool key_pressed) {
+  void Capture(const int16* data,
+               int sample_rate,
+               int number_of_channels,
+               int number_of_frames) {
     base::AutoLock lock(lock_);
     if (delegate_) {
-      delegate_->Capture(audio_source,
-                         audio_delay_milliseconds,
-                         volume,
-                         key_pressed);
+      delegate_->Capture(data,
+                         sample_rate,
+                         number_of_channels,
+                         number_of_frames);
     }
   }
 
   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;
 }
 
-void WebRtcAudioCapturer::Reconfigure(int sample_rate,
-                                      media::ChannelLayout channel_layout) {
+void WebRtcAudioCapturer::Reconfigure(
+    int sample_rate,
+    media::ChannelLayout channel_layout,
+    const webrtc::MediaConstraintsInterface* constraints) {
   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);
 
+  audio_processing_.reset(new WebRtcAudioProcessingWrapper());
+  audio_processing_->Configure(params, constraints);
+  sink_params_ = audio_processing_->OutputFormat();
+
   TrackList tracks;
   {
     base::AutoLock auto_lock(lock_);
     tracks = tracks_;
-    params_ = params;
+    source_params_ = params;
   }
 
   // Tell all audio_tracks which format we use.
   for (TrackList::const_iterator it = tracks.begin();
        it != tracks.end(); ++it)
-    (*it)->SetCaptureFormat(params);
+    (*it)->SetCaptureFormat(sink_params_);
 }
 
-bool WebRtcAudioCapturer::Initialize(int render_view_id,
-                                     media::ChannelLayout channel_layout,
-                                     int sample_rate,
-                                     int buffer_size,
-                                     int session_id,
-                                     const std::string& device_id,
-                                     int paired_output_sample_rate,
-                                     int paired_output_frames_per_buffer) {
+bool WebRtcAudioCapturer::Initialize(
+    int render_view_id,
+    media::ChannelLayout channel_layout,
+    int sample_rate,
+    int buffer_size,
+    int session_id,
+    const std::string& device_id,
+    int paired_output_sample_rate,
+    int paired_output_frames_per_buffer,
+    const webrtc::MediaConstraintsInterface* constraints) {
   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;
@@ skipping 31 matching lines @@
                 &kValidInputRates[0] + arraysize(kValidInputRates),
                 sample_rate) ==
           &kValidInputRates[arraysize(kValidInputRates)]) {
     DLOG(ERROR) << sample_rate << " is not a supported input rate.";
     return false;
   }
 
   // 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));
+  InitializeCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
+                           channel_layout,
+                           static_cast<float>(sample_rate),
+                           constraints);
 
   return true;
 }
 
 WebRtcAudioCapturer::WebRtcAudioCapturer()
     : source_(NULL),
       running_(false),
       agc_is_enabled_(false),
       render_view_id_(-1),
       hardware_buffer_size_(0),
@@ skipping 20 matching lines @@
 
   // 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());
 
-  track->SetCaptureFormat(params_);
+  track->SetCaptureFormat(sink_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
     // true.
     TrackList::iterator it = std::find_if(
         tracks_.begin(), tracks_.end(), TrackOwner::TrackWrapper(track));
     if (it != tracks_.end()) {
       // Clear the delegate to ensure that no more capture callbacks will
       // be sent to this sink. Also avoids a possible crash which can happen
       // if this method is called while capturing is active.
       (*it)->Reset();
       tracks_.erase(it);
     }
 
     // Stop the source if the last audio track is going away.
     stop_source = tracks_.empty();
   }
 
   if (stop_source)
     Stop();
 }
 
-void WebRtcAudioCapturer::SetCapturerSource(
+void WebRtcAudioCapturer::InitializeCapturerSource(
     const scoped_refptr<media::AudioCapturerSource>& source,
     media::ChannelLayout channel_layout,
-    float sample_rate) {
+    float sample_rate,
+    const webrtc::MediaConstraintsInterface* constraints) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "SetCapturerSource(channel_layout=" << channel_layout << ","
-           << "sample_rate=" << sample_rate << ")";
+  DVLOG(1) << "InitializeCapturerSource(channel_layout=" << channel_layout
+           << "," << "sample_rate=" << sample_rate << ")";
   scoped_refptr<media::AudioCapturerSource> old_source;
   bool restart_source = false;
   {
     base::AutoLock auto_lock(lock_);
     if (source_.get() == source.get())
       return;
 
     source_.swap(old_source);
     source_ = source;
 
     // Reset the flag to allow starting the new source.
     restart_source = running_;
     running_ = false;
   }
 
   DVLOG(1) << "Switching to a new capture source.";
   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.
-  Reconfigure(sample_rate, channel_layout);
+  Reconfigure(sample_rate, channel_layout, constraints);
 
   // 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();
 }
@@ skipping 17 matching lines @@
     render_view_id = render_view_id_;
   }
 
   // Do nothing if the current buffer size is the WebRtc native buffer size.
   media::AudioParameters params = audio_parameters();
   if (GetBufferSize(params.sample_rate()) == params.frames_per_buffer())
     return;
 
   // Create a new audio stream as source which will open the hardware using
   // WebRtc native buffer size.
-  SetCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
-                    params.channel_layout(),
-                    static_cast<float>(params.sample_rate()));
+  InitializeCapturerSource(AudioDeviceFactory::NewInputDevice(render_view_id),
+                           params.channel_layout(),
+                           static_cast<float>(params.sample_rate()),
+                           NULL);
 }
 
+void WebRtcAudioCapturer::FeedRenderDataToAudioProcessing(
+    const int16* render_audio,
+    int sample_rate,
+    int number_of_channels,
+    int number_of_frames,
+    int render_delay_ms) {
+  audio_processing_->FeedRenderDataToAudioProcessing(render_audio,
+                                                     sample_rate,
+                                                     number_of_channels,
+                                                     number_of_frames,
+                                                     render_delay_ms);
+
+}
 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;
-  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);
-    current_volume = volume_;
     tracks = tracks_;
   }
 
-  // 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);
+  audio_processing_->Push(audio_source);
+  int current_volume = volume;
+  while (audio_processing_->ProcessAndConsume10MsData(audio_delay_milliseconds,
+                                                      current_volume,
+                                                      key_pressed)) {
+    // TODO(xians): Get the new volume and set it to |current_volume|.
 
-  // Feed the data to the tracks.
-  for (TrackList::const_iterator it = tracks.begin();
-       it != tracks.end();
-       ++it) {
-    (*it)->Capture(audio_source, audio_delay_milliseconds,
-                   current_volume, key_pressed);
+    for (TrackList::const_iterator it = tracks.begin();
+         it != tracks.end(); ++it) {
+      (*it)->Capture(audio_processing_->OutputBuffer(),
+                     sink_params_.sample_rate(),
+                     sink_params_.channels(),
+                     sink_params_.frames_per_buffer());
+    }
+
+    // TODO(xians): Make the source provider as one of the sinks.
+    // Deliver captured data to source provider, which stores the data into FIFO
+    // for WebAudio to fetch.
+    source_provider_->DeliverData(audio_processing_->OutputBuffer(),
+                                  sink_params_.sample_rate(),
+                                  sink_params_.channels(),
+                                  sink_params_.frames_per_buffer());
   }
 }
 
 void WebRtcAudioCapturer::OnCaptureError() {
   NOTIMPLEMENTED();
 }
 
 media::AudioParameters WebRtcAudioCapturer::audio_parameters() const {
   base::AutoLock auto_lock(lock_);
-  return params_;
+  return source_params_;
 }
 
 bool WebRtcAudioCapturer::GetPairedOutputParameters(
     int* session_id,
     int* output_sample_rate,
     int* output_frames_per_buffer) const {
   *session_id = session_id_;
   *output_sample_rate = output_sample_rate_;
   *output_frames_per_buffer = output_frames_per_buffer_;
   return session_id_ > 0 && output_sample_rate_ > 0 &&
@@ skipping 12 matching lines @@
   if (!peer_connection_mode_ && hardware_buffer_size_)
     return hardware_buffer_size_;
 #endif
 
   // 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);
 }
 
 }  // namespace content