Removing silence trimming from WebRTC quality test.

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"
@@ skipping 36 matching lines @@
 #define MAYBE_WebRtcAudioQualityBrowserTest WebRtcAudioQualityBrowserTest
 #else
 // Not implemented on Android, ChromeOS etc.
 #define MAYBE_WebRtcAudioQualityBrowserTest DISABLED_WebRtcAudioQualityBrowserTest
 #endif
 
 }  // namespace
 
 // Test we can set up a WebRTC call and play audio through it.
 //
+// WARNING: this test may mess with both output and input levels on your system
+//          and may cause audio to start blasting at full volume into your
+//          headphones.
+//
 // If you're not a googler and want to run this test, you need to provide a
 // pesq binary for your platform (and sox.exe on windows). Read more on how
 // resources are managed in chrome/test/data/webrtc/resources/README.
 //
 // This test will only work on machines that have been configured to record
 // their own input.
 //
 // On Linux:
 // 1. # sudo apt-get install pavucontrol sox
 // 2. For the user who will run the test: # pavucontrol
@@ skipping 32 matching lines @@
 // 1. Control panel > Sound > Manage audio devices.
 // 2. In the recording tab, right-click in an empty space in the pane with the
 //    devices. Tick 'show disabled devices'.
 // 3. You should see a 'stero mix' device - this is what your speakers output.
 //    Right click > Properties.
 // 4. In the Listen tab for the mix device, check the 'listen to this device'
 //    checkbox. Ensure the mix device is the default recording device.
 // 5. Launch chrome and try playing a video with sound. You should see
 //    in the volume meter for the mix device. Configure the mix device to have
 //    50 / 100 in level. Also go into the playback tab, right-click Speakers,
-//    and set that level to 50 / 100. Otherwise you will get distortion in
+//    and set that level to 50 / 100. Otherwise you might get distortion in
 //    the recording.
 class MAYBE_WebRtcAudioQualityBrowserTest : public WebRtcTestBase {
  public:
   MAYBE_WebRtcAudioQualityBrowserTest() {}
   void SetUpInProcessBrowserTestFixture() override {
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EXPECT_FALSE(command_line->HasSwitch(
@@ skipping 122 matching lines @@
   // Joins the recording program. Returns true on success.
   bool WaitForRecordingToEnd() {
     int exit_code = -1;
     recording_application_.WaitForExit(&exit_code);
     return exit_code == 0;
   }
  private:
   base::Process recording_application_;
 };
 
-bool ForceMicrophoneVolumeTo100Percent() {
+bool ForceMicrophoneLevelTo100Percent() {
 #if defined(OS_WIN)
   // Note: the force binary isn't in tools since it's one of our own.
   base::CommandLine command_line(test::GetReferenceFilesDir().Append(
       FILE_PATH_LITERAL("force_mic_volume_max.exe")));
   DVLOG(0) << "Running " << command_line.GetCommandLineString();
   std::string result;
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to set source volume: output was " << result;
     return false;
   }
@@ skipping 217 matching lines @@
 }
 
 // Splits |to_split| into sub-files based 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();
 
+  // TODO(phoglund): find smarter way to do this and get rid of RemoveSilence.
   ASSERT_TRUE(RemoveSilence(to_split, trimmed_audio));
   DVLOG(0) << "Trimmed silence: " << trimmed_audio.value() << std::endl;
 
   ASSERT_TRUE(SplitFileOnSilence(
       trimmed_audio, workdir.Append(FILE_PATH_LITERAL("output.wav"))));
   ASSERT_TRUE(base::DeleteFile(trimmed_audio, false));
 }
 
 // Computes the difference between the actual and reference segment. A positive
 // number x means the actual file is x dB stronger than the reference.
@@ skipping 36 matching lines @@
     std::string trace_name = base::StringPrintf(
         "%s_segment_%zu", reference_file.BaseName().value().c_str(), i);
     perf_test::PrintResult("agc_energy_diff", perf_modifier, trace_name,
                            difference_in_decibel, "dB", false);
   }
 }
 
 void ComputeAndPrintPesqResults(const base::FilePath& reference_file,
                                 const base::FilePath& recording,
                                 const std::string& perf_modifier) {
-  base::FilePath trimmed_reference = CreateTemporaryWaveFile();
-  base::FilePath trimmed_recording = CreateTemporaryWaveFile();
-
-  ASSERT_TRUE(RemoveSilence(reference_file, trimmed_reference));
-  ASSERT_TRUE(RemoveSilence(recording, trimmed_recording));
-
   std::string raw_mos;
   std::string mos_lqo;
-  ASSERT_TRUE(RunPesq(trimmed_reference, trimmed_recording, 16000,
-                      &raw_mos, &mos_lqo));
+  ASSERT_TRUE(RunPesq(reference_file, recording, 16000, &raw_mos, &mos_lqo));
 
   perf_test::PrintResult(
       "audio_pesq", perf_modifier, "raw_mos", raw_mos, "score", true);
   perf_test::PrintResult(
       "audio_pesq", perf_modifier, "mos_lqo", mos_lqo, "score", true);
-
-  EXPECT_TRUE(base::DeleteFile(trimmed_reference, false));
-  EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
 }
 
 }  // namespace
 
 // Sets up a one-way WebRTC call and records its output to |recording|, using
 // getUserMedia.
 //
 // |reference_file| should have at least two seconds of silence in the
 // beginning: otherwise all the reference audio will not be picked up by the
 // recording. Note that the reference file will start playing as soon as the
 // audio device is up following the getUserMedia call in the left tab. The time
 // it takes to negotiate a call isn't deterministic, but two seconds should be
 // plenty of time. Similarly, the recording time should be enough to catch the
