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 #include <stdarg.h>
  24
  25 #ifdef __WINESRC__
  26
  27 #define COBJMACROS
  28 #define NONAMELESSSTRUCT
  29 #define NONAMELESSUNION
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winuser.h"
  33 #include "winnls.h"
  34 #include "winreg.h"
  35 #include "mmsystem.h"
  36 #include "winternl.h"
  37 #include "mmddk.h"
  38 #include "wine/debug.h"
  39 #include "dsound.h"
  40
  41 #include "dsound_private.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  44
  45 #else
  46
  47 #define WINVER 0x0600
  48 #include <windows.h>
  49 #include <dsound.h>
  50
  51 #include "dsound_private.h"
  52
  53 #ifndef DSSPEAKER_7POINT1
  54 #define DSSPEAKER_7POINT1       7
  55 #endif
  56
  57 #endif
  58
  59 static DS8Impl **devicelist;
  60 static UINT devicelistsize;
  61
  62 static const IDirectSound8Vtbl DS8_Vtbl;
  63
  64 static inline DS8Impl *impl_from_IDirectSound8(IDirectSound8 *iface)
  65 {
  66     return CONTAINING_RECORD(iface, DS8Impl, IDirectSound8_iface);
  67 }
  68
  69 HRESULT DSOUND_Create(REFIID riid, void **ds)
  70 {
  71     HRESULT hr;
  72
  73     if(IsEqualIID(riid, &IID_IDirectSound8))
  74         return E_NOINTERFACE;
  75     hr = DSOUND_Create8(&IID_IDirectSound8, ds);
  76     if(hr == S_OK)
  77     {
  78         DS8Impl *impl = impl_from_IDirectSound8(*ds);
  79         impl->is_8 = FALSE;
  80
  81         hr = IDirectSound8_QueryInterface(&impl->IDirectSound8_iface, riid, ds);
  82         IDirectSound8_Release(&impl->IDirectSound8_iface);
  83     }
  84     return hr;
  85 }
  86
  87 static void DS8Impl_Destroy(DS8Impl *This);
  88
  89 static const WCHAR speakerconfigkey[] = {
  90     'S','Y','S','T','E','M','\\',
  91     'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  92     'C','o','n','t','r','o','l','\\',
  93     'M','e','d','i','a','R','e','s','o','u','r','c','e','s','\\',
  94     'D','i','r','e','c','t','S','o','u','n','d','\\',
  95     'S','p','e','a','k','e','r',' ','C','o','n','f','i','g','u','r','a','t','i','o','n',0
  96 };
  97
  98 static const WCHAR speakerconfig[] = {
  99     'S','p','e','a','k','e','r',' ','C','o','n','f','i','g','u','r','a','t','i','o','n',0
 100 };
 101
 102 HRESULT DSOUND_Create8(REFIID riid, LPVOID *ds)
 103 {
 104     DS8Impl *This;
 105     HKEY regkey;
 106     HRESULT hr;
 107
 108     *ds = NULL;
 109     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 110     if(!This)
 111         return E_OUTOFMEMORY;
 112     This->IDirectSound8_iface.lpVtbl = (IDirectSound8Vtbl*)&DS8_Vtbl;
 113
 114     This->is_8 = TRUE;
 115     This->speaker_config = DSSPEAKER_COMBINED(DSSPEAKER_5POINT1, DSSPEAKER_GEOMETRY_WIDE);
 116
 117     if(RegOpenKeyExW(HKEY_LOCAL_MACHINE, speakerconfigkey, 0, KEY_READ, &regkey) == ERROR_SUCCESS)
 118     {
 119         DWORD type, conf, confsize = sizeof(DWORD);
 120
 121         if(RegQueryValueExW(regkey, speakerconfig, NULL, &type, (BYTE*)&conf, &confsize) == ERROR_SUCCESS)
 122         {
 123             if(type == REG_DWORD)
 124                 This->speaker_config = conf;
 125         }
 126
 127         RegCloseKey(regkey);
 128     }
 129     /*RegGetValueW(HKEY_LOCAL_MACHINE, speakerconfigkey, speakerconfig, RRF_RT_REG_DWORD, NULL, &This->speaker_config, NULL);*/
 130
 131     hr = IDirectSound8_QueryInterface(&This->IDirectSound8_iface, riid, ds);
 132     if(FAILED(hr))
 133         DS8Impl_Destroy(This);
 134     else
 135     {
 136         void *temp;
 137
 138         EnterCriticalSection(&openal_crst);
 139         if(devicelist)
 140             temp = HeapReAlloc(GetProcessHeap(), 0, devicelist, sizeof(*devicelist)*(devicelistsize+1));
 141         else
 142             temp = HeapAlloc(GetProcessHeap(), 0, sizeof(*devicelist)*(devicelistsize+1));
 143         if(temp)
 144         {
 145             devicelist = temp;
 146             devicelist[devicelistsize++] = This;
 147         }
 148         LeaveCriticalSection(&openal_crst);
 149     }
 150     return hr;
 151 }
 152
 153 static void DS8Impl_Destroy(DS8Impl *This)
 154 {
 155     UINT i;
 156
 157     EnterCriticalSection(&openal_crst);
 158     for(i = 0;i < devicelistsize;i++)
 159     {
 160         if(devicelist[i] == This)
 161         {
 162             devicelist[i] = devicelist[--devicelistsize];
 163             if(devicelistsize == 0)
 164             {
 165                 HeapFree(GetProcessHeap(), 0, devicelist);
 166                 devicelist = NULL;
 167             }
 168             break;
 169         }
 170     }
 171     LeaveCriticalSection(&openal_crst);
 172
 173     if(This->deviceref && InterlockedDecrement(This->deviceref) == 0)
 174     {
 175         if(This->primary)
 176             DS8Primary_Destroy(This->primary);
 177         if(This->device)
 178             alcCloseDevice(This->device);
 179
 180         HeapFree(GetProcessHeap(), 0, This->deviceref);
 181     }
 182     else
 183     {
 184         EnterCriticalSection(&openal_crst);
 185         if(This->primary && This->primary->parent == This)
 186         {
 187             /* If the primary is referencing this as its parent, update it to
 188              * reference another handle for the device */
 189             for(i = 0;i < devicelistsize;i++)
 190             {
 191                 if(devicelist[i]->primary == This->primary)
 192                 {
 193                     This->primary->parent = devicelist[i];
 194                     break;
 195                 }
 196             }
 197         }
 198         LeaveCriticalSection(&openal_crst);
 199     }
 200
 201     HeapFree(GetProcessHeap(), 0, This);
 202 }
 203
 204
 205 static HRESULT WINAPI DS8_QueryInterface(IDirectSound8 *iface, REFIID riid, LPVOID *ppv)
 206 {
 207     DS8Impl *This = impl_from_IDirectSound8(iface);
 208
 209     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 210
 211     *ppv = NULL;
 212     if(IsEqualIID(riid, &IID_IUnknown) ||
 213        IsEqualIID(riid, &IID_IDirectSound))
 214         *ppv = &This->IDirectSound8_iface;
 215     else if((IsEqualIID(riid, &IID_IDirectSound8)))
 216     {
 217         if(This->is_8)
 218             *ppv = &This->IDirectSound8_iface;
 219     }
 220     else
 221         FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
 222
 223     if(*ppv)
 224     {
 225         IUnknown_AddRef((IUnknown*)*ppv);
 226         return S_OK;
 227     }
 228
 229     return E_NOINTERFACE;
 230 }
 231
 232 static ULONG WINAPI DS8_AddRef(IDirectSound8 *iface)
 233 {
 234     DS8Impl *This = impl_from_IDirectSound8(iface);
 235     LONG ref;
 236
 237     ref = InterlockedIncrement(&This->ref);
 238     TRACE("Reference count incremented to %d\n", ref);
 239
 240     return ref;
 241 }
 242
 243 static ULONG WINAPI DS8_Release(IDirectSound8 *iface)
 244 {
 245     DS8Impl *This = impl_from_IDirectSound8(iface);
 246     LONG ref;
 247
 248     ref = InterlockedDecrement(&This->ref);
 249     TRACE("Reference count decremented to %d\n", ref);
 250     if(ref == 0)
 251         DS8Impl_Destroy(This);
 252
 253     return ref;
 254 }
 255
 256 static HRESULT WINAPI DS8_CreateSoundBuffer(IDirectSound8 *iface, LPCDSBUFFERDESC desc, LPLPDIRECTSOUNDBUFFER buf, IUnknown *pUnkOuter)
 257 {
 258     DS8Impl *This = impl_from_IDirectSound8(iface);
 259     HRESULT hr;
 260
 261     TRACE("(%p)->(%p, %p, %p)\n", iface, desc, buf, pUnkOuter);
 262
 263     if(!buf)
 264     {
 265         WARN("buf is null\n");
 266         return DSERR_INVALIDPARAM;
 267     }
 268     *buf = NULL;
 269
 270     if(pUnkOuter)
 271     {
 272         WARN("Aggregation isn't supported\n");
 273         return DSERR_NOAGGREGATION;
 274     }
 275     if(!desc || desc->dwSize < sizeof(DSBUFFERDESC1))
 276     {
 277         WARN("Invalid buffer %p/%u\n", desc, desc?desc->dwSize:0);
 278         return DSERR_INVALIDPARAM;
 279     }
 280
 281     if(!This->primary)
 282     {
 283         WARN("Device not initialized\n");
 284         return DSERR_UNINITIALIZED;
 285     }
 286
 287     TRACE("Requested buffer:\n"
 288           "    Size        = %u\n"
 289           "    Flags       = 0x%08x\n"
 290           "    BufferBytes = %u\n",
 291           (UINT)desc->dwSize, (UINT)desc->dwFlags,
 292           (UINT)desc->dwBufferBytes);
 293
 294     if(desc->dwSize >= sizeof(DSBUFFERDESC))
 295     {
 296         if(!(desc->dwFlags&DSBCAPS_CTRL3D))
 297         {
 298             if(!IsEqualGUID(&desc->guid3DAlgorithm, &GUID_NULL))
 299             {
 300                 WARN("Invalid 3D algorithm GUID specified for non-3D buffer: %s\n", debugstr_guid(&desc->guid3DAlgorithm));
 301                 return DSERR_INVALIDPARAM;
 302             }
 303         }
 304         else
 305             TRACE("Requested 3D algorithm GUID: %s\n", debugstr_guid(&desc->guid3DAlgorithm));
 306     }
 307
 308     /* OpenAL doesn't support playing with 3d and panning at same time.. */
 309     if((desc->dwFlags&(DSBCAPS_CTRL3D|DSBCAPS_CTRLPAN)) == (DSBCAPS_CTRL3D|DSBCAPS_CTRLPAN))
 310     {
 311         if(!This->is_8)
 312             ERR("Cannot create buffers with 3D and panning control\n");
 313         else
 314             WARN("Cannot create buffers with 3D and panning control\n");
 315         return DSERR_INVALIDPARAM;
 316     }
 317
 318     EnterCriticalSection(&This->primary->crst);
 319     if((desc->dwFlags&DSBCAPS_PRIMARYBUFFER))
 320     {
 321         IDirectSoundBuffer *prim = &This->primary->IDirectSoundBuffer_iface;
 322
 323         hr = S_OK;
 324         if(IDirectSoundBuffer_AddRef(prim) == 1)
 325         {
 326             hr = IDirectSoundBuffer_Initialize(prim, (IDirectSound*)&This->IDirectSound8_iface, desc);
 327             if(FAILED(hr))
 328             {
 329                 IDirectSoundBuffer_Release(prim);
 330                 prim = NULL;
 331             }
 332         }
 333         *buf = prim;
 334     }
 335     else
 336     {
 337         DS8Buffer *dsb;
 338
 339         hr = DS8Buffer_Create(&dsb, This->primary, NULL);
 340         if(SUCCEEDED(hr))
 341         {
 342             hr = IDirectSoundBuffer8_Initialize(&dsb->IDirectSoundBuffer8_iface, (IDirectSound*)&This->IDirectSound8_iface, desc);
 343             if(FAILED(hr))
 344                 IDirectSoundBuffer8_Release(&dsb->IDirectSoundBuffer8_iface);
 345             else
 346             {
 347                 dsb->bufferlost = (This->prio_level == DSSCL_WRITEPRIMARY);
 348                 *buf = &dsb->IDirectSoundBuffer_iface;
 349             }
 350         }
 351     }
 352     LeaveCriticalSection(&This->primary->crst);
 353
 354     TRACE("%08x\n", hr);
 355     return hr;
 356 }
 357
 358 static HRESULT WINAPI DS8_GetCaps(IDirectSound8 *iface, LPDSCAPS caps)
 359 {
 360     DS8Impl *This = impl_from_IDirectSound8(iface);
 361     LONG count;
 362
 363     TRACE("(%p)->(%p)\n", iface, caps);
 364
 365     if(!This->primary)
 366     {
 367         WARN("Device not initialized\n");
 368         return DSERR_UNINITIALIZED;
 369     }
 370
 371     if(!caps || caps->dwSize < sizeof(*caps))
 372     {
 373         WARN("Invalid DSCAPS (%p, %u)\n", caps, (caps?caps->dwSize:0));
 374         return DSERR_INVALIDPARAM;
 375     }
 376
 377     EnterCriticalSection(&This->primary->crst);
 378     count = This->primary->max_sources;
 379
 380     setALContext(This->primary->ctx);
 381     caps->dwFlags = DSCAPS_CONTINUOUSRATE |
 382                     DSCAPS_PRIMARY16BIT | DSCAPS_PRIMARYSTEREO |
 383                     DSCAPS_PRIMARY8BIT | DSCAPS_PRIMARYMONO |
 384                     DSCAPS_SECONDARY16BIT | DSCAPS_SECONDARY8BIT |
 385                     DSCAPS_SECONDARYMONO | DSCAPS_SECONDARYSTEREO;
 386     caps->dwPrimaryBuffers = 1;
 387     caps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
 388     caps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
 389     caps->dwMaxHwMixingAllBuffers =
 390         caps->dwMaxHwMixingStaticBuffers =
 391         caps->dwMaxHwMixingStreamingBuffers =
 392         caps->dwMaxHw3DAllBuffers =
 393         caps->dwMaxHw3DStaticBuffers =
 394         caps->dwMaxHw3DStreamingBuffers = count;
 395     count -= This->primary->nbuffers;
 396     if(count < 0)
 397     {
 398         ERR("How did the count drop below 0?\n");
 399         count = 0;
 400     }
 401     caps->dwFreeHwMixingAllBuffers =
 402         caps->dwFreeHwMixingStaticBuffers =
 403         caps->dwFreeHwMixingStreamingBuffers =
 404         caps->dwFreeHw3DAllBuffers =
 405         caps->dwFreeHw3DStaticBuffers =
 406         caps->dwFreeHw3DStreamingBuffers = count;
 407     caps->dwTotalHwMemBytes =
 408         caps->dwFreeHwMemBytes = 64 * 1024 * 1024;
 409     caps->dwMaxContigFreeHwMemBytes = caps->dwFreeHwMemBytes;
 410     caps->dwUnlockTransferRateHwBuffers = 4096;
 411     caps->dwPlayCpuOverheadSwBuffers = 0;
 412     popALContext();
 413
 414     LeaveCriticalSection(&This->primary->crst);
 415
 416     return DS_OK;
 417 }
 418 static HRESULT WINAPI DS8_DuplicateSoundBuffer(IDirectSound8 *iface, IDirectSoundBuffer *in, IDirectSoundBuffer **out)
 419 {
 420     DS8Impl *This = impl_from_IDirectSound8(iface);
 421     DS8Buffer *buf;
 422     DSBCAPS caps;
 423     HRESULT hr;
 424
 425     TRACE("(%p)->(%p, %p)\n", iface, in, out);
 426
 427     if(!This->primary)
 428     {
 429         WARN("Device not initialized\n");
 430         return DSERR_UNINITIALIZED;
 431     }
 432
 433     if(!in || !out)
 434     {
 435         WARN("Invalid pointer: int = %p, out = %p\n", in, out);
 436         return DSERR_INVALIDPARAM;
 437     }
 438     *out = NULL;
 439
 440     EnterCriticalSection(&This->primary->crst);
 441
 442     caps.dwSize = sizeof(caps);
 443     hr = IDirectSoundBuffer_GetCaps(in, &caps);
 444     if(SUCCEEDED(hr) && (caps.dwFlags&DSBCAPS_PRIMARYBUFFER))
 445     {
 446         WARN("Cannot duplicate buffer %p, which has DSBCAPS_PRIMARYBUFFER\n", in);
 447         hr = DSERR_INVALIDPARAM;
 448     }
 449     if(SUCCEEDED(hr) && (caps.dwFlags&DSBCAPS_CTRLFX))
 450     {
 451         WARN("Cannot duplicate buffer %p, which has DSBCAPS_CTRLFX\n", in);
 452         hr = DSERR_INVALIDPARAM;
 453     }
 454     if(SUCCEEDED(hr))
 455         hr = DS8Buffer_Create(&buf, This->primary, in);
 456     if(SUCCEEDED(hr))
 457     {
 458         *out = &buf->IDirectSoundBuffer_iface;
 459         hr = IDirectSoundBuffer_Initialize(*out, NULL, NULL);
 460     }
 461     if(SUCCEEDED(hr))
 462     {
 463         /* According to MSDN volume isn't copied */
 464         if((caps.dwFlags&DSBCAPS_CTRLPAN))
 465         {
 466             LONG pan;
 467             if(SUCCEEDED(IDirectSoundBuffer_GetPan(in, &pan)))
 468                 IDirectSoundBuffer_SetPan(*out, pan);
 469         }
 470         if((caps.dwFlags&DSBCAPS_CTRLFREQUENCY))
 471         {
 472             DWORD freq;
 473             if(SUCCEEDED(IDirectSoundBuffer_GetFrequency(in, &freq)))
 474                 IDirectSoundBuffer_SetFrequency(*out, freq);
 475         }
 476         if((caps.dwFlags&DSBCAPS_CTRL3D))
 477         {
 478             IDirectSound3DBuffer *buf3d;
 479             DS3DBUFFER DS3DBuffer;
 480             HRESULT subhr;
 481
 482             subhr = IDirectSound_QueryInterface(in, &IID_IDirectSound3DBuffer, (void**)&buf3d);
 483             if(SUCCEEDED(subhr))
 484             {
 485                 DS3DBuffer.dwSize = sizeof(DS3DBuffer);
 486                 subhr = IDirectSound3DBuffer_GetAllParameters(buf3d, &DS3DBuffer);
 487                 IDirectSound3DBuffer_Release(buf3d);
 488             }
 489             if(SUCCEEDED(subhr))
 490                 subhr = IDirectSoundBuffer_QueryInterface(*out, &IID_IDirectSound3DBuffer, (void**)&buf3d);
 491             if(SUCCEEDED(subhr))
 492             {
 493                 subhr = IDirectSound3DBuffer_SetAllParameters(buf3d, &DS3DBuffer, DS3D_IMMEDIATE);
 494                 IDirectSound3DBuffer_Release(buf3d);
 495             }
 496         }
 497     }
 498     if(FAILED(hr))
 499     {
 500         if(*out)
 501             IDirectSoundBuffer_Release(*out);
 502         *out = NULL;
 503     }
 504
 505     LeaveCriticalSection(&This->primary->crst);
 506     return hr;
 507 }
 508
 509 static HRESULT WINAPI DS8_SetCooperativeLevel(IDirectSound8 *iface, HWND hwnd, DWORD level)
 510 {
 511     DS8Impl *This = impl_from_IDirectSound8(iface);
 512     HRESULT hr = S_OK;
 513
 514     TRACE("(%p)->(%p, %u)\n", iface, hwnd, level);
 515
 516     if(!This->primary)
 517     {
 518         WARN("Device not initialized\n");
 519         return DSERR_UNINITIALIZED;
 520     }
 521
 522     if(level > DSSCL_WRITEPRIMARY || level < DSSCL_NORMAL)
 523     {
 524         WARN("Invalid coop level: %u\n", level);
 525         return DSERR_INVALIDPARAM;
 526     }
 527
 528     EnterCriticalSection(&This->primary->crst);
 529     if(level == DSSCL_WRITEPRIMARY && (This->prio_level != DSSCL_WRITEPRIMARY))
 530     {
 531         DWORD i, state;
 532
 533         for(i = 0; i < This->primary->nbuffers; ++i)
 534         {
 535             DS8Buffer *buf = This->primary->buffers[i];
 536             if(FAILED(IDirectSoundBuffer_GetStatus(&buf->IDirectSoundBuffer8_iface, &state)) ||
 537                (state&DSBSTATUS_PLAYING))
 538             {
 539                 WARN("DSSCL_WRITEPRIMARY set with playing buffers!\n");
 540                 hr = DSERR_INVALIDCALL;
 541                 goto out;
 542             }
 543             /* Mark buffer as lost */
 544             buf->bufferlost = 1;
 545         }
 546         if(This->primary->write_emu)
 547         {
 548             ERR("Why was there a write_emu?\n");
 549             /* Delete it */
 550             IDirectSoundBuffer8_Release(This->primary->write_emu);
 551             This->primary->write_emu = NULL;
 552         }
 553         if(This->primary->flags)
 554         {
 555             /* Primary has open references.. create write_emu */
 556             DSBUFFERDESC desc;
 557             DS8Buffer *emu;
 558
 559             memset(&desc, 0, sizeof(desc));
 560             desc.dwSize = sizeof(desc);
 561             desc.dwFlags = DSBCAPS_LOCHARDWARE | (This->primary->flags&DSBCAPS_CTRLPAN);
 562             desc.dwBufferBytes = This->primary->buf_size;
 563             desc.lpwfxFormat = &This->primary->format.Format;
 564
 565             hr = DS8Buffer_Create(&emu, This->primary, NULL);
 566             if(SUCCEEDED(hr))
 567             {
 568                 This->primary->write_emu = &emu->IDirectSoundBuffer8_iface;
 569                 hr = IDirectSoundBuffer8_Initialize(This->primary->write_emu, (IDirectSound*)&This->IDirectSound8_iface, &desc);
 570                 if(FAILED(hr))
 571                 {
 572                     IDirectSoundBuffer8_Release(This->primary->write_emu);
 573                     This->primary->write_emu = NULL;
 574                 }
 575             }
 576         }
 577     }
 578     else if(This->prio_level == DSSCL_WRITEPRIMARY && level != DSSCL_WRITEPRIMARY && This->primary->write_emu)
 579     {
 580         TRACE("Nuking write_emu\n");
 581         /* Delete it */
 582         IDirectSoundBuffer8_Release(This->primary->write_emu);
 583         This->primary->write_emu = NULL;
 584     }
 585     if(SUCCEEDED(hr))
 586         This->prio_level = level;
 587 out:
 588     LeaveCriticalSection(&This->primary->crst);
 589
 590     return hr;
 591 }
 592
 593 static HRESULT WINAPI DS8_Compact(IDirectSound8 *iface)
 594 {
 595     DS8Impl *This = impl_from_IDirectSound8(iface);
 596     HRESULT hr = S_OK;
 597
 598     TRACE("(%p)->()\n", iface);
 599
 600     if(!This->primary)
 601     {
 602         WARN("Device not initialized\n");
 603         return DSERR_UNINITIALIZED;
 604     }
 605
 606     EnterCriticalSection(&This->primary->crst);
 607     if(This->prio_level < DSSCL_PRIORITY)
 608     {
 609         WARN("Coop level not high enough (%u)\n", This->prio_level);
 610         hr = DSERR_PRIOLEVELNEEDED;
 611     }
 612     LeaveCriticalSection(&This->primary->crst);
 613
 614     return hr;
 615 }
 616
 617 static HRESULT WINAPI DS8_GetSpeakerConfig(IDirectSound8 *iface, DWORD *config)
 618 {
 619     DS8Impl *This = impl_from_IDirectSound8(iface);
 620     HRESULT hr = S_OK;
 621
 622     TRACE("(%p)->(%p)\n", iface, config);
 623
 624     if(!config)
 625         return DSERR_INVALIDPARAM;
 626     *config = 0;
 627
 628     if(!This->primary)
 629     {
 630         WARN("Device not initialized\n");
 631         return DSERR_UNINITIALIZED;
 632     }
 633
 634     EnterCriticalSection(&This->primary->crst);
 635     *config = This->speaker_config;
 636     LeaveCriticalSection(&This->primary->crst);
 637
 638     return hr;
 639 }
 640
 641 static HRESULT WINAPI DS8_SetSpeakerConfig(IDirectSound8 *iface, DWORD config)
 642 {
 643     DS8Impl *This = impl_from_IDirectSound8(iface);
 644     DWORD geo, speaker;
 645     HKEY key;
 646     HRESULT hr;
 647
 648     TRACE("(%p)->(0x%08x)\n", iface, config);
 649
 650     if(!This->primary)
 651     {
 652         WARN("Device not initialized\n");
 653         return DSERR_UNINITIALIZED;
 654     }
 655
 656     EnterCriticalSection(&This->primary->crst);
 657
 658     geo = DSSPEAKER_GEOMETRY(config);
 659     speaker = DSSPEAKER_CONFIG(config);
 660
 661     hr = DSERR_INVALIDPARAM;
 662     if(geo && (geo < DSSPEAKER_GEOMETRY_MIN || geo > DSSPEAKER_GEOMETRY_MAX))
 663     {
 664         WARN("Invalid speaker angle %u\n", geo);
 665         goto out;
 666     }
 667     if(speaker < DSSPEAKER_HEADPHONE || speaker > DSSPEAKER_7POINT1)
 668     {
 669         WARN("Invalid speaker config %u\n", speaker);
 670         goto out;
 671     }
 672
 673     hr = DSERR_GENERIC;
 674     if(!RegCreateKeyExW(HKEY_LOCAL_MACHINE, speakerconfigkey, 0, NULL, 0, KEY_WRITE, NULL, &key, NULL))
 675     {
 676         RegSetValueExW(key, speakerconfig, 0, REG_DWORD, (const BYTE*)&config, sizeof(DWORD));
 677         This->speaker_config = config;
 678         RegCloseKey(key);
 679         hr = S_OK;
 680     }
 681 out:
 682     LeaveCriticalSection(&This->primary->crst);
 683
 684     return hr;
 685 }
 686
 687 static HRESULT WINAPI DS8_Initialize(IDirectSound8 *iface, const GUID *devguid)
 688 {
 689     DS8Impl *This = impl_from_IDirectSound8(iface);
 690     const ALCchar *drv_name;
 691     HRESULT hr;
 692     UINT n;
 693
 694     TRACE("(%p)->(%s)\n", iface, debugstr_guid(devguid));
 695
 696     if(!openal_loaded)
 697         return DSERR_NODRIVER;
 698
 699     if(This->primary)
 700     {
 701         WARN("Device already initialized\n");
 702         return DSERR_ALREADYINITIALIZED;
 703     }
 704
 705     if(!devguid)
 706         devguid = &DSDEVID_DefaultPlayback;
 707     hr = GetDeviceID(devguid, &This->guid);
 708     if(FAILED(hr))
 709         return hr;
 710
 711     EnterCriticalSection(&openal_crst);
 712
 713     for(n = 0;n < devicelistsize;n++)
 714     {
 715         if(devicelist[n]->device && devicelist[n]->is_8 == This->is_8 &&
 716            IsEqualGUID(&devicelist[n]->guid, &This->guid))
 717         {
 718             TRACE("Matched already open device %p\n", devicelist[n]);
 719
 720             This->device = devicelist[n]->device;
 721             This->primary = devicelist[n]->primary;
 722             This->deviceref = devicelist[n]->deviceref;
 723             InterlockedIncrement(This->deviceref);
 724
 725             hr = DS_OK;
 726             goto out;
 727         }
 728     }
 729
 730     if(!This->deviceref)
 731     {
 732         hr = DSERR_OUTOFMEMORY;
 733         if(!(This->deviceref=HeapAlloc(GetProcessHeap(), 0, sizeof(LONG))))
 734             goto out;
 735         This->deviceref[0] = 1;
 736     }
 737
 738     hr = DSERR_NODRIVER;
 739     if(!(drv_name=DSOUND_getdevicestrings()) ||
 740        memcmp(&This->guid, &DSOUND_renderer_guid, sizeof(GUID)-1) != 0)
 741     {
 742         WARN("No device found\n");
 743         goto out;
 744     }
 745
 746     n = This->guid.Data4[7];
 747     while(*drv_name && n--)
 748         drv_name += strlen(drv_name) + 1;
 749     if(!*drv_name)
 750     {
 751         WARN("No device string found\n");
 752         goto out;
 753     }
 754
 755     This->device = alcOpenDevice(drv_name);
 756     if(!This->device)
 757     {
 758         alcGetError(NULL);
 759         WARN("Couldn't open device \"%s\"\n", drv_name);
 760         goto out;
 761     }
 762     TRACE("Opened device: %s\n", alcGetString(This->device, ALC_DEVICE_SPECIFIER));
 763
 764     hr = DS8Primary_Create(&This->primary, This);
 765     if(FAILED(hr))
 766     {
 767         alcCloseDevice(This->device);
 768         This->device = NULL;
 769     }
 770
 771 out:
 772     LeaveCriticalSection(&openal_crst);
 773
 774     return hr;
 775 }
 776
 777 /* I, Maarten Lankhorst, hereby declare this driver certified
 778  * What this means.. ? An extra bit set
 779  */
 780 static HRESULT WINAPI DS8_VerifyCertification(IDirectSound8 *iface, DWORD *certified)
 781 {
 782     DS8Impl *This = impl_from_IDirectSound8(iface);
 783
 784     TRACE("(%p)->(%p)\n", iface, certified);
 785
 786     if(!certified)
 787         return DSERR_INVALIDPARAM;
 788     *certified = 0;
 789
 790     if(!This->primary)
 791     {
 792         WARN("Device not initialized\n");
 793         return DSERR_UNINITIALIZED;
 794     }
 795
 796     *certified = DS_CERTIFIED;
 797
 798     return DS_OK;
 799 }
 800
 801 static const IDirectSound8Vtbl DS8_Vtbl =
 802 {
 803     DS8_QueryInterface,
 804     DS8_AddRef,
 805     DS8_Release,
 806     DS8_CreateSoundBuffer,
 807     DS8_GetCaps,
 808     DS8_DuplicateSoundBuffer,
 809     DS8_SetCooperativeLevel,
 810     DS8_Compact,
 811     DS8_GetSpeakerConfig,
 812     DS8_SetSpeakerConfig,
 813     DS8_Initialize,
 814     DS8_VerifyCertification
 815 };