SV platform dependency builds

/*

 * Portable Audio I/O Library WASAPI implementation

 * Copyright (c) 2006-2010 David Viens, Dmitry Kostjuchenko

 *

 * Based on the Open Source API proposed by Ross Bencina

 * Copyright (c) 1999-2002 Ross Bencina, Phil Burk

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files

 * (the "Software"), to deal in the Software without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Software,

 * and to permit persons to whom the Software is furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

/*

 * The text above constitutes the entire PortAudio license; however,

 * the PortAudio community also makes the following non-binding requests:

 *

 * Any person wishing to distribute modifications to the Software is

 * requested to send the modifications to the original developer so that

 * they can be incorporated into the canonical version. It is also

 * requested that these non-binding requests be included along with the

 * license above.

 */

/** @file

 @ingroup hostapi_src

 @brief WASAPI implementation of support for a host API.

 @note pa_wasapi currently requires minimum VC 2005, and the latest Vista SDK

*/

#include <windows.h>

#include <stdio.h>

#include <process.h>

#include <assert.h>

// WinRT

#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)

        #define PA_WINRT

        #define INITGUID

#endif

// WASAPI

#include <mmreg.h>  // must be before other Wasapi headers

#if defined(_MSC_VER) && (_MSC_VER >= 1400)

        #include <Avrt.h>

        #define COBJMACROS

        #include <Audioclient.h>

        #include <endpointvolume.h>

        #define INITGUID // Avoid additional linkage of static libs, excessive code will be optimized out by the compiler

        #include <mmdeviceapi.h>

        #include <functiondiscoverykeys.h>

    #include <devicetopology.h>        // Used to get IKsJackDescription interface

        #undef INITGUID

#endif

#ifndef __MWERKS__

        #include <malloc.h>

        #include <memory.h>

#endif

#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_win_wasapi.h"

#include "pa_debugprint.h"

#include "pa_ringbuffer.h"

#include "pa_win_coinitialize.h"

#if !defined(NTDDI_VERSION)

    #undef WINVER

    #undef _WIN32_WINNT

    #define WINVER       0x0600 // VISTA

        #define _WIN32_WINNT WINVER

        #ifndef _AVRT_ //<< fix MinGW dummy compile by defining missing type: AVRT_PRIORITY

        typedef enum _AVRT_PRIORITY

        {

            AVRT_PRIORITY_LOW = -1,

            AVRT_PRIORITY_NORMAL,

            AVRT_PRIORITY_HIGH,

            AVRT_PRIORITY_CRITICAL

        } AVRT_PRIORITY, *PAVRT_PRIORITY;

        #endif

        #include <basetyps.h> // << for IID/CLSID

    #include <rpcsal.h>

    #include <sal.h>

        #ifndef __LPCGUID_DEFINED__

                #define __LPCGUID_DEFINED__

                typedef const GUID *LPCGUID;

        #endif

    #ifndef PROPERTYKEY_DEFINED

        #define PROPERTYKEY_DEFINED

        typedef struct _tagpropertykey

        {

            GUID fmtid;

            DWORD pid;

        }         PROPERTYKEY;

    #endif

    #ifdef __midl_proxy

        #define __MIDL_CONST

    #else

        #define __MIDL_CONST const

    #endif

    #ifdef WIN64

        #include <wtypes.h>

        typedef LONG NTSTATUS;

        #define FASTCALL

        #include <oleidl.h>

        #include <objidl.h>

     #else

        typedef struct _BYTE_BLOB

        {

            unsigned long clSize;

            unsigned char abData[ 1 ];

        }         BYTE_BLOB;

        typedef /* [unique] */  __RPC_unique_pointer BYTE_BLOB *UP_BYTE_BLOB;

        typedef LONGLONG REFERENCE_TIME;

        #define NONAMELESSUNION

    #endif

    #ifndef WAVE_FORMAT_IEEE_FLOAT

        #define WAVE_FORMAT_IEEE_FLOAT 0x0003 // 32-bit floating-point

    #endif    

    #ifndef __MINGW_EXTENSION

        #if defined(__GNUC__) || defined(__GNUG__)

            #define __MINGW_EXTENSION __extension__

        #else

            #define __MINGW_EXTENSION

        #endif

    #endif 

    #include <sdkddkver.h>

    #include <propkeydef.h>

    #define COBJMACROS

    #define INITGUID // Avoid additional linkage of static libs, excessive code will be optimized out by the compiler

    #include <audioclient.h>

    #include <mmdeviceapi.h>

    #include <endpointvolume.h>

    #include <functiondiscoverykeys.h>

        #include <devicetopology.h>        // Used to get IKsJackDescription interface

    #undef INITGUID

#endif // NTDDI_VERSION

// Missing declarations for WinRT

#ifdef PA_WINRT

        #define DEVICE_STATE_ACTIVE 0x00000001

        typedef        enum _EDataFlow

        {        

                eRender                                        = 0,

                eCapture                                = ( eRender + 1 ) ,

                eAll                                        = ( eCapture + 1 ) ,

                EDataFlow_enum_count        = ( eAll + 1 )

        }

        EDataFlow;

        typedef enum _EndpointFormFactor

        {        

                RemoteNetworkDevice                        = 0,

                Speakers                                        = ( RemoteNetworkDevice + 1 ) ,

                LineLevel                                        = ( Speakers + 1 ) ,

                Headphones                                        = ( LineLevel + 1 ) ,

                Microphone                                        = ( Headphones + 1 ) ,

                Headset                                                = ( Microphone + 1 ) ,

                Handset                                                = ( Headset + 1 ) ,

                UnknownDigitalPassthrough        = ( Handset + 1 ) ,

                SPDIF                                                = ( UnknownDigitalPassthrough + 1 ) ,

                HDMI                                                = ( SPDIF + 1 ) ,

                UnknownFormFactor                        = ( HDMI + 1 ) 

        }         

        EndpointFormFactor;

#endif

#ifndef GUID_SECT

    #define GUID_SECT

#endif

#define __DEFINE_GUID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) static const GUID n GUID_SECT = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}

#define __DEFINE_IID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) static const IID n GUID_SECT = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}

#define __DEFINE_CLSID(n,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) static const CLSID n GUID_SECT = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}}

