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

Reformat the WebRTC code base

Browse Source 
Running clang-format with chromium's style guide.

The goal is n-fold:
 * providing consistency and readability (that's what code guidelines are for)
 * preventing noise with presubmit checks and git cl format
 * building on the previous point: making it easier to automatically fix format issues
 * you name it

Please consider using git-hyper-blame to ignore this commit.

Bug: webrtc:9340
Change-Id: I694567c4cdf8cee2860958cfe82bfaf25848bb87
Reviewed-on: https://webrtc-review.googlesource.com/81185
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23660}
This commit is contained in:
Yves Gerey
2018-06-19 15:03:05 +02:00
parent b602123a5a
commit 665174fdbb
1569 changed files with 30495 additions and 30309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
modules/audio_processing/transient/click_annotate.cc
View File

@ -73,9 +73,7 @@ int main(int argc, char* argv[]) {
// Read first buffer from the PCM test file.
size_t file_samples_read = ReadInt16FromFileToFloatBuffer(
pcm_file.get(),
audio_buffer_length,
audio_buffer.get());
pcm_file.get(), audio_buffer_length, audio_buffer.get());
for (int time = 0; file_samples_read > 0; time += chunk_size_ms) {
// Pad the rest of the buffer with zeros.
for (size_t i = file_samples_read; i < audio_buffer_length; ++i) {
@ -92,14 +90,12 @@ int main(int argc, char* argv[]) {
send_times.push_back(value);
// Read next buffer from the PCM test file.
file_samples_read = ReadInt16FromFileToFloatBuffer(pcm_file.get(),
audio_buffer_length,
audio_buffer.get());
file_samples_read = ReadInt16FromFileToFloatBuffer(
pcm_file.get(), audio_buffer_length, audio_buffer.get());
}
size_t floats_written = WriteFloatBufferToFile(dat_file.get(),
send_times.size(),
&send_times[0]);
size_t floats_written =
WriteFloatBufferToFile(dat_file.get(), send_times.size(), &send_times[0]);
if (floats_written == 0) {
printf("\nThe send times could not be written to DAT file\n\n");

4
modules/audio_processing/transient/common.h
View File

@ -22,6 +22,6 @@ enum {
kSampleRate48kHz = 48000
};
} // namespace ts
} // namespace webrtc
} // namespace ts
} // namespace webrtc
#endif // MODULES_AUDIO_PROCESSING_TRANSIENT_COMMON_H_

53
modules/audio_processing/transient/daubechies_8_wavelet_coeffs.h
View File

@ -19,44 +19,25 @@ namespace webrtc {
const int kDaubechies8CoefficientsLength = 16;
const float kDaubechies8HighPassCoefficients[kDaubechies8CoefficientsLength]
= {
-5.44158422430816093862e-02f,
3.12871590914465924627e-01f,
-6.75630736298012846142e-01f,
5.85354683654869090148e-01f,
1.58291052560238926228e-02f,
-2.84015542962428091389e-01f,
-4.72484573997972536787e-04f,
1.28747426620186011803e-01f,
1.73693010020221083600e-02f,
-4.40882539310647192377e-02f,
-1.39810279170155156436e-02f,
8.74609404701565465445e-03f,
4.87035299301066034600e-03f,
-3.91740372995977108837e-04f,
-6.75449405998556772109e-04f,
-1.17476784002281916305e-04f
};
const float kDaubechies8HighPassCoefficients[kDaubechies8CoefficientsLength] = {
-5.44158422430816093862e-02f, 3.12871590914465924627e-01f,
-6.75630736298012846142e-01f, 5.85354683654869090148e-01f,
1.58291052560238926228e-02f, -2.84015542962428091389e-01f,
-4.72484573997972536787e-04f, 1.28747426620186011803e-01f,
1.73693010020221083600e-02f, -4.40882539310647192377e-02f,
-1.39810279170155156436e-02f, 8.74609404701565465445e-03f,
4.87035299301066034600e-03f, -3.91740372995977108837e-04f,
-6.75449405998556772109e-04f, -1.17476784002281916305e-04f};
const float kDaubechies8LowPassCoefficients[kDaubechies8CoefficientsLength] = {
-1.17476784002281916305e-04f,
6.75449405998556772109e-04f,
-3.91740372995977108837e-04f,
-4.87035299301066034600e-03f,
8.74609404701565465445e-03f,
1.39810279170155156436e-02f,
-4.40882539310647192377e-02f,
-1.73693010020221083600e-02f,
1.28747426620186011803e-01f,
4.72484573997972536787e-04f,
-2.84015542962428091389e-01f,
-1.58291052560238926228e-02f,
5.85354683654869090148e-01f,
6.75630736298012846142e-01f,
3.12871590914465924627e-01f,
5.44158422430816093862e-02f
};
-1.17476784002281916305e-04f, 6.75449405998556772109e-04f,
-3.91740372995977108837e-04f, -4.87035299301066034600e-03f,
8.74609404701565465445e-03f, 1.39810279170155156436e-02f,
-4.40882539310647192377e-02f, -1.73693010020221083600e-02f,
1.28747426620186011803e-01f, 4.72484573997972536787e-04f,
-2.84015542962428091389e-01f, -1.58291052560238926228e-02f,
5.85354683654869090148e-01f, 6.75630736298012846142e-01f,
3.12871590914465924627e-01f, 5.44158422430816093862e-02f};
} // namespace webrtc

2
modules/audio_processing/transient/dyadic_decimator.h
View File

