SV platform dependency builds

/*

 * $Id$

 * Portable Audio I/O Library for ASIO Drivers

 *

 * Author: Stephane Letz

 * Based on the Open Source API proposed by Ross Bencina

 * Copyright (c) 2000-2002 Stephane Letz, Phil Burk, Ross Bencina

 * Blocking i/o implementation by Sven Fischer, Institute of Hearing

 * Technology and Audiology (www.hoertechnik-audiologie.de)

 *

 * 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.

 */

/* Modification History

        08-03-01 First version : Stephane Letz

        08-06-01 Tweaks for PC, use C++, buffer allocation, Float32 to Int32 conversion : Phil Burk

        08-20-01 More conversion, PA_StreamTime, Pa_GetHostError : Stephane Letz

        08-21-01 PaUInt8 bug correction, implementation of ASIOSTFloat32LSB and ASIOSTFloat32MSB native formats : Stephane Letz

        08-24-01 MAX_INT32_FP hack, another Uint8 fix : Stephane and Phil

        08-27-01 Implementation of hostBufferSize < userBufferSize case, better management of the ouput buffer when

                 the stream is stopped : Stephane Letz

        08-28-01 Check the stream pointer for null in bufferSwitchTimeInfo, correct bug in bufferSwitchTimeInfo when

                 the stream is stopped : Stephane Letz

        10-12-01 Correct the PaHost_CalcNumHostBuffers function: computes FramesPerHostBuffer to be the lowest that

                 respect requested FramesPerUserBuffer and userBuffersPerHostBuffer : Stephane Letz

        10-26-01 Management of hostBufferSize and userBufferSize of any size : Stephane Letz

        10-27-01 Improve calculus of hostBufferSize to be multiple or divisor of userBufferSize if possible : Stephane and Phil

        10-29-01 Change MAX_INT32_FP to (2147483520.0f) to prevent roundup to 0x80000000 : Phil Burk

        10-31-01 Clear the ouput buffer and user buffers in PaHost_StartOutput, correct bug in GetFirstMultiple : Stephane Letz

        11-06-01 Rename functions : Stephane Letz

        11-08-01 New Pa_ASIO_Adaptor_Init function to init Callback adpatation variables, cleanup of Pa_ASIO_Callback_Input: Stephane Letz

        11-29-01 Break apart device loading to debug random failure in Pa_ASIO_QueryDeviceInfo ; Phil Burk

        01-03-02 Desallocate all resources in PaHost_Term for cases where Pa_CloseStream is not called properly :  Stephane Letz

        02-01-02 Cleanup, test of multiple-stream opening : Stephane Letz

        19-02-02 New Pa_ASIO_loadDriver that calls CoInitialize on each thread on Windows : Stephane Letz

        09-04-02 Correct error code management in PaHost_Term, removes various compiler warning : Stephane Letz

        12-04-02 Add Mac includes for <Devices.h> and <Timer.h> : Phil Burk

        13-04-02 Removes another compiler warning : Stephane Letz

        30-04-02 Pa_ASIO_QueryDeviceInfo bug correction, memory allocation checking, better error handling : D Viens, P Burk, S Letz

        12-06-02 Rehashed into new multi-api infrastructure, added support for all ASIO sample formats : Ross Bencina

        18-06-02 Added pa_asio.h, PaAsio_GetAvailableLatencyValues() : Ross B.

        21-06-02 Added SelectHostBufferSize() which selects host buffer size based on user latency parameters : Ross Bencina

        ** NOTE  maintanance history is now stored in CVS **

*/

/** @file

    @ingroup hostapi_src

    Note that specific support for paInputUnderflow, paOutputOverflow and

    paNeverDropInput is not necessary or possible with this driver due to the

    synchronous full duplex double-buffered architecture of ASIO.

*/

#include <stdio.h>

#include <assert.h>

#include <string.h>

//#include <values.h>

#include <new>

#include <windows.h>

#include <mmsystem.h>

#include "portaudio.h"

#include "pa_asio.h"

#include "pa_util.h"

#include "pa_allocation.h"

#include "pa_hostapi.h"

#include "pa_stream.h"

#include "pa_cpuload.h"

#include "pa_process.h"

#include "pa_debugprint.h"

#include "pa_ringbuffer.h"

#include "pa_win_coinitialize.h"

/* This version of pa_asio.cpp is currently only targetted at Win32,

   It would require a few tweaks to work with pre-OS X Macintosh.

   To make configuration easier, we define WIN32 here to make sure

   that the ASIO SDK knows this is Win32.

*/

#ifndef WIN32

#define WIN32

#endif

#include "asiosys.h"

#include "asio.h"

#include "asiodrivers.h"

#include "iasiothiscallresolver.h"

/*

#if MAC

#include <Devices.h>

#include <Timer.h>

#include <Math64.h>

#else

*/

/*

#include <math.h>

#include <windows.h>

#include <mmsystem.h>

*/

/*

#endif

*/

/* winmm.lib is needed for timeGetTime() (this is in winmm.a if you're using gcc) */

#if (defined(WIN32) && (defined(_MSC_VER) && (_MSC_VER >= 1200))) /* MSC version 6 and above */

#pragma comment(lib, "winmm.lib")

#endif

/* external reference to ASIO SDK's asioDrivers.

 This is a bit messy because we want to explicitly manage 

 allocation/deallocation of this structure, but some layers of the SDK 

 which we currently use (eg the implementation in asio.cpp) still

 use this global version.

 For now we keep it in sync with our local instance in the host

 API representation structure, but later we should be able to remove

 all dependence on it.

*/

