Add an optional artificial nearend signal for aecdump call recreation

webrtc/modules/audio_processing/test/audioproc_float.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 22 matching lines @@
     "Command-line tool to simulate a call using the audio "
     "processing module, either based on wav files or "
     "protobuf debug dump recordings.";
 
 DEFINE_string(dump_input, "", "Aec dump input filename");
 DEFINE_string(dump_output, "", "Aec dump output filename");
 DEFINE_string(i, "", "Forward stream input wav filename");
 DEFINE_string(o, "", "Forward stream output wav filename");
 DEFINE_string(ri, "", "Reverse stream input wav filename");
 DEFINE_string(ro, "", "Reverse stream output wav filename");
+DEFINE_string(artificial_nearend, "", "Artificial nearend wav filename");
 DEFINE_int32(output_num_channels,
              kParameterNotSpecifiedValue,
              "Number of forward stream output channels");
 DEFINE_int32(reverse_output_num_channels,
              kParameterNotSpecifiedValue,
              "Number of Reverse stream output channels");
 DEFINE_int32(output_sample_rate_hz,
              kParameterNotSpecifiedValue,
              "Forward stream output sample rate in Hz");
 DEFINE_int32(reverse_output_sample_rate_hz,
@@ skipping 148 matching lines @@
     settings.use_aec = rtc::Optional<bool>(true);
     settings.use_aecm = rtc::Optional<bool>(false);
     settings.use_ed = rtc::Optional<bool>(false);
   }
   SetSettingIfSpecified(FLAGS_dump_input, &settings.aec_dump_input_filename);
   SetSettingIfSpecified(FLAGS_dump_output, &settings.aec_dump_output_filename);
   SetSettingIfSpecified(FLAGS_i, &settings.input_filename);
   SetSettingIfSpecified(FLAGS_o, &settings.output_filename);
   SetSettingIfSpecified(FLAGS_ri, &settings.reverse_input_filename);
   SetSettingIfSpecified(FLAGS_ro, &settings.reverse_output_filename);
+  SetSettingIfSpecified(FLAGS_artificial_nearend,
+                        &settings.artificial_nearend_filename);
   SetSettingIfSpecified(FLAGS_output_num_channels,
                         &settings.output_num_channels);
   SetSettingIfSpecified(FLAGS_reverse_output_num_channels,
                         &settings.reverse_output_num_channels);
   SetSettingIfSpecified(FLAGS_output_sample_rate_hz,
                         &settings.output_sample_rate_hz);
   SetSettingIfSpecified(FLAGS_reverse_output_sample_rate_hz,
                         &settings.reverse_output_sample_rate_hz);
   SetSettingIfSpecified(FLAGS_mic_positions, &settings.microphone_positions);
   settings.target_angle_degrees = FLAGS_target_angle_degrees;
@@ skipping 49 matching lines @@
     exit(1);
   }
 }
 
 void PerformBasicParameterSanityChecks(const SimulationSettings& settings) {
   if (settings.input_filename || settings.reverse_input_filename) {
     ReportConditionalErrorAndExit(!!settings.aec_dump_input_filename,
                                   "Error: The aec dump cannot be specified "
                                   "together with input wav files!\n");
 
+    ReportConditionalErrorAndExit(!!settings.artificial_nearend_filename,
+                                  "Error: The artificial nearend cannot be "
+                                  "specified together with input wav files!\n");
+
     ReportConditionalErrorAndExit(!settings.input_filename,
                                   "Error: When operating at wav files, the "
                                   "input wav filename must be "
                                   "specified!\n");
 
     ReportConditionalErrorAndExit(
         settings.reverse_output_filename && !settings.reverse_input_filename,
         "Error: When operating at wav files, the reverse input wav filename "
         "must be specified if the reverse output wav filename is specified!\n");
   } else {
@@ skipping 92 matching lines @@
 
   ReportConditionalErrorAndExit(
       settings.reverse_input_filename &&
           (!valid_wav_name(*settings.reverse_input_filename)),
       "Error: --ri must be a valid .wav file name.\n");
 
   ReportConditionalErrorAndExit(
       settings.reverse_output_filename &&
           (!valid_wav_name(*settings.reverse_output_filename)),
       "Error: --ro must be a valid .wav file name.\n");
+
+  ReportConditionalErrorAndExit(
+      settings.artificial_nearend_filename &&
+          (!valid_wav_name(*settings.artificial_nearend_filename)),
+      "Error: --artifical_nearend must be a valid .wav file name.\n");
 }
 
 }  // namespace
 
 int main(int argc, char* argv[]) {
   google::SetUsageMessage(kUsageDescription);
   google::ParseCommandLineFlags(&argc, &argv, true);
 
   SimulationSettings settings = CreateSettings();
   PerformBasicParameterSanityChecks(settings);
   std::unique_ptr<AudioProcessingSimulator> processor;
 
   if (settings.aec_dump_input_filename) {
     processor.reset(new AecDumpBasedSimulator(settings));
   } else {
     processor.reset(new WavBasedSimulator(settings));

[aleloi, 2016/12/08 13:00:55]

IIUC, artificial nearend functionality only works when there is an AEC dump.
There should probably be a few more error messages for that case.

[peah-webrtc, 2016/12/09 07:19:25]

There is an error message on line 283 that triggers if an artificial nearend wav
file is used when a wav file is specified for either the render or capture side,
but you are probably correct that there could be more. 

Do you have any special case that you think should be covered? A .wav file
-based simulation requires either a wav file to be specified for the render or
capture input so I think that the error message above is sufficient for that. 

[aleloi, 2016/12/09 10:09:23]

Ah, I see now. When there is an artificial nearend, but no aec dump, the check
on 283 will be hit.

   }
 
   processor->Process();
 
   if (settings.report_performance) {
     const auto& proc_time = processor->proc_time();
     int64_t exec_time_us = proc_time.sum / rtc::kNumNanosecsPerMicrosec;
     std::cout << std::endl
               << "Execution time: " << exec_time_us * 1e-6 << " s, File time: "
               << processor->get_num_process_stream_calls() * 1.f /
@@ skipping 16 matching lines @@
 
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   return webrtc::test::main(argc, argv);
 }