SV platform dependency builds

/*

 * $Id$

 * Portable Audio I/O Library DirectSound implementation

 *

 * Authors: Phil Burk, Robert Marsanyi & Ross Bencina

 * Based on the Open Source API proposed by Ross Bencina

 * Copyright (c) 1999-2007 Ross Bencina, Phil Burk, Robert Marsanyi

 *

 * 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

*/

/* Until May 2011 PA/DS has used a multimedia timer to perform the callback.

   We're replacing this with a new implementation using a thread and a different timer mechanim.

   Defining PA_WIN_DS_USE_WMME_TIMER uses the old (pre-May 2011) behavior.

*/

//#define PA_WIN_DS_USE_WMME_TIMER

#include <assert.h>

#include <stdio.h>

#include <string.h> /* strlen() */

#define _WIN32_WINNT 0x0400 /* required to get waitable timer APIs */

#include <initguid.h> /* make sure ds guids get defined */

#include <windows.h>

#include <objbase.h>

/*

  Use the earliest version of DX required, no need to polute the namespace

*/

#ifdef PAWIN_USE_DIRECTSOUNDFULLDUPLEXCREATE

#define DIRECTSOUND_VERSION 0x0800

#else

#define DIRECTSOUND_VERSION 0x0300

#endif

#include <dsound.h>

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

#include <dsconf.h>

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

#ifndef PA_WIN_DS_USE_WMME_TIMER

#ifndef UNDER_CE

#include <process.h>

#endif

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

#include "pa_win_ds.h"

#include "pa_win_ds_dynlink.h"

#include "pa_win_waveformat.h"

#include "pa_win_wdmks_utils.h"

#include "pa_win_coinitialize.h"

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

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

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

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

#endif

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

#ifndef PA_WIN_DS_USE_WMME_TIMER

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

#define CREATE_THREAD (HANDLE)_beginthreadex

#undef CLOSE_THREAD_HANDLE /* as per documentation we don't call CloseHandle on a thread created with _beginthreadex */

#define PA_THREAD_FUNC static unsigned WINAPI

#define PA_THREAD_ID unsigned

#else

#define CREATE_THREAD CreateThread

#define CLOSE_THREAD_HANDLE CloseHandle

#define PA_THREAD_FUNC static DWORD WINAPI

#define PA_THREAD_ID DWORD

#endif

#if (defined(UNDER_CE))

#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

PA_THREAD_FUNC ProcessingThreadProc( void *pArg );

#if !defined(UNDER_CE)

#define PA_WIN_DS_USE_WAITABLE_TIMER_OBJECT /* use waitable timer where possible, otherwise we use a WaitForSingleObject timeout */

#endif

#endif /* !PA_WIN_DS_USE_WMME_TIMER */

/*

 provided in newer platform sdks and x64

 */

#ifndef DWORD_PTR

    #if defined(_WIN64)

        #define DWORD_PTR unsigned __int64

    #else

        #define DWORD_PTR unsigned long

    #endif

#endif

#define PRINT(x) PA_DEBUG(x);

#define ERR_RPT(x) PRINT(x)

#define DBUG(x)   PRINT(x)

#define DBUGX(x)  PRINT(x)

#define PA_USE_HIGH_LATENCY   (0)

#if PA_USE_HIGH_LATENCY

#define PA_DS_WIN_9X_DEFAULT_LATENCY_     (.500)

#define PA_DS_WIN_NT_DEFAULT_LATENCY_     (.600)

#else

#define PA_DS_WIN_9X_DEFAULT_LATENCY_     (.140)

#define PA_DS_WIN_NT_DEFAULT_LATENCY_     (.280)

#endif

#define PA_DS_WIN_WDM_DEFAULT_LATENCY_    (.120)

/* we allow the polling period to range between 1 and 100ms.

   prior to August 2011 we limited the minimum polling period to 10ms.

*/

#define PA_DS_MINIMUM_POLLING_PERIOD_SECONDS    (0.001) /* 1ms */

#define PA_DS_MAXIMUM_POLLING_PERIOD_SECONDS    (0.100) /* 100ms */

#define PA_DS_POLLING_JITTER_SECONDS            (0.001) /* 1ms */

#define SECONDS_PER_MSEC      (0.001)

#define MSECS_PER_SECOND       (1000)

/* prototypes for functions declared in this file */

#ifdef __cplusplus

extern "C"

{

#endif /* __cplusplus */

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

#ifdef __cplusplus

}

#endif /* __cplusplus */

static void Terminate( struct PaUtilHostApiRepresentation *hostApi );

static PaError OpenStream( struct PaUtilHostApiRepresentation *hostApi,

                           PaStream** s,

                           const PaStreamParameters *inputParameters,

                           const PaStreamParameters *outputParameters,

                           double sampleRate,

                           unsigned long framesPerBuffer,

                           PaStreamFlags streamFlags,

                           PaStreamCallback *streamCallback,

                           void *userData );

static PaError IsFormatSupported( struct PaUtilHostApiRepresentation *hostApi,

                                  const PaStreamParameters *inputParameters,

                                  const PaStreamParameters *outputParameters,

                                  double sampleRate );

static PaError CloseStream( PaStream* stream );

static PaError StartStream( PaStream *stream );

static PaError StopStream( PaStream *stream );

static PaError AbortStream( PaStream *stream );

static PaError IsStreamStopped( PaStream *s );

static PaError IsStreamActive( PaStream *stream );

static PaTime GetStreamTime( PaStream *stream );

static double GetStreamCpuLoad( PaStream* stream );

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

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

static signed long GetStreamReadAvailable( PaStream* stream );

static signed long GetStreamWriteAvailable( PaStream* stream );

/* FIXME: should convert hr to a string */

#define PA_DS_SET_LAST_DIRECTSOUND_ERROR( hr ) \

    PaUtil_SetLastHostErrorInfo( paDirectSound, hr, "DirectSound error" )

/************************************************* DX Prototypes **********/

static BOOL CALLBACK CollectGUIDsProcW(LPGUID lpGUID,

                                     LPCWSTR lpszDesc,

                                     LPCWSTR lpszDrvName,

                                     LPVOID lpContext );

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

