precomp.h File Reference

#include <windows.h>
#include <setupapi.h>
#include <mmddk.h>
#include <objbase.h>
#include <olectl.h>
#include <unknwn.h>
#include <dsound.h>
#include <dsconf.h>
#include <vfwmsgs.h>
#include <ks.h>
#include <ksmedia.h>
#include <limits.h>
#include <stdio.h>
#include "resource.h"
#include <debug.h>

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	INTERFACE_TABLE
struct	tagFILTERINFO

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	INIT_GUID(guid, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)

Typedefs
typedef HRESULT(CALLBACK *	LPFNCREATEINSTANCE) (IUnknown *pUnkOuter, REFIID riid, LPVOID *ppvObject)
typedef struct tagFILTERINFO	FILTERINFO
typedef struct tagFILTERINFO *	LPFILTERINFO

Enumerations
enum	PIN_TYPE { PIN_TYPE_NONE = 0 , PIN_TYPE_PLAYBACK = 1 , PIN_TYPE_RECORDING = 2 }

Functions
IClassFactory *	IClassFactory_fnConstructor (LPFNCREATEINSTANCE lpfnCI, PLONG pcRefDll, REFIID riidInst)
HRESULT	EnumAudioDeviceInterfaces (LPFILTERINFO *OutRootInfo)
BOOL	FindDeviceByGuid (LPCGUID pGuidSrc, LPFILTERINFO *Filter)
BOOL	FindDeviceByMappedId (IN ULONG DeviceID, LPFILTERINFO *Filter, BOOL bPlayback)
ULONG	GetPinIdFromFilter (LPFILTERINFO Filter, BOOL bCapture, ULONG Offset)
HRESULT CALLBACK	NewDirectSound (IUnknown *pUnkOuter, REFIID riid, LPVOID *ppvObject)
VOID	PerformChannelConversion (PUCHAR Buffer, ULONG BufferLength, PULONG BytesRead, ULONG OldChannels, ULONG NewChannels, ULONG BitsPerSample, PUCHAR Result, ULONG ResultLength, PULONG BytesWritten)
BOOL	SetPinFormat (IN HANDLE hPin, IN LPWAVEFORMATEX WaveFormatEx)
BOOL	CreateCompatiblePin (IN HANDLE hFilter, IN DWORD PinId, IN BOOL bLoop, IN LPWAVEFORMATEX WaveFormatEx, OUT LPWAVEFORMATEX WaveFormatOut, OUT PHANDLE hPin)
DWORD	SyncOverlappedDeviceIoControl (IN HANDLE Handle, IN DWORD IoControlCode, IN LPVOID InBuffer, IN DWORD InBufferSize, OUT LPVOID OutBuffer, IN DWORD OutBufferSize, OUT LPDWORD BytesTransferred OPTIONAL)
DWORD	PrimaryDirectSoundBuffer_Write (LPDIRECTSOUNDBUFFER8 iface, LPVOID Buffer, DWORD BufferSize)
DWORD	OpenPin (HANDLE hFilter, ULONG PinId, LPWAVEFORMATEX WaveFormatEx, PHANDLE hPin, BOOL bLoop)
DWORD	OpenFilter (IN LPCWSTR lpFileName, IN PHANDLE OutHandle)
DWORD	GetFilterPinCount (IN HANDLE hFilter, OUT PULONG NumPins)
DWORD	GetFilterPinCommunication (IN HANDLE hFilter, IN ULONG PinId, OUT PKSPIN_COMMUNICATION Communication)
DWORD	GetFilterPinDataFlow (IN HANDLE hFilter, IN ULONG PinId, OUT PKSPIN_DATAFLOW DataFlow)
HRESULT	PrimaryDirectSoundBuffer_GetPosition (LPDIRECTSOUNDBUFFER8 iface, LPDWORD pdwCurrentPlayCursor, LPDWORD pdwCurrentWriteCursor)
VOID	PrimaryDirectSoundBuffer_SetState (LPDIRECTSOUNDBUFFER8 iface, KSSTATE State)
HRESULT	NewPrimarySoundBuffer (LPDIRECTSOUNDBUFFER8 *OutBuffer, LPFILTERINFO Filter, DWORD dwLevel, DWORD dwFlags)
HRESULT	PrimaryDirectSoundBuffer_SetFormat (LPDIRECTSOUNDBUFFER8 iface, LPWAVEFORMATEX pcfxFormat, BOOL bLooped)
VOID	PrimaryDirectSoundBuffer_AcquireLock (LPDIRECTSOUNDBUFFER8 iface)
VOID	PrimaryDirectSoundBuffer_ReleaseLock (LPDIRECTSOUNDBUFFER8 iface)
HRESULT	NewSecondarySoundBuffer (LPDIRECTSOUNDBUFFER8 *OutBuffer, LPFILTERINFO Filter, DWORD dwLevel, LPCDSBUFFERDESC lpcDSBufferDesc, LPDIRECTSOUNDBUFFER8 PrimaryBuffer)
HRESULT CALLBACK	NewKsPropertySet (IUnknown *pUnkOuter, REFIID riid, LPVOID *ppvObject)
HRESULT CALLBACK	NewDirectSoundCapture (IUnknown *pUnkOuter, REFIID riid, LPVOID *ppvObject)
HRESULT	NewDirectSoundCaptureBuffer (LPDIRECTSOUNDCAPTUREBUFFER8 *OutBuffer, LPFILTERINFO Filter, LPCDSCBUFFERDESC lpcDSBufferDesc)
VOID	DoNotifyPositionEvents (LPDIRECTSOUNDNOTIFY iface, DWORD OldPosition, DWORD NewPosition)
HRESULT	NewDirectSoundNotify (LPDIRECTSOUNDNOTIFY *Notify, BOOL bLoop, BOOL bMix, HANDLE hPin, DWORD BufferSize)

Variables
HINSTANCE	dsound_hInstance
LPFILTERINFO	RootInfo

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 4 of file precomp.h.

INIT_GUID

#define INIT_GUID	(		guid,
			l,
			w1,
			w2,
			b1,
			b2,
			b3,
			b4,
			b5,
			b6,
			b7,
			b8
	)

Value:

        guid.Data1 = l; guid.Data2 = w1; guid.Data3 = w2;               \
        guid.Data4[0] = b1; guid.Data4[1] = b2; guid.Data4[2] = b3;     \
        guid.Data4[3] = b4; guid.Data4[4] = b5; guid.Data4[5] = b6;     \
        guid.Data4[6] = b7; guid.Data4[7] = b8;

