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 IDirectSoundBufferVtbl DSPrimary_Vtbl;
  41 static IDirectSound3DListenerVtbl DSPrimary3D_Vtbl;
  42 static 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", (int)(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", (int)(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", (int)(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
 299     wfx = &This->format.Format;
 300     wfx->wFormatTag = WAVE_FORMAT_PCM;
 301     wfx->nChannels = 2;
 302     wfx->wBitsPerSample = 8;
 303     wfx->nSamplesPerSec = 22050;
 304     wfx->nBlockAlign = wfx->wBitsPerSample * wfx->nChannels / 8;
 305     wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign;
 306     wfx->cbSize = 0;
 307
 308     This->stopped = TRUE;
 309
 310     /* Apparently primary buffer size is always 32k,
 311      * tested on windows with 192k 24 bits sound @ 6 channels
 312      * where it will run out in 60 ms and it isn't pointer aligned
 313      */
 314     This->buf_size = 32768;
 315
 316     num_srcs = This->share->sources.maxhw_alloc + This->share->sources.maxsw_alloc;
 317
 318     hr = DSERR_OUTOFMEMORY;
 319     This->notifies = HeapAlloc(GetProcessHeap(), 0, num_srcs*sizeof(*This->notifies));
 320     if(!This->notifies) goto fail;
 321     This->sizenotifies = num_srcs;
 322
 323     count = (MAX_HWBUFFERS+63) / 64;
 324     This->BufferGroups = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 325                                    count*sizeof(*This->BufferGroups));
 326     if(!This->BufferGroups) goto fail;
 327
 328     for(i = 0;i < count;++i)
 329     {
 330         This->BufferGroups[i].Buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 331                                                   64*sizeof(This->BufferGroups[0].Buffers[0]));
 332         if(!This->BufferGroups[i].Buffers)
 333         {
 334             while(i > 0)
 335                 HeapFree(GetProcessHeap(), 0, This->BufferGroups[--i].Buffers);
 336             HeapFree(GetProcessHeap(), 0, This->BufferGroups);
 337             This->BufferGroups = NULL;
 338             goto fail;
 339         }
 340         This->BufferGroups[i].FreeBuffers = ~(DWORD64)0;
 341     }
 342     This->NumBufferGroups = count;
 343
 344     return S_OK;
 345
 346 fail:
 347     DSPrimary_Clear(This);
 348     return hr;
 349 }
 350
 351 void DSPrimary_Clear(DSPrimary *This)
 352 {
 353     struct DSBufferGroup *bufgroup;
 354     DWORD i;
 355
 356     if(!This->parent)
 357         return;
 358
 359     bufgroup = This->BufferGroups;
 360     for(i = 0;i < This->NumBufferGroups;++i)
 361     {
 362         DWORD64 usemask = ~bufgroup[i].FreeBuffers;
 363         while(usemask)
 364         {
 365             int idx = CTZ64(usemask);
 366             DSBuffer *buf = bufgroup[i].Buffers + idx;
 367             usemask &= ~(U64(1) << idx);
 368
 369             DSBuffer_Destroy(buf);
 370         }
 371         HeapFree(GetProcessHeap(), 0, This->BufferGroups[i].Buffers);
 372     }
 373
 374     HeapFree(GetProcessHeap(), 0, This->BufferGroups);
 375     HeapFree(GetProcessHeap(), 0, This->notifies);
 376     memset(This, 0, sizeof(*This));
 377 }
 378
 379 static HRESULT WINAPI DSPrimary_QueryInterface(IDirectSoundBuffer *iface, REFIID riid, LPVOID *ppv)
 380 {
 381     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 382
 383     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 384
 385     *ppv = NULL;
 386     if(IsEqualIID(riid, &IID_IUnknown) ||
 387        IsEqualIID(riid, &IID_IDirectSoundBuffer))
 388         *ppv = &This->IDirectSoundBuffer_iface;
 389     else if(IsEqualIID(riid, &IID_IDirectSound3DListener))
 390     {
 391         if((This->flags&DSBCAPS_CTRL3D))
 392             *ppv = &This->IDirectSound3DListener_iface;
 393     }
 394     else if(IsEqualIID(riid, &IID_IKsPropertySet))
 395         *ppv = &This->IKsPropertySet_iface;
 396     else
 397         FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
 398
 399     if(*ppv)
 400     {
 401         IUnknown_AddRef((IUnknown*)*ppv);
 402         return S_OK;
 403     }
 404
 405     return E_NOINTERFACE;
 406 }
 407
 408 static ULONG WINAPI DSPrimary_AddRef(IDirectSoundBuffer *iface)
 409 {
 410     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 411     LONG ret;
 412
 413     ret = InterlockedIncrement(&This->ref);
 414     if(ret == 1) This->flags = 0;
 415     TRACE("(%p) ref %lu\n", iface, ret);
 416
 417     return ret;
 418 }
 419
 420 static ULONG WINAPI DSPrimary_Release(IDirectSoundBuffer *iface)
 421 {
 422     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 423     LONG ref, oldval;
 424
 425     oldval = *(volatile LONG*)&This->ref;
 426     do {
 427         ref = oldval;
 428         if(ref)
 429         {
 430             --ref;
 431             oldval = InterlockedCompareExchange(&This->ref, ref, ref+1)-1;
 432         }
 433     } while(oldval != ref);
 434     TRACE("(%p) ref %lu\n", iface, ref);
 435
 436     return ref;
 437 }
 438
 439 static HRESULT WINAPI DSPrimary_GetCaps(IDirectSoundBuffer *iface, DSBCAPS *caps)
 440 {
 441     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 442
 443     TRACE("(%p)->(%p)\n", iface, caps);
 444
 445     if(!caps || caps->dwSize < sizeof(*caps))
 446     {
 447         WARN("Invalid DSBCAPS (%p, %lu)\n", caps, caps ? caps->dwSize : 0);
 448         return DSERR_INVALIDPARAM;
 449     }
 450
 451     caps->dwFlags = This->flags;
 452     caps->dwBufferBytes = This->buf_size;
 453     caps->dwUnlockTransferRate = 0;
 454     caps->dwPlayCpuOverhead = 0;
 455
 456     return DS_OK;
 457 }
 458
 459 static HRESULT WINAPI DSPrimary_GetCurrentPosition(IDirectSoundBuffer *iface, DWORD *playpos, DWORD *curpos)
 460 {
 461     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 462     HRESULT hr = DSERR_PRIOLEVELNEEDED;
 463
 464     EnterCriticalSection(&This->share->crst);
 465     if(This->write_emu)
 466         hr = IDirectSoundBuffer_GetCurrentPosition(This->write_emu, playpos, curpos);
 467     LeaveCriticalSection(&This->share->crst);
 468
 469     return hr;
 470 }
 471
 472 static HRESULT WINAPI DSPrimary_GetFormat(IDirectSoundBuffer *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
 473 {
 474     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 475     HRESULT hr = S_OK;
 476     UINT size;
 477
 478     if(!wfx && !written)
 479     {
 480         WARN("Cannot report format or format size\n");
 481         return DSERR_INVALIDPARAM;
 482     }
 483
 484     EnterCriticalSection(&This->share->crst);
 485     size = sizeof(This->format.Format) + This->format.Format.cbSize;
 486     if(written)
 487         *written = size;
 488     if(wfx)
 489     {
 490         if(allocated < size)
 491             hr = DSERR_INVALIDPARAM;
 492         else
 493             memcpy(wfx, &This->format.Format, size);
 494     }
 495     LeaveCriticalSection(&This->share->crst);
 496
 497     return hr;
 498 }
 499
 500 static HRESULT WINAPI DSPrimary_GetVolume(IDirectSoundBuffer *iface, LONG *volume)
 501 {
 502     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 503     ALfloat gain;
 504
 505     TRACE("(%p)->(%p)\n", iface, volume);
 506
 507     if(!volume)
 508         return DSERR_INVALIDPARAM;
 509     *volume = 0;
 510
 511     if(!(This->flags&DSBCAPS_CTRLVOLUME))
 512         return DSERR_CONTROLUNAVAIL;
 513
 514     setALContext(This->ctx);
 515     alGetListenerf(AL_GAIN, &gain);
 516     checkALError();
 517     popALContext();
 518
 519     *volume = clampI(gain_to_mB(gain), DSBVOLUME_MIN, DSBVOLUME_MAX);
 520     return DS_OK;
 521 }
 522
 523 static HRESULT WINAPI DSPrimary_GetPan(IDirectSoundBuffer *iface, LONG *pan)
 524 {
 525     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 526     HRESULT hr = DS_OK;
 527
 528     WARN("(%p)->(%p): semi-stub\n", iface, pan);
 529
 530     if(!pan)
 531         return DSERR_INVALIDPARAM;
 532
 533     EnterCriticalSection(&This->share->crst);
 534     if(This->write_emu)
 535         hr = IDirectSoundBuffer_GetPan(This->write_emu, pan);
 536     else if(!(This->flags & DSBCAPS_CTRLPAN))
 537         hr = DSERR_CONTROLUNAVAIL;
 538     else
 539         *pan = 0;
 540     LeaveCriticalSection(&This->share->crst);
 541
 542     return hr;
 543 }
 544
 545 static HRESULT WINAPI DSPrimary_GetFrequency(IDirectSoundBuffer *iface, DWORD *freq)
 546 {
 547     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 548     HRESULT hr = DS_OK;
 549
 550     WARN("(%p)->(%p): semi-stub\n", iface, freq);
 551
 552     if(!freq)
 553         return DSERR_INVALIDPARAM;
 554
 555     if(!(This->flags&DSBCAPS_CTRLFREQUENCY))
 556         return DSERR_CONTROLUNAVAIL;
 557
 558     EnterCriticalSection(&This->share->crst);
 559     *freq = This->format.Format.nSamplesPerSec;
 560     LeaveCriticalSection(&This->share->crst);
 561
 562     return hr;
 563 }
 564
 565 static HRESULT WINAPI DSPrimary_GetStatus(IDirectSoundBuffer *iface, DWORD *status)
 566 {
 567     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 568
 569     TRACE("(%p)->(%p)\n", iface, status);
 570
 571     if(!status)
 572         return DSERR_INVALIDPARAM;
 573
 574     EnterCriticalSection(&This->share->crst);
 575     *status = DSBSTATUS_PLAYING|DSBSTATUS_LOOPING;
 576     if((This->flags&DSBCAPS_LOCDEFER))
 577         *status |= DSBSTATUS_LOCHARDWARE;
 578
 579     if(This->stopped)
 580     {
 581         struct DSBufferGroup *bufgroup = This->BufferGroups;
 582         DWORD i, state = 0;
 583         HRESULT hr;
 584
 585         for(i = 0;i < This->NumBufferGroups;++i)
 586         {
 587             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
 588             while(usemask)
 589             {
 590                 int idx = CTZ64(usemask);
 591                 DSBuffer *buf = bufgroup[i].Buffers + idx;
 592                 usemask &= ~(U64(1) << idx);
 593
 594                 hr = DSBuffer_GetStatus(&buf->IDirectSoundBuffer8_iface, &state);
 595                 if(SUCCEEDED(hr) && (state&DSBSTATUS_PLAYING)) break;
 596             }
 597         }
 598         if(!(state&DSBSTATUS_PLAYING))
 599         {
 600             /* Primary stopped and no buffers playing.. */
 601             *status = 0;
 602         }
 603     }
 604     LeaveCriticalSection(&This->share->crst);
 605
 606     return DS_OK;
 607 }
 608
 609 HRESULT WINAPI DSPrimary_Initialize(IDirectSoundBuffer *iface, IDirectSound *ds, const DSBUFFERDESC *desc)
 610 {
 611     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 612     HRESULT hr;
 613
 614     TRACE("(%p)->(%p, %p)\n", iface, ds, desc);
 615
 616     if(!desc || desc->lpwfxFormat || desc->dwBufferBytes)
 617     {
 618         WARN("Bad DSBDESC for primary buffer\n");
 619         return DSERR_INVALIDPARAM;
 620     }
 621     if((desc->dwFlags&DSBCAPS_CTRLFX) ||
 622        (desc->dwFlags&DSBCAPS_CTRLPOSITIONNOTIFY) ||
 623        (desc->dwFlags&DSBCAPS_LOCSOFTWARE))
 624     {
 625         WARN("Bad dwFlags %08lx\n", desc->dwFlags);
 626         return DSERR_INVALIDPARAM;
 627     }
 628
 629     /* Should be 0 if not initialized */
 630     if(This->flags)
 631         return DSERR_ALREADYINITIALIZED;
 632
 633     hr = DS_OK;
 634     if(This->parent->prio_level == DSSCL_WRITEPRIMARY)
 635     {
 636         DSBUFFERDESC emudesc;
 637         DSBuffer *emu;
 638
 639         if(This->write_emu)
 640         {
 641             ERR("There shouldn't be a write_emu!\n");
 642             IDirectSoundBuffer_Release(This->write_emu);
 643             This->write_emu = NULL;
 644         }
 645
 646         memset(&emudesc, 0, sizeof(emudesc));
 647         emudesc.dwSize = sizeof(emudesc);
 648         emudesc.dwFlags = DSBCAPS_LOCHARDWARE | (desc->dwFlags&DSBCAPS_CTRLPAN);
 649         /* Dont play last incomplete sample */
 650         emudesc.dwBufferBytes = This->buf_size - (This->buf_size%This->format.Format.nBlockAlign);
 651         emudesc.lpwfxFormat = &This->format.Format;
 652
 653         hr = DSBuffer_Create(&emu, This, NULL);
 654         if(SUCCEEDED(hr))
 655         {
 656             hr = DSBuffer_Initialize(&emu->IDirectSoundBuffer8_iface, ds, &emudesc);
 657             if(SUCCEEDED(hr))
 658                 hr = DSBuffer_GetInterface(emu, &IID_IDirectSoundBuffer, (void**)&This->write_emu);
 659             if(FAILED(hr))
 660                 DSBuffer_Destroy(emu);
 661         }
 662     }
 663
 664     if(SUCCEEDED(hr))
 665     {
 666         This->current.ds3d.dwSize = sizeof(This->current.ds3d);
 667         This->current.ds3d.vPosition.x = 0.0f;
 668         This->current.ds3d.vPosition.y = 0.0f;
 669         This->current.ds3d.vPosition.z = 0.0f;
 670         This->current.ds3d.vVelocity.x = 0.0f;
 671         This->current.ds3d.vVelocity.y = 0.0f;
 672         This->current.ds3d.vVelocity.z = 0.0f;
 673         This->current.ds3d.vOrientFront.x = 0.0f;
 674         This->current.ds3d.vOrientFront.y = 0.0f;
 675         This->current.ds3d.vOrientFront.z = 1.0f;
 676         This->current.ds3d.vOrientTop.x = 0.0f;
 677         This->current.ds3d.vOrientTop.y = 1.0f;
 678         This->current.ds3d.vOrientTop.z = 0.0f;
 679         This->current.ds3d.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
 680         This->current.ds3d.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
 681         This->current.ds3d.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
 682         This->deferred.ds3d = This->current.ds3d;
 683
 684         This->flags = desc->dwFlags | DSBCAPS_LOCHARDWARE;
 685
 686         if((This->flags&DSBCAPS_CTRL3D))
 687         {
 688             union PrimaryParamFlags dirty = { 0l };
 689
 690             dirty.bit.pos = 1;
 691             dirty.bit.vel = 1;
 692             dirty.bit.orientation = 1;
 693             dirty.bit.distancefactor = 1;
 694             dirty.bit.rollofffactor = 1;
 695             dirty.bit.dopplerfactor = 1;
 696             DSPrimary_SetParams(This, &This->deferred.ds3d, dirty.flags);
 697         }
 698     }
 699     return hr;
 700 }
 701
 702 static HRESULT WINAPI DSPrimary_Lock(IDirectSoundBuffer *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
 703 {
 704     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 705     HRESULT hr = DSERR_PRIOLEVELNEEDED;
 706
 707     TRACE("(%p)->(%lu, %lu, %p, %p, %p, %p, %lu)\n", iface, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 708
 709     EnterCriticalSection(&This->share->crst);
 710     if(This->write_emu)
 711         hr = IDirectSoundBuffer_Lock(This->write_emu, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 712     LeaveCriticalSection(&This->share->crst);
 713
 714     return hr;
 715 }
 716
 717 static HRESULT WINAPI DSPrimary_Play(IDirectSoundBuffer *iface, DWORD res1, DWORD res2, DWORD flags)
 718 {
 719     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 720     HRESULT hr;
 721
 722     TRACE("(%p)->(%lu, %lu, %lu)\n", iface, res1, res2, flags);
 723
 724     if(!(flags & DSBPLAY_LOOPING))
 725     {
 726         WARN("Flags (%08lx) not set to DSBPLAY_LOOPING\n", flags);
 727         return DSERR_INVALIDPARAM;
 728     }
 729
 730     EnterCriticalSection(&This->share->crst);
 731     hr = S_OK;
 732     if(This->write_emu)
 733         hr = IDirectSoundBuffer_Play(This->write_emu, res1, res2, flags);
 734     if(SUCCEEDED(hr))
 735         This->stopped = FALSE;
 736     LeaveCriticalSection(&This->share->crst);
 737
 738     return hr;
 739 }
 740
 741 static HRESULT WINAPI DSPrimary_SetCurrentPosition(IDirectSoundBuffer *iface, DWORD pos)
 742 {
 743     WARN("(%p)->(%lu)\n", iface, pos);
 744     return DSERR_INVALIDCALL;
 745 }
 746
 747 /* Just assume the format is crap, and clean up the damage */
 748 static HRESULT copy_waveformat(WAVEFORMATEX *wfx, const WAVEFORMATEX *from)
 749 {
 750     if(from->nChannels <= 0)
 751     {
 752         WARN("Invalid Channels %d\n", from->nChannels);
 753         return DSERR_INVALIDPARAM;
 754     }
 755     if(from->nSamplesPerSec < DSBFREQUENCY_MIN || from->nSamplesPerSec > DSBFREQUENCY_MAX)
 756     {
 757         WARN("Invalid SamplesPerSec %lu\n", from->nSamplesPerSec);
 758         return DSERR_INVALIDPARAM;
 759     }
 760     if(from->nBlockAlign <= 0)
 761     {
 762         WARN("Invalid BlockAlign %d\n", from->nBlockAlign);
 763         return DSERR_INVALIDPARAM;
 764     }
 765     if(from->wBitsPerSample == 0 || (from->wBitsPerSample%8) != 0)
 766     {
 767         WARN("Invalid BitsPerSample %d\n", from->wBitsPerSample);
 768         return DSERR_INVALIDPARAM;
 769     }
 770     if(from->nBlockAlign != from->nChannels*from->wBitsPerSample/8)
 771     {
 772         WARN("Invalid BlockAlign %d (expected %u = %u*%u/8)\n",
 773              from->nBlockAlign, from->nChannels*from->wBitsPerSample/8,
 774              from->nChannels, from->wBitsPerSample);
 775         return DSERR_INVALIDPARAM;
 776     }
 777     if(from->nAvgBytesPerSec != from->nBlockAlign*from->nSamplesPerSec)
 778     {
 779         WARN("Invalid AvgBytesPerSec %lu (expected %lu = %lu*%u)\n",
 780              from->nAvgBytesPerSec, from->nSamplesPerSec*from->nBlockAlign,
 781              from->nSamplesPerSec, from->nBlockAlign);
 782         return DSERR_INVALIDPARAM;
 783     }
 784
 785     if(from->wFormatTag == WAVE_FORMAT_PCM)
 786     {
 787         if(from->wBitsPerSample > 32)
 788             return DSERR_INVALIDPARAM;
 789         wfx->cbSize = 0;
 790     }
 791     else if(from->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
 792     {
 793         if(from->wBitsPerSample != 32)
 794             return DSERR_INVALIDPARAM;
 795         wfx->cbSize = 0;
 796     }
 797     else if(from->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 798     {
 799         WAVEFORMATEXTENSIBLE *wfe = (WAVEFORMATEXTENSIBLE*)wfx;
 800         const WAVEFORMATEXTENSIBLE *fromx = (const WAVEFORMATEXTENSIBLE*)from;
 801         const WORD size = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 802
 803         /* Fail silently.. */
 804         if(from->cbSize < size) return DS_OK;
 805         if(fromx->Samples.wValidBitsPerSample > fromx->Format.wBitsPerSample)
 806             return DSERR_INVALIDPARAM;
 807
 808         if(IsEqualGUID(&fromx->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 809         {
 810             if(from->wBitsPerSample > 32)
 811                 return DSERR_INVALIDPARAM;
 812         }
 813         else if(IsEqualGUID(&fromx->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
 814         {
 815             if(from->wBitsPerSample != 32)
 816                 return DSERR_INVALIDPARAM;
 817         }
 818         else
 819         {
 820             ERR("Unhandled extensible format: %s\n", debugstr_guid(&fromx->SubFormat));
 821             return DSERR_INVALIDPARAM;
 822         }
 823
 824         wfe->Format.cbSize = size;
 825         wfe->Samples.wValidBitsPerSample = fromx->Samples.wValidBitsPerSample;
 826         if(!wfe->Samples.wValidBitsPerSample)
 827             wfe->Samples.wValidBitsPerSample = fromx->Format.wBitsPerSample;
 828         wfe->dwChannelMask = fromx->dwChannelMask;
 829         wfe->SubFormat = fromx->SubFormat;
 830     }
 831     else
 832     {
 833         ERR("Unhandled format tag %04x\n", from->wFormatTag);
 834         return DSERR_INVALIDPARAM;
 835     }
 836
 837     wfx->wFormatTag = from->wFormatTag;
 838     wfx->nChannels = from->nChannels;
 839     wfx->nSamplesPerSec = from->nSamplesPerSec;
 840     wfx->nAvgBytesPerSec = from->nSamplesPerSec * from->nBlockAlign;
 841     wfx->nBlockAlign = from->wBitsPerSample * from->nChannels / 8;
 842     wfx->wBitsPerSample = from->wBitsPerSample;
 843     return DS_OK;
 844 }
 845
 846 static HRESULT WINAPI DSPrimary_SetFormat(IDirectSoundBuffer *iface, const WAVEFORMATEX *wfx)
 847 {
 848     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 849     HRESULT hr = S_OK;
 850
 851     TRACE("(%p)->(%p)\n", iface, wfx);
 852
 853     if(!wfx)
 854     {
 855         WARN("Missing format\n");
 856         return DSERR_INVALIDPARAM;
 857     }
 858
 859     EnterCriticalSection(&This->share->crst);
 860
 861     if(This->parent->prio_level < DSSCL_PRIORITY)
 862     {
 863         hr = DSERR_PRIOLEVELNEEDED;
 864         goto out;
 865     }
 866
 867     TRACE("Requested primary format:\n"
 868           "    FormatTag      = %04x\n"
 869           "    Channels       = %u\n"
 870           "    SamplesPerSec  = %lu\n"
 871           "    AvgBytesPerSec = %lu\n"
 872           "    BlockAlign     = %u\n"
 873           "    BitsPerSample  = %u\n",
 874           wfx->wFormatTag, wfx->nChannels,
 875           wfx->nSamplesPerSec, wfx->nAvgBytesPerSec,
 876           wfx->nBlockAlign, wfx->wBitsPerSample);
 877
 878     hr = copy_waveformat(&This->format.Format, wfx);
 879     if(SUCCEEDED(hr) && This->write_emu)
 880     {
 881         DSBuffer *buf;
 882         DSBUFFERDESC desc;
 883
 884         IDirectSoundBuffer_Release(This->write_emu);
 885         This->write_emu = NULL;
 886
 887         memset(&desc, 0, sizeof(desc));
 888         desc.dwSize = sizeof(desc);
 889         desc.dwFlags = DSBCAPS_LOCHARDWARE | DSBCAPS_CTRLPAN;
 890         desc.dwBufferBytes = This->buf_size - (This->buf_size % This->format.Format.nBlockAlign);
 891         desc.lpwfxFormat = &This->format.Format;
 892
 893         hr = DSBuffer_Create(&buf, This, NULL);
 894         if(SUCCEEDED(hr))
 895         {
 896             hr = DSBuffer_Initialize(&buf->IDirectSoundBuffer8_iface,
 897                                      &This->parent->IDirectSound_iface, &desc);
 898             if(SUCCEEDED(hr))
 899                 hr = DSBuffer_GetInterface(buf, &IID_IDirectSoundBuffer, (void**)&This->write_emu);
 900             if(FAILED(hr))
 901                 DSBuffer_Destroy(buf);
 902         }
 903     }
 904
 905 out:
 906     LeaveCriticalSection(&This->share->crst);
 907     return hr;
 908 }
 909
 910 static HRESULT WINAPI DSPrimary_SetVolume(IDirectSoundBuffer *iface, LONG vol)
 911 {
 912     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 913
 914     TRACE("(%p)->(%ld)\n", iface, vol);
 915
 916     if(vol > DSBVOLUME_MAX || vol < DSBVOLUME_MIN)
 917     {
 918         WARN("Invalid volume (%ld)\n", vol);
 919         return DSERR_INVALIDPARAM;
 920     }
 921
 922     if(!(This->flags&DSBCAPS_CTRLVOLUME))
 923         return DSERR_CONTROLUNAVAIL;
 924
 925     setALContext(This->ctx);
 926     alListenerf(AL_GAIN, mB_to_gain((float)vol));
 927     popALContext();
 928
 929     return DS_OK;
 930 }
 931
 932 static HRESULT WINAPI DSPrimary_SetPan(IDirectSoundBuffer *iface, LONG pan)
 933 {
 934     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 935     HRESULT hr;
 936
 937     TRACE("(%p)->(%ld)\n", iface, pan);
 938
 939     if(pan > DSBPAN_RIGHT || pan < DSBPAN_LEFT)
 940     {
 941         WARN("invalid parameter: pan = %ld\n", pan);
 942         return DSERR_INVALIDPARAM;
 943     }
 944
 945     EnterCriticalSection(&This->share->crst);
 946     if(!(This->flags&DSBCAPS_CTRLPAN))
 947     {
 948         WARN("control unavailable\n");
 949         hr = DSERR_CONTROLUNAVAIL;
 950     }
 951     else if(This->write_emu)
 952         hr = IDirectSoundBuffer_SetPan(This->write_emu, pan);
 953     else
 954     {
 955         FIXME("Not supported\n");
 956         hr = E_NOTIMPL;
 957     }
 958     LeaveCriticalSection(&This->share->crst);
 959
 960     return hr;
 961 }
 962
 963 static HRESULT WINAPI DSPrimary_SetFrequency(IDirectSoundBuffer *iface, DWORD freq)
 964 {
 965     WARN("(%p)->(%lu)\n", iface, freq);
 966     return DSERR_CONTROLUNAVAIL;
 967 }
 968
 969 static HRESULT WINAPI DSPrimary_Stop(IDirectSoundBuffer *iface)
 970 {
 971     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 972     HRESULT hr = S_OK;
 973
 974     TRACE("(%p)->()\n", iface);
 975
 976     EnterCriticalSection(&This->share->crst);
 977     if(This->write_emu)
 978         hr = IDirectSoundBuffer_Stop(This->write_emu);
 979     if(SUCCEEDED(hr))
 980         This->stopped = TRUE;
 981     LeaveCriticalSection(&This->share->crst);
 982
 983     return hr;
 984 }
 985
 986 static HRESULT WINAPI DSPrimary_Unlock(IDirectSoundBuffer *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
 987 {
 988     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
 989     HRESULT hr = DSERR_INVALIDCALL;
 990
 991     TRACE("(%p)->(%p, %lu, %p, %lu)\n", iface, ptr1, len1, ptr2, len2);
 992
 993     EnterCriticalSection(&This->share->crst);
 994     if(This->write_emu)
 995         hr = IDirectSoundBuffer_Unlock(This->write_emu, ptr1, len1, ptr2, len2);
 996     LeaveCriticalSection(&This->share->crst);
 997
 998     return hr;
 999 }
1000
1001 static HRESULT WINAPI DSPrimary_Restore(IDirectSoundBuffer *iface)
1002 {
1003     DSPrimary *This = impl_from_IDirectSoundBuffer(iface);
1004     HRESULT hr = S_OK;
1005
1006     TRACE("(%p)->()\n", iface);
1007
1008     EnterCriticalSection(&This->share->crst);
1009     if(This->write_emu)
1010         hr = IDirectSoundBuffer_Restore(This->write_emu);
1011     LeaveCriticalSection(&This->share->crst);
1012
1013     return hr;
1014 }
1015
1016 static IDirectSoundBufferVtbl DSPrimary_Vtbl =
1017 {
1018     DSPrimary_QueryInterface,
1019     DSPrimary_AddRef,
1020     DSPrimary_Release,
1021     DSPrimary_GetCaps,
1022     DSPrimary_GetCurrentPosition,
1023     DSPrimary_GetFormat,
1024     DSPrimary_GetVolume,
1025     DSPrimary_GetPan,
1026     DSPrimary_GetFrequency,
1027     DSPrimary_GetStatus,
1028     DSPrimary_Initialize,
1029     DSPrimary_Lock,
1030     DSPrimary_Play,
1031     DSPrimary_SetCurrentPosition,
1032     DSPrimary_SetFormat,
1033     DSPrimary_SetVolume,
1034     DSPrimary_SetPan,
1035     DSPrimary_SetFrequency,
1036     DSPrimary_Stop,
1037     DSPrimary_Unlock,
1038     DSPrimary_Restore
1039 };
1040
1041
1042 static void DSPrimary_SetParams(DSPrimary *This, const DS3DLISTENER *params, LONG flags)
1043 {
1044     union PrimaryParamFlags dirty = { flags };
1045     DWORD i;
1046
1047     if(dirty.bit.pos)
1048         This->current.ds3d.vPosition = params->vPosition;
1049     if(dirty.bit.vel)
1050         This->current.ds3d.vVelocity = params->vVelocity;
1051     if(dirty.bit.orientation)
1052     {
1053         This->current.ds3d.vOrientFront = params->vOrientFront;
1054         This->current.ds3d.vOrientTop = params->vOrientTop;
1055     }
1056     if(dirty.bit.distancefactor)
1057         This->current.ds3d.flDistanceFactor = params->flDistanceFactor;
1058     if(dirty.bit.rollofffactor)
1059         This->current.ds3d.flRolloffFactor = params->flRolloffFactor;
1060     if(dirty.bit.dopplerfactor)
1061         This->current.ds3d.flDopplerFactor = params->flDopplerFactor;
1062
1063     if(dirty.bit.pos)
1064         alListener3f(AL_POSITION, params->vPosition.x, params->vPosition.y,
1065                                  -params->vPosition.z);
1066     if(dirty.bit.vel)
1067         alListener3f(AL_VELOCITY, params->vVelocity.x, params->vVelocity.y,
1068                                  -params->vVelocity.z);
1069     if(dirty.bit.orientation)
1070     {
1071         ALfloat orient[6] = {
1072             params->vOrientFront.x, params->vOrientFront.y, -params->vOrientFront.z,
1073             params->vOrientTop.x, params->vOrientTop.y, -params->vOrientTop.z
1074         };
1075         alListenerfv(AL_ORIENTATION, orient);
1076     }
1077     if(dirty.bit.distancefactor)
1078         alSpeedOfSound(343.3f/params->flDistanceFactor);
1079     if(dirty.bit.rollofffactor)
1080     {
1081         struct DSBufferGroup *bufgroup = This->BufferGroups;
1082         ALfloat rolloff = params->flRolloffFactor;
1083
1084         for(i = 0;i < This->NumBufferGroups;++i)
1085         {
1086             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
1087             while(usemask)
1088             {
1089                 int idx = CTZ64(usemask);
1090                 DSBuffer *buf = bufgroup[i].Buffers + idx;
1091                 usemask &= ~(U64(1) << idx);
1092
1093                 if(buf->source)
1094                     alSourcef(buf->source, AL_ROLLOFF_FACTOR, rolloff);
1095             }
1096         }
1097     }
1098     if(dirty.bit.dopplerfactor)
1099         alDopplerFactor(params->flDopplerFactor);
1100     if(dirty.bit.eax)
1101         EAXSet(&EAXPROPERTYID_EAX40_Context, 0, 0, NULL, 0);
1102 }
1103
1104 static HRESULT WINAPI DSPrimary3D_QueryInterface(IDirectSound3DListener *iface, REFIID riid, void **ppv)
1105 {
1106     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1107     return DSPrimary_QueryInterface(&This->IDirectSoundBuffer_iface, riid, ppv);
1108 }
1109
1110 static ULONG WINAPI DSPrimary3D_AddRef(IDirectSound3DListener *iface)
1111 {
1112     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1113     LONG ret;
1114
1115     ret = InterlockedIncrement(&This->ds3d_ref);
1116     TRACE("(%p) ref %lu\n", iface, ret);
1117
1118     return ret;
1119 }
1120
1121 static ULONG WINAPI DSPrimary3D_Release(IDirectSound3DListener *iface)
1122 {
1123     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1124     LONG ret;
1125
1126     ret = InterlockedDecrement(&This->ds3d_ref);
1127     TRACE("(%p) ref %lu\n", iface, ret);
1128
1129     return ret;
1130 }
1131
1132
1133 static HRESULT WINAPI DSPrimary3D_GetDistanceFactor(IDirectSound3DListener *iface, D3DVALUE *distancefactor)
1134 {
1135     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1136
1137     TRACE("(%p)->(%p)\n", iface, distancefactor);
1138
1139     if(!distancefactor)
1140     {
1141         WARN("Invalid parameter %p\n", distancefactor);
1142         return DSERR_INVALIDPARAM;
1143     }
1144
1145     *distancefactor = This->current.ds3d.flDistanceFactor;
1146     return S_OK;
1147 }
1148
1149 static HRESULT WINAPI DSPrimary3D_GetDopplerFactor(IDirectSound3DListener *iface, D3DVALUE *dopplerfactor)
1150 {
1151     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1152
1153     TRACE("(%p)->(%p)\n", iface, dopplerfactor);
1154
1155     if(!dopplerfactor)
1156     {
1157         WARN("Invalid parameter %p\n", dopplerfactor);
1158         return DSERR_INVALIDPARAM;
1159     }
1160
1161     *dopplerfactor = This->current.ds3d.flDopplerFactor;
1162     return S_OK;
1163 }
1164
1165 static HRESULT WINAPI DSPrimary3D_GetOrientation(IDirectSound3DListener *iface, D3DVECTOR *front, D3DVECTOR *top)
1166 {
1167     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1168
1169     TRACE("(%p)->(%p, %p)\n", iface, front, top);
1170
1171     if(!front || !top)
1172     {
1173         WARN("Invalid parameter %p %p\n", front, top);
1174         return DSERR_INVALIDPARAM;
1175     }
1176
1177     EnterCriticalSection(&This->share->crst);
1178     *front = This->current.ds3d.vOrientFront;
1179     *top = This->current.ds3d.vOrientTop;
1180     LeaveCriticalSection(&This->share->crst);
1181     return S_OK;
1182 }
1183
1184 static HRESULT WINAPI DSPrimary3D_GetPosition(IDirectSound3DListener *iface, D3DVECTOR *pos)
1185 {
1186     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1187
1188     TRACE("(%p)->(%p)\n", iface, pos);
1189
1190     if(!pos)
1191     {
1192         WARN("Invalid parameter %p\n", pos);
1193         return DSERR_INVALIDPARAM;
1194     }
1195
1196     EnterCriticalSection(&This->share->crst);
1197     *pos = This->current.ds3d.vPosition;
1198     LeaveCriticalSection(&This->share->crst);
1199     return S_OK;
1200 }
1201
1202 static HRESULT WINAPI DSPrimary3D_GetRolloffFactor(IDirectSound3DListener *iface, D3DVALUE *rollofffactor)
1203 {
1204     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1205
1206     TRACE("(%p)->(%p)\n", iface, rollofffactor);
1207
1208     if(!rollofffactor)
1209     {
1210         WARN("Invalid parameter %p\n", rollofffactor);
1211         return DSERR_INVALIDPARAM;
1212     }
1213
1214     *rollofffactor = This->current.ds3d.flRolloffFactor;
1215     return S_OK;
1216 }
1217
1218 static HRESULT WINAPI DSPrimary3D_GetVelocity(IDirectSound3DListener *iface, D3DVECTOR *velocity)
1219 {
1220     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1221
1222     TRACE("(%p)->(%p)\n", iface, velocity);
1223
1224     if(!velocity)
1225     {
1226         WARN("Invalid parameter %p\n", velocity);
1227         return DSERR_INVALIDPARAM;
1228     }
1229
1230     EnterCriticalSection(&This->share->crst);
1231     *velocity = This->current.ds3d.vVelocity;
1232     LeaveCriticalSection(&This->share->crst);
1233     return S_OK;
1234 }
1235
1236 static HRESULT WINAPI DSPrimary3D_GetAllParameters(IDirectSound3DListener *iface, DS3DLISTENER *listener)
1237 {
1238     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1239
1240     TRACE("(%p)->(%p)\n", iface, listener);
1241
1242     if(!listener || listener->dwSize < sizeof(*listener))
1243     {
1244         WARN("Invalid DS3DLISTENER %p %lu\n", listener, listener ? listener->dwSize : 0);
1245         return DSERR_INVALIDPARAM;
1246     }
1247
1248     EnterCriticalSection(&This->share->crst);
1249     listener->vPosition = This->current.ds3d.vPosition;
1250     listener->vVelocity = This->current.ds3d.vVelocity;
1251     listener->vOrientFront = This->current.ds3d.vOrientFront;
1252     listener->vOrientTop = This->current.ds3d.vOrientTop;
1253     listener->flDistanceFactor = This->current.ds3d.flDistanceFactor;
1254     listener->flRolloffFactor = This->current.ds3d.flRolloffFactor;
1255     listener->flDopplerFactor = This->current.ds3d.flDopplerFactor;
1256     LeaveCriticalSection(&This->share->crst);
1257
1258     return DS_OK;
1259 }
1260
1261
1262 static HRESULT WINAPI DSPrimary3D_SetDistanceFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1263 {
1264     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1265
1266     TRACE("(%p)->(%f, %lu)\n", iface, factor, apply);
1267
1268     if(factor < DS3D_MINDISTANCEFACTOR ||
1269        factor > DS3D_MAXDISTANCEFACTOR)
1270     {
1271         WARN("Invalid parameter %f\n", factor);
1272         return DSERR_INVALIDPARAM;
1273     }
1274
1275     EnterCriticalSection(&This->share->crst);
1276     if(apply == DS3D_DEFERRED)
1277     {
1278         This->deferred.ds3d.flDistanceFactor = factor;
1279         This->dirty.bit.distancefactor = 1;
1280     }
1281     else
1282     {
1283         setALContext(This->ctx);
1284         This->current.ds3d.flDistanceFactor = factor;
1285         alSpeedOfSound(343.3f/factor);
1286         checkALError();
1287         popALContext();
1288     }
1289     LeaveCriticalSection(&This->share->crst);
1290
1291     return S_OK;
1292 }
1293
1294 static HRESULT WINAPI DSPrimary3D_SetDopplerFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1295 {
1296     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1297
1298     TRACE("(%p)->(%f, %lu)\n", iface, factor, apply);
1299
1300     if(factor < DS3D_MINDOPPLERFACTOR ||
1301        factor > DS3D_MAXDOPPLERFACTOR)
1302     {
1303         WARN("Invalid parameter %f\n", factor);
1304         return DSERR_INVALIDPARAM;
1305     }
1306
1307     EnterCriticalSection(&This->share->crst);
1308     if(apply == DS3D_DEFERRED)
1309     {
1310         This->deferred.ds3d.flDopplerFactor = factor;
1311         This->dirty.bit.dopplerfactor = 1;
1312     }
1313     else
1314     {
1315         setALContext(This->ctx);
1316         This->current.ds3d.flDopplerFactor = factor;
1317         alDopplerFactor(factor);
1318         checkALError();
1319         popALContext();
1320     }
1321     LeaveCriticalSection(&This->share->crst);
1322
1323     return S_OK;
1324 }
1325
1326 static HRESULT WINAPI DSPrimary3D_SetOrientation(IDirectSound3DListener *iface, D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront, D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop, DWORD apply)
1327 {
1328     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1329
1330     TRACE("(%p)->(%f, %f, %f, %f, %f, %f, %lu)\n", iface, xFront, yFront, zFront, xTop, yTop, zTop, apply);
1331
1332     EnterCriticalSection(&This->share->crst);
1333     if(apply == DS3D_DEFERRED)
1334     {
1335         This->deferred.ds3d.vOrientFront.x = xFront;
1336         This->deferred.ds3d.vOrientFront.y = yFront;
1337         This->deferred.ds3d.vOrientFront.z = zFront;
1338         This->deferred.ds3d.vOrientTop.x = xTop;
1339         This->deferred.ds3d.vOrientTop.y = yTop;
1340         This->deferred.ds3d.vOrientTop.z = zTop;
1341         This->dirty.bit.orientation = 1;
1342     }
1343     else
1344     {
1345         ALfloat orient[6] = {
1346             xFront, yFront, -zFront,
1347             xTop, yTop, -zTop
1348         };
1349         This->current.ds3d.vOrientFront.x = xFront;
1350         This->current.ds3d.vOrientFront.y = yFront;
1351         This->current.ds3d.vOrientFront.z = zFront;
1352         This->current.ds3d.vOrientTop.x = xTop;
1353         This->current.ds3d.vOrientTop.y = yTop;
1354         This->current.ds3d.vOrientTop.z = zTop;
1355
1356         setALContext(This->ctx);
1357         alListenerfv(AL_ORIENTATION, orient);
1358         checkALError();
1359         popALContext();
1360     }
1361     LeaveCriticalSection(&This->share->crst);
1362
1363     return S_OK;
1364 }
1365
1366 static HRESULT WINAPI DSPrimary3D_SetPosition(IDirectSound3DListener *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
1367 {
1368     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1369
1370     TRACE("(%p)->(%f, %f, %f, %lu)\n", iface, x, y, z, apply);
1371
1372     EnterCriticalSection(&This->share->crst);
1373     if(apply == DS3D_DEFERRED)
1374     {
1375         This->deferred.ds3d.vPosition.x = x;
1376         This->deferred.ds3d.vPosition.y = y;
1377         This->deferred.ds3d.vPosition.z = z;
1378         This->dirty.bit.pos = 1;
1379     }
1380     else
1381     {
1382         setALContext(This->ctx);
1383         This->current.ds3d.vPosition.x = x;
1384         This->current.ds3d.vPosition.y = y;
1385         This->current.ds3d.vPosition.z = z;
1386         alListener3f(AL_POSITION, x, y, -z);
1387         checkALError();
1388         popALContext();
1389     }
1390     LeaveCriticalSection(&This->share->crst);
1391
1392     return S_OK;
1393 }
1394
1395 static HRESULT WINAPI DSPrimary3D_SetRolloffFactor(IDirectSound3DListener *iface, D3DVALUE factor, DWORD apply)
1396 {
1397     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1398
1399     TRACE("(%p)->(%f, %lu)\n", iface, factor, apply);
1400
1401     if(factor < DS3D_MINROLLOFFFACTOR ||
1402        factor > DS3D_MAXROLLOFFFACTOR)
1403     {
1404         WARN("Invalid parameter %f\n", factor);
1405         return DSERR_INVALIDPARAM;
1406     }
1407
1408     EnterCriticalSection(&This->share->crst);
1409     if(apply == DS3D_DEFERRED)
1410     {
1411         This->deferred.ds3d.flRolloffFactor = factor;
1412         This->dirty.bit.rollofffactor = 1;
1413     }
1414     else
1415     {
1416         struct DSBufferGroup *bufgroup = This->BufferGroups;
1417         DWORD i;
1418
1419         This->current.ds3d.flRolloffFactor = factor;
1420
1421         setALContext(This->ctx);
1422         for(i = 0;i < This->NumBufferGroups;++i)
1423         {
1424             DWORD64 usemask = ~bufgroup[i].FreeBuffers;
1425             while(usemask)
1426             {
1427                 int idx = CTZ64(usemask);
1428                 DSBuffer *buf = bufgroup[i].Buffers + idx;
1429                 usemask &= ~(U64(1) << idx);
1430
1431                 if(buf->source)
1432                     alSourcef(buf->source, AL_ROLLOFF_FACTOR, factor);
1433             }
1434         }
1435         checkALError();
1436         popALContext();
1437     }
1438     LeaveCriticalSection(&This->share->crst);
1439
1440     return S_OK;
1441 }
1442
1443 static HRESULT WINAPI DSPrimary3D_SetVelocity(IDirectSound3DListener *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
1444 {
1445     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1446
1447     TRACE("(%p)->(%f, %f, %f, %lu)\n", iface, x, y, z, apply);
1448
1449     EnterCriticalSection(&This->share->crst);
1450     if(apply == DS3D_DEFERRED)
1451     {
1452         This->deferred.ds3d.vVelocity.x = x;
1453         This->deferred.ds3d.vVelocity.y = y;
1454         This->deferred.ds3d.vVelocity.z = z;
1455         This->dirty.bit.vel = 1;
1456     }
1457     else
1458     {
1459         setALContext(This->ctx);
1460         This->current.ds3d.vVelocity.x = x;
1461         This->current.ds3d.vVelocity.y = y;
1462         This->current.ds3d.vVelocity.z = z;
1463         alListener3f(AL_VELOCITY, x, y, -z);
1464         checkALError();
1465         popALContext();
1466     }
1467     LeaveCriticalSection(&This->share->crst);
1468
1469     return S_OK;
1470 }
1471
1472 static HRESULT WINAPI DSPrimary3D_SetAllParameters(IDirectSound3DListener *iface, const DS3DLISTENER *listen, DWORD apply)
1473 {
1474     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1475
1476     TRACE("(%p)->(%p, %lu)\n", iface, listen, apply);
1477
1478     if(!listen || listen->dwSize < sizeof(*listen))
1479     {
1480         WARN("Invalid parameter %p %lu\n", listen, listen ? listen->dwSize : 0);
1481         return DSERR_INVALIDPARAM;
1482     }
1483
1484     if(listen->flDistanceFactor > DS3D_MAXDISTANCEFACTOR ||
1485        listen->flDistanceFactor < DS3D_MINDISTANCEFACTOR)
1486     {
1487         WARN("Invalid distance factor (%f)\n", listen->flDistanceFactor);
1488         return DSERR_INVALIDPARAM;
1489     }
1490
1491     if(listen->flDopplerFactor > DS3D_MAXDOPPLERFACTOR ||
1492        listen->flDopplerFactor < DS3D_MINDOPPLERFACTOR)
1493     {
1494         WARN("Invalid doppler factor (%f)\n", listen->flDopplerFactor);
1495         return DSERR_INVALIDPARAM;
1496     }
1497
1498     if(listen->flRolloffFactor < DS3D_MINROLLOFFFACTOR ||
1499        listen->flRolloffFactor > DS3D_MAXROLLOFFFACTOR)
1500     {
1501         WARN("Invalid rolloff factor (%f)\n", listen->flRolloffFactor);
1502         return DSERR_INVALIDPARAM;
1503     }
1504
1505     if(apply == DS3D_DEFERRED)
1506     {
1507         EnterCriticalSection(&This->share->crst);
1508         This->deferred.ds3d = *listen;
1509         This->deferred.ds3d.dwSize = sizeof(This->deferred.ds3d);
1510         This->dirty.bit.pos = 1;
1511         This->dirty.bit.vel = 1;
1512         This->dirty.bit.orientation = 1;
1513         This->dirty.bit.distancefactor = 1;
1514         This->dirty.bit.rollofffactor = 1;
1515         This->dirty.bit.dopplerfactor = 1;
1516         LeaveCriticalSection(&This->share->crst);
1517     }
1518     else
1519     {
1520         union PrimaryParamFlags dirty = { 0l };
1521         dirty.bit.pos = 1;
1522         dirty.bit.vel = 1;
1523         dirty.bit.orientation = 1;
1524         dirty.bit.distancefactor = 1;
1525         dirty.bit.rollofffactor = 1;
1526         dirty.bit.dopplerfactor = 1;
1527
1528         EnterCriticalSection(&This->share->crst);
1529         setALContext(This->ctx);
1530         DSPrimary_SetParams(This, listen, dirty.flags);
1531         checkALError();
1532         popALContext();
1533         LeaveCriticalSection(&This->share->crst);
1534     }
1535
1536     return S_OK;
1537 }
1538
1539 HRESULT WINAPI DSPrimary3D_CommitDeferredSettings(IDirectSound3DListener *iface)
1540 {
1541     DSPrimary *This = impl_from_IDirectSound3DListener(iface);
1542     struct DSBufferGroup *bufgroup;
1543     LONG flags;
1544     DWORD i;
1545
1546     EnterCriticalSection(&This->share->crst);
1547     setALContext(This->ctx);
1548     alDeferUpdatesSOFT();
1549
1550     if((flags=InterlockedExchange(&This->dirty.flags, 0)) != 0)
1551     {
1552         DSPrimary_SetParams(This, &This->deferred.ds3d, flags);
1553         /* checkALError is here for debugging */
1554         checkALError();
1555     }
1556     TRACE("Dirty flags was: 0x%02lx\n", flags);
1557
1558     bufgroup = This->BufferGroups;
1559     for(i = 0;i < This->NumBufferGroups;++i)
1560     {
1561         DWORD64 usemask = ~bufgroup[i].FreeBuffers;
1562         while(usemask)
1563         {
1564             int idx = CTZ64(usemask);
1565             DSBuffer *buf = bufgroup[i].Buffers + idx;
1566             usemask &= ~(U64(1) << idx);
1567
1568             if((flags=InterlockedExchange(&buf->dirty.flags, 0)) != 0)
1569                 DSBuffer_SetParams(buf, &buf->deferred.ds3d, flags);
1570         }
1571     }
1572     alProcessUpdatesSOFT();
1573     checkALError();
1574
1575     popALContext();
1576     LeaveCriticalSection(&This->share->crst);
1577
1578     return DS_OK;
1579 }
1580
1581 static IDirectSound3DListenerVtbl DSPrimary3D_Vtbl =
1582 {
1583     DSPrimary3D_QueryInterface,
1584     DSPrimary3D_AddRef,
1585     DSPrimary3D_Release,
1586     DSPrimary3D_GetAllParameters,
1587     DSPrimary3D_GetDistanceFactor,
1588     DSPrimary3D_GetDopplerFactor,
1589     DSPrimary3D_GetOrientation,
1590     DSPrimary3D_GetPosition,
1591     DSPrimary3D_GetRolloffFactor,
1592     DSPrimary3D_GetVelocity,
1593     DSPrimary3D_SetAllParameters,
1594     DSPrimary3D_SetDistanceFactor,
1595     DSPrimary3D_SetDopplerFactor,
1596     DSPrimary3D_SetOrientation,
1597     DSPrimary3D_SetPosition,
1598     DSPrimary3D_SetRolloffFactor,
1599     DSPrimary3D_SetVelocity,
1600     DSPrimary3D_CommitDeferredSettings
1601 };
1602
1603
1604 static HRESULT WINAPI DSPrimaryProp_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
1605 {
1606     DSPrimary *This = impl_from_IKsPropertySet(iface);
1607     return DSPrimary_QueryInterface(&This->IDirectSoundBuffer_iface, riid, ppv);
1608 }
1609
1610 static ULONG WINAPI DSPrimaryProp_AddRef(IKsPropertySet *iface)
1611 {
1612     DSPrimary *This = impl_from_IKsPropertySet(iface);
1613     LONG ret;
1614
1615     ret = InterlockedIncrement(&This->prop_ref);
1616     TRACE("(%p) ref %lu\n", iface, ret);
1617
1618     return ret;
1619 }
1620
1621 static ULONG WINAPI DSPrimaryProp_Release(IKsPropertySet *iface)
1622 {
1623     DSPrimary *This = impl_from_IKsPropertySet(iface);
1624     LONG ret;
1625
1626     ret = InterlockedDecrement(&This->prop_ref);
1627     TRACE("(%p) ref %lu\n", iface, ret);
1628
1629     return ret;
1630 }
1631
1632 static HRESULT WINAPI DSPrimaryProp_Get(IKsPropertySet *iface,
1633   REFGUID guidPropSet, ULONG dwPropID,
1634   LPVOID pInstanceData, ULONG cbInstanceData,
1635   LPVOID pPropData, ULONG cbPropData,
1636   ULONG *pcbReturned)
1637 {
1638     (void)iface;
1639     (void)dwPropID;
1640     (void)pInstanceData;
1641     (void)cbInstanceData;
1642     (void)pPropData;
1643     (void)cbPropData;
1644     (void)pcbReturned;
1645
1646     FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
1647
1648     return E_PROP_ID_UNSUPPORTED;
1649 }
1650
1651 static HRESULT WINAPI DSPrimaryProp_Set(IKsPropertySet *iface,
1652   REFGUID guidPropSet, ULONG dwPropID,
1653   LPVOID pInstanceData, ULONG cbInstanceData,
1654   LPVOID pPropData, ULONG cbPropData)
1655 {
1656     (void)iface;
1657     (void)dwPropID;
1658     (void)pInstanceData;
1659     (void)cbInstanceData;
1660     (void)pPropData;
1661     (void)cbPropData;
1662
1663     FIXME("Unhandled propset: %s\n", debugstr_guid(guidPropSet));
1664
1665     return E_PROP_ID_UNSUPPORTED;
1666 }
1667
1668 static HRESULT WINAPI DSPrimaryProp_QuerySupport(IKsPropertySet *iface,
1669   REFGUID guidPropSet, ULONG dwPropID,
1670   ULONG *pTypeSupport)
1671 {
1672     (void)iface;
1673     (void)pTypeSupport;
1674
1675     FIXME("Unhandled propset: %s (propid: %lu)\n", debugstr_guid(guidPropSet), dwPropID);
1676
1677     return E_PROP_ID_UNSUPPORTED;
1678 }
1679
1680 static IKsPropertySetVtbl DSPrimaryProp_Vtbl =
1681 {
1682     DSPrimaryProp_QueryInterface,
1683     DSPrimaryProp_AddRef,
1684     DSPrimaryProp_Release,
1685     DSPrimaryProp_Get,
1686     DSPrimaryProp_Set,
1687     DSPrimaryProp_QuerySupport
1688 };