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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #ifdef __WINESRC__
  25
  26 #define COBJMACROS
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "mmsystem.h"
  32 #include "winternl.h"
  33 #include "winnls.h"
  34 #include "vfwmsgs.h"
  35 #include "mmddk.h"
  36 #include "wine/debug.h"
  37 #include "dsound.h"
  38 #include "dsdriver.h"
  39
  40 #include "dsound_private.h"
  41 #include "dsconf.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  44
  45 #else
  46
  47 #define WINVER 0x0600
  48 #include <windows.h>
  49 #include <dsound.h>
  50
  51 #include "dsound_private.h"
  52
  53 typedef enum
  54 {
  55         DIRECTSOUNDDEVICE_DATAFLOW_RENDER,
  56         DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE
  57 } DIRECTSOUNDDEVICE_DATAFLOW;
  58
  59 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA
  60 {
  61         LPSTR                           DeviceName;
  62         DIRECTSOUNDDEVICE_DATAFLOW      DataFlow;
  63         GUID                            DeviceId;
  64 } DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA;
  65
  66 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA
  67 {
  68         LPWSTR                          DeviceName;
  69         DIRECTSOUNDDEVICE_DATAFLOW      DataFlow;
  70         GUID                            DeviceId;
  71 } DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA;
  72
  73 typedef enum
  74 {
  75         DIRECTSOUNDDEVICE_TYPE_EMULATED,
  76         DIRECTSOUNDDEVICE_TYPE_VXD,
  77         DIRECTSOUNDDEVICE_TYPE_WDM
  78 } DIRECTSOUNDDEVICE_TYPE;
  79
  80 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA
  81 {
  82         GUID                            DeviceId;
  83         CHAR                            DescriptionA[0x100];
  84         WCHAR                           DescriptionW[0x100];
  85         CHAR                            ModuleA[MAX_PATH];
  86         WCHAR                           ModuleW[MAX_PATH];
  87         DIRECTSOUNDDEVICE_TYPE          Type;
  88         DIRECTSOUNDDEVICE_DATAFLOW      DataFlow;
  89         ULONG                           WaveDeviceId;
  90         ULONG                           Devnode;
  91 } DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA;
  92
  93 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA
  94 {
  95         DIRECTSOUNDDEVICE_TYPE          Type;
  96         DIRECTSOUNDDEVICE_DATAFLOW      DataFlow;
  97         GUID                            DeviceId;
  98         LPSTR                           Description;
  99         LPSTR                           Module;
 100         LPSTR                           Interface;
 101         ULONG                           WaveDeviceId;
 102 } DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA;
 103
 104 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA
 105 {
 106         DIRECTSOUNDDEVICE_TYPE          Type;
 107         DIRECTSOUNDDEVICE_DATAFLOW      DataFlow;
 108         GUID                            DeviceId;
 109         LPWSTR                          Description;
 110         LPWSTR                          Module;
 111         LPWSTR                          Interface;
 112         ULONG                           WaveDeviceId;
 113 } DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA;
 114
 115 typedef struct _DSDRIVERDESC
 116 {
 117     DWORD       dwFlags;
 118     CHAR        szDesc[256];
 119     CHAR        szDrvname[256];
 120     DWORD       dnDevNode;
 121     WORD        wVxdId;
 122     WORD        wReserved;
 123     ULONG       ulDeviceNum;
 124     DWORD       dwHeapType;
 125     LPVOID      pvDirectDrawHeap;
 126     DWORD       dwMemStartAddress;
 127     DWORD       dwMemEndAddress;
 128     DWORD       dwMemAllocExtra;
 129     LPVOID      pvReserved1;
 130     LPVOID      pvReserved2;
 131 } DSDRIVERDESC,*PDSDRIVERDESC;
 132
 133 #ifndef E_PROP_ID_UNSUPPORTED
 134 #define E_PROP_ID_UNSUPPORTED            ((HRESULT)0x80070490)
 135 #endif
 136
 137 #ifndef DRV_QUERYDSOUNDDESC
 138 #define DRV_QUERYDSOUNDDESC             (DRV_RESERVED + 21)
 139 #endif
 140
 141 typedef BOOL (CALLBACK *LPFNDIRECTSOUNDDEVICEENUMERATECALLBACK1)(PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA, LPVOID);
 142 typedef BOOL (CALLBACK *LPFNDIRECTSOUNDDEVICEENUMERATECALLBACKA)(PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA, LPVOID);
 143 typedef BOOL (CALLBACK *LPFNDIRECTSOUNDDEVICEENUMERATECALLBACKW)(PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA, LPVOID);
 144
 145 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA
 146 {
 147         LPFNDIRECTSOUNDDEVICEENUMERATECALLBACK1 Callback;
 148         LPVOID                                  Context;
 149 } DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA;
 150
 151 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA
 152 {
 153         LPFNDIRECTSOUNDDEVICEENUMERATECALLBACKA Callback;
 154         LPVOID                                  Context;
 155 } DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA;
 156
 157 typedef struct _DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA
 158 {
 159         LPFNDIRECTSOUNDDEVICEENUMERATECALLBACKW Callback;
 160         LPVOID                                  Context;
 161 } DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA, *PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA;
 162
 163 DEFINE_GUID(DSPROPSETID_DirectSoundDevice,0x84624f82,0x25ec,0x11d1,0xa4,0xd8,0x00,0xc0,0x4f,0xc2,0x8a,0xca);
 164
 165 typedef enum
 166 {
 167         DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A = 1,
 168         DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1       = 2,
 169         DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1         = 3,
 170         DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W = 4,
 171         DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A       = 5,
 172         DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W       = 6,
 173         DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A         = 7,
 174         DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W         = 8,
 175 } DSPROPERTY_DIRECTSOUNDDEVICE;
 176
 177 #ifndef ULongToHandle
 178 #define ULongToHandle(ul)       ((HANDLE)(ULONG_PTR)(ul))
 179 #endif
 180 #ifndef UlongToHandle
 181 #define UlongToHandle(ul)       ULongToHandle(ul)
 182 #endif
 183
 184 #endif
 185
 186 typedef struct IKsPrivatePropertySetImpl {
 187     IKsPropertySet IKsPropertySet_iface;
 188     LONG           ref;
 189 } IKsPrivatePropertySetImpl;
 190
 191 /*******************************************************************************
 192  *              IKsPrivatePropertySet
 193  */
 194
 195 /* IUnknown methods */
 196 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
 197     LPKSPROPERTYSET iface,
 198     REFIID riid,
 199     LPVOID *ppobj )
 200 {
 201     IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
 202     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 203
 204     if (IsEqualIID(riid, &IID_IUnknown) ||
 205         IsEqualIID(riid, &IID_IKsPropertySet)) {
 206         *ppobj = iface;
 207         IUnknown_AddRef(iface);
 208         return S_OK;
 209     }
 210     *ppobj = NULL;
 211     return E_NOINTERFACE;
 212 }
 213
 214 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface)
 215 {
 216     IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
 217     ULONG ref = InterlockedIncrement(&(This->ref));
 218     TRACE("(%p) ref was %u\n", This, (UINT)ref - 1);
 219     return ref;
 220 }
 221
 222 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
 223 {
 224     IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
 225     ULONG ref = InterlockedDecrement(&(This->ref));
 226     TRACE("(%p) ref was %u\n", This, (UINT)ref + 1);
 227
 228     if (!ref) {
 229         HeapFree(GetProcessHeap(), 0, This);
 230         TRACE("(%p) released\n", This);
 231     }
 232     return ref;
 233 }
 234
 235 static HRESULT DSPROPERTY_WaveDeviceMappingW(
 236     LPVOID pPropData,
 237     ULONG cbPropData,
 238     PULONG pcbReturned )
 239 {
 240     HRESULT hr = DSERR_INVALIDPARAM;
 241     PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
 242     TRACE("(pPropData=%p,cbPropData=%u,pcbReturned=%p)\n",
 243           pPropData,(UINT)cbPropData,pcbReturned);
 244
 245     ppd = pPropData;
 246
 247     if (!ppd) {
 248         WARN("invalid parameter: pPropData\n");
 249         return DSERR_INVALIDPARAM;
 250     }
 251
 252     if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 253         ULONG wod;
 254         unsigned int wodn;
 255         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 256         wodn = waveOutGetNumDevs();
 257         for (wod = 0; wod < wodn; wod++) {
 258             WAVEOUTCAPSW capsW;
 259             MMRESULT res;
 260             res = waveOutGetDevCapsW(wod, &capsW, sizeof(capsW));
 261             if (res == MMSYSERR_NOERROR) {
 262                 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
 263                     ppd->DeviceId = DSOUND_renderer_guid;
 264                     ppd->DeviceId.Data4[7] = wod;
 265                     hr = DS_OK;
 266                     TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
 267                           debugstr_w(ppd->DeviceName));
 268                     break;
 269                 }
 270             }
 271         }
 272     } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 273         ULONG wid;
 274         unsigned int widn;
 275         TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 276         widn = waveInGetNumDevs();
 277         for (wid = 0; wid < widn; wid++) {
 278             WAVEINCAPSW capsW;
 279             MMRESULT res;
 280             res = waveInGetDevCapsW(wid, &capsW, sizeof(capsW));
 281             if (res == MMSYSERR_NOERROR) {
 282                 if (lstrcmpW(capsW.szPname, ppd->DeviceName) == 0) {
 283                     ppd->DeviceId = DSOUND_capture_guid;
 284                     ppd->DeviceId.Data4[7] = wid;
 285                     hr = DS_OK;
 286                     TRACE("found %s for %s\n", debugstr_guid(&ppd->DeviceId),
 287                           debugstr_w(ppd->DeviceName));
 288                     break;
 289                 }
 290             }
 291         }
 292     }
 293
 294     if (pcbReturned)
 295         *pcbReturned = cbPropData;
 296
 297     return hr;
 298 }
 299
 300 static HRESULT DSPROPERTY_WaveDeviceMappingA(
 301     LPVOID pPropData,
 302     ULONG cbPropData,
 303     PULONG pcbReturned )
 304 {
 305     DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA *ppd = pPropData;
 306     DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA data;
 307     DWORD len;
 308     HRESULT hr;
 309
 310     TRACE("(pPropData=%p,cbPropData=%u,pcbReturned=%p)\n",
 311       pPropData,(UINT)cbPropData,pcbReturned);
 312
 313     if (!ppd || !ppd->DeviceName) {
 314         WARN("invalid parameter: ppd=%p\n", ppd);
 315         return DSERR_INVALIDPARAM;
 316     }
 317
 318     data.DataFlow = ppd->DataFlow;
 319     len = strlen(ppd->DeviceName)+1;
 320     data.DeviceName = HeapAlloc(GetProcessHeap(), 0, len);
 321     if (!data.DeviceName)
 322         return E_OUTOFMEMORY;
 323     MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, data.DeviceName, len );
 324
 325     hr = DSPROPERTY_WaveDeviceMappingW(&data, cbPropData, pcbReturned);
 326     HeapFree(GetProcessHeap(), 0, data.DeviceName);
 327     ppd->DeviceId = data.DeviceId;
 328
 329     if (pcbReturned)
 330         *pcbReturned = cbPropData;
 331
 332     return hr;
 333 }
 334
 335 static HRESULT DSPROPERTY_DescriptionW(
 336     LPVOID pPropData,
 337     ULONG cbPropData,
 338     PULONG pcbReturned )
 339 {
 340     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData;
 341     HRESULT err;
 342     GUID dev_guid;
 343     ULONG wod, wid, wodn, widn;
 344     DSDRIVERDESC desc;
 345
 346     TRACE("pPropData=%p,cbPropData=%u,pcbReturned=%p)\n",
 347           pPropData,(UINT)cbPropData,pcbReturned);
 348
 349     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 350     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 351         /* default device of type specified by ppd->DataFlow */
 352         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 353             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 354             ppd->DeviceId = DSDEVID_DefaultCapture;
 355         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 356             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 357             ppd->DeviceId = DSDEVID_DefaultPlayback;
 358         } else {
 359             WARN("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 360             return E_PROP_ID_UNSUPPORTED;
 361         }
 362     }
 363
 364     GetDeviceID(&ppd->DeviceId, &dev_guid);
 365
 366     wodn = waveOutGetNumDevs();
 367     widn = waveInGetNumDevs();
 368     wid = wod = dev_guid.Data4[7];
 369     if (!memcmp(&dev_guid, &DSOUND_renderer_guid, sizeof(GUID)-1)
 370         && wod < wodn)
 371     {
 372         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 373         ppd->WaveDeviceId = wod;
 374     }
 375     else if (!memcmp(&dev_guid, &DSOUND_capture_guid, sizeof(GUID)-1)
 376              && wid < widn)
 377     {
 378         ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 379         ppd->WaveDeviceId = wid;
 380     }
 381     else
 382     {
 383         WARN("Device not found\n");
 384         return E_PROP_ID_UNSUPPORTED;
 385     }
 386
 387     if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER)
 388         err = waveOutMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0);
 389     else
 390         err = waveInMessage(UlongToHandle(wod),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0);
 391
 392     if (err != MMSYSERR_NOERROR)
 393     {
 394         WARN("waveMessage(DRV_QUERYDSOUNDDESC) failed!\n");
 395         return E_PROP_ID_UNSUPPORTED;
 396     }
 397     else
 398     {
 399         /* FIXME: Still a memory leak.. */
 400         int desclen, modlen;
 401         static WCHAR wInterface[] = { 'I','n','t','e','r','f','a','c','e',0 };
 402
 403         modlen = strlen(desc.szDrvname)+1;
 404         desclen = strlen(desc.szDesc)+1;
 405         ppd->Module = HeapAlloc(GetProcessHeap(),0,modlen*sizeof(WCHAR));
 406         ppd->Description = HeapAlloc(GetProcessHeap(),0,desclen*sizeof(WCHAR));
 407         ppd->Interface = wInterface;
 408         if (!ppd->Description || !ppd->Module)
 409         {
 410             WARN("Out of memory\n");
 411             HeapFree(GetProcessHeap(), 0, ppd->Description);
 412             HeapFree(GetProcessHeap(), 0, ppd->Module);
 413             ppd->Description = ppd->Module = NULL;
 414             return E_OUTOFMEMORY;
 415         }
 416
 417         MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1, ppd->Module, modlen );
 418         MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->Description, desclen );
 419     }
 420
 421     ppd->Type = DIRECTSOUNDDEVICE_TYPE_VXD;
 422
 423     if (pcbReturned) {
 424         *pcbReturned = sizeof(*ppd);
 425         TRACE("*pcbReturned=%u\n", (UINT)*pcbReturned);
 426     }
 427
 428     return S_OK;
 429 }
 430
 431 static HRESULT DSPROPERTY_EnumerateW(
 432     LPVOID pPropData,
 433     ULONG cbPropData,
 434     PULONG pcbReturned )
 435 {
 436     PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData;
 437     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 438     BOOL ret;
 439     int widn, wodn, i;
 440     TRACE("(pPropData=%p,cbPropData=%u,pcbReturned=%p)\n",
 441           pPropData,(UINT)cbPropData,pcbReturned);
 442
 443     if (pcbReturned)
 444         *pcbReturned = 0;
 445
 446     if (!ppd || !ppd->Callback)
 447     {
 448         WARN("Invalid ppd %p\n", ppd);
 449         return E_PROP_ID_UNSUPPORTED;
 450     }
 451
 452     wodn = waveOutGetNumDevs();
 453     widn = waveInGetNumDevs();
 454
 455     data.DeviceId = DSOUND_renderer_guid;
 456     for (i = 0; i < wodn; ++i)
 457     {
 458         HRESULT hr;
 459         data.DeviceId.Data4[7] = i;
 460         hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
 461         if (FAILED(hr))
 462         {
 463             ERR("DescriptionW failed!\n");
 464             return S_OK;
 465         }
 466         ret = ppd->Callback(&data, ppd->Context);
 467         HeapFree(GetProcessHeap(), 0, data.Module);
 468         HeapFree(GetProcessHeap(), 0, data.Description);
 469         if (!ret)
 470             return S_OK;
 471     }
 472
 473     data.DeviceId = DSOUND_capture_guid;
 474     for (i = 0; i < widn; ++i)
 475     {
 476         HRESULT hr;
 477         data.DeviceId.Data4[7] = i;
 478         hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
 479         if (FAILED(hr))
 480         {
 481             ERR("DescriptionW failed!\n");
 482             return S_OK;
 483         }
 484         ret = ppd->Callback(&data, ppd->Context);
 485         HeapFree(GetProcessHeap(), 0, data.Module);
 486         HeapFree(GetProcessHeap(), 0, data.Description);
 487         if (!ret)
 488             return S_OK;
 489     }
 490     return S_OK;
 491 }
 492
 493 static void DSPROPERTY_descWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
 494                                 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *dataA)
 495 {
 496     DWORD modlen, desclen;
 497     static char Interface[] = "Interface";
 498
 499     modlen = lstrlenW(dataW->Module)+1;
 500     desclen = lstrlenW(dataW->Description)+1;
 501     dataA->Type = dataW->Type;
 502     dataA->DataFlow = dataW->DataFlow;
 503     dataA->DeviceId = dataW->DeviceId;
 504     dataA->WaveDeviceId = dataW->WaveDeviceId;
 505     dataA->Interface = Interface;
 506     dataA->Module = HeapAlloc(GetProcessHeap(), 0, modlen);
 507     dataA->Description = HeapAlloc(GetProcessHeap(), 0, desclen);
 508     if (dataA->Module)
 509         WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, dataA->Module, modlen, NULL, NULL);
 510     if (dataA->Description)
 511         WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, dataA->Description, desclen, NULL, NULL);
 512 }
 513
 514 static void DSPROPERTY_descWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
 515                                 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *data1)
 516 {
 517     data1->DeviceId = dataW->DeviceId;
 518     lstrcpynW(data1->ModuleW, dataW->Module, sizeof(data1->ModuleW)/sizeof(*data1->ModuleW));
 519     lstrcpynW(data1->DescriptionW, dataW->Description, sizeof(data1->DescriptionW)/sizeof(*data1->DescriptionW));
 520     WideCharToMultiByte(CP_ACP, 0, data1->DescriptionW, -1, data1->DescriptionA, sizeof(data1->DescriptionA), NULL, NULL);
 521     WideCharToMultiByte(CP_ACP, 0, data1->ModuleW, -1, data1->ModuleA, sizeof(data1->ModuleA), NULL, NULL);
 522     data1->Type = dataW->Type;
 523     data1->DataFlow = dataW->DataFlow;
 524     data1->WaveDeviceId = data1->Devnode = dataW->WaveDeviceId;
 525 }
 526
 527 static BOOL CALLBACK DSPROPERTY_enumWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data)
 528 {
 529     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA descA;
 530     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = data;
 531     BOOL ret;
 532
 533     DSPROPERTY_descWtoA(descW, &descA);
 534     ret = ppd->Callback(&descA, ppd->Context);
 535     HeapFree(GetProcessHeap(), 0, descA.Module);
 536     HeapFree(GetProcessHeap(), 0, descA.Description);
 537     return ret;
 538 }
 539
 540 static HRESULT DSPROPERTY_EnumerateA(
 541     LPVOID pPropData,
 542     ULONG cbPropData,
 543     PULONG pcbReturned)
 544 {
 545     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = pPropData;
 546     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;
 547
 548     if (!ppd || !ppd->Callback)
 549     {
 550         WARN("Invalid ppd %p\n", ppd);
 551         return E_PROP_ID_UNSUPPORTED;
 552     }
 553
 554     data.Callback = DSPROPERTY_enumWtoA;
 555     data.Context = ppd;
 556
 557     return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned);
 558 }
 559
 560 static BOOL CALLBACK DSPROPERTY_enumWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data)
 561 {
 562     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA desc1;
 563     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = data;
 564     BOOL ret;
 565
 566     DSPROPERTY_descWto1(descW, &desc1);
 567     ret = ppd->Callback(&desc1, ppd->Context);
 568     return ret;
 569 }
 570
 571 static HRESULT DSPROPERTY_Enumerate1(
 572     LPVOID pPropData,
 573     ULONG cbPropData,
 574     PULONG pcbReturned)
 575 {
 576     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = pPropData;
 577     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;
 578
 579     if (!ppd || !ppd->Callback)
 580     {
 581         WARN("Invalid ppd %p\n", ppd);
 582         return E_PROP_ID_UNSUPPORTED;
 583     }
 584
 585     data.Callback = DSPROPERTY_enumWto1;
 586     data.Context = ppd;
 587
 588     return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned);
 589 }
 590
 591 static HRESULT DSPROPERTY_DescriptionA(
 592     LPVOID pPropData,
 593     ULONG cbPropData,
 594     PULONG pcbReturned)
 595 {
 596     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 597     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *ppd = pPropData;
 598     HRESULT hr;
 599
 600     if (pcbReturned)
 601         *pcbReturned = sizeof(*ppd);
 602     if (!pPropData)
 603         return S_OK;
 604
 605     data.DeviceId = ppd->DeviceId;
 606     data.DataFlow = ppd->DataFlow;
 607     hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
 608     if (FAILED(hr))
 609         return hr;
 610     DSPROPERTY_descWtoA(&data, ppd);
 611     HeapFree(GetProcessHeap(), 0, data.Module);
 612     HeapFree(GetProcessHeap(), 0, data.Interface);
 613     return hr;
 614 }
 615
 616 static HRESULT DSPROPERTY_Description1(
 617     LPVOID pPropData,
 618     ULONG cbPropData,
 619     PULONG pcbReturned)
 620 {
 621     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 622     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *ppd = pPropData;
 623     HRESULT hr;
 624
 625     if (pcbReturned)
 626         *pcbReturned = sizeof(*ppd);
 627     if (!pPropData)
 628         return S_OK;
 629
 630     data.DeviceId = ppd->DeviceId;
 631     data.DataFlow = ppd->DataFlow;
 632     hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
 633     if (FAILED(hr))
 634         return hr;
 635     DSPROPERTY_descWto1(&data, ppd);
 636     HeapFree(GetProcessHeap(), 0, data.Module);
 637     HeapFree(GetProcessHeap(), 0, data.Interface);
 638     return hr;
 639 }
 640
 641 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get(
 642     LPKSPROPERTYSET iface,
 643     REFGUID guidPropSet,
 644     ULONG dwPropID,
 645     LPVOID pInstanceData,
 646     ULONG cbInstanceData,
 647     LPVOID pPropData,
 648     ULONG cbPropData,
 649     PULONG pcbReturned )
 650 {
 651     IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
 652     TRACE("(iface=%p,guidPropSet=%s,dwPropID=%u,pInstanceData=%p,cbInstanceData=%u,pPropData=%p,cbPropData=%u,pcbReturned=%p)\n",
 653           This,debugstr_guid(guidPropSet),(UINT)dwPropID,
 654           pInstanceData,(UINT)cbInstanceData,
 655           pPropData,(UINT)cbPropData,pcbReturned);
 656
 657     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 658         switch (dwPropID) {
 659         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 660             return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned);
 661         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 662             return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned);
 663         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 664             return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned);
 665         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 666             return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned);
 667         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
 668             return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned);
 669         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
 670             return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned);
 671         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
 672             return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned);
 673         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
 674             return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned);
 675         default:
 676             FIXME("unsupported ID: %u\n",(UINT)dwPropID);
 677             break;
 678         }
 679     } else {
 680         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 681     }
 682
 683     if (pcbReturned) {
 684         *pcbReturned = 0;
 685         FIXME("*pcbReturned=%u\n", (UINT)*pcbReturned);
 686     }
 687
 688     return E_PROP_ID_UNSUPPORTED;
 689 }
 690
 691 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set(
 692     LPKSPROPERTYSET iface,
 693     REFGUID guidPropSet,
 694     ULONG dwPropID,
 695     LPVOID pInstanceData,
 696     ULONG cbInstanceData,
 697     LPVOID pPropData,
 698     ULONG cbPropData )
 699 {
 700     IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
 701
 702     FIXME("(%p)->(%s,%u,%p,%u,%p,%u), stub!\n",This,
 703           debugstr_guid(guidPropSet),(unsigned int)dwPropID,
 704           pInstanceData,(unsigned int)cbInstanceData,pPropData,(unsigned int)cbPropData);
 705     return E_PROP_ID_UNSUPPORTED;
 706 }
 707
 708 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport(
 709     LPKSPROPERTYSET iface,
 710     REFGUID guidPropSet,
 711     ULONG dwPropID,
 712     PULONG pTypeSupport )
 713 {
 714     IKsPrivatePropertySetImpl *This = (IKsPrivatePropertySetImpl *)iface;
 715     TRACE("(%p,%s,%u,%p)\n",This,debugstr_guid(guidPropSet),(unsigned int)dwPropID,pTypeSupport);
 716
 717     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 718         switch (dwPropID) {
 719         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 720             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 721             return S_OK;
 722         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 723             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 724             return S_OK;
 725         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 726             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 727             return S_OK;
 728         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 729             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 730             return S_OK;
 731         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
 732             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 733             return S_OK;
 734         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
 735             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 736             return S_OK;
 737         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
 738             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 739             return S_OK;
 740         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
 741             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 742             return S_OK;
 743         default:
 744             FIXME("unsupported ID: %u\n",(unsigned int)dwPropID);
 745             break;
 746         }
 747     } else {
 748         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 749     }
 750
 751     return E_PROP_ID_UNSUPPORTED;
 752 }
 753
 754 static const IKsPropertySetVtbl ikspvt = {
 755     IKsPrivatePropertySetImpl_QueryInterface,
 756     IKsPrivatePropertySetImpl_AddRef,
 757     IKsPrivatePropertySetImpl_Release,
 758     IKsPrivatePropertySetImpl_Get,
 759     IKsPrivatePropertySetImpl_Set,
 760     IKsPrivatePropertySetImpl_QuerySupport
 761 };
 762
 763 HRESULT IKsPrivatePropertySetImpl_Create(
 764     REFIID riid,
 765     void **piks)
 766 {
 767     IKsPrivatePropertySetImpl *iks;
 768     TRACE("(%s, %p)\n", debugstr_guid(riid), piks);
 769
 770     if (!IsEqualIID(riid, &IID_IUnknown) &&
 771         !IsEqualIID(riid, &IID_IKsPropertySet)) {
 772         *piks = 0;
 773         return E_NOINTERFACE;
 774     }
 775
 776     iks = HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
 777     iks->ref = 1;
 778     iks->IKsPropertySet_iface.lpVtbl = &ikspvt;
 779
 780     *piks = iks;
 781     return S_OK;
 782 }