Enable new getUserMedia audio constraints algorithm behind a flag.

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 <stddef.h>
 #include <utility>
 
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/common/media/media_stream_options.h"
+#include "content/public/common/content_features.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_source.h"
 #include "media/base/audio_parameters.h"
 #include "third_party/webrtc/modules/audio_processing/include/audio_processing.h"
 #include "third_party/webrtc/modules/audio_processing/typing_detection.h"
 
 namespace content {
 
 const char MediaAudioConstraints::kEchoCancellation[] = "echoCancellation";
 const char MediaAudioConstraints::kGoogEchoCancellation[] =
@@ skipping 69 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());
-  for (const auto& point : points)
-    webrtc_points.push_back(WebrtcPointFromMediaPoint(point));
-  return webrtc_points;
-}
-
 // Scan the basic and advanced constraints until a value is found.
 // If nothing is found, the default is returned.
 // Argument 2 is a pointer to class data member.
 bool ScanConstraintsForBoolean(
     const blink::WebMediaConstraints& constraints,
     blink::BooleanConstraint blink::WebMediaTrackConstraintSet::*picker,
     bool the_default) {
   bool value;
   if (GetConstraintValueAsBoolean(constraints, picker, &value)) {
     return value;
   }
   return the_default;
 }
 
 }  // namespace
 
 MediaAudioConstraints::MediaAudioConstraints(
     const blink::WebMediaConstraints& constraints, int effects)
     : constraints_(constraints),
       effects_(effects),
       default_audio_processing_constraint_value_(true) {
+  DCHECK(IsOldAudioConstraints());
   // The default audio processing constraints are turned off when
   // - gUM has a specific kMediaStreamSource, which is used by tab capture
   //   and screen capture.
   // - |kEchoCancellation| is explicitly set to false.
   bool echo_constraint;
   std::string source_string;
   if (GetConstraintValueAsString(
           constraints, &blink::WebMediaTrackConstraintSet::media_stream_source,
           &source_string) ||
       (GetConstraintValueAsBoolean(
@@ skipping 125 matching lines @@
 AudioProcessingProperties::AudioProcessingProperties(
     const AudioProcessingProperties& other) = default;
 AudioProcessingProperties& AudioProcessingProperties::operator=(
     const AudioProcessingProperties& other) = default;
 AudioProcessingProperties::AudioProcessingProperties(
     AudioProcessingProperties&& other) = default;
 AudioProcessingProperties& AudioProcessingProperties::operator=(
     AudioProcessingProperties&& other) = default;
 AudioProcessingProperties::~AudioProcessingProperties() = default;
 
+void AudioProcessingProperties::DisableDefaultPropertiesForTesting() {
+  enable_sw_echo_cancellation = false;
+  goog_auto_gain_control = false;
+  goog_experimental_echo_cancellation = false;
+  goog_typing_noise_detection = false;
+  goog_noise_suppression = false;
+  goog_experimental_noise_suppression = false;
+  goog_beamforming = false;
+  goog_highpass_filter = false;
+  goog_experimental_auto_gain_control = false;
+}
+
+// static
+AudioProcessingProperties AudioProcessingProperties::FromConstraints(
+    const blink::WebMediaConstraints& constraints,
+    const MediaStreamDevice::AudioDeviceParameters& input_params) {
+  DCHECK(IsOldAudioConstraints());
+  MediaAudioConstraints audio_constraints(constraints, input_params.effects);
+  AudioProcessingProperties properties;
+  properties.enable_sw_echo_cancellation =
+      audio_constraints.GetEchoCancellationProperty();
+  // |properties.disable_hw_echo_cancellation| is not used when
+  // IsOldAudioConstraints() is true.
+  properties.goog_audio_mirroring = audio_constraints.GetGoogAudioMirroring();
+  properties.goog_auto_gain_control =
+      audio_constraints.GetGoogAutoGainControl();
+  properties.goog_experimental_echo_cancellation =
+      audio_constraints.GetGoogExperimentalEchoCancellation();
+  properties.goog_typing_noise_detection =
+      audio_constraints.GetGoogTypingNoiseDetection();
+  properties.goog_noise_suppression =
+      audio_constraints.GetGoogNoiseSuppression();
+  properties.goog_experimental_noise_suppression =
+      audio_constraints.GetGoogExperimentalNoiseSuppression();
+  properties.goog_beamforming = audio_constraints.GetGoogBeamforming();
+  properties.goog_highpass_filter = audio_constraints.GetGoogHighpassFilter();
+  properties.goog_experimental_auto_gain_control =
+      audio_constraints.GetGoogExperimentalAutoGainControl();
+  properties.goog_array_geometry =
+      GetArrayGeometryPreferringConstraints(audio_constraints, input_params);
+
+  return properties;
+}
+
 EchoInformation::EchoInformation()
     : delay_stats_time_ms_(0),
       echo_frames_received_(false),
       divergent_filter_stats_time_ms_(0),
       num_divergent_filter_fraction_(0),
       num_non_zero_divergent_filter_fraction_(0) {}
 
 EchoInformation::~EchoInformation() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ReportAndResetAecDivergentFilterStats();
@@ skipping 176 matching lines @@
   stats->aec_divergent_filter_fraction = apm_stats.divergent_filter_fraction;
 
   stats->echo_delay_median_ms = apm_stats.delay_median;
   stats->echo_delay_std_ms = apm_stats.delay_standard_deviation;
 
   stats->residual_echo_likelihood = apm_stats.residual_echo_likelihood;
   stats->residual_echo_likelihood_recent_max =
       apm_stats.residual_echo_likelihood_recent_max;
 }
 
-std::vector<webrtc::Point> GetArrayGeometryPreferringConstraints(
+std::vector<media::Point> GetArrayGeometryPreferringConstraints(
     const MediaAudioConstraints& audio_constraints,
     const MediaStreamDevice::AudioDeviceParameters& input_params) {
   const std::string constraints_geometry =
       audio_constraints.GetGoogArrayGeometry();
 
   // 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));
+  return constraints_geometry.empty()
+             ? input_params.mic_positions
+             : media::ParsePointsFromString(constraints_geometry);
+}
+
+bool IsOldAudioConstraints() {
+  return base::FeatureList::IsEnabled(
+      features::kMediaStreamOldAudioConstraints);
 }
 
 }  // namespace content