SV platform dependency builds

/*

 * $Id$

 * pa_win_wmme.c

 * Implementation of PortAudio for Windows MultiMedia Extensions (WMME)       

 *                                                                                         

 * PortAudio Portable Real-Time Audio Library

 * Latest Version at: http://www.portaudio.com

 *

 * Authors: Ross Bencina and Phil Burk

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

 */

/* Modification History:

 PLB = Phil Burk

 JM = Julien Maillard

 RDB = Ross Bencina

 PLB20010402 - sDevicePtrs now allocates based on sizeof(pointer)

 PLB20010413 - check for excessive numbers of channels

 PLB20010422 - apply Mike Berry's changes for CodeWarrior on PC

               including conditional inclusion of memory.h,

               and explicit typecasting on memory allocation

 PLB20010802 - use GlobalAlloc for sDevicesPtr instead of PaHost_AllocFastMemory

 PLB20010816 - pass process instead of thread to SetPriorityClass()

 PLB20010927 - use number of frames instead of real-time for CPULoad calculation.

 JM20020118 - prevent hung thread when buffers underflow.

 PLB20020321 - detect Win XP versus NT, 9x; fix DBUG typo; removed init of CurrentCount

 RDB20020411 - various renaming cleanups, factored streamData alloc and cpu usage init

 RDB20020417 - stopped counting WAVE_MAPPER when there were no real devices

               refactoring, renaming and fixed a few edge case bugs

 RDB20020531 - converted to V19 framework

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

*/

/** @file

    @ingroup hostapi_src

    @brief Win32 host API implementation for the Windows MultiMedia Extensions (WMME) audio API.

*/

/*

    How it works:

    For both callback and blocking read/write streams we open the MME devices

    in CALLBACK_EVENT mode. In this mode, MME signals an Event object whenever

    it has finished with a buffer (either filled it for input, or played it

    for output). Where necessary, we block waiting for Event objects using

    WaitMultipleObjects().

    When implementing a PA callback stream, we set up a high priority thread

    which waits on the MME buffer Events and drains/fills the buffers when

    they are ready.

    When implementing a PA blocking read/write stream, we simply wait on these

    Events (when necessary) inside the ReadStream() and WriteStream() functions.

*/

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include <math.h>

#include <windows.h>

#include <mmsystem.h>

#ifndef UNDER_CE

#include <process.h>

#endif

#include <assert.h>

/* PLB20010422 - "memory.h" doesn't work on CodeWarrior for PC. Thanks Mike Berry for the mod. */

#ifndef __MWERKS__

#include <malloc.h>

#include <memory.h>

#endif /* __MWERKS__ */

#include "portaudio.h"

#include "pa_trace.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_win_wmme.h"

#include "pa_win_waveformat.h"

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

#include "pa_win_wdmks_utils.h"

#ifndef DRV_QUERYDEVICEINTERFACE

#define DRV_QUERYDEVICEINTERFACE     (DRV_RESERVED + 12)

#endif

#ifndef DRV_QUERYDEVICEINTERFACESIZE

#define DRV_QUERYDEVICEINTERFACESIZE (DRV_RESERVED + 13)

#endif

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

/* use CreateThread for CYGWIN, _beginthreadex for all others */

#if !defined(__CYGWIN__) && !defined(_WIN32_WCE)

#define CREATE_THREAD (HANDLE)_beginthreadex( 0, 0, ProcessingThreadProc, stream, 0, &stream->processingThreadId )

#define PA_THREAD_FUNC static unsigned WINAPI

#define PA_THREAD_ID unsigned

#else

#define CREATE_THREAD CreateThread( 0, 0, ProcessingThreadProc, stream, 0, &stream->processingThreadId )

#define PA_THREAD_FUNC static DWORD WINAPI

#define PA_THREAD_ID DWORD

#endif

#if (defined(_WIN32_WCE))

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

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

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

#endif

/*

 provided in newer platform sdks

 */

#ifndef DWORD_PTR

    #if defined(_WIN64)

        #define DWORD_PTR unsigned __int64

    #else

        #define DWORD_PTR unsigned long

    #endif

#endif

/************************************************* Constants ********/

#define PA_MME_USE_HIGH_DEFAULT_LATENCY_    (0)  /* For debugging glitches. */

#if PA_MME_USE_HIGH_DEFAULT_LATENCY_

 #define PA_MME_WIN_9X_DEFAULT_LATENCY_                             (0.4)

 #define PA_MME_MIN_HOST_OUTPUT_BUFFER_COUNT_                       (4)

 #define PA_MME_MIN_HOST_INPUT_BUFFER_COUNT_FULL_DUPLEX_                (4)

 #define PA_MME_MIN_HOST_INPUT_BUFFER_COUNT_HALF_DUPLEX_                (4)

 #define PA_MME_HOST_BUFFER_GRANULARITY_FRAMES_WHEN_UNSPECIFIED_        (16)

 #define PA_MME_MAX_HOST_BUFFER_SECS_                                                (0.3)       /* Do not exceed unless user buffer exceeds */

 #define PA_MME_MAX_HOST_BUFFER_BYTES_                                                (32 * 1024) /* Has precedence over PA_MME_MAX_HOST_BUFFER_SECS_, some drivers are known to crash with buffer sizes > 32k */

#else

 #define PA_MME_WIN_9X_DEFAULT_LATENCY_                             (0.2)

 #define PA_MME_MIN_HOST_OUTPUT_BUFFER_COUNT_                       (2)

 #define PA_MME_MIN_HOST_INPUT_BUFFER_COUNT_FULL_DUPLEX_                (3)         /* always use at least 3 input buffers for full duplex */

 #define PA_MME_MIN_HOST_INPUT_BUFFER_COUNT_HALF_DUPLEX_                (2)

 #define PA_MME_HOST_BUFFER_GRANULARITY_FRAMES_WHEN_UNSPECIFIED_        (16)

 #define PA_MME_MAX_HOST_BUFFER_SECS_                                                (0.1)       /* Do not exceed unless user buffer exceeds */

 #define PA_MME_MAX_HOST_BUFFER_BYTES_                                                (32 * 1024) /* Has precedence over PA_MME_MAX_HOST_BUFFER_SECS_, some drivers are known to crash with buffer sizes > 32k */

#endif

/* Use higher latency for NT because it is even worse at real-time

   operation than Win9x.

*/

#define PA_MME_WIN_NT_DEFAULT_LATENCY_                              (0.4)

/* Default low latency for WDM based systems. This is based on a rough

   survey of workable latency settings using patest_wmme_find_best_latency_params.c.

   See pdf attached to ticket 185 for a graph of the survey results:

   http://www.portaudio.com/trac/ticket/185

   Workable latencies varied between 40ms and ~80ms on different systems (different

   combinations of hardware, 32 and 64 bit, WinXP, Vista and Win7. We didn't

   get enough Vista results to know if Vista has systemically worse latency.

   For now we choose a safe value across all Windows versions here.

*/