#define PA_DEFINE_CLSID(className, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

    __DEFINE_CLSID(pa_CLSID_##className, 0x##l, 0x##w1, 0x##w2, 0x##b1, 0x##b2, 0x##b3, 0x##b4, 0x##b5, 0x##b6, 0x##b7, 0x##b8)

#define PA_DEFINE_IID(interfaceName, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

    __DEFINE_IID(pa_IID_##interfaceName, 0x##l, 0x##w1, 0x##w2, 0x##b1, 0x##b2, 0x##b3, 0x##b4, 0x##b5, 0x##b6, 0x##b7, 0x##b8)

// "1CB9AD4C-DBFA-4c32-B178-C2F568A703B2"

PA_DEFINE_IID(IAudioClient,         1cb9ad4c, dbfa, 4c32, b1, 78, c2, f5, 68, a7, 03, b2);

// "726778CD-F60A-4EDA-82DE-E47610CD78AA"

PA_DEFINE_IID(IAudioClient2,        726778cd, f60a, 4eda, 82, de, e4, 76, 10, cd, 78, aa);

// "1BE09788-6894-4089-8586-9A2A6C265AC5"

PA_DEFINE_IID(IMMEndpoint,          1be09788, 6894, 4089, 85, 86, 9a, 2a, 6c, 26, 5a, c5);

// "A95664D2-9614-4F35-A746-DE8DB63617E6"

PA_DEFINE_IID(IMMDeviceEnumerator,  a95664d2, 9614, 4f35, a7, 46, de, 8d, b6, 36, 17, e6);

// "BCDE0395-E52F-467C-8E3D-C4579291692E"

PA_DEFINE_CLSID(IMMDeviceEnumerator,bcde0395, e52f, 467c, 8e, 3d, c4, 57, 92, 91, 69, 2e);

// "F294ACFC-3146-4483-A7BF-ADDCA7C260E2"

PA_DEFINE_IID(IAudioRenderClient,   f294acfc, 3146, 4483, a7, bf, ad, dc, a7, c2, 60, e2);

// "C8ADBD64-E71E-48a0-A4DE-185C395CD317"

PA_DEFINE_IID(IAudioCaptureClient,  c8adbd64, e71e, 48a0, a4, de, 18, 5c, 39, 5c, d3, 17);

// *2A07407E-6497-4A18-9787-32F79BD0D98F*  Or this??

PA_DEFINE_IID(IDeviceTopology,      2A07407E, 6497, 4A18, 97, 87, 32, f7, 9b, d0, d9, 8f);

// *AE2DE0E4-5BCA-4F2D-AA46-5D13F8FDB3A9*

PA_DEFINE_IID(IPart,                AE2DE0E4, 5BCA, 4F2D, aa, 46, 5d, 13, f8, fd, b3, a9);

// *4509F757-2D46-4637-8E62-CE7DB944F57B*

PA_DEFINE_IID(IKsJackDescription,   4509F757, 2D46, 4637, 8e, 62, ce, 7d, b9, 44, f5, 7b);

// Media formats:

__DEFINE_GUID(pa_KSDATAFORMAT_SUBTYPE_PCM,        0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 );

__DEFINE_GUID(pa_KSDATAFORMAT_SUBTYPE_ADPCM,      0x00000002, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 );

__DEFINE_GUID(pa_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 );

#ifdef __IAudioClient2_INTERFACE_DEFINED__

typedef enum _pa_AUDCLNT_STREAMOPTIONS { 

        pa_AUDCLNT_STREAMOPTIONS_NONE          = 0x00,

        pa_AUDCLNT_STREAMOPTIONS_RAW           = 0x01,

        pa_AUDCLNT_STREAMOPTIONS_MATCH_FORMAT  = 0x02

} pa_AUDCLNT_STREAMOPTIONS;

typedef struct _pa_AudioClientProperties {

        UINT32                   cbSize;

        BOOL                     bIsOffload;

        AUDIO_STREAM_CATEGORY    eCategory;

        pa_AUDCLNT_STREAMOPTIONS Options;

} pa_AudioClientProperties;

#define PA_AUDIOCLIENTPROPERTIES_SIZE_CATEGORY (sizeof(pa_AudioClientProperties) - sizeof(pa_AUDCLNT_STREAMOPTIONS))

#define PA_AUDIOCLIENTPROPERTIES_SIZE_OPTIONS   sizeof(pa_AudioClientProperties)

#endif // __IAudioClient2_INTERFACE_DEFINED__

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

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

        #define CREATE_THREAD(PROC) (HANDLE)_beginthreadex( NULL, 0, (PROC), stream, 0, &stream->dwThreadId )

        #define PA_THREAD_FUNC static unsigned WINAPI

        #define PA_THREAD_ID unsigned

#else

        #define CREATE_THREAD(PROC) CreateThread( NULL, 0, (PROC), stream, 0, &stream->dwThreadId )

        #define PA_THREAD_FUNC static DWORD WINAPI

        #define PA_THREAD_ID DWORD

#endif

// Thread function forward decl.

PA_THREAD_FUNC ProcThreadEvent(void *param);

PA_THREAD_FUNC ProcThreadPoll(void *param);

// Availabe from Windows 7

#ifndef AUDCLNT_E_BUFFER_ERROR

        #define AUDCLNT_E_BUFFER_ERROR AUDCLNT_ERR(0x018)

#endif

#ifndef AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED

        #define AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED AUDCLNT_ERR(0x019)

#endif

#ifndef AUDCLNT_E_INVALID_DEVICE_PERIOD

        #define AUDCLNT_E_INVALID_DEVICE_PERIOD AUDCLNT_ERR(0x020)

#endif

#define MAX_STR_LEN 512

enum { S_INPUT = 0, S_OUTPUT = 1, S_COUNT = 2, S_FULLDUPLEX = 0 };

// Number of packets which compose single contignous buffer. With trial and error it was calculated

// that WASAPI Input sub-system uses 6 packets per whole buffer. Please provide more information

// or corrections if available.

enum { WASAPI_PACKETS_PER_INPUT_BUFFER = 6 };

#define STATIC_ARRAY_SIZE(array) (sizeof(array)/sizeof(array[0]))

#define PRINT(x) PA_DEBUG(x);

#define PA_SKELETON_SET_LAST_HOST_ERROR( errorCode, errorText ) \

    PaUtil_SetLastHostErrorInfo( paWASAPI, errorCode, errorText )

#define PA_WASAPI__IS_FULLDUPLEX(STREAM) ((STREAM)->in.clientProc && (STREAM)->out.clientProc)

#ifndef IF_FAILED_JUMP

#define IF_FAILED_JUMP(hr, label) if(FAILED(hr)) goto label;

#endif

#ifndef IF_FAILED_INTERNAL_ERROR_JUMP

#define IF_FAILED_INTERNAL_ERROR_JUMP(hr, error, label) if(FAILED(hr)) { error = paInternalError; goto label; }

#endif

#define SAFE_CLOSE(h) if ((h) != NULL) { CloseHandle((h)); (h) = NULL; }

#define SAFE_RELEASE(punk) if ((punk) != NULL) { (punk)->lpVtbl->Release((punk)); (punk) = NULL; }

// Mixer function

typedef void (*MixMonoToStereoF) (void *__to, void *__from, UINT32 count);

// AVRT is the new "multimedia schedulling stuff"

#ifndef PA_WINRT

typedef BOOL   (WINAPI *FAvRtCreateThreadOrderingGroup)  (PHANDLE,PLARGE_INTEGER,GUID*,PLARGE_INTEGER);

typedef BOOL   (WINAPI *FAvRtDeleteThreadOrderingGroup)  (HANDLE);

typedef BOOL   (WINAPI *FAvRtWaitOnThreadOrderingGroup)  (HANDLE);

typedef HANDLE (WINAPI *FAvSetMmThreadCharacteristics)   (LPCSTR,LPDWORD);

typedef BOOL   (WINAPI *FAvRevertMmThreadCharacteristics)(HANDLE);

typedef BOOL   (WINAPI *FAvSetMmThreadPriority)          (HANDLE,AVRT_PRIORITY);

static HMODULE hDInputDLL = 0;

FAvRtCreateThreadOrderingGroup   pAvRtCreateThreadOrderingGroup = NULL;

FAvRtDeleteThreadOrderingGroup   pAvRtDeleteThreadOrderingGroup = NULL;

FAvRtWaitOnThreadOrderingGroup   pAvRtWaitOnThreadOrderingGroup = NULL;

FAvSetMmThreadCharacteristics    pAvSetMmThreadCharacteristics = NULL;

FAvRevertMmThreadCharacteristics pAvRevertMmThreadCharacteristics = NULL;

FAvSetMmThreadPriority           pAvSetMmThreadPriority = NULL;

#endif

#define _GetProc(fun, type, name)  {                                                        \

                                        fun = (type) GetProcAddress(hDInputDLL,name);       \

                                        if (fun == NULL) {                                  \

                                            PRINT(("GetProcAddr failed for %s" ,name));     \

                                            return FALSE;                                   \

                                        }                                                   \

                                    }                                                       \

// ------------------------------------------------------------------------------------------

/* prototypes for functions declared in this file */

#ifdef __cplusplus

extern "C"

{

#endif /* __cplusplus */

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

#ifdef __cplusplus

}

#endif /* __cplusplus */

// dummy entry point for other compilers and sdks

// currently built using RC1 SDK (5600)

//#if _MSC_VER < 1400

//PaError PaWasapi_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )

//{

    //return paNoError;

//}

//#else

// ------------------------------------------------------------------------------------------

static void Terminate( struct PaUtilHostApiRepresentation *hostApi );

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate );

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

