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 #define CONST_VTABLE
  23 #include <stdarg.h>
  24 #include <string.h>
  25
  26 #include <windows.h>
  27 #include <dsound.h>
  28 #include <mmsystem.h>
  29 #include <mmdeviceapi.h>
  30 #include <dsconf.h>
  31 #include <devpropdef.h>
  32
  33 #include "dsound_private.h"
  34
  35
  36 DEFINE_DEVPROPKEY(DEVPKEY_Device_FriendlyName, 0xa45c254e,0xdf1c,0x4efd,0x80,0x20,0x67,0xd1,0x46,0xa8,0x50,0xe0, 14);
  37
  38 static WCHAR *strdupW(const WCHAR *str)
  39 {
  40     WCHAR *ret;
  41     int l = lstrlenW(str);
  42     if(l < 0) return NULL;
  43
  44     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (l+1)*sizeof(WCHAR));
  45     if(!ret) return NULL;
  46
  47     memcpy(ret, str, l*sizeof(WCHAR));
  48     return ret;
  49 }
  50
  51
  52 typedef struct IKsPrivatePropertySetImpl
  53 {
  54     IKsPropertySet IKsPropertySet_iface;
  55     LONG ref;
  56 } IKsPrivatePropertySetImpl;
  57
  58 static IKsPrivatePropertySetImpl *impl_from_IKsPropertySet(IKsPropertySet *iface)
  59 {
  60     return CONTAINING_RECORD(iface, IKsPrivatePropertySetImpl, IKsPropertySet_iface);
  61 }
  62
  63 /*******************************************************************************
  64  *              IKsPrivatePropertySet
  65  */
  66
  67 /* IUnknown methods */
  68 static HRESULT WINAPI IKsPrivatePropertySetImpl_QueryInterface(
  69         IKsPropertySet *iface, REFIID riid, void **ppobj)
  70 {
  71     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
  72     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
  73
  74     if (IsEqualIID(riid, &IID_IUnknown) ||
  75         IsEqualIID(riid, &IID_IKsPropertySet)) {
  76         *ppobj = iface;
  77         IKsPropertySet_AddRef(iface);
  78         return S_OK;
  79     }
  80     *ppobj = NULL;
  81     return E_NOINTERFACE;
  82 }
  83
  84 static ULONG WINAPI IKsPrivatePropertySetImpl_AddRef(LPKSPROPERTYSET iface)
  85 {
  86     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
  87     ULONG ref = InterlockedIncrement(&(This->ref));
  88     TRACE("(%p) ref %lu\n", iface, ref);
  89     return ref;
  90 }
  91
  92 static ULONG WINAPI IKsPrivatePropertySetImpl_Release(LPKSPROPERTYSET iface)
  93 {
  94     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
  95     ULONG ref = InterlockedDecrement(&(This->ref));
  96     TRACE("(%p) ref %lu\n", iface, ref);
  97
  98     if(!ref)
  99     {
 100         HeapFree(GetProcessHeap(), 0, This);
 101         TRACE("(%p) released\n", This);
 102     }
 103     return ref;
 104 }
 105
 106 struct search_data {
 107     const WCHAR *tgt_name;
 108     GUID *found_guid;
 109 };
 110
 111 static BOOL CALLBACK search_callback(EDataFlow flow, GUID *guid, const WCHAR *desc,
 112         const WCHAR *module, void *user)
 113 {
 114     struct search_data *search = user;
 115     (void)flow;
 116     (void)module;
 117
 118     if(lstrcmpW(desc, search->tgt_name) != 0)
 119         return TRUE;
 120
 121     *search->found_guid = *guid;
 122     return FALSE;
 123 }
 124
 125 static HRESULT DSPROPERTY_WaveDeviceMappingW(
 126     LPVOID pPropData,
 127     ULONG cbPropData,
 128     PULONG pcbReturned )
 129 {
 130     HRESULT hr;
 131     PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd = pPropData;
 132     struct search_data search;
 133
 134     TRACE("(pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 135           pPropData,cbPropData,pcbReturned);
 136
 137     if (!ppd)
 138     {
 139         WARN("invalid parameter: pPropData\n");
 140         return DSERR_INVALIDPARAM;
 141     }
 142
 143     search.tgt_name = ppd->DeviceName;
 144     search.found_guid = &ppd->DeviceId;
 145
 146     if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER)
 147         hr = enumerate_mmdevices(eRender, search_callback, &search);
 148     else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE)
 149         hr = enumerate_mmdevices(eCapture, search_callback, &search);
 150     else
 151         return DSERR_INVALIDPARAM;
 152
 153     if(hr != S_FALSE)
 154         /* device was not found */
 155         return DSERR_INVALIDPARAM;
 156
 157     if (pcbReturned)
 158         *pcbReturned = cbPropData;
 159
 160     return DS_OK;
 161 }
 162
 163 static HRESULT DSPROPERTY_WaveDeviceMappingA(
 164     LPVOID pPropData,
 165     ULONG cbPropData,
 166     PULONG pcbReturned )
 167 {
 168     DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA *ppd = pPropData;
 169     DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA data;
 170     DWORD len;
 171     HRESULT hr;
 172
 173     TRACE("(pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 174       pPropData,cbPropData,pcbReturned);
 175
 176     if (!ppd || !ppd->DeviceName) {
 177         WARN("invalid parameter: ppd=%p\n", ppd);
 178         return DSERR_INVALIDPARAM;
 179     }
 180
 181     data.DataFlow = ppd->DataFlow;
 182     len = MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, NULL, 0);
 183     data.DeviceName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 184     if (!data.DeviceName)
 185         return E_OUTOFMEMORY;
 186     MultiByteToWideChar(CP_ACP, 0, ppd->DeviceName, -1, data.DeviceName, len);
 187
 188     hr = DSPROPERTY_WaveDeviceMappingW(&data, cbPropData, pcbReturned);
 189     HeapFree(GetProcessHeap(), 0, data.DeviceName);
 190     ppd->DeviceId = data.DeviceId;
 191
 192     if (pcbReturned)
 193         *pcbReturned = cbPropData;
 194
 195     return hr;
 196 }
 197
 198 static HRESULT DSPROPERTY_DescriptionW(
 199     LPVOID pPropData,
 200     ULONG cbPropData,
 201     PULONG pcbReturned )
 202 {
 203     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = pPropData;
 204     GUID dev_guid;
 205     IMMDevice *mmdevice;
 206     IPropertyStore *ps;
 207     PROPVARIANT pv;
 208     HRESULT hr;
 209
 210     TRACE("pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 211           pPropData,cbPropData,pcbReturned);
 212
 213     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 214     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 215         /* default device of type specified by ppd->DataFlow */
 216         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 217             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 218             ppd->DeviceId = DSDEVID_DefaultCapture;
 219         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 220             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 221             ppd->DeviceId = DSDEVID_DefaultPlayback;
 222         } else {
 223             WARN("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 224             return E_PROP_ID_UNSUPPORTED;
 225         }
 226     }
 227
 228     GetDeviceID(&ppd->DeviceId, &dev_guid);
 229
 230     hr = get_mmdevice(eRender, &dev_guid, &mmdevice);
 231     if(FAILED(hr)){
 232         hr = get_mmdevice(eCapture, &dev_guid, &mmdevice);
 233         if(FAILED(hr))
 234             return hr;
 235     }
 236
 237     hr = IMMDevice_OpenPropertyStore(mmdevice, STGM_READ, &ps);
 238     if(FAILED(hr))
 239     {
 240         IMMDevice_Release(mmdevice);
 241         WARN("OpenPropertyStore failed: %08lx\n", hr);
 242         return hr;
 243     }
 244
 245     hr = IPropertyStore_GetValue(ps, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv);
 246     if(FAILED(hr))
 247     {
 248         IPropertyStore_Release(ps);
 249         IMMDevice_Release(mmdevice);
 250         WARN("GetValue(FriendlyName) failed: %08lx\n", hr);
 251         return hr;
 252     }
 253
 254     ppd->Description = strdupW(pv.pwszVal);
 255     ppd->Module = strdupW(aldriver_name);
 256     ppd->Interface = strdupW(L"Interface");
 257     ppd->Type = DIRECTSOUNDDEVICE_TYPE_WDM;
 258
 259     PropVariantClear(&pv);
 260     IPropertyStore_Release(ps);
 261     IMMDevice_Release(mmdevice);
 262
 263     if (pcbReturned)
 264     {
 265         *pcbReturned = sizeof(*ppd);
 266         TRACE("*pcbReturned=%ld\n", *pcbReturned);
 267     }
 268
 269     return S_OK;
 270 }
 271
 272 static
 273 BOOL CALLBACK enum_callback(EDataFlow flow, GUID *guid, const WCHAR *desc, const WCHAR *module,
 274         void *user)
 275 {
 276     PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = user;
 277     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 278     DWORD len;
 279     BOOL ret;
 280
 281     TRACE("%s %ls %ls %p\n", debugstr_guid(guid), desc, module, user);
 282
 283     if(!guid)
 284         return TRUE;
 285
 286     data.Type = DIRECTSOUNDDEVICE_TYPE_WDM;
 287     data.DataFlow = (flow==eCapture) ? DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE :
 288                                        DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 289     data.DeviceId = *guid;
 290
 291     len = lstrlenW(module) + 1;
 292     data.Module = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 293     memcpy(data.Module, module, len * sizeof(WCHAR));
 294
 295     len = lstrlenW(desc) + 1;
 296     data.Description = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 297     memcpy(data.Description, desc, len * sizeof(WCHAR));
 298
 299     data.Interface = L"Interface";
 300
 301     ret = ppd->Callback(&data, ppd->Context);
 302
 303     HeapFree(GetProcessHeap(), 0, data.Module);
 304     HeapFree(GetProcessHeap(), 0, data.Description);
 305
 306     return ret;
 307 }
 308
 309 static HRESULT DSPROPERTY_EnumerateW(
 310     LPVOID pPropData,
 311     ULONG cbPropData,
 312     PULONG pcbReturned )
 313 {
 314     PDSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA ppd = pPropData;
 315     HRESULT hr;
 316
 317     TRACE("(pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 318           pPropData,cbPropData,pcbReturned);
 319
 320     if (pcbReturned)
 321         *pcbReturned = 0;
 322
 323     if (!ppd || !ppd->Callback)
 324     {
 325         WARN("Invalid ppd %p\n", ppd);
 326         return E_PROP_ID_UNSUPPORTED;
 327     }
 328
 329     hr = enumerate_mmdevices(eRender, enum_callback, ppd);
 330     if(hr == S_OK)
 331         hr = enumerate_mmdevices(eCapture, enum_callback, ppd);
 332
 333     return SUCCEEDED(hr) ? DS_OK : hr;
 334 }
 335
 336 static BOOL DSPROPERTY_descWtoA(const DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
 337                                 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *dataA)
 338 {
 339     static char Interface[] = "Interface";
 340     DWORD modlen, desclen;
 341
 342     modlen = WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, NULL, 0, NULL, NULL);
 343     desclen = WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, NULL, 0, NULL, NULL);
 344     dataA->Type = dataW->Type;
 345     dataA->DataFlow = dataW->DataFlow;
 346     dataA->DeviceId = dataW->DeviceId;
 347     dataA->WaveDeviceId = dataW->WaveDeviceId;
 348     dataA->Interface = Interface;
 349     dataA->Module = HeapAlloc(GetProcessHeap(), 0, modlen);
 350     dataA->Description = HeapAlloc(GetProcessHeap(), 0, desclen);
 351     if (!dataA->Module || !dataA->Description)
 352     {
 353         HeapFree(GetProcessHeap(), 0, dataA->Module);
 354         HeapFree(GetProcessHeap(), 0, dataA->Description);
 355         dataA->Module = dataA->Description = NULL;
 356         return FALSE;
 357     }
 358
 359     WideCharToMultiByte(CP_ACP, 0, dataW->Module, -1, dataA->Module, modlen, NULL, NULL);
 360     WideCharToMultiByte(CP_ACP, 0, dataW->Description, -1, dataA->Description, desclen, NULL, NULL);
 361     return TRUE;
 362 }
 363
 364 static void DSPROPERTY_descWto1(const DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *dataW,
 365                                 DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *data1)
 366 {
 367     data1->DeviceId = dataW->DeviceId;
 368     lstrcpynW(data1->ModuleW, dataW->Module, sizeof(data1->ModuleW)/sizeof(*data1->ModuleW));
 369     lstrcpynW(data1->DescriptionW, dataW->Description, sizeof(data1->DescriptionW)/sizeof(*data1->DescriptionW));
 370     WideCharToMultiByte(CP_ACP, 0, data1->DescriptionW, -1, data1->DescriptionA, sizeof(data1->DescriptionA)-1, NULL, NULL);
 371     WideCharToMultiByte(CP_ACP, 0, data1->ModuleW, -1, data1->ModuleA, sizeof(data1->ModuleA)-1, NULL, NULL);
 372     data1->DescriptionA[sizeof(data1->DescriptionA)-1] = 0;
 373     data1->ModuleA[sizeof(data1->ModuleA)-1] = 0;
 374     data1->Type = dataW->Type;
 375     data1->DataFlow = dataW->DataFlow;
 376     data1->WaveDeviceId = data1->Devnode = dataW->WaveDeviceId;
 377 }
 378
 379 static BOOL CALLBACK DSPROPERTY_enumWtoA(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data)
 380 {
 381     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA descA;
 382     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = data;
 383     BOOL ret;
 384
 385     ret = DSPROPERTY_descWtoA(descW, &descA);
 386     if (!ret)
 387         return FALSE;
 388     ret = ppd->Callback(&descA, ppd->Context);
 389     HeapFree(GetProcessHeap(), 0, descA.Module);
 390     HeapFree(GetProcessHeap(), 0, descA.Description);
 391     return ret;
 392 }
 393
 394 static HRESULT DSPROPERTY_EnumerateA(
 395     LPVOID pPropData,
 396     ULONG cbPropData,
 397     PULONG pcbReturned)
 398 {
 399     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A_DATA *ppd = pPropData;
 400     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;
 401
 402     if (!ppd || !ppd->Callback)
 403     {
 404         WARN("Invalid ppd %p\n", ppd);
 405         return E_PROP_ID_UNSUPPORTED;
 406     }
 407
 408     data.Callback = DSPROPERTY_enumWtoA;
 409     data.Context = ppd;
 410
 411     return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned);
 412 }
 413
 414 static BOOL CALLBACK DSPROPERTY_enumWto1(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA *descW, void *data)
 415 {
 416     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA desc1;
 417     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = data;
 418     BOOL ret;
 419
 420     DSPROPERTY_descWto1(descW, &desc1);
 421     ret = ppd->Callback(&desc1, ppd->Context);
 422     return ret;
 423 }
 424
 425 static HRESULT DSPROPERTY_Enumerate1(
 426     LPVOID pPropData,
 427     ULONG cbPropData,
 428     PULONG pcbReturned)
 429 {
 430     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1_DATA *ppd = pPropData;
 431     DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W_DATA data;
 432
 433     if (!ppd || !ppd->Callback)
 434     {
 435         WARN("Invalid ppd %p\n", ppd);
 436         return E_PROP_ID_UNSUPPORTED;
 437     }
 438
 439     data.Callback = DSPROPERTY_enumWto1;
 440     data.Context = ppd;
 441
 442     return DSPROPERTY_EnumerateW(&data, cbPropData, pcbReturned);
 443 }
 444
 445 static HRESULT DSPROPERTY_DescriptionA(
 446     LPVOID pPropData,
 447     ULONG cbPropData,
 448     PULONG pcbReturned)
 449 {
 450     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 451     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA *ppd = pPropData;
 452     HRESULT hr;
 453
 454     if(cbPropData < sizeof(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A_DATA))
 455         return E_INVALIDARG;
 456     if (pcbReturned)
 457         *pcbReturned = sizeof(*ppd);
 458     if (!pPropData)
 459         return S_OK;
 460
 461     data.DeviceId = ppd->DeviceId;
 462     data.DataFlow = ppd->DataFlow;
 463     hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
 464     if (FAILED(hr))
 465         return hr;
 466     if (!DSPROPERTY_descWtoA(&data, ppd))
 467         hr = E_OUTOFMEMORY;
 468     HeapFree(GetProcessHeap(), 0, data.Description);
 469     HeapFree(GetProcessHeap(), 0, data.Module);
 470     HeapFree(GetProcessHeap(), 0, data.Interface);
 471     return hr;
 472 }
 473
 474 static HRESULT DSPROPERTY_Description1(
 475     LPVOID pPropData,
 476     ULONG cbPropData,
 477     PULONG pcbReturned)
 478 {
 479     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA data;
 480     DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA *ppd = pPropData;
 481     HRESULT hr;
 482
 483     if(cbPropData < sizeof(DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA))
 484         return E_INVALIDARG;
 485     if (pcbReturned)
 486         *pcbReturned = sizeof(*ppd);
 487     if (!pPropData)
 488         return S_OK;
 489
 490     data.DeviceId = ppd->DeviceId;
 491     data.DataFlow = ppd->DataFlow;
 492     hr = DSPROPERTY_DescriptionW(&data, sizeof(data), NULL);
 493     if (FAILED(hr))
 494         return hr;
 495     DSPROPERTY_descWto1(&data, ppd);
 496     HeapFree(GetProcessHeap(), 0, data.Description);
 497     HeapFree(GetProcessHeap(), 0, data.Module);
 498     HeapFree(GetProcessHeap(), 0, data.Interface);
 499     return hr;
 500 }
 501
 502 static HRESULT WINAPI IKsPrivatePropertySetImpl_Get(
 503     LPKSPROPERTYSET iface,
 504     REFGUID guidPropSet,
 505     ULONG dwPropID,
 506     LPVOID pInstanceData,
 507     ULONG cbInstanceData,
 508     LPVOID pPropData,
 509     ULONG cbPropData,
 510     PULONG pcbReturned )
 511 {
 512     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
 513     TRACE("(iface=%p,guidPropSet=%s,dwPropID=%ld,pInstanceData=%p,cbInstanceData=%ld,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 514           This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
 515
 516     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 517         switch (dwPropID) {
 518         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 519             return DSPROPERTY_WaveDeviceMappingA(pPropData,cbPropData,pcbReturned);
 520         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 521             return DSPROPERTY_Description1(pPropData,cbPropData,pcbReturned);
 522         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 523             return DSPROPERTY_Enumerate1(pPropData,cbPropData,pcbReturned);
 524         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 525             return DSPROPERTY_WaveDeviceMappingW(pPropData,cbPropData,pcbReturned);
 526         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
 527             return DSPROPERTY_DescriptionA(pPropData,cbPropData,pcbReturned);
 528         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
 529             return DSPROPERTY_DescriptionW(pPropData,cbPropData,pcbReturned);
 530         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
 531             return DSPROPERTY_EnumerateA(pPropData,cbPropData,pcbReturned);
 532         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
 533             return DSPROPERTY_EnumerateW(pPropData,cbPropData,pcbReturned);
 534         default:
 535             FIXME("unsupported ID: %ld\n",dwPropID);
 536             break;
 537         }
 538     } else {
 539         FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 540     }
 541
 542     if (pcbReturned) {
 543         *pcbReturned = 0;
 544         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 545     }
 546
 547     return E_PROP_ID_UNSUPPORTED;
 548 }
 549
 550 static HRESULT WINAPI IKsPrivatePropertySetImpl_Set(
 551     LPKSPROPERTYSET iface,
 552     REFGUID guidPropSet,
 553     ULONG dwPropID,
 554     LPVOID pInstanceData,
 555     ULONG cbInstanceData,
 556     LPVOID pPropData,
 557     ULONG cbPropData )
 558 {
 559     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
 560
 561     FIXME("(%p,%s,%ld,%p,%ld,%p,%ld), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
 562     return E_PROP_ID_UNSUPPORTED;
 563 }
 564
 565 static HRESULT WINAPI IKsPrivatePropertySetImpl_QuerySupport(
 566     LPKSPROPERTYSET iface,
 567     REFGUID guidPropSet,
 568     ULONG dwPropID,
 569     PULONG pTypeSupport )
 570 {
 571     IKsPrivatePropertySetImpl *This = impl_from_IKsPropertySet(iface);
 572     TRACE("(%p,%s,%ld,%p)\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
 573
 574     if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 575         switch (dwPropID) {
 576         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 577             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 578             return S_OK;
 579         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 580             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 581             return S_OK;
 582         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 583             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 584             return S_OK;
 585         case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 586             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 587             return S_OK;
 588         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
 589             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 590             return S_OK;
 591         case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
 592             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 593             return S_OK;
 594         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
 595             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 596             return S_OK;
 597         case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
 598             *pTypeSupport = KSPROPERTY_SUPPORT_GET;
 599             return S_OK;
 600         default:
 601             FIXME("unsupported ID: %ld\n",dwPropID);
 602             break;
 603         }
 604     } else {
 605         FIXME("unsupported property: %s (propid: %lu)\n",debugstr_guid(guidPropSet),dwPropID);
 606     }
 607
 608     return E_PROP_ID_UNSUPPORTED;
 609 }
 610
 611 static const IKsPropertySetVtbl ikspvt = {
 612     IKsPrivatePropertySetImpl_QueryInterface,
 613     IKsPrivatePropertySetImpl_AddRef,
 614     IKsPrivatePropertySetImpl_Release,
 615     IKsPrivatePropertySetImpl_Get,
 616     IKsPrivatePropertySetImpl_Set,
 617     IKsPrivatePropertySetImpl_QuerySupport
 618 };
 619
 620 HRESULT IKsPrivatePropertySetImpl_Create(REFIID riid, void **ppv)
 621 {
 622     IKsPrivatePropertySetImpl *iks;
 623     HRESULT hr;
 624
 625     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 626
 627     iks = HeapAlloc(GetProcessHeap(), 0, sizeof(*iks));
 628     if (!iks) {
 629         WARN("out of memory\n");
 630         return DSERR_OUTOFMEMORY;
 631     }
 632
 633     iks->ref = 1;
 634     iks->IKsPropertySet_iface.lpVtbl = &ikspvt;
 635
 636     hr = IKsPropertySet_QueryInterface(&iks->IKsPropertySet_iface, riid, ppv);
 637     IKsPropertySet_Release(&iks->IKsPropertySet_iface);
 638
 639     return hr;
 640 }