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 * IKsPrivatePropertySet
49 */
50
51 /* IUnknown methods */
52 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
53 LPKSPROPERTYSET iface,
54 REFIID riid,
55 LPVOID *ppobj )
56 {
57 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
58 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
59
60 if (IsEqualIID(riid, &IID_IUnknown) ||
61 IsEqualIID(riid, &IID_IKsPropertySet)) {
62 *ppobj = iface;
63 IUnknown_AddRef(iface);
64 return S_OK;
65 }
66 *ppobj = NULL;
67 return E_NOINTERFACE;
68 }
69
70 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface)
71 {
72 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
73 ULONG ref = InterlockedIncrement(&(This->ref));
74 TRACE("(%p) ref was %d\n", This, ref - 1);
75 return ref;
76 }
77
78 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
79 {
80 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
81 ULONG ref = InterlockedDecrement(&(This->ref));
82 TRACE("(%p) ref was %d\n", This, ref + 1);
83
84 if (!ref) {
85 HeapFree(GetProcessHeap(), 0, This);
86 TRACE("(%p) released\n", This);
87 }
88 return ref;
89 }
90
91 static HRESULT DSPROPERTY_WaveDeviceMappingW(
92 LPVOID pPropData,
93 ULONG cbPropData,
94 PULONG pcbReturned )
95 {
96 HRESULT hr = DSERR_INVALIDPARAM;
97 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
98 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
99 pPropData,cbPropData,pcbReturned);
100
101 ppd = pPropData;
102
103 if (!ppd) {
104 WARN("invalid parameter: pPropData\n");
105 return DSERR_INVALIDPARAM;
106 }
107
108 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
109 ULONG wod;
110 unsigned int wodn;
111 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
112 wodn = waveOutGetNumDevs();
113 for (wod = 0; wod < wodn; wod++) {
114 WAVEOUTCAPSW capsW;
115 MMRESULT res;
116 res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW));
117 if (res == MMSYSERR_NOERROR) {
118 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
119 ppd->DeviceId = DSOUND_renderer_guids[wod];
120 hr = DS_OK;
121 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
122 debugstr_w(ppd->DeviceName));
123 break;
124 }
125 }
126 }
127 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
128 ULONG wid;
129 unsigned int widn;
130 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
131 widn = waveInGetNumDevs();
132 for (wid = 0; wid < widn; wid++) {
133 WAVEINCAPSW capsW;
134 MMRESULT res;
135 res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW));
136 if (res == MMSYSERR_NOERROR) {
137 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
138 ppd->DeviceId = DSOUND_capture_guids[wid];
139 hr = DS_OK;
140 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
141 debugstr_w(ppd->DeviceName));
142 break;
143 }
144 }
145 }
146 }
147
148 if (pcbReturned)
149 *pcbReturned = cbPropData;
150
151 return hr;
152 }
153
154 static HRESULT DSPROPERTY_WaveDeviceMappingA(
155 LPVOID pPropData,
156 ULONG cbPropData,
157 PULONG pcbReturned )
158 {
159 DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA *ppd = pPropData;
160 DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA data;
161 DWORD len;
162 HRESULT hr;
163
164 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
165 pPropData,cbPropData,pcbReturned);
166
167 if (!ppd || !ppd->DeviceName) {
168 WARN("invalid parameter: ppd=%p\n", ppd);
169 return DSERR_INVALIDPARAM;
170 }
171
172 data.DataFlow = ppd->DataFlow;
173 len = MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, NULL, 0);
174 data.DeviceName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
175 if (!data.DeviceName)
176 return E_OUTOFMEMORY;
177 MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, data.DeviceName, len);
178
179 hr = DSPROPERTY_WaveDeviceMappingW(&data, cbPropData, pcbReturned);
180 HeapFree(GetProcessHeap(), 0, data.DeviceName);
181 ppd->DeviceId = data.DeviceId;
182
183 if (pcbReturned)
184 *pcbReturned = cbPropData;
185
186 return hr;
187 }
188
189 static HRESULT DSPROPERTY_DescriptionW(
190 LPVOID pPropData,
191 ULONG cbPropData,
192 PULONG pcbReturned )
193 {
194 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData;
195 HRESULT err;
196 GUID dev_guid;
197 ULONG wod, wid, wodn, widn;
198 DSDRIVERDESC desc;
199
200 TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
201 pPropData,cbPropData,pcbReturned);
202
203 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
204 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
205 /* default device of type specified by ppd->DataFlow */
206 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
207 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
208 ppd->DeviceId = DSDEVID_DefaultCapture;
209 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
210 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
211 ppd->DeviceId = DSDEVID_DefaultPlayback;
212 } else {
213 WARN("DataFlow=Unknown(%d)\n", ppd->DataFlow);
214 return E_PROP_ID_UNSUPPORTED;
215 }
216 }
217
218 GetDeviceID(&ppd->DeviceId, &dev_guid);
219
220 wodn = waveOutGetNumDevs();
221 widn = waveInGetNumDevs();
222 wid = wod = dev_guid.Data4[7];
223 if (!memcmp(&dev_guid, &DSOUND_renderer_guids[0], sizeof(GUID)-1)
224 && wod < wodn)
225 {
226 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
227 ppd->WaveDeviceId = wod;
228 }
229 else if (!memcmp(&dev_guid, &DSOUND_capture_guids[0], sizeof(GUID)-1)
230 && wid < widn)
231 {
232 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
233 ppd->WaveDeviceId = wid;
234 }
235 else
236 {
237 WARN("Device not found\n");
238 return E_PROP_ID_UNSUPPORTED;
239 }
240
241 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER)
242 err = waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0);
243 else
244 err = waveInMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0);
245
246 if (err != MMSYSERR_NOERROR)
247 {
248 WARN("waveMessage(DRV_QUERYDSOUNDDESC) failed!\n");
249 return E_PROP_ID_UNSUPPORTED;
250 }
251 else
252 {
253 /* FIXME: Still a memory leak.. */
254 int desclen, modlen;
255 static WCHAR wInterface[] = { 'I','n','t','e','r','f','a','c','e',0 };
256
257 modlen = MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, NULL, 0 );
258 desclen = MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, NULL, 0 );
259 ppd->Module = HeapAlloc(GetProcessHeap(),0,modlen*sizeof(WCHAR));
260 ppd->Description = HeapAlloc(GetProcessHeap(),0,desclen*sizeof(WCHAR));
261 ppd->Interface = wInterface;
262 if (!ppd->Description || !ppd->Module)
263 {
264 WARN("Out of memory\n");
265 HeapFree(GetProcessHeap(), 0, ppd->Description);
266 HeapFree(GetProcessHeap(), 0, ppd->Module);
267 ppd->Description = ppd->Module = NULL;
268 return E_OUTOFMEMORY;
269 }
270
271 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->Module, modlen );
272 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->Description, desclen );
273 }
274
275 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
276
277 if (pcbReturned) {
278 *pcbReturned = sizeof(*ppd);
279 TRACE("*pcbReturned=%d\n", *pcbReturned);
280 }
281
282 return S_OK;
283 }
284
285 static HRESULT DSPROPERTY_EnumerateW(
286 LPVOID pPropData,
287 ULONG cbPropData,
288 PULONG pcbReturned )
289 {
290 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData;
291 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
292 BOOL ret;
293 int widn, wodn, i;
294 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
295 pPropData,cbPropData,pcbReturned);
296
297 if (pcbReturned)
298 *pcbReturned = 0;
299
300 if (!ppd || !ppd->Callback)
301 {
302 WARN("Invalid ppd %p\n", ppd);
303 return E_PROP_ID_UNSUPPORTED;
304 }
305
306 wodn = waveOutGetNumDevs();
307 widn = waveInGetNumDevs();
308
309 data.DeviceId = DSOUND_renderer_guids[0];
310 for (i = 0; i < wodn; ++i)
311 {
312 HRESULT hr;
313 data.DeviceId.Data4[7] = i;
314 hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
315 if (FAILED(hr))
316 {
317 ERR("DescriptionW failed!\n");
318 return S_OK;
319 }
320 ret = ppd->Callback(&data, ppd->Context);
321 HeapFree(GetProcessHeap(), 0, data.Module);
322 HeapFree(GetProcessHeap(), 0, data.Description);
323 if (!ret)
324 return S_OK;
325 }
326
327 data.DeviceId = DSOUND_capture_guids[0];
328 for (i = 0; i < widn; ++i)
329 {
330 HRESULT hr;
331 data.DeviceId.Data4[7] = i;
332 hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
333 if (FAILED(hr))
334 {
335 ERR("DescriptionW failed!\n");
336 return S_OK;
337 }
338 ret = ppd->Callback(&data, ppd->Context);
339 HeapFree(GetProcessHeap(), 0, data.Module);
340 HeapFree(GetProcessHeap(), 0, data.Description);
341 if (!ret)
342 return S_OK;
343 }
344 return S_OK;
345 }
346
347 static BOOL DSPROPERTY_descWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
348 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *dataA)
349 {
350 DWORD modlen, desclen;
351 static char Interface[] = "Interface";
352
353 modlen = WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, NULL, 0, NULL, NULL);
354 desclen = WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, NULL, 0, NULL, NULL);
355 dataA->Type = dataW->Type;
356 dataA->DataFlow = dataW->DataFlow;
357 dataA->DeviceId = dataW->DeviceId;
358 dataA->WaveDeviceId = dataW->WaveDeviceId;
359 dataA->Interface = Interface;
360 dataA->Module = HeapAlloc(GetProcessHeap(), 0, modlen);
361 dataA->Description = HeapAlloc(GetProcessHeap(), 0, desclen);
362 if (!dataA->Module || !dataA->Description)
363 {
364 HeapFree(GetProcessHeap(), 0, dataA->Module);
365 HeapFree(GetProcessHeap(), 0, dataA->Description);
366 dataA->Module = dataA->Description = NULL;
367 return FALSE;
368 }
369
370 WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, dataA->Module, modlen, NULL, NULL);
371 WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, dataA->Description, desclen, NULL, NULL);
372 return TRUE;
373 }
374
375 static void DSPROPERTY_descWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
376 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *data1)
377 {
378 data1->DeviceId = dataW->DeviceId;
379 lstrcpynW(data1->ModuleW, dataW->Module, sizeof(data1->ModuleW)/sizeof(*data1->ModuleW));
380 lstrcpynW(data1->DescriptionW, dataW->Description, sizeof(data1->DescriptionW)/sizeof(*data1->DescriptionW));
381 WideCharToMultiByte(CP_ACP, 0, data1->DescriptionW, -1, data1->DescriptionA, sizeof(data1->DescriptionA)-1, NULL, NULL);
382 WideCharToMultiByte(CP_ACP, 0, data1->ModuleW, -1, data1->ModuleA, sizeof(data1->ModuleA)-1, NULL, NULL);
383 data1->DescriptionA[sizeof(data1->DescriptionA)-1] = 0;
384 data1->ModuleA[sizeof(data1->ModuleA)-1] = 0;
385 data1->Type = dataW->Type;
386 data1->DataFlow = dataW->DataFlow;
387 data1->WaveDeviceId = data1->Devnode = dataW->WaveDeviceId;
388 }
389
390 static BOOL CALLBACK DSPROPERTY_enumWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data)
391 {
392 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA descA;
393 DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = data;
394 BOOL ret;
395
396 ret = DSPROPERTY_descWtoA(descW, &descA);
397 if (!ret)
398 return FALSE;
399 ret = ppd->Callback(&descA, ppd->Context);
400 HeapFree(GetProcessHeap(), 0, descA.Module);
401 HeapFree(GetProcessHeap(), 0, descA.Description);
402 return ret;
403 }
404
405 static HRESULT DSPROPERTY_EnumerateA(
406 LPVOID pPropData,
407 ULONG cbPropData,
408 PULONG pcbReturned)
409 {
410 DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = pPropData;
411 DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;
412
413 if (!ppd || !ppd->Callback)
414 {
415 WARN("Invalid ppd %p\n", ppd);
416 return E_PROP_ID_UNSUPPORTED;
417 }
418
419 data.Callback = DSPROPERTY_enumWtoA;
420 data.Context = ppd;
421
422 return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned);
423 }
424
425 static BOOL CALLBACK DSPROPERTY_enumWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data)
426 {
427 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA desc1;
428 DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = data;
429 BOOL ret;
430
431 DSPROPERTY_descWto1(descW, &desc1);
432 ret = ppd->Callback(&desc1, ppd->Context);
433 return ret;
434 }
435
436 static HRESULT DSPROPERTY_Enumerate1(
437 LPVOID pPropData,
438 ULONG cbPropData,
439 PULONG pcbReturned)
440 {
441 DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = pPropData;
442 DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;
443
444 if (!ppd || !ppd->Callback)
445 {
446 WARN("Invalid ppd %p\n", ppd);
447 return E_PROP_ID_UNSUPPORTED;
448 }
449
450 data.Callback = DSPROPERTY_enumWto1;
451 data.Context = ppd;
452
453 return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned);
454 }
455
456 static HRESULT DSPROPERTY_DescriptionA(
457 LPVOID pPropData,
458 ULONG cbPropData,
459 PULONG pcbReturned)
460 {
461 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
462 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *ppd = pPropData;
463 HRESULT hr;
464
465 if (pcbReturned)
466 *pcbReturned = sizeof(*ppd);
467 if (!pPropData)
468 return S_OK;
469
470 data.DeviceId = ppd->DeviceId;
471 data.DataFlow = ppd->DataFlow;
472 hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
473 if (FAILED(hr))
474 return hr;
475 if (!DSPROPERTY_descWtoA(&data, ppd))
476 hr = E_OUTOFMEMORY;
477 HeapFree(GetProcessHeap(), 0, data.Module);
478 HeapFree(GetProcessHeap(), 0, data.Interface);
479 return hr;
480 }
481
482 static HRESULT DSPROPERTY_Description1(
483 LPVOID pPropData,
484 ULONG cbPropData,
485 PULONG pcbReturned)
486 {
487 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
488 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *ppd = pPropData;
489 HRESULT hr;
490
491 if (pcbReturned)
492 *pcbReturned = sizeof(*ppd);
493 if (!pPropData)
494 return S_OK;
495
496 data.DeviceId = ppd->DeviceId;
497 data.DataFlow = ppd->DataFlow;
498 hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
499 if (FAILED(hr))
500 return hr;
501 DSPROPERTY_descWto1(&data, ppd);
502 HeapFree(GetProcessHeap(), 0, data.Module);
503 HeapFree(GetProcessHeap(), 0, data.Interface);
504 return hr;
505 }
506
507 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get(
508 LPKSPROPERTYSET iface,
509 REFGUID guidPropSet,
510 ULONG dwPropID,
511 LPVOID pInstanceData,
512 ULONG cbInstanceData,
513 LPVOID pPropData,
514 ULONG cbPropData,
515 PULONG pcbReturned )
516 {
517 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
518 TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
519 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
520
521 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
522 switch (dwPropID) {
523 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
524 return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned);
525 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
526 return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned);
527 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
528 return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned);
529 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
530 return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned);
531 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
532 return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned);
533 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
534 return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned);
535 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
536 return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned);
537 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
538 return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned);
539 default:
540 FIXME("unsupported ID: %d\n",dwPropID);
541 break;
542 }
543 } else {
544 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
545 }
546
547 if (pcbReturned) {
548 *pcbReturned = 0;
549 FIXME("*pcbReturned=%d\n", *pcbReturned);
550 }
551
552 return E_PROP_ID_UNSUPPORTED;
553 }
554
555 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set(
556 LPKSPROPERTYSET iface,
557 REFGUID guidPropSet,
558 ULONG dwPropID,
559 LPVOID pInstanceData,
560 ULONG cbInstanceData,
561 LPVOID pPropData,
562 ULONG cbPropData )
563 {
564 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
565
566 FIXME("(%p,%s,%d,%p,%d,%p,%d), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
567 return E_PROP_ID_UNSUPPORTED;
568 }
569
570 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport(
571 LPKSPROPERTYSET iface,
572 REFGUID guidPropSet,
573 ULONG dwPropID,
574 PULONG pTypeSupport )
575 {
576 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
577 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
578
579 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
580 switch (dwPropID) {
581 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
582 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
583 return S_OK;
584 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
585 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
586 return S_OK;
587 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
588 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
589 return S_OK;
590 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
591 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
592 return S_OK;
593 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
594 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
595 return S_OK;
596 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
597 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
598 return S_OK;
599 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
600 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
601 return S_OK;
602 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
603 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
604 return S_OK;
605 default:
606 FIXME("unsupported ID: %d\n",dwPropID);
607 break;
608 }
609 } else {
610 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
611 }
612
613 return E_PROP_ID_UNSUPPORTED;
614 }
615
616 static const IKsPropertySetVtbl ikspvt = {
617 IKsPrivatePropertySetImpl_QueryInterface,
618 IKsPrivatePropertySetImpl_AddRef,
619 IKsPrivatePropertySetImpl_Release,
620 IKsPrivatePropertySetImpl_Get,
621 IKsPrivatePropertySetImpl_Set,
622 IKsPrivatePropertySetImpl_QuerySupport
623 };
624
625 HRESULT IKsPrivatePropertySetImpl_Create(
626 REFIID riid,
627 IKsPrivatePropertySetImpl **piks)
628 {
629 IKsPrivatePropertySetImpl *iks;
630 TRACE("(%s, %p)\n", debugstr_guid(riid), piks);
631
632 if (!IsEqualIID(riid, &IID_IUnknown) &&
633 !IsEqualIID(riid, &IID_IKsPropertySet)) {
634 *piks = 0;
635 return E_NOINTERFACE;
636 }
637
638 iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
639 iks->ref = 1;
640 iks->lpVtbl = &ikspvt;
641
642 *piks = iks;
643 return S_OK;
644 }
645
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.