blob: 41d6dd1e18d25f89e3e408d34f337eed771028b1 [file] [log] [blame]
/*
* Copyright (c) 2014 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 <iostream>
#include <memory>
#include <string.h>
#include "gflags/gflags.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
#include "webrtc/modules/audio_processing/test/aec_dump_based_simulator.h"
#include "webrtc/modules/audio_processing/test/audio_processing_simulator.h"
#include "webrtc/modules/audio_processing/test/wav_based_simulator.h"
namespace webrtc {
namespace test {
namespace {
const int kParameterNotSpecifiedValue = -10000;
const char kUsageDescription[] =
"Usage: audioproc_f [options] -i <input.wav>\n"
" or\n"
" audioproc_f [options] -dump_input <aec_dump>\n"
"\n\n"
"Command-line tool to simulate a call using the audio "
"processing module, either based on wav files or "
"protobuf debug dump recordings.";
DEFINE_string(dump_input, "", "Aec dump input filename");
DEFINE_string(dump_output, "", "Aec dump output filename");
DEFINE_string(i, "", "Forward stream input wav filename");
DEFINE_string(o, "", "Forward stream output wav filename");
DEFINE_string(ri, "", "Reverse stream input wav filename");
DEFINE_string(ro, "", "Reverse stream output wav filename");
DEFINE_int32(output_num_channels,
kParameterNotSpecifiedValue,
"Number of forward stream output channels");
DEFINE_int32(reverse_output_num_channels,
kParameterNotSpecifiedValue,
"Number of Reverse stream output channels");
DEFINE_int32(output_sample_rate_hz,
kParameterNotSpecifiedValue,
"Forward stream output sample rate in Hz");
DEFINE_int32(reverse_output_sample_rate_hz,
kParameterNotSpecifiedValue,
"Reverse stream output sample rate in Hz");
DEFINE_string(mic_positions,
"",
"Space delimited cartesian coordinates of microphones in "
"meters. The coordinates of each point are contiguous. For a "
"two element array: \"x1 y1 z1 x2 y2 z2\"");
DEFINE_int32(target_angle_degrees,
90,
"The azimuth of the target in degrees (0-359). Only applies to "
"beamforming.");
DEFINE_bool(fixed_interface,
false,
"Use the fixed interface when operating on wav files");
DEFINE_int32(aec,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the echo canceller");
DEFINE_int32(aecm,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the mobile echo controller");
DEFINE_int32(agc,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the AGC");
DEFINE_int32(hpf,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the high-pass filter");
DEFINE_int32(ns,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the noise suppressor");
DEFINE_int32(ts,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the transient suppressor");
DEFINE_int32(bf,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the beamformer");
DEFINE_int32(ie,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the intelligibility enhancer");
DEFINE_int32(vad,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the voice activity detector");
DEFINE_int32(le,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the level estimator");
DEFINE_bool(all_default,
false,
"Activate all of the default components (will be overridden by any "
"other settings)");
DEFINE_int32(aec_suppression_level,
kParameterNotSpecifiedValue,
"Set the aec suppression level (0-2)");
DEFINE_int32(delay_agnostic,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the AEC delay agnostic mode");
DEFINE_int32(extended_filter,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the AEC extended filter mode");
DEFINE_int32(drift_compensation,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the drift compensation");
DEFINE_int32(aec3,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the experimental AEC mode AEC3");
DEFINE_int32(lc,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the level control");
DEFINE_int32(
refined_adaptive_filter,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the refined adaptive filter functionality");
DEFINE_int32(aecm_routing_mode,
kParameterNotSpecifiedValue,
"Specify the AECM routing mode (0-4)");
DEFINE_int32(aecm_comfort_noise,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the AECM comfort noise");
DEFINE_int32(agc_mode,
kParameterNotSpecifiedValue,
"Specify the AGC mode (0-2)");
DEFINE_int32(agc_target_level,
kParameterNotSpecifiedValue,
"Specify the AGC target level (0-31)");
DEFINE_int32(agc_limiter,
kParameterNotSpecifiedValue,
"Activate (1) or deactivate(0) the level estimator");
DEFINE_int32(agc_compression_gain,
kParameterNotSpecifiedValue,
"Specify the AGC compression gain (0-90)");
DEFINE_int32(vad_likelihood,
kParameterNotSpecifiedValue,
"Specify the VAD likelihood (0-3)");
DEFINE_int32(ns_level,
kParameterNotSpecifiedValue,
"Specify the NS level (0-3)");
DEFINE_int32(stream_delay,
kParameterNotSpecifiedValue,
"Specify the stream delay in ms to use");
DEFINE_int32(stream_drift_samples,
kParameterNotSpecifiedValue,
"Specify the number of stream drift samples to use");
DEFINE_bool(performance_report, false, "Report the APM performance ");
DEFINE_bool(verbose, false, "Produce verbose output");
DEFINE_bool(bitexactness_report,
false,
"Report bitexactness for aec dump result reproduction");
DEFINE_bool(discard_settings_in_aecdump,
false,
"Discard any config settings specified in the aec dump");
DEFINE_bool(store_intermediate_output,
false,
"Creates new output files after each init");
void SetSettingIfSpecified(const std::string value,
rtc::Optional<std::string>* parameter) {
if (value.compare("") != 0) {
*parameter = rtc::Optional<std::string>(value);
}
}
void SetSettingIfSpecified(int value, rtc::Optional<int>* parameter) {
if (value != kParameterNotSpecifiedValue) {
*parameter = rtc::Optional<int>(value);
}
}
void SetSettingIfFlagSet(int32_t flag, rtc::Optional<bool>* parameter) {
if (flag == 0) {
*parameter = rtc::Optional<bool>(false);
} else if (flag == 1) {
*parameter = rtc::Optional<bool>(true);
}
}
SimulationSettings CreateSettings() {
SimulationSettings settings;
if (FLAGS_all_default) {
settings.use_le = rtc::Optional<bool>(true);
settings.use_vad = rtc::Optional<bool>(true);
settings.use_ie = rtc::Optional<bool>(false);
settings.use_bf = rtc::Optional<bool>(false);
settings.use_ts = rtc::Optional<bool>(true);
settings.use_ns = rtc::Optional<bool>(true);
settings.use_hpf = rtc::Optional<bool>(true);
settings.use_agc = rtc::Optional<bool>(true);
settings.use_aec = rtc::Optional<bool>(true);
settings.use_aecm = rtc::Optional<bool>(false);
}
SetSettingIfSpecified(FLAGS_dump_input, &settings.aec_dump_input_filename);
SetSettingIfSpecified(FLAGS_dump_output, &settings.aec_dump_output_filename);
SetSettingIfSpecified(FLAGS_i, &settings.input_filename);
SetSettingIfSpecified(FLAGS_o, &settings.output_filename);
SetSettingIfSpecified(FLAGS_ri, &settings.reverse_input_filename);
SetSettingIfSpecified(FLAGS_ro, &settings.reverse_output_filename);
SetSettingIfSpecified(FLAGS_output_num_channels,
&settings.output_num_channels);
SetSettingIfSpecified(FLAGS_reverse_output_num_channels,
&settings.reverse_output_num_channels);
SetSettingIfSpecified(FLAGS_output_sample_rate_hz,
&settings.output_sample_rate_hz);
SetSettingIfSpecified(FLAGS_reverse_output_sample_rate_hz,
&settings.reverse_output_sample_rate_hz);
SetSettingIfSpecified(FLAGS_mic_positions, &settings.microphone_positions);
settings.target_angle_degrees = FLAGS_target_angle_degrees;
SetSettingIfFlagSet(FLAGS_aec, &settings.use_aec);
SetSettingIfFlagSet(FLAGS_aecm, &settings.use_aecm);
SetSettingIfFlagSet(FLAGS_agc, &settings.use_agc);
SetSettingIfFlagSet(FLAGS_hpf, &settings.use_hpf);
SetSettingIfFlagSet(FLAGS_ns, &settings.use_ns);
SetSettingIfFlagSet(FLAGS_ts, &settings.use_ts);
SetSettingIfFlagSet(FLAGS_bf, &settings.use_bf);
SetSettingIfFlagSet(FLAGS_ie, &settings.use_ie);
SetSettingIfFlagSet(FLAGS_vad, &settings.use_vad);
SetSettingIfFlagSet(FLAGS_le, &settings.use_le);
SetSettingIfSpecified(FLAGS_aec_suppression_level,
&settings.aec_suppression_level);
SetSettingIfFlagSet(FLAGS_delay_agnostic, &settings.use_delay_agnostic);
SetSettingIfFlagSet(FLAGS_extended_filter, &settings.use_extended_filter);
SetSettingIfFlagSet(FLAGS_drift_compensation,
&settings.use_drift_compensation);
SetSettingIfFlagSet(FLAGS_refined_adaptive_filter,
&settings.use_refined_adaptive_filter);
SetSettingIfFlagSet(FLAGS_aec3, &settings.use_aec3);
SetSettingIfFlagSet(FLAGS_lc, &settings.use_lc);
SetSettingIfSpecified(FLAGS_aecm_routing_mode, &settings.aecm_routing_mode);
SetSettingIfFlagSet(FLAGS_aecm_comfort_noise,
&settings.use_aecm_comfort_noise);
SetSettingIfSpecified(FLAGS_agc_mode, &settings.agc_mode);
SetSettingIfSpecified(FLAGS_agc_target_level, &settings.agc_target_level);
SetSettingIfFlagSet(FLAGS_agc_limiter, &settings.use_agc_limiter);
SetSettingIfSpecified(FLAGS_agc_compression_gain,
&settings.agc_compression_gain);
SetSettingIfSpecified(FLAGS_vad_likelihood, &settings.vad_likelihood);
SetSettingIfSpecified(FLAGS_ns_level, &settings.ns_level);
SetSettingIfSpecified(FLAGS_stream_delay, &settings.stream_delay);
SetSettingIfSpecified(FLAGS_stream_drift_samples,
&settings.stream_drift_samples);
settings.report_performance = FLAGS_performance_report;
settings.use_verbose_logging = FLAGS_verbose;
settings.report_bitexactness = FLAGS_bitexactness_report;
settings.discard_all_settings_in_aecdump = FLAGS_discard_settings_in_aecdump;
settings.fixed_interface = FLAGS_fixed_interface;
settings.store_intermediate_output = FLAGS_store_intermediate_output;
return settings;
}
void ReportConditionalErrorAndExit(bool condition, std::string message) {
if (condition) {
std::cerr << message << std::endl;
exit(1);
}
}
void PerformBasicParameterSanityChecks(const SimulationSettings& settings) {
if (settings.input_filename || settings.reverse_input_filename) {
ReportConditionalErrorAndExit(!!settings.aec_dump_input_filename,
"Error: The aec dump cannot be specified "
"together with input wav files!\n");
ReportConditionalErrorAndExit(!settings.input_filename,
"Error: When operating at wav files, the "
"input wav filename must be "
"specified!\n");
ReportConditionalErrorAndExit(
settings.reverse_output_filename && !settings.reverse_input_filename,
"Error: When operating at wav files, the reverse input wav filename "
"must be specified if the reverse output wav filename is specified!\n");
} else {
ReportConditionalErrorAndExit(!settings.aec_dump_input_filename,
"Error: Either the aec dump or the wav "
"input files must be specified!\n");
}
ReportConditionalErrorAndExit(
settings.use_aec && *settings.use_aec && settings.use_aecm &&
*settings.use_aecm,
"Error: The AEC and the AECM cannot be activated at the same time!\n");
ReportConditionalErrorAndExit(
settings.output_sample_rate_hz && *settings.output_sample_rate_hz <= 0,
"Error: --output_sample_rate_hz must be positive!\n");
ReportConditionalErrorAndExit(
settings.reverse_output_sample_rate_hz &&
settings.output_sample_rate_hz &&
*settings.output_sample_rate_hz <= 0,
"Error: --reverse_output_sample_rate_hz must be positive!\n");
ReportConditionalErrorAndExit(
settings.output_num_channels && *settings.output_num_channels <= 0,
"Error: --output_num_channels must be positive!\n");
ReportConditionalErrorAndExit(
settings.reverse_output_num_channels &&
*settings.reverse_output_num_channels <= 0,
"Error: --reverse_output_num_channels must be positive!\n");
ReportConditionalErrorAndExit(
settings.use_bf && *settings.use_bf && !settings.microphone_positions,
"Error: --mic_positions must be specified when the beamformer is "
"activated.\n");
ReportConditionalErrorAndExit(
settings.target_angle_degrees < 0 || settings.target_angle_degrees > 359,
"Error: -target_angle_degrees must be specified between 0 and 359.\n");
ReportConditionalErrorAndExit(
settings.aec_suppression_level &&
((*settings.aec_suppression_level) < 0 ||
(*settings.aec_suppression_level) > 2),
"Error: --aec_suppression_level must be specified between 0 and 2.\n");
ReportConditionalErrorAndExit(
settings.aecm_routing_mode && ((*settings.aecm_routing_mode) < 0 ||
(*settings.aecm_routing_mode) > 4),
"Error: --aecm_routing_mode must be specified between 0 and 4.\n");
ReportConditionalErrorAndExit(
settings.agc_target_level && ((*settings.agc_target_level) < 0 ||
(*settings.agc_target_level) > 31),
"Error: --agc_target_level must be specified between 0 and 31.\n");
ReportConditionalErrorAndExit(
settings.agc_compression_gain && ((*settings.agc_compression_gain) < 0 ||
(*settings.agc_compression_gain) > 90),
"Error: --agc_compression_gain must be specified between 0 and 90.\n");
ReportConditionalErrorAndExit(
settings.vad_likelihood &&
((*settings.vad_likelihood) < 0 || (*settings.vad_likelihood) > 3),
"Error: --vad_likelihood must be specified between 0 and 3.\n");
ReportConditionalErrorAndExit(
settings.ns_level &&
((*settings.ns_level) < 0 || (*settings.ns_level) > 3),
"Error: --ns_level must be specified between 0 and 3.\n");
ReportConditionalErrorAndExit(
settings.report_bitexactness && !settings.aec_dump_input_filename,
"Error: --bitexactness_report can only be used when operating on an "
"aecdump\n");
auto valid_wav_name = [](const std::string& wav_file_name) {
if (wav_file_name.size() < 5) {
return false;
}
if ((wav_file_name.compare(wav_file_name.size() - 4, 4, ".wav") == 0) ||
(wav_file_name.compare(wav_file_name.size() - 4, 4, ".WAV") == 0)) {
return true;
}
return false;
};
ReportConditionalErrorAndExit(
settings.input_filename && (!valid_wav_name(*settings.input_filename)),
"Error: --i must be a valid .wav file name.\n");
ReportConditionalErrorAndExit(
settings.output_filename && (!valid_wav_name(*settings.output_filename)),
"Error: --o must be a valid .wav file name.\n");
ReportConditionalErrorAndExit(
settings.reverse_input_filename &&
(!valid_wav_name(*settings.reverse_input_filename)),
"Error: --ri must be a valid .wav file name.\n");
ReportConditionalErrorAndExit(
settings.reverse_output_filename &&
(!valid_wav_name(*settings.reverse_output_filename)),
"Error: --ro must be a valid .wav file name.\n");
}
} // namespace
int main(int argc, char* argv[]) {
google::SetUsageMessage(kUsageDescription);
google::ParseCommandLineFlags(&argc, &argv, true);
SimulationSettings settings = CreateSettings();
PerformBasicParameterSanityChecks(settings);
std::unique_ptr<AudioProcessingSimulator> processor;
if (settings.aec_dump_input_filename) {
processor.reset(new AecDumpBasedSimulator(settings));
} else {
processor.reset(new WavBasedSimulator(settings));
}
processor->Process();
if (settings.report_performance) {
const auto& proc_time = processor->proc_time();
int64_t exec_time_us = proc_time.sum / rtc::kNumNanosecsPerMicrosec;
std::cout << std::endl
<< "Execution time: " << exec_time_us * 1e-6 << " s, File time: "
<< processor->get_num_process_stream_calls() * 1.f /
AudioProcessingSimulator::kChunksPerSecond
<< std::endl
<< "Time per fwd stream chunk (mean, max, min): " << std::endl
<< exec_time_us * 1.f / processor->get_num_process_stream_calls()
<< " us, " << 1.f * proc_time.max / rtc::kNumNanosecsPerMicrosec
<< " us, " << 1.f * proc_time.min / rtc::kNumNanosecsPerMicrosec
<< " us" << std::endl;
}
if (settings.report_bitexactness && settings.aec_dump_input_filename) {
if (processor->OutputWasBitexact()) {
std::cout << "The processing was bitexact.";
} else {
std::cout << "The processing was not bitexact.";
}
}
return 0;
}
} // namespace test
} // namespace webrtc
int main(int argc, char* argv[]) {
return webrtc::test::main(argc, argv);
}