#define PA_MME_WIN_WDM_DEFAULT_LATENCY_                             (0.090)

/* When client suggestedLatency could result in many host buffers, we aim to have around 8, 

   based off Windows documentation that suggests that the kmixer uses 8 buffers. This choice

   is somewhat arbitrary here, since we havn't observed significant stability degredation 

   with using either more, or less buffers.     

*/

#define PA_MME_TARGET_HOST_BUFFER_COUNT_    8

#define PA_MME_MIN_TIMEOUT_MSEC_        (1000)

static const char constInputMapperSuffix_[] = " - Input";

static const char constOutputMapperSuffix_[] = " - Output";

/********************************************************************/

/* Copy null-terminated TCHAR string to explicit char string using UTF8 encoding */

static char *CopyTCharStringToUtf8CString(char *destination, size_t destLengthBytes, const TCHAR *source)

{

#if !defined(_UNICODE) && !defined(UNICODE)

    return strcpy(destination, source);

#else

    /* The cbMultiByte parameter ["destLengthBytes" below] is:

    """

    Size, in bytes, of the buffer indicated by lpMultiByteStr ["destination" below]. 

    If this parameter is set to 0, the function returns the required buffer 

    size for lpMultiByteStr and makes no use of the output parameter itself.

    """

    Source: WideCharToMultiByte at MSDN:

    http://msdn.microsoft.com/en-us/library/windows/desktop/dd374130(v=vs.85).aspx

    */

    int intDestLengthBytes; /* cbMultiByte */

    /* intDestLengthBytes is an int, destLengthBytes is a size_t. Ensure that we don't overflow

    intDestLengthBytes by only using at most INT_MAX bytes of destination buffer.

    */

    if (destLengthBytes < INT_MAX)

    {

#pragma warning (disable : 4267) /* "conversion from 'size_t' to 'int', possible loss of data" */

        intDestLengthBytes = (int)destLengthBytes; /* destLengthBytes is guaranteed < INT_MAX here */

#pragma warning (default : 4267)

    }

    else

    {

        intDestLengthBytes = INT_MAX;

    }

    if (WideCharToMultiByte(CP_UTF8, 0, source, -1, destination, /*cbMultiByte=*/intDestLengthBytes, NULL, NULL) == 0)

        return NULL;

    return destination;

#endif

}

/* returns required length (in bytes) of destination buffer when 

   converting TCHAR string to UTF8 bytes, not including the terminating null. */

static size_t TCharStringLen(const TCHAR *str)

{

#if !defined(_UNICODE) && !defined(UNICODE)

    return strlen(str);

#else

    return WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL);        

#endif

}

/********************************************************************/

typedef struct PaWinMmeStream PaWinMmeStream;     /* forward declaration */

/* prototypes for functions declared in this file */

#ifdef __cplusplus

extern "C"

{

#endif /* __cplusplus */

PaError PaWinMme_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex index );

#ifdef __cplusplus

}

#endif /* __cplusplus */

static void Terminate( struct PaUtilHostApiRepresentation *hostApi );

static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

                           PaStream** stream,

                           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 );

/* macros for setting last host error information */

#ifdef UNICODE

#define PA_MME_SET_LAST_WAVEIN_ERROR( mmresult ) \

    {                                                                   \

        wchar_t mmeErrorTextWide[ MAXERRORLENGTH ];                     \

        char mmeErrorText[ MAXERRORLENGTH ];                            \

        waveInGetErrorText( mmresult, mmeErrorTextWide, MAXERRORLENGTH );   \

        WideCharToMultiByte( CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR,\

            mmeErrorTextWide, -1, mmeErrorText, MAXERRORLENGTH, NULL, NULL );  \

        PaUtil_SetLastHostErrorInfo( paMME, mmresult, mmeErrorText );   \

    }

#define PA_MME_SET_LAST_WAVEOUT_ERROR( mmresult ) \

    {                                                                   \

        wchar_t mmeErrorTextWide[ MAXERRORLENGTH ];                     \

        char mmeErrorText[ MAXERRORLENGTH ];                            \

        waveOutGetErrorText( mmresult, mmeErrorTextWide, MAXERRORLENGTH );  \

        WideCharToMultiByte( CP_ACP, WC_COMPOSITECHECK | WC_DEFAULTCHAR,\

            mmeErrorTextWide, -1, mmeErrorText, MAXERRORLENGTH, NULL, NULL );  \

        PaUtil_SetLastHostErrorInfo( paMME, mmresult, mmeErrorText );   \

    }

#else /* !UNICODE */

#define PA_MME_SET_LAST_WAVEIN_ERROR( mmresult ) \

    {                                                                   \

        char mmeErrorText[ MAXERRORLENGTH ];                            \

        waveInGetErrorText( mmresult, mmeErrorText, MAXERRORLENGTH );   \

        PaUtil_SetLastHostErrorInfo( paMME, mmresult, mmeErrorText );   \

    }

#define PA_MME_SET_LAST_WAVEOUT_ERROR( mmresult ) \

    {                                                                   \

        char mmeErrorText[ MAXERRORLENGTH ];                            \

        waveOutGetErrorText( mmresult, mmeErrorText, MAXERRORLENGTH );  \

        PaUtil_SetLastHostErrorInfo( paMME, mmresult, mmeErrorText );   \

    }

#endif /* UNICODE */

static void PaMme_SetLastSystemError( DWORD errorCode )

{

    char *lpMsgBuf;

    FormatMessage(

        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

        NULL,

        errorCode,

        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

        (LPTSTR) &lpMsgBuf,

        0,

        NULL

    );

    PaUtil_SetLastHostErrorInfo( paMME, errorCode, lpMsgBuf );

    LocalFree( lpMsgBuf );

}

#define PA_MME_SET_LAST_SYSTEM_ERROR( errorCode ) \

    PaMme_SetLastSystemError( errorCode )

/* PaError returning wrappers for some commonly used win32 functions

    note that we allow passing a null ptr to have no effect.

*/

static PaError CreateEventWithPaError( HANDLE *handle,

        LPSECURITY_ATTRIBUTES lpEventAttributes,

        BOOL bManualReset,

        BOOL bInitialState,

        LPCTSTR lpName )

{

    PaError result = paNoError;

    *handle = NULL;

    *handle = CreateEvent( lpEventAttributes, bManualReset, bInitialState, lpName );

    if( *handle == NULL )

    {

        result = paUnanticipatedHostError;

        PA_MME_SET_LAST_SYSTEM_ERROR( GetLastError() );

    }

    return result;

}

static PaError ResetEventWithPaError( HANDLE handle )

