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
  22 #include <stdarg.h>
  23
  24 #define NONAMELESSSTRUCT
  25 #define NONAMELESSUNION
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "mmsystem.h"
  30 #include "winreg.h"
  31 #include "winternl.h"
  32 #include "mmddk.h"
  33 #include "wine/debug.h"
  34 #include "dsound.h"
  35 #include "dsdriver.h"
  36 #include "dsound_private.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  39
  40 static void DSOUND_RecalcPrimary(DirectSoundDevice *device)
  41 {
  42         DWORD nBlockAlign;
  43         TRACE("(%p)\n", device);
  44
  45         nBlockAlign = device->pwfx->nBlockAlign;
  46         if (device->hwbuf) {
  47                 DWORD fraglen;
  48                 /* let fragment size approximate the timer delay */
  49                 fraglen = (device->pwfx->nSamplesPerSec * DS_TIME_DEL / 1000) * nBlockAlign;
  50                 /* reduce fragment size until an integer number of them fits in the buffer */
  51                 /* (FIXME: this may or may not be a good idea) */
  52                 while (device->buflen % fraglen) fraglen -= nBlockAlign;
  53                 device->fraglen = fraglen;
  54                 TRACE("fraglen=%d\n", device->fraglen);
  55         }
  56         /* calculate the 10ms write lead */
  57         device->writelead = (device->pwfx->nSamplesPerSec / 100) * nBlockAlign;
  58 }
  59
  60 static HRESULT DSOUND_PrimaryOpen(DirectSoundDevice *device)
  61 {
  62         HRESULT err = DS_OK;
  63         TRACE("(%p)\n", device);
  64
  65         /* are we using waveOut stuff? */
  66         if (!device->driver) {
  67                 LPBYTE newbuf;
  68                 DWORD buflen;
  69                 HRESULT merr = DS_OK;
  70                 /* Start in pause mode, to allow buffers to get filled */
  71                 waveOutPause(device->hwo);
  72                 if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
  73                 else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
  74                 /* use fragments of 10ms (1/100s) each (which should get us within
  75                  * the documented write cursor lead of 10-15ms) */
  76                 buflen = ((device->pwfx->nSamplesPerSec / 100) * device->pwfx->nBlockAlign) * DS_HEL_FRAGS;
  77                 TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
  78                 /* reallocate emulated primary buffer */
  79
  80                 if (device->buffer)
  81                         newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
  82                 else
  83                         newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
  84
  85                 if (newbuf == NULL) {
  86                         ERR("failed to allocate primary buffer\n");
  87                         merr = DSERR_OUTOFMEMORY;
  88                         /* but the old buffer might still exist and must be re-prepared */
  89                 } else {
  90                         device->buffer = newbuf;
  91                         device->buflen = buflen;
  92                 }
  93                 if (device->buffer) {
  94                         unsigned c;
  95
  96                         device->fraglen = device->buflen / DS_HEL_FRAGS;
  97
  98                         /* prepare fragment headers */
  99                         for (c=0; c<DS_HEL_FRAGS; c++) {
 100                                 device->pwave[c]->lpData = (char*)device->buffer + c*device->fraglen;
 101                                 device->pwave[c]->dwBufferLength = device->fraglen;
 102                                 device->pwave[c]->dwUser = (DWORD)device;
 103                                 device->pwave[c]->dwFlags = 0;
 104                                 device->pwave[c]->dwLoops = 0;
 105                                 err = mmErr(waveOutPrepareHeader(device->hwo,device->pwave[c],sizeof(WAVEHDR)));
 106                                 if (err != DS_OK) {
 107                                         while (c--)
 108                                                 waveOutUnprepareHeader(device->hwo,device->pwave[c],sizeof(WAVEHDR));
 109                                         break;
 110                                 }
 111                         }
 112
 113                         device->pwplay = 0;
 114                         device->pwwrite = 0;
 115                         device->pwqueue = 0;
 116                         device->playpos = 0;
 117                         device->mixpos = 0;
 118                         FillMemory(device->buffer, device->buflen, (device->pwfx->wBitsPerSample == 8) ? 128 : 0);
 119                         TRACE("fraglen=%d\n", device->fraglen);
 120                         DSOUND_WaveQueue(device, (DWORD)-1);
 121                 }
 122                 if ((err == DS_OK) && (merr != DS_OK))
 123                         err = merr;
 124         } else if (!device->hwbuf) {
 125                 err = IDsDriver_CreateSoundBuffer(device->driver,device->pwfx,
 126                                                   DSBCAPS_PRIMARYBUFFER,0,
 127                                                   &(device->buflen),&(device->buffer),
 128                                                   (LPVOID*)&(device->hwbuf));
 129                 if (err != DS_OK) {
 130                         WARN("IDsDriver_CreateSoundBuffer failed\n");
 131                         return err;
 132                 }
 133
 134                 if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
 135                 else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
 136                 device->playpos = 0;
 137                 device->mixpos = 0;
 138                 FillMemory(device->buffer, device->buflen, (device->pwfx->wBitsPerSample == 8) ? 128 : 0);
 139         }
 140
 141         return err;
 142 }
 143
 144
 145 static void DSOUND_PrimaryClose(DirectSoundDevice *device)
 146 {
 147         TRACE("(%p)\n", device);
 148
 149         /* are we using waveOut stuff? */
 150         if (!device->hwbuf) {
 151                 unsigned c;
 152
 153                 device->pwqueue = (DWORD)-1; /* resetting queues */
 154                 waveOutReset(device->hwo);
 155                 for (c=0; c<DS_HEL_FRAGS; c++)
 156                         waveOutUnprepareHeader(device->hwo, device->pwave[c], sizeof(WAVEHDR));
 157                 device->pwqueue = 0;
 158         } else {
 159                 if (IDsDriverBuffer_Release(device->hwbuf) == 0)
 160                         device->hwbuf = 0;
 161         }
 162 }
 163
 164 HRESULT DSOUND_PrimaryCreate(DirectSoundDevice *device)
 165 {
 166         HRESULT err = DS_OK;
 167         TRACE("(%p)\n", device);
 168
 169         device->buflen = device->pwfx->nAvgBytesPerSec;
 170
 171         /* FIXME: verify that hardware capabilities (DSCAPS_PRIMARY flags) match */
 172
 173         if (device->driver) {
 174                 err = IDsDriver_CreateSoundBuffer(device->driver,device->pwfx,
 175                                                   DSBCAPS_PRIMARYBUFFER,0,
 176                                                   &(device->buflen),&(device->buffer),
 177                                                   (LPVOID*)&(device->hwbuf));
 178                 if (err != DS_OK) {
 179                         WARN("IDsDriver_CreateSoundBuffer failed\n");
 180                         return err;
 181                 }
 182         }
 183         if (!device->hwbuf) {
 184                 /* Allocate memory for HEL buffer headers */
 185                 unsigned c;
 186                 for (c=0; c<DS_HEL_FRAGS; c++) {
 187                         device->pwave[c] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(WAVEHDR));
 188                         if (!device->pwave[c]) {
 189                                 /* Argh, out of memory */
 190                                 while (c--) {
 191                                         HeapFree(GetProcessHeap(),0,device->pwave[c]);
 192                                 }
 193                                 WARN("out of memory\n");
 194                                 return DSERR_OUTOFMEMORY;
 195                         }
 196                 }
 197         }
 198
 199         err = DSOUND_PrimaryOpen(device);
 200
 201         if (err != DS_OK) {
 202                 WARN("DSOUND_PrimaryOpen failed\n");
 203                 return err;
 204         }
 205
 206         /* calculate fragment size and write lead */
 207         DSOUND_RecalcPrimary(device);
 208         device->state = STATE_STOPPED;
 209         return DS_OK;
 210 }
 211
 212 HRESULT DSOUND_PrimaryDestroy(DirectSoundDevice *device)
 213 {
 214         TRACE("(%p)\n", device);
 215
 216         DSOUND_PrimaryClose(device);
 217         if (device->driver) {
 218                 if (device->hwbuf) {
 219                         if (IDsDriverBuffer_Release(device->hwbuf) == 0)
 220                                 device->hwbuf = 0;
 221                 }
 222         } else {
 223                 unsigned c;
 224                 for (c=0; c<DS_HEL_FRAGS; c++) {
 225                         HeapFree(GetProcessHeap(),0,device->pwave[c]);
 226                 }
 227         }
 228         HeapFree(GetProcessHeap(),0,device->pwfx);
 229         device->pwfx=NULL;
 230         return DS_OK;
 231 }
 232
 233 HRESULT DSOUND_PrimaryPlay(DirectSoundDevice *device)
 234 {
 235         HRESULT err = DS_OK;
 236         TRACE("(%p)\n", device);
 237
 238         if (device->hwbuf) {
 239                 err = IDsDriverBuffer_Play(device->hwbuf, 0, 0, DSBPLAY_LOOPING);
 240                 if (err != DS_OK)
 241                         WARN("IDsDriverBuffer_Play failed\n");
 242         } else {
 243                 err = mmErr(waveOutRestart(device->hwo));
 244                 if (err != DS_OK)
 245                         WARN("waveOutRestart failed\n");
 246         }
 247
 248         return err;
 249 }
 250
 251 HRESULT DSOUND_PrimaryStop(DirectSoundDevice *device)
 252 {
 253         HRESULT err = DS_OK;
 254         TRACE("(%p)\n", device);
 255
 256         if (device->hwbuf) {
 257                 err = IDsDriverBuffer_Stop(device->hwbuf);
 258                 if (err == DSERR_BUFFERLOST) {
 259                         DWORD flags = CALLBACK_FUNCTION;
 260                         if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
 261                                 flags |= WAVE_DIRECTSOUND;
 262                         /* Wine-only: the driver wants us to reopen the device */
 263                         /* FIXME: check for errors */
 264                         IDsDriverBuffer_Release(device->hwbuf);
 265                         waveOutClose(device->hwo);
 266                         device->hwo = 0;
 267                         err = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode,
 268                                                 device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD)device,
 269                                                 flags));
 270                         if (err == DS_OK) {
 271                                 err = IDsDriver_CreateSoundBuffer(device->driver,device->pwfx,
 272                                                                   DSBCAPS_PRIMARYBUFFER,0,
 273                                                                   &(device->buflen),&(device->buffer),
 274                                                                   (LPVOID)&(device->hwbuf));
 275                                 if (err != DS_OK)
 276                                 {
 277                                     unsigned c;
 278                                     WARN("IDsDriver_CreateSoundBuffer failed\n");
 279                                     /* We had a HW buffer and now we do not. This could cause
 280                                      * problems in the future with pwave being uncreated and
 281                                      * crashing
 282                                      */
 283                                     device->buffer = NULL;
 284                                     device->buflen = device->pwfx->nAvgBytesPerSec;
 285                                     /* Allocate memory for HEL buffer headers */
 286                                     for (c=0; c<DS_HEL_FRAGS; c++) {
 287                                         device->pwave[c] = HeapAlloc(GetProcessHeap(),
 288                                                                    HEAP_ZERO_MEMORY,sizeof(WAVEHDR));
 289                                         if (!device->pwave[c]) {
 290                                             /* Argh, out of memory */
 291                                             while (c--) {
 292                                                 HeapFree(GetProcessHeap(),0,device->pwave[c]);
 293                                             }
 294                                             WARN("out of memory\n");
 295                                             err =  DSERR_OUTOFMEMORY;
 296                                         }
 297                                     }
 298                                 }
 299                                 else
 300                                     memset(device->buffer, (device->pwfx->wBitsPerSample == 16) ? 0 : 128, device->buflen);
 301                         } else {
 302                                 WARN("waveOutOpen failed\n");
 303                         }
 304                 } else if (err != DS_OK) {
 305                         WARN("IDsDriverBuffer_Stop failed\n");
 306                 }
 307         } else {
 308                 err = mmErr(waveOutPause(device->hwo));
 309                 if (err != DS_OK)
 310                         WARN("waveOutPause failed\n");
 311         }
 312         return err;
 313 }
 314
 315 HRESULT DSOUND_PrimaryGetPosition(DirectSoundDevice *device, LPDWORD playpos, LPDWORD writepos)
 316 {
 317         TRACE("(%p,%p,%p)\n", device, playpos, writepos);
 318
 319         if (device->hwbuf) {
 320                 HRESULT err=IDsDriverBuffer_GetPosition(device->hwbuf,playpos,writepos);
 321                 if (err) {
 322                         WARN("IDsDriverBuffer_GetPosition failed\n");
 323                         return err;
 324                 }
 325         } else {
 326                 if (playpos) {
 327                         MMTIME mtime;
 328                         mtime.wType = TIME_BYTES;
 329                         waveOutGetPosition(device->hwo, &mtime, sizeof(mtime));
 330                         mtime.u.cb = mtime.u.cb % device->buflen;
 331                         *playpos = mtime.u.cb;
 332                 }
 333                 if (writepos) {
 334                         /* the writepos should only be used by apps with WRITEPRIMARY priority,
 335                          * in which case our software mixer is disabled anyway */
 336                         *writepos = (device->pwplay + ds_hel_margin) * device->fraglen;
 337                         while (*writepos >= device->buflen)
 338                                 *writepos -= device->buflen;
 339                 }
 340         }
 341         TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:0, writepos?*writepos:0, device, GetTickCount());
 342         return DS_OK;
 343 }
 344
 345 HRESULT DSOUND_PrimarySetFormat(DirectSoundDevice *device, LPCWAVEFORMATEX wfex)
 346 {
 347         HRESULT err = DS_OK;
 348         int i, alloc_size, cp_size;
 349         DWORD nSamplesPerSec;
 350         TRACE("(%p,%p)\n", device, wfex);
 351
 352         if (device->priolevel == DSSCL_NORMAL) {
 353                 WARN("failed priority check!\n");
 354                 return DSERR_PRIOLEVELNEEDED;
 355         }
 356
 357         /* Let's be pedantic! */
 358         if (wfex == NULL) {
 359                 WARN("invalid parameter: wfex==NULL!\n");
 360                 return DSERR_INVALIDPARAM;
 361         }
 362         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
 363               "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
 364               wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
 365               wfex->nAvgBytesPerSec, wfex->nBlockAlign,
 366               wfex->wBitsPerSample, wfex->cbSize);
 367
 368         if (device->no_reformat)
 369         {
 370             TRACE("no_reformat set, not changing the format\n");
 371             return DS_OK;
 372         }
 373
 374         /* **** */
 375         RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
 376         EnterCriticalSection(&(device->mixlock));
 377
 378         if (wfex->wFormatTag == WAVE_FORMAT_PCM) {
 379             alloc_size = sizeof(WAVEFORMATEX);
 380             cp_size = sizeof(PCMWAVEFORMAT);
 381         } else
 382             alloc_size = cp_size = sizeof(WAVEFORMATEX) + wfex->cbSize;
 383
 384         device->pwfx = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,device->pwfx,alloc_size);
 385
 386         nSamplesPerSec = device->pwfx->nSamplesPerSec;
 387
 388         CopyMemory(device->pwfx, wfex, cp_size);
 389
 390         if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMSETFORMAT) {
 391                 DWORD flags = CALLBACK_FUNCTION;
 392                 if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
 393                         flags |= WAVE_DIRECTSOUND;
 394                 /* FIXME: check for errors */
 395                 DSOUND_PrimaryClose(device);
 396                 waveOutClose(device->hwo);
 397                 device->hwo = 0;
 398                 err = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode,
 399                                         device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD)device,
 400                                         flags));
 401                 if (err == DS_OK) {
 402                     err = DSOUND_PrimaryOpen(device);
 403                     if (err != DS_OK) {
 404                         WARN("DSOUND_PrimaryOpen failed\n");
 405                         goto done;
 406                     }
 407                 } else {
 408                         WARN("waveOutOpen failed\n");
 409                         goto done;
 410                 }
 411         } else if (device->hwbuf) {
 412                 err = IDsDriverBuffer_SetFormat(device->hwbuf, device->pwfx);
 413                 if (err == DSERR_BUFFERLOST) {
 414                         /* Wine-only: the driver wants us to recreate the HW buffer */
 415                         IDsDriverBuffer_Release(device->hwbuf);
 416                         err = IDsDriver_CreateSoundBuffer(device->driver,device->pwfx,
 417                                                           DSBCAPS_PRIMARYBUFFER,0,
 418                                                           &(device->buflen),&(device->buffer),
 419                                                           (LPVOID)&(device->hwbuf));
 420                         if (err != DS_OK) {
 421                                 WARN("IDsDriver_CreateSoundBuffer failed\n");
 422                                 goto done;
 423                         }
 424                         if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
 425                         else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
 426                 } else {
 427                         WARN("IDsDriverBuffer_SetFormat failed\n");
 428                         goto done;
 429                 }
 430                 /* FIXME: should we set err back to DS_OK in all cases ? */
 431         }
 432         DSOUND_RecalcPrimary(device);
 433
 434         if (nSamplesPerSec != device->pwfx->nSamplesPerSec) {
 435                 IDirectSoundBufferImpl** dsb = device->buffers;
 436                 for (i = 0; i < device->nrofbuffers; i++, dsb++) {
 437                         /* **** */
 438                         EnterCriticalSection(&((*dsb)->lock));
 439
 440                         (*dsb)->freqAdjust = ((*dsb)->freq << DSOUND_FREQSHIFT) /
 441                                 wfex->nSamplesPerSec;
 442
 443                         LeaveCriticalSection(&((*dsb)->lock));
 444                         /* **** */
 445                 }
 446         }
 447
 448 done:
 449         LeaveCriticalSection(&(device->mixlock));
 450         RtlReleaseResource(&(device->buffer_list_lock));
 451         /* **** */
 452
 453         return err;
 454 }
 455
 456 /*******************************************************************************
 457  *              PrimaryBuffer
 458  */
 459 /* This sets this format for the <em>Primary Buffer Only</em> */
 460 /* See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 120 */
 461 static HRESULT WINAPI PrimaryBufferImpl_SetFormat(
 462     LPDIRECTSOUNDBUFFER8 iface,
 463     LPCWAVEFORMATEX wfex)
 464 {
 465     TRACE("(%p,%p)\n", iface, wfex);
 466     return DSOUND_PrimarySetFormat(((PrimaryBufferImpl *)iface)->device, wfex);
 467 }
 468
 469 static HRESULT WINAPI PrimaryBufferImpl_SetVolume(
 470         LPDIRECTSOUNDBUFFER8 iface,LONG vol
 471 ) {
 472         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 473         DWORD ampfactors;
 474         DSVOLUMEPAN volpan;
 475         HRESULT hres = DS_OK;
 476         TRACE("(%p,%d)\n", iface, vol);
 477
 478         if (!(device->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
 479                 WARN("control unavailable\n");
 480                 return DSERR_CONTROLUNAVAIL;
 481         }
 482
 483         if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN)) {
 484                 WARN("invalid parameter: vol = %d\n", vol);
 485                 return DSERR_INVALIDPARAM;
 486         }
 487
 488         /* **** */
 489         EnterCriticalSection(&(device->mixlock));
 490
 491         waveOutGetVolume(device->hwo, &ampfactors);
 492         volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 493         volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 494         DSOUND_AmpFactorToVolPan(&volpan);
 495         if (vol != volpan.lVolume) {
 496             volpan.lVolume=vol;
 497             DSOUND_RecalcVolPan(&volpan);
 498             if (device->hwbuf) {
 499                 hres = IDsDriverBuffer_SetVolumePan(device->hwbuf, &volpan);
 500                 if (hres != DS_OK)
 501                     WARN("IDsDriverBuffer_SetVolumePan failed\n");
 502             } else {
 503                 ampfactors = (volpan.dwTotalLeftAmpFactor & 0xffff) | (volpan.dwTotalRightAmpFactor << 16);
 504                 waveOutSetVolume(device->hwo, ampfactors);
 505             }
 506         }
 507
 508         LeaveCriticalSection(&(device->mixlock));
 509         /* **** */
 510
 511         return hres;
 512 }
 513
 514 static HRESULT WINAPI PrimaryBufferImpl_GetVolume(
 515         LPDIRECTSOUNDBUFFER8 iface,LPLONG vol
 516 ) {
 517         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 518         DWORD ampfactors;
 519         DSVOLUMEPAN volpan;
 520         TRACE("(%p,%p)\n", iface, vol);
 521
 522         if (!(device->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
 523                 WARN("control unavailable\n");
 524                 return DSERR_CONTROLUNAVAIL;
 525         }
 526
 527         if (vol == NULL) {
 528                 WARN("invalid parameter: vol = NULL\n");
 529                 return DSERR_INVALIDPARAM;
 530         }
 531
 532         waveOutGetVolume(device->hwo, &ampfactors);
 533         volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 534         volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 535         DSOUND_AmpFactorToVolPan(&volpan);
 536         *vol = volpan.lVolume;
 537         return DS_OK;
 538 }
 539
 540 static HRESULT WINAPI PrimaryBufferImpl_SetFrequency(
 541         LPDIRECTSOUNDBUFFER8 iface,DWORD freq
 542 ) {
 543         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 544         TRACE("(%p,%d)\n",This,freq);
 545
 546         /* You cannot set the frequency of the primary buffer */
 547         WARN("control unavailable\n");
 548         return DSERR_CONTROLUNAVAIL;
 549 }
 550
 551 static HRESULT WINAPI PrimaryBufferImpl_Play(
 552         LPDIRECTSOUNDBUFFER8 iface,DWORD reserved1,DWORD reserved2,DWORD flags
 553 ) {
 554         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 555         TRACE("(%p,%08x,%08x,%08x)\n", iface, reserved1, reserved2, flags);
 556
 557         if (!(flags & DSBPLAY_LOOPING)) {
 558                 WARN("invalid parameter: flags = %08x\n", flags);
 559                 return DSERR_INVALIDPARAM;
 560         }
 561
 562         /* **** */
 563         EnterCriticalSection(&(device->mixlock));
 564
 565         if (device->state == STATE_STOPPED)
 566                 device->state = STATE_STARTING;
 567         else if (device->state == STATE_STOPPING)
 568                 device->state = STATE_PLAYING;
 569
 570         LeaveCriticalSection(&(device->mixlock));
 571         /* **** */
 572
 573         return DS_OK;
 574 }
 575
 576 static HRESULT WINAPI PrimaryBufferImpl_Stop(LPDIRECTSOUNDBUFFER8 iface)
 577 {
 578         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 579         TRACE("(%p)\n", iface);
 580
 581         /* **** */
 582         EnterCriticalSection(&(device->mixlock));
 583
 584         if (device->state == STATE_PLAYING)
 585                 device->state = STATE_STOPPING;
 586         else if (device->state == STATE_STARTING)
 587                 device->state = STATE_STOPPED;
 588
 589         LeaveCriticalSection(&(device->mixlock));
 590         /* **** */
 591
 592         return DS_OK;
 593 }
 594
 595 static ULONG WINAPI PrimaryBufferImpl_AddRef(LPDIRECTSOUNDBUFFER8 iface)
 596 {
 597     PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 598     ULONG ref = InterlockedIncrement(&(This->ref));
 599     TRACE("(%p) ref was %d\n", This, ref - 1);
 600     return ref;
 601 }
 602
 603 static ULONG WINAPI PrimaryBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface)
 604 {
 605     PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 606     DWORD ref = InterlockedDecrement(&(This->ref));
 607     TRACE("(%p) ref was %d\n", This, ref + 1);
 608
 609     if (!ref) {
 610         This->device->primary = NULL;
 611         HeapFree(GetProcessHeap(), 0, This);
 612         TRACE("(%p) released\n", This);
 613     }
 614     return ref;
 615 }
 616
 617 static HRESULT WINAPI PrimaryBufferImpl_GetCurrentPosition(
 618         LPDIRECTSOUNDBUFFER8 iface,LPDWORD playpos,LPDWORD writepos
 619 ) {
 620         HRESULT hres;
 621         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 622         TRACE("(%p,%p,%p)\n", iface, playpos, writepos);
 623
 624         hres = DSOUND_PrimaryGetPosition(device, playpos, writepos);
 625         if (hres != DS_OK) {
 626                 WARN("DSOUND_PrimaryGetPosition failed\n");
 627                 return hres;
 628         }
 629         if (writepos) {
 630                 if (device->state != STATE_STOPPED)
 631                         /* apply the documented 10ms lead to writepos */
 632                         *writepos += device->writelead;
 633                 while (*writepos >= device->buflen) *writepos -= device->buflen;
 634         }
 635         TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:0, writepos?*writepos:0, device, GetTickCount());
 636         return DS_OK;
 637 }
 638
 639 static HRESULT WINAPI PrimaryBufferImpl_GetStatus(
 640         LPDIRECTSOUNDBUFFER8 iface,LPDWORD status
 641 ) {
 642         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 643         TRACE("(%p,%p)\n", iface, status);
 644
 645         if (status == NULL) {
 646                 WARN("invalid parameter: status == NULL\n");
 647                 return DSERR_INVALIDPARAM;
 648         }
 649
 650         *status = 0;
 651         if ((device->state == STATE_STARTING) ||
 652             (device->state == STATE_PLAYING))
 653                 *status |= DSBSTATUS_PLAYING | DSBSTATUS_LOOPING;
 654
 655         TRACE("status=%x\n", *status);
 656         return DS_OK;
 657 }
 658
 659
 660 static HRESULT WINAPI PrimaryBufferImpl_GetFormat(
 661     LPDIRECTSOUNDBUFFER8 iface,
 662     LPWAVEFORMATEX lpwf,
 663     DWORD wfsize,
 664     LPDWORD wfwritten)
 665 {
 666     DWORD size;
 667     DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 668     TRACE("(%p,%p,%d,%p)\n", iface, lpwf, wfsize, wfwritten);
 669
 670     size = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
 671
 672     if (lpwf) { /* NULL is valid */
 673         if (wfsize >= size) {
 674             CopyMemory(lpwf,device->pwfx,size);
 675             if (wfwritten)
 676                 *wfwritten = size;
 677         } else {
 678             WARN("invalid parameter: wfsize too small\n");
 679             if (wfwritten)
 680                 *wfwritten = 0;
 681             return DSERR_INVALIDPARAM;
 682         }
 683     } else {
 684         if (wfwritten)
 685             *wfwritten = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
 686         else {
 687             WARN("invalid parameter: wfwritten == NULL\n");
 688             return DSERR_INVALIDPARAM;
 689         }
 690     }
 691
 692     return DS_OK;
 693 }
 694
 695 static HRESULT WINAPI PrimaryBufferImpl_Lock(
 696         LPDIRECTSOUNDBUFFER8 iface,DWORD writecursor,DWORD writebytes,LPVOID *lplpaudioptr1,LPDWORD audiobytes1,LPVOID *lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
 697 ) {
 698         HRESULT hres;
 699         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 700         TRACE("(%p,%d,%d,%p,%p,%p,%p,0x%08x) at %d\n",
 701                 iface,
 702                 writecursor,
 703                 writebytes,
 704                 lplpaudioptr1,
 705                 audiobytes1,
 706                 lplpaudioptr2,
 707                 audiobytes2,
 708                 flags,
 709                 GetTickCount()
 710         );
 711
 712         if (device->priolevel != DSSCL_WRITEPRIMARY) {
 713                 WARN("failed priority check!\n");
 714                 return DSERR_PRIOLEVELNEEDED;
 715         }
 716
 717         /* when this flag is set, writecursor is meaningless and must be calculated */
 718         if (flags & DSBLOCK_FROMWRITECURSOR) {
 719                 /* GetCurrentPosition does too much magic to duplicate here */
 720                 hres = IDirectSoundBuffer_GetCurrentPosition(iface, NULL, &writecursor);
 721                 if (hres != DS_OK) {
 722                         WARN("IDirectSoundBuffer_GetCurrentPosition failed\n");
 723                         return hres;
 724                 }
 725         }
 726
 727         /* when this flag is set, writebytes is meaningless and must be set */
 728         if (flags & DSBLOCK_ENTIREBUFFER)
 729                 writebytes = device->buflen;
 730
 731         if (writecursor >= device->buflen) {
 732                 WARN("Invalid parameter, writecursor: %u >= buflen: %u\n",
 733                      writecursor, device->buflen);
 734                 return DSERR_INVALIDPARAM;
 735         }
 736
 737         if (writebytes > device->buflen) {
 738                 WARN("Invalid parameter, writebytes: %u > buflen: %u\n",
 739                      writebytes, device->buflen);
 740                 return DSERR_INVALIDPARAM;
 741         }
 742
 743         if (!(device->drvdesc.dwFlags & DSDDESC_DONTNEEDPRIMARYLOCK) && device->hwbuf) {
 744                 hres = IDsDriverBuffer_Lock(device->hwbuf,
 745                                             lplpaudioptr1, audiobytes1,
 746                                             lplpaudioptr2, audiobytes2,
 747                                             writecursor, writebytes,
 748                                             0);
 749                 if (hres != DS_OK) {
 750                         WARN("IDsDriverBuffer_Lock failed\n");
 751                         return hres;
 752                 }
 753         } else {
 754                 if (writecursor+writebytes <= device->buflen) {
 755                         *(LPBYTE*)lplpaudioptr1 = device->buffer+writecursor;
 756                         *audiobytes1 = writebytes;
 757                         if (lplpaudioptr2)
 758                                 *(LPBYTE*)lplpaudioptr2 = NULL;
 759                         if (audiobytes2)
 760                                 *audiobytes2 = 0;
 761                         TRACE("->%d.0\n",writebytes);
 762                 } else {
 763                         *(LPBYTE*)lplpaudioptr1 = device->buffer+writecursor;
 764                         *audiobytes1 = device->buflen-writecursor;
 765                         if (lplpaudioptr2)
 766                                 *(LPBYTE*)lplpaudioptr2 = device->buffer;
 767                         if (audiobytes2)
 768                                 *audiobytes2 = writebytes-(device->buflen-writecursor);
 769                         TRACE("->%d.%d\n",*audiobytes1,audiobytes2?*audiobytes2:0);
 770                 }
 771         }
 772         return DS_OK;
 773 }
 774
 775 static HRESULT WINAPI PrimaryBufferImpl_SetCurrentPosition(
 776         LPDIRECTSOUNDBUFFER8 iface,DWORD newpos
 777 ) {
 778         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 779         TRACE("(%p,%d)\n",This,newpos);
 780
 781         /* You cannot set the position of the primary buffer */
 782         WARN("invalid call\n");
 783         return DSERR_INVALIDCALL;
 784 }
 785
 786 static HRESULT WINAPI PrimaryBufferImpl_SetPan(
 787         LPDIRECTSOUNDBUFFER8 iface,LONG pan
 788 ) {
 789         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 790         DWORD ampfactors;
 791         DSVOLUMEPAN volpan;
 792         HRESULT hres = DS_OK;
 793         TRACE("(%p,%d)\n", iface, pan);
 794
 795         if (!(device->dsbd.dwFlags & DSBCAPS_CTRLPAN)) {
 796                 WARN("control unavailable\n");
 797                 return DSERR_CONTROLUNAVAIL;
 798         }
 799
 800         if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT)) {
 801                 WARN("invalid parameter: pan = %d\n", pan);
 802                 return DSERR_INVALIDPARAM;
 803         }
 804
 805         /* **** */
 806         EnterCriticalSection(&(device->mixlock));
 807
 808         waveOutGetVolume(device->hwo, &ampfactors);
 809         volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 810         volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 811         DSOUND_AmpFactorToVolPan(&volpan);
 812         if (pan != volpan.lPan) {
 813             volpan.lPan=pan;
 814             DSOUND_RecalcVolPan(&volpan);
 815             if (device->hwbuf) {
 816                 hres = IDsDriverBuffer_SetVolumePan(device->hwbuf, &volpan);
 817                 if (hres != DS_OK)
 818                     WARN("IDsDriverBuffer_SetVolumePan failed\n");
 819             } else {
 820                 ampfactors = (volpan.dwTotalLeftAmpFactor & 0xffff) | (volpan.dwTotalRightAmpFactor << 16);
 821                 waveOutSetVolume(device->hwo, ampfactors);
 822             }
 823         }
 824
 825         LeaveCriticalSection(&(device->mixlock));
 826         /* **** */
 827
 828         return hres;
 829 }
 830
 831 static HRESULT WINAPI PrimaryBufferImpl_GetPan(
 832         LPDIRECTSOUNDBUFFER8 iface,LPLONG pan
 833 ) {
 834         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 835         DWORD ampfactors;
 836         DSVOLUMEPAN volpan;
 837         TRACE("(%p,%p)\n", iface, pan);
 838
 839         if (!(device->dsbd.dwFlags & DSBCAPS_CTRLPAN)) {
 840                 WARN("control unavailable\n");
 841                 return DSERR_CONTROLUNAVAIL;
 842         }
 843
 844         if (pan == NULL) {
 845                 WARN("invalid parameter: pan == NULL\n");
 846                 return DSERR_INVALIDPARAM;
 847         }
 848
 849         waveOutGetVolume(device->hwo, &ampfactors);
 850         volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
 851         volpan.dwTotalRightAmpFactor=ampfactors >> 16;
 852         DSOUND_AmpFactorToVolPan(&volpan);
 853         *pan = volpan.lPan;
 854         return DS_OK;
 855 }
 856
 857 static HRESULT WINAPI PrimaryBufferImpl_Unlock(
 858         LPDIRECTSOUNDBUFFER8 iface,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
 859 ) {
 860         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 861         TRACE("(%p,%p,%d,%p,%d)\n", iface, p1, x1, p2, x2);
 862
 863         if (device->priolevel != DSSCL_WRITEPRIMARY) {
 864                 WARN("failed priority check!\n");
 865                 return DSERR_PRIOLEVELNEEDED;
 866         }
 867
 868         if (!(device->drvdesc.dwFlags & DSDDESC_DONTNEEDPRIMARYLOCK) && device->hwbuf) {
 869                 HRESULT hres;
 870
 871                 hres = IDsDriverBuffer_Unlock(device->hwbuf, p1, x1, p2, x2);
 872                 if (hres != DS_OK) {
 873                         WARN("IDsDriverBuffer_Unlock failed\n");
 874                         return hres;
 875                 }
 876         }
 877
 878         return DS_OK;
 879 }
 880
 881 static HRESULT WINAPI PrimaryBufferImpl_Restore(
 882         LPDIRECTSOUNDBUFFER8 iface
 883 ) {
 884         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 885         FIXME("(%p):stub\n",This);
 886         return DS_OK;
 887 }
 888
 889 static HRESULT WINAPI PrimaryBufferImpl_GetFrequency(
 890         LPDIRECTSOUNDBUFFER8 iface,LPDWORD freq
 891 ) {
 892         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 893         TRACE("(%p,%p)\n", iface, freq);
 894
 895         if (freq == NULL) {
 896                 WARN("invalid parameter: freq == NULL\n");
 897                 return DSERR_INVALIDPARAM;
 898         }
 899
 900         if (!(device->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY)) {
 901                 WARN("control unavailable\n");
 902                 return DSERR_CONTROLUNAVAIL;
 903         }
 904
 905         *freq = device->pwfx->nSamplesPerSec;
 906         TRACE("-> %d\n", *freq);
 907
 908         return DS_OK;
 909 }
 910
 911 static HRESULT WINAPI PrimaryBufferImpl_SetFX(
 912         LPDIRECTSOUNDBUFFER8 iface,DWORD dwEffectsCount,LPDSEFFECTDESC pDSFXDesc,LPDWORD pdwResultCodes
 913 ) {
 914         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 915         DWORD u;
 916         FIXME("(%p,%u,%p,%p): stub\n",This,dwEffectsCount,pDSFXDesc,pdwResultCodes);
 917
 918         if (pdwResultCodes)
 919                 for (u=0; u<dwEffectsCount; u++) pdwResultCodes[u] = DSFXR_UNKNOWN;
 920
 921         WARN("control unavailable\n");
 922         return DSERR_CONTROLUNAVAIL;
 923 }
 924
 925 static HRESULT WINAPI PrimaryBufferImpl_AcquireResources(
 926         LPDIRECTSOUNDBUFFER8 iface,DWORD dwFlags,DWORD dwEffectsCount,LPDWORD pdwResultCodes
 927 ) {
 928         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 929         DWORD u;
 930         FIXME("(%p,%08u,%u,%p): stub\n",This,dwFlags,dwEffectsCount,pdwResultCodes);
 931
 932         if (pdwResultCodes)
 933                 for (u=0; u<dwEffectsCount; u++) pdwResultCodes[u] = DSFXR_UNKNOWN;
 934
 935         WARN("control unavailable\n");
 936         return DSERR_CONTROLUNAVAIL;
 937 }
 938
 939 static HRESULT WINAPI PrimaryBufferImpl_GetObjectInPath(
 940         LPDIRECTSOUNDBUFFER8 iface,REFGUID rguidObject,DWORD dwIndex,REFGUID rguidInterface,LPVOID* ppObject
 941 ) {
 942         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 943         FIXME("(%p,%s,%u,%s,%p): stub\n",This,debugstr_guid(rguidObject),dwIndex,debugstr_guid(rguidInterface),ppObject);
 944
 945         WARN("control unavailable\n");
 946         return DSERR_CONTROLUNAVAIL;
 947 }
 948
 949 static HRESULT WINAPI PrimaryBufferImpl_Initialize(
 950         LPDIRECTSOUNDBUFFER8 iface,LPDIRECTSOUND dsound,LPCDSBUFFERDESC dbsd
 951 ) {
 952         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 953         FIXME("(%p,%p,%p):stub\n",This,dsound,dbsd);
 954         DPRINTF("Re-Init!!!\n");
 955         WARN("already initialized\n");
 956         return DSERR_ALREADYINITIALIZED;
 957 }
 958
 959 static HRESULT WINAPI PrimaryBufferImpl_GetCaps(
 960         LPDIRECTSOUNDBUFFER8 iface,LPDSBCAPS caps
 961 ) {
 962         DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
 963         TRACE("(%p,%p)\n", iface, caps);
 964
 965         if (caps == NULL) {
 966                 WARN("invalid parameter: caps == NULL\n");
 967                 return DSERR_INVALIDPARAM;
 968         }
 969
 970         if (caps->dwSize < sizeof(*caps)) {
 971                 WARN("invalid parameter: caps->dwSize = %d\n", caps->dwSize);
 972                 return DSERR_INVALIDPARAM;
 973         }
 974
 975         caps->dwFlags = device->dsbd.dwFlags;
 976         if (device->hwbuf) caps->dwFlags |= DSBCAPS_LOCHARDWARE;
 977         else caps->dwFlags |= DSBCAPS_LOCSOFTWARE;
 978
 979         caps->dwBufferBytes = device->buflen;
 980
 981         /* This value represents the speed of the "unlock" command.
 982            As unlock is quite fast (it does not do anything), I put
 983            4096 ko/s = 4 Mo / s */
 984         /* FIXME: hwbuf speed */
 985         caps->dwUnlockTransferRate = 4096;
 986         caps->dwPlayCpuOverhead = 0;
 987
 988         return DS_OK;
 989 }
 990
 991 static HRESULT WINAPI PrimaryBufferImpl_QueryInterface(
 992         LPDIRECTSOUNDBUFFER8 iface,REFIID riid,LPVOID *ppobj
 993 ) {
 994         PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
 995         DirectSoundDevice *device = This->device;
 996         TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppobj);
 997
 998         if (ppobj == NULL) {
 999                 WARN("invalid parameter\n");
1000                 return E_INVALIDARG;
1001         }
1002
1003         *ppobj = NULL;  /* assume failure */
1004
1005         if ( IsEqualGUID(riid, &IID_IUnknown) ||
1006              IsEqualGUID(riid, &IID_IDirectSoundBuffer) ) {
1007                 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)This);
1008                 *ppobj = This;
1009                 return S_OK;
1010         }
1011
1012         /* DirectSoundBuffer and DirectSoundBuffer8 are different and */
1013         /* a primary buffer can't have a DirectSoundBuffer8 interface */
1014         if ( IsEqualGUID( &IID_IDirectSoundBuffer8, riid ) ) {
1015                 WARN("app requested DirectSoundBuffer8 on primary buffer\n");
1016                 return E_NOINTERFACE;
1017         }
1018
1019         if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
1020                 ERR("app requested IDirectSoundNotify on primary buffer\n");
1021                 /* FIXME: should we support this? */
1022                 return E_NOINTERFACE;
1023         }
1024
1025         if ( IsEqualGUID( &IID_IDirectSound3DBuffer, riid ) ) {
1026                 ERR("app requested IDirectSound3DBuffer on primary buffer\n");
1027                 return E_NOINTERFACE;
1028         }
1029
1030         if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
1031                 if (!device->listener)
1032                         IDirectSound3DListenerImpl_Create(device, &device->listener);
1033                 if (device->listener) {
1034                         *ppobj = device->listener;
1035                         IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)*ppobj);
1036                         return S_OK;
1037                 }
1038
1039                 WARN("IID_IDirectSound3DListener failed\n");
1040                 return E_NOINTERFACE;
1041         }
1042
1043         if ( IsEqualGUID( &IID_IKsPropertySet, riid ) ) {
1044                 FIXME("app requested IKsPropertySet on primary buffer\n");
1045                 return E_NOINTERFACE;
1046         }
1047
1048         FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
1049         return E_NOINTERFACE;
1050 }
1051
1052 static const IDirectSoundBuffer8Vtbl dspbvt =
1053 {
1054         PrimaryBufferImpl_QueryInterface,
1055         PrimaryBufferImpl_AddRef,
1056         PrimaryBufferImpl_Release,
1057         PrimaryBufferImpl_GetCaps,
1058         PrimaryBufferImpl_GetCurrentPosition,
1059         PrimaryBufferImpl_GetFormat,
1060         PrimaryBufferImpl_GetVolume,
1061         PrimaryBufferImpl_GetPan,
1062         PrimaryBufferImpl_GetFrequency,
1063         PrimaryBufferImpl_GetStatus,
1064         PrimaryBufferImpl_Initialize,
1065         PrimaryBufferImpl_Lock,
1066         PrimaryBufferImpl_Play,
1067         PrimaryBufferImpl_SetCurrentPosition,
1068         PrimaryBufferImpl_SetFormat,
1069         PrimaryBufferImpl_SetVolume,
1070         PrimaryBufferImpl_SetPan,
1071         PrimaryBufferImpl_SetFrequency,
1072         PrimaryBufferImpl_Stop,
1073         PrimaryBufferImpl_Unlock,
1074         PrimaryBufferImpl_Restore,
1075         PrimaryBufferImpl_SetFX,
1076         PrimaryBufferImpl_AcquireResources,
1077         PrimaryBufferImpl_GetObjectInPath
1078 };
1079
1080 HRESULT PrimaryBufferImpl_Create(
1081         DirectSoundDevice * device,
1082         PrimaryBufferImpl ** ppdsb,
1083         LPCDSBUFFERDESC dsbd)
1084 {
1085         PrimaryBufferImpl *dsb;
1086         TRACE("%p,%p,%p)\n",device,ppdsb,dsbd);
1087
1088         if (dsbd->lpwfxFormat) {
1089                 WARN("invalid parameter: dsbd->lpwfxFormat != NULL\n");
1090                 *ppdsb = NULL;
1091                 return DSERR_INVALIDPARAM;
1092         }
1093
1094         dsb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb));
1095
1096         if (dsb == NULL) {
1097                 WARN("out of memory\n");
1098                 *ppdsb = NULL;
1099                 return DSERR_OUTOFMEMORY;
1100         }
1101
1102         dsb->ref = 0;
1103         dsb->device = device;
1104         dsb->lpVtbl = &dspbvt;
1105
1106         CopyMemory(&device->dsbd, dsbd, sizeof(*dsbd));
1107
1108         TRACE("Created primary buffer at %p\n", dsb);
1109         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
1110                 "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1111                 device->pwfx->wFormatTag, device->pwfx->nChannels,
1112                 device->pwfx->nSamplesPerSec, device->pwfx->nAvgBytesPerSec,
1113                 device->pwfx->nBlockAlign, device->pwfx->wBitsPerSample,
1114                 device->pwfx->cbSize);
1115
1116         *ppdsb = dsb;
1117         return S_OK;
1118 }