Definition at line 51 of file precomp.h.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 6 of file precomp.h.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 5 of file precomp.h.

Typedef Documentation

FILTERINFO

typedef struct tagFILTERINFO FILTERINFO

LPFILTERINFO

typedef struct tagFILTERINFO * LPFILTERINFO

LPFNCREATEINSTANCE

typedef HRESULT(CALLBACK * LPFNCREATEINSTANCE) (IUnknown *pUnkOuter, REFIID riid, LPVOID *ppvObject)

Definition at line 29 of file precomp.h.

Enumeration Type Documentation

PIN_TYPE

enum PIN_TYPE

Enumerator
PIN_TYPE_NONE
PIN_TYPE_PLAYBACK
PIN_TYPE_RECORDING

Definition at line 57 of file precomp.h.

{
    PIN_TYPE_NONE = 0,
    PIN_TYPE_PLAYBACK = 1,
    PIN_TYPE_RECORDING = 2
}PIN_TYPE;

Function Documentation

CreateCompatiblePin()

BOOL CreateCompatiblePin	(	IN HANDLE	hFilter,
		IN DWORD	PinId,
		IN BOOL	bLoop,
		IN LPWAVEFORMATEX	WaveFormatEx,
		OUT LPWAVEFORMATEX	WaveFormatOut,
		OUT PHANDLE	hPin
	)

Definition at line 517 of file misc.c.

{
    PKSMULTIPLE_ITEM Item = NULL;
    PKSDATARANGE_AUDIO AudioRange;
    DWORD dwResult;
    DWORD dwIndex, nChannels;
 
    dwResult = GetFilterPinDataRanges(hFilter, PinId, &Item);
 
    if (dwResult != ERROR_SUCCESS)
    {
        /* failed to get data ranges */
         return FALSE;
    }
 
    CopyMemory(WaveFormatOut, WaveFormatEx, sizeof(WAVEFORMATEX));
 
    /* iterate through all dataranges */
    AudioRange = (PKSDATARANGE_AUDIO)(Item + 1);
    for(dwIndex = 0; dwIndex < Item->Count; dwIndex++)
    {
        if (AudioRange->DataRange.FormatSize != sizeof(KSDATARANGE_AUDIO))
        {
            UNIMPLEMENTED;
            AudioRange = (PKSDATARANGE_AUDIO)((PUCHAR)AudioRange + AudioRange->DataRange.FormatSize);
            continue;
        }
 
        if (WaveFormatOut->nSamplesPerSec < AudioRange->MinimumSampleFrequency)
            WaveFormatOut->nSamplesPerSec = AudioRange->MinimumSampleFrequency;
        else if (WaveFormatOut->nSamplesPerSec > AudioRange->MaximumSampleFrequency)
            WaveFormatOut->nSamplesPerSec = AudioRange->MaximumSampleFrequency;
 
        if (WaveFormatOut->wBitsPerSample < AudioRange->MinimumBitsPerSample)
            WaveFormatOut->wBitsPerSample = AudioRange->MinimumBitsPerSample;
        else if (WaveFormatOut->wBitsPerSample > AudioRange->MaximumBitsPerSample)
            WaveFormatOut->wBitsPerSample = AudioRange->MaximumBitsPerSample;
 
        DPRINT("MinimumBitsPerSample %u MaximumBitsPerSample %u MinimumSampleFrequency %u MaximumSampleFrequency %u\n",
            AudioRange->MinimumBitsPerSample, AudioRange->MaximumBitsPerSample, AudioRange->MinimumSampleFrequency, AudioRange->MaximumSampleFrequency);
 
        for(nChannels = 1; nChannels <= AudioRange->MaximumChannels; nChannels++)
        {
            WaveFormatOut->nChannels = nChannels;
 
            dwResult = OpenPin(hFilter, PinId, WaveFormatOut, hPin, TRUE);
            if (dwResult == ERROR_SUCCESS)
            {
                DPRINT("InFormat  nChannels %u wBitsPerSample %u nSamplesPerSec %u\nOutFormat nChannels %u nBitsPerSample %u nSamplesPerSec %u\n",
                       WaveFormatEx->nChannels, WaveFormatEx->wBitsPerSample, WaveFormatEx->nSamplesPerSec,
                       WaveFormatOut->nChannels, WaveFormatOut->wBitsPerSample, WaveFormatOut->nSamplesPerSec);
 
 
                /* free buffer */
                HeapFree(GetProcessHeap(), 0, Item);
                return TRUE;
            }
        }
        AudioRange = (PKSDATARANGE_AUDIO)((PUCHAR)AudioRange + AudioRange->DataRange.FormatSize);
    }
 
    /* free buffer */
    HeapFree(GetProcessHeap(), 0, Item);
    return FALSE;
}

Referenced by NewDirectSoundCaptureBuffer().

DoNotifyPositionEvents()

VOID DoNotifyPositionEvents	(	LPDIRECTSOUNDNOTIFY	iface,
		DWORD	OldPosition,
		DWORD	NewPosition
	)

Definition at line 190 of file notify.c.

{
    DWORD Index;
    LPNOTIFYEVENT CurEventList;
 
    LPCDirectSoundNotifyImpl This = (LPCDirectSoundNotifyImpl)CONTAINING_RECORD(iface, CDirectSoundNotifyImpl, lpVtbl);
 
    CurEventList = This->EventListHead;
 
    while(CurEventList)
    {
        for(Index = 0; Index < CurEventList->NotifyCount; Index++)
        {
            if (NewPosition > OldPosition)
            {
                /* buffer progress no overlap */
                if (OldPosition < CurEventList->Notify[Index].Position && CurEventList->Notify[Index].Position <= NewPosition)
                {
                    /* process event */
                    SetEvent(CurEventList->Notify[Index].KsEventData.EventHandle.Event);
                }
            }
            else
            {
                /* buffer wrap-arround */
                if (OldPosition < CurEventList->Notify[Index].Position || NewPosition > CurEventList->Notify[Index].Position)
                {
                    /* process event */
                    SetEvent(CurEventList->Notify[Index].KsEventData.EventHandle.Event);
                }
            }
        }
 
        /* iterate to next event list */
        CurEventList = CurEventList->lpNext;
    }
}

