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/include/audio_processing.h"
 
 namespace webrtc {
 namespace test {
 namespace {
 
 void CopyFromAudioFrame(const AudioFrame& src, ChannelBuffer<float>* dest) {
   RTC_CHECK_EQ(src.num_channels_, dest->num_channels());
@@ skipping 41 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) {
+        : settings_(settings),
+          fake_recording_device_(settings_.simulate_mic_gain ?
+              static_cast<FakeRecordingDevice::LevelToScalingMappingKind>(
+                  *settings.simulated_mic_kind) : kDefaultMicKind) {
+  if (settings_.simulate_mic_gain) {
+    fake_recording_device_.set_analog_level(kInitialMicrophoneGainLevel);
+  }
   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) {
+  LOG(LS_VERBOSE) << "AGC set_stream_analog_level set to "

[peah-webrtc, 2017/05/05 06:28:41]

Too verbose logging.

[AleBzk, 2017/05/05 12:20:17]

I only removed the log below (namely, LOG(LS_VERBOSE) << "AGC
stream_analog_level() returned ").
Note that I'm using LS_VERBOSE as sink and that it's not shown by default
(--verbose must be specified).

I think this log is useful to extract AGC suggested values.

WDYT?

[peah-webrtc, 2017/05/05 20:25:20]

I would not analyze the AGC suggested values like that. What I instead do is to
dump the to a file using the ApmDataDumper functionality. That allows the values
to be analyzed using numpy/etc.

It may be useful to use the LOG feature to extract only the AGC suggested
values, but it would not scale for doing the same for other things. The log
would be unreadable with all the data coming being logged.

If would prefer using the LOG functionality for doing analysis, I would only add
it briefly, and not having it as a permanent logging. 

+      << fake_recording_device_.analog_level();
+  RTC_CHECK_EQ(AudioProcessing::kNoError,
+               ap_->gain_control()->set_stream_analog_level(

[peah-webrtc, 2017/05/05 06:28:41]

I'd prefer a decoupling between the stored stream analog level and the fake
audio device for the case when there is no simulation of the analog gain, and I
think the code will become simpler for that.

With the suggestions elsewhere in the code, this method can be simplified to

void AudioProcessingSimulator::ProcessStream(bool fixed_interface)
  if (settings_.simulate_mic_gain) {
    if (fixed_interface) {    
      fake_audiodevice.Transform(level_for_input_, &fwd_frame);
    } 
    else {
      fake_audiodevice.Transform(level_for_input_, in_buf_->channels());
    }
  }
  ap_->gain_control()->set_stream_analog_level(settings_.simulate_mic_gain ?
fake_recording_device_.analog_level() : *level_for_input_);
  
  if (fixed_interface) {    
    ap_->ProcessStream(&fwd_frame_)
  }
  else {
    ap_->ProcessStream(in_buf_->channels(), in_config_, out_config_,
out_buf_->channels());
  }

 
fake_recording_device_.set_analog_level(ap_->gain_control()->stream_analog_level());

  
WDYT?

[AleBzk, 2017/05/05 12:20:17]

Done.

+                   fake_recording_device_.analog_level()));
+
   if (fixed_interface) {
     {
       const auto st = ScopedTimer(mutable_proc_time());
+      // TODO(alessiob): Simulate application gain.
+      if (settings_.simulate_mic_gain) {
+        fake_recording_device_.ProcessStream(&fwd_frame_, &fwd_frame_);
+      }
       RTC_CHECK_EQ(AudioProcessing::kNoError, ap_->ProcessStream(&fwd_frame_));
     }
     CopyFromAudioFrame(fwd_frame_, out_buf_.get());
   } else {
     const auto st = ScopedTimer(mutable_proc_time());
+    // TODO(alessiob): Simulate application gain.
+    if (settings_.simulate_mic_gain) {
+      const size_t channel_size = in_config_.num_frames();
+
+      std::vector<rtc::ArrayView<const float>> data_view;
+      std::vector<rtc::ArrayView<float>> after_scaling_view;
+      for (size_t i = 0; i < in_config_.num_channels(); ++i) {
+        data_view.emplace_back(in_buf_->channels()[i], channel_size);
+        after_scaling_view.emplace_back(in_buf_->channels()[i], channel_size);
+      }
+
+      fake_recording_device_.ProcessStream(data_view, after_scaling_view);
+    }
     RTC_CHECK_EQ(AudioProcessing::kNoError,
                  ap_->ProcessStream(in_buf_->channels(), in_config_,
                                     out_config_, out_buf_->channels()));
   }
 
+  // Store the mic gain level suggested by AGC if required.
+  fake_recording_device_.set_analog_level(
+      ap_->gain_control()->stream_analog_level());
+  LOG(LS_VERBOSE) << "AGC stream_analog_level() returned "

[peah-webrtc, 2017/05/05 06:28:41]

This will become too much logging.

[AleBzk, 2017/05/05 12:20:17]

Done.

+      << fake_recording_device_.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 182 matching lines @@
     size_t kMaxFilenameSize = AudioProcessing::kMaxFilenameSize;
     RTC_CHECK_LE(settings_.aec_dump_output_filename->size(), kMaxFilenameSize);
     RTC_CHECK_EQ(AudioProcessing::kNoError,
                  ap_->StartDebugRecording(
                      settings_.aec_dump_output_filename->c_str(), -1));
   }
 }
 
 }  // namespace test
 }  // namespace webrtc