git.oblomov.eu Git - wine/blob - dlls/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include <sys/fcntl.h>
  28 #ifdef HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <math.h>       /* Insomnia - pow() function */
  34
  35 #define NONAMELESSUNION
  36 #define NONAMELESSSTRUCT
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "wingdi.h"
  40 #include "winuser.h"
  41 #include "winerror.h"
  42 #include "mmsystem.h"
  43 #include "winreg.h"
  44 #include "winternl.h"
  45 #include "winnls.h"
  46 #include "mmddk.h"
  47 #include "wine/windef16.h"
  48 #include "wine/debug.h"
  49 #include "dsound.h"
  50 #include "dsconf.h"
  51 #include "dsdriver.h"
  52 #include "dsound_private.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  55
  56
  57 /*******************************************************************************
  58  *              IKsBufferPropertySet
  59  */
  60
  61 /* IUnknown methods */
  62 static HRESULT WINAPI IKsBufferPropertySetImpl_QueryInterface(
  63     LPKSPROPERTYSET iface,
  64     REFIID riid,
  65     LPVOID *ppobj )
  66 {
  67     ICOM_THIS(IKsBufferPropertySetImpl,iface);
  68     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
  69
  70     return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb, riid, ppobj);
  71 }
  72
  73 static ULONG WINAPI IKsBufferPropertySetImpl_AddRef(LPKSPROPERTYSET iface)
  74 {
  75     ICOM_THIS(IKsBufferPropertySetImpl,iface);
  76     ULONG ulReturn;
  77
  78     TRACE("(%p) ref was %ld\n", This, This->ref);
  79     ulReturn = InterlockedIncrement(&(This->ref));
  80     return ulReturn;
  81 }
  82
  83 static ULONG WINAPI IKsBufferPropertySetImpl_Release(LPKSPROPERTYSET iface)
  84 {
  85     ICOM_THIS(IKsBufferPropertySetImpl,iface);
  86     ULONG ulReturn;
  87
  88     TRACE("(%p) ref was %ld\n", This, This->ref);
  89     ulReturn = InterlockedDecrement(&This->ref);
  90     if (!ulReturn) {
  91         This->dsb->iks = 0;
  92         IDirectSoundBuffer_Release((LPDIRECTSOUND3DBUFFER)This->dsb);
  93         HeapFree(GetProcessHeap(),0,This);
  94         TRACE("(%p) released\n",This);
  95     }
  96     return ulReturn;
  97 }
  98
  99 static HRESULT WINAPI IKsBufferPropertySetImpl_Get(
 100     LPKSPROPERTYSET iface,
 101     REFGUID guidPropSet,
 102     ULONG dwPropID,
 103     LPVOID pInstanceData,
 104     ULONG cbInstanceData,
 105     LPVOID pPropData,
 106     ULONG cbPropData,
 107     PULONG pcbReturned )
 108 {
 109     ICOM_THIS(IKsBufferPropertySetImpl,iface);
 110     PIDSDRIVERPROPERTYSET ps;
 111     TRACE("(iface=%p,guidPropSet=%s,dwPropID=%ld,pInstanceData=%p,cbInstanceData=%ld,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 112         This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
 113
 114     IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
 115
 116     if (ps) {
 117         DSPROPERTY prop;
 118         HRESULT hres;
 119
 120         prop.s.Set = *guidPropSet;
 121         prop.s.Id = dwPropID;
 122         prop.s.Flags = 0;       /* unused */
 123         prop.s.InstanceId = (ULONG)This->dsb->dsound;
 124
 125         hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
 126
 127         IDsDriverPropertySet_Release(ps);
 128
 129         return hres;
 130     }
 131
 132     return E_PROP_ID_UNSUPPORTED;
 133 }
 134
 135 static HRESULT WINAPI IKsBufferPropertySetImpl_Set(
 136     LPKSPROPERTYSET iface,
 137     REFGUID guidPropSet,
 138     ULONG dwPropID,
 139     LPVOID pInstanceData,
 140     ULONG cbInstanceData,
 141     LPVOID pPropData,
 142     ULONG cbPropData )
 143 {
 144     ICOM_THIS(IKsBufferPropertySetImpl,iface);
 145     PIDSDRIVERPROPERTYSET ps;
 146     TRACE("(%p,%s,%ld,%p,%ld,%p,%ld)\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
 147
 148     IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
 149
 150     if (ps) {
 151         DSPROPERTY prop;
 152         HRESULT hres;
 153
 154         prop.s.Set = *guidPropSet;
 155         prop.s.Id = dwPropID;
 156         prop.s.Flags = 0;       /* unused */
 157         prop.s.InstanceId = (ULONG)This->dsb->dsound;
 158         hres = IDsDriverPropertySet_Set(ps,&prop,pInstanceData,cbInstanceData,pPropData,cbPropData);
 159
 160         IDsDriverPropertySet_Release(ps);
 161
 162         return hres;
 163     }
 164
 165     return E_PROP_ID_UNSUPPORTED;
 166 }
 167
 168 static HRESULT WINAPI IKsBufferPropertySetImpl_QuerySupport(
 169     LPKSPROPERTYSET iface,
 170     REFGUID guidPropSet,
 171     ULONG dwPropID,
 172     PULONG pTypeSupport )
 173 {
 174     ICOM_THIS(IKsBufferPropertySetImpl,iface);
 175     PIDSDRIVERPROPERTYSET ps;
 176     TRACE("(%p,%s,%ld,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
 177
 178     IDsDriver_QueryInterface(This->dsb->hwbuf, &IID_IDsDriverPropertySet, (void **)&ps);
 179
 180     if (ps) {
 181         HRESULT hres;
 182
 183         hres = IDsDriverPropertySet_QuerySupport(ps,guidPropSet, dwPropID,pTypeSupport);
 184
 185         IDsDriverPropertySet_Release(ps);
 186
 187         return hres;
 188     }
 189
 190     return E_PROP_ID_UNSUPPORTED;
 191 }
 192
 193 static ICOM_VTABLE(IKsPropertySet) iksbvt = {
 194     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 195     IKsBufferPropertySetImpl_QueryInterface,
 196     IKsBufferPropertySetImpl_AddRef,
 197     IKsBufferPropertySetImpl_Release,
 198     IKsBufferPropertySetImpl_Get,
 199     IKsBufferPropertySetImpl_Set,
 200     IKsBufferPropertySetImpl_QuerySupport
 201 };
 202
 203 HRESULT WINAPI IKsBufferPropertySetImpl_Create(
 204     IDirectSoundBufferImpl *dsb,
 205     IKsBufferPropertySetImpl **piks)
 206 {
 207     IKsBufferPropertySetImpl *iks;
 208     TRACE("(%p,%p)\n",dsb,piks);
 209
 210     iks = (IKsBufferPropertySetImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*iks));
 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 /*******************************************************************************
 223  *              IKsPrivatePropertySet
 224  */
 225
 226 /* IUnknown methods */
 227 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
 228     LPKSPROPERTYSET iface,
 229     REFIID riid,
 230     LPVOID *ppobj )
 231 {
 232     ICOM_THIS(IKsPrivatePropertySetImpl,iface);
 233     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 234
 235     *ppobj = NULL;
 236     return DSERR_INVALIDPARAM;
 237 }
 238
 239 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface)
 240 {
 241     ICOM_THIS(IKsPrivatePropertySetImpl,iface);
 242     ULONG ulReturn;
 243
 244     TRACE("(%p) ref was %ld\n", This, This->ref);
 245     ulReturn = InterlockedIncrement(&This->ref);
 246     return ulReturn;
 247 }
 248
 249 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
 250 {
 251     ICOM_THIS(IKsPrivatePropertySetImpl,iface);
 252     ULONG ulReturn;
 253
 254     TRACE("(%p) ref was %ld\n", This, This->ref);
 255     ulReturn = InterlockedDecrement(&This->ref);
 256     return ulReturn;
 257 }
 258
 259 static HRESULT WINAPI DSPROPERTY_WaveDeviceMappingA(
 260     REFGUID guidPropSet,
 261     LPVOID pPropData,
 262     ULONG cbPropData,
 263     PULONG pcbReturned )
 264 {
 265     PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA ppd;
 266     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) not implemented!\n",
 267         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 268
 269     ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA) pPropData;
 270
 271     if (!ppd) {
 272         WARN("invalid parameter: pPropData\n");
 273         return DSERR_INVALIDPARAM;
 274     }
 275
 276     FIXME("DeviceName=%s\n",ppd->DeviceName);
 277     FIXME("DataFlow=%s\n",
 278         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER ? "DIRECTSOUNDDEVICE_DATAFLOW_RENDER" :
 279         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE ? "DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE" : "UNKNOWN");
 280
 281     /* FIXME: match the name to a wave device somehow. */
 282     ppd->DeviceId = GUID_NULL;
 283
 284     if (pcbReturned) {
 285         *pcbReturned = cbPropData;
 286         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 287     }
 288
 289     return S_OK;
 290 }
 291
 292 static HRESULT WINAPI DSPROPERTY_WaveDeviceMappingW(
 293     REFGUID guidPropSet,
 294     LPVOID pPropData,
 295     ULONG cbPropData,
 296     PULONG pcbReturned )
 297 {
 298     PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
 299     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) not implemented!\n",
 300         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 301
 302     ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA) pPropData;
 303
 304     if (!ppd) {
 305         WARN("invalid parameter: pPropData\n");
 306         return DSERR_INVALIDPARAM;
 307     }
 308
 309     FIXME("DeviceName=%s\n",debugstr_w(ppd->DeviceName));
 310     FIXME("DataFlow=%s\n",
 311         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER ? "DIRECTSOUNDDEVICE_DATAFLOW_RENDER" :
 312         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE ? "DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE" : "UNKNOWN");
 313
 314     /* FIXME: match the name to a wave device somehow. */
 315     ppd->DeviceId = GUID_NULL;
 316
 317     if (pcbReturned) {
 318         *pcbReturned = cbPropData;
 319         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 320     }
 321
 322     return S_OK;
 323 }
 324
 325 static HRESULT WINAPI DSPROPERTY_Description1(
 326     REFGUID guidPropSet,
 327     LPVOID pPropData,
 328     ULONG cbPropData,
 329     PULONG pcbReturned )
 330 {
 331     HRESULT err;
 332     GUID guid, dev_guid;
 333     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA ppd;
 334     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 335         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 336
 337     ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA) pPropData;
 338
 339     if (!ppd) {
 340         WARN("invalid parameter: pPropData\n");
 341         return DSERR_INVALIDPARAM;
 342     }
 343
 344     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 345     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 346         /* default device of type specified by ppd->DataFlow */
 347         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 348             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 349         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 350             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 351         } else {
 352             TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 353         }
 354         FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) GUID_NULL not implemented!\n",
 355             debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 356         return E_PROP_ID_UNSUPPORTED;
 357     }
 358
 359     ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
 360     GetDeviceID(&ppd->DeviceId, &dev_guid);
 361
 362     if ( IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultPlayback) ||
 363          IsEqualGUID( &ppd->DeviceId, &DSDEVID_DefaultVoicePlayback) ) {
 364         ULONG wod;
 365         int wodn;
 366         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 367         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 368         wodn = waveOutGetNumDevs();
 369         for (wod = 0; wod < wodn; wod++) {
 370             err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 371             if (err == DS_OK) {
 372                 if (IsEqualGUID( &dev_guid, &guid) ) {
 373                     DSDRIVERDESC desc;
 374                     ppd->WaveDeviceId = wod;
 375                     ppd->Devnode = wod;
 376                     err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 377                     if (err == DS_OK) {
 378                         PIDSDRIVER drv = NULL;
 379                         strncpy(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA) - 1);
 380                         strncpy(ppd->ModuleA, desc.szDrvName, sizeof(ppd->ModuleA) - 1);
 381                         MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
 382                         MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
 383                         err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD)&drv, 0));
 384                         if (err == DS_OK && drv)
 385                                 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 386                         break;
 387                     } else {
 388                         WARN("waveOutMessage failed\n");
 389                         return E_PROP_ID_UNSUPPORTED;
 390                     }
 391                 }
 392             } else {
 393                 WARN("waveOutMessage failed\n");
 394                 return E_PROP_ID_UNSUPPORTED;
 395             }
 396         }
 397     } else if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
 398                 IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
 399         ULONG wid;
 400         int widn;
 401         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 402         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 403         widn = waveInGetNumDevs();
 404         for (wid = 0; wid < widn; wid++) {
 405             err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 406             if (err == DS_OK) {
 407                 if (IsEqualGUID( &dev_guid, &guid) ) {
 408                     DSDRIVERDESC desc;
 409                     ppd->WaveDeviceId = wid;
 410                     ppd->Devnode = wid;
 411                     err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 412                     if (err == DS_OK) {
 413                         PIDSCDRIVER drv;
 414                         strncpy(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA) - 1);
 415                         strncpy(ppd->ModuleA, desc.szDrvName, sizeof(ppd->ModuleA) - 1);
 416                         MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
 417                         MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
 418                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD)&drv,0));
 419                         if (err == DS_OK && drv)
 420                                 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 421                         break;
 422                     } else {
 423                         WARN("waveInMessage failed\n");
 424                         return E_PROP_ID_UNSUPPORTED;
 425                     }
 426                     break;
 427                 }
 428             } else {
 429                 WARN("waveInMessage failed\n");
 430                 return E_PROP_ID_UNSUPPORTED;
 431             }
 432         }
 433     } else {
 434         BOOL found = FALSE;
 435         ULONG wod;
 436         int wodn;
 437         /* given specific device so try the render devices first */
 438         wodn = waveOutGetNumDevs();
 439         for (wod = 0; wod < wodn; wod++) {
 440             err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 441             if (err == DS_OK) {
 442                 if (IsEqualGUID( &ppd->DeviceId, &guid) ) {
 443                     DSDRIVERDESC desc;
 444                     TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 445                     ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 446                     ppd->WaveDeviceId = wod;
 447                     ppd->Devnode = wod;
 448                     err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 449                     if (err == DS_OK) {
 450                         PIDSDRIVER drv = NULL;
 451                         strncpy(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA) - 1);
 452                         strncpy(ppd->ModuleA, desc.szDrvName, sizeof(ppd->ModuleA) - 1);
 453                         MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
 454                         MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
 455                         err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD)&drv, 0));
 456                         if (err == DS_OK && drv)
 457                                 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 458                         found = TRUE;
 459                         break;
 460                     } else {
 461                         WARN("waveOutMessage failed\n");
 462                         return E_PROP_ID_UNSUPPORTED;
 463                     }
 464                 }
 465             } else {
 466                 WARN("waveOutMessage failed\n");
 467                 return E_PROP_ID_UNSUPPORTED;
 468             }
 469         }
 470
 471         if (found == FALSE) {
 472             WARN("device not found\n");
 473             return E_PROP_ID_UNSUPPORTED;
 474         }
 475     }
 476
 477     if (pcbReturned) {
 478         *pcbReturned = cbPropData;
 479         TRACE("*pcbReturned=%ld\n", *pcbReturned);
 480     }
 481
 482     return S_OK;
 483 }
 484
 485 static HRESULT WINAPI DSPROPERTY_DescriptionA(
 486     REFGUID guidPropSet,
 487     LPVOID pPropData,
 488     ULONG cbPropData,
 489     PULONG pcbReturned )
 490 {
 491     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA) pPropData;
 492     HRESULT err;
 493     GUID guid, dev_guid;
 494     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 495         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 496
 497     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 498     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 499         /* default device of type specified by ppd->DataFlow */
 500         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 501             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 502         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 503             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 504         } else {
 505             TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 506         }
 507         FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) GUID_NULL not implemented!\n",
 508             debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 509         return E_PROP_ID_UNSUPPORTED;
 510     }
 511
 512     ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
 513     GetDeviceID(&ppd->DeviceId, &dev_guid);
 514
 515     if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
 516          IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
 517         ULONG wod;
 518         int wodn;
 519         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 520         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 521         wodn = waveOutGetNumDevs();
 522         for (wod = 0; wod < wodn; wod++) {
 523             err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 524             if (err == DS_OK) {
 525                 if (IsEqualGUID( &dev_guid, &guid) ) {
 526                     DSDRIVERDESC desc;
 527                     ppd->WaveDeviceId = wod;
 528                     err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 529                     if (err == DS_OK) {
 530                         PIDSDRIVER drv = NULL;
 531                         /* FIXME: this is a memory leak */
 532                         CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
 533                         CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvName) + 1);
 534                         CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
 535
 536                         strcpy(szDescription, desc.szDesc);
 537                         strcpy(szModule, desc.szDrvName);
 538                         strcpy(szInterface, "Interface");
 539
 540                         ppd->Description = szDescription;
 541                         ppd->Module = szModule;
 542                         ppd->Interface = szInterface;
 543                         err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD)&drv, 0));
 544                         if (err == DS_OK && drv)
 545                             ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 546                         break;
 547                     } else {
 548                         WARN("waveOutMessage failed\n");
 549                         return E_PROP_ID_UNSUPPORTED;
 550                     }
 551                 }
 552             } else {
 553                 WARN("waveOutMessage failed\n");
 554                 return E_PROP_ID_UNSUPPORTED;
 555             }
 556         }
 557     } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
 558                IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
 559         ULONG wid;
 560         int widn;
 561         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 562         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 563         widn = waveInGetNumDevs();
 564         for (wid = 0; wid < widn; wid++) {
 565             err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 566             if (err == DS_OK) {
 567                 if (IsEqualGUID( &dev_guid, &guid) ) {
 568                     DSDRIVERDESC desc;
 569                     ppd->WaveDeviceId = wid;
 570                     err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 571                     if (err == DS_OK) {
 572                         PIDSCDRIVER drv;
 573                         /* FIXME: this is a memory leak */
 574                         CHAR * szDescription = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDesc) + 1);
 575                         CHAR * szModule = HeapAlloc(GetProcessHeap(),0,strlen(desc.szDrvName) + 1);
 576                         CHAR * szInterface = HeapAlloc(GetProcessHeap(),0,strlen("Interface") + 1);
 577
 578                         strcpy(szDescription, desc.szDesc);
 579                         strcpy(szModule, desc.szDrvName);
 580                         strcpy(szInterface, "Interface");
 581
 582                         ppd->Description = szDescription;
 583                         ppd->Module = szModule;
 584                         ppd->Interface = szInterface;
 585                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD)&drv,0));
 586                         if (err == DS_OK && drv)
 587                                 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 588                         break;
 589                     } else {
 590                         WARN("waveInMessage failed\n");
 591                         return E_PROP_ID_UNSUPPORTED;
 592                     }
 593                     break;
 594                 }
 595             } else {
 596                 WARN("waveOutMessage failed\n");
 597                 return E_PROP_ID_UNSUPPORTED;
 598             }
 599         }
 600     }
 601
 602     if (pcbReturned) {
 603         *pcbReturned = cbPropData;
 604         TRACE("*pcbReturned=%ld\n", *pcbReturned);
 605     }
 606
 607     return S_OK;
 608 }
 609
 610 static HRESULT WINAPI DSPROPERTY_DescriptionW(
 611     REFGUID guidPropSet,
 612     LPVOID pPropData,
 613     ULONG cbPropData,
 614     PULONG pcbReturned )
 615 {
 616     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA) pPropData;
 617     HRESULT err;
 618     GUID guid, dev_guid;
 619     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 620         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 621
 622     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 623     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 624         /* default device of type specified by ppd->DataFlow */
 625         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 626             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 627         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 628             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 629         } else {
 630             TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 631         }
 632         FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) GUID_NULL not implemented!\n",
 633             debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 634         return E_PROP_ID_UNSUPPORTED;
 635     }
 636
 637     ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
 638     GetDeviceID(&ppd->DeviceId, &dev_guid);
 639
 640     if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
 641          IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
 642         ULONG wod;
 643         int wodn;
 644         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 645         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 646         wodn = waveOutGetNumDevs();
 647         for (wod = 0; wod < wodn; wod++) {
 648             err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 649             if (err == DS_OK) {
 650                 if (IsEqualGUID( &dev_guid, &guid) ) {
 651                     DSDRIVERDESC desc;
 652                     ppd->WaveDeviceId = wod;
 653                     err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 654                     if (err == DS_OK) {
 655                         PIDSDRIVER drv = NULL;
 656                         /* FIXME: this is a memory leak */
 657                         WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
 658                         WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
 659                         WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
 660
 661                         MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100  );
 662                         MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, wModule, 0x100 );
 663                         MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
 664
 665                         ppd->Description = wDescription;
 666                         ppd->Module = wModule;
 667                         ppd->Interface = wInterface;
 668                         err = mmErr(waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD)&drv, 0));
 669                         if (err == DS_OK && drv)
 670                                 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 671                             break;
 672                     } else {
 673                         WARN("waveOutMessage failed\n");
 674                         return E_PROP_ID_UNSUPPORTED;
 675                     }
 676                 }
 677             } else {
 678                 WARN("waveOutMessage failed\n");
 679                 return E_PROP_ID_UNSUPPORTED;
 680             }
 681         }
 682     } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
 683                IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
 684         ULONG wid;
 685         int widn;
 686         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 687         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 688         widn = waveInGetNumDevs();
 689         for (wid = 0; wid < widn; wid++) {
 690             err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 691             if (err == DS_OK) {
 692                 if (IsEqualGUID( &dev_guid, &guid) ) {
 693                     DSDRIVERDESC desc;
 694                     ppd->WaveDeviceId = wid;
 695                     err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 696                     if (err == DS_OK) {
 697                         PIDSCDRIVER drv;
 698                         /* FIXME: this is a memory leak */
 699                         WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
 700                         WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
 701                         WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
 702
 703                         MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100  );
 704                         MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, wModule, 0x100 );
 705                         MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
 706
 707                         ppd->Description = wDescription;
 708                         ppd->Module = wModule;
 709                         ppd->Interface = wInterface;
 710                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD)&drv,0));
 711                         if (err == DS_OK && drv)
 712                                 ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 713                         break;
 714                     } else {
 715                         WARN("waveInMessage failed\n");
 716                         return E_PROP_ID_UNSUPPORTED;
 717                     }
 718                     break;
 719                 }
 720             } else {
 721                 WARN("waveInMessage failed\n");
 722                 return E_PROP_ID_UNSUPPORTED;
 723             }
 724         }
 725     } else {
 726         FIXME("DeviceId=Unknown\n");
 727         return E_PROP_ID_UNSUPPORTED;
 728     }
 729
 730     if (pcbReturned) {
 731         *pcbReturned = cbPropData;
 732         TRACE("*pcbReturned=%ld\n", *pcbReturned);
 733     }
 734
 735     return S_OK;
 736 }
 737
 738 static HRESULT WINAPI DSPROPERTY_Enumerate1(
 739     REFGUID guidPropSet,
 740     LPVOID pPropData,
 741     ULONG cbPropData,
 742     PULONG pcbReturned )
 743 {
 744     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 745         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 746     return E_PROP_ID_UNSUPPORTED;
 747 }
 748
 749 static HRESULT WINAPI DSPROPERTY_EnumerateA(
 750     REFGUID guidPropSet,
 751     LPVOID pPropData,
 752     ULONG cbPropData,
 753     PULONG pcbReturned )
 754 {
 755     PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA) pPropData;
 756     HRESULT err;
 757     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 758         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 759
 760     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 761         if (ppd) {
 762             if (ppd->Callback) {
 763                 unsigned devs, wod, wid;
 764                 DSDRIVERDESC desc;
 765                 GUID guid;
 766                 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA data;
 767
 768                 devs = waveOutGetNumDevs();
 769                 for (wod = 0; wod < devs; ++wod) {
 770                     err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 771                     if (err == DS_OK) {
 772                         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 773                         if (err == DS_OK) {
 774                             memset(&data, 0, sizeof(data));
 775                             data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 776                             data.WaveDeviceId = wod;
 777                             data.DeviceId = guid;
 778                             data.Description = desc.szDesc;
 779                             data.Module = desc.szDrvName;
 780                             data.Interface = "Interface";
 781                             TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
 782                             (ppd->Callback)(&data, ppd->Context);
 783                         }
 784                     }
 785                 }
 786
 787                 devs = waveInGetNumDevs();
 788                 for (wid = 0; wid < devs; ++wid) {
 789                     err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 790                     if (err == DS_OK) {
 791                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 792                         if (err == DS_OK) {
 793                             memset(&data, 0, sizeof(data));
 794                             data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 795                             data.WaveDeviceId = wid;
 796                             data.DeviceId = guid;
 797                             data.Description = desc.szDesc;
 798                             data.Module = desc.szDrvName;
 799                             data.Interface = "Interface";
 800                             TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
 801                             (ppd->Callback)(&data, ppd->Context);
 802                         }
 803                     }
 804                 }
 805
 806                 return S_OK;
 807             }
 808         }
 809     } else {
 810         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 811     }
 812
 813     if (pcbReturned) {
 814         *pcbReturned = 0;
 815         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 816     }
 817
 818     return E_PROP_ID_UNSUPPORTED;
 819 }
 820
 821 static HRESULT WINAPI DSPROPERTY_EnumerateW(
 822     REFGUID guidPropSet,
 823     LPVOID pPropData,
 824     ULONG cbPropData,
 825     PULONG pcbReturned )
 826 {
 827     PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA) pPropData;
 828     HRESULT err;
 829     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 830         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 831
 832     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 833         if (ppd) {
 834             if (ppd->Callback) {
 835                 unsigned devs, wod, wid;
 836                 DSDRIVERDESC desc;
 837                 GUID guid;
 838                 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 839
 840                 devs = waveOutGetNumDevs();
 841                 for (wod = 0; wod < devs; ++wod) {
 842                     err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 843                     if (err == DS_OK) {
 844                         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 845                         if (err == DS_OK) {
 846                             /* FIXME: this is a memory leak */
 847                             WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
 848                             WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
 849                             WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
 850
 851                             memset(&data, 0, sizeof(data));
 852                             data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 853                             data.WaveDeviceId = wod;
 854                             data.DeviceId = guid;
 855
 856                             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100  );
 857                             MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, wModule, 0x100 );
 858                             MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
 859
 860                             data.Description = wDescription;
 861                             data.Module = wModule;
 862                             data.Interface = wInterface;
 863                             TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
 864                             (ppd->Callback)(&data, ppd->Context);
 865                         }
 866                     }
 867                 }
 868
 869                 devs = waveInGetNumDevs();
 870                 for (wid = 0; wid < devs; ++wid) {
 871                     err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 872                     if (err == DS_OK) {
 873                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 874                         if (err == DS_OK) {
 875                             /* FIXME: this is a memory leak */
 876                             WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
 877                             WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
 878                             WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
 879
 880                             memset(&data, 0, sizeof(data));
 881                             data.DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 882                             data.WaveDeviceId = wid;
 883                             data.DeviceId = guid;
 884
 885                             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100  );
 886                             MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, wModule, 0x100 );
 887                             MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
 888
 889                             data.Description = wDescription;
 890                             data.Module = wModule;
 891                             data.Interface = wInterface;
 892                             TRACE("calling Callback(%p,%p)\n", &data, ppd->Context);
 893                             (ppd->Callback)(&data, ppd->Context);
 894                         }
 895                     }
 896                 }
 897
 898                 return S_OK;
 899             }
 900         }
 901     } else {
 902         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 903     }
 904
 905     if (pcbReturned) {
 906         *pcbReturned = 0;
 907         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 908     }
 909
 910     return E_PROP_ID_UNSUPPORTED;
 911 }
 912
 913 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get(
 914     LPKSPROPERTYSET iface,
 915     REFGUID guidPropSet,
 916     ULONG dwPropID,
 917     LPVOID pInstanceData,
 918     ULONG cbInstanceData,
 919     LPVOID pPropData,
 920     ULONG cbPropData,
 921     PULONG pcbReturned
 922 ) {
 923     ICOM_THIS(IKsPrivatePropertySetImpl,iface);
 924     TRACE("(iface=%p,guidPropSet=%s,dwPropID=%ld,pInstanceData=%p,cbInstanceData=%ld,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 925         This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
 926
 927     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 928         switch (dwPropID) {
 929         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 930             return DSPROPERTY_WaveDeviceMappingA(guidPropSet,pPropData,cbPropData,pcbReturned);
 931         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 932             return DSPROPERTY_Description1(guidPropSet,pPropData,cbPropData,pcbReturned);
 933         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 934             return DSPROPERTY_Enumerate1(guidPropSet,pPropData,cbPropData,pcbReturned);
 935         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 936             return DSPROPERTY_WaveDeviceMappingW(guidPropSet,pPropData,cbPropData,pcbReturned);
 937         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
 938             return DSPROPERTY_DescriptionA(guidPropSet,pPropData,cbPropData,pcbReturned);
 939         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
 940             return DSPROPERTY_DescriptionW(guidPropSet,pPropData,cbPropData,pcbReturned);
 941         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
 942             return DSPROPERTY_EnumerateA(guidPropSet,pPropData,cbPropData,pcbReturned);
 943         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
 944             return DSPROPERTY_EnumerateW(guidPropSet,pPropData,cbPropData,pcbReturned);
 945         default:
 946             FIXME("unsupported ID: %ld\n",dwPropID);
 947             break;
 948         }
 949     } else {
 950         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 951     }
 952
 953     if (pcbReturned) {
 954         *pcbReturned = 0;
 955         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 956     }
 957
 958     return E_PROP_ID_UNSUPPORTED;
 959 }
 960
 961 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set(
 962     LPKSPROPERTYSET iface,
 963     REFGUID guidPropSet,
 964     ULONG dwPropID,
 965     LPVOID pInstanceData,
 966     ULONG cbInstanceData,
 967     LPVOID pPropData,
 968     ULONG cbPropData )
 969 {
 970     ICOM_THIS(IKsPrivatePropertySetImpl,iface);
 971
 972     FIXME("(%p,%s,%ld,%p,%ld,%p,%ld), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
 973     return E_PROP_ID_UNSUPPORTED;
 974 }
 975
 976 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport(
 977     LPKSPROPERTYSET iface,
 978     REFGUID guidPropSet,
 979     ULONG dwPropID,
 980     PULONG pTypeSupport )
 981 {
 982     ICOM_THIS(IKsPrivatePropertySetImpl,iface);
 983     TRACE("(%p,%s,%ld,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
 984
 985     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 986         switch (dwPropID) {
 987         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 988             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 989             return S_OK;
 990         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 991             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 992             return S_OK;
 993         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 994             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 995             return S_OK;
 996         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 997             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 998             return S_OK;
 999         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
1000             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1001             return S_OK;
1002         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
1003             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1004             return S_OK;
1005         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
1006             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1007             return S_OK;
1008         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
1009             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
1010             return S_OK;
1011         default:
1012             FIXME("unsupported ID: %ld\n",dwPropID);
1013             break;
1014         }
1015     } else {
1016         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
1017     }
1018
1019     return E_PROP_ID_UNSUPPORTED;
1020 }
1021
1022 static ICOM_VTABLE(IKsPropertySet) ikspvt = {
1023     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1024     IKsPrivatePropertySetImpl_QueryInterface,
1025     IKsPrivatePropertySetImpl_AddRef,
1026     IKsPrivatePropertySetImpl_Release,
1027     IKsPrivatePropertySetImpl_Get,
1028     IKsPrivatePropertySetImpl_Set,
1029     IKsPrivatePropertySetImpl_QuerySupport
1030 };
1031
1032 HRESULT WINAPI IKsPrivatePropertySetImpl_Create(
1033     IKsPrivatePropertySetImpl **piks)
1034 {
1035     IKsPrivatePropertySetImpl *iks;
1036
1037     iks = (IKsPrivatePropertySetImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
1038     iks->ref = 0;
1039     iks->lpVtbl = &ikspvt;
1040
1041     *piks = iks;
1042     return S_OK;
1043 }