Referenced by MixerThreadRoutine().

EnumAudioDeviceInterfaces()

HRESULT EnumAudioDeviceInterfaces

(

LPFILTERINFO *

OutRootInfo

)

Definition at line 384 of file devicelist.c.

{
    HDEVINFO hList;
    DWORD Status;
    HRESULT hResult;
    ULONG WaveOutCount, WaveInCount;
    GUID AudioDeviceGuid = {STATIC_KSCATEGORY_AUDIO};
    LPFILTERINFO CurInfo;
 
    /* try open the device list */
    Status = OpenDeviceList(&AudioDeviceGuid, &hList);
 
    if (Status != ERROR_SUCCESS)
    {
        DPRINT1("OpenDeviceList failed with %lx\n", Status);
        return E_FAIL;
    }
 
    if (!GetDeviceListInterfaces(hList, &AudioDeviceGuid, OutRootInfo))
    {
        DPRINT1("No devices found\n");
        CloseDeviceList(hList);
        return S_FALSE;
    }
 
    /* sanity check */
    ASSERT(*OutRootInfo);
 
    CurInfo = *OutRootInfo;
 
    WaveOutCount = 0;
    WaveInCount = 0;
 
    /* now check all audio filters */
    while(CurInfo)
    {
        /* now check details of the audio filter */
        hResult = EnumerateAudioFilter(CurInfo, &WaveInCount, &WaveOutCount);
 
        if (hResult != S_OK)
        {
           DPRINT1("EnumerateAudioFilter failed with %lx\n", Status);
           break;
        }
 
        /* move to next filter */
        CurInfo = CurInfo->lpNext;
    }
 
    /* close device list */
    CloseDeviceList(hList);
 
    /* done */
    return hResult;
}

Referenced by DllMain(), DSoundEnumerate(), and IDirectSound8_fnInitialize().

FindDeviceByGuid()

BOOL FindDeviceByGuid	(	LPCGUID	pGuidSrc,
		LPFILTERINFO *	Filter
	)

Definition at line 470 of file devicelist.c.

{
    LPFILTERINFO CurInfo;
    if (!RootInfo)
        return FALSE;
 
    /* get first entry */
    CurInfo = RootInfo;
 
    while(CurInfo)
    {
        if (IsEqualGUID(&CurInfo->DeviceGuid[0], pGuidSrc) ||
            IsEqualGUID(&CurInfo->DeviceGuid[1], pGuidSrc))
        {
            /* found filter */
            *Filter = CurInfo;
            return TRUE;
        }
 
        CurInfo = CurInfo->lpNext;
    }
 
    return FALSE;
}

Referenced by CDirectSoundCapture_fnInitialize(), GetDeviceID(), IDirectSound8_fnInitialize(), and KSPropertySetImpl_Get().

FindDeviceByMappedId()

BOOL FindDeviceByMappedId	(	IN ULONG	DeviceID,
		LPFILTERINFO *	Filter,
		BOOL	bPlayback
	)

Definition at line 442 of file devicelist.c.

{
    LPFILTERINFO CurInfo;
    if (!RootInfo)
        return FALSE;
 
    /* get first entry */
    CurInfo = RootInfo;
 
    while(CurInfo)
    {
        if ((bPlayback && CurInfo->MappedId[1] == DeviceID) ||
            (!bPlayback && CurInfo->MappedId[0] == DeviceID))
        {
            /* found filter */
            *Filter = CurInfo;
            return TRUE;
        }
 
        CurInfo = CurInfo->lpNext;
    }
    return FALSE;
}

Referenced by GetDeviceID().

GetFilterPinCommunication()

DWORD GetFilterPinCommunication	(	IN HANDLE	hFilter,
		IN ULONG	PinId,
		OUT PKSPIN_COMMUNICATION	Communication
	)

Definition at line 427 of file misc.c.

{
    KSP_PIN Property;
 
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = KSPROPERTY_PIN_COMMUNICATION;
    Property.PinId = PinId;
    Property.Reserved = 0;
 
    return SyncOverlappedDeviceIoControl(hFilter, IOCTL_KS_PROPERTY, (LPVOID)&Property, sizeof(KSP_PIN), (LPVOID)Communication, sizeof(KSPIN_COMMUNICATION), NULL);
}

Referenced by FindAudioFilterPins().

GetFilterPinCount()

DWORD GetFilterPinCount	(	IN HANDLE	hFilter,
		OUT PULONG	NumPins
	)

Definition at line 357 of file misc.c.

{
    KSPROPERTY Pin;
 
    *NumPins = 0;
 
    /* setup the pin request */
    Pin.Flags = KSPROPERTY_TYPE_GET;
    Pin.Set = KSPROPSETID_Pin;
    Pin.Id = KSPROPERTY_PIN_CTYPES;
 
    /* query the device */
    return SyncOverlappedDeviceIoControl(hFilter, IOCTL_KS_PROPERTY, (LPVOID)&Pin, sizeof(KSPROPERTY), (PVOID)NumPins, sizeof(ULONG), NULL);
}

Referenced by EnumerateAudioFilter().

GetFilterPinDataFlow()

DWORD GetFilterPinDataFlow	(	IN HANDLE	hFilter,
		IN ULONG	PinId,
		OUT PKSPIN_DATAFLOW	DataFlow
	)

Definition at line 444 of file misc.c.

{
    KSP_PIN Property;
 
    Property.Property.Flags = KSPROPERTY_TYPE_GET;
    Property.Property.Set = KSPROPSETID_Pin;
    Property.Property.Id = KSPROPERTY_PIN_DATAFLOW;
    Property.PinId = PinId;
    Property.Reserved = 0;
 
    return SyncOverlappedDeviceIoControl(hFilter, IOCTL_KS_PROPERTY, (LPVOID)&Property, sizeof(KSP_PIN), (LPVOID)DataFlow, sizeof(KSPIN_DATAFLOW), NULL);
}

Referenced by FindAudioFilterPins().

GetPinIdFromFilter()

ULONG GetPinIdFromFilter	(	LPFILTERINFO	Filter,
		BOOL	bCapture,
		ULONG	Offset
	)

Definition at line 13 of file devicelist.c.

{
    ULONG Index;
 
    for(Index = Offset; Index < Filter->PinCount; Index++)
    {
        if (Filter->Pin[Index] == PIN_TYPE_PLAYBACK && !bCapture)
            return Index;
 
        if (Filter->Pin[Index] == PIN_TYPE_RECORDING && bCapture)
            return Index;
    }
    return ULONG_MAX;
}

