diff src/portaudio/test/patest_converters.c @ 4:e13257ea84a4

Add bzip2, zlib, liblo, portaudio sources

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/portaudio/test/patest_converters.c	Wed Mar 20 13:59:52 2013 +0000
@@ -0,0 +1,395 @@
+/** @file patest_converters.c
+	@ingroup test_src
+	@brief Tests the converter functions in pa_converters.c
+	@author Ross Bencina <[e-mail]>
+
+    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;
+}