primary.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 "vfwmsgs.h"
  36 #include "mmsystem.h"
  37 #include "winternl.h"
  38 #include "mmddk.h"
  39 #include "wine/debug.h"
  40 #include "dsound.h"
  41
  42 #include "dsound_private.h"
  43
  44 #include "mmreg.h"
  45 #include "ks.h"
  46 #include "ksmedia.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  49
  50 #else
  51
  52 #define WINVER 0x0600
  53 #include <windows.h>
  54 #include <dsound.h>
  55
  56 #include "dsound_private.h"
  57
  58 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  59 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  60
  61 #ifndef E_PROP_ID_UNSUPPORTED
  62 #define E_PROP_ID_UNSUPPORTED            ((HRESULT)0x80070490)
  63 #endif
  64
  65 #endif
  66
  67 static const IDirectSoundBufferVtbl DS8Primary_Vtbl;
  68 static const IDirectSound3DListenerVtbl DS8Primary3D_Vtbl;
  69 static const IKsPropertySetVtbl DS8PrimaryProp_Vtbl;
  70
  71 static void AL_APIENTRY wrap_DeferUpdates(void)
  72 { alcSuspendContext(alcGetCurrentContext()); }
  73 static void AL_APIENTRY wrap_ProcessUpdates(void)
  74 { alcProcessContext(alcGetCurrentContext()); }
  75
  76
  77 static void trigger_elapsed_notifies(DS8Buffer *buf, DWORD lastpos, DWORD curpos)
  78 {
  79     DWORD i;
  80     for(i = 0; i < buf->nnotify; ++i)
  81     {
  82         DSBPOSITIONNOTIFY *not = &buf->notify[i];
  83         HANDLE event = not->hEventNotify;
  84         DWORD ofs = not->dwOffset;
  85
  86         if(ofs == (DWORD)DSBPN_OFFSETSTOP)
  87             continue;
  88
  89         /* Wraparound case */
  90         if(curpos < lastpos)
  91         {
  92             if(ofs < curpos || ofs >= lastpos)
  93                 SetEvent(event);
  94             continue;
  95         }
  96
  97         /* Normal case */
  98         if(ofs >= lastpos && ofs < curpos)
  99             SetEvent(event);
 100     }
 101 }
 102
 103 static void trigger_stop_notifies(DS8Buffer *buf)
 104 {
 105     DWORD i;
 106     for(i = 0; i < buf->nnotify; ++i)
 107     {
 108         DSBPOSITIONNOTIFY *not = &buf->notify[i];
 109         if(not->dwOffset == (DWORD)DSBPN_OFFSETSTOP)
 110             SetEvent(not->hEventNotify);
 111     }
 112 }
 113
 114 static DWORD CALLBACK ThreadProc(void *dwUser)
 115 {
 116     DS8Primary *prim = (DS8Primary*)dwUser;
 117     DWORD i;
 118     MSG msg;
 119
 120     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
 121
 122     while(GetMessageA(&msg, NULL, 0, 0))
 123     {
 124         if(msg.message != WM_USER)
 125             continue;
 126
 127         EnterCriticalSection(&prim->crst);
 128         setALContext(prim->ctx);
 129
 130         /* OpenAL doesn't support our lovely buffer extensions
 131          * so just make sure enough buffers are queued
 132          */
 133         if(!prim->SupportedExt[SOFT_BUFFER_SAMPLES] &&
 134            !prim->SupportedExt[SOFT_BUFFER_SUB_DATA] &&
 135            !prim->SupportedExt[EXT_STATIC_BUFFER])
 136         {
 137             for(i = 0;i < prim->nbuffers;++i)
 138             {
 139                 DS8Buffer *buf = prim->buffers[i];
 140                 ALint done = 0, queued = QBUFFERS, state = AL_PLAYING;
 141                 ALuint which, ofs;
 142
 143                 if(buf->buffer->numsegs == 1 || !buf->isplaying)
 144                     continue;
 145
 146                 alGetSourcei(buf->source, AL_SOURCE_STATE, &state);
 147                 alGetSourcei(buf->source, AL_BUFFERS_QUEUED, &queued);
 148                 alGetSourcei(buf->source, AL_BUFFERS_PROCESSED, &done);
 149
 150                 queued -= done;
 151                 while(done--)
 152                     alSourceUnqueueBuffers(buf->source, 1, &which);
 153                 while(queued < QBUFFERS)
 154                 {
 155                     which = buf->buffer->buffers[buf->curidx];
 156                     ofs = buf->curidx*buf->buffer->segsize;
 157                     if(buf->curidx < buf->buffer->numsegs-1)
 158                         alBufferData(which, buf->buffer->buf_format,
 159                                      buf->buffer->data + ofs, buf->buffer->segsize,
 160                                      buf->buffer->format.Format.nSamplesPerSec);
 161                     else
 162                         alBufferData(which, buf->buffer->buf_format,
 163                                      buf->buffer->data + ofs, buf->buffer->lastsegsize,
 164                                      buf->buffer->format.Format.nSamplesPerSec);
 165
 166                     alSourceQueueBuffers(buf->source, 1, &which);
 167                     buf->curidx = (buf->curidx+1)%buf->buffer->numsegs;
 168                     queued++;
 169
 170                     if(!buf->curidx && !buf->islooping)
 171                     {
 172                         buf->isplaying = FALSE;
 173                         break;
 174                     }
 175                 }
 176                 if(state != AL_PLAYING)
 177                 {
 178                     if(!queued)
 179                     {
 180                         IDirectSoundBuffer8_Stop(&buf->IDirectSoundBuffer8_iface);
 181                         continue;
 182                     }
 183                     alSourcePlay(buf->source);
 184                 }
 185             }
 186             checkALError();
 187         }
 188
 189         for(i = 0;i < prim->nnotifies;)
 190         {
 191             DS8Buffer *buf = prim->notifies[i];
 192             IDirectSoundBuffer8 *dsb = &buf->IDirectSoundBuffer8_iface;
 193             DWORD status=0, curpos=buf->lastpos;
 194
 195             IDirectSoundBuffer8_GetStatus(dsb, &status);
 196             IDirectSoundBuffer8_GetCurrentPosition(dsb, &curpos, NULL);
 197             if(buf->lastpos != curpos)
 198             {
 199                 trigger_elapsed_notifies(buf, buf->lastpos, curpos);
 200                 buf->lastpos = curpos;
 201             }
 202             if(!(status&DSBSTATUS_PLAYING))
 203             {
 204                 /* Remove this buffer from list and put another at the
 205                  * current position; don't increment i
 206                  */
 207                 trigger_stop_notifies(buf);
 208                 prim->notifies[i] = prim->notifies[--prim->nnotifies];
 209                 continue;
 210             }
 211             i++;
 212         }
 213         popALContext();
 214         LeaveCriticalSection(&prim->crst);
 215     }
 216     return 0;
 217 }
 218
 219
 220 HRESULT DS8Primary_Create(DS8Primary **ppv, DS8Impl *parent)
 221 {
 222     HRESULT hr = DSERR_OUTOFMEMORY;
 223     DS8Primary *This = NULL;
 224     DS3DLISTENER *listener;
 225     WAVEFORMATEX *wfx;
 226     ALuint srcs[256];
 227     DWORD nsources;
 228
 229     *ppv = NULL;
 230     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 231     if(!This) return hr;
 232
 233     This->IDirectSoundBuffer_iface.lpVtbl = (IDirectSoundBufferVtbl*)&DS8Primary_Vtbl;
 234     This->IDirectSound3DListener_iface.lpVtbl = (IDirectSound3DListenerVtbl*)&DS8Primary3D_Vtbl;
 235     This->IKsPropertySet_iface.lpVtbl = (IKsPropertySetVtbl*)&DS8PrimaryProp_Vtbl;
 236
 237     InitializeCriticalSection(&This->crst);
 238     This->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DS8Primary.crst");
 239
 240     /* Allocate enough for a WAVEFORMATEXTENSIBLE */
 241     wfx = &This->format.Format;
 242
 243     hr = DSERR_NODRIVER;
 244     This->ctx = alcCreateContext(parent->device, NULL);
 245     if(!This->ctx)
 246     {
 247         ALCenum err = alcGetError(parent->device);
 248         ERR("Could not create context (0x%x)!\n", err);
 249         goto fail;
 250     }
 251
 252     setALContext(This->ctx);
 253     if(alIsExtensionPresent("AL_EXT_FLOAT32"))
 254     {
 255         TRACE("Found AL_EXT_FLOAT32\n");
 256         This->SupportedExt[EXT_FLOAT32] = AL_TRUE;
 257     }
 258     if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
 259     {
 260         TRACE("Found AL_EXT_MCFORMATS\n");
 261         This->SupportedExt[EXT_MCFORMATS] = AL_TRUE;
 262     }
 263     if(alIsExtensionPresent("AL_EXT_STATIC_BUFFER"))
 264     {
 265         TRACE("Found AL_EXT_STATIC_BUFFER\n");
 266         This->ExtAL.BufferDataStatic = alGetProcAddress("alBufferDataStatic");
 267         This->SupportedExt[EXT_STATIC_BUFFER] = AL_TRUE;
 268     }
 269     if(alIsExtensionPresent("AL_SOFTX_buffer_samples"))
 270     {
 271         TRACE("Found AL_SOFTX_buffer_samples\n");
 272         This->ExtAL.BufferSamplesSOFT = alGetProcAddress("alBufferSamplesSOFT");
 273         This->ExtAL.BufferSubSamplesSOFT = alGetProcAddress("alBufferSubSamplesSOFT");
 274         This->ExtAL.GetBufferSamplesSOFT = alGetProcAddress("alGetBufferSamplesSOFT");
 275         This->ExtAL.IsBufferFormatSupportedSOFT = alGetProcAddress("alIsBufferFormatSupportedSOFT");
 276         This->SupportedExt[SOFT_BUFFER_SAMPLES] = AL_TRUE;
 277     }
 278     if(alIsExtensionPresent("AL_SOFT_buffer_sub_data"))
 279     {
 280         TRACE("Found AL_SOFT_buffer_sub_data\n");
 281         This->ExtAL.BufferSubData = alGetProcAddress("alBufferSubDataSOFT");
 282         This->SupportedExt[SOFT_BUFFER_SUB_DATA] = AL_TRUE;
 283     }
 284     if(alIsExtensionPresent("AL_SOFTX_deferred_updates"))
 285     {
 286         TRACE("Found AL_SOFTX_deferred_updates\n");
 287         This->ExtAL.DeferUpdatesSOFT = alGetProcAddress("alDeferUpdatesSOFT");
 288         This->ExtAL.ProcessUpdatesSOFT = alGetProcAddress("alProcessUpdatesSOFT");
 289         This->SupportedExt[SOFT_DEFERRED_UPDATES] = AL_TRUE;
 290     }
 291
 292     if(alcIsExtensionPresent(parent->device, "ALC_EXT_EFX"))
 293     {
 294 #define LOAD_FUNC(x) (This->ExtAL.x = alGetProcAddress("al"#x))
 295         LOAD_FUNC(GenEffects);
 296         LOAD_FUNC(DeleteEffects);
 297         LOAD_FUNC(Effecti);
 298         LOAD_FUNC(Effectf);
 299
 300         LOAD_FUNC(GenAuxiliaryEffectSlots);
 301         LOAD_FUNC(DeleteAuxiliaryEffectSlots);
 302         LOAD_FUNC(AuxiliaryEffectSloti);
 303 #undef LOAD_FUNC
 304         This->SupportedExt[EXT_EFX] = AL_TRUE;
 305
 306         This->ExtAL.GenEffects(1, &This->effect);
 307         This->ExtAL.Effecti(This->effect, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
 308
 309         This->ExtAL.GenAuxiliaryEffectSlots(1, &This->auxslot);
 310     }
 311     This->eax_prop = EnvironmentDefaults[EAX_ENVIRONMENT_GENERIC];
 312
 313     wfx->wFormatTag = WAVE_FORMAT_PCM;
 314     wfx->nChannels = 2;
 315     wfx->wBitsPerSample = 8;
 316     wfx->nSamplesPerSec = 22050;
 317     wfx->nBlockAlign = wfx->wBitsPerSample * wfx->nChannels / 8;
 318     wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign;
 319     wfx->cbSize = 0;
 320
 321     This->stopped = TRUE;
 322     This->parent = parent;
 323     /* Apparently primary buffer size is always 32k,
 324      * tested on windows with 192k 24 bits sound @ 6 channels
 325      * where it will run out in 60 ms and it isn't pointer aligned
 326      */
 327     This->buf_size = 32768;
 328
 329     if(!This->SupportedExt[SOFT_BUFFER_SUB_DATA] &&
 330        !This->SupportedExt[SOFT_BUFFER_SAMPLES] &&
 331        !This->SupportedExt[EXT_STATIC_BUFFER])
 332     {
 333         ERR("Missing alBufferSubDataSOFT, alBufferSamplesSOFT , and alBufferDataStatic on device '%s', sound playback quality may be degraded\n",
 334              alcGetString(parent->device, ALC_DEVICE_SPECIFIER));
 335         ERR("Please consider using OpenAL-Soft\n");
 336     }
 337
 338     if(This->SupportedExt[SOFT_DEFERRED_UPDATES])
 339     {
 340         This->DeferUpdates = This->ExtAL.DeferUpdatesSOFT;
 341         This->ProcessUpdates = This->ExtAL.ProcessUpdatesSOFT;
 342     }
 343     else
 344     {
 345         This->DeferUpdates = wrap_DeferUpdates;
 346         This->ProcessUpdates = wrap_ProcessUpdates;
 347     }
 348
 349     /* Make sure DS3DListener defaults are applied to OpenAL */
 350     listener = &This->listen;
 351     listener->dwSize = sizeof(*listener);
 352     listener->vPosition.x = 0.0;
 353     listener->vPosition.y = 0.0;
 354     listener->vPosition.z = 0.0;
 355     listener->vVelocity.x = 0.0;
 356     listener->vVelocity.y = 0.0;
 357     listener->vVelocity.z = 0.0;
 358     listener->vOrientFront.x = 0.0;
 359     listener->vOrientFront.y = 0.0;
 360     listener->vOrientFront.z = 1.0;
 361     listener->vOrientTop.x = 0.0;
 362     listener->vOrientTop.y = 1.0;
 363     listener->vOrientTop.z = 0.0;
 364     listener->flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
 365     listener->flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
 366     listener->flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
 367     hr = IDirectSound3DListener_SetAllParameters(&This->IDirectSound3DListener_iface, listener, DS3D_IMMEDIATE);
 368     if(FAILED(hr))
 369         ERR("Could not set 3d parameters: %08"LONGFMT"x\n", hr);
 370
 371     for(nsources = 0;nsources < sizeof(srcs)/sizeof(*srcs);nsources++)
 372     {
 373         alGenSources(1, &srcs[nsources]);
 374         if(alGetError() != AL_NO_ERROR)
 375             break;
 376     }
 377     alDeleteSources(nsources, srcs);
 378     checkALError();
 379
 380     popALContext();
 381
 382     This->max_sources = nsources;
 383     This->sizenotifies = This->sizebuffers = This->sizesources = nsources+1;
 384
 385     hr = DSERR_OUTOFMEMORY;
 386     This->sources = HeapAlloc(GetProcessHeap(), 0, nsources*sizeof(*This->sources));
 387     This->buffers = HeapAlloc(GetProcessHeap(), 0, nsources*sizeof(*This->buffers));
 388     This->notifies = HeapAlloc(GetProcessHeap(), 0, nsources*sizeof(*This->notifies));
 389     if(!This->sources || !This->buffers || !This->notifies)
 390         goto fail;
 391
 392     This->thread_hdl = CreateThread(NULL, 0, ThreadProc, This, 0, &This->thread_id);
 393     if(This->thread_hdl == NULL)
 394         goto fail;
 395
 396     *ppv = This;
 397     return S_OK;
 398
 399 fail:
 400     DS8Primary_Destroy(This);
 401     return hr;
 402 }
 403
 404 void DS8Primary_Destroy(DS8Primary *This)
 405 {
 406     TRACE("Destroying primary %p\n", This);
 407
 408     if(This->timer_id)
 409     {
 410         timeKillEvent(This->timer_id);
 411         timeEndPeriod(This->timer_res);
 412         TRACE("Killed timer\n");
 413     }
 414     if(This->thread_hdl)
 415     {
 416         PostThreadMessageA(This->thread_id, WM_QUIT, 0, 0);
 417         if(WaitForSingleObject(This->thread_hdl, 1000) != WAIT_OBJECT_0)
 418             ERR("Thread wait timed out");
 419         CloseHandle(This->thread_hdl);
 420     }
 421
 422     if(This->ctx)
 423     {
 424         /* Calling setALContext is not appropriate here,
 425          * since we *have* to unset the context before destroying it
 426          */
 427         ALCcontext *old_ctx;
 428
 429         EnterCriticalSection(&This->crst);
 430         EnterCriticalSection(&openal_crst);
 431         old_ctx = get_context();
 432         if(old_ctx != This->ctx)
 433             set_context(This->ctx);
 434         else
 435             old_ctx = NULL;
 436
 437         while(This->nbuffers--)
 438             DS8Buffer_Destroy(This->buffers[This->nbuffers]);
 439
 440         if(This->nsources)
 441             alDeleteSources(This->nsources, This->sources);
 442
 443         if(This->effect)
 444             This->ExtAL.DeleteEffects(1, &This->effect);
 445         if(This->auxslot)
 446             This->ExtAL.DeleteAuxiliaryEffectSlots(1, &This->auxslot);
 447
 448         HeapFree(GetProcessHeap(), 0, This->sources);
 449         HeapFree(GetProcessHeap(), 0, This->notifies);
 450         HeapFree(GetProcessHeap(), 0, This->buffers);
 451
 452         set_context(old_ctx);
 453         alcDestroyContext(This->ctx);
 454         LeaveCriticalSection(&openal_crst);
 455         LeaveCriticalSection(&This->crst);
 456     }
 457
 458     This->crst.DebugInfo->Spare[0] = 0;
 459     DeleteCriticalSection(&This->crst);
 460
 461     HeapFree(GetProcessHeap(), 0, This);
 462 }
 463
 464 static inline DS8Primary *impl_from_IDirectSoundBuffer(IDirectSoundBuffer *iface)
 465 {
 466     return CONTAINING_RECORD(iface, DS8Primary, IDirectSoundBuffer_iface);
 467 }
 468
 469 static HRESULT WINAPI DS8Primary_QueryInterface(IDirectSoundBuffer *iface, REFIID riid, LPVOID *ppv)
 470 {
 471     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 472
 473     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 474
 475     *ppv = NULL;
 476     if(IsEqualIID(riid, &IID_IUnknown) ||
 477        IsEqualIID(riid, &IID_IDirectSoundBuffer))
 478         *ppv = &This->IDirectSoundBuffer_iface;
 479     else if(IsEqualIID(riid, &IID_IDirectSound3DListener))
 480     {
 481         if((This->flags&DSBCAPS_CTRL3D))
 482             *ppv = &This->IDirectSound3DListener_iface;
 483     }
 484     else
 485         FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
 486
 487     if(*ppv)
 488     {
 489         IUnknown_AddRef((IUnknown*)*ppv);
 490         return S_OK;
 491     }
 492
 493     return E_NOINTERFACE;
 494 }
 495
 496 static ULONG WINAPI DS8Primary_AddRef(IDirectSoundBuffer *iface)
 497 {
 498     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 499     LONG ret;
 500
 501     ret = InterlockedIncrement(&This->ref);
 502     if(ret == 1) This->flags = 0;
 503
 504     return ret;
 505 }
 506
 507 static ULONG WINAPI DS8Primary_Release(IDirectSoundBuffer *iface)
 508 {
 509     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 510     LONG ret;
 511
 512     ret = InterlockedDecrement(&This->ref);
 513
 514     return ret;
 515 }
 516
 517 static HRESULT WINAPI DS8Primary_GetCaps(IDirectSoundBuffer *iface, DSBCAPS *caps)
 518 {
 519     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 520
 521     TRACE("(%p)->(%p)\n", iface, caps);
 522
 523     if(!caps || caps->dwSize < sizeof(*caps))
 524     {
 525         WARN("Invalid DSBCAPS (%p, %"LONGFMT"u)\n", caps, caps ? caps->dwSize : 0);
 526         return DSERR_INVALIDPARAM;
 527     }
 528
 529     EnterCriticalSection(&This->crst);
 530     caps->dwFlags = This->flags;
 531     caps->dwBufferBytes = This->buf_size;
 532     caps->dwUnlockTransferRate = 0;
 533     caps->dwPlayCpuOverhead = 0;
 534     LeaveCriticalSection(&This->crst);
 535
 536     return DS_OK;
 537 }
 538
 539 static HRESULT WINAPI DS8Primary_GetCurrentPosition(IDirectSoundBuffer *iface, DWORD *playpos, DWORD *curpos)
 540 {
 541     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 542     HRESULT hr = DSERR_PRIOLEVELNEEDED;
 543
 544     EnterCriticalSection(&This->crst);
 545     if(This->write_emu)
 546         hr = IDirectSoundBuffer8_GetCurrentPosition(This->write_emu, playpos, curpos);
 547     LeaveCriticalSection(&This->crst);
 548
 549     return hr;
 550 }
 551
 552 static HRESULT WINAPI DS8Primary_GetFormat(IDirectSoundBuffer *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
 553 {
 554     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 555     HRESULT hr = S_OK;
 556     UINT size;
 557
 558     if(!wfx && !written)
 559     {
 560         WARN("Cannot report format or format size\n");
 561         return DSERR_INVALIDPARAM;
 562     }
 563
 564     EnterCriticalSection(&This->crst);
 565     size = sizeof(This->format.Format) + This->format.Format.cbSize;
 566     if(written)
 567         *written = size;
 568     if(wfx)
 569     {
 570         if(allocated < size)
 571             hr = DSERR_INVALIDPARAM;
 572         else
 573             memcpy(wfx, &This->format.Format, size);
 574     }
 575     LeaveCriticalSection(&This->crst);
 576
 577     return hr;
 578 }
 579
 580 static HRESULT WINAPI DS8Primary_GetVolume(IDirectSoundBuffer *iface, LONG *volume)
 581 {
 582     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 583     HRESULT hr = S_OK;
 584
 585     TRACE("(%p)->(%p)\n", iface, volume);
 586
 587     if(!volume)
 588         return DSERR_INVALIDPARAM;
 589
 590     EnterCriticalSection(&This->crst);
 591     if(!(This->flags & DSBCAPS_CTRLVOLUME))
 592         hr = DSERR_CONTROLUNAVAIL;
 593     else
 594     {
 595         ALfloat gain;
 596
 597         setALContext(This->ctx);
 598         alGetListenerf(AL_GAIN, &gain);
 599         checkALError();
 600         popALContext();
 601
 602         *volume = clampI(gain_to_mB(gain), DSBVOLUME_MIN, DSBVOLUME_MAX);
 603     }
 604     LeaveCriticalSection(&This->crst);
 605
 606     return hr;
 607 }
 608
 609 static HRESULT WINAPI DS8Primary_GetPan(IDirectSoundBuffer *iface, LONG *pan)
 610 {
 611     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 612     HRESULT hr = S_OK;
 613
 614     WARN("(%p)->(%p): semi-stub\n", iface, pan);
 615
 616     if(!pan)
 617         return DSERR_INVALIDPARAM;
 618
 619     EnterCriticalSection(&This->crst);
 620     if(This->write_emu)
 621         hr = IDirectSoundBuffer8_GetPan(This->write_emu, pan);
 622     else if(!(This->flags & DSBCAPS_CTRLPAN))
 623         hr = DSERR_CONTROLUNAVAIL;
 624     else
 625         *pan = 0;
 626     LeaveCriticalSection(&This->crst);
 627
 628     return hr;
 629 }
 630
 631 static HRESULT WINAPI DS8Primary_GetFrequency(IDirectSoundBuffer *iface, DWORD *freq)
 632 {
 633     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 634     HRESULT hr = S_OK;
 635
 636     WARN("(%p)->(%p): semi-stub\n", iface, freq);
 637
 638     if(!freq)
 639         return DSERR_INVALIDPARAM;
 640
 641     EnterCriticalSection(&This->crst);
 642     if(!(This->flags & DSBCAPS_CTRLFREQUENCY))
 643         hr = DSERR_CONTROLUNAVAIL;
 644     else
 645         *freq = This->format.Format.nSamplesPerSec;
 646     LeaveCriticalSection(&This->crst);
 647
 648     return hr;
 649 }
 650
 651 static HRESULT WINAPI DS8Primary_GetStatus(IDirectSoundBuffer *iface, DWORD *status)
 652 {
 653     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 654
 655     TRACE("(%p)->(%p)\n", iface, status);
 656
 657     if(!status)
 658         return DSERR_INVALIDPARAM;
 659
 660     EnterCriticalSection(&This->crst);
 661
 662     *status = DSBSTATUS_PLAYING|DSBSTATUS_LOOPING;
 663     if((This->flags&DSBCAPS_LOCDEFER))
 664         *status |= DSBSTATUS_LOCHARDWARE;
 665
 666     if(This->stopped)
 667     {
 668         DWORD i, state;
 669         HRESULT hr;
 670
 671         for(i = 0;i < This->nbuffers;++i)
 672         {
 673             hr = IDirectSoundBuffer8_GetStatus(&This->buffers[i]->IDirectSoundBuffer8_iface, &state);
 674             if(SUCCEEDED(hr) && (state&DSBSTATUS_PLAYING))
 675                 break;
 676         }
 677         if(i == This->nbuffers)
 678         {
 679             /* Primary stopped and no buffers playing.. */
 680             *status = 0;
 681         }
 682     }
 683
 684     LeaveCriticalSection(&This->crst);
 685
 686     return S_OK;
 687 }
 688
 689 static HRESULT WINAPI DS8Primary_Initialize(IDirectSoundBuffer *iface, IDirectSound *ds, const DSBUFFERDESC *desc)
 690 {
 691     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 692     HRESULT hr = S_OK;
 693
 694     TRACE("(%p)->(%p, %p)\n", iface, ds, desc);
 695
 696     if(!desc || desc->lpwfxFormat || desc->dwBufferBytes)
 697     {
 698         WARN("Bad DSBDESC for primary buffer\n");
 699         return DSERR_INVALIDPARAM;
 700     }
 701     if((desc->dwFlags&DSBCAPS_CTRLFX) ||
 702        (desc->dwFlags&DSBCAPS_CTRLPOSITIONNOTIFY) ||
 703        (desc->dwFlags&DSBCAPS_LOCSOFTWARE))
 704     {
 705         WARN("Bad dwFlags %08"LONGFMT"x\n", desc->dwFlags);
 706         return DSERR_INVALIDPARAM;
 707     }
 708
 709     EnterCriticalSection(&This->crst);
 710     /* Should be 0 if not initialized */
 711     if(This->flags)
 712     {
 713         hr = DSERR_ALREADYINITIALIZED;
 714         goto out;
 715     }
 716
 717     if(This->parent->prio_level == DSSCL_WRITEPRIMARY)
 718     {
 719         DSBUFFERDESC emudesc;
 720         DS8Buffer *emu;
 721
 722         if(This->write_emu)
 723         {
 724             ERR("There shouldn't be a write_emu!\n");
 725             IDirectSoundBuffer8_Release(This->write_emu);
 726             This->write_emu = NULL;
 727         }
 728
 729         memset(&emudesc, 0, sizeof(emudesc));
 730         emudesc.dwSize = sizeof(emudesc);
 731         emudesc.dwFlags = DSBCAPS_LOCHARDWARE | (desc->dwFlags&DSBCAPS_CTRLPAN);
 732         /* Dont play last incomplete sample */
 733         emudesc.dwBufferBytes = This->buf_size - (This->buf_size%This->format.Format.nBlockAlign);
 734         emudesc.lpwfxFormat = &This->format.Format;
 735
 736         hr = DS8Buffer_Create(&emu, This, NULL);
 737         if(SUCCEEDED(hr))
 738         {
 739             This->write_emu = &emu->IDirectSoundBuffer8_iface;
 740             hr = IDirectSoundBuffer8_Initialize(This->write_emu, ds, &emudesc);
 741             if(FAILED(hr))
 742             {
 743                 IDirectSoundBuffer8_Release(This->write_emu);
 744                 This->write_emu = NULL;
 745             }
 746         }
 747     }
 748
 749     if(SUCCEEDED(hr))
 750         This->flags = desc->dwFlags | DSBCAPS_LOCHARDWARE;
 751 out:
 752     LeaveCriticalSection(&This->crst);
 753     return hr;
 754 }
 755
 756 static HRESULT WINAPI DS8Primary_Lock(IDirectSoundBuffer *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
 757 {
 758     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 759     HRESULT hr = DSERR_PRIOLEVELNEEDED;
 760
 761     TRACE("(%p)->(%"LONGFMT"u, %"LONGFMT"u, %p, %p, %p, %p, %"LONGFMT"u)\n", iface, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 762
 763     EnterCriticalSection(&This->crst);
 764     if(This->write_emu)
 765         hr = IDirectSoundBuffer8_Lock(This->write_emu, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 766     LeaveCriticalSection(&This->crst);
 767
 768     return hr;
 769 }
 770
 771 static HRESULT WINAPI DS8Primary_Play(IDirectSoundBuffer *iface, DWORD res1, DWORD res2, DWORD flags)
 772 {
 773     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 774     HRESULT hr;
 775
 776     TRACE("(%p)->(%"LONGFMT"u, %"LONGFMT"u, %"LONGFMT"u)\n", iface, res1, res2, flags);
 777
 778     if(!(flags & DSBPLAY_LOOPING))
 779     {
 780         WARN("Flags (%08"LONGFMT"x) not set to DSBPLAY_LOOPING\n", flags);
 781         return DSERR_INVALIDPARAM;
 782     }
 783
 784     EnterCriticalSection(&This->crst);
 785     hr = S_OK;
 786     if(This->write_emu)
 787         hr = IDirectSoundBuffer8_Play(This->write_emu, res1, res2, flags);
 788     if(SUCCEEDED(hr))
 789         This->stopped = FALSE;
 790     LeaveCriticalSection(&This->crst);
 791
 792     return hr;
 793 }
 794
 795 static HRESULT WINAPI DS8Primary_SetCurrentPosition(IDirectSoundBuffer *iface, DWORD pos)
 796 {
 797     WARN("(%p)->(%"LONGFMT"u)\n", iface, pos);
 798     return DSERR_INVALIDCALL;
 799 }
 800
 801 /* Just assume the format is crap, and clean up the damage */
 802 static void copy_waveformat(WAVEFORMATEX *wfx, const WAVEFORMATEX *from)
 803 {
 804     if(from->wFormatTag == WAVE_FORMAT_PCM)
 805     {
 806         wfx->cbSize = 0;
 807         if(from->wBitsPerSample == 8 ||
 808            from->wBitsPerSample == 16 ||
 809            from->wBitsPerSample == 24 ||
 810            from->wBitsPerSample == 32)
 811             wfx->wBitsPerSample = from->wBitsPerSample;
 812     }
 813     else if(from->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 814     {
 815         WAVEFORMATEXTENSIBLE *wfe = (WAVEFORMATEXTENSIBLE*)wfx;
 816         const WAVEFORMATEXTENSIBLE *fromx = (const WAVEFORMATEXTENSIBLE*)from;
 817         DWORD size = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 818
 819         /* Fail silently.. */
 820         if(from->cbSize < size)
 821             return;
 822         if(!fromx->Samples.wValidBitsPerSample &&
 823            !fromx->Format.wBitsPerSample)
 824             return;
 825
 826         if(!IsEqualGUID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM) &&
 827            !IsEqualGUID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
 828         {
 829             ERR("Unhandled extensible format: %s\n", debugstr_guid(&wfe->SubFormat));
 830             return;
 831         }
 832
 833         wfe->Format.wBitsPerSample = from->wBitsPerSample;
 834         wfe->Samples.wValidBitsPerSample = fromx->Samples.wValidBitsPerSample;
 835         if(!wfe->Samples.wValidBitsPerSample)
 836             wfe->Samples.wValidBitsPerSample = wfe->Format.wBitsPerSample;
 837         wfe->Format.cbSize = size;
 838         wfe->dwChannelMask = fromx->dwChannelMask;
 839         wfe->SubFormat = fromx->SubFormat;
 840     }
 841     else
 842     {
 843         ERR("Unhandled format tag %04x\n", from->wFormatTag);
 844         return;
 845     }
 846
 847     if(from->nChannels)
 848         wfx->nChannels = from->nChannels;
 849     wfx->wFormatTag = from->wFormatTag;
 850     if(from->nSamplesPerSec >= DSBFREQUENCY_MIN &&
 851        from->nSamplesPerSec <= DSBFREQUENCY_MAX)
 852         wfx->nSamplesPerSec = from->nSamplesPerSec;
 853     wfx->nBlockAlign = wfx->wBitsPerSample * wfx->nChannels / 8;
 854     wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign;
 855 }
 856
 857 static HRESULT WINAPI DS8Primary_SetFormat(IDirectSoundBuffer *iface, const WAVEFORMATEX *wfx)
 858 {
 859     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 860     HRESULT hr = S_OK;
 861     ALCint freq;
 862
 863     TRACE("(%p)->(%p)\n", iface, wfx);
 864
 865     if(!wfx)
 866     {
 867         WARN("Missing format\n");
 868         return DSERR_INVALIDPARAM;
 869     }
 870
 871     EnterCriticalSection(&This->crst);
 872
 873     if(This->parent->prio_level < DSSCL_PRIORITY)
 874     {
 875         hr = DSERR_PRIOLEVELNEEDED;
 876         goto out;
 877     }
 878
 879     TRACE("Requested primary format:\n"
 880           "    FormatTag      = %04x\n"
 881           "    Channels       = %u\n"
 882           "    SamplesPerSec  = %"LONGFMT"u\n"
 883           "    AvgBytesPerSec = %"LONGFMT"u\n"
 884           "    BlockAlign     = %u\n"
 885           "    BitsPerSample  = %u\n",
 886           wfx->wFormatTag, wfx->nChannels,
 887           wfx->nSamplesPerSec, wfx->nAvgBytesPerSec,
 888           wfx->nBlockAlign, wfx->wBitsPerSample);
 889
 890     copy_waveformat(&This->format.Format, wfx);
 891
 892     freq = This->format.Format.nSamplesPerSec;
 893     alcGetIntegerv(This->parent->device, ALC_FREQUENCY, 1, &freq);
 894     checkALCError(This->parent->device);
 895
 896     This->format.Format.nSamplesPerSec = freq;
 897     This->format.Format.nAvgBytesPerSec = This->format.Format.nBlockAlign *
 898                                           This->format.Format.nSamplesPerSec;
 899
 900     if(This->write_emu)
 901     {
 902         DS8Buffer *buf;
 903         DSBUFFERDESC desc;
 904
 905         memset(&desc, 0, sizeof(desc));
 906         desc.dwSize = sizeof(desc);
 907         desc.dwFlags = DSBCAPS_LOCHARDWARE|DSBCAPS_CTRLPAN;
 908         desc.dwBufferBytes = This->buf_size - (This->buf_size % This->format.Format.nBlockAlign);
 909         desc.lpwfxFormat = &This->format.Format;
 910
 911         hr = DS8Buffer_Create(&buf, This, NULL);
 912         if(FAILED(hr))
 913             goto out;
 914
 915         hr = IDirectSoundBuffer8_Initialize(&buf->IDirectSoundBuffer8_iface, &This->parent->IDirectSound_iface, &desc);
 916         if(FAILED(hr))
 917             DS8Buffer_Destroy(buf);
 918         else
 919         {
 920             IDirectSoundBuffer8_Release(This->write_emu);
 921             This->write_emu = &buf->IDirectSoundBuffer8_iface;
 922         }
 923     }
 924
 925 out:
 926     LeaveCriticalSection(&This->crst);
 927     return hr;
 928 }
 929
 930 static HRESULT WINAPI DS8Primary_SetVolume(IDirectSoundBuffer *iface, LONG vol)
 931 {
 932     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 933     HRESULT hr = S_OK;
 934
 935     TRACE("(%p)->(%"LONGFMT"d)\n", iface, vol);
 936
 937     if(vol > DSBVOLUME_MAX || vol < DSBVOLUME_MIN)
 938     {
 939         WARN("Invalid volume (%"LONGFMT"d)\n", vol);
 940         return DSERR_INVALIDPARAM;
 941     }
 942
 943     EnterCriticalSection(&This->crst);
 944     if(!(This->flags&DSBCAPS_CTRLVOLUME))
 945         hr = DSERR_CONTROLUNAVAIL;
 946     if(SUCCEEDED(hr))
 947     {
 948         setALContext(This->ctx);
 949         alListenerf(AL_GAIN, mB_to_gain(vol));
 950         popALContext();
 951     }
 952     LeaveCriticalSection(&This->crst);
 953
 954     return hr;
 955 }
 956
 957 static HRESULT WINAPI DS8Primary_SetPan(IDirectSoundBuffer *iface, LONG pan)
 958 {
 959     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 960     HRESULT hr;
 961
 962     TRACE("(%p)->(%"LONGFMT"d)\n", iface, pan);
 963
 964     if(pan > DSBPAN_RIGHT || pan < DSBPAN_LEFT)
 965     {
 966         WARN("invalid parameter: pan = %"LONGFMT"d\n", pan);
 967         return DSERR_INVALIDPARAM;
 968     }
 969
 970     EnterCriticalSection(&This->crst);
 971     if(!(This->flags&DSBCAPS_CTRLPAN))
 972     {
 973         WARN("control unavailable\n");
 974         hr = DSERR_CONTROLUNAVAIL;
 975     }
 976     else if(This->write_emu)
 977         hr = IDirectSoundBuffer8_SetPan(This->write_emu, pan);
 978     else
 979     {
 980         FIXME("Not supported\n");
 981         hr = E_NOTIMPL;
 982     }
 983     LeaveCriticalSection(&This->crst);
 984
 985     return hr;
 986 }
 987
 988 static HRESULT WINAPI DS8Primary_SetFrequency(IDirectSoundBuffer *iface, DWORD freq)
 989 {
 990     WARN("(%p)->(%"LONGFMT"u)\n", iface, freq);
 991     return DSERR_CONTROLUNAVAIL;
 992 }
 993
 994 static HRESULT WINAPI DS8Primary_Stop(IDirectSoundBuffer *iface)
 995 {
 996     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
 997     HRESULT hr = S_OK;
 998
 999     TRACE("(%p)->()\n", iface);
1000
1001     EnterCriticalSection(&This->crst);
1002     if(This->write_emu)
1003         hr = IDirectSoundBuffer8_Stop(This->write_emu);
1004     if(SUCCEEDED(hr))
1005         This->stopped = TRUE;
1006     LeaveCriticalSection(&This->crst);
1007
1008     return hr;
1009 }
1010
1011 static HRESULT WINAPI DS8Primary_Unlock(IDirectSoundBuffer *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
1012 {
1013     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
1014     HRESULT hr = DSERR_INVALIDCALL;
1015
1016     TRACE("(%p)->(%p, %"LONGFMT"u, %p, %"LONGFMT"u)\n", iface, ptr1, len1, ptr2, len2);
1017
1018     EnterCriticalSection(&This->crst);
1019     if(This->write_emu)
1020         hr = IDirectSoundBuffer8_Unlock(This->write_emu, ptr1, len1, ptr2, len2);
1021     LeaveCriticalSection(&This->crst);
1022
1023     return hr;
1024 }
1025
1026 static HRESULT WINAPI DS8Primary_Restore(IDirectSoundBuffer *iface)
1027 {
1028     DS8Primary *This = impl_from_IDirectSoundBuffer(iface);
1029     HRESULT hr = S_OK;
1030
1031     TRACE("(%p)->()\n", iface);
1032
1033     EnterCriticalSection(&This->crst);
1034     if(This->write_emu)
1035         hr = IDirectSoundBuffer8_Restore(This->write_emu);
1036     LeaveCriticalSection(&This->crst);
1037
1038     return hr;
1039 }
1040
1041 static const IDirectSoundBufferVtbl DS8Primary_Vtbl =
1042 {
1043     DS8Primary_QueryInterface,
1044     DS8Primary_AddRef,
1045     DS8Primary_Release,
1046     DS8Primary_GetCaps,
1047     DS8Primary_GetCurrentPosition,
1048     DS8Primary_GetFormat,
1049     DS8Primary_GetVolume,
1050     DS8Primary_GetPan,
1051     DS8Primary_GetFrequency,
1052     DS8Primary_GetStatus,
1053     DS8Primary_Initialize,
1054     DS8Primary_Lock,
1055     DS8Primary_Play,
1056     DS8Primary_SetCurrentPosition,
1057     DS8Primary_SetFormat,
1058     DS8Primary_SetVolume,
1059     DS8Primary_SetPan,
1060     DS8Primary_SetFrequency,
1061     DS8Primary_Stop,
1062     DS8Primary_Unlock,
1063     DS8Primary_Restore
1064 };
1065
1066 static inline DS8Primary *impl_from_IDirectSound3DListener(IDirectSound3DListener *iface)
1067 {
1068     return CONTAINING_RECORD(iface, DS8Primary, IDirectSound3DListener_iface);
1069 }
1070
1071 static HRESULT WINAPI DS8Primary3D_QueryInterface(IDirectSound3DListener *iface, REFIID riid, void **ppv)
1072 {
1073     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1074     return DS8Primary_QueryInterface(&This->IDirectSoundBuffer_iface, riid, ppv);
1075 }
1076
1077 static ULONG WINAPI DS8Primary3D_AddRef(IDirectSound3DListener *iface)
1078 {
1079     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1080     LONG ret;
1081
1082     ret = InterlockedIncrement(&This->ds3d_ref);
1083     TRACE("new refcount %"LONGFMT"d\n", ret);
1084
1085     return ret;
1086 }
1087
1088
1089 /* Considering the primary buffer doesn't get destroyed
1090  * it doesn't make sense to destroy ds3d here
1091  */
1092 static ULONG WINAPI DS8Primary3D_Release(IDirectSound3DListener *iface)
1093 {
1094     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1095     LONG ret;
1096
1097     ret = InterlockedDecrement(&This->ds3d_ref);
1098     TRACE("new refcount %"LONGFMT"d\n", ret);
1099
1100     return ret;
1101 }
1102
1103
1104 static HRESULT WINAPI DS8Primary3D_GetAllParameters(IDirectSound3DListener *iface, DS3DLISTENER *listener)
1105 {
1106     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1107
1108     TRACE("(%p)->(%p)\n", iface, listener);
1109
1110     if(!listener || listener->dwSize < sizeof(*listener))
1111     {
1112         WARN("Invalid DS3DLISTENER %p %"LONGFMT"u\n", listener, listener ? listener->dwSize : 0);
1113         return DSERR_INVALIDPARAM;
1114     }
1115
1116     EnterCriticalSection(&This->crst);
1117     setALContext(This->ctx);
1118     IDirectSound3DListener_GetPosition(iface, &listener->vPosition);
1119     IDirectSound3DListener_GetVelocity(iface, &listener->vVelocity);
1120     IDirectSound3DListener_GetOrientation(iface, &listener->vOrientFront, &listener->vOrientTop);
1121     IDirectSound3DListener_GetDistanceFactor(iface, &listener->flDistanceFactor);
1122     IDirectSound3DListener_GetRolloffFactor(iface, &listener->flRolloffFactor);
1123     IDirectSound3DListener_GetRolloffFactor(iface, &listener->flDopplerFactor);
1124     popALContext();
1125     LeaveCriticalSection(&This->crst);
1126
1127     return DS_OK;
1128 }
1129
1130 static HRESULT WINAPI DS8Primary3D_GetDistanceFactor(IDirectSound3DListener *iface, D3DVALUE *distancefactor)
1131 {
1132     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1133
1134     TRACE("(%p)->(%p)\n", iface, distancefactor);
1135
1136     if(!distancefactor)
1137     {
1138         WARN("Invalid parameter %p\n", distancefactor);
1139         return DSERR_INVALIDPARAM;
1140     }
1141
1142     EnterCriticalSection(&This->crst);
1143     setALContext(This->ctx);
1144
1145     *distancefactor = 343.3f/alGetFloat(AL_SPEED_OF_SOUND);
1146     checkALError();
1147
1148     popALContext();
1149     LeaveCriticalSection(&This->crst);
1150
1151     return S_OK;
1152 }
1153
1154 static HRESULT WINAPI DS8Primary3D_GetDopplerFactor(IDirectSound3DListener *iface, D3DVALUE *dopplerfactor)
1155 {
1156     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1157
1158     TRACE("(%p)->(%p)\n", iface, dopplerfactor);
1159
1160     if(!dopplerfactor)
1161     {
1162         WARN("Invalid parameter %p\n", dopplerfactor);
1163         return DSERR_INVALIDPARAM;
1164     }
1165
1166     EnterCriticalSection(&This->crst);
1167     setALContext(This->ctx);
1168
1169     *dopplerfactor = alGetFloat(AL_DOPPLER_FACTOR);
1170     checkALError();
1171
1172     popALContext();
1173     LeaveCriticalSection(&This->crst);
1174
1175     return S_OK;
1176 }
1177
1178 static HRESULT WINAPI DS8Primary3D_GetOrientation(IDirectSound3DListener *iface, D3DVECTOR *front, D3DVECTOR *top)
1179 {
1180     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1181     ALfloat orient[6];
1182
1183     TRACE("(%p)->(%p, %p)\n", iface, front, top);
1184
1185     if(!front || !top)
1186     {
1187         WARN("Invalid parameter %p %p\n", front, top);
1188         return DSERR_INVALIDPARAM;
1189     }
1190
1191     EnterCriticalSection(&This->crst);
1192     setALContext(This->ctx);
1193
1194     alGetListenerfv(AL_ORIENTATION, orient);
1195     checkALError();
1196
1197     front->x =  orient[0];
1198     front->y =  orient[1];
1199     front->z = -orient[2];
1200     top->x =  orient[3];
1201     top->y =  orient[4];
1202     top->z = -orient[5];
1203
1204     popALContext();
1205     LeaveCriticalSection(&This->crst);
1206
1207     return S_OK;
1208 }
1209
1210 static HRESULT WINAPI DS8Primary3D_GetPosition(IDirectSound3DListener *iface, D3DVECTOR *pos)
1211 {
1212     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1213     ALfloat alpos[3];
1214
1215     TRACE("(%p)->(%p)\n", iface, pos);
1216
1217     if(!pos)
1218     {
1219         WARN("Invalid parameter %p\n", pos);
1220         return DSERR_INVALIDPARAM;
1221     }
1222
1223     EnterCriticalSection(&This->crst);
1224     setALContext(This->ctx);
1225
1226     alGetListenerfv(AL_POSITION, alpos);
1227     checkALError();
1228
1229     pos->x =  alpos[0];
1230     pos->y =  alpos[1];
1231     pos->z = -alpos[2];
1232
1233     popALContext();
1234     LeaveCriticalSection(&This->crst);
1235
1236     return S_OK;
1237 }
1238
1239 static HRESULT WINAPI DS8Primary3D_GetRolloffFactor(IDirectSound3DListener *iface, D3DVALUE *rollofffactor)
1240 {
1241     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1242
1243     TRACE("(%p)->(%p)\n", iface, rollofffactor);
1244
1245     if(!rollofffactor)
1246     {
1247         WARN("Invalid parameter %p\n", rollofffactor);
1248         return DSERR_INVALIDPARAM;
1249     }
1250
1251     EnterCriticalSection(&This->crst);
1252     *rollofffactor = This->rollofffactor;
1253     LeaveCriticalSection(&This->crst);
1254
1255     return S_OK;
1256 }
1257
1258 static HRESULT WINAPI DS8Primary3D_GetVelocity(IDirectSound3DListener *iface, D3DVECTOR *velocity)
1259 {
1260     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1261     ALfloat vel[3];
1262
1263     TRACE("(%p)->(%p)\n", iface, velocity);
1264
1265     if(!velocity)
1266     {
1267         WARN("Invalid parameter %p\n", velocity);
1268         return DSERR_INVALIDPARAM;
1269     }
1270
1271     EnterCriticalSection(&This->crst);
1272     setALContext(This->ctx);
1273
1274     alGetListenerfv(AL_VELOCITY, vel);
1275     checkALError();
1276
1277     velocity->x =  vel[0];
1278     velocity->y =  vel[1];
1279     velocity->z = -vel[2];
1280
1281     popALContext();
1282     LeaveCriticalSection(&This->crst);
1283
1284     return S_OK;
1285 }
1286
1287 static HRESULT WINAPI DS8Primary3D_SetAllParameters(IDirectSound3DListener *iface, const DS3DLISTENER *listen, DWORD apply)
1288 {
1289     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1290
1291     TRACE("(%p)->(%p, %"LONGFMT"u)\n", iface, listen, apply);
1292
1293     if(!listen || listen->dwSize < sizeof(*listen))
1294     {
1295         WARN("Invalid parameter %p %"LONGFMT"u\n", listen, listen ? listen->dwSize : 0);
1296         return DSERR_INVALIDPARAM;
1297     }
1298
1299     if(listen->flDistanceFactor > DS3D_MAXDISTANCEFACTOR ||
1300        listen->flDistanceFactor < DS3D_MINDISTANCEFACTOR)
1301     {
1302         WARN("Invalid distance factor (%f)\n", listen->flDistanceFactor);
1303         return DSERR_INVALIDPARAM;
1304     }
1305
1306     if(listen->flDopplerFactor > DS3D_MAXDOPPLERFACTOR ||
1307        listen->flDopplerFactor < DS3D_MINDOPPLERFACTOR)
1308     {
1309         WARN("Invalid doppler factor (%f)\n", listen->flDopplerFactor);
1310         return DSERR_INVALIDPARAM;
1311     }
1312
1313     if(listen->flRolloffFactor < DS3D_MINROLLOFFFACTOR ||
1314        listen->flRolloffFactor > DS3D_MAXROLLOFFFACTOR)
1315     {
1316         WARN("Invalid rolloff factor (%f)\n", listen->flRolloffFactor);
1317         return DSERR_INVALIDPARAM;
1318     }
1319
1320     EnterCriticalSection(&This->crst);
1321     setALContext(This->ctx);
1322     IDirectSound3DListener_SetPosition(iface, listen->vPosition.x, listen->vPosition.y, listen->vPosition.z, apply);
1323     IDirectSound3DListener_SetVelocity(iface, listen->vVelocity.x, listen->vVelocity.y, listen->vVelocity.z, apply);
1324     IDirectSound3DListener_SetOrientation(iface, listen->vOrientFront.x, listen->vOrientFront.y, listen->vOrientFront.z,
1325                                           listen->vOrientTop.x, listen->vOrientTop.y, listen->vOrientTop.z, apply);
1326     IDirectSound3DListener_SetDistanceFactor(iface, listen->flDistanceFactor, apply);
1327     IDirectSound3DListener_SetRolloffFactor(iface, listen->flRolloffFactor, apply);
1328     IDirectSound3DListener_SetDopplerFactor(iface, listen->flDopplerFactor, apply);
1329     popALContext();
1330     LeaveCriticalSection(&This->crst);
1331
1332     return S_OK;
1333 }
1334
1335 static HRESULT WINAPI DS8Primary3D_SetDistanceFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1336 {
1337     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1338
1339     TRACE("(%p)->(%f, %"LONGFMT"u)\n", iface, factor, apply);
1340
1341     if(factor < DS3D_MINDISTANCEFACTOR ||
1342        factor > DS3D_MAXDISTANCEFACTOR)
1343     {
1344         WARN("Invalid parameter %f\n", factor);
1345         return DSERR_INVALIDPARAM;
1346     }
1347
1348     EnterCriticalSection(&This->crst);
1349     if(apply == DS3D_DEFERRED)
1350     {
1351         This->listen.flDistanceFactor = factor;
1352         This->dirty.bit.distancefactor = 1;
1353     }
1354     else
1355     {
1356         setALContext(This->ctx);
1357         alSpeedOfSound(343.3f/factor);
1358         if(This->SupportedExt[EXT_EFX])
1359             alListenerf(AL_METERS_PER_UNIT, factor);
1360         checkALError();
1361         popALContext();
1362     }
1363     LeaveCriticalSection(&This->crst);
1364
1365     return S_OK;
1366 }
1367
1368 static HRESULT WINAPI DS8Primary3D_SetDopplerFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1369 {
1370     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1371
1372     TRACE("(%p)->(%f, %"LONGFMT"u)\n", iface, factor, apply);
1373
1374     if(factor < DS3D_MINDOPPLERFACTOR ||
1375        factor > DS3D_MAXDOPPLERFACTOR)
1376     {
1377         WARN("Invalid parameter %f\n", factor);
1378         return DSERR_INVALIDPARAM;
1379     }
1380
1381     EnterCriticalSection(&This->crst);
1382     if(apply == DS3D_DEFERRED)
1383     {
1384         This->listen.flDopplerFactor = factor;
1385         This->dirty.bit.dopplerfactor = 1;
1386     }
1387     else
1388     {
1389         setALContext(This->ctx);
1390         alDopplerFactor(factor);
1391         checkALError();
1392         popALContext();
1393     }
1394     LeaveCriticalSection(&This->crst);
1395
1396     return S_OK;
1397 }
1398
1399 static HRESULT WINAPI DS8Primary3D_SetOrientation(IDirectSound3DListener *iface, D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront, D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop, DWORD apply)
1400 {
1401     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1402
1403     TRACE("(%p)->(%f, %f, %f, %f, %f, %f, %"LONGFMT"u)\n", iface, xFront, yFront, zFront, xTop, yTop, zTop, apply);
1404
1405     EnterCriticalSection(&This->crst);
1406     if(apply == DS3D_DEFERRED)
1407     {
1408         This->listen.vOrientFront.x = xFront;
1409         This->listen.vOrientFront.y = yFront;
1410         This->listen.vOrientFront.z = zFront;
1411         This->listen.vOrientTop.x = xTop;
1412         This->listen.vOrientTop.y = yTop;
1413         This->listen.vOrientTop.z = zTop;
1414         This->dirty.bit.orientation = 1;
1415     }
1416     else
1417     {
1418         ALfloat orient[6] = {
1419             xFront, yFront, -zFront,
1420             xTop, yTop, -zTop
1421         };
1422         setALContext(This->ctx);
1423         alListenerfv(AL_ORIENTATION, orient);
1424         checkALError();
1425         popALContext();
1426     }
1427     LeaveCriticalSection(&This->crst);
1428
1429     return S_OK;
1430 }
1431
1432 static HRESULT WINAPI DS8Primary3D_SetPosition(IDirectSound3DListener *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
1433 {
1434     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1435
1436     TRACE("(%p)->(%f, %f, %f, %"LONGFMT"u)\n", iface, x, y, z, apply);
1437
1438     EnterCriticalSection(&This->crst);
1439     if(apply == DS3D_DEFERRED)
1440     {
1441         This->listen.vPosition.x = x;
1442         This->listen.vPosition.y = y;
1443         This->listen.vPosition.z = z;
1444         This->dirty.bit.pos = 1;
1445     }
1446     else
1447     {
1448         setALContext(This->ctx);
1449         alListener3f(AL_POSITION, x, y, -z);
1450         checkALError();
1451         popALContext();
1452     }
1453     LeaveCriticalSection(&This->crst);
1454
1455     return S_OK;
1456 }
1457
1458 static HRESULT WINAPI DS8Primary3D_SetRolloffFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1459 {
1460     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1461
1462     TRACE("(%p)->(%f, %"LONGFMT"u)\n", iface, factor, apply);
1463
1464     if(factor < DS3D_MINROLLOFFFACTOR ||
1465        factor > DS3D_MAXROLLOFFFACTOR)
1466     {
1467         WARN("Invalid parameter %f\n", factor);
1468         return DSERR_INVALIDPARAM;
1469     }
1470
1471     EnterCriticalSection(&This->crst);
1472     if(apply == DS3D_DEFERRED)
1473     {
1474         This->listen.flRolloffFactor = factor;
1475         This->dirty.bit.rollofffactor = 1;
1476     }
1477     else
1478     {
1479         DWORD i;
1480
1481         setALContext(This->ctx);
1482         for(i = 0;i < This->nbuffers;++i)
1483         {
1484             if(This->buffers[i]->ds3dmode != DS3DMODE_DISABLE)
1485                 alSourcef(This->buffers[i]->source, AL_ROLLOFF_FACTOR, factor);
1486         }
1487         checkALError();
1488         popALContext();
1489
1490         This->rollofffactor = factor;
1491     }
1492     LeaveCriticalSection(&This->crst);
1493
1494     return S_OK;
1495 }
1496
1497 static HRESULT WINAPI DS8Primary3D_SetVelocity(IDirectSound3DListener *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
1498 {
1499     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1500
1501     TRACE("(%p)->(%f, %f, %f, %"LONGFMT"u)\n", iface, x, y, z, apply);
1502
1503     EnterCriticalSection(&This->crst);
1504     if(apply == DS3D_DEFERRED)
1505     {
1506         This->listen.vVelocity.x = x;
1507         This->listen.vVelocity.y = y;
1508         This->listen.vVelocity.z = z;
1509         This->dirty.bit.vel = 1;
1510     }
1511     else
1512     {
1513         setALContext(This->ctx);
1514         alListener3f(AL_VELOCITY, x, y, -z);
1515         checkALError();
1516         popALContext();
1517     }
1518     LeaveCriticalSection(&This->crst);
1519
1520     return S_OK;
1521 }
1522
1523 static HRESULT WINAPI DS8Primary3D_CommitDeferredSettings(IDirectSound3DListener *iface)
1524 {
1525     DS8Primary *This = impl_from_IDirectSound3DListener(iface);
1526     const DS3DLISTENER *listen = &This->listen;
1527     DWORD i;
1528
1529     EnterCriticalSection(&This->crst);
1530     setALContext(This->ctx);
1531     This->DeferUpdates();
1532
1533     if(This->dirty.bit.pos)
1534         alListener3f(AL_POSITION, listen->vPosition.x, listen->vPosition.y, -listen->vPosition.z);
1535     if(This->dirty.bit.vel)
1536         alListener3f(AL_VELOCITY, listen->vVelocity.x, listen->vVelocity.y, -listen->vVelocity.z);
1537     if(This->dirty.bit.orientation)
1538     {
1539         ALfloat orient[6] = {
1540             listen->vOrientFront.x, listen->vOrientFront.y, -listen->vOrientFront.z,
1541             listen->vOrientTop.x, listen->vOrientTop.y, -listen->vOrientTop.z
1542         };
1543         alListenerfv(AL_ORIENTATION, orient);
1544     }
1545     if(This->dirty.bit.distancefactor)
1546     {
1547         alSpeedOfSound(343.3f/listen->flDistanceFactor);
1548         if(This->SupportedExt[EXT_EFX])
1549             alListenerf(AL_METERS_PER_UNIT, listen->flDistanceFactor);
1550     }
1551
1552     if(This->dirty.bit.rollofffactor)
1553     {
1554         ALfloat rolloff = This->rollofffactor;
1555         for(i = 0;i < This->nbuffers;++i)
1556         {
1557             DS8Buffer *buf = This->buffers[i];
1558             if(buf->ds3dmode != DS3DMODE_DISABLE)
1559                 alSourcef(buf->source, AL_ROLLOFF_FACTOR, rolloff);
1560         }
1561     }
1562
1563     if(This->dirty.bit.dopplerfactor)
1564         alDopplerFactor(listen->flDopplerFactor);
1565
1566     if(This->dirty.bit.effect)
1567         This->ExtAL.AuxiliaryEffectSloti(This->auxslot, AL_EFFECTSLOT_EFFECT, This->effect);
1568
1569     /* checkALError is here for debugging */
1570     checkALError();
1571
1572     TRACE("Dirty flags was: 0x%02x\n", This->dirty.flags);
1573     This->dirty.flags = 0;
1574
1575     for(i = 0;i < This->nbuffers;++i)
1576     {
1577         DS8Buffer *buf = This->buffers[i];
1578
1579         if(!buf->dirty.flags)
1580             continue;
1581
1582         if(buf->dirty.bit.pos)
1583             alSource3f(buf->source, AL_POSITION,
1584                        buf->ds3dbuffer.vPosition.x,
1585                        buf->ds3dbuffer.vPosition.y,
1586                       -buf->ds3dbuffer.vPosition.z);
1587         if(buf->dirty.bit.vel)
1588             alSource3f(buf->source, AL_VELOCITY,
1589                        buf->ds3dbuffer.vVelocity.x,
1590                        buf->ds3dbuffer.vVelocity.y,
1591                       -buf->ds3dbuffer.vVelocity.z);
1592         if(buf->dirty.bit.cone_angles)
1593         {
1594             alSourcei(buf->source, AL_CONE_INNER_ANGLE,
1595                       buf->ds3dbuffer.dwInsideConeAngle);
1596             alSourcei(buf->source, AL_CONE_OUTER_ANGLE,
1597                       buf->ds3dbuffer.dwOutsideConeAngle);
1598         }
1599         if(buf->dirty.bit.cone_orient)
1600             alSource3f(buf->source, AL_DIRECTION,
1601                        buf->ds3dbuffer.vConeOrientation.x,
1602                        buf->ds3dbuffer.vConeOrientation.y,
1603                       -buf->ds3dbuffer.vConeOrientation.z);
1604         if(buf->dirty.bit.cone_outsidevolume)
1605             alSourcef(buf->source, AL_CONE_OUTER_GAIN,
1606                       mB_to_gain(buf->ds3dbuffer.lConeOutsideVolume));
1607         if(buf->dirty.bit.min_distance)
1608             alSourcef(buf->source, AL_REFERENCE_DISTANCE, buf->ds3dbuffer.flMinDistance);
1609         if(buf->dirty.bit.max_distance)
1610             alSourcef(buf->source, AL_MAX_DISTANCE, buf->ds3dbuffer.flMaxDistance);
1611         if(buf->dirty.bit.mode)
1612         {
1613             buf->ds3dmode = buf->ds3dbuffer.dwMode;
1614             alSourcei(buf->source, AL_SOURCE_RELATIVE,
1615                       (buf->ds3dmode!=DS3DMODE_NORMAL) ? AL_TRUE : AL_FALSE);
1616             alSourcef(buf->source, AL_ROLLOFF_FACTOR,
1617                       (buf->ds3dmode==DS3DMODE_DISABLE) ? 0.0f : This->rollofffactor);
1618         }
1619         buf->dirty.flags = 0;
1620     }
1621     checkALError();
1622
1623     This->ProcessUpdates();
1624     popALContext();
1625     LeaveCriticalSection(&This->crst);
1626
1627     return S_OK;
1628 }
1629
1630 static const IDirectSound3DListenerVtbl DS8Primary3D_Vtbl =
1631 {
1632     DS8Primary3D_QueryInterface,
1633     DS8Primary3D_AddRef,
1634     DS8Primary3D_Release,
1635     DS8Primary3D_GetAllParameters,
1636     DS8Primary3D_GetDistanceFactor,
1637     DS8Primary3D_GetDopplerFactor,
1638     DS8Primary3D_GetOrientation,
1639     DS8Primary3D_GetPosition,
1640     DS8Primary3D_GetRolloffFactor,
1641     DS8Primary3D_GetVelocity,
1642     DS8Primary3D_SetAllParameters,
1643     DS8Primary3D_SetDistanceFactor,
1644     DS8Primary3D_SetDopplerFactor,
1645     DS8Primary3D_SetOrientation,
1646     DS8Primary3D_SetPosition,
1647     DS8Primary3D_SetRolloffFactor,
1648     DS8Primary3D_SetVelocity,
1649     DS8Primary3D_CommitDeferredSettings
1650 };
1651
1652 /* NOTE: Although the app handles listener properties through secondary buffers,
1653  * we pass the requests to the primary buffer though a propertyset interface.
1654  * These methods are not exposed to the app. */
1655 static inline DS8Primary *impl_from_IKsPropertySet(IKsPropertySet *iface)
1656 {
1657     return CONTAINING_RECORD(iface, DS8Primary, IKsPropertySet_iface);
1658 }
1659
1660 static HRESULT WINAPI DS8PrimaryProp_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
1661 {
1662     DS8Primary *This = impl_from_IKsPropertySet(iface);
1663     return DS8Primary_QueryInterface(&This->IDirectSoundBuffer_iface, riid, ppv);
1664 }
1665
1666 static ULONG WINAPI DS8PrimaryProp_AddRef(IKsPropertySet *iface)
1667 {
1668     DS8Primary *This = impl_from_IKsPropertySet(iface);
1669     LONG ret;
1670
1671     ret = InterlockedIncrement(&This->prop_ref);
1672     TRACE("new refcount %"LONGFMT"d\n", ret);
1673
1674     return ret;
1675 }
1676
1677 static ULONG WINAPI DS8PrimaryProp_Release(IKsPropertySet *iface)
1678 {
1679     DS8Primary *This = impl_from_IKsPropertySet(iface);
1680     LONG ret;
1681
1682     ret = InterlockedDecrement(&This->prop_ref);
1683     TRACE("new refcount %"LONGFMT"d\n", ret);
1684
1685     return ret;
1686 }
1687
1688 static HRESULT WINAPI DS8PrimaryProp_Get(IKsPropertySet *iface,
1689   REFGUID guidPropSet, ULONG dwPropID,
1690   LPVOID pInstanceData, ULONG cbInstanceData,
1691   LPVOID pPropData, ULONG cbPropData,
1692   PULONG pcbReturned)
1693 {
1694     DS8Primary *This = impl_from_IKsPropertySet(iface);
1695     HRESULT res = E_PROP_ID_UNSUPPORTED;
1696     (void)pInstanceData;
1697     (void)cbInstanceData;
1698
1699     if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_ListenerProperties))
1700     {
1701         EnterCriticalSection(&This->crst);
1702
1703         if(This->effect == 0)
1704             res = E_PROP_ID_UNSUPPORTED;
1705         else switch(dwPropID)
1706         {
1707         case DSPROPERTY_EAXLISTENER_ALLPARAMETERS:
1708             res = DSERR_INVALIDPARAM;
1709             if(cbPropData >= sizeof(EAXLISTENERPROPERTIES))
1710             {
1711                 union {
1712                     void *v;
1713                     EAXLISTENERPROPERTIES *props;
1714                 } data = { pPropData };
1715
1716                 *data.props = This->eax_prop;
1717                 *pcbReturned = sizeof(EAXLISTENERPROPERTIES);
1718                 res = DS_OK;
1719             }
1720             break;
1721
1722         case DSPROPERTY_EAXLISTENER_ROOM:
1723             res = DSERR_INVALIDPARAM;
1724             if(cbPropData >= sizeof(LONG))
1725             {
1726                 union {
1727                     void *v;
1728                     LONG *l;
1729                 } data = { pPropData };
1730
1731                 *data.l = This->eax_prop.lRoom;
1732                 *pcbReturned = sizeof(LONG);
1733                 res = DS_OK;
1734             }
1735             break;
1736         case DSPROPERTY_EAXLISTENER_ROOMHF:
1737             res = DSERR_INVALIDPARAM;
1738             if(cbPropData >= sizeof(LONG))
1739             {
1740                 union {
1741                     void *v;
1742                     LONG *l;
1743                 } data = { pPropData };
1744
1745                 *data.l = This->eax_prop.lRoomHF;
1746                 *pcbReturned = sizeof(LONG);
1747                 res = DS_OK;
1748             }
1749             break;
1750
1751         case DSPROPERTY_EAXLISTENER_ROOMROLLOFFFACTOR:
1752             res = DSERR_INVALIDPARAM;
1753             if(cbPropData >= sizeof(FLOAT))
1754             {
1755                 union {
1756                     void *v;
1757                     FLOAT *fl;
1758                 } data = { pPropData };
1759
1760                 *data.fl = This->eax_prop.flRoomRolloffFactor;
1761                 *pcbReturned = sizeof(FLOAT);
1762                 res = DS_OK;
1763             }
1764             break;
1765
1766         case DSPROPERTY_EAXLISTENER_ENVIRONMENT:
1767             res = DSERR_INVALIDPARAM;
1768             if(cbPropData >= sizeof(DWORD))
1769             {
1770                 union {
1771                     void *v;
1772                     DWORD *dw;
1773                 } data = { pPropData };
1774
1775                 *data.dw = This->eax_prop.dwEnvironment;
1776                 *pcbReturned = sizeof(DWORD);
1777                 res = DS_OK;
1778             }
1779             break;
1780
1781         case DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE:
1782             res = DSERR_INVALIDPARAM;
1783             if(cbPropData >= sizeof(FLOAT))
1784             {
1785                 union {
1786                     void *v;
1787                     FLOAT *fl;
1788                 } data = { pPropData };
1789
1790                 *data.fl = This->eax_prop.flEnvironmentSize;
1791                 *pcbReturned = sizeof(FLOAT);
1792                 res = DS_OK;
1793             }
1794             break;
1795         case DSPROPERTY_EAXLISTENER_ENVIRONMENTDIFFUSION:
1796             res = DSERR_INVALIDPARAM;
1797             if(cbPropData >= sizeof(FLOAT))
1798             {
1799                 union {
1800                     void *v;
1801                     FLOAT *fl;
1802                 } data = { pPropData };
1803
1804                 *data.fl = This->eax_prop.flEnvironmentDiffusion;
1805                 *pcbReturned = sizeof(FLOAT);
1806                 res = DS_OK;
1807             }
1808             break;
1809
1810         case DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF:
1811             res = DSERR_INVALIDPARAM;
1812             if(cbPropData >= sizeof(FLOAT))
1813             {
1814                 union {
1815                     void *v;
1816                     FLOAT *fl;
1817                 } data = { pPropData };
1818
1819                 *data.fl = This->eax_prop.flAirAbsorptionHF;
1820                 *pcbReturned = sizeof(FLOAT);
1821                 res = DS_OK;
1822             }
1823             break;
1824
1825         case DSPROPERTY_EAXLISTENER_FLAGS:
1826             res = DSERR_INVALIDPARAM;
1827             if(cbPropData >= sizeof(DWORD))
1828             {
1829                 union {
1830                     void *v;
1831                     DWORD *dw;
1832                 } data = { pPropData };
1833
1834                 *data.dw = This->eax_prop.dwFlags;
1835                 *pcbReturned = sizeof(DWORD);
1836                 res = DS_OK;
1837             }
1838             break;
1839
1840         default:
1841             FIXME("Unhandled propid: 0x%08"LONGFMT"x\n", dwPropID);
1842             break;
1843         }
1844
1845         LeaveCriticalSection(&This->crst);
1846     }
1847     else
1848         FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
1849
1850     return res;
1851 }
1852
1853 static HRESULT WINAPI DS8PrimaryProp_Set(IKsPropertySet *iface,
1854   REFGUID guidPropSet, ULONG dwPropID,
1855   LPVOID pInstanceData, ULONG cbInstanceData,
1856   LPVOID pPropData, ULONG cbPropData)
1857 {
1858     DS8Primary *This = impl_from_IKsPropertySet(iface);
1859     HRESULT res = E_PROP_ID_UNSUPPORTED;
1860     (void)pInstanceData;
1861     (void)cbInstanceData;
1862
1863     if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_ListenerProperties))
1864     {
1865         DWORD propid = dwPropID & ~DSPROPERTY_EAXLISTENER_DEFERRED;
1866         BOOL immediate = !(dwPropID&DSPROPERTY_EAXLISTENER_DEFERRED);
1867
1868         EnterCriticalSection(&This->crst);
1869         setALContext(This->ctx);
1870
1871         if(This->effect == 0)
1872             res = E_PROP_ID_UNSUPPORTED;
1873         else switch(propid)
1874         {
1875         case 0: /* 0 = not setting any property, just apply */
1876             res = DS_OK;
1877             break;
1878
1879         case DSPROPERTY_EAXLISTENER_ALLPARAMETERS:
1880         do_allparams:
1881             res = DSERR_INVALIDPARAM;
1882             if(cbPropData >= sizeof(EAXLISTENERPROPERTIES))
1883             {
1884                 union {
1885                     const void *v;
1886                     const EAXLISTENERPROPERTIES *props;
1887                 } data = { pPropData };
1888
1889                 /* FIXME: Need to validate property values... Ignore? Clamp? Error? */
1890                 This->eax_prop = *data.props;
1891                 This->ExtAL.Effectf(This->effect, AL_REVERB_DENSITY,
1892                                     (data.props->flEnvironmentSize < 2.0f) ?
1893                                     (data.props->flEnvironmentSize - 1.0f) : 1.0f);
1894                 This->ExtAL.Effectf(This->effect, AL_REVERB_DIFFUSION,
1895                                     data.props->flEnvironmentDiffusion);
1896
1897                 This->ExtAL.Effectf(This->effect, AL_REVERB_GAIN,
1898                                     mB_to_gain(data.props->lRoom));
1899                 This->ExtAL.Effectf(This->effect, AL_REVERB_GAINHF,
1900                                     mB_to_gain(data.props->lRoomHF));
1901
1902                 This->ExtAL.Effectf(This->effect, AL_REVERB_ROOM_ROLLOFF_FACTOR,
1903                                     data.props->flRoomRolloffFactor);
1904
1905                 This->ExtAL.Effectf(This->effect, AL_REVERB_DECAY_TIME,
1906                                     data.props->flDecayTime);
1907                 This->ExtAL.Effectf(This->effect, AL_REVERB_DECAY_HFRATIO,
1908                                     data.props->flDecayHFRatio);
1909
1910                 This->ExtAL.Effectf(This->effect, AL_REVERB_REFLECTIONS_GAIN,
1911                                     mB_to_gain(data.props->lReflections));
1912                 This->ExtAL.Effectf(This->effect, AL_REVERB_REFLECTIONS_DELAY,
1913                                     data.props->flReflectionsDelay);
1914
1915                 This->ExtAL.Effectf(This->effect, AL_REVERB_LATE_REVERB_GAIN,
1916                                     mB_to_gain(data.props->lReverb));
1917                 This->ExtAL.Effectf(This->effect, AL_REVERB_LATE_REVERB_DELAY,
1918                                     data.props->flReverbDelay);
1919
1920                 This->ExtAL.Effectf(This->effect, AL_REVERB_AIR_ABSORPTION_GAINHF,
1921                                     mB_to_gain(data.props->flAirAbsorptionHF));
1922
1923                 This->ExtAL.Effecti(This->effect, AL_REVERB_DECAY_HFLIMIT,
1924                                     (data.props->dwFlags&EAXLISTENERFLAGS_DECAYHFLIMIT) ?
1925                                     AL_TRUE : AL_FALSE);
1926
1927                 checkALError();
1928
1929                 This->dirty.bit.effect = 1;
1930                 res = DS_OK;
1931             }
1932             break;
1933
1934         case DSPROPERTY_EAXLISTENER_ROOM:
1935             res = DSERR_INVALIDPARAM;
1936             if(cbPropData >= sizeof(LONG))
1937             {
1938                 union {
1939                     const void *v;
1940                     const LONG *l;
1941                 } data = { pPropData };
1942
1943                 This->eax_prop.lRoom = *data.l;
1944                 This->ExtAL.Effectf(This->effect, AL_REVERB_GAIN,
1945                                     mB_to_gain(This->eax_prop.lRoom));
1946                 checkALError();
1947
1948                 This->dirty.bit.effect = 1;
1949                 res = DS_OK;
1950             }
1951             break;
1952         case DSPROPERTY_EAXLISTENER_ROOMHF:
1953             res = DSERR_INVALIDPARAM;
1954             if(cbPropData >= sizeof(LONG))
1955             {
1956                 union {
1957                     const void *v;
1958                     const LONG *l;
1959                 } data = { pPropData };
1960
1961                 This->eax_prop.lRoomHF = *data.l;
1962                 This->ExtAL.Effectf(This->effect, AL_REVERB_GAINHF,
1963                                     mB_to_gain(This->eax_prop.lRoomHF));
1964                 checkALError();
1965
1966                 This->dirty.bit.effect = 1;
1967                 res = DS_OK;
1968             }
1969             break;
1970
1971         case DSPROPERTY_EAXLISTENER_ROOMROLLOFFFACTOR:
1972             res = DSERR_INVALIDPARAM;
1973             if(cbPropData >= sizeof(FLOAT))
1974             {
1975                 union {
1976                     const void *v;
1977                     const FLOAT *fl;
1978                 } data = { pPropData };
1979
1980                 This->eax_prop.flRoomRolloffFactor = *data.fl;
1981                 This->ExtAL.Effectf(This->effect, AL_REVERB_ROOM_ROLLOFF_FACTOR,
1982                                     This->eax_prop.flRoomRolloffFactor);
1983                 checkALError();
1984
1985                 This->dirty.bit.effect = 1;
1986                 res = DS_OK;
1987             }
1988             break;
1989
1990         case DSPROPERTY_EAXLISTENER_ENVIRONMENT:
1991             res = DSERR_INVALIDPARAM;
1992             if(cbPropData >= sizeof(DWORD))
1993             {
1994                 union {
1995                     const void *v;
1996                     const DWORD *dw;
1997                 } data = { pPropData };
1998
1999                 if(*data.dw < EAX_ENVIRONMENT_COUNT)
2000                 {
2001                     /* Get the environment index's default and pass it down to
2002                      * ALLPARAMETERS */
2003                     propid = DSPROPERTY_EAXLISTENER_ALLPARAMETERS;
2004                     pPropData = (void*)&EnvironmentDefaults[*data.dw];
2005                     cbPropData = sizeof(EnvironmentDefaults[*data.dw]);
2006                     goto do_allparams;
2007                 }
2008             }
2009             break;
2010
2011         case DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE:
2012             res = DSERR_INVALIDPARAM;
2013             if(cbPropData >= sizeof(FLOAT))
2014             {
2015                 union {
2016                     const void *v;
2017                     const FLOAT *fl;
2018                 } data = { pPropData };
2019
2020                 if(*data.fl >= 1.0f && *data.fl <= 100.0f)
2021                 {
2022                     double scale = (*data.fl)/This->eax_prop.flEnvironmentSize;
2023
2024                     This->eax_prop.flEnvironmentSize = *data.fl;
2025
2026                     if((This->eax_prop.dwFlags&EAXLISTENERFLAGS_DECAYTIMESCALE))
2027                     {
2028                         This->eax_prop.flDecayTime *= scale;
2029                         This->eax_prop.flDecayTime = clampF(This->eax_prop.flDecayTime, 0.1f, 20.0f);
2030                     }
2031                     if((This->eax_prop.dwFlags&EAXLISTENERFLAGS_REFLECTIONSSCALE))
2032                     {
2033                         This->eax_prop.lReflections += gain_to_mB(1.0/scale);
2034                         This->eax_prop.lReflections = clampI(This->eax_prop.lReflections, -10000, 1000);
2035                     }
2036                     if((This->eax_prop.dwFlags&EAXLISTENERFLAGS_REFLECTIONSDELAYSCALE))
2037                     {
2038                         This->eax_prop.flReflectionsDelay *= scale;
2039                         This->eax_prop.flReflectionsDelay = clampF(This->eax_prop.flReflectionsDelay, 0.0f, 0.3f);
2040                     }
2041                     if((This->eax_prop.dwFlags&EAXLISTENERFLAGS_REVERBSCALE))
2042                     {
2043                         This->eax_prop.lReverb += gain_to_mB(1.0/scale);
2044                         This->eax_prop.lReverb = clampI(This->eax_prop.lReverb, -10000, 2000);
2045                     }
2046                     if((This->eax_prop.dwFlags&EAXLISTENERFLAGS_REVERBDELAYSCALE))
2047                     {
2048                         This->eax_prop.flReverbDelay *= scale;
2049                         This->eax_prop.flReverbDelay = clampF(This->eax_prop.flReverbDelay, 0.0f, 0.1f);
2050                     }
2051
2052                     /* Pass the updated environment properties down to ALLPARAMETERS */
2053                     propid = DSPROPERTY_EAXLISTENER_ALLPARAMETERS;
2054                     pPropData = (void*)&This->eax_prop;
2055                     cbPropData = sizeof(This->eax_prop);
2056                     goto do_allparams;
2057                 }
2058             }
2059             break;
2060         case DSPROPERTY_EAXLISTENER_ENVIRONMENTDIFFUSION:
2061             res = DSERR_INVALIDPARAM;
2062             if(cbPropData >= sizeof(FLOAT))
2063             {
2064                 union {
2065                     const void *v;
2066                     const FLOAT *fl;
2067                 } data = { pPropData };
2068
2069                 This->eax_prop.flEnvironmentDiffusion = *data.fl;
2070                 This->ExtAL.Effectf(This->effect, AL_REVERB_DIFFUSION,
2071                                     This->eax_prop.flEnvironmentDiffusion);
2072                 checkALError();
2073
2074                 This->dirty.bit.effect = 1;
2075                 res = DS_OK;
2076             }
2077             break;
2078
2079         case DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF:
2080             res = DSERR_INVALIDPARAM;
2081             if(cbPropData >= sizeof(FLOAT))
2082             {
2083                 union {
2084                     const void *v;
2085                     const FLOAT *fl;
2086                 } data = { pPropData };
2087
2088                 This->eax_prop.flAirAbsorptionHF = *data.fl;
2089                 This->ExtAL.Effectf(This->effect, AL_REVERB_AIR_ABSORPTION_GAINHF,
2090                                     mB_to_gain(This->eax_prop.flAirAbsorptionHF));
2091                 checkALError();
2092
2093                 This->dirty.bit.effect = 1;
2094                 res = DS_OK;
2095             }
2096             break;
2097
2098         case DSPROPERTY_EAXLISTENER_FLAGS:
2099             res = DSERR_INVALIDPARAM;
2100             if(cbPropData >= sizeof(DWORD))
2101             {
2102                 union {
2103                     const void *v;
2104                     const DWORD *dw;
2105                 } data = { pPropData };
2106
2107                 This->eax_prop.dwFlags = *data.dw;
2108                 This->ExtAL.Effecti(This->effect, AL_REVERB_DECAY_HFLIMIT,
2109                                     (This->eax_prop.dwFlags&EAXLISTENERFLAGS_DECAYHFLIMIT) ?
2110                                     AL_TRUE : AL_FALSE);
2111                 checkALError();
2112
2113                 This->dirty.bit.effect = 1;
2114                 res = DS_OK;
2115             }
2116         default:
2117             FIXME("Unhandled propid: 0x%08"LONGFMT"x\n", propid);
2118             break;
2119         }
2120
2121         if(res == DS_OK && immediate)
2122             IDirectSound3DListener_CommitDeferredSettings(&This->IDirectSound3DListener_iface);
2123
2124         popALContext();
2125         LeaveCriticalSection(&This->crst);
2126     }
2127     else
2128         FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
2129
2130     return res;
2131 }
2132
2133 static HRESULT WINAPI DS8PrimaryProp_QuerySupport(IKsPropertySet *iface,
2134   REFGUID guidPropSet, ULONG dwPropID,
2135   PULONG pTypeSupport)
2136 {
2137     DS8Primary *This = impl_from_IKsPropertySet(iface);
2138     HRESULT res = E_PROP_ID_UNSUPPORTED;
2139
2140     if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_ListenerProperties))
2141     {
2142         EnterCriticalSection(&This->crst);
2143
2144         if(This->effect == 0)
2145             res = E_PROP_ID_UNSUPPORTED;
2146         else if(dwPropID == DSPROPERTY_EAXLISTENER_ALLPARAMETERS ||
2147                 dwPropID == DSPROPERTY_EAXLISTENER_ROOM ||
2148                 dwPropID == DSPROPERTY_EAXLISTENER_ROOMHF ||
2149                 dwPropID == DSPROPERTY_EAXLISTENER_ROOMROLLOFFFACTOR ||
2150                 dwPropID == DSPROPERTY_EAXLISTENER_ENVIRONMENT ||
2151                 dwPropID == DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE ||
2152                 dwPropID == DSPROPERTY_EAXLISTENER_ENVIRONMENTDIFFUSION ||
2153                 dwPropID == DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF ||
2154                 dwPropID == DSPROPERTY_EAXLISTENER_FLAGS)
2155         {
2156             *pTypeSupport = KSPROPERTY_SUPPORT_GET|KSPROPERTY_SUPPORT_SET;
2157             res = DS_OK;
2158         }
2159         else
2160             FIXME("Unhandled propid: 0x%08"LONGFMT"x\n", dwPropID);
2161
2162         LeaveCriticalSection(&This->crst);
2163     }
2164     else
2165         FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
2166
2167     return res;
2168 }
2169
2170 static const IKsPropertySetVtbl DS8PrimaryProp_Vtbl =
2171 {
2172     DS8PrimaryProp_QueryInterface,
2173     DS8PrimaryProp_AddRef,
2174     DS8PrimaryProp_Release,
2175     DS8PrimaryProp_Get,
2176     DS8PrimaryProp_Set,
2177     DS8PrimaryProp_QuerySupport
2178 };