Referenced by NewDirectSoundCaptureBuffer(), and PrimaryDirectSoundBuffer_SetFormat().

IClassFactory_fnConstructor()

IClassFactory * IClassFactory_fnConstructor	(	LPFNCREATEINSTANCE	lpfnCI,
		PLONG	pcRefDll,
		REFIID	riidInst
	)

Definition at line 125 of file classfactory.c.

{
    IClassFactoryImpl* lpclf;
 
    lpclf = CoTaskMemAlloc(sizeof(IClassFactoryImpl));
    lpclf->ref = 1;
    lpclf->lpVtbl = &dclfvt;
    lpclf->lpfnCI = lpfnCI;
 
    if (pcRefDll)
        InterlockedIncrement(pcRefDll);
    lpclf->riidInst = riidInst;
 
    return (LPCLASSFACTORY)lpclf;
}

NewDirectSound()

HRESULT CALLBACK NewDirectSound	(	IUnknown *	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObject
	)

Definition at line 449 of file directsound.c.

{
    LPOLESTR pStr;
    LPCDirectSoundImpl This;
 
    /* check param */
    if (!ppvObject)
    {
        /* invalid param */
        return E_INVALIDARG;
    }
 
    /* check requested interface */
    if (!IsEqualIID(riid, &IID_IUnknown) && !IsEqualIID(riid, &IID_IDirectSound) && !IsEqualIID(riid, &IID_IDirectSound8))
    {
        *ppvObject = 0;
        StringFromIID(riid, &pStr);
        DPRINT("KsPropertySet does not support Interface %ws\n", pStr);
        CoTaskMemFree(pStr);
        return E_NOINTERFACE;
    }
 
    /* allocate CDirectSoundCaptureImpl struct */
    This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CDirectSoundImpl));
    if (!This)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
 
    /* initialize object */
    This->ref = 1;
    This->lpVtbl = &vt_DirectSound8;
    This->bInitialized = FALSE;
    *ppvObject = (LPVOID)&This->lpVtbl;
 
    return S_OK;
}

NewDirectSoundCapture()

HRESULT CALLBACK NewDirectSoundCapture	(	IUnknown *	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObject
	)

Definition at line 284 of file capture.c.

{
    LPOLESTR pStr;
    LPCDirectSoundCaptureImpl This;
 
    /* check requested interface */
    if (!IsEqualIID(riid, &IID_IUnknown) && !IsEqualIID(riid, &IID_IDirectSoundCapture) && !IsEqualIID(riid, &IID_IDirectSoundCapture8))
    {
        *ppvObject = 0;
        StringFromIID(riid, &pStr);
        DPRINT("NewDirectSoundCapture does not support Interface %ws\n", pStr);
        CoTaskMemFree(pStr);
        return E_NOINTERFACE;
    }
 
    /* allocate CDirectSoundCaptureImpl struct */
    This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CDirectSoundCaptureImpl));
    if (!This)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
 
    /* initialize object */
    This->ref = 1;
    This->lpVtbl = &vt_DirectSoundCapture;
    This->bInitialized = FALSE;
    *ppvObject = (LPVOID)&This->lpVtbl;
 
    return S_OK;
}

NewDirectSoundCaptureBuffer()

HRESULT NewDirectSoundCaptureBuffer	(	LPDIRECTSOUNDCAPTUREBUFFER8 *	OutBuffer,
		LPFILTERINFO	Filter,
		LPCDSCBUFFERDESC	lpcDSBufferDesc
	)

Definition at line 687 of file capturebuffer.c.

{
    DWORD FormatSize, MixBufferSize;
    ULONG DeviceId = 0, PinId;
    DWORD Result = ERROR_SUCCESS;
    WAVEFORMATEX MixFormat;
 
    LPCDirectSoundCaptureBufferImpl This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CDirectSoundCaptureBufferImpl));
 
    if (!This)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
 
     /* calculate format size */
    FormatSize = sizeof(WAVEFORMATEX) + lpcDSBufferDesc->lpwfxFormat->cbSize;
    /* allocate format struct */
    This->Format = HeapAlloc(GetProcessHeap(), 0, FormatSize);
    if (!This->Format)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, This);
        return DSERR_OUTOFMEMORY;
    }
 
    /* sanity check */
    ASSERT(lpcDSBufferDesc->dwBufferBytes);
 
    /* allocate capture buffer */
    This->Buffer = HeapAlloc(GetProcessHeap(), 0, lpcDSBufferDesc->dwBufferBytes);
    if (!This->Buffer)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, This->Format);
        HeapFree(GetProcessHeap(), 0, This);
        return DSERR_OUTOFMEMORY;
    }
 
    /* store buffer size */
    This->BufferSize = lpcDSBufferDesc->dwBufferBytes;
    ASSERT(lpcDSBufferDesc->lpwfxFormat->cbSize == 0);
 
    do
    {
        /* try all available recording pins on that filter */
        PinId = GetPinIdFromFilter(Filter, TRUE, DeviceId);
 
        if (PinId == ULONG_MAX)
            break;
 
        Result = OpenPin(Filter->hFilter, PinId, lpcDSBufferDesc->lpwfxFormat, &This->hPin, TRUE);
        if (Result == ERROR_SUCCESS)
            break;
 
        DeviceId++;
    }while(TRUE);
 
    if (Result != ERROR_SUCCESS)
    {
        /* failed to instantiate the capture pin with the native format
         * try to compute a compatible format and use that
         * we could use the mixer api for this purpose but... the kmixer isnt working very good atm
         */
 
       DeviceId = 0;
       do
       {
           /* try all available recording pins on that filter */
            PinId = GetPinIdFromFilter(Filter, TRUE, DeviceId);
            DPRINT("PinId %u DeviceId %u\n", PinId, DeviceId);
 
            if (PinId == ULONG_MAX)
                break;
 
            if (CreateCompatiblePin(Filter->hFilter, PinId, TRUE, lpcDSBufferDesc->lpwfxFormat, &MixFormat, &This->hPin))
            {
                This->bMix = TRUE;
                CopyMemory(&This->MixFormat, &MixFormat, sizeof(WAVEFORMATEX));
                break;
            }
 
            DeviceId++;
        }while(TRUE);
 
 
        if (!This->bMix)
        {
            /* FIXME should not happen */
            DPRINT("failed to compute a compatible format\n");
            HeapFree(GetProcessHeap(), 0, This->MixBuffer);
            HeapFree(GetProcessHeap(), 0, This->Buffer);
            HeapFree(GetProcessHeap(), 0, This->Format);
            HeapFree(GetProcessHeap(), 0, This);
            return DSERR_GENERIC;
        }
 
        MixBufferSize = lpcDSBufferDesc->dwBufferBytes;
        MixBufferSize /= lpcDSBufferDesc->lpwfxFormat->nChannels;
        MixBufferSize /= (lpcDSBufferDesc->lpwfxFormat->wBitsPerSample/8);
 
        MixBufferSize *= This->MixFormat.nChannels;
        MixBufferSize *= (This->MixFormat.wBitsPerSample/8);
 
        /* allocate buffer for mixing */
        This->MixBuffer = HeapAlloc(GetProcessHeap(), 0, MixBufferSize);
        if (!This->Buffer)
        {
            /* not enough memory */
            CloseHandle(This->hPin);
            HeapFree(GetProcessHeap(), 0, This->Buffer);
            HeapFree(GetProcessHeap(), 0, This->Format);
            HeapFree(GetProcessHeap(), 0, This);
            return DSERR_OUTOFMEMORY;
        }
        This->MixBufferSize = MixBufferSize;
        DPRINT1("MixBufferSize %u BufferSize %u\n", MixBufferSize, This->BufferSize);
    }
 
    /* initialize capture buffer */
    This->ref = 1;
    This->lpVtbl = &vt_DirectSoundCaptureBuffer8;
    This->Filter = Filter;
    This->State = KSSTATE_STOP;
    This->bLoop = TRUE;
 
    RtlMoveMemory(This->Format, lpcDSBufferDesc->lpwfxFormat, FormatSize);
 
    *OutBuffer = (LPDIRECTSOUNDCAPTUREBUFFER8)&This->lpVtbl;
    return DS_OK;
}

