git.oblomov.eu Git - wine/blob - dlls/dsound/propset.c

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