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 <stdio.h>
  25 #include <sys/types.h>
  26 #include <sys/fcntl.h>
  27 #ifdef HAVE_UNISTD_H
  28 # include <unistd.h>
  29 #endif
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <math.h>       /* Insomnia - pow() function */
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "wingdi.h"
  37 #include "winuser.h"
  38 #include "winerror.h"
  39 #include "mmsystem.h"
  40 #include "winternl.h"
  41 #include "winnls.h"
  42 #include "mmddk.h"
  43 #include "wine/windef16.h"
  44 #include "wine/debug.h"
  45 #include "dsound.h"
  46 #include "dsdriver.h"
  47 #include "dsound_private.h"
  48 #include "dsconf.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  51
  52
  53 /*******************************************************************************
  54  *              IKsPropertySet
  55  */
  56
  57 /* IUnknown methods */
  58 static HRESULT WINAPI IKsPropertySetImpl_QueryInterface(
  59         LPKSPROPERTYSET iface, REFIID riid, LPVOID *ppobj
  60 ) {
  61         ICOM_THIS(IKsPropertySetImpl,iface);
  62
  63         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
  64         return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb, riid, ppobj);
  65 }
  66
  67 static ULONG WINAPI IKsPropertySetImpl_AddRef(LPKSPROPERTYSET iface) {
  68         ICOM_THIS(IKsPropertySetImpl,iface);
  69         ULONG ulReturn;
  70
  71         TRACE("(%p) ref was %ld\n", This, This->ref);
  72         ulReturn = InterlockedIncrement(&This->ref);
  73         if (ulReturn == 1)
  74                 IDirectSoundBuffer_AddRef((LPDIRECTSOUND3DBUFFER)This->dsb);
  75         return ulReturn;
  76 }
  77
  78 static ULONG WINAPI IKsPropertySetImpl_Release(LPKSPROPERTYSET iface) {
  79         ICOM_THIS(IKsPropertySetImpl,iface);
  80         ULONG ulReturn;
  81
  82         TRACE("(%p) ref was %ld\n", This, This->ref);
  83         ulReturn = InterlockedDecrement(&This->ref);
  84         if (ulReturn)
  85                 return ulReturn;
  86         IDirectSoundBuffer_Release((LPDIRECTSOUND3DBUFFER)This->dsb);
  87         return 0;
  88 }
  89
  90 static HRESULT WINAPI DSPROPERTY_WaveDeviceMappingA(
  91     REFGUID guidPropSet,
  92     LPVOID pPropData,
  93     ULONG cbPropData,
  94     PULONG pcbReturned )
  95 {
  96     PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA ppd;
  97     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) not implemented!\n",
  98         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
  99
 100     ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A_DATA) pPropData;
 101
 102     if (!ppd) {
 103         WARN("invalid parameter: pPropData\n");
 104         return DSERR_INVALIDPARAM;
 105     }
 106
 107     FIXME("DeviceName=%s\n",ppd->DeviceName);
 108     FIXME("DataFlow=%s\n",
 109         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER ? "DIRECTSOUNDDEVICE_DATAFLOW_RENDER" :
 110         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE ? "DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE" : "UNKNOWN");
 111
 112     /* FIXME: match the name to a wave device somehow. */
 113     ppd->DeviceId = GUID_NULL;
 114
 115     if (pcbReturned) {
 116         *pcbReturned = cbPropData;
 117         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 118     }
 119
 120     return S_OK;
 121 }
 122
 123 static HRESULT WINAPI DSPROPERTY_WaveDeviceMappingW(
 124     REFGUID guidPropSet,
 125     LPVOID pPropData,
 126     ULONG cbPropData,
 127     PULONG pcbReturned )
 128 {
 129     PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA ppd;
 130     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) not implemented!\n",
 131         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 132
 133     ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W_DATA) pPropData;
 134
 135     if (!ppd) {
 136         WARN("invalid parameter: pPropData\n");
 137         return DSERR_INVALIDPARAM;
 138     }
 139
 140     FIXME("DeviceName=%s\n",debugstr_w(ppd->DeviceName));
 141     FIXME("DataFlow=%s\n",
 142         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER ? "DIRECTSOUNDDEVICE_DATAFLOW_RENDER" :
 143         ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE ? "DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE" : "UNKNOWN");
 144
 145     /* FIXME: match the name to a wave device somehow. */
 146     ppd->DeviceId = GUID_NULL;
 147
 148     if (pcbReturned) {
 149         *pcbReturned = cbPropData;
 150         FIXME("*pcbReturned=%ld\n", *pcbReturned);
 151     }
 152
 153     return S_OK;
 154 }
 155
 156 static HRESULT WINAPI DSPROPERTY_Description1(
 157     REFGUID guidPropSet,
 158     LPVOID pPropData,
 159     ULONG cbPropData,
 160     PULONG pcbReturned )
 161 {
 162     HRESULT err;
 163     GUID guid, dev_guid;
 164     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA ppd;
 165     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 166         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 167
 168     ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1_DATA) pPropData;
 169
 170     if (!ppd) {
 171         WARN("invalid parameter: pPropData\n");
 172         return DSERR_INVALIDPARAM;
 173     }
 174
 175     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 176     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 177         /* default device of type specified by ppd->DataFlow */
 178         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 179             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 180         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 181             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 182         } else {
 183             TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 184         }
 185         FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) GUID_NULL not implemented!\n",
 186             debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 187         return E_PROP_ID_UNSUPPORTED;
 188     } else {
 189         GetDeviceID(&ppd->DeviceId, &dev_guid);
 190
 191         if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
 192              IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
 193             ULONG wod;
 194             int wodn;
 195             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 196             ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 197             wodn = waveOutGetNumDevs();
 198             for (wod = 0; wod < wodn; wod++) {
 199                 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 200                 if (err == DS_OK) {
 201                     if (IsEqualGUID( &dev_guid, &guid) ) {
 202                         DSDRIVERDESC desc;
 203                         ppd->WaveDeviceId = wod;
 204                         ppd->Devnode = wod;
 205                         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 206                         if (err == DS_OK) {
 207                             strncpy(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA) - 1);
 208                             strncpy(ppd->ModuleA, desc.szDrvName, sizeof(ppd->ModuleA) - 1);
 209                             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
 210                             MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
 211                             break;
 212                         } else {
 213                             WARN("waveOutMessage failed\n");
 214                             return E_PROP_ID_UNSUPPORTED;
 215                         }
 216                     }
 217                 } else {
 218                     WARN("waveOutMessage failed\n");
 219                     return E_PROP_ID_UNSUPPORTED;
 220                 }
 221             }
 222         } else if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
 223                     IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
 224             ULONG wid;
 225             int widn;
 226             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 227             ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 228             widn = waveInGetNumDevs();
 229             for (wid = 0; wid < widn; wid++) {
 230                 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 231                 if (err == DS_OK) {
 232                     if (IsEqualGUID( &dev_guid, &guid) ) {
 233                         DSDRIVERDESC desc;
 234                         ppd->WaveDeviceId = wid;
 235                         ppd->Devnode = wid;
 236                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 237                         if (err == DS_OK) {
 238                             strncpy(ppd->DescriptionA, desc.szDesc, sizeof(ppd->DescriptionA) - 1);
 239                             strncpy(ppd->ModuleA, desc.szDrvName, sizeof(ppd->ModuleA) - 1);
 240                             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, ppd->DescriptionW, sizeof(ppd->DescriptionW)/sizeof(WCHAR) );
 241                             MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, ppd->ModuleW, sizeof(ppd->ModuleW)/sizeof(WCHAR) );
 242                             break;
 243                         } else {
 244                             WARN("waveInMessage failed\n");
 245                             return E_PROP_ID_UNSUPPORTED;
 246                         }
 247                         break;
 248                     }
 249                 } else {
 250                     WARN("waveInMessage failed\n");
 251                     return E_PROP_ID_UNSUPPORTED;
 252                 }
 253             }
 254         } else {
 255             FIXME("DeviceId=Unknown\n");
 256             return E_PROP_ID_UNSUPPORTED;
 257         }
 258     }
 259
 260     ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
 261
 262     if (pcbReturned) {
 263         *pcbReturned = cbPropData;
 264         TRACE("*pcbReturned=%ld\n", *pcbReturned);
 265     }
 266
 267     return S_OK;
 268 }
 269
 270 static HRESULT WINAPI DSPROPERTY_DescriptionA(
 271     REFGUID guidPropSet,
 272     LPVOID pPropData,
 273     ULONG cbPropData,
 274     PULONG pcbReturned )
 275 {
 276     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 277         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 278     return E_PROP_ID_UNSUPPORTED;
 279 }
 280
 281 static HRESULT WINAPI DSPROPERTY_DescriptionW(
 282     REFGUID guidPropSet,
 283     LPVOID pPropData,
 284     ULONG cbPropData,
 285     PULONG pcbReturned )
 286 {
 287     PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA ppd = (PDSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W_DATA) pPropData;
 288     HRESULT err;
 289     GUID guid, dev_guid;
 290     TRACE("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 291         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 292
 293     TRACE("DeviceId=%s\n",debugstr_guid(&ppd->DeviceId));
 294     if ( IsEqualGUID( &ppd->DeviceId , &GUID_NULL) ) {
 295         /* default device of type specified by ppd->DataFlow */
 296         if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE) {
 297             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 298         } else if (ppd->DataFlow == DIRECTSOUNDDEVICE_DATAFLOW_RENDER) {
 299             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 300         } else {
 301             TRACE("DataFlow=Unknown(%d)\n", ppd->DataFlow);
 302         }
 303         FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p) GUID_NULL not implemented!\n",
 304             debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 305         return E_PROP_ID_UNSUPPORTED;
 306     } else {
 307         GetDeviceID(&ppd->DeviceId, &dev_guid);
 308
 309         if ( IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultPlayback) ||
 310              IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoicePlayback) ) {
 311             ULONG wod;
 312             int wodn;
 313             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_RENDER\n");
 314             ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_RENDER;
 315             wodn = waveOutGetNumDevs();
 316             for (wod = 0; wod < wodn; wod++) {
 317                 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 318                 if (err == DS_OK) {
 319                     if (IsEqualGUID( &dev_guid, &guid) ) {
 320                         DSDRIVERDESC desc;
 321                         ppd->WaveDeviceId = wod;
 322                         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 323                         if (err == DS_OK) {
 324                             /* FIXME: this is a memory leak */
 325                             WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
 326                             WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
 327                             WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
 328
 329                             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100  );
 330                             MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, wModule, 0x100 );
 331                             MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
 332
 333                             ppd->Description = wDescription;
 334                             ppd->Module = wModule;
 335                             ppd->Interface = wInterface;
 336                             break;
 337                         } else {
 338                             WARN("waveOutMessage failed\n");
 339                             return E_PROP_ID_UNSUPPORTED;
 340                         }
 341                     }
 342                 } else {
 343                     WARN("waveOutMessage failed\n");
 344                     return E_PROP_ID_UNSUPPORTED;
 345                 }
 346             }
 347         } else if (IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultCapture) ||
 348                    IsEqualGUID( &ppd->DeviceId , &DSDEVID_DefaultVoiceCapture) ) {
 349             ULONG wid;
 350             int widn;
 351             TRACE("DataFlow=DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE\n");
 352             ppd->DataFlow = DIRECTSOUNDDEVICE_DATAFLOW_CAPTURE;
 353             widn = waveInGetNumDevs();
 354             for (wid = 0; wid < widn; wid++) {
 355                 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 356                 if (err == DS_OK) {
 357                     if (IsEqualGUID( &dev_guid, &guid) ) {
 358                         DSDRIVERDESC desc;
 359                         ppd->WaveDeviceId = wid;
 360                         err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&(desc),0));
 361                         if (err == DS_OK) {
 362                             /* FIXME: this is a memory leak */
 363                             WCHAR * wDescription = HeapAlloc(GetProcessHeap(),0,0x200);
 364                             WCHAR * wModule = HeapAlloc(GetProcessHeap(),0,0x200);
 365                             WCHAR * wInterface = HeapAlloc(GetProcessHeap(),0,0x200);
 366
 367                             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1, wDescription, 0x100  );
 368                             MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1, wModule, 0x100 );
 369                             MultiByteToWideChar( CP_ACP, 0, "Interface", -1, wInterface, 0x100 );
 370
 371                             ppd->Description = wDescription;
 372                             ppd->Module = wModule;
 373                             ppd->Interface = wInterface;
 374                             break;
 375                         } else {
 376                             WARN("waveInMessage failed\n");
 377                             return E_PROP_ID_UNSUPPORTED;
 378                         }
 379                         break;
 380                     }
 381                 } else {
 382                     WARN("waveInMessage failed\n");
 383                     return E_PROP_ID_UNSUPPORTED;
 384                 }
 385             }
 386         } else {
 387             FIXME("DeviceId=Unknown\n");
 388             return E_PROP_ID_UNSUPPORTED;
 389         }
 390     }
 391
 392     ppd->Type = DIRECTSOUNDDEVICE_TYPE_EMULATED;
 393
 394     if (pcbReturned) {
 395         *pcbReturned = cbPropData;
 396         TRACE("*pcbReturned=%ld\n", *pcbReturned);
 397     }
 398
 399     return S_OK;
 400 }
 401
 402 static HRESULT WINAPI DSPROPERTY_Enumerate1(
 403     REFGUID guidPropSet,
 404     LPVOID pPropData,
 405     ULONG cbPropData,
 406     PULONG pcbReturned )
 407 {
 408     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 409         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 410     return E_PROP_ID_UNSUPPORTED;
 411 }
 412
 413 static HRESULT WINAPI DSPROPERTY_EnumerateA(
 414     REFGUID guidPropSet,
 415     LPVOID pPropData,
 416     ULONG cbPropData,
 417     PULONG pcbReturned )
 418 {
 419     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 420         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 421     return E_PROP_ID_UNSUPPORTED;
 422 }
 423
 424 static HRESULT WINAPI DSPROPERTY_EnumerateW(
 425     REFGUID guidPropSet,
 426     LPVOID pPropData,
 427     ULONG cbPropData,
 428     PULONG pcbReturned )
 429 {
 430     FIXME("(guidPropSet=%s,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 431         debugstr_guid(guidPropSet),pPropData,cbPropData,pcbReturned);
 432     return E_PROP_ID_UNSUPPORTED;
 433 }
 434
 435 static HRESULT WINAPI IKsPropertySetImpl_Get(LPKSPROPERTYSET iface,
 436         REFGUID guidPropSet, ULONG dwPropID,
 437         LPVOID pInstanceData, ULONG cbInstanceData,
 438         LPVOID pPropData, ULONG cbPropData,
 439         PULONG pcbReturned
 440 ) {
 441         ICOM_THIS(IKsPropertySetImpl,iface);
 442         TRACE("(iface=%p,guidPropSet=%s,dwPropID=%ld,pInstanceData=%p,cbInstanceData=%ld,pPropData=%p,cbPropData=%ld,pcbReturned=%p)\n",
 443                 This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData,pcbReturned);
 444
 445         if ( IsEqualGUID( &DSPROPSETID_DirectSoundDevice, guidPropSet) ) {
 446                 switch (dwPropID) {
 447                 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_A:
 448                         return DSPROPERTY_WaveDeviceMappingA(guidPropSet,pPropData,cbPropData,pcbReturned);
 449                 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_1:
 450                         return DSPROPERTY_Description1(guidPropSet,pPropData,cbPropData,pcbReturned);
 451                 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_1:
 452                         return DSPROPERTY_Enumerate1(guidPropSet,pPropData,cbPropData,pcbReturned);
 453                 case DSPROPERTY_DIRECTSOUNDDEVICE_WAVEDEVICEMAPPING_W:
 454                         return DSPROPERTY_WaveDeviceMappingW(guidPropSet,pPropData,cbPropData,pcbReturned);
 455                 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_A:
 456                         return DSPROPERTY_DescriptionA(guidPropSet,pPropData,cbPropData,pcbReturned);
 457                 case DSPROPERTY_DIRECTSOUNDDEVICE_DESCRIPTION_W:
 458                         return DSPROPERTY_DescriptionW(guidPropSet,pPropData,cbPropData,pcbReturned);
 459                 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_A:
 460                         return DSPROPERTY_EnumerateA(guidPropSet,pPropData,cbPropData,pcbReturned);
 461                 case DSPROPERTY_DIRECTSOUNDDEVICE_ENUMERATE_W:
 462                         return DSPROPERTY_EnumerateW(guidPropSet,pPropData,cbPropData,pcbReturned);
 463                 default:
 464                         FIXME("unsupported ID: %ld\n",dwPropID);
 465                         break;
 466                 }
 467         } else {
 468                 FIXME("unsupported property: %s\n",debugstr_guid(guidPropSet));
 469         }
 470
 471         if (pcbReturned) {
 472                 *pcbReturned = 0;
 473                 FIXME("*pcbReturned=%ld\n", *pcbReturned);
 474         }
 475
 476         return E_PROP_ID_UNSUPPORTED;
 477 }
 478
 479 static HRESULT WINAPI IKsPropertySetImpl_Set(LPKSPROPERTYSET iface,
 480         REFGUID guidPropSet, ULONG dwPropID,
 481         LPVOID pInstanceData, ULONG cbInstanceData,
 482         LPVOID pPropData, ULONG cbPropData
 483 ) {
 484         ICOM_THIS(IKsPropertySetImpl,iface);
 485
 486         FIXME("(%p,%s,%ld,%p,%ld,%p,%ld), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pInstanceData,cbInstanceData,pPropData,cbPropData);
 487         return E_PROP_ID_UNSUPPORTED;
 488 }
 489
 490 static HRESULT WINAPI IKsPropertySetImpl_QuerySupport(LPKSPROPERTYSET iface,
 491         REFGUID guidPropSet, ULONG dwPropID, PULONG pTypeSupport
 492 ) {
 493         ICOM_THIS(IKsPropertySetImpl,iface);
 494
 495         FIXME("(%p,%s,%ld,%p), stub!\n",This,debugstr_guid(guidPropSet),dwPropID,pTypeSupport);
 496         return E_PROP_ID_UNSUPPORTED;
 497 }
 498
 499 static ICOM_VTABLE(IKsPropertySet) iksvt = {
 500         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 501         IKsPropertySetImpl_QueryInterface,
 502         IKsPropertySetImpl_AddRef,
 503         IKsPropertySetImpl_Release,
 504         IKsPropertySetImpl_Get,
 505         IKsPropertySetImpl_Set,
 506         IKsPropertySetImpl_QuerySupport
 507 };
 508
 509 HRESULT WINAPI IKsPropertySetImpl_Create(
 510         IDirectSoundBufferImpl *This,
 511         IKsPropertySetImpl **piks)
 512 {
 513         IKsPropertySetImpl *iks;
 514
 515         iks = (IKsPropertySetImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(*iks));
 516         iks->ref = 0;
 517         iks->dsb = This;
 518         iks->lpVtbl = &iksvt;
 519
 520         *piks = iks;
 521         return S_OK;
 522 }