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_) {
+    if (artificial_nearend_buffer_reader_->Read(

[hlundin-webrtc, 2016/12/09 07:48:26]

If the file ends before the rest of the simulation, we'll just silently not add
any more artificial nerend. Is this your intention? I think it is more honest to
the one running the test to kick and scream about it (essentially RTC_CHECK the
call to Read).

[peah-webrtc, 2016/12/09 08:07:51]

The intention was actually to do this silently but it can definitely be
discussed whether that is the best way. My view is that this is a
simulation/development tool and I don't think that it should limit the user in
any unnecessary way. If we CHECK on this, that will force the user to adjust the
length of the wav file just to comply with this restriction.

I'll add a printout to warn about this, because I agree that it could be that it
is not intentional for the .wav file to be that short.

WDYT?

[hlundin-webrtc, 2016/12/09 09:24:26]

Good.

+            artificial_nearend_buf_.get())) {
+      if (msg.has_input_data()) {
+        for (size_t k = 0; k < in_buf_->num_frames(); ++k) {
+          int32_t tmp = fwd_frame_.data_[k] +
+                        static_cast<int16_t>(
+                            32767 * artificial_nearend_buf_->channels()[0][k]);
+          fwd_frame_.data_[k] =
+              static_cast<int16_t>(std::min(32767, std::max(-32768, tmp)));

[hlundin-webrtc, 2016/12/09 07:48:26]

rtc::saturated_cast<int16_t>(tmp) will do the same thing.

[peah-webrtc, 2016/12/09 08:07:51]

Great! That I did not know. Changed the code to use that.

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];
+            in_buf_->channels()[i][k] = std::min(
+                32767.f, std::max(-32768.f, in_buf_->channels()[i][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) {

[hlundin-webrtc, 2016/12/09 07:48:26]

Any point continuing here? Or simply
RTC_DCHECK_EQ(artificial_nearend_file->num_channels(), 1) << "Oh no...";

[peah-webrtc, 2016/12/09 08:07:51]

Good point! I added the DCHECK.

Done.

+      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)));
+
+      artificial_nearend_buf_.reset(new ChannelBuffer<float>(
+          rtc::CheckedDivExact(artificial_nearend_file->sample_rate(),
+                               kChunksPerSecond),
+          1));
+    }
+  }
+
   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