blob: 90ebb226d2f6f0b964f8c25e97fd0ce8737a0b5c [file] [log] [blame]
/*
* Copyright (c) 2013 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/transient/transient_suppressor.h"
#include <stdlib.h>
#include <stdio.h>
#include <memory>
#include <string>
#include "gflags/gflags.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/common_audio/include/audio_util.h"
#include "webrtc/modules/audio_processing/agc/agc.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/test/testsupport/fileutils.h"
#include "webrtc/typedefs.h"
DEFINE_string(in_file_name, "", "PCM file that contains the signal.");
DEFINE_string(detection_file_name,
"",
"PCM file that contains the detection signal.");
DEFINE_string(reference_file_name,
"",
"PCM file that contains the reference signal.");
static bool ValidatePositiveInt(const char* flagname, int32_t value) {
if (value <= 0) {
printf("%s must be a positive integer.\n", flagname);
return false;
}
return true;
}
DEFINE_int32(chunk_size_ms,
10,
"Time between each chunk of samples in milliseconds.");
static const bool chunk_size_ms_dummy =
google::RegisterFlagValidator(&FLAGS_chunk_size_ms, &ValidatePositiveInt);
DEFINE_int32(sample_rate_hz,
16000,
"Sampling frequency of the signal in Hertz.");
static const bool sample_rate_hz_dummy =
google::RegisterFlagValidator(&FLAGS_sample_rate_hz, &ValidatePositiveInt);
DEFINE_int32(detection_rate_hz,
0,
"Sampling frequency of the detection signal in Hertz.");
DEFINE_int32(num_channels, 1, "Number of channels.");
static const bool num_channels_dummy =
google::RegisterFlagValidator(&FLAGS_num_channels, &ValidatePositiveInt);
namespace webrtc {
const char kUsage[] =
"\nDetects and suppresses transients from file.\n\n"
"This application loads the signal from the in_file_name with a specific\n"
"num_channels and sample_rate_hz, the detection signal from the\n"
"detection_file_name with a specific detection_rate_hz, and the reference\n"
"signal from the reference_file_name with sample_rate_hz, divides them\n"
"into chunk_size_ms blocks, computes its voice value and depending on the\n"
"voice_threshold does the respective restoration. You can always get the\n"
"all-voiced or all-unvoiced cases by setting the voice_threshold to 0 or\n"
"1 respectively.\n\n";
// Read next buffers from the test files (signed 16-bit host-endian PCM
// format). audio_buffer has int16 samples, detection_buffer has float samples
// with range [-32768,32767], and reference_buffer has float samples with range
// [-1,1]. Return true iff all the buffers were filled completely.
bool ReadBuffers(FILE* in_file,
size_t audio_buffer_size,
int num_channels,
int16_t* audio_buffer,
FILE* detection_file,
size_t detection_buffer_size,
float* detection_buffer,
FILE* reference_file,
float* reference_buffer) {
std::unique_ptr<int16_t[]> tmpbuf;
int16_t* read_ptr = audio_buffer;
if (num_channels > 1) {
tmpbuf.reset(new int16_t[num_channels * audio_buffer_size]);
read_ptr = tmpbuf.get();
}
if (fread(read_ptr,
sizeof(*read_ptr),
num_channels * audio_buffer_size,
in_file) != num_channels * audio_buffer_size) {
return false;
}
// De-interleave.
if (num_channels > 1) {
for (int i = 0; i < num_channels; ++i) {
for (size_t j = 0; j < audio_buffer_size; ++j) {
audio_buffer[i * audio_buffer_size + j] =
read_ptr[i + j * num_channels];
}
}
}
if (detection_file) {
std::unique_ptr<int16_t[]> ibuf(new int16_t[detection_buffer_size]);
if (fread(ibuf.get(), sizeof(ibuf[0]), detection_buffer_size,
detection_file) != detection_buffer_size)
return false;
for (size_t i = 0; i < detection_buffer_size; ++i)
detection_buffer[i] = ibuf[i];
}
if (reference_file) {
std::unique_ptr<int16_t[]> ibuf(new int16_t[audio_buffer_size]);
if (fread(ibuf.get(), sizeof(ibuf[0]), audio_buffer_size, reference_file)
!= audio_buffer_size)
return false;
S16ToFloat(ibuf.get(), audio_buffer_size, reference_buffer);
}
return true;
}
// Write a number of samples to an open signed 16-bit host-endian PCM file.
static void WritePCM(FILE* f,
size_t num_samples,
int num_channels,
const float* buffer) {
std::unique_ptr<int16_t[]> ibuf(new int16_t[num_channels * num_samples]);
// Interleave.
for (int i = 0; i < num_channels; ++i) {
for (size_t j = 0; j < num_samples; ++j) {
ibuf[i + j * num_channels] = FloatS16ToS16(buffer[i * num_samples + j]);
}
}
fwrite(ibuf.get(), sizeof(ibuf[0]), num_channels * num_samples, f);
}
// This application tests the transient suppression by providing a processed
// PCM file, which has to be listened to in order to evaluate the
// performance.
// It gets an audio file, and its voice gain information, and the suppressor
// process it giving the output file "suppressed_keystrokes.pcm".
void void_main() {
// TODO(aluebs): Remove all FileWrappers.
// Prepare the input file.
FILE* in_file = fopen(FLAGS_in_file_name.c_str(), "rb");
ASSERT_TRUE(in_file != NULL);
// Prepare the detection file.
FILE* detection_file = NULL;
if (!FLAGS_detection_file_name.empty()) {
detection_file = fopen(FLAGS_detection_file_name.c_str(), "rb");
}
// Prepare the reference file.
FILE* reference_file = NULL;
if (!FLAGS_reference_file_name.empty()) {
reference_file = fopen(FLAGS_reference_file_name.c_str(), "rb");
}
// Prepare the output file.
std::string out_file_name = test::OutputPath() + "suppressed_keystrokes.pcm";
FILE* out_file = fopen(out_file_name.c_str(), "wb");
ASSERT_TRUE(out_file != NULL);
int detection_rate_hz = FLAGS_detection_rate_hz;
if (detection_rate_hz == 0) {
detection_rate_hz = FLAGS_sample_rate_hz;
}
Agc agc;
TransientSuppressor suppressor;
suppressor.Initialize(
FLAGS_sample_rate_hz, detection_rate_hz, FLAGS_num_channels);
const size_t audio_buffer_size =
FLAGS_chunk_size_ms * FLAGS_sample_rate_hz / 1000;
const size_t detection_buffer_size =
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[FLAGS_num_channels * audio_buffer_size]);
std::unique_ptr<float[]> audio_buffer_f(
new float[FLAGS_num_channels * audio_buffer_size]);
std::unique_ptr<float[]> detection_buffer, reference_buffer;
if (detection_file)
detection_buffer.reset(new float[detection_buffer_size]);
if (reference_file)
reference_buffer.reset(new float[audio_buffer_size]);
while (ReadBuffers(in_file,
audio_buffer_size,
FLAGS_num_channels,
audio_buffer_i.get(),
detection_file,
detection_buffer_size,
detection_buffer.get(),
reference_file,
reference_buffer.get())) {
ASSERT_EQ(0,
agc.Process(audio_buffer_i.get(),
static_cast<int>(audio_buffer_size),
FLAGS_sample_rate_hz))
<< "The AGC could not process the frame";
for (size_t i = 0; i < 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,
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, FLAGS_num_channels, audio_buffer_f.get());
}
fclose(in_file);
if (detection_file) {
fclose(detection_file);
}
if (reference_file) {
fclose(reference_file);
}
fclose(out_file);
}
} // namespace webrtc
int main(int argc, char* argv[]) {
google::SetUsageMessage(webrtc::kUsage);
google::ParseCommandLineFlags(&argc, &argv, true);
webrtc::void_main();
return 0;
}