audioproc_f with simulated mic analog gain

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.
  */
 
+#include <algorithm>
 #include <iostream>
+#include <utility>
 
 #include "webrtc/modules/audio_processing/test/aec_dump_based_simulator.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_processing/test/protobuf_utils.h"
 #include "webrtc/test/testsupport/trace_to_stderr.h"
 
 namespace webrtc {
 namespace test {
 namespace {
@@ skipping 39 matching lines @@
 }
 
 }  // 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) {
+    const webrtc::audioproc::Stream& msg) {
   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;
 
     // Populate input buffer.
     RTC_CHECK_EQ(sizeof(fwd_frame_.data_[0]) * fwd_frame_.samples_per_channel_ *
                      fwd_frame_.num_channels_,
@@ skipping 68 matching lines @@
   if (!settings_.use_ts) {
     if (msg.has_keypress()) {
       ap_->set_stream_key_pressed(msg.keypress());
     }
   } else {
     ap_->set_stream_key_pressed(*settings_.use_ts);
   }
 
   // TODO(peah): Add support for controlling the analog level via the
   // command-line.
-  if (msg.has_level()) {
-    RTC_CHECK_EQ(AudioProcessing::kNoError,
-                 ap_->gain_control()->set_stream_analog_level(msg.level()));
-    *set_stream_analog_level_called = true;
-  } else {
-    *set_stream_analog_level_called = false;
-  }
+  RTC_CHECK(msg.has_level());  // Level is always logged in AEC dumps.

[peah-webrtc, 2017/05/02 21:27:32]

It is probably fine, but I haven't checked the protobuf storing code. To avoid
errors, I'd choose to keep the optional level as it is though, since it does not
really affect he rest of the code as much. If you are 100% sure that the level
is always stored, this is a good change though.

+  // When the analog gain is simulated, use the gain suggested by AGC instead of
+  // that stored in the AEC dump.
+  RTC_CHECK_EQ(AudioProcessing::kNoError,
+               ap_->gain_control()->set_stream_analog_level(

[peah-webrtc, 2017/05/02 21:27:32]

What about putting the set_stream_analog_level call into
AudioProcessingSimulator? The purpose of that is to contain what is common to
both aecdump and wav file processing, and there seems to be code duplication
here and in the WavBasedSimulator class.

+                   settings_.simulate_mic_gain ?
+                      last_specified_microphone_level_ : msg.level()));
+  // TODO(aleloi): If settings_.simulate_mic_gain, set undo level to

[peah-webrtc, 2017/05/02 21:27:33]

It would be good to have FakeRecordingDevice as part of this CL. 

+  // |msg.level()| via FakeRecordingDevice::NotifyAudioDeviceLevel().
 }
 
 void AecDumpBasedSimulator::VerifyProcessStreamBitExactness(
     const webrtc::audioproc::Stream& msg) {
   if (bitexact_output_) {
     if (interface_used_ == InterfaceType::kFixedInterface) {
       bitexact_output_ = VerifyFixedBitExactness(msg, fwd_frame_);
     } else {
       bitexact_output_ = VerifyFloatBitExactness(msg, out_config_, *out_buf_);
     }
@@ skipping 377 matching lines @@
   }
 
   SetupBuffersConfigsOutputs(
       msg.sample_rate(), output_sample_rate, msg.reverse_sample_rate(),
       reverse_output_sample_rate, msg.num_input_channels(), num_output_channels,
       msg.num_reverse_channels(), num_reverse_output_channels);
 }
 
 void AecDumpBasedSimulator::HandleMessage(
     const webrtc::audioproc::Stream& msg) {
-  bool set_stream_analog_level_called = false;
-  PrepareProcessStreamCall(msg, &set_stream_analog_level_called);
+  PrepareProcessStreamCall(msg);
   ProcessStream(interface_used_ == InterfaceType::kFixedInterface);
-  if (set_stream_analog_level_called) {
+  if (settings_.simulate_mic_gain) {
+    // Store analog level for the next analyzed frame.
+    last_specified_microphone_level_ =
+        ap_->gain_control()->stream_analog_level();

[peah-webrtc, 2017/05/02 21:27:32]

What about putting the stream_analog_level call into AudioProcessingSimulator?
The purpose of that is to contain what is common to both aecdump and wav file
processing, and there seems to be code duplication here and in the
WavBasedSimulator class.

+    // TODO(aleloi): Set the returned value into a FakeRecordingDevice instance
+    // via FakeRecordingDevice::set_analog_level() instead of using
+    // last_specified_microphone_level_.
+  } else {
     // Call stream analog level to ensure that any side-effects are triggered.
     (void)ap_->gain_control()->stream_analog_level();
   }
-
   VerifyProcessStreamBitExactness(msg);
 }
 
 void AecDumpBasedSimulator::HandleMessage(
     const webrtc::audioproc::ReverseStream& msg) {
   PrepareReverseProcessStreamCall(msg);
   ProcessReverseStream(interface_used_ == InterfaceType::kFixedInterface);
 }
 
 }  // namespace test
 }  // namespace webrtc