Referenced by CDirectSoundCapture_fnCreateCaptureBuffer().

NewDirectSoundNotify()

HRESULT NewDirectSoundNotify	(	LPDIRECTSOUNDNOTIFY *	Notify,
		BOOL	bLoop,
		BOOL	bMix,
		HANDLE	hPin,
		DWORD	BufferSize
	)

Definition at line 232 of file notify.c.

{
    LPCDirectSoundNotifyImpl This = HeapAlloc(GetProcessHeap(), 0, sizeof(CDirectSoundNotifyImpl));
 
    if (!This)
        return DSERR_OUTOFMEMORY;
 
    This->lpVtbl = &vt_DirectSoundNotify;
    This->bLoop = bLoop;
    This->bMix = bMix;
    This->hPin = hPin;
    This->ref = 1;
    This->EventListHead = NULL;
    This->BufferSize = BufferSize;
 
    *Notify = (LPDIRECTSOUNDNOTIFY)&This->lpVtbl;
    return DS_OK;
 
}

Referenced by IDirectSoundCaptureBufferImpl_QueryInterface().

NewKsPropertySet()

HRESULT CALLBACK NewKsPropertySet	(	IUnknown *	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObject
	)

Definition at line 244 of file property.c.

{
    LPOLESTR pStr;
    LPCKsPropertySetImpl This;
 
    /* check requested interface */
    if (!IsEqualIID(riid, &IID_IUnknown) && !IsEqualIID(riid, &IID_IKsPropertySet))
    {
        *ppvObject = 0;
        StringFromIID(riid, &pStr);
        DPRINT("KsPropertySet does not support Interface %ws\n", pStr);
        CoTaskMemFree(pStr);
        return E_NOINTERFACE;
    }
 
    /* allocate object */
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(CKsPropertySetImpl));
    if (!This)
        return E_OUTOFMEMORY;
 
    /* initialize object */
    This->ref = 1;
    This->lpVtbl = &vt_KsPropertySet;
    *ppvObject = (LPVOID)&This->lpVtbl;
 
    return S_OK;
}

NewPrimarySoundBuffer()

HRESULT NewPrimarySoundBuffer	(	LPDIRECTSOUNDBUFFER8 *	OutBuffer,
		LPFILTERINFO	Filter,
		DWORD	dwLevel,
		DWORD	dwFlags
	)

Definition at line 768 of file primary.c.

{
    LPCDirectSoundBuffer This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CDirectSoundBuffer));
 
    if (!This)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
 
    This->ref = 1;
    This->lpVtbl = &vt_DirectSoundBuffer8;
    This->Filter = Filter;
    This->dwLevel = dwLevel;
    This->dwFlags = dwFlags;
    This->dwFrequency = 0;
    This->Volume = DSBVOLUME_MAX;
    This->VolumePan = DSBPAN_CENTER;
    This->hPin = NULL;
 
    /* FIXME: determine default format for audio device */
    This->Format.cbSize = sizeof(WAVEFORMATEX);
    This->Format.nChannels = 2;
    This->Format.nSamplesPerSec = 44100;
    This->Format.wBitsPerSample = 16;
    This->Format.wFormatTag = WAVE_FORMAT_PCM;
    This->Format.nBlockAlign = (This->Format.nChannels * This->Format.wBitsPerSample) / 8;
    This->Format.nAvgBytesPerSec = (This->Format.nChannels * This->Format.nSamplesPerSec * This->Format.wBitsPerSample) / 8;
 
    InitializeCriticalSection(&This->Lock);
 
    *OutBuffer = (LPDIRECTSOUNDBUFFER8)&This->lpVtbl;
    return DS_OK;
}

Referenced by IDirectSound8_fnCreateSoundBuffer().

NewSecondarySoundBuffer()

HRESULT NewSecondarySoundBuffer	(	LPDIRECTSOUNDBUFFER8 *	OutBuffer,
		LPFILTERINFO	Filter,
		DWORD	dwLevel,
		LPCDSBUFFERDESC	lpcDSBufferDesc,
		LPDIRECTSOUNDBUFFER8	PrimaryBuffer
	)

Definition at line 611 of file secondary.c.

