3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000-2002 TransGaming Technologies, Inc.
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.
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.
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
33 #include "wine/debug.h"
36 #include "dsound_private.h"
39 #ifdef NONAMELESSSTRUCT
45 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
48 /*******************************************************************************
49 * IKsBufferPropertySet
52 /* IUnknown methods */
53 static HRESULT WINAPI IKsBufferPropertySetImpl_QueryInterface(
54 LPKSPROPERTYSET iface,
58 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
59 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
61 return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb, riid, ppobj);
64 static ULONG WINAPI IKsBufferPropertySetImpl_AddRef(LPKSPROPERTYSET iface)
66 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
67 ULONG ref = InterlockedIncrement(&(This->ref));
68 TRACE("(%p) ref was %d\n", This, ref - 1);
72 static ULONG WINAPI IKsBufferPropertySetImpl_Release(LPKSPROPERTYSET iface)
74 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
75 ULONG ref = InterlockedDecrement(&(This->ref));
76 TRACE("(%p) ref was %d\n", This, ref + 1);
80 IDirectSoundBuffer_Release((LPDIRECTSOUND3DBUFFER)This->dsb);
81 HeapFree(GetProcessHeap(), 0, This);
82 TRACE("(%p) released\n", This);
87 static HRESULT WINAPI IKsBufferPropertySetImpl_Get(
88 LPKSPROPERTYSET iface,
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);
102 if (This->dsb->hwbuf) {
103 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
109 S(prop).Set = *guidPropSet;
110 S(prop).Id = dwPropID;
111 S(prop).Flags = 0; /* unused */
112 S(prop).InstanceId = (ULONG)This->dsb->device;
114 hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
116 IDsDriverPropertySet_Release(ps);
122 return E_PROP_ID_UNSUPPORTED;
125 static HRESULT WINAPI IKsBufferPropertySetImpl_Set(
126 LPKSPROPERTYSET iface,
129 LPVOID pInstanceData,
130 ULONG cbInstanceData,
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);
138 if (This->dsb->hwbuf) {
139 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
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);
151 IDsDriverPropertySet_Release(ps);
157 return E_PROP_ID_UNSUPPORTED;
160 static HRESULT WINAPI IKsBufferPropertySetImpl_QuerySupport(
161 LPKSPROPERTYSET iface,
164 PULONG pTypeSupport )
166 IKsBufferPropertySetImpl *This = (IKsBufferPropertySetImpl *)iface;
167 PIDSDRIVERPROPERTYSET ps;
168 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
170 if (This->dsb->hwbuf) {
171 IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
176 hres = IDsDriverPropertySet_QuerySupport(ps,guidPropSet, dwPropID,pTypeSupport);
178 IDsDriverPropertySet_Release(ps);
184 return E_PROP_ID_UNSUPPORTED;
187 static const IKsPropertySetVtbl iksbvt = {
188 IKsBufferPropertySetImpl_QueryInterface,
189 IKsBufferPropertySetImpl_AddRef,
190 IKsBufferPropertySetImpl_Release,
191 IKsBufferPropertySetImpl_Get,
192 IKsBufferPropertySetImpl_Set,
193 IKsBufferPropertySetImpl_QuerySupport
196 HRESULT IKsBufferPropertySetImpl_Create(
197 IDirectSoundBufferImpl *dsb,
198 IKsBufferPropertySetImpl **piks)
200 PIDSDRIVERPROPERTYSET ps = NULL;
201 IKsBufferPropertySetImpl *iks;
202 TRACE("(%p,%p)\n",dsb,piks);
205 return DSERR_INVALIDPARAM;
207 IDsDriver_QueryInterface(dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
209 return DSERR_INVALIDPARAM;
211 IUnknown_Release(ps);
213 iks = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*iks));
215 WARN("out of memory\n");
217 return DSERR_OUTOFMEMORY;
223 iks->lpVtbl = &iksbvt;
225 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)dsb);
231 HRESULT IKsBufferPropertySetImpl_Destroy(
232 IKsBufferPropertySetImpl *piks)
234 TRACE("(%p)\n",piks);
236 while (IKsBufferPropertySetImpl_Release((LPKSPROPERTYSET)piks) > 0);
241 /*******************************************************************************
242 * IKsPrivatePropertySet
245 /* IUnknown methods */
246 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
247 LPKSPROPERTYSET iface,
251 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
252 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
254 if (IsEqualIID(riid, &IID_IUnknown) ||
255 IsEqualIID(riid, &IID_IKsPropertySet)) {
257 IUnknown_AddRef(iface);
261 return E_NOINTERFACE;
264 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface)
266 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
267 ULONG ref = InterlockedIncrement(&(This->ref));
268 TRACE("(%p) ref was %d\n", This, ref - 1);
272 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
274 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
275 ULONG ref = InterlockedDecrement(&(This->ref));
276 TRACE("(%p) ref was %d\n", This, ref + 1);
279 HeapFree(GetProcessHeap(), 0, This);
280 TRACE("(%p) released\n", This);
285 static HRESULT WINAPI DSPROPERTY_WaveDeviceMappingA(
290 HRESULT hr = DSERR_INVALIDPARAM;
291 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA ppd;
292 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
293 pPropData,cbPropData,pcbReturned);
295 ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA) pPropData;
298 WARN("invalid parameter: pPropData\n");
299 return DSERR_INVALIDPARAM;
302 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
305 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
306 wodn = waveOutGetNumDevs();
307 for (wod = 0; wod < wodn; wod++) {
310 res = waveOutGetDevCapsA(wod, &capsA, sizeof(capsA));
311 if (res == MMSYSERR_NOERROR) {
312 if (lstrcmpA(capsA.szPname, ppd->DeviceName) == 0) {
313 ppd->DeviceId = DSOUND_renderer_guids[wod];
315 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
321 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
324 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
325 widn = waveInGetNumDevs();
326 for (wid = 0; wid < widn; wid++) {
329 res = waveInGetDevCapsA(wid, &capsA, sizeof(capsA));
330 if (res == MMSYSERR_NOERROR) {
331 if (lstrcmpA(capsA.szPname, ppd->DeviceName) == 0) {
332 ppd->DeviceId = DSOUND_capture_guids[wid];
333 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
343 *pcbReturned = cbPropData;
348 static HRESULT WINAPI DSPROPERTY_WaveDeviceMappingW(
353 HRESULT hr = DSERR_INVALIDPARAM;
354 PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
355 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
356 pPropData,cbPropData,pcbReturned);
358 ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA) pPropData;
361 WARN("invalid parameter: pPropData\n");
362 return DSERR_INVALIDPARAM;
365 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
368 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
369 wodn = waveOutGetNumDevs();
370 for (wod = 0; wod < wodn; wod++) {
373 res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW));
374 if (res == MMSYSERR_NOERROR) {
375 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
376 ppd->DeviceId = DSOUND_renderer_guids[wod];
378 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
379 debugstr_w(ppd->DeviceName));
384 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
387 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
388 widn = waveInGetNumDevs();
389 for (wid = 0; wid < widn; wid++) {
392 res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW));
393 if (res == MMSYSERR_NOERROR) {
394 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
395 ppd->DeviceId = DSOUND_capture_guids[wid];
397 TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
398 debugstr_w(ppd->DeviceName));
406 *pcbReturned = cbPropData;
411 static HRESULT WINAPI DSPROPERTY_Description1(
418 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA ppd;
419 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
420 pPropData,cbPropData,pcbReturned);
422 ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA) pPropData;
425 WARN("invalid parameter: pPropData\n");
426 return DSERR_INVALIDPARAM;
429 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
430 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
431 /* default device of type specified by ppd->DataFlow */
432 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
433 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
434 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
435 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
437 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
439 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n",
440 pPropData,cbPropData,pcbReturned);
441 return E_PROP_ID_UNSUPPORTED;
444 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
445 GetDeviceID(&ppd->DeviceId, &dev_guid);
447 if ( IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultPlayback) ||
448 IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultVoicePlayback) ) {
451 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
452 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
453 wodn = waveOutGetNumDevs();
454 for (wod = 0; wod < wodn; wod++) {
455 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) {
457 ppd->WaveDeviceId = wod;
459 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
461 PIDSDRIVER drv = NULL;
462 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
463 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
464 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
465 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
466 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
467 if (err == DS_OK && drv)
468 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
470 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
473 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
474 return E_PROP_ID_UNSUPPORTED;
478 } else if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
479 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
482 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
483 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
484 widn = waveInGetNumDevs();
485 for (wid = 0; wid < widn; wid++) {
486 if (IsEqualGUID( &dev_guid, &guid) ) {
488 ppd->WaveDeviceId = wid;
490 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
493 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
494 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
495 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
496 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
497 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
498 if (err == DS_OK && drv)
499 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
501 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
504 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
505 return E_PROP_ID_UNSUPPORTED;
513 /* given specific device so try the render devices first */
514 wodn = waveOutGetNumDevs();
515 for (wod = 0; wod < wodn; wod++) {
516 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) {
518 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
519 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
520 ppd->WaveDeviceId = wod;
522 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
524 PIDSDRIVER drv = NULL;
525 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
526 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
527 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
528 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
529 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
530 if (err == DS_OK && drv)
531 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
533 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
537 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
538 return E_PROP_ID_UNSUPPORTED;
543 if (found == FALSE) {
546 /* given specific device so try the capture devices next */
547 widn = waveInGetNumDevs();
548 for (wid = 0; wid < widn; wid++) {
549 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_capture_guids[wid] ) ) {
551 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
552 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
553 ppd->WaveDeviceId = wid;
555 err = mmErr(waveInMessage((HWAVEIN)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
557 PIDSDRIVER drv = NULL;
558 lstrcpynA(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA));
559 lstrcpynA(ppd->ModuleA, desc.szDrvname, sizeof(ppd->ModuleA));
560 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
561 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
562 err = mmErr(waveInMessage((HWAVEIN)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
563 if (err == DS_OK && drv)
564 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
566 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
570 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
571 return E_PROP_ID_UNSUPPORTED;
576 if (found == FALSE) {
577 WARN("device not found\n");
578 return E_PROP_ID_UNSUPPORTED;
584 *pcbReturned = cbPropData;
585 TRACE("*pcbReturned=%d\n", *pcbReturned);
591 static HRESULT WINAPI DSPROPERTY_DescriptionA(
596 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA) pPropData;
599 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
600 pPropData,cbPropData,pcbReturned);
602 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
603 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
604 /* default device of type specified by ppd->DataFlow */
605 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
606 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
607 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
608 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
610 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
612 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n",
613 pPropData,cbPropData,pcbReturned);
614 return E_PROP_ID_UNSUPPORTED;
617 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
618 GetDeviceID(&ppd->DeviceId, &dev_guid);
620 if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
621 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
624 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) )
625 TRACE("DSDEVID_DefaultPlayback\n");
627 TRACE("DSDEVID_DefaultVoicePlayback\n");
628 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
629 wodn = waveOutGetNumDevs();
630 for (wod = 0; wod < wodn; wod++) {
631 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) {
633 ppd->WaveDeviceId = wod;
634 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
636 PIDSDRIVER drv = NULL;
637 /* FIXME: this is a memory leak */
638 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
639 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
640 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
642 if (szDescription && szModule && szInterface) {
643 strcpy(szDescription, desc.szDesc);
644 strcpy(szModule, desc.szDrvname);
645 strcpy(szInterface, "Interface");
647 ppd->Description = szDescription;
648 ppd->Module = szModule;
649 ppd->Interface = szInterface;
650 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
651 if (err == DS_OK && drv)
652 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
654 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
658 HeapFree(GetProcessHeap(), 0, szDescription);
659 HeapFree(GetProcessHeap(), 0, szModule);
660 HeapFree(GetProcessHeap(), 0, szInterface);
661 return E_OUTOFMEMORY;
664 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
665 return E_PROP_ID_UNSUPPORTED;
669 } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
670 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
673 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) )
674 TRACE("DSDEVID_DefaultCapture\n");
676 TRACE("DSDEVID_DefaultVoiceCapture\n");
677 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
678 widn = waveInGetNumDevs();
679 for (wid = 0; wid < widn; wid++) {
680 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) {
682 ppd->WaveDeviceId = wid;
683 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
686 /* FIXME: this is a memory leak */
687 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
688 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
689 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
691 if (szDescription && szModule && szInterface) {
692 strcpy(szDescription, desc.szDesc);
693 strcpy(szModule, desc.szDrvname);
694 strcpy(szInterface, "Interface");
696 ppd->Description = szDescription;
697 ppd->Module = szModule;
698 ppd->Interface = szInterface;
699 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
700 if (err == DS_OK && drv)
701 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
703 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
707 HeapFree(GetProcessHeap(), 0, szDescription);
708 HeapFree(GetProcessHeap(), 0, szModule);
709 HeapFree(GetProcessHeap(), 0, szInterface);
710 return E_OUTOFMEMORY;
713 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
714 return E_PROP_ID_UNSUPPORTED;
722 /* given specific device so try the render devices first */
723 TRACE("Checking renderer devices\n");
724 wodn = waveOutGetNumDevs();
725 for (wod = 0; wod < wodn; wod++) {
726 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) {
728 TRACE("DSOUND_renderer_guids[%d]\n", wod);
729 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
730 ppd->WaveDeviceId = wod;
731 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
733 PIDSDRIVER drv = NULL;
734 /* FIXME: this is a memory leak */
735 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
736 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
737 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
739 if (szDescription && szModule && szInterface) {
740 strcpy(szDescription, desc.szDesc);
741 strcpy(szModule, desc.szDrvname);
742 strcpy(szInterface, "Interface");
744 ppd->Description = szDescription;
745 ppd->Module = szModule;
746 ppd->Interface = szInterface;
747 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
748 if (err == DS_OK && drv)
749 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
751 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
756 HeapFree(GetProcessHeap(), 0, szDescription);
757 HeapFree(GetProcessHeap(), 0, szModule);
758 HeapFree(GetProcessHeap(), 0, szInterface);
759 return E_OUTOFMEMORY;
762 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
763 return E_PROP_ID_UNSUPPORTED;
768 if (found == FALSE) {
771 TRACE("Checking capture devices\n");
772 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
773 widn = waveInGetNumDevs();
774 for (wid = 0; wid < widn; wid++) {
775 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_capture_guids[wid] ) ) {
777 TRACE("DSOUND_capture_guids[%d]\n", wid);
778 ppd->WaveDeviceId = wid;
779 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
782 /* FIXME: this is a memory leak */
783 CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
784 CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvname) + 1);
785 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
787 if (szDescription && szModule && szInterface) {
788 strcpy(szDescription, desc.szDesc);
789 strcpy(szModule, desc.szDrvname);
790 strcpy(szInterface, "Interface");
792 ppd->Description = szDescription;
793 ppd->Module = szModule;
794 ppd->Interface = szInterface;
795 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
796 if (err == DS_OK && drv)
797 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
799 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
804 HeapFree(GetProcessHeap(), 0, szDescription);
805 HeapFree(GetProcessHeap(), 0, szModule);
806 HeapFree(GetProcessHeap(), 0, szInterface);
807 return E_OUTOFMEMORY;
810 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
811 return E_PROP_ID_UNSUPPORTED;
817 if (found == FALSE) {
818 WARN("device not found\n");
819 return E_PROP_ID_UNSUPPORTED;
824 *pcbReturned = cbPropData;
825 TRACE("*pcbReturned=%d\n", *pcbReturned);
831 static HRESULT WINAPI DSPROPERTY_DescriptionW(
836 PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA) pPropData;
839 TRACE("pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
840 pPropData,cbPropData,pcbReturned);
842 TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
843 if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
844 /* default device of type specified by ppd->DataFlow */
845 if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
846 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
847 } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
848 TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
850 TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
852 FIXME("(pPropData=%p,cbPropData=%d,pcbReturned=%p) GUID_NULL not implemented!\n",
853 pPropData,cbPropData,pcbReturned);
854 return E_PROP_ID_UNSUPPORTED;
857 ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
858 GetDeviceID(&ppd->DeviceId, &dev_guid);
860 if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
861 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
864 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) )
865 TRACE("DSDEVID_DefaultPlayback\n");
867 TRACE("DSDEVID_DefaultVoicePlayback\n");
868 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
869 wodn = waveOutGetNumDevs();
870 for (wod = 0; wod < wodn; wod++) {
871 if (IsEqualGUID( &dev_guid, &DSOUND_renderer_guids[wod] ) ) {
873 TRACE("DSOUND_renderer_guids[%d]\n", wod);
874 ppd->WaveDeviceId = wod;
875 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
877 PIDSDRIVER drv = NULL;
878 /* FIXME: this is a memory leak */
879 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
880 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
881 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
883 if (wDescription && wModule && wInterface) {
884 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
885 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
886 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
888 ppd->Description = wDescription;
889 ppd->Module = wModule;
890 ppd->Interface = wInterface;
891 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
892 if (err == DS_OK && drv)
893 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
895 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
899 HeapFree(GetProcessHeap(), 0, wDescription);
900 HeapFree(GetProcessHeap(), 0, wModule);
901 HeapFree(GetProcessHeap(), 0, wInterface);
902 return E_OUTOFMEMORY;
905 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
906 return E_PROP_ID_UNSUPPORTED;
910 } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
911 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
914 if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture))
915 TRACE("DSDEVID_DefaultCapture\n");
917 TRACE("DSDEVID_DefaultVoiceCapture\n");
918 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
919 widn = waveInGetNumDevs();
920 for (wid = 0; wid < widn; wid++) {
921 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) {
923 ppd->WaveDeviceId = wid;
924 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
927 /* FIXME: this is a memory leak */
928 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
929 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
930 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
932 if (wDescription && wModule && wInterface) {
933 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
934 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
935 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
937 ppd->Description = wDescription;
938 ppd->Module = wModule;
939 ppd->Interface = wInterface;
940 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
941 if (err == DS_OK && drv)
942 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
944 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
948 HeapFree(GetProcessHeap(), 0, wDescription);
949 HeapFree(GetProcessHeap(), 0, wModule);
950 HeapFree(GetProcessHeap(), 0, wInterface);
951 return E_OUTOFMEMORY;
954 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
955 return E_PROP_ID_UNSUPPORTED;
963 TRACE("Checking renderer devices\n");
964 /* given specific device so try the render devices first */
965 wodn = waveOutGetNumDevs();
966 for (wod = 0; wod < wodn; wod++) {
967 if (IsEqualGUID( &ppd->DeviceId, &DSOUND_renderer_guids[wod] ) ) {
969 TRACE("DSOUND_renderer_guids[%d]\n", wod);
970 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
971 ppd->WaveDeviceId = wod;
972 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
974 PIDSDRIVER drv = NULL;
975 /* FIXME: this is a memory leak */
976 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
977 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
978 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
980 if (wDescription && wModule && wInterface) {
981 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
982 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
983 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
985 ppd->Description = wDescription;
986 ppd->Module = wModule;
987 ppd->Interface = wInterface;
988 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
989 if (err == DS_OK && drv)
990 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
992 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
997 HeapFree(GetProcessHeap(), 0, wDescription);
998 HeapFree(GetProcessHeap(), 0, wModule);
999 HeapFree(GetProcessHeap(), 0, wInterface);
1000 return E_OUTOFMEMORY;
1003 WARN("waveOutMessage(DRV_QUERYDSOUNDDESC) failed\n");
1004 return E_PROP_ID_UNSUPPORTED;
1009 if (found == FALSE) {
1012 TRACE("Checking capture devices\n");
1013 ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1014 widn = waveInGetNumDevs();
1015 for (wid = 0; wid < widn; wid++) {
1016 if (IsEqualGUID( &dev_guid, &DSOUND_capture_guids[wid] ) ) {
1018 TRACE("DSOUND_capture_guids[%d]\n", wid);
1019 ppd->WaveDeviceId = wid;
1020 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&(desc),0));
1023 /* FIXME: this is a memory leak */
1024 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
1025 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
1026 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
1028 if (wDescription && wModule && wInterface) {
1029 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
1030 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
1031 MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
1033 ppd->Description = wDescription;
1034 ppd->Module = wModule;
1035 ppd->Interface = wInterface;
1036 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&drv,0));
1037 if (err == DS_OK && drv)
1038 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1040 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1044 WARN("no memory\n");
1045 HeapFree(GetProcessHeap(), 0, wDescription);
1046 HeapFree(GetProcessHeap(), 0, wModule);
1047 HeapFree(GetProcessHeap(), 0, wInterface);
1048 return E_OUTOFMEMORY;
1051 WARN("waveInMessage(DRV_QUERYDSOUNDDESC) failed\n");
1052 return E_PROP_ID_UNSUPPORTED;
1058 if (found == FALSE) {
1059 WARN("device not found\n");
1060 return E_PROP_ID_UNSUPPORTED;
1065 *pcbReturned = cbPropData;
1066 TRACE("*pcbReturned=%d\n", *pcbReturned);
1072 static HRESULT WINAPI DSPROPERTY_Enumerate1(
1075 PULONG pcbReturned )
1077 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA) pPropData;
1079 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1080 pPropData,cbPropData,pcbReturned);
1083 if (ppd->Callback) {
1084 unsigned devs, wod, wid;
1086 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA data;
1088 devs = waveOutGetNumDevs();
1089 for (wod = 0; wod < devs; ++wod) {
1090 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1093 ZeroMemory(&data, sizeof(data));
1094 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
1095 data.WaveDeviceId = wod;
1096 data.DeviceId = DSOUND_renderer_guids[wod];
1097 lstrcpynA(data.DescriptionA, desc.szDesc, sizeof(data.DescriptionA));
1098 lstrcpynA(data.ModuleA, desc.szDrvname, sizeof(data.ModuleA));
1100 MultiByteToWideChar( CP_ACP, 0, data.DescriptionA, -1, data.DescriptionW, sizeof(data.DescriptionW)/sizeof(WCHAR) );
1101 MultiByteToWideChar( CP_ACP, 0, data.ModuleA, -1, data.ModuleW, sizeof(data.ModuleW)/sizeof(WCHAR) );
1103 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1104 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1105 if (err == DS_OK && drv)
1106 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1108 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1110 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1111 (ppd->Callback)(&data, ppd->Context);
1115 devs = waveInGetNumDevs();
1116 for (wid = 0; wid < devs; ++wid) {
1117 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1120 ZeroMemory(&data, sizeof(data));
1121 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1122 data.WaveDeviceId = wid;
1123 data.DeviceId = DSOUND_capture_guids[wid];
1124 lstrcpynA(data.DescriptionA, desc.szDesc, sizeof(data.DescriptionA));
1125 lstrcpynA(data.ModuleA, desc.szDrvname, sizeof(data.ModuleA));
1127 MultiByteToWideChar( CP_ACP, 0, data.DescriptionA, -1, data.DescriptionW, sizeof(data.DescriptionW)/sizeof(WCHAR) );
1128 MultiByteToWideChar( CP_ACP, 0, data.ModuleA, -1, data.ModuleW, sizeof(data.ModuleW)/sizeof(WCHAR) );
1130 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1131 err = mmErr(waveInMessage((HWAVEIN)wid, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1132 if (err == DS_OK && drv)
1133 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1135 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1137 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1138 (ppd->Callback)(&data, ppd->Context);
1148 FIXME("*pcbReturned=%d\n", *pcbReturned);
1151 return E_PROP_ID_UNSUPPORTED;
1154 static HRESULT WINAPI DSPROPERTY_EnumerateA(
1157 PULONG pcbReturned )
1159 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA) pPropData;
1161 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1162 pPropData,cbPropData,pcbReturned);
1165 if (ppd->Callback) {
1166 unsigned devs, wod, wid;
1168 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA data;
1170 devs = waveOutGetNumDevs();
1171 for (wod = 0; wod < devs; ++wod) {
1172 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1175 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDEVICEINTERFACESIZE,(DWORD_PTR)&size,0));
1177 WCHAR * nameW = HeapAlloc(GetProcessHeap(),0,size);
1179 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDEVICEINTERFACE,(DWORD_PTR)nameW,size));
1181 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,size/sizeof(WCHAR));
1184 ZeroMemory(&data, sizeof(data));
1185 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
1186 data.WaveDeviceId = wod;
1187 data.DeviceId = DSOUND_renderer_guids[wod];
1188 data.Description = desc.szDesc;
1189 data.Module = desc.szDrvname;
1190 WideCharToMultiByte( CP_ACP, 0, nameW, size/sizeof(WCHAR), szInterface, size/sizeof(WCHAR), NULL, NULL );
1191 data.Interface = szInterface;
1193 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1194 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1195 if (err == DS_OK && drv)
1196 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1198 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1200 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1201 (ppd->Callback)(&data, ppd->Context);
1203 HeapFree(GetProcessHeap(),0,szInterface);
1206 HeapFree(GetProcessHeap(),0,nameW);
1211 devs = waveInGetNumDevs();
1212 for (wid = 0; wid < devs; ++wid) {
1213 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1216 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDEVICEINTERFACESIZE,(DWORD_PTR)&size,0));
1218 WCHAR * nameW = HeapAlloc(GetProcessHeap(),0,size);
1220 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDEVICEINTERFACE,(DWORD_PTR)nameW,size));
1222 CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,size/sizeof(WCHAR));
1225 ZeroMemory(&data, sizeof(data));
1226 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1227 data.WaveDeviceId = wid;
1228 data.DeviceId = DSOUND_capture_guids[wid];
1229 data.Description = desc.szDesc;
1230 data.Module = desc.szDrvname;
1231 WideCharToMultiByte( CP_ACP, 0, nameW, size/sizeof(WCHAR), szInterface, size/sizeof(WCHAR), NULL, NULL );
1232 data.Interface = szInterface;
1234 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1235 err = mmErr(waveInMessage((HWAVEIN)wid, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1236 if (err == DS_OK && drv)
1237 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1239 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1241 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1242 (ppd->Callback)(&data, ppd->Context);
1244 HeapFree(GetProcessHeap(),0,szInterface);
1247 HeapFree(GetProcessHeap(),0,nameW);
1258 FIXME("*pcbReturned=%d\n", *pcbReturned);
1261 return E_PROP_ID_UNSUPPORTED;
1264 static HRESULT WINAPI DSPROPERTY_EnumerateW(
1267 PULONG pcbReturned )
1269 PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA) pPropData;
1271 TRACE("(pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1272 pPropData,cbPropData,pcbReturned);
1275 if (ppd->Callback) {
1276 unsigned devs, wod, wid;
1278 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
1280 devs = waveOutGetNumDevs();
1281 for (wod = 0; wod < devs; ++wod) {
1282 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1284 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
1285 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
1286 if (wDescription && wModule) {
1288 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0));
1290 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,size);
1292 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)wInterface, size));
1295 ZeroMemory(&data, sizeof(data));
1296 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
1297 data.WaveDeviceId = wod;
1298 data.DeviceId = DSOUND_renderer_guids[wod];
1300 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
1301 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
1303 data.Description = wDescription;
1304 data.Module = wModule;
1305 data.Interface = wInterface;
1307 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1308 err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1309 if (err == DS_OK && drv)
1310 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1312 WARN("waveOutMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1314 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1315 (ppd->Callback)(&data, ppd->Context);
1318 HeapFree(GetProcessHeap(),0,wInterface);
1321 HeapFree(GetProcessHeap(),0,wDescription);
1322 HeapFree(GetProcessHeap(),0,wModule);
1326 devs = waveInGetNumDevs();
1327 for (wid = 0; wid < devs; ++wid) {
1328 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
1330 WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
1331 WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
1332 if (wDescription && wModule) {
1334 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDEVICEINTERFACESIZE, (DWORD_PTR)&size, 0));
1336 WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,size);
1338 err = mmErr(waveInMessage((HWAVEIN)wid, DRV_QUERYDEVICEINTERFACE, (DWORD_PTR)wInterface, size));
1341 ZeroMemory(&data, sizeof(data));
1342 data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
1343 data.WaveDeviceId = wid;
1344 data.DeviceId = DSOUND_capture_guids[wid];
1346 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100 );
1347 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, wModule, 0x100 );
1349 data.Description = wDescription;
1350 data.Module = wModule;
1351 data.Interface = wInterface;
1352 data.Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
1353 err = mmErr(waveInMessage((HWAVEIN)wid, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&drv, 0));
1354 if (err == DS_OK && drv)
1355 data.Type = DIRECTSOUNDDEVICE_TYPE_VXD;
1357 WARN("waveInMessage(DRV_QUERYDSOUNDIFACE) failed\n");
1359 TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
1360 (ppd->Callback)(&data, ppd->Context);
1363 HeapFree(GetProcessHeap(),0,wInterface);
1366 HeapFree(GetProcessHeap(),0,wDescription);
1367 HeapFree(GetProcessHeap(),0,wModule);
1377 FIXME("*pcbReturned=%d\n", *pcbReturned);
1380 return E_PROP_ID_UNSUPPORTED;
1383 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get(
1384 LPKSPROPERTYSET iface,
1385 REFGUID guidPropSet,
1387 LPVOID pInstanceData,
1388 ULONG cbInstanceData,
1391 PULONG pcbReturned )
1393 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
1394 TRACE("(iface=%p,guidPropSet=%s,dwPropID=%d,pInstanceData=%p,cbInstanceData=%d,pPropData=%p,cbPropData=%d,pcbReturned=%p)\n",
1395 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
1397 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
1399 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
1400 return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned);
1401 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
1402 return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned);
1403 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
1404 return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned);
1405 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
1406 return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned);
1407 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
1408 return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned);
1409 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
1410 return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned);
1411 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
1412 return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned);
1413 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
1414 return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned);
1416 FIXME("unsupported ID: %d\n",dwPropID);
1420 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
1425 FIXME("*pcbReturned=%d\n", *pcbReturned);
1428 return E_PROP_ID_UNSUPPORTED;
1431 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set(
1432 LPKSPROPERTYSET iface,
1433 REFGUID guidPropSet,
1435 LPVOID pInstanceData,
1436 ULONG cbInstanceData,
1440 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
1442 FIXME("(%p,%s,%d,%p,%d,%p,%d), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
1443 return E_PROP_ID_UNSUPPORTED;
1446 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport(
1447 LPKSPROPERTYSET iface,
1448 REFGUID guidPropSet,
1450 PULONG pTypeSupport )
1452 IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
1453 TRACE("(%p,%s,%d,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
1455 if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
1457 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
1458 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1460 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
1461 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1463 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
1464 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1466 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
1467 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1469 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
1470 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1472 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
1473 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1475 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
1476 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1478 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
1479 *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1482 FIXME("unsupported ID: %d\n",dwPropID);
1486 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
1489 return E_PROP_ID_UNSUPPORTED;
1492 static const IKsPropertySetVtbl ikspvt = {
1493 IKsPrivatePropertySetImpl_QueryInterface,
1494 IKsPrivatePropertySetImpl_AddRef,
1495 IKsPrivatePropertySetImpl_Release,
1496 IKsPrivatePropertySetImpl_Get,
1497 IKsPrivatePropertySetImpl_Set,
1498 IKsPrivatePropertySetImpl_QuerySupport
1501 HRESULT IKsPrivatePropertySetImpl_Create(
1503 IKsPrivatePropertySetImpl **piks)
1505 IKsPrivatePropertySetImpl *iks;
1506 TRACE("(%s, %p)\n", debugstr_guid(riid), piks);
1508 if (!IsEqualIID(riid, &IID_IUnknown) &&
1509 !IsEqualIID(riid, &IID_IKsPropertySet)) {
1511 return E_NOINTERFACE;
1514 iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
1516 iks->lpVtbl = &ikspvt;