/********************** Structures **************************************************/

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

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

typedef struct PaWinDsDeviceInfo

{

    PaDeviceInfo        inheritedDeviceInfo;

    GUID                guid;

    GUID                *lpGUID;

    double              sampleRates[3];

    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)*/

} PaWinDsDeviceInfo;

typedef struct

{

    PaUtilHostApiRepresentation inheritedHostApiRep;

    PaUtilStreamInterface    callbackStreamInterface;

    PaUtilStreamInterface    blockingStreamInterface;

    PaUtilAllocationGroup   *allocations;

    /* implementation specific data goes here */

    PaWinUtilComInitializationResult comInitializationResult;

} PaWinDsHostApiRepresentation;

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

typedef struct PaWinDsStream

{

    PaUtilStreamRepresentation streamRepresentation;

    PaUtilCpuLoadMeasurer cpuLoadMeasurer;

    PaUtilBufferProcessor bufferProcessor;

/* DirectSound specific data. */

#ifdef PAWIN_USE_DIRECTSOUNDFULLDUPLEXCREATE

    LPDIRECTSOUNDFULLDUPLEX8 pDirectSoundFullDuplex8;

#endif

/* Output */

    LPDIRECTSOUND        pDirectSound;

    LPDIRECTSOUNDBUFFER  pDirectSoundPrimaryBuffer;

    LPDIRECTSOUNDBUFFER  pDirectSoundOutputBuffer;

    DWORD                outputBufferWriteOffsetBytes;     /* last write position */

    INT                  outputBufferSizeBytes;

    INT                  outputFrameSizeBytes;

    /* Try to detect play buffer underflows. */

    LARGE_INTEGER        perfCounterTicksPerBuffer; /* counter ticks it should take to play a full buffer */

    LARGE_INTEGER        previousPlayTime;

    DWORD                previousPlayCursor;

    UINT                 outputUnderflowCount;

    BOOL                 outputIsRunning;

    INT                  finalZeroBytesWritten; /* used to determine when we've flushed the whole buffer */

/* Input */

    LPDIRECTSOUNDCAPTURE pDirectSoundCapture;

    LPDIRECTSOUNDCAPTUREBUFFER   pDirectSoundInputBuffer;

    INT                  inputFrameSizeBytes;

    UINT                 readOffset;      /* last read position */

    UINT                 inputBufferSizeBytes;

    int              hostBufferSizeFrames; /* input and output host ringbuffers have the same number of frames */

    double           framesWritten;

    double           secondsPerHostByte; /* Used to optimize latency calculation for outTime */

    double           pollingPeriodSeconds;

    PaStreamCallbackFlags callbackFlags;

    PaStreamFlags    streamFlags;

    int              callbackResult;

    HANDLE           processingCompleted;

/* FIXME - move all below to PaUtilStreamRepresentation */

    volatile int     isStarted;

    volatile int     isActive;

    volatile int     stopProcessing; /* stop thread once existing buffers have been returned */

    volatile int     abortProcessing; /* stop thread immediately */

    UINT             systemTimerResolutionPeriodMs; /* set to 0 if we were unable to set the timer period */ 

#ifdef PA_WIN_DS_USE_WMME_TIMER

    MMRESULT         timerID;

#else

#ifdef PA_WIN_DS_USE_WAITABLE_TIMER_OBJECT

    HANDLE           waitableTimer;

#endif

    HANDLE           processingThread;

    PA_THREAD_ID     processingThreadId;

    HANDLE           processingThreadCompleted;

#endif

} PaWinDsStream;

/* Set minimal latency based on the current OS version.

 * NT has higher latency.

 */

static double PaWinDS_GetMinSystemLatencySeconds( void )

{

/*

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

    double minLatencySeconds;

    /* Set minimal latency based on whether NT or other OS.

     * NT has higher latency.

     */

    OSVERSIONINFO osvi;

    osvi.dwOSVersionInfoSize = sizeof( osvi );

    GetVersionEx( &osvi );

    DBUG(("PA - PlatformId = 0x%x\n", osvi.dwPlatformId ));

    DBUG(("PA - MajorVersion = 0x%x\n", osvi.dwMajorVersion ));

    DBUG(("PA - MinorVersion = 0x%x\n", osvi.dwMinorVersion ));

    /* Check for NT */

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

    {

        minLatencySeconds = PA_DS_WIN_NT_DEFAULT_LATENCY_;

    }

    else if(osvi.dwMajorVersion >= 5)

    {

        minLatencySeconds = PA_DS_WIN_WDM_DEFAULT_LATENCY_;

    }

    else

    {

        minLatencySeconds = PA_DS_WIN_9X_DEFAULT_LATENCY_;

    }

    return minLatencySeconds;

#pragma warning (default : 4996)

}

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

** Return minimum workable latency required for this host. This is returned

** As the default stream latency in PaDeviceInfo.

** Latency can be optionally set by user by setting an environment variable. 

** For example, to set latency to 200 msec, put:

**

**    set PA_MIN_LATENCY_MSEC=200

**

** in the AUTOEXEC.BAT file and reboot.

** If the environment variable is not set, then the latency will be determined

** based on the OS. Windows NT has higher latency than Win95.

*/

#define PA_LATENCY_ENV_NAME  ("PA_MIN_LATENCY_MSEC")

#define PA_ENV_BUF_SIZE  (32)

static double PaWinDs_GetMinLatencySeconds( double sampleRate )

{

    char      envbuf[PA_ENV_BUF_SIZE];

    DWORD     hresult;

    double    minLatencySeconds = 0;

    /* Let user determine minimal latency by setting environment variable. */

    hresult = GetEnvironmentVariableA( PA_LATENCY_ENV_NAME, envbuf, PA_ENV_BUF_SIZE );

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

    {

        minLatencySeconds = atoi( envbuf ) * SECONDS_PER_MSEC;

    }

    else

    {

        minLatencySeconds = PaWinDS_GetMinSystemLatencySeconds();

#if PA_USE_HIGH_LATENCY

        PRINT(("PA - Minimum Latency set to %f msec!\n", minLatencySeconds * MSECS_PER_SECOND ));

#endif

    }

    return minLatencySeconds;

}

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

