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