Add a virtual beamforming audio device on ChromeOS.

content/renderer/media/media_stream_audio_processor.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/media_stream_audio_processor.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_converter.h"
 #include "media/base/audio_fifo.h"
 #include "media/base/channel_layout.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediaconstraintsinterface.h"
 #include "third_party/webrtc/modules/audio_processing/typing_detection.h"
 
-#if defined(OS_CHROMEOS)
-#include "base/sys_info.h"
-#endif
-
 namespace content {
 
 namespace {
 
 using webrtc::AudioProcessing;
 using webrtc::NoiseSuppression;
 
 const int kAudioProcessingNumberOfChannels = 1;
 
 AudioProcessing::ChannelLayout MapLayout(media::ChannelLayout media_layout) {
@@ skipping 49 matching lines @@
 
   return (group_name == "Enabled" || group_name == "DefaultEnabled");
 }
 
 bool IsBeamformingEnabled(const MediaAudioConstraints& audio_constraints) {
   return base::FieldTrialList::FindFullName("ChromebookBeamforming") ==
              "Enabled" ||
          audio_constraints.GetProperty(MediaAudioConstraints::kGoogBeamforming);
 }
 
-void ConfigureBeamforming(webrtc::Config* config,
-                          const std::string& geometry_str) {
-  std::vector<webrtc::Point> geometry = ParseArrayGeometry(geometry_str);
-#if defined(OS_CHROMEOS)
-  if (geometry.empty()) {
-    const std::string& board = base::SysInfo::GetLsbReleaseBoard();
-    if (board.find("nyan_kitty") != std::string::npos) {
-      geometry.push_back(webrtc::Point(-0.03f, 0.f, 0.f));
-      geometry.push_back(webrtc::Point(0.03f, 0.f, 0.f));
-    } else if (board.find("peach_pi") != std::string::npos) {
-      geometry.push_back(webrtc::Point(-0.025f, 0.f, 0.f));
-      geometry.push_back(webrtc::Point(0.025f, 0.f, 0.f));
-    } else if (board.find("samus") != std::string::npos) {
-      geometry.push_back(webrtc::Point(-0.032f, 0.f, 0.f));
-      geometry.push_back(webrtc::Point(0.032f, 0.f, 0.f));
-    } else if (board.find("swanky") != std::string::npos) {
-      geometry.push_back(webrtc::Point(-0.026f, 0.f, 0.f));
-      geometry.push_back(webrtc::Point(0.026f, 0.f, 0.f));
-    }
-  }
-#endif
-  config->Set<webrtc::Beamforming>(
-      new webrtc::Beamforming(geometry.size() > 1, geometry));
-}
-
 }  // namespace
 
 // Wraps AudioBus to provide access to the array of channel pointers, since this
 // is the type webrtc::AudioProcessing deals in. The array is refreshed on every
 // channel_ptrs() call, and will be valid until the underlying AudioBus pointers
 // are changed, e.g. through calls to SetChannelData() or SwapChannels().
 //
 // All methods are called on one of the capture or render audio threads
 // exclusively.
 class MediaStreamAudioBus {
@@ skipping 133 matching lines @@
   // delay of the first sample in |destination_|.
   base::TimeDelta next_audio_delay_;
 
   // True when |destination_| contains the data to be returned by the next call
   // to Consume().  Only used when the FIFO is disabled.
   bool data_available_;
 };
 
 MediaStreamAudioProcessor::MediaStreamAudioProcessor(
     const blink::WebMediaConstraints& constraints,
-    int effects,
+    const MediaStreamDevice::AudioDeviceParameters& input_params,
     WebRtcPlayoutDataSource* playout_data_source)
     : render_delay_ms_(0),
       playout_data_source_(playout_data_source),
       audio_mirroring_(false),
       typing_detected_(false),
       stopped_(false) {
   capture_thread_checker_.DetachFromThread();
   render_thread_checker_.DetachFromThread();
-  InitializeAudioProcessingModule(constraints, effects);
+  InitializeAudioProcessingModule(constraints, input_params);
 
   aec_dump_message_filter_ = AecDumpMessageFilter::Get();
   // In unit tests not creating a message filter, |aec_dump_message_filter_|
   // will be NULL. We can just ignore that. Other unit tests and browser tests
   // ensure that we do get the filter when we should.
   if (aec_dump_message_filter_.get())
     aec_dump_message_filter_->AddDelegate(this);
 }
 
 MediaStreamAudioProcessor::~MediaStreamAudioProcessor() {
@@ skipping 154 matching lines @@
   render_fifo_.reset();
 }
 
 void MediaStreamAudioProcessor::GetStats(AudioProcessorStats* stats) {
   stats->typing_noise_detected =
       (base::subtle::Acquire_Load(&typing_detected_) != false);
   GetAecStats(audio_processing_.get()->echo_cancellation(), stats);
 }
 
 void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
-    const blink::WebMediaConstraints& constraints, int effects) {
+    const blink::WebMediaConstraints& constraints,
+    const MediaStreamDevice::AudioDeviceParameters& input_params) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!audio_processing_);
 
