| /* |
| * 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 "modules/audio_processing/test/audio_processing_simulator.h" |
| |
| #include <algorithm> |
| #include <fstream> |
| #include <iostream> |
| #include <sstream> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include "absl/memory/memory.h" |
| #include "api/audio/echo_canceller3_factory.h" |
| #include "common_audio/include/audio_util.h" |
| #include "modules/audio_processing/aec_dump/aec_dump_factory.h" |
| #include "modules/audio_processing/include/audio_processing.h" |
| #include "modules/audio_processing/test/fake_recording_device.h" |
| #include "rtc_base/checks.h" |
| #include "rtc_base/json.h" |
| #include "rtc_base/logging.h" |
| #include "rtc_base/stringutils.h" |
| |
| namespace webrtc { |
| namespace test { |
| namespace { |
| |
| // Class for parsing the AEC3 parameters from a JSON file and producing a config |
| // struct. |
| class Aec3ParametersParser { |
| public: |
| static EchoCanceller3Config Parse(bool verbose_output, |
| const std::string& filename) { |
| return Aec3ParametersParser(verbose_output).Parse(filename); |
| } |
| |
| private: |
| explicit Aec3ParametersParser(bool verbose_output) |
| : verbose_output_(verbose_output) {} |
| |
| void ReadParam(const Json::Value& root, |
| std::string param_name, |
| bool* param) const { |
| RTC_CHECK(param); |
| bool v; |
| if (rtc::GetBoolFromJsonObject(root, param_name, &v)) { |
| *param = v; |
| if (verbose_output_) { |
| std::cout << param_name << ":" << (*param ? "true" : "false") |
| << std::endl; |
| } |
| } |
| } |
| |
| void ReadParam(const Json::Value& root, |
| std::string param_name, |
| size_t* param) const { |
| RTC_CHECK(param); |
| int v; |
| if (rtc::GetIntFromJsonObject(root, param_name, &v)) { |
| *param = v; |
| if (verbose_output_) { |
| std::cout << param_name << ":" << *param << std::endl; |
| } |
| } |
| } |
| |
| void ReadParam(const Json::Value& root, |
| std::string param_name, |
| int* param) const { |
| RTC_CHECK(param); |
| int v; |
| if (rtc::GetIntFromJsonObject(root, param_name, &v)) { |
| *param = v; |
| if (verbose_output_) { |
| std::cout << param_name << ":" << *param << std::endl; |
| } |
| } |
| } |
| |
| void ReadParam(const Json::Value& root, |
| std::string param_name, |
| float* param) const { |
| RTC_CHECK(param); |
| double v; |
| if (rtc::GetDoubleFromJsonObject(root, param_name, &v)) { |
| *param = static_cast<float>(v); |
| if (verbose_output_) { |
| std::cout << param_name << ":" << *param << std::endl; |
| } |
| } |
| } |
| |
| void ReadParam(const Json::Value& root, |
| std::string param_name, |
| EchoCanceller3Config::Filter::MainConfiguration* param) const { |
| RTC_CHECK(param); |
| Json::Value json_array; |
| if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) { |
| std::vector<double> v; |
| rtc::JsonArrayToDoubleVector(json_array, &v); |
| if (v.size() != 5) { |
| std::cout << "Incorrect array size for " << param_name << std::endl; |
| RTC_CHECK(false); |
| } |
| param->length_blocks = static_cast<size_t>(v[0]); |
| param->leakage_converged = static_cast<float>(v[1]); |
| param->leakage_diverged = static_cast<float>(v[2]); |
| param->error_floor = static_cast<float>(v[3]); |
| param->noise_gate = static_cast<float>(v[4]); |
| |
| if (verbose_output_) { |
| std::cout << param_name << ":" |
| << "[" << param->length_blocks << "," |
| << param->leakage_converged << "," << param->leakage_diverged |
| << "," << param->error_floor << "," << param->noise_gate |
| << "]" << std::endl; |
| } |
| } |
| } |
| |
| void ReadParam( |
| const Json::Value& root, |
| std::string param_name, |
| EchoCanceller3Config::Filter::ShadowConfiguration* param) const { |
| RTC_CHECK(param); |
| Json::Value json_array; |
| if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) { |
| std::vector<double> v; |
| rtc::JsonArrayToDoubleVector(json_array, &v); |
| if (v.size() != 3) { |
| std::cout << "Incorrect array size for " << param_name << std::endl; |
| RTC_CHECK(false); |
| } |
| param->length_blocks = static_cast<size_t>(v[0]); |
| param->rate = static_cast<float>(v[1]); |
| param->noise_gate = static_cast<float>(v[2]); |
| |
| if (verbose_output_) { |
| std::cout << param_name << ":" |
| << "[" << param->length_blocks << "," << param->rate << "," |
| << param->noise_gate << "]" << std::endl; |
| } |
| } |
| } |
| |
| void ReadParam( |
| const Json::Value& root, |
| std::string param_name, |
| EchoCanceller3Config::Suppressor::MaskingThresholds* param) const { |
| RTC_CHECK(param); |
| Json::Value json_array; |
| if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) { |
| std::vector<double> v; |
| rtc::JsonArrayToDoubleVector(json_array, &v); |
| if (v.size() != 3) { |
| std::cout << "Incorrect array size for " << param_name << std::endl; |
| RTC_CHECK(false); |
| } |
| param->enr_transparent = static_cast<float>(v[0]); |
| param->enr_suppress = static_cast<float>(v[1]); |
| param->emr_transparent = static_cast<float>(v[2]); |
| |
| if (verbose_output_) { |
| std::cout << param_name << ":" |
| << "[" << param->enr_transparent << "," << param->enr_suppress |
| << "," << param->emr_transparent << "]" << std::endl; |
| } |
| } |
| } |
| |
| EchoCanceller3Config Parse(const std::string& filename) const { |
| EchoCanceller3Config cfg; |
| Json::Value root; |
| std::string s; |
| std::string json_string; |
| std::ifstream f(filename.c_str()); |
| |
| if (f.fail()) { |
| std::cout << "Failed to open the file " << filename << std::endl; |
| RTC_CHECK(false); |
| } |
| |
| while (std::getline(f, s)) { |
| json_string += s; |
| } |
| bool success = Json::Reader().parse(json_string, root); |
| if (!success) { |
| std::cout << "Incorrect JSON format:" << std::endl; |
| std::cout << json_string << std::endl; |
| RTC_CHECK(false); |
| } |
| |
| if (verbose_output_) { |
| std::cout << "AEC3 Parameters from JSON input:" << std::endl; |
| } |
| Json::Value section; |
| if (rtc::GetValueFromJsonObject(root, "delay", §ion)) { |
| ReadParam(section, "default_delay", &cfg.delay.default_delay); |
| ReadParam(section, "down_sampling_factor", |
| &cfg.delay.down_sampling_factor); |
| ReadParam(section, "num_filters", &cfg.delay.num_filters); |
| ReadParam(section, "api_call_jitter_blocks", |
| &cfg.delay.api_call_jitter_blocks); |
| ReadParam(section, "min_echo_path_delay_blocks", |
| &cfg.delay.min_echo_path_delay_blocks); |
| ReadParam(section, "delay_headroom_blocks", |
| &cfg.delay.delay_headroom_blocks); |
| ReadParam(section, "hysteresis_limit_1_blocks", |
| &cfg.delay.hysteresis_limit_1_blocks); |
| ReadParam(section, "hysteresis_limit_2_blocks", |
| &cfg.delay.hysteresis_limit_2_blocks); |
| ReadParam(section, "skew_hysteresis_blocks", |
| &cfg.delay.skew_hysteresis_blocks); |
| ReadParam(section, "fixed_capture_delay_samples", |
| &cfg.delay.fixed_capture_delay_samples); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "filter", §ion)) { |
| ReadParam(section, "main", &cfg.filter.main); |
| ReadParam(section, "shadow", &cfg.filter.shadow); |
| ReadParam(section, "main_initial", &cfg.filter.main_initial); |
| ReadParam(section, "shadow_initial", &cfg.filter.shadow_initial); |
| ReadParam(section, "config_change_duration_blocks", |
| &cfg.filter.config_change_duration_blocks); |
| ReadParam(section, "initial_state_seconds", |
| &cfg.filter.initial_state_seconds); |
| ReadParam(section, "conservative_initial_phase", |
| &cfg.filter.conservative_initial_phase); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "erle", §ion)) { |
| ReadParam(section, "min", &cfg.erle.min); |
| ReadParam(section, "max_l", &cfg.erle.max_l); |
| ReadParam(section, "max_h", &cfg.erle.max_h); |
| ReadParam(section, "onset_detection", &cfg.erle.onset_detection); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "ep_strength", §ion)) { |
| ReadParam(section, "lf", &cfg.ep_strength.lf); |
| ReadParam(section, "mf", &cfg.ep_strength.mf); |
| ReadParam(section, "hf", &cfg.ep_strength.hf); |
| ReadParam(section, "default_len", &cfg.ep_strength.default_len); |
| ReadParam(section, "reverb_based_on_render", |
| &cfg.ep_strength.reverb_based_on_render); |
| ReadParam(section, "echo_can_saturate", |
| &cfg.ep_strength.echo_can_saturate); |
| ReadParam(section, "bounded_erl", &cfg.ep_strength.bounded_erl); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "gain_mask", §ion)) { |
| ReadParam(section, "m1", &cfg.gain_mask.m1); |
| ReadParam(section, "m2", &cfg.gain_mask.m2); |
| ReadParam(section, "m3", &cfg.gain_mask.m3); |
| ReadParam(section, "m5", &cfg.gain_mask.m5); |
| ReadParam(section, "m6", &cfg.gain_mask.m6); |
| ReadParam(section, "m7", &cfg.gain_mask.m7); |
| ReadParam(section, "m8", &cfg.gain_mask.m8); |
| ReadParam(section, "m9", &cfg.gain_mask.m9); |
| |
| ReadParam(section, "gain_curve_offset", &cfg.gain_mask.gain_curve_offset); |
| ReadParam(section, "gain_curve_slope", &cfg.gain_mask.gain_curve_slope); |
| ReadParam(section, "temporal_masking_lf", |
| &cfg.gain_mask.temporal_masking_lf); |
| ReadParam(section, "temporal_masking_hf", |
| &cfg.gain_mask.temporal_masking_hf); |
| ReadParam(section, "temporal_masking_lf_bands", |
| &cfg.gain_mask.temporal_masking_lf_bands); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "echo_audibility", §ion)) { |
| ReadParam(section, "low_render_limit", |
| &cfg.echo_audibility.low_render_limit); |
| ReadParam(section, "normal_render_limit", |
| &cfg.echo_audibility.normal_render_limit); |
| |
| ReadParam(section, "floor_power", &cfg.echo_audibility.floor_power); |
| ReadParam(section, "audibility_threshold_lf", |
| &cfg.echo_audibility.audibility_threshold_lf); |
| ReadParam(section, "audibility_threshold_mf", |
| &cfg.echo_audibility.audibility_threshold_mf); |
| ReadParam(section, "audibility_threshold_hf", |
| &cfg.echo_audibility.audibility_threshold_hf); |
| ReadParam(section, "use_stationary_properties", |
| &cfg.echo_audibility.use_stationary_properties); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "echo_removal_control", §ion)) { |
| Json::Value subsection; |
| if (rtc::GetValueFromJsonObject(section, "gain_rampup", &subsection)) { |
| ReadParam(subsection, "initial_gain", |
| &cfg.echo_removal_control.gain_rampup.initial_gain); |
| ReadParam(subsection, "first_non_zero_gain", |
| &cfg.echo_removal_control.gain_rampup.first_non_zero_gain); |
| ReadParam(subsection, "non_zero_gain_blocks", |
| &cfg.echo_removal_control.gain_rampup.non_zero_gain_blocks); |
| ReadParam(subsection, "full_gain_blocks", |
| &cfg.echo_removal_control.gain_rampup.full_gain_blocks); |
| } |
| ReadParam(section, "has_clock_drift", |
| &cfg.echo_removal_control.has_clock_drift); |
| ReadParam(section, "linear_and_stable_echo_path", |
| &cfg.echo_removal_control.linear_and_stable_echo_path); |
| } |
| |
| if (rtc::GetValueFromJsonObject(root, "echo_model", §ion)) { |
| Json::Value subsection; |
| ReadParam(section, "noise_floor_hold", &cfg.echo_model.noise_floor_hold); |
| ReadParam(section, "min_noise_floor_power", |
| &cfg.echo_model.min_noise_floor_power); |
| ReadParam(section, "stationary_gate_slope", |
| &cfg.echo_model.stationary_gate_slope); |
| ReadParam(section, "noise_gate_power", &cfg.echo_model.noise_gate_power); |
| ReadParam(section, "noise_gate_slope", &cfg.echo_model.noise_gate_slope); |
| ReadParam(section, "render_pre_window_size", |
| &cfg.echo_model.render_pre_window_size); |
| ReadParam(section, "render_post_window_size", |
| &cfg.echo_model.render_post_window_size); |
| ReadParam(section, "render_pre_window_size_init", |
| &cfg.echo_model.render_pre_window_size_init); |
| ReadParam(section, "render_post_window_size_init", |
| &cfg.echo_model.render_post_window_size_init); |
| ReadParam(section, "nonlinear_hold", &cfg.echo_model.nonlinear_hold); |
| ReadParam(section, "nonlinear_release", |
| &cfg.echo_model.nonlinear_release); |
| } |
| |
| Json::Value subsection; |
| if (rtc::GetValueFromJsonObject(root, "suppressor", §ion)) { |
| ReadParam(section, "nearend_average_blocks", |
| &cfg.suppressor.nearend_average_blocks); |
| |
| if (rtc::GetValueFromJsonObject(section, "normal_tuning", &subsection)) { |
| ReadParam(subsection, "mask_lf", &cfg.suppressor.normal_tuning.mask_lf); |
| ReadParam(subsection, "mask_hf", &cfg.suppressor.normal_tuning.mask_hf); |
| ReadParam(subsection, "max_inc_factor", |
| &cfg.suppressor.normal_tuning.max_inc_factor); |
| ReadParam(subsection, "max_dec_factor_lf", |
| &cfg.suppressor.normal_tuning.max_dec_factor_lf); |
| } |
| |
| if (rtc::GetValueFromJsonObject(section, "nearend_tuning", &subsection)) { |
| ReadParam(subsection, "mask_lf", |
| &cfg.suppressor.nearend_tuning.mask_lf); |
| ReadParam(subsection, "mask_hf", |
| &cfg.suppressor.nearend_tuning.mask_hf); |
| ReadParam(subsection, "max_inc_factor", |
| &cfg.suppressor.nearend_tuning.max_inc_factor); |
| ReadParam(subsection, "max_dec_factor_lf", |
| &cfg.suppressor.nearend_tuning.max_dec_factor_lf); |
| } |
| |
| if (rtc::GetValueFromJsonObject(section, "dominant_nearend_detection", |
| &subsection)) { |
| ReadParam(subsection, "enr_threshold", |
| &cfg.suppressor.dominant_nearend_detection.enr_threshold); |
| ReadParam(subsection, "snr_threshold", |
| &cfg.suppressor.dominant_nearend_detection.snr_threshold); |
| ReadParam(subsection, "hold_duration", |
| &cfg.suppressor.dominant_nearend_detection.hold_duration); |
| ReadParam(subsection, "trigger_threshold", |
| &cfg.suppressor.dominant_nearend_detection.trigger_threshold); |
| } |
| |
| if (rtc::GetValueFromJsonObject(section, "high_bands_suppression", |
| &subsection)) { |
| ReadParam(subsection, "enr_threshold", |
| &cfg.suppressor.high_bands_suppression.enr_threshold); |
| ReadParam(subsection, "max_gain_during_echo", |
| &cfg.suppressor.high_bands_suppression.max_gain_during_echo); |
| } |
| |
| ReadParam(section, "floor_first_increase", |
| &cfg.suppressor.floor_first_increase); |
| ReadParam(section, "enforce_transparent", |
| &cfg.suppressor.enforce_transparent); |
| ReadParam(section, "enforce_empty_higher_bands", |
| &cfg.suppressor.enforce_empty_higher_bands); |
| } |
| |
| std::cout << std::endl; |
| return cfg; |
| } |
| |
| const bool verbose_output_; |
| }; |
| |
| 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()); |
| } |
| |
| std::string GetIndexedOutputWavFilename(const std::string& wav_name, |
| int counter) { |
| std::stringstream ss; |
| ss << wav_name.substr(0, wav_name.size() - 4) << "_" << counter |
| << wav_name.substr(wav_name.size() - 4); |
| return ss.str(); |
| } |
| |
| void WriteEchoLikelihoodGraphFileHeader(std::ofstream* output_file) { |
| (*output_file) << "import numpy as np" << std::endl |
| << "import matplotlib.pyplot as plt" << std::endl |
| << "y = np.array(["; |
| } |
| |
| void WriteEchoLikelihoodGraphFileFooter(std::ofstream* output_file) { |
| (*output_file) << "])" << std::endl |
| << "if __name__ == '__main__':" << std::endl |
| << " x = np.arange(len(y))*.01" << std::endl |
| << " plt.plot(x, y)" << std::endl |
| << " plt.ylabel('Echo likelihood')" << std::endl |
| << " plt.xlabel('Time (s)')" << std::endl |
| << " plt.ylim([0,1])" << std::endl |
| << " plt.show()" << std::endl; |
| } |
| |
| } // namespace |
| |
| SimulationSettings::SimulationSettings() = default; |
| SimulationSettings::SimulationSettings(const SimulationSettings&) = default; |
| SimulationSettings::~SimulationSettings() = default; |
| |
| void CopyToAudioFrame(const ChannelBuffer<float>& src, AudioFrame* dest) { |
| RTC_CHECK_EQ(src.num_channels(), dest->num_channels_); |
| RTC_CHECK_EQ(src.num_frames(), dest->samples_per_channel_); |
| int16_t* dest_data = dest->mutable_data(); |
| 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, |
| std::unique_ptr<AudioProcessingBuilder> ap_builder) |
| : settings_(settings), |
| ap_builder_(ap_builder ? std::move(ap_builder) |
| : absl::make_unique<AudioProcessingBuilder>()), |
| analog_mic_level_(settings.initial_mic_level), |
| fake_recording_device_( |
| settings.initial_mic_level, |
| settings_.simulate_mic_gain ? *settings.simulated_mic_kind : 0), |
| worker_queue_("file_writer_task_queue") { |
| if (settings_.ed_graph_output_filename && |
| !settings_.ed_graph_output_filename->empty()) { |
| 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_); |
| } |
| |
| if (settings_.simulate_mic_gain) |
| RTC_LOG(LS_VERBOSE) << "Simulating analog mic gain"; |
| } |
| |
| 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) { |
| // Optionally use the fake recording device to simulate analog gain. |
| if (settings_.simulate_mic_gain) { |
| if (settings_.aec_dump_input_filename) { |
| // When the analog gain is simulated 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. |
| fake_recording_device_.SetUndoMicLevel(aec_dump_mic_level_); |
| } |
| |
| if (fixed_interface) { |
| fake_recording_device_.SimulateAnalogGain(&fwd_frame_); |
| } else { |
| fake_recording_device_.SimulateAnalogGain(in_buf_.get()); |
| } |
| |
| // Notify the current mic level to AGC. |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->gain_control()->set_stream_analog_level( |
| fake_recording_device_.MicLevel())); |
| } else { |
| // Notify the current mic level to AGC. |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->gain_control()->set_stream_analog_level( |
| settings_.aec_dump_input_filename ? aec_dump_mic_level_ |
| : analog_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. |
| // Note that when the analog gain is simulated and an AEC dump is used as |
| // input, |analog_mic_level_| will not be used with set_stream_analog_level(). |
| analog_mic_level_ = ap_->gain_control()->stream_analog_level(); |
| if (settings_.simulate_mic_gain) { |
| fake_recording_device_.SetMicLevel(analog_mic_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 |
| << ", "; |
| } |
| |
| ++num_process_stream_calls_; |
| } |
| |
| void AudioProcessingSimulator::ProcessReverseStream(bool fixed_interface) { |
| if (fixed_interface) { |
| const auto st = ScopedTimer(mutable_proc_time()); |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->ProcessReverseStream(&rev_frame_)); |
| CopyFromAudioFrame(rev_frame_, reverse_out_buf_.get()); |
| |
| } else { |
| const auto st = ScopedTimer(mutable_proc_time()); |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->ProcessReverseStream( |
| reverse_in_buf_->channels(), reverse_in_config_, |
| reverse_out_config_, reverse_out_buf_->channels())); |
| } |
| |
| if (reverse_buffer_writer_) { |
| reverse_buffer_writer_->Write(*reverse_out_buf_); |
| } |
| |
| ++num_reverse_process_stream_calls_; |
| } |
| |
| void AudioProcessingSimulator::SetupBuffersConfigsOutputs( |
| int input_sample_rate_hz, |
| int output_sample_rate_hz, |
| int reverse_input_sample_rate_hz, |
| int reverse_output_sample_rate_hz, |
| int input_num_channels, |
| int output_num_channels, |
| int reverse_input_num_channels, |
| int reverse_output_num_channels) { |
| in_config_ = StreamConfig(input_sample_rate_hz, input_num_channels); |
| in_buf_.reset(new ChannelBuffer<float>( |
| rtc::CheckedDivExact(input_sample_rate_hz, kChunksPerSecond), |
| input_num_channels)); |
| |
| reverse_in_config_ = |
| StreamConfig(reverse_input_sample_rate_hz, reverse_input_num_channels); |
| reverse_in_buf_.reset(new ChannelBuffer<float>( |
| rtc::CheckedDivExact(reverse_input_sample_rate_hz, kChunksPerSecond), |
| reverse_input_num_channels)); |
| |
| out_config_ = StreamConfig(output_sample_rate_hz, output_num_channels); |
| out_buf_.reset(new ChannelBuffer<float>( |
| rtc::CheckedDivExact(output_sample_rate_hz, kChunksPerSecond), |
| output_num_channels)); |
| |
| reverse_out_config_ = |
| StreamConfig(reverse_output_sample_rate_hz, reverse_output_num_channels); |
| reverse_out_buf_.reset(new ChannelBuffer<float>( |
| rtc::CheckedDivExact(reverse_output_sample_rate_hz, kChunksPerSecond), |
| reverse_output_num_channels)); |
| |
| fwd_frame_.sample_rate_hz_ = input_sample_rate_hz; |
| 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; |
| std::cout << " Reverse input: " << reverse_input_num_channels << std::endl; |
| std::cout << " Reverse output: " << reverse_output_num_channels |
| << std::endl; |
| } |
| |
| SetupOutput(); |
| } |
| |
| void AudioProcessingSimulator::SetupOutput() { |
| if (settings_.output_filename) { |
| std::string filename; |
| if (settings_.store_intermediate_output) { |
| filename = GetIndexedOutputWavFilename(*settings_.output_filename, |
| output_reset_counter_); |
| } else { |
| filename = *settings_.output_filename; |
| } |
| |
| std::unique_ptr<WavWriter> out_file( |
| new WavWriter(filename, out_config_.sample_rate_hz(), |
| static_cast<size_t>(out_config_.num_channels()))); |
| buffer_writer_.reset(new ChannelBufferWavWriter(std::move(out_file))); |
| } |
| |
| if (settings_.reverse_output_filename) { |
| std::string filename; |
| if (settings_.store_intermediate_output) { |
| filename = GetIndexedOutputWavFilename(*settings_.reverse_output_filename, |
| output_reset_counter_); |
| } else { |
| filename = *settings_.reverse_output_filename; |
| } |
| |
| std::unique_ptr<WavWriter> reverse_out_file( |
| new WavWriter(filename, reverse_out_config_.sample_rate_hz(), |
| 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(); |
| } |
| } |
| |
| void AudioProcessingSimulator::CreateAudioProcessor() { |
| Config config; |
| AudioProcessing::Config apm_config; |
| std::unique_ptr<EchoControlFactory> echo_control_factory; |
| if (settings_.use_ts) { |
| config.Set<ExperimentalNs>(new ExperimentalNs(*settings_.use_ts)); |
| } |
| if (settings_.use_agc2) { |
| apm_config.gain_controller2.enabled = *settings_.use_agc2; |
| apm_config.gain_controller2.fixed_gain_db = settings_.agc2_fixed_gain_db; |
| } |
| if (settings_.use_pre_amplifier) { |
| apm_config.pre_amplifier.enabled = *settings_.use_pre_amplifier; |
| apm_config.pre_amplifier.fixed_gain_factor = |
| settings_.pre_amplifier_gain_factor; |
| } |
| |
| if (settings_.use_aec3 && *settings_.use_aec3) { |
| EchoCanceller3Config cfg; |
| if (settings_.aec3_settings_filename) { |
| cfg = Aec3ParametersParser::Parse(!settings_.use_quiet_output, |
| *settings_.aec3_settings_filename); |
| } |
| echo_control_factory.reset(new EchoCanceller3Factory(cfg)); |
| } |
| if (settings_.use_hpf) { |
| apm_config.high_pass_filter.enabled = *settings_.use_hpf; |
| } |
| |
| if (settings_.use_refined_adaptive_filter) { |
| config.Set<RefinedAdaptiveFilter>( |
| new RefinedAdaptiveFilter(*settings_.use_refined_adaptive_filter)); |
| } |
| config.Set<ExtendedFilter>(new ExtendedFilter( |
| !settings_.use_extended_filter || *settings_.use_extended_filter)); |
| config.Set<DelayAgnostic>(new DelayAgnostic(!settings_.use_delay_agnostic || |
| *settings_.use_delay_agnostic)); |
| config.Set<ExperimentalAgc>(new ExperimentalAgc( |
| !settings_.use_experimental_agc || *settings_.use_experimental_agc, |
| !!settings_.use_experimental_agc_agc2_level_estimator && |
| *settings_.use_experimental_agc_agc2_level_estimator, |
| !!settings_.experimental_agc_disable_digital_adaptive && |
| *settings_.experimental_agc_disable_digital_adaptive)); |
| if (settings_.use_ed) { |
| apm_config.residual_echo_detector.enabled = *settings_.use_ed; |
| } |
| |
| RTC_CHECK(ap_builder_); |
| ap_.reset((*ap_builder_) |
| .SetEchoControlFactory(std::move(echo_control_factory)) |
| .Create(config)); |
| RTC_CHECK(ap_); |
| |
| ap_->ApplyConfig(apm_config); |
| |
| if (settings_.use_aec) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->echo_cancellation()->Enable(*settings_.use_aec)); |
| } |
| if (settings_.use_aecm) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->echo_control_mobile()->Enable(*settings_.use_aecm)); |
| } |
| if (settings_.use_agc) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->gain_control()->Enable(*settings_.use_agc)); |
| } |
| if (settings_.use_ns) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->noise_suppression()->Enable(*settings_.use_ns)); |
| } |
| if (settings_.use_le) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->level_estimator()->Enable(*settings_.use_le)); |
| } |
| if (settings_.use_vad) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->voice_detection()->Enable(*settings_.use_vad)); |
| } |
| if (settings_.use_agc_limiter) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, ap_->gain_control()->enable_limiter( |
| *settings_.use_agc_limiter)); |
| } |
| if (settings_.agc_target_level) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->gain_control()->set_target_level_dbfs( |
| *settings_.agc_target_level)); |
| } |
| if (settings_.agc_compression_gain) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->gain_control()->set_compression_gain_db( |
| *settings_.agc_compression_gain)); |
| } |
| if (settings_.agc_mode) { |
| RTC_CHECK_EQ( |
| AudioProcessing::kNoError, |
| ap_->gain_control()->set_mode( |
| static_cast<webrtc::GainControl::Mode>(*settings_.agc_mode))); |
| } |
| |
| if (settings_.use_drift_compensation) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->echo_cancellation()->enable_drift_compensation( |
| *settings_.use_drift_compensation)); |
| } |
| |
| if (settings_.aec_suppression_level) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->echo_cancellation()->set_suppression_level( |
| static_cast<webrtc::EchoCancellation::SuppressionLevel>( |
| *settings_.aec_suppression_level))); |
| } |
| |
| if (settings_.aecm_routing_mode) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->echo_control_mobile()->set_routing_mode( |
| static_cast<webrtc::EchoControlMobile::RoutingMode>( |
| *settings_.aecm_routing_mode))); |
| } |
| |
| if (settings_.use_aecm_comfort_noise) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->echo_control_mobile()->enable_comfort_noise( |
| *settings_.use_aecm_comfort_noise)); |
| } |
| |
| if (settings_.vad_likelihood) { |
| RTC_CHECK_EQ(AudioProcessing::kNoError, |
| ap_->voice_detection()->set_likelihood( |
| static_cast<webrtc::VoiceDetection::Likelihood>( |
| *settings_.vad_likelihood))); |
| } |
| if (settings_.ns_level) { |
| RTC_CHECK_EQ( |
| AudioProcessing::kNoError, |
| 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_)); |
| } |
| } |
| |
| } // namespace test |
| } // namespace webrtc |