{

    PaError result = paNoError;

    if( handle )

    {

        if( ResetEvent( handle ) == 0 )

        {

            result = paUnanticipatedHostError;

            PA_MME_SET_LAST_SYSTEM_ERROR( GetLastError() );

        }

    }

    return result;

}

static PaError CloseHandleWithPaError( HANDLE handle )

{

    PaError result = paNoError;

    if( handle )

    {

        if( CloseHandle( handle ) == 0 )

        {

            result = paUnanticipatedHostError;

            PA_MME_SET_LAST_SYSTEM_ERROR( GetLastError() );

        }

    }

    return result;

}

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

typedef struct

{

    PaUtilHostApiRepresentation inheritedHostApiRep;

    PaUtilStreamInterface callbackStreamInterface;

    PaUtilStreamInterface blockingStreamInterface;

    PaUtilAllocationGroup *allocations;

    int inputDeviceCount, outputDeviceCount;

    /** winMmeDeviceIds is an array of WinMme device ids.

        fields in the range [0, inputDeviceCount) are input device ids,

        and [inputDeviceCount, inputDeviceCount + outputDeviceCount) are output

        device ids.

     */ 

    UINT *winMmeDeviceIds;

}

PaWinMmeHostApiRepresentation;

typedef struct

{

    PaDeviceInfo inheritedDeviceInfo;

    DWORD dwFormats; /**<< standard formats bitmask from the WAVEINCAPS and WAVEOUTCAPS structures */

    char deviceInputChannelCountIsKnown; /**<< if the system returns 0xFFFF then we don't really know the number of supported channels (1=>known, 0=>unknown)*/

    char deviceOutputChannelCountIsKnown; /**<< if the system returns 0xFFFF then we don't really know the number of supported channels (1=>known, 0=>unknown)*/

}

PaWinMmeDeviceInfo;

/*************************************************************************

 * Returns recommended device ID.

 * On the PC, the recommended device can be specified by the user by

 * setting an environment variable. For example, to use device #1.

 *

 *    set PA_RECOMMENDED_OUTPUT_DEVICE=1

 *

 * The user should first determine the available device ID by using

 * the supplied application "pa_devs".

 */

#define PA_ENV_BUF_SIZE_  (32)

#define PA_REC_IN_DEV_ENV_NAME_  ("PA_RECOMMENDED_INPUT_DEVICE")

#define PA_REC_OUT_DEV_ENV_NAME_  ("PA_RECOMMENDED_OUTPUT_DEVICE")

static PaDeviceIndex GetEnvDefaultDeviceID( char *envName )

{

    PaDeviceIndex recommendedIndex = paNoDevice;

    DWORD   hresult;

    char    envbuf[PA_ENV_BUF_SIZE_];

#ifndef WIN32_PLATFORM_PSPC /* no GetEnvironmentVariable on PocketPC */

    /* Let user determine default device by setting environment variable. */

    hresult = GetEnvironmentVariableA( envName, envbuf, PA_ENV_BUF_SIZE_ );

    if( (hresult > 0) && (hresult < PA_ENV_BUF_SIZE_) )

    {

        recommendedIndex = atoi( envbuf );

    }

#endif

    return recommendedIndex;

}

static void InitializeDefaultDeviceIdsFromEnv( PaWinMmeHostApiRepresentation *hostApi )

{

    PaDeviceIndex device;

    /* input */

    device = GetEnvDefaultDeviceID( PA_REC_IN_DEV_ENV_NAME_ );

    if( device != paNoDevice &&

            ( device >= 0 && device < hostApi->inheritedHostApiRep.info.deviceCount ) &&

            hostApi->inheritedHostApiRep.deviceInfos[ device ]->maxInputChannels > 0 )

    {

        hostApi->inheritedHostApiRep.info.defaultInputDevice = device;

    }

    /* output */

    device = GetEnvDefaultDeviceID( PA_REC_OUT_DEV_ENV_NAME_ );

    if( device != paNoDevice &&

            ( device >= 0 && device < hostApi->inheritedHostApiRep.info.deviceCount ) &&

            hostApi->inheritedHostApiRep.deviceInfos[ device ]->maxOutputChannels > 0 )

    {

        hostApi->inheritedHostApiRep.info.defaultOutputDevice = device;

    }

}

/** Convert external PA ID to a windows multimedia device ID

*/

static UINT LocalDeviceIndexToWinMmeDeviceId( PaWinMmeHostApiRepresentation *hostApi, PaDeviceIndex device )

{

    assert( device >= 0 && device < hostApi->inputDeviceCount + hostApi->outputDeviceCount );

    return hostApi->winMmeDeviceIds[ device ];

}

static int SampleFormatAndWinWmmeSpecificFlagsToLinearWaveFormatTag( PaSampleFormat sampleFormat, unsigned long winMmeSpecificFlags )

{

    int waveFormatTag = 0;

    if( winMmeSpecificFlags & paWinMmeWaveFormatDolbyAc3Spdif )

        waveFormatTag = PAWIN_WAVE_FORMAT_DOLBY_AC3_SPDIF;

    else if( winMmeSpecificFlags & paWinMmeWaveFormatWmaSpdif )

        waveFormatTag = PAWIN_WAVE_FORMAT_WMA_SPDIF;

    else

        waveFormatTag = PaWin_SampleFormatToLinearWaveFormatTag( sampleFormat );

    return waveFormatTag;

}

static PaError QueryInputWaveFormatEx( int deviceId, WAVEFORMATEX *waveFormatEx )

{

    MMRESULT mmresult;

    switch( mmresult = waveInOpen( NULL, deviceId, waveFormatEx, 0, 0, WAVE_FORMAT_QUERY ) )

    {

        case MMSYSERR_NOERROR:

            return paNoError;

        case MMSYSERR_ALLOCATED:    /* Specified resource is already allocated. */

            return paDeviceUnavailable;

        case MMSYSERR_NODRIVER:            /* No device driver is present. */

            return paDeviceUnavailable;

        case MMSYSERR_NOMEM:            /* Unable to allocate or lock memory. */

            return paInsufficientMemory;

        case WAVERR_BADFORMAT:      /* Attempted to open with an unsupported waveform-audio format. */

            return paSampleFormatNotSupported;

        case MMSYSERR_BADDEVICEID:        /* Specified device identifier is out of range. */

            /* falls through */

        default:

            PA_MME_SET_LAST_WAVEIN_ERROR( mmresult );

            return paUnanticipatedHostError;

    }

}

static PaError QueryOutputWaveFormatEx( int deviceId, WAVEFORMATEX *waveFormatEx )

