add plibsys

25 files changed, 0 insertions, 9845 deletions

diff --git a/portaudio/src/common/pa_allocation.c b/portaudio/src/common/pa_allocation.c
deleted file mode 100644
index 7e3298a..0000000
--- a/portaudio/src/common/pa_allocation.c
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library allocation group implementation
- * memory allocation group for tracking allocation groups
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Allocation Group implementation.
-*/
-
-
-#include "pa_allocation.h"
-#include "pa_util.h"
-
-
-/*
-    Maintain 3 singly linked lists...
-    linkBlocks: the buffers used to allocate the links
-    spareLinks: links available for use in the allocations list
-    allocations: the buffers currently allocated using PaUtil_ContextAllocateMemory()
-
-    Link block size is doubled every time new links are allocated.
-*/
-
-
-#define PA_INITIAL_LINK_COUNT_    16
-
-struct PaUtilAllocationGroupLink
-{
-    struct PaUtilAllocationGroupLink *next;
-    void *buffer;
-};
-
-/*
-    Allocate a block of links. The first link will have it's buffer member
-    pointing to the block, and it's next member set to <nextBlock>. The remaining
-    links will have NULL buffer members, and each link will point to
-    the next link except the last, which will point to <nextSpare>
-*/
-static struct PaUtilAllocationGroupLink *AllocateLinks( long count,
-        struct PaUtilAllocationGroupLink *nextBlock,
-        struct PaUtilAllocationGroupLink *nextSpare )
-{
-    struct PaUtilAllocationGroupLink *result;
-    int i;
-
-    result = (struct PaUtilAllocationGroupLink *)PaUtil_AllocateMemory(
-            sizeof(struct PaUtilAllocationGroupLink) * count );
-    if( result )
-    {
-        /* the block link */
-        result[0].buffer = result;
-        result[0].next = nextBlock;
-
-        /* the spare links */
-        for( i=1; i<count; ++i )
-        {
-            result[i].buffer = 0;
-            result[i].next = &result[i+1];
-        }
-        result[count-1].next = nextSpare;
-    }
-
-    return result;
-}
-
-
-PaUtilAllocationGroup* PaUtil_CreateAllocationGroup( void )
-{
-    PaUtilAllocationGroup* result = 0;
-    struct PaUtilAllocationGroupLink *links;
-
-
-    links = AllocateLinks( PA_INITIAL_LINK_COUNT_, 0, 0 );
-    if( links != 0 )
-    {
-        result = (PaUtilAllocationGroup*)PaUtil_AllocateMemory( sizeof(PaUtilAllocationGroup) );
-        if( result )
-        {
-            result->linkCount = PA_INITIAL_LINK_COUNT_;
-            result->linkBlocks = &links[0];
-            result->spareLinks = &links[1];
-            result->allocations = 0;
-        }
-        else
-        {
-            PaUtil_FreeMemory( links );
-        }
-    }
-
-    return result;
-}
-
-
-void PaUtil_DestroyAllocationGroup( PaUtilAllocationGroup* group )
-{
-    struct PaUtilAllocationGroupLink *current = group->linkBlocks;
-    struct PaUtilAllocationGroupLink *next;
-
-    while( current )
-    {
-        next = current->next;
-        PaUtil_FreeMemory( current->buffer );
-        current = next;
-    }
-
-    PaUtil_FreeMemory( group );
-}
-
-
-void* PaUtil_GroupAllocateMemory( PaUtilAllocationGroup* group, long size )
-{
-    struct PaUtilAllocationGroupLink *links, *link;
-    void *result = 0;
-
-    /* allocate more links if necessary */
-    if( !group->spareLinks )
-    {
-        /* double the link count on each block allocation */
-        links = AllocateLinks( group->linkCount, group->linkBlocks, group->spareLinks );
-        if( links )
-        {
-            group->linkCount += group->linkCount;
-            group->linkBlocks = &links[0];
-            group->spareLinks = &links[1];
-        }
-    }
-
-    if( group->spareLinks )
-    {
-        result = PaUtil_AllocateMemory( size );
-        if( result )
-        {
-            link = group->spareLinks;
-            group->spareLinks = link->next;
-
-            link->buffer = result;
-            link->next = group->allocations;
-
-            group->allocations = link;
-        }
-    }
-
-    return result;
-}
-
-
-void PaUtil_GroupFreeMemory( PaUtilAllocationGroup* group, void *buffer )
-{
-    struct PaUtilAllocationGroupLink *current = group->allocations;
-    struct PaUtilAllocationGroupLink *previous = 0;
-
-    if( buffer == 0 )
-        return;
-
-    /* find the right link and remove it */
-    while( current )
-    {
-        if( current->buffer == buffer )
-        {
-            if( previous )
-            {
-                previous->next = current->next;
-            }
-            else
-            {
-                group->allocations = current->next;
-            }
-
-            current->buffer = 0;
-            current->next = group->spareLinks;
-            group->spareLinks = current;
-
-            break;
-        }
-
-        previous = current;
-        current = current->next;
-    }
-
-    PaUtil_FreeMemory( buffer ); /* free the memory whether we found it in the list or not */
-}
-
-
-void PaUtil_FreeAllAllocations( PaUtilAllocationGroup* group )
-{
-    struct PaUtilAllocationGroupLink *current = group->allocations;
-    struct PaUtilAllocationGroupLink *previous = 0;
-
-    /* free all buffers in the allocations list */
-    while( current )
-    {
-        PaUtil_FreeMemory( current->buffer );
-        current->buffer = 0;
-
-        previous = current;
-        current = current->next;
-    }
-
-    /* link the former allocations list onto the front of the spareLinks list */
-    if( previous )
-    {
-        previous->next = group->spareLinks;
-        group->spareLinks = group->allocations;
-        group->allocations = 0;
-    }
-}
diff --git a/portaudio/src/common/pa_allocation.h b/portaudio/src/common/pa_allocation.h
deleted file mode 100644
index 5c3cf53..0000000
--- a/portaudio/src/common/pa_allocation.h
+++ /dev/null
@@ -1,104 +0,0 @@
-#ifndef PA_ALLOCATION_H
-#define PA_ALLOCATION_H
-/*
- * $Id$
- * Portable Audio I/O Library allocation context header
- * memory allocation context for tracking allocation groups
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2008 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Allocation Group prototypes. An Allocation Group makes it easy to
- allocate multiple blocks of memory and free them all at once.
-
- An allocation group is useful for keeping track of multiple blocks
- of memory which are allocated at the same time (such as during initialization)
- and need to be deallocated at the same time. The allocation group maintains
- a list of allocated blocks, and can free all allocations at once. This
- can be useful for cleaning up after a partially initialized object fails.
-
- The allocation group implementation is built on top of the lower
- level allocation functions defined in pa_util.h
-*/
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-typedef struct
-{
-    long linkCount;
-    struct PaUtilAllocationGroupLink *linkBlocks;
-    struct PaUtilAllocationGroupLink *spareLinks;
-    struct PaUtilAllocationGroupLink *allocations;
-}PaUtilAllocationGroup;
-
-
-
-/** Create an allocation group.
-*/
-PaUtilAllocationGroup* PaUtil_CreateAllocationGroup( void );
-
-/** Destroy an allocation group, but not the memory allocated through the group.
-*/
-void PaUtil_DestroyAllocationGroup( PaUtilAllocationGroup* group );
-
-/** Allocate a block of memory though an allocation group.
-*/
-void* PaUtil_GroupAllocateMemory( PaUtilAllocationGroup* group, long size );
-
-/** Free a block of memory that was previously allocated though an allocation
- group. Calling this function is a relatively time consuming operation.
- Under normal circumstances clients should call PaUtil_FreeAllAllocations to
- free all allocated blocks simultaneously.
- @see PaUtil_FreeAllAllocations
-*/
-void PaUtil_GroupFreeMemory( PaUtilAllocationGroup* group, void *buffer );
-
-/** Free all blocks of memory which have been allocated through the allocation
- group. This function doesn't destroy the group itself.
-*/
-void PaUtil_FreeAllAllocations( PaUtilAllocationGroup* group );
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_ALLOCATION_H */
diff --git a/portaudio/src/common/pa_converters.c b/portaudio/src/common/pa_converters.c
deleted file mode 100644
index 93e44a3..0000000
--- a/portaudio/src/common/pa_converters.c
+++ /dev/null
@@ -1,1983 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library sample conversion mechanism
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Conversion function implementations.
-
- If the C9x function lrintf() is available, define PA_USE_C99_LRINTF to use it
-
- @todo Consider whether functions which dither but don't clip should exist,
- V18 automatically enabled clipping whenever dithering was selected. Perhaps
- we should do the same.
-    see: "require clipping for dithering sample conversion functions?"
-    http://www.portaudio.com/trac/ticket/112
-
- @todo implement the converters marked IMPLEMENT ME: Int32_To_Int24_Dither,
- Int32_To_UInt8_Dither, Int24_To_Int16_Dither, Int24_To_Int8_Dither,
- Int24_To_UInt8_Dither, Int16_To_Int8_Dither, Int16_To_UInt8_Dither
-    see: "some conversion functions are not implemented in pa_converters.c"
-    http://www.portaudio.com/trac/ticket/35
-
- @todo review the converters marked REVIEW: Float32_To_Int32,
- Float32_To_Int32_Dither, Float32_To_Int32_Clip, Float32_To_Int32_DitherClip,
- Int32_To_Int16_Dither, Int32_To_Int8_Dither, Int16_To_Int32
-*/
-
-
-#include "pa_converters.h"
-#include "pa_dither.h"
-#include "pa_endianness.h"
-#include "pa_types.h"
-
-
-PaSampleFormat PaUtil_SelectClosestAvailableFormat(
-        PaSampleFormat availableFormats, PaSampleFormat format )
-{
-    PaSampleFormat result;
-
-    format &= ~paNonInterleaved;
-    availableFormats &= ~paNonInterleaved;
-
-    if( (format & availableFormats) == 0 )
-    {
-        /* NOTE: this code depends on the sample format constants being in
-            descending order of quality - ie best quality is 0
-            FIXME: should write an assert which checks that all of the
-            known constants conform to that requirement.
-        */
-
-        if( format != 0x01 )
-        {
-            /* scan for better formats */
-            result = format;
-            do
-            {
-                result >>= 1;
-            }
-            while( (result & availableFormats) == 0 && result != 0 );
-        }
-        else
-        {
-            result = 0;
-        }
-
-        if( result == 0 ){
-            /* scan for worse formats */
-            result = format;
-            do
-            {
-                result <<= 1;
-            }
-            while( (result & availableFormats) == 0 && result != paCustomFormat );
-
-            if( (result & availableFormats) == 0 )
-                result = paSampleFormatNotSupported;
-        }
-
-    }else{
-        result = format;
-    }
-
-    return result;
-}
-
-/* -------------------------------------------------------------------------- */
-
-#define PA_SELECT_FORMAT_( format, float32, int32, int24, int16, int8, uint8 ) \
-    switch( format & ~paNonInterleaved ){                                      \
-    case paFloat32:                                                            \
-        float32                                                                \
-    case paInt32:                                                              \
-        int32                                                                  \
-    case paInt24:                                                              \
-        int24                                                                  \
-    case paInt16:                                                              \
-        int16                                                                  \
-    case paInt8:                                                               \
-        int8                                                                   \
-    case paUInt8:                                                              \
-        uint8                                                                  \
-    default: return 0;                                                         \
-    }
-
-/* -------------------------------------------------------------------------- */
-
-#define PA_SELECT_CONVERTER_DITHER_CLIP_( flags, source, destination )         \
-    if( flags & paClipOff ){ /* no clip */                                     \
-        if( flags & paDitherOff ){ /* no dither */                             \
-            return paConverters. source ## _To_ ## destination;                \
-        }else{ /* dither */                                                    \
-            return paConverters. source ## _To_ ## destination ## _Dither;     \
-        }                                                                      \
-    }else{ /* clip */                                                          \
-        if( flags & paDitherOff ){ /* no dither */                             \
-            return paConverters. source ## _To_ ## destination ## _Clip;       \
-        }else{ /* dither */                                                    \
-            return paConverters. source ## _To_ ## destination ## _DitherClip; \
-        }                                                                      \
-    }
-
-/* -------------------------------------------------------------------------- */
-
-#define PA_SELECT_CONVERTER_DITHER_( flags, source, destination )              \
-    if( flags & paDitherOff ){ /* no dither */                                 \
-        return paConverters. source ## _To_ ## destination;                    \
-    }else{ /* dither */                                                        \
-        return paConverters. source ## _To_ ## destination ## _Dither;         \
-    }
-
-/* -------------------------------------------------------------------------- */
-
-#define PA_USE_CONVERTER_( source, destination )\
-    return paConverters. source ## _To_ ## destination;
-
-/* -------------------------------------------------------------------------- */
-
-#define PA_UNITY_CONVERSION_( wordlength )\
-    return paConverters. Copy_ ## wordlength ## _To_ ## wordlength;
-
-/* -------------------------------------------------------------------------- */
-
-PaUtilConverter* PaUtil_SelectConverter( PaSampleFormat sourceFormat,
-        PaSampleFormat destinationFormat, PaStreamFlags flags )
-{
-    PA_SELECT_FORMAT_( sourceFormat,
-                       /* paFloat32: */
-                       PA_SELECT_FORMAT_( destinationFormat,
-                                          /* paFloat32: */        PA_UNITY_CONVERSION_( 32 ),
-                                          /* paInt32: */          PA_SELECT_CONVERTER_DITHER_CLIP_( flags, Float32, Int32 ),
-                                          /* paInt24: */          PA_SELECT_CONVERTER_DITHER_CLIP_( flags, Float32, Int24 ),
-                                          /* paInt16: */          PA_SELECT_CONVERTER_DITHER_CLIP_( flags, Float32, Int16 ),
-                                          /* paInt8: */           PA_SELECT_CONVERTER_DITHER_CLIP_( flags, Float32, Int8 ),
-                                          /* paUInt8: */          PA_SELECT_CONVERTER_DITHER_CLIP_( flags, Float32, UInt8 )
-                                        ),
-                       /* paInt32: */
-                       PA_SELECT_FORMAT_( destinationFormat,
-                                          /* paFloat32: */        PA_USE_CONVERTER_( Int32, Float32 ),
-                                          /* paInt32: */          PA_UNITY_CONVERSION_( 32 ),
-                                          /* paInt24: */          PA_SELECT_CONVERTER_DITHER_( flags, Int32, Int24 ),
-                                          /* paInt16: */          PA_SELECT_CONVERTER_DITHER_( flags, Int32, Int16 ),
-                                          /* paInt8: */           PA_SELECT_CONVERTER_DITHER_( flags, Int32, Int8 ),
-                                          /* paUInt8: */          PA_SELECT_CONVERTER_DITHER_( flags, Int32, UInt8 )
-                                        ),
-                       /* paInt24: */
-                       PA_SELECT_FORMAT_( destinationFormat,
-                                          /* paFloat32: */        PA_USE_CONVERTER_( Int24, Float32 ),
-                                          /* paInt32: */          PA_USE_CONVERTER_( Int24, Int32 ),
-                                          /* paInt24: */          PA_UNITY_CONVERSION_( 24 ),
-                                          /* paInt16: */          PA_SELECT_CONVERTER_DITHER_( flags, Int24, Int16 ),
-                                          /* paInt8: */           PA_SELECT_CONVERTER_DITHER_( flags, Int24, Int8 ),
-                                          /* paUInt8: */          PA_SELECT_CONVERTER_DITHER_( flags, Int24, UInt8 )
-                                        ),
-                       /* paInt16: */
-                       PA_SELECT_FORMAT_( destinationFormat,
-                                          /* paFloat32: */        PA_USE_CONVERTER_( Int16, Float32 ),
-                                          /* paInt32: */          PA_USE_CONVERTER_( Int16, Int32 ),
-                                          /* paInt24: */          PA_USE_CONVERTER_( Int16, Int24 ),
-                                          /* paInt16: */          PA_UNITY_CONVERSION_( 16 ),
-                                          /* paInt8: */           PA_SELECT_CONVERTER_DITHER_( flags, Int16, Int8 ),
-                                          /* paUInt8: */          PA_SELECT_CONVERTER_DITHER_( flags, Int16, UInt8 )
-                                        ),
-                       /* paInt8: */
-                       PA_SELECT_FORMAT_( destinationFormat,
-                                          /* paFloat32: */        PA_USE_CONVERTER_( Int8, Float32 ),
-                                          /* paInt32: */          PA_USE_CONVERTER_( Int8, Int32 ),
-                                          /* paInt24: */          PA_USE_CONVERTER_( Int8, Int24 ),
-                                          /* paInt16: */          PA_USE_CONVERTER_( Int8, Int16 ),
-                                          /* paInt8: */           PA_UNITY_CONVERSION_( 8 ),
-                                          /* paUInt8: */          PA_USE_CONVERTER_( Int8, UInt8 )
-                                        ),
-                       /* paUInt8: */
-                       PA_SELECT_FORMAT_( destinationFormat,
-                                          /* paFloat32: */        PA_USE_CONVERTER_( UInt8, Float32 ),
-                                          /* paInt32: */          PA_USE_CONVERTER_( UInt8, Int32 ),
-                                          /* paInt24: */          PA_USE_CONVERTER_( UInt8, Int24 ),
-                                          /* paInt16: */          PA_USE_CONVERTER_( UInt8, Int16 ),
-                                          /* paInt8: */           PA_USE_CONVERTER_( UInt8, Int8 ),
-                                          /* paUInt8: */          PA_UNITY_CONVERSION_( 8 )
-                                        )
-                     )
-}
-
-/* -------------------------------------------------------------------------- */
-
-#ifdef PA_NO_STANDARD_CONVERTERS
-
-/* -------------------------------------------------------------------------- */
-
-PaUtilConverterTable paConverters = {
-    0, /* PaUtilConverter *Float32_To_Int32; */
-    0, /* PaUtilConverter *Float32_To_Int32_Dither; */
-    0, /* PaUtilConverter *Float32_To_Int32_Clip; */
-    0, /* PaUtilConverter *Float32_To_Int32_DitherClip; */
-
-    0, /* PaUtilConverter *Float32_To_Int24; */
-    0, /* PaUtilConverter *Float32_To_Int24_Dither; */
-    0, /* PaUtilConverter *Float32_To_Int24_Clip; */
-    0, /* PaUtilConverter *Float32_To_Int24_DitherClip; */
-
-    0, /* PaUtilConverter *Float32_To_Int16; */
-    0, /* PaUtilConverter *Float32_To_Int16_Dither; */
-    0, /* PaUtilConverter *Float32_To_Int16_Clip; */
-    0, /* PaUtilConverter *Float32_To_Int16_DitherClip; */
-
-    0, /* PaUtilConverter *Float32_To_Int8; */
-    0, /* PaUtilConverter *Float32_To_Int8_Dither; */
-    0, /* PaUtilConverter *Float32_To_Int8_Clip; */
-    0, /* PaUtilConverter *Float32_To_Int8_DitherClip; */
-
-    0, /* PaUtilConverter *Float32_To_UInt8; */
-    0, /* PaUtilConverter *Float32_To_UInt8_Dither; */
-    0, /* PaUtilConverter *Float32_To_UInt8_Clip; */
-    0, /* PaUtilConverter *Float32_To_UInt8_DitherClip; */
-
-    0, /* PaUtilConverter *Int32_To_Float32; */
-    0, /* PaUtilConverter *Int32_To_Int24; */
-    0, /* PaUtilConverter *Int32_To_Int24_Dither; */
-    0, /* PaUtilConverter *Int32_To_Int16; */
-    0, /* PaUtilConverter *Int32_To_Int16_Dither; */
-    0, /* PaUtilConverter *Int32_To_Int8; */
-    0, /* PaUtilConverter *Int32_To_Int8_Dither; */
-    0, /* PaUtilConverter *Int32_To_UInt8; */
-    0, /* PaUtilConverter *Int32_To_UInt8_Dither; */
-
-    0, /* PaUtilConverter *Int24_To_Float32; */
-    0, /* PaUtilConverter *Int24_To_Int32; */
-    0, /* PaUtilConverter *Int24_To_Int16; */
-    0, /* PaUtilConverter *Int24_To_Int16_Dither; */
-    0, /* PaUtilConverter *Int24_To_Int8; */
-    0, /* PaUtilConverter *Int24_To_Int8_Dither; */
-    0, /* PaUtilConverter *Int24_To_UInt8; */
-    0, /* PaUtilConverter *Int24_To_UInt8_Dither; */
-
-    0, /* PaUtilConverter *Int16_To_Float32; */
-    0, /* PaUtilConverter *Int16_To_Int32; */
-    0, /* PaUtilConverter *Int16_To_Int24; */
-    0, /* PaUtilConverter *Int16_To_Int8; */
-    0, /* PaUtilConverter *Int16_To_Int8_Dither; */
-    0, /* PaUtilConverter *Int16_To_UInt8; */
-    0, /* PaUtilConverter *Int16_To_UInt8_Dither; */
-
-    0, /* PaUtilConverter *Int8_To_Float32; */
-    0, /* PaUtilConverter *Int8_To_Int32; */
-    0, /* PaUtilConverter *Int8_To_Int24 */
-    0, /* PaUtilConverter *Int8_To_Int16; */
-    0, /* PaUtilConverter *Int8_To_UInt8; */
-
-    0, /* PaUtilConverter *UInt8_To_Float32; */
-    0, /* PaUtilConverter *UInt8_To_Int32; */
-    0, /* PaUtilConverter *UInt8_To_Int24; */
-    0, /* PaUtilConverter *UInt8_To_Int16; */
-    0, /* PaUtilConverter *UInt8_To_Int8; */
-
-    0, /* PaUtilConverter *Copy_8_To_8; */
-    0, /* PaUtilConverter *Copy_16_To_16; */
-    0, /* PaUtilConverter *Copy_24_To_24; */
-    0  /* PaUtilConverter *Copy_32_To_32; */
-};
-
-/* -------------------------------------------------------------------------- */
-
-#else /* PA_NO_STANDARD_CONVERTERS is not defined */
-
-/* -------------------------------------------------------------------------- */
-
-#define PA_CLIP_( val, min, max )\
-    { val = ((val) < (min)) ? (min) : (((val) > (max)) ? (max) : (val)); }
-
-
-static const float const_1_div_128_ = 1.0f / 128.0f;  /* 8 bit multiplier */
-
-static const float const_1_div_32768_ = 1.0f / 32768.f; /* 16 bit multiplier */
-
-static const double const_1_div_2147483648_ = 1.0 / 2147483648.0; /* 32 bit multiplier */
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt32 *dest =  (PaInt32*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* REVIEW */
-#ifdef PA_USE_C99_LRINTF
-        float scaled = *src * 0x7FFFFFFF;
-        *dest = lrintf(scaled-0.5f);
-#else
-        double scaled = *src * 0x7FFFFFFF;
-        *dest = (PaInt32) scaled;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int32_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt32 *dest =  (PaInt32*)destinationBuffer;
-
-    while( count-- )
-    {
-        /* REVIEW */
-#ifdef PA_USE_C99_LRINTF
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = ((float)*src * (2147483646.0f)) + dither;
-        *dest = lrintf(dithered - 0.5f);
-#else
-        double dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        double dithered = ((double)*src * (2147483646.0)) + dither;
-        *dest = (PaInt32) dithered;
-#endif
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int32_Clip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt32 *dest =  (PaInt32*)destinationBuffer;
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* REVIEW */
-#ifdef PA_USE_C99_LRINTF
-        float scaled = *src * 0x7FFFFFFF;
-        PA_CLIP_( scaled, -2147483648.f, 2147483647.f  );
-        *dest = lrintf(scaled-0.5f);
-#else
-        double scaled = *src * 0x7FFFFFFF;
-        PA_CLIP_( scaled, -2147483648., 2147483647.  );
-        *dest = (PaInt32) scaled;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int32_DitherClip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt32 *dest =  (PaInt32*)destinationBuffer;
-
-    while( count-- )
-    {
-        /* REVIEW */
-#ifdef PA_USE_C99_LRINTF
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = ((float)*src * (2147483646.0f)) + dither;
-        PA_CLIP_( dithered, -2147483648.f, 2147483647.f  );
-        *dest = lrintf(dithered-0.5f);
-#else
-        double dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        double dithered = ((double)*src * (2147483646.0)) + dither;
-        PA_CLIP_( dithered, -2147483648., 2147483647.  );
-        *dest = (PaInt32) dithered;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int24(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    PaInt32 temp;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* convert to 32 bit and drop the low 8 bits */
-        double scaled = (double)(*src) * 2147483647.0;
-        temp = (PaInt32) scaled;
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 8);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 24);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 24);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 8);
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int24_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    PaInt32 temp;
-
-    while( count-- )
-    {
-        /* convert to 32 bit and drop the low 8 bits */
-
-        double dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        double dithered = ((double)*src * (2147483646.0)) + dither;
-
-        temp = (PaInt32) dithered;
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 8);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 24);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 24);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 8);
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int24_Clip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    PaInt32 temp;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* convert to 32 bit and drop the low 8 bits */
-        double scaled = *src * 0x7FFFFFFF;
-        PA_CLIP_( scaled, -2147483648., 2147483647.  );
-        temp = (PaInt32) scaled;
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 8);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 24);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 24);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 8);
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int24_DitherClip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    PaInt32 temp;
-
-    while( count-- )
-    {
-        /* convert to 32 bit and drop the low 8 bits */
-
-        double dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        double dithered = ((double)*src * (2147483646.0)) + dither;
-        PA_CLIP_( dithered, -2147483648., 2147483647.  );
-
-        temp = (PaInt32) dithered;
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 8);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 24);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 24);
-        dest[1] = (unsigned char)(temp >> 16);
-        dest[2] = (unsigned char)(temp >> 8);
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int16(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-#ifdef PA_USE_C99_LRINTF
-        float tempf = (*src * (32767.0f)) ;
-        *dest = lrintf(tempf-0.5f);
-#else
-        short samp = (short) (*src * (32767.0f));
-        *dest = samp;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int16_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt16 *dest = (PaInt16*)destinationBuffer;
-
-    while( count-- )
-    {
-
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = (*src * (32766.0f)) + dither;
-
-#ifdef PA_USE_C99_LRINTF
-        *dest = lrintf(dithered-0.5f);
-#else
-        *dest = (PaInt16) dithered;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int16_Clip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-#ifdef PA_USE_C99_LRINTF
-        long samp = lrintf((*src * (32767.0f)) -0.5f);
-#else
-        long samp = (PaInt32) (*src * (32767.0f));
-#endif
-        PA_CLIP_( samp, -0x8000, 0x7FFF );
-        *dest = (PaInt16) samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int16_DitherClip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = (*src * (32766.0f)) + dither;
-        PaInt32 samp = (PaInt32) dithered;
-        PA_CLIP_( samp, -0x8000, 0x7FFF );
-#ifdef PA_USE_C99_LRINTF
-        *dest = lrintf(samp-0.5f);
-#else
-        *dest = (PaInt16) samp;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        signed char samp = (signed char) (*src * (127.0f));
-        *dest = samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-
-    while( count-- )
-    {
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = (*src * (126.0f)) + dither;
-        PaInt32 samp = (PaInt32) dithered;
-        *dest = (signed char) samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int8_Clip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        PaInt32 samp = (PaInt32)(*src * (127.0f));
-        PA_CLIP_( samp, -0x80, 0x7F );
-        *dest = (signed char) samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_Int8_DitherClip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = (*src * (126.0f)) + dither;
-        PaInt32 samp = (PaInt32) dithered;
-        PA_CLIP_( samp, -0x80, 0x7F );
-        *dest = (signed char) samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_UInt8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        unsigned char samp = (unsigned char)(128 + ((unsigned char) (*src * (127.0f))));
-        *dest = samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_UInt8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-
-    while( count-- )
-    {
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = (*src * (126.0f)) + dither;
-        PaInt32 samp = (PaInt32) dithered;
-        *dest = (unsigned char) (128 + samp);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_UInt8_Clip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        PaInt32 samp = 128 + (PaInt32)(*src * (127.0f));
-        PA_CLIP_( samp, 0x0000, 0x00FF );
-        *dest = (unsigned char) samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Float32_To_UInt8_DitherClip(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    float *src = (float*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        float dither  = PaUtil_GenerateFloatTriangularDither( ditherGenerator );
-        /* use smaller scaler to prevent overflow when we add the dither */
-        float dithered = (*src * (126.0f)) + dither;
-        PaInt32 samp = 128 + (PaInt32) dithered;
-        PA_CLIP_( samp, 0x0000, 0x00FF );
-        *dest = (unsigned char) samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Float32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    float *dest =  (float*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        *dest = (float) ((double)*src * const_1_div_2147483648_);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Int24(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src    = (PaInt32*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* REVIEW */
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = (unsigned char)(*src >> 8);
-        dest[1] = (unsigned char)(*src >> 16);
-        dest[2] = (unsigned char)(*src >> 24);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(*src >> 24);
-        dest[1] = (unsigned char)(*src >> 16);
-        dest[2] = (unsigned char)(*src >> 8);
-#endif
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Int24_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    (void) destinationBuffer; /* unused parameters */
-    (void) destinationStride; /* unused parameters */
-    (void) sourceBuffer; /* unused parameters */
-    (void) sourceStride; /* unused parameters */
-    (void) count; /* unused parameters */
-    (void) ditherGenerator; /* unused parameters */
-    /* IMPLEMENT ME */
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Int16(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        *dest = (PaInt16) ((*src) >> 16);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Int16_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    PaInt32 dither;
-
-    while( count-- )
-    {
-        /* REVIEW */
-        dither = PaUtil_Generate16BitTriangularDither( ditherGenerator );
-        *dest = (PaInt16) ((((*src)>>1) + dither) >> 15);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Int8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        *dest = (signed char) ((*src) >> 24);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_Int8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    PaInt32 dither;
-
-    while( count-- )
-    {
-        /* REVIEW */
-        dither = PaUtil_Generate16BitTriangularDither( ditherGenerator );
-        *dest = (signed char) ((((*src)>>1) + dither) >> 23);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_UInt8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (unsigned char)(((*src) >> 24) + 128);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int32_To_UInt8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt32 *src = (PaInt32*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* IMPLEMENT ME */
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_Float32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    float *dest = (float*)destinationBuffer;
-    PaInt32 temp;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        temp = (((PaInt32)src[0]) << 8);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 24);
-#elif defined(PA_BIG_ENDIAN)
-        temp = (((PaInt32)src[0]) << 24);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 8);
-#endif
-
-        *dest = (float) ((double)temp * const_1_div_2147483648_);
-
-        src += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_Int32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src  = (unsigned char*)sourceBuffer;
-    PaInt32 *dest = (PaInt32*)  destinationBuffer;
-    PaInt32 temp;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        temp = (((PaInt32)src[0]) << 8);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 24);
-#elif defined(PA_BIG_ENDIAN)
-        temp = (((PaInt32)src[0]) << 24);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 8);
-#endif
-
-        *dest = temp;
-
-        src += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_Int16(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    PaInt16 *dest = (PaInt16*)destinationBuffer;
-
-    PaInt16 temp;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        /* src[0] is discarded */
-        temp = (((PaInt16)src[1]));
-        temp = temp | (PaInt16)(((PaInt16)src[2]) << 8);
-#elif defined(PA_BIG_ENDIAN)
-        /* src[2] is discarded */
-        temp = (PaInt16)(((PaInt16)src[0]) << 8);
-        temp = temp | (((PaInt16)src[1]));
-#endif
-
-        *dest = temp;
-
-        src += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_Int16_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    PaInt16 *dest = (PaInt16*)destinationBuffer;
-
-    PaInt32 temp, dither;
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        temp = (((PaInt32)src[0]) << 8);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 24);
-#elif defined(PA_BIG_ENDIAN)
-        temp = (((PaInt32)src[0]) << 24);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 8);
-#endif
-
-        /* REVIEW */
-        dither = PaUtil_Generate16BitTriangularDither( ditherGenerator );
-        *dest = (PaInt16) (((temp >> 1) + dither) >> 15);
-
-        src  += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_Int8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    signed char  *dest = (signed char*)destinationBuffer;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        /* src[0] is discarded */
-        /* src[1] is discarded */
-        *dest = src[2];
-#elif defined(PA_BIG_ENDIAN)
-        /* src[2] is discarded */
-        /* src[1] is discarded */
-        *dest = src[0];
-#endif
-
-        src += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_Int8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    signed char  *dest = (signed char*)destinationBuffer;
-
-    PaInt32 temp, dither;
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        temp = (((PaInt32)src[0]) << 8);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 24);
-#elif defined(PA_BIG_ENDIAN)
-        temp = (((PaInt32)src[0]) << 24);
-        temp = temp | (((PaInt32)src[1]) << 16);
-        temp = temp | (((PaInt32)src[2]) << 8);
-#endif
-
-        /* REVIEW */
-        dither = PaUtil_Generate16BitTriangularDither( ditherGenerator );
-        *dest = (signed char) (((temp >> 1) + dither) >> 23);
-
-        src += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_UInt8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        /* src[0] is discarded */
-        /* src[1] is discarded */
-        *dest = (unsigned char)(src[2] + 128);
-#elif defined(PA_BIG_ENDIAN)
-        *dest = (unsigned char)(src[0] + 128);
-        /* src[1] is discarded */
-        /* src[2] is discarded */
-#endif
-
-        src += sourceStride * 3;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int24_To_UInt8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    (void) destinationBuffer; /* unused parameters */
-    (void) destinationStride; /* unused parameters */
-    (void) sourceBuffer; /* unused parameters */
-    (void) sourceStride; /* unused parameters */
-    (void) count; /* unused parameters */
-    (void) ditherGenerator; /* unused parameters */
-    /* IMPLEMENT ME */
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_Float32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src = (PaInt16*)sourceBuffer;
-    float *dest =  (float*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        float samp = *src * const_1_div_32768_; /* FIXME: i'm concerned about this being asymmetrical with float->int16 -rb */
-        *dest = samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_Int32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src = (PaInt16*)sourceBuffer;
-    PaInt32 *dest =  (PaInt32*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* REVIEW: we should consider something like
-            (*src << 16) | (*src & 0xFFFF)
-        */
-
-        *dest = *src << 16;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_Int24(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src   = (PaInt16*) sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    PaInt16 temp;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        temp = *src;
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = 0;
-        dest[1] = (unsigned char)(temp);
-        dest[2] = (unsigned char)(temp >> 8);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(temp >> 8);
-        dest[1] = (unsigned char)(temp);
-        dest[2] = 0;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_Int8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src = (PaInt16*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (signed char)((*src) >> 8);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_Int8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src = (PaInt16*)sourceBuffer;
-    signed char *dest =  (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* IMPLEMENT ME */
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_UInt8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src = (PaInt16*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (unsigned char)(((*src) >> 8) + 128);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int16_To_UInt8_Dither(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaInt16 *src = (PaInt16*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        /* IMPLEMENT ME */
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int8_To_Float32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    signed char *src = (signed char*)sourceBuffer;
-    float *dest =  (float*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        float samp = *src * const_1_div_128_;
-        *dest = samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int8_To_Int32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    signed char *src = (signed char*)sourceBuffer;
-    PaInt32 *dest =  (PaInt32*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (*src) << 24;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int8_To_Int24(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    signed char *src = (signed char*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = 0;
-        dest[1] = 0;
-        dest[2] = (*src);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (*src);
-        dest[1] = 0;
-        dest[2] = 0;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int8_To_Int16(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    signed char *src = (signed char*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (PaInt16)((*src) << 8);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Int8_To_UInt8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    signed char *src = (signed char*)sourceBuffer;
-    unsigned char *dest =  (unsigned char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (unsigned char)(*src + 128);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void UInt8_To_Float32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    float *dest =  (float*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        float samp = (*src - 128) * const_1_div_128_;
-        *dest = samp;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void UInt8_To_Int32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    PaInt32 *dest = (PaInt32*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (*src - 128) << 24;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void UInt8_To_Int24(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src  = (unsigned char*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-    (void) ditherGenerator; /* unused parameters */
-
-    while( count-- )
-    {
-
-#if defined(PA_LITTLE_ENDIAN)
-        dest[0] = 0;
-        dest[1] = 0;
-        dest[2] = (unsigned char)(*src - 128);
-#elif defined(PA_BIG_ENDIAN)
-        dest[0] = (unsigned char)(*src - 128);
-        dest[1] = 0;
-        dest[2] = 0;
-#endif
-
-        src += sourceStride;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void UInt8_To_Int16(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    PaInt16 *dest =  (PaInt16*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (PaInt16)((*src - 128) << 8);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void UInt8_To_Int8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    signed char  *dest = (signed char*)destinationBuffer;
-    (void)ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        (*dest) = (signed char)(*src - 128);
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Copy_8_To_8(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        *dest = *src;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Copy_16_To_16(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaUint16 *src = (PaUint16 *)sourceBuffer;
-    PaUint16 *dest = (PaUint16 *)destinationBuffer;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        *dest = *src;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Copy_24_To_24(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    unsigned char *src = (unsigned char*)sourceBuffer;
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        dest[0] = src[0];
-        dest[1] = src[1];
-        dest[2] = src[2];
-
-        src += sourceStride * 3;
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Copy_32_To_32(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
-{
-    PaUint32 *dest = (PaUint32 *)destinationBuffer;
-    PaUint32 *src = (PaUint32 *)sourceBuffer;
-
-    (void) ditherGenerator; /* unused parameter */
-
-    while( count-- )
-    {
-        *dest = *src;
-
-        src += sourceStride;
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-PaUtilConverterTable paConverters = {
-    Float32_To_Int32,              /* PaUtilConverter *Float32_To_Int32; */
-    Float32_To_Int32_Dither,       /* PaUtilConverter *Float32_To_Int32_Dither; */
-    Float32_To_Int32_Clip,         /* PaUtilConverter *Float32_To_Int32_Clip; */
-    Float32_To_Int32_DitherClip,   /* PaUtilConverter *Float32_To_Int32_DitherClip; */
-
-    Float32_To_Int24,              /* PaUtilConverter *Float32_To_Int24; */
-    Float32_To_Int24_Dither,       /* PaUtilConverter *Float32_To_Int24_Dither; */
-    Float32_To_Int24_Clip,         /* PaUtilConverter *Float32_To_Int24_Clip; */
-    Float32_To_Int24_DitherClip,   /* PaUtilConverter *Float32_To_Int24_DitherClip; */
-
-    Float32_To_Int16,              /* PaUtilConverter *Float32_To_Int16; */
-    Float32_To_Int16_Dither,       /* PaUtilConverter *Float32_To_Int16_Dither; */
-    Float32_To_Int16_Clip,         /* PaUtilConverter *Float32_To_Int16_Clip; */
-    Float32_To_Int16_DitherClip,   /* PaUtilConverter *Float32_To_Int16_DitherClip; */
-
-    Float32_To_Int8,               /* PaUtilConverter *Float32_To_Int8; */
-    Float32_To_Int8_Dither,        /* PaUtilConverter *Float32_To_Int8_Dither; */
-    Float32_To_Int8_Clip,          /* PaUtilConverter *Float32_To_Int8_Clip; */
-    Float32_To_Int8_DitherClip,    /* PaUtilConverter *Float32_To_Int8_DitherClip; */
-
-    Float32_To_UInt8,              /* PaUtilConverter *Float32_To_UInt8; */
-    Float32_To_UInt8_Dither,       /* PaUtilConverter *Float32_To_UInt8_Dither; */
-    Float32_To_UInt8_Clip,         /* PaUtilConverter *Float32_To_UInt8_Clip; */
-    Float32_To_UInt8_DitherClip,   /* PaUtilConverter *Float32_To_UInt8_DitherClip; */
-
-    Int32_To_Float32,              /* PaUtilConverter *Int32_To_Float32; */
-    Int32_To_Int24,                /* PaUtilConverter *Int32_To_Int24; */
-    Int32_To_Int24_Dither,         /* PaUtilConverter *Int32_To_Int24_Dither; */
-    Int32_To_Int16,                /* PaUtilConverter *Int32_To_Int16; */
-    Int32_To_Int16_Dither,         /* PaUtilConverter *Int32_To_Int16_Dither; */
-    Int32_To_Int8,                 /* PaUtilConverter *Int32_To_Int8; */
-    Int32_To_Int8_Dither,          /* PaUtilConverter *Int32_To_Int8_Dither; */
-    Int32_To_UInt8,                /* PaUtilConverter *Int32_To_UInt8; */
-    Int32_To_UInt8_Dither,         /* PaUtilConverter *Int32_To_UInt8_Dither; */
-
-    Int24_To_Float32,              /* PaUtilConverter *Int24_To_Float32; */
-    Int24_To_Int32,                /* PaUtilConverter *Int24_To_Int32; */
-    Int24_To_Int16,                /* PaUtilConverter *Int24_To_Int16; */
-    Int24_To_Int16_Dither,         /* PaUtilConverter *Int24_To_Int16_Dither; */
-    Int24_To_Int8,                 /* PaUtilConverter *Int24_To_Int8; */
-    Int24_To_Int8_Dither,          /* PaUtilConverter *Int24_To_Int8_Dither; */
-    Int24_To_UInt8,                /* PaUtilConverter *Int24_To_UInt8; */
-    Int24_To_UInt8_Dither,         /* PaUtilConverter *Int24_To_UInt8_Dither; */
-
-    Int16_To_Float32,              /* PaUtilConverter *Int16_To_Float32; */
-    Int16_To_Int32,                /* PaUtilConverter *Int16_To_Int32; */
-    Int16_To_Int24,                /* PaUtilConverter *Int16_To_Int24; */
-    Int16_To_Int8,                 /* PaUtilConverter *Int16_To_Int8; */
-    Int16_To_Int8_Dither,          /* PaUtilConverter *Int16_To_Int8_Dither; */
-    Int16_To_UInt8,                /* PaUtilConverter *Int16_To_UInt8; */
-    Int16_To_UInt8_Dither,         /* PaUtilConverter *Int16_To_UInt8_Dither; */
-
-    Int8_To_Float32,               /* PaUtilConverter *Int8_To_Float32; */
-    Int8_To_Int32,                 /* PaUtilConverter *Int8_To_Int32; */
-    Int8_To_Int24,                 /* PaUtilConverter *Int8_To_Int24 */
-    Int8_To_Int16,                 /* PaUtilConverter *Int8_To_Int16; */
-    Int8_To_UInt8,                 /* PaUtilConverter *Int8_To_UInt8; */
-
-    UInt8_To_Float32,              /* PaUtilConverter *UInt8_To_Float32; */
-    UInt8_To_Int32,                /* PaUtilConverter *UInt8_To_Int32; */
-    UInt8_To_Int24,                /* PaUtilConverter *UInt8_To_Int24; */
-    UInt8_To_Int16,                /* PaUtilConverter *UInt8_To_Int16; */
-    UInt8_To_Int8,                 /* PaUtilConverter *UInt8_To_Int8; */
-
-    Copy_8_To_8,                   /* PaUtilConverter *Copy_8_To_8; */
-    Copy_16_To_16,                 /* PaUtilConverter *Copy_16_To_16; */
-    Copy_24_To_24,                 /* PaUtilConverter *Copy_24_To_24; */
-    Copy_32_To_32                  /* PaUtilConverter *Copy_32_To_32; */
-};
-
-/* -------------------------------------------------------------------------- */
-
-#endif /* PA_NO_STANDARD_CONVERTERS */
-
-/* -------------------------------------------------------------------------- */
-
-PaUtilZeroer* PaUtil_SelectZeroer( PaSampleFormat destinationFormat )
-{
-    switch( destinationFormat & ~paNonInterleaved ){
-    case paFloat32:
-        return paZeroers.Zero32;
-    case paInt32:
-        return paZeroers.Zero32;
-    case paInt24:
-        return paZeroers.Zero24;
-    case paInt16:
-        return paZeroers.Zero16;
-    case paInt8:
-        return paZeroers.Zero8;
-    case paUInt8:
-        return paZeroers.ZeroU8;
-    default: return 0;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-#ifdef PA_NO_STANDARD_ZEROERS
-
-/* -------------------------------------------------------------------------- */
-
-PaUtilZeroerTable paZeroers = {
-    0,  /* PaUtilZeroer *ZeroU8; */
-    0,  /* PaUtilZeroer *Zero8; */
-    0,  /* PaUtilZeroer *Zero16; */
-    0,  /* PaUtilZeroer *Zero24; */
-    0,  /* PaUtilZeroer *Zero32; */
-};
-
-/* -------------------------------------------------------------------------- */
-
-#else /* PA_NO_STANDARD_ZEROERS is not defined */
-
-/* -------------------------------------------------------------------------- */
-
-static void ZeroU8( void *destinationBuffer, signed int destinationStride,
-        unsigned int count )
-{
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-
-    while( count-- )
-    {
-        *dest = 128;
-
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Zero8( void *destinationBuffer, signed int destinationStride,
-        unsigned int count )
-{
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-
-    while( count-- )
-    {
-        *dest = 0;
-
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Zero16( void *destinationBuffer, signed int destinationStride,
-        unsigned int count )
-{
-    PaUint16 *dest = (PaUint16 *)destinationBuffer;
-
-    while( count-- )
-    {
-        *dest = 0;
-
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Zero24( void *destinationBuffer, signed int destinationStride,
-        unsigned int count )
-{
-    unsigned char *dest = (unsigned char*)destinationBuffer;
-
-    while( count-- )
-    {
-        dest[0] = 0;
-        dest[1] = 0;
-        dest[2] = 0;
-
-        dest += destinationStride * 3;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-static void Zero32( void *destinationBuffer, signed int destinationStride,
-        unsigned int count )
-{
-    PaUint32 *dest = (PaUint32 *)destinationBuffer;
-
-    while( count-- )
-    {
-        *dest = 0;
-
-        dest += destinationStride;
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-PaUtilZeroerTable paZeroers = {
-    ZeroU8,  /* PaUtilZeroer *ZeroU8; */
-    Zero8,  /* PaUtilZeroer *Zero8; */
-    Zero16,  /* PaUtilZeroer *Zero16; */
-    Zero24,  /* PaUtilZeroer *Zero24; */
-    Zero32,  /* PaUtilZeroer *Zero32; */
-};
-
-/* -------------------------------------------------------------------------- */
-
-#endif /* PA_NO_STANDARD_ZEROERS */
diff --git a/portaudio/src/common/pa_converters.h b/portaudio/src/common/pa_converters.h
deleted file mode 100644
index 96edf1c..0000000
--- a/portaudio/src/common/pa_converters.h
+++ /dev/null
@@ -1,263 +0,0 @@
-#ifndef PA_CONVERTERS_H
-#define PA_CONVERTERS_H
-/*
- * $Id$
- * Portable Audio I/O Library sample conversion mechanism
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Conversion functions used to convert buffers of samples from one
- format to another.
-*/
-
-
-#include "portaudio.h"  /* for PaSampleFormat */
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-struct PaUtilTriangularDitherGenerator;
-
-
-/** Choose an available sample format which is most appropriate for
- representing the requested format. If the requested format is not available
- higher quality formats are considered before lower quality formats.
- @param availableFormats A variable containing the logical OR of all available
- formats.
- @param format The desired format.
- @return The most appropriate available format for representing the requested
- format.
-*/
-PaSampleFormat PaUtil_SelectClosestAvailableFormat(
-        PaSampleFormat availableFormats, PaSampleFormat format );
-
-
-/* high level conversions functions for use by implementations */
-
-
-/** The generic sample converter prototype. Sample converters convert count
-    samples from sourceBuffer to destinationBuffer. The actual type of the data
-    pointed to by these parameters varys for different converter functions.
-    @param destinationBuffer A pointer to the first sample of the destination.
-    @param destinationStride An offset between successive destination samples
-    expressed in samples (not bytes.) It may be negative.
-    @param sourceBuffer A pointer to the first sample of the source.
-    @param sourceStride An offset between successive source samples
-    expressed in samples (not bytes.) It may be negative.
-    @param count The number of samples to convert.
-    @param ditherState State information used to calculate dither. Converters
-    that do not perform dithering will ignore this parameter, in which case
-    NULL or invalid dither state may be passed.
-*/
-typedef void PaUtilConverter(
-    void *destinationBuffer, signed int destinationStride,
-    void *sourceBuffer, signed int sourceStride,
-    unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator );
-
-
-/** Find a sample converter function for the given source and destinations
-    formats and flags (clip and dither.)
-    @return
-    A pointer to a PaUtilConverter which will perform the requested
-    conversion, or NULL if the given format conversion is not supported.
-    For conversions where clipping or dithering is not necessary, the
-    clip and dither flags are ignored and a non-clipping or dithering
-    version is returned.
-    If the source and destination formats are the same, a function which
-    copies data of the appropriate size will be returned.
-*/
-PaUtilConverter* PaUtil_SelectConverter( PaSampleFormat sourceFormat,
-        PaSampleFormat destinationFormat, PaStreamFlags flags );
-
-
-/** The generic buffer zeroer prototype. Buffer zeroers copy count zeros to
-    destinationBuffer. The actual type of the data pointed to varys for
-    different zeroer functions.
-    @param destinationBuffer A pointer to the first sample of the destination.
-    @param destinationStride An offset between successive destination samples
-    expressed in samples (not bytes.) It may be negative.
-    @param count The number of samples to zero.
-*/
-typedef void PaUtilZeroer(
-    void *destinationBuffer, signed int destinationStride, unsigned int count );
-
-
-/** Find a buffer zeroer function for the given destination format.
-    @return
-    A pointer to a PaUtilZeroer which will perform the requested
-    zeroing.
-*/
-PaUtilZeroer* PaUtil_SelectZeroer( PaSampleFormat destinationFormat );
-
-/*----------------------------------------------------------------------------*/
-/* low level functions and data structures which may be used for
-    substituting conversion functions */
-
-
-/** The type used to store all sample conversion functions.
-    @see paConverters;
-*/
-typedef struct{
-    PaUtilConverter *Float32_To_Int32;
-    PaUtilConverter *Float32_To_Int32_Dither;
-    PaUtilConverter *Float32_To_Int32_Clip;
-    PaUtilConverter *Float32_To_Int32_DitherClip;
-
-    PaUtilConverter *Float32_To_Int24;
-    PaUtilConverter *Float32_To_Int24_Dither;
-    PaUtilConverter *Float32_To_Int24_Clip;
-    PaUtilConverter *Float32_To_Int24_DitherClip;
-
-    PaUtilConverter *Float32_To_Int16;
-    PaUtilConverter *Float32_To_Int16_Dither;
-    PaUtilConverter *Float32_To_Int16_Clip;
-    PaUtilConverter *Float32_To_Int16_DitherClip;
-
-    PaUtilConverter *Float32_To_Int8;
-    PaUtilConverter *Float32_To_Int8_Dither;
-    PaUtilConverter *Float32_To_Int8_Clip;
-    PaUtilConverter *Float32_To_Int8_DitherClip;
-
-    PaUtilConverter *Float32_To_UInt8;
-    PaUtilConverter *Float32_To_UInt8_Dither;
-    PaUtilConverter *Float32_To_UInt8_Clip;
-    PaUtilConverter *Float32_To_UInt8_DitherClip;
-
-    PaUtilConverter *Int32_To_Float32;
-    PaUtilConverter *Int32_To_Int24;
-    PaUtilConverter *Int32_To_Int24_Dither;
-    PaUtilConverter *Int32_To_Int16;
-    PaUtilConverter *Int32_To_Int16_Dither;
-    PaUtilConverter *Int32_To_Int8;
-    PaUtilConverter *Int32_To_Int8_Dither;
-    PaUtilConverter *Int32_To_UInt8;
-    PaUtilConverter *Int32_To_UInt8_Dither;
-
-    PaUtilConverter *Int24_To_Float32;
-    PaUtilConverter *Int24_To_Int32;
-    PaUtilConverter *Int24_To_Int16;
-    PaUtilConverter *Int24_To_Int16_Dither;
-    PaUtilConverter *Int24_To_Int8;
-    PaUtilConverter *Int24_To_Int8_Dither;
-    PaUtilConverter *Int24_To_UInt8;
-    PaUtilConverter *Int24_To_UInt8_Dither;
-
-    PaUtilConverter *Int16_To_Float32;
-    PaUtilConverter *Int16_To_Int32;
-    PaUtilConverter *Int16_To_Int24;
-    PaUtilConverter *Int16_To_Int8;
-    PaUtilConverter *Int16_To_Int8_Dither;
-    PaUtilConverter *Int16_To_UInt8;
-    PaUtilConverter *Int16_To_UInt8_Dither;
-
-    PaUtilConverter *Int8_To_Float32;
-    PaUtilConverter *Int8_To_Int32;
-    PaUtilConverter *Int8_To_Int24;
-    PaUtilConverter *Int8_To_Int16;
-    PaUtilConverter *Int8_To_UInt8;
-
-    PaUtilConverter *UInt8_To_Float32;
-    PaUtilConverter *UInt8_To_Int32;
-    PaUtilConverter *UInt8_To_Int24;
-    PaUtilConverter *UInt8_To_Int16;
-    PaUtilConverter *UInt8_To_Int8;
-
-    PaUtilConverter *Copy_8_To_8;       /* copy without any conversion */
-    PaUtilConverter *Copy_16_To_16;     /* copy without any conversion */
-    PaUtilConverter *Copy_24_To_24;     /* copy without any conversion */
-    PaUtilConverter *Copy_32_To_32;     /* copy without any conversion */
-} PaUtilConverterTable;
-
-
-/** A table of pointers to all required converter functions.
-    PaUtil_SelectConverter() uses this table to lookup the appropriate
-    conversion functions. The fields of this structure are initialized
-    with default conversion functions. Fields may be NULL, indicating that
-    no conversion function is available. User code may substitute optimised
-    conversion functions by assigning different function pointers to
-    these fields.
-
-    @note
-    If the PA_NO_STANDARD_CONVERTERS preprocessor variable is defined,
-    PortAudio's standard converters will not be compiled, and all fields
-    of this structure will be initialized to NULL. In such cases, users
-    should supply their own conversion functions if the require PortAudio
-    to open a stream that requires sample conversion.
-
-    @see PaUtilConverterTable, PaUtilConverter, PaUtil_SelectConverter
-*/
-extern PaUtilConverterTable paConverters;
-
-
-/** The type used to store all buffer zeroing functions.
-    @see paZeroers;
-*/
-typedef struct{
-    PaUtilZeroer *ZeroU8; /* unsigned 8 bit, zero == 128 */
-    PaUtilZeroer *Zero8;
-    PaUtilZeroer *Zero16;
-    PaUtilZeroer *Zero24;
-    PaUtilZeroer *Zero32;
-} PaUtilZeroerTable;
-
-
-/** A table of pointers to all required zeroer functions.
-    PaUtil_SelectZeroer() uses this table to lookup the appropriate
-    conversion functions. The fields of this structure are initialized
-    with default conversion functions. User code may substitute optimised
-    conversion functions by assigning different function pointers to
-    these fields.
-
-    @note
-    If the PA_NO_STANDARD_ZEROERS preprocessor variable is defined,
-    PortAudio's standard zeroers will not be compiled, and all fields
-    of this structure will be initialized to NULL. In such cases, users
-    should supply their own zeroing functions for the sample sizes which
-    they intend to use.
-
-    @see PaUtilZeroerTable, PaUtilZeroer, PaUtil_SelectZeroer
-*/
-extern PaUtilZeroerTable paZeroers;
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_CONVERTERS_H */
diff --git a/portaudio/src/common/pa_cpuload.c b/portaudio/src/common/pa_cpuload.c
deleted file mode 100644
index de57db2..0000000
--- a/portaudio/src/common/pa_cpuload.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library CPU Load measurement functions
- * Portable CPU load measurement facility.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 2002 Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Functions to assist in measuring the CPU utilization of a callback
- stream. Used to implement the Pa_GetStreamCpuLoad() function.
-
- @todo Dynamically calculate the coefficients used to smooth the CPU Load
- Measurements over time to provide a uniform characterisation of CPU Load
- independent of rate at which PaUtil_BeginCpuLoadMeasurement /
- PaUtil_EndCpuLoadMeasurement are called. see http://www.portaudio.com/trac/ticket/113
-*/
-
-
-#include "pa_cpuload.h"
-
-#include <assert.h>
-
-#include "pa_util.h"   /* for PaUtil_GetTime() */
-
-
-void PaUtil_InitializeCpuLoadMeasurer( PaUtilCpuLoadMeasurer* measurer, double sampleRate )
-{
-    assert( sampleRate > 0 );
-
-    measurer->samplingPeriod = 1. / sampleRate;
-    measurer->averageLoad = 0.;
-}
-
-void PaUtil_ResetCpuLoadMeasurer( PaUtilCpuLoadMeasurer* measurer )
-{
-    measurer->averageLoad = 0.;
-}
-
-void PaUtil_BeginCpuLoadMeasurement( PaUtilCpuLoadMeasurer* measurer )
-{
-    measurer->measurementStartTime = PaUtil_GetTime();
-}
-
-
-void PaUtil_EndCpuLoadMeasurement( PaUtilCpuLoadMeasurer* measurer, unsigned long framesProcessed )
-{
-    double measurementEndTime, secondsFor100Percent, measuredLoad;
-
-    if( framesProcessed > 0 ){
-        measurementEndTime = PaUtil_GetTime();
-
-        assert( framesProcessed > 0 );
-        secondsFor100Percent = framesProcessed * measurer->samplingPeriod;
-
-        measuredLoad = (measurementEndTime - measurer->measurementStartTime) / secondsFor100Percent;
-
-        /* Low pass filter the calculated CPU load to reduce jitter using a simple IIR low pass filter. */
-        /** FIXME @todo these coefficients shouldn't be hardwired see: http://www.portaudio.com/trac/ticket/113 */
-#define LOWPASS_COEFFICIENT_0   (0.9)
-#define LOWPASS_COEFFICIENT_1   (0.99999 - LOWPASS_COEFFICIENT_0)
-
-        measurer->averageLoad = (LOWPASS_COEFFICIENT_0 * measurer->averageLoad) +
-                                (LOWPASS_COEFFICIENT_1 * measuredLoad);
-    }
-}
-
-
-double PaUtil_GetCpuLoad( PaUtilCpuLoadMeasurer* measurer )
-{
-    return measurer->averageLoad;
-}
diff --git a/portaudio/src/common/pa_cpuload.h b/portaudio/src/common/pa_cpuload.h
deleted file mode 100644
index 8d3f618..0000000
--- a/portaudio/src/common/pa_cpuload.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef PA_CPULOAD_H
-#define PA_CPULOAD_H
-/*
- * $Id$
- * Portable Audio I/O Library CPU Load measurement functions
- * Portable CPU load measurement facility.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 2002 Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Functions to assist in measuring the CPU utilization of a callback
- stream. Used to implement the Pa_GetStreamCpuLoad() function.
-*/
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-typedef struct {
-    double samplingPeriod;
-    double measurementStartTime;
-    double averageLoad;
-} PaUtilCpuLoadMeasurer; /**< @todo need better name than measurer */
-
-void PaUtil_InitializeCpuLoadMeasurer( PaUtilCpuLoadMeasurer* measurer, double sampleRate );
-void PaUtil_BeginCpuLoadMeasurement( PaUtilCpuLoadMeasurer* measurer );
-void PaUtil_EndCpuLoadMeasurement( PaUtilCpuLoadMeasurer* measurer, unsigned long framesProcessed );
-void PaUtil_ResetCpuLoadMeasurer( PaUtilCpuLoadMeasurer* measurer );
-double PaUtil_GetCpuLoad( PaUtilCpuLoadMeasurer* measurer );
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_CPULOAD_H */
diff --git a/portaudio/src/common/pa_debugprint.c b/portaudio/src/common/pa_debugprint.c
deleted file mode 100644
index 3e4024c..0000000
--- a/portaudio/src/common/pa_debugprint.c
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * $Id: pa_log.c $
- * Portable Audio I/O Library Multi-Host API front end
- * Validate function parameters and manage multiple host APIs.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2006 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Implements log function.
-
-    PaUtil_SetLogPrintFunction can be user called to replace the provided
-    DefaultLogPrint function, which writes to stderr.
-    One can NOT pass var_args across compiler/dll boundaries as it is not
-    "byte code/abi portable". So the technique used here is to allocate a local
-    a static array, write in it, then callback the user with a pointer to its
-    start.
-*/
-
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "pa_debugprint.h"
-
-// for OutputDebugStringA
-#if defined(_MSC_VER) && defined(PA_ENABLE_MSVC_DEBUG_OUTPUT)
-    #define WIN32_LEAN_AND_MEAN // exclude rare headers
-    #include "windows.h"
-#endif
-
-// User callback
-static PaUtilLogCallback userCB = NULL;
-
-// Sets user callback
-void PaUtil_SetDebugPrintFunction(PaUtilLogCallback cb)
-{
-    userCB = cb;
-}
-
-/*
- If your platform doesn't have vsnprintf, you are stuck with a
- VERY dangerous alternative, vsprintf (with no n)
-*/
-#if _MSC_VER
-    /* Some Windows Mobile SDKs don't define vsnprintf but all define _vsnprintf (hopefully).
-       According to MSDN "vsnprintf is identical to _vsnprintf". So we use _vsnprintf with MSC.
-    */
-    #define VSNPRINTF  _vsnprintf
-#else
-    #define VSNPRINTF  vsnprintf
-#endif
-
-#define PA_LOG_BUF_SIZE 2048
-
-void PaUtil_DebugPrint( const char *format, ... )
-{
-    // Optional logging into Output console of Visual Studio
-#if defined(_MSC_VER) && defined(PA_ENABLE_MSVC_DEBUG_OUTPUT)
-    {
-        char buf[PA_LOG_BUF_SIZE];
-        va_list ap;
-        va_start(ap, format);
-        VSNPRINTF(buf, sizeof(buf), format, ap);
-        buf[sizeof(buf)-1] = 0;
-        OutputDebugStringA(buf);
-        va_end(ap);
-    }
-#endif
-
-    // Output to User-Callback
-    if (userCB != NULL)
-    {
-        char strdump[PA_LOG_BUF_SIZE];
-        va_list ap;
-        va_start(ap, format);
-        VSNPRINTF(strdump, sizeof(strdump), format, ap);
-        strdump[sizeof(strdump)-1] = 0;
-        userCB(strdump);
-        va_end(ap);
-    }
-    else
-    // Standard output to stderr
-    {
-        va_list ap;
-        va_start(ap, format);
-        vfprintf(stderr, format, ap);
-        va_end(ap);
-        fflush(stderr);
-    }
-}
diff --git a/portaudio/src/common/pa_debugprint.h b/portaudio/src/common/pa_debugprint.h
deleted file mode 100644
index ca81724..0000000
--- a/portaudio/src/common/pa_debugprint.h
+++ /dev/null
@@ -1,149 +0,0 @@
-#ifndef PA_LOG_H
-#define PA_LOG_H
-/*
- * Log file redirector function
- * Copyright (c) 1999-2006 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-*/
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-
-void PaUtil_DebugPrint( const char *format, ... );
-
-
-/*
-    The basic format for log messages is described below. If you need to
-    add any log messages, please follow this format.
-
-    Function entry (void function):
-
-        "FunctionName called.\n"
-
-    Function entry (non void function):
-
-        "FunctionName called:\n"
-        "\tParam1Type param1: param1Value\n"
-        "\tParam2Type param2: param2Value\n"      (etc...)
-
-
-    Function exit (no return value):
-
-        "FunctionName returned.\n"
-
-    Function exit (simple return value):
-
-        "FunctionName returned:\n"
-        "\tReturnType: returnValue\n"
-
-    If the return type is an error code, the error text is displayed in ()
-
-    If the return type is not an error code, but has taken a special value
-    because an error occurred, then the reason for the error is shown in []
-
-    If the return type is a struct ptr, the struct is dumped.
-
-    See the code below for examples
-*/
-
-/** PA_DEBUG() provides a simple debug message printing facility. The macro
- passes it's argument to a printf-like function called PaUtil_DebugPrint()
- which prints to stderr and always flushes the stream after printing.
- Because preprocessor macros cannot directly accept variable length argument
- lists, calls to the macro must include an additional set of parenthesis, eg:
- PA_DEBUG(("errorno: %d", 1001 ));
-*/
-
-
-#ifdef PA_ENABLE_DEBUG_OUTPUT
-#define PA_DEBUG(x) PaUtil_DebugPrint x ;
-#else
-#define PA_DEBUG(x)
-#endif
-
-
-#ifdef PA_LOG_API_CALLS
-#define PA_LOGAPI(x) PaUtil_DebugPrint x
-
-#define PA_LOGAPI_ENTER(functionName) PaUtil_DebugPrint( functionName " called.\n" )
-
-#define PA_LOGAPI_ENTER_PARAMS(functionName) PaUtil_DebugPrint( functionName " called:\n" )
-
-#define PA_LOGAPI_EXIT(functionName) PaUtil_DebugPrint( functionName " returned.\n" )
-
-#define PA_LOGAPI_EXIT_PAERROR( functionName, result ) \
-    PaUtil_DebugPrint( functionName " returned:\n" ); \
-    PaUtil_DebugPrint("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) )
-
-#define PA_LOGAPI_EXIT_T( functionName, resultFormatString, result ) \
-    PaUtil_DebugPrint( functionName " returned:\n" ); \
-    PaUtil_DebugPrint("\t" resultFormatString "\n", result )
-
-#define PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( functionName, positiveResultFormatString, result ) \
-    PaUtil_DebugPrint( functionName " returned:\n" ); \
-    if( result > 0 ) \
-        PaUtil_DebugPrint("\t" positiveResultFormatString "\n", result ); \
-    else \
-        PaUtil_DebugPrint("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) )
-#else
-#define PA_LOGAPI(x)
-#define PA_LOGAPI_ENTER(functionName)
-#define PA_LOGAPI_ENTER_PARAMS(functionName)
-#define PA_LOGAPI_EXIT(functionName)
-#define PA_LOGAPI_EXIT_PAERROR( functionName, result )
-#define PA_LOGAPI_EXIT_T( functionName, resultFormatString, result )
-#define PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( functionName, positiveResultFormatString, result )
-#endif
-
-
-typedef void (*PaUtilLogCallback ) (const char *log);
-
-/**
-    Install user provided log function
-*/
-void PaUtil_SetDebugPrintFunction(PaUtilLogCallback  cb);
-
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_LOG_H */
diff --git a/portaudio/src/common/pa_dither.c b/portaudio/src/common/pa_dither.c
deleted file mode 100644
index 0d1666a..0000000
--- a/portaudio/src/common/pa_dither.c
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library triangular dither generator
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Functions for generating dither noise
-*/
-
-#include "pa_types.h"
-#include "pa_dither.h"
-
-
-/* Note that the linear congruential algorithm requires 32 bit integers
- * because it uses arithmetic overflow. So use PaUint32 instead of
- * unsigned long so it will work on 64 bit systems.
- */
-
-#define PA_DITHER_BITS_   (15)
-
-
-void PaUtil_InitializeTriangularDitherState( PaUtilTriangularDitherGenerator *state )
-{
-    state->previous = 0;
-    state->randSeed1 = 22222;
-    state->randSeed2 = 5555555;
-}
-
-
-PaInt32 PaUtil_Generate16BitTriangularDither( PaUtilTriangularDitherGenerator *state )
-{
-    PaInt32 current, highPass;
-
-    /* Generate two random numbers. */
-    state->randSeed1 = (state->randSeed1 * 196314165) + 907633515;
-    state->randSeed2 = (state->randSeed2 * 196314165) + 907633515;
-
-    /* Generate triangular distribution about 0.
-     * Shift before adding to prevent overflow which would skew the distribution.
-     * Also shift an extra bit for the high pass filter.
-     */
-#define DITHER_SHIFT_  ((sizeof(PaInt32)*8 - PA_DITHER_BITS_) + 1)
-
-    current = (((PaInt32)state->randSeed1)>>DITHER_SHIFT_) +
-              (((PaInt32)state->randSeed2)>>DITHER_SHIFT_);
-
-    /* High pass filter to reduce audibility. */
-    highPass = current - state->previous;
-    state->previous = current;
-    return highPass;
-}
-
-
-/* Multiply by PA_FLOAT_DITHER_SCALE_ to get a float between -2.0 and +1.99999 */
-#define PA_FLOAT_DITHER_SCALE_  (1.0f / ((1<<PA_DITHER_BITS_)-1))
-static const float const_float_dither_scale_ = PA_FLOAT_DITHER_SCALE_;
-
-float PaUtil_GenerateFloatTriangularDither( PaUtilTriangularDitherGenerator *state )
-{
-    PaInt32 current, highPass;
-
-    /* Generate two random numbers. */
-    state->randSeed1 = (state->randSeed1 * 196314165) + 907633515;
-    state->randSeed2 = (state->randSeed2 * 196314165) + 907633515;
-
-    /* Generate triangular distribution about 0.
-     * Shift before adding to prevent overflow which would skew the distribution.
-     * Also shift an extra bit for the high pass filter.
-     */
-    current = (((PaInt32)state->randSeed1)>>DITHER_SHIFT_) +
-              (((PaInt32)state->randSeed2)>>DITHER_SHIFT_);
-
-    /* High pass filter to reduce audibility. */
-    highPass = current - state->previous;
-    state->previous = current;
-    return ((float)highPass) * const_float_dither_scale_;
-}
-
-
-/*
-The following alternate dither algorithms (from musicdsp.org) could be
-considered
-*/
-
-/*Noise shaped dither  (March 2000)
--------------------
-
-This is a simple implementation of highpass triangular-PDF dither with
-2nd-order noise shaping, for use when truncating floating point audio
-data to fixed point.
-
-The noise shaping lowers the noise floor by 11dB below 5kHz (@ 44100Hz
-sample rate) compared to triangular-PDF dither. The code below assumes
-input data is in the range +1 to -1 and doesn't check for overloads!
-
-To save time when generating dither for multiple channels you can do
-things like this:  r3=(r1 & 0x7F)<<8; instead of calling rand() again.
-
-
-
-  int   r1, r2;                //rectangular-PDF random numbers
-  float s1, s2;                //error feedback buffers
-  float s = 0.5f;              //set to 0.0f for no noise shaping
-  float w = pow(2.0,bits-1);   //word length (usually bits=16)
-  float wi= 1.0f/w;
-  float d = wi / RAND_MAX;     //dither amplitude (2 lsb)
-  float o = wi * 0.5f;         //remove dc offset
-  float in, tmp;
-  int   out;
-
-
-//for each sample...
-
-  r2=r1;                               //can make HP-TRI dither by
-  r1=rand();                           //subtracting previous rand()
-
-  in += s * (s1 + s1 - s2);            //error feedback
-  tmp = in + o + d * (float)(r1 - r2); //dc offset and dither
-
-  out = (int)(w * tmp);                //truncate downwards
-  if(tmp<0.0f) out--;                  //this is faster than floor()
-
-  s2 = s1;
-  s1 = in - wi * (float)out;           //error
-
-
-
---
-paul.kellett@maxim.abel.co.uk
-http://www.maxim.abel.co.uk
-*/
-
-
-/*
-16-to-8-bit first-order dither
-
-Type : First order error feedforward dithering code
-References : Posted by Jon Watte
-
-Notes :
-This is about as simple a dithering algorithm as you can implement, but it's
-likely to sound better than just truncating to N bits.
-
-Note that you might not want to carry forward the full difference for infinity.
-It's probably likely that the worst performance hit comes from the saturation
-conditionals, which can be avoided with appropriate instructions on many DSPs
-and integer SIMD type instructions, or CMOV.
-
-Last, if sound quality is paramount (such as when going from > 16 bits to 16
-bits) you probably want to use a higher-order dither function found elsewhere
-on this site.
-
-
-Code :
-// This code will down-convert and dither a 16-bit signed short
-// mono signal into an 8-bit unsigned char signal, using a first
-// order forward-feeding error term dither.
-
-#define uchar unsigned char
-
-void dither_one_channel_16_to_8( short * input, uchar * output, int count, int * memory )
-{
-  int m = *memory;
-  while( count-- > 0 ) {
-    int i = *input++;
-    i += m;
-    int j = i + 32768 - 128;
-    uchar o;
-    if( j < 0 ) {
-      o = 0;
-    }
-    else if( j > 65535 ) {
-      o = 255;
-    }
-    else {
-      o = (uchar)((j>>8)&0xff);
-    }
-    m = ((j-32768+128)-i);
-    *output++ = o;
-  }
-  *memory = m;
-}
-*/
diff --git a/portaudio/src/common/pa_dither.h b/portaudio/src/common/pa_dither.h
deleted file mode 100644
index 4f81123..0000000
--- a/portaudio/src/common/pa_dither.h
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef PA_DITHER_H
-#define PA_DITHER_H
-/*
- * $Id$
- * Portable Audio I/O Library triangular dither generator
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Functions for generating dither noise
-*/
-
-#include "pa_types.h"
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-/* Note that the linear congruential algorithm requires 32 bit integers
- * because it uses arithmetic overflow. So use PaUint32 instead of
- * unsigned long so it will work on 64 bit systems.
- */
-
-/** @brief State needed to generate a dither signal */
-typedef struct PaUtilTriangularDitherGenerator{
-    PaUint32 previous;
-    PaUint32 randSeed1;
-    PaUint32 randSeed2;
-} PaUtilTriangularDitherGenerator;
-
-
-/** @brief Initialize dither state */
-void PaUtil_InitializeTriangularDitherState( PaUtilTriangularDitherGenerator *ditherState );
-
-
-/**
- @brief Calculate 2 LSB dither signal with a triangular distribution.
- Ranged for adding to a 1 bit right-shifted 32 bit integer
- prior to >>15. eg:
-<pre>
-    signed long in = *
-    signed long dither = PaUtil_Generate16BitTriangularDither( ditherState );
-    signed short out = (signed short)(((in>>1) + dither) >> 15);
-</pre>
- @return
- A signed 32-bit integer with a range of +32767 to -32768
-*/
-PaInt32 PaUtil_Generate16BitTriangularDither( PaUtilTriangularDitherGenerator *ditherState );
-
-
-/**
- @brief Calculate 2 LSB dither signal with a triangular distribution.
- Ranged for adding to a pre-scaled float.
-<pre>
-    float in = *
-    float dither = PaUtil_GenerateFloatTriangularDither( ditherState );
-    // use smaller scaler to prevent overflow when we add the dither
-    signed short out = (signed short)(in*(32766.0f) + dither );
-</pre>
- @return
- A float with a range of -2.0 to +1.99999.
-*/
-float PaUtil_GenerateFloatTriangularDither( PaUtilTriangularDitherGenerator *ditherState );
-
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_DITHER_H */
diff --git a/portaudio/src/common/pa_endianness.h b/portaudio/src/common/pa_endianness.h
deleted file mode 100644
index e074836..0000000
--- a/portaudio/src/common/pa_endianness.h
+++ /dev/null
@@ -1,145 +0,0 @@
-#ifndef PA_ENDIANNESS_H
-#define PA_ENDIANNESS_H
-/*
- * $Id$
- * Portable Audio I/O Library current platform endianness macros
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Configure endianness symbols for the target processor.
-
- Arrange for either the PA_LITTLE_ENDIAN or PA_BIG_ENDIAN preprocessor symbols
- to be defined. The one that is defined reflects the endianness of the target
- platform and may be used to implement conditional compilation of byte-order
- dependent code.
-
- If either PA_LITTLE_ENDIAN or PA_BIG_ENDIAN is defined already, then no attempt
- is made to override that setting. This may be useful if you have a better way
- of determining the platform's endianness. The autoconf mechanism uses this for
- example.
-
- A PA_VALIDATE_ENDIANNESS macro is provided to compare the compile time
- and runtime endianness and raise an assertion if they don't match.
-*/
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-/* If this is an apple, we need to do detect endianness this way */
-#if defined(__APPLE__)
-    /* we need to do some endian detection that is sensitive to hardware arch */
-    #if defined(__LITTLE_ENDIAN__)
-        #if !defined( PA_LITTLE_ENDIAN )
-            #define PA_LITTLE_ENDIAN
-        #endif
-        #if defined( PA_BIG_ENDIAN )
-            #undef PA_BIG_ENDIAN
-        #endif
-    #else
-        #if !defined( PA_BIG_ENDIAN )
-            #define PA_BIG_ENDIAN
-        #endif
-        #if defined( PA_LITTLE_ENDIAN )
-            #undef PA_LITTLE_ENDIAN
-        #endif
-    #endif
-#else
-    /* this is not an apple, so first check the existing defines, and, failing that,
-       detect well-known architectures. */
-
-    #if defined(PA_LITTLE_ENDIAN) || defined(PA_BIG_ENDIAN)
-        /* endianness define has been set externally, such as by autoconf */
-
-        #if defined(PA_LITTLE_ENDIAN) && defined(PA_BIG_ENDIAN)
-        #error both PA_LITTLE_ENDIAN and PA_BIG_ENDIAN have been defined externally to pa_endianness.h - only one endianness at a time please
-        #endif
-
-    #else
-        /* endianness define has not been set externally */
-
-        /* set PA_LITTLE_ENDIAN or PA_BIG_ENDIAN by testing well known platform specific defines */
-
-        #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(LITTLE_ENDIAN) || defined(__i386) || defined(_M_IX86) || defined(__x86_64__)
-            #define PA_LITTLE_ENDIAN /* win32, assume intel byte order */
-        #else
-            #define PA_BIG_ENDIAN
-        #endif
-    #endif
-
-    #if !defined(PA_LITTLE_ENDIAN) && !defined(PA_BIG_ENDIAN)
-        /*
-         If the following error is raised, you either need to modify the code above
-         to automatically determine the endianness from other symbols defined on your
-         platform, or define either PA_LITTLE_ENDIAN or PA_BIG_ENDIAN externally.
-        */
-        #error pa_endianness.h was unable to automatically determine the endianness of the target platform
-    #endif
-
-#endif
-
-
-/* PA_VALIDATE_ENDIANNESS compares the compile time and runtime endianness,
- and raises an assertion if they don't match. <assert.h> must be included in
- the context in which this macro is used.
-*/
-#if defined(NDEBUG)
-    #define PA_VALIDATE_ENDIANNESS
-#else
-    #if defined(PA_LITTLE_ENDIAN)
-        #define PA_VALIDATE_ENDIANNESS \
-        { \
-            const long nativeOne = 1; \
-            assert( "PortAudio: compile time and runtime endianness don't match" && (((char *)&nativeOne)[0]) == 1 ); \
-        }
-    #elif defined(PA_BIG_ENDIAN)
-        #define PA_VALIDATE_ENDIANNESS \
-        { \
-            const long nativeOne = 1; \
-            assert( "PortAudio: compile time and runtime endianness don't match" && (((char *)&nativeOne)[0]) == 0 ); \
-        }
-    #endif
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_ENDIANNESS_H */
diff --git a/portaudio/src/common/pa_front.c b/portaudio/src/common/pa_front.c
deleted file mode 100644
index 65a656f..0000000
--- a/portaudio/src/common/pa_front.c
+++ /dev/null
@@ -1,1810 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library Multi-Host API front end
- * Validate function parameters and manage multiple host APIs.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2008 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Implements PortAudio API functions defined in portaudio.h, checks
- some errors, delegates platform-specific behavior to host API implementations.
-
- Implements the functions defined in the PortAudio API (portaudio.h),
- validates some parameters and checks for state inconsistencies before
- forwarding API requests to specific Host API implementations (via the
- interface declared in pa_hostapi.h), and Streams (via the interface
- declared in pa_stream.h).
-
- This file manages initialization and termination of Host API
- implementations via initializer functions stored in the paHostApiInitializers
- global array (usually defined in an os-specific pa_[os]_hostapis.c file).
-
- This file maintains a list of all open streams and closes them at Pa_Terminate().
-
- Some utility functions declared in pa_util.h are implemented in this file.
-
- All PortAudio API functions can be conditionally compiled with logging code.
- To compile with logging, define the PA_LOG_API_CALLS precompiler symbol.
-*/
-
-
-#include <stdio.h>
-#include <memory.h>
-#include <string.h>
-#include <stdlib.h> /* needed for strtol() */
-#include <assert.h> /* needed by PA_VALIDATE_ENDIANNESS */
-
-#include "portaudio.h"
-#include "pa_util.h"
-#include "pa_endianness.h"
-#include "pa_types.h"
-#include "pa_hostapi.h"
-#include "pa_stream.h"
-#include "pa_trace.h" /* still useful?*/
-#include "pa_debugprint.h"
-
-#ifndef PA_GIT_REVISION
-#include "pa_gitrevision.h"
-#endif
-
-/**
- * This is incremented if we make incompatible API changes.
- * This version scheme is based loosely on http://semver.org/
- */
-#define paVersionMajor     19
-
-/**
- * This is incremented when we add functionality in a backwards-compatible manner.
- * Or it is set to zero when paVersionMajor is incremented.
- */
-#define paVersionMinor      7
-
-/**
- * This is incremented when we make backwards-compatible bug fixes.
- * Or it is set to zero when paVersionMinor changes.
- */
-#define paVersionSubMinor   0
-
-/**
- * This is a combination of paVersionMajor, paVersionMinor and paVersionSubMinor.
- * It will always increase so that version numbers can be compared as integers to
- * see which is later.
- */
-#define paVersion  paMakeVersionNumber(paVersionMajor, paVersionMinor, paVersionSubMinor)
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-
-#define PA_VERSION_STRING_ TOSTRING(paVersionMajor) "." TOSTRING(paVersionMinor) "." TOSTRING(paVersionSubMinor)
-#define PA_VERSION_TEXT_   "PortAudio V" PA_VERSION_STRING_ "-devel, revision " TOSTRING(PA_GIT_REVISION)
-
-int Pa_GetVersion( void )
-{
-    return paVersion;
-}
-
-const char* Pa_GetVersionText( void )
-{
-    return PA_VERSION_TEXT_;
-}
-
-static PaVersionInfo versionInfo_ = {
-    /*.versionMajor =*/ paVersionMajor,
-    /*.versionMinor =*/ paVersionMinor,
-    /*.versionSubMinor =*/ paVersionSubMinor,
-    /*.versionControlRevision =*/ TOSTRING(PA_GIT_REVISION),
-    /*.versionText =*/ PA_VERSION_TEXT_
-};
-
-const PaVersionInfo* Pa_GetVersionInfo( void )
-{
-    return &versionInfo_;
-}
-
-#define PA_LAST_HOST_ERROR_TEXT_LENGTH_  1024
-
-static char lastHostErrorText_[ PA_LAST_HOST_ERROR_TEXT_LENGTH_ + 1 ] = {0};
-
-static PaHostErrorInfo lastHostErrorInfo_ = { (PaHostApiTypeId)-1, 0, lastHostErrorText_ };
-
-
-void PaUtil_SetLastHostErrorInfo( PaHostApiTypeId hostApiType, long errorCode,
-        const char *errorText )
-{
-    lastHostErrorInfo_.hostApiType = hostApiType;
-    lastHostErrorInfo_.errorCode = errorCode;
-
-    strncpy( lastHostErrorText_, errorText, PA_LAST_HOST_ERROR_TEXT_LENGTH_ );
-}
-
-
-
-static PaUtilHostApiRepresentation **hostApis_ = 0;
-static int hostApisCount_ = 0;
-static int defaultHostApiIndex_ = 0;
-static int initializationCount_ = 0;
-static int deviceCount_ = 0;
-
-PaUtilStreamRepresentation *firstOpenStream_ = NULL;
-
-
-#define PA_IS_INITIALISED_ (initializationCount_ != 0)
-
-
-static int CountHostApiInitializers( void )
-{
-    int result = 0;
-
-    while( paHostApiInitializers[ result ] != 0 )
-        ++result;
-    return result;
-}
-
-
-static void TerminateHostApis( void )
-{
-    /* terminate in reverse order from initialization */
-    PA_DEBUG(("TerminateHostApis in \n"));
-
-    while( hostApisCount_ > 0 )
-    {
-        --hostApisCount_;
-        hostApis_[hostApisCount_]->Terminate( hostApis_[hostApisCount_] );
-    }
-    hostApisCount_ = 0;
-    defaultHostApiIndex_ = 0;
-    deviceCount_ = 0;
-
-    if( hostApis_ != 0 )
-        PaUtil_FreeMemory( hostApis_ );
-    hostApis_ = 0;
-
-    PA_DEBUG(("TerminateHostApis out\n"));
-}
-
-
-static PaError InitializeHostApis( void )
-{
-    PaError result = paNoError;
-    int i, initializerCount, baseDeviceIndex;
-
-    initializerCount = CountHostApiInitializers();
-
-    hostApis_ = (PaUtilHostApiRepresentation**)PaUtil_AllocateMemory(
-            sizeof(PaUtilHostApiRepresentation*) * initializerCount );
-    if( !hostApis_ )
-    {
-        result = paInsufficientMemory;
-        goto error;
-    }
-
-    hostApisCount_ = 0;
-    defaultHostApiIndex_ = -1; /* indicates that we haven't determined the default host API yet */
-    deviceCount_ = 0;
-    baseDeviceIndex = 0;
-
-    for( i=0; i< initializerCount; ++i )
-    {
-        hostApis_[hostApisCount_] = NULL;
-
-        PA_DEBUG(( "before paHostApiInitializers[%d].\n",i));
-
-        result = paHostApiInitializers[i]( &hostApis_[hostApisCount_], hostApisCount_ );
-        if( result != paNoError )
-            goto error;
-
-        PA_DEBUG(( "after paHostApiInitializers[%d].\n",i));
-
-        if( hostApis_[hostApisCount_] )
-        {
-            PaUtilHostApiRepresentation* hostApi = hostApis_[hostApisCount_];
-            assert( hostApi->info.defaultInputDevice < hostApi->info.deviceCount );
-            assert( hostApi->info.defaultOutputDevice < hostApi->info.deviceCount );
-
-            /* the first successfully initialized host API with a default input *or*
-               output device is used as the default host API.
-            */
-            if( (defaultHostApiIndex_ == -1) &&
-                    ( hostApi->info.defaultInputDevice != paNoDevice
-                        || hostApi->info.defaultOutputDevice != paNoDevice ) )
-            {
-                defaultHostApiIndex_ = hostApisCount_;
-            }
-
-            hostApi->privatePaFrontInfo.baseDeviceIndex = baseDeviceIndex;
-
-            if( hostApi->info.defaultInputDevice != paNoDevice )
-                hostApi->info.defaultInputDevice += baseDeviceIndex;
-
-            if( hostApi->info.defaultOutputDevice != paNoDevice )
-                hostApi->info.defaultOutputDevice += baseDeviceIndex;
-
-            baseDeviceIndex += hostApi->info.deviceCount;
-            deviceCount_ += hostApi->info.deviceCount;
-
-            ++hostApisCount_;
-        }
-    }
-
-    /* if no host APIs have devices, the default host API is the first initialized host API */
-    if( defaultHostApiIndex_ == -1 )
-        defaultHostApiIndex_ = 0;
-
-    return result;
-
-error:
-    TerminateHostApis();
-    return result;
-}
-
-
-/*
-    FindHostApi() finds the index of the host api to which
-    <device> belongs and returns it. if <hostSpecificDeviceIndex> is
-    non-null, the host specific device index is returned in it.
-    returns -1 if <device> is out of range.
-
-*/
-static int FindHostApi( PaDeviceIndex device, int *hostSpecificDeviceIndex )
-{
-    int i=0;
-
-    if( !PA_IS_INITIALISED_ )
-        return -1;
-
-    if( device < 0 )
-        return -1;
-
-    while( i < hostApisCount_
-            && device >= hostApis_[i]->info.deviceCount )
-    {
-
-        device -= hostApis_[i]->info.deviceCount;
-        ++i;
-    }
-
-    if( i >= hostApisCount_ )
-        return -1;
-
-    if( hostSpecificDeviceIndex )
-        *hostSpecificDeviceIndex = device;
-
-    return i;
-}
-
-
-static void AddOpenStream( PaStream* stream )
-{
-    ((PaUtilStreamRepresentation*)stream)->nextOpenStream = firstOpenStream_;
-    firstOpenStream_ = (PaUtilStreamRepresentation*)stream;
-}
-
-
-static void RemoveOpenStream( PaStream* stream )
-{
-    PaUtilStreamRepresentation *previous = NULL;
-    PaUtilStreamRepresentation *current = firstOpenStream_;
-
-    while( current != NULL )
-    {
-        if( ((PaStream*)current) == stream )
-        {
-            if( previous == NULL )
-            {
-                firstOpenStream_ = current->nextOpenStream;
-            }
-            else
-            {
-                previous->nextOpenStream = current->nextOpenStream;
-            }
-            return;
-        }
-        else
-        {
-            previous = current;
-            current = current->nextOpenStream;
-        }
-    }
-}
-
-
-static void CloseOpenStreams( void )
-{
-    /* we call Pa_CloseStream() here to ensure that the same destruction
-        logic is used for automatically closed streams */
-
-    while( firstOpenStream_ != NULL )
-        Pa_CloseStream( firstOpenStream_ );
-}
-
-
-PaError Pa_Initialize( void )
-{
-    PaError result;
-
-    PA_LOGAPI_ENTER( "Pa_Initialize" );
-
-    if( PA_IS_INITIALISED_ )
-    {
-        ++initializationCount_;
-        result = paNoError;
-    }
-    else
-    {
-        PA_VALIDATE_TYPE_SIZES;
-        PA_VALIDATE_ENDIANNESS;
-
-        PaUtil_InitializeClock();
-        PaUtil_ResetTraceMessages();
-
-        result = InitializeHostApis();
-        if( result == paNoError )
-            ++initializationCount_;
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_Initialize", result );
-
-    return result;
-}
-
-
-PaError Pa_Terminate( void )
-{
-    PaError result;
-
-    PA_LOGAPI_ENTER( "Pa_Terminate" );
-
-    if( PA_IS_INITIALISED_ )
-    {
-        // leave initializationCount_>0 so that Pa_CloseStream() can execute
-        if( initializationCount_ == 1 )
-        {
-            CloseOpenStreams();
-
-            TerminateHostApis();
-
-            PaUtil_DumpTraceMessages();
-        }
-        --initializationCount_;
-        result = paNoError;
-    }
-    else
-    {
-        result=  paNotInitialized;
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_Terminate", result );
-
-    return result;
-}
-
-
-const PaHostErrorInfo* Pa_GetLastHostErrorInfo( void )
-{
-    return &lastHostErrorInfo_;
-}
-
-
-const char *Pa_GetErrorText( PaError errorCode )
-{
-    const char *result;
-
-    switch( errorCode )
-    {
-    case paNoError:                  result = "Success"; break;
-    case paNotInitialized:           result = "PortAudio not initialized"; break;
-    /** @todo could catenate the last host error text to result in the case of paUnanticipatedHostError. see: http://www.portaudio.com/trac/ticket/114 */
-    case paUnanticipatedHostError:   result = "Unanticipated host error"; break;
-    case paInvalidChannelCount:      result = "Invalid number of channels"; break;
-    case paInvalidSampleRate:        result = "Invalid sample rate"; break;
-    case paInvalidDevice:            result = "Invalid device"; break;
-    case paInvalidFlag:              result = "Invalid flag"; break;
-    case paSampleFormatNotSupported: result = "Sample format not supported"; break;
-    case paBadIODeviceCombination:   result = "Illegal combination of I/O devices"; break;
-    case paInsufficientMemory:       result = "Insufficient memory"; break;
-    case paBufferTooBig:             result = "Buffer too big"; break;
-    case paBufferTooSmall:           result = "Buffer too small"; break;
-    case paNullCallback:             result = "No callback routine specified"; break;
-    case paBadStreamPtr:             result = "Invalid stream pointer"; break;
-    case paTimedOut:                 result = "Wait timed out"; break;
-    case paInternalError:            result = "Internal PortAudio error"; break;
-    case paDeviceUnavailable:        result = "Device unavailable"; break;
-    case paIncompatibleHostApiSpecificStreamInfo:   result = "Incompatible host API specific stream info"; break;
-    case paStreamIsStopped:          result = "Stream is stopped"; break;
-    case paStreamIsNotStopped:       result = "Stream is not stopped"; break;
-    case paInputOverflowed:          result = "Input overflowed"; break;
-    case paOutputUnderflowed:        result = "Output underflowed"; break;
-    case paHostApiNotFound:          result = "Host API not found"; break;
-    case paInvalidHostApi:           result = "Invalid host API"; break;
-    case paCanNotReadFromACallbackStream:       result = "Can't read from a callback stream"; break;
-    case paCanNotWriteToACallbackStream:        result = "Can't write to a callback stream"; break;
-    case paCanNotReadFromAnOutputOnlyStream:    result = "Can't read from an output only stream"; break;
-    case paCanNotWriteToAnInputOnlyStream:      result = "Can't write to an input only stream"; break;
-    case paIncompatibleStreamHostApi: result = "Incompatible stream host API"; break;
-    case paBadBufferPtr:             result = "Bad buffer pointer"; break;
-    default:
-        if( errorCode > 0 )
-            result = "Invalid error code (value greater than zero)";
-        else
-            result = "Invalid error code";
-        break;
-    }
-    return result;
-}
-
-
-PaHostApiIndex Pa_HostApiTypeIdToHostApiIndex( PaHostApiTypeId type )
-{
-    PaHostApiIndex result;
-    int i;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_HostApiTypeIdToHostApiIndex" );
-    PA_LOGAPI(("\tPaHostApiTypeId type: %d\n", type ));
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-    }
-    else
-    {
-        result = paHostApiNotFound;
-
-        for( i=0; i < hostApisCount_; ++i )
-        {
-            if( hostApis_[i]->info.type == type )
-            {
-                result = i;
-                break;
-            }
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_HostApiTypeIdToHostApiIndex", "PaHostApiIndex: %d", result );
-
-    return result;
-}
-
-
-PaError PaUtil_GetHostApiRepresentation( struct PaUtilHostApiRepresentation **hostApi,
-        PaHostApiTypeId type )
-{
-    PaError result;
-    int i;
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-    }
-    else
-    {
-        result = paHostApiNotFound;
-
-        for( i=0; i < hostApisCount_; ++i )
-        {
-            if( hostApis_[i]->info.type == type )
-            {
-                *hostApi = hostApis_[i];
-                result = paNoError;
-                break;
-            }
-        }
-    }
-
-    return result;
-}
-
-
-PaError PaUtil_DeviceIndexToHostApiDeviceIndex(
-        PaDeviceIndex *hostApiDevice, PaDeviceIndex device, struct PaUtilHostApiRepresentation *hostApi )
-{
-    PaError result;
-    PaDeviceIndex x;
-
-    x = device - hostApi->privatePaFrontInfo.baseDeviceIndex;
-
-    if( x < 0 || x >= hostApi->info.deviceCount )
-    {
-        result = paInvalidDevice;
-    }
-    else
-    {
-        *hostApiDevice = x;
-        result = paNoError;
-    }
-
-    return result;
-}
-
-
-PaHostApiIndex Pa_GetHostApiCount( void )
-{
-    int result;
-
-    PA_LOGAPI_ENTER( "Pa_GetHostApiCount" );
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-    }
-    else
-    {
-        result = hostApisCount_;
-    }
-
-    PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_GetHostApiCount", "PaHostApiIndex: %d", result );
-
-    return result;
-}
-
-
-PaHostApiIndex Pa_GetDefaultHostApi( void )
-{
-    int result;
-
-    PA_LOGAPI_ENTER( "Pa_GetDefaultHostApi" );
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-    }
-    else
-    {
-        result = defaultHostApiIndex_;
-
-        /* internal consistency check: make sure that the default host api
-         index is within range */
-
-        if( result < 0 || result >= hostApisCount_ )
-        {
-            result = paInternalError;
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_GetDefaultHostApi", "PaHostApiIndex: %d", result );
-
-    return result;
-}
-
-
-const PaHostApiInfo* Pa_GetHostApiInfo( PaHostApiIndex hostApi )
-{
-    PaHostApiInfo *info;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetHostApiInfo" );
-    PA_LOGAPI(("\tPaHostApiIndex hostApi: %d\n", hostApi ));
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        info = NULL;
-
-        PA_LOGAPI(("Pa_GetHostApiInfo returned:\n" ));
-        PA_LOGAPI(("\tPaHostApiInfo*: NULL [ PortAudio not initialized ]\n" ));
-
-    }
-    else if( hostApi < 0 || hostApi >= hostApisCount_ )
-    {
-        info = NULL;
-
-        PA_LOGAPI(("Pa_GetHostApiInfo returned:\n" ));
-        PA_LOGAPI(("\tPaHostApiInfo*: NULL [ hostApi out of range ]\n" ));
-
-    }
-    else
-    {
-        info = &hostApis_[hostApi]->info;
-
-        PA_LOGAPI(("Pa_GetHostApiInfo returned:\n" ));
-        PA_LOGAPI(("\tPaHostApiInfo*: 0x%p\n", info ));
-        PA_LOGAPI(("\t{\n" ));
-        PA_LOGAPI(("\t\tint structVersion: %d\n", info->structVersion ));
-        PA_LOGAPI(("\t\tPaHostApiTypeId type: %d\n", info->type ));
-        PA_LOGAPI(("\t\tconst char *name: %s\n", info->name ));
-        PA_LOGAPI(("\t}\n" ));
-
-    }
-
-    return info;
-}
-
-
-PaDeviceIndex Pa_HostApiDeviceIndexToDeviceIndex( PaHostApiIndex hostApi, int hostApiDeviceIndex )
-{
-    PaDeviceIndex result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_HostApiDeviceIndexToPaDeviceIndex" );
-    PA_LOGAPI(("\tPaHostApiIndex hostApi: %d\n", hostApi ));
-    PA_LOGAPI(("\tint hostApiDeviceIndex: %d\n", hostApiDeviceIndex ));
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-    }
-    else
-    {
-        if( hostApi < 0 || hostApi >= hostApisCount_ )
-        {
-            result = paInvalidHostApi;
-        }
-        else
-        {
-            if( hostApiDeviceIndex < 0 ||
-                    hostApiDeviceIndex >= hostApis_[hostApi]->info.deviceCount )
-            {
-                result = paInvalidDevice;
-            }
-            else
-            {
-                result = hostApis_[hostApi]->privatePaFrontInfo.baseDeviceIndex + hostApiDeviceIndex;
-            }
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_HostApiDeviceIndexToPaDeviceIndex", "PaDeviceIndex: %d", result );
-
-    return result;
-}
-
-
-PaDeviceIndex Pa_GetDeviceCount( void )
-{
-    PaDeviceIndex result;
-
-    PA_LOGAPI_ENTER( "Pa_GetDeviceCount" );
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-    }
-    else
-    {
-        result = deviceCount_;
-    }
-
-    PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_GetDeviceCount", "PaDeviceIndex: %d", result );
-
-    return result;
-}
-
-
-PaDeviceIndex Pa_GetDefaultInputDevice( void )
-{
-    PaHostApiIndex hostApi;
-    PaDeviceIndex result;
-
-    PA_LOGAPI_ENTER( "Pa_GetDefaultInputDevice" );
-
-    hostApi = Pa_GetDefaultHostApi();
-    if( hostApi < 0 )
-    {
-        result = paNoDevice;
-    }
-    else
-    {
-        result = hostApis_[hostApi]->info.defaultInputDevice;
-    }
-
-    PA_LOGAPI_EXIT_T( "Pa_GetDefaultInputDevice", "PaDeviceIndex: %d", result );
-
-    return result;
-}
-
-
-PaDeviceIndex Pa_GetDefaultOutputDevice( void )
-{
-    PaHostApiIndex hostApi;
-    PaDeviceIndex result;
-
-    PA_LOGAPI_ENTER( "Pa_GetDefaultOutputDevice" );
-
-    hostApi = Pa_GetDefaultHostApi();
-    if( hostApi < 0 )
-    {
-        result = paNoDevice;
-    }
-    else
-    {
-        result = hostApis_[hostApi]->info.defaultOutputDevice;
-    }
-
-    PA_LOGAPI_EXIT_T( "Pa_GetDefaultOutputDevice", "PaDeviceIndex: %d", result );
-
-    return result;
-}
-
-
-const PaDeviceInfo* Pa_GetDeviceInfo( PaDeviceIndex device )
-{
-    int hostSpecificDeviceIndex;
-    int hostApiIndex = FindHostApi( device, &hostSpecificDeviceIndex );
-    PaDeviceInfo *result;
-
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetDeviceInfo" );
-    PA_LOGAPI(("\tPaDeviceIndex device: %d\n", device ));
-
-    if( hostApiIndex < 0 )
-    {
-        result = NULL;
-
-        PA_LOGAPI(("Pa_GetDeviceInfo returned:\n" ));
-        PA_LOGAPI(("\tPaDeviceInfo* NULL [ invalid device index ]\n" ));
-
-    }
-    else
-    {
-        result = hostApis_[hostApiIndex]->deviceInfos[ hostSpecificDeviceIndex ];
-
-        PA_LOGAPI(("Pa_GetDeviceInfo returned:\n" ));
-        PA_LOGAPI(("\tPaDeviceInfo*: 0x%p:\n", result ));
-        PA_LOGAPI(("\t{\n" ));
-
-        PA_LOGAPI(("\t\tint structVersion: %d\n", result->structVersion ));
-        PA_LOGAPI(("\t\tconst char *name: %s\n", result->name ));
-        PA_LOGAPI(("\t\tPaHostApiIndex hostApi: %d\n", result->hostApi ));
-        PA_LOGAPI(("\t\tint maxInputChannels: %d\n", result->maxInputChannels ));
-        PA_LOGAPI(("\t\tint maxOutputChannels: %d\n", result->maxOutputChannels ));
-        PA_LOGAPI(("\t}\n" ));
-
-    }
-
-    return result;
-}
-
-
-/*
-    SampleFormatIsValid() returns 1 if sampleFormat is a sample format
-    defined in portaudio.h, or 0 otherwise.
-*/
-static int SampleFormatIsValid( PaSampleFormat format )
-{
-    switch( format & ~paNonInterleaved )
-    {
-    case paFloat32: return 1;
-    case paInt16: return 1;
-    case paInt32: return 1;
-    case paInt24: return 1;
-    case paInt8: return 1;
-    case paUInt8: return 1;
-    case paCustomFormat: return 1;
-    default: return 0;
-    }
-}
-
-/*
-    NOTE: make sure this validation list is kept synchronised with the one in
-            pa_hostapi.h
-
-    ValidateOpenStreamParameters() checks that parameters to Pa_OpenStream()
-    conform to the expected values as described below. This function is
-    also designed to be used with the proposed Pa_IsFormatSupported() function.
-
-    There are basically two types of validation that could be performed:
-    Generic conformance validation, and device capability mismatch
-    validation. This function performs only generic conformance validation.
-    Validation that would require knowledge of device capabilities is
-    not performed because of potentially complex relationships between
-    combinations of parameters - for example, even if the sampleRate
-    seems ok, it might not be for a duplex stream - we have no way of
-    checking this in an API-neutral way, so we don't try.
-
-    On success the function returns PaNoError and fills in hostApi,
-    hostApiInputDeviceID, and hostApiOutputDeviceID fields. On failure
-    the function returns an error code indicating the first encountered
-    parameter error.
-
-
-    If ValidateOpenStreamParameters() returns paNoError, the following
-    assertions are guaranteed to be true.
-
-    - at least one of inputParameters & outputParmeters is valid (not NULL)
-
-    - if inputParameters & outputParameters are both valid, that
-        inputParameters->device & outputParameters->device  both use the same host api
-
-    PaDeviceIndex inputParameters->device
-        - is within range (0 to Pa_GetDeviceCount-1) Or:
-        - is paUseHostApiSpecificDeviceSpecification and
-            inputParameters->hostApiSpecificStreamInfo is non-NULL and refers
-            to a valid host api
-
-    int inputParameters->channelCount
-        - if inputParameters->device is not paUseHostApiSpecificDeviceSpecification, channelCount is > 0
-        - upper bound is NOT validated against device capabilities
-
-    PaSampleFormat inputParameters->sampleFormat
-        - is one of the sample formats defined in portaudio.h
-
-    void *inputParameters->hostApiSpecificStreamInfo
-        - if supplied its hostApi field matches the input device's host Api
-
-    PaDeviceIndex outputParmeters->device
-        - is within range (0 to Pa_GetDeviceCount-1)
-
-    int outputParmeters->channelCount
-        - if inputDevice is valid, channelCount is > 0
-        - upper bound is NOT validated against device capabilities
-
-    PaSampleFormat outputParmeters->sampleFormat
-        - is one of the sample formats defined in portaudio.h
-
-    void *outputParmeters->hostApiSpecificStreamInfo
-        - if supplied its hostApi field matches the output device's host Api
-
-    double sampleRate
-        - is not an 'absurd' rate (less than 1000. or greater than 384000.)
-        - sampleRate is NOT validated against device capabilities
-
-    PaStreamFlags streamFlags
-        - unused platform neutral flags are zero
-        - paNeverDropInput is only used for full-duplex callback streams with
-            variable buffer size (paFramesPerBufferUnspecified)
-*/
-static PaError ValidateOpenStreamParameters(
-    const PaStreamParameters *inputParameters,
-    const PaStreamParameters *outputParameters,
-    double sampleRate,
-    unsigned long framesPerBuffer,
-    PaStreamFlags streamFlags,
-    PaStreamCallback *streamCallback,
-    PaUtilHostApiRepresentation **hostApi,
-    PaDeviceIndex *hostApiInputDevice,
-    PaDeviceIndex *hostApiOutputDevice )
-{
-    int inputHostApiIndex  = -1;    /* Suppress uninitialised var warnings: compiler does */
-    int outputHostApiIndex = -1;    /* not see that if inputParameters and outputParameters  */
-                                    /* are both nonzero, these indices are set. */
-
-    if( (inputParameters == NULL) && (outputParameters == NULL) )
-    {
-        return paInvalidDevice; /** @todo should be a new error code "invalid device parameters" or something */
-    }
-    else
-    {
-        if( inputParameters == NULL )
-        {
-            *hostApiInputDevice = paNoDevice;
-        }
-        else if( inputParameters->device == paUseHostApiSpecificDeviceSpecification )
-        {
-            if( inputParameters->hostApiSpecificStreamInfo )
-            {
-                inputHostApiIndex = Pa_HostApiTypeIdToHostApiIndex(
-                        ((PaUtilHostApiSpecificStreamInfoHeader*)inputParameters->hostApiSpecificStreamInfo)->hostApiType );
-
-                if( inputHostApiIndex != -1 )
-                {
-                    *hostApiInputDevice = paUseHostApiSpecificDeviceSpecification;
-                    *hostApi = hostApis_[inputHostApiIndex];
-                }
-                else
-                {
-                    return paInvalidDevice;
-                }
-            }
-            else
-            {
-                return paInvalidDevice;
-            }
-        }
-        else
-        {
-            if( inputParameters->device < 0 || inputParameters->device >= deviceCount_ )
-                return paInvalidDevice;
-
-            inputHostApiIndex = FindHostApi( inputParameters->device, hostApiInputDevice );
-            if( inputHostApiIndex < 0 )
-                return paInternalError;
-
-            *hostApi = hostApis_[inputHostApiIndex];
-
-            if( inputParameters->channelCount <= 0 )
-                return paInvalidChannelCount;
-
-            if( !SampleFormatIsValid( inputParameters->sampleFormat ) )
-                return paSampleFormatNotSupported;
-
-            if( inputParameters->hostApiSpecificStreamInfo != NULL )
-            {
-                if( ((PaUtilHostApiSpecificStreamInfoHeader*)inputParameters->hostApiSpecificStreamInfo)->hostApiType
-                        != (*hostApi)->info.type )
-                    return paIncompatibleHostApiSpecificStreamInfo;
-            }
-        }
-
-        if( outputParameters == NULL )
-        {
-            *hostApiOutputDevice = paNoDevice;
-        }
-        else if( outputParameters->device == paUseHostApiSpecificDeviceSpecification  )
-        {
-            if( outputParameters->hostApiSpecificStreamInfo )
-            {
-                outputHostApiIndex = Pa_HostApiTypeIdToHostApiIndex(
-                        ((PaUtilHostApiSpecificStreamInfoHeader*)outputParameters->hostApiSpecificStreamInfo)->hostApiType );
-
-                if( outputHostApiIndex != -1 )
-                {
-                    *hostApiOutputDevice = paUseHostApiSpecificDeviceSpecification;
-                    *hostApi = hostApis_[outputHostApiIndex];
-                }
-                else
-                {
-                    return paInvalidDevice;
-                }
-            }
-            else
-            {
-                return paInvalidDevice;
-            }
-        }
-        else
-        {
-            if( outputParameters->device < 0 || outputParameters->device >= deviceCount_ )
-                return paInvalidDevice;
-
-            outputHostApiIndex = FindHostApi( outputParameters->device, hostApiOutputDevice );
-            if( outputHostApiIndex < 0 )
-                return paInternalError;
-
-            *hostApi = hostApis_[outputHostApiIndex];
-
-            if( outputParameters->channelCount <= 0 )
-                return paInvalidChannelCount;
-
-            if( !SampleFormatIsValid( outputParameters->sampleFormat ) )
-                return paSampleFormatNotSupported;
-
-            if( outputParameters->hostApiSpecificStreamInfo != NULL )
-            {
-                if( ((PaUtilHostApiSpecificStreamInfoHeader*)outputParameters->hostApiSpecificStreamInfo)->hostApiType
-                        != (*hostApi)->info.type )
-                    return paIncompatibleHostApiSpecificStreamInfo;
-            }
-        }
-
-        if( (inputParameters != NULL) && (outputParameters != NULL) )
-        {
-            /* ensure that both devices use the same API */
-            if( inputHostApiIndex != outputHostApiIndex )
-                return paBadIODeviceCombination;
-        }
-    }
-
-
-    /* Check for absurd sample rates. */
-    if( (sampleRate < 1000.0) || (sampleRate > 384000.0) )
-        return paInvalidSampleRate;
-
-    if( ((streamFlags & ~paPlatformSpecificFlags) & ~(paClipOff | paDitherOff | paNeverDropInput | paPrimeOutputBuffersUsingStreamCallback ) ) != 0 )
-        return paInvalidFlag;
-
-    if( streamFlags & paNeverDropInput )
-    {
-        /* must be a callback stream */
-        if( !streamCallback )
-            return paInvalidFlag;
-
-        /* must be a full duplex stream */
-        if( (inputParameters == NULL) || (outputParameters == NULL) )
-            return paInvalidFlag;
-
-        /* must use paFramesPerBufferUnspecified */
-        if( framesPerBuffer != paFramesPerBufferUnspecified )
-            return paInvalidFlag;
-    }
-
-    return paNoError;
-}
-
-
-PaError Pa_IsFormatSupported( const PaStreamParameters *inputParameters,
-                              const PaStreamParameters *outputParameters,
-                              double sampleRate )
-{
-    PaError result;
-    PaUtilHostApiRepresentation *hostApi = 0;
-    PaDeviceIndex hostApiInputDevice = paNoDevice, hostApiOutputDevice = paNoDevice;
-    PaStreamParameters hostApiInputParameters, hostApiOutputParameters;
-    PaStreamParameters *hostApiInputParametersPtr, *hostApiOutputParametersPtr;
-
-
-#ifdef PA_LOG_API_CALLS
-    PA_LOGAPI_ENTER_PARAMS( "Pa_IsFormatSupported" );
-
-    if( inputParameters == NULL ){
-        PA_LOGAPI(("\tPaStreamParameters *inputParameters: NULL\n" ));
-    }else{
-        PA_LOGAPI(("\tPaStreamParameters *inputParameters: 0x%p\n", inputParameters ));
-        PA_LOGAPI(("\tPaDeviceIndex inputParameters->device: %d\n", inputParameters->device ));
-        PA_LOGAPI(("\tint inputParameters->channelCount: %d\n", inputParameters->channelCount ));
-        PA_LOGAPI(("\tPaSampleFormat inputParameters->sampleFormat: %d\n", inputParameters->sampleFormat ));
-        PA_LOGAPI(("\tPaTime inputParameters->suggestedLatency: %f\n", inputParameters->suggestedLatency ));
-        PA_LOGAPI(("\tvoid *inputParameters->hostApiSpecificStreamInfo: 0x%p\n", inputParameters->hostApiSpecificStreamInfo ));
-    }
-
-    if( outputParameters == NULL ){
-        PA_LOGAPI(("\tPaStreamParameters *outputParameters: NULL\n" ));
-    }else{
-        PA_LOGAPI(("\tPaStreamParameters *outputParameters: 0x%p\n", outputParameters ));
-        PA_LOGAPI(("\tPaDeviceIndex outputParameters->device: %d\n", outputParameters->device ));
-        PA_LOGAPI(("\tint outputParameters->channelCount: %d\n", outputParameters->channelCount ));
-        PA_LOGAPI(("\tPaSampleFormat outputParameters->sampleFormat: %d\n", outputParameters->sampleFormat ));
-        PA_LOGAPI(("\tPaTime outputParameters->suggestedLatency: %f\n", outputParameters->suggestedLatency ));
-        PA_LOGAPI(("\tvoid *outputParameters->hostApiSpecificStreamInfo: 0x%p\n", outputParameters->hostApiSpecificStreamInfo ));
-    }
-
-    PA_LOGAPI(("\tdouble sampleRate: %g\n", sampleRate ));
-#endif
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-
-        PA_LOGAPI_EXIT_PAERROR( "Pa_IsFormatSupported", result );
-        return result;
-    }
-
-    result = ValidateOpenStreamParameters( inputParameters,
-                                           outputParameters,
-                                           sampleRate, 0, paNoFlag, 0,
-                                           &hostApi,
-                                           &hostApiInputDevice,
-                                           &hostApiOutputDevice );
-    if( result != paNoError )
-    {
-        PA_LOGAPI_EXIT_PAERROR( "Pa_IsFormatSupported", result );
-        return result;
-    }
-
-
-    if( inputParameters )
-    {
-        hostApiInputParameters.device = hostApiInputDevice;
-        hostApiInputParameters.channelCount = inputParameters->channelCount;
-        hostApiInputParameters.sampleFormat = inputParameters->sampleFormat;
-        hostApiInputParameters.suggestedLatency = inputParameters->suggestedLatency;
-        hostApiInputParameters.hostApiSpecificStreamInfo = inputParameters->hostApiSpecificStreamInfo;
-        hostApiInputParametersPtr = &hostApiInputParameters;
-    }
-    else
-    {
-        hostApiInputParametersPtr = NULL;
-    }
-
-    if( outputParameters )
-    {
-        hostApiOutputParameters.device = hostApiOutputDevice;
-        hostApiOutputParameters.channelCount = outputParameters->channelCount;
-        hostApiOutputParameters.sampleFormat = outputParameters->sampleFormat;
-        hostApiOutputParameters.suggestedLatency = outputParameters->suggestedLatency;
-        hostApiOutputParameters.hostApiSpecificStreamInfo = outputParameters->hostApiSpecificStreamInfo;
-        hostApiOutputParametersPtr = &hostApiOutputParameters;
-    }
-    else
-    {
-        hostApiOutputParametersPtr = NULL;
-    }
-
-    result = hostApi->IsFormatSupported( hostApi,
-                                  hostApiInputParametersPtr, hostApiOutputParametersPtr,
-                                  sampleRate );
-
-#ifdef PA_LOG_API_CALLS
-    PA_LOGAPI(("Pa_OpenStream returned:\n" ));
-    if( result == paFormatIsSupported )
-        PA_LOGAPI(("\tPaError: 0 [ paFormatIsSupported ]\n" ));
-    else
-        PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-#endif
-
-    return result;
-}
-
-
-PaError Pa_OpenStream( PaStream** stream,
-                       const PaStreamParameters *inputParameters,
-                       const PaStreamParameters *outputParameters,
-                       double sampleRate,
-                       unsigned long framesPerBuffer,
-                       PaStreamFlags streamFlags,
-                       PaStreamCallback *streamCallback,
-                       void *userData )
-{
-    PaError result;
-    PaUtilHostApiRepresentation *hostApi = 0;
-    PaDeviceIndex hostApiInputDevice = paNoDevice, hostApiOutputDevice = paNoDevice;
-    PaStreamParameters hostApiInputParameters, hostApiOutputParameters;
-    PaStreamParameters *hostApiInputParametersPtr, *hostApiOutputParametersPtr;
-
-
-#ifdef PA_LOG_API_CALLS
-    PA_LOGAPI_ENTER_PARAMS( "Pa_OpenStream" );
-    PA_LOGAPI(("\tPaStream** stream: 0x%p\n", stream ));
-
-    if( inputParameters == NULL ){
-        PA_LOGAPI(("\tPaStreamParameters *inputParameters: NULL\n" ));
-    }else{
-        PA_LOGAPI(("\tPaStreamParameters *inputParameters: 0x%p\n", inputParameters ));
-        PA_LOGAPI(("\tPaDeviceIndex inputParameters->device: %d\n", inputParameters->device ));
-        PA_LOGAPI(("\tint inputParameters->channelCount: %d\n", inputParameters->channelCount ));
-        PA_LOGAPI(("\tPaSampleFormat inputParameters->sampleFormat: %d\n", inputParameters->sampleFormat ));
-        PA_LOGAPI(("\tPaTime inputParameters->suggestedLatency: %f\n", inputParameters->suggestedLatency ));
-        PA_LOGAPI(("\tvoid *inputParameters->hostApiSpecificStreamInfo: 0x%p\n", inputParameters->hostApiSpecificStreamInfo ));
-    }
-
-    if( outputParameters == NULL ){
-        PA_LOGAPI(("\tPaStreamParameters *outputParameters: NULL\n" ));
-    }else{
-        PA_LOGAPI(("\tPaStreamParameters *outputParameters: 0x%p\n", outputParameters ));
-        PA_LOGAPI(("\tPaDeviceIndex outputParameters->device: %d\n", outputParameters->device ));
-        PA_LOGAPI(("\tint outputParameters->channelCount: %d\n", outputParameters->channelCount ));
-        PA_LOGAPI(("\tPaSampleFormat outputParameters->sampleFormat: %d\n", outputParameters->sampleFormat ));
-        PA_LOGAPI(("\tPaTime outputParameters->suggestedLatency: %f\n", outputParameters->suggestedLatency ));
-        PA_LOGAPI(("\tvoid *outputParameters->hostApiSpecificStreamInfo: 0x%p\n", outputParameters->hostApiSpecificStreamInfo ));
-    }
-
-    PA_LOGAPI(("\tdouble sampleRate: %g\n", sampleRate ));
-    PA_LOGAPI(("\tunsigned long framesPerBuffer: %d\n", framesPerBuffer ));
-    PA_LOGAPI(("\tPaStreamFlags streamFlags: 0x%x\n", streamFlags ));
-    PA_LOGAPI(("\tPaStreamCallback *streamCallback: 0x%p\n", streamCallback ));
-    PA_LOGAPI(("\tvoid *userData: 0x%p\n", userData ));
-#endif
-
-    if( !PA_IS_INITIALISED_ )
-    {
-        result = paNotInitialized;
-
-        PA_LOGAPI(("Pa_OpenStream returned:\n" ));
-        PA_LOGAPI(("\t*(PaStream** stream): undefined\n" ));
-        PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-        return result;
-    }
-
-    /* Check for parameter errors.
-        NOTE: make sure this validation list is kept synchronised with the one
-        in pa_hostapi.h
-    */
-
-    if( stream == NULL )
-    {
-        result = paBadStreamPtr;
-
-        PA_LOGAPI(("Pa_OpenStream returned:\n" ));
-        PA_LOGAPI(("\t*(PaStream** stream): undefined\n" ));
-        PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-        return result;
-    }
-
-    result = ValidateOpenStreamParameters( inputParameters,
-                                           outputParameters,
-                                           sampleRate, framesPerBuffer,
-                                           streamFlags, streamCallback,
-                                           &hostApi,
-                                           &hostApiInputDevice,
-                                           &hostApiOutputDevice );
-    if( result != paNoError )
-    {
-        PA_LOGAPI(("Pa_OpenStream returned:\n" ));
-        PA_LOGAPI(("\t*(PaStream** stream): undefined\n" ));
-        PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-        return result;
-    }
-
-
-    if( inputParameters )
-    {
-        hostApiInputParameters.device = hostApiInputDevice;
-        hostApiInputParameters.channelCount = inputParameters->channelCount;
-        hostApiInputParameters.sampleFormat = inputParameters->sampleFormat;
-        hostApiInputParameters.suggestedLatency = inputParameters->suggestedLatency;
-        hostApiInputParameters.hostApiSpecificStreamInfo = inputParameters->hostApiSpecificStreamInfo;
-        hostApiInputParametersPtr = &hostApiInputParameters;
-    }
-    else
-    {
-        hostApiInputParametersPtr = NULL;
-    }
-
-    if( outputParameters )
-    {
-        hostApiOutputParameters.device = hostApiOutputDevice;
-        hostApiOutputParameters.channelCount = outputParameters->channelCount;
-        hostApiOutputParameters.sampleFormat = outputParameters->sampleFormat;
-        hostApiOutputParameters.suggestedLatency = outputParameters->suggestedLatency;
-        hostApiOutputParameters.hostApiSpecificStreamInfo = outputParameters->hostApiSpecificStreamInfo;
-        hostApiOutputParametersPtr = &hostApiOutputParameters;
-    }
-    else
-    {
-        hostApiOutputParametersPtr = NULL;
-    }
-
-    result = hostApi->OpenStream( hostApi, stream,
-                                  hostApiInputParametersPtr, hostApiOutputParametersPtr,
-                                  sampleRate, framesPerBuffer, streamFlags, streamCallback, userData );
-
-    if( result == paNoError )
-        AddOpenStream( *stream );
-
-
-    PA_LOGAPI(("Pa_OpenStream returned:\n" ));
-    PA_LOGAPI(("\t*(PaStream** stream): 0x%p\n", *stream ));
-    PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-
-    return result;
-}
-
-
-PaError Pa_OpenDefaultStream( PaStream** stream,
-                              int inputChannelCount,
-                              int outputChannelCount,
-                              PaSampleFormat sampleFormat,
-                              double sampleRate,
-                              unsigned long framesPerBuffer,
-                              PaStreamCallback *streamCallback,
-                              void *userData )
-{
-    PaError result;
-    PaStreamParameters hostApiInputParameters, hostApiOutputParameters;
-    PaStreamParameters *hostApiInputParametersPtr, *hostApiOutputParametersPtr;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_OpenDefaultStream" );
-    PA_LOGAPI(("\tPaStream** stream: 0x%p\n", stream ));
-    PA_LOGAPI(("\tint inputChannelCount: %d\n", inputChannelCount ));
-    PA_LOGAPI(("\tint outputChannelCount: %d\n", outputChannelCount ));
-    PA_LOGAPI(("\tPaSampleFormat sampleFormat: %d\n", sampleFormat ));
-    PA_LOGAPI(("\tdouble sampleRate: %g\n", sampleRate ));
-    PA_LOGAPI(("\tunsigned long framesPerBuffer: %d\n", framesPerBuffer ));
-    PA_LOGAPI(("\tPaStreamCallback *streamCallback: 0x%p\n", streamCallback ));
-    PA_LOGAPI(("\tvoid *userData: 0x%p\n", userData ));
-
-
-    if( inputChannelCount > 0 )
-    {
-        hostApiInputParameters.device = Pa_GetDefaultInputDevice();
-        if( hostApiInputParameters.device == paNoDevice )
-            return paDeviceUnavailable;
-
-        hostApiInputParameters.channelCount = inputChannelCount;
-        hostApiInputParameters.sampleFormat = sampleFormat;
-        /* defaultHighInputLatency is used below instead of
-           defaultLowInputLatency because it is more important for the default
-           stream to work reliably than it is for it to work with the lowest
-           latency.
-         */
-        hostApiInputParameters.suggestedLatency =
-             Pa_GetDeviceInfo( hostApiInputParameters.device )->defaultHighInputLatency;
-        hostApiInputParameters.hostApiSpecificStreamInfo = NULL;
-        hostApiInputParametersPtr = &hostApiInputParameters;
-    }
-    else
-    {
-        hostApiInputParametersPtr = NULL;
-    }
-
-    if( outputChannelCount > 0 )
-    {
-        hostApiOutputParameters.device = Pa_GetDefaultOutputDevice();
-        if( hostApiOutputParameters.device == paNoDevice )
-            return paDeviceUnavailable;
-
-        hostApiOutputParameters.channelCount = outputChannelCount;
-        hostApiOutputParameters.sampleFormat = sampleFormat;
-        /* defaultHighOutputLatency is used below instead of
-           defaultLowOutputLatency because it is more important for the default
-           stream to work reliably than it is for it to work with the lowest
-           latency.
-         */
-        hostApiOutputParameters.suggestedLatency =
-             Pa_GetDeviceInfo( hostApiOutputParameters.device )->defaultHighOutputLatency;
-        hostApiOutputParameters.hostApiSpecificStreamInfo = NULL;
-        hostApiOutputParametersPtr = &hostApiOutputParameters;
-    }
-    else
-    {
-        hostApiOutputParametersPtr = NULL;
-    }
-
-
-    result = Pa_OpenStream(
-                 stream, hostApiInputParametersPtr, hostApiOutputParametersPtr,
-                 sampleRate, framesPerBuffer, paNoFlag, streamCallback, userData );
-
-    PA_LOGAPI(("Pa_OpenDefaultStream returned:\n" ));
-    PA_LOGAPI(("\t*(PaStream** stream): 0x%p", *stream ));
-    PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-
-    return result;
-}
-
-
-PaError PaUtil_ValidateStreamPointer( PaStream* stream )
-{
-    if( !PA_IS_INITIALISED_ ) return paNotInitialized;
-
-    if( stream == NULL ) return paBadStreamPtr;
-
-    if( ((PaUtilStreamRepresentation*)stream)->magic != PA_STREAM_MAGIC )
-        return paBadStreamPtr;
-
-    return paNoError;
-}
-
-
-PaError Pa_CloseStream( PaStream* stream )
-{
-    PaUtilStreamInterface *interface;
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_CloseStream" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    /* always remove the open stream from our list, even if this function
-        eventually returns an error. Otherwise CloseOpenStreams() will
-        get stuck in an infinite loop */
-    RemoveOpenStream( stream ); /* be sure to call this _before_ closing the stream */
-
-    if( result == paNoError )
-    {
-        interface = PA_STREAM_INTERFACE(stream);
-
-        /* abort the stream if it isn't stopped */
-        result = interface->IsStopped( stream );
-        if( result == 1 )
-            result = paNoError;
-        else if( result == 0 )
-            result = interface->Abort( stream );
-
-        if( result == paNoError )                 /** @todo REVIEW: shouldn't we close anyway? see: http://www.portaudio.com/trac/ticket/115 */
-            result = interface->Close( stream );
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_CloseStream", result );
-
-    return result;
-}
-
-
-PaError Pa_SetStreamFinishedCallback( PaStream *stream, PaStreamFinishedCallback* streamFinishedCallback )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_SetStreamFinishedCallback" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-    PA_LOGAPI(("\tPaStreamFinishedCallback* streamFinishedCallback: 0x%p\n", streamFinishedCallback ));
-
-    if( result == paNoError )
-    {
-        result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-        if( result == 0 )
-        {
-            result = paStreamIsNotStopped ;
-        }
-        if( result == 1 )
-        {
-            PA_STREAM_REP( stream )->streamFinishedCallback = streamFinishedCallback;
-            result = paNoError;
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_SetStreamFinishedCallback", result );
-
-    return result;
-
-}
-
-
-PaError Pa_StartStream( PaStream *stream )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_StartStream" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-    {
-        result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-        if( result == 0 )
-        {
-            result = paStreamIsNotStopped ;
-        }
-        else if( result == 1 )
-        {
-            result = PA_STREAM_INTERFACE(stream)->Start( stream );
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_StartStream", result );
-
-    return result;
-}
-
-
-PaError Pa_StopStream( PaStream *stream )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_StopStream" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-    {
-        result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-        if( result == 0 )
-        {
-            result = PA_STREAM_INTERFACE(stream)->Stop( stream );
-        }
-        else if( result == 1 )
-        {
-            result = paStreamIsStopped;
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_StopStream", result );
-
-    return result;
-}
-
-
-PaError Pa_AbortStream( PaStream *stream )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_AbortStream" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-    {
-        result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-        if( result == 0 )
-        {
-            result = PA_STREAM_INTERFACE(stream)->Abort( stream );
-        }
-        else if( result == 1 )
-        {
-            result = paStreamIsStopped;
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_AbortStream", result );
-
-    return result;
-}
-
-
-PaError Pa_IsStreamStopped( PaStream *stream )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_IsStreamStopped" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-        result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_IsStreamStopped", result );
-
-    return result;
-}
-
-
-PaError Pa_IsStreamActive( PaStream *stream )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_IsStreamActive" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-        result = PA_STREAM_INTERFACE(stream)->IsActive( stream );
-
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_IsStreamActive", result );
-
-    return result;
-}
-
-
-const PaStreamInfo* Pa_GetStreamInfo( PaStream *stream )
-{
-    PaError error = PaUtil_ValidateStreamPointer( stream );
-    const PaStreamInfo *result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetStreamInfo" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( error != paNoError )
-    {
-        result = 0;
-
-        PA_LOGAPI(("Pa_GetStreamInfo returned:\n" ));
-        PA_LOGAPI(("\tconst PaStreamInfo*: 0 [PaError error:%d ( %s )]\n", error, Pa_GetErrorText( error ) ));
-
-    }
-    else
-    {
-        result = &PA_STREAM_REP( stream )->streamInfo;
-
-        PA_LOGAPI(("Pa_GetStreamInfo returned:\n" ));
-        PA_LOGAPI(("\tconst PaStreamInfo*: 0x%p:\n", result ));
-        PA_LOGAPI(("\t{" ));
-
-        PA_LOGAPI(("\t\tint structVersion: %d\n", result->structVersion ));
-        PA_LOGAPI(("\t\tPaTime inputLatency: %f\n", result->inputLatency ));
-        PA_LOGAPI(("\t\tPaTime outputLatency: %f\n", result->outputLatency ));
-        PA_LOGAPI(("\t\tdouble sampleRate: %f\n", result->sampleRate ));
-        PA_LOGAPI(("\t}\n" ));
-
-    }
-
-    return result;
-}
-
-
-PaTime Pa_GetStreamTime( PaStream *stream )
-{
-    PaError error = PaUtil_ValidateStreamPointer( stream );
-    PaTime result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetStreamTime" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( error != paNoError )
-    {
-        result = 0;
-
-        PA_LOGAPI(("Pa_GetStreamTime returned:\n" ));
-        PA_LOGAPI(("\tPaTime: 0 [PaError error:%d ( %s )]\n", result, error, Pa_GetErrorText( error ) ));
-
-    }
-    else
-    {
-        result = PA_STREAM_INTERFACE(stream)->GetTime( stream );
-
-        PA_LOGAPI(("Pa_GetStreamTime returned:\n" ));
-        PA_LOGAPI(("\tPaTime: %g\n", result ));
-
-    }
-
-    return result;
-}
-
-
-double Pa_GetStreamCpuLoad( PaStream* stream )
-{
-    PaError error = PaUtil_ValidateStreamPointer( stream );
-    double result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetStreamCpuLoad" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( error != paNoError )
-    {
-
-        result = 0.0;
-
-        PA_LOGAPI(("Pa_GetStreamCpuLoad returned:\n" ));
-        PA_LOGAPI(("\tdouble: 0.0 [PaError error: %d ( %s )]\n", error, Pa_GetErrorText( error ) ));
-
-    }
-    else
-    {
-        result = PA_STREAM_INTERFACE(stream)->GetCpuLoad( stream );
-
-        PA_LOGAPI(("Pa_GetStreamCpuLoad returned:\n" ));
-        PA_LOGAPI(("\tdouble: %g\n", result ));
-
-    }
-
-    return result;
-}
-
-
-PaError Pa_ReadStream( PaStream* stream,
-                       void *buffer,
-                       unsigned long frames )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_ReadStream" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-    {
-        if( frames == 0 )
-        {
-            /* @todo Should we not allow the implementation to signal any overflow condition? see: http://www.portaudio.com/trac/ticket/116*/
-            result = paNoError;
-        }
-        else if( buffer == 0 )
-        {
-            result = paBadBufferPtr;
-        }
-        else
-        {
-            result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-            if( result == 0 )
-            {
-                result = PA_STREAM_INTERFACE(stream)->Read( stream, buffer, frames );
-            }
-            else if( result == 1 )
-            {
-                result = paStreamIsStopped;
-            }
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_ReadStream", result );
-
-    return result;
-}
-
-
-PaError Pa_WriteStream( PaStream* stream,
-                        const void *buffer,
-                        unsigned long frames )
-{
-    PaError result = PaUtil_ValidateStreamPointer( stream );
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_WriteStream" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( result == paNoError )
-    {
-        if( frames == 0 )
-        {
-            /* @todo Should we not allow the implementation to signal any underflow condition? see: http://www.portaudio.com/trac/ticket/116*/
-            result = paNoError;
-        }
-        else if( buffer == 0 )
-        {
-            result = paBadBufferPtr;
-        }
-        else
-        {
-            result = PA_STREAM_INTERFACE(stream)->IsStopped( stream );
-            if( result == 0 )
-            {
-                result = PA_STREAM_INTERFACE(stream)->Write( stream, buffer, frames );
-            }
-            else if( result == 1 )
-            {
-                result = paStreamIsStopped;
-            }
-        }
-    }
-
-    PA_LOGAPI_EXIT_PAERROR( "Pa_WriteStream", result );
-
-    return result;
-}
-
-signed long Pa_GetStreamReadAvailable( PaStream* stream )
-{
-    PaError error = PaUtil_ValidateStreamPointer( stream );
-    signed long result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetStreamReadAvailable" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( error != paNoError )
-    {
-        result = 0;
-
-        PA_LOGAPI(("Pa_GetStreamReadAvailable returned:\n" ));
-        PA_LOGAPI(("\tunsigned long: 0 [ PaError error: %d ( %s ) ]\n", error, Pa_GetErrorText( error ) ));
-
-    }
-    else
-    {
-        result = PA_STREAM_INTERFACE(stream)->GetReadAvailable( stream );
-
-        PA_LOGAPI(("Pa_GetStreamReadAvailable returned:\n" ));
-        PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-
-    }
-
-    return result;
-}
-
-
-signed long Pa_GetStreamWriteAvailable( PaStream* stream )
-{
-    PaError error = PaUtil_ValidateStreamPointer( stream );
-    signed long result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetStreamWriteAvailable" );
-    PA_LOGAPI(("\tPaStream* stream: 0x%p\n", stream ));
-
-    if( error != paNoError )
-    {
-        result = 0;
-
-        PA_LOGAPI(("Pa_GetStreamWriteAvailable returned:\n" ));
-        PA_LOGAPI(("\tunsigned long: 0 [ PaError error: %d ( %s ) ]\n", error, Pa_GetErrorText( error ) ));
-
-    }
-    else
-    {
-        result = PA_STREAM_INTERFACE(stream)->GetWriteAvailable( stream );
-
-        PA_LOGAPI(("Pa_GetStreamWriteAvailable returned:\n" ));
-        PA_LOGAPI(("\tPaError: %d ( %s )\n", result, Pa_GetErrorText( result ) ));
-
-    }
-
-    return result;
-}
-
-
-PaError Pa_GetSampleSize( PaSampleFormat format )
-{
-    int result;
-
-    PA_LOGAPI_ENTER_PARAMS( "Pa_GetSampleSize" );
-    PA_LOGAPI(("\tPaSampleFormat format: %d\n", format ));
-
-    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;
-    }
-
-    PA_LOGAPI_EXIT_PAERROR_OR_T_RESULT( "Pa_GetSampleSize", "int: %d", result );
-
-    return (PaError) result;
-}
diff --git a/portaudio/src/common/pa_gitrevision.h b/portaudio/src/common/pa_gitrevision.h
deleted file mode 100644
index b5a042c..0000000
--- a/portaudio/src/common/pa_gitrevision.h
+++ /dev/null
@@ -1 +0,0 @@
-#define PA_GIT_REVISION 147dd722548358763a8b649b3e4b41dfffbcfbb6
diff --git a/portaudio/src/common/pa_hostapi.h b/portaudio/src/common/pa_hostapi.h
deleted file mode 100644
index 4ac3ab6..0000000
--- a/portaudio/src/common/pa_hostapi.h
+++ /dev/null
@@ -1,362 +0,0 @@
-#ifndef PA_HOSTAPI_H
-#define PA_HOSTAPI_H
-/*
- * $Id$
- * Portable Audio I/O Library
- * host api representation
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2008 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Interfaces and representation structures used by pa_front.c
- to manage and communicate with host API implementations.
-*/
-
-#include "portaudio.h"
-
-/**
-The PA_NO_* host API macros are now deprecated in favor of PA_USE_* macros.
-PA_USE_* indicates whether a particular host API will be initialized by PortAudio.
-An undefined or 0 value indicates that the host API will not be used. A value of 1
-indicates that the host API will be used. PA_USE_* macros should be left undefined
-or defined to either 0 or 1.
-
-The code below ensures that PA_USE_* macros are always defined and have value
-0 or 1. Undefined symbols are defaulted to 0. Symbols that are neither 0 nor 1
-are defaulted to 1.
-*/
-
-#ifndef PA_USE_SKELETON
-#define PA_USE_SKELETON 0
-#elif (PA_USE_SKELETON != 0) && (PA_USE_SKELETON != 1)
-#undef PA_USE_SKELETON
-#define PA_USE_SKELETON 1
-#endif
-
-#if defined(PA_NO_ASIO) || defined(PA_NO_DS) || defined(PA_NO_WMME) || defined(PA_NO_WASAPI) || defined(PA_NO_WDMKS)
-#error "Portaudio: PA_NO_<APINAME> is no longer supported, please remove definition and use PA_USE_<APINAME> instead"
-#endif
-
-#ifndef PA_USE_ASIO
-#define PA_USE_ASIO 0
-#elif (PA_USE_ASIO != 0) && (PA_USE_ASIO != 1)
-#undef PA_USE_ASIO
-#define PA_USE_ASIO 1
-#endif
-
-#ifndef PA_USE_DS
-#define PA_USE_DS 0
-#elif (PA_USE_DS != 0) && (PA_USE_DS != 1)
-#undef PA_USE_DS
-#define PA_USE_DS 1
-#endif
-
-#ifndef PA_USE_WMME
-#define PA_USE_WMME 0
-#elif (PA_USE_WMME != 0) && (PA_USE_WMME != 1)
-#undef PA_USE_WMME
-#define PA_USE_WMME 1
-#endif
-
-#ifndef PA_USE_WASAPI
-#define PA_USE_WASAPI 0
-#elif (PA_USE_WASAPI != 0) && (PA_USE_WASAPI != 1)
-#undef PA_USE_WASAPI
-#define PA_USE_WASAPI 1
-#endif
-
-#ifndef PA_USE_WDMKS
-#define PA_USE_WDMKS 0
-#elif (PA_USE_WDMKS != 0) && (PA_USE_WDMKS != 1)
-#undef PA_USE_WDMKS
-#define PA_USE_WDMKS 1
-#endif
-
-/* Set default values for Unix based APIs. */
-#if defined(PA_NO_OSS) || defined(PA_NO_ALSA) || defined(PA_NO_JACK) || defined(PA_NO_COREAUDIO) || defined(PA_NO_SGI) || defined(PA_NO_ASIHPI)
-#error "Portaudio: PA_NO_<APINAME> is no longer supported, please remove definition and use PA_USE_<APINAME> instead"
-#endif
-
-#ifndef PA_USE_OSS
-#define PA_USE_OSS 0
-#elif (PA_USE_OSS != 0) && (PA_USE_OSS != 1)
-#undef PA_USE_OSS
-#define PA_USE_OSS 1
-#endif
-
-#ifndef PA_USE_ALSA
-#define PA_USE_ALSA 0
-#elif (PA_USE_ALSA != 0) && (PA_USE_ALSA != 1)
-#undef PA_USE_ALSA
-#define PA_USE_ALSA 1
-#endif
-
-#ifndef PA_USE_JACK
-#define PA_USE_JACK 0
-#elif (PA_USE_JACK != 0) && (PA_USE_JACK != 1)
-#undef PA_USE_JACK
-#define PA_USE_JACK 1
-#endif
-
-#ifndef PA_USE_SGI
-#define PA_USE_SGI 0
-#elif (PA_USE_SGI != 0) && (PA_USE_SGI != 1)
-#undef PA_USE_SGI
-#define PA_USE_SGI 1
-#endif
-
-#ifndef PA_USE_COREAUDIO
-#define PA_USE_COREAUDIO 0
-#elif (PA_USE_COREAUDIO != 0) && (PA_USE_COREAUDIO != 1)
-#undef PA_USE_COREAUDIO
-#define PA_USE_COREAUDIO 1
-#endif
-
-#ifndef PA_USE_ASIHPI
-#define PA_USE_ASIHPI 0
-#elif (PA_USE_ASIHPI != 0) && (PA_USE_ASIHPI != 1)
-#undef PA_USE_ASIHPI
-#define PA_USE_ASIHPI 1
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-/** **FOR THE USE OF pa_front.c ONLY**
-    Do NOT use fields in this structure, they my change at any time.
-    Use functions defined in pa_util.h if you think you need functionality
-    which can be derived from here.
-*/
-typedef struct PaUtilPrivatePaFrontHostApiInfo {
-
-
-    unsigned long baseDeviceIndex;
-}PaUtilPrivatePaFrontHostApiInfo;
-
-
-/** The common header for all data structures whose pointers are passed through
- the hostApiSpecificStreamInfo field of the PaStreamParameters structure.
- Note that in order to keep the public PortAudio interface clean, this structure
- is not used explicitly when declaring hostApiSpecificStreamInfo data structures.
- However, some code in pa_front depends on the first 3 members being equivalent
- with this structure.
- @see PaStreamParameters
-*/
-typedef struct PaUtilHostApiSpecificStreamInfoHeader
-{
-    unsigned long size;             /**< size of whole structure including this header */
-    PaHostApiTypeId hostApiType;    /**< host API for which this data is intended */
-    unsigned long version;          /**< structure version */
-} PaUtilHostApiSpecificStreamInfoHeader;
-
-
-
-/** A structure representing the interface to a host API. Contains both
- concrete data and pointers to functions which implement the interface.
-*/
-typedef struct PaUtilHostApiRepresentation {
-    PaUtilPrivatePaFrontHostApiInfo privatePaFrontInfo;
-
-    /** The host api implementation should populate the info field. In the
-        case of info.defaultInputDevice and info.defaultOutputDevice the
-        values stored should be 0 based indices within the host api's own
-        device index range (0 to deviceCount). These values will be converted
-        to global device indices by pa_front after PaUtilHostApiInitializer()
-        returns.
-    */
-    PaHostApiInfo info;
-
-    PaDeviceInfo** deviceInfos;
-
-    /**
-        (*Terminate)() is guaranteed to be called with a valid <hostApi>
-        parameter, which was previously returned from the same implementation's
-        initializer.
-    */
-    void (*Terminate)( struct PaUtilHostApiRepresentation *hostApi );
-
-    /**
-        The inputParameters and outputParameters pointers should not be saved
-        as they will not remain valid after OpenStream is called.
-
-
-        The following guarantees are made about parameters to (*OpenStream)():
-
-            [NOTE: the following list up to *END PA FRONT VALIDATIONS* should be
-                kept in sync with the one for ValidateOpenStreamParameters and
-                Pa_OpenStream in pa_front.c]
-
-            PaHostApiRepresentation *hostApi
-                - is valid for this implementation
-
-            PaStream** stream
-                - is non-null
-
-            - at least one of inputParameters & outputParmeters is valid (not NULL)
-
-            - if inputParameters & outputParmeters are both valid, that
-                inputParameters->device & outputParmeters->device  both use the same host api
-
-            PaDeviceIndex inputParameters->device
-                - is within range (0 to Pa_CountDevices-1) Or:
-                - is paUseHostApiSpecificDeviceSpecification and
-                    inputParameters->hostApiSpecificStreamInfo is non-NULL and refers
-                    to a valid host api
-
-            int inputParameters->numChannels
-                - if inputParameters->device is not paUseHostApiSpecificDeviceSpecification, numInputChannels is > 0
-                - upper bound is NOT validated against device capabilities
-
-            PaSampleFormat inputParameters->sampleFormat
-                - is one of the sample formats defined in portaudio.h
-
-            void *inputParameters->hostApiSpecificStreamInfo
-                - if supplied its hostApi field matches the input device's host Api
-
-            PaDeviceIndex outputParmeters->device
-                - is within range (0 to Pa_CountDevices-1)
-
-            int outputParmeters->numChannels
-                - if inputDevice is valid, numInputChannels is > 0
-                - upper bound is NOT validated against device capabilities
-
-            PaSampleFormat outputParmeters->sampleFormat
-                - is one of the sample formats defined in portaudio.h
-
-            void *outputParmeters->hostApiSpecificStreamInfo
-                - if supplied its hostApi field matches the output device's host Api
-
-            double sampleRate
-                - is not an 'absurd' rate (less than 1000. or greater than 384000.)
-                - sampleRate is NOT validated against device capabilities
-
-            PaStreamFlags streamFlags
-                - unused platform neutral flags are zero
-                - paNeverDropInput is only used for full-duplex callback streams
-                    with variable buffer size (paFramesPerBufferUnspecified)
-
-            [*END PA FRONT VALIDATIONS*]
-
-
-        The following validations MUST be performed by (*OpenStream)():
-
-            - check that input device can support numInputChannels
-
-            - check that input device can support inputSampleFormat, or that
-                we have the capability to convert from outputSampleFormat to
-                a native format
-
-            - if inputStreamInfo is supplied, validate its contents,
-                or return an error if no inputStreamInfo is expected
-
-            - check that output device can support numOutputChannels
-
-            - check that output device can support outputSampleFormat, or that
-                we have the capability to convert from outputSampleFormat to
-                a native format
-
-            - if outputStreamInfo is supplied, validate its contents,
-                or return an error if no outputStreamInfo is expected
-
-            - if a full duplex stream is requested, check that the combination
-                of input and output parameters is supported
-
-            - check that the device supports sampleRate
-
-            - alter sampleRate to a close allowable rate if necessary
-
-            - validate inputLatency and outputLatency
-
-            - validate any platform specific flags, if flags are supplied they
-                must be valid.
-    */
-    PaError (*OpenStream)( struct PaUtilHostApiRepresentation *hostApi,
-                           PaStream** stream,
-                           const PaStreamParameters *inputParameters,
-                           const PaStreamParameters *outputParameters,
-                           double sampleRate,
-                           unsigned long framesPerCallback,
-                           PaStreamFlags streamFlags,
-                           PaStreamCallback *streamCallback,
-                           void *userData );
-
-
-    PaError (*IsFormatSupported)( struct PaUtilHostApiRepresentation *hostApi,
-                                  const PaStreamParameters *inputParameters,
-                                  const PaStreamParameters *outputParameters,
-                                  double sampleRate );
-} PaUtilHostApiRepresentation;
-
-
-/** Prototype for the initialization function which must be implemented by every
- host API.
-
- This function should only return an error other than paNoError if it encounters
- an unexpected and fatal error (memory allocation error for example). In general,
- there may be conditions under which it returns a NULL interface pointer and also
- returns paNoError. For example, if the ASIO implementation detects that ASIO is
- not installed, it should return a NULL interface, and paNoError.
-
- @see paHostApiInitializers
-*/
-typedef PaError PaUtilHostApiInitializer( PaUtilHostApiRepresentation**, PaHostApiIndex );
-
-
-/** paHostApiInitializers is a NULL-terminated array of host API initialization
- functions. These functions are called by pa_front.c to initialize the host APIs
- when the client calls Pa_Initialize().
-
- The initialization functions are invoked in order.
-
- The first successfully initialized host API that has a default input *or* output
- device is used as the default PortAudio host API. This is based on the logic that
- there is only one default host API, and it must contain the default input and output
- devices (if defined).
-
- There is a platform specific file that defines paHostApiInitializers for that
- platform, pa_win/pa_win_hostapis.c contains the Win32 definitions for example.
-*/
-extern PaUtilHostApiInitializer *paHostApiInitializers[];
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_HOSTAPI_H */
diff --git a/portaudio/src/common/pa_memorybarrier.h b/portaudio/src/common/pa_memorybarrier.h
deleted file mode 100644
index 0dca6aa..0000000
--- a/portaudio/src/common/pa_memorybarrier.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * $Id: pa_memorybarrier.h 1240 2007-07-17 13:05:07Z bjornroche $
- * Portable Audio I/O Library
- * Memory barrier utilities
- *
- * Author: Bjorn Roche, XO Audio, LLC
- *
- * This program uses the PortAudio Portable Audio Library.
- * For more information see: http://www.portaudio.com
- * Copyright (c) 1999-2000 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.
- */
-
-/**
- @file pa_memorybarrier.h
- @ingroup common_src
-*/
-
-/****************
- * Some memory barrier primitives based on the system.
- * right now only OS X, FreeBSD, and Linux are supported. In addition to providing
- * memory barriers, these functions should ensure that data cached in registers
- * is written out to cache where it can be snooped by other CPUs. (ie, the volatile
- * keyword should not be required)
- *
- * the primitives that must be defined are:
- *
- * PaUtil_FullMemoryBarrier()
- * PaUtil_ReadMemoryBarrier()
- * PaUtil_WriteMemoryBarrier()
- *
- ****************/
-
-#if defined(__APPLE__)
-#   include <libkern/OSAtomic.h>
-    /* Here are the memory barrier functions. Mac OS X only provides
-       full memory barriers, so the three types of barriers are the same,
-       however, these barriers are superior to compiler-based ones. */
-#   define PaUtil_FullMemoryBarrier()  OSMemoryBarrier()
-#   define PaUtil_ReadMemoryBarrier()  OSMemoryBarrier()
-#   define PaUtil_WriteMemoryBarrier() OSMemoryBarrier()
-#elif defined(__GNUC__)
-    /* GCC >= 4.1 has built-in intrinsics. We'll use those */
-#   if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)
-#       define PaUtil_FullMemoryBarrier()  __sync_synchronize()
-#       define PaUtil_ReadMemoryBarrier()  __sync_synchronize()
-#       define PaUtil_WriteMemoryBarrier() __sync_synchronize()
-    /* as a fallback, GCC understands volatile asm and "memory" to mean it
-     * should not reorder memory read/writes */
-    /* Note that it is not clear that any compiler actually defines __PPC__,
-     * it can probably removed safely. */
-#   elif defined( __ppc__ ) || defined( __powerpc__) || defined( __PPC__ )
-#       define PaUtil_FullMemoryBarrier()  asm volatile("sync":::"memory")
-#       define PaUtil_ReadMemoryBarrier()  asm volatile("sync":::"memory")
-#       define PaUtil_WriteMemoryBarrier() asm volatile("sync":::"memory")
-#   elif defined( __i386__ ) || defined( __i486__ ) || defined( __i586__ ) || \
-            defined( __i686__ ) || defined( __x86_64__ )
-#       define PaUtil_FullMemoryBarrier()  asm volatile("mfence":::"memory")
-#       define PaUtil_ReadMemoryBarrier()  asm volatile("lfence":::"memory")
-#       define PaUtil_WriteMemoryBarrier() asm volatile("sfence":::"memory")
-#   else
-#       ifdef ALLOW_SMP_DANGERS
-#           warning Memory barriers not defined on this system or system unknown
-#           warning For SMP safety, you should fix this.
-#           define PaUtil_FullMemoryBarrier()
-#           define PaUtil_ReadMemoryBarrier()
-#           define PaUtil_WriteMemoryBarrier()
-#       else
-#           error Memory barriers are not defined on this system. You can still compile by defining ALLOW_SMP_DANGERS, but SMP safety will not be guaranteed.
-#       endif
-#   endif
-#elif (_MSC_VER >= 1400) && !defined(_WIN32_WCE)
-#   include <intrin.h>
-#   pragma intrinsic(_ReadWriteBarrier)
-#   pragma intrinsic(_ReadBarrier)
-#   pragma intrinsic(_WriteBarrier)
-/* note that MSVC intrinsics _ReadWriteBarrier(), _ReadBarrier(), _WriteBarrier() are just compiler barriers *not* memory barriers */
-#   define PaUtil_FullMemoryBarrier()  _ReadWriteBarrier()
-#   define PaUtil_ReadMemoryBarrier()  _ReadBarrier()
-#   define PaUtil_WriteMemoryBarrier() _WriteBarrier()
-#elif defined(_WIN32_WCE)
-#   define PaUtil_FullMemoryBarrier()
-#   define PaUtil_ReadMemoryBarrier()
-#   define PaUtil_WriteMemoryBarrier()
-#elif defined(_MSC_VER) || defined(__BORLANDC__)
-#   define PaUtil_FullMemoryBarrier()  _asm { lock add    [esp], 0 }
-#   define PaUtil_ReadMemoryBarrier()  _asm { lock add    [esp], 0 }
-#   define PaUtil_WriteMemoryBarrier() _asm { lock add    [esp], 0 }
-#else
-#   ifdef ALLOW_SMP_DANGERS
-#       warning Memory barriers not defined on this system or system unknown
-#       warning For SMP safety, you should fix this.
-#       define PaUtil_FullMemoryBarrier()
-#       define PaUtil_ReadMemoryBarrier()
-#       define PaUtil_WriteMemoryBarrier()
-#   else
-#       error Memory barriers are not defined on this system. You can still compile by defining ALLOW_SMP_DANGERS, but SMP safety will not be guaranteed.
-#   endif
-#endif
diff --git a/portaudio/src/common/pa_process.c b/portaudio/src/common/pa_process.c
deleted file mode 100644
index 084cabb..0000000
--- a/portaudio/src/common/pa_process.c
+++ /dev/null
@@ -1,1831 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library
- * streamCallback <-> host buffer processing adapter
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Buffer Processor implementation.
-*/
-
-
-#include <assert.h>
-#include <string.h> /* memset() */
-
-#include "pa_process.h"
-#include "pa_util.h"
-
-
-#define PA_FRAMES_PER_TEMP_BUFFER_WHEN_HOST_BUFFER_SIZE_IS_UNKNOWN_    1024
-
-#define PA_MIN_( a, b ) ( ((a)<(b)) ? (a) : (b) )
-
-
-/* greatest common divisor - PGCD in French */
-static unsigned long GCD( unsigned long a, unsigned long b )
-{
-    return (b==0) ? a : GCD( b, a%b);
-}
-
-/* least common multiple - PPCM in French */
-static unsigned long LCM( unsigned long a, unsigned long b )
-{
-    return (a*b) / GCD(a,b);
-}
-
-#define PA_MAX_( a, b ) (((a) > (b)) ? (a) : (b))
-
-static unsigned long CalculateFrameShift( unsigned long M, unsigned long N )
-{
-    unsigned long result = 0;
-    unsigned long i;
-    unsigned long lcm;
-
-    assert( M > 0 );
-    assert( N > 0 );
-
-    lcm = LCM( M, N );
-    for( i = M; i < lcm; i += M )
-        result = PA_MAX_( result, i % N );
-
-    return result;
-}
-
-
-PaError PaUtil_InitializeBufferProcessor( PaUtilBufferProcessor* bp,
-        int inputChannelCount, PaSampleFormat userInputSampleFormat,
-        PaSampleFormat hostInputSampleFormat,
-        int outputChannelCount, PaSampleFormat userOutputSampleFormat,
-        PaSampleFormat hostOutputSampleFormat,
-        double sampleRate,
-        PaStreamFlags streamFlags,
-        unsigned long framesPerUserBuffer,
-        unsigned long framesPerHostBuffer,
-        PaUtilHostBufferSizeMode hostBufferSizeMode,
-        PaStreamCallback *streamCallback, void *userData )
-{
-    PaError result = paNoError;
-    PaError bytesPerSample;
-    unsigned long tempInputBufferSize, tempOutputBufferSize;
-    PaStreamFlags tempInputStreamFlags;
-
-    if( streamFlags & paNeverDropInput )
-    {
-        /* paNeverDropInput is only valid for full-duplex callback streams, with an unspecified number of frames per buffer. */
-        if( !streamCallback || !(inputChannelCount > 0 && outputChannelCount > 0) ||
-                framesPerUserBuffer != paFramesPerBufferUnspecified )
-            return paInvalidFlag;
-    }
-
-    /* initialize buffer ptrs to zero so they can be freed if necessary in error */
-    bp->tempInputBuffer = 0;
-    bp->tempInputBufferPtrs = 0;
-    bp->tempOutputBuffer = 0;
-    bp->tempOutputBufferPtrs = 0;
-
-    bp->framesPerUserBuffer = framesPerUserBuffer;
-    bp->framesPerHostBuffer = framesPerHostBuffer;
-
-    bp->inputChannelCount = inputChannelCount;
-    bp->outputChannelCount = outputChannelCount;
-
-    bp->hostBufferSizeMode = hostBufferSizeMode;
-
-    bp->hostInputChannels[0] = bp->hostInputChannels[1] = 0;
-    bp->hostOutputChannels[0] = bp->hostOutputChannels[1] = 0;
-
-    if( framesPerUserBuffer == 0 ) /* streamCallback will accept any buffer size */
-    {
-        bp->useNonAdaptingProcess = 1;
-        bp->initialFramesInTempInputBuffer = 0;
-        bp->initialFramesInTempOutputBuffer = 0;
-
-        if( hostBufferSizeMode == paUtilFixedHostBufferSize
-                || hostBufferSizeMode == paUtilBoundedHostBufferSize )
-        {
-            bp->framesPerTempBuffer = framesPerHostBuffer;
-        }
-        else /* unknown host buffer size */
-        {
-            bp->framesPerTempBuffer = PA_FRAMES_PER_TEMP_BUFFER_WHEN_HOST_BUFFER_SIZE_IS_UNKNOWN_;
-        }
-    }
-    else
-    {
-        bp->framesPerTempBuffer = framesPerUserBuffer;
-
-        if( hostBufferSizeMode == paUtilFixedHostBufferSize
-                && framesPerHostBuffer % framesPerUserBuffer == 0 )
-        {
-            bp->useNonAdaptingProcess = 1;
-            bp->initialFramesInTempInputBuffer = 0;
-            bp->initialFramesInTempOutputBuffer = 0;
-        }
-        else
-        {
-            bp->useNonAdaptingProcess = 0;
-
-            if( inputChannelCount > 0 && outputChannelCount > 0 )
-            {
-                /* full duplex */
-                if( hostBufferSizeMode == paUtilFixedHostBufferSize )
-                {
-                    unsigned long frameShift =
-                        CalculateFrameShift( framesPerHostBuffer, framesPerUserBuffer );
-
-                    if( framesPerUserBuffer > framesPerHostBuffer )
-                    {
-                        bp->initialFramesInTempInputBuffer = frameShift;
-                        bp->initialFramesInTempOutputBuffer = 0;
-                    }
-                    else
-                    {
-                        bp->initialFramesInTempInputBuffer = 0;
-                        bp->initialFramesInTempOutputBuffer = frameShift;
-                    }
-                }
-                else /* variable host buffer size, add framesPerUserBuffer latency */
-                {
-                    bp->initialFramesInTempInputBuffer = 0;
-                    bp->initialFramesInTempOutputBuffer = framesPerUserBuffer;
-                }
-            }
-            else
-            {
-                /* half duplex */
-                bp->initialFramesInTempInputBuffer = 0;
-                bp->initialFramesInTempOutputBuffer = 0;
-            }
-        }
-    }
-
-
-    bp->framesInTempInputBuffer = bp->initialFramesInTempInputBuffer;
-    bp->framesInTempOutputBuffer = bp->initialFramesInTempOutputBuffer;
-
-
-    if( inputChannelCount > 0 )
-    {
-        bytesPerSample = Pa_GetSampleSize( hostInputSampleFormat );
-        if( bytesPerSample > 0 )
-        {
-            bp->bytesPerHostInputSample = bytesPerSample;
-        }
-        else
-        {
-            result = bytesPerSample;
-            goto error;
-        }
-
-        bytesPerSample = Pa_GetSampleSize( userInputSampleFormat );
-        if( bytesPerSample > 0 )
-        {
-            bp->bytesPerUserInputSample = bytesPerSample;
-        }
-        else
-        {
-            result = bytesPerSample;
-            goto error;
-        }
-
-        /* Under the assumption that no ADC in existence delivers better than 24bits resolution,
-            we disable dithering when host input format is paInt32 and user format is paInt24,
-            since the host samples will just be padded with zeros anyway. */
-
-        tempInputStreamFlags = streamFlags;
-        if( !(tempInputStreamFlags & paDitherOff) /* dither is on */
-                && (hostInputSampleFormat & paInt32) /* host input format is int32 */
-                && (userInputSampleFormat & paInt24) /* user requested format is int24 */ ){
-
-            tempInputStreamFlags = tempInputStreamFlags | paDitherOff;
-        }
-
-        bp->inputConverter =
-            PaUtil_SelectConverter( hostInputSampleFormat, userInputSampleFormat, tempInputStreamFlags );
-
-        bp->inputZeroer = PaUtil_SelectZeroer( userInputSampleFormat );
-
-        bp->userInputIsInterleaved = (userInputSampleFormat & paNonInterleaved)?0:1;
-
-        bp->hostInputIsInterleaved = (hostInputSampleFormat & paNonInterleaved)?0:1;
-
-        bp->userInputSampleFormatIsEqualToHost = ((userInputSampleFormat & ~paNonInterleaved) == (hostInputSampleFormat & ~paNonInterleaved));
-
-        tempInputBufferSize =
-            bp->framesPerTempBuffer * bp->bytesPerUserInputSample * inputChannelCount;
-
-        bp->tempInputBuffer = PaUtil_AllocateMemory( tempInputBufferSize );
-        if( bp->tempInputBuffer == 0 )
-        {
-            result = paInsufficientMemory;
-            goto error;
-        }
-
-        if( bp->framesInTempInputBuffer > 0 )
-            memset( bp->tempInputBuffer, 0, tempInputBufferSize );
-
-        if( userInputSampleFormat & paNonInterleaved )
-        {
-            bp->tempInputBufferPtrs =
-                (void **)PaUtil_AllocateMemory( sizeof(void*)*inputChannelCount );
-            if( bp->tempInputBufferPtrs == 0 )
-            {
-                result = paInsufficientMemory;
-                goto error;
-            }
-        }
-
-        bp->hostInputChannels[0] = (PaUtilChannelDescriptor*)
-                PaUtil_AllocateMemory( sizeof(PaUtilChannelDescriptor) * inputChannelCount * 2);
-        if( bp->hostInputChannels[0] == 0 )
-        {
-            result = paInsufficientMemory;
-            goto error;
-        }
-
-        bp->hostInputChannels[1] = &bp->hostInputChannels[0][inputChannelCount];
-    }
-
-    if( outputChannelCount > 0 )
-    {
-        bytesPerSample = Pa_GetSampleSize( hostOutputSampleFormat );
-        if( bytesPerSample > 0 )
-        {
-            bp->bytesPerHostOutputSample = bytesPerSample;
-        }
-        else
-        {
-            result = bytesPerSample;
-            goto error;
-        }
-
-        bytesPerSample = Pa_GetSampleSize( userOutputSampleFormat );
-        if( bytesPerSample > 0 )
-        {
-            bp->bytesPerUserOutputSample = bytesPerSample;
-        }
-        else
-        {
-            result = bytesPerSample;
-            goto error;
-        }
-
-        bp->outputConverter =
-            PaUtil_SelectConverter( userOutputSampleFormat, hostOutputSampleFormat, streamFlags );
-
-        bp->outputZeroer = PaUtil_SelectZeroer( hostOutputSampleFormat );
-
-        bp->userOutputIsInterleaved = (userOutputSampleFormat & paNonInterleaved)?0:1;
-
-        bp->hostOutputIsInterleaved = (hostOutputSampleFormat & paNonInterleaved)?0:1;
-
-        bp->userOutputSampleFormatIsEqualToHost = ((userOutputSampleFormat & ~paNonInterleaved) == (hostOutputSampleFormat & ~paNonInterleaved));
-
-        tempOutputBufferSize =
-                bp->framesPerTempBuffer * bp->bytesPerUserOutputSample * outputChannelCount;
-
-        bp->tempOutputBuffer = PaUtil_AllocateMemory( tempOutputBufferSize );
-        if( bp->tempOutputBuffer == 0 )
-        {
-            result = paInsufficientMemory;
-            goto error;
-        }
-
-        if( bp->framesInTempOutputBuffer > 0 )
-            memset( bp->tempOutputBuffer, 0, tempOutputBufferSize );
-
-        if( userOutputSampleFormat & paNonInterleaved )
-        {
-            bp->tempOutputBufferPtrs =
-                (void **)PaUtil_AllocateMemory( sizeof(void*)*outputChannelCount );
-            if( bp->tempOutputBufferPtrs == 0 )
-            {
-                result = paInsufficientMemory;
-                goto error;
-            }
-        }
-
-        bp->hostOutputChannels[0] = (PaUtilChannelDescriptor*)
-                PaUtil_AllocateMemory( sizeof(PaUtilChannelDescriptor)*outputChannelCount * 2 );
-        if( bp->hostOutputChannels[0] == 0 )
-        {
-            result = paInsufficientMemory;
-            goto error;
-        }
-
-        bp->hostOutputChannels[1] = &bp->hostOutputChannels[0][outputChannelCount];
-    }
-
-    PaUtil_InitializeTriangularDitherState( &bp->ditherGenerator );
-
-    bp->samplePeriod = 1. / sampleRate;
-
-    bp->streamCallback = streamCallback;
-    bp->userData = userData;
-
-    return result;
-
-error:
-    if( bp->tempInputBuffer )
-        PaUtil_FreeMemory( bp->tempInputBuffer );
-
-    if( bp->tempInputBufferPtrs )
-        PaUtil_FreeMemory( bp->tempInputBufferPtrs );
-
-    if( bp->hostInputChannels[0] )
-        PaUtil_FreeMemory( bp->hostInputChannels[0] );
-
-    if( bp->tempOutputBuffer )
-        PaUtil_FreeMemory( bp->tempOutputBuffer );
-
-    if( bp->tempOutputBufferPtrs )
-        PaUtil_FreeMemory( bp->tempOutputBufferPtrs );
-
-    if( bp->hostOutputChannels[0] )
-        PaUtil_FreeMemory( bp->hostOutputChannels[0] );
-
-    return result;
-}
-
-
-void PaUtil_TerminateBufferProcessor( PaUtilBufferProcessor* bp )
-{
-    if( bp->tempInputBuffer )
-        PaUtil_FreeMemory( bp->tempInputBuffer );
-
-    if( bp->tempInputBufferPtrs )
-        PaUtil_FreeMemory( bp->tempInputBufferPtrs );
-
-    if( bp->hostInputChannels[0] )
-        PaUtil_FreeMemory( bp->hostInputChannels[0] );
-
-    if( bp->tempOutputBuffer )
-        PaUtil_FreeMemory( bp->tempOutputBuffer );
-
-    if( bp->tempOutputBufferPtrs )
-        PaUtil_FreeMemory( bp->tempOutputBufferPtrs );
-
-    if( bp->hostOutputChannels[0] )
-        PaUtil_FreeMemory( bp->hostOutputChannels[0] );
-}
-
-
-void PaUtil_ResetBufferProcessor( PaUtilBufferProcessor* bp )
-{
-    unsigned long tempInputBufferSize, tempOutputBufferSize;
-
-    bp->framesInTempInputBuffer = bp->initialFramesInTempInputBuffer;
-    bp->framesInTempOutputBuffer = bp->initialFramesInTempOutputBuffer;
-
-    if( bp->framesInTempInputBuffer > 0 )
-    {
-        tempInputBufferSize =
-            bp->framesPerTempBuffer * bp->bytesPerUserInputSample * bp->inputChannelCount;
-        memset( bp->tempInputBuffer, 0, tempInputBufferSize );
-    }
-
-    if( bp->framesInTempOutputBuffer > 0 )
-    {
-        tempOutputBufferSize =
-            bp->framesPerTempBuffer * bp->bytesPerUserOutputSample * bp->outputChannelCount;
-        memset( bp->tempOutputBuffer, 0, tempOutputBufferSize );
-    }
-}
-
-
-unsigned long PaUtil_GetBufferProcessorInputLatencyFrames( PaUtilBufferProcessor* bp )
-{
-    return bp->initialFramesInTempInputBuffer;
-}
-
-
-unsigned long PaUtil_GetBufferProcessorOutputLatencyFrames( PaUtilBufferProcessor* bp )
-{
-    return bp->initialFramesInTempOutputBuffer;
-}
-
-
-void PaUtil_SetInputFrameCount( PaUtilBufferProcessor* bp,
-        unsigned long frameCount )
-{
-    if( frameCount == 0 )
-        bp->hostInputFrameCount[0] = bp->framesPerHostBuffer;
-    else
-        bp->hostInputFrameCount[0] = frameCount;
-}
-
-
-void PaUtil_SetNoInput( PaUtilBufferProcessor* bp )
-{
-    assert( bp->inputChannelCount > 0 );
-
-    bp->hostInputChannels[0][0].data = 0;
-}
-
-
-void PaUtil_SetInputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data, unsigned int stride )
-{
-    assert( channel < bp->inputChannelCount );
-
-    bp->hostInputChannels[0][channel].data = data;
-    bp->hostInputChannels[0][channel].stride = stride;
-}
-
-
-void PaUtil_SetInterleavedInputChannels( PaUtilBufferProcessor* bp,
-        unsigned int firstChannel, void *data, unsigned int channelCount )
-{
-    unsigned int i;
-    unsigned int channel = firstChannel;
-    unsigned char *p = (unsigned char*)data;
-
-    if( channelCount == 0 )
-        channelCount = bp->inputChannelCount;
-
-    assert( firstChannel < bp->inputChannelCount );
-    assert( firstChannel + channelCount <= bp->inputChannelCount );
-    assert( bp->hostInputIsInterleaved );
-
-    for( i=0; i< channelCount; ++i )
-    {
-        bp->hostInputChannels[0][channel+i].data = p;
-        p += bp->bytesPerHostInputSample;
-        bp->hostInputChannels[0][channel+i].stride = channelCount;
-    }
-}
-
-
-void PaUtil_SetNonInterleavedInputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data )
-{
-    assert( channel < bp->inputChannelCount );
-    assert( !bp->hostInputIsInterleaved );
-
-    bp->hostInputChannels[0][channel].data = data;
-    bp->hostInputChannels[0][channel].stride = 1;
-}
-
-
-void PaUtil_Set2ndInputFrameCount( PaUtilBufferProcessor* bp,
-        unsigned long frameCount )
-{
-    bp->hostInputFrameCount[1] = frameCount;
-}
-
-
-void PaUtil_Set2ndInputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data, unsigned int stride )
-{
-    assert( channel < bp->inputChannelCount );
-
-    bp->hostInputChannels[1][channel].data = data;
-    bp->hostInputChannels[1][channel].stride = stride;
-}
-
-
-void PaUtil_Set2ndInterleavedInputChannels( PaUtilBufferProcessor* bp,
-        unsigned int firstChannel, void *data, unsigned int channelCount )
-{
-    unsigned int i;
-    unsigned int channel = firstChannel;
-    unsigned char *p = (unsigned char*)data;
-
-    if( channelCount == 0 )
-        channelCount = bp->inputChannelCount;
-
-    assert( firstChannel < bp->inputChannelCount );
-    assert( firstChannel + channelCount <= bp->inputChannelCount );
-    assert( bp->hostInputIsInterleaved );
-
-    for( i=0; i< channelCount; ++i )
-    {
-        bp->hostInputChannels[1][channel+i].data = p;
-        p += bp->bytesPerHostInputSample;
-        bp->hostInputChannels[1][channel+i].stride = channelCount;
-    }
-}
-
-
-void PaUtil_Set2ndNonInterleavedInputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data )
-{
-    assert( channel < bp->inputChannelCount );
-    assert( !bp->hostInputIsInterleaved );
-
-    bp->hostInputChannels[1][channel].data = data;
-    bp->hostInputChannels[1][channel].stride = 1;
-}
-
-
-void PaUtil_SetOutputFrameCount( PaUtilBufferProcessor* bp,
-        unsigned long frameCount )
-{
-    if( frameCount == 0 )
-        bp->hostOutputFrameCount[0] = bp->framesPerHostBuffer;
-    else
-        bp->hostOutputFrameCount[0] = frameCount;
-}
-
-
-void PaUtil_SetNoOutput( PaUtilBufferProcessor* bp )
-{
-    assert( bp->outputChannelCount > 0 );
-
-    bp->hostOutputChannels[0][0].data = 0;
-
-    /* note that only NonAdaptingProcess is able to deal with no output at this stage. not implemented for AdaptingProcess */
-}
-
-
-void PaUtil_SetOutputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data, unsigned int stride )
-{
-    assert( channel < bp->outputChannelCount );
-    assert( data != NULL );
-
-    bp->hostOutputChannels[0][channel].data = data;
-    bp->hostOutputChannels[0][channel].stride = stride;
-}
-
-
-void PaUtil_SetInterleavedOutputChannels( PaUtilBufferProcessor* bp,
-        unsigned int firstChannel, void *data, unsigned int channelCount )
-{
-    unsigned int i;
-    unsigned int channel = firstChannel;
-    unsigned char *p = (unsigned char*)data;
-
-    if( channelCount == 0 )
-        channelCount = bp->outputChannelCount;
-
-    assert( firstChannel < bp->outputChannelCount );
-    assert( firstChannel + channelCount <= bp->outputChannelCount );
-    assert( bp->hostOutputIsInterleaved );
-
-    for( i=0; i< channelCount; ++i )
-    {
-        PaUtil_SetOutputChannel( bp, channel + i, p, channelCount );
-        p += bp->bytesPerHostOutputSample;
-    }
-}
-
-
-void PaUtil_SetNonInterleavedOutputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data )
-{
-    assert( channel < bp->outputChannelCount );
-    assert( !bp->hostOutputIsInterleaved );
-
-    PaUtil_SetOutputChannel( bp, channel, data, 1 );
-}
-
-
-void PaUtil_Set2ndOutputFrameCount( PaUtilBufferProcessor* bp,
-        unsigned long frameCount )
-{
-    bp->hostOutputFrameCount[1] = frameCount;
-}
-
-
-void PaUtil_Set2ndOutputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data, unsigned int stride )
-{
-    assert( channel < bp->outputChannelCount );
-    assert( data != NULL );
-
-    bp->hostOutputChannels[1][channel].data = data;
-    bp->hostOutputChannels[1][channel].stride = stride;
-}
-
-
-void PaUtil_Set2ndInterleavedOutputChannels( PaUtilBufferProcessor* bp,
-        unsigned int firstChannel, void *data, unsigned int channelCount )
-{
-    unsigned int i;
-    unsigned int channel = firstChannel;
-    unsigned char *p = (unsigned char*)data;
-
-    if( channelCount == 0 )
-        channelCount = bp->outputChannelCount;
-
-    assert( firstChannel < bp->outputChannelCount );
-    assert( firstChannel + channelCount <= bp->outputChannelCount );
-    assert( bp->hostOutputIsInterleaved );
-
-    for( i=0; i< channelCount; ++i )
-    {
-        PaUtil_Set2ndOutputChannel( bp, channel + i, p, channelCount );
-        p += bp->bytesPerHostOutputSample;
-    }
-}
-
-
-void PaUtil_Set2ndNonInterleavedOutputChannel( PaUtilBufferProcessor* bp,
-        unsigned int channel, void *data )
-{
-    assert( channel < bp->outputChannelCount );
-    assert( !bp->hostOutputIsInterleaved );
-
-    PaUtil_Set2ndOutputChannel( bp, channel, data, 1 );
-}
-
-
-void PaUtil_BeginBufferProcessing( PaUtilBufferProcessor* bp,
-        PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags callbackStatusFlags )
-{
-    bp->timeInfo = timeInfo;
-
-    /* the first streamCallback will be called to process samples which are
-        currently in the input buffer before the ones starting at the timeInfo time */
-
-    bp->timeInfo->inputBufferAdcTime -= bp->framesInTempInputBuffer * bp->samplePeriod;
-
-    /* We just pass through timeInfo->currentTime provided by the caller. This is
-        not strictly conformant to the word of the spec, since the buffer processor
-        might call the callback multiple times, and we never refresh currentTime. */
-
-    /* the first streamCallback will be called to generate samples which will be
-        outputted after the frames currently in the output buffer have been
-        outputted. */
-    bp->timeInfo->outputBufferDacTime += bp->framesInTempOutputBuffer * bp->samplePeriod;
-
-    bp->callbackStatusFlags = callbackStatusFlags;
-
-    bp->hostInputFrameCount[1] = 0;
-    bp->hostOutputFrameCount[1] = 0;
-}
-
-
-/*
-    NonAdaptingProcess() is a simple buffer copying adaptor that can handle
-    both full and half duplex copies. It processes framesToProcess frames,
-    broken into blocks bp->framesPerTempBuffer long.
-    This routine can be used when the streamCallback doesn't care what length
-    the buffers are, or when framesToProcess is an integer multiple of
-    bp->framesPerTempBuffer, in which case streamCallback will always be called
-    with bp->framesPerTempBuffer samples.
-*/
-static unsigned long NonAdaptingProcess( PaUtilBufferProcessor *bp,
-        int *streamCallbackResult,
-        PaUtilChannelDescriptor *hostInputChannels,
-        PaUtilChannelDescriptor *hostOutputChannels,
-        unsigned long framesToProcess )
-{
-    void *userInput, *userOutput;
-    unsigned char *srcBytePtr, *destBytePtr;
-    unsigned int srcSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int srcChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int destSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int destChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int i;
-    unsigned long frameCount;
-    unsigned long framesToGo = framesToProcess;
-    unsigned long framesProcessed = 0;
-    int skipOutputConvert = 0;
-    int skipInputConvert = 0;
-
-
-    if( *streamCallbackResult == paContinue )
-    {
-        do
-        {
-            frameCount = PA_MIN_( bp->framesPerTempBuffer, framesToGo );
-
-            /* configure user input buffer and convert input data (host -> user) */
-            if( bp->inputChannelCount == 0 )
-            {
-                /* no input */
-                userInput = 0;
-            }
-            else /* there are input channels */
-            {
-
-                destBytePtr = (unsigned char *)bp->tempInputBuffer;
-
-                if( bp->userInputIsInterleaved )
-                {
-                    destSampleStrideSamples = bp->inputChannelCount;
-                    destChannelStrideBytes = bp->bytesPerUserInputSample;
-
-                    /* process host buffer directly, or use temp buffer if formats differ or host buffer non-interleaved,
-                     * or if num channels differs between the host (set in stride) and the user (eg with some Alsa hw:) */
-                    if( bp->userInputSampleFormatIsEqualToHost && bp->hostInputIsInterleaved
-                        && bp->hostInputChannels[0][0].data && bp->inputChannelCount == hostInputChannels[0].stride )
-                    {
-                        userInput = hostInputChannels[0].data;
-                        destBytePtr = (unsigned char *)hostInputChannels[0].data;
-                        skipInputConvert = 1;
-                    }
-                    else
-                    {
-                        userInput = bp->tempInputBuffer;
-                    }
-                }
-                else /* user input is not interleaved */
-                {
-                    destSampleStrideSamples = 1;
-                    destChannelStrideBytes = frameCount * bp->bytesPerUserInputSample;
-
-                    /* setup non-interleaved ptrs */
-                    if( bp->userInputSampleFormatIsEqualToHost && !bp->hostInputIsInterleaved && bp->hostInputChannels[0][0].data )
-                    {
-                        for( i=0; i<bp->inputChannelCount; ++i )
-                        {
-                            bp->tempInputBufferPtrs[i] = hostInputChannels[i].data;
-                        }
-                        skipInputConvert = 1;
-                    }
-                    else
-                    {
-                        for( i=0; i<bp->inputChannelCount; ++i )
-                        {
-                            bp->tempInputBufferPtrs[i] = ((unsigned char*)bp->tempInputBuffer) +
-                                i * bp->bytesPerUserInputSample * frameCount;
-                        }
-                    }
-
-                    userInput = bp->tempInputBufferPtrs;
-                }
-
-                if( !bp->hostInputChannels[0][0].data )
-                {
-                    /* no input was supplied (see PaUtil_SetNoInput), so
-                        zero the input buffer */
-
-                    for( i=0; i<bp->inputChannelCount; ++i )
-                    {
-                        bp->inputZeroer( destBytePtr, destSampleStrideSamples, frameCount );
-                        destBytePtr += destChannelStrideBytes;  /* skip to next destination channel */
-                    }
-                }
-                else
-                {
-                    if( skipInputConvert )
-                    {
-                        for( i=0; i<bp->inputChannelCount; ++i )
-                        {
-                            /* advance src ptr for next iteration */
-                            hostInputChannels[i].data = ((unsigned char*)hostInputChannels[i].data) +
-                                    frameCount * hostInputChannels[i].stride * bp->bytesPerHostInputSample;
-                        }
-                    }
-                    else
-                    {
-                        for( i=0; i<bp->inputChannelCount; ++i )
-                        {
-                            bp->inputConverter( destBytePtr, destSampleStrideSamples,
-                                                    hostInputChannels[i].data,
-                                                    hostInputChannels[i].stride,
-                                                    frameCount, &bp->ditherGenerator );
-
-                            destBytePtr += destChannelStrideBytes;  /* skip to next destination channel */
-
-                            /* advance src ptr for next iteration */
-                            hostInputChannels[i].data = ((unsigned char*)hostInputChannels[i].data) +
-                                    frameCount * hostInputChannels[i].stride * bp->bytesPerHostInputSample;
-                        }
-                    }
-                }
-            }
-
-            /* configure user output buffer */
-            if( bp->outputChannelCount == 0 )
-            {
-                /* no output */
-                userOutput = 0;
-            }
-            else /* there are output channels */
-            {
-                if( bp->userOutputIsInterleaved )
-                {
-                    /* process host buffer directly, or use temp buffer if formats differ or host buffer non-interleaved,
-                     * or if num channels differs between the host (set in stride) and the user (eg with some Alsa hw:) */
-                    if( bp->userOutputSampleFormatIsEqualToHost && bp->hostOutputIsInterleaved
-                            && bp->outputChannelCount == hostOutputChannels[0].stride )
-                    {
-                        userOutput = hostOutputChannels[0].data;
-                        skipOutputConvert = 1;
-                    }
-                    else
-                    {
-                        userOutput = bp->tempOutputBuffer;
-                    }
-                }
-                else /* user output is not interleaved */
-                {
-                    if( bp->userOutputSampleFormatIsEqualToHost && !bp->hostOutputIsInterleaved )
-                    {
-                        for( i=0; i<bp->outputChannelCount; ++i )
-                        {
-                            bp->tempOutputBufferPtrs[i] = hostOutputChannels[i].data;
-                        }
-                        skipOutputConvert = 1;
-                    }
-                    else
-                    {
-                        for( i=0; i<bp->outputChannelCount; ++i )
-                        {
-                            bp->tempOutputBufferPtrs[i] = ((unsigned char*)bp->tempOutputBuffer) +
-                                i * bp->bytesPerUserOutputSample * frameCount;
-                        }
-                    }
-
-                    userOutput = bp->tempOutputBufferPtrs;
-                }
-            }
-
-            *streamCallbackResult = bp->streamCallback( userInput, userOutput,
-                    frameCount, bp->timeInfo, bp->callbackStatusFlags, bp->userData );
-
-            if( *streamCallbackResult == paAbort )
-            {
-                /* callback returned paAbort, don't advance framesProcessed
-                        and framesToGo, they will be handled below */
-            }
-            else
-            {
-                bp->timeInfo->inputBufferAdcTime += frameCount * bp->samplePeriod;
-                bp->timeInfo->outputBufferDacTime += frameCount * bp->samplePeriod;
-
-                /* convert output data (user -> host) */
-
-                if( bp->outputChannelCount != 0 && bp->hostOutputChannels[0][0].data )
-                {
-                    if( skipOutputConvert )
-                    {
-                        for( i=0; i<bp->outputChannelCount; ++i )
-                        {
-                            /* advance dest ptr for next iteration */
-                            hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                                    frameCount * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-                        }
-                    }
-                    else
-                    {
-
-                        srcBytePtr = (unsigned char *)bp->tempOutputBuffer;
-
-                        if( bp->userOutputIsInterleaved )
-                        {
-                            srcSampleStrideSamples = bp->outputChannelCount;
-                            srcChannelStrideBytes = bp->bytesPerUserOutputSample;
-                        }
-                        else /* user output is not interleaved */
-                        {
-                            srcSampleStrideSamples = 1;
-                            srcChannelStrideBytes = frameCount * bp->bytesPerUserOutputSample;
-                        }
-
-                        for( i=0; i<bp->outputChannelCount; ++i )
-                        {
-                            bp->outputConverter(    hostOutputChannels[i].data,
-                                                    hostOutputChannels[i].stride,
-                                                    srcBytePtr, srcSampleStrideSamples,
-                                                    frameCount, &bp->ditherGenerator );
-
-                            srcBytePtr += srcChannelStrideBytes;  /* skip to next source channel */
-
-                            /* advance dest ptr for next iteration */
-                            hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                                        frameCount * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-                        }
-                    }
-                }
-
-                framesProcessed += frameCount;
-
-                framesToGo -= frameCount;
-            }
-        }
-        while( framesToGo > 0  && *streamCallbackResult == paContinue );
-    }
-
-    if( framesToGo > 0 )
-    {
-        /* zero any remaining frames output. There will only be remaining frames
-            if the callback has returned paComplete or paAbort */
-
-        frameCount = framesToGo;
-
-        if( bp->outputChannelCount != 0 && bp->hostOutputChannels[0][0].data )
-        {
-            for( i=0; i<bp->outputChannelCount; ++i )
-            {
-                bp->outputZeroer(   hostOutputChannels[i].data,
-                                    hostOutputChannels[i].stride,
-                                    frameCount );
-
-                /* advance dest ptr for next iteration */
-                hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                        frameCount * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-            }
-        }
-
-        framesProcessed += frameCount;
-    }
-
-    return framesProcessed;
-}
-
-
-/*
-    AdaptingInputOnlyProcess() is a half duplex input buffer processor. It
-    converts data from the input buffers into the temporary input buffer,
-    when the temporary input buffer is full, it calls the streamCallback.
-*/
-static unsigned long AdaptingInputOnlyProcess( PaUtilBufferProcessor *bp,
-        int *streamCallbackResult,
-        PaUtilChannelDescriptor *hostInputChannels,
-        unsigned long framesToProcess )
-{
-    void *userInput, *userOutput;
-    unsigned char *destBytePtr;
-    unsigned int destSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int destChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int i;
-    unsigned long frameCount;
-    unsigned long framesToGo = framesToProcess;
-    unsigned long framesProcessed = 0;
-
-    userOutput = 0;
-
-    do
-    {
-        frameCount = ( bp->framesInTempInputBuffer + framesToGo > bp->framesPerUserBuffer )
-                ? ( bp->framesPerUserBuffer - bp->framesInTempInputBuffer )
-                : framesToGo;
-
-        /* convert frameCount samples into temp buffer */
-
-        if( bp->userInputIsInterleaved )
-        {
-            destBytePtr = ((unsigned char*)bp->tempInputBuffer) +
-                    bp->bytesPerUserInputSample * bp->inputChannelCount *
-                    bp->framesInTempInputBuffer;
-
-            destSampleStrideSamples = bp->inputChannelCount;
-            destChannelStrideBytes = bp->bytesPerUserInputSample;
-
-            userInput = bp->tempInputBuffer;
-        }
-        else /* user input is not interleaved */
-        {
-            destBytePtr = ((unsigned char*)bp->tempInputBuffer) +
-                    bp->bytesPerUserInputSample * bp->framesInTempInputBuffer;
-
-            destSampleStrideSamples = 1;
-            destChannelStrideBytes = bp->framesPerUserBuffer * bp->bytesPerUserInputSample;
-
-            /* setup non-interleaved ptrs */
-            for( i=0; i<bp->inputChannelCount; ++i )
-            {
-                bp->tempInputBufferPtrs[i] = ((unsigned char*)bp->tempInputBuffer) +
-                    i * bp->bytesPerUserInputSample * bp->framesPerUserBuffer;
-            }
-
-            userInput = bp->tempInputBufferPtrs;
-        }
-
-        for( i=0; i<bp->inputChannelCount; ++i )
-        {
-            bp->inputConverter( destBytePtr, destSampleStrideSamples,
-                                    hostInputChannels[i].data,
-                                    hostInputChannels[i].stride,
-                                    frameCount, &bp->ditherGenerator );
-
-            destBytePtr += destChannelStrideBytes;  /* skip to next destination channel */
-
-            /* advance src ptr for next iteration */
-            hostInputChannels[i].data = ((unsigned char*)hostInputChannels[i].data) +
-                    frameCount * hostInputChannels[i].stride * bp->bytesPerHostInputSample;
-        }
-
-        bp->framesInTempInputBuffer += frameCount;
-
-        if( bp->framesInTempInputBuffer == bp->framesPerUserBuffer )
-        {
-            /**
-            @todo (non-critical optimisation)
-            The conditional below implements the continue/complete/abort mechanism
-            simply by continuing on iterating through the input buffer, but not
-            passing the data to the callback. With care, the outer loop could be
-            terminated earlier, thus some unneeded conversion cycles would be
-            saved.
-            */
-            if( *streamCallbackResult == paContinue )
-            {
-                bp->timeInfo->outputBufferDacTime = 0;
-
-                *streamCallbackResult = bp->streamCallback( userInput, userOutput,
-                        bp->framesPerUserBuffer, bp->timeInfo,
-                        bp->callbackStatusFlags, bp->userData );
-
-                bp->timeInfo->inputBufferAdcTime += bp->framesPerUserBuffer * bp->samplePeriod;
-            }
-
-            bp->framesInTempInputBuffer = 0;
-        }
-
-        framesProcessed += frameCount;
-
-        framesToGo -= frameCount;
-    }while( framesToGo > 0 );
-
-    return framesProcessed;
-}
-
-
-/*
-    AdaptingOutputOnlyProcess() is a half duplex output buffer processor.
-    It converts data from the temporary output buffer, to the output buffers,
-    when the temporary output buffer is empty, it calls the streamCallback.
-*/
-static unsigned long AdaptingOutputOnlyProcess( PaUtilBufferProcessor *bp,
-        int *streamCallbackResult,
-        PaUtilChannelDescriptor *hostOutputChannels,
-        unsigned long framesToProcess )
-{
-    void *userInput, *userOutput;
-    unsigned char *srcBytePtr;
-    unsigned int srcSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int srcChannelStrideBytes;  /* stride from one channel to the next, in bytes */
-    unsigned int i;
-    unsigned long frameCount;
-    unsigned long framesToGo = framesToProcess;
-    unsigned long framesProcessed = 0;
-
-    do
-    {
-        if( bp->framesInTempOutputBuffer == 0 && *streamCallbackResult == paContinue )
-        {
-            userInput = 0;
-
-            /* setup userOutput */
-            if( bp->userOutputIsInterleaved )
-            {
-                userOutput = bp->tempOutputBuffer;
-            }
-            else /* user output is not interleaved */
-            {
-                for( i = 0; i < bp->outputChannelCount; ++i )
-                {
-                    bp->tempOutputBufferPtrs[i] = ((unsigned char*)bp->tempOutputBuffer) +
-                            i * bp->framesPerUserBuffer * bp->bytesPerUserOutputSample;
-                }
-
-                userOutput = bp->tempOutputBufferPtrs;
-            }
-
-            bp->timeInfo->inputBufferAdcTime = 0;
-
-            *streamCallbackResult = bp->streamCallback( userInput, userOutput,
-                    bp->framesPerUserBuffer, bp->timeInfo,
-                    bp->callbackStatusFlags, bp->userData );
-
-            if( *streamCallbackResult == paAbort )
-            {
-                /* if the callback returned paAbort, we disregard its output */
-            }
-            else
-            {
-                bp->timeInfo->outputBufferDacTime += bp->framesPerUserBuffer * bp->samplePeriod;
-
-                bp->framesInTempOutputBuffer = bp->framesPerUserBuffer;
-            }
-        }
-
-        if( bp->framesInTempOutputBuffer > 0 )
-        {
-            /* convert frameCount frames from user buffer to host buffer */
-
-            frameCount = PA_MIN_( bp->framesInTempOutputBuffer, framesToGo );
-
-            if( bp->userOutputIsInterleaved )
-            {
-                srcBytePtr = ((unsigned char*)bp->tempOutputBuffer) +
-                        bp->bytesPerUserOutputSample * bp->outputChannelCount *
-                        (bp->framesPerUserBuffer - bp->framesInTempOutputBuffer);
-
-                srcSampleStrideSamples = bp->outputChannelCount;
-                srcChannelStrideBytes = bp->bytesPerUserOutputSample;
-            }
-            else /* user output is not interleaved */
-            {
-                srcBytePtr = ((unsigned char*)bp->tempOutputBuffer) +
-                        bp->bytesPerUserOutputSample *
-                        (bp->framesPerUserBuffer - bp->framesInTempOutputBuffer);
-
-                srcSampleStrideSamples = 1;
-                srcChannelStrideBytes = bp->framesPerUserBuffer * bp->bytesPerUserOutputSample;
-            }
-
-            for( i=0; i<bp->outputChannelCount; ++i )
-            {
-                bp->outputConverter(    hostOutputChannels[i].data,
-                                        hostOutputChannels[i].stride,
-                                        srcBytePtr, srcSampleStrideSamples,
-                                        frameCount, &bp->ditherGenerator );
-
-                srcBytePtr += srcChannelStrideBytes;  /* skip to next source channel */
-
-                /* advance dest ptr for next iteration */
-                hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                        frameCount * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-            }
-
-            bp->framesInTempOutputBuffer -= frameCount;
-        }
-        else
-        {
-            /* no more user data is available because the callback has returned
-                paComplete or paAbort. Fill the remainder of the host buffer
-                with zeros.
-            */
-
-            frameCount = framesToGo;
-
-            for( i=0; i<bp->outputChannelCount; ++i )
-            {
-                bp->outputZeroer(   hostOutputChannels[i].data,
-                                    hostOutputChannels[i].stride,
-                                    frameCount );
-
-                /* advance dest ptr for next iteration */
-                hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                        frameCount * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-            }
-        }
-
-        framesProcessed += frameCount;
-
-        framesToGo -= frameCount;
-
-    }while( framesToGo > 0 );
-
-    return framesProcessed;
-}
-
-/* CopyTempOutputBuffersToHostOutputBuffers is called from AdaptingProcess to copy frames from
-    tempOutputBuffer to hostOutputChannels. This includes data conversion
-    and interleaving.
-*/
-static void CopyTempOutputBuffersToHostOutputBuffers( PaUtilBufferProcessor *bp)
-{
-    unsigned long maxFramesToCopy;
-    PaUtilChannelDescriptor *hostOutputChannels;
-    unsigned int frameCount;
-    unsigned char *srcBytePtr;
-    unsigned int srcSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int srcChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int i;
-
-    /* copy frames from user to host output buffers */
-    while( bp->framesInTempOutputBuffer > 0 &&
-            ((bp->hostOutputFrameCount[0] + bp->hostOutputFrameCount[1]) > 0) )
-    {
-        maxFramesToCopy = bp->framesInTempOutputBuffer;
-
-        /* select the output buffer set (1st or 2nd) */
-        if( bp->hostOutputFrameCount[0] > 0 )
-        {
-            hostOutputChannels = bp->hostOutputChannels[0];
-            frameCount = PA_MIN_( bp->hostOutputFrameCount[0], maxFramesToCopy );
-        }
-        else
-        {
-            hostOutputChannels = bp->hostOutputChannels[1];
-            frameCount = PA_MIN_( bp->hostOutputFrameCount[1], maxFramesToCopy );
-        }
-
-        if( bp->userOutputIsInterleaved )
-        {
-            srcBytePtr = ((unsigned char*)bp->tempOutputBuffer) +
-                    bp->bytesPerUserOutputSample * bp->outputChannelCount *
-                    (bp->framesPerUserBuffer - bp->framesInTempOutputBuffer);
-
-            srcSampleStrideSamples = bp->outputChannelCount;
-            srcChannelStrideBytes = bp->bytesPerUserOutputSample;
-        }
-        else /* user output is not interleaved */
-        {
-            srcBytePtr = ((unsigned char*)bp->tempOutputBuffer) +
-                    bp->bytesPerUserOutputSample *
-                    (bp->framesPerUserBuffer - bp->framesInTempOutputBuffer);
-
-            srcSampleStrideSamples = 1;
-            srcChannelStrideBytes = bp->framesPerUserBuffer * bp->bytesPerUserOutputSample;
-        }
-
-        for( i=0; i<bp->outputChannelCount; ++i )
-        {
-            assert( hostOutputChannels[i].data != NULL );
-            bp->outputConverter(    hostOutputChannels[i].data,
-                                    hostOutputChannels[i].stride,
-                                    srcBytePtr, srcSampleStrideSamples,
-                                    frameCount, &bp->ditherGenerator );
-
-            srcBytePtr += srcChannelStrideBytes;  /* skip to next source channel */
-
-            /* advance dest ptr for next iteration */
-            hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                    frameCount * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-        }
-
-        if( bp->hostOutputFrameCount[0] > 0 )
-            bp->hostOutputFrameCount[0] -= frameCount;
-        else
-            bp->hostOutputFrameCount[1] -= frameCount;
-
-        bp->framesInTempOutputBuffer -= frameCount;
-    }
-}
-
-/*
-    AdaptingProcess is a full duplex adapting buffer processor. It converts
-    data from the temporary output buffer into the host output buffers, then
-    from the host input buffers into the temporary input buffers. Calling the
-    streamCallback when necessary.
-    When processPartialUserBuffers is 0, all available input data will be
-    consumed and all available output space will be filled. When
-    processPartialUserBuffers is non-zero, as many full user buffers
-    as possible will be processed, but partial buffers will not be consumed.
-*/
-static unsigned long AdaptingProcess( PaUtilBufferProcessor *bp,
-        int *streamCallbackResult, int processPartialUserBuffers )
-{
-    void *userInput, *userOutput;
-    unsigned long framesProcessed = 0;
-    unsigned long framesAvailable;
-    unsigned long endProcessingMinFrameCount;
-    unsigned long maxFramesToCopy;
-    PaUtilChannelDescriptor *hostInputChannels, *hostOutputChannels;
-    unsigned int frameCount;
-    unsigned char *destBytePtr;
-    unsigned int destSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int destChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int i, j;
-
-
-    framesAvailable = bp->hostInputFrameCount[0] + bp->hostInputFrameCount[1];/* this is assumed to be the same as the output buffer's frame count */
-
-    if( processPartialUserBuffers )
-        endProcessingMinFrameCount = 0;
-    else
-        endProcessingMinFrameCount = (bp->framesPerUserBuffer - 1);
-
-    /* Fill host output with remaining frames in user output (tempOutputBuffer) */
-    CopyTempOutputBuffersToHostOutputBuffers( bp );
-
-    while( framesAvailable > endProcessingMinFrameCount )
-    {
-
-        if( bp->framesInTempOutputBuffer == 0 && *streamCallbackResult != paContinue )
-        {
-            /* the callback will not be called any more, so zero what remains
-                of the host output buffers */
-
-            for( i=0; i<2; ++i )
-            {
-                frameCount = bp->hostOutputFrameCount[i];
-                if( frameCount > 0 )
-                {
-                    hostOutputChannels = bp->hostOutputChannels[i];
-
-                    for( j=0; j<bp->outputChannelCount; ++j )
-                    {
-                        bp->outputZeroer(   hostOutputChannels[j].data,
-                                            hostOutputChannels[j].stride,
-                                            frameCount );
-
-                        /* advance dest ptr for next iteration  */
-                        hostOutputChannels[j].data = ((unsigned char*)hostOutputChannels[j].data) +
-                                frameCount * hostOutputChannels[j].stride * bp->bytesPerHostOutputSample;
-                    }
-                    bp->hostOutputFrameCount[i] = 0;
-                }
-            }
-        }
-
-
-        /* copy frames from host to user input buffers */
-        while( bp->framesInTempInputBuffer < bp->framesPerUserBuffer &&
-                ((bp->hostInputFrameCount[0] + bp->hostInputFrameCount[1]) > 0) )
-        {
-            maxFramesToCopy = bp->framesPerUserBuffer - bp->framesInTempInputBuffer;
-
-            /* select the input buffer set (1st or 2nd) */
-            if( bp->hostInputFrameCount[0] > 0 )
-            {
-                hostInputChannels = bp->hostInputChannels[0];
-                frameCount = PA_MIN_( bp->hostInputFrameCount[0], maxFramesToCopy );
-            }
-            else
-            {
-                hostInputChannels = bp->hostInputChannels[1];
-                frameCount = PA_MIN_( bp->hostInputFrameCount[1], maxFramesToCopy );
-            }
-
-            /* configure conversion destination pointers */
-            if( bp->userInputIsInterleaved )
-            {
-                destBytePtr = ((unsigned char*)bp->tempInputBuffer) +
-                        bp->bytesPerUserInputSample * bp->inputChannelCount *
-                        bp->framesInTempInputBuffer;
-
-                destSampleStrideSamples = bp->inputChannelCount;
-                destChannelStrideBytes = bp->bytesPerUserInputSample;
-            }
-            else /* user input is not interleaved */
-            {
-                destBytePtr = ((unsigned char*)bp->tempInputBuffer) +
-                        bp->bytesPerUserInputSample * bp->framesInTempInputBuffer;
-
-                destSampleStrideSamples = 1;
-                destChannelStrideBytes = bp->framesPerUserBuffer * bp->bytesPerUserInputSample;
-            }
-
-            for( i=0; i<bp->inputChannelCount; ++i )
-            {
-                bp->inputConverter( destBytePtr, destSampleStrideSamples,
-                                        hostInputChannels[i].data,
-                                        hostInputChannels[i].stride,
-                                        frameCount, &bp->ditherGenerator );
-
-                destBytePtr += destChannelStrideBytes;  /* skip to next destination channel */
-
-                /* advance src ptr for next iteration */
-                hostInputChannels[i].data = ((unsigned char*)hostInputChannels[i].data) +
-                        frameCount * hostInputChannels[i].stride * bp->bytesPerHostInputSample;
-            }
-
-            if( bp->hostInputFrameCount[0] > 0 )
-                bp->hostInputFrameCount[0] -= frameCount;
-            else
-                bp->hostInputFrameCount[1] -= frameCount;
-
-            bp->framesInTempInputBuffer += frameCount;
-
-            /* update framesAvailable and framesProcessed based on input consumed
-                unless something is very wrong this will also correspond to the
-                amount of output generated */
-            framesAvailable -= frameCount;
-            framesProcessed += frameCount;
-        }
-
-        /* call streamCallback */
-        if( bp->framesInTempInputBuffer == bp->framesPerUserBuffer &&
-            bp->framesInTempOutputBuffer == 0 )
-        {
-            if( *streamCallbackResult == paContinue )
-            {
-                /* setup userInput */
-                if( bp->userInputIsInterleaved )
-                {
-                    userInput = bp->tempInputBuffer;
-                }
-                else /* user input is not interleaved */
-                {
-                    for( i = 0; i < bp->inputChannelCount; ++i )
-                    {
-                        bp->tempInputBufferPtrs[i] = ((unsigned char*)bp->tempInputBuffer) +
-                                i * bp->framesPerUserBuffer * bp->bytesPerUserInputSample;
-                    }
-
-                    userInput = bp->tempInputBufferPtrs;
-                }
-
-                /* setup userOutput */
-                if( bp->userOutputIsInterleaved )
-                {
-                    userOutput = bp->tempOutputBuffer;
-                }
-                else /* user output is not interleaved */
-                {
-                    for( i = 0; i < bp->outputChannelCount; ++i )
-                    {
-                        bp->tempOutputBufferPtrs[i] = ((unsigned char*)bp->tempOutputBuffer) +
-                                i * bp->framesPerUserBuffer * bp->bytesPerUserOutputSample;
-                    }
-
-                    userOutput = bp->tempOutputBufferPtrs;
-                }
-
-                /* call streamCallback */
-
-                *streamCallbackResult = bp->streamCallback( userInput, userOutput,
-                        bp->framesPerUserBuffer, bp->timeInfo,
-                        bp->callbackStatusFlags, bp->userData );
-
-                bp->timeInfo->inputBufferAdcTime += bp->framesPerUserBuffer * bp->samplePeriod;
-                bp->timeInfo->outputBufferDacTime += bp->framesPerUserBuffer * bp->samplePeriod;
-
-                bp->framesInTempInputBuffer = 0;
-
-                if( *streamCallbackResult == paAbort )
-                    bp->framesInTempOutputBuffer = 0;
-                else
-                    bp->framesInTempOutputBuffer = bp->framesPerUserBuffer;
-            }
-            else
-            {
-                /* paComplete or paAbort has already been called. */
-
-                bp->framesInTempInputBuffer = 0;
-            }
-        }
-
-        /* copy frames from user (tempOutputBuffer) to host output buffers (hostOutputChannels)
-           Means to process the user output provided by the callback. Has to be called after
-            each callback. */
-        CopyTempOutputBuffersToHostOutputBuffers( bp );
-
-    }
-
-    return framesProcessed;
-}
-
-
-unsigned long PaUtil_EndBufferProcessing( PaUtilBufferProcessor* bp, int *streamCallbackResult )
-{
-    unsigned long framesToProcess, framesToGo;
-    unsigned long framesProcessed = 0;
-
-    if( bp->inputChannelCount != 0 && bp->outputChannelCount != 0
-            && bp->hostInputChannels[0][0].data /* input was supplied (see PaUtil_SetNoInput) */
-            && bp->hostOutputChannels[0][0].data /* output was supplied (see PaUtil_SetNoOutput) */ )
-    {
-        assert( (bp->hostInputFrameCount[0] + bp->hostInputFrameCount[1]) ==
-                (bp->hostOutputFrameCount[0] + bp->hostOutputFrameCount[1]) );
-    }
-
-    assert( *streamCallbackResult == paContinue
-            || *streamCallbackResult == paComplete
-            || *streamCallbackResult == paAbort ); /* don't forget to pass in a valid callback result value */
-
-    if( bp->useNonAdaptingProcess )
-    {
-        if( bp->inputChannelCount != 0 && bp->outputChannelCount != 0 )
-        {
-            /* full duplex non-adapting process, splice buffers if they are
-                different lengths */
-
-            framesToGo = bp->hostOutputFrameCount[0] + bp->hostOutputFrameCount[1]; /* relies on assert above for input/output equivalence */
-
-            do{
-                unsigned long noInputInputFrameCount;
-                unsigned long *hostInputFrameCount;
-                PaUtilChannelDescriptor *hostInputChannels;
-                unsigned long noOutputOutputFrameCount;
-                unsigned long *hostOutputFrameCount;
-                PaUtilChannelDescriptor *hostOutputChannels;
-                unsigned long framesProcessedThisIteration;
-
-                if( !bp->hostInputChannels[0][0].data )
-                {
-                    /* no input was supplied (see PaUtil_SetNoInput)
-                        NonAdaptingProcess knows how to deal with this
-                    */
-                    noInputInputFrameCount = framesToGo;
-                    hostInputFrameCount = &noInputInputFrameCount;
-                    hostInputChannels = 0;
-                }
-                else if( bp->hostInputFrameCount[0] != 0 )
-                {
-                    hostInputFrameCount = &bp->hostInputFrameCount[0];
-                    hostInputChannels = bp->hostInputChannels[0];
-                }
-                else
-                {
-                    hostInputFrameCount = &bp->hostInputFrameCount[1];
-                    hostInputChannels = bp->hostInputChannels[1];
-                }
-
-                if( !bp->hostOutputChannels[0][0].data )
-                {
-                    /* no output was supplied (see PaUtil_SetNoOutput)
-                        NonAdaptingProcess knows how to deal with this
-                    */
-                    noOutputOutputFrameCount = framesToGo;
-                    hostOutputFrameCount = &noOutputOutputFrameCount;
-                    hostOutputChannels = 0;
-                }
-                if( bp->hostOutputFrameCount[0] != 0 )
-                {
-                    hostOutputFrameCount = &bp->hostOutputFrameCount[0];
-                    hostOutputChannels = bp->hostOutputChannels[0];
-                }
-                else
-                {
-                    hostOutputFrameCount = &bp->hostOutputFrameCount[1];
-                    hostOutputChannels = bp->hostOutputChannels[1];
-                }
-
-                framesToProcess = PA_MIN_( *hostInputFrameCount,
-                                       *hostOutputFrameCount );
-
-                assert( framesToProcess != 0 );
-
-                framesProcessedThisIteration = NonAdaptingProcess( bp, streamCallbackResult,
-                        hostInputChannels, hostOutputChannels,
-                        framesToProcess );
-
-                *hostInputFrameCount -= framesProcessedThisIteration;
-                *hostOutputFrameCount -= framesProcessedThisIteration;
-
-                framesProcessed += framesProcessedThisIteration;
-                framesToGo -= framesProcessedThisIteration;
-
-            }while( framesToGo > 0 );
-        }
-        else
-        {
-            /* half duplex non-adapting process, just process 1st and 2nd buffer */
-            /* process first buffer */
-
-            framesToProcess = (bp->inputChannelCount != 0)
-                            ? bp->hostInputFrameCount[0]
-                            : bp->hostOutputFrameCount[0];
-
-            framesProcessed = NonAdaptingProcess( bp, streamCallbackResult,
-                        bp->hostInputChannels[0], bp->hostOutputChannels[0],
-                        framesToProcess );
-
-            /* process second buffer if provided */
-
-            framesToProcess = (bp->inputChannelCount != 0)
-                            ? bp->hostInputFrameCount[1]
-                            : bp->hostOutputFrameCount[1];
-            if( framesToProcess > 0 )
-            {
-                framesProcessed += NonAdaptingProcess( bp, streamCallbackResult,
-                    bp->hostInputChannels[1], bp->hostOutputChannels[1],
-                    framesToProcess );
-            }
-        }
-    }
-    else /* block adaption necessary*/
-    {
-
-        if( bp->inputChannelCount != 0 && bp->outputChannelCount != 0 )
-        {
-            /* full duplex */
-
-            if( bp->hostBufferSizeMode == paUtilVariableHostBufferSizePartialUsageAllowed  )
-            {
-                framesProcessed = AdaptingProcess( bp, streamCallbackResult,
-                        0 /* dont process partial user buffers */ );
-            }
-            else
-            {
-                framesProcessed = AdaptingProcess( bp, streamCallbackResult,
-                        1 /* process partial user buffers */ );
-            }
-        }
-        else if( bp->inputChannelCount != 0 )
-        {
-            /* input only */
-            framesToProcess = bp->hostInputFrameCount[0];
-
-            framesProcessed = AdaptingInputOnlyProcess( bp, streamCallbackResult,
-                        bp->hostInputChannels[0], framesToProcess );
-
-            framesToProcess = bp->hostInputFrameCount[1];
-            if( framesToProcess > 0 )
-            {
-                framesProcessed += AdaptingInputOnlyProcess( bp, streamCallbackResult,
-                        bp->hostInputChannels[1], framesToProcess );
-            }
-        }
-        else
-        {
-            /* output only */
-            framesToProcess = bp->hostOutputFrameCount[0];
-
-            framesProcessed = AdaptingOutputOnlyProcess( bp, streamCallbackResult,
-                        bp->hostOutputChannels[0], framesToProcess );
-
-            framesToProcess = bp->hostOutputFrameCount[1];
-            if( framesToProcess > 0 )
-            {
-                framesProcessed += AdaptingOutputOnlyProcess( bp, streamCallbackResult,
-                        bp->hostOutputChannels[1], framesToProcess );
-            }
-        }
-    }
-
-    return framesProcessed;
-}
-
-
-int PaUtil_IsBufferProcessorOutputEmpty( PaUtilBufferProcessor* bp )
-{
-    return (bp->framesInTempOutputBuffer) ? 0 : 1;
-}
-
-
-unsigned long PaUtil_CopyInput( PaUtilBufferProcessor* bp,
-        void **buffer, unsigned long frameCount )
-{
-    PaUtilChannelDescriptor *hostInputChannels;
-    unsigned int framesToCopy;
-    unsigned char *destBytePtr;
-    void **nonInterleavedDestPtrs;
-    unsigned int destSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int destChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int i;
-
-    hostInputChannels = bp->hostInputChannels[0];
-    framesToCopy = PA_MIN_( bp->hostInputFrameCount[0], frameCount );
-
-    if( bp->userInputIsInterleaved )
-    {
-        destBytePtr = (unsigned char*)*buffer;
-
-        destSampleStrideSamples = bp->inputChannelCount;
-        destChannelStrideBytes = bp->bytesPerUserInputSample;
-
-        for( i=0; i<bp->inputChannelCount; ++i )
-        {
-            bp->inputConverter( destBytePtr, destSampleStrideSamples,
-                                hostInputChannels[i].data,
-                                hostInputChannels[i].stride,
-                                framesToCopy, &bp->ditherGenerator );
-
-            destBytePtr += destChannelStrideBytes;  /* skip to next dest channel */
-
-            /* advance source ptr for next iteration */
-            hostInputChannels[i].data = ((unsigned char*)hostInputChannels[i].data) +
-                    framesToCopy * hostInputChannels[i].stride * bp->bytesPerHostInputSample;
-        }
-
-        /* advance callers dest pointer (buffer) */
-        *buffer = ((unsigned char *)*buffer) +
-                framesToCopy * bp->inputChannelCount * bp->bytesPerUserInputSample;
-    }
-    else
-    {
-        /* user input is not interleaved */
-
-        nonInterleavedDestPtrs = (void**)*buffer;
-
-        destSampleStrideSamples = 1;
-
-        for( i=0; i<bp->inputChannelCount; ++i )
-        {
-            destBytePtr = (unsigned char*)nonInterleavedDestPtrs[i];
-
-            bp->inputConverter( destBytePtr, destSampleStrideSamples,
-                                hostInputChannels[i].data,
-                                hostInputChannels[i].stride,
-                                framesToCopy, &bp->ditherGenerator );
-
-            /* advance callers dest pointer (nonInterleavedDestPtrs[i]) */
-            destBytePtr += bp->bytesPerUserInputSample * framesToCopy;
-            nonInterleavedDestPtrs[i] = destBytePtr;
-
-            /* advance source ptr for next iteration */
-            hostInputChannels[i].data = ((unsigned char*)hostInputChannels[i].data) +
-                    framesToCopy * hostInputChannels[i].stride * bp->bytesPerHostInputSample;
-        }
-    }
-
-    bp->hostInputFrameCount[0] -= framesToCopy;
-
-    return framesToCopy;
-}
-
-unsigned long PaUtil_CopyOutput( PaUtilBufferProcessor* bp,
-        const void ** buffer, unsigned long frameCount )
-{
-    PaUtilChannelDescriptor *hostOutputChannels;
-    unsigned int framesToCopy;
-    unsigned char *srcBytePtr;
-    void **nonInterleavedSrcPtrs;
-    unsigned int srcSampleStrideSamples; /* stride from one sample to the next within a channel, in samples */
-    unsigned int srcChannelStrideBytes; /* stride from one channel to the next, in bytes */
-    unsigned int i;
-
-    hostOutputChannels = bp->hostOutputChannels[0];
-    framesToCopy = PA_MIN_( bp->hostOutputFrameCount[0], frameCount );
-
-    if( bp->userOutputIsInterleaved )
-    {
-        srcBytePtr = (unsigned char*)*buffer;
-
-        srcSampleStrideSamples = bp->outputChannelCount;
-        srcChannelStrideBytes = bp->bytesPerUserOutputSample;
-
-        for( i=0; i<bp->outputChannelCount; ++i )
-        {
-            bp->outputConverter(    hostOutputChannels[i].data,
-                                    hostOutputChannels[i].stride,
-                                    srcBytePtr, srcSampleStrideSamples,
-                                    framesToCopy, &bp->ditherGenerator );
-
-            srcBytePtr += srcChannelStrideBytes;  /* skip to next source channel */
-
-            /* advance dest ptr for next iteration */
-            hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                    framesToCopy * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-        }
-
-        /* advance callers source pointer (buffer) */
-        *buffer = ((unsigned char *)*buffer) +
-                framesToCopy * bp->outputChannelCount * bp->bytesPerUserOutputSample;
-
-    }
-    else
-    {
-        /* user output is not interleaved */
-
-        nonInterleavedSrcPtrs = (void**)*buffer;
-
-        srcSampleStrideSamples = 1;
-
-        for( i=0; i<bp->outputChannelCount; ++i )
-        {
-            srcBytePtr = (unsigned char*)nonInterleavedSrcPtrs[i];
-
-            bp->outputConverter(    hostOutputChannels[i].data,
-                                    hostOutputChannels[i].stride,
-                                    srcBytePtr, srcSampleStrideSamples,
-                                    framesToCopy, &bp->ditherGenerator );
-
-
-            /* advance callers source pointer (nonInterleavedSrcPtrs[i]) */
-            srcBytePtr += bp->bytesPerUserOutputSample * framesToCopy;
-            nonInterleavedSrcPtrs[i] = srcBytePtr;
-
-            /* advance dest ptr for next iteration */
-            hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                    framesToCopy * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-        }
-    }
-
-    bp->hostOutputFrameCount[0] += framesToCopy;
-
-    return framesToCopy;
-}
-
-
-unsigned long PaUtil_ZeroOutput( PaUtilBufferProcessor* bp, unsigned long frameCount )
-{
-    PaUtilChannelDescriptor *hostOutputChannels;
-    unsigned int framesToZero;
-    unsigned int i;
-
-    hostOutputChannels = bp->hostOutputChannels[0];
-    framesToZero = PA_MIN_( bp->hostOutputFrameCount[0], frameCount );
-
-    for( i=0; i<bp->outputChannelCount; ++i )
-    {
-        bp->outputZeroer(   hostOutputChannels[i].data,
-                            hostOutputChannels[i].stride,
-                            framesToZero );
-
-
-        /* advance dest ptr for next iteration */
-        hostOutputChannels[i].data = ((unsigned char*)hostOutputChannels[i].data) +
-                framesToZero * hostOutputChannels[i].stride * bp->bytesPerHostOutputSample;
-    }
-
-    bp->hostOutputFrameCount[0] += framesToZero;
-
-    return framesToZero;
-}
diff --git a/portaudio/src/common/pa_process.h b/portaudio/src/common/pa_process.h
deleted file mode 100644
index 444bdf5..0000000
--- a/portaudio/src/common/pa_process.h
+++ /dev/null
@@ -1,754 +0,0 @@
-#ifndef PA_PROCESS_H
-#define PA_PROCESS_H
-/*
- * $Id$
- * Portable Audio I/O Library callback buffer processing adapters
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2002 Phil Burk, Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Buffer Processor prototypes. A Buffer Processor performs buffer length
- adaption, coordinates sample format conversion, and interleaves/deinterleaves
- channels.
-
- <h3>Overview</h3>
-
- The "Buffer Processor" (PaUtilBufferProcessor) manages conversion of audio
- data from host buffers to user buffers and back again. Where required, the
- buffer processor takes care of converting between host and user sample formats,
- interleaving and deinterleaving multichannel buffers, and adapting between host
- and user buffers with different lengths. The buffer processor may be used with
- full and half duplex streams, for both callback streams and blocking read/write
- streams.
-
- One of the important capabilities provided by the buffer processor is
- the ability to adapt between user and host buffer sizes of different lengths
- with minimum latency. Although this task is relatively easy to perform when
- the host buffer size is an integer multiple of the user buffer size, the
- problem is more complicated when this is not the case - especially for
- full-duplex callback streams. Where necessary the adaption is implemented by
- internally buffering some input and/or output data. The buffer adation
- algorithm used by the buffer processor was originally implemented by
- Stephan Letz for the ASIO version of PortAudio, and is described in his
- Callback_adaption_.pdf which is included in the distribution.
-
- The buffer processor performs sample conversion using the functions provided
- by pa_converters.c.
-
- The following sections provide an overview of how to use the buffer processor.
- Interested readers are advised to consult the host API implementations for
- examples of buffer processor usage.
-
-
- <h4>Initialization, resetting and termination</h4>
-
- When a stream is opened, the buffer processor should be initialized using
- PaUtil_InitializeBufferProcessor. This function initializes internal state
- and allocates temporary buffers as necessary according to the supplied
- configuration parameters. Some of the parameters correspond to those requested
- by the user in their call to Pa_OpenStream(), others reflect the requirements
- of the host API implementation - they indicate host buffer sizes, formats,
- and the type of buffering which the Host API uses. The buffer processor should
- be initialized for callback streams and blocking read/write streams.
-
- Call PaUtil_ResetBufferProcessor to clear any sample data which is present
- in the buffer processor before starting to use it (for example when
- Pa_StartStream is called).
-
- When the buffer processor is no longer used call
- PaUtil_TerminateBufferProcessor.
-
-
- <h4>Using the buffer processor for a callback stream</h4>
-
- The buffer processor's role in a callback stream is to take host input buffers
- process them with the stream callback, and fill host output buffers. For a
- full duplex stream, the buffer processor handles input and output simultaneously
- due to the requirements of the minimum-latency buffer adation algorithm.
-
- When a host buffer becomes available, the implementation should call
- the buffer processor to process the buffer. The buffer processor calls the
- stream callback to consume and/or produce audio data as necessary. The buffer
- processor will convert sample formats, interleave/deinterleave channels,
- and slice or chunk the data to the appropriate buffer lengths according to
- the requirements of the stream callback and the host API.
-
- To process a host buffer (or a pair of host buffers for a full-duplex stream)
- use the following calling sequence:
-
- -# Call PaUtil_BeginBufferProcessing
- -# For a stream which takes input:
-    - Call PaUtil_SetInputFrameCount with the number of frames in the host input
-        buffer.
-    - Call one of the following functions one or more times to tell the
-        buffer processor about the host input buffer(s): PaUtil_SetInputChannel,
-        PaUtil_SetInterleavedInputChannels, PaUtil_SetNonInterleavedInputChannel.
-        Which function you call will depend on whether the host buffer(s) are
-        interleaved or not.
-    - If the available host data is split across two buffers (for example a
-        data range at the end of a circular buffer and another range at the
-        beginning of the circular buffer), also call
-        PaUtil_Set2ndInputFrameCount, PaUtil_Set2ndInputChannel,
-        PaUtil_Set2ndInterleavedInputChannels,
-        PaUtil_Set2ndNonInterleavedInputChannel as necessary to tell the buffer
-        processor about the second buffer.
- -# For a stream which generates output:
-    - Call PaUtil_SetOutputFrameCount with the number of frames in the host
-        output buffer.
-    - Call one of the following functions one or more times to tell the
-        buffer processor about the host output buffer(s): PaUtil_SetOutputChannel,
-        PaUtil_SetInterleavedOutputChannels, PaUtil_SetNonInterleavedOutputChannel.
-        Which function you call will depend on whether the host buffer(s) are
-        interleaved or not.
-    - If the available host output buffer space is split across two buffers
-        (for example a data range at the end of a circular buffer and another
-        range at the beginning of the circular buffer), call
-        PaUtil_Set2ndOutputFrameCount, PaUtil_Set2ndOutputChannel,
-        PaUtil_Set2ndInterleavedOutputChannels,
-        PaUtil_Set2ndNonInterleavedOutputChannel as necessary to tell the buffer
-        processor about the second buffer.
- -# Call PaUtil_EndBufferProcessing, this function performs the actual data
-    conversion and processing.
-
-
- <h4>Using the buffer processor for a blocking read/write stream</h4>
-
- Blocking read/write streams use the buffer processor to convert and copy user
- output data to a host buffer, and to convert and copy host input data to
- the user's buffer. The buffer processor does not perform any buffer adaption.
- When using the buffer processor in a blocking read/write stream the input and
- output conversion are performed separately by the PaUtil_CopyInput and
- PaUtil_CopyOutput functions.
-
- To copy data from a host input buffer to the buffer(s) which the user supplies
- to Pa_ReadStream, use the following calling sequence.
-
- - Repeat the following three steps until the user buffer(s) have been filled
-    with samples from the host input buffers:
-     -# Call PaUtil_SetInputFrameCount with the number of frames in the host
-        input buffer.
-     -# Call one of the following functions one or more times to tell the
-        buffer processor about the host input buffer(s): PaUtil_SetInputChannel,
-        PaUtil_SetInterleavedInputChannels, PaUtil_SetNonInterleavedInputChannel.
-        Which function you call will depend on whether the host buffer(s) are
-        interleaved or not.
-     -# Call PaUtil_CopyInput with the user buffer pointer (or a copy of the
-        array of buffer pointers for a non-interleaved stream) passed to
-        Pa_ReadStream, along with the number of frames in the user buffer(s).
-        Be careful to pass a <i>copy</i> of the user buffer pointers to
-        PaUtil_CopyInput because PaUtil_CopyInput advances the pointers to
-        the start of the next region to copy.
- - PaUtil_CopyInput will not copy more data than is available in the
-    host buffer(s), so the above steps need to be repeated until the user
-    buffer(s) are full.
-
-
- To copy data to the host output buffer from the user buffers(s) supplied
- to Pa_WriteStream use the following calling sequence.
-
- - Repeat the following three steps until all frames from the user buffer(s)
-    have been copied to the host API:
-     -# Call PaUtil_SetOutputFrameCount with the number of frames in the host
-        output buffer.
-     -# Call one of the following functions one or more times to tell the
-        buffer processor about the host output buffer(s): PaUtil_SetOutputChannel,
-        PaUtil_SetInterleavedOutputChannels, PaUtil_SetNonInterleavedOutputChannel.
-        Which function you call will depend on whether the host buffer(s) are
-        interleaved or not.
-     -# Call PaUtil_CopyOutput with the user buffer pointer (or a copy of the
-        array of buffer pointers for a non-interleaved stream) passed to
-        Pa_WriteStream, along with the number of frames in the user buffer(s).
-        Be careful to pass a <i>copy</i> of the user buffer pointers to
-        PaUtil_CopyOutput because PaUtil_CopyOutput advances the pointers to
-        the start of the next region to copy.
- - PaUtil_CopyOutput will not copy more data than fits in the host buffer(s),
-    so the above steps need to be repeated until all user data is copied.
-*/
-
-
-#include "portaudio.h"
-#include "pa_converters.h"
-#include "pa_dither.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-/** @brief Mode flag passed to PaUtil_InitializeBufferProcessor indicating the type
- of buffering that the host API uses.
-
- The mode used depends on whether the host API or the implementation manages
- the buffers, and how these buffers are used (scatter gather, circular buffer).
-*/
-typedef enum {
-/** The host buffer size is a fixed known size. */
-    paUtilFixedHostBufferSize,
-
-/** The host buffer size may vary, but has a known maximum size. */
-    paUtilBoundedHostBufferSize,
-
-/** Nothing is known about the host buffer size. */
-    paUtilUnknownHostBufferSize,
-
-/** The host buffer size varies, and the client does not require the buffer
- processor to consume all of the input and fill all of the output buffer. This
- is useful when the implementation has access to the host API's circular buffer
- and only needs to consume/fill some of it, not necessarily all of it, with each
- call to the buffer processor. This is the only mode where
- PaUtil_EndBufferProcessing() may not consume the whole buffer.
-*/
-    paUtilVariableHostBufferSizePartialUsageAllowed
-}PaUtilHostBufferSizeMode;
-
-
-/** @brief An auxiliary data structure used internally by the buffer processor
- to represent host input and output buffers. */
-typedef struct PaUtilChannelDescriptor{
-    void *data;
-    unsigned int stride;  /**< stride in samples, not bytes */
-}PaUtilChannelDescriptor;
-
-
-/** @brief The main buffer processor data structure.
-
- Allocate one of these, initialize it with PaUtil_InitializeBufferProcessor
- and terminate it with PaUtil_TerminateBufferProcessor.
-*/
-typedef struct {
-    unsigned long framesPerUserBuffer;
-    unsigned long framesPerHostBuffer;
-
-    PaUtilHostBufferSizeMode hostBufferSizeMode;
-    int useNonAdaptingProcess;
-    int userOutputSampleFormatIsEqualToHost;
-    int userInputSampleFormatIsEqualToHost;
-    unsigned long framesPerTempBuffer;
-
-    unsigned int inputChannelCount;
-    unsigned int bytesPerHostInputSample;
-    unsigned int bytesPerUserInputSample;
-    int userInputIsInterleaved;
-    PaUtilConverter *inputConverter;
-    PaUtilZeroer *inputZeroer;
-
-    unsigned int outputChannelCount;
-    unsigned int bytesPerHostOutputSample;
-    unsigned int bytesPerUserOutputSample;
-    int userOutputIsInterleaved;
-    PaUtilConverter *outputConverter;
-    PaUtilZeroer *outputZeroer;
-
-    unsigned long initialFramesInTempInputBuffer;
-    unsigned long initialFramesInTempOutputBuffer;
-
-    void *tempInputBuffer;          /**< used for slips, block adaption, and conversion. */
-    void **tempInputBufferPtrs;     /**< storage for non-interleaved buffer pointers, NULL for interleaved user input */
-    unsigned long framesInTempInputBuffer; /**< frames remaining in input buffer from previous adaption iteration */
-
-    void *tempOutputBuffer;         /**< used for slips, block adaption, and conversion. */
-    void **tempOutputBufferPtrs;    /**< storage for non-interleaved buffer pointers, NULL for interleaved user output */
-    unsigned long framesInTempOutputBuffer; /**< frames remaining in input buffer from previous adaption iteration */
-
-    PaStreamCallbackTimeInfo *timeInfo;
-
-    PaStreamCallbackFlags callbackStatusFlags;
-
-    int hostInputIsInterleaved;
-    unsigned long hostInputFrameCount[2];
-    PaUtilChannelDescriptor *hostInputChannels[2]; /**< pointers to arrays of channel descriptors.
-                                                        pointers are NULL for half-duplex output processing.
-                                                        hostInputChannels[i].data is NULL when the caller
-                                                        calls PaUtil_SetNoInput()
-                                                        */
-    int hostOutputIsInterleaved;
-    unsigned long hostOutputFrameCount[2];
-    PaUtilChannelDescriptor *hostOutputChannels[2]; /**< pointers to arrays of channel descriptors.
-                                                         pointers are NULL for half-duplex input processing.
-                                                         hostOutputChannels[i].data is NULL when the caller
-                                                         calls PaUtil_SetNoOutput()
-                                                         */
-
-    PaUtilTriangularDitherGenerator ditherGenerator;
-
-    double samplePeriod;
-
-    PaStreamCallback *streamCallback;
-    void *userData;
-} PaUtilBufferProcessor;
-
-
-/** @name Initialization, termination, resetting and info */
-/*@{*/
-
-/** Initialize a buffer processor's representation stored in a
- PaUtilBufferProcessor structure. Be sure to call
- PaUtil_TerminateBufferProcessor after finishing with a buffer processor.
-
- @param bufferProcessor The buffer processor structure to initialize.
-
- @param inputChannelCount The number of input channels as passed to
- Pa_OpenStream or 0 for an output-only stream.
-
- @param userInputSampleFormat Format of user input samples, as passed to
- Pa_OpenStream. This parameter is ignored for ouput-only streams.
-
- @param hostInputSampleFormat Format of host input samples. This parameter is
- ignored for output-only streams. See note about host buffer interleave below.
-
- @param outputChannelCount The number of output channels as passed to
- Pa_OpenStream or 0 for an input-only stream.
-
- @param userOutputSampleFormat Format of user output samples, as passed to
- Pa_OpenStream. This parameter is ignored for input-only streams.
-
- @param hostOutputSampleFormat Format of host output samples. This parameter is
- ignored for input-only streams. See note about host buffer interleave below.
-
- @param sampleRate Sample rate of the stream. The more accurate this is the
- better - it is used for updating time stamps when adapting buffers.
-
- @param streamFlags Stream flags as passed to Pa_OpenStream, this parameter is
- used for selecting special sample conversion options such as clipping and
- dithering.
-
- @param framesPerUserBuffer Number of frames per user buffer, as requested
- by the framesPerBuffer parameter to Pa_OpenStream. This parameter may be
- zero to indicate that the user will accept any (and varying) buffer sizes.
-
- @param framesPerHostBuffer Specifies the number of frames per host buffer
- for the fixed buffer size mode, and the maximum number of frames
- per host buffer for the bounded host buffer size mode. It is ignored for
- the other modes.
-
- @param hostBufferSizeMode A mode flag indicating the size variability of
- host buffers that will be passed to the buffer processor. See
- PaUtilHostBufferSizeMode for further details.
-
- @param streamCallback The user stream callback passed to Pa_OpenStream.
-
- @param userData The user data field passed to Pa_OpenStream.
-
- @note The interleave flag is ignored for host buffer formats. Host
- interleave is determined by the use of different SetInput and SetOutput
- functions.
-
- @return An error code indicating whether the initialization was successful.
- If the error code is not PaNoError, the buffer processor was not initialized
- and should not be used.
-
- @see Pa_OpenStream, PaUtilHostBufferSizeMode, PaUtil_TerminateBufferProcessor
-*/
-PaError PaUtil_InitializeBufferProcessor( PaUtilBufferProcessor* bufferProcessor,
-            int inputChannelCount, PaSampleFormat userInputSampleFormat,
-            PaSampleFormat hostInputSampleFormat,
-            int outputChannelCount, PaSampleFormat userOutputSampleFormat,
-            PaSampleFormat hostOutputSampleFormat,
-            double sampleRate,
-            PaStreamFlags streamFlags,
-            unsigned long framesPerUserBuffer, /* 0 indicates don't care */
-            unsigned long framesPerHostBuffer,
-            PaUtilHostBufferSizeMode hostBufferSizeMode,
-            PaStreamCallback *streamCallback, void *userData );
-
-
-/** Terminate a buffer processor's representation. Deallocates any temporary
- buffers allocated by PaUtil_InitializeBufferProcessor.
-
- @param bufferProcessor The buffer processor structure to terminate.
-
- @see PaUtil_InitializeBufferProcessor.
-*/
-void PaUtil_TerminateBufferProcessor( PaUtilBufferProcessor* bufferProcessor );
-
-
-/** Clear any internally buffered data. If you call
- PaUtil_InitializeBufferProcessor in your OpenStream routine, make sure you
- call PaUtil_ResetBufferProcessor in your StartStream call.
-
- @param bufferProcessor The buffer processor to reset.
-*/
-void PaUtil_ResetBufferProcessor( PaUtilBufferProcessor* bufferProcessor );
-
-
-/** Retrieve the input latency of a buffer processor, in frames.
-
- @param bufferProcessor The buffer processor examine.
-
- @return The input latency introduced by the buffer processor, in frames.
-
- @see PaUtil_GetBufferProcessorOutputLatencyFrames
-*/
-unsigned long PaUtil_GetBufferProcessorInputLatencyFrames( PaUtilBufferProcessor* bufferProcessor );
-
-/** Retrieve the output latency of a buffer processor, in frames.
-
- @param bufferProcessor The buffer processor examine.
-
- @return The output latency introduced by the buffer processor, in frames.
-
- @see PaUtil_GetBufferProcessorInputLatencyFrames
-*/
-unsigned long PaUtil_GetBufferProcessorOutputLatencyFrames( PaUtilBufferProcessor* bufferProcessor );
-
-/*@}*/
-
-
-/** @name Host buffer pointer configuration
-
- Functions to set host input and output buffers, used by both callback streams
- and blocking read/write streams.
-*/
-/*@{*/
-
-
-/** Set the number of frames in the input host buffer(s) specified by the
- PaUtil_Set*InputChannel functions.
-
- @param bufferProcessor The buffer processor.
-
- @param frameCount The number of host input frames. A 0 frameCount indicates to
- use the framesPerHostBuffer value passed to PaUtil_InitializeBufferProcessor.
-
- @see PaUtil_SetNoInput, PaUtil_SetInputChannel,
- PaUtil_SetInterleavedInputChannels, PaUtil_SetNonInterleavedInputChannel
-*/
-void PaUtil_SetInputFrameCount( PaUtilBufferProcessor* bufferProcessor,
-        unsigned long frameCount );
-
-
-/** Indicate that no input is available. This function should be used when
- priming the output of a full-duplex stream opened with the
- paPrimeOutputBuffersUsingStreamCallback flag. Note that it is not necessary
- to call this or any other PaUtil_Set*Input* functions for ouput-only streams.
-
- @param bufferProcessor The buffer processor.
-*/
-void PaUtil_SetNoInput( PaUtilBufferProcessor* bufferProcessor );
-
-
-/** Provide the buffer processor with a pointer to a host input channel.
-
- @param bufferProcessor The buffer processor.
- @param channel The channel number.
- @param data The buffer.
- @param stride The stride from one sample to the next, in samples. For
- interleaved host buffers, the stride will usually be the same as the number of
- channels in the buffer.
-*/
-void PaUtil_SetInputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data, unsigned int stride );
-
-
-/** Provide the buffer processor with a pointer to an number of interleaved
- host input channels.
-
- @param bufferProcessor The buffer processor.
- @param firstChannel The first channel number.
- @param data The buffer.
- @param channelCount The number of interleaved channels in the buffer. If
- channelCount is zero, the number of channels specified to
- PaUtil_InitializeBufferProcessor will be used.
-*/
-void PaUtil_SetInterleavedInputChannels( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int firstChannel, void *data, unsigned int channelCount );
-
-
-/** Provide the buffer processor with a pointer to one non-interleaved host
- output channel.
-
- @param bufferProcessor The buffer processor.
- @param channel The channel number.
- @param data The buffer.
-*/
-void PaUtil_SetNonInterleavedInputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data );
-
-
-/** Use for the second buffer half when the input buffer is split in two halves.
- @see PaUtil_SetInputFrameCount
-*/
-void PaUtil_Set2ndInputFrameCount( PaUtilBufferProcessor* bufferProcessor,
-        unsigned long frameCount );
-
-/** Use for the second buffer half when the input buffer is split in two halves.
- @see PaUtil_SetInputChannel
-*/
-void PaUtil_Set2ndInputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data, unsigned int stride );
-
-/** Use for the second buffer half when the input buffer is split in two halves.
- @see PaUtil_SetInterleavedInputChannels
-*/
-void PaUtil_Set2ndInterleavedInputChannels( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int firstChannel, void *data, unsigned int channelCount );
-
-/** Use for the second buffer half when the input buffer is split in two halves.
- @see PaUtil_SetNonInterleavedInputChannel
-*/
-void PaUtil_Set2ndNonInterleavedInputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data );
-
-
-/** Set the number of frames in the output host buffer(s) specified by the
- PaUtil_Set*OutputChannel functions.
-
- @param bufferProcessor The buffer processor.
-
- @param frameCount The number of host output frames. A 0 frameCount indicates to
- use the framesPerHostBuffer value passed to PaUtil_InitializeBufferProcessor.
-
- @see PaUtil_SetOutputChannel, PaUtil_SetInterleavedOutputChannels,
- PaUtil_SetNonInterleavedOutputChannel
-*/
-void PaUtil_SetOutputFrameCount( PaUtilBufferProcessor* bufferProcessor,
-        unsigned long frameCount );
-
-
-/** Indicate that the output will be discarded. This function should be used
- when implementing the paNeverDropInput mode for full duplex streams.
-
- @param bufferProcessor The buffer processor.
-*/
-void PaUtil_SetNoOutput( PaUtilBufferProcessor* bufferProcessor );
-
-
-/** Provide the buffer processor with a pointer to a host output channel.
-
- @param bufferProcessor The buffer processor.
- @param channel The channel number.
- @param data The buffer.
- @param stride The stride from one sample to the next, in samples. For
- interleaved host buffers, the stride will usually be the same as the number of
- channels in the buffer.
-*/
-void PaUtil_SetOutputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data, unsigned int stride );
-
-
-/** Provide the buffer processor with a pointer to a number of interleaved
- host output channels.
-
- @param bufferProcessor The buffer processor.
- @param firstChannel The first channel number.
- @param data The buffer.
- @param channelCount The number of interleaved channels in the buffer. If
- channelCount is zero, the number of channels specified to
- PaUtil_InitializeBufferProcessor will be used.
-*/
-void PaUtil_SetInterleavedOutputChannels( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int firstChannel, void *data, unsigned int channelCount );
-
-
-/** Provide the buffer processor with a pointer to one non-interleaved host
- output channel.
-
- @param bufferProcessor The buffer processor.
- @param channel The channel number.
- @param data The buffer.
-*/
-void PaUtil_SetNonInterleavedOutputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data );
-
-
-/** Use for the second buffer half when the output buffer is split in two halves.
- @see PaUtil_SetOutputFrameCount
-*/
-void PaUtil_Set2ndOutputFrameCount( PaUtilBufferProcessor* bufferProcessor,
-        unsigned long frameCount );
-
-/** Use for the second buffer half when the output buffer is split in two halves.
- @see PaUtil_SetOutputChannel
-*/
-void PaUtil_Set2ndOutputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data, unsigned int stride );
-
-/** Use for the second buffer half when the output buffer is split in two halves.
- @see PaUtil_SetInterleavedOutputChannels
-*/
-void PaUtil_Set2ndInterleavedOutputChannels( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int firstChannel, void *data, unsigned int channelCount );
-
-/** Use for the second buffer half when the output buffer is split in two halves.
- @see PaUtil_SetNonInterleavedOutputChannel
-*/
-void PaUtil_Set2ndNonInterleavedOutputChannel( PaUtilBufferProcessor* bufferProcessor,
-        unsigned int channel, void *data );
-
-/*@}*/
-
-
-/** @name Buffer processing functions for callback streams
-*/
-/*@{*/
-
-/** Commence processing a host buffer (or a pair of host buffers in the
- full-duplex case) for a callback stream.
-
- @param bufferProcessor The buffer processor.
-
- @param timeInfo Timing information for the first sample of the host
- buffer(s). This information may be adjusted when buffer adaption is being
- performed.
-
- @param callbackStatusFlags Flags indicating whether underruns and overruns
- have occurred since the last time the buffer processor was called.
-*/
-void PaUtil_BeginBufferProcessing( PaUtilBufferProcessor* bufferProcessor,
-        PaStreamCallbackTimeInfo* timeInfo, PaStreamCallbackFlags callbackStatusFlags );
-
-
-/** Finish processing a host buffer (or a pair of host buffers in the
- full-duplex case) for a callback stream.
-
- @param bufferProcessor The buffer processor.
-
- @param callbackResult On input, indicates a previous callback result, and on
- exit, the result of the user stream callback, if it is called.
- On entry callbackResult should contain one of { paContinue, paComplete, or
- paAbort}. If paComplete is passed, the stream callback will not be called
- but any audio that was generated by previous stream callbacks will be copied
- to the output buffer(s). You can check whether the buffer processor's internal
- buffer is empty by calling PaUtil_IsBufferProcessorOutputEmpty.
-
- If the stream callback is called its result is stored in *callbackResult. If
- the stream callback returns paComplete or paAbort, all output buffers will be
- full of valid data - some of which may be zeros to account for data that
- wasn't generated by the terminating callback.
-
- @return The number of frames processed. This usually corresponds to the
- number of frames specified by the PaUtil_Set*FrameCount functions, except in
- the paUtilVariableHostBufferSizePartialUsageAllowed buffer size mode when a
- smaller value may be returned.
-*/
-unsigned long PaUtil_EndBufferProcessing( PaUtilBufferProcessor* bufferProcessor,
-        int *callbackResult );
-
-
-/** Determine whether any callback generated output remains in the buffer
- processor's internal buffers. This method may be used to determine when to
- continue calling PaUtil_EndBufferProcessing() after the callback has returned
- a callbackResult of paComplete.
-
- @param bufferProcessor The buffer processor.
-
- @return Returns non-zero when callback generated output remains in the internal
- buffer and zero (0) when there internal buffer contains no callback generated
- data.
-*/
-int PaUtil_IsBufferProcessorOutputEmpty( PaUtilBufferProcessor* bufferProcessor );
-
-/*@}*/
-
-
-/** @name Buffer processing functions for blocking read/write streams
-*/
-/*@{*/
-
-/** Copy samples from host input channels set up by the PaUtil_Set*InputChannels
- functions to a user supplied buffer. This function is intended for use with
- blocking read/write streams. Copies the minimum of the number of
- user frames (specified by the frameCount parameter) and the number of available
- host frames (specified in a previous call to SetInputFrameCount()).
-
- @param bufferProcessor The buffer processor.
-
- @param buffer A pointer to the user buffer pointer, or a pointer to a pointer
- to an array of user buffer pointers for a non-interleaved stream. It is
- important that this parameter points to a copy of the user buffer pointers,
- not to the actual user buffer pointers, because this function updates the
- pointers before returning.
-
- @param frameCount The number of frames of data in the buffer(s) pointed to by
- the buffer parameter.
-
- @return The number of frames copied. The buffer pointer(s) pointed to by the
- buffer parameter are advanced to point to the frame(s) following the last one
- filled.
-*/
-unsigned long PaUtil_CopyInput( PaUtilBufferProcessor* bufferProcessor,
-        void **buffer, unsigned long frameCount );
-
-
-/* Copy samples from a user supplied buffer to host output channels set up by
- the PaUtil_Set*OutputChannels functions. This function is intended for use with
- blocking read/write streams. Copies the minimum of the number of
- user frames (specified by the frameCount parameter) and the number of
- host frames (specified in a previous call to SetOutputFrameCount()).
-
- @param bufferProcessor The buffer processor.
-
- @param buffer A pointer to the user buffer pointer, or a pointer to a pointer
- to an array of user buffer pointers for a non-interleaved stream. It is
- important that this parameter points to a copy of the user buffer pointers,
- not to the actual user buffer pointers, because this function updates the
- pointers before returning.
-
- @param frameCount The number of frames of data in the buffer(s) pointed to by
- the buffer parameter.
-
- @return The number of frames copied. The buffer pointer(s) pointed to by the
- buffer parameter are advanced to point to the frame(s) following the last one
- copied.
-*/
-unsigned long PaUtil_CopyOutput( PaUtilBufferProcessor* bufferProcessor,
-        const void ** buffer, unsigned long frameCount );
-
-
-/* Zero samples in host output channels set up by the PaUtil_Set*OutputChannels
- functions. This function is useful for flushing streams.
- Zeros the minimum of frameCount and the number of host frames specified in a
- previous call to SetOutputFrameCount().
-
- @param bufferProcessor The buffer processor.
-
- @param frameCount The maximum number of frames to zero.
-
- @return The number of frames zeroed.
-*/
-unsigned long PaUtil_ZeroOutput( PaUtilBufferProcessor* bufferProcessor,
-        unsigned long frameCount );
-
-
-/*@}*/
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_PROCESS_H */
diff --git a/portaudio/src/common/pa_ringbuffer.c b/portaudio/src/common/pa_ringbuffer.c
deleted file mode 100644
index b978d54..0000000
--- a/portaudio/src/common/pa_ringbuffer.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library
- * Ring Buffer utility.
- *
- * Author: Phil Burk, http://www.softsynth.com
- * modified for SMP safety on Mac OS X by Bjorn Roche
- * modified for SMP safety on Linux by Leland Lucius
- * also, allowed for const where possible
- * modified for multiple-byte-sized data elements by Sven Fischer
- *
- * Note that this is safe only for a single-thread reader and a
- * single-thread writer.
- *
- * This program uses the PortAudio Portable Audio Library.
- * For more information see: http://www.portaudio.com
- * Copyright (c) 1999-2000 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.
- */
-
-/**
- @file
- @ingroup common_src
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include "pa_ringbuffer.h"
-#include <string.h>
-#include "pa_memorybarrier.h"
-
-/***************************************************************************
- * Initialize FIFO.
- * elementCount must be power of 2, returns -1 if not.
- */
-ring_buffer_size_t PaUtil_InitializeRingBuffer( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementSizeBytes, ring_buffer_size_t elementCount, void *dataPtr )
-{
-    if( ((elementCount-1) & elementCount) != 0) return -1; /* Not Power of two. */
-    rbuf->bufferSize = elementCount;
-    rbuf->buffer = (char *)dataPtr;
-    PaUtil_FlushRingBuffer( rbuf );
-    rbuf->bigMask = (elementCount*2)-1;
-    rbuf->smallMask = (elementCount)-1;
-    rbuf->elementSizeBytes = elementSizeBytes;
-    return 0;
-}
-
-/***************************************************************************
-** Return number of elements available for reading. */
-ring_buffer_size_t PaUtil_GetRingBufferReadAvailable( const PaUtilRingBuffer *rbuf )
-{
-    return ( (rbuf->writeIndex - rbuf->readIndex) & rbuf->bigMask );
-}
-/***************************************************************************
-** Return number of elements available for writing. */
-ring_buffer_size_t PaUtil_GetRingBufferWriteAvailable( const PaUtilRingBuffer *rbuf )
-{
-    return ( rbuf->bufferSize - PaUtil_GetRingBufferReadAvailable(rbuf));
-}
-
-/***************************************************************************
-** Clear buffer. Should only be called when buffer is NOT being read or written. */
-void PaUtil_FlushRingBuffer( PaUtilRingBuffer *rbuf )
-{
-    rbuf->writeIndex = rbuf->readIndex = 0;
-}
-
-/***************************************************************************
-** Get address of region(s) to which we can write data.
-** If the region is contiguous, size2 will be zero.
-** If non-contiguous, size2 will be the size of second region.
-** Returns room available to be written or elementCount, whichever is smaller.
-*/
-ring_buffer_size_t PaUtil_GetRingBufferWriteRegions( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount,
-                                       void **dataPtr1, ring_buffer_size_t *sizePtr1,
-                                       void **dataPtr2, ring_buffer_size_t *sizePtr2 )
-{
-    ring_buffer_size_t   index;
-    ring_buffer_size_t   available = PaUtil_GetRingBufferWriteAvailable( rbuf );
-    if( elementCount > available ) elementCount = available;
-    /* Check to see if write is not contiguous. */
-    index = rbuf->writeIndex & rbuf->smallMask;
-    if( (index + elementCount) > rbuf->bufferSize )
-    {
-        /* Write data in two blocks that wrap the buffer. */
-        ring_buffer_size_t   firstHalf = rbuf->bufferSize - index;
-        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
-        *sizePtr1 = firstHalf;
-        *dataPtr2 = &rbuf->buffer[0];
-        *sizePtr2 = elementCount - firstHalf;
-    }
-    else
-    {
-        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
-        *sizePtr1 = elementCount;
-        *dataPtr2 = NULL;
-        *sizePtr2 = 0;
-    }
-
-    if( available )
-        PaUtil_FullMemoryBarrier(); /* (write-after-read) => full barrier */
-
-    return elementCount;
-}
-
-
-/***************************************************************************
-*/
-ring_buffer_size_t PaUtil_AdvanceRingBufferWriteIndex( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount )
-{
-    /* ensure that previous writes are seen before we update the write index
-       (write after write)
-    */
-    PaUtil_WriteMemoryBarrier();
-    return rbuf->writeIndex = (rbuf->writeIndex + elementCount) & rbuf->bigMask;
-}
-
-/***************************************************************************
-** Get address of region(s) from which we can read data.
-** If the region is contiguous, size2 will be zero.
-** If non-contiguous, size2 will be the size of second region.
-** Returns room available to be read or elementCount, whichever is smaller.
-*/
-ring_buffer_size_t PaUtil_GetRingBufferReadRegions( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount,
-                                void **dataPtr1, ring_buffer_size_t *sizePtr1,
-                                void **dataPtr2, ring_buffer_size_t *sizePtr2 )
-{
-    ring_buffer_size_t   index;
-    ring_buffer_size_t   available = PaUtil_GetRingBufferReadAvailable( rbuf ); /* doesn't use memory barrier */
-    if( elementCount > available ) elementCount = available;
-    /* Check to see if read is not contiguous. */
-    index = rbuf->readIndex & rbuf->smallMask;
-    if( (index + elementCount) > rbuf->bufferSize )
-    {
-        /* Write data in two blocks that wrap the buffer. */
-        ring_buffer_size_t firstHalf = rbuf->bufferSize - index;
-        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
-        *sizePtr1 = firstHalf;
-        *dataPtr2 = &rbuf->buffer[0];
-        *sizePtr2 = elementCount - firstHalf;
-    }
-    else
-    {
-        *dataPtr1 = &rbuf->buffer[index*rbuf->elementSizeBytes];
-        *sizePtr1 = elementCount;
-        *dataPtr2 = NULL;
-        *sizePtr2 = 0;
-    }
-
-    if( available )
-        PaUtil_ReadMemoryBarrier(); /* (read-after-read) => read barrier */
-
-    return elementCount;
-}
-/***************************************************************************
-*/
-ring_buffer_size_t PaUtil_AdvanceRingBufferReadIndex( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount )
-{
-    /* ensure that previous reads (copies out of the ring buffer) are always completed before updating (writing) the read index.
-       (write-after-read) => full barrier
-    */
-    PaUtil_FullMemoryBarrier();
-    return rbuf->readIndex = (rbuf->readIndex + elementCount) & rbuf->bigMask;
-}
-
-/***************************************************************************
-** Return elements written. */
-ring_buffer_size_t PaUtil_WriteRingBuffer( PaUtilRingBuffer *rbuf, const void *data, ring_buffer_size_t elementCount )
-{
-    ring_buffer_size_t size1, size2, numWritten;
-    void *data1, *data2;
-    numWritten = PaUtil_GetRingBufferWriteRegions( rbuf, elementCount, &data1, &size1, &data2, &size2 );
-    if( size2 > 0 )
-    {
-
-        memcpy( data1, data, size1*rbuf->elementSizeBytes );
-        data = ((char *)data) + size1*rbuf->elementSizeBytes;
-        memcpy( data2, data, size2*rbuf->elementSizeBytes );
-    }
-    else
-    {
-        memcpy( data1, data, size1*rbuf->elementSizeBytes );
-    }
-    PaUtil_AdvanceRingBufferWriteIndex( rbuf, numWritten );
-    return numWritten;
-}
-
-/***************************************************************************
-** Return elements read. */
-ring_buffer_size_t PaUtil_ReadRingBuffer( PaUtilRingBuffer *rbuf, void *data, ring_buffer_size_t elementCount )
-{
-    ring_buffer_size_t size1, size2, numRead;
-    void *data1, *data2;
-    numRead = PaUtil_GetRingBufferReadRegions( rbuf, elementCount, &data1, &size1, &data2, &size2 );
-    if( size2 > 0 )
-    {
-        memcpy( data, data1, size1*rbuf->elementSizeBytes );
-        data = ((char *)data) + size1*rbuf->elementSizeBytes;
-        memcpy( data, data2, size2*rbuf->elementSizeBytes );
-    }
-    else
-    {
-        memcpy( data, data1, size1*rbuf->elementSizeBytes );
-    }
-    PaUtil_AdvanceRingBufferReadIndex( rbuf, numRead );
-    return numRead;
-}
diff --git a/portaudio/src/common/pa_ringbuffer.h b/portaudio/src/common/pa_ringbuffer.h
deleted file mode 100644
index 400aaac..0000000
--- a/portaudio/src/common/pa_ringbuffer.h
+++ /dev/null
@@ -1,236 +0,0 @@
-#ifndef PA_RINGBUFFER_H
-#define PA_RINGBUFFER_H
-/*
- * $Id$
- * Portable Audio I/O Library
- * Ring Buffer utility.
- *
- * Author: Phil Burk, http://www.softsynth.com
- * modified for SMP safety on OS X by Bjorn Roche.
- * also allowed for const where possible.
- * modified for multiple-byte-sized data elements by Sven Fischer
- *
- * Note that this is safe only for a single-thread reader
- * and a single-thread writer.
- *
- * This program is distributed with the PortAudio Portable Audio Library.
- * For more information see: http://www.portaudio.com
- * Copyright (c) 1999-2000 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.
- */
-
-/** @file
- @ingroup common_src
- @brief Single-reader single-writer lock-free ring buffer
-
- PaUtilRingBuffer is a ring buffer used to transport samples between
- different execution contexts (threads, OS callbacks, interrupt handlers)
- without requiring the use of any locks. This only works when there is
- a single reader and a single writer (ie. one thread or callback writes
- to the ring buffer, another thread or callback reads from it).
-
- The PaUtilRingBuffer structure manages a ring buffer containing N
- elements, where N must be a power of two. An element may be any size
- (specified in bytes).
-
- The memory area used to store the buffer elements must be allocated by
- the client prior to calling PaUtil_InitializeRingBuffer() and must outlive
- the use of the ring buffer.
-
- @note The ring buffer functions are not normally exposed in the PortAudio libraries.
- If you want to call them then you will need to add pa_ringbuffer.c to your application source code.
-*/
-
-#if defined(__APPLE__)
-#include <sys/types.h>
-typedef int32_t ring_buffer_size_t;
-#elif defined( __GNUC__ )
-typedef long ring_buffer_size_t;
-#elif (_MSC_VER >= 1400)
-typedef long ring_buffer_size_t;
-#elif defined(_MSC_VER) || defined(__BORLANDC__)
-typedef long ring_buffer_size_t;
-#else
-typedef long ring_buffer_size_t;
-#endif
-
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-typedef struct PaUtilRingBuffer
-{
-    ring_buffer_size_t  bufferSize; /**< Number of elements in FIFO. Power of 2. Set by PaUtil_InitRingBuffer. */
-    volatile ring_buffer_size_t  writeIndex; /**< Index of next writable element. Set by PaUtil_AdvanceRingBufferWriteIndex. */
-    volatile ring_buffer_size_t  readIndex;  /**< Index of next readable element. Set by PaUtil_AdvanceRingBufferReadIndex. */
-    ring_buffer_size_t  bigMask;    /**< Used for wrapping indices with extra bit to distinguish full/empty. */
-    ring_buffer_size_t  smallMask;  /**< Used for fitting indices to buffer. */
-    ring_buffer_size_t  elementSizeBytes; /**< Number of bytes per element. */
-    char  *buffer;    /**< Pointer to the buffer containing the actual data. */
-}PaUtilRingBuffer;
-
-/** Initialize Ring Buffer to empty state ready to have elements written to it.
-
- @param rbuf The ring buffer.
-
- @param elementSizeBytes The size of a single data element in bytes.
-
- @param elementCount The number of elements in the buffer (must be a power of 2).
-
- @param dataPtr A pointer to a previously allocated area where the data
- will be maintained.  It must be elementCount*elementSizeBytes long.
-
- @return -1 if elementCount is not a power of 2, otherwise 0.
-*/
-ring_buffer_size_t PaUtil_InitializeRingBuffer( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementSizeBytes, ring_buffer_size_t elementCount, void *dataPtr );
-
-/** Reset buffer to empty. Should only be called when buffer is NOT being read or written.
-
- @param rbuf The ring buffer.
-*/
-void PaUtil_FlushRingBuffer( PaUtilRingBuffer *rbuf );
-
-/** Retrieve the number of elements available in the ring buffer for writing.
-
- @param rbuf The ring buffer.
-
- @return The number of elements available for writing.
-*/
-ring_buffer_size_t PaUtil_GetRingBufferWriteAvailable( const PaUtilRingBuffer *rbuf );
-
-/** Retrieve the number of elements available in the ring buffer for reading.
-
- @param rbuf The ring buffer.
-
- @return The number of elements available for reading.
-*/
-ring_buffer_size_t PaUtil_GetRingBufferReadAvailable( const PaUtilRingBuffer *rbuf );
-
-/** Write data to the ring buffer.
-
- @param rbuf The ring buffer.
-
- @param data The address of new data to write to the buffer.
-
- @param elementCount The number of elements to be written.
-
- @return The number of elements written.
-*/
-ring_buffer_size_t PaUtil_WriteRingBuffer( PaUtilRingBuffer *rbuf, const void *data, ring_buffer_size_t elementCount );
-
-/** Read data from the ring buffer.
-
- @param rbuf The ring buffer.
-
- @param data The address where the data should be stored.
-
- @param elementCount The number of elements to be read.
-
- @return The number of elements read.
-*/
-ring_buffer_size_t PaUtil_ReadRingBuffer( PaUtilRingBuffer *rbuf, void *data, ring_buffer_size_t elementCount );
-
-/** Get address of region(s) to which we can write data.
-
- @param rbuf The ring buffer.
-
- @param elementCount The number of elements desired.
-
- @param dataPtr1 The address where the first (or only) region pointer will be
- stored.
-
- @param sizePtr1 The address where the first (or only) region length will be
- stored.
-
- @param dataPtr2 The address where the second region pointer will be stored if
- the first region is too small to satisfy elementCount.
-
- @param sizePtr2 The address where the second region length will be stored if
- the first region is too small to satisfy elementCount.
-
- @return The room available to be written or elementCount, whichever is smaller.
-*/
-ring_buffer_size_t PaUtil_GetRingBufferWriteRegions( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount,
-                                       void **dataPtr1, ring_buffer_size_t *sizePtr1,
-                                       void **dataPtr2, ring_buffer_size_t *sizePtr2 );
-
-/** Advance the write index to the next location to be written.
-
- @param rbuf The ring buffer.
-
- @param elementCount The number of elements to advance.
-
- @return The new position.
-*/
-ring_buffer_size_t PaUtil_AdvanceRingBufferWriteIndex( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount );
-
-/** Get address of region(s) from which we can read data.
-
- @param rbuf The ring buffer.
-
- @param elementCount The number of elements desired.
-
- @param dataPtr1 The address where the first (or only) region pointer will be
- stored.
-
- @param sizePtr1 The address where the first (or only) region length will be
- stored.
-
- @param dataPtr2 The address where the second region pointer will be stored if
- the first region is too small to satisfy elementCount.
-
- @param sizePtr2 The address where the second region length will be stored if
- the first region is too small to satisfy elementCount.
-
- @return The number of elements available for reading.
-*/
-ring_buffer_size_t PaUtil_GetRingBufferReadRegions( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount,
-                                      void **dataPtr1, ring_buffer_size_t *sizePtr1,
-                                      void **dataPtr2, ring_buffer_size_t *sizePtr2 );
-
-/** Advance the read index to the next location to be read.
-
- @param rbuf The ring buffer.
-
- @param elementCount The number of elements to advance.
-
- @return The new position.
-*/
-ring_buffer_size_t PaUtil_AdvanceRingBufferReadIndex( PaUtilRingBuffer *rbuf, ring_buffer_size_t elementCount );
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_RINGBUFFER_H */
diff --git a/portaudio/src/common/pa_stream.c b/portaudio/src/common/pa_stream.c
deleted file mode 100644
index ffbf530..0000000
--- a/portaudio/src/common/pa_stream.c
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library
- * stream interface
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 2008 Ross Bencina
- *
- * 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Stream interfaces, representation structures and helper functions
- used to interface between pa_front.c host API implementations.
-*/
-
-
-#include "pa_stream.h"
-
-
-void PaUtil_InitializeStreamInterface( PaUtilStreamInterface *streamInterface,
-                                       PaError (*Close)( PaStream* ),
-                                       PaError (*Start)( PaStream* ),
-                                       PaError (*Stop)( PaStream* ),
-                                       PaError (*Abort)( PaStream* ),
-                                       PaError (*IsStopped)( PaStream* ),
-                                       PaError (*IsActive)( PaStream* ),
-                                       PaTime (*GetTime)( PaStream* ),
-                                       double (*GetCpuLoad)( PaStream* ),
-                                       PaError (*Read)( PaStream*, void *, unsigned long ),
-                                       PaError (*Write)( PaStream*, const void *, unsigned long ),
-                                       signed long (*GetReadAvailable)( PaStream* ),
-                                       signed long (*GetWriteAvailable)( PaStream* )  )
-{
-    streamInterface->Close = Close;
-    streamInterface->Start = Start;
-    streamInterface->Stop = Stop;
-    streamInterface->Abort = Abort;
-    streamInterface->IsStopped = IsStopped;
-    streamInterface->IsActive = IsActive;
-    streamInterface->GetTime = GetTime;
-    streamInterface->GetCpuLoad = GetCpuLoad;
-    streamInterface->Read = Read;
-    streamInterface->Write = Write;
-    streamInterface->GetReadAvailable = GetReadAvailable;
-    streamInterface->GetWriteAvailable = GetWriteAvailable;
-}
-
-
-void PaUtil_InitializeStreamRepresentation( PaUtilStreamRepresentation *streamRepresentation,
-        PaUtilStreamInterface *streamInterface,
-        PaStreamCallback *streamCallback,
-        void *userData )
-{
-    streamRepresentation->magic = PA_STREAM_MAGIC;
-    streamRepresentation->nextOpenStream = 0;
-    streamRepresentation->streamInterface = streamInterface;
-    streamRepresentation->streamCallback = streamCallback;
-    streamRepresentation->streamFinishedCallback = 0;
-
-    streamRepresentation->userData = userData;
-
-    streamRepresentation->streamInfo.inputLatency = 0.;
-    streamRepresentation->streamInfo.outputLatency = 0.;
-    streamRepresentation->streamInfo.sampleRate = 0.;
-}
-
-
-void PaUtil_TerminateStreamRepresentation( PaUtilStreamRepresentation *streamRepresentation )
-{
-    streamRepresentation->magic = 0;
-}
-
-
-PaError PaUtil_DummyRead( PaStream* stream,
-                               void *buffer,
-                               unsigned long frames )
-{
-    (void)stream; /* unused parameter */
-    (void)buffer; /* unused parameter */
-    (void)frames; /* unused parameter */
-
-    return paCanNotReadFromACallbackStream;
-}
-
-
-PaError PaUtil_DummyWrite( PaStream* stream,
-                               const void *buffer,
-                               unsigned long frames )
-{
-    (void)stream; /* unused parameter */
-    (void)buffer; /* unused parameter */
-    (void)frames; /* unused parameter */
-
-    return paCanNotWriteToACallbackStream;
-}
-
-
-signed long PaUtil_DummyGetReadAvailable( PaStream* stream )
-{
-    (void)stream; /* unused parameter */
-
-    return paCanNotReadFromACallbackStream;
-}
-
-
-signed long PaUtil_DummyGetWriteAvailable( PaStream* stream )
-{
-    (void)stream; /* unused parameter */
-
-    return paCanNotWriteToACallbackStream;
-}
-
-
-double PaUtil_DummyGetCpuLoad( PaStream* stream )
-{
-    (void)stream; /* unused parameter */
-
-    return 0.0;
-}
diff --git a/portaudio/src/common/pa_stream.h b/portaudio/src/common/pa_stream.h
deleted file mode 100644
index 4afda39..0000000
--- a/portaudio/src/common/pa_stream.h
+++ /dev/null
@@ -1,205 +0,0 @@
-#ifndef PA_STREAM_H
-#define PA_STREAM_H
-/*
- * $Id$
- * Portable Audio I/O Library
- * stream interface
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2008 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Stream interfaces, representation structures and helper functions
- used to interface between pa_front.c host API implementations.
-*/
-
-
-#include "portaudio.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-#define PA_STREAM_MAGIC (0x18273645)
-
-
-/** A structure representing an (abstract) interface to a host API. Contains
- pointers to functions which implement the interface.
-
- All PaStreamInterface functions are guaranteed to be called with a non-null,
- valid stream parameter.
-*/
-typedef struct {
-    PaError (*Close)( PaStream* stream );
-    PaError (*Start)( PaStream *stream );
-    PaError (*Stop)( PaStream *stream );
-    PaError (*Abort)( PaStream *stream );
-    PaError (*IsStopped)( PaStream *stream );
-    PaError (*IsActive)( PaStream *stream );
-    PaTime (*GetTime)( PaStream *stream );
-    double (*GetCpuLoad)( PaStream* stream );
-    PaError (*Read)( PaStream* stream, void *buffer, unsigned long frames );
-    PaError (*Write)( PaStream* stream, const void *buffer, unsigned long frames );
-    signed long (*GetReadAvailable)( PaStream* stream );
-    signed long (*GetWriteAvailable)( PaStream* stream );
-} PaUtilStreamInterface;
-
-
-/** Initialize the fields of a PaUtilStreamInterface structure.
-*/
-void PaUtil_InitializeStreamInterface( PaUtilStreamInterface *streamInterface,
-    PaError (*Close)( PaStream* ),
-    PaError (*Start)( PaStream* ),
-    PaError (*Stop)( PaStream* ),
-    PaError (*Abort)( PaStream* ),
-    PaError (*IsStopped)( PaStream* ),
-    PaError (*IsActive)( PaStream* ),
-    PaTime (*GetTime)( PaStream* ),
-    double (*GetCpuLoad)( PaStream* ),
-    PaError (*Read)( PaStream* stream, void *buffer, unsigned long frames ),
-    PaError (*Write)( PaStream* stream, const void *buffer, unsigned long frames ),
-    signed long (*GetReadAvailable)( PaStream* stream ),
-    signed long (*GetWriteAvailable)( PaStream* stream ) );
-
-
-/** Dummy Read function for use in interfaces to a callback based streams.
- Pass to the Read parameter of PaUtil_InitializeStreamInterface.
- @return An error code indicating that the function has no effect
- because the stream is a callback stream.
-*/
-PaError PaUtil_DummyRead( PaStream* stream,
-                       void *buffer,
-                       unsigned long frames );
-
-
-/** Dummy Write function for use in an interfaces to callback based streams.
- Pass to the Write parameter of PaUtil_InitializeStreamInterface.
- @return An error code indicating that the function has no effect
- because the stream is a callback stream.
-*/
-PaError PaUtil_DummyWrite( PaStream* stream,
-                       const void *buffer,
-                       unsigned long frames );
-
-
-/** Dummy GetReadAvailable function for use in interfaces to callback based
- streams. Pass to the GetReadAvailable parameter of PaUtil_InitializeStreamInterface.
- @return An error code indicating that the function has no effect
- because the stream is a callback stream.
-*/
-signed long PaUtil_DummyGetReadAvailable( PaStream* stream );
-
-
-/** Dummy GetWriteAvailable function for use in interfaces to callback based
- streams. Pass to the GetWriteAvailable parameter of PaUtil_InitializeStreamInterface.
- @return An error code indicating that the function has no effect
- because the stream is a callback stream.
-*/
-signed long PaUtil_DummyGetWriteAvailable( PaStream* stream );
-
-
-
-/** Dummy GetCpuLoad function for use in an interface to a read/write stream.
- Pass to the GetCpuLoad parameter of PaUtil_InitializeStreamInterface.
- @return Returns 0.
-*/
-double PaUtil_DummyGetCpuLoad( PaStream* stream );
-
-
-/** Non host specific data for a stream. This data is used by pa_front to
- forward to the appropriate functions in the streamInterface structure.
-*/
-typedef struct PaUtilStreamRepresentation {
-    unsigned long magic;    /**< set to PA_STREAM_MAGIC */
-    struct PaUtilStreamRepresentation *nextOpenStream; /**< field used by multi-api code */
-    PaUtilStreamInterface *streamInterface;
-    PaStreamCallback *streamCallback;
-    PaStreamFinishedCallback *streamFinishedCallback;
-    void *userData;
-    PaStreamInfo streamInfo;
-} PaUtilStreamRepresentation;
-
-
-/** Initialize a PaUtilStreamRepresentation structure.
-
- @see PaUtil_InitializeStreamRepresentation
-*/
-void PaUtil_InitializeStreamRepresentation(
-        PaUtilStreamRepresentation *streamRepresentation,
-        PaUtilStreamInterface *streamInterface,
-        PaStreamCallback *streamCallback,
-        void *userData );
-
-
-/** Clean up a PaUtilStreamRepresentation structure previously initialized
- by a call to PaUtil_InitializeStreamRepresentation.
-
- @see PaUtil_InitializeStreamRepresentation
-*/
-void PaUtil_TerminateStreamRepresentation( PaUtilStreamRepresentation *streamRepresentation );
-
-
-/** Check that the stream pointer is valid.
-
- @return Returns paNoError if the stream pointer appears to be OK, otherwise
- returns an error indicating the cause of failure.
-*/
-PaError PaUtil_ValidateStreamPointer( PaStream *stream );
-
-
-/** Cast an opaque stream pointer into a pointer to a PaUtilStreamRepresentation.
-
- @see PaUtilStreamRepresentation
-*/
-#define PA_STREAM_REP( stream )\
-    ((PaUtilStreamRepresentation*) (stream) )
-
-
-/** Cast an opaque stream pointer into a pointer to a PaUtilStreamInterface.
-
- @see PaUtilStreamRepresentation, PaUtilStreamInterface
-*/
-#define PA_STREAM_INTERFACE( stream )\
-    PA_STREAM_REP( (stream) )->streamInterface
-
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_STREAM_H */
diff --git a/portaudio/src/common/pa_trace.c b/portaudio/src/common/pa_trace.c
deleted file mode 100644
index 6763dfa..0000000
--- a/portaudio/src/common/pa_trace.c
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * $Id$
- * Portable Audio I/O Library Trace Facility
- * Store trace information in real-time for later printing.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2000 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Real-time safe event trace logging facility for debugging.
-*/
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#include <assert.h>
-#include "pa_trace.h"
-#include "pa_util.h"
-#include "pa_debugprint.h"
-
-#if PA_TRACE_REALTIME_EVENTS
-
-static char const *traceTextArray[PA_MAX_TRACE_RECORDS];
-static int traceIntArray[PA_MAX_TRACE_RECORDS];
-static int traceIndex = 0;
-static int traceBlock = 0;
-
-/*********************************************************************/
-void PaUtil_ResetTraceMessages()
-{
-    traceIndex = 0;
-}
-
-/*********************************************************************/
-void PaUtil_DumpTraceMessages()
-{
-    int i;
-    int messageCount = (traceIndex < PA_MAX_TRACE_RECORDS) ? traceIndex : PA_MAX_TRACE_RECORDS;
-
-    printf("DumpTraceMessages: traceIndex = %d\n", traceIndex );
-    for( i=0; i<messageCount; i++ )
-    {
-        printf("%3d: %s = 0x%08X\n",
-               i, traceTextArray[i], traceIntArray[i] );
-    }
-    PaUtil_ResetTraceMessages();
-    fflush(stdout);
-}
-
-/*********************************************************************/
-void PaUtil_AddTraceMessage( const char *msg, int data )
-{
-    if( (traceIndex == PA_MAX_TRACE_RECORDS) && (traceBlock == 0) )
-    {
-        traceBlock = 1;
-        /*  PaUtil_DumpTraceMessages(); */
-    }
-    else if( traceIndex < PA_MAX_TRACE_RECORDS )
-    {
-        traceTextArray[traceIndex] = msg;
-        traceIntArray[traceIndex] = data;
-        traceIndex++;
-    }
-}
-
-/************************************************************************/
-/* High performance log alternative                                     */
-/************************************************************************/
-
-typedef unsigned long long  PaUint64;
-
-typedef struct __PaHighPerformanceLog
-{
-    unsigned    magik;
-    int         writePtr;
-    int         readPtr;
-    int         size;
-    double      refTime;
-    char*       data;
-} PaHighPerformanceLog;
-
-static const unsigned kMagik = 0xcafebabe;
-
-#define USEC_PER_SEC    (1000000ULL)
-
-int PaUtil_InitializeHighSpeedLog( LogHandle* phLog, unsigned maxSizeInBytes )
-{
-    PaHighPerformanceLog* pLog = (PaHighPerformanceLog*)PaUtil_AllocateMemory(sizeof(PaHighPerformanceLog));
-    if (pLog == 0)
-    {
-        return paInsufficientMemory;
-    }
-    assert(phLog != 0);
-    *phLog = pLog;
-
-    pLog->data = (char*)PaUtil_AllocateMemory(maxSizeInBytes);
-    if (pLog->data == 0)
-    {
-        PaUtil_FreeMemory(pLog);
-        return paInsufficientMemory;
-    }
-    pLog->magik = kMagik;
-    pLog->size = maxSizeInBytes;
-    pLog->refTime = PaUtil_GetTime();
-    return paNoError;
-}
-
-void PaUtil_ResetHighSpeedLogTimeRef( LogHandle hLog )
-{
-    PaHighPerformanceLog* pLog = (PaHighPerformanceLog*)hLog;
-    assert(pLog->magik == kMagik);
-    pLog->refTime = PaUtil_GetTime();
-}
-
-typedef struct __PaLogEntryHeader
-{
-    int    size;
-    double timeStamp;
-} PaLogEntryHeader;
-
-#ifdef __APPLE__
-#define _vsnprintf vsnprintf
-#define min(a,b) ((a)<(b)?(a):(b))
-#endif
-
-
-int PaUtil_AddHighSpeedLogMessage( LogHandle hLog, const char* fmt, ... )
-{
-    va_list l;
-    int n = 0;
-    PaHighPerformanceLog* pLog = (PaHighPerformanceLog*)hLog;
-    if (pLog != 0)
-    {
-        PaLogEntryHeader* pHeader;
-        char* p;
-        int maxN;
-        assert(pLog->magik == kMagik);
-        pHeader = (PaLogEntryHeader*)( pLog->data + pLog->writePtr );
-        p = (char*)( pHeader + 1 );
-        maxN = pLog->size - pLog->writePtr - 2 * sizeof(PaLogEntryHeader);
-
-        pHeader->timeStamp = PaUtil_GetTime() - pLog->refTime;
-        if (maxN > 0)
-        {
-            if (maxN > 32)
-            {
-                va_start(l, fmt);
-                n = _vsnprintf(p, min(1024, maxN), fmt, l);
-                va_end(l);
-            }
-            else {
-                n = sprintf(p, "End of log...");
-            }
-            n = ((n + sizeof(unsigned)) & ~(sizeof(unsigned)-1)) + sizeof(PaLogEntryHeader);
-            pHeader->size = n;
-#if 0
-            PaUtil_DebugPrint("%05u.%03u: %s\n", pHeader->timeStamp/1000, pHeader->timeStamp%1000, p);
-#endif
-            pLog->writePtr += n;
-        }
-    }
-    return n;
-}
-
-void PaUtil_DumpHighSpeedLog( LogHandle hLog, const char* fileName )
-{
-    FILE* f = (fileName != NULL) ? fopen(fileName, "w") : stdout;
-    unsigned localWritePtr;
-    PaHighPerformanceLog* pLog = (PaHighPerformanceLog*)hLog;
-    assert(pLog->magik == kMagik);
-    localWritePtr = pLog->writePtr;
-    while (pLog->readPtr != localWritePtr)
-    {
-        const PaLogEntryHeader* pHeader = (const PaLogEntryHeader*)( pLog->data + pLog->readPtr );
-        const char* p = (const char*)( pHeader + 1 );
-        const PaUint64 ts = (const PaUint64)( pHeader->timeStamp * USEC_PER_SEC );
-        assert(pHeader->size < (1024+sizeof(unsigned)+sizeof(PaLogEntryHeader)));
-        fprintf(f, "%05u.%03u: %s\n", (unsigned)(ts/1000), (unsigned)(ts%1000), p);
-        pLog->readPtr += pHeader->size;
-    }
-    if (f != stdout)
-    {
-        fclose(f);
-    }
-}
-
-void PaUtil_DiscardHighSpeedLog( LogHandle hLog )
-{
-    PaHighPerformanceLog* pLog = (PaHighPerformanceLog*)hLog;
-    assert(pLog->magik == kMagik);
-    PaUtil_FreeMemory(pLog->data);
-    PaUtil_FreeMemory(pLog);
-}
-
-#else
-/* This stub was added so that this file will generate a symbol.
- * Otherwise linker/archiver programs will complain.
- */
-int PaUtil_TraceStubToSatisfyLinker(void)
-{
-    return 0;
-}
-#endif /* TRACE_REALTIME_EVENTS */
diff --git a/portaudio/src/common/pa_trace.h b/portaudio/src/common/pa_trace.h
deleted file mode 100644
index 7827766..0000000
--- a/portaudio/src/common/pa_trace.h
+++ /dev/null
@@ -1,117 +0,0 @@
-#ifndef PA_TRACE_H
-#define PA_TRACE_H
-/*
- * $Id$
- * Portable Audio I/O Library Trace Facility
- * Store trace information in real-time for later printing.
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2000 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Real-time safe event trace logging facility for debugging.
-
- Allows data to be logged to a fixed size trace buffer in a real-time
- execution context (such as at interrupt time). Each log entry consists
- of a message comprising a string pointer and an int.  The trace buffer
- may be dumped to stdout later.
-
- This facility is only active if PA_TRACE_REALTIME_EVENTS is set to 1,
- otherwise the trace functions expand to no-ops.
-
- @fn PaUtil_ResetTraceMessages
- @brief Clear the trace buffer.
-
- @fn PaUtil_AddTraceMessage
- @brief Add a message to the trace buffer. A message consists of string and an int.
- @param msg The string pointer must remain valid until PaUtil_DumpTraceMessages
-    is called. As a result, usually only string literals should be passed as
-    the msg parameter.
-
- @fn PaUtil_DumpTraceMessages
- @brief Print all messages in the trace buffer to stdout and clear the trace buffer.
-*/
-
-#ifndef PA_TRACE_REALTIME_EVENTS
-#define PA_TRACE_REALTIME_EVENTS     (0)   /**< Set to 1 to enable logging using the trace functions defined below */
-#endif
-
-#ifndef PA_MAX_TRACE_RECORDS
-#define PA_MAX_TRACE_RECORDS      (2048)   /**< Maximum number of records stored in trace buffer */
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-#if PA_TRACE_REALTIME_EVENTS
-
-void PaUtil_ResetTraceMessages();
-void PaUtil_AddTraceMessage( const char *msg, int data );
-void PaUtil_DumpTraceMessages();
-
-/* Alternative interface */
-
-typedef void* LogHandle;
-
-int PaUtil_InitializeHighSpeedLog(LogHandle* phLog, unsigned maxSizeInBytes);
-void PaUtil_ResetHighSpeedLogTimeRef(LogHandle hLog);
-int PaUtil_AddHighSpeedLogMessage(LogHandle hLog, const char* fmt, ...);
-void PaUtil_DumpHighSpeedLog(LogHandle hLog, const char* fileName);
-void PaUtil_DiscardHighSpeedLog(LogHandle hLog);
-
-#else
-
-#define PaUtil_ResetTraceMessages() /* noop */
-#define PaUtil_AddTraceMessage(msg,data) /* noop */
-#define PaUtil_DumpTraceMessages() /* noop */
-
-#define PaUtil_InitializeHighSpeedLog(phLog, maxSizeInBytes)  (0)
-#define PaUtil_ResetHighSpeedLogTimeRef(hLog)
-#define PaUtil_AddHighSpeedLogMessage(...)   (0)
-#define PaUtil_DumpHighSpeedLog(hLog, fileName)
-#define PaUtil_DiscardHighSpeedLog(hLog)
-
-#endif
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* PA_TRACE_H */
diff --git a/portaudio/src/common/pa_types.h b/portaudio/src/common/pa_types.h
deleted file mode 100644
index f628783..0000000
--- a/portaudio/src/common/pa_types.h
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef PA_TYPES_H
-#define PA_TYPES_H
-
-/*
- * Portable Audio I/O Library
- * integer type definitions
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2006 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
- @brief Definition of 16 and 32 bit integer types (PaInt16, PaInt32 etc)
-
- SIZEOF_SHORT, SIZEOF_INT and SIZEOF_LONG are set by the configure script
- when it is used. Otherwise we default to the common 32 bit values, if your
- platform doesn't use configure, and doesn't use the default values below
- you will need to explicitly define these symbols in your make file.
-
- A PA_VALIDATE_SIZES macro is provided to assert that the values set in this
- file are correct.
-*/
-
-#ifndef SIZEOF_SHORT
-#define SIZEOF_SHORT 2
-#endif
-
-#ifndef SIZEOF_INT
-#define SIZEOF_INT 4
-#endif
-
-#ifndef SIZEOF_LONG
-#define SIZEOF_LONG 4
-#endif
-
-
-#if SIZEOF_SHORT == 2
-typedef signed short PaInt16;
-typedef unsigned short PaUint16;
-#elif SIZEOF_INT == 2
-typedef signed int PaInt16;
-typedef unsigned int PaUint16;
-#else
-#error pa_types.h was unable to determine which type to use for 16bit integers on the target platform
-#endif
-
-#if SIZEOF_SHORT == 4
-typedef signed short PaInt32;
-typedef unsigned short PaUint32;
-#elif SIZEOF_INT == 4
-typedef signed int PaInt32;
-typedef unsigned int PaUint32;
-#elif SIZEOF_LONG == 4
-typedef signed long PaInt32;
-typedef unsigned long PaUint32;
-#else
-#error pa_types.h was unable to determine which type to use for 32bit integers on the target platform
-#endif
-
-
-/* PA_VALIDATE_TYPE_SIZES compares the size of the integer types at runtime to
- ensure that PortAudio was configured correctly, and raises an assertion if
- they don't match the expected values. <assert.h> must be included in the
- context in which this macro is used.
-*/
-#define PA_VALIDATE_TYPE_SIZES \
-    { \
-        assert( "PortAudio: type sizes are not correct in pa_types.h" && sizeof( PaUint16 ) == 2 ); \
-        assert( "PortAudio: type sizes are not correct in pa_types.h" && sizeof( PaInt16 ) == 2 ); \
-        assert( "PortAudio: type sizes are not correct in pa_types.h" && sizeof( PaUint32 ) == 4 ); \
-        assert( "PortAudio: type sizes are not correct in pa_types.h" && sizeof( PaInt32 ) == 4 ); \
-    }
-
-
-#endif /* PA_TYPES_H */
diff --git a/portaudio/src/common/pa_util.h b/portaudio/src/common/pa_util.h
deleted file mode 100644
index 08dc0ec..0000000
--- a/portaudio/src/common/pa_util.h
+++ /dev/null
@@ -1,159 +0,0 @@
-#ifndef PA_UTIL_H
-#define PA_UTIL_H
-/*
- * $Id$
- * Portable Audio I/O Library implementation utilities header
- * common implementation utilities and interfaces
- *
- * Based on the Open Source API proposed by Ross Bencina
- * Copyright (c) 1999-2008 Ross Bencina, 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.
- */
-
-/** @file
- @ingroup common_src
-
-    @brief Prototypes for utility functions used by PortAudio implementations.
-
-    Some functions declared here are defined in pa_front.c while others
-    are implemented separately for each platform.
-*/
-
-
-#include "portaudio.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-
-struct PaUtilHostApiRepresentation;
-
-
-/** Retrieve a specific host API representation. This function can be used
- by implementations to retrieve a pointer to their representation in
- host api specific extension functions which aren't passed a rep pointer
- by pa_front.c.
-
- @param hostApi A pointer to a host API representation pointer. Upon success
- this will receive the requested representation pointer.
-
- @param type A valid host API type identifier.
-
- @returns An error code. If the result is PaNoError then a pointer to the
- requested host API representation will be stored in *hostApi. If the host API
- specified by type is not found, this function returns paHostApiNotFound.
-*/
-PaError PaUtil_GetHostApiRepresentation( struct PaUtilHostApiRepresentation **hostApi,
-        PaHostApiTypeId type );
-
-
-/** Convert a PortAudio device index into a host API specific device index.
- @param hostApiDevice Pointer to a device index, on success this will receive the
- converted device index value.
- @param device The PortAudio device index to convert.
- @param hostApi The host api which the index should be converted for.
-
- @returns On success returns PaNoError and places the converted index in the
- hostApiDevice parameter.
-*/
-PaError PaUtil_DeviceIndexToHostApiDeviceIndex(
-        PaDeviceIndex *hostApiDevice, PaDeviceIndex device,
-        struct PaUtilHostApiRepresentation *hostApi );
-
-
-/** Set the host error information returned by Pa_GetLastHostErrorInfo. This
- function and the paUnanticipatedHostError error code should be used as a
- last resort.  Implementors should use existing PA error codes where possible,
- or nominate new ones. Note that at it is always better to use
- PaUtil_SetLastHostErrorInfo() and paUnanticipatedHostError than to return an
- ambiguous or inaccurate PaError code.
-
- @param hostApiType  The host API which encountered the error (ie of the caller)
-
- @param errorCode The error code returned by the native API function.
-
- @param errorText A string describing the error. PaUtil_SetLastHostErrorInfo
- makes a copy of the string, so it is not necessary for the pointer to remain
- valid after the call to PaUtil_SetLastHostErrorInfo() returns.
-
-*/
-void PaUtil_SetLastHostErrorInfo( PaHostApiTypeId hostApiType, long errorCode,
-        const char *errorText );
-
-
-
-/* the following functions are implemented in a platform platform specific
- .c file
-*/
-
-/** Allocate size bytes, guaranteed to be aligned to a FIXME byte boundary */
-void *PaUtil_AllocateMemory( long size );
-
-
-/** Release block if non-NULL. block may be NULL */
-void PaUtil_FreeMemory( void *block );
-
-
-/** Return the number of currently allocated blocks. This function can be
- used for detecting memory leaks.
-
- @note Allocations will only be tracked if PA_TRACK_MEMORY is #defined. If
- it isn't, this function will always return 0.
-*/
-int PaUtil_CountCurrentlyAllocatedBlocks( void );
-
-
-/** Initialize the clock used by PaUtil_GetTime(). Call this before calling
- PaUtil_GetTime.
-
- @see PaUtil_GetTime
-*/
-void PaUtil_InitializeClock( void );
-
-
-/** Return the system time in seconds. Used to implement CPU load functions
-
- @see PaUtil_InitializeClock
-*/
-double PaUtil_GetTime( void );
-
-
-/* void Pa_Sleep( long msec );  must also be implemented in per-platform .c file */
-
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* PA_UTIL_H */