extern AsioDrivers* asioDrivers;

/* We are trying to be compatible with CARBON but this has not been thoroughly tested. */

/* not tested at all since new V19 code was introduced. */

#define CARBON_COMPATIBLE  (0)

/* prototypes for functions declared in this file */

extern "C" PaError PaAsio_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex );

static void Terminate( struct PaUtilHostApiRepresentation *hostApi );

static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

                           PaStream** s,

                           const PaStreamParameters *inputParameters,

                           const PaStreamParameters *outputParameters,

                           double sampleRate,

                           unsigned long framesPerBuffer,

                           PaStreamFlags streamFlags,

                           PaStreamCallback *streamCallback,

                           void *userData );

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate );

static PaError CloseStream( PaStream* stream );

static PaError StartStream( PaStream *stream );

static PaError StopStream( PaStream *stream );

static PaError AbortStream( PaStream *stream );

static PaError IsStreamStopped( PaStream *s );

static PaError IsStreamActive( PaStream *stream );

static PaTime GetStreamTime( PaStream *stream );

static double GetStreamCpuLoad( PaStream* stream );

static PaError ReadStream( PaStream* stream, void *buffer, unsigned long frames );

static PaError WriteStream( PaStream* stream, const void *buffer, unsigned long frames );

static signed long GetStreamReadAvailable( PaStream* stream );

static signed long GetStreamWriteAvailable( PaStream* stream );

/* Blocking i/o callback function. */

static int BlockingIoPaCallback(const void                     *inputBuffer    ,

                                      void                     *outputBuffer   ,

                                      unsigned long             framesPerBuffer,

                                const PaStreamCallbackTimeInfo *timeInfo       ,

                                      PaStreamCallbackFlags     statusFlags    ,

                                      void                     *userData       );

/* our ASIO callback functions */

static void bufferSwitch(long index, ASIOBool processNow);

static ASIOTime *bufferSwitchTimeInfo(ASIOTime *timeInfo, long index, ASIOBool processNow);

static void sampleRateChanged(ASIOSampleRate sRate);

static long asioMessages(long selector, long value, void* message, double* opt);

static ASIOCallbacks asioCallbacks_ =

    { bufferSwitch, sampleRateChanged, asioMessages, bufferSwitchTimeInfo };

#define PA_ASIO_SET_LAST_HOST_ERROR( errorCode, errorText ) \

    PaUtil_SetLastHostErrorInfo( paASIO, errorCode, errorText )

static void PaAsio_SetLastSystemError( DWORD errorCode )

{

    LPVOID lpMsgBuf;

    FormatMessage(

        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

        NULL,

        errorCode,

        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

        (LPTSTR) &lpMsgBuf,

        0,

        NULL

    );

    PaUtil_SetLastHostErrorInfo( paASIO, errorCode, (const char*)lpMsgBuf );

    LocalFree( lpMsgBuf );

}

#define PA_ASIO_SET_LAST_SYSTEM_ERROR( errorCode ) \

    PaAsio_SetLastSystemError( errorCode )

static const char* PaAsio_GetAsioErrorText( ASIOError asioError )

{

    const char *result;

    switch( asioError ){

        case ASE_OK:

        case ASE_SUCCESS:           result = "Success"; break;

        case ASE_NotPresent:        result = "Hardware input or output is not present or available"; break;

        case ASE_HWMalfunction:     result = "Hardware is malfunctioning"; break;

        case ASE_InvalidParameter:  result = "Input parameter invalid"; break;

        case ASE_InvalidMode:       result = "Hardware is in a bad mode or used in a bad mode"; break;

        case ASE_SPNotAdvancing:    result = "Hardware is not running when sample position is inquired"; break;

        case ASE_NoClock:           result = "Sample clock or rate cannot be determined or is not present"; break;

        case ASE_NoMemory:          result = "Not enough memory for completing the request"; break;

        default:                    result = "Unknown ASIO error"; break;

    }

    return result;

}

#define PA_ASIO_SET_LAST_ASIO_ERROR( asioError ) \

    PaUtil_SetLastHostErrorInfo( paASIO, asioError, PaAsio_GetAsioErrorText( asioError ) )

// Atomic increment and decrement operations

#if MAC

    /* need to be implemented on Mac */

    inline long PaAsio_AtomicIncrement(volatile long* v) {return ++(*const_cast<long*>(v));}

    inline long PaAsio_AtomicDecrement(volatile long* v) {return --(*const_cast<long*>(v));}

#elif WINDOWS

    inline long PaAsio_AtomicIncrement(volatile long* v) {return InterlockedIncrement(const_cast<long*>(v));}

    inline long PaAsio_AtomicDecrement(volatile long* v) {return InterlockedDecrement(const_cast<long*>(v));}

#endif

typedef struct PaAsioDriverInfo

{

    ASIODriverInfo asioDriverInfo;

    long inputChannelCount, outputChannelCount;

    long bufferMinSize, bufferMaxSize, bufferPreferredSize, bufferGranularity;

    bool postOutput;

}

PaAsioDriverInfo;

/* PaAsioHostApiRepresentation - host api datastructure specific to this implementation */

typedef struct

