WebRtcHybridAgc experiment: wire up AGC2 AVX2 kill switch

AGC2 includes SIMD optimizations for different platforms.
Recently, AVX2 code has been added (see [1]) and a kill switch
has been added to the GainController2 configuration in APM.
When `avx2_allowed` is set to false, AVX2 won't be used even if
available.

Tested: appr.tc call made

[1] third_party/webrtc/modules/audio_processing/agc2/rnn_vad/vector_math_avx2.cc

Bug: webrtc:7494
Change-Id: I12fe73008e4d1a434d2e57b38fef191e6db0d71f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2580528Reviewed-by: Olga Sharonova <olka@chromium.org>
Commit-Queue: Ale Bzk <alessiob@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836614}

third_party/blink/renderer/modules/mediastream/media_stream_audio_processor.cc

@@ -613,6 +613,8 @@ void MediaStreamAudioProcessor::InitializeAudioProcessingModule(
       agc2_properties->max_output_noise_level_dbfs =
           base::GetFieldTrialParamByFeatureAsInt(
               features::kWebRtcHybridAgc, "max_output_noise_level_dbfs", -50);
+      agc2_properties->avx2_allowed = base::GetFieldTrialParamByFeatureAsBool(
+          features::kWebRtcHybridAgc, "avx2_allowed", true);
     }
     blink::ConfigAutomaticGainControl(
         properties.goog_auto_gain_control,

third_party/blink/renderer/modules/mediastream/media_stream_audio_processor.h

@@ -11,6 +11,7 @@
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
+#include "base/optional.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "media/webrtc/audio_delay_stats_reporter.h"
@@ -117,7 +118,11 @@ class MODULES_EXPORT MediaStreamAudioProcessor
   friend class MediaStreamAudioProcessorTest;
 
   FRIEND_TEST_ALL_PREFIXES(MediaStreamAudioProcessorTest,
-                           GetAecDumpMessageFilter);
+                           TestAgcEnableDefaultAgc1);
+  FRIEND_TEST_ALL_PREFIXES(MediaStreamAudioProcessorTest,
+                           TestAgcEnableHybridAgc);
+  FRIEND_TEST_ALL_PREFIXES(MediaStreamAudioProcessorTest,
+                           TestAgcEnableHybridAgcAvx2NotAllowed);
 
   // WebRtcPlayoutDataSource::Sink implementation.
   void OnPlayoutData(media::AudioBus* audio_bus,
@@ -126,6 +131,14 @@ class MODULES_EXPORT MediaStreamAudioProcessor
   void OnPlayoutDataSourceChanged() override;
   void OnRenderThreadChanged() override;
 
+  base::Optional<webrtc::AudioProcessing::Config>
+  GetAudioProcessingModuleConfig() const {
+    if (audio_processing_) {
+      return audio_processing_->GetConfig();
+    }
+    return base::nullopt;
+  }
+
   // This method is called on the libjingle thread.
   AudioProcessorStatistics GetStats(bool has_remote_tracks) override;
 

third_party/blink/renderer/modules/mediastream/media_stream_audio_processor_test.cc

@@ -14,12 +14,14 @@
 #include "base/memory/aligned_memory.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "build/chromecast_buildflags.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
+#include "media/webrtc/webrtc_switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/mediastream/media_stream_request.h"
@@ -392,4 +394,110 @@ TEST_F(MediaStreamAudioProcessorTest, MAYBE_TestWithKeyboardMicChannel) {
   audio_processor->Stop();
 }
 
+TEST_F(MediaStreamAudioProcessorTest, TestAgcEnableDefaultAgc1) {
+  ::base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndDisableFeature(features::kWebRtcHybridAgc);
+
+  blink::AudioProcessingProperties properties;
+  properties.goog_auto_gain_control = true;
+  properties.goog_experimental_auto_gain_control = false;
+
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
+      new rtc::RefCountedObject<WebRtcAudioDeviceImpl>());
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new rtc::RefCountedObject<MediaStreamAudioProcessor>(
+          properties, webrtc_audio_device.get()));
+
+  base::Optional<webrtc::AudioProcessing::Config> apm_config =
+      audio_processor->GetAudioProcessingModuleConfig();
+  ASSERT_TRUE(apm_config);
+
+  EXPECT_TRUE(apm_config->gain_controller1.enabled);
+  EXPECT_EQ(
+      apm_config->gain_controller1.mode,
+#if defined(OS_ANDROID)
+      webrtc::AudioProcessing::Config::GainController1::Mode::kFixedDigital);
+#else
+      webrtc::AudioProcessing::Config::GainController1::Mode::kAdaptiveAnalog);
+#endif  // defined(OS_ANDROID)
+}
+
+TEST_F(MediaStreamAudioProcessorTest, TestAgcEnableHybridAgc) {
+  ::base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndEnableFeatureWithParameters(
+      features::kWebRtcHybridAgc,
+      {{"vad_probability_attack", "0.2"},
+       {"use_peaks_not_rms", "true"},
+       {"level_estimator_speech_frames_threshold", "3"},
+       {"initial_saturation_margin", "10"},
+       {"extra_saturation_margin", "11"},
+       {"gain_applier_speech_frames_threshold", "5"},
+       {"max_gain_change_db_per_second", "4"},
+       {"max_output_noise_level_dbfs", "-22"},
+       {"avx2_allowed", "true"}});
+
+  blink::AudioProcessingProperties properties;
+  properties.goog_auto_gain_control = true;
+  properties.goog_experimental_auto_gain_control = true;
+
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
+      new rtc::RefCountedObject<WebRtcAudioDeviceImpl>());
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new rtc::RefCountedObject<MediaStreamAudioProcessor>(
+          properties, webrtc_audio_device.get()));
+
+  base::Optional<webrtc::AudioProcessing::Config> apm_config =
+      audio_processor->GetAudioProcessingModuleConfig();
+  ASSERT_TRUE(apm_config);
+
+  EXPECT_TRUE(apm_config->gain_controller1.enabled);
+  EXPECT_EQ(
+      apm_config->gain_controller1.mode,
+#if defined(OS_ANDROID)
+      webrtc::AudioProcessing::Config::GainController1::Mode::kFixedDigital);
+#else
+      webrtc::AudioProcessing::Config::GainController1::Mode::kAdaptiveAnalog);
+#endif  // defined(OS_ANDROID)
+  EXPECT_TRUE(apm_config->gain_controller2.enabled);
+  // `compression_gain_db` has no effect when hybrid AGC is active.
+  EXPECT_EQ(apm_config->gain_controller2.fixed_digital.gain_db, 0);
+
+  const auto& adaptive_digital = apm_config->gain_controller2.adaptive_digital;
+  EXPECT_TRUE(adaptive_digital.enabled);
+  EXPECT_FLOAT_EQ(adaptive_digital.vad_probability_attack, 0.2f);
+  EXPECT_EQ(
+      adaptive_digital.level_estimator,
+      webrtc::AudioProcessing::Config::GainController2::LevelEstimator::kPeak);
+  EXPECT_EQ(adaptive_digital.level_estimator_adjacent_speech_frames_threshold,
+            3);
+  EXPECT_FLOAT_EQ(adaptive_digital.initial_saturation_margin_db, 10);
+  EXPECT_FLOAT_EQ(adaptive_digital.extra_saturation_margin_db, 11);
+  EXPECT_EQ(adaptive_digital.gain_applier_adjacent_speech_frames_threshold, 5);
+  EXPECT_FLOAT_EQ(adaptive_digital.max_gain_change_db_per_second, 4);
+  EXPECT_FLOAT_EQ(adaptive_digital.max_output_noise_level_dbfs, -22);
+  EXPECT_TRUE(adaptive_digital.avx2_allowed);
+}
+
+TEST_F(MediaStreamAudioProcessorTest, TestAgcEnableHybridAgcAvx2NotAllowed) {
+  ::base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndEnableFeatureWithParameters(features::kWebRtcHybridAgc,
+                                                  {{"avx2_allowed", "false"}});
+
+  blink::AudioProcessingProperties properties;
+  properties.goog_auto_gain_control = true;
+  properties.goog_experimental_auto_gain_control = true;
+
+  scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
+      new rtc::RefCountedObject<WebRtcAudioDeviceImpl>());
+  scoped_refptr<MediaStreamAudioProcessor> audio_processor(
+      new rtc::RefCountedObject<MediaStreamAudioProcessor>(
+          properties, webrtc_audio_device.get()));
+
+  base::Optional<webrtc::AudioProcessing::Config> apm_config =
+      audio_processor->GetAudioProcessingModuleConfig();
+  ASSERT_TRUE(apm_config);
+
+  EXPECT_FALSE(apm_config->gain_controller2.adaptive_digital.avx2_allowed);
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options.cc