** Duplicate and convert the input string using the group allocations allocator.

** A NULL string is converted to a zero length string.

** If memory cannot be allocated, NULL is returned.

**/

static char *DuplicateDeviceNameString( PaUtilAllocationGroup *allocations, const wchar_t* src )

{

    char *result = 0;

    if( src != NULL )

    {

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

        size_t len = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);

        result = (char*)PaUtil_GroupAllocateMemory( allocations, (long)(len + 1) );

        if( result ) {

            if (WideCharToMultiByte(CP_ACP, 0, src, -1, result, (int)len, NULL, NULL) == 0) {

                result = 0;

            }

        }

#else

        size_t len = WideCharToMultiByte(CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL);

        result = (char*)PaUtil_GroupAllocateMemory( allocations, (long)(len + 1) );

        if( result ) {

            if (WideCharToMultiByte(CP_UTF8, 0, src, -1, result, (int)len, NULL, NULL) == 0) {

                result = 0;

            }

        }

#endif

    }

    else

    {

        result = (char*)PaUtil_GroupAllocateMemory( allocations, 1 );

        if( result )

            result[0] = '\0';

    }

    return result;

}

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

** DSDeviceNameAndGUID, DSDeviceNameAndGUIDVector used for collecting preliminary

** information during device enumeration.

*/

typedef struct DSDeviceNameAndGUID{

    char *name; // allocated from parent's allocations, never deleted by this structure

    GUID guid;

    LPGUID lpGUID;

    void *pnpInterface;  // wchar_t* interface path, allocated using the DS host api's allocation group

} DSDeviceNameAndGUID;

typedef struct DSDeviceNameAndGUIDVector{

    PaUtilAllocationGroup *allocations;

    PaError enumerationError;

    int count;

    int free;

    DSDeviceNameAndGUID *items; // Allocated using LocalAlloc()

} DSDeviceNameAndGUIDVector;

typedef struct DSDeviceNamesAndGUIDs{

    PaWinDsHostApiRepresentation *winDsHostApi;

    DSDeviceNameAndGUIDVector inputNamesAndGUIDs;

    DSDeviceNameAndGUIDVector outputNamesAndGUIDs;

} DSDeviceNamesAndGUIDs;

static PaError InitializeDSDeviceNameAndGUIDVector(

        DSDeviceNameAndGUIDVector *guidVector, PaUtilAllocationGroup *allocations )

{

    PaError result = paNoError;

    guidVector->allocations = allocations;

    guidVector->enumerationError = paNoError;

    guidVector->count = 0;

    guidVector->free = 8;

    guidVector->items = (DSDeviceNameAndGUID*)LocalAlloc( LMEM_FIXED, sizeof(DSDeviceNameAndGUID) * guidVector->free );

    if( guidVector->items == NULL )

        result = paInsufficientMemory;

    return result;

}

static PaError ExpandDSDeviceNameAndGUIDVector( DSDeviceNameAndGUIDVector *guidVector )

{

    PaError result = paNoError;

    DSDeviceNameAndGUID *newItems;

    int i;

    /* double size of vector */

    int size = guidVector->count + guidVector->free;

    guidVector->free += size;

    newItems = (DSDeviceNameAndGUID*)LocalAlloc( LMEM_FIXED, sizeof(DSDeviceNameAndGUID) * size * 2 );

    if( newItems == NULL )

    {

        result = paInsufficientMemory;

    }

    else

    {

        for( i=0; i < guidVector->count; ++i )

        {

            newItems[i].name = guidVector->items[i].name;

            if( guidVector->items[i].lpGUID == NULL )

            {

                newItems[i].lpGUID = NULL;

            }

            else

            {

                newItems[i].lpGUID = &newItems[i].guid;

                memcpy( &newItems[i].guid, guidVector->items[i].lpGUID, sizeof(GUID) );

            }

            newItems[i].pnpInterface = guidVector->items[i].pnpInterface;

        }

        LocalFree( guidVector->items );

        guidVector->items = newItems;

    }                                

    return result;

}

/*

    it's safe to call DSDeviceNameAndGUIDVector multiple times

*/

static PaError TerminateDSDeviceNameAndGUIDVector( DSDeviceNameAndGUIDVector *guidVector )

{

    PaError result = paNoError;

    if( guidVector->items != NULL )

    {

        if( LocalFree( guidVector->items ) != NULL )

            result = paInsufficientMemory;              /** @todo this isn't the correct error to return from a deallocation failure */

        guidVector->items = NULL;

    }

    return result;

}

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

** Collect preliminary device information during DirectSound enumeration 

*/

static BOOL CALLBACK CollectGUIDsProcW(LPGUID lpGUID,

                                     LPCWSTR lpszDesc,

                                     LPCWSTR lpszDrvName,

                                     LPVOID lpContext )

{

    DSDeviceNameAndGUIDVector *namesAndGUIDs = (DSDeviceNameAndGUIDVector*)lpContext;

    PaError error;

    (void) lpszDrvName; /* unused variable */

    if( namesAndGUIDs->free == 0 )

    {

        error = ExpandDSDeviceNameAndGUIDVector( namesAndGUIDs );

        if( error != paNoError )

        {

            namesAndGUIDs->enumerationError = error;

            return FALSE;

        }

    }

    /* Set GUID pointer, copy GUID to storage in DSDeviceNameAndGUIDVector. */

    if( lpGUID == NULL )

    {

        namesAndGUIDs->items[namesAndGUIDs->count].lpGUID = NULL;

    }

    else

    {

        namesAndGUIDs->items[namesAndGUIDs->count].lpGUID =

                &namesAndGUIDs->items[namesAndGUIDs->count].guid;

        memcpy( &namesAndGUIDs->items[namesAndGUIDs->count].guid, lpGUID, sizeof(GUID) );

    }

    namesAndGUIDs->items[namesAndGUIDs->count].name =

            DuplicateDeviceNameString( namesAndGUIDs->allocations, lpszDesc );

    if( namesAndGUIDs->items[namesAndGUIDs->count].name == NULL )

    {

        namesAndGUIDs->enumerationError = paInsufficientMemory;

        return FALSE;

    }

    namesAndGUIDs->items[namesAndGUIDs->count].pnpInterface = 0;

    ++namesAndGUIDs->count;

    --namesAndGUIDs->free;

    return TRUE;

}

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