// ------------------------------------------------------------------------------------------

/*

 These are fields that can be gathered from IDevice and IAudioDevice PRIOR to Initialize, and

 done in first pass i assume that neither of these will cause the Driver to "load", but again,

 who knows how they implement their stuff

 */

typedef struct PaWasapiDeviceInfo

{

    // Device

#ifndef PA_WINRT

    IMMDevice *device;

#endif

        // from GetId

    WCHAR szDeviceID[MAX_STR_LEN];

        // from GetState

    DWORD state;

    // Fields filled from IAudioDevice (_prior_ to Initialize)

    // from GetDevicePeriod(

    REFERENCE_TIME DefaultDevicePeriod;

    REFERENCE_TIME MinimumDevicePeriod;

        // Default format (setup through Control Panel by user)

        WAVEFORMATEXTENSIBLE DefaultFormat;

    // Fields filled from IMMEndpoint'sGetDataFlow

    EDataFlow flow;

        // Formfactor

        EndpointFormFactor formFactor;

}

PaWasapiDeviceInfo;

// ------------------------------------------------------------------------------------------

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

typedef struct

{

    PaUtilHostApiRepresentation inheritedHostApiRep;

    PaUtilStreamInterface       callbackStreamInterface;

    PaUtilStreamInterface       blockingStreamInterface;

    PaUtilAllocationGroup      *allocations;

    /* implementation specific data goes here */

    PaWinUtilComInitializationResult comInitializationResult;

    //in case we later need the synch

#ifndef PA_WINRT

    IMMDeviceEnumerator *enumerator;

#endif

    //this is the REAL number of devices, whether they are usefull to PA or not!

    UINT32 deviceCount;

    WCHAR defaultRenderer [MAX_STR_LEN];

    WCHAR defaultCapturer [MAX_STR_LEN];

    PaWasapiDeviceInfo *devInfo;

        // Is true when WOW64 Vista/7 Workaround is needed

        BOOL useWOW64Workaround;

}

PaWasapiHostApiRepresentation;

// ------------------------------------------------------------------------------------------

/* PaWasapiAudioClientParams - audio client parameters */

typedef struct PaWasapiAudioClientParams

{

        PaWasapiDeviceInfo *device_info;

        PaStreamParameters  stream_params;

        PaWasapiStreamInfo  wasapi_params;

        UINT32              frames_per_buffer;

        double              sample_rate;

        BOOL                blocking;

        BOOL                full_duplex;

        BOOL                wow64_workaround;

}

PaWasapiAudioClientParams;

// ------------------------------------------------------------------------------------------

/* PaWasapiStream - a stream data structure specifically for this implementation */

typedef struct PaWasapiSubStream

{

    IAudioClient        *clientParent;

#ifndef PA_WINRT

        IStream                                *clientStream;

#endif

        IAudioClient                *clientProc;

    WAVEFORMATEXTENSIBLE wavex;

    UINT32               bufferSize;

    REFERENCE_TIME       deviceLatency;

    REFERENCE_TIME       period;

        double                                 latencySeconds;

    UINT32                                 framesPerHostCallback;

        AUDCLNT_SHAREMODE    shareMode;

        UINT32               streamFlags; // AUDCLNT_STREAMFLAGS_EVENTCALLBACK, ...

        UINT32               flags;

        PaWasapiAudioClientParams params; //!< parameters

        // Buffers

        UINT32               buffers;                        //!< number of buffers used (from host side)

        UINT32               framesPerBuffer;        //!< number of frames per 1 buffer

        BOOL                 userBufferAndHostMatch;

        // Used for Mono >> Stereo workaround, if driver does not support it

        // (in Exclusive mode WASAPI usually refuses to operate with Mono (1-ch)

        void                *monoBuffer;         //!< pointer to buffer

        UINT32               monoBufferSize; //!< buffer size in bytes

        MixMonoToStereoF     monoMixer;                 //!< pointer to mixer function

        PaUtilRingBuffer    *tailBuffer;       //!< buffer with trailing sample for blocking mode operations (only for Input)

        void                *tailBufferMemory; //!< tail buffer memory region

}

