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