static void *DuplicateWCharString( PaUtilAllocationGroup *allocations, wchar_t *source )

{

    size_t len;

    wchar_t *result;

    len = wcslen( source );

    result = (wchar_t*)PaUtil_GroupAllocateMemory( allocations, (long) ((len+1) * sizeof(wchar_t)) );

    wcscpy( result, source );

    return result;

}

static BOOL CALLBACK KsPropertySetEnumerateCallback( PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data, LPVOID context )

{

    int i;

    DSDeviceNamesAndGUIDs *deviceNamesAndGUIDs = (DSDeviceNamesAndGUIDs*)context;

    /*

        Apparently data->Interface can be NULL in some cases. 

        Possibly virtual devices without hardware.

        So we check for NULLs now. See mailing list message November 10, 2012:

        "[Portaudio] portaudio initialization crash in KsPropertySetEnumerateCallback(pa_win_ds.c)"

    */

    if( data->Interface )

    {

        if( data->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER )

        {

            for( i=0; i < deviceNamesAndGUIDs->outputNamesAndGUIDs.count; ++i )

            {

                if( deviceNamesAndGUIDs->outputNamesAndGUIDs.items[i].lpGUID

                    && memcmp( &data->DeviceId, deviceNamesAndGUIDs->outputNamesAndGUIDs.items[i].lpGUID, sizeof(GUID) ) == 0 )

                {

                    deviceNamesAndGUIDs->outputNamesAndGUIDs.items[i].pnpInterface = 

                        (char*)DuplicateWCharString( deviceNamesAndGUIDs->winDsHostApi->allocations, data->Interface );

                    break;

                }

            }

        }

        else if( data->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE )

        {

            for( i=0; i < deviceNamesAndGUIDs->inputNamesAndGUIDs.count; ++i )

            {

                if( deviceNamesAndGUIDs->inputNamesAndGUIDs.items[i].lpGUID

                    && memcmp( &data->DeviceId, deviceNamesAndGUIDs->inputNamesAndGUIDs.items[i].lpGUID, sizeof(GUID) ) == 0 )

                {

                    deviceNamesAndGUIDs->inputNamesAndGUIDs.items[i].pnpInterface = 

                        (char*)DuplicateWCharString( deviceNamesAndGUIDs->winDsHostApi->allocations, data->Interface );

                    break;

                }

            }

        }

    }

    return TRUE;

}

static GUID pawin_CLSID_DirectSoundPrivate = 

{ 0x11ab3ec0, 0x25ec, 0x11d1, 0xa4, 0xd8, 0x00, 0xc0, 0x4f, 0xc2, 0x8a, 0xca };

static GUID pawin_DSPROPSETID_DirectSoundDevice = 

{ 0x84624f82, 0x25ec, 0x11d1, 0xa4, 0xd8, 0x00, 0xc0, 0x4f, 0xc2, 0x8a, 0xca };

static GUID pawin_IID_IKsPropertySet = 

{ 0x31efac30, 0x515c, 0x11d0, 0xa9, 0xaa, 0x00, 0xaa, 0x00, 0x61, 0xbe, 0x93 };

/*

    FindDevicePnpInterfaces fills in the pnpInterface fields in deviceNamesAndGUIDs

    with UNICODE file paths to the devices. The DS documentation mentions

    at least two techniques by which these Interface paths can be found using IKsPropertySet on

    the DirectSound class object. One is using the DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION 

    property, and the other is using DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE.

    I tried both methods and only the second worked. I found two postings on the

    net from people who had the same problem with the first method, so I think the method used here is 

    more common/likely to work. The probem is that IKsPropertySet_Get returns S_OK

    but the fields of the device description are not filled in.

    The mechanism we use works by registering an enumeration callback which is called for 

    every DSound device. Our callback searches for a device in our deviceNamesAndGUIDs list

    with the matching GUID and copies the pointer to the Interface path.

    Note that we could have used this enumeration callback to perform the original 

    device enumeration, however we choose not to so we can disable this step easily.

    Apparently the IKsPropertySet mechanism was added in DirectSound 9c 2004

    http://www.tech-archive.net/Archive/Development/microsoft.public.win32.programmer.mmedia/2004-12/0099.html

        -- rossb

*/

static void FindDevicePnpInterfaces( DSDeviceNamesAndGUIDs *deviceNamesAndGUIDs )

{

    IClassFactory *pClassFactory;

    if( paWinDsDSoundEntryPoints.DllGetClassObject(&pawin_CLSID_DirectSoundPrivate, &IID_IClassFactory, (PVOID *) &pClassFactory) == S_OK ){

        IKsPropertySet *pPropertySet;

        if( pClassFactory->lpVtbl->CreateInstance( pClassFactory, NULL, &pawin_IID_IKsPropertySet, (PVOID *) &pPropertySet) == S_OK ){

            DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;

            ULONG bytesReturned;

            data.Callback = KsPropertySetEnumerateCallback;

            data.Context = deviceNamesAndGUIDs;

            IKsPropertySet_Get( pPropertySet,

                &pawin_DSPROPSETID_DirectSoundDevice,

                DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W,

                NULL,

                0,

                &data,

                sizeof(data),

                &bytesReturned

            );

            IKsPropertySet_Release( pPropertySet );

        }

        pClassFactory->lpVtbl->Release( pClassFactory );

    }

    /*

        The following code fragment, which I chose not to use, queries for the 

        device interface for a device with a specific GUID:

        ULONG BytesReturned;

        DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA Property;

        memset (&Property, 0, sizeof(Property));

        Property.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;

        Property.DeviceId = *lpGUID;  

        hr = IKsPropertySet_Get( pPropertySet,

            &pawin_DSPROPSETID_DirectSoundDevice,

            DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W,

            NULL,

            0,

            &Property,

            sizeof(Property),

            &BytesReturned

        );

        if( hr == S_OK )

        {

            //pnpInterface = Property.Interface;

        }

    */

}

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