PaWasapiSubStream;

// ------------------------------------------------------------------------------------------

/* PaWasapiHostProcessor - redirects processing data */

typedef struct PaWasapiHostProcessor

{

    PaWasapiHostProcessorCallback processor;

    void *userData;

}

PaWasapiHostProcessor;

// ------------------------------------------------------------------------------------------

typedef struct PaWasapiStream

{

        /* IMPLEMENT ME: rename this */

    PaUtilStreamRepresentation streamRepresentation;

    PaUtilCpuLoadMeasurer      cpuLoadMeasurer;

    PaUtilBufferProcessor      bufferProcessor;

    // input

        PaWasapiSubStream          in;

    IAudioCaptureClient       *captureClientParent;

#ifndef PA_WINRT

        IStream                   *captureClientStream;

#endif

        IAudioCaptureClient       *captureClient;

    IAudioEndpointVolume      *inVol;

        // output

        PaWasapiSubStream          out;

    IAudioRenderClient        *renderClientParent;

#ifndef PA_WINRT

        IStream                   *renderClientStream;

#endif

        IAudioRenderClient        *renderClient;

        IAudioEndpointVolume      *outVol;

        // event handles for event-driven processing mode

        HANDLE event[S_COUNT];

        // buffer mode

        PaUtilHostBufferSizeMode bufferMode;

        // must be volatile to avoid race condition on user query while

        // thread is being started

    volatile BOOL running;

    PA_THREAD_ID dwThreadId;

    HANDLE hThread;

        HANDLE hCloseRequest;

        HANDLE hThreadStart;        //!< signalled by thread on start

        HANDLE hThreadExit;         //!< signalled by thread on exit

        HANDLE hBlockingOpStreamRD;

        HANDLE hBlockingOpStreamWR;

    // Host callback Output overrider

        PaWasapiHostProcessor hostProcessOverrideOutput;

    // Host callback Input overrider

        PaWasapiHostProcessor hostProcessOverrideInput;

        // Defines blocking/callback interface used

        BOOL bBlocking;

        // Av Task (MM thread management)

        HANDLE hAvTask;

        // Thread priority level

        PaWasapiThreadPriority nThreadPriority;

}

PaWasapiStream;

// COM marshaling

static HRESULT MarshalSubStreamComPointers(PaWasapiSubStream *substream);

static HRESULT MarshalStreamComPointers(PaWasapiStream *stream);

static HRESULT UnmarshalSubStreamComPointers(PaWasapiSubStream *substream);

static HRESULT UnmarshalStreamComPointers(PaWasapiStream *stream);

static void ReleaseUnmarshaledSubComPointers(PaWasapiSubStream *substream);

static void ReleaseUnmarshaledComPointers(PaWasapiStream *stream);

// Local stream methods

static void _StreamOnStop(PaWasapiStream *stream);

static void _StreamFinish(PaWasapiStream *stream);

static void _StreamCleanup(PaWasapiStream *stream);

static HRESULT _PollGetOutputFramesAvailable(PaWasapiStream *stream, UINT32 *available);

static HRESULT _PollGetInputFramesAvailable(PaWasapiStream *stream, UINT32 *available);

static void *PaWasapi_ReallocateMemory(void *ptr, size_t size);

static void PaWasapi_FreeMemory(void *ptr);

// Local statics

// ------------------------------------------------------------------------------------------

#define LogHostError(HRES) __LogHostError(HRES, __FUNCTION__, __FILE__, __LINE__)

static HRESULT __LogHostError(HRESULT res, const char *func, const char *file, int line)

{

    const char *text = NULL;

    switch (res)

        {

        case S_OK: return res;

        case E_POINTER                              :text ="E_POINTER"; break;

        case E_INVALIDARG                           :text ="E_INVALIDARG"; break;

        case AUDCLNT_E_NOT_INITIALIZED              :text ="AUDCLNT_E_NOT_INITIALIZED"; break;

        case AUDCLNT_E_ALREADY_INITIALIZED          :text ="AUDCLNT_E_ALREADY_INITIALIZED"; break;

        case AUDCLNT_E_WRONG_ENDPOINT_TYPE          :text ="AUDCLNT_E_WRONG_ENDPOINT_TYPE"; break;

        case AUDCLNT_E_DEVICE_INVALIDATED           :text ="AUDCLNT_E_DEVICE_INVALIDATED"; break;

        case AUDCLNT_E_NOT_STOPPED                  :text ="AUDCLNT_E_NOT_STOPPED"; break;

        case AUDCLNT_E_BUFFER_TOO_LARGE             :text ="AUDCLNT_E_BUFFER_TOO_LARGE"; break;

        case AUDCLNT_E_OUT_OF_ORDER                 :text ="AUDCLNT_E_OUT_OF_ORDER"; break;

        case AUDCLNT_E_UNSUPPORTED_FORMAT           :text ="AUDCLNT_E_UNSUPPORTED_FORMAT"; break;

        case AUDCLNT_E_INVALID_SIZE                 :text ="AUDCLNT_E_INVALID_SIZE"; break;

        case AUDCLNT_E_DEVICE_IN_USE                :text ="AUDCLNT_E_DEVICE_IN_USE"; break;

        case AUDCLNT_E_BUFFER_OPERATION_PENDING     :text ="AUDCLNT_E_BUFFER_OPERATION_PENDING"; break;

        case AUDCLNT_E_THREAD_NOT_REGISTERED        :text ="AUDCLNT_E_THREAD_NOT_REGISTERED"; break;

        case AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED   :text ="AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED"; break;

        case AUDCLNT_E_ENDPOINT_CREATE_FAILED       :text ="AUDCLNT_E_ENDPOINT_CREATE_FAILED"; break;

        case AUDCLNT_E_SERVICE_NOT_RUNNING          :text ="AUDCLNT_E_SERVICE_NOT_RUNNING"; break;

        case AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED     :text ="AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED"; break;

        case AUDCLNT_E_EXCLUSIVE_MODE_ONLY          :text ="AUDCLNT_E_EXCLUSIVE_MODE_ONLY"; break;

        case AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL :text ="AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL"; break;

        case AUDCLNT_E_EVENTHANDLE_NOT_SET          :text ="AUDCLNT_E_EVENTHANDLE_NOT_SET"; break;

        case AUDCLNT_E_INCORRECT_BUFFER_SIZE        :text ="AUDCLNT_E_INCORRECT_BUFFER_SIZE"; break;

        case AUDCLNT_E_BUFFER_SIZE_ERROR            :text ="AUDCLNT_E_BUFFER_SIZE_ERROR"; break;

        case AUDCLNT_E_CPUUSAGE_EXCEEDED            :text ="AUDCLNT_E_CPUUSAGE_EXCEEDED"; break;

        case AUDCLNT_E_BUFFER_ERROR                                        :text ="AUDCLNT_E_BUFFER_ERROR"; break;

        case AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED                :text ="AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED"; break;

        case AUDCLNT_E_INVALID_DEVICE_PERIOD                :text ="AUDCLNT_E_INVALID_DEVICE_PERIOD"; break;

        case AUDCLNT_S_BUFFER_EMPTY                 :text ="AUDCLNT_S_BUFFER_EMPTY"; break;

        case AUDCLNT_S_THREAD_ALREADY_REGISTERED    :text ="AUDCLNT_S_THREAD_ALREADY_REGISTERED"; break;

        case AUDCLNT_S_POSITION_STALLED                                :text ="AUDCLNT_S_POSITION_STALLED"; break;

        // other windows common errors:

        case CO_E_NOTINITIALIZED                    :text ="CO_E_NOTINITIALIZED: you must call CoInitialize() before Pa_OpenStream()"; break;

        default:

                text = "UNKNOWN ERROR";

    }

        PRINT(("WASAPI ERROR HRESULT: 0x%X : %s\n [FUNCTION: %s FILE: %s {LINE: %d}]\n", res, text, func, file, line));

        PA_SKELETON_SET_LAST_HOST_ERROR(res, text);

        return res;

}

