Add a media constraint to enable beamforming.

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/debug/trace_event.h"
 #if defined(OS_MACOSX)
 #include "base/metrics/field_trial.h"
 #endif
 #include "base/metrics/histogram.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;
 
 #if defined(OS_ANDROID)
 const int kAudioProcessingSampleRate = 16000;
 #else
 const int kAudioProcessingSampleRate = 32000;
@@ skipping 405 matching lines @@
   const bool goog_experimental_aec = audio_constraints.GetProperty(
       MediaAudioConstraints::kGoogExperimentalEchoCancellation);
   const bool goog_typing_detection = audio_constraints.GetProperty(
       MediaAudioConstraints::kGoogTypingNoiseDetection);
 #endif
 
   const bool goog_ns = audio_constraints.GetProperty(
       MediaAudioConstraints::kGoogNoiseSuppression);
   const bool goog_experimental_ns = audio_constraints.GetProperty(
       MediaAudioConstraints::kGoogExperimentalNoiseSuppression);
+  const bool goog_beamforming = audio_constraints.GetProperty(
+      MediaAudioConstraints::kGoogBeamforming);
  const bool goog_high_pass_filter = audio_constraints.GetProperty(
      MediaAudioConstraints::kGoogHighpassFilter);
 
   // Return immediately if no goog constraint is enabled.
   if (!echo_cancellation && !goog_experimental_aec && !goog_ns &&
       !goog_high_pass_filter && !goog_typing_detection &&
-      !goog_agc && !goog_experimental_ns) {
+      !goog_agc && !goog_experimental_ns && !goog_beamforming) {
     RecordProcessingState(AUDIO_PROCESSING_DISABLED);
     return;
   }
 
   // Experimental options provided at creation.
   webrtc::Config config;
   if (goog_experimental_aec)
     config.Set<webrtc::DelayCorrection>(new webrtc::DelayCorrection(true));
   if (goog_experimental_ns)
     config.Set<webrtc::ExperimentalNs>(new webrtc::ExperimentalNs(true));
 #if defined(OS_MACOSX)
   if (base::FieldTrialList::FindFullName("NoReportedDelayOnMac") == "Enabled")
     config.Set<webrtc::ReportedDelay>(new webrtc::ReportedDelay(false));
 #endif
+  if (goog_beamforming) {
+    ConfigureBeamforming(&config);
+  }
 
   // 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_)
       playout_data_source_->AddPlayoutSink(this);
@@ skipping 15 matching lines @@
     typing_detector_.reset(new webrtc::TypingDetection());
     EnableTypingDetection(audio_processing_.get(), typing_detector_.get());
   }
 
   if (goog_agc)
     EnableAutomaticGainControl(audio_processing_.get());
 
   RecordProcessingState(AUDIO_PROCESSING_ENABLED);
 }
 
+void MediaStreamAudioProcessor::ConfigureBeamforming(webrtc::Config* config) {
+  bool enabled = false;
+  std::vector<webrtc::Point> geometry(1, webrtc::Point(0.f, 0.f, 0.f));
+#if defined(OS_CHROMEOS)
+  const std::string board = base::SysInfo::GetLsbReleaseBoard();
+  if (board == "peach_pi") {
+    enabled = true;
+    geometry.push_back(webrtc::Point(0.050f, 0.f, 0.f));
+  } else if (board == "swanky") {
+    // TODO(aluebs): Verify beamforming works on Swanky and enable.
+    enabled = false;
+    geometry.push_back(webrtc::Point(0.052f, 0.f, 0.f));
+  }
+#endif
+  config->Set<webrtc::Beamforming>(new webrtc::Beamforming(enabled, geometry));
+}
+
 void MediaStreamAudioProcessor::InitializeCaptureFifo(
     const media::AudioParameters& input_format) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(input_format.IsValid());
   input_format_ = input_format;
 
   // TODO(ajm): For now, we assume fixed parameters for the output when audio
   // processing is enabled, to match the previous behavior. We should either
   // use the input parameters (in which case, audio processing will convert
   // at output) or ideally, have a backchannel from the sink to know what
@@ skipping 130 matching lines @@
                                               vad->stream_has_voice());
     base::subtle::Release_Store(&typing_detected_, detected);
   }
 
   // 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