/* 

    GUIDs for emulated devices which we blacklist below.

    are there more than two of them??

*/

GUID IID_IRolandVSCEmulated1 = {0xc2ad1800, 0xb243, 0x11ce, 0xa8, 0xa4, 0x00, 0xaa, 0x00, 0x6c, 0x45, 0x01};

GUID IID_IRolandVSCEmulated2 = {0xc2ad1800, 0xb243, 0x11ce, 0xa8, 0xa4, 0x00, 0xaa, 0x00, 0x6c, 0x45, 0x02};

#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 };

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

** Extract capabilities from an output device, and add it to the device info list

** if successful. This function assumes that there is enough room in the

** device info list to accomodate all entries.

**

** The device will not be added to the device list if any errors are encountered.

*/

static PaError AddOutputDeviceInfoFromDirectSound(

        PaWinDsHostApiRepresentation *winDsHostApi, char *name, LPGUID lpGUID, char *pnpInterface )

{

    PaUtilHostApiRepresentation  *hostApi = &winDsHostApi->inheritedHostApiRep;

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

    PaDeviceInfo                 *deviceInfo = &winDsDeviceInfo->inheritedDeviceInfo;

    HRESULT                       hr;

    LPDIRECTSOUND                 lpDirectSound;

    DSCAPS                        caps;

    int                           deviceOK = TRUE;

    PaError                       result = paNoError;

    int                           i;

    /* Copy GUID to the device info structure. Set pointer. */

    if( lpGUID == NULL )

    {

        winDsDeviceInfo->lpGUID = NULL;

    }

    else

    {

        memcpy( &winDsDeviceInfo->guid, lpGUID, sizeof(GUID) );

        winDsDeviceInfo->lpGUID = &winDsDeviceInfo->guid;

    }

    if( lpGUID )

    {

        if (IsEqualGUID (&IID_IRolandVSCEmulated1,lpGUID) ||

            IsEqualGUID (&IID_IRolandVSCEmulated2,lpGUID) )

        {

            PA_DEBUG(("BLACKLISTED: %s \n",name));

            return paNoError;

        }

    }

    /* Create a DirectSound object for the specified GUID

        Note that using CoCreateInstance doesn't work on windows CE.

    */

    hr = paWinDsDSoundEntryPoints.DirectSoundCreate( lpGUID, &lpDirectSound, NULL );

    /** try using CoCreateInstance because DirectSoundCreate was hanging under

        some circumstances - note this was probably related to the

        #define BOOL short bug which has now been fixed

        @todo delete this comment and the following code once we've ensured

        there is no bug.

    */

    /*

    hr = CoCreateInstance( &CLSID_DirectSound, NULL, CLSCTX_INPROC_SERVER,

            &IID_IDirectSound, (void**)&lpDirectSound );

    if( hr == S_OK )

    {

        hr = IDirectSound_Initialize( lpDirectSound, lpGUID );

    }

    */

    if( hr != DS_OK )

    {

        if (hr == DSERR_ALLOCATED)

            PA_DEBUG(("AddOutputDeviceInfoFromDirectSound %s DSERR_ALLOCATED\n",name));

        DBUG(("Cannot create DirectSound for %s. Result = 0x%x\n", name, hr ));

        if (lpGUID)

            DBUG(("%s's GUID: {0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x, 0x%x} \n",

                 name,

                 lpGUID->Data1,

                 lpGUID->Data2,

                 lpGUID->Data3,

                 lpGUID->Data4[0],

                 lpGUID->Data4[1],

                 lpGUID->Data4[2],

                 lpGUID->Data4[3],

                 lpGUID->Data4[4],

                 lpGUID->Data4[5],

                 lpGUID->Data4[6],

                 lpGUID->Data4[7]));

        deviceOK = FALSE;

    }

    else

    {

        /* Query device characteristics. */

        memset( &caps, 0, sizeof(caps) ); 

        caps.dwSize = sizeof(caps);

        hr = IDirectSound_GetCaps( lpDirectSound, &caps );

        if( hr != DS_OK )

        {

            DBUG(("Cannot GetCaps() for DirectSound device %s. Result = 0x%x\n", name, hr ));

            deviceOK = FALSE;

        }

        else

        {

#if PA_USE_WMME

            if( caps.dwFlags & DSCAPS_EMULDRIVER )

            {

                /* If WMME supported, then reject Emulated drivers because they are lousy. */

                deviceOK = FALSE;

            }

#endif

            if( deviceOK )

            {

                deviceInfo->maxInputChannels = 0;

                winDsDeviceInfo->deviceInputChannelCountIsKnown = 1;

                /* DS output capabilities only indicate supported number of channels

                   using two flags which indicate mono and/or stereo.

                   We assume that stereo devices may support more than 2 channels

                   (as is the case with 5.1 devices for example) and so

                   set deviceOutputChannelCountIsKnown to 0 (unknown).

                   In this case OpenStream will try to open the device

                   when the user requests more than 2 channels, rather than

                   returning an error. 

                */

                if( caps.dwFlags & DSCAPS_PRIMARYSTEREO )

                {

                    deviceInfo->maxOutputChannels = 2;

                    winDsDeviceInfo->deviceOutputChannelCountIsKnown = 0;

                }

                else

                {

                    deviceInfo->maxOutputChannels = 1;

                    winDsDeviceInfo->deviceOutputChannelCountIsKnown = 1;

                }

                /* Guess channels count from speaker configuration. We do it only when 

                   pnpInterface is NULL or when PAWIN_USE_WDMKS_DEVICE_INFO is undefined.

                */

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

                if( !pnpInterface )

#endif

                {

                    DWORD spkrcfg;

                    if( SUCCEEDED(IDirectSound_GetSpeakerConfig( lpDirectSound, &spkrcfg )) )

                    {

                        int count = 0;

                        switch (DSSPEAKER_CONFIG(spkrcfg))

                        {

                            case DSSPEAKER_HEADPHONE:        count = 2; break;

                            case DSSPEAKER_MONO:             count = 1; break;

                            case DSSPEAKER_QUAD:             count = 4; break;

                            case DSSPEAKER_STEREO:           count = 2; break;

                            case DSSPEAKER_SURROUND:         count = 4; break;

                            case DSSPEAKER_5POINT1:          count = 6; break;

                            case DSSPEAKER_7POINT1:          count = 8; break;

#ifndef DSSPEAKER_7POINT1_SURROUND

#define DSSPEAKER_7POINT1_SURROUND 0x00000008

#endif                            

                            case DSSPEAKER_7POINT1_SURROUND: count = 8; break;

#ifndef DSSPEAKER_5POINT1_SURROUND

#define DSSPEAKER_5POINT1_SURROUND 0x00000009

#endif

                            case DSSPEAKER_5POINT1_SURROUND: count = 6; break;

                        }

                        if( count )

                        {

                            deviceInfo->maxOutputChannels = count;

                            winDsDeviceInfo->deviceOutputChannelCountIsKnown = 1;

                        }

                    }

                }

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

                if( pnpInterface )

                {

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

                    if( count > 0 )

                    {

                        deviceInfo->maxOutputChannels = count;

                        winDsDeviceInfo->deviceOutputChannelCountIsKnown = 1;

                    }

                }

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

                /* initialize defaultSampleRate */

                if( caps.dwFlags & DSCAPS_CONTINUOUSRATE )

                {

                    /* initialize to caps.dwMaxSecondarySampleRate incase none of the standard rates match */

                    deviceInfo->defaultSampleRate = caps.dwMaxSecondarySampleRate;

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

                    {

                        if( defaultSampleRateSearchOrder_[i] >= caps.dwMinSecondarySampleRate

                                && defaultSampleRateSearchOrder_[i] <= caps.dwMaxSecondarySampleRate )

                        {

                            deviceInfo->defaultSampleRate = defaultSampleRateSearchOrder_[i];

                            break;

                        }

                    }

                }

                else if( caps.dwMinSecondarySampleRate == caps.dwMaxSecondarySampleRate )

                {

                    if( caps.dwMinSecondarySampleRate == 0 )

                    {

                        /*

                        ** On my Thinkpad 380Z, DirectSoundV6 returns min-max=0 !!

                        ** But it supports continuous sampling.

                        ** So fake range of rates, and hope it really supports it.

                        */

                        deviceInfo->defaultSampleRate = 48000.0f;  /* assume 48000 as the default */

                        DBUG(("PA - Reported rates both zero. Setting to fake values for device #%s\n", name ));

                    }

                    else

                    {

                        deviceInfo->defaultSampleRate = caps.dwMaxSecondarySampleRate;

                    }

                }

                else if( (caps.dwMinSecondarySampleRate < 1000.0) && (caps.dwMaxSecondarySampleRate > 50000.0) )

                {

                    /* The EWS88MT drivers lie, lie, lie. The say they only support two rates, 100 & 100000.

                    ** But we know that they really support a range of rates!

                    ** So when we see a ridiculous set of rates, assume it is a range.

                    */

                  deviceInfo->defaultSampleRate = 48000.0f;  /* assume 48000 as the default */

                  DBUG(("PA - Sample rate range used instead of two odd values for device #%s\n", name ));

                }

                else deviceInfo->defaultSampleRate = caps.dwMaxSecondarySampleRate;

                //printf( "min %d max %d\n", caps.dwMinSecondarySampleRate, caps.dwMaxSecondarySampleRate );

                // dwFlags | DSCAPS_CONTINUOUSRATE 

                deviceInfo->defaultLowInputLatency = 0.;

                deviceInfo->defaultHighInputLatency = 0.;

                deviceInfo->defaultLowOutputLatency = PaWinDs_GetMinLatencySeconds( deviceInfo->defaultSampleRate );

                deviceInfo->defaultHighOutputLatency = deviceInfo->defaultLowOutputLatency * 2;

            }

        }

        IDirectSound_Release( lpDirectSound );

    }

    if( deviceOK )

    {

        deviceInfo->name = name;

        if( lpGUID == NULL )

            hostApi->info.defaultOutputDevice = hostApi->info.deviceCount;

        hostApi->info.deviceCount++;

    }

    return result;

}

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

