Adding WebRTC Auto Gain Control Test (linux)

chrome/browser/media/chrome_webrtc_audio_quality_browsertest.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 <ctime>
 
 #include "base/command_line.h"
+#include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/scoped_native_library.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "chrome/browser/media/webrtc_browsertest_audio.h"
 #include "chrome/browser/media/webrtc_browsertest_base.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/test/browser_test_utils.h"
@@ skipping 119 matching lines @@
                               content::WebContents* tab_contents) {
     // This calls into webaudio.js.
     EXPECT_EQ("ok-added", ExecuteJavascript(
         "addAudioFile('" + input_file_relative_url + "')", tab_contents));
   }
 
   void PlayAudioFileThroughWebAudio(content::WebContents* tab_contents) {
     EXPECT_EQ("ok-playing", ExecuteJavascript("playAudioFile()", tab_contents));
   }
 
-  base::FilePath CreateTemporaryWaveFile() {
-    base::FilePath filename;
-    EXPECT_TRUE(base::CreateTemporaryFile(&filename));
-    base::FilePath wav_filename =
-        filename.AddExtension(FILE_PATH_LITERAL(".wav"));
-    EXPECT_TRUE(base::Move(filename, wav_filename));
-    return wav_filename;
-  }
-
   content::WebContents* OpenPageWithoutGetUserMedia(const char* url) {
     chrome::AddTabAt(browser(), GURL(), -1, true);
     ui_test_utils::NavigateToURL(
         browser(), embedded_test_server()->GetURL(url));
     content::WebContents* tab =
         browser()->tab_strip_model()->GetActiveWebContents();
 
     // Prepare the peer connections manually in this test since we don't add
     // getUserMedia-derived media streams in this test like the other tests.
     EXPECT_EQ("ok-peerconnection-created",
               ExecuteJavascript("preparePeerConnection()", tab));
     return tab;
   }
+
+ protected:
+  void TestAutoGainControl(const base::FilePath::StringType& reference_filename,
+                           const std::string& constraints,
+                           const std::string& perf_modifier);
 };
 
+namespace {
+
 class AudioRecorder {
  public:
   AudioRecorder() {}
   ~AudioRecorder() {}
 
   // Starts the recording program for the specified duration. Returns true
-  // on success.
+  // on success. We record in CD format unless record_cd is false, in which case
+  // we record in DAT format.
+  // TODO(phoglund): make win and mac also support the record_cd parameter. Or,
+  // even better, make everybody use the CD format rather than DAT.
   bool StartRecording(int duration_sec, const base::FilePath& output_file,
-                      bool mono) {
+                      bool mono, bool record_cd) {
     EXPECT_FALSE(recording_application_.IsValid())
         << "Tried to record, but is already recording.";
 
     CommandLine command_line(CommandLine::NO_PROGRAM);
 #if defined(OS_WIN)
     // This disable is required to run SoundRecorder.exe on 64-bit Windows
     // from a 32-bit binary. We need to load the wow64 disable function from
     // the DLL since it doesn't exist on Windows XP.
     // TODO(phoglund): find some cleaner solution than using SoundRecorder.exe.
     base::ScopedNativeLibrary kernel32_lib(base::FilePath(L"kernel32"));
@@ skipping 36 matching lines @@
     if (mono) {
       command_line.AppendArg("remix");
       command_line.AppendArg("-");
     }
 #else
     int num_channels = mono ? 1 : 2;
     command_line.SetProgram(base::FilePath("arecord"));
     command_line.AppendArg("-d");
     command_line.AppendArg(base::StringPrintf("%d", duration_sec));
     command_line.AppendArg("-f");
-    command_line.AppendArg("dat");
+    if (record_cd)
+      command_line.AppendArg("cd");
+    else
+      command_line.AppendArg("dat");
     command_line.AppendArg("-c");
     command_line.AppendArg(base::StringPrintf("%d", num_channels));
     command_line.AppendArgPath(output_file);
 #endif
 
     DVLOG(0) << "Running " << command_line.GetCommandLineString();
     recording_application_ =
         base::LaunchProcess(command_line, base::LaunchOptions());
     return recording_application_.IsValid();
   }
@@ skipping 45 matching lines @@
     DVLOG(0) << "Running " << command_line.GetCommandLineString();
     if (!base::GetAppOutput(command_line, &result)) {
       LOG(ERROR) << "Failed to set source volume: output was " << result;
       return false;
     }
   }
 #endif
   return true;
 }
 