// ------------------------------------------------------------------------------------------

#define LogPaError(PAERR) __LogPaError(PAERR, __FUNCTION__, __FILE__, __LINE__)

static PaError __LogPaError(PaError err, const char *func, const char *file, int line)

{

        if (err == paNoError)

                return err;

        PRINT(("WASAPI ERROR PAERROR: %i : %s\n [FUNCTION: %s FILE: %s {LINE: %d}]\n", err, Pa_GetErrorText(err), func, file, line));

        return err;

}

// ------------------------------------------------------------------------------------------

/*! \class ThreadSleepScheduler

           Allows to emulate thread sleep of less than 1 millisecond under Windows. Scheduler

                   calculates number of times the thread must run untill next sleep of 1 millisecond.

                   It does not make thread sleeping for real number of microseconds but rather controls

                   how many of imaginary microseconds the thread task can allow thread to sleep.

*/

typedef struct ThreadIdleScheduler

{

        UINT32 m_idle_microseconds; //!< number of microseconds to sleep

        UINT32 m_next_sleep;        //!< next sleep round

        UINT32 m_i;                                        //!< current round iterator position

        UINT32 m_resolution;                //!< resolution in number of milliseconds

}

ThreadIdleScheduler;

//! Setup scheduler.

static void ThreadIdleScheduler_Setup(ThreadIdleScheduler *sched, UINT32 resolution, UINT32 microseconds)

{

        assert(microseconds != 0);

        assert(resolution != 0);

        assert((resolution * 1000) >= microseconds);

        memset(sched, 0, sizeof(*sched));

        sched->m_idle_microseconds = microseconds;

        sched->m_resolution        = resolution;

        sched->m_next_sleep        = (resolution * 1000) / microseconds;

}

//! Iterate and check if can sleep.

static UINT32 ThreadIdleScheduler_NextSleep(ThreadIdleScheduler *sched)

{

        // advance and check if thread can sleep

        if (++ sched->m_i == sched->m_next_sleep)

        {

                sched->m_i = 0;

                return sched->m_resolution;

        }

        return 0;

}

// ------------------------------------------------------------------------------------------

/*static double nano100ToMillis(REFERENCE_TIME ref)

{

    //  1 nano = 0.000000001 seconds

    //100 nano = 0.0000001   seconds

    //100 nano = 0.0001   milliseconds

    return ((double)ref)*0.0001;

}*/

// ------------------------------------------------------------------------------------------

static double nano100ToSeconds(REFERENCE_TIME ref)

{

    //  1 nano = 0.000000001 seconds

    //100 nano = 0.0000001   seconds

    //100 nano = 0.0001   milliseconds

    return ((double)ref)*0.0000001;

}

// ------------------------------------------------------------------------------------------

/*static REFERENCE_TIME MillisTonano100(double ref)

{

    //  1 nano = 0.000000001 seconds

    //100 nano = 0.0000001   seconds

    //100 nano = 0.0001   milliseconds

    return (REFERENCE_TIME)(ref/0.0001);

}*/

// ------------------------------------------------------------------------------------------

static REFERENCE_TIME SecondsTonano100(double ref)

{

    //  1 nano = 0.000000001 seconds

    //100 nano = 0.0000001   seconds

    //100 nano = 0.0001   milliseconds

    return (REFERENCE_TIME)(ref/0.0000001);

}

// ------------------------------------------------------------------------------------------

// Makes Hns period from frames and sample rate

static REFERENCE_TIME MakeHnsPeriod(UINT32 nFrames, DWORD nSamplesPerSec)

{

        return (REFERENCE_TIME)((10000.0 * 1000 / nSamplesPerSec * nFrames) + 0.5);

}

// ------------------------------------------------------------------------------------------

// Converts PaSampleFormat to bits per sample value

static WORD PaSampleFormatToBitsPerSample(PaSampleFormat format_id)

{

        switch (format_id & ~paNonInterleaved)

        {

                case paFloat32:

                case paInt32: return 32;

                case paInt24: return 24;

                case paInt16: return 16;

                case paInt8:

                case paUInt8: return 8;

        }

        return 0;

}

// ------------------------------------------------------------------------------------------

// Converts PaSampleFormat to bits per sample value

/*static WORD PaSampleFormatToBytesPerSample(PaSampleFormat format_id)

{

        return PaSampleFormatToBitsPerSample(format_id) >> 3; // 'bits/8'

}*/

// ------------------------------------------------------------------------------------------

// Converts Hns period into number of frames

static UINT32 MakeFramesFromHns(REFERENCE_TIME hnsPeriod, UINT32 nSamplesPerSec)

