dll/directx/dsound/dsound.c

   1 /* DirectSound
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998 Rob Riggs
   5  * Copyright 2000-2002 TransGaming Technologies, Inc.
   6  * Copyright 2004 Robert Reif
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25
  26 #define NONAMELESSSTRUCT
  27 #define NONAMELESSUNION
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "mmsystem.h"
  32 #include "winternl.h"
  33 #include "mmddk.h"
  34 #include "wingdi.h"
  35 #include "mmreg.h"
  36 #include "ks.h"
  37 #include "ksmedia.h"
  38 #include "wine/debug.h"
  39 #include "dsound.h"
  40 #include "dsdriver.h"
  41 #include "dsound_private.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  44
  45 /*****************************************************************************
  46  * IDirectSound COM components
  47  */
  48 struct IDirectSound_IUnknown {
  49     const IUnknownVtbl         *lpVtbl;
  50     LONG                        ref;
  51     LPDIRECTSOUND8              pds;
  52 };
  53
  54 static HRESULT IDirectSound_IUnknown_Create(LPDIRECTSOUND8 pds, LPUNKNOWN * ppunk);
  55
  56 struct IDirectSound_IDirectSound {
  57     const IDirectSoundVtbl     *lpVtbl;
  58     LONG                        ref;
  59     LPDIRECTSOUND8              pds;
  60 };
  61
  62 static HRESULT IDirectSound_IDirectSound_Create(LPDIRECTSOUND8 pds, LPDIRECTSOUND * ppds);
  63
  64 /*****************************************************************************
  65  * IDirectSound8 COM components
  66  */
  67 struct IDirectSound8_IUnknown {
  68     const IUnknownVtbl         *lpVtbl;
  69     LONG                        ref;
  70     LPDIRECTSOUND8              pds;
  71 };
  72
  73 static HRESULT IDirectSound8_IUnknown_Create(LPDIRECTSOUND8 pds, LPUNKNOWN * ppunk);
  74 static ULONG WINAPI IDirectSound8_IUnknown_AddRef(LPUNKNOWN iface);
  75
  76 struct IDirectSound8_IDirectSound {
  77     const IDirectSoundVtbl     *lpVtbl;
  78     LONG                        ref;
  79     LPDIRECTSOUND8              pds;
  80 };
  81
  82 static HRESULT IDirectSound8_IDirectSound_Create(LPDIRECTSOUND8 pds, LPDIRECTSOUND * ppds);
  83 static ULONG WINAPI IDirectSound8_IDirectSound_AddRef(LPDIRECTSOUND iface);
  84
  85 struct IDirectSound8_IDirectSound8 {
  86     const IDirectSound8Vtbl    *lpVtbl;
  87     LONG                        ref;
  88     LPDIRECTSOUND8              pds;
  89 };
  90
  91 static HRESULT IDirectSound8_IDirectSound8_Create(LPDIRECTSOUND8 pds, LPDIRECTSOUND8 * ppds);
  92 static ULONG WINAPI IDirectSound8_IDirectSound8_AddRef(LPDIRECTSOUND8 iface);
  93
  94 /*****************************************************************************
  95  * IDirectSound implementation structure
  96  */
  97 struct IDirectSoundImpl
  98 {
  99     LONG                        ref;
 100
 101     DirectSoundDevice          *device;
 102     LPUNKNOWN                   pUnknown;
 103     LPDIRECTSOUND               pDS;
 104     LPDIRECTSOUND8              pDS8;
 105 };
 106
 107 static HRESULT IDirectSoundImpl_Create(LPDIRECTSOUND8 * ppds);
 108
 109 static ULONG WINAPI IDirectSound_IUnknown_AddRef(LPUNKNOWN iface);
 110 static ULONG WINAPI IDirectSound_IDirectSound_AddRef(LPDIRECTSOUND iface);
 111
 112 static HRESULT DirectSoundDevice_VerifyCertification(DirectSoundDevice * device, LPDWORD pdwCertified);
 113
 114 const char * dumpCooperativeLevel(DWORD level)
 115 {
 116     static char unknown[32];
 117 #define LE(x) case x: return #x
 118     switch (level) {
 119         LE(DSSCL_NORMAL);
 120         LE(DSSCL_PRIORITY);
 121         LE(DSSCL_EXCLUSIVE);
 122         LE(DSSCL_WRITEPRIMARY);
 123     }
 124 #undef LE
 125     sprintf(unknown, "Unknown(%08x)", (UINT)level);
 126     return unknown;
 127 }
 128
 129 static void _dump_DSCAPS(DWORD xmask) {
 130     struct {
 131         DWORD   mask;
 132         const char    *name;
 133     } flags[] = {
 134 #define FE(x) { x, #x },
 135         FE(DSCAPS_PRIMARYMONO)
 136         FE(DSCAPS_PRIMARYSTEREO)
 137         FE(DSCAPS_PRIMARY8BIT)
 138         FE(DSCAPS_PRIMARY16BIT)
 139         FE(DSCAPS_CONTINUOUSRATE)
 140         FE(DSCAPS_EMULDRIVER)
 141         FE(DSCAPS_CERTIFIED)
 142         FE(DSCAPS_SECONDARYMONO)
 143         FE(DSCAPS_SECONDARYSTEREO)
 144         FE(DSCAPS_SECONDARY8BIT)
 145         FE(DSCAPS_SECONDARY16BIT)
 146 #undef FE
 147     };
 148     unsigned int     i;
 149
 150     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 151         if ((flags[i].mask & xmask) == flags[i].mask)
 152             TRACE("%s ",flags[i].name);
 153 }
 154
 155 static void _dump_DSBCAPS(DWORD xmask) {
 156     struct {
 157         DWORD   mask;
 158         const char    *name;
 159     } flags[] = {
 160 #define FE(x) { x, #x },
 161         FE(DSBCAPS_PRIMARYBUFFER)
 162         FE(DSBCAPS_STATIC)
 163         FE(DSBCAPS_LOCHARDWARE)
 164         FE(DSBCAPS_LOCSOFTWARE)
 165         FE(DSBCAPS_CTRL3D)
 166         FE(DSBCAPS_CTRLFREQUENCY)
 167         FE(DSBCAPS_CTRLPAN)
 168         FE(DSBCAPS_CTRLVOLUME)
 169         FE(DSBCAPS_CTRLPOSITIONNOTIFY)
 170         FE(DSBCAPS_STICKYFOCUS)
 171         FE(DSBCAPS_GLOBALFOCUS)
 172         FE(DSBCAPS_GETCURRENTPOSITION2)
 173         FE(DSBCAPS_MUTE3DATMAXDISTANCE)
 174 #undef FE
 175     };
 176     unsigned int     i;
 177
 178     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 179         if ((flags[i].mask & xmask) == flags[i].mask)
 180             TRACE("%s ",flags[i].name);
 181 }
 182
 183 /*******************************************************************************
 184  *              IDirectSoundImpl_DirectSound
 185  */
 186 static HRESULT DSOUND_QueryInterface(
 187     LPDIRECTSOUND8 iface,
 188     REFIID riid,
 189     LPVOID * ppobj)
 190 {
 191     IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
 192     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 193
 194     if (ppobj == NULL) {
 195         WARN("invalid parameter\n");
 196         return E_INVALIDARG;
 197     }
 198
 199     if (IsEqualIID(riid, &IID_IUnknown)) {
 200         if (!This->pUnknown) {
 201             IDirectSound_IUnknown_Create(iface, &This->pUnknown);
 202             if (!This->pUnknown) {
 203                 WARN("IDirectSound_IUnknown_Create() failed\n");
 204                 *ppobj = NULL;
 205                 return E_NOINTERFACE;
 206             }
 207         }
 208         IDirectSound_IUnknown_AddRef(This->pUnknown);
 209         *ppobj = This->pUnknown;
 210         return S_OK;
 211     } else if (IsEqualIID(riid, &IID_IDirectSound)) {
 212         if (!This->pDS) {
 213             IDirectSound_IDirectSound_Create(iface, &This->pDS);
 214             if (!This->pDS) {
 215                 WARN("IDirectSound_IDirectSound_Create() failed\n");
 216                 *ppobj = NULL;
 217                 return E_NOINTERFACE;
 218             }
 219         }
 220         IDirectSound_IDirectSound_AddRef(This->pDS);
 221         *ppobj = This->pDS;
 222         return S_OK;
 223     }
 224
 225     *ppobj = NULL;
 226     WARN("Unknown IID %s\n",debugstr_guid(riid));
 227     return E_NOINTERFACE;
 228 }
 229
 230 static HRESULT DSOUND_QueryInterface8(
 231     LPDIRECTSOUND8 iface,
 232     REFIID riid,
 233     LPVOID * ppobj)
 234 {
 235     IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
 236     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 237
 238     if (ppobj == NULL) {
 239         WARN("invalid parameter\n");
 240         return E_INVALIDARG;
 241     }
 242
 243     if (IsEqualIID(riid, &IID_IUnknown)) {
 244         if (!This->pUnknown) {
 245             IDirectSound8_IUnknown_Create(iface, &This->pUnknown);
 246             if (!This->pUnknown) {
 247                 WARN("IDirectSound8_IUnknown_Create() failed\n");
 248                 *ppobj = NULL;
 249                 return E_NOINTERFACE;
 250             }
 251         }
 252         IDirectSound8_IUnknown_AddRef(This->pUnknown);
 253         *ppobj = This->pUnknown;
 254         return S_OK;
 255     } else if (IsEqualIID(riid, &IID_IDirectSound)) {
 256         if (!This->pDS) {
 257             IDirectSound8_IDirectSound_Create(iface, &This->pDS);
 258             if (!This->pDS) {
 259                 WARN("IDirectSound8_IDirectSound_Create() failed\n");
 260                 *ppobj = NULL;
 261                 return E_NOINTERFACE;
 262             }
 263         }
 264         IDirectSound8_IDirectSound_AddRef(This->pDS);
 265         *ppobj = This->pDS;
 266         return S_OK;
 267     } else if (IsEqualIID(riid, &IID_IDirectSound8)) {
 268         if (!This->pDS8) {
 269             IDirectSound8_IDirectSound8_Create(iface, &This->pDS8);
 270             if (!This->pDS8) {
 271                 WARN("IDirectSound8_IDirectSound8_Create() failed\n");
 272                 *ppobj = NULL;
 273                 return E_NOINTERFACE;
 274             }
 275         }
 276         IDirectSound8_IDirectSound8_AddRef(This->pDS8);
 277         *ppobj = This->pDS8;
 278         return S_OK;
 279     }
 280
 281     *ppobj = NULL;
 282     WARN("Unknown IID %s\n",debugstr_guid(riid));
 283     return E_NOINTERFACE;
 284 }
 285
 286 static ULONG IDirectSoundImpl_AddRef(
 287     LPDIRECTSOUND8 iface)
 288 {
 289     IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
 290     ULONG ref = InterlockedIncrement(&(This->ref));
 291     TRACE("(%p) ref was %d\n", This, ref - 1);
 292     return ref;
 293 }
 294
 295 static ULONG IDirectSoundImpl_Release(
 296     LPDIRECTSOUND8 iface)
 297 {
 298     IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
 299     ULONG ref = InterlockedDecrement(&(This->ref));
 300     TRACE("(%p) ref was %d\n", This, ref + 1);
 301
 302     if (!ref) {
 303         if (This->device)
 304             DirectSoundDevice_Release(This->device);
 305         HeapFree(GetProcessHeap(),0,This);
 306         TRACE("(%p) released\n", This);
 307     }
 308     return ref;
 309 }
 310
 311 static HRESULT IDirectSoundImpl_Create(
 312     LPDIRECTSOUND8 * ppDS)
 313 {
 314     IDirectSoundImpl* pDS;
 315     TRACE("(%p)\n",ppDS);
 316
 317     /* Allocate memory */
 318     pDS = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundImpl));
 319     if (pDS == NULL) {
 320         WARN("out of memory\n");
 321         *ppDS = NULL;
 322         return DSERR_OUTOFMEMORY;
 323     }
 324
 325     pDS->ref    = 0;
 326     pDS->device = NULL;
 327
 328     *ppDS = (LPDIRECTSOUND8)pDS;
 329
 330     return DS_OK;
 331 }
 332
 333 /*******************************************************************************
 334  *              IDirectSound_IUnknown
 335  */
 336 static HRESULT WINAPI IDirectSound_IUnknown_QueryInterface(
 337     LPUNKNOWN iface,
 338     REFIID riid,
 339     LPVOID * ppobj)
 340 {
 341     IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
 342     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 343     return DSOUND_QueryInterface(This->pds, riid, ppobj);
 344 }
 345
 346 static ULONG WINAPI IDirectSound_IUnknown_AddRef(
 347     LPUNKNOWN iface)
 348 {
 349     IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
 350     ULONG ref = InterlockedIncrement(&(This->ref));
 351     TRACE("(%p) ref was %d\n", This, ref - 1);
 352     return ref;
 353 }
 354
 355 static ULONG WINAPI IDirectSound_IUnknown_Release(
 356     LPUNKNOWN iface)
 357 {
 358     IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
 359     ULONG ref = InterlockedDecrement(&(This->ref));
 360     TRACE("(%p) ref was %d\n", This, ref + 1);
 361     if (!ref) {
 362         ((IDirectSoundImpl*)This->pds)->pUnknown = NULL;
 363         IDirectSoundImpl_Release(This->pds);
 364         HeapFree(GetProcessHeap(), 0, This);
 365         TRACE("(%p) released\n", This);
 366     }
 367     return ref;
 368 }
 369
 370 static const IUnknownVtbl DirectSound_Unknown_Vtbl =
 371 {
 372     IDirectSound_IUnknown_QueryInterface,
 373     IDirectSound_IUnknown_AddRef,
 374     IDirectSound_IUnknown_Release
 375 };
 376
 377 static HRESULT IDirectSound_IUnknown_Create(
 378     LPDIRECTSOUND8 pds,
 379     LPUNKNOWN * ppunk)
 380 {
 381     IDirectSound_IUnknown * pdsunk;
 382     TRACE("(%p,%p)\n",pds,ppunk);
 383
 384     if (ppunk == NULL) {
 385         ERR("invalid parameter: ppunk == NULL\n");
 386         return DSERR_INVALIDPARAM;
 387     }
 388
 389     if (pds == NULL) {
 390         ERR("invalid parameter: pds == NULL\n");
 391         *ppunk = NULL;
 392         return DSERR_INVALIDPARAM;
 393     }
 394
 395     pdsunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsunk));
 396     if (pdsunk == NULL) {
 397         WARN("out of memory\n");
 398         *ppunk = NULL;
 399         return DSERR_OUTOFMEMORY;
 400     }
 401
 402     pdsunk->lpVtbl = &DirectSound_Unknown_Vtbl;
 403     pdsunk->ref = 0;
 404     pdsunk->pds = pds;
 405
 406     IDirectSoundImpl_AddRef(pds);
 407     *ppunk = (LPUNKNOWN)pdsunk;
 408
 409     return DS_OK;
 410 }
 411
 412 /*******************************************************************************
 413  *              IDirectSound_IDirectSound
 414  */
 415 static HRESULT WINAPI IDirectSound_IDirectSound_QueryInterface(
 416     LPDIRECTSOUND iface,
 417     REFIID riid,
 418     LPVOID * ppobj)
 419 {
 420     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 421     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 422     return DSOUND_QueryInterface(This->pds, riid, ppobj);
 423 }
 424
 425 static ULONG WINAPI IDirectSound_IDirectSound_AddRef(
 426     LPDIRECTSOUND iface)
 427 {
 428     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 429     ULONG ref = InterlockedIncrement(&(This->ref));
 430     TRACE("(%p) ref was %d\n", This, ref - 1);
 431     return ref;
 432 }
 433
 434 static ULONG WINAPI IDirectSound_IDirectSound_Release(
 435     LPDIRECTSOUND iface)
 436 {
 437     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 438     ULONG ref = InterlockedDecrement(&(This->ref));
 439     TRACE("(%p) ref was %d\n", This, ref + 1);
 440     if (!ref) {
 441         ((IDirectSoundImpl*)This->pds)->pDS = NULL;
 442         IDirectSoundImpl_Release(This->pds);
 443         HeapFree(GetProcessHeap(), 0, This);
 444         TRACE("(%p) released\n", This);
 445     }
 446     return ref;
 447 }
 448
 449 static HRESULT WINAPI IDirectSound_IDirectSound_CreateSoundBuffer(
 450     LPDIRECTSOUND iface,
 451     LPCDSBUFFERDESC dsbd,
 452     LPLPDIRECTSOUNDBUFFER ppdsb,
 453     LPUNKNOWN lpunk)
 454 {
 455     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 456     TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
 457     return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,FALSE);
 458 }
 459
 460 static HRESULT WINAPI IDirectSound_IDirectSound_GetCaps(
 461     LPDIRECTSOUND iface,
 462     LPDSCAPS lpDSCaps)
 463 {
 464     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 465     TRACE("(%p,%p)\n",This,lpDSCaps);
 466     return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps);
 467 }
 468
 469 static HRESULT WINAPI IDirectSound_IDirectSound_DuplicateSoundBuffer(
 470     LPDIRECTSOUND iface,
 471     LPDIRECTSOUNDBUFFER psb,
 472     LPLPDIRECTSOUNDBUFFER ppdsb)
 473 {
 474     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 475     TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
 476     return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb);
 477 }
 478
 479 static HRESULT WINAPI IDirectSound_IDirectSound_SetCooperativeLevel(
 480     LPDIRECTSOUND iface,
 481     HWND hwnd,
 482     DWORD level)
 483 {
 484     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 485     TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
 486     return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level);
 487 }
 488
 489 static HRESULT WINAPI IDirectSound_IDirectSound_Compact(
 490     LPDIRECTSOUND iface)
 491 {
 492     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 493     TRACE("(%p)\n", This);
 494     return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device);
 495 }
 496
 497 static HRESULT WINAPI IDirectSound_IDirectSound_GetSpeakerConfig(
 498     LPDIRECTSOUND iface,
 499     LPDWORD lpdwSpeakerConfig)
 500 {
 501     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 502     TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
 503     return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig);
 504 }
 505
 506 static HRESULT WINAPI IDirectSound_IDirectSound_SetSpeakerConfig(
 507     LPDIRECTSOUND iface,
 508     DWORD config)
 509 {
 510     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 511     TRACE("(%p,0x%08x)\n",This,config);
 512     return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config);
 513 }
 514
 515 static HRESULT WINAPI IDirectSound_IDirectSound_Initialize(
 516     LPDIRECTSOUND iface,
 517     LPCGUID lpcGuid)
 518 {
 519     IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
 520     TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
 521     return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid);
 522 }
 523
 524 static const IDirectSoundVtbl DirectSound_DirectSound_Vtbl =
 525 {
 526     IDirectSound_IDirectSound_QueryInterface,
 527     IDirectSound_IDirectSound_AddRef,
 528     IDirectSound_IDirectSound_Release,
 529     IDirectSound_IDirectSound_CreateSoundBuffer,
 530     IDirectSound_IDirectSound_GetCaps,
 531     IDirectSound_IDirectSound_DuplicateSoundBuffer,
 532     IDirectSound_IDirectSound_SetCooperativeLevel,
 533     IDirectSound_IDirectSound_Compact,
 534     IDirectSound_IDirectSound_GetSpeakerConfig,
 535     IDirectSound_IDirectSound_SetSpeakerConfig,
 536     IDirectSound_IDirectSound_Initialize
 537 };
 538
 539 static HRESULT IDirectSound_IDirectSound_Create(
 540     LPDIRECTSOUND8  pds,
 541     LPDIRECTSOUND * ppds)
 542 {
 543     IDirectSound_IDirectSound * pdsds;
 544     TRACE("(%p,%p)\n",pds,ppds);
 545
 546     if (ppds == NULL) {
 547         ERR("invalid parameter: ppds == NULL\n");
 548         return DSERR_INVALIDPARAM;
 549     }
 550
 551     if (pds == NULL) {
 552         ERR("invalid parameter: pds == NULL\n");
 553         *ppds = NULL;
 554         return DSERR_INVALIDPARAM;
 555     }
 556
 557     pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds));
 558     if (pdsds == NULL) {
 559         WARN("out of memory\n");
 560         *ppds = NULL;
 561         return DSERR_OUTOFMEMORY;
 562     }
 563
 564     pdsds->lpVtbl = &DirectSound_DirectSound_Vtbl;
 565     pdsds->ref = 0;
 566     pdsds->pds = pds;
 567
 568     IDirectSoundImpl_AddRef(pds);
 569     *ppds = (LPDIRECTSOUND)pdsds;
 570
 571     return DS_OK;
 572 }
 573
 574 /*******************************************************************************
 575  *              IDirectSound8_IUnknown
 576  */
 577 static HRESULT WINAPI IDirectSound8_IUnknown_QueryInterface(
 578     LPUNKNOWN iface,
 579     REFIID riid,
 580     LPVOID * ppobj)
 581 {
 582     IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
 583     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 584     return DSOUND_QueryInterface8(This->pds, riid, ppobj);
 585 }
 586
 587 static ULONG WINAPI IDirectSound8_IUnknown_AddRef(
 588     LPUNKNOWN iface)
 589 {
 590     IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
 591     ULONG ref = InterlockedIncrement(&(This->ref));
 592     TRACE("(%p) ref was %d\n", This, ref - 1);
 593     return ref;
 594 }
 595
 596 static ULONG WINAPI IDirectSound8_IUnknown_Release(
 597     LPUNKNOWN iface)
 598 {
 599     IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
 600     ULONG ref = InterlockedDecrement(&(This->ref));
 601     TRACE("(%p) ref was %d\n", This, ref + 1);
 602     if (!ref) {
 603         ((IDirectSoundImpl*)This->pds)->pUnknown = NULL;
 604         IDirectSoundImpl_Release(This->pds);
 605         HeapFree(GetProcessHeap(), 0, This);
 606         TRACE("(%p) released\n", This);
 607     }
 608     return ref;
 609 }
 610
 611 static const IUnknownVtbl DirectSound8_Unknown_Vtbl =
 612 {
 613     IDirectSound8_IUnknown_QueryInterface,
 614     IDirectSound8_IUnknown_AddRef,
 615     IDirectSound8_IUnknown_Release
 616 };
 617
 618 static HRESULT IDirectSound8_IUnknown_Create(
 619     LPDIRECTSOUND8 pds,
 620     LPUNKNOWN * ppunk)
 621 {
 622     IDirectSound8_IUnknown * pdsunk;
 623     TRACE("(%p,%p)\n",pds,ppunk);
 624
 625     if (ppunk == NULL) {
 626         ERR("invalid parameter: ppunk == NULL\n");
 627         return DSERR_INVALIDPARAM;
 628     }
 629
 630     if (pds == NULL) {
 631         ERR("invalid parameter: pds == NULL\n");
 632         *ppunk = NULL;
 633         return DSERR_INVALIDPARAM;
 634     }
 635
 636     pdsunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsunk));
 637     if (pdsunk == NULL) {
 638         WARN("out of memory\n");
 639         *ppunk = NULL;
 640         return DSERR_OUTOFMEMORY;
 641     }
 642
 643     pdsunk->lpVtbl = &DirectSound8_Unknown_Vtbl;
 644     pdsunk->ref = 0;
 645     pdsunk->pds = pds;
 646
 647     IDirectSoundImpl_AddRef(pds);
 648     *ppunk = (LPUNKNOWN)pdsunk;
 649
 650     return DS_OK;
 651 }
 652
 653 /*******************************************************************************
 654  *              IDirectSound8_IDirectSound
 655  */
 656 static HRESULT WINAPI IDirectSound8_IDirectSound_QueryInterface(
 657     LPDIRECTSOUND iface,
 658     REFIID riid,
 659     LPVOID * ppobj)
 660 {
 661     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 662     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 663     return DSOUND_QueryInterface8(This->pds, riid, ppobj);
 664 }
 665
 666 static ULONG WINAPI IDirectSound8_IDirectSound_AddRef(
 667     LPDIRECTSOUND iface)
 668 {
 669     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 670     ULONG ref = InterlockedIncrement(&(This->ref));
 671     TRACE("(%p) ref was %d\n", This, ref - 1);
 672     return ref;
 673 }
 674
 675 static ULONG WINAPI IDirectSound8_IDirectSound_Release(
 676     LPDIRECTSOUND iface)
 677 {
 678     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 679     ULONG ref = InterlockedDecrement(&(This->ref));
 680     TRACE("(%p) ref was %d\n", This, ref + 1);
 681     if (!ref) {
 682         ((IDirectSoundImpl*)This->pds)->pDS = NULL;
 683         IDirectSoundImpl_Release(This->pds);
 684         HeapFree(GetProcessHeap(), 0, This);
 685         TRACE("(%p) released\n", This);
 686     }
 687     return ref;
 688 }
 689
 690 static HRESULT WINAPI IDirectSound8_IDirectSound_CreateSoundBuffer(
 691     LPDIRECTSOUND iface,
 692     LPCDSBUFFERDESC dsbd,
 693     LPLPDIRECTSOUNDBUFFER ppdsb,
 694     LPUNKNOWN lpunk)
 695 {
 696     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 697     TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
 698     return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,TRUE);
 699 }
 700
 701 static HRESULT WINAPI IDirectSound8_IDirectSound_GetCaps(
 702     LPDIRECTSOUND iface,
 703     LPDSCAPS lpDSCaps)
 704 {
 705     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 706     TRACE("(%p,%p)\n",This,lpDSCaps);
 707     return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps);
 708 }
 709
 710 static HRESULT WINAPI IDirectSound8_IDirectSound_DuplicateSoundBuffer(
 711     LPDIRECTSOUND iface,
 712     LPDIRECTSOUNDBUFFER psb,
 713     LPLPDIRECTSOUNDBUFFER ppdsb)
 714 {
 715     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 716     TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
 717     return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb);
 718 }
 719
 720 static HRESULT WINAPI IDirectSound8_IDirectSound_SetCooperativeLevel(
 721     LPDIRECTSOUND iface,
 722     HWND hwnd,
 723     DWORD level)
 724 {
 725     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 726     TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
 727     return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level);
 728 }
 729
 730 static HRESULT WINAPI IDirectSound8_IDirectSound_Compact(
 731     LPDIRECTSOUND iface)
 732 {
 733     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 734     TRACE("(%p)\n", This);
 735     return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device);
 736 }
 737
 738 static HRESULT WINAPI IDirectSound8_IDirectSound_GetSpeakerConfig(
 739     LPDIRECTSOUND iface,
 740     LPDWORD lpdwSpeakerConfig)
 741 {
 742     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 743     TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
 744     return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig);
 745 }
 746
 747 static HRESULT WINAPI IDirectSound8_IDirectSound_SetSpeakerConfig(
 748     LPDIRECTSOUND iface,
 749     DWORD config)
 750 {
 751     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 752     TRACE("(%p,0x%08x)\n",This,config);
 753     return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config);
 754 }
 755
 756 static HRESULT WINAPI IDirectSound8_IDirectSound_Initialize(
 757     LPDIRECTSOUND iface,
 758     LPCGUID lpcGuid)
 759 {
 760     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 761     TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
 762     return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid);
 763 }
 764
 765 static const IDirectSoundVtbl DirectSound8_DirectSound_Vtbl =
 766 {
 767     IDirectSound8_IDirectSound_QueryInterface,
 768     IDirectSound8_IDirectSound_AddRef,
 769     IDirectSound8_IDirectSound_Release,
 770     IDirectSound8_IDirectSound_CreateSoundBuffer,
 771     IDirectSound8_IDirectSound_GetCaps,
 772     IDirectSound8_IDirectSound_DuplicateSoundBuffer,
 773     IDirectSound8_IDirectSound_SetCooperativeLevel,
 774     IDirectSound8_IDirectSound_Compact,
 775     IDirectSound8_IDirectSound_GetSpeakerConfig,
 776     IDirectSound8_IDirectSound_SetSpeakerConfig,
 777     IDirectSound8_IDirectSound_Initialize
 778 };
 779
 780 static HRESULT IDirectSound8_IDirectSound_Create(
 781     LPDIRECTSOUND8 pds,
 782     LPDIRECTSOUND * ppds)
 783 {
 784     IDirectSound8_IDirectSound * pdsds;
 785     TRACE("(%p,%p)\n",pds,ppds);
 786
 787     if (ppds == NULL) {
 788         ERR("invalid parameter: ppds == NULL\n");
 789         return DSERR_INVALIDPARAM;
 790     }
 791
 792     if (pds == NULL) {
 793         ERR("invalid parameter: pds == NULL\n");
 794         *ppds = NULL;
 795         return DSERR_INVALIDPARAM;
 796     }
 797
 798     pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds));
 799     if (pdsds == NULL) {
 800         WARN("out of memory\n");
 801         *ppds = NULL;
 802         return DSERR_OUTOFMEMORY;
 803     }
 804
 805     pdsds->lpVtbl = &DirectSound8_DirectSound_Vtbl;
 806     pdsds->ref = 0;
 807     pdsds->pds = pds;
 808
 809     IDirectSoundImpl_AddRef(pds);
 810     *ppds = (LPDIRECTSOUND)pdsds;
 811
 812     return DS_OK;
 813 }
 814
 815 /*******************************************************************************
 816  *              IDirectSound8_IDirectSound8
 817  */
 818 static HRESULT WINAPI IDirectSound8_IDirectSound8_QueryInterface(
 819     LPDIRECTSOUND8 iface,
 820     REFIID riid,
 821     LPVOID * ppobj)
 822 {
 823     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 824     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 825     return DSOUND_QueryInterface8(This->pds, riid, ppobj);
 826 }
 827
 828 static ULONG WINAPI IDirectSound8_IDirectSound8_AddRef(
 829     LPDIRECTSOUND8 iface)
 830 {
 831     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 832     ULONG ref = InterlockedIncrement(&(This->ref));
 833     TRACE("(%p) ref was %d\n", This, ref - 1);
 834     return ref;
 835 }
 836
 837 static ULONG WINAPI IDirectSound8_IDirectSound8_Release(
 838     LPDIRECTSOUND8 iface)
 839 {
 840     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 841     ULONG ref = InterlockedDecrement(&(This->ref));
 842     TRACE("(%p) ref was %d\n", This, ref + 1);
 843     if (!ref) {
 844         ((IDirectSoundImpl*)This->pds)->pDS8 = NULL;
 845         IDirectSoundImpl_Release(This->pds);
 846         HeapFree(GetProcessHeap(), 0, This);
 847         TRACE("(%p) released\n", This);
 848     }
 849     return ref;
 850 }
 851
 852 static HRESULT WINAPI IDirectSound8_IDirectSound8_CreateSoundBuffer(
 853     LPDIRECTSOUND8 iface,
 854     LPCDSBUFFERDESC dsbd,
 855     LPLPDIRECTSOUNDBUFFER ppdsb,
 856     LPUNKNOWN lpunk)
 857 {
 858     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 859     TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
 860     return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,TRUE);
 861 }
 862
 863 static HRESULT WINAPI IDirectSound8_IDirectSound8_GetCaps(
 864     LPDIRECTSOUND8 iface,
 865     LPDSCAPS lpDSCaps)
 866 {
 867     IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
 868     TRACE("(%p,%p)\n",This,lpDSCaps);
 869     return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps);
 870 }
 871
 872 static HRESULT WINAPI IDirectSound8_IDirectSound8_DuplicateSoundBuffer(
 873     LPDIRECTSOUND8 iface,
 874     LPDIRECTSOUNDBUFFER psb,
 875     LPLPDIRECTSOUNDBUFFER ppdsb)
 876 {
 877     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 878     TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
 879     return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb);
 880 }
 881
 882 static HRESULT WINAPI IDirectSound8_IDirectSound8_SetCooperativeLevel(
 883     LPDIRECTSOUND8 iface,
 884     HWND hwnd,
 885     DWORD level)
 886 {
 887     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 888     TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
 889     return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level);
 890 }
 891
 892 static HRESULT WINAPI IDirectSound8_IDirectSound8_Compact(
 893     LPDIRECTSOUND8 iface)
 894 {
 895     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 896     TRACE("(%p)\n", This);
 897     return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device);
 898 }
 899
 900 static HRESULT WINAPI IDirectSound8_IDirectSound8_GetSpeakerConfig(
 901     LPDIRECTSOUND8 iface,
 902     LPDWORD lpdwSpeakerConfig)
 903 {
 904     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 905     TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
 906     return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig);
 907 }
 908
 909 static HRESULT WINAPI IDirectSound8_IDirectSound8_SetSpeakerConfig(
 910     LPDIRECTSOUND8 iface,
 911     DWORD config)
 912 {
 913     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 914     TRACE("(%p,0x%08x)\n",This,config);
 915     return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config);
 916 }
 917
 918 static HRESULT WINAPI IDirectSound8_IDirectSound8_Initialize(
 919     LPDIRECTSOUND8 iface,
 920     LPCGUID lpcGuid)
 921 {
 922     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 923     TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
 924     return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid);
 925 }
 926
 927 static HRESULT WINAPI IDirectSound8_IDirectSound8_VerifyCertification(
 928     LPDIRECTSOUND8 iface,
 929     LPDWORD pdwCertified)
 930 {
 931     IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
 932     TRACE("(%p, %p)\n", This, pdwCertified);
 933     return DirectSoundDevice_VerifyCertification(((IDirectSoundImpl *)This->pds)->device,pdwCertified);
 934 }
 935
 936 static const IDirectSound8Vtbl DirectSound8_DirectSound8_Vtbl =
 937 {
 938     IDirectSound8_IDirectSound8_QueryInterface,
 939     IDirectSound8_IDirectSound8_AddRef,
 940     IDirectSound8_IDirectSound8_Release,
 941     IDirectSound8_IDirectSound8_CreateSoundBuffer,
 942     IDirectSound8_IDirectSound8_GetCaps,
 943     IDirectSound8_IDirectSound8_DuplicateSoundBuffer,
 944     IDirectSound8_IDirectSound8_SetCooperativeLevel,
 945     IDirectSound8_IDirectSound8_Compact,
 946     IDirectSound8_IDirectSound8_GetSpeakerConfig,
 947     IDirectSound8_IDirectSound8_SetSpeakerConfig,
 948     IDirectSound8_IDirectSound8_Initialize,
 949     IDirectSound8_IDirectSound8_VerifyCertification
 950 };
 951
 952 static HRESULT IDirectSound8_IDirectSound8_Create(
 953     LPDIRECTSOUND8 pds,
 954     LPDIRECTSOUND8 * ppds)
 955 {
 956     IDirectSound8_IDirectSound8 * pdsds;
 957     TRACE("(%p,%p)\n",pds,ppds);
 958
 959     if (ppds == NULL) {
 960         ERR("invalid parameter: ppds == NULL\n");
 961         return DSERR_INVALIDPARAM;
 962     }
 963
 964     if (pds == NULL) {
 965         ERR("invalid parameter: pds == NULL\n");
 966         *ppds = NULL;
 967         return DSERR_INVALIDPARAM;
 968     }
 969
 970     pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds));
 971     if (pdsds == NULL) {
 972         WARN("out of memory\n");
 973         *ppds = NULL;
 974         return DSERR_OUTOFMEMORY;
 975     }
 976
 977     pdsds->lpVtbl = &DirectSound8_DirectSound8_Vtbl;
 978     pdsds->ref = 0;
 979     pdsds->pds = pds;
 980
 981     IDirectSoundImpl_AddRef(pds);
 982     *ppds = (LPDIRECTSOUND8)pdsds;
 983
 984     return DS_OK;
 985 }
 986
 987 HRESULT DSOUND_Create(
 988     REFIID riid,
 989     LPDIRECTSOUND *ppDS)
 990 {
 991     LPDIRECTSOUND8 pDS;
 992     HRESULT hr;
 993     TRACE("(%s, %p)\n", debugstr_guid(riid), ppDS);
 994
 995     if (!IsEqualIID(riid, &IID_IUnknown) &&
 996         !IsEqualIID(riid, &IID_IDirectSound)) {
 997         *ppDS = 0;
 998         return E_NOINTERFACE;
 999     }
1000
1001     /* Get dsound configuration */
1002     setup_dsound_options();
1003
1004     hr = IDirectSoundImpl_Create(&pDS);
1005     if (hr == DS_OK) {
1006         hr = IDirectSound_IDirectSound_Create(pDS, ppDS);
1007         if (*ppDS)
1008             IDirectSound_IDirectSound_AddRef(*ppDS);
1009         else {
1010             WARN("IDirectSound_IDirectSound_Create failed\n");
1011             IDirectSound8_Release(pDS);
1012         }
1013     } else {
1014         WARN("IDirectSoundImpl_Create failed\n");
1015         *ppDS = 0;
1016     }
1017
1018     return hr;
1019 }
1020
1021 /*******************************************************************************
1022  *              DirectSoundCreate (DSOUND.1)
1023  *
1024  *  Creates and initializes a DirectSound interface.
1025  *
1026  *  PARAMS
1027  *     lpcGUID   [I] Address of the GUID that identifies the sound device.
1028  *     ppDS      [O] Address of a variable to receive the interface pointer.
1029  *     pUnkOuter [I] Must be NULL.
1030  *
1031  *  RETURNS
1032  *     Success: DS_OK
1033  *     Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
1034  *              DSERR_NODRIVER, DSERR_OUTOFMEMORY
1035  */
1036 HRESULT WINAPI DirectSoundCreate(
1037     LPCGUID lpcGUID,
1038     LPDIRECTSOUND *ppDS,
1039     IUnknown *pUnkOuter)
1040 {
1041     HRESULT hr;
1042     LPDIRECTSOUND pDS;
1043
1044     TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter);
1045
1046     if (ppDS == NULL) {
1047         WARN("invalid parameter: ppDS == NULL\n");
1048         return DSERR_INVALIDPARAM;
1049     }
1050
1051     if (pUnkOuter != NULL) {
1052         WARN("invalid parameter: pUnkOuter != NULL\n");
1053         *ppDS = 0;
1054         return DSERR_INVALIDPARAM;
1055     }
1056
1057     hr = DSOUND_Create(&IID_IDirectSound, &pDS);
1058     if (hr == DS_OK) {
1059         hr = IDirectSound_Initialize(pDS, lpcGUID);
1060         if (hr != DS_OK) {
1061             if (hr != DSERR_ALREADYINITIALIZED) {
1062                 IDirectSound_Release(pDS);
1063                 pDS = 0;
1064             } else
1065                 hr = DS_OK;
1066         }
1067     }
1068
1069     *ppDS = pDS;
1070
1071     return hr;
1072 }
1073
1074 HRESULT DSOUND_Create8(
1075     REFIID riid,
1076     LPDIRECTSOUND8 *ppDS)
1077 {
1078     LPDIRECTSOUND8 pDS;
1079     HRESULT hr;
1080     TRACE("(%s, %p)\n", debugstr_guid(riid), ppDS);
1081
1082     if (!IsEqualIID(riid, &IID_IUnknown) &&
1083         !IsEqualIID(riid, &IID_IDirectSound) &&
1084         !IsEqualIID(riid, &IID_IDirectSound8)) {
1085         *ppDS = 0;
1086         return E_NOINTERFACE;
1087     }
1088
1089     /* Get dsound configuration */
1090     setup_dsound_options();
1091
1092     hr = IDirectSoundImpl_Create(&pDS);
1093     if (hr == DS_OK) {
1094         hr = IDirectSound8_IDirectSound8_Create(pDS, ppDS);
1095         if (*ppDS)
1096             IDirectSound8_IDirectSound8_AddRef(*ppDS);
1097         else {
1098             WARN("IDirectSound8_IDirectSound8_Create failed\n");
1099             IDirectSound8_Release(pDS);
1100         }
1101     } else {
1102         WARN("IDirectSoundImpl_Create failed\n");
1103         *ppDS = 0;
1104     }
1105
1106     return hr;
1107 }
1108
1109 /*******************************************************************************
1110  *        DirectSoundCreate8 (DSOUND.11)
1111  *
1112  *  Creates and initializes a DirectSound8 interface.
1113  *
1114  *  PARAMS
1115  *     lpcGUID   [I] Address of the GUID that identifies the sound device.
1116  *     ppDS      [O] Address of a variable to receive the interface pointer.
1117  *     pUnkOuter [I] Must be NULL.
1118  *
1119  *  RETURNS
1120  *     Success: DS_OK
1121  *     Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
1122  *              DSERR_NODRIVER, DSERR_OUTOFMEMORY
1123  */
1124 HRESULT WINAPI DirectSoundCreate8(
1125     LPCGUID lpcGUID,
1126     LPDIRECTSOUND8 *ppDS,
1127     IUnknown *pUnkOuter)
1128 {
1129     HRESULT hr;
1130     LPDIRECTSOUND8 pDS;
1131
1132     TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter);
1133
1134     if (ppDS == NULL) {
1135         WARN("invalid parameter: ppDS == NULL\n");
1136         return DSERR_INVALIDPARAM;
1137     }
1138
1139     if (pUnkOuter != NULL) {
1140         WARN("invalid parameter: pUnkOuter != NULL\n");
1141         *ppDS = 0;
1142         return DSERR_INVALIDPARAM;
1143     }
1144
1145     hr = DSOUND_Create8(&IID_IDirectSound8, &pDS);
1146     if (hr == DS_OK) {
1147         hr = IDirectSound8_Initialize(pDS, lpcGUID);
1148         if (hr != DS_OK) {
1149             if (hr != DSERR_ALREADYINITIALIZED) {
1150                 IDirectSound8_Release(pDS);
1151                 pDS = 0;
1152             } else
1153                 hr = DS_OK;
1154         }
1155     }
1156
1157     *ppDS = pDS;
1158
1159     return hr;
1160 }
1161
1162 /*******************************************************************************
1163  *        DirectSoundDevice
1164  */
1165 static HRESULT DirectSoundDevice_Create(DirectSoundDevice ** ppDevice)
1166 {
1167     DirectSoundDevice * device;
1168     TRACE("(%p)\n", ppDevice);
1169
1170     /* Allocate memory */
1171     device = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DirectSoundDevice));
1172     if (device == NULL) {
1173         WARN("out of memory\n");
1174         return DSERR_OUTOFMEMORY;
1175     }
1176
1177     device->ref            = 1;
1178     device->priolevel      = DSSCL_NORMAL;
1179     device->state          = STATE_STOPPED;
1180     device->speaker_config = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16);
1181
1182     /* 3D listener initial parameters */
1183     device->ds3dl.dwSize   = sizeof(DS3DLISTENER);
1184     device->ds3dl.vPosition.x = 0.0;
1185     device->ds3dl.vPosition.y = 0.0;
1186     device->ds3dl.vPosition.z = 0.0;
1187     device->ds3dl.vVelocity.x = 0.0;
1188     device->ds3dl.vVelocity.y = 0.0;
1189     device->ds3dl.vVelocity.z = 0.0;
1190     device->ds3dl.vOrientFront.x = 0.0;
1191     device->ds3dl.vOrientFront.y = 0.0;
1192     device->ds3dl.vOrientFront.z = 1.0;
1193     device->ds3dl.vOrientTop.x = 0.0;
1194     device->ds3dl.vOrientTop.y = 1.0;
1195     device->ds3dl.vOrientTop.z = 0.0;
1196     device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
1197     device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
1198     device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
1199
1200     device->prebuf = ds_snd_queue_max;
1201     device->guid = GUID_NULL;
1202
1203     /* Set default wave format (may need it for waveOutOpen) */
1204     device->pwfx = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(WAVEFORMATEX));
1205     if (device->pwfx == NULL) {
1206         WARN("out of memory\n");
1207         HeapFree(GetProcessHeap(),0,device);
1208         return DSERR_OUTOFMEMORY;
1209     }
1210
1211     /* We rely on the sound driver to return the actual sound format of
1212      * the device if it does not support 22050x8x2 and is given the
1213      * WAVE_DIRECTSOUND flag.
1214      */
1215     device->pwfx->wFormatTag = WAVE_FORMAT_PCM;
1216     device->pwfx->nSamplesPerSec = ds_default_sample_rate;
1217     device->pwfx->wBitsPerSample = ds_default_bits_per_sample;
1218     device->pwfx->nChannels = 2;
1219     device->pwfx->nBlockAlign = device->pwfx->wBitsPerSample * device->pwfx->nChannels / 8;
1220     device->pwfx->nAvgBytesPerSec = device->pwfx->nSamplesPerSec * device->pwfx->nBlockAlign;
1221     device->pwfx->cbSize = 0;
1222
1223     InitializeCriticalSection(&(device->mixlock));
1224     device->mixlock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DirectSoundDevice.mixlock");
1225
1226     RtlInitializeResource(&(device->buffer_list_lock));
1227
1228    *ppDevice = device;
1229
1230     return DS_OK;
1231 }
1232
1233 static ULONG DirectSoundDevice_AddRef(DirectSoundDevice * device)
1234 {
1235     ULONG ref = InterlockedIncrement(&(device->ref));
1236     TRACE("(%p) ref was %d\n", device, ref - 1);
1237     return ref;
1238 }
1239
1240 ULONG DirectSoundDevice_Release(DirectSoundDevice * device)
1241 {
1242     HRESULT hr;
1243     ULONG ref = InterlockedDecrement(&(device->ref));
1244     TRACE("(%p) ref was %u\n", device, ref + 1);
1245     if (!ref) {
1246         int i;
1247         timeKillEvent(device->timerID);
1248         timeEndPeriod(DS_TIME_RES);
1249
1250         /* The kill event should have allowed the timer process to expire
1251          * but try to grab the lock just in case. Can't hold lock because
1252          * IDirectSoundBufferImpl_Destroy also grabs the lock */
1253         RtlAcquireResourceShared(&(device->buffer_list_lock), TRUE);
1254         RtlReleaseResource(&(device->buffer_list_lock));
1255
1256         /* It is allowed to release this object even when buffers are playing */
1257         if (device->buffers) {
1258             WARN("%d secondary buffers not released\n", device->nrofbuffers);
1259             for( i=0;i<device->nrofbuffers;i++)
1260                 IDirectSoundBufferImpl_Destroy(device->buffers[i]);
1261         }
1262
1263         if (device->primary) {
1264             WARN("primary buffer not released\n");
1265             IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)device->primary);
1266         }
1267
1268         hr = DSOUND_PrimaryDestroy(device);
1269         if (hr != DS_OK)
1270             WARN("DSOUND_PrimaryDestroy failed\n");
1271
1272         if (device->driver)
1273             IDsDriver_Close(device->driver);
1274
1275         if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
1276             waveOutClose(device->hwo);
1277
1278         if (device->driver)
1279             IDsDriver_Release(device->driver);
1280
1281         DSOUND_renderer[device->drvdesc.dnDevNode] = NULL;
1282
1283         HeapFree(GetProcessHeap(), 0, device->tmp_buffer);
1284         HeapFree(GetProcessHeap(), 0, device->mix_buffer);
1285         if (device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY)
1286             HeapFree(GetProcessHeap(), 0, device->buffer);
1287         RtlDeleteResource(&device->buffer_list_lock);
1288         device->mixlock.DebugInfo->Spare[0] = 0;
1289         DeleteCriticalSection(&device->mixlock);
1290         HeapFree(GetProcessHeap(),0,device);
1291         TRACE("(%p) released\n", device);
1292     }
1293     return ref;
1294 }
1295
1296 HRESULT DirectSoundDevice_GetCaps(
1297     DirectSoundDevice * device,
1298     LPDSCAPS lpDSCaps)
1299 {
1300     TRACE("(%p,%p)\n",device,lpDSCaps);
1301
1302     if (device == NULL) {
1303         WARN("not initialized\n");
1304         return DSERR_UNINITIALIZED;
1305     }
1306
1307     if (lpDSCaps == NULL) {
1308         WARN("invalid parameter: lpDSCaps = NULL\n");
1309         return DSERR_INVALIDPARAM;
1310     }
1311
1312     /* check if there is enough room */
1313     if (lpDSCaps->dwSize < sizeof(*lpDSCaps)) {
1314         WARN("invalid parameter: lpDSCaps->dwSize = %d\n", lpDSCaps->dwSize);
1315         return DSERR_INVALIDPARAM;
1316     }
1317
1318     lpDSCaps->dwFlags                           = device->drvcaps.dwFlags;
1319     if (TRACE_ON(dsound)) {
1320         TRACE("(flags=0x%08x:\n",lpDSCaps->dwFlags);
1321         _dump_DSCAPS(lpDSCaps->dwFlags);
1322         TRACE(")\n");
1323     }
1324     lpDSCaps->dwMinSecondarySampleRate          = device->drvcaps.dwMinSecondarySampleRate;
1325     lpDSCaps->dwMaxSecondarySampleRate          = device->drvcaps.dwMaxSecondarySampleRate;
1326     lpDSCaps->dwPrimaryBuffers                  = device->drvcaps.dwPrimaryBuffers;
1327     lpDSCaps->dwMaxHwMixingAllBuffers           = device->drvcaps.dwMaxHwMixingAllBuffers;
1328     lpDSCaps->dwMaxHwMixingStaticBuffers        = device->drvcaps.dwMaxHwMixingStaticBuffers;
1329     lpDSCaps->dwMaxHwMixingStreamingBuffers     = device->drvcaps.dwMaxHwMixingStreamingBuffers;
1330     lpDSCaps->dwFreeHwMixingAllBuffers          = device->drvcaps.dwFreeHwMixingAllBuffers;
1331     lpDSCaps->dwFreeHwMixingStaticBuffers       = device->drvcaps.dwFreeHwMixingStaticBuffers;
1332     lpDSCaps->dwFreeHwMixingStreamingBuffers    = device->drvcaps.dwFreeHwMixingStreamingBuffers;
1333     lpDSCaps->dwMaxHw3DAllBuffers               = device->drvcaps.dwMaxHw3DAllBuffers;
1334     lpDSCaps->dwMaxHw3DStaticBuffers            = device->drvcaps.dwMaxHw3DStaticBuffers;
1335     lpDSCaps->dwMaxHw3DStreamingBuffers         = device->drvcaps.dwMaxHw3DStreamingBuffers;
1336     lpDSCaps->dwFreeHw3DAllBuffers              = device->drvcaps.dwFreeHw3DAllBuffers;
1337     lpDSCaps->dwFreeHw3DStaticBuffers           = device->drvcaps.dwFreeHw3DStaticBuffers;
1338     lpDSCaps->dwFreeHw3DStreamingBuffers        = device->drvcaps.dwFreeHw3DStreamingBuffers;
1339     lpDSCaps->dwTotalHwMemBytes                 = device->drvcaps.dwTotalHwMemBytes;
1340     lpDSCaps->dwFreeHwMemBytes                  = device->drvcaps.dwFreeHwMemBytes;
1341     lpDSCaps->dwMaxContigFreeHwMemBytes         = device->drvcaps.dwMaxContigFreeHwMemBytes;
1342
1343     /* driver doesn't have these */
1344     lpDSCaps->dwUnlockTransferRateHwBuffers     = 4096; /* But we have none... */
1345     lpDSCaps->dwPlayCpuOverheadSwBuffers        = 1;    /* 1% */
1346
1347     return DS_OK;
1348 }
1349
1350 HRESULT DirectSoundDevice_Initialize(DirectSoundDevice ** ppDevice, LPCGUID lpcGUID)
1351 {
1352     HRESULT hr = DS_OK;
1353     unsigned wod, wodn;
1354     BOOLEAN found = FALSE;
1355     GUID devGUID;
1356     DirectSoundDevice * device = *ppDevice;
1357     TRACE("(%p,%s)\n",ppDevice,debugstr_guid(lpcGUID));
1358
1359     if (*ppDevice != NULL) {
1360         WARN("already initialized\n");
1361         return DSERR_ALREADYINITIALIZED;
1362     }
1363
1364     /* Default device? */
1365     if (!lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL))
1366         lpcGUID = &DSDEVID_DefaultPlayback;
1367
1368     if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
1369         WARN("invalid parameter: lpcGUID\n");
1370         return DSERR_INVALIDPARAM;
1371     }
1372
1373     /* Enumerate WINMM audio devices and find the one we want */
1374     wodn = waveOutGetNumDevs();
1375     if (!wodn) {
1376         WARN("no driver\n");
1377         return DSERR_NODRIVER;
1378     }
1379
1380     for (wod=0; wod<wodn; wod++) {
1381         if (IsEqualGUID( &devGUID, &DSOUND_renderer_guids[wod])) {
1382             found = TRUE;
1383             break;
1384         }
1385     }
1386
1387     if (found == FALSE) {
1388         WARN("No device found matching given ID!\n");
1389         return DSERR_NODRIVER;
1390     }
1391
1392     if (DSOUND_renderer[wod]) {
1393         if (IsEqualGUID(&devGUID, &DSOUND_renderer[wod]->guid)) {
1394             device = DSOUND_renderer[wod];
1395             DirectSoundDevice_AddRef(device);
1396             *ppDevice = device;
1397             return DS_OK;
1398         } else {
1399             ERR("device GUID doesn't match\n");
1400             hr = DSERR_GENERIC;
1401             return hr;
1402         }
1403     } else {
1404         hr = DirectSoundDevice_Create(&device);
1405         if (hr != DS_OK) {
1406             WARN("DirectSoundDevice_Create failed\n");
1407             return hr;
1408         }
1409     }
1410
1411     *ppDevice = device;
1412     device->guid = devGUID;
1413     device->driver = NULL;
1414
1415     device->drvdesc.dnDevNode = wod;
1416     hr = DSOUND_ReopenDevice(device, FALSE);
1417     if (FAILED(hr))
1418     {
1419         WARN("DSOUND_ReopenDevice failed: %08x\n", hr);
1420         return hr;
1421     }
1422
1423     if (device->driver) {
1424         /* the driver is now open, so it's now allowed to call GetCaps */
1425         hr = IDsDriver_GetCaps(device->driver,&(device->drvcaps));
1426         if (hr != DS_OK) {
1427             WARN("IDsDriver_GetCaps failed\n");
1428             return hr;
1429         }
1430     } else {
1431         WAVEOUTCAPSA woc;
1432         hr = mmErr(waveOutGetDevCapsA(device->drvdesc.dnDevNode, &woc, sizeof(woc)));
1433         if (hr != DS_OK) {
1434             WARN("waveOutGetDevCaps failed\n");
1435             return hr;
1436         }
1437         ZeroMemory(&device->drvcaps, sizeof(device->drvcaps));
1438         if ((woc.dwFormats & WAVE_FORMAT_1M08) ||
1439             (woc.dwFormats & WAVE_FORMAT_2M08) ||
1440             (woc.dwFormats & WAVE_FORMAT_4M08) ||
1441             (woc.dwFormats & WAVE_FORMAT_48M08) ||
1442             (woc.dwFormats & WAVE_FORMAT_96M08)) {
1443             device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
1444             device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
1445         }
1446         if ((woc.dwFormats & WAVE_FORMAT_1M16) ||
1447             (woc.dwFormats & WAVE_FORMAT_2M16) ||
1448             (woc.dwFormats & WAVE_FORMAT_4M16) ||
1449             (woc.dwFormats & WAVE_FORMAT_48M16) ||
1450             (woc.dwFormats & WAVE_FORMAT_96M16)) {
1451             device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
1452             device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
1453         }
1454         if ((woc.dwFormats & WAVE_FORMAT_1S08) ||
1455             (woc.dwFormats & WAVE_FORMAT_2S08) ||
1456             (woc.dwFormats & WAVE_FORMAT_4S08) ||
1457             (woc.dwFormats & WAVE_FORMAT_48S08) ||
1458             (woc.dwFormats & WAVE_FORMAT_96S08)) {
1459             device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
1460             device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
1461         }
1462         if ((woc.dwFormats & WAVE_FORMAT_1S16) ||
1463             (woc.dwFormats & WAVE_FORMAT_2S16) ||
1464             (woc.dwFormats & WAVE_FORMAT_4S16) ||
1465             (woc.dwFormats & WAVE_FORMAT_48S16) ||
1466             (woc.dwFormats & WAVE_FORMAT_96S16)) {
1467             device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
1468             device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
1469         }
1470         if (ds_emuldriver)
1471             device->drvcaps.dwFlags |= DSCAPS_EMULDRIVER;
1472         device->drvcaps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
1473         device->drvcaps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
1474         ZeroMemory(&device->volpan, sizeof(device->volpan));
1475     }
1476
1477     hr = DSOUND_PrimaryCreate(device);
1478     if (hr == DS_OK) {
1479         UINT triggertime = DS_TIME_DEL, res = DS_TIME_RES, id;
1480         TIMECAPS time;
1481
1482         DSOUND_renderer[device->drvdesc.dnDevNode] = device;
1483         timeGetDevCaps(&time, sizeof(TIMECAPS));
1484         TRACE("Minimum timer resolution: %u, max timer: %u\n", time.wPeriodMin, time.wPeriodMax);
1485         if (triggertime < time.wPeriodMin)
1486             triggertime = time.wPeriodMin;
1487         if (res < time.wPeriodMin)
1488             res = time.wPeriodMin;
1489         if (timeBeginPeriod(res) == TIMERR_NOCANDO)
1490             WARN("Could not set minimum resolution, don't expect sound\n");
1491         id = timeSetEvent(triggertime, res, DSOUND_timer, (DWORD_PTR)device, TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
1492         if (!id)
1493         {
1494             WARN("Timer not created! Retrying without TIME_KILL_SYNCHRONOUS\n");
1495             id = timeSetEvent(triggertime, res, DSOUND_timer, (DWORD_PTR)device, TIME_PERIODIC);
1496             if (!id) ERR("Could not create timer, sound playback will not occur\n");
1497         }
1498         DSOUND_renderer[device->drvdesc.dnDevNode]->timerID = id;
1499     } else {
1500         WARN("DSOUND_PrimaryCreate failed\n");
1501     }
1502
1503     return hr;
1504 }
1505
1506 HRESULT DirectSoundDevice_CreateSoundBuffer(
1507     DirectSoundDevice * device,
1508     LPCDSBUFFERDESC dsbd,
1509     LPLPDIRECTSOUNDBUFFER ppdsb,
1510     LPUNKNOWN lpunk,
1511     BOOL from8)
1512 {
1513     HRESULT hres = DS_OK;
1514     TRACE("(%p,%p,%p,%p)\n",device,dsbd,ppdsb,lpunk);
1515
1516     if (device == NULL) {
1517         WARN("not initialized\n");
1518         return DSERR_UNINITIALIZED;
1519     }
1520
1521     if (dsbd == NULL) {
1522         WARN("invalid parameter: dsbd == NULL\n");
1523         return DSERR_INVALIDPARAM;
1524     }
1525
1526     if (dsbd->dwSize != sizeof(DSBUFFERDESC) &&
1527         dsbd->dwSize != sizeof(DSBUFFERDESC1)) {
1528         WARN("invalid parameter: dsbd\n");
1529         return DSERR_INVALIDPARAM;
1530     }
1531
1532     if (ppdsb == NULL) {
1533         WARN("invalid parameter: ppdsb == NULL\n");
1534         return DSERR_INVALIDPARAM;
1535     }
1536     *ppdsb = NULL;
1537
1538     if (TRACE_ON(dsound)) {
1539         TRACE("(structsize=%d)\n",dsbd->dwSize);
1540         TRACE("(flags=0x%08x:\n",dsbd->dwFlags);
1541         _dump_DSBCAPS(dsbd->dwFlags);
1542         TRACE(")\n");
1543         TRACE("(bufferbytes=%d)\n",dsbd->dwBufferBytes);
1544         TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
1545     }
1546
1547     if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
1548         if (dsbd->lpwfxFormat != NULL) {
1549             WARN("invalid parameter: dsbd->lpwfxFormat must be NULL for "
1550                  "primary buffer\n");
1551             return DSERR_INVALIDPARAM;
1552         }
1553
1554         if (device->primary) {
1555             WARN("Primary Buffer already created\n");
1556             IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary));
1557             *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary);
1558         } else {
1559            device->dsbd = *dsbd;
1560            device->dsbd.dwFlags &= ~(DSBCAPS_LOCHARDWARE | DSBCAPS_LOCSOFTWARE);
1561            if (device->hwbuf)
1562                device->dsbd.dwFlags |= DSBCAPS_LOCHARDWARE;
1563            else device->dsbd.dwFlags |= DSBCAPS_LOCSOFTWARE;
1564            hres = PrimaryBufferImpl_Create(device, &(device->primary), &(device->dsbd));
1565            if (device->primary) {
1566                IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary));
1567                *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary);
1568            } else
1569                WARN("PrimaryBufferImpl_Create failed\n");
1570         }
1571     } else {
1572         IDirectSoundBufferImpl * dsb;
1573         WAVEFORMATEXTENSIBLE *pwfxe;
1574
1575         if (dsbd->lpwfxFormat == NULL) {
1576             WARN("invalid parameter: dsbd->lpwfxFormat can't be NULL for "
1577                  "secondary buffer\n");
1578             return DSERR_INVALIDPARAM;
1579         }
1580         pwfxe = (WAVEFORMATEXTENSIBLE*)dsbd->lpwfxFormat;
1581
1582         if (pwfxe->Format.wBitsPerSample != 16 && pwfxe->Format.wBitsPerSample != 8 && pwfxe->Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE)
1583         {
1584             WARN("wBitsPerSample=%d needs a WAVEFORMATEXTENSIBLE\n", dsbd->lpwfxFormat->wBitsPerSample);
1585             return DSERR_CONTROLUNAVAIL;
1586         }
1587         if (pwfxe->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE)
1588         {
1589             if (pwfxe->Format.cbSize < (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
1590             {
1591                 WARN("Too small a cbSize %u\n", pwfxe->Format.cbSize);
1592                 return DSERR_INVALIDPARAM;
1593             }
1594
1595             if (pwfxe->Format.cbSize > (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
1596             {
1597                 WARN("Too big a cbSize %u\n", pwfxe->Format.cbSize);
1598                 return DSERR_CONTROLUNAVAIL;
1599             }
1600
1601             if (!IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
1602             {
1603                 if (!IsEqualGUID(&pwfxe->SubFormat, &GUID_NULL))
1604                     FIXME("SubFormat %s not supported right now.\n", debugstr_guid(&pwfxe->SubFormat));
1605                 return DSERR_INVALIDPARAM;
1606             }
1607             if (pwfxe->Samples.wValidBitsPerSample > dsbd->lpwfxFormat->wBitsPerSample)
1608             {
1609                 WARN("Samples.wValidBitsPerSample(%d) > Format.wBitsPerSample (%d)\n", pwfxe->Samples.wValidBitsPerSample, pwfxe->Format.wBitsPerSample);
1610                 return DSERR_INVALIDPARAM;
1611             }
1612             if (pwfxe->Samples.wValidBitsPerSample && pwfxe->Samples.wValidBitsPerSample < dsbd->lpwfxFormat->wBitsPerSample)
1613             {
1614                 FIXME("Non-packed formats not supported right now: %d/%d\n", pwfxe->Samples.wValidBitsPerSample, dsbd->lpwfxFormat->wBitsPerSample);
1615                 return DSERR_CONTROLUNAVAIL;
1616             }
1617         }
1618
1619         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
1620               "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1621               dsbd->lpwfxFormat->wFormatTag, dsbd->lpwfxFormat->nChannels,
1622               dsbd->lpwfxFormat->nSamplesPerSec,
1623               dsbd->lpwfxFormat->nAvgBytesPerSec,
1624               dsbd->lpwfxFormat->nBlockAlign,
1625               dsbd->lpwfxFormat->wBitsPerSample, dsbd->lpwfxFormat->cbSize);
1626
1627         if (from8 && (dsbd->dwFlags & DSBCAPS_CTRL3D) && (dsbd->lpwfxFormat->nChannels != 1)) {
1628             WARN("invalid parameter: 3D buffer format must be mono\n");
1629             return DSERR_INVALIDPARAM;
1630         }
1631
1632         hres = IDirectSoundBufferImpl_Create(device, &dsb, dsbd);
1633         if (dsb) {
1634             hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
1635             if (*ppdsb) {
1636                 dsb->secondary = (SecondaryBufferImpl*)*ppdsb;
1637                 IDirectSoundBuffer_AddRef(*ppdsb);
1638             } else
1639                 WARN("SecondaryBufferImpl_Create failed\n");
1640         } else
1641            WARN("IDirectSoundBufferImpl_Create failed\n");
1642    }
1643
1644    return hres;
1645 }
1646
1647 HRESULT DirectSoundDevice_DuplicateSoundBuffer(
1648     DirectSoundDevice * device,
1649     LPDIRECTSOUNDBUFFER psb,
1650     LPLPDIRECTSOUNDBUFFER ppdsb)
1651 {
1652     HRESULT hres = DS_OK;
1653     IDirectSoundBufferImpl* dsb;
1654     TRACE("(%p,%p,%p)\n",device,psb,ppdsb);
1655
1656     if (device == NULL) {
1657         WARN("not initialized\n");
1658         return DSERR_UNINITIALIZED;
1659     }
1660
1661     if (psb == NULL) {
1662         WARN("invalid parameter: psb == NULL\n");
1663         return DSERR_INVALIDPARAM;
1664     }
1665
1666     if (ppdsb == NULL) {
1667         WARN("invalid parameter: ppdsb == NULL\n");
1668         return DSERR_INVALIDPARAM;
1669     }
1670
1671     /* make sure we have a secondary buffer */
1672     if ((PrimaryBufferImpl *)psb == device->primary) {
1673         WARN("trying to duplicate primary buffer\n");
1674         *ppdsb = NULL;
1675         return DSERR_INVALIDCALL;
1676     }
1677
1678     /* duplicate the actual buffer implementation */
1679     hres = IDirectSoundBufferImpl_Duplicate(device, &dsb,
1680                                            ((SecondaryBufferImpl *)psb)->dsb);
1681
1682     if (hres == DS_OK) {
1683         /* create a new secondary buffer using the new implementation */
1684         hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
1685         if (*ppdsb) {
1686             dsb->secondary = (SecondaryBufferImpl*)*ppdsb;
1687             IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)*ppdsb);
1688         } else {
1689             WARN("SecondaryBufferImpl_Create failed\n");
1690             IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)dsb);
1691             IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER8)dsb);
1692         }
1693     }
1694
1695     return hres;
1696 }
1697
1698 HRESULT DirectSoundDevice_SetCooperativeLevel(
1699     DirectSoundDevice * device,
1700     HWND hwnd,
1701     DWORD level)
1702 {
1703     TRACE("(%p,%p,%s)\n",device,hwnd,dumpCooperativeLevel(level));
1704
1705     if (device == NULL) {
1706         WARN("not initialized\n");
1707         return DSERR_UNINITIALIZED;
1708     }
1709
1710     if (level==DSSCL_PRIORITY || level==DSSCL_EXCLUSIVE) {
1711         WARN("level=%s not fully supported\n",
1712              level==DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
1713     }
1714
1715     device->priolevel = level;
1716     return DS_OK;
1717 }
1718
1719 HRESULT DirectSoundDevice_Compact(
1720     DirectSoundDevice * device)
1721 {
1722     TRACE("(%p)\n", device);
1723
1724     if (device == NULL) {
1725         WARN("not initialized\n");
1726         return DSERR_UNINITIALIZED;
1727     }
1728
1729     if (device->priolevel < DSSCL_PRIORITY) {
1730         WARN("incorrect priority level\n");
1731         return DSERR_PRIOLEVELNEEDED;
1732     }
1733
1734     return DS_OK;
1735 }
1736
1737 HRESULT DirectSoundDevice_GetSpeakerConfig(
1738     DirectSoundDevice * device,
1739     LPDWORD lpdwSpeakerConfig)
1740 {
1741     TRACE("(%p, %p)\n", device, lpdwSpeakerConfig);
1742
1743     if (device == NULL) {
1744         WARN("not initialized\n");
1745         return DSERR_UNINITIALIZED;
1746     }
1747
1748     if (lpdwSpeakerConfig == NULL) {
1749         WARN("invalid parameter: lpdwSpeakerConfig == NULL\n");
1750         return DSERR_INVALIDPARAM;
1751     }
1752
1753     WARN("not fully functional\n");
1754     *lpdwSpeakerConfig = device->speaker_config;
1755     return DS_OK;
1756 }
1757
1758 HRESULT DirectSoundDevice_SetSpeakerConfig(
1759     DirectSoundDevice * device,
1760     DWORD config)
1761 {
1762     TRACE("(%p,0x%08x)\n",device,config);
1763
1764     if (device == NULL) {
1765         WARN("not initialized\n");
1766         return DSERR_UNINITIALIZED;
1767     }
1768
1769     device->speaker_config = config;
1770     WARN("not fully functional\n");
1771     return DS_OK;
1772 }
1773
1774 static HRESULT DirectSoundDevice_VerifyCertification(
1775     DirectSoundDevice * device,
1776     LPDWORD pdwCertified)
1777 {
1778     TRACE("(%p, %p)\n",device,pdwCertified);
1779
1780     if (device == NULL) {
1781         WARN("not initialized\n");
1782         return DSERR_UNINITIALIZED;
1783     }
1784
1785     if (device->drvcaps.dwFlags & DSCAPS_CERTIFIED)
1786         *pdwCertified = DS_CERTIFIED;
1787     else
1788         *pdwCertified = DS_UNCERTIFIED;
1789
1790     return DS_OK;
1791 }
1792
1793 /*
1794  * Add secondary buffer to buffer list.
1795  * Gets exclusive access to buffer for writing.
1796  */
1797 HRESULT DirectSoundDevice_AddBuffer(
1798     DirectSoundDevice * device,
1799     IDirectSoundBufferImpl * pDSB)
1800 {
1801     IDirectSoundBufferImpl **newbuffers;
1802     HRESULT hr = DS_OK;
1803
1804     TRACE("(%p, %p)\n", device, pDSB);
1805
1806     RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
1807
1808     if (device->buffers)
1809         newbuffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
1810     else
1811         newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
1812
1813     if (newbuffers) {
1814         device->buffers = newbuffers;
1815         device->buffers[device->nrofbuffers] = pDSB;
1816         device->nrofbuffers++;
1817         TRACE("buffer count is now %d\n", device->nrofbuffers);
1818     } else {
1819         ERR("out of memory for buffer list! Current buffer count is %d\n", device->nrofbuffers);
1820         hr = DSERR_OUTOFMEMORY;
1821     }
1822
1823     RtlReleaseResource(&(device->buffer_list_lock));
1824
1825     return hr;
1826 }
1827
1828 /*
1829  * Remove secondary buffer from buffer list.
1830  * Gets exclusive access to buffer for writing.
1831  */
1832 HRESULT DirectSoundDevice_RemoveBuffer(
1833     DirectSoundDevice * device,
1834     IDirectSoundBufferImpl * pDSB)
1835 {
1836     int i;
1837     HRESULT hr = DS_OK;
1838
1839     TRACE("(%p, %p)\n", device, pDSB);
1840
1841     RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
1842
1843     for (i = 0; i < device->nrofbuffers; i++)
1844         if (device->buffers[i] == pDSB)
1845             break;
1846
1847     if (i < device->nrofbuffers) {
1848         /* Put the last buffer of the list in the (now empty) position */
1849         device->buffers[i] = device->buffers[device->nrofbuffers - 1];
1850         device->nrofbuffers--;
1851         device->buffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(LPDIRECTSOUNDBUFFER8)*device->nrofbuffers);
1852         TRACE("buffer count is now %d\n", device->nrofbuffers);
1853     }
1854
1855     if (device->nrofbuffers == 0) {
1856         HeapFree(GetProcessHeap(),0,device->buffers);
1857         device->buffers = NULL;
1858     }
1859
1860     RtlReleaseResource(&(device->buffer_list_lock));
1861
1862     return hr;
1863 }