Nanako/Alicho
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

使用对齐音频缓冲区替换 std::vector，优化音频处理测试代码

Browse Source
This commit is contained in:
nanako
2025-11-04 10:38:07 +08:00
parent 79ba01856e
commit 60661a1153
1 changed files with 63 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
tests/test_audio_processing_comprehensive.cpp
View File

@@ -48,6 +48,8 @@ constexpr float PEAK_TOLERANCE = 1e-6f;
constexpr size_t PERF_TEST_SIZE = 1024 * 1024; // 1M samples
constexpr int PERF_TEST_ITERATIONS = 100;
using aligned_audio_buffer = std::vector<float, avx512_aligned_allocator<float>>;
/**
* 浮点数比较函数
*/
@@ -111,13 +113,13 @@ public:
}
// 生成直流信号
std::vector<float> generate_dc(size_t num_samples, float value = 1.0f) const {
return std::vector<float>(num_samples, value);
aligned_audio_buffer generate_dc(size_t num_samples, float value = 1.0f) const {
return aligned_audio_buffer(num_samples, value);
}
// 生成立体声测试数据
std::vector<float> generate_stereo_test_data(size_t num_stereo_samples) const {
std::vector<float> data(num_stereo_samples * 2);
aligned_audio_buffer generate_stereo_test_data(size_t num_stereo_samples) const {
aligned_audio_buffer data(num_stereo_samples * 2);
for (size_t i = 0; i < num_stereo_samples; ++i) {
data[i * 2] = std::sin(2.0f * M_PI * 440.0f * i / 44100.0f); // 左声道: 440Hz
data[i * 2 + 1] = std::sin(2.0f * M_PI * 880.0f * i / 44100.0f); // 右声道: 880Hz
@@ -126,8 +128,8 @@ public:
}
// 生成边界测试数据
std::vector<float> generate_boundary_data(size_t num_samples) const {
std::vector<float> data;
aligned_audio_buffer generate_boundary_data(size_t num_samples) const {
aligned_audio_buffer data;
data.reserve(num_samples);
// 添加各种边界值
@@ -244,11 +246,11 @@ TEST_F(AudioProcessingTest, RegistryRegistration) {
// 测试 mix_audio 函数
TEST_F(AudioProcessingTest, MixAudioBasic) {
const size_t num_samples = 16;
auto src1 = data_gen.generate_sine_wave(num_samples, 440.0f);
auto src2 = data_gen.generate_sine_wave(num_samples, 880.0f);
std::vector<float> result(num_samples);
std::vector<float> expected(num_samples);
const size_t num_samples = 16;
auto src1 = data_gen.generate_sine_wave(num_samples, 440.0f);
auto src2 = data_gen.generate_sine_wave(num_samples, 880.0f);
aligned_audio_buffer result(num_samples);
aligned_audio_buffer expected(num_samples);
// 计算期望结果
for (size_t i = 0; i < num_samples; ++i) {
@@ -264,11 +266,11 @@ TEST_F(AudioProcessingTest, MixAudioBasic) {
// 测试 apply_gain 函数
TEST_F(AudioProcessingTest, ApplyGainBasic) {
const size_t num_samples = 16;
const float gain = 0.5f;
auto src = data_gen.generate_sine_wave(num_samples);
std::vector<float> result(num_samples);
std::vector<float> expected(num_samples);
const size_t num_samples = 16;
const float gain = 0.5f;
auto src = data_gen.generate_sine_wave(num_samples);
std::vector<float, avx512_aligned_allocator<float>> result(num_samples);
std::vector<float, avx512_aligned_allocator<float>> expected(num_samples);
// 计算期望结果
for (size_t i = 0; i < num_samples; ++i) {
@@ -327,10 +329,10 @@ TEST_F(AudioProcessingTest, CalculatePeakBasic) {
// 测试 normalize_audio 函数
TEST_F(AudioProcessingTest, NormalizeAudioBasic) {
const size_t num_samples = 1024;
const float target_peak = 0.8f;
auto src = data_gen.generate_sine_wave(num_samples, 440.0f, 44100.0f, 2.0f); // 超过1.0的幅度
std::vector<float> result(num_samples);
const size_t num_samples = 1024;
const float target_peak = 0.8f;
auto src = data_gen.generate_sine_wave(num_samples, 440.0f, 44100.0f, 2.0f); // 超过1.0的幅度
aligned_audio_buffer result(num_samples);
// 测试标量版本
scalar_audio_processing_func::normalize_audio(src.data(), result.data(), target_peak, num_samples);
@@ -344,10 +346,10 @@ TEST_F(AudioProcessingTest, NormalizeAudioBasic) {
// 测试 stereo_to_mono 函数
TEST_F(AudioProcessingTest, StereoToMonoBasic) {
const size_t num_stereo_samples = 512;
auto stereo_src = data_gen.generate_stereo_test_data(num_stereo_samples);
std::vector<float> mono_result(num_stereo_samples);
std::vector<float> expected_mono(num_stereo_samples);
const size_t num_stereo_samples = 512;
auto stereo_src = data_gen.generate_stereo_test_data(num_stereo_samples);
aligned_audio_buffer mono_result(num_stereo_samples);
aligned_audio_buffer expected_mono(num_stereo_samples);
// 计算期望结果
for (size_t i = 0; i < num_stereo_samples; ++i) {
@@ -363,11 +365,11 @@ TEST_F(AudioProcessingTest, StereoToMonoBasic) {
// 测试 limit_audio 函数
TEST_F(AudioProcessingTest, LimitAudioBasic) {
const size_t num_samples = 1024;
const float threshold = 0.5f;
auto src = data_gen.generate_sine_wave(num_samples, 440.0f, 44100.0f, 1.0f);
std::vector<float> result(num_samples);
float limiter_state = 1.0f;
const size_t num_samples = 1024;
const float threshold = 0.5f;
auto src = data_gen.generate_sine_wave(num_samples, 440.0f, 44100.0f, 1.0f);
aligned_audio_buffer result(num_samples);
float limiter_state = 1.0f;
// 测试标量版本
scalar_audio_processing_func::limit_audio(src.data(), result.data(), threshold, &limiter_state, 44100.f,
@@ -393,11 +395,11 @@ TEST_F(AudioProcessingTest, LimitAudioBasic) {
// 测试 fade_audio 函数
TEST_F(AudioProcessingTest, FadeAudioBasic) {
const size_t num_samples = 1024;
const size_t fade_in_samples = 100;
const size_t fade_out_samples = 100;
auto src = data_gen.generate_dc(num_samples, 1.0f);
std::vector<float> result(num_samples);
const size_t num_samples = 1024;
const size_t fade_in_samples = 100;
const size_t fade_out_samples = 100;
auto src = data_gen.generate_dc(num_samples, 1.0f);
aligned_audio_buffer result(num_samples);
// 测试标量版本
scalar_audio_processing_func::fade_audio(src.data(), result.data(), fade_in_samples, fade_out_samples, num_samples);
@@ -419,13 +421,13 @@ TEST_F(AudioProcessingTest, FadeAudioBasic) {
// 测试 simple_eq 函数
TEST_F(AudioProcessingTest, SimpleEqBasic) {
const size_t num_samples = 1024;
const float low_gain = 1.2f;
const float mid_gain = 1.0f;
const float high_gain = 0.8f;
auto src = data_gen.generate_white_noise(num_samples, 0.5f);
std::vector<float> result(num_samples);
std::vector<float> eq_state(2, 0.0f); // 低通和高通滤波器状态
const size_t num_samples = 1024;
const float low_gain = 1.2f;
const float mid_gain = 1.0f;
const float high_gain = 0.8f;
auto src = data_gen.generate_white_noise(num_samples, 0.5f);
aligned_audio_buffer result(num_samples);
aligned_audio_buffer eq_state(2, 0.0f); // 低通和高通滤波器状态
// 测试标量版本
scalar_audio_processing_func::simple_eq(src.data(), result.data(), low_gain, mid_gain, high_gain, eq_state.data(),
@@ -452,10 +454,10 @@ TEST_F(AudioProcessingTest, SimpleEqBasic) {
// 测试零长度输入
TEST_F(AudioProcessingTest, ZeroLengthInput) {
const size_t num_samples = 0;
std::vector<float> dummy(1, 0.0f);
std::vector<float> result(1, 0.0f);
float state = 1.0f;
const size_t num_samples = 0;
aligned_audio_buffer dummy(1, 0.0f);
aligned_audio_buffer result(1, 0.0f);
float state = 1.0f;
// 这些函数应该能安全处理零长度输入
EXPECT_NO_THROW({
@@ -471,11 +473,11 @@ TEST_F(AudioProcessingTest, ZeroLengthInput) {
// 测试单样本输入
TEST_F(AudioProcessingTest, SingleSampleInput) {
const size_t num_samples = 1;
std::vector<float> src1{0.5f};
std::vector<float> src2{0.3f};
std::vector<float> result(1);
float state = 1.0f;
const size_t num_samples = 1;
aligned_audio_buffer src1{0.5f};
aligned_audio_buffer src2{0.3f};
aligned_audio_buffer result(1);
float state = 1.0f;
// 测试混合
scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), result.data(), num_samples);
@@ -500,8 +502,8 @@ TEST_F(AudioProcessingTest, SingleSampleInput) {
// 测试极值处理
TEST_F(AudioProcessingTest, ExtremeValues) {
const size_t num_samples = 8;
std::vector<float> extreme_values = {
const size_t num_samples = 8;
aligned_audio_buffer extreme_values = {
0.0f,
1.0f,
-1.0f,
@@ -512,7 +514,7 @@ TEST_F(AudioProcessingTest, ExtremeValues) {
-std::numeric_limits<float>::epsilon()
};
std::vector<float> result(num_samples);
aligned_audio_buffer result(num_samples);
// 测试峰值计算对极值的处理
float peak = scalar_audio_processing_func::calculate_peak(extreme_values.data(), num_samples);
@@ -551,9 +553,9 @@ TEST_F(AudioProcessingTest, X86SimdConsistency) {
auto src2 = data_gen.generate_sine_wave(num_samples, 880.0f);
auto stereo_src = data_gen.generate_stereo_test_data(num_samples);
std::vector<float> scalar_result(num_samples);
std::vector<float> sse_result(num_samples);
std::vector<float> avx_result(num_samples);
aligned_audio_buffer scalar_result(num_samples);
aligned_audio_buffer sse_result(num_samples);
aligned_audio_buffer avx_result(num_samples);
std::vector<float, aligned_allocator<float, ALIGNMENT_AVX512>> avx512_result(num_samples);
// 测试 mix_audio 一致性
@@ -620,8 +622,8 @@ TEST_F(AudioProcessingTest, ArmSimdConsistency) {
auto src1 = data_gen.generate_sine_wave(num_samples, 440.0f);
auto src2 = data_gen.generate_sine_wave(num_samples, 880.0f);
std::vector<float> scalar_result(num_samples);
std::vector<float> neon_result(num_samples);
aligned_audio_buffer scalar_result(num_samples);
aligned_audio_buffer neon_result(num_samples);
// 测试 mix_audio 一致性
scalar_audio_processing_func::mix_audio(src1.data(), src2.data(), scalar_result.data(), num_samples);
@@ -666,9 +668,9 @@ TEST_F(AudioProcessingTest, PerformanceTests) {
std::cout << "\n=== 性能测试 ===" << std::endl;
// 生成大量测试数据
auto src1 = data_gen.generate_sine_wave(PERF_TEST_SIZE, 440.0f);
auto src2 = data_gen.generate_sine_wave(PERF_TEST_SIZE, 880.0f);
std::vector<float> result(PERF_TEST_SIZE);
auto src1 = data_gen.generate_sine_wave(PERF_TEST_SIZE, 440.0f);
auto src2 = data_gen.generate_sine_wave(PERF_TEST_SIZE, 880.0f);
aligned_audio_buffer result(PERF_TEST_SIZE);
// 性能测试：mix_audio
{