** Extract capabilities from an input device, and add it to the device info list

** if successful. This function assumes that there is enough room in the

** device info list to accomodate all entries.

**

** The device will not be added to the device list if any errors are encountered.

*/

static PaError AddInputDeviceInfoFromDirectSoundCapture(

        PaWinDsHostApiRepresentation *winDsHostApi, char *name, LPGUID lpGUID, char *pnpInterface )

{

    PaUtilHostApiRepresentation  *hostApi = &winDsHostApi->inheritedHostApiRep;

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

    PaDeviceInfo                 *deviceInfo = &winDsDeviceInfo->inheritedDeviceInfo;

    HRESULT                       hr;

    LPDIRECTSOUNDCAPTURE          lpDirectSoundCapture;

    DSCCAPS                       caps;

    int                           deviceOK = TRUE;

    PaError                       result = paNoError;

    /* Copy GUID to the device info structure. Set pointer. */

    if( lpGUID == NULL )

    {

        winDsDeviceInfo->lpGUID = NULL;

    }

    else

    {

        winDsDeviceInfo->lpGUID = &winDsDeviceInfo->guid;

        memcpy( &winDsDeviceInfo->guid, lpGUID, sizeof(GUID) );

    }

    hr = paWinDsDSoundEntryPoints.DirectSoundCaptureCreate( lpGUID, &lpDirectSoundCapture, NULL );

    /** try using CoCreateInstance because DirectSoundCreate was hanging under

        some circumstances - note this was probably related to the

        #define BOOL short bug which has now been fixed

        @todo delete this comment and the following code once we've ensured

        there is no bug.

    */

    /*

    hr = CoCreateInstance( &CLSID_DirectSoundCapture, NULL, CLSCTX_INPROC_SERVER,

            &IID_IDirectSoundCapture, (void**)&lpDirectSoundCapture );

    */

    if( hr != DS_OK )

    {

        DBUG(("Cannot create Capture for %s. Result = 0x%x\n", name, hr ));

        deviceOK = FALSE;

    }

    else

    {

        /* Query device characteristics. */

        memset( &caps, 0, sizeof(caps) );

        caps.dwSize = sizeof(caps);

        hr = IDirectSoundCapture_GetCaps( lpDirectSoundCapture, &caps );

        if( hr != DS_OK )

        {

            DBUG(("Cannot GetCaps() for Capture device %s. Result = 0x%x\n", name, hr ));

            deviceOK = FALSE;

        }

        else

        {

#if PA_USE_WMME

            if( caps.dwFlags & DSCAPS_EMULDRIVER )

            {

                /* If WMME supported, then reject Emulated drivers because they are lousy. */

                deviceOK = FALSE;

            }

#endif

            if( deviceOK )

            {

                deviceInfo->maxInputChannels = caps.dwChannels;

                winDsDeviceInfo->deviceInputChannelCountIsKnown = 1;

                deviceInfo->maxOutputChannels = 0;

                winDsDeviceInfo->deviceOutputChannelCountIsKnown = 1;

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

                if( pnpInterface )

                {

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

                    if( count > 0 )

                    {

                        deviceInfo->maxInputChannels = count;

                        winDsDeviceInfo->deviceInputChannelCountIsKnown = 1;

                    }

                }

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

/*  constants from a WINE patch by Francois Gouget, see:

    http://www.winehq.com/hypermail/wine-patches/2003/01/0290.html

    ---

    Date: Fri, 14 May 2004 10:38:12 +0200 (CEST)

    From: Francois Gouget <fgouget@ ... .fr>

    To: Ross Bencina <rbencina@ ... .au>

    Subject: Re: Permission to use wine 48/96 wave patch in BSD licensed library

    [snip]

    I give you permission to use the patch below under the BSD license.

    http://www.winehq.com/hypermail/wine-patches/2003/01/0290.html

    [snip]

*/

#ifndef WAVE_FORMAT_48M08

#define WAVE_FORMAT_48M08      0x00001000    /* 48     kHz, Mono,   8-bit  */

#define WAVE_FORMAT_48S08      0x00002000    /* 48     kHz, Stereo, 8-bit  */

#define WAVE_FORMAT_48M16      0x00004000    /* 48     kHz, Mono,   16-bit */

#define WAVE_FORMAT_48S16      0x00008000    /* 48     kHz, Stereo, 16-bit */

#define WAVE_FORMAT_96M08      0x00010000    /* 96     kHz, Mono,   8-bit  */

#define WAVE_FORMAT_96S08      0x00020000    /* 96     kHz, Stereo, 8-bit  */

#define WAVE_FORMAT_96M16      0x00040000    /* 96     kHz, Mono,   16-bit */

#define WAVE_FORMAT_96S16      0x00080000    /* 96     kHz, Stereo, 16-bit */

#endif

                /* defaultSampleRate */

                if( caps.dwChannels == 2 )

                {

                    if( caps.dwFormats & WAVE_FORMAT_4S16 )

                        deviceInfo->defaultSampleRate = 44100.0;

                    else if( caps.dwFormats & WAVE_FORMAT_48S16 )

                        deviceInfo->defaultSampleRate = 48000.0;

                    else if( caps.dwFormats & WAVE_FORMAT_2S16 )

                        deviceInfo->defaultSampleRate = 22050.0;

                    else if( caps.dwFormats & WAVE_FORMAT_1S16 )

                        deviceInfo->defaultSampleRate = 11025.0;

                    else if( caps.dwFormats & WAVE_FORMAT_96S16 )

                        deviceInfo->defaultSampleRate = 96000.0;

                    else

                        deviceInfo->defaultSampleRate = 48000.0; /* assume 48000 as the default */

                }

                else if( caps.dwChannels == 1 )

                {

                    if( caps.dwFormats & WAVE_FORMAT_4M16 )

                        deviceInfo->defaultSampleRate = 44100.0;

                    else if( caps.dwFormats & WAVE_FORMAT_48M16 )

                        deviceInfo->defaultSampleRate = 48000.0;

                    else if( caps.dwFormats & WAVE_FORMAT_2M16 )

                        deviceInfo->defaultSampleRate = 22050.0;

                    else if( caps.dwFormats & WAVE_FORMAT_1M16 )

                        deviceInfo->defaultSampleRate = 11025.0;

                    else if( caps.dwFormats & WAVE_FORMAT_96M16 )

                        deviceInfo->defaultSampleRate = 96000.0;

                    else

                        deviceInfo->defaultSampleRate = 48000.0; /* assume 48000 as the default */

                }

                else deviceInfo->defaultSampleRate = 48000.0; /* assume 48000 as the default */

                deviceInfo->defaultLowInputLatency = PaWinDs_GetMinLatencySeconds( deviceInfo->defaultSampleRate );

                deviceInfo->defaultHighInputLatency = deviceInfo->defaultLowInputLatency * 2;

                deviceInfo->defaultLowOutputLatency = 0.;

                deviceInfo->defaultHighOutputLatency = 0.;

            }

        }

        IDirectSoundCapture_Release( lpDirectSoundCapture );

    }

    if( deviceOK )

    {

        deviceInfo->name = name;

        if( lpGUID == NULL )

            hostApi->info.defaultInputDevice = hostApi->info.deviceCount;

        hostApi->info.deviceCount++;

    }

    return result;

}

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