{

    PaUtilHostApiRepresentation inheritedHostApiRep;

    PaUtilStreamInterface callbackStreamInterface;

    PaUtilStreamInterface blockingStreamInterface;

    PaUtilAllocationGroup *allocations;

    PaWinUtilComInitializationResult comInitializationResult;

    AsioDrivers *asioDrivers;

    void *systemSpecific;

    /* the ASIO C API only allows one ASIO driver to be open at a time,

        so we keep track of whether we have the driver open here, and

        use this information to return errors from OpenStream if the

        driver is already open.

        openAsioDeviceIndex will be PaNoDevice if there is no device open

        and a valid pa_asio (not global) device index otherwise.

        openAsioDriverInfo is populated with the driver info for the

        currently open device (if any)

    */

    PaDeviceIndex openAsioDeviceIndex;

    PaAsioDriverInfo openAsioDriverInfo;

}

PaAsioHostApiRepresentation;

/*

    Retrieve <driverCount> driver names from ASIO, returned in a char**

    allocated in <group>.

*/

static char **GetAsioDriverNames( PaAsioHostApiRepresentation *asioHostApi, PaUtilAllocationGroup *group, long driverCount )

{

    char **result = 0;

    int i;

    result =(char**)PaUtil_GroupAllocateMemory(

            group, sizeof(char*) * driverCount );

    if( !result )

        goto error;

    result[0] = (char*)PaUtil_GroupAllocateMemory(

            group, 32 * driverCount );

    if( !result[0] )

        goto error;

    for( i=0; i<driverCount; ++i )

        result[i] = result[0] + (32 * i);

    asioHostApi->asioDrivers->getDriverNames( result, driverCount );

error:

    return result;

}

static PaSampleFormat AsioSampleTypeToPaNativeSampleFormat(ASIOSampleType type)

{

    switch (type) {

        case ASIOSTInt16MSB:

        case ASIOSTInt16LSB:

                return paInt16;

        case ASIOSTFloat32MSB:

        case ASIOSTFloat32LSB:

        case ASIOSTFloat64MSB:

        case ASIOSTFloat64LSB:

                return paFloat32;

        case ASIOSTInt32MSB:

        case ASIOSTInt32LSB:

        case ASIOSTInt32MSB16:

        case ASIOSTInt32LSB16:

        case ASIOSTInt32MSB18:

        case ASIOSTInt32MSB20:

        case ASIOSTInt32MSB24:

        case ASIOSTInt32LSB18:

        case ASIOSTInt32LSB20:

        case ASIOSTInt32LSB24:

                return paInt32;

        case ASIOSTInt24MSB:

        case ASIOSTInt24LSB:

                return paInt24;

        default:

                return paCustomFormat;

    }

}

void AsioSampleTypeLOG(ASIOSampleType type)

{

    switch (type) {

        case ASIOSTInt16MSB:  PA_DEBUG(("ASIOSTInt16MSB\n"));  break;

        case ASIOSTInt16LSB:  PA_DEBUG(("ASIOSTInt16LSB\n"));  break;

        case ASIOSTFloat32MSB:PA_DEBUG(("ASIOSTFloat32MSB\n"));break;

        case ASIOSTFloat32LSB:PA_DEBUG(("ASIOSTFloat32LSB\n"));break;

        case ASIOSTFloat64MSB:PA_DEBUG(("ASIOSTFloat64MSB\n"));break;

        case ASIOSTFloat64LSB:PA_DEBUG(("ASIOSTFloat64LSB\n"));break;

        case ASIOSTInt32MSB:  PA_DEBUG(("ASIOSTInt32MSB\n"));  break;

        case ASIOSTInt32LSB:  PA_DEBUG(("ASIOSTInt32LSB\n"));  break;

        case ASIOSTInt32MSB16:PA_DEBUG(("ASIOSTInt32MSB16\n"));break;

        case ASIOSTInt32LSB16:PA_DEBUG(("ASIOSTInt32LSB16\n"));break;

        case ASIOSTInt32MSB18:PA_DEBUG(("ASIOSTInt32MSB18\n"));break;

        case ASIOSTInt32MSB20:PA_DEBUG(("ASIOSTInt32MSB20\n"));break;

        case ASIOSTInt32MSB24:PA_DEBUG(("ASIOSTInt32MSB24\n"));break;

        case ASIOSTInt32LSB18:PA_DEBUG(("ASIOSTInt32LSB18\n"));break;

        case ASIOSTInt32LSB20:PA_DEBUG(("ASIOSTInt32LSB20\n"));break;

        case ASIOSTInt32LSB24:PA_DEBUG(("ASIOSTInt32LSB24\n"));break;

        case ASIOSTInt24MSB:  PA_DEBUG(("ASIOSTInt24MSB\n"));  break;

        case ASIOSTInt24LSB:  PA_DEBUG(("ASIOSTInt24LSB\n"));  break;

        default:              PA_DEBUG(("Custom Format%d\n",type));break;

    }

}

static int BytesPerAsioSample( ASIOSampleType sampleType )

{

    switch (sampleType) {

        case ASIOSTInt16MSB:

        case ASIOSTInt16LSB:

            return 2;

        case ASIOSTFloat64MSB:

        case ASIOSTFloat64LSB:

            return 8;

        case ASIOSTFloat32MSB:

        case ASIOSTFloat32LSB:

        case ASIOSTInt32MSB:

        case ASIOSTInt32LSB:

        case ASIOSTInt32MSB16:

        case ASIOSTInt32LSB16:

        case ASIOSTInt32MSB18:

        case ASIOSTInt32MSB20:

        case ASIOSTInt32MSB24:

        case ASIOSTInt32LSB18:

        case ASIOSTInt32LSB20:

        case ASIOSTInt32LSB24:

            return 4;

        case ASIOSTInt24MSB:

        case ASIOSTInt24LSB:

            return 3;

        default:

            return 0;

    }

}