{

    UINT32 nFrames = (UINT32)(        // frames =

        1.0 * hnsPeriod *                // hns *

        nSamplesPerSec /                // (frames / s) /

        1000 /                                        // (ms / s) /

        10000                                        // (hns / s) /

        + 0.5                                        // rounding

    );

        return nFrames;

}

// Aligning function type

typedef UINT32 (*ALIGN_FUNC) (UINT32 v, UINT32 align);

// ------------------------------------------------------------------------------------------

// Aligns 'v' backwards

static UINT32 ALIGN_BWD(UINT32 v, UINT32 align)

{

        return ((v - (align ? v % align : 0)));

}

// ------------------------------------------------------------------------------------------

// Aligns 'v' forward

static UINT32 ALIGN_FWD(UINT32 v, UINT32 align)

{

        UINT32 remainder = (align ? (v % align) : 0);

        if (remainder == 0)

                return v;

        return v + (align - remainder);

}

// ------------------------------------------------------------------------------------------

// Get next value power of 2

UINT32 ALIGN_NEXT_POW2(UINT32 v)

{

        UINT32 v2 = 1;

        while (v > (v2 <<= 1)) { }

        v = v2;

        return v;

}

// ------------------------------------------------------------------------------------------

// Aligns WASAPI buffer to 128 byte packet boundary. HD Audio will fail to play if buffer

// is misaligned. This problem was solved in Windows 7 were AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED

// is thrown although we must align for Vista anyway.

static UINT32 AlignFramesPerBuffer(UINT32 nFrames, UINT32 nSamplesPerSec, UINT32 nBlockAlign,

                                                                   ALIGN_FUNC pAlignFunc)

{

#define HDA_PACKET_SIZE (128)

        long frame_bytes = nFrames * nBlockAlign;

        long packets;

        (void)nSamplesPerSec;

        // align to packet size

        frame_bytes  = pAlignFunc(frame_bytes, HDA_PACKET_SIZE); // use ALIGN_FWD if bigger but safer period is more desired

        // atlest 1 frame must be available

        if (frame_bytes < HDA_PACKET_SIZE)

                frame_bytes = HDA_PACKET_SIZE;

        nFrames      = frame_bytes / nBlockAlign;

        packets      = frame_bytes / HDA_PACKET_SIZE;

        frame_bytes = packets * HDA_PACKET_SIZE;

        nFrames     = frame_bytes / nBlockAlign;

        return nFrames;

#undef HDA_PACKET_SIZE

}

// ------------------------------------------------------------------------------------------

static UINT32 GetFramesSleepTime(UINT32 nFrames, UINT32 nSamplesPerSec)

{

        REFERENCE_TIME nDuration;

        if (nSamplesPerSec == 0)

                return 0;

#define REFTIMES_PER_SEC  10000000

#define REFTIMES_PER_MILLISEC  10000

        // Calculate the actual duration of the allocated buffer.

        nDuration = (REFERENCE_TIME)((double)REFTIMES_PER_SEC * nFrames / nSamplesPerSec);

        return (UINT32)(nDuration/REFTIMES_PER_MILLISEC/2);

}

// ------------------------------------------------------------------------------------------

static UINT32 GetFramesSleepTimeMicroseconds(UINT32 nFrames, UINT32 nSamplesPerSec)

{

        REFERENCE_TIME nDuration;

        if (nSamplesPerSec == 0)

                return 0;

#define REFTIMES_PER_SEC  10000000

#define REFTIMES_PER_MILLISEC  10000

        // Calculate the actual duration of the allocated buffer.

        nDuration = (REFERENCE_TIME)((double)REFTIMES_PER_SEC * nFrames / nSamplesPerSec);

        return (UINT32)(nDuration/10/2);

}

// ------------------------------------------------------------------------------------------

#ifndef PA_WINRT

static BOOL SetupAVRT()

{

    hDInputDLL = LoadLibraryA("avrt.dll");

    if (hDInputDLL == NULL)

        return FALSE;

    _GetProc(pAvRtCreateThreadOrderingGroup,  FAvRtCreateThreadOrderingGroup,  "AvRtCreateThreadOrderingGroup");

    _GetProc(pAvRtDeleteThreadOrderingGroup,  FAvRtDeleteThreadOrderingGroup,  "AvRtDeleteThreadOrderingGroup");

    _GetProc(pAvRtWaitOnThreadOrderingGroup,  FAvRtWaitOnThreadOrderingGroup,  "AvRtWaitOnThreadOrderingGroup");

    _GetProc(pAvSetMmThreadCharacteristics,   FAvSetMmThreadCharacteristics,   "AvSetMmThreadCharacteristicsA");

        _GetProc(pAvRevertMmThreadCharacteristics,FAvRevertMmThreadCharacteristics,"AvRevertMmThreadCharacteristics");

    _GetProc(pAvSetMmThreadPriority,          FAvSetMmThreadPriority,          "AvSetMmThreadPriority");

        return pAvRtCreateThreadOrderingGroup &&

                pAvRtDeleteThreadOrderingGroup &&

                pAvRtWaitOnThreadOrderingGroup &&

                pAvSetMmThreadCharacteristics &&

                pAvRevertMmThreadCharacteristics &&

                pAvSetMmThreadPriority;

}

#endif

// ------------------------------------------------------------------------------------------

static void CloseAVRT()

{

#ifndef PA_WINRT

        if (hDInputDLL != NULL)

                FreeLibrary(hDInputDLL);

        hDInputDLL = NULL;

#endif

}

// ------------------------------------------------------------------------------------------

static BOOL IsWow64()

{

#ifndef PA_WINRT

        // http://msdn.microsoft.com/en-us/library/ms684139(VS.85).aspx

        typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);

        LPFN_ISWOW64PROCESS fnIsWow64Process;

    BOOL bIsWow64 = FALSE;

    // IsWow64Process is not available on all supported versions of Windows.

    // Use GetModuleHandle to get a handle to the DLL that contains the function

    // and GetProcAddress to get a pointer to the function if available.

    fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(

        GetModuleHandleA("kernel32"), "IsWow64Process");

    if (fnIsWow64Process == NULL)

                return FALSE;

    if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64))

                return FALSE;

    return bIsWow64;

#else

        return FALSE;

#endif

}

// ------------------------------------------------------------------------------------------

typedef enum EWindowsVersion

{

        WINDOWS_UNKNOWN = 0,

        WINDOWS_VISTA_SERVER2008,

        WINDOWS_7_SERVER2008R2,

        WINDOWS_8_SERVER2012,

        WINDOWS_8_1_SERVER2012R2,

        WINDOWS_10_SERVER2016,

        WINDOWS_FUTURE

}

