| /* DirectSound |
| * |
| * Copyright 1998 Marcus Meissner |
| * Copyright 1998 Rob Riggs |
| * Copyright 2000-2002 TransGaming Technologies, Inc. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #define COBJMACROS |
| #include <stdarg.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winuser.h" |
| #include "mmsystem.h" |
| #include "winternl.h" |
| #include "winnls.h" |
| #include "vfwmsgs.h" |
| #include "mmddk.h" |
| #include "wine/debug.h" |
| #include "dsound.h" |
| #include "dsdriver.h" |
| #include "dsound_private.h" |
| #include "dsconf.h" |
| |
| #ifdef NONAMELESSSTRUCT |
| # define S(x) (x).s |
| #else |
| # define S(x) (x) |
| #endif |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(dsound); |
| |
| /******************************************************************************* |
| * IKsPrivatePropertySet |
| */ |
| |
| /* IUnknown methods */ |
| static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface( |
| LPKSPROPERTYSET iface, |
| REFIID riid, |
| LPVOID *ppobj ) |
| { |
| IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; |
| TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); |
| |
| if (IsEqualIID(riid, &IID_IUnknown) || |
| IsEqualIID(riid, &IID_IKsPropertySet)) { |
| *ppobj = iface; |
| IUnknown_AddRef(iface); |
| return S_OK; |
| } |
| *ppobj = NULL; |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface) |
| { |
| IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; |
| ULONG ref = InterlockedIncrement(&(This->ref)); |
| TRACE("(%p) ref was %d\n", This, ref - 1); |
| return ref; |
| } |
| |
| static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface) |
| { |
| IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; |
| ULONG ref = InterlockedDecrement(&(This->ref)); |
| TRACE("(%p) ref was %d\n", This, ref + 1); |
| |
| if (!ref) { |
| HeapFree(GetProcessHeap(), 0, This); |
| TRACE("(%p) released\n", This); |
| } |
| return ref; |
| } |
| |
| static HRESULT DSPROPERTY_WaveDeviceMappingW( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned ) |
| { |
| HRESULT hr = DSERR_INVALIDPARAM; |
| PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd; |
| TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", |
| pPropData,cbPropData,pcbReturned); |
| |
| ppd = pPropData; |
| |
| if (!ppd) { |
| WARN("invalid parameter: pPropData\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { |
| ULONG wod; |
| unsigned int wodn; |
| TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); |
| wodn = waveOutGetNumDevs(); |
| for (wod = 0; wod < wodn; wod++) { |
| WAVEOUTCAPSW capsW; |
| MMRESULT res; |
| res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW)); |
| if (res == MMSYSERR_NOERROR) { |
| if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) { |
| ppd->DeviceId = DSOUND_renderer_guids[wod]; |
| hr = DS_OK; |
| TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId), |
| debugstr_w(ppd->DeviceName)); |
| break; |
| } |
| } |
| } |
| } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { |
| ULONG wid; |
| unsigned int widn; |
| TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); |
| widn = waveInGetNumDevs(); |
| for (wid = 0; wid < widn; wid++) { |
| WAVEINCAPSW capsW; |
| MMRESULT res; |
| res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW)); |
| if (res == MMSYSERR_NOERROR) { |
| if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) { |
| ppd->DeviceId = DSOUND_capture_guids[wid]; |
| hr = DS_OK; |
| TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId), |
| debugstr_w(ppd->DeviceName)); |
| break; |
| } |
| } |
| } |
| } |
| |
| if (pcbReturned) |
| *pcbReturned = cbPropData; |
| |
| return hr; |
| } |
| |
| static HRESULT DSPROPERTY_WaveDeviceMappingA( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned ) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA *ppd = pPropData; |
| DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA data; |
| DWORD len; |
| HRESULT hr; |
| |
| TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", |
| pPropData,cbPropData,pcbReturned); |
| |
| if (!ppd || !ppd->DeviceName) { |
| WARN("invalid parameter: ppd=%p\n", ppd); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| data.DataFlow = ppd->DataFlow; |
| len = MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, NULL, 0); |
| data.DeviceName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); |
| if (!data.DeviceName) |
| return E_OUTOFMEMORY; |
| MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, data.DeviceName, len); |
| |
| hr = DSPROPERTY_WaveDeviceMappingW(&data, cbPropData, pcbReturned); |
| HeapFree(GetProcessHeap(), 0, data.DeviceName); |
| ppd->DeviceId = data.DeviceId; |
| |
| if (pcbReturned) |
| *pcbReturned = cbPropData; |
| |
| return hr; |
| } |
| |
| static HRESULT DSPROPERTY_DescriptionW( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned ) |
| { |
| PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData; |
| HRESULT err; |
| GUID dev_guid; |
| ULONG wod, wid, wodn, widn; |
| DSDRIVERDESC desc; |
| |
| TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", |
| pPropData,cbPropData,pcbReturned); |
| |
| TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId)); |
| if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) { |
| /* default device of type specified by ppd->DataFlow */ |
| if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { |
| TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); |
| ppd->DeviceId = DSDEVID_DefaultCapture; |
| } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { |
| TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); |
| ppd->DeviceId = DSDEVID_DefaultPlayback; |
| } else { |
| WARN("DataFlow=Unknown(%d)\n", ppd->DataFlow); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| } |
| |
| GetDeviceID(&ppd->DeviceId, &dev_guid); |
| |
| wodn = waveOutGetNumDevs(); |
| widn = waveInGetNumDevs(); |
| wid = wod = dev_guid.Data4[7]; |
| if (!memcmp(&dev_guid, &DSOUND_renderer_guids[0], sizeof(GUID)-1) |
| && wod < wodn) |
| { |
| ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; |
| ppd->WaveDeviceId = wod; |
| } |
| else if (!memcmp(&dev_guid, &DSOUND_capture_guids[0], sizeof(GUID)-1) |
| && wid < widn) |
| { |
| ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; |
| ppd->WaveDeviceId = wid; |
| } |
| else |
| { |
| WARN("Device not found\n"); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) |
| err = waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0); |
| else |
| err = waveInMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0); |
| |
| if (err != MMSYSERR_NOERROR) |
| { |
| WARN("waveMessage(DRV_QUERYDSOUNDDESC) failed!\n"); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| else |
| { |
| /* FIXME: Still a memory leak.. */ |
| int desclen, modlen; |
| static WCHAR wInterface[] = { 'I','n','t','e','r','f','a','c','e',0 }; |
| |
| modlen = MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, NULL, 0 ); |
| desclen = MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, NULL, 0 ); |
| ppd->Module = HeapAlloc(GetProcessHeap(),0,modlen*sizeof(WCHAR)); |
| ppd->Description = HeapAlloc(GetProcessHeap(),0,desclen*sizeof(WCHAR)); |
| ppd->Interface = wInterface; |
| if (!ppd->Description || !ppd->Module) |
| { |
| WARN("Out of memory\n"); |
| HeapFree(GetProcessHeap(), 0, ppd->Description); |
| HeapFree(GetProcessHeap(), 0, ppd->Module); |
| ppd->Description = ppd->Module = NULL; |
| return E_OUTOFMEMORY; |
| } |
| |
| MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->Module, modlen ); |
| MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->Description, desclen ); |
| } |
| |
| ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; |
| |
| if (pcbReturned) { |
| *pcbReturned = sizeof(*ppd); |
| TRACE("*pcbReturned=%d\n", *pcbReturned); |
| } |
| |
| return S_OK; |
| } |
| |
| static HRESULT DSPROPERTY_EnumerateW( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned ) |
| { |
| PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData; |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data; |
| BOOL ret; |
| int widn, wodn, i; |
| TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", |
| pPropData,cbPropData,pcbReturned); |
| |
| if (pcbReturned) |
| *pcbReturned = 0; |
| |
| if (!ppd || !ppd->Callback) |
| { |
| WARN("Invalid ppd %p\n", ppd); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| wodn = waveOutGetNumDevs(); |
| widn = waveInGetNumDevs(); |
| |
| data.DeviceId = DSOUND_renderer_guids[0]; |
| for (i = 0; i < wodn; ++i) |
| { |
| HRESULT hr; |
| data.DeviceId.Data4[7] = i; |
| hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL); |
| if (FAILED(hr)) |
| { |
| ERR("DescriptionW failed!\n"); |
| return S_OK; |
| } |
| ret = ppd->Callback(&data, ppd->Context); |
| HeapFree(GetProcessHeap(), 0, data.Module); |
| HeapFree(GetProcessHeap(), 0, data.Description); |
| if (!ret) |
| return S_OK; |
| } |
| |
| data.DeviceId = DSOUND_capture_guids[0]; |
| for (i = 0; i < widn; ++i) |
| { |
| HRESULT hr; |
| data.DeviceId.Data4[7] = i; |
| hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL); |
| if (FAILED(hr)) |
| { |
| ERR("DescriptionW failed!\n"); |
| return S_OK; |
| } |
| ret = ppd->Callback(&data, ppd->Context); |
| HeapFree(GetProcessHeap(), 0, data.Module); |
| HeapFree(GetProcessHeap(), 0, data.Description); |
| if (!ret) |
| return S_OK; |
| } |
| return S_OK; |
| } |
| |
| static BOOL DSPROPERTY_descWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW, |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *dataA) |
| { |
| DWORD modlen, desclen; |
| static char Interface[] = "Interface"; |
| |
| modlen = WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, NULL, 0, NULL, NULL); |
| desclen = WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, NULL, 0, NULL, NULL); |
| dataA->Type = dataW->Type; |
| dataA->DataFlow = dataW->DataFlow; |
| dataA->DeviceId = dataW->DeviceId; |
| dataA->WaveDeviceId = dataW->WaveDeviceId; |
| dataA->Interface = Interface; |
| dataA->Module = HeapAlloc(GetProcessHeap(), 0, modlen); |
| dataA->Description = HeapAlloc(GetProcessHeap(), 0, desclen); |
| if (!dataA->Module || !dataA->Description) |
| { |
| HeapFree(GetProcessHeap(), 0, dataA->Module); |
| HeapFree(GetProcessHeap(), 0, dataA->Description); |
| dataA->Module = dataA->Description = NULL; |
| return FALSE; |
| } |
| |
| WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, dataA->Module, modlen, NULL, NULL); |
| WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, dataA->Description, desclen, NULL, NULL); |
| return TRUE; |
| } |
| |
| static void DSPROPERTY_descWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW, |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *data1) |
| { |
| data1->DeviceId = dataW->DeviceId; |
| lstrcpynW(data1->ModuleW, dataW->Module, sizeof(data1->ModuleW)/sizeof(*data1->ModuleW)); |
| lstrcpynW(data1->DescriptionW, dataW->Description, sizeof(data1->DescriptionW)/sizeof(*data1->DescriptionW)); |
| WideCharToMultiByte(CP_ACP, 0, data1->DescriptionW, -1, data1->DescriptionA, sizeof(data1->DescriptionA)-1, NULL, NULL); |
| WideCharToMultiByte(CP_ACP, 0, data1->ModuleW, -1, data1->ModuleA, sizeof(data1->ModuleA)-1, NULL, NULL); |
| data1->DescriptionA[sizeof(data1->DescriptionA)-1] = 0; |
| data1->ModuleA[sizeof(data1->ModuleA)-1] = 0; |
| data1->Type = dataW->Type; |
| data1->DataFlow = dataW->DataFlow; |
| data1->WaveDeviceId = data1->Devnode = dataW->WaveDeviceId; |
| } |
| |
| static BOOL CALLBACK DSPROPERTY_enumWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA descA; |
| DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = data; |
| BOOL ret; |
| |
| ret = DSPROPERTY_descWtoA(descW, &descA); |
| if (!ret) |
| return FALSE; |
| ret = ppd->Callback(&descA, ppd->Context); |
| HeapFree(GetProcessHeap(), 0, descA.Module); |
| HeapFree(GetProcessHeap(), 0, descA.Description); |
| return ret; |
| } |
| |
| static HRESULT DSPROPERTY_EnumerateA( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = pPropData; |
| DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data; |
| |
| if (!ppd || !ppd->Callback) |
| { |
| WARN("Invalid ppd %p\n", ppd); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| data.Callback = DSPROPERTY_enumWtoA; |
| data.Context = ppd; |
| |
| return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned); |
| } |
| |
| static BOOL CALLBACK DSPROPERTY_enumWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA desc1; |
| DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = data; |
| BOOL ret; |
| |
| DSPROPERTY_descWto1(descW, &desc1); |
| ret = ppd->Callback(&desc1, ppd->Context); |
| return ret; |
| } |
| |
| static HRESULT DSPROPERTY_Enumerate1( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = pPropData; |
| DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data; |
| |
| if (!ppd || !ppd->Callback) |
| { |
| WARN("Invalid ppd %p\n", ppd); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| data.Callback = DSPROPERTY_enumWto1; |
| data.Context = ppd; |
| |
| return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned); |
| } |
| |
| static HRESULT DSPROPERTY_DescriptionA( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data; |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *ppd = pPropData; |
| HRESULT hr; |
| |
| if (pcbReturned) |
| *pcbReturned = sizeof(*ppd); |
| if (!pPropData) |
| return S_OK; |
| |
| data.DeviceId = ppd->DeviceId; |
| data.DataFlow = ppd->DataFlow; |
| hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL); |
| if (FAILED(hr)) |
| return hr; |
| if (!DSPROPERTY_descWtoA(&data, ppd)) |
| hr = E_OUTOFMEMORY; |
| HeapFree(GetProcessHeap(), 0, data.Module); |
| HeapFree(GetProcessHeap(), 0, data.Interface); |
| return hr; |
| } |
| |
| static HRESULT DSPROPERTY_Description1( |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned) |
| { |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data; |
| DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *ppd = pPropData; |
| HRESULT hr; |
| |
| if (pcbReturned) |
| *pcbReturned = sizeof(*ppd); |
| if (!pPropData) |
| return S_OK; |
| |
| data.DeviceId = ppd->DeviceId; |
| data.DataFlow = ppd->DataFlow; |
| hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL); |
| if (FAILED(hr)) |
| return hr; |
| DSPROPERTY_descWto1(&data, ppd); |
| HeapFree(GetProcessHeap(), 0, data.Module); |
| HeapFree(GetProcessHeap(), 0, data.Interface); |
| return hr; |
| } |
| |
| static HRESULT WINAPI IKsPrivatePropertySetImpl_Get( |
| LPKSPROPERTYSET iface, |
| REFGUID guidPropSet, |
| ULONG dwPropID, |
| LPVOID pInstanceData, |
| ULONG cbInstanceData, |
| LPVOID pPropData, |
| ULONG cbPropData, |
| PULONG pcbReturned ) |
| { |
| IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; |
| TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", |
| This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned); |
| |
| if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) { |
| switch (dwPropID) { |
| case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A: |
| return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1: |
| return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1: |
| return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W: |
| return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A: |
| return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W: |
| return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A: |
| return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned); |
| case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W: |
| return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned); |
| default: |
| FIXME("unsupported ID: %d\n",dwPropID); |
| break; |
| } |
| } else { |
| FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet)); |
| } |
| |
| if (pcbReturned) { |
| *pcbReturned = 0; |
| FIXME("*pcbReturned=%d\n", *pcbReturned); |
| } |
| |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| static HRESULT WINAPI IKsPrivatePropertySetImpl_Set( |
| LPKSPROPERTYSET iface, |
| REFGUID guidPropSet, |
| ULONG dwPropID, |
| LPVOID pInstanceData, |
| ULONG cbInstanceData, |
| LPVOID pPropData, |
| ULONG cbPropData ) |
| { |
| IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; |
| |
| FIXME("(%p,%s,%d,%p,%d,%p,%d), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData); |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport( |
| LPKSPROPERTYSET iface, |
| REFGUID guidPropSet, |
| ULONG dwPropID, |
| PULONG pTypeSupport ) |
| { |
| IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; |
| TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport); |
| |
| if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) { |
| switch (dwPropID) { |
| case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W: |
| *pTypeSupport = KSPROPERTY_SUPPORT_GET; |
| return S_OK; |
| default: |
| FIXME("unsupported ID: %d\n",dwPropID); |
| break; |
| } |
| } else { |
| FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet)); |
| } |
| |
| return E_PROP_ID_UNSUPPORTED; |
| } |
| |
| static const IKsPropertySetVtbl ikspvt = { |
| IKsPrivatePropertySetImpl_QueryInterface, |
| IKsPrivatePropertySetImpl_AddRef, |
| IKsPrivatePropertySetImpl_Release, |
| IKsPrivatePropertySetImpl_Get, |
| IKsPrivatePropertySetImpl_Set, |
| IKsPrivatePropertySetImpl_QuerySupport |
| }; |
| |
| HRESULT IKsPrivatePropertySetImpl_Create( |
| REFIID riid, |
| IKsPrivatePropertySetImpl **piks) |
| { |
| IKsPrivatePropertySetImpl *iks; |
| TRACE("(%s, %p)\n", debugstr_guid(riid), piks); |
| |
| if (!IsEqualIID(riid, &IID_IUnknown) && |
| !IsEqualIID(riid, &IID_IKsPropertySet)) { |
| *piks = 0; |
| return E_NOINTERFACE; |
| } |
| |
| iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks)); |
| iks->ref = 1; |
| iks->lpVtbl = &ikspvt; |
| |
| *piks = iks; |
| return S_OK; |
| } |
