Add feature for decreasing ProcessingAudioFifo size

If ChromeWideEchoCancellation is enabled, we now use the
DecreaseProcessingAudioFifoSize experiment to set the size of the
ProcessingAudioFifo. If the experiment is disabled, the size defaults
to 110.

This simultaneously removes the
kChromeWideEchoCancellationProcessingFifoSize parameter from the
ChromeWideEchoCancellation feature. This parameter is always set to
110 today, so this CL does not change existing behaviour.

Bug: 1420568
Change-Id: Ic344cf30b04a5ca3ee011b387999fb5572185afe
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4356940
Reviewed-by: Olga Sharonova <olka@chromium.org>
Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Commit-Queue: Fredrik Hernqvist <fhernqvist@google.com>
Cr-Commit-Position: refs/heads/main@{#1120815}

chrome/browser/media/webrtc/webrtc_text_log_handler.cc

@@ -527,10 +527,7 @@ void WebRtcTextLogHandler::OnGetNetworkInterfaceListFinish(
 #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
   if (media::IsChromeWideEchoCancellationEnabled()) {
     LogToCircularBuffer(base::StrCat(
-        {"ChromeWideEchoCancellation : Enabled", ", processing_fifo_size = ",
-         NumberToString(
-             media::kChromeWideEchoCancellationProcessingFifoSize.Get()),
-         ", minimize_resampling = ",
+        {"ChromeWideEchoCancellation : Enabled", ", minimize_resampling = ",
          media::kChromeWideEchoCancellationMinimizeResampling.Get() ? "true"
                                                                     : "false",
          ", allow_all_sample_rates = ",
@@ -540,6 +537,14 @@ void WebRtcTextLogHandler::OnGetNetworkInterfaceListFinish(
   } else {
     LogToCircularBuffer("ChromeWideEchoCancellation : Disabled");
   }
+
+  if (base::FeatureList::IsEnabled(media::kDecreaseProcessingAudioFifoSize)) {
+    LogToCircularBuffer(base::StrCat(
+        {"DecreaseProcessingAudioFifoSize : Enabled", ", fifo_size = ",
+         base::NumberToString(media::GetProcessingAudioFifoSize())}));
+  } else {
+    LogToCircularBuffer("DecreaseProcessingAudioFifoSize : Disabled");
+  }
 #endif
 
   // Audio manager

content/browser/media/media_internals.cc

@@ -499,11 +499,7 @@ void MediaInternals::SendGeneralAudioInformation() {
   std::string chrome_wide_echo_cancellation_value_string =
       media::IsChromeWideEchoCancellationEnabled()
           ? base::StrCat(
-                {"Enabled, processing_fifo_size = ",
-                 base::NumberToString(
-                     media::kChromeWideEchoCancellationProcessingFifoSize
-                         .Get()),
-                 ", minimize_resampling = ",
+                {"Enabled, minimize_resampling = ",
                  media::kChromeWideEchoCancellationMinimizeResampling.Get()
                      ? "true"
                      : "false",
@@ -514,6 +510,16 @@ void MediaInternals::SendGeneralAudioInformation() {
           : "Disabled";
   audio_info_data.Set(media::kChromeWideEchoCancellation.name,
                       base::Value(chrome_wide_echo_cancellation_value_string));
+
+  std::string decrease_processing_audio_fifo_size_value_string =
+      base::FeatureList::IsEnabled(media::kDecreaseProcessingAudioFifoSize)
+          ? base::StrCat(
+                {"Enabled, fifo_size = ",
+                 base::NumberToString(media::GetProcessingAudioFifoSize())})
+          : "Disabled";
+  audio_info_data.Set(
+      media::kDecreaseProcessingAudioFifoSize.name,
+      base::Value(decrease_processing_audio_fifo_size_value_string));
 #endif
   std::u16string audio_info_update =
       SerializeUpdate("media.updateGeneralAudioInformation", audio_info_data);

media/base/media_switches.cc

@@ -425,15 +425,6 @@ BASE_FEATURE(kChromeWideEchoCancellation,
 #endif
              );
 
-// If non-zero, audio processing is done on a dedicated processing thread which
-// receives audio from the audio capture thread via a fifo of a specified size.
-// Zero fifo size means the usage of such processing thread is disabled and
-// processing is done on the audio capture thread itself.
-const base::FeatureParam<int> kChromeWideEchoCancellationProcessingFifoSize{
-    &kChromeWideEchoCancellation, "processing_fifo_size",
-    110  // Default value for the enabled feature.
-};
-
 // When audio processing is done in the audio process, at the renderer side IPC
 // is set up to receive audio at the processing sample rate. This is a
 // kill-switch to fallback to receiving audio at the default sample rate of the
@@ -457,6 +448,27 @@ const base::FeatureParam<double>
 // https://crbug.com/1332484.
 const base::FeatureParam<bool> kChromeWideEchoCancellationAllowAllSampleRates{
     &kChromeWideEchoCancellation, "allow_all_sample_rates", true};
+
+// https://crbug.com/1420568
+// Applicable only if kChromeWideEchoCancellation is enabled.
+// If disabled, the ProcessingAudioFifo size defaults to 110.
+// If enabled, the ProcessingAudioFifo size is set to the value of the fifo_size
+// parameter.
+//
+// If the ProcessingAudioFifo size is non-zero, audio processing is done on a
+// dedicated processing thread which receives audio from the audio capture
+// thread via a fifo of a specified size.
+// If the ProcessingAudioFifo size is zero, the usage of this processing thread
+// is disabled and processing is done on the audio capture thread itself.
+BASE_FEATURE(kDecreaseProcessingAudioFifoSize,
+             "DecreaseProcessingAudioFifoSize",
+             base::FEATURE_DISABLED_BY_DEFAULT);
+
+const base::FeatureParam<int> kDecreaseProcessingAudioFifoSizeValue{
+    &kDecreaseProcessingAudioFifoSize, "fifo_size",
+    110  // Default value for the enabled feature.
+};
+
 #endif
 
 #if BUILDFLAG(IS_CHROMEOS)
@@ -1424,6 +1436,20 @@ bool IsChromeWideEchoCancellationEnabled() {
 #endif
 }
 
+int GetProcessingAudioFifoSize() {
+#if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
+  if (!IsChromeWideEchoCancellationEnabled()) {
+    return 0;
+  }
+  if (base::FeatureList::IsEnabled(media::kDecreaseProcessingAudioFifoSize)) {
+    return media::kDecreaseProcessingAudioFifoSizeValue.Get();
+  }
+  return 110;
+#else
+  return 0;
+#endif
+}
+
 bool IsHardwareSecureDecryptionEnabled() {
   return base::FeatureList::IsEnabled(kHardwareSecureDecryption) ||
          base::FeatureList::IsEnabled(kHardwareSecureDecryptionExperiment);

media/base/media_switches.h

@@ -164,14 +164,15 @@ MEDIA_EXPORT BASE_DECLARE_FEATURE(kCdmHostVerification);
 MEDIA_EXPORT BASE_DECLARE_FEATURE(kCdmProcessSiteIsolation);
 #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
 MEDIA_EXPORT BASE_DECLARE_FEATURE(kChromeWideEchoCancellation);
-MEDIA_EXPORT extern const base::FeatureParam<int>
-    kChromeWideEchoCancellationProcessingFifoSize;
 MEDIA_EXPORT extern const base::FeatureParam<bool>
     kChromeWideEchoCancellationMinimizeResampling;
 MEDIA_EXPORT extern const base::FeatureParam<double>
     kChromeWideEchoCancellationDynamicMixingTimeout;
 MEDIA_EXPORT extern const base::FeatureParam<bool>
     kChromeWideEchoCancellationAllowAllSampleRates;
+MEDIA_EXPORT BASE_DECLARE_FEATURE(kDecreaseProcessingAudioFifoSize);
+MEDIA_EXPORT extern const base::FeatureParam<int>
+    kDecreaseProcessingAudioFifoSizeValue;
 #endif
 #if BUILDFLAG(IS_CHROMEOS)
 MEDIA_EXPORT BASE_DECLARE_FEATURE(kCrOSSystemAEC);
@@ -421,6 +422,7 @@ MEDIA_EXPORT std::string GetEffectiveAutoplayPolicy(
     const base::CommandLine& command_line);
 
 MEDIA_EXPORT bool IsChromeWideEchoCancellationEnabled();
+MEDIA_EXPORT int GetProcessingAudioFifoSize();
 MEDIA_EXPORT bool IsHardwareSecureDecryptionEnabled();
 MEDIA_EXPORT bool IsVideoCaptureAcceleratedJpegDecodingEnabled();
 

services/audio/input_controller.cc

@@ -264,10 +264,7 @@ void InputController::MaybeSetUpAudioProcessing(
     return;
   }
 
-  int fifo_size =
-      media::IsChromeWideEchoCancellationEnabled()
-          ? media::kChromeWideEchoCancellationProcessingFifoSize.Get()
-          : 0;
+  int fifo_size = media::GetProcessingAudioFifoSize();
 
   // Only use the FIFO/new thread if its size is explicitly set.
   if (fifo_size) {