- fix some prototypes, remove dxroslayer from dsound
[reactos.git] / reactos / dll / directx / dsound / propset.c
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000-2002 TransGaming Technologies, Inc.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "mmsystem.h"
29 #include "winternl.h"
30 #include "winnls.h"
31 #include "vfwmsgs.h"
32 #include "mmddk.h"
33 #include "wine/debug.h"
34 #include "dsound.h"
35 #include "dsdriver.h"
36 #include "dsound_private.h"
37 #include "dsconf.h"
38
39 #ifdef NONAMELESSSTRUCT
40 # define S(x) (x).s
41 #else
42 # define S(x) (x)
43 #endif
44
45 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
46
47
48 /*******************************************************************************
49 * IKsBufferPropertySet
50 */
51
52 /* IUnknown methods */
53 static HRESULT WINAPI IKsBufferPropertySetImpl_QueryInterface(
54 LPKSPROPERTYSET iface,
55 REFIID riid,
56 LPVOID *ppobj )
57 {
58 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
59 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
60
61 return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb, riid, ppobj);
62 }
63
64 static ULONG WINAPI IKsBufferPropertySetImpl_AddRef(LPKSPROPERTYSET iface)
65 {
66 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
67 ULONG ref = InterlockedIncrement(&(This->ref));
68 TRACE("(%p) ref was %d\n", This, ref - 1);
69 return ref;
70 }
71
72 static ULONG WINAPI IKsBufferPropertySetImpl_Release(LPKSPROPERTYSET iface)
73 {
74 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
75 ULONG ref = InterlockedDecrement(&(This->ref));
76 TRACE("(%p) ref was %d\n", This, ref + 1);
77
78 if (!ref) {
79 This->dsb->iks = 0;
80 IDirectSoundBuffer_Release((LPDIRECTSOUND3DBUFFER)This->dsb);
81 HeapFree(GetProcessHeap(), 0, This);
82 TRACE("(%p) released\n", This);
83 }
84 return ref;
85 }
86
87 static HRESULT WINAPI IKsBufferPropertySetImpl_Get(
88 LPKSPROPERTYSET iface,
89 REFGUID guidPropSet,
90 ULONG dwPropID,
91 LPVOID pInstanceData,
92 ULONG cbInstanceData,
93 LPVOID pPropData,
94 ULONG cbPropData,
95 PULONG pcbReturned )
96 {
97 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
98 PIDSDRIVERPROPERTYSET ps;
99 TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
100 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
101
102 if (This->dsb->hwbuf) {
103 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
104
105 if (ps) {
106 DSPROPERTY prop;
107 HRESULT hres;
108
109 S(prop).Set = *guidPropSet;
110 S(prop).Id = dwPropID;
111 S(prop).Flags = 0; /* unused */
112 S(prop).InstanceId = (ULONG)This->dsb->device;
113
114 hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
115
116 IDsDriverPropertySet_Release(ps);
117
118 return hres;
119 }
120 }
121
122 return E_PROP_ID_UNSUPPORTED;
123 }
124
125 static HRESULT WINAPI IKsBufferPropertySetImpl_Set(
126 LPKSPROPERTYSET iface,
127 REFGUID guidPropSet,
128 ULONG dwPropID,
129 LPVOID pInstanceData,
130 ULONG cbInstanceData,
131 LPVOID pPropData,
132 ULONG cbPropData )
133 {
134 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
135 PIDSDRIVERPROPERTYSET ps;
136 TRACE("(%p,%s,%d,%p,%d,%p,%d)\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
137
138 if (This->dsb->hwbuf) {
139 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
140
141 if (ps) {
142 DSPROPERTY prop;
143 HRESULT hres;
144
145 S(prop).Set = *guidPropSet;
146 S(prop).Id = dwPropID;
147 S(prop).Flags = 0; /* unused */
148 S(prop).InstanceId = (ULONG)This->dsb->device;
149 hres = IDsDriverPropertySet_Set(ps,&prop,pInstanceData,cbInstanceData,pPropData,cbPropData);
150
151 IDsDriverPropertySet_Release(ps);
152
153 return hres;
154 }
155 }
156
157 return E_PROP_ID_UNSUPPORTED;
158 }
159
160 static HRESULT WINAPI IKsBufferPropertySetImpl_QuerySupport(
161 LPKSPROPERTYSET iface,
162 REFGUID guidPropSet,
163 ULONG dwPropID,
164 PULONG pTypeSupport )
165 {
166 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
167 PIDSDRIVERPROPERTYSET ps;
168 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
169
170 if (This->dsb->hwbuf) {
171 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
172
173 if (ps) {
174 HRESULT hres;
175
176 hres = IDsDriverPropertySet_QuerySupport(ps,guidPropSet, dwPropID,pTypeSupport);
177
178 IDsDriverPropertySet_Release(ps);
179
180 return hres;
181 }
182 }
183
184 return E_PROP_ID_UNSUPPORTED;
185 }
186
187 static const IKsPropertySetVtbl iksbvt = {
188 IKsBufferPropertySetImpl_QueryInterface,
189 IKsBufferPropertySetImpl_AddRef,
190 IKsBufferPropertySetImpl_Release,
191 IKsBufferPropertySetImpl_Get,
192 IKsBufferPropertySetImpl_Set,
193 IKsBufferPropertySetImpl_QuerySupport
194 };
195
196 HRESULT IKsBufferPropertySetImpl_Create(
197 IDirectSoundBufferImpl *dsb,
198 IKsBufferPropertySetImpl **piks)
199 {
200 IKsBufferPropertySetImpl *iks;
201 TRACE("(%p,%p)\n",dsb,piks);
202 *piks = NULL;
203
204 iks = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*iks));
205 if (iks == 0) {
206 WARN("out of memory\n");
207 *piks = NULL;
208 return DSERR_OUTOFMEMORY;
209 }
210
211 iks->ref = 0;
212 iks->dsb = dsb;
213 dsb->iks = iks;
214 iks->lpVtbl = &iksbvt;
215
216 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)dsb);
217
218 *piks = iks;
219 return S_OK;
220 }
221
222 HRESULT IKsBufferPropertySetImpl_Destroy(
223 IKsBufferPropertySetImpl *piks)
224 {
225 TRACE("(%p)\n",piks);
226
227 while (IKsBufferPropertySetImpl_Release((LPKSPROPERTYSET)piks) > 0);
228
229 return S_OK;
230 }
231
232 /*******************************************************************************
233 * IKsPrivatePropertySet
234 */
235
236 /* IUnknown methods */
237 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
238 LPKSPROPERTYSET iface,
239 REFIID riid,
240 LPVOID *ppobj )
241 {
242 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
243 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
244
245 if (IsEqualIID(riid, &IID_IUnknown) ||
246 IsEqualIID(riid, &IID_IKsPropertySet)) {
247 *ppobj = iface;
248 IUnknown_AddRef(iface);
249 return S_OK;
250 }
251 *ppobj = NULL;
252 return E_NOINTERFACE;
253 }
254
255 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface)
256 {
257 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
258 ULONG ref = InterlockedIncrement(&(This->ref));
259 TRACE("(%p) ref was %d\n", This, ref - 1);
260 return ref;
261 }
262
263 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
264 {
265 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
266 ULONG ref = InterlockedDecrement(&(This->ref));
267 TRACE("(%p) ref was %d\n", This, ref + 1);
268
269 if (!ref) {
270 HeapFree(GetProcessHeap(), 0, This);
271 TRACE("(%p) released\n", This);
272 }
273 return ref;
274 }
275
276 static HRESULT DSPROPERTY_WaveDeviceMappingA(
277 LPVOID pPropData,
278 ULONG cbPropData,
279 PULONG pcbReturned )
280 {
281 HRESULT hr = DSERR_INVALIDPARAM;
282 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA ppd;
283 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
284 pPropData,cbPropData,pcbReturned);
285
286 ppd = pPropData;
287
288 if (!ppd) {
289 WARN("invalid parameter: pPropData\n");
290 return DSERR_INVALIDPARAM;
291 }
292
293 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
294 ULONG wod;
295 unsigned int wodn;
296 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
297 wodn = waveOutGetNumDevs();
298 for (wod = 0; wod < wodn; wod++) {
299 WAVEOUTCAPSA capsA;
300 MMRESULT res;
301 res = waveOutGetDevCapsA(wod, &capsA, sizeof(capsA));
302 if (res == MMSYSERR_NOERROR) {
303 if (lstrcmpA(capsA.szPname, ppd->DeviceName) == 0) {
304 ppd->DeviceId = DSOUND_renderer_guids[wod];
305 hr = DS_OK;
306 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
307 ppd->DeviceName);
308 break;
309 }
310 }
311 }
312 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
313 ULONG wid;
314 unsigned int widn;
315 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
316 widn = waveInGetNumDevs();
317 for (wid = 0; wid < widn; wid++) {
318 WAVEINCAPSA capsA;
319 MMRESULT res;
320 res = waveInGetDevCapsA(wid, &capsA, sizeof(capsA));
321 if (res == MMSYSERR_NOERROR) {
322 if (lstrcmpA(capsA.szPname, ppd->DeviceName) == 0) {
323 ppd->DeviceId = DSOUND_capture_guids[wid];
324 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
325 ppd->DeviceName);
326 hr = DS_OK;
327 break;
328 }
329 }
330 }
331 }
332
333 if (pcbReturned)
334 *pcbReturned = cbPropData;
335
336 return hr;
337 }
338
339 static HRESULT DSPROPERTY_WaveDeviceMappingW(
340 LPVOID pPropData,
341 ULONG cbPropData,
342 PULONG pcbReturned )
343 {
344 HRESULT hr = DSERR_INVALIDPARAM;
345 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
346 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
347 pPropData,cbPropData,pcbReturned);
348
349 ppd = pPropData;
350
351 if (!ppd) {
352 WARN("invalid parameter: pPropData\n");
353 return DSERR_INVALIDPARAM;
354 }
355
356 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
357 ULONG wod;
358 unsigned int wodn;
359 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
360 wodn = waveOutGetNumDevs();
361 for (wod = 0; wod < wodn; wod++) {
362 WAVEOUTCAPSW capsW;
363 MMRESULT res;
364 res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW));
365 if (res == MMSYSERR_NOERROR) {
366 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
367 ppd->DeviceId = DSOUND_renderer_guids[wod];
368 hr = DS_OK;
369 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
370 debugstr_w(ppd->DeviceName));
371 break;
372 }
373 }
374 }
375 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
376 ULONG wid;
377 unsigned int widn;
378 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
379 widn = waveInGetNumDevs();
380 for (wid = 0; wid < widn; wid++) {
381 WAVEINCAPSW capsW;
382 MMRESULT res;
383 res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW));
384 if (res == MMSYSERR_NOERROR) {
385 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
386 ppd->DeviceId = DSOUND_capture_guids[wid];
387 hr = DS_OK;
388 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
389 debugstr_w(ppd->DeviceName));
390 break;
391 }
392 }
393 }
394 }
395
396 if (pcbReturned)
397 *pcbReturned = cbPropData;
398
399 return hr;
400 }
401
402 static HRESULT DSPROPERTY_Description1(
403 LPVOID pPropData,
404 ULONG cbPropData,
405 PULONG pcbReturned )
406 {
407 HRESULT err;
408 GUID guid, dev_guid;
409 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA ppd;
410 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
411 pPropData,cbPropData,pcbReturned);
412
413 ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA) pPropData;
414
415 if (!ppd) {
416 WARN("invalid parameter: pPropData\n");
417 return DSERR_INVALIDPARAM;
418 }
419
420 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
421 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
422 /* default device of type specified by ppd->DataFlow */
423 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
424 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
425 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
426 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
427 } else {
428 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
429 }
430 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n",
431 pPropData,cbPropData,pcbReturned);
432 return E_PROP_ID_UNSUPPORTED;
433 }
434
435 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
436 GetDeviceID(&ppd->DeviceId, &dev_guid);
437
438 if ( IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultPlayback) ||
439 IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultVoicePlayback) ) {
440 ULONG wod;
441 unsigned int wodn;
442 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
443 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
444 wodn = waveOutGetNumDevs();
445 for (wod = 0; wod < wodn; wod++) {
446 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) {
447 DSDRIVERDESC desc;
448 ppd->WaveDeviceId = wod;
449 ppd->Devnode = wod;
450 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
451 if (err == DS_OK) {
452 PIDSDRIVER drv = NULL;
453 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
454 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
455 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
456 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
457 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
458 if (err == DS_OK && drv)
459 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
460 else
461 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
462 break;
463 } else {
464 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
465 return E_PROP_ID_UNSUPPORTED;
466 }
467 }
468 }
469 } else if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
470 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
471 ULONG wid;
472 unsigned int widn;
473 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
474 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
475 widn = waveInGetNumDevs();
476 for (wid = 0; wid < widn; wid++) {
477 if (IsEqualGUID( &dev_guid, &guid) ) {
478 DSDRIVERDESC desc;
479 ppd->WaveDeviceId = wid;
480 ppd->Devnode = wid;
481 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
482 if (err == DS_OK) {
483 PIDSCDRIVER drv;
484 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
485 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
486 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
487 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
488 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
489 if (err == DS_OK && drv)
490 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
491 else
492 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
493 break;
494 } else {
495 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
496 return E_PROP_ID_UNSUPPORTED;
497 }
498 }
499 }
500 } else {
501 BOOL found = FALSE;
502 ULONG wod;
503 unsigned int wodn;
504 /* given specific device so try the render devices first */
505 wodn = waveOutGetNumDevs();
506 for (wod = 0; wod < wodn; wod++) {
507 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) {
508 DSDRIVERDESC desc;
509 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
510 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
511 ppd->WaveDeviceId = wod;
512 ppd->Devnode = wod;
513 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
514 if (err == DS_OK) {
515 PIDSDRIVER drv = NULL;
516 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
517 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
518 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
519 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
520 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
521 if (err == DS_OK && drv)
522 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
523 else
524 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
525 found = TRUE;
526 break;
527 } else {
528 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
529 return E_PROP_ID_UNSUPPORTED;
530 }
531 }
532 }
533
534 if (found == FALSE) {
535 ULONG wid;
536 unsigned int widn;
537 /* given specific device so try the capture devices next */
538 widn = waveInGetNumDevs();
539 for (wid = 0; wid < widn; wid++) {
540 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_capture_guids[wid] ) ) {
541 DSDRIVERDESC desc;
542 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
543 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
544 ppd->WaveDeviceId = wid;
545 ppd->Devnode = wid;
546 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
547 if (err == DS_OK) {
548 PIDSDRIVER drv = NULL;
549 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
550 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
551 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
552 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
553 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
554 if (err == DS_OK && drv)
555 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
556 else
557 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
558 found = TRUE;
559 break;
560 } else {
561 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
562 return E_PROP_ID_UNSUPPORTED;
563 }
564 }
565 }
566
567 if (found == FALSE) {
568 WARN("device not found\n");
569 return E_PROP_ID_UNSUPPORTED;
570 }
571 }
572 }
573
574 if (pcbReturned) {
575 *pcbReturned = cbPropData;
576 TRACE("*pcbReturned=%d\n", *pcbReturned);
577 }
578
579 return S_OK;
580 }
581
582 static HRESULT DSPROPERTY_DescriptionA(
583 LPVOID pPropData,
584 ULONG cbPropData,
585 PULONG pcbReturned )
586 {
587 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA ppd = pPropData;
588 HRESULT err;
589 GUID dev_guid;
590 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
591 pPropData,cbPropData,pcbReturned);
592
593 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
594 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
595 /* default device of type specified by ppd->DataFlow */
596 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
597 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
598 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
599 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
600 } else {
601 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
602 }
603 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n",
604 pPropData,cbPropData,pcbReturned);
605 return E_PROP_ID_UNSUPPORTED;
606 }
607
608 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
609 GetDeviceID(&ppd->DeviceId, &dev_guid);
610
611 if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
612 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
613 ULONG wod;
614 unsigned int wodn;
615 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) )
616 TRACE("DSDEVID_DefaultPlayback\n");
617 else
618 TRACE("DSDEVID_DefaultVoicePlayback\n");
619 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
620 wodn = waveOutGetNumDevs();
621 for (wod = 0; wod < wodn; wod++) {
622 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) {
623 DSDRIVERDESC desc;
624 ppd->WaveDeviceId = wod;
625 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
626 if (err == DS_OK) {
627 PIDSDRIVER drv = NULL;
628 /* FIXME: this is a memory leak */
629 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
630 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
631 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
632
633 if (szDescription && szModule && szInterface) {
634 strcpy(szDescription, desc.szDesc);
635 strcpy(szModule, desc.szDrvname);
636 strcpy(szInterface, "Interface");
637
638 ppd->Description = szDescription;
639 ppd->Module = szModule;
640 ppd->Interface = szInterface;
641 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
642 if (err == DS_OK && drv)
643 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
644 else
645 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
646 break;
647 } else {
648 WARN("no memory\n");
649 HeapFree(GetProcessHeap(), 0, szDescription);
650 HeapFree(GetProcessHeap(), 0, szModule);
651 HeapFree(GetProcessHeap(), 0, szInterface);
652 return E_OUTOFMEMORY;
653 }
654 } else {
655 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
656 return E_PROP_ID_UNSUPPORTED;
657 }
658 }
659 }
660 } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
661 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
662 ULONG wid;
663 unsigned int widn;
664 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) )
665 TRACE("DSDEVID_DefaultCapture\n");
666 else
667 TRACE("DSDEVID_DefaultVoiceCapture\n");
668 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
669 widn = waveInGetNumDevs();
670 for (wid = 0; wid < widn; wid++) {
671 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) {
672 DSDRIVERDESC desc;
673 ppd->WaveDeviceId = wid;
674 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
675 if (err == DS_OK) {
676 PIDSCDRIVER drv;
677 /* FIXME: this is a memory leak */
678 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
679 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
680 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
681
682 if (szDescription && szModule && szInterface) {
683 strcpy(szDescription, desc.szDesc);
684 strcpy(szModule, desc.szDrvname);
685 strcpy(szInterface, "Interface");
686
687 ppd->Description = szDescription;
688 ppd->Module = szModule;
689 ppd->Interface = szInterface;
690 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
691 if (err == DS_OK && drv)
692 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
693 else
694 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
695 break;
696 } else {
697 WARN("no memory\n");
698 HeapFree(GetProcessHeap(), 0, szDescription);
699 HeapFree(GetProcessHeap(), 0, szModule);
700 HeapFree(GetProcessHeap(), 0, szInterface);
701 return E_OUTOFMEMORY;
702 }
703 } else {
704 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
705 return E_PROP_ID_UNSUPPORTED;
706 }
707 }
708 }
709 } else {
710 BOOL found = FALSE;
711 ULONG wod;
712 unsigned int wodn;
713 /* given specific device so try the render devices first */
714 TRACE("Checking renderer devices\n");
715 wodn = waveOutGetNumDevs();
716 for (wod = 0; wod < wodn; wod++) {
717 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) {
718 DSDRIVERDESC desc;
719 TRACE("DSOUND_renderer_guids[%d]\n", wod);
720 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
721 ppd->WaveDeviceId = wod;
722 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
723 if (err == DS_OK) {
724 PIDSDRIVER drv = NULL;
725 /* FIXME: this is a memory leak */
726 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
727 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
728 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
729
730 if (szDescription && szModule && szInterface) {
731 strcpy(szDescription, desc.szDesc);
732 strcpy(szModule, desc.szDrvname);
733 strcpy(szInterface, "Interface");
734
735 ppd->Description = szDescription;
736 ppd->Module = szModule;
737 ppd->Interface = szInterface;
738 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
739 if (err == DS_OK && drv)
740 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
741 else
742 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
743 found = TRUE;
744 break;
745 } else {
746 WARN("no memory\n");
747 HeapFree(GetProcessHeap(), 0, szDescription);
748 HeapFree(GetProcessHeap(), 0, szModule);
749 HeapFree(GetProcessHeap(), 0, szInterface);
750 return E_OUTOFMEMORY;
751 }
752 } else {
753 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
754 return E_PROP_ID_UNSUPPORTED;
755 }
756 }
757 }
758
759 if (found == FALSE) {
760 ULONG wid;
761 unsigned int widn;
762 TRACE("Checking capture devices\n");
763 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
764 widn = waveInGetNumDevs();
765 for (wid = 0; wid < widn; wid++) {
766 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_capture_guids[wid] ) ) {
767 DSDRIVERDESC desc;
768 TRACE("DSOUND_capture_guids[%d]\n", wid);
769 ppd->WaveDeviceId = wid;
770 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
771 if (err == DS_OK) {
772 PIDSCDRIVER drv;
773 /* FIXME: this is a memory leak */
774 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
775 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
776 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
777
778 if (szDescription && szModule && szInterface) {
779 strcpy(szDescription, desc.szDesc);
780 strcpy(szModule, desc.szDrvname);
781 strcpy(szInterface, "Interface");
782
783 ppd->Description = szDescription;
784 ppd->Module = szModule;
785 ppd->Interface = szInterface;
786 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
787 if (err == DS_OK && drv)
788 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
789 else
790 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
791 found = TRUE;
792 break;
793 } else {
794 WARN("no memory\n");
795 HeapFree(GetProcessHeap(), 0, szDescription);
796 HeapFree(GetProcessHeap(), 0, szModule);
797 HeapFree(GetProcessHeap(), 0, szInterface);
798 return E_OUTOFMEMORY;
799 }
800 } else {
801 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
802 return E_PROP_ID_UNSUPPORTED;
803 }
804 }
805 }
806 }
807
808 if (found == FALSE) {
809 WARN("device not found\n");
810 return E_PROP_ID_UNSUPPORTED;
811 }
812 }
813
814 if (pcbReturned) {
815 *pcbReturned = cbPropData;
816 TRACE("*pcbReturned=%d\n", *pcbReturned);
817 }
818
819 return S_OK;
820 }
821
822 static HRESULT DSPROPERTY_DescriptionW(
823 LPVOID pPropData,
824 ULONG cbPropData,
825 PULONG pcbReturned )
826 {
827 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData;
828 HRESULT err;
829 GUID dev_guid;
830 TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
831 pPropData,cbPropData,pcbReturned);
832
833 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
834 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
835 /* default device of type specified by ppd->DataFlow */
836 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
837 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
838 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
839 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
840 } else {
841 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
842 }
843 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n",
844 pPropData,cbPropData,pcbReturned);
845 return E_PROP_ID_UNSUPPORTED;
846 }
847
848 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
849 GetDeviceID(&ppd->DeviceId, &dev_guid);
850
851 if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
852 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
853 ULONG wod;
854 unsigned int wodn;
855 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) )
856 TRACE("DSDEVID_DefaultPlayback\n");
857 else
858 TRACE("DSDEVID_DefaultVoicePlayback\n");
859 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
860 wodn = waveOutGetNumDevs();
861 for (wod = 0; wod < wodn; wod++) {
862 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) {
863 DSDRIVERDESC desc;
864 TRACE("DSOUND_renderer_guids[%d]\n", wod);
865 ppd->WaveDeviceId = wod;
866 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
867 if (err == DS_OK) {
868 PIDSDRIVER drv = NULL;
869 /* FIXME: this is a memory leak */
870 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
871 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
872 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
873
874 if (wDescription && wModule && wInterface) {
875 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
876 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
877 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
878
879 ppd->Description = wDescription;
880 ppd->Module = wModule;
881 ppd->Interface = wInterface;
882 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
883 if (err == DS_OK && drv)
884 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
885 else
886 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
887 break;
888 } else {
889 WARN("no memory\n");
890 HeapFree(GetProcessHeap(), 0, wDescription);
891 HeapFree(GetProcessHeap(), 0, wModule);
892 HeapFree(GetProcessHeap(), 0, wInterface);
893 return E_OUTOFMEMORY;
894 }
895 } else {
896 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
897 return E_PROP_ID_UNSUPPORTED;
898 }
899 }
900 }
901 } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
902 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
903 ULONG wid;
904 unsigned int widn;
905 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture))
906 TRACE("DSDEVID_DefaultCapture\n");
907 else
908 TRACE("DSDEVID_DefaultVoiceCapture\n");
909 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
910 widn = waveInGetNumDevs();
911 for (wid = 0; wid < widn; wid++) {
912 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) {
913 DSDRIVERDESC desc;
914 ppd->WaveDeviceId = wid;
915 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
916 if (err == DS_OK) {
917 PIDSCDRIVER drv;
918 /* FIXME: this is a memory leak */
919 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
920 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
921 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
922
923 if (wDescription && wModule && wInterface) {
924 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
925 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
926 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
927
928 ppd->Description = wDescription;
929 ppd->Module = wModule;
930 ppd->Interface = wInterface;
931 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
932 if (err == DS_OK && drv)
933 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
934 else
935 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
936 break;
937 } else {
938 WARN("no memory\n");
939 HeapFree(GetProcessHeap(), 0, wDescription);
940 HeapFree(GetProcessHeap(), 0, wModule);
941 HeapFree(GetProcessHeap(), 0, wInterface);
942 return E_OUTOFMEMORY;
943 }
944 } else {
945 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
946 return E_PROP_ID_UNSUPPORTED;
947 }
948 }
949 }
950 } else {
951 BOOL found = FALSE;
952 ULONG wod;
953 unsigned int wodn;
954 TRACE("Checking renderer devices\n");
955 /* given specific device so try the render devices first */
956 wodn = waveOutGetNumDevs();
957 for (wod = 0; wod < wodn; wod++) {
958 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) {
959 DSDRIVERDESC desc;
960 TRACE("DSOUND_renderer_guids[%d]\n", wod);
961 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
962 ppd->WaveDeviceId = wod;
963 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
964 if (err == DS_OK) {
965 PIDSDRIVER drv = NULL;
966 /* FIXME: this is a memory leak */
967 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
968 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
969 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
970
971 if (wDescription && wModule && wInterface) {
972 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
973 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
974 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
975
976 ppd->Description = wDescription;
977 ppd->Module = wModule;
978 ppd->Interface = wInterface;
979 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
980 if (err == DS_OK && drv)
981 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
982 else
983 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
984 found = TRUE;
985 break;
986 } else {
987 WARN("no memory\n");
988 HeapFree(GetProcessHeap(), 0, wDescription);
989 HeapFree(GetProcessHeap(), 0, wModule);
990 HeapFree(GetProcessHeap(), 0, wInterface);
991 return E_OUTOFMEMORY;
992 }
993 } else {
994 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
995 return E_PROP_ID_UNSUPPORTED;
996 }
997 }
998 }
999
1000 if (found == FALSE) {
1001 ULONG wid;
1002 unsigned int widn;
1003 TRACE("Checking capture devices\n");
1004 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1005 widn = waveInGetNumDevs();
1006 for (wid = 0; wid < widn; wid++) {
1007 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) {
1008 DSDRIVERDESC desc;
1009 TRACE("DSOUND_capture_guids[%d]\n", wid);
1010 ppd->WaveDeviceId = wid;
1011 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1012 if (err == DS_OK) {
1013 PIDSCDRIVER drv;
1014 /* FIXME: this is a memory leak */
1015 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
1016 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
1017 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
1018
1019 if (wDescription && wModule && wInterface) {
1020 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
1021 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
1022 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
1023
1024 ppd->Description = wDescription;
1025 ppd->Module = wModule;
1026 ppd->Interface = wInterface;
1027 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
1028 if (err == DS_OK && drv)
1029 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1030 else
1031 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1032 found = TRUE;
1033 break;
1034 } else {
1035 WARN("no memory\n");
1036 HeapFree(GetProcessHeap(), 0, wDescription);
1037 HeapFree(GetProcessHeap(), 0, wModule);
1038 HeapFree(GetProcessHeap(), 0, wInterface);
1039 return E_OUTOFMEMORY;
1040 }
1041 } else {
1042 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
1043 return E_PROP_ID_UNSUPPORTED;
1044 }
1045 }
1046 }
1047 }
1048
1049 if (found == FALSE) {
1050 WARN("device not found\n");
1051 return E_PROP_ID_UNSUPPORTED;
1052 }
1053 }
1054
1055 if (pcbReturned) {
1056 *pcbReturned = cbPropData;
1057 TRACE("*pcbReturned=%d\n", *pcbReturned);
1058 }
1059
1060 return S_OK;
1061 }
1062
1063 static HRESULT DSPROPERTY_Enumerate1(
1064 LPVOID pPropData,
1065 ULONG cbPropData,
1066 PULONG pcbReturned )
1067 {
1068 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA) pPropData;
1069 HRESULT err;
1070 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1071 pPropData,cbPropData,pcbReturned);
1072
1073 if (ppd) {
1074 if (ppd->Callback) {
1075 unsigned devs, wod, wid;
1076 DSDRIVERDESC desc;
1077 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA data;
1078
1079 devs = waveOutGetNumDevs();
1080 for (wod = 0; wod < devs; ++wod) {
1081 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1082 if (err == DS_OK) {
1083 PIDSCDRIVER drv;
1084 ZeroMemory(&data, sizeof(data));
1085 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
1086 data.WaveDeviceId = wod;
1087 data.DeviceId = DSOUND_renderer_guids[wod];
1088 lstrcpynA(data.DescriptionA, desc.szDesc, sizeof(data.DescriptionA));
1089 lstrcpynA(data.ModuleA, desc.szDrvname, sizeof(data.ModuleA));
1090
1091 MultiByteToWideChar( CP_ACP, 0, data.DescriptionA, -1, data.DescriptionW, sizeof(data.DescriptionW)/sizeof(WCHAR) );
1092 MultiByteToWideChar( CP_ACP, 0, data.ModuleA, -1, data.ModuleW, sizeof(data.ModuleW)/sizeof(WCHAR) );
1093
1094 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1095 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1096 if (err == DS_OK && drv)
1097 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1098 else
1099 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1100
1101 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1102 (ppd->Callback)(&data, ppd->Context);
1103 }
1104 }
1105
1106 devs = waveInGetNumDevs();
1107 for (wid = 0; wid < devs; ++wid) {
1108 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1109 if (err == DS_OK) {
1110 PIDSCDRIVER drv;
1111 ZeroMemory(&data, sizeof(data));
1112 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1113 data.WaveDeviceId = wid;
1114 data.DeviceId = DSOUND_capture_guids[wid];
1115 lstrcpynA(data.DescriptionA, desc.szDesc, sizeof(data.DescriptionA));
1116 lstrcpynA(data.ModuleA, desc.szDrvname, sizeof(data.ModuleA));
1117
1118 MultiByteToWideChar( CP_ACP, 0, data.DescriptionA, -1, data.DescriptionW, sizeof(data.DescriptionW)/sizeof(WCHAR) );
1119 MultiByteToWideChar( CP_ACP, 0, data.ModuleA, -1, data.ModuleW, sizeof(data.ModuleW)/sizeof(WCHAR) );
1120
1121 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1122 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1123 if (err == DS_OK && drv)
1124 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1125 else
1126 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1127
1128 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1129 (ppd->Callback)(&data, ppd->Context);
1130 }
1131 }
1132
1133 return S_OK;
1134 }
1135 }
1136
1137 if (pcbReturned) {
1138 *pcbReturned = 0;
1139 FIXME("*pcbReturned=%d\n", *pcbReturned);
1140 }
1141
1142 return E_PROP_ID_UNSUPPORTED;
1143 }
1144
1145 static HRESULT DSPROPERTY_EnumerateA(
1146 LPVOID pPropData,
1147 ULONG cbPropData,
1148 PULONG pcbReturned )
1149 {
1150 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA ppd = pPropData;
1151 HRESULT err;
1152 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1153 pPropData,cbPropData,pcbReturned);
1154
1155 if (ppd) {
1156 if (ppd->Callback) {
1157 unsigned devs, wod, wid;
1158 DSDRIVERDESC desc;
1159 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA data;
1160
1161 devs = waveOutGetNumDevs();
1162 for (wod = 0; wod < devs; ++wod) {
1163 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1164 if (err == DS_OK) {
1165 DWORD size;
1166 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDEVICEINTERFACESIZE,(DWORD_PTR)&size,0));
1167 if (err == DS_OK) {
1168 WCHAR * nameW = HeapAlloc(GetProcessHeap(),0,size);
1169 if (nameW) {
1170 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDEVICEINTERFACE,(DWORD_PTR)nameW,size));
1171 if (err == DS_OK) {
1172 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,size/sizeof(WCHAR));
1173 if (szInterface) {
1174 PIDSCDRIVER drv;
1175 ZeroMemory(&data, sizeof(data));
1176 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
1177 data.WaveDeviceId = wod;
1178 data.DeviceId = DSOUND_renderer_guids[wod];
1179 data.Description = desc.szDesc;
1180 data.Module = desc.szDrvname;
1181 WideCharToMultiByte( CP_ACP, 0, nameW, size/sizeof(WCHAR), szInterface, size/sizeof(WCHAR), NULL, NULL );
1182 data.Interface = szInterface;
1183
1184 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1185 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1186 if (err == DS_OK && drv)
1187 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1188 else
1189 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1190
1191 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1192 (ppd->Callback)(&data, ppd->Context);
1193 }
1194 HeapFree(GetProcessHeap(),0,szInterface);
1195 }
1196 }
1197 HeapFree(GetProcessHeap(),0,nameW);
1198 }
1199 }
1200 }
1201
1202 devs = waveInGetNumDevs();
1203 for (wid = 0; wid < devs; ++wid) {
1204 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1205 if (err == DS_OK) {
1206 DWORD size;
1207 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDEVICEINTERFACESIZE,(DWORD_PTR)&size,0));
1208 if (err == DS_OK) {
1209 WCHAR * nameW = HeapAlloc(GetProcessHeap(),0,size);
1210 if (nameW) {
1211 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDEVICEINTERFACE,(DWORD_PTR)nameW,size));
1212 if (err == DS_OK) {
1213 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,size/sizeof(WCHAR));
1214 if (szInterface) {
1215 PIDSCDRIVER drv;
1216 ZeroMemory(&data, sizeof(data));
1217 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1218 data.WaveDeviceId = wid;
1219 data.DeviceId = DSOUND_capture_guids[wid];
1220 data.Description = desc.szDesc;
1221 data.Module = desc.szDrvname;
1222 WideCharToMultiByte( CP_ACP, 0, nameW, size/sizeof(WCHAR), szInterface, size/sizeof(WCHAR), NULL, NULL );
1223 data.Interface = szInterface;
1224
1225 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1226 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1227 if (err == DS_OK && drv)
1228 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1229 else
1230 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1231
1232 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1233 (ppd->Callback)(&data, ppd->Context);
1234 }
1235 HeapFree(GetProcessHeap(),0,szInterface);
1236 }
1237 }
1238 HeapFree(GetProcessHeap(),0,nameW);
1239 }
1240 }
1241 }
1242
1243 return S_OK;
1244 }
1245 }
1246
1247 if (pcbReturned) {
1248 *pcbReturned = 0;
1249 FIXME("*pcbReturned=%d\n", *pcbReturned);
1250 }
1251
1252 return E_PROP_ID_UNSUPPORTED;
1253 }
1254
1255 static HRESULT DSPROPERTY_EnumerateW(
1256 LPVOID pPropData,
1257 ULONG cbPropData,
1258 PULONG pcbReturned )
1259 {
1260 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData;
1261 HRESULT err;
1262 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1263 pPropData,cbPropData,pcbReturned);
1264
1265 if (ppd) {
1266 if (ppd->Callback) {
1267 unsigned devs, wod, wid;
1268 DSDRIVERDESC desc;
1269 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
1270
1271 devs = waveOutGetNumDevs();
1272 for (wod = 0; wod < devs; ++wod) {
1273 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1274 if (err == DS_OK) {
1275 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
1276 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
1277 if (wDescription && wModule) {
1278 DWORD size;
1279 err = mmErr(waveOutMessage(UlongToHandle(wod),DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0));
1280 if (err == DS_OK) {
1281 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,size);
1282 if (wInterface) {
1283 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)wInterface, size));
1284 if (err == DS_OK) {
1285 PIDSCDRIVER drv;
1286 ZeroMemory(&data, sizeof(data));
1287 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
1288 data.WaveDeviceId = wod;
1289 data.DeviceId = DSOUND_renderer_guids[wod];
1290
1291 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
1292 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
1293
1294 data.Description = wDescription;
1295 data.Module = wModule;
1296 data.Interface = wInterface;
1297
1298 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1299 err = mmErr(waveOutMessage(UlongToHandle(wod), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1300 if (err == DS_OK && drv)
1301 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1302 else
1303 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1304
1305 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1306 (ppd->Callback)(&data, ppd->Context);
1307 }
1308 }
1309 HeapFree(GetProcessHeap(),0,wInterface);
1310 }
1311 }
1312 HeapFree(GetProcessHeap(),0,wDescription);
1313 HeapFree(GetProcessHeap(),0,wModule);
1314 }
1315 }
1316
1317 devs = waveInGetNumDevs();
1318 for (wid = 0; wid < devs; ++wid) {
1319 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1320 if (err == DS_OK) {
1321 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
1322 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
1323 if (wDescription && wModule) {
1324 DWORD size;
1325 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0));
1326 if (err == DS_OK) {
1327 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,size);
1328 if (wInterface) {
1329 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)wInterface, size));
1330 if (err == DS_OK) {
1331 PIDSCDRIVER drv;
1332 ZeroMemory(&data, sizeof(data));
1333 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1334 data.WaveDeviceId = wid;
1335 data.DeviceId = DSOUND_capture_guids[wid];
1336
1337 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
1338 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
1339
1340 data.Description = wDescription;
1341 data.Module = wModule;
1342 data.Interface = wInterface;
1343 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1344 err = mmErr(waveInMessage(UlongToHandle(wid), DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1345 if (err == DS_OK && drv)
1346 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1347 else
1348 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1349
1350 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1351 (ppd->Callback)(&data, ppd->Context);
1352 }
1353 }
1354 HeapFree(GetProcessHeap(),0,wInterface);
1355 }
1356 }
1357 HeapFree(GetProcessHeap(),0,wDescription);
1358 HeapFree(GetProcessHeap(),0,wModule);
1359 }
1360 }
1361
1362 return S_OK;
1363 }
1364 }
1365
1366 if (pcbReturned) {
1367 *pcbReturned = 0;
1368 FIXME("*pcbReturned=%d\n", *pcbReturned);
1369 }
1370
1371 return E_PROP_ID_UNSUPPORTED;
1372 }
1373
1374 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get(
1375 LPKSPROPERTYSET iface,
1376 REFGUID guidPropSet,
1377 ULONG dwPropID,
1378 LPVOID pInstanceData,
1379 ULONG cbInstanceData,
1380 LPVOID pPropData,
1381 ULONG cbPropData,
1382 PULONG pcbReturned )
1383 {
1384 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
1385 TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1386 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
1387
1388 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
1389 switch (dwPropID) {
1390 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
1391 return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned);
1392 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
1393 return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned);
1394 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
1395 return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned);
1396 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
1397 return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned);
1398 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
1399 return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned);
1400 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
1401 return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned);
1402 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
1403 return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned);
1404 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
1405 return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned);
1406 default:
1407 FIXME("unsupported ID: %d\n",dwPropID);
1408 break;
1409 }
1410 } else {
1411 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
1412 }
1413
1414 if (pcbReturned) {
1415 *pcbReturned = 0;
1416 FIXME("*pcbReturned=%d\n", *pcbReturned);
1417 }
1418
1419 return E_PROP_ID_UNSUPPORTED;
1420 }
1421
1422 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set(
1423 LPKSPROPERTYSET iface,
1424 REFGUID guidPropSet,
1425 ULONG dwPropID,
1426 LPVOID pInstanceData,
1427 ULONG cbInstanceData,
1428 LPVOID pPropData,
1429 ULONG cbPropData )
1430 {
1431 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
1432
1433 FIXME("(%p,%s,%d,%p,%d,%p,%d), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
1434 return E_PROP_ID_UNSUPPORTED;
1435 }
1436
1437 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport(
1438 LPKSPROPERTYSET iface,
1439 REFGUID guidPropSet,
1440 ULONG dwPropID,
1441 PULONG pTypeSupport )
1442 {
1443 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
1444 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
1445
1446 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
1447 switch (dwPropID) {
1448 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
1449 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1450 return S_OK;
1451 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
1452 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1453 return S_OK;
1454 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
1455 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1456 return S_OK;
1457 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
1458 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1459 return S_OK;
1460 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
1461 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1462 return S_OK;
1463 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
1464 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1465 return S_OK;
1466 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
1467 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1468 return S_OK;
1469 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
1470 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1471 return S_OK;
1472 default:
1473 FIXME("unsupported ID: %d\n",dwPropID);
1474 break;
1475 }
1476 } else {
1477 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
1478 }
1479
1480 return E_PROP_ID_UNSUPPORTED;
1481 }
1482
1483 static const IKsPropertySetVtbl ikspvt = {
1484 IKsPrivatePropertySetImpl_QueryInterface,
1485 IKsPrivatePropertySetImpl_AddRef,
1486 IKsPrivatePropertySetImpl_Release,
1487 IKsPrivatePropertySetImpl_Get,
1488 IKsPrivatePropertySetImpl_Set,
1489 IKsPrivatePropertySetImpl_QuerySupport
1490 };
1491
1492 HRESULT IKsPrivatePropertySetImpl_Create(
1493 REFIID riid,
1494 IKsPrivatePropertySetImpl **piks)
1495 {
1496 IKsPrivatePropertySetImpl *iks;
1497 TRACE("(%s, %p)\n", debugstr_guid(riid), piks);
1498
1499 if (!IsEqualIID(riid, &IID_IUnknown) &&
1500 !IsEqualIID(riid, &IID_IKsPropertySet)) {
1501 *piks = 0;
1502 return E_NOINTERFACE;
1503 }
1504
1505 iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
1506 iks->ref = 1;
1507 iks->lpVtbl = &ikspvt;
1508
1509 *piks = iks;
1510 return S_OK;
1511 }