+CommandLine MakeSoxCommandLine() {
+#if defined(OS_WIN)
+  base::FilePath sox_path = test::GetReferenceFilesDir().Append(
+      FILE_PATH_LITERAL("tools/sox.exe"));
+  if (!base::PathExists(sox_path)) {
+    LOG(ERROR) << "Missing sox.exe binary in " << sox_path.value()
+               << "; you may have to provide this binary yourself.";
+    return false;
+  }
+  CommandLine command_line(sox_path);
+#else
+  CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("sox")));
+#endif
+  return command_line;
+}
+
 // Removes silence from beginning and end of the |input_audio_file| and writes
 // the result to the |output_audio_file|. Returns true on success.
 bool RemoveSilence(const base::FilePath& input_file,
                    const base::FilePath& output_file) {
   // SOX documentation for silence command: http://sox.sourceforge.net/sox.html
   // To remove the silence from both beginning and end of the audio file, we
   // call sox silence command twice: once on normal file and again on its
   // reverse, then we reverse the final output.
   // Silence parameters are (in sequence):
   // ABOVE_PERIODS: The period for which silence occurs. Value 1 is used for
   //                 silence at beginning of audio.
   // DURATION: the amount of time in seconds that non-silence must be detected
   //           before sox stops trimming audio.
-  // THRESHOLD: value used to indicate what sample value is treates as silence.
+  // THRESHOLD: value used to indicate what sample value is treats as silence.
   const char* kAbovePeriods = "1";
   const char* kDuration = "2";
-  const char* kTreshold = "5%";
+  const char* kTreshold = "3%";
 
-#if defined(OS_WIN)
-  base::FilePath sox_path = test::GetReferenceFilesDir().Append(
-      FILE_PATH_LITERAL("tools/sox.exe"));
-  if (!base::PathExists(sox_path)) {
-    LOG(ERROR) << "Missing sox.exe binary in " << sox_path.value()
-               << "; you may have to provide this binary yourself.";
-    return false;
-  }
-  CommandLine command_line(sox_path);
-#else
-  CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("sox")));
-#endif
+  CommandLine command_line = MakeSoxCommandLine();
   command_line.AppendArgPath(input_file);
   command_line.AppendArgPath(output_file);
   command_line.AppendArg("silence");
   command_line.AppendArg(kAbovePeriods);
   command_line.AppendArg(kDuration);
   command_line.AppendArg(kTreshold);
   command_line.AppendArg("reverse");
   command_line.AppendArg("silence");
   command_line.AppendArg(kAbovePeriods);
   command_line.AppendArg(kDuration);
   command_line.AppendArg(kTreshold);
   command_line.AppendArg("reverse");
 
   DVLOG(0) << "Running " << command_line.GetCommandLineString();
   std::string result;
   bool ok = base::GetAppOutput(command_line, &result);
   DVLOG(0) << "Output was:\n\n" << result;
   return ok;
 }
 
+// Looks for 0.3-second silences (under 1% audio power) and splits the input

[phoglund_chromium, 2014/12/17 18:52:52]

I'm thinking about moving some of these new functions into
webrtc_browsertest_audio in the next patch. In that case I'll probably move
existing helper functions as well, and that would have made this patch harder to
understand so I'll wait with that.