-// whole reference file. If you then silence-trim the reference file and actual
-// file, you should end up with two time-synchronized files.
+// whole reference file.
 void MAYBE_WebRtcAudioQualityBrowserTest::SetupAndRecordAudioCall(
     const base::FilePath& reference_file,
     const base::FilePath& recording,
     const std::string& constraints,
     const base::TimeDelta recording_time) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
-  ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
+  ASSERT_TRUE(ForceMicrophoneLevelTo100Percent());
 
   ConfigureFakeDeviceToPlayFile(reference_file);
 
   // Create a one-way call.
   GURL test_page = embedded_test_server()->GetURL(kWebRtcAudioTestHtmlPage);
   content::WebContents* left_tab =
       OpenPageAndGetUserMediaInNewTabWithConstraints(test_page, constraints);
   SetupPeerconnectionWithLocalStream(left_tab);
 
   content::WebContents* right_tab =
@@ skipping 27 matching lines @@
     return;
   }
 
   base::FilePath reference_file =
       test::GetReferenceFilesDir().Append(kReferenceFile);
   base::FilePath recording = CreateTemporaryWaveFile();
 
   ASSERT_NO_FATAL_FAILURE(SetupAndRecordAudioCall(
       reference_file, recording, kAudioOnlyCallConstraints,
       base::TimeDelta::FromSeconds(25)));
-  ComputeAndPrintPesqResults(reference_file, recording, "_getusermedia");
+  ASSERT_NO_FATAL_FAILURE(ComputeAndPrintPesqResults(
+      reference_file, recording, "_getusermedia"));
 
   EXPECT_TRUE(base::DeleteFile(recording, false));
 }
 
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MANUAL_TestCallQualityWithAudioFromWebAudio) {
   if (OnWinXp() || OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     return;
   }
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
-  ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
+  ASSERT_TRUE(ForceMicrophoneLevelTo100Percent());
 
   content::WebContents* left_tab =
       OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
   content::WebContents* right_tab =
       OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
 
   AddAudioFileToWebAudio(kReferenceFileRelativeUrl, left_tab);
 
   NegotiateCall(left_tab, right_tab);
 
   base::FilePath recording = CreateTemporaryWaveFile();
 
   // Note: the sound clip is about 13 seconds: record for 20 seconds to get some
   // safety margins on each side.
   AudioRecorder recorder;
   ASSERT_TRUE(recorder.StartRecording(base::TimeDelta::FromSeconds(20),
                                       recording));
 
   PlayAudioFileThroughWebAudio(left_tab);
 
   ASSERT_TRUE(recorder.WaitForRecordingToEnd());
   DVLOG(0) << "Done recording to " << recording.value() << std::endl;
 
   HangUp(left_tab);
 
   // Compare with the reference file on disk (this is the same file we played
   // through WebAudio earlier).
   base::FilePath reference_file =
       test::GetReferenceFilesDir().Append(kReferenceFile);
-  ComputeAndPrintPesqResults(reference_file, recording, "_webaudio");
+  ASSERT_NO_FATAL_FAILURE(ComputeAndPrintPesqResults(
+      reference_file, recording, "_webaudio"));
+  EXPECT_TRUE(base::DeleteFile(recording, false));
 }
 
 /**
  * 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
@@ skipping 84 matching lines @@
 #endif
 
 // Since the AGC is off here there should be no gain at all.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MAYBE_MANUAL_TestAutoGainIsOffWithAudioProcessingOff) {
   const char* kAudioCallWithoutAudioProcessing =
       "{audio: { mandatory: { echoCancellation: false } } }";
   ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
       kReferenceFile, kAudioCallWithoutAudioProcessing, "_no_agc"));
 }