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

Clear out an out of date test.

Browse Source
This commit is contained in:
David Reid
2026-02-14 20:20:28 +10:00
parent ec69cafef8
commit 5ffa29a80b
1 changed files with 1 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/conversion/conversion.c
+1 -321
View File
@@ -35,322 +35,6 @@ ma_result test_data_converter__passthrough()
}
#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)
{
@@ -367,11 +51,7 @@ int test_entry__data_converter(int argc, char** argv)
}
#endif
result = test_data_converter__resampling();
if (result != MA_SUCCESS) {
hasError = MA_TRUE;
}
(void)result;
if (hasError) {
return -1;