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 #define CONST_VTABLE
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #include <windows.h>
  28 #include <dsound.h>
  29 #include <mmsystem.h>
  30
  31 #include "dsound_private.h"
  32 #include "eax-presets.h"
  33
  34
  35 #ifndef E_PROP_ID_UNSUPPORTED
  36 #define E_PROP_ID_UNSUPPORTED            ((HRESULT)0x80070490)
  37 #endif
  38
  39
  40 static const IDirectSoundBufferVtbl DSPrimary_Vtbl;
  41 static const IDirectSound3DListenerVtbl DSPrimary3D_Vtbl;
  42 static const IKsPropertySetVtbl DSPrimaryProp_Vtbl;
  43
  44 static void DSPrimary_SetParams(DSPrimary *This, const DS3DLISTENER *params, LONG flags);
  45
  46
  47 static inline DSPrimary *impl_from_IDirectSoundBuffer(IDirectSoundBuffer *iface)
  48 {
  49     return CONTAINING_RECORD(iface, DSPrimary, IDirectSoundBuffer_iface);
  50 }
  51
  52 static inline DSPrimary *impl_from_IDirectSound3DListener(IDirectSound3DListener *iface)
  53 {
  54     return CONTAINING_RECORD(iface, DSPrimary, IDirectSound3DListener_iface);
  55 }
  56
  57 static inline DSPrimary *impl_from_IKsPropertySet(IKsPropertySet *iface)
  58 {
  59     return CONTAINING_RECORD(iface, DSPrimary, IKsPropertySet_iface);
  60 }
  61
  62
  63 static void trigger_elapsed_notifies(DSBuffer *buf, DWORD lastpos, DWORD curpos)
  64 {
  65     DSBPOSITIONNOTIFY *not = buf->notify;
  66     DSBPOSITIONNOTIFY *not_end = not + buf->nnotify;
  67     for(;not != not_end;++not)
  68     {
  69         HANDLE event = not->hEventNotify;
  70         DWORD ofs = not->dwOffset;
  71
  72         if(ofs == (DWORD)DSBPN_OFFSETSTOP)
  73             continue;
  74
  75         if(curpos < lastpos) /* Wraparound case */
  76         {
  77             if(ofs < curpos || ofs >= lastpos)
  78             {
  79                 TRACE("Triggering notification %d from buffer %p\n", not - buf->notify, buf);
  80                 SetEvent(event);
  81             }
  82         }
  83         else if(ofs >= lastpos && ofs < curpos) /* Normal case */
  84         {
  85             TRACE("Triggering notification %d from buffer %p\n", not - buf->notify, buf);
  86             SetEvent(event);
  87         }
  88     }
  89 }
  90
  91 static void trigger_stop_notifies(DSBuffer *buf)
  92 {
  93     DSBPOSITIONNOTIFY *not = buf->notify;
  94     DSBPOSITIONNOTIFY *not_end = not + buf->nnotify;
  95     for(;not != not_end;++not)
  96     {
  97         if(not->dwOffset != (DWORD)DSBPN_OFFSETSTOP)
  98             continue;
  99         TRACE("Triggering notification %d from buffer %p\n", not - buf->notify, buf);
 100         SetEvent(not->hEventNotify);
 101     }
 102 }
 103
 104 void DSPrimary_triggernots(DSPrimary *prim)
 105 {
 106     DSBuffer **curnot, **endnot;
 107
 108     curnot = prim->notifies;
 109     endnot = curnot + prim->nnotifies;
 110     while(curnot != endnot)
 111     {
 112         DSBuffer *buf = *curnot;
 113         DSData *data = buf->buffer;
 114         DWORD curpos = buf->lastpos;
 115         ALint state = 0;
 116         ALint ofs;
 117
 118         alGetSourcei(buf->source, AL_BYTE_OFFSET, &ofs);
 119         alGetSourcei(buf->source, AL_SOURCE_STATE, &state);
 120         if(buf->segsize == 0)
 121             curpos = (state == AL_STOPPED) ? data->buf_size : ofs;
 122         else
 123         {
 124             if(state != AL_STOPPED)
 125                 curpos = ofs + buf->queue_base;
 126             else
 127             {
 128                 ALint queued;
 129                 alGetSourcei(buf->source, AL_BUFFERS_QUEUED, &queued);
 130                 curpos = buf->segsize*queued + buf->queue_base;
 131             }
 132
 133             if(curpos >= (DWORD)data->buf_size)
 134             {
 135                 if(buf->islooping)
 136                     curpos %= (DWORD)data->buf_size;
 137                 else if(buf->isplaying)
 138                 {
 139                     curpos = data->buf_size;
 140                     alSourceStop(buf->source);
 141                     alSourcei(buf->source, AL_BUFFER, 0);
 142                     buf->curidx = 0;
 143                     buf->isplaying = FALSE;
 144                 }
 145             }
 146
 147             if(state != AL_PLAYING)
 148                 state = buf->isplaying ? AL_PLAYING : AL_PAUSED;
 149         }
 150         checkALError();
 151
 152         if(buf->lastpos != curpos)
 153         {
 154             trigger_elapsed_notifies(buf, buf->lastpos, curpos);
 155             buf->lastpos = curpos;
 156         }
 157         if(state != AL_PLAYING)
 158         {
 159             /* Remove this buffer from list and put another at the current
 160              * position; don't increment i
 161              */
 162             trigger_stop_notifies(buf);
 163             *curnot = *(--endnot);
 164             prim->nnotifies--;
 165             continue;
 166         }
 167         curnot++;
 168     }
 169     checkALError();
 170 }
 171
 172 static void do_buffer_stream(DSBuffer *buf, BYTE *scratch_mem)
 173 {
 174     DSData *data = buf->buffer;
 175     ALint ofs, done = 0, queued = QBUFFERS, state = AL_PLAYING;
 176     ALuint which;
 177
 178     alGetSourcei(buf->source, AL_BUFFERS_QUEUED, &queued);
 179     alGetSourcei(buf->source, AL_SOURCE_STATE, &state);
 180     alGetSourcei(buf->source, AL_BUFFERS_PROCESSED, &done);
 181
 182     if(done > 0)
 183     {
 184         ALuint bids[QBUFFERS];
 185         queued -= done;
 186
 187         alSourceUnqueueBuffers(buf->source, done, bids);
 188         buf->queue_base = (buf->queue_base + buf->segsize*done) % data->buf_size;
 189     }
 190     while(queued < QBUFFERS)
 191     {
 192         which = buf->stream_bids[buf->curidx];
 193         ofs = buf->data_offset;
 194
 195         if(buf->segsize < data->buf_size - ofs)
 196         {
 197             alBufferData(which, data->buf_format, data->data + ofs, buf->segsize,
 198                             data->format.Format.nSamplesPerSec);
 199             buf->data_offset = ofs + buf->segsize;
 200         }
 201         else if(buf->islooping)
 202         {
 203             ALsizei rem = data->buf_size - ofs;
 204             if(rem > 2048) rem = 2048;
 205
 206             memcpy(scratch_mem, data->data + ofs, rem);
 207             while(rem < buf->segsize)
 208             {
 209                 ALsizei todo = buf->segsize - rem;
 210                 if(todo > data->buf_size)
 211                     todo = data->buf_size;
 212                 memcpy(scratch_mem + rem, data->data, todo);
 213                 rem += todo;
 214             }
 215             alBufferData(which, data->buf_format, scratch_mem, buf->segsize,
 216                             data->format.Format.nSamplesPerSec);
 217             buf->data_offset = (ofs+buf->segsize) % data->buf_size;
 218         }
 219         else
 220         {
 221             ALsizei rem = data->buf_size - ofs;
 222             if(rem > 2048) rem = 2048;
 223             if(rem == 0) break;
 224
 225             memcpy(scratch_mem, data->data + ofs, rem);
 226             memset(scratch_mem+rem, (data->format.Format.wBitsPerSample==8) ? 128 : 0,
 227                     buf->segsize - rem);
 228             alBufferData(which, data->buf_format, scratch_mem, buf->segsize,
 229                             data->format.Format.nSamplesPerSec);
 230             buf->data_offset = data->buf_size;
 231         }
 232
 233         alSourceQueueBuffers(buf->source, 1, &which);
 234         buf->curidx = (buf->curidx+1)%QBUFFERS;
 235         queued++;
 236     }
 237
 238     if(!queued)
 239     {
 240         buf->data_offset = 0;
 241         buf->queue_base = data->buf_size;
 242         buf->curidx = 0;
 243         buf->isplaying = FALSE;
 244     }
 245     else if(state != AL_PLAYING)
 246         alSourcePlay(buf->source);
 247 }
 248
 249 void DSPrimary_streamfeeder(DSPrimary *prim, BYTE *scratch_mem)
 250 {
 251     /* OpenAL doesn't support our lovely buffer extensions so just make sure
 252      * enough buffers are queued for streaming
 253      */
 254     if(prim->write_emu)
 255     {
 256         DSBuffer *buf = CONTAINING_RECORD(prim->write_emu, DSBuffer, IDirectSoundBuffer8_iface);
 257         if(buf->segsize != 0 && buf->isplaying)
 258             do_buffer_stream(buf, scratch_mem);
 259     }
 260     else
 261     {
 262         struct DSBufferGroup *bufgroup = prim->BufferGroups;
 263         struct DSBufferGroup *endgroup = bufgroup + prim->NumBufferGroups;
 264         for(;bufgroup != endgroup;++bufgroup)
 265         {
 266             DWORD64 usemask = ~bufgroup->FreeBuffers;
 267             while(usemask)
 268             {
 269                 int idx = CTZ64(usemask);
 270                 DSBuffer *buf = bufgroup->Buffers + idx;
 271                 usemask &= ~(U64(1) << idx);
 272
 273                 if(buf->segsize != 0 && buf->isplaying)
 274                     do_buffer_stream(buf, scratch_mem);
 275             }
 276         }
 277     }
 278     checkALError();
 279 }
 280
 281
 282 HRESULT DSPrimary_PreInit(DSPrimary *This, DSDevice *parent)
 283 {
 284     WAVEFORMATEX *wfx;
 285     DWORD num_srcs;
 286     DWORD count;
 287     HRESULT hr;
 288     DWORD i;
 289
 290     This->IDirectSoundBuffer_iface.lpVtbl = &DSPrimary_Vtbl;
 291     This->IDirectSound3DListener_iface.lpVtbl = &DSPrimary3D_Vtbl;
 292     This->IKsPropertySet_iface.lpVtbl = &DSPrimaryProp_Vtbl;
 293
 294     This->parent = parent;
 295     This->share = parent->share;
 296     This->ctx = parent->share->ctx;
 297     This->refresh = parent->share->refresh;
 298     This->auxslot = parent->share->auxslot;
 299
 300     wfx = &This->format.Format;
 301     wfx->wFormatTag = WAVE_FORMAT_PCM;
 302     wfx->nChannels = 2;
 303     wfx->wBitsPerSample = 8;
 304     wfx->nSamplesPerSec = 22050;
 305     wfx->nBlockAlign = wfx->wBitsPerSample * wfx->nChannels / 8;
 306     wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign;
 307     wfx->cbSize = 0;
 308
 309     This->stopped = TRUE;
 310
 311     /* Apparently primary buffer size is always 32k,
 312      * tested on windows with 192k 24 bits sound @ 6 channels
 313      * where it will run out in 60 ms and it isn't pointer aligned
 314      */
 315     This->buf_size = 32768;
 316
 317     setALContext(This->ctx);
 318     This->deferred.eax = EnvironmentDefaults[EAX_ENVIRONMENT_GENERIC];
 319     This->deferred.eax1_volume = 0.5f;
 320     This->deferred.eax1_dampening = 0.5f;
 321     if(This->auxslot != 0)
 322     {
 323         ALint revid = alGetEnumValue("AL_EFFECT_EAXREVERB");
 324         if(revid != 0 && revid != -1)
 325         {
 326             alGenEffects(1, &This->effect);
 327             alEffecti(This->effect, AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB);
 328             checkALError();
 329         }
 330     }
 331     popALContext();
 332
 333     num_srcs = This->share->sources.maxhw_alloc + This->share->sources.maxsw_alloc;
 334
 335     hr = DSERR_OUTOFMEMORY;
 336     This->notifies = HeapAlloc(GetProcessHeap(), 0, num_srcs*sizeof(*This->notifies));
 337     if(!This->notifies) goto fail;
 338     This->sizenotifies = num_srcs;
 339
 340     count = (MAX_HWBUFFERS+63) / 64;
 341     This->BufferGroups = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 342                                    count*sizeof(*This->BufferGroups));
 343     if(!This->BufferGroups) goto fail;
 344
 345     for(i = 0;i < count;++i)
 346     {
 347         This->BufferGroups[i].Buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 348                                                   64*sizeof(This->BufferGroups[0].Buffers[0]));
 349         if(!This->BufferGroups[i].Buffers)
 350         {
 351             while(i > 0)
 352                 HeapFree(GetProcessHeap(), 0, This->BufferGroups[--i].Buffers);
 353             HeapFree(GetProcessHeap(), 0, This->BufferGroups);
 354             This->BufferGroups = NULL;
 355             goto fail;
 356         }
 357         This->BufferGroups[i].FreeBuffers = ~(DWORD64)0;
 358     }
 359     This->NumBufferGroups = count;
 360
 361     return S_OK;
 362
 363 fail:
 364     DSPrimary_Clear(This);
 365     return hr;
 366 }
 367
 368 void DSPrimary_Clear(DSPrimary *This)
 369 {
 370     struct DSBufferGroup *bufgroup;
 371     DWORD i;
 372
 373     TRACE("Clearing primary %p\n", This);
 374
 375     if(!This->parent)
 376         return;
 377
 378     setALContext(This->ctx);
 379     if(This->effect)
 380         alDeleteEffects(1, &This->effect);
 381     popALContext();
 382
 383     bufgroup = This->BufferGroups;
 384     for(i = 0;i < This->NumBufferGroups;++i)
 385     {
 386         DWORD64 usemask = ~bufgroup[i].FreeBuffers;
 387         while(usemask)
 388         {
 389             int idx = CTZ64(usemask);
 390             DSBuffer *buf = bufgroup[i].Buffers + idx;
 391             usemask &= ~(U64(1) << idx);
 392
 393             DSBuffer_Destroy(buf);
 394         }
 395         HeapFree(GetProcessHeap(), 0, This->BufferGroups[i].Buffers);
 396     }
 397
 398     HeapFree(GetProcessHeap(), 0, This->BufferGroups);
 399     HeapFree(GetProcessHeap(), 0, This->notifies);
 400     memset(This, 0, sizeof(*This));
 401 }
 402
 403 static HRESULT WINAPI DSPrimary_QueryInterface(IDirectSoundBuffer *iface, REFIID riid, LPVOID *ppv)
 404 {
 405     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 406
 407     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 408
 409     *ppv = NULL;
 410     if(IsEqualIID(riid, &IID_IUnknown) ||
 411        IsEqualIID(riid, &IID_IDirectSoundBuffer))
 412         *ppv = &This->IDirectSoundBuffer_iface;
 413     else if(IsEqualIID(riid, &IID_IDirectSound3DListener))
 414     {
 415         if((This->flags&DSBCAPS_CTRL3D))
 416             *ppv = &This->IDirectSound3DListener_iface;
 417     }
 418     else if(IsEqualIID(riid, &IID_IKsPropertySet))
 419         *ppv = &This->IKsPropertySet_iface;
 420     else
 421         FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
 422
 423     if(*ppv)
 424     {
 425         IUnknown_AddRef((IUnknown*)*ppv);
 426         return S_OK;
 427     }
 428
 429     return E_NOINTERFACE;
 430 }
 431
 432 static ULONG WINAPI DSPrimary_AddRef(IDirectSoundBuffer *iface)
 433 {
 434     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 435     LONG ret;
 436
 437     ret = InterlockedIncrement(&This->ref);
 438     if(ret == 1) This->flags = 0;
 439     TRACE("(%p) ref %lu\n", iface, ret);
 440
 441     return ret;
 442 }
 443
 444 static ULONG WINAPI DSPrimary_Release(IDirectSoundBuffer *iface)
 445 {
 446     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 447     LONG ref, oldval;
 448
 449     oldval = *(volatile LONG*)&This->ref;
 450     do {
 451         ref = oldval;
 452         if(ref)
 453         {
 454             --ref;
 455             oldval = InterlockedCompareExchange(&This->ref, ref, ref+1)-1;
 456         }
 457     } while(oldval != ref);
 458     TRACE("(%p) ref %lu\n", iface, ref);
 459
 460     return ref;
 461 }
 462
 463 static HRESULT WINAPI DSPrimary_GetCaps(IDirectSoundBuffer *iface, DSBCAPS *caps)
 464 {
 465     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 466
 467     TRACE("(%p)->(%p)\n", iface, caps);
 468
 469     if(!caps || caps->dwSize < sizeof(*caps))
 470     {
 471         WARN("Invalid DSBCAPS (%p, %lu)\n", caps, caps ? caps->dwSize : 0);
 472         return DSERR_INVALIDPARAM;
 473     }
 474
 475     caps->dwFlags = This->flags;
 476     caps->dwBufferBytes = This->buf_size;
 477     caps->dwUnlockTransferRate = 0;
 478     caps->dwPlayCpuOverhead = 0;
 479
 480     return DS_OK;
 481 }
 482
 483 static HRESULT WINAPI DSPrimary_GetCurrentPosition(IDirectSoundBuffer *iface, DWORD *playpos, DWORD *curpos)
 484 {
 485     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 486     HRESULT hr = DSERR_PRIOLEVELNEEDED;
 487
 488     EnterCriticalSection(&This->share->crst);
 489     if(This->write_emu)
 490         hr = IDirectSoundBuffer8_GetCurrentPosition(This->write_emu, playpos, curpos);
 491     LeaveCriticalSection(&This->share->crst);
 492
 493     return hr;
 494 }
 495
 496 static HRESULT WINAPI DSPrimary_GetFormat(IDirectSoundBuffer *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
 497 {
 498     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 499     HRESULT hr = S_OK;
 500     UINT size;
 501
 502     if(!wfx && !written)
 503     {
 504         WARN("Cannot report format or format size\n");
 505         return DSERR_INVALIDPARAM;
 506     }
 507
 508     EnterCriticalSection(&This->share->crst);
 509     size = sizeof(This->format.Format) + This->format.Format.cbSize;
 510     if(written)
 511         *written = size;
 512     if(wfx)
 513     {
 514         if(allocated < size)
 515             hr = DSERR_INVALIDPARAM;
 516         else
 517             memcpy(wfx, &This->format.Format, size);
 518     }
 519     LeaveCriticalSection(&This->share->crst);
 520
 521     return hr;
 522 }
 523
 524 static HRESULT WINAPI DSPrimary_GetVolume(IDirectSoundBuffer *iface, LONG *volume)
 525 {
 526     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 527     ALfloat gain;
 528
 529     TRACE("(%p)->(%p)\n", iface, volume);
 530
 531     if(!volume)
 532         return DSERR_INVALIDPARAM;
 533     *volume = 0;
 534
 535     if(!(This->flags&DSBCAPS_CTRLVOLUME))
 536         return DSERR_CONTROLUNAVAIL;
 537
 538     setALContext(This->ctx);
 539     alGetListenerf(AL_GAIN, &gain);
 540     checkALError();
 541     popALContext();
 542
 543     *volume = clampI(gain_to_mB(gain), DSBVOLUME_MIN, DSBVOLUME_MAX);
 544     return DS_OK;
 545 }
 546
 547 static HRESULT WINAPI DSPrimary_GetPan(IDirectSoundBuffer *iface, LONG *pan)
 548 {
 549     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 550     HRESULT hr = DS_OK;
 551
 552     WARN("(%p)->(%p): semi-stub\n", iface, pan);
 553
 554     if(!pan)
 555         return DSERR_INVALIDPARAM;
 556
 557     EnterCriticalSection(&This->share->crst);
 558     if(This->write_emu)
 559         hr = IDirectSoundBuffer8_GetPan(This->write_emu, pan);
 560     else if(!(This->flags & DSBCAPS_CTRLPAN))
 561         hr = DSERR_CONTROLUNAVAIL;
 562     else
 563         *pan = 0;
 564     LeaveCriticalSection(&This->share->crst);
 565
 566     return hr;
 567 }
 568
 569 static HRESULT WINAPI DSPrimary_GetFrequency(IDirectSoundBuffer *iface, DWORD *freq)
 570 {
 571     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 572     HRESULT hr = DS_OK;
 573
 574     WARN("(%p)->(%p): semi-stub\n", iface, freq);
 575
 576     if(!freq)
 577         return DSERR_INVALIDPARAM;
 578
 579     if(!(This->flags&DSBCAPS_CTRLFREQUENCY))
 580         return DSERR_CONTROLUNAVAIL;
 581
 582     EnterCriticalSection(&This->share->crst);
 583     *freq = This->format.Format.nSamplesPerSec;
 584     LeaveCriticalSection(&This->share->crst);
 585
 586     return hr;
 587 }
 588
 589 static HRESULT WINAPI DSPrimary_GetStatus(IDirectSoundBuffer *iface, DWORD *status)
 590 {
 591     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 592
 593     TRACE("(%p)->(%p)\n", iface, status);
 594
 595     if(!status)
 596         return DSERR_INVALIDPARAM;
 597
 598     EnterCriticalSection(&This->share->crst);
 599     *status = DSBSTATUS_PLAYING|DSBSTATUS_LOOPING;
 600     if((This->flags&DSBCAPS_LOCDEFER))
 601         *status |= DSBSTATUS_LOCHARDWARE;
 602
 603     if(This->stopped)
 604     {
 605         struct DSBufferGroup *bufgroup = This->BufferGroups;
 606         DWORD i, state = 0;
 607         HRESULT hr;
 608
 609         for(i = 0;i < This->NumBufferGroups;++i)
 610         {
 611             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
 612             while(usemask)
 613             {
 614                 int idx = CTZ64(usemask);
 615                 DSBuffer *buf = bufgroup[i].Buffers + idx;
 616                 usemask &= ~(U64(1) << idx);
 617
 618                 hr = DSBuffer_GetStatus(&buf->IDirectSoundBuffer8_iface, &state);
 619                 if(SUCCEEDED(hr) && (state&DSBSTATUS_PLAYING)) break;
 620             }
 621         }
 622         if(!(state&DSBSTATUS_PLAYING))
 623         {
 624             /* Primary stopped and no buffers playing.. */
 625             *status = 0;
 626         }
 627     }
 628     LeaveCriticalSection(&This->share->crst);
 629
 630     return DS_OK;
 631 }
 632
 633 HRESULT WINAPI DSPrimary_Initialize(IDirectSoundBuffer *iface, IDirectSound *ds, const DSBUFFERDESC *desc)
 634 {
 635     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 636     HRESULT hr;
 637
 638     TRACE("(%p)->(%p, %p)\n", iface, ds, desc);
 639
 640     if(!desc || desc->lpwfxFormat || desc->dwBufferBytes)
 641     {
 642         WARN("Bad DSBDESC for primary buffer\n");
 643         return DSERR_INVALIDPARAM;
 644     }
 645     if((desc->dwFlags&DSBCAPS_CTRLFX) ||
 646        (desc->dwFlags&DSBCAPS_CTRLPOSITIONNOTIFY) ||
 647        (desc->dwFlags&DSBCAPS_LOCSOFTWARE))
 648     {
 649         WARN("Bad dwFlags %08lx\n", desc->dwFlags);
 650         return DSERR_INVALIDPARAM;
 651     }
 652
 653     /* Should be 0 if not initialized */
 654     if(This->flags)
 655         return DSERR_ALREADYINITIALIZED;
 656
 657     hr = DS_OK;
 658     if(This->parent->prio_level == DSSCL_WRITEPRIMARY)
 659     {
 660         DSBUFFERDESC emudesc;
 661         DSBuffer *emu;
 662
 663         if(This->write_emu)
 664         {
 665             ERR("There shouldn't be a write_emu!\n");
 666             IDirectSoundBuffer8_Release(This->write_emu);
 667             This->write_emu = NULL;
 668         }
 669
 670         memset(&emudesc, 0, sizeof(emudesc));
 671         emudesc.dwSize = sizeof(emudesc);
 672         emudesc.dwFlags = DSBCAPS_LOCHARDWARE | (desc->dwFlags&DSBCAPS_CTRLPAN);
 673         /* Dont play last incomplete sample */
 674         emudesc.dwBufferBytes = This->buf_size - (This->buf_size%This->format.Format.nBlockAlign);
 675         emudesc.lpwfxFormat = &This->format.Format;
 676
 677         hr = DSBuffer_Create(&emu, This, NULL);
 678         if(SUCCEEDED(hr))
 679         {
 680             This->write_emu = &emu->IDirectSoundBuffer8_iface;
 681             hr = DSBuffer_Initialize(This->write_emu, ds, &emudesc);
 682             if(FAILED(hr))
 683             {
 684                 IDirectSoundBuffer8_Release(This->write_emu);
 685                 This->write_emu = NULL;
 686             }
 687         }
 688     }
 689
 690     if(SUCCEEDED(hr))
 691     {
 692         DS3DLISTENER *listener = &This->deferred.ds3d;
 693         listener->dwSize = sizeof(This->deferred.ds3d);
 694         listener->vPosition.x = 0.0f;
 695         listener->vPosition.y = 0.0f;
 696         listener->vPosition.z = 0.0f;
 697         listener->vVelocity.x = 0.0f;
 698         listener->vVelocity.y = 0.0f;
 699         listener->vVelocity.z = 0.0f;
 700         listener->vOrientFront.x = 0.0f;
 701         listener->vOrientFront.y = 0.0f;
 702         listener->vOrientFront.z = 1.0f;
 703         listener->vOrientTop.x = 0.0f;
 704         listener->vOrientTop.y = 1.0f;
 705         listener->vOrientTop.z = 0.0f;
 706         listener->flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
 707         listener->flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
 708         listener->flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
 709
 710         This->flags = desc->dwFlags | DSBCAPS_LOCHARDWARE;
 711
 712         if((This->flags&DSBCAPS_CTRL3D))
 713         {
 714             union PrimaryParamFlags dirty = { 0l };
 715
 716             dirty.bit.pos = 1;
 717             dirty.bit.vel = 1;
 718             dirty.bit.orientation = 1;
 719             dirty.bit.distancefactor = 1;
 720             dirty.bit.rollofffactor = 1;
 721             dirty.bit.dopplerfactor = 1;
 722             DSPrimary_SetParams(This, listener, dirty.flags);
 723         }
 724     }
 725     return hr;
 726 }
 727
 728 static HRESULT WINAPI DSPrimary_Lock(IDirectSoundBuffer *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
 729 {
 730     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 731     HRESULT hr = DSERR_PRIOLEVELNEEDED;
 732
 733     TRACE("(%p)->(%lu, %lu, %p, %p, %p, %p, %lu)\n", iface, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 734
 735     EnterCriticalSection(&This->share->crst);
 736     if(This->write_emu)
 737         hr = IDirectSoundBuffer8_Lock(This->write_emu, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 738     LeaveCriticalSection(&This->share->crst);
 739
 740     return hr;
 741 }
 742
 743 static HRESULT WINAPI DSPrimary_Play(IDirectSoundBuffer *iface, DWORD res1, DWORD res2, DWORD flags)
 744 {
 745     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 746     HRESULT hr;
 747
 748     TRACE("(%p)->(%lu, %lu, %lu)\n", iface, res1, res2, flags);
 749
 750     if(!(flags & DSBPLAY_LOOPING))
 751     {
 752         WARN("Flags (%08lx) not set to DSBPLAY_LOOPING\n", flags);
 753         return DSERR_INVALIDPARAM;
 754     }
 755
 756     EnterCriticalSection(&This->share->crst);
 757     hr = S_OK;
 758     if(This->write_emu)
 759         hr = IDirectSoundBuffer8_Play(This->write_emu, res1, res2, flags);
 760     if(SUCCEEDED(hr))
 761         This->stopped = FALSE;
 762     LeaveCriticalSection(&This->share->crst);
 763
 764     return hr;
 765 }
 766
 767 static HRESULT WINAPI DSPrimary_SetCurrentPosition(IDirectSoundBuffer *iface, DWORD pos)
 768 {
 769     WARN("(%p)->(%lu)\n", iface, pos);
 770     return DSERR_INVALIDCALL;
 771 }
 772
 773 /* Just assume the format is crap, and clean up the damage */
 774 static HRESULT copy_waveformat(WAVEFORMATEX *wfx, const WAVEFORMATEX *from)
 775 {
 776     if(from->nChannels <= 0)
 777     {
 778         WARN("Invalid Channels %d\n", from->nChannels);
 779         return DSERR_INVALIDPARAM;
 780     }
 781     if(from->nSamplesPerSec < DSBFREQUENCY_MIN || from->nSamplesPerSec > DSBFREQUENCY_MAX)
 782     {
 783         WARN("Invalid SamplesPerSec %lu\n", from->nSamplesPerSec);
 784         return DSERR_INVALIDPARAM;
 785     }
 786     if(from->nBlockAlign <= 0)
 787     {
 788         WARN("Invalid BlockAlign %d\n", from->nBlockAlign);
 789         return DSERR_INVALIDPARAM;
 790     }
 791     if(from->wBitsPerSample == 0 || (from->wBitsPerSample%8) != 0)
 792     {
 793         WARN("Invalid BitsPerSample %d\n", from->wBitsPerSample);
 794         return DSERR_INVALIDPARAM;
 795     }
 796     if(from->nBlockAlign != from->nChannels*from->wBitsPerSample/8)
 797     {
 798         WARN("Invalid BlockAlign %d (expected %u = %u*%u/8)\n",
 799              from->nBlockAlign, from->nChannels*from->wBitsPerSample/8,
 800              from->nChannels, from->wBitsPerSample);
 801         return DSERR_INVALIDPARAM;
 802     }
 803     if(from->nAvgBytesPerSec != from->nBlockAlign*from->nSamplesPerSec)
 804     {
 805         WARN("Invalid AvgBytesPerSec %lu (expected %lu = %lu*%u)\n",
 806              from->nAvgBytesPerSec, from->nSamplesPerSec*from->nBlockAlign,
 807              from->nSamplesPerSec, from->nBlockAlign);
 808         return DSERR_INVALIDPARAM;
 809     }
 810
 811     if(from->wFormatTag == WAVE_FORMAT_PCM)
 812     {
 813         if(from->wBitsPerSample > 32)
 814             return DSERR_INVALIDPARAM;
 815         wfx->cbSize = 0;
 816     }
 817     else if(from->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 818     {
 819         if(from->wBitsPerSample != 32)
 820             return DSERR_INVALIDPARAM;
 821         wfx->cbSize = 0;
 822     }
 823     else if(from->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 824     {
 825         WAVEFORMATEXTENSIBLE *wfe = (WAVEFORMATEXTENSIBLE*)wfx;
 826         const WAVEFORMATEXTENSIBLE *fromx = (const WAVEFORMATEXTENSIBLE*)from;
 827         const WORD size = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 828
 829         /* Fail silently.. */
 830         if(from->cbSize < size) return DS_OK;
 831         if(fromx->Samples.wValidBitsPerSample > fromx->Format.wBitsPerSample)
 832             return DSERR_INVALIDPARAM;
 833
 834         if(IsEqualGUID(&fromx->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 835         {
 836             if(from->wBitsPerSample > 32)
 837                 return DSERR_INVALIDPARAM;
 838         }
 839         else if(IsEqualGUID(&fromx->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
 840         {
 841             if(from->wBitsPerSample != 32)
 842                 return DSERR_INVALIDPARAM;
 843         }
 844         else
 845         {
 846             ERR("Unhandled extensible format: %s\n", debugstr_guid(&fromx->SubFormat));
 847             return DSERR_INVALIDPARAM;
 848         }
 849
 850         wfe->Format.cbSize = size;
 851         wfe->Samples.wValidBitsPerSample = fromx->Samples.wValidBitsPerSample;
 852         if(!wfe->Samples.wValidBitsPerSample)
 853             wfe->Samples.wValidBitsPerSample = fromx->Format.wBitsPerSample;
 854         wfe->dwChannelMask = fromx->dwChannelMask;
 855         wfe->SubFormat = fromx->SubFormat;
 856     }
 857     else
 858     {
 859         ERR("Unhandled format tag %04x\n", from->wFormatTag);
 860         return DSERR_INVALIDPARAM;
 861     }
 862
 863     wfx->wFormatTag = from->wFormatTag;
 864     wfx->nChannels = from->nChannels;
 865     wfx->nSamplesPerSec = from->nSamplesPerSec;
 866     wfx->nAvgBytesPerSec = from->nSamplesPerSec * from->nBlockAlign;
 867     wfx->nBlockAlign = from->wBitsPerSample * from->nChannels / 8;
 868     wfx->wBitsPerSample = from->wBitsPerSample;
 869     return DS_OK;
 870 }
 871
 872 static HRESULT WINAPI DSPrimary_SetFormat(IDirectSoundBuffer *iface, const WAVEFORMATEX *wfx)
 873 {
 874     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 875     HRESULT hr = S_OK;
 876
 877     TRACE("(%p)->(%p)\n", iface, wfx);
 878
 879     if(!wfx)
 880     {
 881         WARN("Missing format\n");
 882         return DSERR_INVALIDPARAM;
 883     }
 884
 885     EnterCriticalSection(&This->share->crst);
 886
 887     if(This->parent->prio_level < DSSCL_PRIORITY)
 888     {
 889         hr = DSERR_PRIOLEVELNEEDED;
 890         goto out;
 891     }
 892
 893     TRACE("Requested primary format:\n"
 894           "    FormatTag      = %04x\n"
 895           "    Channels       = %u\n"
 896           "    SamplesPerSec  = %lu\n"
 897           "    AvgBytesPerSec = %lu\n"
 898           "    BlockAlign     = %u\n"
 899           "    BitsPerSample  = %u\n",
 900           wfx->wFormatTag, wfx->nChannels,
 901           wfx->nSamplesPerSec, wfx->nAvgBytesPerSec,
 902           wfx->nBlockAlign, wfx->wBitsPerSample);
 903
 904     hr = copy_waveformat(&This->format.Format, wfx);
 905     if(SUCCEEDED(hr) && This->write_emu)
 906     {
 907         DSBuffer *buf;
 908         DSBUFFERDESC desc;
 909
 910         IDirectSoundBuffer8_Release(This->write_emu);
 911         This->write_emu = NULL;
 912
 913         memset(&desc, 0, sizeof(desc));
 914         desc.dwSize = sizeof(desc);
 915         desc.dwFlags = DSBCAPS_LOCHARDWARE|DSBCAPS_CTRLPAN;
 916         desc.dwBufferBytes = This->buf_size - (This->buf_size % This->format.Format.nBlockAlign);
 917         desc.lpwfxFormat = &This->format.Format;
 918
 919         hr = DSBuffer_Create(&buf, This, NULL);
 920         if(FAILED(hr)) goto out;
 921
 922         This->write_emu = &buf->IDirectSoundBuffer8_iface;
 923         hr = DSBuffer_Initialize(This->write_emu, &This->parent->IDirectSound_iface, &desc);
 924         if(FAILED(hr))
 925         {
 926             IDirectSoundBuffer8_Release(This->write_emu);
 927             This->write_emu = NULL;
 928         }
 929     }
 930
 931 out:
 932     LeaveCriticalSection(&This->share->crst);
 933     return hr;
 934 }
 935
 936 static HRESULT WINAPI DSPrimary_SetVolume(IDirectSoundBuffer *iface, LONG vol)
 937 {
 938     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 939
 940     TRACE("(%p)->(%ld)\n", iface, vol);
 941
 942     if(vol > DSBVOLUME_MAX || vol < DSBVOLUME_MIN)
 943     {
 944         WARN("Invalid volume (%ld)\n", vol);
 945         return DSERR_INVALIDPARAM;
 946     }
 947
 948     if(!(This->flags&DSBCAPS_CTRLVOLUME))
 949         return DSERR_CONTROLUNAVAIL;
 950
 951     setALContext(This->ctx);
 952     alListenerf(AL_GAIN, mB_to_gain(vol));
 953     popALContext();
 954
 955     return DS_OK;
 956 }
 957
 958 static HRESULT WINAPI DSPrimary_SetPan(IDirectSoundBuffer *iface, LONG pan)
 959 {
 960     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 961     HRESULT hr;
 962
 963     TRACE("(%p)->(%ld)\n", iface, pan);
 964
 965     if(pan > DSBPAN_RIGHT || pan < DSBPAN_LEFT)
 966     {
 967         WARN("invalid parameter: pan = %ld\n", pan);
 968         return DSERR_INVALIDPARAM;
 969     }
 970
 971     EnterCriticalSection(&This->share->crst);
 972     if(!(This->flags&DSBCAPS_CTRLPAN))
 973     {
 974         WARN("control unavailable\n");
 975         hr = DSERR_CONTROLUNAVAIL;
 976     }
 977     else if(This->write_emu)
 978         hr = IDirectSoundBuffer8_SetPan(This->write_emu, pan);
 979     else
 980     {
 981         FIXME("Not supported\n");
 982         hr = E_NOTIMPL;
 983     }
 984     LeaveCriticalSection(&This->share->crst);
 985
 986     return hr;
 987 }
 988
 989 static HRESULT WINAPI DSPrimary_SetFrequency(IDirectSoundBuffer *iface, DWORD freq)
 990 {
 991     WARN("(%p)->(%lu)\n", iface, freq);
 992     return DSERR_CONTROLUNAVAIL;
 993 }
 994
 995 static HRESULT WINAPI DSPrimary_Stop(IDirectSoundBuffer *iface)
 996 {
 997     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 998     HRESULT hr = S_OK;
 999
1000     TRACE("(%p)->()\n", iface);
1001
1002     EnterCriticalSection(&This->share->crst);
1003     if(This->write_emu)
1004         hr = IDirectSoundBuffer8_Stop(This->write_emu);
1005     if(SUCCEEDED(hr))
1006         This->stopped = TRUE;
1007     LeaveCriticalSection(&This->share->crst);
1008
1009     return hr;
1010 }
1011
1012 static HRESULT WINAPI DSPrimary_Unlock(IDirectSoundBuffer *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
1013 {
1014     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
1015     HRESULT hr = DSERR_INVALIDCALL;
1016
1017     TRACE("(%p)->(%p, %lu, %p, %lu)\n", iface, ptr1, len1, ptr2, len2);
1018
1019     EnterCriticalSection(&This->share->crst);
1020     if(This->write_emu)
1021         hr = IDirectSoundBuffer8_Unlock(This->write_emu, ptr1, len1, ptr2, len2);
1022     LeaveCriticalSection(&This->share->crst);
1023
1024     return hr;
1025 }
1026
1027 static HRESULT WINAPI DSPrimary_Restore(IDirectSoundBuffer *iface)
1028 {
1029     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
1030     HRESULT hr = S_OK;
1031
1032     TRACE("(%p)->()\n", iface);
1033
1034     EnterCriticalSection(&This->share->crst);
1035     if(This->write_emu)
1036         hr = IDirectSoundBuffer8_Restore(This->write_emu);
1037     LeaveCriticalSection(&This->share->crst);
1038
1039     return hr;
1040 }
1041
1042 static const IDirectSoundBufferVtbl DSPrimary_Vtbl =
1043 {
1044     DSPrimary_QueryInterface,
1045     DSPrimary_AddRef,
1046     DSPrimary_Release,
1047     DSPrimary_GetCaps,
1048     DSPrimary_GetCurrentPosition,
1049     DSPrimary_GetFormat,
1050     DSPrimary_GetVolume,
1051     DSPrimary_GetPan,
1052     DSPrimary_GetFrequency,
1053     DSPrimary_GetStatus,
1054     DSPrimary_Initialize,
1055     DSPrimary_Lock,
1056     DSPrimary_Play,
1057     DSPrimary_SetCurrentPosition,
1058     DSPrimary_SetFormat,
1059     DSPrimary_SetVolume,
1060     DSPrimary_SetPan,
1061     DSPrimary_SetFrequency,
1062     DSPrimary_Stop,
1063     DSPrimary_Unlock,
1064     DSPrimary_Restore
1065 };
1066
1067
1068 static void DSPrimary_SetParams(DSPrimary *This, const DS3DLISTENER *params, LONG flags)
1069 {
1070     union PrimaryParamFlags dirty = { flags };
1071     DWORD i;
1072
1073     if(dirty.bit.pos)
1074         alListener3f(AL_POSITION, params->vPosition.x, params->vPosition.y,
1075                                  -params->vPosition.z);
1076     if(dirty.bit.vel)
1077         alListener3f(AL_VELOCITY, params->vVelocity.x, params->vVelocity.y,
1078                                  -params->vVelocity.z);
1079     if(dirty.bit.orientation)
1080     {
1081         ALfloat orient[6] = {
1082             params->vOrientFront.x, params->vOrientFront.y, -params->vOrientFront.z,
1083             params->vOrientTop.x, params->vOrientTop.y, -params->vOrientTop.z
1084         };
1085         alListenerfv(AL_ORIENTATION, orient);
1086     }
1087     if(dirty.bit.distancefactor)
1088     {
1089         alSpeedOfSound(343.3f/params->flDistanceFactor);
1090         if(HAS_EXTENSION(This->share, EXT_EFX))
1091             alListenerf(AL_METERS_PER_UNIT, params->flDistanceFactor);
1092     }
1093     if(dirty.bit.rollofffactor)
1094     {
1095         struct DSBufferGroup *bufgroup = This->BufferGroups;
1096         ALfloat rolloff = params->flRolloffFactor;
1097         This->rollofffactor = rolloff;
1098
1099         for(i = 0;i < This->NumBufferGroups;++i)
1100         {
1101             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
1102             while(usemask)
1103             {
1104                 int idx = CTZ64(usemask);
1105                 DSBuffer *buf = bufgroup[i].Buffers + idx;
1106                 usemask &= ~(U64(1) << idx);
1107
1108                 if(buf->source)
1109                     alSourcef(buf->source, AL_ROLLOFF_FACTOR,
1110                               buf->current.eax.flRolloffFactor + rolloff);
1111             }
1112         }
1113     }
1114     if(dirty.bit.dopplerfactor)
1115         alDopplerFactor(params->flDopplerFactor);
1116     if(dirty.bit.effect)
1117         alAuxiliaryEffectSloti(This->auxslot, AL_EFFECTSLOT_EFFECT, This->effect);
1118 }
1119
1120 static HRESULT WINAPI DSPrimary3D_QueryInterface(IDirectSound3DListener *iface, REFIID riid, void **ppv)
1121 {
1122     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1123     return DSPrimary_QueryInterface(&This->IDirectSoundBuffer_iface, riid, ppv);
1124 }
1125
1126 static ULONG WINAPI DSPrimary3D_AddRef(IDirectSound3DListener *iface)
1127 {
1128     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1129     LONG ret;
1130
1131     ret = InterlockedIncrement(&This->ds3d_ref);
1132     TRACE("(%p) ref %lu\n", iface, ret);
1133
1134     return ret;
1135 }
1136
1137 static ULONG WINAPI DSPrimary3D_Release(IDirectSound3DListener *iface)
1138 {
1139     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1140     LONG ret;
1141
1142     ret = InterlockedDecrement(&This->ds3d_ref);
1143     TRACE("(%p) ref %lu\n", iface, ret);
1144
1145     return ret;
1146 }
1147
1148
1149 static HRESULT WINAPI DSPrimary3D_GetDistanceFactor(IDirectSound3DListener *iface, D3DVALUE *distancefactor)
1150 {
1151     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1152
1153     TRACE("(%p)->(%p)\n", iface, distancefactor);
1154
1155     if(!distancefactor)
1156     {
1157         WARN("Invalid parameter %p\n", distancefactor);
1158         return DSERR_INVALIDPARAM;
1159     }
1160
1161     setALContext(This->ctx);
1162     *distancefactor = 343.3f/alGetFloat(AL_SPEED_OF_SOUND);
1163     checkALError();
1164     popALContext();
1165
1166     return S_OK;
1167 }
1168
1169 static HRESULT WINAPI DSPrimary3D_GetDopplerFactor(IDirectSound3DListener *iface, D3DVALUE *dopplerfactor)
1170 {
1171     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1172
1173     TRACE("(%p)->(%p)\n", iface, dopplerfactor);
1174
1175     if(!dopplerfactor)
1176     {
1177         WARN("Invalid parameter %p\n", dopplerfactor);
1178         return DSERR_INVALIDPARAM;
1179     }
1180
1181     setALContext(This->ctx);
1182     *dopplerfactor = alGetFloat(AL_DOPPLER_FACTOR);
1183     checkALError();
1184     popALContext();
1185
1186     return S_OK;
1187 }
1188
1189 static HRESULT WINAPI DSPrimary3D_GetOrientation(IDirectSound3DListener *iface, D3DVECTOR *front, D3DVECTOR *top)
1190 {
1191     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1192     ALfloat orient[6];
1193
1194     TRACE("(%p)->(%p, %p)\n", iface, front, top);
1195
1196     if(!front || !top)
1197     {
1198         WARN("Invalid parameter %p %p\n", front, top);
1199         return DSERR_INVALIDPARAM;
1200     }
1201
1202     setALContext(This->ctx);
1203     alGetListenerfv(AL_ORIENTATION, orient);
1204     checkALError();
1205     popALContext();
1206
1207     front->x =  orient[0];
1208     front->y =  orient[1];
1209     front->z = -orient[2];
1210     top->x =  orient[3];
1211     top->y =  orient[4];
1212     top->z = -orient[5];
1213     return S_OK;
1214 }
1215
1216 static HRESULT WINAPI DSPrimary3D_GetPosition(IDirectSound3DListener *iface, D3DVECTOR *pos)
1217 {
1218     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1219     ALfloat alpos[3];
1220
1221     TRACE("(%p)->(%p)\n", iface, pos);
1222
1223     if(!pos)
1224     {
1225         WARN("Invalid parameter %p\n", pos);
1226         return DSERR_INVALIDPARAM;
1227     }
1228
1229     setALContext(This->ctx);
1230     alGetListenerfv(AL_POSITION, alpos);
1231     checkALError();
1232     popALContext();
1233
1234     pos->x =  alpos[0];
1235     pos->y =  alpos[1];
1236     pos->z = -alpos[2];
1237     return S_OK;
1238 }
1239
1240 static HRESULT WINAPI DSPrimary3D_GetRolloffFactor(IDirectSound3DListener *iface, D3DVALUE *rollofffactor)
1241 {
1242     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1243
1244     TRACE("(%p)->(%p)\n", iface, rollofffactor);
1245
1246     if(!rollofffactor)
1247     {
1248         WARN("Invalid parameter %p\n", rollofffactor);
1249         return DSERR_INVALIDPARAM;
1250     }
1251
1252     EnterCriticalSection(&This->share->crst);
1253     *rollofffactor = This->rollofffactor;
1254     LeaveCriticalSection(&This->share->crst);
1255
1256     return S_OK;
1257 }
1258
1259 static HRESULT WINAPI DSPrimary3D_GetVelocity(IDirectSound3DListener *iface, D3DVECTOR *velocity)
1260 {
1261     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1262     ALfloat vel[3];
1263
1264     TRACE("(%p)->(%p)\n", iface, velocity);
1265
1266     if(!velocity)
1267     {
1268         WARN("Invalid parameter %p\n", velocity);
1269         return DSERR_INVALIDPARAM;
1270     }
1271
1272     setALContext(This->ctx);
1273     alGetListenerfv(AL_VELOCITY, vel);
1274     checkALError();
1275     popALContext();
1276
1277     velocity->x =  vel[0];
1278     velocity->y =  vel[1];
1279     velocity->z = -vel[2];
1280     return S_OK;
1281 }
1282
1283 static HRESULT WINAPI DSPrimary3D_GetAllParameters(IDirectSound3DListener *iface, DS3DLISTENER *listener)
1284 {
1285     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1286
1287     TRACE("(%p)->(%p)\n", iface, listener);
1288
1289     if(!listener || listener->dwSize < sizeof(*listener))
1290     {
1291         WARN("Invalid DS3DLISTENER %p %lu\n", listener, listener ? listener->dwSize : 0);
1292         return DSERR_INVALIDPARAM;
1293     }
1294
1295     EnterCriticalSection(&This->share->crst);
1296     setALContext(This->ctx);
1297     DSPrimary3D_GetPosition(iface, &listener->vPosition);
1298     DSPrimary3D_GetVelocity(iface, &listener->vVelocity);
1299     DSPrimary3D_GetOrientation(iface, &listener->vOrientFront, &listener->vOrientTop);
1300     DSPrimary3D_GetDistanceFactor(iface, &listener->flDistanceFactor);
1301     DSPrimary3D_GetRolloffFactor(iface, &listener->flRolloffFactor);
1302     DSPrimary3D_GetDopplerFactor(iface, &listener->flDopplerFactor);
1303     popALContext();
1304     LeaveCriticalSection(&This->share->crst);
1305
1306     return DS_OK;
1307 }
1308
1309
1310 static HRESULT WINAPI DSPrimary3D_SetDistanceFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1311 {
1312     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1313
1314     TRACE("(%p)->(%f, %lu)\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->share->crst);
1326         This->deferred.ds3d.flDistanceFactor = factor;
1327         This->dirty.bit.distancefactor = 1;
1328         LeaveCriticalSection(&This->share->crst);
1329     }
1330     else
1331     {
1332         setALContext(This->ctx);
1333         alSpeedOfSound(343.3f/factor);
1334         if(HAS_EXTENSION(This->share, 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 DSPrimary3D_SetDopplerFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1344 {
1345     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1346
1347     TRACE("(%p)->(%f, %lu)\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->share->crst);
1359         This->deferred.ds3d.flDopplerFactor = factor;
1360         This->dirty.bit.dopplerfactor = 1;
1361         LeaveCriticalSection(&This->share->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 DSPrimary3D_SetOrientation(IDirectSound3DListener *iface, D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront, D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop, DWORD apply)
1375 {
1376     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1377
1378     TRACE("(%p)->(%f, %f, %f, %f, %f, %f, %lu)\n", iface, xFront, yFront, zFront, xTop, yTop, zTop, apply);
1379
1380     if(apply == DS3D_DEFERRED)
1381     {
1382         EnterCriticalSection(&This->share->crst);
1383         This->deferred.ds3d.vOrientFront.x = xFront;
1384         This->deferred.ds3d.vOrientFront.y = yFront;
1385         This->deferred.ds3d.vOrientFront.z = zFront;
1386         This->deferred.ds3d.vOrientTop.x = xTop;
1387         This->deferred.ds3d.vOrientTop.y = yTop;
1388         This->deferred.ds3d.vOrientTop.z = zTop;
1389         This->dirty.bit.orientation = 1;
1390         LeaveCriticalSection(&This->share->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 DSPrimary3D_SetPosition(IDirectSound3DListener *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
1408 {
1409     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1410
1411     TRACE("(%p)->(%f, %f, %f, %lu)\n", iface, x, y, z, apply);
1412
1413     if(apply == DS3D_DEFERRED)
1414     {
1415         EnterCriticalSection(&This->share->crst);
1416         This->deferred.ds3d.vPosition.x = x;
1417         This->deferred.ds3d.vPosition.y = y;
1418         This->deferred.ds3d.vPosition.z = z;
1419         This->dirty.bit.pos = 1;
1420         LeaveCriticalSection(&This->share->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 DSPrimary3D_SetRolloffFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1434 {
1435     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1436
1437     TRACE("(%p)->(%f, %lu)\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->share->crst);
1447     if(apply == DS3D_DEFERRED)
1448     {
1449         This->deferred.ds3d.flRolloffFactor = factor;
1450         This->dirty.bit.rollofffactor = 1;
1451     }
1452     else
1453     {
1454         struct DSBufferGroup *bufgroup = This->BufferGroups;
1455         DWORD i;
1456
1457         This->rollofffactor = factor;
1458
1459         setALContext(This->ctx);
1460         for(i = 0;i < This->NumBufferGroups;++i)
1461         {
1462             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
1463             while(usemask)
1464             {
1465                 int idx = CTZ64(usemask);
1466                 DSBuffer *buf = bufgroup[i].Buffers + idx;
1467                 usemask &= ~(U64(1) << idx);
1468
1469                 if(buf->source)
1470                     alSourcef(buf->source, AL_ROLLOFF_FACTOR,
1471                               buf->current.eax.flRolloffFactor + factor);
1472             }
1473         }
1474         checkALError();
1475         popALContext();
1476     }
1477     LeaveCriticalSection(&This->share->crst);
1478
1479     return S_OK;
1480 }
1481
1482 static HRESULT WINAPI DSPrimary3D_SetVelocity(IDirectSound3DListener *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
1483 {
1484     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1485
1486     TRACE("(%p)->(%f, %f, %f, %lu)\n", iface, x, y, z, apply);
1487
1488     if(apply == DS3D_DEFERRED)
1489     {
1490         EnterCriticalSection(&This->share->crst);
1491         This->deferred.ds3d.vVelocity.x = x;
1492         This->deferred.ds3d.vVelocity.y = y;
1493         This->deferred.ds3d.vVelocity.z = z;
1494         This->dirty.bit.vel = 1;
1495         LeaveCriticalSection(&This->share->crst);
1496     }
1497     else
1498     {
1499         setALContext(This->ctx);
1500         alListener3f(AL_VELOCITY, x, y, -z);
1501         checkALError();
1502         popALContext();
1503     }
1504
1505     return S_OK;
1506 }
1507
1508 static HRESULT WINAPI DSPrimary3D_SetAllParameters(IDirectSound3DListener *iface, const DS3DLISTENER *listen, DWORD apply)
1509 {
1510     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1511
1512     TRACE("(%p)->(%p, %lu)\n", iface, listen, apply);
1513
1514     if(!listen || listen->dwSize < sizeof(*listen))
1515     {
1516         WARN("Invalid parameter %p %lu\n", listen, listen ? listen->dwSize : 0);
1517         return DSERR_INVALIDPARAM;
1518     }
1519
1520     if(listen->flDistanceFactor > DS3D_MAXDISTANCEFACTOR ||
1521        listen->flDistanceFactor < DS3D_MINDISTANCEFACTOR)
1522     {
1523         WARN("Invalid distance factor (%f)\n", listen->flDistanceFactor);
1524         return DSERR_INVALIDPARAM;
1525     }
1526
1527     if(listen->flDopplerFactor > DS3D_MAXDOPPLERFACTOR ||
1528        listen->flDopplerFactor < DS3D_MINDOPPLERFACTOR)
1529     {
1530         WARN("Invalid doppler factor (%f)\n", listen->flDopplerFactor);
1531         return DSERR_INVALIDPARAM;
1532     }
1533
1534     if(listen->flRolloffFactor < DS3D_MINROLLOFFFACTOR ||
1535        listen->flRolloffFactor > DS3D_MAXROLLOFFFACTOR)
1536     {
1537         WARN("Invalid rolloff factor (%f)\n", listen->flRolloffFactor);
1538         return DSERR_INVALIDPARAM;
1539     }
1540
1541     if(apply == DS3D_DEFERRED)
1542     {
1543         EnterCriticalSection(&This->share->crst);
1544         This->deferred.ds3d = *listen;
1545         This->deferred.ds3d.dwSize = sizeof(This->deferred.ds3d);
1546         This->dirty.bit.pos = 1;
1547         This->dirty.bit.vel = 1;
1548         This->dirty.bit.orientation = 1;
1549         This->dirty.bit.distancefactor = 1;
1550         This->dirty.bit.rollofffactor = 1;
1551         This->dirty.bit.dopplerfactor = 1;
1552         LeaveCriticalSection(&This->share->crst);
1553     }
1554     else
1555     {
1556         union PrimaryParamFlags dirty = { 0l };
1557         dirty.bit.pos = 1;
1558         dirty.bit.vel = 1;
1559         dirty.bit.orientation = 1;
1560         dirty.bit.distancefactor = 1;
1561         dirty.bit.rollofffactor = 1;
1562         dirty.bit.dopplerfactor = 1;
1563
1564         EnterCriticalSection(&This->share->crst);
1565         setALContext(This->ctx);
1566         DSPrimary_SetParams(This, listen, dirty.flags);
1567         checkALError();
1568         popALContext();
1569         LeaveCriticalSection(&This->share->crst);
1570     }
1571
1572     return S_OK;
1573 }
1574
1575 HRESULT WINAPI DSPrimary3D_CommitDeferredSettings(IDirectSound3DListener *iface)
1576 {
1577     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1578     struct DSBufferGroup *bufgroup;
1579     LONG flags;
1580     DWORD i;
1581
1582     EnterCriticalSection(&This->share->crst);
1583     setALContext(This->ctx);
1584     alDeferUpdatesSOFT();
1585
1586     if((flags=InterlockedExchange(&This->dirty.flags, 0)) != 0)
1587     {
1588         DSPrimary_SetParams(This, &This->deferred.ds3d, flags);
1589         /* checkALError is here for debugging */
1590         checkALError();
1591     }
1592     TRACE("Dirty flags was: 0x%02lx\n", flags);
1593
1594     bufgroup = This->BufferGroups;
1595     for(i = 0;i < This->NumBufferGroups;++i)
1596     {
1597         DWORD64 usemask = ~bufgroup[i].FreeBuffers;
1598         while(usemask)
1599         {
1600             int idx = CTZ64(usemask);
1601             DSBuffer *buf = bufgroup[i].Buffers + idx;
1602             usemask &= ~(U64(1) << idx);
1603
1604             if((flags=InterlockedExchange(&buf->dirty.flags, 0)) != 0)
1605                 DSBuffer_SetParams(buf, &buf->deferred.ds3d, &buf->deferred.eax, flags);
1606         }
1607     }
1608     alProcessUpdatesSOFT();
1609     checkALError();
1610
1611     popALContext();
1612     LeaveCriticalSection(&This->share->crst);
1613
1614     return DS_OK;
1615 }
1616
1617 static const IDirectSound3DListenerVtbl DSPrimary3D_Vtbl =
1618 {
1619     DSPrimary3D_QueryInterface,
1620     DSPrimary3D_AddRef,
1621     DSPrimary3D_Release,
1622     DSPrimary3D_GetAllParameters,
1623     DSPrimary3D_GetDistanceFactor,
1624     DSPrimary3D_GetDopplerFactor,
1625     DSPrimary3D_GetOrientation,
1626     DSPrimary3D_GetPosition,
1627     DSPrimary3D_GetRolloffFactor,
1628     DSPrimary3D_GetVelocity,
1629     DSPrimary3D_SetAllParameters,
1630     DSPrimary3D_SetDistanceFactor,
1631     DSPrimary3D_SetDopplerFactor,
1632     DSPrimary3D_SetOrientation,
1633     DSPrimary3D_SetPosition,
1634     DSPrimary3D_SetRolloffFactor,
1635     DSPrimary3D_SetVelocity,
1636     DSPrimary3D_CommitDeferredSettings
1637 };
1638
1639
1640 static HRESULT WINAPI DSPrimaryProp_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
1641 {
1642     DSPrimary *This = impl_from_IKsPropertySet(iface);
1643     return DSPrimary_QueryInterface(&This->IDirectSoundBuffer_iface, riid, ppv);
1644 }
1645
1646 static ULONG WINAPI DSPrimaryProp_AddRef(IKsPropertySet *iface)
1647 {
1648     DSPrimary *This = impl_from_IKsPropertySet(iface);
1649     LONG ret;
1650
1651     ret = InterlockedIncrement(&This->prop_ref);
1652     TRACE("(%p) ref %lu\n", iface, ret);
1653
1654     return ret;
1655 }
1656
1657 static ULONG WINAPI DSPrimaryProp_Release(IKsPropertySet *iface)
1658 {
1659     DSPrimary *This = impl_from_IKsPropertySet(iface);
1660     LONG ret;
1661
1662     ret = InterlockedDecrement(&This->prop_ref);
1663     TRACE("(%p) ref %lu\n", iface, ret);
1664
1665     return ret;
1666 }
1667
1668 static HRESULT WINAPI DSPrimaryProp_Get(IKsPropertySet *iface,
1669   REFGUID guidPropSet, ULONG dwPropID,
1670   LPVOID pInstanceData, ULONG cbInstanceData,
1671   LPVOID pPropData, ULONG cbPropData,
1672   ULONG *pcbReturned)
1673 {
1674     (void)iface;
1675     (void)dwPropID;
1676     (void)pInstanceData;
1677     (void)cbInstanceData;
1678     (void)pPropData;
1679     (void)cbPropData;
1680     (void)pcbReturned;
1681
1682     FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
1683
1684     return E_PROP_ID_UNSUPPORTED;
1685 }
1686
1687 static HRESULT WINAPI DSPrimaryProp_Set(IKsPropertySet *iface,
1688   REFGUID guidPropSet, ULONG dwPropID,
1689   LPVOID pInstanceData, ULONG cbInstanceData,
1690   LPVOID pPropData, ULONG cbPropData)
1691 {
1692     (void)iface;
1693     (void)dwPropID;
1694     (void)pInstanceData;
1695     (void)cbInstanceData;
1696     (void)pPropData;
1697     (void)cbPropData;
1698
1699     FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
1700
1701     return E_PROP_ID_UNSUPPORTED;
1702 }
1703
1704 static HRESULT WINAPI DSPrimaryProp_QuerySupport(IKsPropertySet *iface,
1705   REFGUID guidPropSet, ULONG dwPropID,
1706   ULONG *pTypeSupport)
1707 {
1708     (void)iface;
1709     (void)pTypeSupport;
1710
1711     FIXME("Unhandled propset: %s (propid: %lu)\n", debugstr_guid(guidPropSet), dwPropID);
1712
1713     return E_PROP_ID_UNSUPPORTED;
1714 }
1715
1716 static const IKsPropertySetVtbl DSPrimaryProp_Vtbl =
1717 {
1718     DSPrimaryProp_QueryInterface,
1719     DSPrimaryProp_AddRef,
1720     DSPrimaryProp_Release,
1721     DSPrimaryProp_Get,
1722     DSPrimaryProp_Set,
1723     DSPrimaryProp_QuerySupport
1724 };