Add an optional artificial nearend signal for aecdump call recreation

webrtc/modules/audio_processing/test/aec_dump_based_simulator.cc

 /*
  *  Copyright (c) 2016 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 44 matching lines @@
           return false;
         }
       }
     }
   }
   return true;
 }
 
 }  // namespace
 
+AecDumpBasedSimulator::AecDumpBasedSimulator(const SimulationSettings& settings)
+    : AudioProcessingSimulator(settings) {}
+
+AecDumpBasedSimulator::~AecDumpBasedSimulator() = default;
+
 void AecDumpBasedSimulator::PrepareProcessStreamCall(
     const webrtc::audioproc::Stream& msg,
     bool* set_stream_analog_level_called) {
   if (msg.has_input_data()) {
     // Fixed interface processing.
     // Verify interface invariance.
     RTC_CHECK(interface_used_ == InterfaceType::kFixedInterface ||
               interface_used_ == InterfaceType::kNotSpecified);
     interface_used_ = InterfaceType::kFixedInterface;
 
@@ skipping 14 matching lines @@
 
     // Populate input buffer.
     for (int i = 0; i < msg.input_channel_size(); ++i) {
       RTC_CHECK_EQ(in_buf_->num_frames() * sizeof(*in_buf_->channels()[i]),
                    msg.input_channel(i).size());
       std::memcpy(in_buf_->channels()[i], msg.input_channel(i).data(),
                   msg.input_channel(i).size());
     }
   }
 
+  if (artificial_nearend_buffer_reader_) {
+    bool samples_left_to_process =
+        artificial_nearend_buffer_reader_->Read(artificial_nearend_buf_.get());
+    if (samples_left_to_process) {
+      if (msg.has_input_data()) {
+        for (size_t k = 0; k < in_buf_->num_frames(); ++k) {
+          fwd_frame_.data_[0] += static_cast<int16_t>(
+              32767 * artificial_nearend_buf_->channels()[0][k]);

[ivoc, 2016/12/08 10:55:19]

Shouldn't this be fwd_frame_.data[k]? Also, why is it adding instead of
assigning?

[peah-webrtc, 2016/12/08 12:02:26]

Great find (I probably have not used this yet with the int16 interface.)

Regarding the adding, the idea is to add a nearend signal to the existing
microphone signal (which includes the echo which we want to maintain). Assigning
would replace the microphone signal.

Done.

[ivoc, 2016/12/08 12:13:24]

I see, that makes sense. I think this code can cause over/underflows as well,
should that be addressed, or is it not a problem in practice?

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

You are fully correct! I added explicit controlled saturation.

Done.

+        }
+      } else {
+        for (int i = 0; i < msg.input_channel_size(); ++i) {
+          for (size_t k = 0; k < in_buf_->num_frames(); ++k) {
+            in_buf_->channels()[i][k] +=
+                artificial_nearend_buf_->channels()[0][k];
+          }
+        }
+      }
+    }
+  }
+
   if (!settings_.stream_delay) {
     if (msg.has_delay()) {
       RTC_CHECK_EQ(AudioProcessing::kNoError,
                    ap_->set_stream_delay_ms(msg.delay()));
     }
   } else {
     RTC_CHECK_EQ(AudioProcessing::kNoError,
                  ap_->set_stream_delay_ms(*settings_.stream_delay));
   }
 
@@ skipping 73 matching lines @@
 
 void AecDumpBasedSimulator::Process() {
   std::unique_ptr<test::TraceToStderr> trace_to_stderr;
   if (settings_.use_verbose_logging) {
     trace_to_stderr.reset(new test::TraceToStderr(true));
   }
 
   CreateAudioProcessor();
   dump_input_file_ = OpenFile(settings_.aec_dump_input_filename->c_str(), "rb");
 
+  if (settings_.artificial_nearend_filename) {
+    std::unique_ptr<WavReader> artificial_nearend_file(
+        new WavReader(settings_.artificial_nearend_filename->c_str()));
+
+    if (artificial_nearend_file->num_channels() != 1) {
+      std::cout << "Only mono files for the artificial nearend are supported, "
+                   "reverted to not using the artificial nearend file";
+    } else {
+      artificial_nearend_buffer_reader_.reset(
+          new ChannelBufferWavReader(std::move(artificial_nearend_file)));
+    }
+  }
+
   webrtc::audioproc::Event event_msg;
   int num_forward_chunks_processed = 0;
   const float kOneBykChunksPerSecond =
       1.f / AudioProcessingSimulator::kChunksPerSecond;
   while (ReadMessageFromFile(dump_input_file_, &event_msg)) {
     switch (event_msg.type()) {
       case webrtc::audioproc::Event::INIT:
         RTC_CHECK(event_msg.has_init());
         HandleMessage(event_msg.init());
         break;
@@ skipping 324 matching lines @@
 }
 
 void AecDumpBasedSimulator::HandleMessage(
     const webrtc::audioproc::ReverseStream& msg) {
   PrepareReverseProcessStreamCall(msg);
   ProcessReverseStream(interface_used_ == InterfaceType::kFixedInterface);
 }
 
 }  // namespace test
 }  // namespace webrtc