diff options
Diffstat (limited to 'portaudio/test/patest_converters.c')
| -rw-r--r-- | portaudio/test/patest_converters.c | 395 |
1 files changed, 395 insertions, 0 deletions
diff --git a/portaudio/test/patest_converters.c b/portaudio/test/patest_converters.c new file mode 100644 index 0000000..f76738c --- /dev/null +++ b/portaudio/test/patest_converters.c @@ -0,0 +1,395 @@ +/** @file patest_converters.c + @ingroup test_src + @brief Tests the converter functions in pa_converters.c + @author Ross Bencina <rossb@audiomulch.com> + + Link with pa_dither.c and pa_converters.c + + see http://www.portaudio.com/trac/wiki/V19ConvertersStatus for a discussion of this. +*/ +/* + * $Id: $ + * + * This program uses the PortAudio Portable Audio Library. + * For more information see: http://www.portaudio.com/ + * Copyright (c) 1999-2008 Ross Bencina and Phil Burk + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * The text above constitutes the entire PortAudio license; however, + * the PortAudio community also makes the following non-binding requests: + * + * Any person wishing to distribute modifications to the Software is + * requested to send the modifications to the original developer so that + * they can be incorporated into the canonical version. It is also + * requested that these non-binding requests be included along with the + * license above. + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#include "portaudio.h" +#include "pa_converters.h" +#include "pa_dither.h" +#include "pa_types.h" +#include "pa_endianness.h" + +#ifndef M_PI +#define M_PI (3.14159265) +#endif + +#define MAX_PER_CHANNEL_FRAME_COUNT (2048) +#define MAX_CHANNEL_COUNT (8) + + +#define SAMPLE_FORMAT_COUNT (6) + +static PaSampleFormat sampleFormats_[ SAMPLE_FORMAT_COUNT ] = + { paFloat32, paInt32, paInt24, paInt16, paInt8, paUInt8 }; /* all standard PA sample formats */ + +static const char* sampleFormatNames_[SAMPLE_FORMAT_COUNT] = + { "paFloat32", "paInt32", "paInt24", "paInt16", "paInt8", "paUInt8" }; + + +static const char* abbreviatedSampleFormatNames_[SAMPLE_FORMAT_COUNT] = + { "f32", "i32", "i24", "i16", " i8", "ui8" }; + + +PaError My_Pa_GetSampleSize( PaSampleFormat format ); + +/* + available flags are paClipOff and paDitherOff + clipping is usually applied for float -> int conversions + dither is usually applied for all downconversions (ie anything but 8bit->8bit conversions +*/ + +static int CanClip( PaSampleFormat sourceFormat, PaSampleFormat destinationFormat ) +{ + if( sourceFormat == paFloat32 && destinationFormat != sourceFormat ) + return 1; + else + return 0; +} + +static int CanDither( PaSampleFormat sourceFormat, PaSampleFormat destinationFormat ) +{ + if( sourceFormat < destinationFormat && sourceFormat != paInt8 ) + return 1; + else + return 0; +} + +static void GenerateOneCycleSineReference( double *out, int frameCount, int strideFrames ) +{ + int i; + for( i=0; i < frameCount; ++i ){ + *out = sin( ((double)i/(double)frameCount) * 2. * M_PI ); + out += strideFrames; + } +} + + +static void GenerateOneCycleSine( PaSampleFormat format, void *buffer, int frameCount, int strideFrames ) +{ + switch( format ){ + + case paFloat32: + { + int i; + float *out = (float*)buffer; + for( i=0; i < frameCount; ++i ){ + *out = (float).9 * sin( ((double)i/(double)frameCount) * 2. * M_PI ); + out += strideFrames; + } + } + break; + case paInt32: + { + int i; + PaInt32 *out = (PaInt32*)buffer; + for( i=0; i < frameCount; ++i ){ + *out = (PaInt32)(.9 * sin( ((double)i/(double)frameCount) * 2. * M_PI ) * 0x7FFFFFFF); + out += strideFrames; + } + } + break; + case paInt24: + { + int i; + unsigned char *out = (unsigned char*)buffer; + for( i=0; i < frameCount; ++i ){ + signed long temp = (PaInt32)(.9 * sin( ((double)i/(double)frameCount) * 2. * M_PI ) * 0x7FFFFFFF); + + #if defined(PA_LITTLE_ENDIAN) + out[0] = (unsigned char)(temp >> 8) & 0xFF; + out[1] = (unsigned char)(temp >> 16) & 0xFF; + out[2] = (unsigned char)(temp >> 24) & 0xFF; + #elif defined(PA_BIG_ENDIAN) + out[0] = (unsigned char)(temp >> 24) & 0xFF; + out[1] = (unsigned char)(temp >> 16) & 0xFF; + out[2] = (unsigned char)(temp >> 8) & 0xFF; + #endif + out += 3; + } + } + break; + case paInt16: + { + int i; + PaInt16 *out = (PaInt16*)buffer; + for( i=0; i < frameCount; ++i ){ + *out = (PaInt16)(.9 * sin( ((double)i/(double)frameCount) * 2. * M_PI ) * 0x7FFF ); + out += strideFrames; + } + } + break; + case paInt8: + { + int i; + signed char *out = (signed char*)buffer; + for( i=0; i < frameCount; ++i ){ + *out = (signed char)(.9 * sin( ((double)i/(double)frameCount) * 2. * M_PI ) * 0x7F ); + out += strideFrames; + } + } + break; + case paUInt8: + { + int i; + unsigned char *out = (unsigned char*)buffer; + for( i=0; i < frameCount; ++i ){ + *out = (unsigned char)( .5 * (1. + (.9 * sin( ((double)i/(double)frameCount) * 2. * M_PI ))) * 0xFF ); + out += strideFrames; + } + } + break; + } +} + +int TestNonZeroPresent( void *buffer, int size ) +{ + char *p = (char*)buffer; + int i; + + for( i=0; i < size; ++i ){ + + if( *p != 0 ) + return 1; + ++p; + } + + return 0; +} + +float MaximumAbsDifference( float* sourceBuffer, float* referenceBuffer, int count ) +{ + float result = 0; + float difference; + while( count-- ){ + difference = fabs( *sourceBuffer++ - *referenceBuffer++ ); + if( difference > result ) + result = difference; + } + + return result; +} + +int main( const char **argv, int argc ) +{ + PaUtilTriangularDitherGenerator ditherState; + PaUtilConverter *converter; + void *destinationBuffer, *sourceBuffer; + double *referenceBuffer; + int sourceFormatIndex, destinationFormatIndex; + PaSampleFormat sourceFormat, destinationFormat; + PaStreamFlags flags; + int passFailMatrix[SAMPLE_FORMAT_COUNT][SAMPLE_FORMAT_COUNT]; // [source][destination] + float noiseAmplitudeMatrix[SAMPLE_FORMAT_COUNT][SAMPLE_FORMAT_COUNT]; // [source][destination] + float amp; + +#define FLAG_COMBINATION_COUNT (4) + PaStreamFlags flagCombinations[FLAG_COMBINATION_COUNT] = { paNoFlag, paClipOff, paDitherOff, paClipOff | paDitherOff }; + const char *flagCombinationNames[FLAG_COMBINATION_COUNT] = { "paNoFlag", "paClipOff", "paDitherOff", "paClipOff | paDitherOff" }; + int flagCombinationIndex; + + PaUtil_InitializeTriangularDitherState( &ditherState ); + + /* allocate more than enough space, we use sizeof(float) but we need to fit any 32 bit datum */ + + destinationBuffer = (void*)malloc( MAX_PER_CHANNEL_FRAME_COUNT * MAX_CHANNEL_COUNT * sizeof(float) ); + sourceBuffer = (void*)malloc( MAX_PER_CHANNEL_FRAME_COUNT * MAX_CHANNEL_COUNT * sizeof(float) ); + referenceBuffer = (void*)malloc( MAX_PER_CHANNEL_FRAME_COUNT * MAX_CHANNEL_COUNT * sizeof(float) ); + + + /* the first round of tests simply iterates through the buffer combinations testing + that putting something in gives something out */ + + printf( "= Sine wave in, something out =\n" ); + + printf( "\n" ); + + GenerateOneCycleSine( paFloat32, referenceBuffer, MAX_PER_CHANNEL_FRAME_COUNT, 1 ); + + for( flagCombinationIndex = 0; flagCombinationIndex < FLAG_COMBINATION_COUNT; ++flagCombinationIndex ){ + flags = flagCombinations[flagCombinationIndex]; + + printf( "\n" ); + printf( "== flags = %s ==\n", flagCombinationNames[flagCombinationIndex] ); + + for( sourceFormatIndex = 0; sourceFormatIndex < SAMPLE_FORMAT_COUNT; ++sourceFormatIndex ){ + for( destinationFormatIndex = 0; destinationFormatIndex < SAMPLE_FORMAT_COUNT; ++destinationFormatIndex ){ + sourceFormat = sampleFormats_[sourceFormatIndex]; + destinationFormat = sampleFormats_[destinationFormatIndex]; + //printf( "%s -> %s ", sampleFormatNames_[ sourceFormatIndex ], sampleFormatNames_[ destinationFormatIndex ] ); + + converter = PaUtil_SelectConverter( sourceFormat, destinationFormat, flags ); + + /* source is a sinewave */ + GenerateOneCycleSine( sourceFormat, sourceBuffer, MAX_PER_CHANNEL_FRAME_COUNT, 1 ); + + /* zero destination */ + memset( destinationBuffer, 0, MAX_PER_CHANNEL_FRAME_COUNT * My_Pa_GetSampleSize( destinationFormat ) ); + + (*converter)( destinationBuffer, 1, sourceBuffer, 1, MAX_PER_CHANNEL_FRAME_COUNT, &ditherState ); + + /* + Other ways we could test this would be: + - pass a constant, check for a constant (wouldn't work with dither) + - pass alternating +/-, check for the same... + */ + if( TestNonZeroPresent( destinationBuffer, MAX_PER_CHANNEL_FRAME_COUNT * My_Pa_GetSampleSize( destinationFormat ) ) ){ + //printf( "PASSED\n" ); + passFailMatrix[sourceFormatIndex][destinationFormatIndex] = 1; + }else{ + //printf( "FAILED\n" ); + passFailMatrix[sourceFormatIndex][destinationFormatIndex] = 0; + } + + + /* try to measure the noise floor (comparing output signal to a float32 sine wave) */ + + if( passFailMatrix[sourceFormatIndex][destinationFormatIndex] ){ + + /* convert destination back to paFloat32 into source */ + converter = PaUtil_SelectConverter( destinationFormat, paFloat32, paNoFlag ); + + memset( sourceBuffer, 0, MAX_PER_CHANNEL_FRAME_COUNT * My_Pa_GetSampleSize( paFloat32 ) ); + (*converter)( sourceBuffer, 1, destinationBuffer, 1, MAX_PER_CHANNEL_FRAME_COUNT, &ditherState ); + + if( TestNonZeroPresent( sourceBuffer, MAX_PER_CHANNEL_FRAME_COUNT * My_Pa_GetSampleSize( paFloat32 ) ) ){ + + noiseAmplitudeMatrix[sourceFormatIndex][destinationFormatIndex] = MaximumAbsDifference( (float*)sourceBuffer, (float*)referenceBuffer, MAX_PER_CHANNEL_FRAME_COUNT ); + + }else{ + /* can't test noise floor because there is no conversion from dest format to float available */ + noiseAmplitudeMatrix[sourceFormatIndex][destinationFormatIndex] = -1; // mark as failed + } + }else{ + noiseAmplitudeMatrix[sourceFormatIndex][destinationFormatIndex] = -1; // mark as failed + } + } + } + + printf( "\n" ); + printf( "=== Output contains non-zero data ===\n" ); + printf( "Key: . - pass, X - fail\n" ); + printf( "{{{\n" ); // trac preformated text tag + printf( "in| out: " ); + for( destinationFormatIndex = 0; destinationFormatIndex < SAMPLE_FORMAT_COUNT; ++destinationFormatIndex ){ + printf( " %s ", abbreviatedSampleFormatNames_[destinationFormatIndex] ); + } + printf( "\n" ); + + for( sourceFormatIndex = 0; sourceFormatIndex < SAMPLE_FORMAT_COUNT; ++sourceFormatIndex ){ + printf( "%s ", abbreviatedSampleFormatNames_[sourceFormatIndex] ); + for( destinationFormatIndex = 0; destinationFormatIndex < SAMPLE_FORMAT_COUNT; ++destinationFormatIndex ){ + printf( " %s ", (passFailMatrix[sourceFormatIndex][destinationFormatIndex])? " ." : " X" ); + } + printf( "\n" ); + } + printf( "}}}\n" ); // trac preformated text tag + + printf( "\n" ); + printf( "=== Combined dynamic range (src->dest->float32) ===\n" ); + printf( "Key: Noise amplitude in dBfs, X - fail (either above failed or dest->float32 failed)\n" ); + printf( "{{{\n" ); // trac preformated text tag + printf( "in| out: " ); + for( destinationFormatIndex = 0; destinationFormatIndex < SAMPLE_FORMAT_COUNT; ++destinationFormatIndex ){ + printf( " %s ", abbreviatedSampleFormatNames_[destinationFormatIndex] ); + } + printf( "\n" ); + + for( sourceFormatIndex = 0; sourceFormatIndex < SAMPLE_FORMAT_COUNT; ++sourceFormatIndex ){ + printf( " %s ", abbreviatedSampleFormatNames_[sourceFormatIndex] ); + for( destinationFormatIndex = 0; destinationFormatIndex < SAMPLE_FORMAT_COUNT; ++destinationFormatIndex ){ + amp = noiseAmplitudeMatrix[sourceFormatIndex][destinationFormatIndex]; + if( amp < 0. ) + printf( " X " ); + else + printf( " % 6.1f ", 20.*log10(amp) ); + } + printf( "\n" ); + } + printf( "}}}\n" ); // trac preformated text tag + } + + + free( destinationBuffer ); + free( sourceBuffer ); + free( referenceBuffer ); +} + +// copied here for now otherwise we need to include the world just for this function. +PaError My_Pa_GetSampleSize( PaSampleFormat format ) +{ + int result; + + switch( format & ~paNonInterleaved ) + { + + case paUInt8: + case paInt8: + result = 1; + break; + + case paInt16: + result = 2; + break; + + case paInt24: + result = 3; + break; + + case paFloat32: + case paInt32: + result = 4; + break; + + default: + result = paSampleFormatNotSupported; + break; + } + + return (PaError) result; +} |