{
    ULONG FormatSize;
    LPCDirectSoundBuffer This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CDirectSoundBuffer));
 
    if (!This)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
 
    FormatSize = sizeof(WAVEFORMATEX) + lpcDSBufferDesc->lpwfxFormat->cbSize;
 
    This->Format = HeapAlloc(GetProcessHeap(), 0, FormatSize);
    if (!This->Format)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, This);
        return DSERR_OUTOFMEMORY;
    }
 
    /* sanity check */
    ASSERT(lpcDSBufferDesc->dwBufferBytes);
 
    /* allocate sound buffer */
    This->Buffer = HeapAlloc(GetProcessHeap(), 0, lpcDSBufferDesc->dwBufferBytes);
    if (!This->Buffer)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, This->Format);
        HeapFree(GetProcessHeap(), 0, This);
        return DSERR_OUTOFMEMORY;
    }
 
    /* fill buffer with silence */
    FillMemory(This->Buffer, lpcDSBufferDesc->dwBufferBytes, lpcDSBufferDesc->lpwfxFormat->wBitsPerSample == 8 ? 0x80 : 0);
 
    This->ref = 1;
    This->lpVtbl = &vt_DirectSoundBuffer8;
    This->Filter = Filter;
    This->dwLevel = dwLevel;
    This->dwFlags = lpcDSBufferDesc->dwFlags;
    This->dwFrequency = lpcDSBufferDesc->lpwfxFormat->nSamplesPerSec;
    This->State = KSSTATE_STOP;
    This->Volume = DSBVOLUME_MAX;
    This->VolumePan = DSBPAN_CENTER;
    This->Flags = 0;
    This->Position = 0;
    This->BufferSize = lpcDSBufferDesc->dwBufferBytes;
    This->PrimaryBuffer = PrimaryBuffer;
 
    CopyMemory(This->Format, lpcDSBufferDesc->lpwfxFormat, FormatSize);
 
    *OutBuffer = (LPDIRECTSOUNDBUFFER8)&This->lpVtbl;
    return DS_OK;
}

Referenced by IDirectSound8_fnCreateSoundBuffer().

OpenFilter()

DWORD OpenFilter	(	IN LPCWSTR	lpFileName,
		IN PHANDLE	OutHandle
	)

Definition at line 277 of file misc.c.

{
    HANDLE Handle;
 
    /* open the filter */
    Handle = CreateFileW(lpFileName, GENERIC_WRITE | GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
 
    /* check for success */
    if (Handle == INVALID_HANDLE_VALUE)
    {
        DPRINT("Failed to open Filter %ws\n", lpFileName);
        return GetLastError();
    }
 
    *OutHandle = Handle;
    return ERROR_SUCCESS;
}

Referenced by EnumerateAudioFilter().

OpenPin()

DWORD OpenPin	(	HANDLE	hFilter,
		ULONG	PinId,
		LPWAVEFORMATEX	WaveFormatEx,
		PHANDLE	hPin,
		BOOL	bLoop
	)

Definition at line 212 of file misc.c.

{
    DWORD Size, Result;
    PKSPIN_CONNECT PinConnect;
    PKSDATAFORMAT_WAVEFORMATEX DataFormat;
 
    /* calculate request size */
    Size = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT_WAVEFORMATEX);
 
    PinConnect = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Size);
    if (!PinConnect)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
    /* build pin request */
    PinConnect->Interface.Set = KSINTERFACESETID_Standard;
 
    if (bLoop)
        PinConnect->Interface.Id = KSINTERFACE_STANDARD_LOOPED_STREAMING;
    else
        PinConnect->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
 
    PinConnect->Interface.Flags = 0;
    PinConnect->Medium.Set = KSMEDIUMSETID_Standard;
    PinConnect->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
    PinConnect->Medium.Flags = 0;
    PinConnect->PinToHandle = NULL;
    PinConnect->PinId = PinId;
    PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
    PinConnect->Priority.PrioritySubClass = 1;
 
    DataFormat = (PKSDATAFORMAT_WAVEFORMATEX) (PinConnect + 1);
 
    /* initialize data format */
    DataFormat->WaveFormatEx.wFormatTag = WaveFormatEx->wFormatTag;
    DataFormat->WaveFormatEx.nChannels = WaveFormatEx->nChannels;
    DataFormat->WaveFormatEx.nSamplesPerSec = WaveFormatEx->nSamplesPerSec;
    DataFormat->WaveFormatEx.nBlockAlign = WaveFormatEx->nBlockAlign;
    DataFormat->WaveFormatEx.nAvgBytesPerSec = WaveFormatEx->nAvgBytesPerSec;
    DataFormat->WaveFormatEx.wBitsPerSample = WaveFormatEx->wBitsPerSample;
    DataFormat->WaveFormatEx.cbSize = 0;
    DataFormat->DataFormat.FormatSize = sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATEX);
    DataFormat->DataFormat.Flags = 0;
    DataFormat->DataFormat.Reserved = 0;
    DataFormat->DataFormat.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
 
    DataFormat->DataFormat.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
    DataFormat->DataFormat.Specifier = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
    DataFormat->DataFormat.SampleSize = 4;
 
    Result = KsCreatePin(hFilter, PinConnect, GENERIC_READ | GENERIC_WRITE, hPin);
 
    HeapFree(GetProcessHeap(), 0, PinConnect);
 
    return Result;
}

Referenced by CreateCompatiblePin(), NewDirectSoundCaptureBuffer(), and PrimaryDirectSoundBuffer_SetFormat().

PerformChannelConversion()

VOID PerformChannelConversion	(	PUCHAR	Buffer,
		ULONG	BufferLength,
		PULONG	BytesRead,
		ULONG	OldChannels,
		ULONG	NewChannels,
		ULONG	BitsPerSample,
		PUCHAR	Result,
		ULONG	ResultLength,
		PULONG	BytesWritten
	)

Definition at line 18 of file misc.c.

{
    DWORD NewIndex, OldIndex;
    DWORD NewLength, Skip;
 
    if (NewChannels > OldChannels)
    {
        UNIMPLEMENTED;
        ASSERT(0);
    }
 
    /* setup index */
    NewIndex = 0;
    OldIndex = 0;
 
    /* calculate offsets */
    NewLength = NewChannels * (BitsPerSample/8);
    Skip = OldChannels * (BitsPerSample/8);
 
    do
    {
        if (NewIndex + NewLength>= ResultLength)
        {
            NewIndex = ResultLength;
            break;
        }
 
        if (OldIndex + Skip >= BufferLength)
        {
            OldIndex = BufferLength;
            break;
        }
 
        /* copy first channel */
        RtlMoveMemory(&Result[NewIndex], &Buffer[OldIndex], NewLength);
 
        /* skip other channels */
        OldIndex += Skip;
 
        /* increment offset */
        NewIndex += NewLength;
 
    }while(TRUE);
 
    *BytesRead = OldIndex;
    *BytesWritten = NewIndex;
}