+// file on those silences. Output files are written according to the output file
+// template (e.g. /tmp/out.wav writes /tmp/out001.wav, /tmp/out002.wav, etc if
+// there are two silence-padded regions in the file). The silences between
+// speech segments must be at least 500 ms for this to be reliable.
+bool SplitFileOnSilence(const base::FilePath& input_file,
+                        const base::FilePath& output_file_template) {
+  CommandLine command_line = MakeSoxCommandLine();
+
+  // These are experimentally determined and work on the files we use.
+  const char* kAbovePeriods = "1";
+  const char* kUnderPeriods = "1";
+  const char* kDuration = "0.3";
+  const char* kTreshold = "1%";
+  command_line.AppendArgPath(input_file);
+  command_line.AppendArgPath(output_file_template);
+  command_line.AppendArg("silence");
+  command_line.AppendArg(kAbovePeriods);
+  command_line.AppendArg(kDuration);
+  command_line.AppendArg(kTreshold);
+  command_line.AppendArg(kUnderPeriods);
+  command_line.AppendArg(kDuration);
+  command_line.AppendArg(kTreshold);
+  command_line.AppendArg(":");
+  command_line.AppendArg("newfile");
+  command_line.AppendArg(":");
+  command_line.AppendArg("restart");
+
+  DVLOG(0) << "Running " << command_line.GetCommandLineString();
+  std::string result;
+  bool ok = base::GetAppOutput(command_line, &result);
+  DVLOG(0) << "Output was:\n\n" << result;
+  return ok;
+}
+
 bool CanParseAsFloat(const std::string& value) {
   return atof(value.c_str()) != 0 || value == "0";
 }
 
 // Runs PESQ to compare |reference_file| to a |actual_file|. The |sample_rate|
 // can be either 16000 or 8000.
 //
 // PESQ is only mono-aware, so the files should preferably be recorded in mono.
 // Furthermore it expects the file to be 16 rather than 32 bits, even though
 // 32 bits might work. The audio bandwidth of the two files should be the same
@@ skipping 50 matching lines @@
   // There are two tab-separated numbers on the format x.xxx, e.g. 5 chars each.
   std::size_t first_number_pos = anchor_pos + result_anchor.length();
   *raw_mos = result.substr(first_number_pos, 5);
   EXPECT_TRUE(CanParseAsFloat(*raw_mos)) << "Failed to parse raw MOS number.";
   *mos_lqo = result.substr(first_number_pos + 5 + 1, 5);
   EXPECT_TRUE(CanParseAsFloat(*mos_lqo)) << "Failed to parse MOS LQO number.";
 
   return true;
 }
 
+base::FilePath CreateTemporaryWaveFile() {
+  base::FilePath filename;
+  EXPECT_TRUE(base::CreateTemporaryFile(&filename));
+  base::FilePath wav_filename =
+      filename.AddExtension(FILE_PATH_LITERAL(".wav"));
+  EXPECT_TRUE(base::Move(filename, wav_filename));
+  return wav_filename;
+}
+
+std::vector<base::FilePath> ListWavFilesInDir(const base::FilePath& dir) {
+  base::FileEnumerator files(dir, false, base::FileEnumerator::FILES,
+                             FILE_PATH_LITERAL("*.wav"));
+
+  std::vector<base::FilePath> result;
+  for (base::FilePath name = files.Next(); !name.empty(); name = files.Next())
+    result.push_back(name);
+  return result;
+}
+
+// Splits |to_split| into sub-files base on silence. The file you use must have
+// at least 500 ms periods of silence between speech segments for this to be
+// reliable.
+void SplitFileOnSilenceIntoDir(const base::FilePath& to_split,
+                               const base::FilePath& workdir) {
+  // First trim beginning and end since they are tricky for the splitter.
+  base::FilePath trimmed_audio = CreateTemporaryWaveFile();
+
+  ASSERT_TRUE(RemoveSilence(to_split, trimmed_audio));
+  DVLOG(0) << "Trimmed silence: " << trimmed_audio.value() << std::endl;
+
+  ASSERT_TRUE(SplitFileOnSilence(trimmed_audio, workdir.Append("output.wav")));
+  ASSERT_TRUE(base::DeleteFile(trimmed_audio, false));
+}
+
+// Computes the difference between the energy dBFS values for the actual and
+// reference audio segment. Returns values as a comma-separated string. The
+// segments do not have to have the exact same length, but this function will
+// fail the the test if the difference is too big (if it is, we're likely