static void Swap16( void *buffer, long shift, long count )

{

    unsigned short *p = (unsigned short*)buffer;

    unsigned short temp;

    (void) shift; /* unused parameter */

    while( count-- )

    {

        temp = *p;

        *p++ = (unsigned short)((temp<<8) | (temp>>8));

    }

}

static void Swap24( void *buffer, long shift, long count )

{

    unsigned char *p = (unsigned char*)buffer;

    unsigned char temp;

    (void) shift; /* unused parameter */

    while( count-- )

    {

        temp = *p;

        *p = *(p+2);

        *(p+2) = temp;

        p += 3;

    }

}

#define PA_SWAP32_( x ) ((x>>24) | ((x>>8)&0xFF00) | ((x<<8)&0xFF0000) | (x<<24));

static void Swap32( void *buffer, long shift, long count )

{

    unsigned long *p = (unsigned long*)buffer;

    unsigned long temp;

    (void) shift; /* unused parameter */

    while( count-- )

    {

        temp = *p;

        *p++ = PA_SWAP32_( temp);

    }

}

static void SwapShiftLeft32( void *buffer, long shift, long count )

{

    unsigned long *p = (unsigned long*)buffer;

    unsigned long temp;

    while( count-- )

    {

        temp = *p;

        temp = PA_SWAP32_( temp);

        *p++ = temp << shift;

    }

}

static void ShiftRightSwap32( void *buffer, long shift, long count )

{

    unsigned long *p = (unsigned long*)buffer;

    unsigned long temp;

    while( count-- )

    {

        temp = *p >> shift;

        *p++ = PA_SWAP32_( temp);

    }

}

static void ShiftLeft32( void *buffer, long shift, long count )

{

    unsigned long *p = (unsigned long*)buffer;

    unsigned long temp;

    while( count-- )

    {

        temp = *p;

        *p++ = temp << shift;

    }

}

static void ShiftRight32( void *buffer, long shift, long count )

{

    unsigned long *p = (unsigned long*)buffer;

    unsigned long temp;

    while( count-- )

    {

        temp = *p;

        *p++ = temp >> shift;

    }

}

#define PA_SWAP_( x, y ) temp=x; x = y; y = temp;

static void Swap64ConvertFloat64ToFloat32( void *buffer, long shift, long count )

{

    double *in = (double*)buffer;

    float *out = (float*)buffer;

    unsigned char *p;

    unsigned char temp;

    (void) shift; /* unused parameter */

    while( count-- )

    {

        p = (unsigned char*)in;

        PA_SWAP_( p[0], p[7] );

        PA_SWAP_( p[1], p[6] );

        PA_SWAP_( p[2], p[5] );

        PA_SWAP_( p[3], p[4] );

        *out++ = (float) (*in++);

    }

}

static void ConvertFloat64ToFloat32( void *buffer, long shift, long count )

{

    double *in = (double*)buffer;

    float *out = (float*)buffer;

    (void) shift; /* unused parameter */

    while( count-- )

        *out++ = (float) (*in++);

}

static void ConvertFloat32ToFloat64Swap64( void *buffer, long shift, long count )

{

    float *in = ((float*)buffer) + (count-1);

    double *out = ((double*)buffer) + (count-1);

    unsigned char *p;

    unsigned char temp;

    (void) shift; /* unused parameter */

    while( count-- )

    {

        *out = *in--;

        p = (unsigned char*)out;

        PA_SWAP_( p[0], p[7] );

        PA_SWAP_( p[1], p[6] );

        PA_SWAP_( p[2], p[5] );

        PA_SWAP_( p[3], p[4] );

        out--;

    }

}

static void ConvertFloat32ToFloat64( void *buffer, long shift, long count )

{

    float *in = ((float*)buffer) + (count-1);

    double *out = ((double*)buffer) + (count-1);

    (void) shift; /* unused parameter */

    while( count-- )

        *out-- = *in--;

}

#ifdef MAC

#define PA_MSB_IS_NATIVE_

#undef PA_LSB_IS_NATIVE_

#endif

#ifdef WINDOWS

#undef PA_MSB_IS_NATIVE_

#define PA_LSB_IS_NATIVE_

#endif

typedef void PaAsioBufferConverter( void *, long, long );

static void SelectAsioToPaConverter( ASIOSampleType type, PaAsioBufferConverter **converter, long *shift )