Referenced by MixerThreadRoutine().

PrimaryDirectSoundBuffer_AcquireLock()

VOID PrimaryDirectSoundBuffer_AcquireLock

(

LPDIRECTSOUNDBUFFER8

iface

)

Definition at line 746 of file primary.c.

{
    LPCDirectSoundBuffer This = (LPCDirectSoundBuffer)CONTAINING_RECORD(iface, CDirectSoundBuffer, lpVtbl);
 
    EnterCriticalSection(&This->Lock);
 
 
}

Referenced by PrimaryDirectSoundBuffer8Impl_fnPlay(), PrimaryDirectSoundBuffer8Impl_fnStop(), and SecondaryDirectSoundBuffer8Impl_fnPlay().

PrimaryDirectSoundBuffer_GetPosition()

HRESULT PrimaryDirectSoundBuffer_GetPosition	(	LPDIRECTSOUNDBUFFER8	iface,
		LPDWORD	pdwCurrentPlayCursor,
		LPDWORD	pdwCurrentWriteCursor
	)

Definition at line 644 of file primary.c.

{
    KSAUDIO_POSITION Position;
    KSPROPERTY Request;
    DWORD Result;
    LPCDirectSoundBuffer This = (LPCDirectSoundBuffer)CONTAINING_RECORD(iface, CDirectSoundBuffer, lpVtbl);
 
    //DPRINT("PrimaryDirectSoundBuffer_GetPosition\n");
 
    if (!This->hPin)
    {
        if (pdwCurrentPlayCursor)
            *pdwCurrentPlayCursor = 0;
 
        if (pdwCurrentWriteCursor)
            *pdwCurrentWriteCursor = 0;
 
        DPRINT("No Audio Pin\n");
        return DS_OK;
    }
 
    /* setup audio position property request */
    Request.Id = KSPROPERTY_AUDIO_POSITION;
    Request.Set = KSPROPSETID_Audio;
    Request.Flags = KSPROPERTY_TYPE_GET;
 
 
    Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSPROPERTY), (PVOID)&Position, sizeof(KSAUDIO_POSITION), NULL);
 
    if (Result != ERROR_SUCCESS)
    {
        DPRINT("GetPosition failed with %x\n", Result);
        return DSERR_UNSUPPORTED;
    }
 
    //DPRINT("Play %I64u Write %I64u \n", Position.PlayOffset, Position.WriteOffset);
 
    if (pdwCurrentPlayCursor)
        *pdwCurrentPlayCursor = (DWORD)Position.PlayOffset;
 
    if (pdwCurrentWriteCursor)
        *pdwCurrentWriteCursor = (DWORD)Position.WriteOffset;
 
    return DS_OK;
}

Referenced by SecondaryDirectSoundBuffer8Impl_fnGetCurrentPosition().

PrimaryDirectSoundBuffer_ReleaseLock()

VOID PrimaryDirectSoundBuffer_ReleaseLock

(

LPDIRECTSOUNDBUFFER8

iface

)

Definition at line 757 of file primary.c.

{
    LPCDirectSoundBuffer This = (LPCDirectSoundBuffer)CONTAINING_RECORD(iface, CDirectSoundBuffer, lpVtbl);
 
    LeaveCriticalSection(&This->Lock);
 
}

Referenced by PrimaryDirectSoundBuffer8Impl_fnPlay(), PrimaryDirectSoundBuffer8Impl_fnStop(), and SecondaryDirectSoundBuffer8Impl_fnPlay().

PrimaryDirectSoundBuffer_SetFormat()

HRESULT PrimaryDirectSoundBuffer_SetFormat	(	LPDIRECTSOUNDBUFFER8	iface,
		LPWAVEFORMATEX	pcfxFormat,
		BOOL	bLooped
	)

Definition at line 694 of file primary.c.

{
    ULONG PinId, DeviceId = 0, Result;
    LPCDirectSoundBuffer This = (LPCDirectSoundBuffer)CONTAINING_RECORD(iface, CDirectSoundBuffer, lpVtbl);
 
    if (This->hPin)
    {
        // FIXME
        // check if multiple buffers are active
        // in that case need mixing
 
        if (SetPinFormat(This->hPin, pcfxFormat))
            return DS_OK;
        else
            return DSERR_GENERIC;
    }
 
    do
    {
        /* try all available recording pins on that filter */
        PinId = GetPinIdFromFilter(This->Filter, FALSE, DeviceId);
        DPRINT("PinId %u DeviceId %u\n", PinId, DeviceId);
 
        if (PinId == ULONG_MAX)
            break;
 
        Result = OpenPin(This->Filter->hFilter, PinId, (LPWAVEFORMATEX)pcfxFormat, &This->hPin, bLooped);
        DPRINT("PinId %u Result %u\n", PinId, Result);
        if (Result == ERROR_SUCCESS)
        {
            This->dwFrequency = pcfxFormat->nSamplesPerSec;
            break;
        }
 
        This->hPin = NULL;
        DeviceId++;
    }while(TRUE);
 
    if (!This->hPin)
    {
        DPRINT("PrimaryDirectSoundBuffer8Impl_fnSetFormat failed\n");
        return DSERR_INVALIDPARAM;
    }
 
    DPRINT("PrimaryDirectSoundBuffer8Impl_fnSetFormat success\n");
    return DS_OK;
}

Referenced by SecondaryDirectSoundBuffer8Impl_fnPlay().

PrimaryDirectSoundBuffer_SetState()

VOID PrimaryDirectSoundBuffer_SetState	(	LPDIRECTSOUNDBUFFER8	iface,
		KSSTATE	State
	)

Definition at line 621 of file primary.c.

{
    KSPROPERTY Property;
    DWORD Result, BytesTransferred;
    LPCDirectSoundBuffer This = (LPCDirectSoundBuffer)CONTAINING_RECORD(iface, CDirectSoundBuffer, lpVtbl);
 
    if (This->State == State)
        return;
 
    Property.Set = KSPROPSETID_Connection;
    Property.Id = KSPROPERTY_CONNECTION_STATE;
    Property.Flags = KSPROPERTY_TYPE_SET;
 
    Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&State, sizeof(KSSTATE), &BytesTransferred);
    if (Result == ERROR_SUCCESS)
    {
        This->State = State;
    }
}

