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 18 matching lines @@
 const char MediaAudioConstraints::kGoogExperimentalEchoCancellation[] =
     "googEchoCancellation2";
 const char MediaAudioConstraints::kGoogAutoGainControl[] =
     "googAutoGainControl";
 const char MediaAudioConstraints::kGoogExperimentalAutoGainControl[] =
     "googAutoGainControl2";
 const char MediaAudioConstraints::kGoogNoiseSuppression[] =
     "googNoiseSuppression";
 const char MediaAudioConstraints::kGoogExperimentalNoiseSuppression[] =
     "googNoiseSuppression2";
 const char MediaAudioConstraints::kGoogBeamforming[] = "googBeamforming";

[tommi (sloooow) - chröme, 2015/09/02 07:43:07]

was this constraint added recently?  If so, is it too late to change it to
beamForming? (we don't want to use the 'goog' prefix)

[ajm, 2015/09/02 17:00:55]

It was added awhile ago, but AFAIK no apps are using it yet.

Do you have a link to the background here? I thought non-prefixed constraints
should be present in the gUM draft?

[tommi (sloooow) - chröme, 2015/09/03 12:01:57]

The background is that we shouldn't be adding constraints we're not trying to
standardize.  The constraints also need to be defined in blink and not here (see
https://code.google.com/p/chromium/issues/detail?id=526734), since it's too easy
to bypass things at this level that should be going through the web platform
process.  We've had several discussions with the blink team about this and
recently had a regression when one more 'goog' constraint got added.
If it's not too late to remove the prefix here, I'd really like to do that since
I think that's what good citizens would do :)

[ajm, 2015/09/03 20:40:48]

Understood. I'm not sure we can faithfully say that we want beamforming to
become a standardized constraint, so should we really un-prefix it? That
suggests to me that we intend to standardize, rather than it being recognized as
legacy badness.

Also, this kind of breaks the model here and I'd like to know what we're going
to replace it with. The custom constraints were mainly used as an easy way to
control features from the apprtc URL. If that's going away, what should we
switch to? Chrome command-line flags?

 const char MediaAudioConstraints::kGoogArrayGeometry[] = "googArrayGeometry";
 const char MediaAudioConstraints::kGoogHighpassFilter[] = "googHighpassFilter";
 const char MediaAudioConstraints::kGoogTypingNoiseDetection[] =
     "googTypingNoiseDetection";
 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},

[tommi (sloooow) - chröme, 2015/09/02 07:43:07]

would be nice to keep the whitespace and indent consistent as it was.

[ajm, 2015/09/02 17:00:55]

Ah sorry, I forgot to fix this after a rebase. I'd like to use clang-format on
this whole block, which will result in the style you see on this line, with a
four-space indent and no space inside the braces. Is that fine, or would you
prefer to keep the original style?

The trouble with not following clang-format is having to manually revert this
block after every run.

+    {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 },
+  // Beamforming will only be enabled if we are also provided with a
+  // multi-microphone geometry.
+  { MediaAudioConstraints::kGoogBeamforming, true },
   { kMediaStreamAudioHotword, false },
 };
 
 // Used to log echo quality based on delay estimates.
 enum DelayBasedEchoQuality {
   DELAY_BASED_ECHO_QUALITY_GOOD = 0,
   DELAY_BASED_ECHO_QUALITY_SPURIOUS,
   DELAY_BASED_ECHO_QUALITY_BAD,
   DELAY_BASED_ECHO_QUALITY_INVALID,
   DELAY_BASED_ECHO_QUALITY_MAX
@@ skipping 13 matching lines @@
   if (delay_frequency < 0)
     return DELAY_BASED_ECHO_QUALITY_INVALID;
   else if (delay_frequency <= kEchoDelayFrequencyLowerLimit)
     return DELAY_BASED_ECHO_QUALITY_GOOD;
   else if (delay_frequency < kEchoDelayFrequencyUpperLimit)
     return DELAY_BASED_ECHO_QUALITY_SPURIOUS;
   else
     return DELAY_BASED_ECHO_QUALITY_BAD;
 }
 
+webrtc::Point WebrtcPointFromMediaPoint(const media::Point& point) {
+  return webrtc::Point(point.x(), point.y(), point.z());
+}
+
+std::vector<webrtc::Point> WebrtcPointsFromMediaPoints(
+    const std::vector<media::Point>& points) {
+  std::vector<webrtc::Point> webrtc_points;
+  webrtc_points.reserve(webrtc_points.size());

[tommi (sloooow) - chröme, 2015/09/02 07:43:07]

appreciate the attention to detail :)

[ajm, 2015/09/02 17:00:55]

Thanks :)

+  for (const auto& point : points) {
+    webrtc_points.push_back(WebrtcPointFromMediaPoint(point));
+  }
+  return webrtc_points;
+}
+
 }  // namespace
 
 // TODO(xians): Remove this method after the APM in WebRtc is deprecated.
 void MediaAudioConstraints::ApplyFixedAudioConstraints(
     RTCMediaConstraints* constraints) {
   for (size_t i = 0; i < arraysize(kDefaultAudioConstraints); ++i) {
     bool already_set_value;
     if (!webrtc::FindConstraint(constraints, kDefaultAudioConstraints[i].key,
                                 &already_set_value, NULL)) {
       const std::string value = kDefaultAudioConstraints[i].value ?
@@ skipping 258 matching lines @@
 
   int median = 0, std = 0;
   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) {
-  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<webrtc::Point> GetArrayGeometryPreferringConstraints(
+    const MediaAudioConstraints& audio_constraints,
+    const MediaStreamDevice::AudioDeviceParameters& input_params) {
+  const std::string& constraints_geometry =

[tommi (sloooow) - chröme, 2015/09/02 07:43:07]

nit: no ref

[ajm, 2015/09/02 17:00:55]

I agree, but would like to get your opinion on the other comment.

[ajm, 2015/09/09 01:01:29]

Done.

+      audio_constraints.GetPropertyAsString(
+          MediaAudioConstraints::kGoogArrayGeometry);
 
-  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;
+  // Give preference to the audio constraint over the device-supplied mic
+  // positions. This is mainly for testing purposes.
+  return WebrtcPointsFromMediaPoints(
+      constraints_geometry.empty()
+          ? input_params.mic_positions
+          : media::ParsePointsFromString(constraints_geometry));
 }
 
 }  // namespace content