{

    MMRESULT mmresult;

    switch( mmresult = waveOutOpen( NULL, deviceId, waveFormatEx, 0, 0, WAVE_FORMAT_QUERY ) )

    {

        case MMSYSERR_NOERROR:

            return paNoError;

        case MMSYSERR_ALLOCATED:    /* Specified resource is already allocated. */

            return paDeviceUnavailable;

        case MMSYSERR_NODRIVER:            /* No device driver is present. */

            return paDeviceUnavailable;

        case MMSYSERR_NOMEM:            /* Unable to allocate or lock memory. */

            return paInsufficientMemory;

        case WAVERR_BADFORMAT:      /* Attempted to open with an unsupported waveform-audio format. */

            return paSampleFormatNotSupported;

        case MMSYSERR_BADDEVICEID:        /* Specified device identifier is out of range. */

            /* falls through */

        default:

            PA_MME_SET_LAST_WAVEOUT_ERROR( mmresult );

            return paUnanticipatedHostError;

    }

}

static PaError QueryFormatSupported( PaDeviceInfo *deviceInfo,

        PaError (*waveFormatExQueryFunction)(int, WAVEFORMATEX*),

        int winMmeDeviceId, int channels, double sampleRate, unsigned long winMmeSpecificFlags )

{

    PaWinMmeDeviceInfo *winMmeDeviceInfo = (PaWinMmeDeviceInfo*)deviceInfo;

    PaWinWaveFormat waveFormat;

    PaSampleFormat sampleFormat;

    int waveFormatTag;

    /* @todo at the moment we only query with 16 bit sample format and directout speaker config*/

    sampleFormat = paInt16;

    waveFormatTag = SampleFormatAndWinWmmeSpecificFlagsToLinearWaveFormatTag( sampleFormat, winMmeSpecificFlags );

    if( waveFormatTag == PaWin_SampleFormatToLinearWaveFormatTag( paInt16 ) ){

        /* attempt bypass querying the device for linear formats */

        if( sampleRate == 11025.0

            && ( (channels == 1 && (winMmeDeviceInfo->dwFormats & WAVE_FORMAT_1M16))

                || (channels == 2 && (winMmeDeviceInfo->dwFormats & WAVE_FORMAT_1S16)) ) ){

            return paNoError;

        }

        if( sampleRate == 22050.0

            && ( (channels == 1 && (winMmeDeviceInfo->dwFormats & WAVE_FORMAT_2M16))

                || (channels == 2 && (winMmeDeviceInfo->dwFormats & WAVE_FORMAT_2S16)) ) ){

            return paNoError;

        }

        if( sampleRate == 44100.0

            && ( (channels == 1 && (winMmeDeviceInfo->dwFormats & WAVE_FORMAT_4M16))

                || (channels == 2 && (winMmeDeviceInfo->dwFormats & WAVE_FORMAT_4S16)) ) ){

            return paNoError;

        }

    }

    /* first, attempt to query the device using WAVEFORMATEXTENSIBLE, 

       if this fails we fall back to WAVEFORMATEX */

    PaWin_InitializeWaveFormatExtensible( &waveFormat, channels, sampleFormat, waveFormatTag,

            sampleRate, PAWIN_SPEAKER_DIRECTOUT );

    if( waveFormatExQueryFunction( winMmeDeviceId, (WAVEFORMATEX*)&waveFormat ) == paNoError )

        return paNoError;

    PaWin_InitializeWaveFormatEx( &waveFormat, channels, sampleFormat, waveFormatTag, sampleRate );

    return waveFormatExQueryFunction( winMmeDeviceId, (WAVEFORMATEX*)&waveFormat );

}

#define PA_DEFAULTSAMPLERATESEARCHORDER_COUNT_  (13) /* must match array length below */

static double 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 void DetectDefaultSampleRate( PaWinMmeDeviceInfo *winMmeDeviceInfo, int winMmeDeviceId,

        PaError (*waveFormatExQueryFunction)(int, WAVEFORMATEX*), int maxChannels )

{

    PaDeviceInfo *deviceInfo = &winMmeDeviceInfo->inheritedDeviceInfo;

    int i;

    deviceInfo->defaultSampleRate = 0.;

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

    {

        double sampleRate = defaultSampleRateSearchOrder_[ i ]; 

        PaError paerror = QueryFormatSupported( deviceInfo, waveFormatExQueryFunction, winMmeDeviceId, maxChannels, sampleRate, 0 );

        if( paerror == paNoError )

        {

            deviceInfo->defaultSampleRate = sampleRate;

            break;

        }

    }

}

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

static int QueryWaveInKSFilterMaxChannels( int waveInDeviceId, int *maxChannels )

{

    void *devicePath;

    DWORD devicePathSize;

    int result = 0;

    if( waveInMessage((HWAVEIN)waveInDeviceId, DRV_QUERYDEVICEINTERFACESIZE,

            (DWORD_PTR)&devicePathSize, 0 ) != MMSYSERR_NOERROR )

        return 0;

    devicePath = PaUtil_AllocateMemory( devicePathSize );

    if( !devicePath )

        return 0;

    /* apparently DRV_QUERYDEVICEINTERFACE returns a unicode interface path, although this is undocumented */

    if( waveInMessage((HWAVEIN)waveInDeviceId, DRV_QUERYDEVICEINTERFACE,

            (DWORD_PTR)devicePath, devicePathSize ) == MMSYSERR_NOERROR )

    {

        int count = PaWin_WDMKS_QueryFilterMaximumChannelCount( devicePath, /* isInput= */ 1  );

        if( count > 0 )

        {

            *maxChannels = count;

            result = 1;

        }

    }

    PaUtil_FreeMemory( devicePath );

    return result;

}

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

static PaError InitializeInputDeviceInfo( PaWinMmeHostApiRepresentation *winMmeHostApi,

        PaWinMmeDeviceInfo *winMmeDeviceInfo, UINT winMmeInputDeviceId, int *success )