Referenced by PrimaryDirectSoundBuffer8Impl_fnPlay(), PrimaryDirectSoundBuffer8Impl_fnStop(), SecondaryDirectSoundBuffer8Impl_fnPlay(), and SecondaryDirectSoundBuffer8Impl_fnStop().

PrimaryDirectSoundBuffer_Write()

DWORD PrimaryDirectSoundBuffer_Write	(	LPDIRECTSOUNDBUFFER8	iface,
		LPVOID	Buffer,
		DWORD	BufferSize
	)

Definition at line 587 of file primary.c.

{
    KSSTREAM_HEADER Header;
    DWORD Result, BytesTransferred;
    OVERLAPPED Overlapped;
 
    LPCDirectSoundBuffer This = (LPCDirectSoundBuffer)CONTAINING_RECORD(iface, CDirectSoundBuffer, lpVtbl);
 
    ZeroMemory(&Overlapped, sizeof(OVERLAPPED));
    Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
 
    ASSERT(This->hPin);
    ZeroMemory(&Header, sizeof(KSSTREAM_HEADER));
 
    Header.FrameExtent = BufferSize;
    Header.DataUsed = BufferSize;
    Header.Data = Buffer;
    Header.Size = sizeof(KSSTREAM_HEADER);
    Header.PresentationTime.Numerator = 1;
    Header.PresentationTime.Denominator = 1;
 
    Result = DeviceIoControl(This->hPin, IOCTL_KS_WRITE_STREAM, NULL, 0, &Header, sizeof(KSSTREAM_HEADER), &BytesTransferred, &Overlapped);
 
    if (Result != ERROR_SUCCESS)
        return 0;
 
    return BytesTransferred;
}

Referenced by SecondaryDirectSoundBuffer8Impl_fnPlay().

SetPinFormat()

BOOL SetPinFormat	(	IN HANDLE	hPin,
		IN LPWAVEFORMATEX	WaveFormatEx
	)

Definition at line 77 of file misc.c.

{
    DWORD dwResult;
    KSPROPERTY Property;
    KSDATAFORMAT_WAVEFORMATEX DataFormat;
 
    /* setup connection request */
    Property.Id = KSPROPERTY_CONNECTION_DATAFORMAT;
    Property.Set = KSPROPSETID_Connection;
    Property.Flags = KSPROPERTY_TYPE_SET;
 
    /* setup data format */
    DataFormat.WaveFormatEx.wFormatTag = WaveFormatEx->wFormatTag;
    DataFormat.WaveFormatEx.nSamplesPerSec = WaveFormatEx->nSamplesPerSec;
    DataFormat.WaveFormatEx.nBlockAlign = WaveFormatEx->nBlockAlign;
    DataFormat.WaveFormatEx.cbSize = 0;
    DataFormat.DataFormat.FormatSize = sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATEX);
    DataFormat.DataFormat.Flags = 0;
    DataFormat.DataFormat.Reserved = 0;
    DataFormat.DataFormat.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
    DataFormat.DataFormat.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
    DataFormat.DataFormat.Specifier = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
    DataFormat.DataFormat.SampleSize = 4;
    DataFormat.WaveFormatEx.nChannels = WaveFormatEx->nChannels;
    DataFormat.WaveFormatEx.nAvgBytesPerSec = WaveFormatEx->nAvgBytesPerSec;
    DataFormat.WaveFormatEx.wBitsPerSample = WaveFormatEx->wBitsPerSample;
 
    dwResult = SyncOverlappedDeviceIoControl(hPin, IOCTL_KS_PROPERTY, (LPVOID)&Property, sizeof(KSPROPERTY),(LPVOID)&DataFormat, sizeof(KSDATAFORMAT_WAVEFORMATEX), NULL);
 
    if (dwResult == ERROR_SUCCESS)
        return TRUE;
    else
        return FALSE;
}

Referenced by PrimaryDirectSoundBuffer_SetFormat().

SyncOverlappedDeviceIoControl()

DWORD SyncOverlappedDeviceIoControl	(	IN HANDLE	Handle,
		IN DWORD	IoControlCode,
		IN LPVOID	InBuffer,
		IN DWORD	InBufferSize,
		OUT LPVOID	OutBuffer,
		IN DWORD	OutBufferSize,
		OUT LPDWORD BytesTransferred	OPTIONAL
	)

Definition at line 298 of file misc.c.

{
    OVERLAPPED Overlapped;
    BOOLEAN IoResult;
    DWORD Transferred = 0;
 
    /* Overlapped I/O is done here - this is used for waiting for completion */
    ZeroMemory(&Overlapped, sizeof(OVERLAPPED));
    Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if (!Overlapped.hEvent)
        return GetLastError();
 
    /* Talk to the device */
    IoResult = DeviceIoControl(Handle,
                               IoControlCode,
                               InBuffer,
                               InBufferSize,
                               OutBuffer,
                               OutBufferSize,
                               BytesTransferred,
                               &Overlapped);
 
    /* If failure occurs, make sure it's not just due to the overlapped I/O */
    if (!IoResult)
    {
        if ( GetLastError() != ERROR_IO_PENDING )
        {
            CloseHandle(Overlapped.hEvent);
            return GetLastError();
        }
    }
 
    /* Wait for the I/O to complete */
    IoResult = GetOverlappedResult(Handle,
                                   &Overlapped,
                                   &Transferred,
                                   TRUE);
 
    /* Don't need this any more */
    CloseHandle(Overlapped.hEvent);
 
    if (!IoResult)
        return GetLastError();
 
    if ( BytesTransferred )
        *BytesTransferred = Transferred;
 
    return ERROR_SUCCESS;
}

Variable Documentation

dsound_hInstance

HINSTANCE dsound_hInstance

extern

Definition at line 12 of file dsound.c.

Referenced by DllMain(), and LoadResourceString().

RootInfo

LPFILTERINFO RootInfo

extern

Definition at line 13 of file dsound.c.

Referenced by CDirectSoundCapture_fnInitialize(), DllMain(), DSoundEnumerate(), FindDeviceByGuid(), FindDeviceByMappedId(), and IDirectSound8_fnInitialize().