EWindowsVersion;

// Alternative way for checking Windows version (allows to check version on Windows 8.1 and up)

#ifndef PA_WINRT

static BOOL IsWindowsVersionOrGreater(WORD wMajorVersion, WORD wMinorVersion, WORD wServicePackMajor)

{

        typedef ULONGLONG (NTAPI *LPFN_VERSETCONDITIONMASK)(ULONGLONG ConditionMask, DWORD TypeMask, BYTE Condition);

        typedef BOOL (WINAPI *LPFN_VERIFYVERSIONINFO)(LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask);

        LPFN_VERSETCONDITIONMASK fnVerSetConditionMask;

        LPFN_VERIFYVERSIONINFO fnVerifyVersionInfo;

        OSVERSIONINFOEXA osvi = { sizeof(osvi), 0, 0, 0, 0, {0}, 0, 0 };

        DWORDLONG dwlConditionMask;

        fnVerSetConditionMask = (LPFN_VERSETCONDITIONMASK)GetProcAddress(GetModuleHandleA("kernel32"), "VerSetConditionMask");

        fnVerifyVersionInfo = (LPFN_VERIFYVERSIONINFO)GetProcAddress(GetModuleHandleA("kernel32"), "VerifyVersionInfoA");

        if ((fnVerSetConditionMask == NULL) || (fnVerifyVersionInfo == NULL))

                return FALSE;

        dwlConditionMask = fnVerSetConditionMask(

                fnVerSetConditionMask(

                        fnVerSetConditionMask(

                                0, VER_MAJORVERSION,     VER_GREATER_EQUAL),

                                   VER_MINORVERSION,     VER_GREATER_EQUAL),

                                   VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);

        osvi.dwMajorVersion    = wMajorVersion;

        osvi.dwMinorVersion    = wMinorVersion;

        osvi.wServicePackMajor = wServicePackMajor;

        return (fnVerifyVersionInfo(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR, dwlConditionMask) != FALSE);

}

#endif

// Get Windows version

static EWindowsVersion GetWindowsVersion()

{

#ifndef PA_WINRT

        static EWindowsVersion version = WINDOWS_UNKNOWN;

        if (version == WINDOWS_UNKNOWN)

        {

                DWORD dwVersion = 0;

                DWORD dwMajorVersion = 0;

                DWORD dwMinorVersion = 0;

                DWORD dwBuild = 0;

                typedef DWORD (WINAPI *LPFN_GETVERSION)(VOID);

                LPFN_GETVERSION fnGetVersion;

                fnGetVersion = (LPFN_GETVERSION)GetProcAddress(GetModuleHandleA("kernel32"), "GetVersion");

                if (fnGetVersion != NULL)

                {

                        PRINT(("WASAPI: getting Windows version with GetVersion()\n"));

                        dwVersion = fnGetVersion();

                        // Get the Windows version

                        dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));

                        dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));

                        // Get the build number

                        if (dwVersion < 0x80000000)

                                dwBuild = (DWORD)(HIWORD(dwVersion));

                        switch (dwMajorVersion)

                        {

                        case 0:

                        case 1:

                        case 2:

                        case 3:

                        case 4:

                        case 5:

                                break; // skip lower

                        case 6:

                                switch (dwMinorVersion)

                                {

                                case 0:  version = WINDOWS_VISTA_SERVER2008;        break;

                                case 1:         version = WINDOWS_7_SERVER2008R2;                break;

                                case 2:         version = WINDOWS_8_SERVER2012;                  break;

                                case 3:         version = WINDOWS_8_1_SERVER2012R2;        break;

                                default: version = WINDOWS_FUTURE;                                break;

                                }

                                break;

                        case 10:

                                switch (dwMinorVersion)

                                {

                                case 0:         version = WINDOWS_10_SERVER2016;                break;

                                default: version = WINDOWS_FUTURE;                                break;

                                }

                                break;

                        default:

                                version = WINDOWS_FUTURE;

                                break;

                        }

                }

                else

                {

                        PRINT(("WASAPI: getting Windows version with VerifyVersionInfo()\n"));

                        if (IsWindowsVersionOrGreater(10, 0, 0))

                                version = WINDOWS_10_SERVER2016;

                        else

                        if (IsWindowsVersionOrGreater(6, 3, 0))

                                version = WINDOWS_8_1_SERVER2012R2;

                        else

                        if (IsWindowsVersionOrGreater(6, 2, 0))

                                version = WINDOWS_8_SERVER2012;

                        else

                        if (IsWindowsVersionOrGreater(6, 1, 0))

                                version = WINDOWS_7_SERVER2008R2;

                        else

                        if (IsWindowsVersionOrGreater(6, 0, 0))

                                version = WINDOWS_VISTA_SERVER2008;

                        else

                                version = WINDOWS_FUTURE;

                }

                PRINT(("WASAPI: Windows version = %d\n", version));

        }

        return version;

#else

        return WINDOWS_8_SERVER2012;

#endif

}

// ------------------------------------------------------------------------------------------

static BOOL UseWOW64Workaround()

{

        // note: WOW64 bug is common to Windows Vista x64, thus we fall back to safe Poll-driven

        //       method. Windows 7 x64 seems has WOW64 bug fixed.

        return (IsWow64() && (GetWindowsVersion() == WINDOWS_VISTA_SERVER2008));

}

// ------------------------------------------------------------------------------------------

static UINT32 GetAudioClientVersion()

{

        if (GetWindowsVersion() >= WINDOWS_10_SERVER2016)

                return 3;

        else

        if (GetWindowsVersion() >= WINDOWS_8_SERVER2012)

                return 2;

        return 1;

}

// ------------------------------------------------------------------------------------------

static const IID *GetAudioClientIID()

{

        static const IID *cli_iid = NULL;

        if (cli_iid == NULL)

        {

                UINT32 cli_version = GetAudioClientVersion();

                if (cli_version <= 1)

                {

                        cli_iid = &pa_IID_IAudioClient;

                }

                else

                {

                        switch (cli_version)

                        {

                        case 3:  cli_iid = &pa_IID_IAudioClient2; cli_version = 2; break; // use IAudioClient2 for Windows 10+ until IAudioClient3 functions are required

                        default: cli_iid = &pa_IID_IAudioClient2; cli_version = 2; break;

                        }

                }

                PRINT(("WASAPI: IAudioClient version = %d\n", cli_version));

        }

        return cli_iid;

}

// ------------------------------------------------------------------------------------------

typedef enum EMixerDir { MIX_DIR__1TO2, MIX_DIR__2TO1, MIX_DIR__2TO1_L } EMixerDir;

