dlls/dsound/primary.c

   1 /*                      DirectSound
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998 Rob Riggs
   5  * Copyright 2000-2002 TransGaming Technologies, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * TODO:
  22  *      When PrimarySetFormat (via ReopenDevice or PrimaryOpen) fails,
  23  *       it leaves dsound in unusable (not really open) state.
  24  */
  25
  26 #include <stdarg.h>
  27
  28 #define NONAMELESSSTRUCT
  29 #define NONAMELESSUNION
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winuser.h"
  33 #include "mmsystem.h"
  34 #include "winternl.h"
  35 #include "mmddk.h"
  36 #include "wine/debug.h"
  37 #include "dsound.h"
  38 #include "dsound_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  41
  42 /** Calculate how long a fragment length of about 10 ms should be in frames
  43  *
  44  * nSamplesPerSec: Frequency rate in samples per second
  45  * nBlockAlign: Size of a single blockalign
  46  *
  47  * Returns:
  48  * Size in bytes of a single fragment
  49  */
  50 DWORD DSOUND_fraglen(DWORD nSamplesPerSec, DWORD nBlockAlign)
  51 {
  52     /* Given a timer delay of 10ms, the fragment size is approximately:
  53      *     fraglen = (nSamplesPerSec * 10 / 1000) * nBlockAlign
  54      * ==> fraglen = (nSamplesPerSec / 100) * nBlockSize
  55      *
  56      * ALSA uses buffers that are powers of 2. Because of this, fraglen
  57      * is rounded up to the nearest power of 2:
  58      */
  59
  60     if (nSamplesPerSec <= 12800)
  61         return 128 * nBlockAlign;
  62
  63     if (nSamplesPerSec <= 25600)
  64         return 256 * nBlockAlign;
  65
  66     if (nSamplesPerSec <= 51200)
  67         return 512 * nBlockAlign;
  68
  69     return 1024 * nBlockAlign;
  70 }
  71
  72 static void DSOUND_RecalcPrimary(DirectSoundDevice *device)
  73 {
  74     TRACE("(%p)\n", device);
  75
  76     device->fraglen = DSOUND_fraglen(device->pwfx->nSamplesPerSec, device->pwfx->nBlockAlign);
  77     device->helfrags = device->buflen / device->fraglen;
  78     TRACE("fraglen=%d helfrags=%d\n", device->fraglen, device->helfrags);
  79
  80     /* calculate the 10ms write lead */
  81     device->writelead = (device->pwfx->nSamplesPerSec / 100) * device->pwfx->nBlockAlign;
  82 }
  83
  84 HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave)
  85 {
  86         HRESULT hres = DS_OK;
  87         TRACE("(%p, %d)\n", device, forcewave);
  88
  89     waveOutClose(device->hwo);
  90
  91     device->drvdesc.dwFlags = 0;
  92
  93     hres = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode,
  94                 device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD_PTR)device,
  95                 CALLBACK_FUNCTION | WAVE_MAPPED));
  96     if (FAILED(hres)) {
  97         WARN("waveOutOpen failed: %08x\n", hres);
  98         return hres;
  99     }
 100
 101         return hres;
 102 }
 103
 104 static HRESULT DSOUND_PrimaryOpen(DirectSoundDevice *device)
 105 {
 106         DWORD buflen;
 107         HRESULT err = DS_OK;
 108     LPBYTE newbuf;
 109     LPWAVEHDR headers = NULL;
 110     DWORD overshot;
 111     unsigned int c;
 112
 113         TRACE("(%p)\n", device);
 114
 115         /* on original windows, the buffer it set to a fixed size, no matter what the settings are.
 116            on windows this size is always fixed (tested on win-xp) */
 117         if (!device->buflen)
 118                 device->buflen = ds_hel_buflen;
 119         buflen = device->buflen;
 120         buflen -= buflen % device->pwfx->nBlockAlign;
 121         device->buflen = buflen;
 122
 123         device->mix_buffer_len = DSOUND_bufpos_to_mixpos(device, device->buflen);
 124         device->mix_buffer = HeapAlloc(GetProcessHeap(), 0, device->mix_buffer_len);
 125         if (!device->mix_buffer)
 126                 return DSERR_OUTOFMEMORY;
 127
 128         if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
 129         else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
 130
 131     /* Start in pause mode, to allow buffers to get filled */
 132     waveOutPause(device->hwo);
 133
 134     TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
 135
 136     /* reallocate emulated primary buffer */
 137     if (device->buffer)
 138         newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer, buflen);
 139     else
 140         newbuf = HeapAlloc(GetProcessHeap(),0, buflen);
 141
 142     if (!newbuf) {
 143         ERR("failed to allocate primary buffer\n");
 144         return DSERR_OUTOFMEMORY;
 145         /* but the old buffer might still exist and must be re-prepared */
 146     }
 147
 148     DSOUND_RecalcPrimary(device);
 149     if (device->pwave)
 150         headers = HeapReAlloc(GetProcessHeap(),0,device->pwave, device->helfrags * sizeof(WAVEHDR));
 151     else
 152         headers = HeapAlloc(GetProcessHeap(),0,device->helfrags * sizeof(WAVEHDR));
 153
 154     if (!headers) {
 155         ERR("failed to allocate wave headers\n");
 156         HeapFree(GetProcessHeap(), 0, newbuf);
 157         DSOUND_RecalcPrimary(device);
 158         return DSERR_OUTOFMEMORY;
 159     }
 160
 161     device->buffer = newbuf;
 162     device->pwave = headers;
 163
 164     /* prepare fragment headers */
 165     for (c=0; c<device->helfrags; c++) {
 166         device->pwave[c].lpData = (char*)device->buffer + c*device->fraglen;
 167         device->pwave[c].dwBufferLength = device->fraglen;
 168         device->pwave[c].dwUser = (DWORD_PTR)device;
 169         device->pwave[c].dwFlags = 0;
 170         device->pwave[c].dwLoops = 0;
 171         err = mmErr(waveOutPrepareHeader(device->hwo,&device->pwave[c],sizeof(WAVEHDR)));
 172         if (err != DS_OK) {
 173             while (c--)
 174                 waveOutUnprepareHeader(device->hwo,&device->pwave[c],sizeof(WAVEHDR));
 175             break;
 176         }
 177     }
 178
 179     overshot = device->buflen % device->fraglen;
 180     /* sanity */
 181     if(overshot)
 182     {
 183         overshot -= overshot % device->pwfx->nBlockAlign;
 184         device->pwave[device->helfrags - 1].dwBufferLength += overshot;
 185     }
 186
 187     TRACE("fraglen=%d, overshot=%d\n", device->fraglen, overshot);
 188
 189         device->mixfunction = mixfunctions[device->pwfx->wBitsPerSample/8 - 1];
 190         device->normfunction = normfunctions[device->pwfx->wBitsPerSample/8 - 1];
 191         FillMemory(device->buffer, device->buflen, (device->pwfx->wBitsPerSample == 8) ? 128 : 0);
 192         FillMemory(device->mix_buffer, device->mix_buffer_len, 0);
 193         device->pwplay = device->pwqueue = device->playpos = device->mixpos = 0;
 194         return err;
 195 }
 196
 197
 198 static void DSOUND_PrimaryClose(DirectSoundDevice *device)
 199 {
 200     unsigned c;
 201
 202         TRACE("(%p)\n", device);
 203
 204     /* get out of CS when calling the wave system */
 205     LeaveCriticalSection(&(device->mixlock));
 206     /* **** */
 207     device->pwqueue = (DWORD)-1; /* resetting queues */
 208     waveOutReset(device->hwo);
 209     for (c=0; c<device->helfrags; c++)
 210         waveOutUnprepareHeader(device->hwo, &device->pwave[c], sizeof(WAVEHDR));
 211     /* **** */
 212     EnterCriticalSection(&(device->mixlock));
 213
 214     /* clear the queue */
 215     device->pwqueue = 0;
 216 }
 217
 218 HRESULT DSOUND_PrimaryCreate(DirectSoundDevice *device)
 219 {
 220         HRESULT err = DS_OK;
 221         TRACE("(%p)\n", device);
 222
 223         device->buflen = ds_hel_buflen;
 224         err = DSOUND_PrimaryOpen(device);
 225
 226         if (err != DS_OK) {
 227                 WARN("DSOUND_PrimaryOpen failed\n");
 228                 return err;
 229         }
 230
 231         device->state = STATE_STOPPED;
 232         return DS_OK;
 233 }
 234
 235 HRESULT DSOUND_PrimaryDestroy(DirectSoundDevice *device)
 236 {
 237         TRACE("(%p)\n", device);
 238
 239         /* **** */
 240         EnterCriticalSection(&(device->mixlock));
 241
 242         DSOUND_PrimaryClose(device);
 243         HeapFree(GetProcessHeap(),0,device->pwave);
 244         HeapFree(GetProcessHeap(),0,device->pwfx);
 245         device->pwfx=NULL;
 246
 247         LeaveCriticalSection(&(device->mixlock));
 248         /* **** */
 249
 250         return DS_OK;
 251 }
 252
 253 HRESULT DSOUND_PrimaryPlay(DirectSoundDevice *device)
 254 {
 255         HRESULT err = DS_OK;
 256         TRACE("(%p)\n", device);
 257
 258         err = mmErr(waveOutRestart(device->hwo));
 259         if (err != DS_OK)
 260                 WARN("waveOutRestart failed\n");
 261
 262         return err;
 263 }
 264
 265 HRESULT DSOUND_PrimaryStop(DirectSoundDevice *device)
 266 {
 267         HRESULT err = DS_OK;
 268         TRACE("(%p)\n", device);
 269
 270         /* don't call the wave system with the lock set */
 271         LeaveCriticalSection(&(device->mixlock));
 272
 273         err = mmErr(waveOutPause(device->hwo));
 274
 275         EnterCriticalSection(&(device->mixlock));
 276
 277         if (err != DS_OK)
 278                 WARN("waveOutPause failed\n");
 279
 280         return err;
 281 }
 282
 283 HRESULT DSOUND_PrimaryGetPosition(DirectSoundDevice *device, LPDWORD playpos, LPDWORD writepos)
 284 {
 285         TRACE("(%p,%p,%p)\n", device, playpos, writepos);
 286
 287         TRACE("pwplay=%i, pwqueue=%i\n", device->pwplay, device->pwqueue);
 288
 289         /* check if playpos was requested */
 290         if (playpos)
 291                 /* use the cached play position */
 292                 *playpos = device->pwplay * device->fraglen;
 293
 294         /* check if writepos was requested */
 295         if (writepos)
 296                 /* the writepos is the first non-queued position */
 297                 *writepos = ((device->pwplay + device->pwqueue) % device->helfrags) * device->fraglen;
 298
 299         TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:-1, writepos?*writepos:-1, device, GetTickCount());
 300         return DS_OK;
 301 }
 302
 303 static DWORD DSOUND_GetFormatSize(LPCWAVEFORMATEX wfex)
 304 {
 305         if (wfex->wFormatTag == WAVE_FORMAT_PCM)
 306                 return sizeof(WAVEFORMATEX);
 307         else
 308                 return sizeof(WAVEFORMATEX) + wfex->cbSize;
 309 }
 310
 311 LPWAVEFORMATEX DSOUND_CopyFormat(LPCWAVEFORMATEX wfex)
 312 {
 313         DWORD size = DSOUND_GetFormatSize(wfex);
 314         LPWAVEFORMATEX pwfx = HeapAlloc(GetProcessHeap(),0,size);
 315         if (pwfx == NULL) {
 316                 WARN("out of memory\n");
 317         } else if (wfex->wFormatTag != WAVE_FORMAT_PCM) {
 318                 CopyMemory(pwfx, wfex, size);
 319         } else {
 320                 CopyMemory(pwfx, wfex, sizeof(PCMWAVEFORMAT));
 321                 pwfx->cbSize=0;
 322                 if (pwfx->nBlockAlign != pwfx->nChannels * pwfx->wBitsPerSample/8) {
 323                         WARN("Fixing bad nBlockAlign (%u)\n", pwfx->nBlockAlign);
 324                         pwfx->nBlockAlign  = pwfx->nChannels * pwfx->wBitsPerSample/8;
 325                 }
 326                 if (pwfx->nAvgBytesPerSec != pwfx->nSamplesPerSec * pwfx->nBlockAlign) {
 327                         WARN("Fixing bad nAvgBytesPerSec (%u)\n", pwfx->nAvgBytesPerSec);
 328                         pwfx->nAvgBytesPerSec  = pwfx->nSamplesPerSec * pwfx->nBlockAlign;
 329                 }
 330         }
 331         return pwfx;
 332 }
 333
 334 HRESULT primarybuffer_SetFormat(DirectSoundDevice *device, LPCWAVEFORMATEX wfex)
 335 {
 336         HRESULT err = DSERR_BUFFERLOST;
 337         int i;
 338         DWORD nSamplesPerSec, bpp, chans;
 339         LPWAVEFORMATEX oldpwfx;
 340         BOOL forced = device->priolevel == DSSCL_WRITEPRIMARY;
 341
 342         TRACE("(%p,%p)\n", device, wfex);
 343
 344         if (device->priolevel == DSSCL_NORMAL) {
 345                 WARN("failed priority check!\n");
 346                 return DSERR_PRIOLEVELNEEDED;
 347         }
 348
 349         /* Let's be pedantic! */
 350         if (wfex == NULL) {
 351                 WARN("invalid parameter: wfex==NULL!\n");
 352                 return DSERR_INVALIDPARAM;
 353         }
 354         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
 355               "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
 356               wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
 357               wfex->nAvgBytesPerSec, wfex->nBlockAlign,
 358               wfex->wBitsPerSample, wfex->cbSize);
 359
 360         /* **** */
 361         RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
 362         EnterCriticalSection(&(device->mixlock));
 363
 364         nSamplesPerSec = device->pwfx->nSamplesPerSec;
 365         bpp = device->pwfx->wBitsPerSample;
 366         chans = device->pwfx->nChannels;
 367
 368         oldpwfx = device->pwfx;
 369         device->pwfx = DSOUND_CopyFormat(wfex);
 370         if (device->pwfx == NULL) {
 371                 device->pwfx = oldpwfx;
 372                 oldpwfx = NULL;
 373                 err = DSERR_OUTOFMEMORY;
 374                 goto done;
 375         }
 376
 377         DSOUND_PrimaryClose(device);
 378
 379         err = DSOUND_ReopenDevice(device, FALSE);
 380         if (FAILED(err))
 381         {
 382                 WARN("DSOUND_ReopenDevice failed: %08x\n", err);
 383                 goto done;
 384         }
 385         err = DSOUND_PrimaryOpen(device);
 386         if (err != DS_OK) {
 387                 WARN("DSOUND_PrimaryOpen failed\n");
 388                 goto done;
 389         }
 390
 391         if (wfex->nSamplesPerSec/100 != device->pwfx->nSamplesPerSec/100 && forced && device->buffer)
 392         {
 393                 DSOUND_PrimaryClose(device);
 394                 device->pwfx->nSamplesPerSec = wfex->nSamplesPerSec;
 395                 err = DSOUND_ReopenDevice(device, TRUE);
 396                 if (FAILED(err))
 397                         WARN("DSOUND_ReopenDevice(2) failed: %08x\n", err);
 398                 else if (FAILED((err = DSOUND_PrimaryOpen(device))))
 399                         WARN("DSOUND_PrimaryOpen(2) failed: %08x\n", err);
 400         }
 401
 402         device->mix_buffer_len = DSOUND_bufpos_to_mixpos(device, device->buflen);
 403         device->mix_buffer = HeapReAlloc(GetProcessHeap(), 0, device->mix_buffer, device->mix_buffer_len);
 404         FillMemory(device->mix_buffer, device->mix_buffer_len, 0);
 405         device->mixfunction = mixfunctions[device->pwfx->wBitsPerSample/8 - 1];
 406         device->normfunction = normfunctions[device->pwfx->wBitsPerSample/8 - 1];
 407
 408         if (nSamplesPerSec != device->pwfx->nSamplesPerSec || bpp != device->pwfx->wBitsPerSample || chans != device->pwfx->nChannels) {
 409                 IDirectSoundBufferImpl** dsb = device->buffers;
 410                 for (i = 0; i < device->nrofbuffers; i++, dsb++) {
 411                         /* **** */
 412                         RtlAcquireResourceExclusive(&(*dsb)->lock, TRUE);
 413
 414                         (*dsb)->freqAdjust = ((DWORD64)(*dsb)->freq << DSOUND_FREQSHIFT) / device->pwfx->nSamplesPerSec;
 415                         DSOUND_RecalcFormat((*dsb));
 416                         DSOUND_MixToTemporary((*dsb), 0, (*dsb)->buflen, FALSE);
 417                         (*dsb)->primary_mixpos = 0;
 418
 419                         RtlReleaseResource(&(*dsb)->lock);
 420                         /* **** */
 421                 }
 422         }
 423
 424 done:
 425         LeaveCriticalSection(&(device->mixlock));
 426         RtlReleaseResource(&(device->buffer_list_lock));
 427         /* **** */
 428
 429         HeapFree(GetProcessHeap(), 0, oldpwfx);
 430         return err;
 431 }
 432
 433 /*******************************************************************************
 434  *              PrimaryBuffer
 435  */
 436 static inline IDirectSoundBufferImpl *impl_from_IDirectSoundBuffer(IDirectSoundBuffer *iface)
 437 {
 438     /* IDirectSoundBuffer and IDirectSoundBuffer8 use the same iface. */
 439     return CONTAINING_RECORD(iface, IDirectSoundBufferImpl, IDirectSoundBuffer8_iface);
 440 }
 441
 442 /* This sets this format for the <em>Primary Buffer Only</em> */
 443 /* See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 120 */
 444 static HRESULT WINAPI PrimaryBufferImpl_SetFormat(
 445     LPDIRECTSOUNDBUFFER iface,
 446     LPCWAVEFORMATEX wfex)
 447 {
 448     IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 449     TRACE("(%p,%p)\n", iface, wfex);
 450     return primarybuffer_SetFormat(This->device, wfex);
 451 }
 452
 453 static HRESULT WINAPI PrimaryBufferImpl_SetVolume(
 454         LPDIRECTSOUNDBUFFER iface,LONG vol
 455 ) {
 456         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 457         DirectSoundDevice *device = This->device;
 458         DWORD ampfactors;
 459         HRESULT hres = DS_OK;
 460         TRACE("(%p,%d)\n", iface, vol);
 461
 462         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
 463                 WARN("control unavailable\n");
 464                 return DSERR_CONTROLUNAVAIL;
 465         }
 466
 467         if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN)) {
 468                 WARN("invalid parameter: vol = %d\n", vol);
 469                 return DSERR_INVALIDPARAM;
 470         }
 471
 472         /* **** */
 473         EnterCriticalSection(&(device->mixlock));
 474
 475         waveOutGetVolume(device->hwo, &ampfactors);
 476         device->volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 477         device->volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 478         DSOUND_AmpFactorToVolPan(&device->volpan);
 479         if (vol != device->volpan.lVolume) {
 480             device->volpan.lVolume=vol;
 481             DSOUND_RecalcVolPan(&device->volpan);
 482                         ampfactors = (device->volpan.dwTotalLeftAmpFactor & 0xffff) | (device->volpan.dwTotalRightAmpFactor << 16);
 483                         waveOutSetVolume(device->hwo, ampfactors);
 484         }
 485
 486         LeaveCriticalSection(&(device->mixlock));
 487         /* **** */
 488
 489         return hres;
 490 }
 491
 492 static HRESULT WINAPI PrimaryBufferImpl_GetVolume(
 493         LPDIRECTSOUNDBUFFER iface,LPLONG vol
 494 ) {
 495         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 496         DirectSoundDevice *device = This->device;
 497         DWORD ampfactors;
 498         TRACE("(%p,%p)\n", iface, vol);
 499
 500         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
 501                 WARN("control unavailable\n");
 502                 return DSERR_CONTROLUNAVAIL;
 503         }
 504
 505         if (vol == NULL) {
 506                 WARN("invalid parameter: vol = NULL\n");
 507                 return DSERR_INVALIDPARAM;
 508         }
 509
 510         waveOutGetVolume(device->hwo, &ampfactors);
 511         device->volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 512         device->volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 513         DSOUND_AmpFactorToVolPan(&device->volpan);
 514         *vol = device->volpan.lVolume;
 515
 516         return DS_OK;
 517 }
 518
 519 static HRESULT WINAPI PrimaryBufferImpl_SetFrequency(
 520         LPDIRECTSOUNDBUFFER iface,DWORD freq
 521 ) {
 522         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 523         TRACE("(%p,%d)\n",This,freq);
 524
 525         /* You cannot set the frequency of the primary buffer */
 526         WARN("control unavailable\n");
 527         return DSERR_CONTROLUNAVAIL;
 528 }
 529
 530 static HRESULT WINAPI PrimaryBufferImpl_Play(
 531         LPDIRECTSOUNDBUFFER iface,DWORD reserved1,DWORD reserved2,DWORD flags
 532 ) {
 533         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 534         DirectSoundDevice *device = This->device;
 535         TRACE("(%p,%08x,%08x,%08x)\n", iface, reserved1, reserved2, flags);
 536
 537         if (!(flags & DSBPLAY_LOOPING)) {
 538                 WARN("invalid parameter: flags = %08x\n", flags);
 539                 return DSERR_INVALIDPARAM;
 540         }
 541
 542         /* **** */
 543         EnterCriticalSection(&(device->mixlock));
 544
 545         if (device->state == STATE_STOPPED)
 546                 device->state = STATE_STARTING;
 547         else if (device->state == STATE_STOPPING)
 548                 device->state = STATE_PLAYING;
 549
 550         LeaveCriticalSection(&(device->mixlock));
 551         /* **** */
 552
 553         return DS_OK;
 554 }
 555
 556 static HRESULT WINAPI PrimaryBufferImpl_Stop(LPDIRECTSOUNDBUFFER iface)
 557 {
 558         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 559         DirectSoundDevice *device = This->device;
 560         TRACE("(%p)\n", iface);
 561
 562         /* **** */
 563         EnterCriticalSection(&(device->mixlock));
 564
 565         if (device->state == STATE_PLAYING)
 566                 device->state = STATE_STOPPING;
 567         else if (device->state == STATE_STARTING)
 568                 device->state = STATE_STOPPED;
 569
 570         LeaveCriticalSection(&(device->mixlock));
 571         /* **** */
 572
 573         return DS_OK;
 574 }
 575
 576 static ULONG WINAPI PrimaryBufferImpl_AddRef(LPDIRECTSOUNDBUFFER iface)
 577 {
 578     IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 579     ULONG ref = InterlockedIncrement(&(This->ref));
 580     TRACE("(%p) ref was %d\n", This, ref - 1);
 581     if(ref == 1)
 582         InterlockedIncrement(&This->numIfaces);
 583     return ref;
 584 }
 585
 586 void primarybuffer_destroy(IDirectSoundBufferImpl *This)
 587 {
 588     This->device->primary = NULL;
 589     HeapFree(GetProcessHeap(), 0, This);
 590     TRACE("(%p) released\n", This);
 591 }
 592
 593 static ULONG WINAPI PrimaryBufferImpl_Release(LPDIRECTSOUNDBUFFER iface)
 594 {
 595     IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 596     DWORD ref = InterlockedDecrement(&(This->ref));
 597     TRACE("(%p) ref was %d\n", This, ref + 1);
 598
 599     if (!ref && !InterlockedDecrement(&This->numIfaces))
 600         primarybuffer_destroy(This);
 601     return ref;
 602 }
 603
 604 static HRESULT WINAPI PrimaryBufferImpl_GetCurrentPosition(
 605         LPDIRECTSOUNDBUFFER iface,LPDWORD playpos,LPDWORD writepos
 606 ) {
 607         HRESULT hres;
 608         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 609         DirectSoundDevice *device = This->device;
 610         TRACE("(%p,%p,%p)\n", iface, playpos, writepos);
 611
 612         /* **** */
 613         EnterCriticalSection(&(device->mixlock));
 614
 615         hres = DSOUND_PrimaryGetPosition(device, playpos, writepos);
 616         if (hres != DS_OK) {
 617                 WARN("DSOUND_PrimaryGetPosition failed\n");
 618                 LeaveCriticalSection(&(device->mixlock));
 619                 return hres;
 620         }
 621         if (writepos) {
 622                 if (device->state != STATE_STOPPED)
 623                         /* apply the documented 10ms lead to writepos */
 624                         *writepos += device->writelead;
 625                 while (*writepos >= device->buflen) *writepos -= device->buflen;
 626         }
 627
 628         LeaveCriticalSection(&(device->mixlock));
 629         /* **** */
 630
 631         TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:0, writepos?*writepos:0, device, GetTickCount());
 632         return DS_OK;
 633 }
 634
 635 static HRESULT WINAPI PrimaryBufferImpl_GetStatus(
 636         LPDIRECTSOUNDBUFFER iface,LPDWORD status
 637 ) {
 638         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 639         DirectSoundDevice *device = This->device;
 640         TRACE("(%p,%p)\n", iface, status);
 641
 642         if (status == NULL) {
 643                 WARN("invalid parameter: status == NULL\n");
 644                 return DSERR_INVALIDPARAM;
 645         }
 646
 647         *status = 0;
 648         if ((device->state == STATE_STARTING) ||
 649             (device->state == STATE_PLAYING))
 650                 *status |= DSBSTATUS_PLAYING | DSBSTATUS_LOOPING;
 651
 652         TRACE("status=%x\n", *status);
 653         return DS_OK;
 654 }
 655
 656
 657 static HRESULT WINAPI PrimaryBufferImpl_GetFormat(
 658     LPDIRECTSOUNDBUFFER iface,
 659     LPWAVEFORMATEX lpwf,
 660     DWORD wfsize,
 661     LPDWORD wfwritten)
 662 {
 663     DWORD size;
 664     IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 665     DirectSoundDevice *device = This->device;
 666     TRACE("(%p,%p,%d,%p)\n", iface, lpwf, wfsize, wfwritten);
 667
 668     size = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
 669
 670     if (lpwf) { /* NULL is valid */
 671         if (wfsize >= size) {
 672             CopyMemory(lpwf,device->pwfx,size);
 673             if (wfwritten)
 674                 *wfwritten = size;
 675         } else {
 676             WARN("invalid parameter: wfsize too small\n");
 677             if (wfwritten)
 678                 *wfwritten = 0;
 679             return DSERR_INVALIDPARAM;
 680         }
 681     } else {
 682         if (wfwritten)
 683             *wfwritten = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
 684         else {
 685             WARN("invalid parameter: wfwritten == NULL\n");
 686             return DSERR_INVALIDPARAM;
 687         }
 688     }
 689
 690     return DS_OK;
 691 }
 692
 693 static HRESULT WINAPI PrimaryBufferImpl_Lock(
 694         LPDIRECTSOUNDBUFFER iface,DWORD writecursor,DWORD writebytes,LPVOID *lplpaudioptr1,LPDWORD audiobytes1,LPVOID *lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
 695 ) {
 696         HRESULT hres;
 697         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 698         DirectSoundDevice *device = This->device;
 699         TRACE("(%p,%d,%d,%p,%p,%p,%p,0x%08x) at %d\n",
 700                 iface,
 701                 writecursor,
 702                 writebytes,
 703                 lplpaudioptr1,
 704                 audiobytes1,
 705                 lplpaudioptr2,
 706                 audiobytes2,
 707                 flags,
 708                 GetTickCount()
 709         );
 710
 711         if (!audiobytes1)
 712             return DSERR_INVALIDPARAM;
 713
 714         if (device->priolevel != DSSCL_WRITEPRIMARY) {
 715                 WARN("failed priority check!\n");
 716                 return DSERR_PRIOLEVELNEEDED;
 717         }
 718
 719         /* when this flag is set, writecursor is meaningless and must be calculated */
 720         if (flags & DSBLOCK_FROMWRITECURSOR) {
 721                 /* GetCurrentPosition does too much magic to duplicate here */
 722                 hres = IDirectSoundBuffer_GetCurrentPosition(iface, NULL, &writecursor);
 723                 if (hres != DS_OK) {
 724                         WARN("IDirectSoundBuffer_GetCurrentPosition failed\n");
 725                         return hres;
 726                 }
 727         }
 728
 729         /* when this flag is set, writebytes is meaningless and must be set */
 730         if (flags & DSBLOCK_ENTIREBUFFER)
 731                 writebytes = device->buflen;
 732
 733         if (writecursor >= device->buflen) {
 734                 WARN("Invalid parameter, writecursor: %u >= buflen: %u\n",
 735                      writecursor, device->buflen);
 736                 return DSERR_INVALIDPARAM;
 737         }
 738
 739         if (writebytes > device->buflen) {
 740                 WARN("Invalid parameter, writebytes: %u > buflen: %u\n",
 741                      writebytes, device->buflen);
 742                 return DSERR_INVALIDPARAM;
 743         }
 744
 745         if (writecursor+writebytes <= device->buflen) {
 746                 *(LPBYTE*)lplpaudioptr1 = device->buffer+writecursor;
 747                 *audiobytes1 = writebytes;
 748                 if (lplpaudioptr2)
 749                         *(LPBYTE*)lplpaudioptr2 = NULL;
 750                 if (audiobytes2)
 751                         *audiobytes2 = 0;
 752                 TRACE("->%d.0\n",writebytes);
 753         } else {
 754                 *(LPBYTE*)lplpaudioptr1 = device->buffer+writecursor;
 755                 *audiobytes1 = device->buflen-writecursor;
 756                 if (lplpaudioptr2)
 757                         *(LPBYTE*)lplpaudioptr2 = device->buffer;
 758                 if (audiobytes2)
 759                         *audiobytes2 = writebytes-(device->buflen-writecursor);
 760                 TRACE("->%d.%d\n",*audiobytes1,audiobytes2?*audiobytes2:0);
 761         }
 762         return DS_OK;
 763 }
 764
 765 static HRESULT WINAPI PrimaryBufferImpl_SetCurrentPosition(
 766         LPDIRECTSOUNDBUFFER iface,DWORD newpos
 767 ) {
 768         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 769         TRACE("(%p,%d)\n",This,newpos);
 770
 771         /* You cannot set the position of the primary buffer */
 772         WARN("invalid call\n");
 773         return DSERR_INVALIDCALL;
 774 }
 775
 776 static HRESULT WINAPI PrimaryBufferImpl_SetPan(
 777         LPDIRECTSOUNDBUFFER iface,LONG pan
 778 ) {
 779         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 780         DirectSoundDevice *device = This->device;
 781         DWORD ampfactors;
 782         HRESULT hres = DS_OK;
 783         TRACE("(%p,%d)\n", iface, pan);
 784
 785         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN)) {
 786                 WARN("control unavailable\n");
 787                 return DSERR_CONTROLUNAVAIL;
 788         }
 789
 790         if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT)) {
 791                 WARN("invalid parameter: pan = %d\n", pan);
 792                 return DSERR_INVALIDPARAM;
 793         }
 794
 795         /* **** */
 796         EnterCriticalSection(&(device->mixlock));
 797
 798         waveOutGetVolume(device->hwo, &ampfactors);
 799         device->volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 800         device->volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 801         DSOUND_AmpFactorToVolPan(&device->volpan);
 802         if (pan != device->volpan.lPan) {
 803                 device->volpan.lPan=pan;
 804                 DSOUND_RecalcVolPan(&device->volpan);
 805                 ampfactors = (device->volpan.dwTotalLeftAmpFactor & 0xffff) | (device->volpan.dwTotalRightAmpFactor << 16);
 806                 waveOutSetVolume(device->hwo, ampfactors);
 807         }
 808
 809         LeaveCriticalSection(&(device->mixlock));
 810         /* **** */
 811
 812         return hres;
 813 }
 814
 815 static HRESULT WINAPI PrimaryBufferImpl_GetPan(
 816         LPDIRECTSOUNDBUFFER iface,LPLONG pan
 817 ) {
 818         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 819         DirectSoundDevice *device = This->device;
 820         DWORD ampfactors;
 821         TRACE("(%p,%p)\n", iface, pan);
 822
 823         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN)) {
 824                 WARN("control unavailable\n");
 825                 return DSERR_CONTROLUNAVAIL;
 826         }
 827
 828         if (pan == NULL) {
 829                 WARN("invalid parameter: pan == NULL\n");
 830                 return DSERR_INVALIDPARAM;
 831         }
 832
 833         waveOutGetVolume(device->hwo, &ampfactors);
 834         device->volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 835         device->volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 836         DSOUND_AmpFactorToVolPan(&device->volpan);
 837         *pan = device->volpan.lPan;
 838         return DS_OK;
 839 }
 840
 841 static HRESULT WINAPI PrimaryBufferImpl_Unlock(
 842         LPDIRECTSOUNDBUFFER iface,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
 843 ) {
 844         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 845         DirectSoundDevice *device = This->device;
 846         TRACE("(%p,%p,%d,%p,%d)\n", iface, p1, x1, p2, x2);
 847
 848         if (device->priolevel != DSSCL_WRITEPRIMARY) {
 849                 WARN("failed priority check!\n");
 850                 return DSERR_PRIOLEVELNEEDED;
 851         }
 852
 853         return DS_OK;
 854 }
 855
 856 static HRESULT WINAPI PrimaryBufferImpl_Restore(
 857         LPDIRECTSOUNDBUFFER iface
 858 ) {
 859         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 860         FIXME("(%p):stub\n",This);
 861         return DS_OK;
 862 }
 863
 864 static HRESULT WINAPI PrimaryBufferImpl_GetFrequency(
 865         LPDIRECTSOUNDBUFFER iface,LPDWORD freq
 866 ) {
 867         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 868         DirectSoundDevice *device = This->device;
 869         TRACE("(%p,%p)\n", iface, freq);
 870
 871         if (freq == NULL) {
 872                 WARN("invalid parameter: freq == NULL\n");
 873                 return DSERR_INVALIDPARAM;
 874         }
 875
 876         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY)) {
 877                 WARN("control unavailable\n");
 878                 return DSERR_CONTROLUNAVAIL;
 879         }
 880
 881         *freq = device->pwfx->nSamplesPerSec;
 882         TRACE("-> %d\n", *freq);
 883
 884         return DS_OK;
 885 }
 886
 887 static HRESULT WINAPI PrimaryBufferImpl_Initialize(
 888         LPDIRECTSOUNDBUFFER iface,LPDIRECTSOUND dsound,LPCDSBUFFERDESC dbsd
 889 ) {
 890         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 891         WARN("(%p) already initialized\n", This);
 892         return DSERR_ALREADYINITIALIZED;
 893 }
 894
 895 static HRESULT WINAPI PrimaryBufferImpl_GetCaps(
 896         LPDIRECTSOUNDBUFFER iface,LPDSBCAPS caps
 897 ) {
 898         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 899         DirectSoundDevice *device = This->device;
 900         TRACE("(%p,%p)\n", iface, caps);
 901
 902         if (caps == NULL) {
 903                 WARN("invalid parameter: caps == NULL\n");
 904                 return DSERR_INVALIDPARAM;
 905         }
 906
 907         if (caps->dwSize < sizeof(*caps)) {
 908                 WARN("invalid parameter: caps->dwSize = %d\n", caps->dwSize);
 909                 return DSERR_INVALIDPARAM;
 910         }
 911
 912         caps->dwFlags = This->dsbd.dwFlags;
 913         caps->dwBufferBytes = device->buflen;
 914
 915         /* Windows reports these as zero */
 916         caps->dwUnlockTransferRate = 0;
 917         caps->dwPlayCpuOverhead = 0;
 918
 919         return DS_OK;
 920 }
 921
 922 static HRESULT WINAPI PrimaryBufferImpl_QueryInterface(
 923         LPDIRECTSOUNDBUFFER iface,REFIID riid,LPVOID *ppobj
 924 ) {
 925         IDirectSoundBufferImpl *This = impl_from_IDirectSoundBuffer(iface);
 926         DirectSoundDevice *device = This->device;
 927         TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppobj);
 928
 929         if (ppobj == NULL) {
 930                 WARN("invalid parameter\n");
 931                 return E_INVALIDARG;
 932         }
 933
 934         *ppobj = NULL;  /* assume failure */
 935
 936         if ( IsEqualGUID(riid, &IID_IUnknown) ||
 937              IsEqualGUID(riid, &IID_IDirectSoundBuffer) ) {
 938                 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)This);
 939                 *ppobj = This;
 940                 return S_OK;
 941         }
 942
 943         /* DirectSoundBuffer and DirectSoundBuffer8 are different and */
 944         /* a primary buffer can't have a DirectSoundBuffer8 interface */
 945         if ( IsEqualGUID( &IID_IDirectSoundBuffer8, riid ) ) {
 946                 WARN("app requested DirectSoundBuffer8 on primary buffer\n");
 947                 return E_NOINTERFACE;
 948         }
 949
 950         if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
 951                 ERR("app requested IDirectSoundNotify on primary buffer\n");
 952                 /* FIXME: should we support this? */
 953                 return E_NOINTERFACE;
 954         }
 955
 956         if ( IsEqualGUID( &IID_IDirectSound3DBuffer, riid ) ) {
 957                 ERR("app requested IDirectSound3DBuffer on primary buffer\n");
 958                 return E_NOINTERFACE;
 959         }
 960
 961         if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
 962                 if (!device->listener)
 963                         IDirectSound3DListenerImpl_Create(device, &device->listener);
 964                 if (device->listener) {
 965                         *ppobj = device->listener;
 966                         IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)*ppobj);
 967                         return S_OK;
 968                 }
 969
 970                 WARN("IID_IDirectSound3DListener failed\n");
 971                 return E_NOINTERFACE;
 972         }
 973
 974         if ( IsEqualGUID( &IID_IKsPropertySet, riid ) ) {
 975                 FIXME("app requested IKsPropertySet on primary buffer\n");
 976                 return E_NOINTERFACE;
 977         }
 978
 979         FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 980         return E_NOINTERFACE;
 981 }
 982
 983 static const IDirectSoundBufferVtbl dspbvt =
 984 {
 985         PrimaryBufferImpl_QueryInterface,
 986         PrimaryBufferImpl_AddRef,
 987         PrimaryBufferImpl_Release,
 988         PrimaryBufferImpl_GetCaps,
 989         PrimaryBufferImpl_GetCurrentPosition,
 990         PrimaryBufferImpl_GetFormat,
 991         PrimaryBufferImpl_GetVolume,
 992         PrimaryBufferImpl_GetPan,
 993         PrimaryBufferImpl_GetFrequency,
 994         PrimaryBufferImpl_GetStatus,
 995         PrimaryBufferImpl_Initialize,
 996         PrimaryBufferImpl_Lock,
 997         PrimaryBufferImpl_Play,
 998         PrimaryBufferImpl_SetCurrentPosition,
 999         PrimaryBufferImpl_SetFormat,
1000         PrimaryBufferImpl_SetVolume,
1001         PrimaryBufferImpl_SetPan,
1002         PrimaryBufferImpl_SetFrequency,
1003         PrimaryBufferImpl_Stop,
1004         PrimaryBufferImpl_Unlock,
1005         PrimaryBufferImpl_Restore
1006 };
1007
1008 HRESULT primarybuffer_create(DirectSoundDevice *device, IDirectSoundBufferImpl **ppdsb,
1009         const DSBUFFERDESC *dsbd)
1010 {
1011         IDirectSoundBufferImpl *dsb;
1012         TRACE("%p,%p,%p)\n",device,ppdsb,dsbd);
1013
1014         if (dsbd->lpwfxFormat) {
1015                 WARN("invalid parameter: dsbd->lpwfxFormat != NULL\n");
1016                 *ppdsb = NULL;
1017                 return DSERR_INVALIDPARAM;
1018         }
1019
1020         dsb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb));
1021
1022         if (dsb == NULL) {
1023                 WARN("out of memory\n");
1024                 *ppdsb = NULL;
1025                 return DSERR_OUTOFMEMORY;
1026         }
1027
1028         dsb->ref = 1;
1029         dsb->numIfaces = 1;
1030         dsb->device = device;
1031         dsb->IDirectSoundBuffer8_iface.lpVtbl = (IDirectSoundBuffer8Vtbl *)&dspbvt;
1032         dsb->dsbd = *dsbd;
1033
1034         TRACE("Created primary buffer at %p\n", dsb);
1035         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
1036                 "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1037                 device->pwfx->wFormatTag, device->pwfx->nChannels,
1038                 device->pwfx->nSamplesPerSec, device->pwfx->nAvgBytesPerSec,
1039                 device->pwfx->nBlockAlign, device->pwfx->wBitsPerSample,
1040                 device->pwfx->cbSize);
1041
1042         *ppdsb = dsb;
1043         return S_OK;
1044 }