{

    *shift = 0;

    *converter = 0;

    switch (type) {

        case ASIOSTInt16MSB:

            /* dest: paInt16, no conversion necessary, possible byte swap*/

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap16;

            #endif

            break;

        case ASIOSTInt16LSB:

            /* dest: paInt16, no conversion necessary, possible byte swap*/

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap16;

            #endif

            break;

        case ASIOSTFloat32MSB:

            /* dest: paFloat32, no conversion necessary, possible byte swap*/

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTFloat32LSB:

            /* dest: paFloat32, no conversion necessary, possible byte swap*/

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTFloat64MSB:

            /* dest: paFloat32, in-place conversion to/from float32, possible byte swap*/

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap64ConvertFloat64ToFloat32;

            #else

                *converter = ConvertFloat64ToFloat32;

            #endif

            break;

        case ASIOSTFloat64LSB:

            /* dest: paFloat32, in-place conversion to/from float32, possible byte swap*/

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap64ConvertFloat64ToFloat32;

            #else

                *converter = ConvertFloat64ToFloat32;

            #endif

            break;

        case ASIOSTInt32MSB:

            /* dest: paInt32, no conversion necessary, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTInt32LSB:

            /* dest: paInt32, no conversion necessary, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTInt32MSB16:

            /* dest: paInt32, 16 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 16;

            break;

        case ASIOSTInt32MSB18:

            /* dest: paInt32, 14 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 14;

            break;

        case ASIOSTInt32MSB20:

            /* dest: paInt32, 12 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 12;

            break;

        case ASIOSTInt32MSB24:

            /* dest: paInt32, 8 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 8;

            break;

        case ASIOSTInt32LSB16:

            /* dest: paInt32, 16 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 16;

            break;

        case ASIOSTInt32LSB18:

            /* dest: paInt32, 14 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 14;

            break;

        case ASIOSTInt32LSB20:

            /* dest: paInt32, 12 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 12;

            break;

        case ASIOSTInt32LSB24:

            /* dest: paInt32, 8 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = SwapShiftLeft32;

            #else

                *converter = ShiftLeft32;

            #endif

            *shift = 8;

            break;

        case ASIOSTInt24MSB:

            /* dest: paInt24, no conversion necessary, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap24;

            #endif

            break;

        case ASIOSTInt24LSB:

            /* dest: paInt24, no conversion necessary, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap24;

            #endif

            break;

    }

}

static void SelectPaToAsioConverter( ASIOSampleType type, PaAsioBufferConverter **converter, long *shift )

{

    *shift = 0;

    *converter = 0;

    switch (type) {

        case ASIOSTInt16MSB:

            /* src: paInt16, no conversion necessary, possible byte swap*/

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap16;

            #endif

            break;

        case ASIOSTInt16LSB:

            /* src: paInt16, no conversion necessary, possible byte swap*/

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap16;

            #endif

            break;

        case ASIOSTFloat32MSB:

            /* src: paFloat32, no conversion necessary, possible byte swap*/

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTFloat32LSB:

            /* src: paFloat32, no conversion necessary, possible byte swap*/

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTFloat64MSB:

            /* src: paFloat32, in-place conversion to/from float32, possible byte swap*/

            #ifdef PA_LSB_IS_NATIVE_

                *converter = ConvertFloat32ToFloat64Swap64;

            #else

                *converter = ConvertFloat32ToFloat64;

            #endif

            break;

        case ASIOSTFloat64LSB:

            /* src: paFloat32, in-place conversion to/from float32, possible byte swap*/

            #ifdef PA_MSB_IS_NATIVE_

                *converter = ConvertFloat32ToFloat64Swap64;

            #else

                *converter = ConvertFloat32ToFloat64;

            #endif

            break;

        case ASIOSTInt32MSB:

            /* src: paInt32, no conversion necessary, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTInt32LSB:

            /* src: paInt32, no conversion necessary, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap32;

            #endif

            break;

        case ASIOSTInt32MSB16:

            /* src: paInt32, 16 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 16;

            break;

        case ASIOSTInt32MSB18:

            /* src: paInt32, 14 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 14;

            break;

        case ASIOSTInt32MSB20:

            /* src: paInt32, 12 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 12;

            break;

        case ASIOSTInt32MSB24:

            /* src: paInt32, 8 bit shift, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 8;

            break;

        case ASIOSTInt32LSB16:

            /* src: paInt32, 16 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 16;

            break;

        case ASIOSTInt32LSB18:

            /* src: paInt32, 14 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 14;

            break;

        case ASIOSTInt32LSB20:

            /* src: paInt32, 12 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 12;

            break;

        case ASIOSTInt32LSB24:

            /* src: paInt32, 8 bit shift, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = ShiftRightSwap32;

            #else

                *converter = ShiftRight32;

            #endif

            *shift = 8;

            break;

        case ASIOSTInt24MSB:

            /* src: paInt24, no conversion necessary, possible byte swap */

            #ifdef PA_LSB_IS_NATIVE_

                *converter = Swap24;

            #endif

            break;

        case ASIOSTInt24LSB:

            /* src: paInt24, no conversion necessary, possible byte swap */

            #ifdef PA_MSB_IS_NATIVE_

                *converter = Swap24;

            #endif

            break;

    }

}

typedef struct PaAsioDeviceInfo

{

    PaDeviceInfo commonDeviceInfo;

    long minBufferSize;

    long maxBufferSize;

    long preferredBufferSize;

    long bufferGranularity;

    ASIOChannelInfo *asioChannelInfos;

}

PaAsioDeviceInfo;

PaError PaAsio_GetAvailableBufferSizes( PaDeviceIndex device,

        long *minBufferSizeFrames, long *maxBufferSizeFrames, long *preferredBufferSizeFrames, long *granularity )