// ------------------------------------------------------------------------------------------

#define _WASAPI_MONO_TO_STEREO_MIXER_1_TO_2(TYPE)\

        TYPE * __restrict to   = __to;\

        TYPE * __restrict from = __from;\

        TYPE * __restrict end  = from + count;\

        while (from != end)\

        {\

                *to ++ = *from;\

                *to ++ = *from;\

                ++ from;\

        }

// ------------------------------------------------------------------------------------------

#define _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_FLT32(TYPE)\

        TYPE * __restrict to   = (TYPE *)__to;\

        TYPE * __restrict from = (TYPE *)__from;\

        TYPE * __restrict end  = to + count;\

        while (to != end)\

        {\

                *to ++ = (TYPE)((float)(from[0] + from[1]) * 0.5f);\

                from += 2;\

        }

// ------------------------------------------------------------------------------------------

#define _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_INT32(TYPE)\

        TYPE * __restrict to   = (TYPE *)__to;\

        TYPE * __restrict from = (TYPE *)__from;\

        TYPE * __restrict end  = to + count;\

        while (to != end)\

        {\

                *to ++ = (TYPE)(((INT32)from[0] + (INT32)from[1]) >> 1);\

                from += 2;\

        }

// ------------------------------------------------------------------------------------------

#define _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_INT64(TYPE)\

        TYPE * __restrict to   = (TYPE *)__to;\

        TYPE * __restrict from = (TYPE *)__from;\

        TYPE * __restrict end  = to + count;\

        while (to != end)\

        {\

                *to ++ = (TYPE)(((INT64)from[0] + (INT64)from[1]) >> 1);\

                from += 2;\

        }

// ------------------------------------------------------------------------------------------

#define _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_L(TYPE)\

        TYPE * __restrict to   = (TYPE *)__to;\

        TYPE * __restrict from = (TYPE *)__from;\

        TYPE * __restrict end  = to + count;\

        while (to != end)\

        {\

                *to ++ = from[0];\

                from += 2;\

        }

// ------------------------------------------------------------------------------------------

static void _MixMonoToStereo_1TO2_8(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_1_TO_2(BYTE); }

static void _MixMonoToStereo_1TO2_16(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_1_TO_2(short); }

static void _MixMonoToStereo_1TO2_24(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_1_TO_2(int); /* !!! int24 data is contained in 32-bit containers*/ }

static void _MixMonoToStereo_1TO2_32(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_1_TO_2(int); }

static void _MixMonoToStereo_1TO2_32f(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_1_TO_2(float); }

// ------------------------------------------------------------------------------------------

static void _MixMonoToStereo_2TO1_8(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_INT32(BYTE); }

static void _MixMonoToStereo_2TO1_16(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_INT32(short); }

static void _MixMonoToStereo_2TO1_24(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_INT32(int); /* !!! int24 data is contained in 32-bit containers*/ }

static void _MixMonoToStereo_2TO1_32(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_INT64(int); }

static void _MixMonoToStereo_2TO1_32f(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_FLT32(float); }

// ------------------------------------------------------------------------------------------

static void _MixMonoToStereo_2TO1_8_L(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_L(BYTE); }

static void _MixMonoToStereo_2TO1_16_L(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_L(short); }

static void _MixMonoToStereo_2TO1_24_L(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_L(int); /* !!! int24 data is contained in 32-bit containers*/ }

static void _MixMonoToStereo_2TO1_32_L(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_L(int); }

static void _MixMonoToStereo_2TO1_32f_L(void *__to, void *__from, UINT32 count) { _WASAPI_MONO_TO_STEREO_MIXER_2_TO_1_L(float); }

// ------------------------------------------------------------------------------------------

static MixMonoToStereoF _GetMonoToStereoMixer(PaSampleFormat format, EMixerDir dir)

{

        switch (dir)

        {

        case MIX_DIR__1TO2:

                switch (format & ~paNonInterleaved)

                {

                case paUInt8:        return _MixMonoToStereo_1TO2_8;

                case paInt16:        return _MixMonoToStereo_1TO2_16;

                case paInt24:        return _MixMonoToStereo_1TO2_24;

                case paInt32:        return _MixMonoToStereo_1TO2_32;

                case paFloat32: return _MixMonoToStereo_1TO2_32f;

                }

                break;

        case MIX_DIR__2TO1:

                switch (format & ~paNonInterleaved)

                {

                case paUInt8:        return _MixMonoToStereo_2TO1_8;

                case paInt16:        return _MixMonoToStereo_2TO1_16;

                case paInt24:        return _MixMonoToStereo_2TO1_24;

                case paInt32:        return _MixMonoToStereo_2TO1_32;

                case paFloat32: return _MixMonoToStereo_2TO1_32f;

                }

                break;

        case MIX_DIR__2TO1_L:

                switch (format & ~paNonInterleaved)

                {

                case paUInt8:        return _MixMonoToStereo_2TO1_8_L;

                case paInt16:        return _MixMonoToStereo_2TO1_16_L;

                case paInt24:        return _MixMonoToStereo_2TO1_24_L;

                case paInt32:        return _MixMonoToStereo_2TO1_32_L;

                case paFloat32: return _MixMonoToStereo_2TO1_32f_L;

                }

                break;

        }

        return NULL;

}

// ------------------------------------------------------------------------------------------

#ifdef PA_WINRT

typedef struct PaActivateAudioInterfaceCompletionHandler

{

        IActivateAudioInterfaceCompletionHandler parent;

        volatile LONG refs;

        volatile LONG done;

        struct

        {

                const IID *iid;

                void **obj;

        }

        in;

        struct

        {

                HRESULT hr;

        }

        out;

}

PaActivateAudioInterfaceCompletionHandler;

static HRESULT (STDMETHODCALLTYPE PaActivateAudioInterfaceCompletionHandler_QueryInterface)( 

    IActivateAudioInterfaceCompletionHandler *This, REFIID riid, void **ppvObject)

{

        PaActivateAudioInterfaceCompletionHandler *handler = (PaActivateAudioInterfaceCompletionHandler *)This;

        // From MSDN:

        // "The IAgileObject interface is a marker interface that indicates that an object 

        //  is free threaded and can be called from any apartment."

        if (IsEqualIID(riid, &IID_IUnknown) || 

                IsEqualIID(riid, &IID_IAgileObject))

        {

                IActivateAudioInterfaceCompletionHandler_AddRef((IActivateAudioInterfaceCompletionHandler *)handler);

                (*ppvObject) = handler;

                return S_OK;

        }