PaError PaWinDs_Initialize( PaUtilHostApiRepresentation **hostApi, PaHostApiIndex hostApiIndex )

{

    PaError result = paNoError;

    int i, deviceCount;

    PaWinDsHostApiRepresentation *winDsHostApi;

    DSDeviceNamesAndGUIDs deviceNamesAndGUIDs;

    PaWinDsDeviceInfo *deviceInfoArray;

    PaWinDs_InitializeDSoundEntryPoints();

    /* initialise guid vectors so they can be safely deleted on error */

    deviceNamesAndGUIDs.winDsHostApi = NULL;

    deviceNamesAndGUIDs.inputNamesAndGUIDs.items = NULL;

    deviceNamesAndGUIDs.outputNamesAndGUIDs.items = NULL;

    winDsHostApi = (PaWinDsHostApiRepresentation*)PaUtil_AllocateMemory( sizeof(PaWinDsHostApiRepresentation) );

    if( !winDsHostApi )

    {

        result = paInsufficientMemory;

        goto error;

    }

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

    result = PaWinUtil_CoInitialize( paDirectSound, &winDsHostApi->comInitializationResult );

    if( result != paNoError )

    {

        goto error;

    }

    winDsHostApi->allocations = PaUtil_CreateAllocationGroup();

    if( !winDsHostApi->allocations )

    {

        result = paInsufficientMemory;

        goto error;

    }

    *hostApi = &winDsHostApi->inheritedHostApiRep;

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

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

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

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

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

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

/* DSound - enumerate devices to count them and to gather their GUIDs */

    result = InitializeDSDeviceNameAndGUIDVector( &deviceNamesAndGUIDs.inputNamesAndGUIDs, winDsHostApi->allocations );

    if( result != paNoError )

        goto error;

    result = InitializeDSDeviceNameAndGUIDVector( &deviceNamesAndGUIDs.outputNamesAndGUIDs, winDsHostApi->allocations );

    if( result != paNoError )

        goto error;

    paWinDsDSoundEntryPoints.DirectSoundCaptureEnumerateW( (LPDSENUMCALLBACKW)CollectGUIDsProcW, (void *)&deviceNamesAndGUIDs.inputNamesAndGUIDs );

    paWinDsDSoundEntryPoints.DirectSoundEnumerateW( (LPDSENUMCALLBACKW)CollectGUIDsProcW, (void *)&deviceNamesAndGUIDs.outputNamesAndGUIDs );

    if( deviceNamesAndGUIDs.inputNamesAndGUIDs.enumerationError != paNoError )

    {

        result = deviceNamesAndGUIDs.inputNamesAndGUIDs.enumerationError;

        goto error;

    }

    if( deviceNamesAndGUIDs.outputNamesAndGUIDs.enumerationError != paNoError )

    {

        result = deviceNamesAndGUIDs.outputNamesAndGUIDs.enumerationError;

        goto error;

    }

    deviceCount = deviceNamesAndGUIDs.inputNamesAndGUIDs.count + deviceNamesAndGUIDs.outputNamesAndGUIDs.count;

#ifdef PAWIN_USE_WDMKS_DEVICE_INFO

    if( deviceCount > 0 )

    {

        deviceNamesAndGUIDs.winDsHostApi = winDsHostApi;

        FindDevicePnpInterfaces( &deviceNamesAndGUIDs );

    }

#endif /* PAWIN_USE_WDMKS_DEVICE_INFO */

    if( deviceCount > 0 )

    {

        /* allocate array for pointers to PaDeviceInfo structs */

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

                winDsHostApi->allocations, sizeof(PaDeviceInfo*) * deviceCount );

        if( !(*hostApi)->deviceInfos )

        {

            result = paInsufficientMemory;

            goto error;

        }

        /* allocate all PaDeviceInfo structs in a contiguous block */

        deviceInfoArray = (PaWinDsDeviceInfo*)PaUtil_GroupAllocateMemory(

                winDsHostApi->allocations, sizeof(PaWinDsDeviceInfo) * deviceCount );

        if( !deviceInfoArray )

        {

            result = paInsufficientMemory;

            goto error;

        }

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

        {

            PaDeviceInfo *deviceInfo = &deviceInfoArray[i].inheritedDeviceInfo;

            deviceInfo->structVersion = 2;

            deviceInfo->hostApi = hostApiIndex;

            deviceInfo->name = 0;

            (*hostApi)->deviceInfos[i] = deviceInfo;

        }

        for( i=0; i < deviceNamesAndGUIDs.inputNamesAndGUIDs.count; ++i )

        {

            result = AddInputDeviceInfoFromDirectSoundCapture( winDsHostApi,

                    deviceNamesAndGUIDs.inputNamesAndGUIDs.items[i].name,

                    deviceNamesAndGUIDs.inputNamesAndGUIDs.items[i].lpGUID,

                    deviceNamesAndGUIDs.inputNamesAndGUIDs.items[i].pnpInterface );

            if( result != paNoError )

                goto error;

        }

        for( i=0; i < deviceNamesAndGUIDs.outputNamesAndGUIDs.count; ++i )

        {

            result = AddOutputDeviceInfoFromDirectSound( winDsHostApi,

                    deviceNamesAndGUIDs.outputNamesAndGUIDs.items[i].name,

                    deviceNamesAndGUIDs.outputNamesAndGUIDs.items[i].lpGUID,

                    deviceNamesAndGUIDs.outputNamesAndGUIDs.items[i].pnpInterface );

            if( result != paNoError )

                goto error;

        }

    }    

    result = TerminateDSDeviceNameAndGUIDVector( &deviceNamesAndGUIDs.inputNamesAndGUIDs );

    if( result != paNoError )

        goto error;

    result = TerminateDSDeviceNameAndGUIDVector( &deviceNamesAndGUIDs.outputNamesAndGUIDs );

    if( result != paNoError )

        goto error;

    (*hostApi)->Terminate = Terminate;

    (*hostApi)->OpenStream = OpenStream;

    (*hostApi)->IsFormatSupported = IsFormatSupported;

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

                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,

                                      GetStreamTime, GetStreamCpuLoad,

                                      PaUtil_DummyRead, PaUtil_DummyWrite,

                                      PaUtil_DummyGetReadAvailable, PaUtil_DummyGetWriteAvailable );

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

                                      StopStream, AbortStream, IsStreamStopped, IsStreamActive,

                                      GetStreamTime, PaUtil_DummyGetCpuLoad,