zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate WebRTC test infra to ABSL_FLAG.

Browse Source 
This is the last CL required to migrate WebRTC to ABSL_FLAG, rtc::Flag
will be removed soon after this one lands.

Bug: webrtc:10616
Change-Id: I2807cec39e28a2737d2c49e2dc23f2a6f98d08f0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/145727
Reviewed-by: Tommi <tommi@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28606}
This commit is contained in:
Mirko Bonadei
2019-07-18 13:44:12 +02:00
committed by Commit Bot
parent 63741c7fa1
commit 2ab97f6f8e
48 changed files with 1959 additions and 1705 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
modules/audio_processing/transient/transient_suppression_test.cc
View File

@ -14,36 +14,41 @@
#include <memory>
#include <string>
#include <vector>
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "common_audio/include/audio_util.h"
#include "modules/audio_processing/agc/agc.h"
#include "modules/audio_processing/transient/transient_suppressor.h"
#include "rtc_base/flags.h"
#include "test/gtest.h"
#include "test/testsupport/file_utils.h"
WEBRTC_DEFINE_string(in_file_name, "", "PCM file that contains the signal.");
WEBRTC_DEFINE_string(detection_file_name,
"",
"PCM file that contains the detection signal.");
WEBRTC_DEFINE_string(reference_file_name,
"",
"PCM file that contains the reference signal.");
ABSL_FLAG(std::string, in_file_name, "", "PCM file that contains the signal.");
ABSL_FLAG(std::string,
detection_file_name,
"",
"PCM file that contains the detection signal.");
ABSL_FLAG(std::string,
reference_file_name,
"",
"PCM file that contains the reference signal.");
WEBRTC_DEFINE_int(chunk_size_ms,
10,
"Time between each chunk of samples in milliseconds.");
ABSL_FLAG(int,
chunk_size_ms,
10,
"Time between each chunk of samples in milliseconds.");
WEBRTC_DEFINE_int(sample_rate_hz,
16000,
"Sampling frequency of the signal in Hertz.");
WEBRTC_DEFINE_int(detection_rate_hz,
0,
"Sampling frequency of the detection signal in Hertz.");
ABSL_FLAG(int,
sample_rate_hz,
16000,
"Sampling frequency of the signal in Hertz.");
ABSL_FLAG(int,
detection_rate_hz,
0,
"Sampling frequency of the detection signal in Hertz.");
WEBRTC_DEFINE_int(num_channels, 1, "Number of channels.");
WEBRTC_DEFINE_bool(help, false, "Print this message.");
ABSL_FLAG(int, num_channels, 1, "Number of channels.");
namespace webrtc {
@ -131,19 +136,21 @@ static void WritePCM(FILE* f,
void void_main() {
// TODO(aluebs): Remove all FileWrappers.
// Prepare the input file.
FILE* in_file = fopen(FLAG_in_file_name, "rb");
FILE* in_file = fopen(absl::GetFlag(FLAGS_in_file_name).c_str(), "rb");
ASSERT_TRUE(in_file != NULL);
// Prepare the detection file.
FILE* detection_file = NULL;
if (strlen(FLAG_detection_file_name) > 0) {
detection_file = fopen(FLAG_detection_file_name, "rb");
if (!absl::GetFlag(FLAGS_detection_file_name).empty()) {
detection_file =
fopen(absl::GetFlag(FLAGS_detection_file_name).c_str(), "rb");
}
// Prepare the reference file.
FILE* reference_file = NULL;
if (strlen(FLAG_reference_file_name) > 0) {
reference_file = fopen(FLAG_reference_file_name, "rb");
if (!absl::GetFlag(FLAGS_reference_file_name).empty()) {
reference_file =
fopen(absl::GetFlag(FLAGS_reference_file_name).c_str(), "rb");
}
// Prepare the output file.
@ -151,27 +158,27 @@ void void_main() {
FILE* out_file = fopen(out_file_name.c_str(), "wb");
ASSERT_TRUE(out_file != NULL);
int detection_rate_hz = FLAG_detection_rate_hz;
int detection_rate_hz = absl::GetFlag(FLAGS_detection_rate_hz);
if (detection_rate_hz == 0) {
detection_rate_hz = FLAG_sample_rate_hz;
detection_rate_hz = absl::GetFlag(FLAGS_sample_rate_hz);
}
Agc agc;
TransientSuppressor suppressor;
suppressor.Initialize(FLAG_sample_rate_hz, detection_rate_hz,
FLAG_num_channels);
suppressor.Initialize(absl::GetFlag(FLAGS_sample_rate_hz), detection_rate_hz,
absl::GetFlag(FLAGS_num_channels));
const size_t audio_buffer_size =
FLAG_chunk_size_ms * FLAG_sample_rate_hz / 1000;
const size_t audio_buffer_size = absl::GetFlag(FLAGS_chunk_size_ms) *
absl::GetFlag(FLAGS_sample_rate_hz) / 1000;
const size_t detection_buffer_size =
FLAG_chunk_size_ms * detection_rate_hz / 1000;
absl::GetFlag(FLAGS_chunk_size_ms) * detection_rate_hz / 1000;
// int16 and float variants of the same data.
std::unique_ptr<int16_t[]> audio_buffer_i(
new int16_t[FLAG_num_channels * audio_buffer_size]);
new int16_t[absl::GetFlag(FLAGS_num_channels) * audio_buffer_size]);
std::unique_ptr<float[]> audio_buffer_f(
new float[FLAG_num_channels * audio_buffer_size]);
new float[absl::GetFlag(FLAGS_num_channels) * audio_buffer_size]);
std::unique_ptr<float[]> detection_buffer, reference_buffer;
@ -180,26 +187,27 @@ void void_main() {
if (reference_file)
reference_buffer.reset(new float[audio_buffer_size]);
while (ReadBuffers(in_file, audio_buffer_size, FLAG_num_channels,
audio_buffer_i.get(), detection_file,
detection_buffer_size, detection_buffer.get(),
reference_file, reference_buffer.get())) {
while (ReadBuffers(
in_file, audio_buffer_size, absl::GetFlag(FLAGS_num_channels),
audio_buffer_i.get(), detection_file, detection_buffer_size,
detection_buffer.get(), reference_file, reference_buffer.get())) {
agc.Process(audio_buffer_i.get(), static_cast<int>(audio_buffer_size),
FLAG_sample_rate_hz);
absl::GetFlag(FLAGS_sample_rate_hz));
for (size_t i = 0; i < FLAG_num_channels * audio_buffer_size; ++i) {
for (size_t i = 0;
i < absl::GetFlag(FLAGS_num_channels) * audio_buffer_size; ++i) {
audio_buffer_f[i] = audio_buffer_i[i];
}
ASSERT_EQ(0, suppressor.Suppress(audio_buffer_f.get(), audio_buffer_size,
FLAG_num_channels, detection_buffer.get(),
detection_buffer_size,
reference_buffer.get(), audio_buffer_size,
agc.voice_probability(), true))
ASSERT_EQ(0, suppressor.Suppress(
audio_buffer_f.get(), audio_buffer_size,
absl::GetFlag(FLAGS_num_channels), detection_buffer.get(),
detection_buffer_size, reference_buffer.get(),
audio_buffer_size, agc.voice_probability(), true))
<< "The transient suppressor could not suppress the frame";
// Write result to out file.
WritePCM(out_file, audio_buffer_size, FLAG_num_channels,
WritePCM(out_file, audio_buffer_size, absl::GetFlag(FLAGS_num_channels),
audio_buffer_f.get());
}
@ -216,18 +224,14 @@ void void_main() {
} // namespace webrtc
int main(int argc, char* argv[]) {
if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true) || FLAG_help ||
argc != 1) {
std::vector<char*> args = absl::ParseCommandLine(argc, argv);
if (args.size() != 1) {
printf("%s", webrtc::kUsage);
if (FLAG_help) {
rtc::FlagList::Print(nullptr, false);
return 0;
}
return 1;
}
RTC_CHECK_GT(FLAG_chunk_size_ms, 0);
RTC_CHECK_GT(FLAG_sample_rate_hz, 0);
RTC_CHECK_GT(FLAG_num_channels, 0);
RTC_CHECK_GT(absl::GetFlag(FLAGS_chunk_size_ms), 0);
RTC_CHECK_GT(absl::GetFlag(FLAGS_sample_rate_hz), 0);
RTC_CHECK_GT(absl::GetFlag(FLAGS_num_channels), 0);
webrtc::void_main();
return 0;