Added WebRTC audio quality test using fake device; improved fake device

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 154 matching lines @@
     // 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);
+  void SetupAndRecordAudioCall(const base::FilePath& reference_file,
+                               const base::FilePath& recording,
+                               const std::string& constraints,
+                               const base::TimeDelta recording_time);
 };
 
 namespace {
 
 class AudioRecorder {
  public:
   AudioRecorder() {}
   ~AudioRecorder() {}
 
   // Starts the recording program for the specified duration. Returns true
   // on success. We record in 44.1 kHz 16-bit format unless |record_cd| is
   // false, in which case we record in 48 kHz 16-bit format. We record in stereo
   // unless |mono| is true.
   // 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 record_cd) {
+  bool StartRecording(base::TimeDelta recording_time,
+                      const base::FilePath& output_file, bool mono,
+                      bool record_cd) {
     EXPECT_FALSE(recording_application_.IsValid())
         << "Tried to record, but is already recording.";
 
+    int duration_sec = static_cast<int>(recording_time.InSeconds());
     base::CommandLine command_line(base::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"));
     if (kernel32_lib.is_valid()) {
       typedef BOOL (WINAPI* Wow64DisableWow64FSRedirection)(PVOID*);
       Wow64DisableWow64FSRedirection wow_64_disable_wow_64_fs_redirection;
       wow_64_disable_wow_64_fs_redirection =
           reinterpret_cast<Wow64DisableWow64FSRedirection>(
               kernel32_lib.GetFunctionPointer(
                   "Wow64DisableWow64FsRedirection"));
       if (wow_64_disable_wow_64_fs_redirection != NULL) {
         PVOID* ignored = NULL;
@@ skipping 343 matching lines @@
     float difference_in_decibel = 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::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(recording, 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));
+
+  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.
+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());
+
+  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 =
+      OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
+
+  AudioRecorder recorder;
+  ASSERT_TRUE(recorder.StartRecording(recording_time, recording, false, true));
+
+  NegotiateCall(left_tab, right_tab);
+
+  ASSERT_TRUE(recorder.WaitForRecordingToEnd());
+  DVLOG(0) << "Done recording to " << recording.value() << std::endl;
+
+  HangUp(left_tab);
+}
+
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
-                       MANUAL_TestAudioQuality) {
-  if (OnWinXp()) {
-    LOG(ERROR) << "This test is not implemented for Windows XP.";
+                       MANUAL_TestCallQualityWithAudioFromFakeDevice) {
+  if (OnWinXp() || OnWin8()) {
+    // http://crbug.com/379798.
+    LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     return;
   }
-  if (OnWin8()) {
+
+  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");
+
+  EXPECT_TRUE(base::DeleteFile(recording, false));
+}
+
+IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
+                       MANUAL_TestCallQualityWithAudioFromWebAudio) {
+  if (OnWinXp() || OnWin8()) {
     // http://crbug.com/379798.
-    LOG(ERROR) << "Temporarily disabled for Win 8.";
+    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());
 
   content::WebContents* left_tab =
       OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
   content::WebContents* right_tab =
       OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
 
   AddAudioFileToWebAudio(kReferenceFileRelativeUrl, left_tab);
 
   NegotiateCall(left_tab, right_tab);
 
-  // Note: the media flow isn't necessarily established on the connection just
-  // 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
+  // Note: the sound clip is about 13 seconds: record for 20 seconds to get some

[phoglund_chromium, 2015/01/07 15:16:26]

This is because I added 3 seconds of silence to the ref file for this test.

   // safety margins on each side.
   AudioRecorder recorder;
-  static int kRecordingTimeSeconds = 15;
-  ASSERT_TRUE(recorder.StartRecording(kRecordingTimeSeconds, recording,
-                                      true, false));
+  ASSERT_TRUE(recorder.StartRecording(base::TimeDelta::FromSeconds(20),
+                                      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 =
+  // 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);
-  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));
+  ComputeAndPrintPesqResults(reference_file, recording, "_webaudio");
 }
 
 /**
  * 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 16 matching lines @@
  * The test only exercises digital AGC for now.
  *
  * 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. See
  * http://crbug.com/421054.
  */
 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.";
+  if (OnWinXp() || OnWin8()) {
+    // http://crbug.com/379798.
+    LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     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());
-
   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, constraints);
-  SetupPeerconnectionWithLocalStream(left_tab);
-
-  content::WebContents* right_tab =
-      OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
-
   base::FilePath recording = CreateTemporaryWaveFile();
 
-  AudioRecorder recorder;
-  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);
+  ASSERT_NO_FATAL_FAILURE(SetupAndRecordAudioCall(
+      reference_file, recording, constraints,
+      base::TimeDelta::FromSeconds(25)));
 
   // 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());
 
@@ skipping 21 matching lines @@
 
 // The AGC should apply non-zero gain here.
 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
+#define MAYBE_MANUAL_TestAutoGainIsOffWithAudioProcessingOff \
+        MANUAL_TestAutoGainIsOffWithAudioProcessingOff
 #else
-#define MAYBE_MANUAL_TestComputeGainWithAudioProcessingOff \
-        DISABLED_MANUAL_TestComputeGainWithAudioProcessingOff
+#define MAYBE_MANUAL_TestAutoGainIsOffWithAudioProcessingOff \
+        DISABLED_MANUAL_TestAutoGainIsOffWithAudioProcessingOff
 #endif
 
 // Since the AGC is off here there should be no gain at all.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
-                       MAYBE_MANUAL_TestComputeGainWithAudioProcessingOff) {
+                       MAYBE_MANUAL_TestAutoGainIsOffWithAudioProcessingOff) {
   const char* kAudioCallWithoutAudioProcessing =
       "{audio: { mandatory: { echoCancellation: false } } }";
   ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
       kAgcTestReferenceFile, kAudioCallWithoutAudioProcessing, "_no_agc"));
 }
-