mirror/miniaudio
1
0
Fork 0
mirror of https://github.com/mackron/miniaudio.git synced 2026-04-22 00:06:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' into dev-0.12

Browse Source
This commit is contained in:
David Reid
2025-02-22 13:00:45 +10:00
parent 489206e7e5 e1f5ed4f79
commit 11f8cbc7bc
17 changed files with 395 additions and 396 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_common/ma_test_common.c → tests/common/common.c
View File
tests/conversion/conversion.c
+381 -2
View File
@@ -1,6 +1,385 @@
#include "../test_common/ma_test_common.c"
#include "ma_test_automated_data_converter.c"
#include "../common/common.c"
ma_result init_data_converter(ma_uint32 rateIn, ma_uint32 rateOut, ma_resample_algorithm algorithm, ma_data_converter* pDataConverter)
{
ma_result result;
ma_data_converter_config config;
config = ma_data_converter_config_init(ma_format_s16, ma_format_s16, 1, 1, rateIn, rateOut);
config.resampling.algorithm = algorithm;
result = ma_data_converter_init(&config, NULL, pDataConverter);
if (result != MA_SUCCESS) {
return result;
}
return MA_SUCCESS;
}
#if 0
ma_result test_data_converter__passthrough()
{
/*
Notes:
- The isPassthrough flag should be set to true. Both the positive and negative cases need to be tested.
- ma_data_converter_set_rate() should fail with MA_INVALID_OPERATION.
- The output should be identical to the input.
*/
printf("Passthrough\n");
return MA_SUCCESS;
}
#endif
ma_result test_data_converter__resampling_expected_output_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
{
ma_result result = MA_SUCCESS;
ma_int16 input[4096];
ma_int16 i;
MA_ASSERT(frameCountPerIteration < ma_countof(input));
/* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
input[i] = i;
}
for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
ma_int16 output[4096];
ma_uint64 outputFrameCount;
ma_uint64 inputFrameCount;
ma_uint64 expectedOutputFrameCount;
/* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
ma_data_converter_get_expected_output_frame_count(pDataConverter, frameCountPerIteration, &expectedOutputFrameCount);
outputFrameCount = ma_countof(output);
inputFrameCount = frameCountPerIteration;
result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
if (result != MA_SUCCESS) {
printf("Failed to process frames.");
break;
}
if (outputFrameCount != expectedOutputFrameCount) {
printf("ERROR: Predicted vs actual output count mismatch: predicted=%d, actual=%d\n", (int)expectedOutputFrameCount, (int)outputFrameCount);
result = MA_ERROR;
}
}
if (result != MA_SUCCESS) {
printf("FAILED\n");
} else {
printf("PASSED\n");
}
return result;
}
ma_result test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
ma_data_converter converter;
result = init_data_converter(rateIn, rateOut, algorithm, &converter);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_fixed_interval(&converter, frameCountPerIteration);
ma_data_converter_uninit(&converter, NULL);
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm algorithm)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 1);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 16);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 127);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_expected_output(void)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
printf("Linear\n");
result = test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm_linear);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
{
ma_result result = MA_SUCCESS;
ma_int16 input[4096];
ma_int16 i;
MA_ASSERT(frameCountPerIteration < ma_countof(input));
/* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
input[i] = i;
}
for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
ma_int16 output[4096];
ma_uint64 outputFrameCount;
ma_uint64 inputFrameCount;
ma_uint64 requiredInputFrameCount;
/* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
ma_data_converter_get_required_input_frame_count(pDataConverter, frameCountPerIteration, &requiredInputFrameCount);
outputFrameCount = frameCountPerIteration;
inputFrameCount = ma_countof(input);
result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
if (result != MA_SUCCESS) {
printf("Failed to process frames.");
break;
}
if (inputFrameCount != requiredInputFrameCount) {
printf("ERROR: Predicted vs actual input count mismatch: predicted=%d, actual=%d\n", (int)requiredInputFrameCount, (int)inputFrameCount);
result = MA_ERROR;
}
}
if (result != MA_SUCCESS) {
printf("FAILED\n");
} else {
printf("PASSED\n");
}
return result;
}
ma_result test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
ma_data_converter converter;
result = init_data_converter(rateIn, rateOut, algorithm, &converter);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_fixed_interval(&converter, frameCountPerIteration);
ma_data_converter_uninit(&converter, NULL);
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm algorithm)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 1);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 16);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 127);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input(void)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
printf("Linear\n");
result = test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm_linear);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling(void)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_expected_output();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
int test_entry__data_converter(int argc, char** argv)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
(void)argc;
(void)argv;
#if 0
result = test_data_converter__passthrough();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
#endif
result = test_data_converter__resampling();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return -1;
} else {
return 0;
}
}
int main(int argc, char** argv)
{
tests/conversion/ma_test_automated_data_converter.c
-379
View File
@@ -1,379 +0,0 @@
ma_result init_data_converter(ma_uint32 rateIn, ma_uint32 rateOut, ma_resample_algorithm algorithm, ma_data_converter* pDataConverter)
{
ma_result result;
ma_data_converter_config config;
config = ma_data_converter_config_init(ma_format_s16, ma_format_s16, 1, 1, rateIn, rateOut);
config.resampling.algorithm = algorithm;
result = ma_data_converter_init(&config, NULL, pDataConverter);
if (result != MA_SUCCESS) {
return result;
}
return MA_SUCCESS;
}
#if 0
ma_result test_data_converter__passthrough()
{
/*
Notes:
- The isPassthrough flag should be set to true. Both the positive and negative cases need to be tested.
- ma_data_converter_set_rate() should fail with MA_INVALID_OPERATION.
- The output should be identical to the input.
*/
printf("Passthrough\n");
return MA_SUCCESS;
}
#endif
ma_result test_data_converter__resampling_expected_output_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
{
ma_result result = MA_SUCCESS;
ma_int16 input[4096];
ma_int16 i;
MA_ASSERT(frameCountPerIteration < ma_countof(input));
/* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
input[i] = i;
}
for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
ma_int16 output[4096];
ma_uint64 outputFrameCount;
ma_uint64 inputFrameCount;
ma_uint64 expectedOutputFrameCount;
/* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
ma_data_converter_get_expected_output_frame_count(pDataConverter, frameCountPerIteration, &expectedOutputFrameCount);
outputFrameCount = ma_countof(output);
inputFrameCount = frameCountPerIteration;
result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
if (result != MA_SUCCESS) {
printf("Failed to process frames.");
break;
}
if (outputFrameCount != expectedOutputFrameCount) {
printf("ERROR: Predicted vs actual output count mismatch: predicted=%d, actual=%d\n", (int)expectedOutputFrameCount, (int)outputFrameCount);
result = MA_ERROR;
}
}
if (result != MA_SUCCESS) {
printf("FAILED\n");
} else {
printf("PASSED\n");
}
return result;
}
ma_result test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
ma_data_converter converter;
result = init_data_converter(rateIn, rateOut, algorithm, &converter);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_fixed_interval(&converter, frameCountPerIteration);
ma_data_converter_uninit(&converter, NULL);
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm algorithm)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 1);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 16);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_expected_output_by_algorithm_fixed_interval(algorithm, 127);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_expected_output(void)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
printf("Linear\n");
result = test_data_converter__resampling_expected_output_by_algorithm(ma_resample_algorithm_linear);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input_fixed_interval(ma_data_converter* pDataConverter, ma_uint64 frameCountPerIteration)
{
ma_result result = MA_SUCCESS;
ma_int16 input[4096];
ma_int16 i;
MA_ASSERT(frameCountPerIteration < ma_countof(input));
/* Fill the input buffer with sequential numbers so we can get an idea on the state of things. Useful for inspecting the linear backend in particular. */
for (i = 0; i < (ma_int16)ma_countof(input); i += 1) {
input[i] = i;
}
for (i = 0; i < (ma_int16)ma_countof(input); i += (ma_int16)frameCountPerIteration) {
ma_int16 output[4096];
ma_uint64 outputFrameCount;
ma_uint64 inputFrameCount;
ma_uint64 requiredInputFrameCount;
/* We retrieve the required number of input frames for the specified number of output frames, and then compare with what we actually get when reading. */
ma_data_converter_get_required_input_frame_count(pDataConverter, frameCountPerIteration, &requiredInputFrameCount);
outputFrameCount = frameCountPerIteration;
inputFrameCount = ma_countof(input);
result = ma_data_converter_process_pcm_frames(pDataConverter, input, &inputFrameCount, output, &outputFrameCount);
if (result != MA_SUCCESS) {
printf("Failed to process frames.");
break;
}
if (inputFrameCount != requiredInputFrameCount) {
printf("ERROR: Predicted vs actual input count mismatch: predicted=%d, actual=%d\n", (int)requiredInputFrameCount, (int)inputFrameCount);
result = MA_ERROR;
}
}
if (result != MA_SUCCESS) {
printf("FAILED\n");
} else {
printf("PASSED\n");
}
return result;
}
ma_result test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(ma_resample_algorithm algorithm, ma_uint32 rateIn, ma_uint32 rateOut, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
ma_data_converter converter;
result = init_data_converter(rateIn, rateOut, algorithm, &converter);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_fixed_interval(&converter, frameCountPerIteration);
ma_data_converter_uninit(&converter, NULL);
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input_by_algorithm_fixed_interval(ma_resample_algorithm algorithm, ma_uint64 frameCountPerIteration)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 48000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 48000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 44100, 192000, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_and_rate_fixed_interval(algorithm, 192000, 44100, frameCountPerIteration);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm algorithm)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 1);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 16);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input_by_algorithm_fixed_interval(algorithm, 127);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling_required_input(void)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
printf("Linear\n");
result = test_data_converter__resampling_required_input_by_algorithm(ma_resample_algorithm_linear);
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
ma_result test_data_converter__resampling(void)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
result = test_data_converter__resampling_expected_output();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
result = test_data_converter__resampling_required_input();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return MA_ERROR;
} else {
return MA_SUCCESS;
}
}
int test_entry__data_converter(int argc, char** argv)
{
ma_result result;
ma_bool32 hasError = MA_FALSE;
(void)argc;
(void)argv;
#if 0
result = test_data_converter__passthrough();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
#endif
result = test_data_converter__resampling();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
if (hasError) {
return -1;
} else {
return 0;
}
}
tests/deviceio/deviceio.c
+1 -1
View File
@@ -41,7 +41,7 @@ will receive the captured audio.
If multiple backends are specified, the priority will be based on the order in which you specify them. If multiple waveform or noise types
are specified the last one on the command line will have priority.
*/
#include "../test_common/ma_test_common.c"
#include "../common/common.c"
#ifndef AUTO_CLOSE_TIME_IN_MILLISECONDS
#define AUTO_CLOSE_TIME_IN_MILLISECONDS 5000
tests/emscripten/emscripten.c
+1 -2
View File
@@ -1,8 +1,7 @@
#define MA_DEBUG_OUTPUT
#define MA_NO_DECODING
#define MA_NO_ENCODING
#define MINIAUDIO_IMPLEMENTATION
#include "../../miniaudio.h"
#include "../../miniaudio.c"
#include <stdio.h>
tests/filtering/filtering.c
+9 -9
View File
@@ -1,4 +1,4 @@
#include "../test_common/ma_test_common.c"
#include "../common/common.c"
ma_result filtering_init_decoder_and_encoder(const char* pInputFilePath, const char* pOutputFilePath, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_decoder* pDecoder, ma_encoder* pEncoder)
{
@@ -24,14 +24,14 @@ ma_result filtering_init_decoder_and_encoder(const char* pInputFilePath, const c
return MA_SUCCESS;
}
#include "ma_test_filtering_dithering.c"
#include "ma_test_filtering_lpf.c"
#include "ma_test_filtering_hpf.c"
#include "ma_test_filtering_bpf.c"
#include "ma_test_filtering_notch.c"
#include "ma_test_filtering_peak.c"
#include "ma_test_filtering_loshelf.c"
#include "ma_test_filtering_hishelf.c"
#include "filtering_dithering.c"
#include "filtering_lpf.c"
#include "filtering_hpf.c"
#include "filtering_bpf.c"
#include "filtering_notch.c"
#include "filtering_peak.c"
#include "filtering_loshelf.c"
#include "filtering_hishelf.c"
int main(int argc, char** argv)
{
tests/filtering/ma_test_filtering_bpf.c → tests/filtering/filtering_bpf.c
View File
tests/filtering/ma_test_filtering_dithering.c → tests/filtering/filtering_dithering.c
View File
tests/filtering/ma_test_filtering_hishelf.c → tests/filtering/filtering_hishelf.c
View File
tests/filtering/ma_test_filtering_hpf.c → tests/filtering/filtering_hpf.c
View File
tests/filtering/ma_test_filtering_loshelf.c → tests/filtering/filtering_loshelf.c
View File
tests/filtering/ma_test_filtering_lpf.c → tests/filtering/filtering_lpf.c
View File
tests/filtering/ma_test_filtering_notch.c → tests/filtering/filtering_notch.c
View File
tests/filtering/ma_test_filtering_peak.c → tests/filtering/filtering_peak.c
View File
tests/generation/generation.c
+3 -3
View File
@@ -1,8 +1,8 @@
#define MA_NO_DEVICE_IO
#include "../test_common/ma_test_common.c"
#include "../common/common.c"
#include "ma_test_generation_noise.c"
#include "ma_test_generation_waveform.c"
#include "generation_noise.c"
#include "generation_waveform.c"
int main(int argc, char** argv)
{
tests/generation/ma_test_generation_noise.c → tests/generation/generation_noise.c
View File
tests/generation/ma_test_generation_waveform.c → tests/generation/generation_waveform.c
View File