dsound8.c

   1 /* DirectSound COM interface
   2  *
   3  * Copyright 2009 Maarten Lankhorst
   4  *
   5  * Some code taken from the original dsound-openal implementation
   6  *    Copyright 2007-2009 Chris Robinson
   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 #define CONST_VTABLE
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #include <windows.h>
  28 #include <dsound.h>
  29 #include <ksmedia.h>
  30
  31 #include "dsound_private.h"
  32
  33 #ifndef DSSPEAKER_7POINT1
  34 #define DSSPEAKER_7POINT1       7
  35 #endif
  36
  37
  38 static DWORD CALLBACK DSShare_thread(void *dwUser)
  39 {
  40     DeviceShare *share = (DeviceShare*)dwUser;
  41     BYTE *scratch_mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 2048);
  42     ALsizei i;
  43
  44     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
  45
  46     TRACE("Shared device (%p) message loop start\n", share);
  47     while(WaitForSingleObject(share->timer_evt, INFINITE) == WAIT_OBJECT_0 && !share->quit_now)
  48     {
  49         EnterCriticalSection(&share->crst);
  50         setALContext(share->ctx);
  51
  52         for(i = 0;i < share->nprimaries;++i)
  53         {
  54             DSPrimary_triggernots(share->primaries[i]);
  55             if(!HAS_EXTENSION(share, SOFTX_MAP_BUFFER))
  56                 DSPrimary_streamfeeder(share->primaries[i], scratch_mem);
  57         }
  58
  59         popALContext();
  60         LeaveCriticalSection(&share->crst);
  61     }
  62     TRACE("Shared device (%p) message loop quit\n", share);
  63
  64     HeapFree(GetProcessHeap(), 0, scratch_mem);
  65     scratch_mem = NULL;
  66
  67     if(local_contexts)
  68     {
  69         set_context(NULL);
  70         TlsSetValue(TlsThreadPtr, NULL);
  71     }
  72
  73     return 0;
  74 }
  75
  76 static void CALLBACK DSShare_timer(void *arg, BOOLEAN unused)
  77 {
  78     (void)unused;
  79     SetEvent((HANDLE)arg);
  80 }
  81
  82 static void DSShare_starttimer(DeviceShare *share)
  83 {
  84     DWORD triggertime;
  85
  86     if(share->queue_timer)
  87         return;
  88
  89     triggertime = 1000 / share->refresh * 2 / 3;
  90     TRACE("Calling timer every %lu ms for %d refreshes per second\n",
  91           triggertime, share->refresh);
  92
  93     CreateTimerQueueTimer(&share->queue_timer, NULL, DSShare_timer, share->timer_evt,
  94                           triggertime, triggertime, WT_EXECUTEINTIMERTHREAD);
  95 }
  96
  97
  98
  99 static DeviceShare **sharelist;
 100 static UINT sharelistsize;
 101
 102 static void DSShare_Destroy(DeviceShare *share)
 103 {
 104     UINT i;
 105
 106     EnterCriticalSection(&openal_crst);
 107     for(i = 0;i < sharelistsize;i++)
 108     {
 109         if(sharelist[i] == share)
 110         {
 111             sharelist[i] = sharelist[--sharelistsize];
 112             if(sharelistsize == 0)
 113             {
 114                 HeapFree(GetProcessHeap(), 0, sharelist);
 115                 sharelist = NULL;
 116             }
 117             break;
 118         }
 119     }
 120     LeaveCriticalSection(&openal_crst);
 121
 122     if(share->queue_timer)
 123         DeleteTimerQueueTimer(NULL, share->queue_timer, INVALID_HANDLE_VALUE);
 124     share->queue_timer = NULL;
 125
 126     if(share->thread_hdl)
 127     {
 128         InterlockedExchange(&share->quit_now, TRUE);
 129         SetEvent(share->timer_evt);
 130
 131         if(WaitForSingleObject(share->thread_hdl, 1000) != WAIT_OBJECT_0)
 132             ERR("Thread wait timed out\n");
 133
 134         CloseHandle(share->thread_hdl);
 135         share->thread_hdl = NULL;
 136     }
 137
 138     if(share->timer_evt)
 139         CloseHandle(share->timer_evt);
 140     share->timer_evt = NULL;
 141
 142     if(share->ctx)
 143     {
 144         /* Calling setALContext is not appropriate here, since we *have* to
 145          * unset the context before destroying it
 146          */
 147         EnterCriticalSection(&openal_crst);
 148         set_context(share->ctx);
 149
 150         if(share->sources.maxhw_alloc + share->sources.maxsw_alloc)
 151             alDeleteSources(share->sources.maxhw_alloc+share->sources.maxsw_alloc,
 152                             share->sources.ids);
 153         share->sources.maxhw_alloc = share->sources.maxsw_alloc = 0;
 154
 155         if(share->auxslot[3])
 156             alDeleteAuxiliaryEffectSlots(4, share->auxslot);
 157         else if(share->auxslot[2])
 158             alDeleteAuxiliaryEffectSlots(3, share->auxslot);
 159         else if(share->auxslot[1])
 160             alDeleteAuxiliaryEffectSlots(2, share->auxslot);
 161         else if(share->auxslot[0])
 162             alDeleteAuxiliaryEffectSlots(1, share->auxslot);
 163         share->auxslot[0] = share->auxslot[1] =
 164         share->auxslot[2] = share->auxslot[3] = 0;
 165
 166         set_context(NULL);
 167         TlsSetValue(TlsThreadPtr, NULL);
 168         alcDestroyContext(share->ctx);
 169         share->ctx = NULL;
 170         LeaveCriticalSection(&openal_crst);
 171     }
 172
 173     if(share->device)
 174         alcCloseDevice(share->device);
 175     share->device = NULL;
 176
 177     DeleteCriticalSection(&share->crst);
 178
 179     HeapFree(GetProcessHeap(), 0, share->primaries);
 180     HeapFree(GetProcessHeap(), 0, share);
 181
 182     TRACE("Closed shared device %p\n", share);
 183 }
 184
 185 static HRESULT DSShare_Create(REFIID guid, DeviceShare **out)
 186 {
 187     static const struct {
 188         const char extname[64];
 189         int extenum;
 190     } extensions[MAX_EXTENSIONS] = {
 191         { "ALC_EXT_EFX",      EXT_EFX },
 192         { "AL_EXT_FLOAT32",   EXT_FLOAT32 },
 193         { "AL_EXT_MCFORMATS", EXT_MCFORMATS },
 194         { "AL_SOFT_deferred_updates",  SOFT_DEFERRED_UPDATES },
 195         { "AL_SOFT_source_spatialize", SOFT_SOURCE_SPATIALIZE },
 196         { "AL_SOFTX_filter_gain_ex",   SOFTX_FILTER_GAIN_EX },
 197         { "AL_SOFTX_map_buffer",       SOFTX_MAP_BUFFER },
 198     };
 199     OLECHAR *guid_str = NULL;
 200     ALchar drv_name[64];
 201     DeviceShare *share;
 202     IMMDevice *mmdev;
 203     ALCint attrs[3];
 204     void *temp;
 205     HRESULT hr;
 206     ALsizei i;
 207
 208     share = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*share));
 209     if(!share) return DSERR_OUTOFMEMORY;
 210     share->ref = 1;
 211     share->refresh = FAKE_REFRESH_COUNT;
 212     share->speaker_config = DSSPEAKER_7POINT1_SURROUND;
 213
 214     TRACE("Creating shared device %p\n", share);
 215
 216     hr = get_mmdevice(eRender, guid, &mmdev);
 217     if(SUCCEEDED(hr))
 218     {
 219         IPropertyStore *store;
 220
 221         hr = IMMDevice_OpenPropertyStore(mmdev, STGM_READ, &store);
 222         if(FAILED(hr))
 223             WARN("IMMDevice_OpenPropertyStore failed: %08lx\n", hr);
 224         else
 225         {
 226             ULONG phys_speakers = 0;
 227             PROPVARIANT pv;
 228
 229             PropVariantInit(&pv);
 230
 231             hr = IPropertyStore_GetValue(store, &PKEY_AudioEndpoint_PhysicalSpeakers, &pv);
 232             if(FAILED(hr))
 233                 WARN("IPropertyStore_GetValue failed: %08lx\n", hr);
 234             else if(pv.vt != VT_UI4)
 235                 WARN("PKEY_AudioEndpoint_PhysicalSpeakers is not a ULONG: 0x%04x\n", pv.vt);
 236             else
 237             {
 238                 phys_speakers = pv.ulVal;
 239
 240 #define BIT_MATCH(v, b) (((v)&(b)) == (b))
 241                 if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_7POINT1))
 242                     share->speaker_config = DSSPEAKER_7POINT1;
 243                 else if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_7POINT1_SURROUND))
 244                     share->speaker_config = DSSPEAKER_7POINT1_SURROUND;
 245                 else if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_5POINT1))
 246                     share->speaker_config = DSSPEAKER_5POINT1_BACK;
 247                 else if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_5POINT1_SURROUND))
 248                     share->speaker_config = DSSPEAKER_5POINT1_SURROUND;
 249                 else if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_QUAD))
 250                     share->speaker_config = DSSPEAKER_QUAD;
 251                 else if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_STEREO))
 252                     share->speaker_config = DSSPEAKER_COMBINED(DSSPEAKER_STEREO, DSSPEAKER_GEOMETRY_WIDE);
 253                 else if(BIT_MATCH(phys_speakers, KSAUDIO_SPEAKER_MONO))
 254                     share->speaker_config = DSSPEAKER_MONO;
 255                 else
 256                     FIXME("Unhandled physical speaker layout: 0x%08lx\n", phys_speakers);
 257 #undef BIT_MATCH
 258             }
 259
 260             /* If the device has a stereo layout, check the formfactor to see
 261              * if it's really headphones/headset.
 262              */
 263             if(DSSPEAKER_CONFIG(share->speaker_config) == DSSPEAKER_STEREO)
 264             {
 265                 hr = IPropertyStore_GetValue(store, &PKEY_AudioEndpoint_FormFactor, &pv);
 266                 if(FAILED(hr))
 267                     WARN("IPropertyStore_GetValue failed: %08lx\n", hr);
 268                 else if(pv.vt != VT_UI4)
 269                     WARN("PKEY_AudioEndpoint_FormFactor is not a ULONG: 0x%04x\n", pv.vt);
 270                 else
 271                 {
 272                     if(pv.ulVal == Headphones || pv.ulVal == Headset)
 273                         share->speaker_config = DSSPEAKER_HEADPHONE;
 274                 }
 275             }
 276
 277             TRACE("Got speaker config %d:%d from physical speakers 0x%08lx\n",
 278                   DSSPEAKER_GEOMETRY(share->speaker_config),
 279                   DSSPEAKER_CONFIG(share->speaker_config), phys_speakers);
 280
 281             PropVariantClear(&pv);
 282             IPropertyStore_Release(store);
 283         }
 284
 285         IMMDevice_Release(mmdev);
 286         mmdev = NULL;
 287     }
 288
 289     InitializeCriticalSection(&share->crst);
 290
 291     hr = StringFromCLSID(guid, &guid_str);
 292     if(FAILED(hr))
 293     {
 294         ERR("Failed to convert GUID to string\n");
 295         goto fail;
 296     }
 297     WideCharToMultiByte(CP_UTF8, 0, guid_str, -1, drv_name, sizeof(drv_name), NULL, NULL);
 298     drv_name[sizeof(drv_name)-1] = 0;
 299     CoTaskMemFree(guid_str);
 300     guid_str = NULL;
 301
 302     hr = DSERR_NODRIVER;
 303     share->device = alcOpenDevice(drv_name);
 304     if(!share->device)
 305     {
 306         alcGetError(NULL);
 307         WARN("Couldn't open device \"%s\"\n", drv_name);
 308         goto fail;
 309     }
 310     TRACE("Opened AL device: %s\n",
 311           alcIsExtensionPresent(share->device, "ALC_ENUMERATE_ALL_EXT") ?
 312           alcGetString(share->device, ALC_ALL_DEVICES_SPECIFIER) :
 313           alcGetString(share->device, ALC_DEVICE_SPECIFIER));
 314
 315     attrs[0] = ALC_MONO_SOURCES;
 316     attrs[1] = MAX_SOURCES;
 317     attrs[2] = 0;
 318     share->ctx = alcCreateContext(share->device, attrs);
 319     if(!share->ctx)
 320     {
 321         ALCenum err = alcGetError(share->device);
 322         ERR("Could not create context (0x%x)!\n", err);
 323         goto fail;
 324     }
 325
 326     share->guid = *guid;
 327
 328     setALContext(share->ctx);
 329     alcGetIntegerv(share->device, ALC_REFRESH, 1, &share->refresh);
 330     checkALCError(share->device);
 331
 332     for(i = 0;i < MAX_EXTENSIONS;i++)
 333     {
 334         if((strncmp(extensions[i].extname, "ALC", 3) == 0) ?
 335            alcIsExtensionPresent(share->device, extensions[i].extname) :
 336            alIsExtensionPresent(extensions[i].extname))
 337         {
 338             TRACE("Found %s\n", extensions[i].extname);
 339             BITFIELD_SET(share->Exts, extensions[i].extenum);
 340         }
 341     }
 342
 343     share->sources.maxhw_alloc = 0;
 344     while(share->sources.maxhw_alloc < MAX_SOURCES)
 345     {
 346         alGenSources(1, &share->sources.ids[share->sources.maxhw_alloc]);
 347         if(alGetError() != AL_NO_ERROR) break;
 348         share->sources.maxhw_alloc++;
 349     }
 350
 351     if(HAS_EXTENSION(share, EXT_EFX))
 352     {
 353         alcGetIntegerv(share->device, ALC_MAX_AUXILIARY_SENDS, 1, &share->num_sends);
 354         checkALCError(share->device);
 355         if(share->num_sends > EAX_MAX_ACTIVE_FXSLOTS)
 356             share->num_sends = EAX_MAX_ACTIVE_FXSLOTS;
 357         TRACE("Got %d auxiliary source send%s\n", share->num_sends, (share->num_sends==1)?"":"s");
 358
 359         for(i = 0;i < EAX_MAX_FXSLOTS;++i)
 360         {
 361             alGenAuxiliaryEffectSlots(1, &share->auxslot[i]);
 362             if(alGetError() != AL_NO_ERROR) break;
 363         }
 364         TRACE("Allocated %d auxiliary effect slot%s\n", i, (i==1)?"":"s");
 365         while(i < EAX_MAX_FXSLOTS)
 366             share->auxslot[i++] = 0;
 367     }
 368     popALContext();
 369
 370     hr = E_OUTOFMEMORY;
 371     if(share->sources.maxhw_alloc < 128)
 372     {
 373         ERR("Could only allocate %lu sources (minimum 128 required)\n",
 374             share->sources.maxhw_alloc);
 375         goto fail;
 376     }
 377
 378     if(share->sources.maxhw_alloc > MAX_HWBUFFERS)
 379     {
 380         share->sources.maxsw_alloc = share->sources.maxhw_alloc - MAX_HWBUFFERS;
 381         share->sources.maxhw_alloc = MAX_HWBUFFERS;
 382     }
 383     else if(share->sources.maxhw_alloc > MAX_HWBUFFERS/2)
 384     {
 385         share->sources.maxsw_alloc = share->sources.maxhw_alloc - MAX_HWBUFFERS/2;
 386         share->sources.maxhw_alloc = MAX_HWBUFFERS/2;
 387     }
 388     else
 389     {
 390         share->sources.maxsw_alloc = share->sources.maxhw_alloc - MAX_HWBUFFERS/4;
 391         share->sources.maxhw_alloc = MAX_HWBUFFERS/4;
 392     }
 393     share->sources.availhw_num = share->sources.maxhw_alloc;
 394     share->sources.availsw_num = share->sources.maxsw_alloc;
 395     TRACE("Allocated %lu hardware sources and %lu software sources\n",
 396           share->sources.maxhw_alloc, share->sources.maxsw_alloc);
 397
 398     if(sharelist)
 399         temp = HeapReAlloc(GetProcessHeap(), 0, sharelist, sizeof(*sharelist)*(sharelistsize+1));
 400     else
 401         temp = HeapAlloc(GetProcessHeap(), 0, sizeof(*sharelist)*(sharelistsize+1));
 402     if(temp)
 403     {
 404         sharelist = temp;
 405         sharelist[sharelistsize++] = share;
 406     }
 407
 408     hr = E_FAIL;
 409
 410     share->quit_now = FALSE;
 411     share->timer_evt = CreateEventA(NULL, FALSE, FALSE, NULL);
 412     if(!share->timer_evt) goto fail;
 413
 414     share->queue_timer = NULL;
 415
 416     share->thread_hdl = CreateThread(NULL, 0, DSShare_thread, share, 0, &share->thread_id);
 417     if(!share->thread_hdl) goto fail;
 418
 419     DSShare_starttimer(share);
 420
 421     *out = share;
 422     return DS_OK;
 423
 424 fail:
 425     DSShare_Destroy(share);
 426     return hr;
 427 }
 428
 429 static ULONG DSShare_AddRef(DeviceShare *share)
 430 {
 431     ULONG ref = InterlockedIncrement(&share->ref);
 432     return ref;
 433 }
 434
 435 static ULONG DSShare_Release(DeviceShare *share)
 436 {
 437     ULONG ref = InterlockedDecrement(&share->ref);
 438     if(ref == 0) DSShare_Destroy(share);
 439     return ref;
 440 }
 441
 442
 443 static const IDirectSound8Vtbl DS8_Vtbl;
 444 static const IDirectSoundVtbl DS_Vtbl;
 445 static const IUnknownVtbl DS8_Unknown_Vtbl;
 446
 447 static HRESULT DSDevice_Create(BOOL is8, REFIID riid, LPVOID *ds);
 448 static void DSDevice_Destroy(DSDevice *This);
 449 static HRESULT DSDevice_GetInterface(DSDevice *This, REFIID riid, LPVOID *ppv);
 450
 451 /*******************************************************************************
 452  * IUnknown
 453  */
 454 static inline DSDevice *impl_from_IUnknown(IUnknown *iface)
 455 {
 456     return CONTAINING_RECORD(iface, DSDevice, IUnknown_iface);
 457 }
 458
 459 static HRESULT WINAPI DSDevice_IUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppobj)
 460 {
 461     DSDevice *This = impl_from_IUnknown(iface);
 462     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppobj);
 463     return DSDevice_GetInterface(This, riid, ppobj);
 464 }
 465
 466 static ULONG WINAPI DSDevice_IUnknown_AddRef(IUnknown *iface)
 467 {
 468     DSDevice *This = impl_from_IUnknown(iface);
 469     ULONG ref;
 470
 471     InterlockedIncrement(&(This->ref));
 472     ref = InterlockedIncrement(&(This->unkref));
 473     TRACE("(%p) ref %lu\n", iface, ref);
 474
 475     return ref;
 476 }
 477
 478 static ULONG WINAPI DSDevice_IUnknown_Release(IUnknown *iface)
 479 {
 480     DSDevice *This = impl_from_IUnknown(iface);
 481     ULONG ref = InterlockedDecrement(&(This->unkref));
 482     TRACE("(%p) ref %lu\n", iface, ref);
 483     if(InterlockedDecrement(&(This->ref)) == 0)
 484         DSDevice_Destroy(This);
 485     return ref;
 486 }
 487
 488 static const IUnknownVtbl DS8_Unknown_Vtbl = {
 489     DSDevice_IUnknown_QueryInterface,
 490     DSDevice_IUnknown_AddRef,
 491     DSDevice_IUnknown_Release
 492 };
 493
 494
 495 static inline DSDevice *impl_from_IDirectSound8(IDirectSound8 *iface)
 496 {
 497     return CONTAINING_RECORD(iface, DSDevice, IDirectSound8_iface);
 498 }
 499
 500 static inline DSDevice *impl_from_IDirectSound(IDirectSound *iface)
 501 {
 502     return CONTAINING_RECORD(iface, DSDevice, IDirectSound_iface);
 503 }
 504
 505
 506 HRESULT DSOUND_Create(REFIID riid, void **ds)
 507 { return DSDevice_Create(FALSE, riid, ds); }
 508
 509 HRESULT DSOUND_Create8(REFIID riid, LPVOID *ds)
 510 { return DSDevice_Create(TRUE, riid, ds); }
 511
 512 static HRESULT DSDevice_Create(BOOL is8, REFIID riid, LPVOID *ds)
 513 {
 514     DSDevice *This;
 515     HRESULT hr;
 516
 517     *ds = NULL;
 518     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 519     if(!This) return DSERR_OUTOFMEMORY;
 520
 521     TRACE("Creating device instance %p\n", This);
 522     This->IDirectSound8_iface.lpVtbl = &DS8_Vtbl;
 523     This->IDirectSound_iface.lpVtbl = &DS_Vtbl;
 524     This->IUnknown_iface.lpVtbl = &DS8_Unknown_Vtbl;
 525
 526     This->is_8 = is8;
 527
 528     hr = DSDevice_GetInterface(This, riid, ds);
 529     if(FAILED(hr)) DSDevice_Destroy(This);
 530     return hr;
 531 }
 532
 533 static void DSDevice_Destroy(DSDevice *This)
 534 {
 535     DeviceShare *share = This->share;
 536
 537     TRACE("Destroying device instance %p\n", This);
 538     if(share)
 539     {
 540         ALsizei i;
 541
 542         EnterCriticalSection(&share->crst);
 543
 544         for(i = 0;i < share->nprimaries;++i)
 545         {
 546             if(share->primaries[i] == &This->primary)
 547             {
 548                 share->nprimaries -= 1;
 549                 share->primaries[i] = share->primaries[share->nprimaries];
 550                 break;
 551             }
 552         }
 553
 554         LeaveCriticalSection(&share->crst);
 555     }
 556
 557     DSPrimary_Clear(&This->primary);
 558     if(This->share)
 559         DSShare_Release(This->share);
 560     This->share = NULL;
 561
 562     HeapFree(GetProcessHeap(), 0, This);
 563 }
 564
 565 static HRESULT DSDevice_GetInterface(DSDevice *This, REFIID riid, LPVOID *ppv)
 566 {
 567     *ppv = NULL;
 568     if(IsEqualIID(riid, &IID_IUnknown))
 569         *ppv = &This->IUnknown_iface;
 570     else if(IsEqualIID(riid, &IID_IDirectSound8))
 571     {
 572         if(This->is_8)
 573             *ppv = &This->IDirectSound8_iface;
 574     }
 575     else if(IsEqualIID(riid, &IID_IDirectSound))
 576         *ppv = &This->IDirectSound_iface;
 577     else
 578         FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
 579
 580     if(*ppv)
 581     {
 582         IUnknown_AddRef((IUnknown*)*ppv);
 583         return S_OK;
 584     }
 585
 586     return E_NOINTERFACE;
 587 }
 588
 589
 590 static HRESULT WINAPI DS8_QueryInterface(IDirectSound8 *iface, REFIID riid, LPVOID *ppv)
 591 {
 592     DSDevice *This = impl_from_IDirectSound8(iface);
 593     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 594     return DSDevice_GetInterface(This, riid, ppv);
 595 }
 596
 597 static ULONG WINAPI DS8_AddRef(IDirectSound8 *iface)
 598 {
 599     DSDevice *This = impl_from_IDirectSound8(iface);
 600     LONG ref;
 601
 602     InterlockedIncrement(&This->ref);
 603     ref = InterlockedIncrement(&This->dsref);
 604     TRACE("(%p) ref %lu\n", iface, ref);
 605
 606     return ref;
 607 }
 608
 609 static ULONG WINAPI DS8_Release(IDirectSound8 *iface)
 610 {
 611     DSDevice *This = impl_from_IDirectSound8(iface);
 612     LONG ref;
 613
 614     ref = InterlockedDecrement(&This->dsref);
 615     TRACE("(%p) ref %lu\n", iface, ref);
 616     if(InterlockedDecrement(&This->ref) == 0)
 617         DSDevice_Destroy(This);
 618
 619     return ref;
 620 }
 621
 622 static HRESULT WINAPI DS8_CreateSoundBuffer(IDirectSound8 *iface, LPCDSBUFFERDESC desc, LPLPDIRECTSOUNDBUFFER buf, IUnknown *pUnkOuter)
 623 {
 624     DSDevice *This = impl_from_IDirectSound8(iface);
 625     HRESULT hr;
 626
 627     TRACE("(%p)->(%p, %p, %p)\n", iface, desc, buf, pUnkOuter);
 628
 629     if(!buf)
 630     {
 631         WARN("buf is null\n");
 632         return DSERR_INVALIDPARAM;
 633     }
 634     *buf = NULL;
 635
 636     if(pUnkOuter)
 637     {
 638         WARN("Aggregation isn't supported\n");
 639         return DSERR_NOAGGREGATION;
 640     }
 641     if(!desc || desc->dwSize < sizeof(DSBUFFERDESC1))
 642     {
 643         WARN("Invalid buffer %p/%lu\n", desc, desc?desc->dwSize:0);
 644         return DSERR_INVALIDPARAM;
 645     }
 646
 647     if(!This->share)
 648     {
 649         WARN("Device not initialized\n");
 650         return DSERR_UNINITIALIZED;
 651     }
 652
 653     TRACE("Requested buffer:\n"
 654           "    Size        = %lu\n"
 655           "    Flags       = 0x%08lx\n"
 656           "    BufferBytes = %lu\n",
 657           desc->dwSize, desc->dwFlags, desc->dwBufferBytes);
 658
 659     if(desc->dwSize >= sizeof(DSBUFFERDESC))
 660     {
 661         if(!(desc->dwFlags&DSBCAPS_CTRL3D))
 662         {
 663             if(!IsEqualGUID(&desc->guid3DAlgorithm, &GUID_NULL))
 664             {
 665                 WARN("Invalid 3D algorithm GUID specified for non-3D buffer: %s\n", debugstr_guid(&desc->guid3DAlgorithm));
 666                 return DSERR_INVALIDPARAM;
 667             }
 668         }
 669         else
 670             TRACE("Requested 3D algorithm GUID: %s\n", debugstr_guid(&desc->guid3DAlgorithm));
 671     }
 672
 673     /* OpenAL doesn't support playing with 3d and panning at same time.. */
 674     if((desc->dwFlags&(DSBCAPS_CTRL3D|DSBCAPS_CTRLPAN)) == (DSBCAPS_CTRL3D|DSBCAPS_CTRLPAN))
 675     {
 676         if(!This->is_8)
 677         {
 678             static int once = 0;
 679             if(!once++)
 680                 FIXME("Buffers with 3D and panning control ignore panning\n");
 681         }
 682         else
 683         {
 684             WARN("Cannot create buffers with 3D and panning control\n");
 685             return DSERR_INVALIDPARAM;
 686         }
 687     }
 688
 689     EnterCriticalSection(&This->share->crst);
 690     if((desc->dwFlags&DSBCAPS_PRIMARYBUFFER))
 691     {
 692         IDirectSoundBuffer *prim = &This->primary.IDirectSoundBuffer_iface;
 693
 694         hr = S_OK;
 695         if(IDirectSoundBuffer_AddRef(prim) == 1)
 696         {
 697             hr = DSPrimary_Initialize(prim, &This->IDirectSound_iface, desc);
 698             if(FAILED(hr))
 699             {
 700                 IDirectSoundBuffer_Release(prim);
 701                 prim = NULL;
 702             }
 703         }
 704         *buf = prim;
 705     }
 706     else
 707     {
 708         DSBuffer *dsb;
 709
 710         hr = DSBuffer_Create(&dsb, &This->primary, NULL);
 711         if(SUCCEEDED(hr))
 712             hr = DSBuffer_Initialize(&dsb->IDirectSoundBuffer8_iface, &This->IDirectSound_iface, desc);
 713         if(SUCCEEDED(hr))
 714         {
 715             dsb->bufferlost = (This->prio_level == DSSCL_WRITEPRIMARY);
 716             hr = DSBuffer_GetInterface(dsb, &IID_IDirectSoundBuffer, (void**)buf);
 717         }
 718         if(FAILED(hr))
 719             DSBuffer_Destroy(dsb);
 720     }
 721     LeaveCriticalSection(&This->share->crst);
 722
 723     TRACE("%08lx\n", hr);
 724     return hr;
 725 }
 726
 727 static HRESULT WINAPI DS8_GetCaps(IDirectSound8 *iface, LPDSCAPS caps)
 728 {
 729     DSDevice *This = impl_from_IDirectSound8(iface);
 730     struct DSBufferGroup *bufgroup, *endgroup;
 731     DWORD free_bufs;
 732
 733     TRACE("(%p)->(%p)\n", iface, caps);
 734
 735     if(!This->share)
 736     {
 737         WARN("Device not initialized\n");
 738         return DSERR_UNINITIALIZED;
 739     }
 740
 741     if(!caps || caps->dwSize < sizeof(*caps))
 742     {
 743         WARN("Invalid DSCAPS (%p, %lu)\n", caps, (caps?caps->dwSize:0));
 744         return DSERR_INVALIDPARAM;
 745     }
 746
 747     EnterCriticalSection(&This->share->crst);
 748
 749     free_bufs = This->share->sources.maxhw_alloc;
 750     bufgroup = This->primary.BufferGroups;
 751     endgroup = bufgroup + This->primary.NumBufferGroups;
 752     for(;free_bufs && bufgroup != endgroup;++bufgroup)
 753     {
 754         DWORD64 usemask = ~bufgroup->FreeBuffers;
 755         while(usemask)
 756         {
 757             int idx = CTZ64(usemask);
 758             DSBuffer *buf = bufgroup->Buffers + idx;
 759             usemask &= ~(U64(1) << idx);
 760
 761             if(buf->loc_status == DSBSTATUS_LOCHARDWARE)
 762             {
 763                 if(!--free_bufs)
 764                     break;
 765             }
 766         }
 767     }
 768
 769     caps->dwFlags = DSCAPS_CONTINUOUSRATE | DSCAPS_CERTIFIED |
 770                     DSCAPS_PRIMARY16BIT | DSCAPS_PRIMARYSTEREO |
 771                     DSCAPS_PRIMARY8BIT | DSCAPS_PRIMARYMONO |
 772                     DSCAPS_SECONDARY16BIT | DSCAPS_SECONDARY8BIT |
 773                     DSCAPS_SECONDARYMONO | DSCAPS_SECONDARYSTEREO;
 774     caps->dwPrimaryBuffers = 1;
 775     caps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
 776     caps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
 777     caps->dwMaxHwMixingAllBuffers =
 778         caps->dwMaxHwMixingStaticBuffers =
 779         caps->dwMaxHwMixingStreamingBuffers =
 780         caps->dwMaxHw3DAllBuffers =
 781         caps->dwMaxHw3DStaticBuffers =
 782         caps->dwMaxHw3DStreamingBuffers = This->share->sources.maxhw_alloc;
 783     caps->dwFreeHwMixingAllBuffers =
 784         caps->dwFreeHwMixingStaticBuffers =
 785         caps->dwFreeHwMixingStreamingBuffers =
 786         caps->dwFreeHw3DAllBuffers =
 787         caps->dwFreeHw3DStaticBuffers =
 788         caps->dwFreeHw3DStreamingBuffers = free_bufs;
 789     caps->dwTotalHwMemBytes =
 790         caps->dwFreeHwMemBytes = 64 * 1024 * 1024;
 791     caps->dwMaxContigFreeHwMemBytes = caps->dwFreeHwMemBytes;
 792     caps->dwUnlockTransferRateHwBuffers = 4096;
 793     caps->dwPlayCpuOverheadSwBuffers = 0;
 794
 795     LeaveCriticalSection(&This->share->crst);
 796
 797     return DS_OK;
 798 }
 799 static HRESULT WINAPI DS8_DuplicateSoundBuffer(IDirectSound8 *iface, IDirectSoundBuffer *in, IDirectSoundBuffer **out)
 800 {
 801     DSDevice *This = impl_from_IDirectSound8(iface);
 802     DSBuffer *buf = NULL;
 803     DSBCAPS caps;
 804     HRESULT hr;
 805
 806     TRACE("(%p)->(%p, %p)\n", iface, in, out);
 807
 808     if(!This->share)
 809     {
 810         WARN("Device not initialized\n");
 811         return DSERR_UNINITIALIZED;
 812     }
 813
 814     if(!in || !out)
 815     {
 816         WARN("Invalid pointer: in = %p, out = %p\n", in, out);
 817         return DSERR_INVALIDPARAM;
 818     }
 819     *out = NULL;
 820
 821     caps.dwSize = sizeof(caps);
 822     hr = IDirectSoundBuffer_GetCaps(in, &caps);
 823     if(SUCCEEDED(hr) && (caps.dwFlags&DSBCAPS_PRIMARYBUFFER))
 824     {
 825         WARN("Cannot duplicate buffer %p, which has DSBCAPS_PRIMARYBUFFER\n", in);
 826         hr = DSERR_INVALIDPARAM;
 827     }
 828     if(SUCCEEDED(hr) && (caps.dwFlags&DSBCAPS_CTRLFX))
 829     {
 830         WARN("Cannot duplicate buffer %p, which has DSBCAPS_CTRLFX\n", in);
 831         hr = DSERR_INVALIDPARAM;
 832     }
 833     if(SUCCEEDED(hr))
 834         hr = DSBuffer_Create(&buf, &This->primary, in);
 835     if(SUCCEEDED(hr))
 836         hr = DSBuffer_Initialize(&buf->IDirectSoundBuffer8_iface, NULL, NULL);
 837     if(SUCCEEDED(hr))
 838         hr = DSBuffer_GetInterface(buf, &IID_IDirectSoundBuffer, (void**)out);
 839     if(FAILED(hr) && buf)
 840         DSBuffer_Destroy(buf);
 841
 842     return hr;
 843 }
 844
 845 static HRESULT WINAPI DS8_SetCooperativeLevel(IDirectSound8 *iface, HWND hwnd, DWORD level)
 846 {
 847     DSDevice *This = impl_from_IDirectSound8(iface);
 848     HRESULT hr = S_OK;
 849
 850     TRACE("(%p)->(%p, %lu)\n", iface, hwnd, level);
 851
 852     if(!This->share)
 853     {
 854         WARN("Device not initialized\n");
 855         return DSERR_UNINITIALIZED;
 856     }
 857
 858     if(level > DSSCL_WRITEPRIMARY || level < DSSCL_NORMAL)
 859     {
 860         WARN("Invalid coop level: %lu\n", level);
 861         return DSERR_INVALIDPARAM;
 862     }
 863
 864     EnterCriticalSection(&This->share->crst);
 865     if(level == DSSCL_WRITEPRIMARY && (This->prio_level != DSSCL_WRITEPRIMARY))
 866     {
 867         struct DSBufferGroup *bufgroup = This->primary.BufferGroups;
 868         DWORD i, state;
 869
 870         if(This->primary.write_emu)
 871         {
 872             ERR("Why was there a write_emu?\n");
 873             /* Delete it */
 874             IDirectSoundBuffer_Release(This->primary.write_emu);
 875             This->primary.write_emu = NULL;
 876         }
 877
 878         for(i = 0;i < This->primary.NumBufferGroups;++i)
 879         {
 880             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
 881             while(usemask)
 882             {
 883                 int idx = CTZ64(usemask);
 884                 DSBuffer *buf = bufgroup[i].Buffers + idx;
 885                 usemask &= ~(U64(1) << idx);
 886
 887                 if(FAILED(DSBuffer_GetStatus(&buf->IDirectSoundBuffer8_iface, &state)) ||
 888                    (state&DSBSTATUS_PLAYING))
 889                 {
 890                     WARN("DSSCL_WRITEPRIMARY set with playing buffers!\n");
 891                     hr = DSERR_INVALIDCALL;
 892                     goto out;
 893                 }
 894                 /* Mark buffer as lost */
 895                 buf->bufferlost = 1;
 896             }
 897         }
 898
 899         if(This->primary.flags)
 900         {
 901             /* Primary has open references.. create write_emu */
 902             DSBUFFERDESC desc;
 903             DSBuffer *emu;
 904
 905             memset(&desc, 0, sizeof(desc));
 906             desc.dwSize = sizeof(desc);
 907             desc.dwFlags = DSBCAPS_LOCHARDWARE | (This->primary.flags&DSBCAPS_CTRLPAN);
 908             desc.dwBufferBytes = This->primary.buf_size;
 909             desc.lpwfxFormat = &This->primary.format.Format;
 910
 911             hr = DSBuffer_Create(&emu, &This->primary, NULL);
 912             if(SUCCEEDED(hr))
 913                 hr = DSBuffer_Initialize(&emu->IDirectSoundBuffer8_iface,
 914                                          &This->IDirectSound_iface, &desc);
 915             if(SUCCEEDED(hr))
 916                 hr = DSBuffer_GetInterface(emu, &IID_IDirectSoundBuffer,
 917                                            (void**)&This->primary.write_emu);
 918             if(FAILED(hr))
 919                 DSBuffer_Destroy(emu);
 920         }
 921     }
 922     else if(This->prio_level == DSSCL_WRITEPRIMARY && level != DSSCL_WRITEPRIMARY)
 923     {
 924         /* Delete it */
 925         TRACE("Nuking write_emu\n");
 926         if(This->primary.write_emu)
 927             IDirectSoundBuffer_Release(This->primary.write_emu);
 928         This->primary.write_emu = NULL;
 929     }
 930     if(SUCCEEDED(hr))
 931         This->prio_level = level;
 932 out:
 933     LeaveCriticalSection(&This->share->crst);
 934
 935     return hr;
 936 }
 937
 938 static HRESULT WINAPI DS8_Compact(IDirectSound8 *iface)
 939 {
 940     DSDevice *This = impl_from_IDirectSound8(iface);
 941     HRESULT hr = S_OK;
 942
 943     TRACE("(%p)->()\n", iface);
 944
 945     if(!This->share)
 946     {
 947         WARN("Device not initialized\n");
 948         return DSERR_UNINITIALIZED;
 949     }
 950
 951     EnterCriticalSection(&This->share->crst);
 952     if(This->prio_level < DSSCL_PRIORITY)
 953     {
 954         WARN("Coop level not high enough (%lu)\n", This->prio_level);
 955         hr = DSERR_PRIOLEVELNEEDED;
 956     }
 957     LeaveCriticalSection(&This->share->crst);
 958
 959     return hr;
 960 }
 961
 962 static HRESULT WINAPI DS8_GetSpeakerConfig(IDirectSound8 *iface, DWORD *config)
 963 {
 964     DSDevice *This = impl_from_IDirectSound8(iface);
 965
 966     TRACE("(%p)->(%p)\n", iface, config);
 967
 968     if(!config)
 969         return DSERR_INVALIDPARAM;
 970     *config = 0;
 971
 972     if(!This->share)
 973     {
 974         WARN("Device not initialized\n");
 975         return DSERR_UNINITIALIZED;
 976     }
 977
 978     *config = This->share->speaker_config;
 979
 980     return DS_OK;
 981 }
 982
 983 static HRESULT WINAPI DS8_SetSpeakerConfig(IDirectSound8 *iface, DWORD config)
 984 {
 985     DSDevice *This = impl_from_IDirectSound8(iface);
 986     DWORD geo, speaker;
 987
 988     TRACE("(%p)->(0x%08lx)\n", iface, config);
 989
 990     if(!This->share)
 991     {
 992         WARN("Device not initialized\n");
 993         return DSERR_UNINITIALIZED;
 994     }
 995
 996     geo = DSSPEAKER_GEOMETRY(config);
 997     speaker = DSSPEAKER_CONFIG(config);
 998
 999     if(geo && (geo < DSSPEAKER_GEOMETRY_MIN || geo > DSSPEAKER_GEOMETRY_MAX))
1000     {
1001         WARN("Invalid speaker angle %lu\n", geo);
1002         return DSERR_INVALIDPARAM;
1003     }
1004     if(speaker < DSSPEAKER_HEADPHONE || speaker > DSSPEAKER_7POINT1)
1005     {
1006         WARN("Invalid speaker config %lu\n", speaker);
1007         return DSERR_INVALIDPARAM;
1008     }
1009
1010     /* No-op on Vista+. */
1011     return DS_OK;
1012 }
1013
1014 static HRESULT WINAPI DS8_Initialize(IDirectSound8 *iface, const GUID *devguid)
1015 {
1016     DSDevice *This = impl_from_IDirectSound8(iface);
1017     HRESULT hr;
1018     GUID guid;
1019     UINT n;
1020
1021     TRACE("(%p)->(%s)\n", iface, debugstr_guid(devguid));
1022
1023     if(!openal_loaded)
1024         return DSERR_NODRIVER;
1025
1026     if(This->share)
1027     {
1028         WARN("Device already initialized\n");
1029         return DSERR_ALREADYINITIALIZED;
1030     }
1031
1032     if(!devguid || IsEqualGUID(devguid, &GUID_NULL))
1033         devguid = &DSDEVID_DefaultPlayback;
1034     else if(IsEqualGUID(devguid, &DSDEVID_DefaultCapture) ||
1035             IsEqualGUID(devguid, &DSDEVID_DefaultVoiceCapture))
1036         return DSERR_NODRIVER;
1037
1038     hr = GetDeviceID(devguid, &guid);
1039     if(FAILED(hr)) return hr;
1040
1041     EnterCriticalSection(&openal_crst);
1042
1043     TRACE("Searching shared devices for %s\n", debugstr_guid(&guid));
1044     for(n = 0;n < sharelistsize;n++)
1045     {
1046         if(IsEqualGUID(&sharelist[n]->guid, &guid))
1047         {
1048             TRACE("Matched shared device %p\n", sharelist[n]);
1049
1050             DSShare_AddRef(sharelist[n]);
1051             This->share = sharelist[n];
1052             break;
1053         }
1054     }
1055
1056     if(!This->share)
1057         hr = DSShare_Create(&guid, &This->share);
1058     if(SUCCEEDED(hr))
1059     {
1060         This->device = This->share->device;
1061         hr = DSPrimary_PreInit(&This->primary, This);
1062     }
1063
1064     if(SUCCEEDED(hr))
1065     {
1066         DeviceShare *share = This->share;
1067         DSPrimary **prims;
1068
1069         EnterCriticalSection(&share->crst);
1070
1071         prims = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1072                           (share->nprimaries+1) * sizeof(*prims));
1073         if(!prims)
1074             hr = DSERR_OUTOFMEMORY;
1075         else
1076         {
1077             ALsizei i;
1078             for(i = 0;i < share->nprimaries;++i)
1079                 prims[i] = share->primaries[i];
1080             prims[i] = &This->primary;
1081
1082             HeapFree(GetProcessHeap(), 0, share->primaries);
1083             share->primaries = prims;
1084             share->nprimaries += 1;
1085         }
1086
1087         LeaveCriticalSection(&share->crst);
1088     }
1089
1090     if(FAILED(hr))
1091     {
1092         if(This->share)
1093             DSShare_Release(This->share);
1094         This->share = NULL;
1095     }
1096
1097     LeaveCriticalSection(&openal_crst);
1098     return hr;
1099 }
1100
1101 /* I, Maarten Lankhorst, hereby declare this driver certified
1102  * What this means.. ? An extra bit set
1103  */
1104 static HRESULT WINAPI DS8_VerifyCertification(IDirectSound8 *iface, DWORD *certified)
1105 {
1106     DSDevice *This = impl_from_IDirectSound8(iface);
1107
1108     TRACE("(%p)->(%p)\n", iface, certified);
1109
1110     if(!certified)
1111         return DSERR_INVALIDPARAM;
1112     *certified = 0;
1113
1114     if(!This->share)
1115     {
1116         WARN("Device not initialized\n");
1117         return DSERR_UNINITIALIZED;
1118     }
1119
1120     *certified = DS_CERTIFIED;
1121
1122     return DS_OK;
1123 }
1124
1125 static const IDirectSound8Vtbl DS8_Vtbl = {
1126     DS8_QueryInterface,
1127     DS8_AddRef,
1128     DS8_Release,
1129     DS8_CreateSoundBuffer,
1130     DS8_GetCaps,
1131     DS8_DuplicateSoundBuffer,
1132     DS8_SetCooperativeLevel,
1133     DS8_Compact,
1134     DS8_GetSpeakerConfig,
1135     DS8_SetSpeakerConfig,
1136     DS8_Initialize,
1137     DS8_VerifyCertification
1138 };
1139
1140
1141 static HRESULT WINAPI DS_QueryInterface(IDirectSound *iface, REFIID riid, LPVOID *ppv)
1142 {
1143     DSDevice *This = impl_from_IDirectSound(iface);
1144     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1145     return DSDevice_GetInterface(This, riid, ppv);
1146 }
1147
1148 static ULONG WINAPI DS_AddRef(IDirectSound *iface)
1149 {
1150     DSDevice *This = impl_from_IDirectSound(iface);
1151     return DS8_AddRef(&This->IDirectSound8_iface);
1152 }
1153
1154 static ULONG WINAPI DS_Release(IDirectSound *iface)
1155 {
1156     DSDevice *This = impl_from_IDirectSound(iface);
1157     return DS8_Release(&This->IDirectSound8_iface);
1158 }
1159
1160 static HRESULT WINAPI DS_CreateSoundBuffer(IDirectSound *iface, LPCDSBUFFERDESC desc, LPLPDIRECTSOUNDBUFFER buf, IUnknown *pUnkOuter)
1161 {
1162     DSDevice *This = impl_from_IDirectSound(iface);
1163     return DS8_CreateSoundBuffer(&This->IDirectSound8_iface, desc, buf, pUnkOuter);
1164 }
1165
1166 static HRESULT WINAPI DS_GetCaps(IDirectSound *iface, LPDSCAPS caps)
1167 {
1168     DSDevice *This = impl_from_IDirectSound(iface);
1169     return DS8_GetCaps(&This->IDirectSound8_iface, caps);
1170 }
1171 static HRESULT WINAPI DS_DuplicateSoundBuffer(IDirectSound *iface, IDirectSoundBuffer *in, IDirectSoundBuffer **out)
1172 {
1173     DSDevice *This = impl_from_IDirectSound(iface);
1174     return DS8_DuplicateSoundBuffer(&This->IDirectSound8_iface, in, out);
1175 }
1176
1177 static HRESULT WINAPI DS_SetCooperativeLevel(IDirectSound *iface, HWND hwnd, DWORD level)
1178 {
1179     DSDevice *This = impl_from_IDirectSound(iface);
1180     return DS8_SetCooperativeLevel(&This->IDirectSound8_iface, hwnd, level);
1181 }
1182
1183 static HRESULT WINAPI DS_Compact(IDirectSound *iface)
1184 {
1185     DSDevice *This = impl_from_IDirectSound(iface);
1186     return DS8_Compact(&This->IDirectSound8_iface);
1187 }
1188
1189 static HRESULT WINAPI DS_GetSpeakerConfig(IDirectSound *iface, DWORD *config)
1190 {
1191     DSDevice *This = impl_from_IDirectSound(iface);
1192     return DS8_GetSpeakerConfig(&This->IDirectSound8_iface, config);
1193 }
1194
1195 static HRESULT WINAPI DS_SetSpeakerConfig(IDirectSound *iface, DWORD config)
1196 {
1197     DSDevice *This = impl_from_IDirectSound(iface);
1198     return DS8_SetSpeakerConfig(&This->IDirectSound8_iface, config);
1199 }
1200
1201 static HRESULT WINAPI DS_Initialize(IDirectSound *iface, const GUID *devguid)
1202 {
1203     DSDevice *This = impl_from_IDirectSound(iface);
1204     return DS8_Initialize(&This->IDirectSound8_iface, devguid);
1205 }
1206
1207 static const IDirectSoundVtbl DS_Vtbl = {
1208     DS_QueryInterface,
1209     DS_AddRef,
1210     DS_Release,
1211     DS_CreateSoundBuffer,
1212     DS_GetCaps,
1213     DS_DuplicateSoundBuffer,
1214     DS_SetCooperativeLevel,
1215     DS_Compact,
1216     DS_GetSpeakerConfig,
1217     DS_SetSpeakerConfig,
1218     DS_Initialize
1219 };