-  MediaAudioConstraints audio_constraints(constraints, effects);
+  MediaAudioConstraints audio_constraints(constraints, input_params.effects);
 
   // Audio mirroring can be enabled even though audio processing is otherwise
   // disabled.
   audio_mirroring_ = audio_constraints.GetProperty(
       MediaAudioConstraints::kGoogAudioMirroring);
 
 #if defined(OS_IOS)
   // On iOS, VPIO provides built-in AGC and AEC.
   const bool echo_cancellation = false;
   const bool goog_agc = false;
@@ skipping 31 matching lines @@
 
   // Experimental options provided at creation.
   webrtc::Config config;
   if (goog_experimental_aec)
     config.Set<webrtc::ExtendedFilter>(new webrtc::ExtendedFilter(true));
   if (goog_experimental_ns)
     config.Set<webrtc::ExperimentalNs>(new webrtc::ExperimentalNs(true));
   if (IsDelayAgnosticAecEnabled())
     config.Set<webrtc::DelayAgnostic>(new webrtc::DelayAgnostic(true));
   if (goog_beamforming) {
-    ConfigureBeamforming(&config,
-                         audio_constraints.GetPropertyAsString(
-                             MediaAudioConstraints::kGoogArrayGeometry));
+    const auto& geometry =
+        GetArrayGeometryPreferringConstraints(audio_constraints, input_params);
+
+    // Only enable beamforming if we have at least two mics.
+    config.Set<webrtc::Beamforming>(
+        new webrtc::Beamforming(geometry.size() > 1, geometry));
   }
 
   // Create and configure the webrtc::AudioProcessing.
   audio_processing_.reset(webrtc::AudioProcessing::Create(config));
 
   // Enable the audio processing components.
   if (echo_cancellation) {
     EnableEchoCancellation(audio_processing_.get());
 
     if (playout_data_source_)
@@ skipping 69 matching lines @@
 
   // webrtc::AudioProcessing requires a 10 ms chunk size. We use this native
   // size when processing is enabled. When disabled we use the same size as
   // the source if less than 10 ms.
   //
   // TODO(ajm): This conditional buffer size appears to be assuming knowledge of
   // the sink based on the source parameters. PeerConnection sinks seem to want
   // 10 ms chunks regardless, while WebAudio sinks want less, and we're assuming
   // we can identify WebAudio sinks by the input chunk size. Less fragile would
   // be to have the sink actually tell us how much it wants (as in the above
-  // TODO).
+  // todo).
   int processing_frames = input_format.sample_rate() / 100;
   int output_frames = output_sample_rate / 100;
   if (!audio_processing_ && input_format.frames_per_buffer() < output_frames) {
     processing_frames = input_format.frames_per_buffer();
     output_frames = processing_frames;
   }
 
   output_format_ = media::AudioParameters(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
       output_channel_layout,
@@ skipping 93 matching lines @@
   if (echo_information_) {
     echo_information_.get()->UpdateAecDelayStats(ap->echo_cancellation());
   }
 
   // Return 0 if the volume hasn't been changed, and otherwise the new volume.
   return (agc->stream_analog_level() == volume) ?
       0 : agc->stream_analog_level();
 }
 
 }  // namespace content