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