audioproc_f with simulated mic analog gain

webrtc/modules/audio_processing/test/audio_processing_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 "webrtc/modules/audio_processing/test/audio_processing_simulator.h"
 
 #include <algorithm>
 #include <iostream>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/modules/audio_processing/aec_dump/aec_dump_factory.h"

[AleBzk, 2017/06/29 11:43:36]

Unrelated (merge)

 #include "webrtc/modules/audio_processing/include/audio_processing.h"
+#include "webrtc/modules/audio_processing/test/fake_recording_device.h"
 
 namespace webrtc {
 namespace test {
 namespace {
 
+constexpr FakeRecordingDevice::DeviceKind kDefaultFakeRecDeviceKind =
+    FakeRecordingDevice::DeviceKind::IDENTITY;
+
 void CopyFromAudioFrame(const AudioFrame& src, ChannelBuffer<float>* dest) {
   RTC_CHECK_EQ(src.num_channels_, dest->num_channels());
   RTC_CHECK_EQ(src.samples_per_channel_, dest->num_frames());
   // Copy the data from the input buffer.
   std::vector<float> tmp(src.samples_per_channel_ * src.num_channels_);
   S16ToFloat(src.data(), tmp.size(), tmp.data());
   Deinterleave(tmp.data(), src.samples_per_channel_, src.num_channels_,
                dest->channels());
 }
 
@@ skipping 34 matching lines @@
   for (size_t ch = 0; ch < dest->num_channels_; ++ch) {
     for (size_t sample = 0; sample < dest->samples_per_channel_; ++sample) {
       dest_data[sample * dest->num_channels_ + ch] =
           src.channels()[ch][sample] * 32767;
     }
   }
 }
 
 AudioProcessingSimulator::AudioProcessingSimulator(
     const SimulationSettings& settings)
-    : settings_(settings), worker_queue_("file_writer_task_queue") {
+    : settings_(settings),
+      fake_recording_device_(settings.initial_mic_level,
+                             settings_.simulate_mic_gain
+                                 ? static_cast<FakeRecordingDevice::DeviceKind>(

[peah-webrtc, 2017/06/29 22:04:00]

I think you should move the selection of DeviceKind into the
fake_recording_device. 
Having it here just constitutes a cast to something specified elsewhere and I
think the mapping between the parameter value and the actual DeviceKind would be
more clear if the DeviceKind and the mapping was done at the same place.

Please check the constructor for more comments.

[AleBzk, 2017/07/26 13:42:30]

Done.

+                                       *settings.simulated_mic_kind)
+                                 : kDefaultFakeRecDeviceKind),
+      worker_queue_("file_writer_task_queue") {

[AleBzk, 2017/06/29 11:43:36]

last line is unrelated (merge)

   if (settings_.ed_graph_output_filename &&
       settings_.ed_graph_output_filename->size() > 0) {
     residual_echo_likelihood_graph_writer_.open(
         *settings_.ed_graph_output_filename);
     RTC_CHECK(residual_echo_likelihood_graph_writer_.is_open());
     WriteEchoLikelihoodGraphFileHeader(&residual_echo_likelihood_graph_writer_);
   }
 }
 
 AudioProcessingSimulator::~AudioProcessingSimulator() {
   if (residual_echo_likelihood_graph_writer_.is_open()) {
     WriteEchoLikelihoodGraphFileFooter(&residual_echo_likelihood_graph_writer_);
     residual_echo_likelihood_graph_writer_.close();
   }
 }
 
 AudioProcessingSimulator::ScopedTimer::~ScopedTimer() {
   int64_t interval = rtc::TimeNanos() - start_time_;
   proc_time_->sum += interval;
   proc_time_->max = std::max(proc_time_->max, interval);
   proc_time_->min = std::min(proc_time_->min, interval);
 }
 
 void AudioProcessingSimulator::ProcessStream(bool fixed_interface) {
+  if (settings_.aec_dump_input_filename && settings_.simulate_mic_gain) {

[peah-webrtc, 2017/06/29 22:04:00]

This is better, but I'd rephrase it as

  if (settings_.simulate_mic_gain) {
     if (settings_.aec_dump_input_filename) { 
        RTC_DCHECK(aec_dump_mic_level_);
        fake_recording_device_.set_undo_mic_level(aec_dump_mic_level_);
     }
 
      if (fixed_interface) {
        fake_recording_device_.SimulateAnalogGain(&fwd_frame_);
      } else {
        fake_recording_device_.SimulateAnalogGain(in_buf_.get());
      }
    }

No need to have two different if-s on simulate_mic_gain

[AleBzk, 2017/07/26 13:42:30]

Done.

+    // When the analog gain is sumulated and an AEC dump is used as input, set
+    // the undo level to |aec_dump_mic_level_| to virtually restore the
+    // unmodified microphone signal level.
+    RTC_DCHECK(aec_dump_mic_level_);
+    fake_recording_device_.set_undo_mic_level(aec_dump_mic_level_);
+  }
+
+  // Optionally use the fake recording device to simulate analog gain.
+  if (settings_.simulate_mic_gain) {
+    if (fixed_interface) {
+      fake_recording_device_.SimulateAnalogGain(&fwd_frame_);
+    } else {
+      fake_recording_device_.SimulateAnalogGain(in_buf_.get());
+    }
+  }
+
+  // Notify the current mic level to AGC.
+  if (settings_.simulate_mic_gain) {
+    RTC_CHECK_EQ(AudioProcessing::kNoError,
+                 ap_->gain_control()->set_stream_analog_level(

[peah-webrtc, 2017/06/29 22:04:00]

No, I don't think this is ok. The fake recording device should not be involved
if the microphone gain is not being simulated.

Furthermore, I doubt that this is correct now, as the  previous call to
set_mic_level was removed.

[AleBzk, 2017/07/26 13:42:30]

The code below is executed only when the mic gain is simulated.
So it should be ok.

RTC_CHECK_EQ(AudioProcessing::kNoError,
    ap_->gain_control()->set_stream_analog_level(
        fake_recording_device_.mic_level()));
It hasn't been removed; look line 151 on the right (latest patch set).

+                     fake_recording_device_.mic_level()));
+  }
+
+  // Process the current audio frame.
   if (fixed_interface) {
     {
       const auto st = ScopedTimer(mutable_proc_time());
       RTC_CHECK_EQ(AudioProcessing::kNoError, ap_->ProcessStream(&fwd_frame_));
     }
     CopyFromAudioFrame(fwd_frame_, out_buf_.get());
   } else {
     const auto st = ScopedTimer(mutable_proc_time());
     RTC_CHECK_EQ(AudioProcessing::kNoError,
                  ap_->ProcessStream(in_buf_->channels(), in_config_,
                                     out_config_, out_buf_->channels()));
   }
 
+  // Store the mic level suggested by AGC.
+  fake_recording_device_.set_mic_level(
+      ap_->gain_control()->stream_analog_level());
+
   if (buffer_writer_) {
     buffer_writer_->Write(*out_buf_);
   }
 
   if (residual_echo_likelihood_graph_writer_.is_open()) {
     auto stats = ap_->GetStatistics();
     residual_echo_likelihood_graph_writer_ << stats.residual_echo_likelihood
                                            << ", ";
   }
 
@@ skipping 57 matching lines @@
   fwd_frame_.samples_per_channel_ =
       rtc::CheckedDivExact(fwd_frame_.sample_rate_hz_, kChunksPerSecond);
   fwd_frame_.num_channels_ = input_num_channels;
 
   rev_frame_.sample_rate_hz_ = reverse_input_sample_rate_hz;
   rev_frame_.samples_per_channel_ =
       rtc::CheckedDivExact(rev_frame_.sample_rate_hz_, kChunksPerSecond);
   rev_frame_.num_channels_ = reverse_input_num_channels;
 
   if (settings_.use_verbose_logging) {
+    rtc::LogMessage::LogToDebug(rtc::LS_VERBOSE);
+
     std::cout << "Sample rates:" << std::endl;
     std::cout << " Forward input: " << input_sample_rate_hz << std::endl;
     std::cout << " Forward output: " << output_sample_rate_hz << std::endl;
     std::cout << " Reverse input: " << reverse_input_sample_rate_hz
               << std::endl;
     std::cout << " Reverse output: " << reverse_output_sample_rate_hz
               << std::endl;
     std::cout << "Number of channels: " << std::endl;
     std::cout << " Forward input: " << input_num_channels << std::endl;
     std::cout << " Forward output: " << output_num_channels << std::endl;
@@ skipping 35 matching lines @@
                       static_cast<size_t>(reverse_out_config_.num_channels())));
     reverse_buffer_writer_.reset(
         new ChannelBufferWavWriter(std::move(reverse_out_file)));
   }
 
   ++output_reset_counter_;
 }
 
 void AudioProcessingSimulator::DestroyAudioProcessor() {
   if (settings_.aec_dump_output_filename) {
     ap_->DetachAecDump();

[AleBzk, 2017/06/29 11:43:36]

Unrelated (merge)

   }
 }
 
 void AudioProcessingSimulator::CreateAudioProcessor() {
   Config config;
   AudioProcessing::Config apm_config;
   if (settings_.use_bf && *settings_.use_bf) {
     config.Set<Beamforming>(new Beamforming(
         true, ParseArrayGeometry(*settings_.microphone_positions),
         SphericalPointf(DegreesToRadians(settings_.target_angle_degrees), 0.f,
@@ skipping 120 matching lines @@
         ap_->noise_suppression()->set_level(
             static_cast<NoiseSuppression::Level>(*settings_.ns_level)));
   }
 
   if (settings_.use_ts) {
     ap_->set_stream_key_pressed(*settings_.use_ts);
   }
 
   if (settings_.aec_dump_output_filename) {
     ap_->AttachAecDump(AecDumpFactory::Create(
         *settings_.aec_dump_output_filename, -1, &worker_queue_));

[AleBzk, 2017/06/29 11:43:36]

Unrelated (merge)

   }
 }
 
 }  // namespace test
 }  // namespace webrtc