[bjornv, 2014/12/18 11:30:27]

Remove one "the"

+// comparing unrelated segments with each other).
+//
+// The ref energy is subtracted from the actual energy, so "6" means the actual
+// file is 6 dBFS units louder than the reference for one particular 10ms

[bjornv, 2014/12/18 11:30:27]

dBFS here is wrong. It is simply dB. The reference to Full Scale was lost in the
subtraction.

The math:
10*log(Energy_A/Energy_full_scale) - 10*log(Energy_B/Energy_full_scale)
= 10*log(Energy_A/Energy_full_scale * Energy_full_scale/Energy_B)
= 10*log(Energy_A/Energy_B)

AND
I thought we agreed on computing the energy for the whole segment and not
multiple 10 ms chunks. That was only used for verify there was no weird effects
when AGC was disabled.

+// interval within a segment.
+std::string AnalyzeOneSegment(const base::FilePath& ref_segment,
+                              const base::FilePath& actual_segment,
+                              int segment_number) {
+  std::vector<float> ref_energy =
+      test::ComputeAudioEnergyForWavFile(ref_segment);
+  std::vector<float> actual_energy =
+      test::ComputeAudioEnergyForWavFile(actual_segment);
+
+  // If this fires the AGC probably enhances noise so much it goes above our
+  // silence threshold in the silence splitting. Either WebRTC is butchering
+  // audio or the silence threshold is too low.
+  EXPECT_LT(std::abs(static_cast<int>(ref_energy.size()) -
+                     static_cast<int>(actual_energy.size())), 50)
+      << "Differing more than 50 10 ms periods for segment " << segment_number
+      << "; appears that output audio is very different from ref audio.";
+
+  // Compare as many samples as possible.
+  size_t num_comparable_samples =
+      std::min(ref_energy.size(), actual_energy.size());
+
+  std::vector<std::string> result;
+  for (size_t i = 0; i < num_comparable_samples; i++) {
+    int rounded_value = std::round(actual_energy[i] - ref_energy[i]);
+    result.push_back(base::StringPrintf("%d", rounded_value));
+  }
+  return JoinString(result, ',');
+}
+
+void AnalyzeSegmentsAndPrintResult(
+    const std::vector<base::FilePath>& ref_segments,
+    const std::vector<base::FilePath>& actual_segments,
+    const base::FilePath& reference_file,
+    const std::string& perf_modifier) {
+  ASSERT_GT(ref_segments.size(), 0u)
+      << "Failed to split reference file on silence; sox is likely broken.";
+  ASSERT_EQ(ref_segments.size(), actual_segments.size())
+      << "The recording did not result in the same number of audio segments "
+      << "after on splitting on silence; WebRTC must have deformed the audio "
+      << "too much.";
+
+  for (size_t i = 0; i < ref_segments.size(); i++) {

[bjornv, 2014/12/18 11:30:27]

Don't compare the first 1-2 segments, due to AGC convergence time.

+    std::string dbfs_difference_csv = AnalyzeOneSegment(ref_segments[i],
+                                                        actual_segments[i],
+                                                        i);
+    std::string trace_name = base::StringPrintf(
+        "%s_segment_%zu", reference_file.BaseName().value().c_str(), i);
+    perf_test::PrintResultList("agc_energy_mod", perf_modifier, trace_name,
+                               dbfs_difference_csv, "dBFS", false);
+  }
+}
+
+}  // namespace
+
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MANUAL_TestAudioQuality) {
   if (OnWinXp()) {
     LOG(ERROR) << "This test is not implemented for Windows XP.";
     return;
   }
   if (OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "Temporarily disabled for Win 8.";
     return;
@@ skipping 16 matching lines @@
   // because the ready state is ok on both sides. We sleep a bit between call
   // establishment and playing to avoid cutting off the beginning of the stream.
   test::SleepInJavascript(left_tab, 2000);
 
   base::FilePath recording = CreateTemporaryWaveFile();
 
   // Note: the sound clip is about 10 seconds: record for 15 seconds to get some
   // safety margins on each side.
   AudioRecorder recorder;
   static int kRecordingTimeSeconds = 15;
-  ASSERT_TRUE(recorder.StartRecording(kRecordingTimeSeconds, recording, true));
+  ASSERT_TRUE(recorder.StartRecording(kRecordingTimeSeconds, recording,
+                                      true, false));
 
   PlayAudioFileThroughWebAudio(left_tab);
 
   ASSERT_TRUE(recorder.WaitForRecordingToEnd());
   DVLOG(0) << "Done recording to " << recording.value() << std::endl;
 
   HangUp(left_tab);
 
   base::FilePath trimmed_recording = CreateTemporaryWaveFile();
 
   ASSERT_TRUE(RemoveSilence(recording, trimmed_recording));
   DVLOG(0) << "Trimmed silence: " << trimmed_recording.value() << std::endl;
 
   std::string raw_mos;
   std::string mos_lqo;
   base::FilePath reference_file_in_test_dir =
       test::GetReferenceFilesDir().Append(kReferenceFile);
   ASSERT_TRUE(RunPesq(reference_file_in_test_dir, trimmed_recording, 16000,
                       &raw_mos, &mos_lqo));
 
   perf_test::PrintResult("audio_pesq", "", "raw_mos", raw_mos, "score", true);
   perf_test::PrintResult("audio_pesq", "", "mos_lqo", mos_lqo, "score", true);
 
   EXPECT_TRUE(base::DeleteFile(recording, false));
   EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
 }
 
-IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
-                       MANUAL_TestAutoGainControlIncreasesEnergyForLowAudio) {
+/**
+ * The auto gain control test plays a file into the fake microphone. Then it
+ * sets up a one-way WebRTC call with audio only and records Chrome's output on
+ * the receiving side using the audio loopback provided by the quality test
+ * (see the class comments for more details).
+ *
+ * Then both the recording and reference file are split on silence. This creates
+ * a number of segments with speech in them. The reason for this is to provide
+ * a kind of synchronization mechanism so the start of each speech segment is
+ * compared to the start of the corresponding speech segment. This is because we
+ * will experience inevitable clock drift between the system clock (which runs
+ * the fake microphone) and the sound card (which runs play-out). Effectively
+ * re-synchronizing on each segment mitigates this.
+ *
+ * The silence splitting is inherently sensitive to the sound file we run on.
+ * Therefore the reference file must have at least 500 ms of pure silence
+ * between speech segments; the test will fail if the output produces more
+ * segments than the reference.
+ *
+ * The test reports the difference in dBFS units between the reference and
+ * output file per 10 ms interval in each speech segment. A value of 6 means the
+ * output was 6 dBFS units louder than the reference, presumably because the
+ * AGC applied gain to the signal.
+ *
+ * We record in CD format here (44.1 kHz) because that's what the fake input
+ * device currently supports, and we want to be able to compare directly.
+ */
+void MAYBE_WebRtcAudioQualityBrowserTest::TestAutoGainControl(
+    const base::FilePath::StringType& reference_filename,
+    const std::string& constraints,
+    const std::string& perf_modifier) {
   if (OnWinXp()) {
     LOG(ERROR) << "This test is not implemented for Windows XP.";
     return;
   }
   if (OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "Temporarily disabled for Win 8.";
     return;
   }
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
 
-  ConfigureFakeDeviceToPlayFile(
-      test::GetReferenceFilesDir().Append(kAgcTestReferenceFile));
+  base::FilePath reference_file =
+      test::GetReferenceFilesDir().Append(reference_filename);
+  ConfigureFakeDeviceToPlayFile(reference_file);
 
   // Create a one-way call.
   GURL test_page = embedded_test_server()->GetURL(kWebRtcAudioTestHtmlPage);
   content::WebContents* left_tab =
-      OpenPageAndGetUserMediaInNewTabWithConstraints(test_page,
-                                                     kAudioOnlyCallConstraints);
+      OpenPageAndGetUserMediaInNewTabWithConstraints(test_page, constraints);
   SetupPeerconnectionWithLocalStream(left_tab);
 
   content::WebContents* right_tab =
       OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
 
-  NegotiateCall(left_tab, right_tab);
-
   base::FilePath recording = CreateTemporaryWaveFile();
 
   AudioRecorder recorder;
-  static int kRecordingTimeSeconds = 10;
-  ASSERT_TRUE(recorder.StartRecording(kRecordingTimeSeconds, recording, true));
+  static int kRecordingTimeSeconds = 25;
+  ASSERT_TRUE(recorder.StartRecording(kRecordingTimeSeconds, recording, false,
+                                      true));
+
+  NegotiateCall(left_tab, right_tab);
 
   ASSERT_TRUE(recorder.WaitForRecordingToEnd());
   DVLOG(0) << "Done recording to " << recording.value() << std::endl;
 
   HangUp(left_tab);
 
-  base::FilePath trimmed_recording = CreateTemporaryWaveFile();
+  // Call Take() on the scoped temp dirs if you want to look at the files after
+  // the test exits (the default is to delete the files).
+  base::ScopedTempDir split_ref_files;
+  ASSERT_TRUE(split_ref_files.CreateUniqueTempDir());
+  ASSERT_NO_FATAL_FAILURE(
+      SplitFileOnSilenceIntoDir(reference_file, split_ref_files.path()));
+  std::vector<base::FilePath> ref_segments =
+      ListWavFilesInDir(split_ref_files.path());
 
-  ASSERT_TRUE(RemoveSilence(recording, trimmed_recording));
-  DVLOG(0) << "Trimmed silence: " << trimmed_recording.value() << std::endl;
+  base::ScopedTempDir split_actual_files;
+  ASSERT_TRUE(split_actual_files.CreateUniqueTempDir());
+  ASSERT_NO_FATAL_FAILURE(
+      SplitFileOnSilenceIntoDir(recording, split_actual_files.path()));
+  std::vector<base::FilePath> actual_segments =
+      ListWavFilesInDir(split_actual_files.path());
 
-  // TODO(phoglund): invoke bjornv's audio energy analysis tool on the trimmed
-  // recording and log the result.
+  AnalyzeSegmentsAndPrintResult(ref_segments, actual_segments, reference_file,
+                                perf_modifier);
 
   EXPECT_TRUE(base::DeleteFile(recording, false));
-  EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
 }
+
+// Only implemented for Linux for now.
+#if defined(OS_LINUX)
+#define MAYBE_MANUAL_TestAutoGainControlOnLowAudio \
+        MANUAL_TestAutoGainControlOnLowAudio
+#else
+#define MAYBE_MANUAL_TestAutoGainControlOnLowAudio \
+        DISABLED_MANUAL_TestAutoGainControlOnLowAudio
+#endif
+
+// The AGC should apply gain here on the order of 5-6 dBFS units.
+IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
+                       MAYBE_MANUAL_TestAutoGainControlOnLowAudio) {
+  ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
+      kAgcTestReferenceFile, kAudioOnlyCallConstraints, "with_agc"));
+}
+
+// Only implemented for Linux for now.
+#if defined(OS_LINUX)
+#define MAYBE_MANUAL_TestComputeGainWithAudioProcessingOff \
+        MANUAL_TestComputeGainWithAudioProcessingOff
+#else
+#define MAYBE_MANUAL_TestComputeGainWithAudioProcessingOff \
+        DISABLED_MANUAL_TestComputeGainWithAudioProcessingOff
+#endif
+
+// Since the AGC is off here there should be no gain at all.
+IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
+                       MAYBE_MANUAL_TestComputeGainWithAudioProcessingOff) {
+  const char* kAudioCallWithoutAudioProcessing =
+      "{audio: { mandatory: { echoCancellation: false } } }";
+  ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
+      kAgcTestReferenceFile, kAudioCallWithoutAudioProcessing, "no_agc"));
+}
+