ReactOS Development > Doxygen
propset.c
Go to the documentation of this file.
00001 /* DirectSound 00002 * 00003 * Copyright 1998 Marcus Meissner 00004 * Copyright 1998 Rob Riggs 00005 * Copyright 2000-2002 TransGaming Technologies, Inc. 00006 * 00007 * This library is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * This library is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with this library; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 00020 */ 00021 00022 #define COBJMACROS 00023 #include <stdarg.h> 00024 00025 #include "windef.h" 00026 #include "winbase.h" 00027 #include "winuser.h" 00028 #include "mmsystem.h" 00029 #include "winternl.h" 00030 #include "winnls.h" 00031 #include "vfwmsgs.h" 00032 #include "mmddk.h" 00033 #include "wine/debug.h" 00034 #include "dsound.h" 00035 #include "dsdriver.h" 00036 #include "dsound_private.h" 00037 #include "dsconf.h" 00038 00039 #ifdef NONAMELESSSTRUCT 00040 # define S(x) (x).s 00041 #else 00042 # define S(x) (x) 00043 #endif 00044 00045 WINE_DEFAULT_DEBUG_CHANNEL(dsound); 00046 00047 00048 /******************************************************************************* 00049 * IKsBufferPropertySet 00050 */ 00051 00052 /* IUnknown methods */ 00053 static HRESULT WINAPI IKsBufferPropertySetImpl_QueryInterface( 00054 LPKSPROPERTYSET iface, 00055 REFIID riid, 00056 LPVOID *ppobj ) 00057 { 00058 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface; 00059 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); 00060 00061 return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb, riid, ppobj); 00062 } 00063 00064 static ULONG WINAPI IKsBufferPropertySetImpl_AddRef(LPKSPROPERTYSET iface) 00065 { 00066 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface; 00067 ULONG ref = InterlockedIncrement(&(This->ref)); 00068 TRACE("(%p) ref was %d\n", This, ref - 1); 00069 return ref; 00070 } 00071 00072 static ULONG WINAPI IKsBufferPropertySetImpl_Release(LPKSPROPERTYSET iface) 00073 { 00074 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface; 00075 ULONG ref = InterlockedDecrement(&(This->ref)); 00076 TRACE("(%p) ref was %d\n", This, ref + 1); 00077 00078 if (!ref) { 00079 This->dsb->iks = 0; 00080 IDirectSoundBuffer_Release((LPDIRECTSOUND3DBUFFER)This->dsb); 00081 HeapFree(GetProcessHeap(), 0, This); 00082 TRACE("(%p) released\n", This); 00083 } 00084 return ref; 00085 } 00086 00087 static HRESULT WINAPI IKsBufferPropertySetImpl_Get( 00088 LPKSPROPERTYSET iface, 00089 REFGUID guidPropSet, 00090 ULONG dwPropID, 00091 LPVOID pInstanceData, 00092 ULONG cbInstanceData, 00093 LPVOID pPropData, 00094 ULONG cbPropData, 00095 PULONG pcbReturned ) 00096 { 00097 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface; 00098 PIDSDRIVERPROPERTYSET ps; 00099 TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 00100 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned); 00101 00102 if (This->dsb->hwbuf) { 00103 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps); 00104 00105 if (ps) { 00106 DSPROPERTY prop; 00107 HRESULT hres; 00108 00109 S(prop).Set = *guidPropSet; 00110 S(prop).Id = dwPropID; 00111 S(prop).Flags = 0; /* unused */ 00112 S(prop).InstanceId = (ULONG_PTR)This->dsb->device; 00113 00114 hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned); 00115 00116 IDsDriverPropertySet_Release(ps); 00117 00118 return hres; 00119 } 00120 } 00121 00122 return E_PROP_ID_UNSUPPORTED; 00123 } 00124 00125 static HRESULT WINAPI IKsBufferPropertySetImpl_Set( 00126 LPKSPROPERTYSET iface, 00127 REFGUID guidPropSet, 00128 ULONG dwPropID, 00129 LPVOID pInstanceData, 00130 ULONG cbInstanceData, 00131 LPVOID pPropData, 00132 ULONG cbPropData ) 00133 { 00134 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface; 00135 PIDSDRIVERPROPERTYSET ps; 00136 TRACE("(%p,%s,%d,%p,%d,%p,%d)\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData); 00137 00138 if (This->dsb->hwbuf) { 00139 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps); 00140 00141 if (ps) { 00142 DSPROPERTY prop; 00143 HRESULT hres; 00144 00145 S(prop).Set = *guidPropSet; 00146 S(prop).Id = dwPropID; 00147 S(prop).Flags = 0; /* unused */ 00148 S(prop).InstanceId = (ULONG_PTR)This->dsb->device; 00149 hres = IDsDriverPropertySet_Set(ps,&prop,pInstanceData,cbInstanceData,pPropData,cbPropData); 00150 00151 IDsDriverPropertySet_Release(ps); 00152 00153 return hres; 00154 } 00155 } 00156 00157 return E_PROP_ID_UNSUPPORTED; 00158 } 00159 00160 static HRESULT WINAPI IKsBufferPropertySetImpl_QuerySupport( 00161 LPKSPROPERTYSET iface, 00162 REFGUID guidPropSet, 00163 ULONG dwPropID, 00164 PULONG pTypeSupport ) 00165 { 00166 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface; 00167 PIDSDRIVERPROPERTYSET ps; 00168 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport); 00169 00170 if (This->dsb->hwbuf) { 00171 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps); 00172 00173 if (ps) { 00174 HRESULT hres; 00175 00176 hres = IDsDriverPropertySet_QuerySupport(ps,guidPropSet, dwPropID,pTypeSupport); 00177 00178 IDsDriverPropertySet_Release(ps); 00179 00180 return hres; 00181 } 00182 } 00183 00184 return E_PROP_ID_UNSUPPORTED; 00185 } 00186 00187 static const IKsPropertySetVtbl iksbvt = { 00188 IKsBufferPropertySetImpl_QueryInterface, 00189 IKsBufferPropertySetImpl_AddRef, 00190 IKsBufferPropertySetImpl_Release, 00191 IKsBufferPropertySetImpl_Get, 00192 IKsBufferPropertySetImpl_Set, 00193 IKsBufferPropertySetImpl_QuerySupport 00194 }; 00195 00196 HRESULT IKsBufferPropertySetImpl_Create( 00197 IDirectSoundBufferImpl *dsb, 00198 IKsBufferPropertySetImpl **piks) 00199 { 00200 IKsBufferPropertySetImpl *iks; 00201 TRACE("(%p,%p)\n",dsb,piks); 00202 *piks = NULL; 00203 00204 iks = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*iks)); 00205 if (iks == 0) { 00206 WARN("out of memory\n"); 00207 *piks = NULL; 00208 return DSERR_OUTOFMEMORY; 00209 } 00210 00211 iks->ref = 0; 00212 iks->dsb = dsb; 00213 dsb->iks = iks; 00214 iks->lpVtbl = &iksbvt; 00215 00216 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)dsb); 00217 00218 *piks = iks; 00219 return S_OK; 00220 } 00221 00222 HRESULT IKsBufferPropertySetImpl_Destroy( 00223 IKsBufferPropertySetImpl *piks) 00224 { 00225 TRACE("(%p)\n",piks); 00226 00227 while (IKsBufferPropertySetImpl_Release((LPKSPROPERTYSET)piks) > 0); 00228 00229 return S_OK; 00230 } 00231 00232 /******************************************************************************* 00233 * IKsPrivatePropertySet 00234 */ 00235 00236 /* IUnknown methods */ 00237 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface( 00238 LPKSPROPERTYSET iface, 00239 REFIID riid, 00240 LPVOID *ppobj ) 00241 { 00242 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; 00243 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj); 00244 00245 if (IsEqualIID(riid, &IID_IUnknown) || 00246 IsEqualIID(riid, &IID_IKsPropertySet)) { 00247 *ppobj = iface; 00248 IUnknown_AddRef(iface); 00249 return S_OK; 00250 } 00251 *ppobj = NULL; 00252 return E_NOINTERFACE; 00253 } 00254 00255 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface) 00256 { 00257 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; 00258 ULONG ref = InterlockedIncrement(&(This->ref)); 00259 TRACE("(%p) ref was %d\n", This, ref - 1); 00260 return ref; 00261 } 00262 00263 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface) 00264 { 00265 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; 00266 ULONG ref = InterlockedDecrement(&(This->ref)); 00267 TRACE("(%p) ref was %d\n", This, ref + 1); 00268 00269 if (!ref) { 00270 HeapFree(GetProcessHeap(), 0, This); 00271 TRACE("(%p) released\n", This); 00272 } 00273 return ref; 00274 } 00275 00276 static HRESULT DSPROPERTY_WaveDeviceMappingA( 00277 LPVOID pPropData, 00278 ULONG cbPropData, 00279 PULONG pcbReturned ) 00280 { 00281 HRESULT hr = DSERR_INVALIDPARAM; 00282 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA ppd; 00283 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 00284 pPropData,cbPropData,pcbReturned); 00285 00286 ppd = pPropData; 00287 00288 if (!ppd) { 00289 WARN("invalid parameter: pPropData\n"); 00290 return DSERR_INVALIDPARAM; 00291 } 00292 00293 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { 00294 ULONG wod; 00295 unsigned int wodn; 00296 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00297 wodn = waveOutGetNumDevs(); 00298 for (wod = 0; wod < wodn; wod++) { 00299 WAVEOUTCAPSA capsA; 00300 MMRESULT res; 00301 res = waveOutGetDevCapsA(wod, &capsA, sizeof(capsA)); 00302 if (res == MMSYSERR_NOERROR) { 00303 if (lstrcmpA(capsA.szPname, ppd->DeviceName) == 0) { 00304 ppd->DeviceId = DSOUND_renderer_guids[wod]; 00305 hr = DS_OK; 00306 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId), 00307 ppd->DeviceName); 00308 break; 00309 } 00310 } 00311 } 00312 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { 00313 ULONG wid; 00314 unsigned int widn; 00315 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00316 widn = waveInGetNumDevs(); 00317 for (wid = 0; wid < widn; wid++) { 00318 WAVEINCAPSA capsA; 00319 MMRESULT res; 00320 res = waveInGetDevCapsA(wid, &capsA, sizeof(capsA)); 00321 if (res == MMSYSERR_NOERROR) { 00322 if (lstrcmpA(capsA.szPname, ppd->DeviceName) == 0) { 00323 ppd->DeviceId = DSOUND_capture_guids[wid]; 00324 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId), 00325 ppd->DeviceName); 00326 hr = DS_OK; 00327 break; 00328 } 00329 } 00330 } 00331 } 00332 00333 if (pcbReturned) 00334 *pcbReturned = cbPropData; 00335 00336 return hr; 00337 } 00338 00339 static HRESULT DSPROPERTY_WaveDeviceMappingW( 00340 LPVOID pPropData, 00341 ULONG cbPropData, 00342 PULONG pcbReturned ) 00343 { 00344 HRESULT hr = DSERR_INVALIDPARAM; 00345 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd; 00346 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 00347 pPropData,cbPropData,pcbReturned); 00348 00349 ppd = pPropData; 00350 00351 if (!ppd) { 00352 WARN("invalid parameter: pPropData\n"); 00353 return DSERR_INVALIDPARAM; 00354 } 00355 00356 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { 00357 ULONG wod; 00358 unsigned int wodn; 00359 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00360 wodn = waveOutGetNumDevs(); 00361 for (wod = 0; wod < wodn; wod++) { 00362 WAVEOUTCAPSW capsW; 00363 MMRESULT res; 00364 res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW)); 00365 if (res == MMSYSERR_NOERROR) { 00366 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) { 00367 ppd->DeviceId = DSOUND_renderer_guids[wod]; 00368 hr = DS_OK; 00369 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId), 00370 debugstr_w(ppd->DeviceName)); 00371 break; 00372 } 00373 } 00374 } 00375 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { 00376 ULONG wid; 00377 unsigned int widn; 00378 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00379 widn = waveInGetNumDevs(); 00380 for (wid = 0; wid < widn; wid++) { 00381 WAVEINCAPSW capsW; 00382 MMRESULT res; 00383 res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW)); 00384 if (res == MMSYSERR_NOERROR) { 00385 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) { 00386 ppd->DeviceId = DSOUND_capture_guids[wid]; 00387 hr = DS_OK; 00388 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId), 00389 debugstr_w(ppd->DeviceName)); 00390 break; 00391 } 00392 } 00393 } 00394 } 00395 00396 if (pcbReturned) 00397 *pcbReturned = cbPropData; 00398 00399 return hr; 00400 } 00401 00402 static HRESULT DSPROPERTY_Description1( 00403 LPVOID pPropData, 00404 ULONG cbPropData, 00405 PULONG pcbReturned ) 00406 { 00407 HRESULT err; 00408 GUID guid, dev_guid; 00409 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA ppd; 00410 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 00411 pPropData,cbPropData,pcbReturned); 00412 00413 ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA) pPropData; 00414 00415 if (!ppd) { 00416 WARN("invalid parameter: pPropData\n"); 00417 return DSERR_INVALIDPARAM; 00418 } 00419 00420 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId)); 00421 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) { 00422 /* default device of type specified by ppd->DataFlow */ 00423 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { 00424 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00425 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { 00426 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00427 } else { 00428 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow); 00429 } 00430 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n", 00431 pPropData,cbPropData,pcbReturned); 00432 return E_PROP_ID_UNSUPPORTED; 00433 } 00434 00435 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 00436 GetDeviceID(&ppd->DeviceId, &dev_guid); 00437 00438 if ( IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultPlayback) || 00439 IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultVoicePlayback) ) { 00440 ULONG wod; 00441 unsigned int wodn; 00442 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00443 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 00444 wodn = waveOutGetNumDevs(); 00445 for (wod = 0; wod < wodn; wod++) { 00446 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) { 00447 DSDRIVERDESC desc; 00448 ppd->WaveDeviceId = wod; 00449 ppd->Devnode = wod; 00450 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00451 if (err == DS_OK) { 00452 PIDSDRIVER drv = NULL; 00453 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA)); 00454 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA)); 00455 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) ); 00456 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) ); 00457 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00458 if (err == DS_OK && drv) 00459 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00460 else 00461 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00462 break; 00463 } else { 00464 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00465 return E_PROP_ID_UNSUPPORTED; 00466 } 00467 } 00468 } 00469 } else if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) || 00470 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) { 00471 ULONG wid; 00472 unsigned int widn; 00473 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00474 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 00475 widn = waveInGetNumDevs(); 00476 for (wid = 0; wid < widn; wid++) { 00477 if (IsEqualGUID( &dev_guid, &guid) ) { 00478 DSDRIVERDESC desc; 00479 ppd->WaveDeviceId = wid; 00480 ppd->Devnode = wid; 00481 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00482 if (err == DS_OK) { 00483 PIDSCDRIVER drv; 00484 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA)); 00485 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA)); 00486 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) ); 00487 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) ); 00488 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0)); 00489 if (err == DS_OK && drv) 00490 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00491 else 00492 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00493 break; 00494 } else { 00495 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00496 return E_PROP_ID_UNSUPPORTED; 00497 } 00498 } 00499 } 00500 } else { 00501 BOOL found = FALSE; 00502 ULONG wod; 00503 unsigned int wodn; 00504 /* given specific device so try the render devices first */ 00505 wodn = waveOutGetNumDevs(); 00506 for (wod = 0; wod < wodn; wod++) { 00507 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) { 00508 DSDRIVERDESC desc; 00509 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00510 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 00511 ppd->WaveDeviceId = wod; 00512 ppd->Devnode = wod; 00513 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00514 if (err == DS_OK) { 00515 PIDSDRIVER drv = NULL; 00516 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA)); 00517 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA)); 00518 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) ); 00519 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) ); 00520 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00521 if (err == DS_OK && drv) 00522 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00523 else 00524 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00525 found = TRUE; 00526 break; 00527 } else { 00528 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00529 return E_PROP_ID_UNSUPPORTED; 00530 } 00531 } 00532 } 00533 00534 if (found == FALSE) { 00535 ULONG wid; 00536 unsigned int widn; 00537 /* given specific device so try the capture devices next */ 00538 widn = waveInGetNumDevs(); 00539 for (wid = 0; wid < widn; wid++) { 00540 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_capture_guids[wid] ) ) { 00541 DSDRIVERDESC desc; 00542 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00543 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 00544 ppd->WaveDeviceId = wid; 00545 ppd->Devnode = wid; 00546 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00547 if (err == DS_OK) { 00548 PIDSDRIVER drv = NULL; 00549 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA)); 00550 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA)); 00551 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) ); 00552 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) ); 00553 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00554 if (err == DS_OK && drv) 00555 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00556 else 00557 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00558 found = TRUE; 00559 break; 00560 } else { 00561 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00562 return E_PROP_ID_UNSUPPORTED; 00563 } 00564 } 00565 } 00566 00567 if (found == FALSE) { 00568 WARN("device not found\n"); 00569 return E_PROP_ID_UNSUPPORTED; 00570 } 00571 } 00572 } 00573 00574 if (pcbReturned) { 00575 *pcbReturned = cbPropData; 00576 TRACE("*pcbReturned=%d\n", *pcbReturned); 00577 } 00578 00579 return S_OK; 00580 } 00581 00582 static HRESULT DSPROPERTY_DescriptionA( 00583 LPVOID pPropData, 00584 ULONG cbPropData, 00585 PULONG pcbReturned ) 00586 { 00587 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA ppd = pPropData; 00588 HRESULT err; 00589 GUID dev_guid; 00590 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 00591 pPropData,cbPropData,pcbReturned); 00592 00593 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId)); 00594 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) { 00595 /* default device of type specified by ppd->DataFlow */ 00596 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { 00597 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00598 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { 00599 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00600 } else { 00601 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow); 00602 } 00603 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n", 00604 pPropData,cbPropData,pcbReturned); 00605 return E_PROP_ID_UNSUPPORTED; 00606 } 00607 00608 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 00609 GetDeviceID(&ppd->DeviceId, &dev_guid); 00610 00611 if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) || 00612 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) { 00613 ULONG wod; 00614 unsigned int wodn; 00615 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ) 00616 TRACE("DSDEVID_DefaultPlayback\n"); 00617 else 00618 TRACE("DSDEVID_DefaultVoicePlayback\n"); 00619 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 00620 wodn = waveOutGetNumDevs(); 00621 for (wod = 0; wod < wodn; wod++) { 00622 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) { 00623 DSDRIVERDESC desc; 00624 ppd->WaveDeviceId = wod; 00625 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00626 if (err == DS_OK) { 00627 PIDSDRIVER drv = NULL; 00628 /* FIXME: this is a memory leak */ 00629 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1); 00630 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1); 00631 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1); 00632 00633 if (szDescription && szModule && szInterface) { 00634 strcpy(szDescription, desc.szDesc); 00635 strcpy(szModule, desc.szDrvname); 00636 strcpy(szInterface, "Interface"); 00637 00638 ppd->Description = szDescription; 00639 ppd->Module = szModule; 00640 ppd->Interface = szInterface; 00641 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00642 if (err == DS_OK && drv) 00643 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00644 else 00645 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00646 break; 00647 } else { 00648 WARN("no memory\n"); 00649 HeapFree(GetProcessHeap(), 0, szDescription); 00650 HeapFree(GetProcessHeap(), 0, szModule); 00651 HeapFree(GetProcessHeap(), 0, szInterface); 00652 return E_OUTOFMEMORY; 00653 } 00654 } else { 00655 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00656 return E_PROP_ID_UNSUPPORTED; 00657 } 00658 } 00659 } 00660 } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) || 00661 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) { 00662 ULONG wid; 00663 unsigned int widn; 00664 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ) 00665 TRACE("DSDEVID_DefaultCapture\n"); 00666 else 00667 TRACE("DSDEVID_DefaultVoiceCapture\n"); 00668 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 00669 widn = waveInGetNumDevs(); 00670 for (wid = 0; wid < widn; wid++) { 00671 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) { 00672 DSDRIVERDESC desc; 00673 ppd->WaveDeviceId = wid; 00674 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00675 if (err == DS_OK) { 00676 PIDSCDRIVER drv; 00677 /* FIXME: this is a memory leak */ 00678 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1); 00679 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1); 00680 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1); 00681 00682 if (szDescription && szModule && szInterface) { 00683 strcpy(szDescription, desc.szDesc); 00684 strcpy(szModule, desc.szDrvname); 00685 strcpy(szInterface, "Interface"); 00686 00687 ppd->Description = szDescription; 00688 ppd->Module = szModule; 00689 ppd->Interface = szInterface; 00690 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0)); 00691 if (err == DS_OK && drv) 00692 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00693 else 00694 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00695 break; 00696 } else { 00697 WARN("no memory\n"); 00698 HeapFree(GetProcessHeap(), 0, szDescription); 00699 HeapFree(GetProcessHeap(), 0, szModule); 00700 HeapFree(GetProcessHeap(), 0, szInterface); 00701 return E_OUTOFMEMORY; 00702 } 00703 } else { 00704 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00705 return E_PROP_ID_UNSUPPORTED; 00706 } 00707 } 00708 } 00709 } else { 00710 BOOL found = FALSE; 00711 ULONG wod; 00712 unsigned int wodn; 00713 /* given specific device so try the render devices first */ 00714 TRACE("Checking renderer devices\n"); 00715 wodn = waveOutGetNumDevs(); 00716 for (wod = 0; wod < wodn; wod++) { 00717 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) { 00718 DSDRIVERDESC desc; 00719 TRACE("DSOUND_renderer_guids[%d]\n", wod); 00720 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 00721 ppd->WaveDeviceId = wod; 00722 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00723 if (err == DS_OK) { 00724 PIDSDRIVER drv = NULL; 00725 /* FIXME: this is a memory leak */ 00726 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1); 00727 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1); 00728 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1); 00729 00730 if (szDescription && szModule && szInterface) { 00731 strcpy(szDescription, desc.szDesc); 00732 strcpy(szModule, desc.szDrvname); 00733 strcpy(szInterface, "Interface"); 00734 00735 ppd->Description = szDescription; 00736 ppd->Module = szModule; 00737 ppd->Interface = szInterface; 00738 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00739 if (err == DS_OK && drv) 00740 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00741 else 00742 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00743 found = TRUE; 00744 break; 00745 } else { 00746 WARN("no memory\n"); 00747 HeapFree(GetProcessHeap(), 0, szDescription); 00748 HeapFree(GetProcessHeap(), 0, szModule); 00749 HeapFree(GetProcessHeap(), 0, szInterface); 00750 return E_OUTOFMEMORY; 00751 } 00752 } else { 00753 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00754 return E_PROP_ID_UNSUPPORTED; 00755 } 00756 } 00757 } 00758 00759 if (found == FALSE) { 00760 ULONG wid; 00761 unsigned int widn; 00762 TRACE("Checking capture devices\n"); 00763 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 00764 widn = waveInGetNumDevs(); 00765 for (wid = 0; wid < widn; wid++) { 00766 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_capture_guids[wid] ) ) { 00767 DSDRIVERDESC desc; 00768 TRACE("DSOUND_capture_guids[%d]\n", wid); 00769 ppd->WaveDeviceId = wid; 00770 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00771 if (err == DS_OK) { 00772 PIDSCDRIVER drv; 00773 /* FIXME: this is a memory leak */ 00774 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1); 00775 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1); 00776 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1); 00777 00778 if (szDescription && szModule && szInterface) { 00779 strcpy(szDescription, desc.szDesc); 00780 strcpy(szModule, desc.szDrvname); 00781 strcpy(szInterface, "Interface"); 00782 00783 ppd->Description = szDescription; 00784 ppd->Module = szModule; 00785 ppd->Interface = szInterface; 00786 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0)); 00787 if (err == DS_OK && drv) 00788 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00789 else 00790 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00791 found = TRUE; 00792 break; 00793 } else { 00794 WARN("no memory\n"); 00795 HeapFree(GetProcessHeap(), 0, szDescription); 00796 HeapFree(GetProcessHeap(), 0, szModule); 00797 HeapFree(GetProcessHeap(), 0, szInterface); 00798 return E_OUTOFMEMORY; 00799 } 00800 } else { 00801 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00802 return E_PROP_ID_UNSUPPORTED; 00803 } 00804 } 00805 } 00806 } 00807 00808 if (found == FALSE) { 00809 WARN("device not found\n"); 00810 return E_PROP_ID_UNSUPPORTED; 00811 } 00812 } 00813 00814 if (pcbReturned) { 00815 *pcbReturned = cbPropData; 00816 TRACE("*pcbReturned=%d\n", *pcbReturned); 00817 } 00818 00819 return S_OK; 00820 } 00821 00822 static HRESULT DSPROPERTY_DescriptionW( 00823 LPVOID pPropData, 00824 ULONG cbPropData, 00825 PULONG pcbReturned ) 00826 { 00827 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData; 00828 HRESULT err; 00829 GUID dev_guid; 00830 TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 00831 pPropData,cbPropData,pcbReturned); 00832 00833 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId)); 00834 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) { 00835 /* default device of type specified by ppd->DataFlow */ 00836 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) { 00837 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n"); 00838 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) { 00839 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n"); 00840 } else { 00841 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow); 00842 } 00843 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n", 00844 pPropData,cbPropData,pcbReturned); 00845 return E_PROP_ID_UNSUPPORTED; 00846 } 00847 00848 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 00849 GetDeviceID(&ppd->DeviceId, &dev_guid); 00850 00851 if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) || 00852 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) { 00853 ULONG wod; 00854 unsigned int wodn; 00855 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ) 00856 TRACE("DSDEVID_DefaultPlayback\n"); 00857 else 00858 TRACE("DSDEVID_DefaultVoicePlayback\n"); 00859 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 00860 wodn = waveOutGetNumDevs(); 00861 for (wod = 0; wod < wodn; wod++) { 00862 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) { 00863 DSDRIVERDESC desc; 00864 TRACE("DSOUND_renderer_guids[%d]\n", wod); 00865 ppd->WaveDeviceId = wod; 00866 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00867 if (err == DS_OK) { 00868 PIDSDRIVER drv = NULL; 00869 /* FIXME: this is a memory leak */ 00870 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200); 00871 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200); 00872 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200); 00873 00874 if (wDescription && wModule && wInterface) { 00875 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 ); 00876 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 ); 00877 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 ); 00878 00879 ppd->Description = wDescription; 00880 ppd->Module = wModule; 00881 ppd->Interface = wInterface; 00882 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00883 if (err == DS_OK && drv) 00884 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00885 else 00886 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00887 break; 00888 } else { 00889 WARN("no memory\n"); 00890 HeapFree(GetProcessHeap(), 0, wDescription); 00891 HeapFree(GetProcessHeap(), 0, wModule); 00892 HeapFree(GetProcessHeap(), 0, wInterface); 00893 return E_OUTOFMEMORY; 00894 } 00895 } else { 00896 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00897 return E_PROP_ID_UNSUPPORTED; 00898 } 00899 } 00900 } 00901 } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) || 00902 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) { 00903 ULONG wid; 00904 unsigned int widn; 00905 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture)) 00906 TRACE("DSDEVID_DefaultCapture\n"); 00907 else 00908 TRACE("DSDEVID_DefaultVoiceCapture\n"); 00909 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 00910 widn = waveInGetNumDevs(); 00911 for (wid = 0; wid < widn; wid++) { 00912 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) { 00913 DSDRIVERDESC desc; 00914 ppd->WaveDeviceId = wid; 00915 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00916 if (err == DS_OK) { 00917 PIDSCDRIVER drv; 00918 /* FIXME: this is a memory leak */ 00919 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200); 00920 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200); 00921 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200); 00922 00923 if (wDescription && wModule && wInterface) { 00924 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 ); 00925 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 ); 00926 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 ); 00927 00928 ppd->Description = wDescription; 00929 ppd->Module = wModule; 00930 ppd->Interface = wInterface; 00931 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0)); 00932 if (err == DS_OK && drv) 00933 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00934 else 00935 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00936 break; 00937 } else { 00938 WARN("no memory\n"); 00939 HeapFree(GetProcessHeap(), 0, wDescription); 00940 HeapFree(GetProcessHeap(), 0, wModule); 00941 HeapFree(GetProcessHeap(), 0, wInterface); 00942 return E_OUTOFMEMORY; 00943 } 00944 } else { 00945 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00946 return E_PROP_ID_UNSUPPORTED; 00947 } 00948 } 00949 } 00950 } else { 00951 BOOL found = FALSE; 00952 ULONG wod; 00953 unsigned int wodn; 00954 TRACE("Checking renderer devices\n"); 00955 /* given specific device so try the render devices first */ 00956 wodn = waveOutGetNumDevs(); 00957 for (wod = 0; wod < wodn; wod++) { 00958 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) { 00959 DSDRIVERDESC desc; 00960 TRACE("DSOUND_renderer_guids[%d]\n", wod); 00961 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 00962 ppd->WaveDeviceId = wod; 00963 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 00964 if (err == DS_OK) { 00965 PIDSDRIVER drv = NULL; 00966 /* FIXME: this is a memory leak */ 00967 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200); 00968 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200); 00969 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200); 00970 00971 if (wDescription && wModule && wInterface) { 00972 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 ); 00973 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 ); 00974 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 ); 00975 00976 ppd->Description = wDescription; 00977 ppd->Module = wModule; 00978 ppd->Interface = wInterface; 00979 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 00980 if (err == DS_OK && drv) 00981 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 00982 else 00983 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 00984 found = TRUE; 00985 break; 00986 } else { 00987 WARN("no memory\n"); 00988 HeapFree(GetProcessHeap(), 0, wDescription); 00989 HeapFree(GetProcessHeap(), 0, wModule); 00990 HeapFree(GetProcessHeap(), 0, wInterface); 00991 return E_OUTOFMEMORY; 00992 } 00993 } else { 00994 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n"); 00995 return E_PROP_ID_UNSUPPORTED; 00996 } 00997 } 00998 } 00999 01000 if (found == FALSE) { 01001 ULONG wid; 01002 unsigned int widn; 01003 TRACE("Checking capture devices\n"); 01004 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 01005 widn = waveInGetNumDevs(); 01006 for (wid = 0; wid < widn; wid++) { 01007 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) { 01008 DSDRIVERDESC desc; 01009 TRACE("DSOUND_capture_guids[%d]\n", wid); 01010 ppd->WaveDeviceId = wid; 01011 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01012 if (err == DS_OK) { 01013 PIDSCDRIVER drv; 01014 /* FIXME: this is a memory leak */ 01015 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200); 01016 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200); 01017 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200); 01018 01019 if (wDescription && wModule && wInterface) { 01020 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 ); 01021 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 ); 01022 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 ); 01023 01024 ppd->Description = wDescription; 01025 ppd->Module = wModule; 01026 ppd->Interface = wInterface; 01027 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0)); 01028 if (err == DS_OK && drv) 01029 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01030 else 01031 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01032 found = TRUE; 01033 break; 01034 } else { 01035 WARN("no memory\n"); 01036 HeapFree(GetProcessHeap(), 0, wDescription); 01037 HeapFree(GetProcessHeap(), 0, wModule); 01038 HeapFree(GetProcessHeap(), 0, wInterface); 01039 return E_OUTOFMEMORY; 01040 } 01041 } else { 01042 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n"); 01043 return E_PROP_ID_UNSUPPORTED; 01044 } 01045 } 01046 } 01047 } 01048 01049 if (found == FALSE) { 01050 WARN("device not found\n"); 01051 return E_PROP_ID_UNSUPPORTED; 01052 } 01053 } 01054 01055 if (pcbReturned) { 01056 *pcbReturned = cbPropData; 01057 TRACE("*pcbReturned=%d\n", *pcbReturned); 01058 } 01059 01060 return S_OK; 01061 } 01062 01063 static HRESULT DSPROPERTY_Enumerate1( 01064 LPVOID pPropData, 01065 ULONG cbPropData, 01066 PULONG pcbReturned ) 01067 { 01068 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA) pPropData; 01069 HRESULT err; 01070 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 01071 pPropData,cbPropData,pcbReturned); 01072 01073 if (ppd) { 01074 if (ppd->Callback) { 01075 unsigned devs, wod, wid; 01076 DSDRIVERDESC desc; 01077 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA data; 01078 01079 devs = waveOutGetNumDevs(); 01080 for (wod = 0; wod < devs; ++wod) { 01081 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01082 if (err == DS_OK) { 01083 PIDSCDRIVER drv; 01084 ZeroMemory(&data, sizeof(data)); 01085 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 01086 data.WaveDeviceId = wod; 01087 data.DeviceId = DSOUND_renderer_guids[wod]; 01088 lstrcpynA(data.DescriptionA, desc.szDesc, sizeof(data.DescriptionA)); 01089 lstrcpynA(data.ModuleA, desc.szDrvname, sizeof(data.ModuleA)); 01090 01091 MultiByteToWideChar( CP_ACP, 0, data.DescriptionA, -1, data.DescriptionW, sizeof(data.DescriptionW)/sizeof(WCHAR) ); 01092 MultiByteToWideChar( CP_ACP, 0, data.ModuleA, -1, data.ModuleW, sizeof(data.ModuleW)/sizeof(WCHAR) ); 01093 01094 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 01095 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 01096 if (err == DS_OK && drv) 01097 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01098 else 01099 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01100 01101 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context); 01102 (ppd->Callback)(&data, ppd->Context); 01103 } 01104 } 01105 01106 devs = waveInGetNumDevs(); 01107 for (wid = 0; wid < devs; ++wid) { 01108 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01109 if (err == DS_OK) { 01110 PIDSCDRIVER drv; 01111 ZeroMemory(&data, sizeof(data)); 01112 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 01113 data.WaveDeviceId = wid; 01114 data.DeviceId = DSOUND_capture_guids[wid]; 01115 lstrcpynA(data.DescriptionA, desc.szDesc, sizeof(data.DescriptionA)); 01116 lstrcpynA(data.ModuleA, desc.szDrvname, sizeof(data.ModuleA)); 01117 01118 MultiByteToWideChar( CP_ACP, 0, data.DescriptionA, -1, data.DescriptionW, sizeof(data.DescriptionW)/sizeof(WCHAR) ); 01119 MultiByteToWideChar( CP_ACP, 0, data.ModuleA, -1, data.ModuleW, sizeof(data.ModuleW)/sizeof(WCHAR) ); 01120 01121 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 01122 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 01123 if (err == DS_OK && drv) 01124 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01125 else 01126 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01127 01128 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context); 01129 (ppd->Callback)(&data, ppd->Context); 01130 } 01131 } 01132 01133 return S_OK; 01134 } 01135 } 01136 01137 if (pcbReturned) { 01138 *pcbReturned = 0; 01139 FIXME("*pcbReturned=%d\n", *pcbReturned); 01140 } 01141 01142 return E_PROP_ID_UNSUPPORTED; 01143 } 01144 01145 static HRESULT DSPROPERTY_EnumerateA( 01146 LPVOID pPropData, 01147 ULONG cbPropData, 01148 PULONG pcbReturned ) 01149 { 01150 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA ppd = pPropData; 01151 HRESULT err; 01152 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 01153 pPropData,cbPropData,pcbReturned); 01154 01155 if (ppd) { 01156 if (ppd->Callback) { 01157 unsigned devs, wod, wid; 01158 DSDRIVERDESC desc; 01159 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA data; 01160 01161 devs = waveOutGetNumDevs(); 01162 for (wod = 0; wod < devs; ++wod) { 01163 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01164 if (err == DS_OK) { 01165 DWORD size; 01166 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDEVICEINTERFACESIZE,(DWORD_PTR)&size,0)); 01167 if (err == DS_OK) { 01168 WCHAR * nameW = HeapAlloc(GetProcessHeap(),0,size); 01169 if (nameW) { 01170 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDEVICEINTERFACE,(DWORD_PTR)nameW,size)); 01171 if (err == DS_OK) { 01172 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,size/sizeof(WCHAR)); 01173 if (szInterface) { 01174 PIDSCDRIVER drv; 01175 ZeroMemory(&data, sizeof(data)); 01176 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 01177 data.WaveDeviceId = wod; 01178 data.DeviceId = DSOUND_renderer_guids[wod]; 01179 data.Description = desc.szDesc; 01180 data.Module = desc.szDrvname; 01181 WideCharToMultiByte( CP_ACP, 0, nameW, size/sizeof(WCHAR), szInterface, size/sizeof(WCHAR), NULL, NULL ); 01182 data.Interface = szInterface; 01183 01184 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 01185 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 01186 if (err == DS_OK && drv) 01187 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01188 else 01189 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01190 01191 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context); 01192 (ppd->Callback)(&data, ppd->Context); 01193 } 01194 HeapFree(GetProcessHeap(),0,szInterface); 01195 } 01196 } 01197 HeapFree(GetProcessHeap(),0,nameW); 01198 } 01199 } 01200 } 01201 01202 devs = waveInGetNumDevs(); 01203 for (wid = 0; wid < devs; ++wid) { 01204 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01205 if (err == DS_OK) { 01206 DWORD size; 01207 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDEVICEINTERFACESIZE,(DWORD_PTR)&size,0)); 01208 if (err == DS_OK) { 01209 WCHAR * nameW = HeapAlloc(GetProcessHeap(),0,size); 01210 if (nameW) { 01211 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDEVICEINTERFACE,(DWORD_PTR)nameW,size)); 01212 if (err == DS_OK) { 01213 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,size/sizeof(WCHAR)); 01214 if (szInterface) { 01215 PIDSCDRIVER drv; 01216 ZeroMemory(&data, sizeof(data)); 01217 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 01218 data.WaveDeviceId = wid; 01219 data.DeviceId = DSOUND_capture_guids[wid]; 01220 data.Description = desc.szDesc; 01221 data.Module = desc.szDrvname; 01222 WideCharToMultiByte( CP_ACP, 0, nameW, size/sizeof(WCHAR), szInterface, size/sizeof(WCHAR), NULL, NULL ); 01223 data.Interface = szInterface; 01224 01225 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 01226 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 01227 if (err == DS_OK && drv) 01228 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01229 else 01230 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01231 01232 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context); 01233 (ppd->Callback)(&data, ppd->Context); 01234 } 01235 HeapFree(GetProcessHeap(),0,szInterface); 01236 } 01237 } 01238 HeapFree(GetProcessHeap(),0,nameW); 01239 } 01240 } 01241 } 01242 01243 return S_OK; 01244 } 01245 } 01246 01247 if (pcbReturned) { 01248 *pcbReturned = 0; 01249 FIXME("*pcbReturned=%d\n", *pcbReturned); 01250 } 01251 01252 return E_PROP_ID_UNSUPPORTED; 01253 } 01254 01255 static HRESULT DSPROPERTY_EnumerateW( 01256 LPVOID pPropData, 01257 ULONG cbPropData, 01258 PULONG pcbReturned ) 01259 { 01260 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData; 01261 HRESULT err; 01262 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 01263 pPropData,cbPropData,pcbReturned); 01264 01265 if (ppd) { 01266 if (ppd->Callback) { 01267 unsigned devs, wod, wid; 01268 DSDRIVERDESC desc; 01269 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data; 01270 01271 devs = waveOutGetNumDevs(); 01272 for (wod = 0; wod < devs; ++wod) { 01273 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01274 if (err == DS_OK) { 01275 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200); 01276 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200); 01277 if (wDescription && wModule) { 01278 DWORD size; 01279 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0)); 01280 if (err == DS_OK) { 01281 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,size); 01282 if (wInterface) { 01283 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)wInterface, size)); 01284 if (err == DS_OK) { 01285 PIDSCDRIVER drv; 01286 ZeroMemory(&data, sizeof(data)); 01287 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER; 01288 data.WaveDeviceId = wod; 01289 data.DeviceId = DSOUND_renderer_guids[wod]; 01290 01291 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 ); 01292 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 ); 01293 01294 data.Description = wDescription; 01295 data.Module = wModule; 01296 data.Interface = wInterface; 01297 01298 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 01299 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 01300 if (err == DS_OK && drv) 01301 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01302 else 01303 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01304 01305 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context); 01306 (ppd->Callback)(&data, ppd->Context); 01307 } 01308 } 01309 HeapFree(GetProcessHeap(),0,wInterface); 01310 } 01311 } 01312 HeapFree(GetProcessHeap(),0,wDescription); 01313 HeapFree(GetProcessHeap(),0,wModule); 01314 } 01315 } 01316 01317 devs = waveInGetNumDevs(); 01318 for (wid = 0; wid < devs; ++wid) { 01319 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0)); 01320 if (err == DS_OK) { 01321 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200); 01322 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200); 01323 if (wDescription && wModule) { 01324 DWORD size; 01325 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0)); 01326 if (err == DS_OK) { 01327 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,size); 01328 if (wInterface) { 01329 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)wInterface, size)); 01330 if (err == DS_OK) { 01331 PIDSCDRIVER drv; 01332 ZeroMemory(&data, sizeof(data)); 01333 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE; 01334 data.WaveDeviceId = wid; 01335 data.DeviceId = DSOUND_capture_guids[wid]; 01336 01337 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 ); 01338 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 ); 01339 01340 data.Description = wDescription; 01341 data.Module = wModule; 01342 data.Interface = wInterface; 01343 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED; 01344 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0)); 01345 if (err == DS_OK && drv) 01346 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD; 01347 else 01348 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n"); 01349 01350 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context); 01351 (ppd->Callback)(&data, ppd->Context); 01352 } 01353 } 01354 HeapFree(GetProcessHeap(),0,wInterface); 01355 } 01356 } 01357 HeapFree(GetProcessHeap(),0,wDescription); 01358 HeapFree(GetProcessHeap(),0,wModule); 01359 } 01360 } 01361 01362 return S_OK; 01363 } 01364 } 01365 01366 if (pcbReturned) { 01367 *pcbReturned = 0; 01368 FIXME("*pcbReturned=%d\n", *pcbReturned); 01369 } 01370 01371 return E_PROP_ID_UNSUPPORTED; 01372 } 01373 01374 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get( 01375 LPKSPROPERTYSET iface, 01376 REFGUID guidPropSet, 01377 ULONG dwPropID, 01378 LPVOID pInstanceData, 01379 ULONG cbInstanceData, 01380 LPVOID pPropData, 01381 ULONG cbPropData, 01382 PULONG pcbReturned ) 01383 { 01384 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; 01385 TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n", 01386 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned); 01387 01388 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) { 01389 switch (dwPropID) { 01390 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A: 01391 return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned); 01392 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1: 01393 return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned); 01394 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1: 01395 return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned); 01396 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W: 01397 return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned); 01398 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A: 01399 return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned); 01400 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W: 01401 return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned); 01402 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A: 01403 return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned); 01404 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W: 01405 return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned); 01406 default: 01407 FIXME("unsupported ID: %d\n",dwPropID); 01408 break; 01409 } 01410 } else { 01411 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet)); 01412 } 01413 01414 if (pcbReturned) { 01415 *pcbReturned = 0; 01416 FIXME("*pcbReturned=%d\n", *pcbReturned); 01417 } 01418 01419 return E_PROP_ID_UNSUPPORTED; 01420 } 01421 01422 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set( 01423 LPKSPROPERTYSET iface, 01424 REFGUID guidPropSet, 01425 ULONG dwPropID, 01426 LPVOID pInstanceData, 01427 ULONG cbInstanceData, 01428 LPVOID pPropData, 01429 ULONG cbPropData ) 01430 { 01431 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; 01432 01433 FIXME("(%p,%s,%d,%p,%d,%p,%d), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData); 01434 return E_PROP_ID_UNSUPPORTED; 01435 } 01436 01437 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport( 01438 LPKSPROPERTYSET iface, 01439 REFGUID guidPropSet, 01440 ULONG dwPropID, 01441 PULONG pTypeSupport ) 01442 { 01443 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface; 01444 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport); 01445 01446 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) { 01447 switch (dwPropID) { 01448 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A: 01449 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01450 return S_OK; 01451 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1: 01452 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01453 return S_OK; 01454 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1: 01455 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01456 return S_OK; 01457 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W: 01458 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01459 return S_OK; 01460 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A: 01461 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01462 return S_OK; 01463 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W: 01464 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01465 return S_OK; 01466 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A: 01467 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01468 return S_OK; 01469 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W: 01470 *pTypeSupport = KSPROPERTY_SUPPORT_GET; 01471 return S_OK; 01472 default: 01473 FIXME("unsupported ID: %d\n",dwPropID); 01474 break; 01475 } 01476 } else { 01477 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet)); 01478 } 01479 01480 return E_PROP_ID_UNSUPPORTED; 01481 } 01482 01483 static const IKsPropertySetVtbl ikspvt = { 01484 IKsPrivatePropertySetImpl_QueryInterface, 01485 IKsPrivatePropertySetImpl_AddRef, 01486 IKsPrivatePropertySetImpl_Release, 01487 IKsPrivatePropertySetImpl_Get, 01488 IKsPrivatePropertySetImpl_Set, 01489 IKsPrivatePropertySetImpl_QuerySupport 01490 }; 01491 01492 HRESULT IKsPrivatePropertySetImpl_Create( 01493 REFIID riid, 01494 IKsPrivatePropertySetImpl **piks) 01495 { 01496 IKsPrivatePropertySetImpl *iks; 01497 TRACE("(%s, %p)\n", debugstr_guid(riid), piks); 01498 01499 if (!IsEqualIID(riid, &IID_IUnknown) && 01500 !IsEqualIID(riid, &IID_IKsPropertySet)) { 01501 *piks = 0; 01502 return E_NOINTERFACE; 01503 } 01504 01505 iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks)); 01506 iks->ref = 1; 01507 iks->lpVtbl = &ikspvt; 01508 01509 *piks = iks; 01510 return S_OK; 01511 }
Generated on Sat May 26 2012 04:20:13 for ReactOS by
1.7.6.1