{

    PaError result = paNoError;

    char *deviceName; /* non-const ptr */

    MMRESULT mmresult;

    WAVEINCAPS wic;

    PaDeviceInfo *deviceInfo = &winMmeDeviceInfo->inheritedDeviceInfo;

    size_t len;

    *success = 0;

    mmresult = waveInGetDevCaps( winMmeInputDeviceId, &wic, sizeof( WAVEINCAPS ) );

    if( mmresult == MMSYSERR_NOMEM )

    {

        result = paInsufficientMemory;

        goto error;

    }

    else if( mmresult != MMSYSERR_NOERROR )

    {

        /* instead of returning paUnanticipatedHostError we return

            paNoError, but leave success set as 0. This allows

            Pa_Initialize to just ignore this device, without failing

            the entire initialisation process.

        */

        return paNoError;

    }           

    /* NOTE: the WAVEOUTCAPS.szPname is a null-terminated array of 32 characters,

        so we are limited to displaying only the first 31 characters of the device name. */

    if( winMmeInputDeviceId == WAVE_MAPPER )

    {

        len = TCharStringLen( wic.szPname ) + 1 + sizeof(constInputMapperSuffix_);

        /* Append I/O suffix to WAVE_MAPPER device. */

        deviceName = (char*)PaUtil_GroupAllocateMemory(

                    winMmeHostApi->allocations,

                    (long)len );

        if( !deviceName )

        {

            result = paInsufficientMemory;

            goto error;

        }

        CopyTCharStringToUtf8CString( deviceName, len, wic.szPname );

        strcat( deviceName, constInputMapperSuffix_ );

    }

    else

    {

        len = TCharStringLen( wic.szPname ) + 1;

        deviceName = (char*)PaUtil_GroupAllocateMemory(

                    winMmeHostApi->allocations,

                    (long)len );

        if( !deviceName )

        {

            result = paInsufficientMemory;

            goto error;

        }

        CopyTCharStringToUtf8CString( deviceName, len, wic.szPname  );

    }

    deviceInfo->name = deviceName;

    if( wic.wChannels == 0xFFFF || wic.wChannels < 1 || wic.wChannels > 255 ){

        /* For Windows versions using WDM (possibly Windows 98 ME and later)

         * the kernel mixer sits between the application and the driver. As a result,

         * wave*GetDevCaps often kernel mixer channel counts, which are unlimited.

         * When this happens we assume the device is stereo and set a flag

         * so that other channel counts can be tried with OpenStream -- i.e. when

         * device*ChannelCountIsKnown is false, OpenStream will try whatever

         * channel count you supply.

         * see also InitializeOutputDeviceInfo() below.

     */

        PA_DEBUG(("Pa_GetDeviceInfo: Num input channels reported as %d! Changed to 2.\n", wic.wChannels ));

        deviceInfo->maxInputChannels = 2;

        winMmeDeviceInfo->deviceInputChannelCountIsKnown = 0;

    }else{

        deviceInfo->maxInputChannels = wic.wChannels;

        winMmeDeviceInfo->deviceInputChannelCountIsKnown = 1;

    }

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

    winMmeDeviceInfo->deviceInputChannelCountIsKnown = 

            QueryWaveInKSFilterMaxChannels( winMmeInputDeviceId, &deviceInfo->maxInputChannels );

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

    winMmeDeviceInfo->dwFormats = wic.dwFormats;

    DetectDefaultSampleRate( winMmeDeviceInfo, winMmeInputDeviceId,

            QueryInputWaveFormatEx, deviceInfo->maxInputChannels );

    *success = 1;

error:

    return result;

}

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

static int QueryWaveOutKSFilterMaxChannels( int waveOutDeviceId, int *maxChannels )

{

    void *devicePath;

    DWORD devicePathSize;

    int result = 0;

    if( waveOutMessage((HWAVEOUT)waveOutDeviceId, DRV_QUERYDEVICEINTERFACESIZE,

            (DWORD_PTR)&devicePathSize, 0 ) != MMSYSERR_NOERROR )

        return 0;

    devicePath = PaUtil_AllocateMemory( devicePathSize );

    if( !devicePath )

        return 0;

    /* apparently DRV_QUERYDEVICEINTERFACE returns a unicode interface path, although this is undocumented */

    if( waveOutMessage((HWAVEOUT)waveOutDeviceId, DRV_QUERYDEVICEINTERFACE,

            (DWORD_PTR)devicePath, devicePathSize ) == MMSYSERR_NOERROR )

    {

        int count = PaWin_WDMKS_QueryFilterMaximumChannelCount( devicePath, /* isInput= */ 0  );

        if( count > 0 )

        {

            *maxChannels = count;

            result = 1;

        }

    }

    PaUtil_FreeMemory( devicePath );

    return result;

}

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

static PaError InitializeOutputDeviceInfo( PaWinMmeHostApiRepresentation *winMmeHostApi,

        PaWinMmeDeviceInfo *winMmeDeviceInfo, UINT winMmeOutputDeviceId, int *success )

{

    PaError result = paNoError;

    char *deviceName; /* non-const ptr */

    MMRESULT mmresult;

    WAVEOUTCAPS woc;

    PaDeviceInfo *deviceInfo = &winMmeDeviceInfo->inheritedDeviceInfo;

    size_t len;

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

    int wdmksDeviceOutputChannelCountIsKnown;

#endif

    *success = 0;

    mmresult = waveOutGetDevCaps( winMmeOutputDeviceId, &woc, sizeof( WAVEOUTCAPS ) );

    if( mmresult == MMSYSERR_NOMEM )

    {

        result = paInsufficientMemory;

        goto error;

    }

    else if( mmresult != MMSYSERR_NOERROR )

    {

        /* instead of returning paUnanticipatedHostError we return

            paNoError, but leave success set as 0. This allows

            Pa_Initialize to just ignore this device, without failing

            the entire initialisation process.

        */

        return paNoError;

    }

    /* NOTE: the WAVEOUTCAPS.szPname is a null-terminated array of 32 characters,

        so we are limited to displaying only the first 31 characters of the device name. */

    if( winMmeOutputDeviceId == WAVE_MAPPER )

    {

        /* Append I/O suffix to WAVE_MAPPER device. */

        len = TCharStringLen( woc.szPname ) + 1 + sizeof(constOutputMapperSuffix_);

        deviceName = (char*)PaUtil_GroupAllocateMemory(

                    winMmeHostApi->allocations, 

                    (long)len );

        if( !deviceName )

        {

            result = paInsufficientMemory;

            goto error;

        }

        CopyTCharStringToUtf8CString( deviceName, len, woc.szPname );

        strcat( deviceName, constOutputMapperSuffix_ );

    }

    else

    {

        len = TCharStringLen( woc.szPname ) + 1;

        deviceName = (char*)PaUtil_GroupAllocateMemory(

                    winMmeHostApi->allocations, 

                    (long)len );

        if( !deviceName )

        {

            result = paInsufficientMemory;

            goto error;

        }

        CopyTCharStringToUtf8CString( deviceName, len, woc.szPname );

    }

    deviceInfo->name = deviceName;

    if( woc.wChannels == 0xFFFF || woc.wChannels < 1 || woc.wChannels > 255 ){

        /* For Windows versions using WDM (possibly Windows 98 ME and later)

         * the kernel mixer sits between the application and the driver. As a result,

         * wave*GetDevCaps often kernel mixer channel counts, which are unlimited.

         * When this happens we assume the device is stereo and set a flag

         * so that other channel counts can be tried with OpenStream -- i.e. when

         * device*ChannelCountIsKnown is false, OpenStream will try whatever

         * channel count you supply.

         * see also InitializeInputDeviceInfo() above.

     */

        PA_DEBUG(("Pa_GetDeviceInfo: Num output channels reported as %d! Changed to 2.\n", woc.wChannels ));

        deviceInfo->maxOutputChannels = 2;

        winMmeDeviceInfo->deviceOutputChannelCountIsKnown = 0;

    }else{

        deviceInfo->maxOutputChannels = woc.wChannels;

        winMmeDeviceInfo->deviceOutputChannelCountIsKnown = 1;

    }

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

    wdmksDeviceOutputChannelCountIsKnown = QueryWaveOutKSFilterMaxChannels( 

            winMmeOutputDeviceId, &deviceInfo->maxOutputChannels );

    if( wdmksDeviceOutputChannelCountIsKnown && !winMmeDeviceInfo->deviceOutputChannelCountIsKnown )

        winMmeDeviceInfo->deviceOutputChannelCountIsKnown = 1;

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

    winMmeDeviceInfo->dwFormats = woc.dwFormats;

    DetectDefaultSampleRate( winMmeDeviceInfo, winMmeOutputDeviceId,

            QueryOutputWaveFormatEx, deviceInfo->maxOutputChannels );

    *success = 1;

error:

    return result;

}