{

    PaError result;

    PaUtilHostApiRepresentation *hostApi;

    PaDeviceIndex hostApiDevice;

    result = PaUtil_GetHostApiRepresentation( &hostApi, paASIO );

    if( result == paNoError )

    {

        result = PaUtil_DeviceIndexToHostApiDeviceIndex( &hostApiDevice, device, hostApi );

        if( result == paNoError )

        {

            PaAsioDeviceInfo *asioDeviceInfo =

                    (PaAsioDeviceInfo*)hostApi->deviceInfos[hostApiDevice];

            *minBufferSizeFrames = asioDeviceInfo->minBufferSize;

            *maxBufferSizeFrames = asioDeviceInfo->maxBufferSize;

            *preferredBufferSizeFrames = asioDeviceInfo->preferredBufferSize;

            *granularity = asioDeviceInfo->bufferGranularity;

        }

    }

    return result;

}

/* Unload whatever we loaded in LoadAsioDriver().

*/

static void UnloadAsioDriver( void )

{

        ASIOExit();

}

/*

    load the asio driver named by <driverName> and return statistics about

    the driver in info. If no error occurred, the driver will remain open

    and must be closed by the called by calling UnloadAsioDriver() - if an error

    is returned the driver will already be unloaded.

*/

static PaError LoadAsioDriver( PaAsioHostApiRepresentation *asioHostApi, const char *driverName,

        PaAsioDriverInfo *driverInfo, void *systemSpecific )

{

    PaError result = paNoError;

    ASIOError asioError;

    int asioIsInitialized = 0;

    if( !asioHostApi->asioDrivers->loadDriver( const_cast<char*>(driverName) ) )

    {

        result = paUnanticipatedHostError;

        PA_ASIO_SET_LAST_HOST_ERROR( 0, "Failed to load ASIO driver" );

        goto error;

    }

    memset( &driverInfo->asioDriverInfo, 0, sizeof(ASIODriverInfo) );

    driverInfo->asioDriverInfo.asioVersion = 2;

    driverInfo->asioDriverInfo.sysRef = systemSpecific;

    if( (asioError = ASIOInit( &driverInfo->asioDriverInfo )) != ASE_OK )

    {

        result = paUnanticipatedHostError;

        PA_ASIO_SET_LAST_ASIO_ERROR( asioError );

        goto error;

    }

    else

    {

        asioIsInitialized = 1;

    }

    if( (asioError = ASIOGetChannels(&driverInfo->inputChannelCount,

            &driverInfo->outputChannelCount)) != ASE_OK )

    {

        result = paUnanticipatedHostError;

        PA_ASIO_SET_LAST_ASIO_ERROR( asioError );

        goto error;

    }

    if( (asioError = ASIOGetBufferSize(&driverInfo->bufferMinSize,

            &driverInfo->bufferMaxSize, &driverInfo->bufferPreferredSize,

            &driverInfo->bufferGranularity)) != ASE_OK )

    {

        result = paUnanticipatedHostError;

        PA_ASIO_SET_LAST_ASIO_ERROR( asioError );

        goto error;

    }

    if( ASIOOutputReady() == ASE_OK )

        driverInfo->postOutput = true;

    else

        driverInfo->postOutput = false;

    return result;

error:

    if( asioIsInitialized )

        {

                ASIOExit();

        }

    return result;

}

#define PA_DEFAULTSAMPLERATESEARCHORDER_COUNT_     13   /* must be the same number of elements as in the array below */

static ASIOSampleRate defaultSampleRateSearchOrder_[]

     = {44100.0, 48000.0, 32000.0, 24000.0, 22050.0, 88200.0, 96000.0,

        192000.0, 16000.0, 12000.0, 11025.0, 9600.0, 8000.0 };

static PaError InitPaDeviceInfoFromAsioDriver( PaAsioHostApiRepresentation *asioHostApi, 

        const char *driverName, int driverIndex,

        PaDeviceInfo *deviceInfo, PaAsioDeviceInfo *asioDeviceInfo )