@@ -246,6 +246,8 @@ void ConfigAutomaticGainControl(
 
       adaptive_digital.max_output_noise_level_dbfs =
           agc2_properties->max_output_noise_level_dbfs;
+
+      adaptive_digital.avx2_allowed = agc2_properties->avx2_allowed;
     }
   } else if (use_fixed_digital_agc2) {
     // Experimental AGC is disabled, thus hybrid AGC is disabled. Config AGC2

third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options.h

@@ -125,6 +125,7 @@ struct PLATFORM_EXPORT AdaptiveGainController2Properties {
   int gain_applier_speech_frames_threshold;
   int max_gain_change_db_per_second;
   int max_output_noise_level_dbfs;
+  bool avx2_allowed;
 };
 
 // Configures automatic gain control in `apm_config`. If `agc_enabled` is true

third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc

@@ -51,6 +51,7 @@ TEST(ConfigAutomaticGainControlTest, EnableHybridAGC) {
   agc2_properties.gain_applier_speech_frames_threshold = 5;
   agc2_properties.max_gain_change_db_per_second = 4;
   agc2_properties.max_output_noise_level_dbfs = -22;
+  agc2_properties.avx2_allowed = true;
   const double compression_gain_db = 10.0;
 
   ConfigAutomaticGainControl(
@@ -88,6 +89,7 @@ TEST(ConfigAutomaticGainControlTest, EnableHybridAGC) {
                   agc2_properties.max_gain_change_db_per_second);
   EXPECT_FLOAT_EQ(adaptive_digital.max_output_noise_level_dbfs,
                   agc2_properties.max_output_noise_level_dbfs);
+  EXPECT_TRUE(adaptive_digital.avx2_allowed);
 }
 
 TEST(PopulateApmConfigTest, DefaultWithoutConfigJson) {