@ -44,7 +44,7 @@ inline size_t GetOutLengthToDyadicDecimate(size_t in_length,
// GetOutLengthToDyadicDecimate().
// Must be previously allocated.
// Returns the number of output samples, -1 on error.
template<typename T>
template <typename T>
static size_t DyadicDecimate(const T* in,
size_t in_length,
bool odd_sequence,

45
modules/audio_processing/transient/dyadic_decimator_unittest.cc
View File

@ -19,7 +19,7 @@ static const size_t kOddBufferLength = 5;
static const size_t kOutBufferLength = 3;
int16_t const test_buffer_even_len[] = {0, 1, 2, 3, 4, 5};
int16_t const test_buffer_odd_len[] = {0, 1, 2, 3, 4};
int16_t const test_buffer_odd_len[] = {0, 1, 2, 3, 4};
int16_t test_buffer_out[kOutBufferLength];
TEST(DyadicDecimatorTest, GetOutLengthToDyadicDecimate) {
@ -29,30 +29,23 @@ TEST(DyadicDecimatorTest, GetOutLengthToDyadicDecimate) {
EXPECT_EQ(2u, GetOutLengthToDyadicDecimate(5, true));
}
TEST(DyadicDecimatorTest, DyadicDecimateErrorValues) {
size_t out_samples = 0;
out_samples = DyadicDecimate(static_cast<int16_t*>(NULL),
kEvenBufferLength,
out_samples = DyadicDecimate(static_cast<int16_t*>(NULL), kEvenBufferLength,
false, // Even sequence.
test_buffer_out,
kOutBufferLength);
test_buffer_out, kOutBufferLength);
EXPECT_EQ(0u, out_samples);
out_samples = DyadicDecimate(test_buffer_even_len,
kEvenBufferLength,
out_samples = DyadicDecimate(test_buffer_even_len, kEvenBufferLength,
false, // Even sequence.
static_cast<int16_t*>(NULL),
kOutBufferLength);
static_cast<int16_t*>(NULL), kOutBufferLength);
EXPECT_EQ(0u, out_samples);
// Less than required |out_length|.
out_samples = DyadicDecimate(test_buffer_even_len,
kEvenBufferLength,
out_samples = DyadicDecimate(test_buffer_even_len, kEvenBufferLength,
false, // Even sequence.
test_buffer_out,
2);
test_buffer_out, 2);
EXPECT_EQ(0u, out_samples);
}
@ -60,11 +53,9 @@ TEST(DyadicDecimatorTest, DyadicDecimateEvenLengthEvenSequence) {
size_t expected_out_samples =
GetOutLengthToDyadicDecimate(kEvenBufferLength, false);
size_t out_samples = DyadicDecimate(test_buffer_even_len,
kEvenBufferLength,
size_t out_samples = DyadicDecimate(test_buffer_even_len, kEvenBufferLength,
false, // Even sequence.
test_buffer_out,
kOutBufferLength);
test_buffer_out, kOutBufferLength);
EXPECT_EQ(expected_out_samples, out_samples);
@ -77,11 +68,9 @@ TEST(DyadicDecimatorTest, DyadicDecimateEvenLengthOddSequence) {
size_t expected_out_samples =
GetOutLengthToDyadicDecimate(kEvenBufferLength, true);
size_t out_samples = DyadicDecimate(test_buffer_even_len,
kEvenBufferLength,
size_t out_samples = DyadicDecimate(test_buffer_even_len, kEvenBufferLength,
true, // Odd sequence.
test_buffer_out,
kOutBufferLength);
test_buffer_out, kOutBufferLength);
EXPECT_EQ(expected_out_samples, out_samples);
@ -94,11 +83,9 @@ TEST(DyadicDecimatorTest, DyadicDecimateOddLengthEvenSequence) {
size_t expected_out_samples =
GetOutLengthToDyadicDecimate(kOddBufferLength, false);
size_t out_samples = DyadicDecimate(test_buffer_odd_len,
kOddBufferLength,
size_t out_samples = DyadicDecimate(test_buffer_odd_len, kOddBufferLength,
false, // Even sequence.
test_buffer_out,
kOutBufferLength);
test_buffer_out, kOutBufferLength);
EXPECT_EQ(expected_out_samples, out_samples);
@ -111,11 +98,9 @@ TEST(DyadicDecimatorTest, DyadicDecimateOddLengthOddSequence) {
size_t expected_out_samples =
GetOutLengthToDyadicDecimate(kOddBufferLength, true);
size_t out_samples = DyadicDecimate(test_buffer_odd_len,
kOddBufferLength,
size_t out_samples = DyadicDecimate(test_buffer_odd_len, kOddBufferLength,
true, // Odd sequence.
test_buffer_out,
kOutBufferLength);
test_buffer_out, kOutBufferLength);
EXPECT_EQ(expected_out_samples, out_samples);

125
modules/audio_processing/transient/file_utils_unittest.cc
View File

@ -11,8 +11,8 @@
#include "modules/audio_processing/transient/file_utils.h"
#include <string.h>
#include <string>
#include <memory>
#include <string>
#include <vector>
#include "rtc_base/system/file_wrapper.h"
@ -26,18 +26,18 @@ static const uint8_t kPiBytesf[4] = {0xDB, 0x0F, 0x49, 0x40};
static const uint8_t kEBytesf[4] = {0x54, 0xF8, 0x2D, 0x40};
static const uint8_t kAvogadroBytesf[4] = {0x2F, 0x0C, 0xFF, 0x66};
static const uint8_t kPiBytes[8] =
{0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40};
static const uint8_t kEBytes[8] =
{0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40};
static const uint8_t kAvogadroBytes[8] =
{0xF4, 0xBC, 0xA8, 0xDF, 0x85, 0xE1, 0xDF, 0x44};
static const uint8_t kPiBytes[8] = {0x18, 0x2D, 0x44, 0x54,
0xFB, 0x21, 0x09, 0x40};
static const uint8_t kEBytes[8] = {0x69, 0x57, 0x14, 0x8B,
0x0A, 0xBF, 0x05, 0x40};
static const uint8_t kAvogadroBytes[8] = {0xF4, 0xBC, 0xA8, 0xDF,
0x85, 0xE1, 0xDF, 0x44};
static const double kPi = 3.14159265358979323846;
static const double kE = 2.71828182845904523536;
static const double kAvogadro = 602214100000000000000000.0;
class TransientFileUtilsTest: public ::testing::Test {
class TransientFileUtilsTest : public ::testing::Test {
protected:
TransientFileUtilsTest()
: kTestFileName(
@ -47,12 +47,10 @@ class TransientFileUtilsTest: public ::testing::Test {
test::ResourcePath("audio_processing/transient/float-utils",
"dat")) {}
~TransientFileUtilsTest() override {
CleanupTempFiles();
}
~TransientFileUtilsTest() override { CleanupTempFiles(); }
std::string CreateTempFilename(const std::string& dir,
const std::string& prefix) {
const std::string& prefix) {
std::string filename = test::TempFilename(dir, prefix);
temp_filenames_.push_back(filename);
return filename;
@ -170,9 +168,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16BufferFromFile) {
const size_t kBufferLength = 12;
std::unique_ptr<int16_t[]> buffer(new int16_t[kBufferLength]);
EXPECT_EQ(kBufferLength, ReadInt16BufferFromFile(file.get(),
kBufferLength,
buffer.get()));
EXPECT_EQ(kBufferLength,
ReadInt16BufferFromFile(file.get(), kBufferLength, buffer.get()));
EXPECT_EQ(22377, buffer[4]);
EXPECT_EQ(16389, buffer[7]);
EXPECT_EQ(17631, buffer[kBufferLength - 1]);
@ -184,9 +181,9 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16BufferFromFile) {
// int16s read.
const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
buffer.reset(new int16_t[kBufferLenghtLargerThanFile]);
EXPECT_EQ(kBufferLength, ReadInt16BufferFromFile(file.get(),
kBufferLenghtLargerThanFile,
buffer.get()));
EXPECT_EQ(kBufferLength,
ReadInt16BufferFromFile(file.get(), kBufferLenghtLargerThanFile,
buffer.get()));
EXPECT_EQ(11544, buffer[0]);
EXPECT_EQ(22377, buffer[4]);
EXPECT_EQ(16389, buffer[7]);
@ -211,9 +208,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToFloatBuffer) {
const size_t kBufferLength = 12;
std::unique_ptr<float[]> buffer(new float[kBufferLength]);
EXPECT_EQ(kBufferLength, ReadInt16FromFileToFloatBuffer(file.get(),
kBufferLength,
buffer.get()));
EXPECT_EQ(kBufferLength, ReadInt16FromFileToFloatBuffer(
file.get(), kBufferLength, buffer.get()));
EXPECT_DOUBLE_EQ(11544, buffer[0]);
EXPECT_DOUBLE_EQ(22377, buffer[4]);
@ -228,9 +224,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToFloatBuffer) {
const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
buffer.reset(new float[kBufferLenghtLargerThanFile]);
EXPECT_EQ(kBufferLength,
ReadInt16FromFileToFloatBuffer(file.get(),
kBufferLenghtLargerThanFile,
buffer.get()));
ReadInt16FromFileToFloatBuffer(
file.get(), kBufferLenghtLargerThanFile, buffer.get()));
EXPECT_DOUBLE_EQ(11544, buffer[0]);
EXPECT_DOUBLE_EQ(22377, buffer[4]);
EXPECT_DOUBLE_EQ(16389, buffer[7]);
@ -255,9 +250,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToDoubleBuffer) {
const size_t kBufferLength = 12;
std::unique_ptr<double[]> buffer(new double[kBufferLength]);
EXPECT_EQ(kBufferLength, ReadInt16FromFileToDoubleBuffer(file.get(),
kBufferLength,
buffer.get()));
EXPECT_EQ(kBufferLength, ReadInt16FromFileToDoubleBuffer(
file.get(), kBufferLength, buffer.get()));
EXPECT_DOUBLE_EQ(11544, buffer[0]);
EXPECT_DOUBLE_EQ(22377, buffer[4]);
EXPECT_DOUBLE_EQ(16389, buffer[7]);
@ -271,9 +265,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadInt16FromFileToDoubleBuffer) {
const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
buffer.reset(new double[kBufferLenghtLargerThanFile]);
EXPECT_EQ(kBufferLength,
ReadInt16FromFileToDoubleBuffer(file.get(),
kBufferLenghtLargerThanFile,
buffer.get()));
ReadInt16FromFileToDoubleBuffer(
file.get(), kBufferLenghtLargerThanFile, buffer.get()));
EXPECT_DOUBLE_EQ(11544, buffer[0]);
EXPECT_DOUBLE_EQ(22377, buffer[4]);
EXPECT_DOUBLE_EQ(16389, buffer[7]);
@ -297,9 +290,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadFloatBufferFromFile) {
const size_t kBufferLength = 3;
std::unique_ptr<float[]> buffer(new float[kBufferLength]);
EXPECT_EQ(kBufferLength, ReadFloatBufferFromFile(file.get(),
kBufferLength,
buffer.get()));
EXPECT_EQ(kBufferLength,
ReadFloatBufferFromFile(file.get(), kBufferLength, buffer.get()));
EXPECT_FLOAT_EQ(kPi, buffer[0]);
EXPECT_FLOAT_EQ(kE, buffer[1]);
EXPECT_FLOAT_EQ(kAvogadro, buffer[2]);
@ -311,9 +303,9 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadFloatBufferFromFile) {
// doubles read.
const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
buffer.reset(new float[kBufferLenghtLargerThanFile]);
EXPECT_EQ(kBufferLength, ReadFloatBufferFromFile(file.get(),
kBufferLenghtLargerThanFile,
buffer.get()));
EXPECT_EQ(kBufferLength,
ReadFloatBufferFromFile(file.get(), kBufferLenghtLargerThanFile,
buffer.get()));
EXPECT_FLOAT_EQ(kPi, buffer[0]);
EXPECT_FLOAT_EQ(kE, buffer[1]);
EXPECT_FLOAT_EQ(kAvogadro, buffer[2]);
@ -336,9 +328,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadDoubleBufferFromFile) {
const size_t kBufferLength = 3;
std::unique_ptr<double[]> buffer(new double[kBufferLength]);
EXPECT_EQ(kBufferLength, ReadDoubleBufferFromFile(file.get(),
kBufferLength,
buffer.get()));
EXPECT_EQ(kBufferLength,
ReadDoubleBufferFromFile(file.get(), kBufferLength, buffer.get()));
EXPECT_DOUBLE_EQ(kPi, buffer[0]);
EXPECT_DOUBLE_EQ(kE, buffer[1]);
EXPECT_DOUBLE_EQ(kAvogadro, buffer[2]);
@ -350,9 +341,9 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadDoubleBufferFromFile) {
// doubles read.
const size_t kBufferLenghtLargerThanFile = kBufferLength * 2;
buffer.reset(new double[kBufferLenghtLargerThanFile]);
EXPECT_EQ(kBufferLength, ReadDoubleBufferFromFile(file.get(),
kBufferLenghtLargerThanFile,
buffer.get()));
EXPECT_EQ(kBufferLength,
ReadDoubleBufferFromFile(file.get(), kBufferLenghtLargerThanFile,
buffer.get()));
EXPECT_DOUBLE_EQ(kPi, buffer[0]);
EXPECT_DOUBLE_EQ(kE, buffer[1]);
EXPECT_DOUBLE_EQ(kAvogadro, buffer[2]);
@ -366,8 +357,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ReadDoubleBufferFromFile) {
TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
std::unique_ptr<FileWrapper> file(FileWrapper::Create());
std::string kOutFileName = CreateTempFilename(test::OutputPath(),
"utils_test");
std::string kOutFileName =
CreateTempFilename(test::OutputPath(), "utils_test");
file->OpenFile(kOutFileName.c_str(), false); // Write mode.
ASSERT_TRUE(file->is_open()) << "File could not be opened:\n"
@ -381,8 +372,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
written_buffer[1] = 2;
written_buffer[2] = 3;
EXPECT_EQ(kBufferLength, WriteInt16BufferToFile(file.get(),
kBufferLength,
EXPECT_EQ(kBufferLength, WriteInt16BufferToFile(file.get(), kBufferLength,
written_buffer.get()));
file->CloseFile();
@ -391,11 +381,9 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
ASSERT_TRUE(file->is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
EXPECT_EQ(kBufferLength, ReadInt16BufferFromFile(file.get(),
kBufferLength,
EXPECT_EQ(kBufferLength, ReadInt16BufferFromFile(file.get(), kBufferLength,
read_buffer.get()));
EXPECT_EQ(0, memcmp(written_buffer.get(),
read_buffer.get(),
EXPECT_EQ(0, memcmp(written_buffer.get(), read_buffer.get(),
kBufferLength * sizeof(written_buffer[0])));
}
@ -407,8 +395,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteInt16BufferToFile) {
TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
std::unique_ptr<FileWrapper> file(FileWrapper::Create());
std::string kOutFileName = CreateTempFilename(test::OutputPath(),
"utils_test");
std::string kOutFileName =
CreateTempFilename(test::OutputPath(), "utils_test");
file->OpenFile(kOutFileName.c_str(), false); // Write mode.
ASSERT_TRUE(file->is_open()) << "File could not be opened:\n"
@ -422,8 +410,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
written_buffer[1] = static_cast<float>(kE);
written_buffer[2] = static_cast<float>(kAvogadro);
EXPECT_EQ(kBufferLength, WriteFloatBufferToFile(file.get(),
kBufferLength,
EXPECT_EQ(kBufferLength, WriteFloatBufferToFile(file.get(), kBufferLength,
written_buffer.get()));
file->CloseFile();
@ -432,11 +419,9 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
ASSERT_TRUE(file->is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
EXPECT_EQ(kBufferLength, ReadFloatBufferFromFile(file.get(),
kBufferLength,
EXPECT_EQ(kBufferLength, ReadFloatBufferFromFile(file.get(), kBufferLength,
read_buffer.get()));
EXPECT_EQ(0, memcmp(written_buffer.get(),
read_buffer.get(),
EXPECT_EQ(0, memcmp(written_buffer.get(), read_buffer.get(),
kBufferLength * sizeof(written_buffer[0])));
}
@ -448,8 +433,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteFloatBufferToFile) {
TEST_F(TransientFileUtilsTest, MAYBE_WriteDoubleBufferToFile) {
std::unique_ptr<FileWrapper> file(FileWrapper::Create());
std::string kOutFileName = CreateTempFilename(test::OutputPath(),
"utils_test");
std::string kOutFileName =
CreateTempFilename(test::OutputPath(), "utils_test");
file->OpenFile(kOutFileName.c_str(), false); // Write mode.
ASSERT_TRUE(file->is_open()) << "File could not be opened:\n"
@ -463,8 +448,7 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteDoubleBufferToFile) {
written_buffer[1] = kE;
written_buffer[2] = kAvogadro;
EXPECT_EQ(kBufferLength, WriteDoubleBufferToFile(file.get(),
kBufferLength,
EXPECT_EQ(kBufferLength, WriteDoubleBufferToFile(file.get(), kBufferLength,
written_buffer.get()));
file->CloseFile();
@ -473,11 +457,9 @@ TEST_F(TransientFileUtilsTest, MAYBE_WriteDoubleBufferToFile) {
ASSERT_TRUE(file->is_open()) << "File could not be opened:\n"
<< kOutFileName.c_str();
EXPECT_EQ(kBufferLength, ReadDoubleBufferFromFile(file.get(),
kBufferLength,
EXPECT_EQ(kBufferLength, ReadDoubleBufferFromFile(file.get(), kBufferLength,
read_buffer.get()));
EXPECT_EQ(0, memcmp(written_buffer.get(),
read_buffer.get(),
EXPECT_EQ(0, memcmp(written_buffer.get(), read_buffer.get(),
kBufferLength * sizeof(written_buffer[0])));
}
@ -501,9 +483,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ExpectedErrorReturnValues) {
// Tests with file not opened.
EXPECT_EQ(0u, ReadInt16BufferFromFile(file.get(), 1, int16_buffer.get()));
EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(file.get(),
1,
double_buffer.get()));
EXPECT_EQ(
0u, ReadInt16FromFileToDoubleBuffer(file.get(), 1, double_buffer.get()));
EXPECT_EQ(0u, ReadDoubleBufferFromFile(file.get(), 1, double_buffer.get()));
EXPECT_EQ(0u, WriteInt16BufferToFile(file.get(), 1, int16_buffer.get()));
EXPECT_EQ(0u, WriteDoubleBufferToFile(file.get(), 1, double_buffer.get()));
@ -518,9 +499,8 @@ TEST_F(TransientFileUtilsTest, MAYBE_ExpectedErrorReturnValues) {
EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(NULL, 1, double_buffer.get()));
EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(file.get(), 1, NULL));
EXPECT_EQ(0u, ReadInt16FromFileToDoubleBuffer(file.get(),
0,
double_buffer.get()));
EXPECT_EQ(
0u, ReadInt16FromFileToDoubleBuffer(file.get(), 0, double_buffer.get()));
EXPECT_EQ(0u, ReadDoubleBufferFromFile(NULL, 1, double_buffer.get()));
EXPECT_EQ(0u, ReadDoubleBufferFromFile(file.get(), 1, NULL));
@ -536,4 +516,3 @@ TEST_F(TransientFileUtilsTest, MAYBE_ExpectedErrorReturnValues) {
}
} // namespace webrtc

11
modules/audio_processing/transient/moving_moments.cc
View File

@ -18,10 +18,7 @@
namespace webrtc {
MovingMoments::MovingMoments(size_t length)
: length_(length),
queue_(),
sum_(0.0),
sum_of_squares_(0.0) {
: length_(length), queue_(), sum_(0.0), sum_of_squares_(0.0) {
RTC_DCHECK_GT(length, 0);
for (size_t i = 0; i < length; ++i) {
queue_.push(0.0);
@ -30,8 +27,10 @@ MovingMoments::MovingMoments(size_t length)
MovingMoments::~MovingMoments() {}
void MovingMoments::CalculateMoments(const float* in, size_t in_length,
float* first, float* second) {
void MovingMoments::CalculateMoments(const float* in,
size_t in_length,
float* first,
float* second) {
RTC_DCHECK(in);
RTC_DCHECK_GT(in_length, 0);
RTC_DCHECK(first);

7
modules/audio_processing/transient/moving_moments.h
View File

@ -33,8 +33,10 @@ class MovingMoments {
// Calculates the new values using |in|. Results will be in the out buffers.
// |first| and |second| must be allocated with at least |in_length|.
void CalculateMoments(const float* in, size_t in_length,
float* first, float* second);
void CalculateMoments(const float* in,
size_t in_length,
float* first,
float* second);
private:
size_t length_;
@ -48,5 +50,4 @@ class MovingMoments {
} // namespace webrtc
#endif // MODULES_AUDIO_PROCESSING_TRANSIENT_MOVING_MOMENTS_H_

134
modules/audio_processing/transient/moving_moments_unittest.cc
View File

@ -26,7 +26,8 @@ class MovingMomentsTest : public ::testing::Test {
virtual void SetUp();
// Calls CalculateMoments and verifies that it produces the expected
// outputs.
void CalculateMomentsAndVerify(const float* input, size_t input_length,
void CalculateMomentsAndVerify(const float* input,
size_t input_length,
const float* expected_mean,
const float* expected_mean_squares);
@ -42,14 +43,13 @@ void MovingMomentsTest::SetUp() {
}
void MovingMomentsTest::CalculateMomentsAndVerify(
const float* input, size_t input_length,
const float* input,
size_t input_length,
const float* expected_mean,
const float* expected_mean_squares) {
ASSERT_LE(input_length, kMaxOutputLength);
moving_moments_->CalculateMoments(input,
input_length,
output_mean_,
moving_moments_->CalculateMoments(input, input_length, output_mean_,
output_mean_squares_);
for (size_t i = 1; i < input_length; ++i) {
@ -73,10 +73,10 @@ TEST_F(MovingMomentsTest, CorrectMomentsOfAConstantBuffer) {
const float kInput[] = {5.f, 5.f, 5.f, 5.f, 5.f, 5.f, 5.f, 5.f, 5.f, 5.f};
const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
const float expected_mean[kInputLength] =
{1.f, 2.f, 3.f, 4.f, 5.f, 5.f, 5.f, 5.f, 5.f, 5.f};
const float expected_mean_squares[kInputLength] =
{5.f, 10.f, 15.f, 20.f, 25.f, 25.f, 25.f, 25.f, 25.f, 25.f};
const float expected_mean[kInputLength] = {1.f, 2.f, 3.f, 4.f, 5.f,
5.f, 5.f, 5.f, 5.f, 5.f};
const float expected_mean_squares[kInputLength] = {
5.f, 10.f, 15.f, 20.f, 25.f, 25.f, 25.f, 25.f, 25.f, 25.f};
CalculateMomentsAndVerify(kInput, kInputLength, expected_mean,
expected_mean_squares);
@ -86,24 +86,23 @@ TEST_F(MovingMomentsTest, CorrectMomentsOfAnIncreasingBuffer) {
const float kInput[] = {1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f};
const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
const float expected_mean[kInputLength] =
{0.2f, 0.6f, 1.2f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f};
const float expected_mean_squares[kInputLength] =
{0.2f, 1.f, 2.8f, 6.f, 11.f, 18.f, 27.f, 38.f, 51.f};
const float expected_mean[kInputLength] = {0.2f, 0.6f, 1.2f, 2.f, 3.f,
4.f, 5.f, 6.f, 7.f};
const float expected_mean_squares[kInputLength] = {
0.2f, 1.f, 2.8f, 6.f, 11.f, 18.f, 27.f, 38.f, 51.f};
CalculateMomentsAndVerify(kInput, kInputLength, expected_mean,
expected_mean_squares);
}
TEST_F(MovingMomentsTest, CorrectMomentsOfADecreasingBuffer) {
const float kInput[] =
{-1.f, -2.f, -3.f, -4.f, -5.f, -6.f, -7.f, -8.f, -9.f};
const float kInput[] = {-1.f, -2.f, -3.f, -4.f, -5.f, -6.f, -7.f, -8.f, -9.f};
const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
const float expected_mean[kInputLength] =
{-0.2f, -0.6f, -1.2f, -2.f, -3.f, -4.f, -5.f, -6.f, -7.f};
const float expected_mean_squares[kInputLength] =
{0.2f, 1.f, 2.8f, 6.f, 11.f, 18.f, 27.f, 38.f, 51.f};
const float expected_mean[kInputLength] = {-0.2f, -0.6f, -1.2f, -2.f, -3.f,
-4.f, -5.f, -6.f, -7.f};
const float expected_mean_squares[kInputLength] = {
0.2f, 1.f, 2.8f, 6.f, 11.f, 18.f, 27.f, 38.f, 51.f};
CalculateMomentsAndVerify(kInput, kInputLength, expected_mean,
expected_mean_squares);
@ -112,76 +111,78 @@ TEST_F(MovingMomentsTest, CorrectMomentsOfADecreasingBuffer) {
TEST_F(MovingMomentsTest, CorrectMomentsOfAZeroMeanSequence) {
const size_t kMovingMomentsBufferLength = 4;
moving_moments_.reset(new MovingMoments(kMovingMomentsBufferLength));
const float kInput[] =
{1.f, -1.f, 1.f, -1.f, 1.f, -1.f, 1.f, -1.f, 1.f, -1.f};
const float kInput[] = {1.f, -1.f, 1.f, -1.f, 1.f,
-1.f, 1.f, -1.f, 1.f, -1.f};
const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
const float expected_mean[kInputLength] =
{0.25f, 0.f, 0.25f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
const float expected_mean_squares[kInputLength] =
{0.25f, 0.5f, 0.75f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
const float expected_mean[kInputLength] = {0.25f, 0.f, 0.25f, 0.f, 0.f,
0.f, 0.f, 0.f, 0.f, 0.f};
const float expected_mean_squares[kInputLength] = {
0.25f, 0.5f, 0.75f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
CalculateMomentsAndVerify(kInput, kInputLength, expected_mean,
expected_mean_squares);
}
TEST_F(MovingMomentsTest, CorrectMomentsOfAnArbitraryBuffer) {
const float kInput[] =
{0.2f, 0.3f, 0.5f, 0.7f, 0.11f, 0.13f, 0.17f, 0.19f, 0.23f};
const float kInput[] = {0.2f, 0.3f, 0.5f, 0.7f, 0.11f,
0.13f, 0.17f, 0.19f, 0.23f};
const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
const float expected_mean[kInputLength] =
{0.04f, 0.1f, 0.2f, 0.34f, 0.362f, 0.348f, 0.322f, 0.26f, 0.166f};
const float expected_mean_squares[kInputLength] =
{0.008f, 0.026f, 0.076f, 0.174f, 0.1764f, 0.1718f, 0.1596f, 0.1168f,
0.0294f};
const float expected_mean[kInputLength] = {
0.04f, 0.1f, 0.2f, 0.34f, 0.362f, 0.348f, 0.322f, 0.26f, 0.166f};
const float expected_mean_squares[kInputLength] = {0.008f, 0.026f, 0.076f,
0.174f, 0.1764f, 0.1718f,
0.1596f, 0.1168f, 0.0294f};
CalculateMomentsAndVerify(kInput, kInputLength, expected_mean,
expected_mean_squares);
}
TEST_F(MovingMomentsTest, MutipleCalculateMomentsCalls) {
const float kInputFirstCall[] =
{0.2f, 0.3f, 0.5f, 0.7f, 0.11f, 0.13f, 0.17f, 0.19f, 0.23f};
const size_t kInputFirstCallLength = sizeof(kInputFirstCall) /
sizeof(kInputFirstCall[0]);
const float kInputFirstCall[] = {0.2f, 0.3f, 0.5f, 0.7f, 0.11f,
0.13f, 0.17f, 0.19f, 0.23f};
const size_t kInputFirstCallLength =
sizeof(kInputFirstCall) / sizeof(kInputFirstCall[0]);
const float kInputSecondCall[] = {0.29f, 0.31f};
const size_t kInputSecondCallLength = sizeof(kInputSecondCall) /
sizeof(kInputSecondCall[0]);
const size_t kInputSecondCallLength =
sizeof(kInputSecondCall) / sizeof(kInputSecondCall[0]);
const float kInputThirdCall[] = {0.37f, 0.41f, 0.43f, 0.47f};
const size_t kInputThirdCallLength = sizeof(kInputThirdCall) /
sizeof(kInputThirdCall[0]);
const size_t kInputThirdCallLength =
sizeof(kInputThirdCall) / sizeof(kInputThirdCall[0]);
const float expected_mean_first_call[kInputFirstCallLength] =
{0.04f, 0.1f, 0.2f, 0.34f, 0.362f, 0.348f, 0.322f, 0.26f, 0.166f};
const float expected_mean_squares_first_call[kInputFirstCallLength] =
{0.008f, 0.026f, 0.076f, 0.174f, 0.1764f, 0.1718f, 0.1596f, 0.1168f,
0.0294f};
const float expected_mean_first_call[kInputFirstCallLength] = {
0.04f, 0.1f, 0.2f, 0.34f, 0.362f, 0.348f, 0.322f, 0.26f, 0.166f};
const float expected_mean_squares_first_call[kInputFirstCallLength] = {
0.008f, 0.026f, 0.076f, 0.174f, 0.1764f,
0.1718f, 0.1596f, 0.1168f, 0.0294f};
const float expected_mean_second_call[kInputSecondCallLength] =
{0.202f, 0.238f};
const float expected_mean_squares_second_call[kInputSecondCallLength] =
{0.0438f, 0.0596f};
const float expected_mean_second_call[kInputSecondCallLength] = {0.202f,
0.238f};
const float expected_mean_squares_second_call[kInputSecondCallLength] = {
0.0438f, 0.0596f};
const float expected_mean_third_call[kInputThirdCallLength] =
{0.278f, 0.322f, 0.362f, 0.398f};
const float expected_mean_squares_third_call[kInputThirdCallLength] =
{0.0812f, 0.1076f, 0.134f, 0.1614f};
const float expected_mean_third_call[kInputThirdCallLength] = {
0.278f, 0.322f, 0.362f, 0.398f};
const float expected_mean_squares_third_call[kInputThirdCallLength] = {
0.0812f, 0.1076f, 0.134f, 0.1614f};
CalculateMomentsAndVerify(kInputFirstCall, kInputFirstCallLength,
expected_mean_first_call, expected_mean_squares_first_call);
expected_mean_first_call,
expected_mean_squares_first_call);
CalculateMomentsAndVerify(kInputSecondCall, kInputSecondCallLength,
expected_mean_second_call, expected_mean_squares_second_call);
expected_mean_second_call,
expected_mean_squares_second_call);
CalculateMomentsAndVerify(kInputThirdCall, kInputThirdCallLength,
expected_mean_third_call, expected_mean_squares_third_call);
expected_mean_third_call,
expected_mean_squares_third_call);
}
TEST_F(MovingMomentsTest,
VerifySampleBasedVsBlockBasedCalculation) {
const float kInput[] =
{0.2f, 0.3f, 0.5f, 0.7f, 0.11f, 0.13f, 0.17f, 0.19f, 0.23f};
TEST_F(MovingMomentsTest, VerifySampleBasedVsBlockBasedCalculation) {
const float kInput[] = {0.2f, 0.3f, 0.5f, 0.7f, 0.11f,
0.13f, 0.17f, 0.19f, 0.23f};
const size_t kInputLength = sizeof(kInput) / sizeof(kInput[0]);
float output_mean_block_based[kInputLength];
@ -190,17 +191,16 @@ TEST_F(MovingMomentsTest,
float output_mean_sample_based;
float output_mean_squares_sample_based;
moving_moments_->CalculateMoments(
kInput, kInputLength, output_mean_block_based,
output_mean_squares_block_based);
moving_moments_->CalculateMoments(kInput, kInputLength,
output_mean_block_based,
output_mean_squares_block_based);
moving_moments_.reset(new MovingMoments(kMovingMomentsBufferLength));
for (size_t i = 0; i < kInputLength; ++i) {
moving_moments_->CalculateMoments(
&kInput[i], 1, &output_mean_sample_based,
&output_mean_squares_sample_based);
moving_moments_->CalculateMoments(&kInput[i], 1, &output_mean_sample_based,
&output_mean_squares_sample_based);
EXPECT_FLOAT_EQ(output_mean_block_based[i], output_mean_sample_based);
EXPECT_FLOAT_EQ(output_mean_squares_block_based[i],
output_mean_squares_sample_based);
output_mean_squares_sample_based);
}
}

11
modules/audio_processing/transient/transient_detector.cc
View File

@ -51,8 +51,7 @@ TransientDetector::TransientDetector(int sample_rate_hz)
wpd_tree_.reset(new WPDTree(samples_per_chunk_,
kDaubechies8HighPassCoefficients,
kDaubechies8LowPassCoefficients,
kDaubechies8CoefficientsLength,
kLevels));
kDaubechies8CoefficientsLength, kLevels));
for (size_t i = 0; i < kLeaves; ++i) {
moving_moments_[i].reset(
new MovingMoments(samples_per_transient / kLeaves));
@ -86,8 +85,7 @@ float TransientDetector::Detect(const float* data,
for (size_t i = 0; i < kLeaves; ++i) {
WPDNode* leaf = wpd_tree_->NodeAt(kLevels, i);
moving_moments_[i]->CalculateMoments(leaf->data(),
tree_leaves_data_length_,
moving_moments_[i]->CalculateMoments(leaf->data(), tree_leaves_data_length_,
first_moments_.get(),
second_moments_.get());
@ -127,8 +125,9 @@ float TransientDetector::Detect(const float* data,
const float kVerticalScaling = 0.5f;
const float kVerticalShift = 1.f;
result = (cos(result * horizontal_scaling + kHorizontalShift)
+ kVerticalShift) * kVerticalScaling;
result =
(cos(result * horizontal_scaling + kHorizontalShift) + kVerticalShift) *
kVerticalScaling;
result *= result;
}

12
modules/audio_processing/transient/transient_detector_unittest.cc
View File

@ -23,8 +23,7 @@
namespace webrtc {
static const int kSampleRatesHz[] = {ts::kSampleRate8kHz,
ts::kSampleRate16kHz,
static const int kSampleRatesHz[] = {ts::kSampleRate8kHz, ts::kSampleRate16kHz,
ts::kSampleRate32kHz,
ts::kSampleRate48kHz};
static const size_t kNumberOfSampleRates =
@ -57,7 +56,7 @@ TEST(TransientDetectorTest, CorrectnessBasedOnFiles) {
bool file_opened = detect_file->is_open();
ASSERT_TRUE(file_opened) << "File could not be opened.\n"
<< detect_file_name.str().c_str();
<< detect_file_name.str().c_str();
// Prepare audio file.
std::stringstream audio_file_name;
@ -80,8 +79,7 @@ TEST(TransientDetectorTest, CorrectnessBasedOnFiles) {
size_t frames_read = 0;
while (ReadInt16FromFileToFloatBuffer(audio_file.get(),
buffer_length,
while (ReadInt16FromFileToFloatBuffer(audio_file.get(), buffer_length,
buffer.get()) == buffer_length) {
++frames_read;
@ -92,8 +90,8 @@ TEST(TransientDetectorTest, CorrectnessBasedOnFiles) {
<< "Detect test file is malformed.\n";
// Compare results with data from the matlab test file.
EXPECT_NEAR(file_value, detector_value, kTolerance) << "Frame: "
<< frames_read;
EXPECT_NEAR(file_value, detector_value, kTolerance)
<< "Frame: " << frames_read;
}
detect_file->CloseFile();

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

@ -10,8 +10,8 @@
#include "modules/audio_processing/transient/transient_suppressor.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory>
@ -36,9 +36,7 @@ DEFINE_int(chunk_size_ms,
10,
"Time between each chunk of samples in milliseconds.");
DEFINE_int(sample_rate_hz,
16000,
"Sampling frequency of the signal in Hertz.");
DEFINE_int(sample_rate_hz, 16000, "Sampling frequency of the signal in Hertz.");
DEFINE_int(detection_rate_hz,
0,
"Sampling frequency of the detection signal in Hertz.");
@ -79,9 +77,7 @@ bool ReadBuffers(FILE* in_file,
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,
if (fread(read_ptr, sizeof(*read_ptr), num_channels * audio_buffer_size,
in_file) != num_channels * audio_buffer_size) {
return false;
}
@ -104,8 +100,8 @@ bool ReadBuffers(FILE* in_file,
}
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)
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);
}
@ -163,8 +159,8 @@ void void_main() {
Agc agc;
TransientSuppressor suppressor;
suppressor.Initialize(
FLAG_sample_rate_hz, detection_rate_hz, FLAG_num_channels);
suppressor.Initialize(FLAG_sample_rate_hz, detection_rate_hz,
FLAG_num_channels);
const size_t audio_buffer_size =
FLAG_chunk_size_ms * FLAG_sample_rate_hz / 1000;
@ -184,38 +180,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())) {
agc.Process(audio_buffer_i.get(),
static_cast<int>(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())) {
agc.Process(audio_buffer_i.get(), static_cast<int>(audio_buffer_size),
FLAG_sample_rate_hz);
for (size_t i = 0; i < FLAG_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,
FLAG_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, audio_buffer_f.get());
WritePCM(out_file, audio_buffer_size, FLAG_num_channels,
audio_buffer_f.get());
}
fclose(in_file);
@ -231,8 +216,8 @@ void void_main() {
} // namespace webrtc
int main(int argc, char* argv[]) {
if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true) ||
FLAG_help || argc != 1) {
if (rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true) || FLAG_help ||
argc != 1) {
printf("%s", webrtc::kUsage);
if (FLAG_help) {
rtc::FlagList::Print(nullptr, false);

49
modules/audio_processing/transient/transient_suppressor.cc
View File

@ -60,8 +60,7 @@ TransientSuppressor::TransientSuppressor()
use_hard_restoration_(false),
chunks_since_voice_change_(0),
seed_(182),
using_reference_(false) {
}
using_reference_(false) {}
TransientSuppressor::~TransientSuppressor() {}
@ -110,17 +109,14 @@ int TransientSuppressor::Initialize(int sample_rate_hz,
RTC_DCHECK_GE(complex_analysis_length_, kMaxVoiceBin);
num_channels_ = num_channels;
in_buffer_.reset(new float[analysis_length_ * num_channels_]);
memset(in_buffer_.get(),
0,
memset(in_buffer_.get(), 0,
analysis_length_ * num_channels_ * sizeof(in_buffer_[0]));
detection_length_ = detection_rate_hz * ts::kChunkSizeMs / 1000;
detection_buffer_.reset(new float[detection_length_]);
memset(detection_buffer_.get(),
0,
memset(detection_buffer_.get(), 0,
detection_length_ * sizeof(detection_buffer_[0]));
out_buffer_.reset(new float[analysis_length_ * num_channels_]);
memset(out_buffer_.get(),
0,
memset(out_buffer_.get(), 0,
analysis_length_ * num_channels_ * sizeof(out_buffer_[0]));
// ip[0] must be zero to trigger initialization using rdft().
size_t ip_length = 2 + sqrtf(analysis_length_);
@ -129,14 +125,12 @@ int TransientSuppressor::Initialize(int sample_rate_hz,
wfft_.reset(new float[complex_analysis_length_ - 1]);
memset(wfft_.get(), 0, (complex_analysis_length_ - 1) * sizeof(wfft_[0]));
spectral_mean_.reset(new float[complex_analysis_length_ * num_channels_]);
memset(spectral_mean_.get(),
0,
memset(spectral_mean_.get(), 0,
complex_analysis_length_ * num_channels_ * sizeof(spectral_mean_[0]));
fft_buffer_.reset(new float[analysis_length_ + 2]);
memset(fft_buffer_.get(), 0, (analysis_length_ + 2) * sizeof(fft_buffer_[0]));
magnitudes_.reset(new float[complex_analysis_length_]);
memset(magnitudes_.get(),
0,
memset(magnitudes_.get(), 0,
complex_analysis_length_ * sizeof(magnitudes_[0]));
mean_factor_.reset(new float[complex_analysis_length_]);
@ -190,8 +184,8 @@ int TransientSuppressor::Suppress(float* data,
detection_data = &in_buffer_[buffer_delay_];
}
float detector_result = detector_->Detect(
detection_data, detection_length, reference_data, reference_length);
float detector_result = detector_->Detect(detection_data, detection_length,
reference_data, reference_length);
if (detector_result < 0) {
return -1;
}
@ -247,8 +241,8 @@ void TransientSuppressor::Suppress(float* in_ptr,
fft_buffer_[1] = 0.f;
for (size_t i = 0; i < complex_analysis_length_; ++i) {
magnitudes_[i] = ComplexMagnitude(fft_buffer_[i * 2],
fft_buffer_[i * 2 + 1]);
magnitudes_[i] =
ComplexMagnitude(fft_buffer_[i * 2], fft_buffer_[i * 2 + 1]);
}
// Restore audio if necessary.
if (suppression_enabled_) {
@ -269,11 +263,7 @@ void TransientSuppressor::Suppress(float* in_ptr,
// Put R[n/2] back in fft_buffer_[1].
fft_buffer_[1] = fft_buffer_[analysis_length_];
WebRtc_rdft(analysis_length_,
-1,
fft_buffer_.get(),
ip_.get(),
wfft_.get());
WebRtc_rdft(analysis_length_, -1, fft_buffer_.get(), ip_.get(), wfft_.get());
const float fft_scaling = 2.f / analysis_length_;
for (size_t i = 0; i < analysis_length_; ++i) {
@ -301,8 +291,7 @@ void TransientSuppressor::UpdateKeypress(bool key_pressed) {
keypress_counter_ = 0;
}
if (detection_enabled_ &&
++chunks_since_keypress_ > kChunksUntilNotTyping) {
if (detection_enabled_ && ++chunks_since_keypress_ > kChunksUntilNotTyping) {
if (suppression_enabled_) {
RTC_LOG(LS_INFO) << "[ts] Transient suppression is now disabled.";
}
@ -337,26 +326,22 @@ void TransientSuppressor::UpdateRestoration(float voice_probability) {
// |detection_enabled_| is updated by UpdateKeypress().
void TransientSuppressor::UpdateBuffers(float* data) {
// TODO(aluebs): Change to ring buffer.
memmove(in_buffer_.get(),
&in_buffer_[data_length_],
memmove(in_buffer_.get(), &in_buffer_[data_length_],
(buffer_delay_ + (num_channels_ - 1) * analysis_length_) *
sizeof(in_buffer_[0]));
// Copy new chunk to buffer.
for (int i = 0; i < num_channels_; ++i) {
memcpy(&in_buffer_[buffer_delay_ + i * analysis_length_],
&data[i * data_length_],
data_length_ * sizeof(*data));
&data[i * data_length_], data_length_ * sizeof(*data));
}
if (detection_enabled_) {
// Shift previous chunk in out buffer.
memmove(out_buffer_.get(),
&out_buffer_[data_length_],
memmove(out_buffer_.get(), &out_buffer_[data_length_],
(buffer_delay_ + (num_channels_ - 1) * analysis_length_) *
sizeof(out_buffer_[0]));
// Initialize new chunk in out buffer.
for (int i = 0; i < num_channels_; ++i) {
memset(&out_buffer_[buffer_delay_ + i * analysis_length_],
0,
memset(&out_buffer_[buffer_delay_ + i * analysis_length_], 0,
data_length_ * sizeof(out_buffer_[0]));
}
}
@ -375,7 +360,7 @@ void TransientSuppressor::HardRestoration(float* spectral_mean) {
if (magnitudes_[i] > spectral_mean[i] && magnitudes_[i] > 0) {
// RandU() generates values on [0, int16::max()]
const float phase = 2 * ts::kPi * WebRtcSpl_RandU(&seed_) /
std::numeric_limits<int16_t>::max();
std::numeric_limits<int16_t>::max();
const float scaled_mean = detector_result * spectral_mean[i];
fft_buffer_[i * 2] = (1 - detector_result) * fft_buffer_[i * 2] +

13
modules/audio_processing/transient/wpd_node.cc
View File

@ -23,13 +23,12 @@ namespace webrtc {
WPDNode::WPDNode(size_t length,
const float* coefficients,
size_t coefficients_length)
: // The data buffer has parent data length to be able to contain and filter
// it.
: // The data buffer has parent data length to be able to contain and
// filter it.
data_(new float[2 * length + 1]),
length_(length),
filter_(CreateFirFilter(coefficients,
coefficients_length,
2 * length + 1)) {
filter_(
CreateFirFilter(coefficients, coefficients_length, 2 * length + 1)) {
RTC_DCHECK_GT(length, 0);
RTC_DCHECK(coefficients);
RTC_DCHECK_GT(coefficients_length, 0);
@ -48,8 +47,8 @@ int WPDNode::Update(const float* parent_data, size_t parent_data_length) {
// Decimate data.
const bool kOddSequence = true;
size_t output_samples = DyadicDecimate(
data_.get(), parent_data_length, kOddSequence, data_.get(), length_);
size_t output_samples = DyadicDecimate(data_.get(), parent_data_length,
kOddSequence, data_.get(), length_);
if (output_samples != length_) {
return -1;
}

11
modules/audio_processing/transient/wpd_node_unittest.cc
View File

@ -20,18 +20,17 @@ static const size_t kDataLength = 5;
static const float kTolerance = 0.0001f;
static const size_t kParentDataLength = kDataLength * 2;
static const float kParentData[kParentDataLength] =
{1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f, 10.f};
static const float kParentData[kParentDataLength] = {1.f, 2.f, 3.f, 4.f, 5.f,
6.f, 7.f, 8.f, 9.f, 10.f};
static const float kCoefficients[] = {0.2f, -0.3f, 0.5f, -0.7f, 0.11f};
static const size_t kCoefficientsLength = sizeof(kCoefficients) /
sizeof(kCoefficients[0]);
static const size_t kCoefficientsLength =
sizeof(kCoefficients) / sizeof(kCoefficients[0]);
TEST(WPDNodeTest, Accessors) {
WPDNode node(kDataLength, kCoefficients, kCoefficientsLength);
EXPECT_EQ(0, node.set_data(kParentData, kDataLength));
EXPECT_EQ(0, memcmp(node.data(),
kParentData,
EXPECT_EQ(0, memcmp(node.data(), kParentData,
kDataLength * sizeof(node.data()[0])));
}

10
modules/audio_processing/transient/wpd_tree.cc
View File

@ -19,8 +19,10 @@
namespace webrtc {
WPDTree::WPDTree(size_t data_length, const float* high_pass_coefficients,
const float* low_pass_coefficients, size_t coefficients_length,
WPDTree::WPDTree(size_t data_length,
const float* high_pass_coefficients,
const float* low_pass_coefficients,
size_t coefficients_length,
int levels)
: data_length_(data_length),
levels_(levels),
@ -98,8 +100,8 @@ int WPDTree::Update(const float* data, size_t data_length) {
index_left_child = index * 2;
index_right_child = index_left_child + 1;
update_result = nodes_[index_left_child]->Update(
nodes_[index]->data(), nodes_[index]->length());
update_result = nodes_[index_left_child]->Update(nodes_[index]->data(),
nodes_[index]->length());
if (update_result != 0) {
return -1;
}

4
modules/audio_processing/transient/wpd_tree.h
View File

@ -47,9 +47,7 @@ class WPDTree {
~WPDTree();
// Returns the number of nodes at any given level.
static int NumberOfNodesAtLevel(int level) {
return 1 << level;
}
static int NumberOfNodesAtLevel(int level) { return 1 << level; }
// Returns a pointer to the node at the given level and index(of that level).
// Level goes from 0 to levels().

36
modules/audio_processing/transient/wpd_tree_unittest.cc
View File

@ -30,13 +30,10 @@ TEST(WPDTreeTest, Construction) {
float test_buffer[kTestBufferSize];
memset(test_buffer, 0.f, kTestBufferSize * sizeof(*test_buffer));
float test_coefficients[] = {1.f, 2.f, 3.f, 4.f, 5.f};
const size_t kTestCoefficientsLength = sizeof(test_coefficients) /
sizeof(test_coefficients[0]);
WPDTree tree(kTestBufferSize,
test_coefficients,
test_coefficients,
kTestCoefficientsLength,
kLevels);
const size_t kTestCoefficientsLength =
sizeof(test_coefficients) / sizeof(test_coefficients[0]);
WPDTree tree(kTestBufferSize, test_coefficients, test_coefficients,
kTestCoefficientsLength, kLevels);
ASSERT_EQ(kExpectedNumberOfNodes, tree.num_nodes());
// Checks for NodeAt(level, index).
int nodes_at_level = 0;
@ -79,10 +76,8 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
const int kLeaves = 1 << kLevels;
const size_t kLeavesSamples = kTestBufferSize >> kLevels;
// Create tree with Discrete Meyer Wavelet Coefficients.
WPDTree tree(kTestBufferSize,
kDaubechies8HighPassCoefficients,
kDaubechies8LowPassCoefficients,
kDaubechies8CoefficientsLength,
WPDTree tree(kTestBufferSize, kDaubechies8HighPassCoefficients,
kDaubechies8LowPassCoefficients, kDaubechies8CoefficientsLength,
kLevels);
// Allocate and open all matlab and out files.
std::unique_ptr<FileWrapper> matlab_files_data[kLeaves];
@ -134,9 +129,8 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
size_t frames_read = 0;
// Read first buffer from the PCM test file.
size_t file_samples_read = ReadInt16FromFileToFloatBuffer(test_file.get(),
kTestBufferSize,
test_buffer);
size_t file_samples_read = ReadInt16FromFileToFloatBuffer(
test_file.get(), kTestBufferSize, test_buffer);
while (file_samples_read > 0 && frames_read < kMaxFramesToTest) {
++frames_read;
@ -152,10 +146,8 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
// Compare results with data from the matlab test files.
for (int i = 0; i < kLeaves; ++i) {
// Compare data values
size_t matlab_samples_read =
ReadDoubleBufferFromFile(matlab_files_data[i].get(),
kLeavesSamples,
matlab_buffer);
size_t matlab_samples_read = ReadDoubleBufferFromFile(
matlab_files_data[i].get(), kLeavesSamples, matlab_buffer);
ASSERT_EQ(kLeavesSamples, matlab_samples_read)
<< "Matlab test files are malformed.\n"
@ -170,15 +162,13 @@ TEST(WPDTreeTest, CorrectnessBasedOnMatlabFiles) {
}
// Write results to out files.
WriteFloatBufferToFile(out_files_data[i].get(),
kLeavesSamples,
WriteFloatBufferToFile(out_files_data[i].get(), kLeavesSamples,
node_data);
}
// Read next buffer from the PCM test file.
file_samples_read = ReadInt16FromFileToFloatBuffer(test_file.get(),
kTestBufferSize,
test_buffer);
file_samples_read = ReadInt16FromFileToFloatBuffer(
test_file.get(), kTestBufferSize, test_buffer);
}
// Close all matlab and out files.