{

    PaError result = paNoError;

    /* Due to the headless design of the ASIO API, drivers are free to write over data given to them (like M-Audio

       drivers f.i.). This is an attempt to overcome that. */

    union _tag_local {

        PaAsioDriverInfo info;

        char _padding[4096];

    } paAsioDriver;

    asioDeviceInfo->asioChannelInfos = 0; /* we check this below to handle error cleanup */

    result = LoadAsioDriver( asioHostApi, driverName, &paAsioDriver.info, asioHostApi->systemSpecific );

    if( result == paNoError )

    {

        PA_DEBUG(("PaAsio_Initialize: drv:%d name = %s\n",  driverIndex,deviceInfo->name));

        PA_DEBUG(("PaAsio_Initialize: drv:%d inputChannels       = %d\n", driverIndex, paAsioDriver.info.inputChannelCount));

        PA_DEBUG(("PaAsio_Initialize: drv:%d outputChannels      = %d\n", driverIndex, paAsioDriver.info.outputChannelCount));

        PA_DEBUG(("PaAsio_Initialize: drv:%d bufferMinSize       = %d\n", driverIndex, paAsioDriver.info.bufferMinSize));

        PA_DEBUG(("PaAsio_Initialize: drv:%d bufferMaxSize       = %d\n", driverIndex, paAsioDriver.info.bufferMaxSize));

        PA_DEBUG(("PaAsio_Initialize: drv:%d bufferPreferredSize = %d\n", driverIndex, paAsioDriver.info.bufferPreferredSize));

        PA_DEBUG(("PaAsio_Initialize: drv:%d bufferGranularity   = %d\n", driverIndex, paAsioDriver.info.bufferGranularity));

        deviceInfo->maxInputChannels  = paAsioDriver.info.inputChannelCount;

        deviceInfo->maxOutputChannels = paAsioDriver.info.outputChannelCount;

        deviceInfo->defaultSampleRate = 0.;

        bool foundDefaultSampleRate = false;

        for( int j=0; j < PA_DEFAULTSAMPLERATESEARCHORDER_COUNT_; ++j )

        {

            ASIOError asioError = ASIOCanSampleRate( defaultSampleRateSearchOrder_[j] );

            if( asioError != ASE_NoClock && asioError != ASE_NotPresent )

            {

                deviceInfo->defaultSampleRate = defaultSampleRateSearchOrder_[j];

                foundDefaultSampleRate = true;

                break;

            }

        }

        PA_DEBUG(("PaAsio_Initialize: drv:%d defaultSampleRate = %f\n", driverIndex, deviceInfo->defaultSampleRate));

        if( foundDefaultSampleRate ){

            /* calculate default latency values from bufferPreferredSize

                for default low latency, and bufferMaxSize

                for default high latency.

                use the default sample rate to convert from samples to

                seconds. Without knowing what sample rate the user will

                use this is the best we can do.

            */

            double defaultLowLatency =

                    paAsioDriver.info.bufferPreferredSize / deviceInfo->defaultSampleRate;

            deviceInfo->defaultLowInputLatency = defaultLowLatency;

            deviceInfo->defaultLowOutputLatency = defaultLowLatency;

            double defaultHighLatency =

                    paAsioDriver.info.bufferMaxSize / deviceInfo->defaultSampleRate;

            if( defaultHighLatency < defaultLowLatency )

                defaultHighLatency = defaultLowLatency; /* just in case the driver returns something strange */ 

            deviceInfo->defaultHighInputLatency = defaultHighLatency;

            deviceInfo->defaultHighOutputLatency = defaultHighLatency;

        }else{

            deviceInfo->defaultLowInputLatency = 0.;

            deviceInfo->defaultLowOutputLatency = 0.;

            deviceInfo->defaultHighInputLatency = 0.;

            deviceInfo->defaultHighOutputLatency = 0.;

        }

        PA_DEBUG(("PaAsio_Initialize: drv:%d defaultLowInputLatency = %f\n", driverIndex, deviceInfo->defaultLowInputLatency));

        PA_DEBUG(("PaAsio_Initialize: drv:%d defaultLowOutputLatency = %f\n", driverIndex, deviceInfo->defaultLowOutputLatency));

        PA_DEBUG(("PaAsio_Initialize: drv:%d defaultHighInputLatency = %f\n", driverIndex, deviceInfo->defaultHighInputLatency));

        PA_DEBUG(("PaAsio_Initialize: drv:%d defaultHighOutputLatency = %f\n", driverIndex, deviceInfo->defaultHighOutputLatency));

        asioDeviceInfo->minBufferSize = paAsioDriver.info.bufferMinSize;

        asioDeviceInfo->maxBufferSize = paAsioDriver.info.bufferMaxSize;

        asioDeviceInfo->preferredBufferSize = paAsioDriver.info.bufferPreferredSize;

        asioDeviceInfo->bufferGranularity = paAsioDriver.info.bufferGranularity;

        asioDeviceInfo->asioChannelInfos = (ASIOChannelInfo*)PaUtil_GroupAllocateMemory(

                asioHostApi->allocations,

                sizeof(ASIOChannelInfo) * (deviceInfo->maxInputChannels

                        + deviceInfo->maxOutputChannels) );

        if( !asioDeviceInfo->asioChannelInfos )

        {

            result = paInsufficientMemory;

            goto error_unload;

        }

        int a;

        for( a=0; a < deviceInfo->maxInputChannels; ++a ){

            asioDeviceInfo->asioChannelInfos[a].channel = a;

            asioDeviceInfo->asioChannelInfos[a].isInput = ASIOTrue;

            ASIOError asioError = ASIOGetChannelInfo( &asioDeviceInfo->asioChannelInfos[a] );

            if( asioError != ASE_OK )

            {

                result = paUnanticipatedHostError;

                PA_ASIO_SET_LAST_ASIO_ERROR( asioError );

                goto error_unload;

            }

        }

        for( a=0; a < deviceInfo->maxOutputChannels; ++a ){

            int b = deviceInfo->maxInputChannels + a;

            asioDeviceInfo->asioChannelInfos[b].channel = a;

            asioDeviceInfo->asioChannelInfos[b].isInput = ASIOFalse;

            ASIOError asioError = ASIOGetChannelInfo( &asioDeviceInfo->asioChannelInfos[b] );

            if( asioError != ASE_OK )

            {

                result = paUnanticipatedHostError;

                PA_ASIO_SET_LAST_ASIO_ERROR( asioError );

                goto error_unload;

            }

        }

        /* unload the driver */

        UnloadAsioDriver();

    }

    return result;

error_unload:

    UnloadAsioDriver();

    if( asioDeviceInfo->asioChannelInfos ){

        PaUtil_GroupFreeMemory( asioHostApi->allocations, asioDeviceInfo->asioChannelInfos );

        asioDeviceInfo->asioChannelInfos = 0;

    }

    return result;

}

/* we look up IsDebuggerPresent at runtime incase it isn't present (on Win95 for example) */

typedef BOOL (WINAPI *IsDebuggerPresentPtr)(VOID);

IsDebuggerPresentPtr IsDebuggerPresent_ = 0;