static void GetDefaultLatencies( PaTime *defaultLowLatency, PaTime *defaultHighLatency )

{

/*

NOTE: GetVersionEx() is deprecated as of Windows 8.1 and can not be used to reliably detect

versions of Windows higher than Windows 8 (due to manifest requirements for reporting higher versions).

Microsoft recommends switching to VerifyVersionInfo (available on Win 2k and later), however GetVersionEx

is is faster, for now we just disable the deprecation warning.

See: https://msdn.microsoft.com/en-us/library/windows/desktop/ms724451(v=vs.85).aspx

See: http://www.codeproject.com/Articles/678606/Part-Overcoming-Windows-s-deprecation-of-GetVe

*/

#pragma warning (disable : 4996) /* use of GetVersionEx */

    OSVERSIONINFO osvi;

    osvi.dwOSVersionInfoSize = sizeof( osvi );

    GetVersionEx( &osvi );

    /* Check for NT */

    if( (osvi.dwMajorVersion == 4) && (osvi.dwPlatformId == 2) )

    {

        *defaultLowLatency = PA_MME_WIN_NT_DEFAULT_LATENCY_;

    }

    else if(osvi.dwMajorVersion >= 5)

    {

        *defaultLowLatency  = PA_MME_WIN_WDM_DEFAULT_LATENCY_;

    }

    else

    {

        *defaultLowLatency  = PA_MME_WIN_9X_DEFAULT_LATENCY_;

    }     

    *defaultHighLatency = *defaultLowLatency * 2;

#pragma warning (default : 4996)

}

PaError PaWinMme_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )

{

    PaError result = paNoError;

    int i;

    PaWinMmeHostApiRepresentation *winMmeHostApi;

    int inputDeviceCount, outputDeviceCount, maximumPossibleDeviceCount;

    PaWinMmeDeviceInfo *deviceInfoArray;

    int deviceInfoInitializationSucceeded;

    PaTime defaultLowLatency, defaultHighLatency;

    DWORD waveInPreferredDevice, waveOutPreferredDevice;

    DWORD preferredDeviceStatusFlags;

    winMmeHostApi = (PaWinMmeHostApiRepresentation*)PaUtil_AllocateMemory( sizeof(PaWinMmeHostApiRepresentation) );

    if( !winMmeHostApi )

    {

        result = paInsufficientMemory;

        goto error;

    }

    winMmeHostApi->allocations = PaUtil_CreateAllocationGroup();

    if( !winMmeHostApi->allocations )

    {

        result = paInsufficientMemory;

        goto error;

    }

    *hostApi = &winMmeHostApi->inheritedHostApiRep;

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

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

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

    /* initialise device counts and default devices under the assumption that

        there are no devices. These values are incremented below if and when

        devices are successfully initialized.

    */

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

    (*hostApi)->info.defaultInputDevice = paNoDevice;

    (*hostApi)->info.defaultOutputDevice = paNoDevice;

    winMmeHostApi->inputDeviceCount = 0;

    winMmeHostApi->outputDeviceCount = 0;

#if !defined(DRVM_MAPPER_PREFERRED_GET)

/* DRVM_MAPPER_PREFERRED_GET is defined in mmddk.h but we avoid a dependency on the DDK by defining it here */

#define DRVM_MAPPER_PREFERRED_GET    (0x2000+21)

#endif

    /* the following calls assume that if wave*Message fails the preferred device parameter won't be modified */

    preferredDeviceStatusFlags = 0;

    waveInPreferredDevice = -1;

    waveInMessage( (HWAVEIN)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&waveInPreferredDevice, (DWORD_PTR)&preferredDeviceStatusFlags );

    preferredDeviceStatusFlags = 0;

    waveOutPreferredDevice = -1;

    waveOutMessage( (HWAVEOUT)WAVE_MAPPER, DRVM_MAPPER_PREFERRED_GET, (DWORD_PTR)&waveOutPreferredDevice, (DWORD_PTR)&preferredDeviceStatusFlags );

    maximumPossibleDeviceCount = 0;

    inputDeviceCount = waveInGetNumDevs();

    if( inputDeviceCount > 0 )

        maximumPossibleDeviceCount += inputDeviceCount + 1;        /* assume there is a WAVE_MAPPER */

    outputDeviceCount = waveOutGetNumDevs();

    if( outputDeviceCount > 0 )

        maximumPossibleDeviceCount += outputDeviceCount + 1;        /* assume there is a WAVE_MAPPER */

    if( maximumPossibleDeviceCount > 0 ){

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

                winMmeHostApi->allocations, sizeof(PaDeviceInfo*) * maximumPossibleDeviceCount );

        if( !(*hostApi)->deviceInfos )

        {

            result = paInsufficientMemory;

            goto error;

        }

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

        deviceInfoArray = (PaWinMmeDeviceInfo*)PaUtil_GroupAllocateMemory(

                winMmeHostApi->allocations, sizeof(PaWinMmeDeviceInfo) * maximumPossibleDeviceCount );

        if( !deviceInfoArray )

        {

            result = paInsufficientMemory;

            goto error;

        }

        winMmeHostApi->winMmeDeviceIds = (UINT*)PaUtil_GroupAllocateMemory(

                winMmeHostApi->allocations, sizeof(int) * maximumPossibleDeviceCount );

        if( !winMmeHostApi->winMmeDeviceIds )

        {

            result = paInsufficientMemory;

            goto error;

        }

        GetDefaultLatencies( &defaultLowLatency, &defaultHighLatency );

        if( inputDeviceCount > 0 ){

            /* -1 is the WAVE_MAPPER */

            for( i = -1; i < inputDeviceCount; ++i ){

                UINT winMmeDeviceId = (UINT)((i==-1) ? WAVE_MAPPER : i);

                PaWinMmeDeviceInfo *wmmeDeviceInfo = &deviceInfoArray[ (*hostApi)->info.deviceCount ];

                PaDeviceInfo *deviceInfo = &wmmeDeviceInfo->inheritedDeviceInfo;

                deviceInfo->structVersion = 2;

                deviceInfo->hostApi = hostApiIndex;

                deviceInfo->maxInputChannels = 0;

                wmmeDeviceInfo->deviceInputChannelCountIsKnown = 1;

                deviceInfo->maxOutputChannels = 0;

                wmmeDeviceInfo->deviceOutputChannelCountIsKnown = 1;

                deviceInfo->defaultLowInputLatency = defaultLowLatency;

                deviceInfo->defaultLowOutputLatency = defaultLowLatency;

                deviceInfo->defaultHighInputLatency = defaultHighLatency;

                deviceInfo->defaultHighOutputLatency = defaultHighLatency;

                result = InitializeInputDeviceInfo( winMmeHostApi, wmmeDeviceInfo,

                        winMmeDeviceId, &deviceInfoInitializationSucceeded );

                if( result != paNoError )

                    goto error;

                if( deviceInfoInitializationSucceeded ){

                    if( (*hostApi)->info.defaultInputDevice == paNoDevice ){

                        /* if there is currently no default device, use the first one available */

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

                    }else if( winMmeDeviceId == waveInPreferredDevice ){

                        /* set the default device to the system preferred device */

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

                    }

                    winMmeHostApi->winMmeDeviceIds[ (*hostApi)->info.deviceCount ] = winMmeDeviceId;

                    (*hostApi)->deviceInfos[ (*hostApi)->info.deviceCount ] = deviceInfo;

                    winMmeHostApi->inputDeviceCount++;

                    (*hostApi)->info.deviceCount++;

                }

            }

        }

        if( outputDeviceCount > 0 ){

            /* -1 is the WAVE_MAPPER */

            for( i = -1; i < outputDeviceCount; ++i ){

                UINT winMmeDeviceId = (UINT)((i==-1) ? WAVE_MAPPER : i);

                PaWinMmeDeviceInfo *wmmeDeviceInfo = &deviceInfoArray[ (*hostApi)->info.deviceCount ];

                PaDeviceInfo *deviceInfo = &wmmeDeviceInfo->inheritedDeviceInfo;

                deviceInfo->structVersion = 2;

                deviceInfo->hostApi = hostApiIndex;

                deviceInfo->maxInputChannels = 0;

                wmmeDeviceInfo->deviceInputChannelCountIsKnown = 1;

                deviceInfo->maxOutputChannels = 0;

                wmmeDeviceInfo->deviceOutputChannelCountIsKnown = 1;

                deviceInfo->defaultLowInputLatency = defaultLowLatency;

                deviceInfo->defaultLowOutputLatency = defaultLowLatency;

                deviceInfo->defaultHighInputLatency = defaultHighLatency;

                deviceInfo->defaultHighOutputLatency = defaultHighLatency; 

                result = InitializeOutputDeviceInfo( winMmeHostApi, wmmeDeviceInfo,

                        winMmeDeviceId, &deviceInfoInitializationSucceeded );

                if( result != paNoError )

                    goto error;

                if( deviceInfoInitializationSucceeded ){

                    if( (*hostApi)->info.defaultOutputDevice == paNoDevice ){

                        /* if there is currently no default device, use the first one available */

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

                    }else if( winMmeDeviceId == waveOutPreferredDevice ){

                        /* set the default device to the system preferred device */

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

                    }

                    winMmeHostApi->winMmeDeviceIds[ (*hostApi)->info.deviceCount ] = winMmeDeviceId;

                    (*hostApi)->deviceInfos[ (*hostApi)->info.deviceCount ] = deviceInfo;

                    winMmeHostApi->outputDeviceCount++;

                    (*hostApi)->info.deviceCount++;

                }

            }

        }

    }

    InitializeDefaultDeviceIdsFromEnv( winMmeHostApi );

    (*hostApi)->Terminate = Terminate;

    (*hostApi)->OpenStream = OpenStream;

    (*hostApi)->IsFormatSupported = IsFormatSupported;

    PaUtil_InitializeStreamInterface( &winMmeHostApi->callbackStreamInterface, CloseStream, StartStream,

                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,

                                      GetStreamTime, GetStreamCpuLoad,

                                      PaUtil_DummyRead, PaUtil_DummyWrite,

                                      PaUtil_DummyGetReadAvailable, PaUtil_DummyGetWriteAvailable );

    PaUtil_InitializeStreamInterface( &winMmeHostApi->blockingStreamInterface, CloseStream, StartStream,

                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,

                                      GetStreamTime, PaUtil_DummyGetCpuLoad,

                                      ReadStream, WriteStream, GetStreamReadAvailable, GetStreamWriteAvailable );

    return result;

error:

    if( winMmeHostApi )

    {

        if( winMmeHostApi->allocations )

        {

            PaUtil_FreeAllAllocations( winMmeHostApi->allocations );

            PaUtil_DestroyAllocationGroup( winMmeHostApi->allocations );

        }

        PaUtil_FreeMemory( winMmeHostApi );

    }

    return result;

}

static void Terminate( struct PaUtilHostApiRepresentation *hostApi )

{

    PaWinMmeHostApiRepresentation *winMmeHostApi = (PaWinMmeHostApiRepresentation*)hostApi;

    if( winMmeHostApi->allocations )

    {

        PaUtil_FreeAllAllocations( winMmeHostApi->allocations );

        PaUtil_DestroyAllocationGroup( winMmeHostApi->allocations );

    }

    PaUtil_FreeMemory( winMmeHostApi );

}

static PaError IsInputChannelCountSupported( PaWinMmeDeviceInfo* deviceInfo, int channelCount )

{

    PaError result = paNoError;

    if( channelCount > 0

            && deviceInfo->deviceInputChannelCountIsKnown

            && channelCount > deviceInfo->inheritedDeviceInfo.maxInputChannels ){

        result = paInvalidChannelCount; 

    }

    return result;

}

static PaError IsOutputChannelCountSupported( PaWinMmeDeviceInfo* deviceInfo, int channelCount )

{

    PaError result = paNoError;

    if( channelCount > 0

            && deviceInfo->deviceOutputChannelCountIsKnown

            && channelCount > deviceInfo->inheritedDeviceInfo.maxOutputChannels ){

        result = paInvalidChannelCount; 

    }

    return result;

}

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate )

{

    PaWinMmeHostApiRepresentation *winMmeHostApi = (PaWinMmeHostApiRepresentation*)hostApi;

    PaDeviceInfo *inputDeviceInfo, *outputDeviceInfo;

    int inputChannelCount, outputChannelCount;

    int inputMultipleDeviceChannelCount, outputMultipleDeviceChannelCount;

    PaSampleFormat inputSampleFormat, outputSampleFormat;

    PaWinMmeStreamInfo *inputStreamInfo, *outputStreamInfo;

    UINT winMmeInputDeviceId, winMmeOutputDeviceId;

    unsigned int i;

    PaError paerror;

    /* The calls to QueryFormatSupported below are intended to detect invalid

        sample rates. If we assume that the channel count and format are OK,

        then the only thing that could fail is the sample rate. This isn't

        strictly true, but I can't think of a better way to test that the

        sample rate is valid.

    */  

    if( inputParameters )

    {

        inputChannelCount = inputParameters->channelCount;

        inputSampleFormat = inputParameters->sampleFormat;

        inputStreamInfo = inputParameters->hostApiSpecificStreamInfo;

        /* all standard sample formats are supported by the buffer adapter,

             this implementation doesn't support any custom sample formats */

        if( inputSampleFormat & paCustomFormat )

            return paSampleFormatNotSupported;

        if( inputParameters->device == paUseHostApiSpecificDeviceSpecification

                && inputStreamInfo && (inputStreamInfo->flags & paWinMmeUseMultipleDevices) )

        {

            inputMultipleDeviceChannelCount = 0;

            for( i=0; i< inputStreamInfo->deviceCount; ++i )

            {

                inputMultipleDeviceChannelCount += inputStreamInfo->devices[i].channelCount;

                inputDeviceInfo = hostApi->deviceInfos[ inputStreamInfo->devices[i].device ];

                /* check that input device can support inputChannelCount */

                if( inputStreamInfo->devices[i].channelCount < 1 )

                    return paInvalidChannelCount;

                paerror = IsInputChannelCountSupported( (PaWinMmeDeviceInfo*)inputDeviceInfo, 

                        inputStreamInfo->devices[i].channelCount );

                if( paerror != paNoError )

                    return paerror;

                /* test for valid sample rate, see comment above */

                winMmeInputDeviceId = LocalDeviceIndexToWinMmeDeviceId( winMmeHostApi, inputStreamInfo->devices[i].device );

                paerror = QueryFormatSupported( inputDeviceInfo, QueryInputWaveFormatEx, 

                        winMmeInputDeviceId, inputStreamInfo->devices[i].channelCount, sampleRate, 

                        ((inputStreamInfo) ? inputStreamInfo->flags : 0) );

                if( paerror != paNoError )

                    return paInvalidSampleRate;

            }

            if( inputMultipleDeviceChannelCount != inputChannelCount )

                return paIncompatibleHostApiSpecificStreamInfo;                  

        }

        else

        {

            if( inputStreamInfo && (inputStreamInfo->flags & paWinMmeUseMultipleDevices) )

                return paIncompatibleHostApiSpecificStreamInfo; /* paUseHostApiSpecificDeviceSpecification was not supplied as the input device */

            inputDeviceInfo = hostApi->deviceInfos[ inputParameters->device ];

            /* check that input device can support inputChannelCount */

            paerror = IsInputChannelCountSupported( (PaWinMmeDeviceInfo*)inputDeviceInfo, inputChannelCount );

            if( paerror != paNoError )

                return paerror;

            /* test for valid sample rate, see comment above */

            winMmeInputDeviceId = LocalDeviceIndexToWinMmeDeviceId( winMmeHostApi, inputParameters->device );

            paerror = QueryFormatSupported( inputDeviceInfo, QueryInputWaveFormatEx, 

                    winMmeInputDeviceId, inputChannelCount, sampleRate,

                    ((inputStreamInfo) ? inputStreamInfo->flags : 0) );

            if( paerror != paNoError )

                return paInvalidSampleRate;

        }

    }

    if( outputParameters )

    {

        outputChannelCount = outputParameters->channelCount;

        outputSampleFormat = outputParameters->sampleFormat;

        outputStreamInfo = outputParameters->hostApiSpecificStreamInfo;

        /* all standard sample formats are supported by the buffer adapter,

            this implementation doesn't support any custom sample formats */

        if( outputSampleFormat & paCustomFormat )

            return paSampleFormatNotSupported;

        if( outputParameters->device == paUseHostApiSpecificDeviceSpecification

                && outputStreamInfo && (outputStreamInfo->flags & paWinMmeUseMultipleDevices) )

        {

            outputMultipleDeviceChannelCount = 0;

            for( i=0; i< outputStreamInfo->deviceCount; ++i )

            {

                outputMultipleDeviceChannelCount += outputStreamInfo->devices[i].channelCount;

                outputDeviceInfo = hostApi->deviceInfos[ outputStreamInfo->devices[i].device ];

                /* check that output device can support outputChannelCount */

                if( outputStreamInfo->devices[i].channelCount < 1 )

                    return paInvalidChannelCount;

                paerror = IsOutputChannelCountSupported( (PaWinMmeDeviceInfo*)outputDeviceInfo, 

                        outputStreamInfo->devices[i].channelCount );

                if( paerror != paNoError )

                    return paerror;

                /* test for valid sample rate, see comment above */

                winMmeOutputDeviceId = LocalDeviceIndexToWinMmeDeviceId( winMmeHostApi, outputStreamInfo->devices[i].device );

                paerror = QueryFormatSupported( outputDeviceInfo, QueryOutputWaveFormatEx, 

                        winMmeOutputDeviceId, outputStreamInfo->devices[i].channelCount, sampleRate,

                        ((outputStreamInfo) ? outputStreamInfo->flags : 0) );

                if( paerror != paNoError )

                    return paInvalidSampleRate;

            }

            if( outputMultipleDeviceChannelCount != outputChannelCount )

                return paIncompatibleHostApiSpecificStreamInfo;            

        }

        else

        {

            if( outputStreamInfo && (outputStreamInfo->flags & paWinMmeUseMultipleDevices) )

                return paIncompatibleHostApiSpecificStreamInfo; /* paUseHostApiSpecificDeviceSpecification was not supplied as the output device */

            outputDeviceInfo = hostApi->deviceInfos[ outputParameters->device ];

            /* check that output device can support outputChannelCount */

            paerror = IsOutputChannelCountSupported( (PaWinMmeDeviceInfo*)outputDeviceInfo, outputChannelCount );

            if( paerror != paNoError )

                return paerror;

            /* test for valid sample rate, see comment above */

            winMmeOutputDeviceId = LocalDeviceIndexToWinMmeDeviceId( winMmeHostApi, outputParameters->device );

            paerror = QueryFormatSupported( outputDeviceInfo, QueryOutputWaveFormatEx,