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