Add a virtual beamforming audio device on ChromeOS.

content/renderer/media/media_stream_audio_processor_options.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_options.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 33 matching lines @@
 const char MediaAudioConstraints::kGoogAudioMirroring[] = "googAudioMirroring";
 
 namespace {
 
 // Constant constraint keys which enables default audio constraints on
 // mediastreams with audio.
 struct {
   const char* key;
   bool value;
 } const kDefaultAudioConstraints[] = {
-  { MediaAudioConstraints::kEchoCancellation, true },
-  { MediaAudioConstraints::kGoogEchoCancellation, true },
+    {MediaAudioConstraints::kEchoCancellation, true},
+    {MediaAudioConstraints::kGoogEchoCancellation, true},
 #if defined(OS_ANDROID) || defined(OS_IOS)
-  { MediaAudioConstraints::kGoogExperimentalEchoCancellation, false },
+    {MediaAudioConstraints::kGoogExperimentalEchoCancellation, false},
 #else
-  // Enable the extended filter mode AEC on all non-mobile platforms.
-  { MediaAudioConstraints::kGoogExperimentalEchoCancellation, true },
+    // Enable the extended filter mode AEC on all non-mobile platforms.
+    {MediaAudioConstraints::kGoogExperimentalEchoCancellation, true},
 #endif
-  { MediaAudioConstraints::kGoogAutoGainControl, true },
-  { MediaAudioConstraints::kGoogExperimentalAutoGainControl, true },
-  { MediaAudioConstraints::kGoogNoiseSuppression, true },
-  { MediaAudioConstraints::kGoogHighpassFilter, true },
-  { MediaAudioConstraints::kGoogTypingNoiseDetection, true },
-  { MediaAudioConstraints::kGoogExperimentalNoiseSuppression, false },
-  { MediaAudioConstraints::kGoogBeamforming, false },
+    {MediaAudioConstraints::kGoogAutoGainControl, true},
+    {MediaAudioConstraints::kGoogExperimentalAutoGainControl, true},
+    {MediaAudioConstraints::kGoogNoiseSuppression, true},
+    {MediaAudioConstraints::kGoogHighpassFilter, true},
+    {MediaAudioConstraints::kGoogTypingNoiseDetection, true},
+    {MediaAudioConstraints::kGoogExperimentalNoiseSuppression, false},
+    // Beamforming will only be enabled if we are also provided with a
+    // multi-microphone geometry.
+    {MediaAudioConstraints::kGoogBeamforming, false},
 #if defined(OS_WIN)
-  { kMediaStreamAudioDucking, true },
+    {kMediaStreamAudioDucking, true},
 #else
-  { kMediaStreamAudioDucking, false },
+    {kMediaStreamAudioDucking, false},
 #endif
-  { kMediaStreamAudioHotword, false },
+    {kMediaStreamAudioHotword, false},
 };
 
 bool IsAudioProcessingConstraint(const std::string& key) {
   // |kMediaStreamAudioDucking| does not require audio processing.
   return key != kMediaStreamAudioDucking;
 }
 
 // Used to log echo quality based on delay estimates.
 enum DelayBasedEchoQuality {
   DELAY_BASED_ECHO_QUALITY_GOOD = 0,
@@ skipping 301 matching lines @@
   float dummy = 0;
   if (echo_cancellation->GetDelayMetrics(&median, &std, &dummy) ==
       webrtc::AudioProcessing::kNoError) {
     stats->echo_delay_median_ms = median;
     stats->echo_delay_std_ms = std;
   }
 }
 
 CONTENT_EXPORT std::vector<webrtc::Point> ParseArrayGeometry(
     const std::string& geometry_string) {
+  std::vector<webrtc::Point> geometry;
+  if (geometry_string.empty()) {
+    return geometry;
+  }
+
   const auto& tokens =
       base::SplitString(geometry_string, base::kWhitespaceASCII,
                         base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
-  std::vector<webrtc::Point> geometry;
   if (tokens.size() < 3 || tokens.size() % 3 != 0) {
     LOG(ERROR) << "Malformed geometry string: " << geometry_string;
     return geometry;
   }
 
   std::vector<float> float_tokens;
   float_tokens.reserve(tokens.size());
   for (const auto& token : tokens) {
     double float_token;
     if (!base::StringToDouble(token, &float_token)) {
       LOG(ERROR) << "Unable to convert token=" << token
                  << " to double from geometry string: " << geometry_string;
       return geometry;
     }
     float_tokens.push_back(float_token);
   }
 
   geometry.reserve(float_tokens.size() / 3);
   for (size_t i = 0; i < float_tokens.size(); i += 3) {
     geometry.push_back(webrtc::Point(float_tokens[i + 0], float_tokens[i + 1],
                                      float_tokens[i + 2]));
   }
 
   return geometry;
 }
 
 }  // namespace content