//FARPROC IsDebuggerPresent_ = 0; // this is the current way to do it apparently according to davidv

PaError PaAsio_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )

{

    PaError result = paNoError;

    int i, driverCount;

    PaAsioHostApiRepresentation *asioHostApi;

    PaAsioDeviceInfo *deviceInfoArray;

    char **names;

    asioHostApi = (PaAsioHostApiRepresentation*)PaUtil_AllocateMemory( sizeof(PaAsioHostApiRepresentation) );

    if( !asioHostApi )

    {

        result = paInsufficientMemory;

        goto error;

    }

    memset( asioHostApi, 0, sizeof(PaAsioHostApiRepresentation) ); /* ensure all fields are zeroed. especially asioHostApi->allocations */

    /*

        We initialize COM ourselves here and uninitialize it in Terminate().

        This should be the only COM initialization needed in this module.

        The ASIO SDK may also initialize COM but since we want to reduce dependency

        on the ASIO SDK we manage COM initialization ourselves.

        There used to be code that initialized COM in other situations

        such as when creating a Stream. This made PA work when calling Pa_CreateStream

        from a non-main thread. However we currently consider initialization 

        of COM in non-main threads to be the caller's responsibility.

    */

    result = PaWinUtil_CoInitialize( paASIO, &asioHostApi->comInitializationResult );

    if( result != paNoError )

    {

        goto error;

    }

    asioHostApi->asioDrivers = 0; /* avoid surprises in our error handler below */

    asioHostApi->allocations = PaUtil_CreateAllocationGroup();

    if( !asioHostApi->allocations )

    {

        result = paInsufficientMemory;

        goto error;

    }

    /* Allocate the AsioDrivers() driver list (class from ASIO SDK) */

    try

    {

        asioHostApi->asioDrivers = new AsioDrivers(); /* invokes CoInitialize(0) in AsioDriverList::AsioDriverList */

    } 

    catch (std::bad_alloc)

    {

        asioHostApi->asioDrivers = 0;

    }

    /* some implementations of new (ie MSVC, see http://support.microsoft.com/?kbid=167733)

       don't throw std::bad_alloc, so we also explicitly test for a null return. */

    if( asioHostApi->asioDrivers == 0 )

    {

        result = paInsufficientMemory;

        goto error;

    }

    asioDrivers = asioHostApi->asioDrivers; /* keep SDK global in sync until we stop depending on it */

    asioHostApi->systemSpecific = 0;

    asioHostApi->openAsioDeviceIndex = paNoDevice;

    *hostApi = &asioHostApi->inheritedHostApiRep;

    (*hostApi)->info.structVersion = 1;

    (*hostApi)->info.type = paASIO;

    (*hostApi)->info.name = "ASIO";

    (*hostApi)->info.deviceCount = 0;

    #ifdef WINDOWS

        /* use desktop window as system specific ptr */

        asioHostApi->systemSpecific = GetDesktopWindow();

    #endif

    /* driverCount is the number of installed drivers - not necessarily

        the number of installed physical devices. */

    #if MAC

        driverCount = asioHostApi->asioDrivers->getNumFragments();

    #elif WINDOWS

        driverCount = asioHostApi->asioDrivers->asioGetNumDev();

    #endif

    if( driverCount > 0 )

    {

        names = GetAsioDriverNames( asioHostApi, asioHostApi->allocations, driverCount );

        if( !names )

        {

            result = paInsufficientMemory;

            goto error;

        }

        /* allocate enough space for all drivers, even if some aren't installed */

        (*hostApi)->deviceInfos = (PaDeviceInfo**)PaUtil_GroupAllocateMemory(

                asioHostApi->allocations, sizeof(PaDeviceInfo*) * driverCount );

        if( !(*hostApi)->deviceInfos )

        {

            result = paInsufficientMemory;

            goto error;

        }

        /* allocate all device info structs in a contiguous block */

        deviceInfoArray = (PaAsioDeviceInfo*)PaUtil_GroupAllocateMemory(

                asioHostApi->allocations, sizeof(PaAsioDeviceInfo) * driverCount );

        if( !deviceInfoArray )

        {

            result = paInsufficientMemory;

            goto error;

        }

        IsDebuggerPresent_ = (IsDebuggerPresentPtr)GetProcAddress( LoadLibraryA( "Kernel32.dll" ), "IsDebuggerPresent" );

        for( i=0; i < driverCount; ++i )

        {

            PA_DEBUG(("ASIO names[%d]:%s\n",i,names[i]));

            // Since portaudio opens ALL ASIO drivers, and no one else does that,

            // we face fact that some drivers were not meant for it, drivers which act

            // like shells on top of REAL drivers, for instance.

            // so we get duplicate handles, locks and other problems.

            // so lets NOT try to load any such wrappers. 

            // The ones i [davidv] know of so far are:

            if (   strcmp (names[i],"ASIO DirectX Full Duplex Driver") == 0

                || strcmp (names[i],"ASIO Multimedia Driver")          == 0

                || strncmp(names[i],"Premiere",8)                      == 0   //"Premiere Elements Windows Sound 1.0"

                || strncmp(names[i],"Adobe",5)                         == 0   //"Adobe Default Windows Sound 1.5"

               )

            {

                PA_DEBUG(("BLACKLISTED!!!\n"));

                continue;

            }

            if( IsDebuggerPresent_ && IsDebuggerPresent_() )  

            {

                /* ASIO Digidesign Driver uses PACE copy protection which quits out