dlls/dsound/buffer.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 "winternl.h"
  31 #include "wine/debug.h"
  32 #include "dsound.h"
  33 #include "dsdriver.h"
  34 #include "dsound_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  37
  38 static HRESULT SecondaryBufferImpl_Destroy(SecondaryBufferImpl *pdsb);
  39
  40 /*******************************************************************************
  41  *              IDirectSoundNotify
  42  */
  43
  44 struct IDirectSoundNotifyImpl
  45 {
  46     /* IUnknown fields */
  47     const IDirectSoundNotifyVtbl *lpVtbl;
  48     LONG                        ref;
  49     IDirectSoundBufferImpl*     dsb;
  50 };
  51
  52 static HRESULT IDirectSoundNotifyImpl_Create(IDirectSoundBufferImpl *dsb,
  53                                              IDirectSoundNotifyImpl **pdsn);
  54 static HRESULT IDirectSoundNotifyImpl_Destroy(IDirectSoundNotifyImpl *pdsn);
  55
  56 static HRESULT WINAPI IDirectSoundNotifyImpl_QueryInterface(
  57         LPDIRECTSOUNDNOTIFY iface,REFIID riid,LPVOID *ppobj
  58 ) {
  59         IDirectSoundNotifyImpl *This = (IDirectSoundNotifyImpl *)iface;
  60         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
  61
  62         if (This->dsb == NULL) {
  63                 WARN("invalid parameter\n");
  64                 return E_INVALIDARG;
  65         }
  66
  67         return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER)This->dsb, riid, ppobj);
  68 }
  69
  70 static ULONG WINAPI IDirectSoundNotifyImpl_AddRef(LPDIRECTSOUNDNOTIFY iface)
  71 {
  72     IDirectSoundNotifyImpl *This = (IDirectSoundNotifyImpl *)iface;
  73     ULONG ref = InterlockedIncrement(&(This->ref));
  74     TRACE("(%p) ref was %d\n", This, ref - 1);
  75     return ref;
  76 }
  77
  78 static ULONG WINAPI IDirectSoundNotifyImpl_Release(LPDIRECTSOUNDNOTIFY iface)
  79 {
  80     IDirectSoundNotifyImpl *This = (IDirectSoundNotifyImpl *)iface;
  81     ULONG ref = InterlockedDecrement(&(This->ref));
  82     TRACE("(%p) ref was %d\n", This, ref + 1);
  83
  84     if (!ref) {
  85         IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->dsb);
  86         This->dsb->notify = NULL;
  87         HeapFree(GetProcessHeap(), 0, This);
  88         TRACE("(%p) released\n", This);
  89     }
  90     return ref;
  91 }
  92
  93 static HRESULT WINAPI IDirectSoundNotifyImpl_SetNotificationPositions(
  94         LPDIRECTSOUNDNOTIFY iface,DWORD howmuch,LPCDSBPOSITIONNOTIFY notify
  95 ) {
  96         IDirectSoundNotifyImpl *This = (IDirectSoundNotifyImpl *)iface;
  97         TRACE("(%p,0x%08x,%p)\n",This,howmuch,notify);
  98
  99         if (howmuch > 0 && notify == NULL) {
 100             WARN("invalid parameter: notify == NULL\n");
 101             return DSERR_INVALIDPARAM;
 102         }
 103
 104         if (TRACE_ON(dsound)) {
 105             unsigned int        i;
 106             for (i=0;i<howmuch;i++)
 107                 TRACE("notify at %d to %p\n",
 108                     notify[i].dwOffset,notify[i].hEventNotify);
 109         }
 110
 111         if (This->dsb->hwnotify) {
 112             HRESULT hres;
 113             hres = IDsDriverNotify_SetNotificationPositions(This->dsb->hwnotify, howmuch, notify);
 114             if (hres != DS_OK)
 115                     WARN("IDsDriverNotify_SetNotificationPositions failed\n");
 116             return hres;
 117         } else if (howmuch > 0) {
 118             /* Make an internal copy of the caller-supplied array.
 119              * Replace the existing copy if one is already present. */
 120             if (This->dsb->notifies)
 121                     This->dsb->notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 122                         This->dsb->notifies, howmuch * sizeof(DSBPOSITIONNOTIFY));
 123             else
 124                     This->dsb->notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 125                         howmuch * sizeof(DSBPOSITIONNOTIFY));
 126
 127             if (This->dsb->notifies == NULL) {
 128                     WARN("out of memory\n");
 129                     return DSERR_OUTOFMEMORY;
 130             }
 131             CopyMemory(This->dsb->notifies, notify, howmuch * sizeof(DSBPOSITIONNOTIFY));
 132             This->dsb->nrofnotifies = howmuch;
 133         } else {
 134            HeapFree(GetProcessHeap(), 0, This->dsb->notifies);
 135            This->dsb->notifies = NULL;
 136            This->dsb->nrofnotifies = 0;
 137         }
 138
 139         return S_OK;
 140 }
 141
 142 static const IDirectSoundNotifyVtbl dsnvt =
 143 {
 144     IDirectSoundNotifyImpl_QueryInterface,
 145     IDirectSoundNotifyImpl_AddRef,
 146     IDirectSoundNotifyImpl_Release,
 147     IDirectSoundNotifyImpl_SetNotificationPositions,
 148 };
 149
 150 static HRESULT IDirectSoundNotifyImpl_Create(
 151     IDirectSoundBufferImpl * dsb,
 152     IDirectSoundNotifyImpl **pdsn)
 153 {
 154     IDirectSoundNotifyImpl * dsn;
 155     TRACE("(%p,%p)\n",dsb,pdsn);
 156
 157     dsn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dsn));
 158
 159     if (dsn == NULL) {
 160         WARN("out of memory\n");
 161         return DSERR_OUTOFMEMORY;
 162     }
 163
 164     dsn->ref = 0;
 165     dsn->lpVtbl = &dsnvt;
 166     dsn->dsb = dsb;
 167     dsb->notify = dsn;
 168     IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)dsb);
 169
 170     *pdsn = dsn;
 171     return DS_OK;
 172 }
 173
 174 static HRESULT IDirectSoundNotifyImpl_Destroy(
 175     IDirectSoundNotifyImpl *pdsn)
 176 {
 177     TRACE("(%p)\n",pdsn);
 178
 179     while (IDirectSoundNotifyImpl_Release((LPDIRECTSOUNDNOTIFY)pdsn) > 0);
 180
 181     return DS_OK;
 182 }
 183
 184 /*******************************************************************************
 185  *              IDirectSoundBuffer
 186  */
 187
 188 static HRESULT WINAPI IDirectSoundBufferImpl_SetFormat(
 189         LPDIRECTSOUNDBUFFER8 iface,LPCWAVEFORMATEX wfex
 190 ) {
 191         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 192
 193         TRACE("(%p,%p)\n",This,wfex);
 194         /* This method is not available on secondary buffers */
 195         WARN("invalid call\n");
 196         return DSERR_INVALIDCALL;
 197 }
 198
 199 static HRESULT WINAPI IDirectSoundBufferImpl_SetVolume(
 200         LPDIRECTSOUNDBUFFER8 iface,LONG vol
 201 ) {
 202         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 203         LONG oldVol;
 204         HRESULT hres = DS_OK;
 205
 206         TRACE("(%p,%d)\n",This,vol);
 207
 208         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
 209                 WARN("control unavailable: This->dsbd.dwFlags = 0x%08x\n", This->dsbd.dwFlags);
 210                 return DSERR_CONTROLUNAVAIL;
 211         }
 212
 213         if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN)) {
 214                 WARN("invalid parameter: vol = %d\n", vol);
 215                 return DSERR_INVALIDPARAM;
 216         }
 217
 218         /* **** */
 219         RtlAcquireResourceExclusive(&This->lock, TRUE);
 220
 221         if (This->dsbd.dwFlags & DSBCAPS_CTRL3D) {
 222                 oldVol = This->ds3db_lVolume;
 223                 This->ds3db_lVolume = vol;
 224                 if (vol != oldVol)
 225                         /* recalc 3d volume, which in turn recalcs the pans */
 226                         DSOUND_Calc3DBuffer(This);
 227         } else {
 228                 oldVol = This->volpan.lVolume;
 229                 This->volpan.lVolume = vol;
 230                 if (vol != oldVol)
 231                         DSOUND_RecalcVolPan(&(This->volpan));
 232         }
 233
 234         if (vol != oldVol) {
 235                 if (This->hwbuf) {
 236                         hres = IDsDriverBuffer_SetVolumePan(This->hwbuf, &(This->volpan));
 237                         if (hres != DS_OK)
 238                                 WARN("IDsDriverBuffer_SetVolumePan failed\n");
 239                 }
 240         }
 241
 242         RtlReleaseResource(&This->lock);
 243         /* **** */
 244
 245         return hres;
 246 }
 247
 248 static HRESULT WINAPI IDirectSoundBufferImpl_GetVolume(
 249         LPDIRECTSOUNDBUFFER8 iface,LPLONG vol
 250 ) {
 251         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 252         TRACE("(%p,%p)\n",This,vol);
 253
 254         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
 255                 WARN("control unavailable\n");
 256                 return DSERR_CONTROLUNAVAIL;
 257         }
 258
 259         if (vol == NULL) {
 260                 WARN("invalid parameter: vol == NULL\n");
 261                 return DSERR_INVALIDPARAM;
 262         }
 263
 264         *vol = This->volpan.lVolume;
 265
 266         return DS_OK;
 267 }
 268
 269 static HRESULT WINAPI IDirectSoundBufferImpl_SetFrequency(
 270         LPDIRECTSOUNDBUFFER8 iface,DWORD freq
 271 ) {
 272         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 273         DWORD oldFreq;
 274
 275         TRACE("(%p,%d)\n",This,freq);
 276
 277         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY)) {
 278                 WARN("control unavailable\n");
 279                 return DSERR_CONTROLUNAVAIL;
 280         }
 281
 282         if (freq == DSBFREQUENCY_ORIGINAL)
 283                 freq = This->pwfx->nSamplesPerSec;
 284
 285         if ((freq < DSBFREQUENCY_MIN) || (freq > DSBFREQUENCY_MAX)) {
 286                 WARN("invalid parameter: freq = %d\n", freq);
 287                 return DSERR_INVALIDPARAM;
 288         }
 289
 290         /* **** */
 291         RtlAcquireResourceExclusive(&This->lock, TRUE);
 292
 293         oldFreq = This->freq;
 294         This->freq = freq;
 295         if (freq != oldFreq) {
 296                 This->freqAdjust = ((DWORD64)This->freq << DSOUND_FREQSHIFT) / This->device->pwfx->nSamplesPerSec;
 297                 This->nAvgBytesPerSec = freq * This->pwfx->nBlockAlign;
 298                 DSOUND_RecalcFormat(This);
 299                 DSOUND_MixToTemporary(This, 0, This->buflen, FALSE);
 300         }
 301
 302         RtlReleaseResource(&This->lock);
 303         /* **** */
 304
 305         return DS_OK;
 306 }
 307
 308 static HRESULT WINAPI IDirectSoundBufferImpl_Play(
 309         LPDIRECTSOUNDBUFFER8 iface,DWORD reserved1,DWORD reserved2,DWORD flags
 310 ) {
 311         HRESULT hres = DS_OK;
 312         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 313         TRACE("(%p,%08x,%08x,%08x)\n",This,reserved1,reserved2,flags);
 314
 315         /* **** */
 316         RtlAcquireResourceExclusive(&This->lock, TRUE);
 317
 318         This->playflags = flags;
 319         if (This->state == STATE_STOPPED && !This->hwbuf) {
 320                 This->leadin = TRUE;
 321                 This->state = STATE_STARTING;
 322         } else if (This->state == STATE_STOPPING)
 323                 This->state = STATE_PLAYING;
 324         if (This->hwbuf) {
 325                 hres = IDsDriverBuffer_Play(This->hwbuf, 0, 0, This->playflags);
 326                 if (hres != DS_OK)
 327                         WARN("IDsDriverBuffer_Play failed\n");
 328                 else
 329                         This->state = STATE_PLAYING;
 330         }
 331
 332         RtlReleaseResource(&This->lock);
 333         /* **** */
 334
 335         return hres;
 336 }
 337
 338 static HRESULT WINAPI IDirectSoundBufferImpl_Stop(LPDIRECTSOUNDBUFFER8 iface)
 339 {
 340         HRESULT hres = DS_OK;
 341         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 342         TRACE("(%p)\n",This);
 343
 344         /* **** */
 345         RtlAcquireResourceExclusive(&This->lock, TRUE);
 346
 347         if (This->state == STATE_PLAYING)
 348                 This->state = STATE_STOPPING;
 349         else if (This->state == STATE_STARTING)
 350         {
 351                 This->state = STATE_STOPPED;
 352                 DSOUND_CheckEvent(This, 0, 0);
 353         }
 354         if (This->hwbuf) {
 355                 hres = IDsDriverBuffer_Stop(This->hwbuf);
 356                 if (hres != DS_OK)
 357                         WARN("IDsDriverBuffer_Stop failed\n");
 358                 else
 359                         This->state = STATE_STOPPED;
 360         }
 361
 362         RtlReleaseResource(&This->lock);
 363         /* **** */
 364
 365         return hres;
 366 }
 367
 368 static ULONG WINAPI IDirectSoundBufferImpl_AddRef(LPDIRECTSOUNDBUFFER8 iface)
 369 {
 370     IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 371     ULONG ref = InterlockedIncrement(&(This->ref));
 372     TRACE("(%p) ref was %d\n", This, ref - 1);
 373     return ref;
 374 }
 375
 376 static ULONG WINAPI IDirectSoundBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface)
 377 {
 378     IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 379     ULONG ref = InterlockedDecrement(&(This->ref));
 380     TRACE("(%p) ref was %d\n", This, ref + 1);
 381
 382     if (!ref) {
 383         DirectSoundDevice_RemoveBuffer(This->device, This);
 384         RtlDeleteResource(&This->lock);
 385
 386         if (This->hwbuf) {
 387                 IDsDriverBuffer_Release(This->hwbuf);
 388                 if (This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) {
 389                         This->buffer->ref--;
 390                         list_remove(&This->entry);
 391                         if (This->buffer->ref==0) {
 392                                 HeapFree(GetProcessHeap(),0,This->buffer->memory);
 393                                 HeapFree(GetProcessHeap(),0,This->buffer);
 394                         }
 395                 }
 396         } else {
 397                 This->buffer->ref--;
 398                 list_remove(&This->entry);
 399                 if (This->buffer->ref==0) {
 400                         HeapFree(GetProcessHeap(),0,This->buffer->memory);
 401                         HeapFree(GetProcessHeap(),0,This->buffer);
 402                 }
 403         }
 404
 405         HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
 406         HeapFree(GetProcessHeap(), 0, This->notifies);
 407         HeapFree(GetProcessHeap(), 0, This->pwfx);
 408         HeapFree(GetProcessHeap(), 0, This);
 409
 410         TRACE("(%p) released\n", This);
 411     }
 412     return ref;
 413 }
 414
 415 static HRESULT WINAPI IDirectSoundBufferImpl_GetCurrentPosition(
 416         LPDIRECTSOUNDBUFFER8 iface,LPDWORD playpos,LPDWORD writepos
 417 ) {
 418         HRESULT hres;
 419         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 420         TRACE("(%p,%p,%p)\n",This,playpos,writepos);
 421
 422         RtlAcquireResourceShared(&This->lock, TRUE);
 423         if (This->hwbuf) {
 424                 hres=IDsDriverBuffer_GetPosition(This->hwbuf,playpos,writepos);
 425                 if (hres != DS_OK) {
 426                     WARN("IDsDriverBuffer_GetPosition failed\n");
 427                     return hres;
 428                 }
 429         } else {
 430                 DWORD pos = This->sec_mixpos;
 431
 432                 /* sanity */
 433                 if (pos >= This->buflen){
 434                         FIXME("Bad play position. playpos: %d, buflen: %d\n", pos, This->buflen);
 435                         pos %= This->buflen;
 436                 }
 437
 438                 if (playpos)
 439                         *playpos = pos;
 440                 if (writepos)
 441                         *writepos = pos;
 442         }
 443         if (writepos && This->state != STATE_STOPPED && (!This->hwbuf || !(This->device->drvdesc.dwFlags & DSDDESC_DONTNEEDWRITELEAD))) {
 444                 /* apply the documented 10ms lead to writepos */
 445                 *writepos += This->writelead;
 446                 *writepos %= This->buflen;
 447         }
 448         RtlReleaseResource(&This->lock);
 449
 450         TRACE("playpos = %d, writepos = %d, buflen=%d (%p, time=%d)\n",
 451                 playpos?*playpos:-1, writepos?*writepos:-1, This->buflen, This, GetTickCount());
 452
 453         return DS_OK;
 454 }
 455
 456 static HRESULT WINAPI IDirectSoundBufferImpl_GetStatus(
 457         LPDIRECTSOUNDBUFFER8 iface,LPDWORD status
 458 ) {
 459         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 460         TRACE("(%p,%p), thread is %04x\n",This,status,GetCurrentThreadId());
 461
 462         if (status == NULL) {
 463                 WARN("invalid parameter: status = NULL\n");
 464                 return DSERR_INVALIDPARAM;
 465         }
 466
 467         *status = 0;
 468         RtlAcquireResourceShared(&This->lock, TRUE);
 469         if ((This->state == STATE_STARTING) || (This->state == STATE_PLAYING)) {
 470                 *status |= DSBSTATUS_PLAYING;
 471                 if (This->playflags & DSBPLAY_LOOPING)
 472                         *status |= DSBSTATUS_LOOPING;
 473         }
 474         RtlReleaseResource(&This->lock);
 475
 476         TRACE("status=%x\n", *status);
 477         return DS_OK;
 478 }
 479
 480
 481 static HRESULT WINAPI IDirectSoundBufferImpl_GetFormat(
 482     LPDIRECTSOUNDBUFFER8 iface,
 483     LPWAVEFORMATEX lpwf,
 484     DWORD wfsize,
 485     LPDWORD wfwritten)
 486 {
 487     DWORD size;
 488     IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 489     TRACE("(%p,%p,%d,%p)\n",This,lpwf,wfsize,wfwritten);
 490
 491     size = sizeof(WAVEFORMATEX) + This->pwfx->cbSize;
 492
 493     if (lpwf) { /* NULL is valid */
 494         if (wfsize >= size) {
 495             CopyMemory(lpwf,This->pwfx,size);
 496             if (wfwritten)
 497                 *wfwritten = size;
 498         } else {
 499             WARN("invalid parameter: wfsize too small\n");
 500             CopyMemory(lpwf,This->pwfx,wfsize);
 501             if (wfwritten)
 502                 *wfwritten = wfsize;
 503             return DSERR_INVALIDPARAM;
 504         }
 505     } else {
 506         if (wfwritten)
 507             *wfwritten = sizeof(WAVEFORMATEX) + This->pwfx->cbSize;
 508         else {
 509             WARN("invalid parameter: wfwritten == NULL\n");
 510             return DSERR_INVALIDPARAM;
 511         }
 512     }
 513
 514     return DS_OK;
 515 }
 516
 517 static HRESULT WINAPI IDirectSoundBufferImpl_Lock(
 518         LPDIRECTSOUNDBUFFER8 iface,DWORD writecursor,DWORD writebytes,LPVOID *lplpaudioptr1,LPDWORD audiobytes1,LPVOID *lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
 519 ) {
 520         HRESULT hres = DS_OK;
 521         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 522
 523         TRACE("(%p,%d,%d,%p,%p,%p,%p,0x%08x) at %d\n",
 524                 This,
 525                 writecursor,
 526                 writebytes,
 527                 lplpaudioptr1,
 528                 audiobytes1,
 529                 lplpaudioptr2,
 530                 audiobytes2,
 531                 flags,
 532                 GetTickCount()
 533         );
 534
 535         if (!audiobytes1)
 536             return DSERR_INVALIDPARAM;
 537
 538         /* when this flag is set, writecursor is meaningless and must be calculated */
 539         if (flags & DSBLOCK_FROMWRITECURSOR) {
 540                 /* GetCurrentPosition does too much magic to duplicate here */
 541                 hres = IDirectSoundBufferImpl_GetCurrentPosition(iface, NULL, &writecursor);
 542                 if (hres != DS_OK) {
 543                         WARN("IDirectSoundBufferImpl_GetCurrentPosition failed\n");
 544                         return hres;
 545                 }
 546         }
 547
 548         /* when this flag is set, writebytes is meaningless and must be set */
 549         if (flags & DSBLOCK_ENTIREBUFFER)
 550                 writebytes = This->buflen;
 551
 552         if (writecursor >= This->buflen) {
 553                 WARN("Invalid parameter, writecursor: %u >= buflen: %u\n",
 554                      writecursor, This->buflen);
 555                 return DSERR_INVALIDPARAM;
 556         }
 557
 558         if (writebytes > This->buflen) {
 559                 WARN("Invalid parameter, writebytes: %u > buflen: %u\n",
 560                      writebytes, This->buflen);
 561                 return DSERR_INVALIDPARAM;
 562         }
 563
 564         /* **** */
 565         RtlAcquireResourceShared(&This->lock, TRUE);
 566
 567         if (!(This->device->drvdesc.dwFlags & DSDDESC_DONTNEEDSECONDARYLOCK) && This->hwbuf) {
 568                 hres = IDsDriverBuffer_Lock(This->hwbuf,
 569                                      lplpaudioptr1, audiobytes1,
 570                                      lplpaudioptr2, audiobytes2,
 571                                      writecursor, writebytes,
 572                                      0);
 573                 if (hres != DS_OK) {
 574                         WARN("IDsDriverBuffer_Lock failed\n");
 575                         RtlReleaseResource(&This->lock);
 576                         return hres;
 577                 }
 578         } else {
 579                 if (writecursor+writebytes <= This->buflen) {
 580                         *(LPBYTE*)lplpaudioptr1 = This->buffer->memory+writecursor;
 581                         if (This->sec_mixpos >= writecursor && This->sec_mixpos < writecursor + writebytes && This->state == STATE_PLAYING)
 582                                 WARN("Overwriting mixing position, case 1\n");
 583                         *audiobytes1 = writebytes;
 584                         if (lplpaudioptr2)
 585                                 *(LPBYTE*)lplpaudioptr2 = NULL;
 586                         if (audiobytes2)
 587                                 *audiobytes2 = 0;
 588                         TRACE("Locked %p(%i bytes) and %p(%i bytes) writecursor=%d\n",
 589                           *(LPBYTE*)lplpaudioptr1, *audiobytes1, lplpaudioptr2 ? *(LPBYTE*)lplpaudioptr2 : NULL, audiobytes2 ? *audiobytes2: 0, writecursor);
 590                         TRACE("->%d.0\n",writebytes);
 591                 } else {
 592                         DWORD remainder = writebytes + writecursor - This->buflen;
 593                         *(LPBYTE*)lplpaudioptr1 = This->buffer->memory+writecursor;
 594                         *audiobytes1 = This->buflen-writecursor;
 595                         if (This->sec_mixpos >= writecursor && This->sec_mixpos < writecursor + writebytes && This->state == STATE_PLAYING)
 596                                 WARN("Overwriting mixing position, case 2\n");
 597                         if (lplpaudioptr2)
 598                                 *(LPBYTE*)lplpaudioptr2 = This->buffer->memory;
 599                         if (audiobytes2)
 600                                 *audiobytes2 = writebytes-(This->buflen-writecursor);
 601                         if (audiobytes2 && This->sec_mixpos < remainder && This->state == STATE_PLAYING)
 602                                 WARN("Overwriting mixing position, case 3\n");
 603                         TRACE("Locked %p(%i bytes) and %p(%i bytes) writecursor=%d\n", *(LPBYTE*)lplpaudioptr1, *audiobytes1, lplpaudioptr2 ? *(LPBYTE*)lplpaudioptr2 : NULL, audiobytes2 ? *audiobytes2: 0, writecursor);
 604                 }
 605         }
 606
 607         RtlReleaseResource(&This->lock);
 608         /* **** */
 609
 610         return DS_OK;
 611 }
 612
 613 static HRESULT WINAPI IDirectSoundBufferImpl_SetCurrentPosition(
 614         LPDIRECTSOUNDBUFFER8 iface,DWORD newpos
 615 ) {
 616         HRESULT hres = DS_OK;
 617         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 618         DWORD oldpos;
 619         TRACE("(%p,%d)\n",This,newpos);
 620
 621         /* **** */
 622         RtlAcquireResourceExclusive(&This->lock, TRUE);
 623
 624         oldpos = This->sec_mixpos;
 625
 626         /* start mixing from this new location instead */
 627         newpos %= This->buflen;
 628         newpos -= newpos%This->pwfx->nBlockAlign;
 629         This->sec_mixpos = newpos;
 630
 631         /* at this point, do not attempt to reset buffers, mess with primary mix position,
 632            or anything like that to reduce latancy. The data already prebuffered cannot be changed */
 633
 634         /* position HW buffer if applicable, else just start mixing from new location instead */
 635         if (This->hwbuf) {
 636                 hres = IDsDriverBuffer_SetPosition(This->hwbuf, This->buf_mixpos);
 637                 if (hres != DS_OK)
 638                         WARN("IDsDriverBuffer_SetPosition failed\n");
 639         }
 640         else if (oldpos != newpos)
 641                 /* FIXME: Perhaps add a call to DSOUND_MixToTemporary here? Not sure it's needed */
 642                 This->buf_mixpos = DSOUND_secpos_to_bufpos(This, newpos, 0, NULL);
 643
 644         RtlReleaseResource(&This->lock);
 645         /* **** */
 646
 647         return hres;
 648 }
 649
 650 static HRESULT WINAPI IDirectSoundBufferImpl_SetPan(
 651         LPDIRECTSOUNDBUFFER8 iface,LONG pan
 652 ) {
 653         HRESULT hres = DS_OK;
 654         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 655
 656         TRACE("(%p,%d)\n",This,pan);
 657
 658         if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT)) {
 659                 WARN("invalid parameter: pan = %d\n", pan);
 660                 return DSERR_INVALIDPARAM;
 661         }
 662
 663         /* You cannot use both pan and 3D controls */
 664         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
 665             (This->dsbd.dwFlags & DSBCAPS_CTRL3D)) {
 666                 WARN("control unavailable\n");
 667                 return DSERR_CONTROLUNAVAIL;
 668         }
 669
 670         /* **** */
 671         RtlAcquireResourceExclusive(&This->lock, TRUE);
 672
 673         if (This->volpan.lPan != pan) {
 674                 This->volpan.lPan = pan;
 675                 DSOUND_RecalcVolPan(&(This->volpan));
 676
 677                 if (This->hwbuf) {
 678                         hres = IDsDriverBuffer_SetVolumePan(This->hwbuf, &(This->volpan));
 679                         if (hres != DS_OK)
 680                                 WARN("IDsDriverBuffer_SetVolumePan failed\n");
 681                 }
 682         }
 683
 684         RtlReleaseResource(&This->lock);
 685         /* **** */
 686
 687         return hres;
 688 }
 689
 690 static HRESULT WINAPI IDirectSoundBufferImpl_GetPan(
 691         LPDIRECTSOUNDBUFFER8 iface,LPLONG pan
 692 ) {
 693         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 694         TRACE("(%p,%p)\n",This,pan);
 695
 696         if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN)) {
 697                 WARN("control unavailable\n");
 698                 return DSERR_CONTROLUNAVAIL;
 699         }
 700
 701         if (pan == NULL) {
 702                 WARN("invalid parameter: pan = NULL\n");
 703                 return DSERR_INVALIDPARAM;
 704         }
 705
 706         *pan = This->volpan.lPan;
 707
 708         return DS_OK;
 709 }
 710
 711 static HRESULT WINAPI IDirectSoundBufferImpl_Unlock(
 712         LPDIRECTSOUNDBUFFER8 iface,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
 713 ) {
 714         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface, *iter;
 715         HRESULT hres = DS_OK;
 716
 717         TRACE("(%p,%p,%d,%p,%d)\n", This,p1,x1,p2,x2);
 718
 719         /* **** */
 720         RtlAcquireResourceShared(&This->lock, TRUE);
 721
 722         if (!(This->device->drvdesc.dwFlags & DSDDESC_DONTNEEDSECONDARYLOCK) && This->hwbuf) {
 723                 hres = IDsDriverBuffer_Unlock(This->hwbuf, p1, x1, p2, x2);
 724                 if (hres != DS_OK)
 725                         WARN("IDsDriverBuffer_Unlock failed\n");
 726         }
 727
 728         RtlReleaseResource(&This->lock);
 729         /* **** */
 730
 731         if (!p2)
 732                 x2 = 0;
 733
 734         if (!This->hwbuf && (x1 || x2))
 735         {
 736                 RtlAcquireResourceShared(&This->device->buffer_list_lock, TRUE);
 737                 LIST_FOR_EACH_ENTRY(iter, &This->buffer->buffers, IDirectSoundBufferImpl, entry )
 738                 {
 739                         RtlAcquireResourceShared(&iter->lock, TRUE);
 740                         if (x1)
 741                         {
 742                             if(x1 + (DWORD_PTR)p1 - (DWORD_PTR)iter->buffer->memory > iter->buflen)
 743                               hres = DSERR_INVALIDPARAM;
 744                             else
 745                               DSOUND_MixToTemporary(iter, (DWORD_PTR)p1 - (DWORD_PTR)iter->buffer->memory, x1, FALSE);
 746                         }
 747                         if (x2)
 748                                 DSOUND_MixToTemporary(iter, 0, x2, FALSE);
 749                         RtlReleaseResource(&iter->lock);
 750                 }
 751                 RtlReleaseResource(&This->device->buffer_list_lock);
 752         }
 753
 754         return hres;
 755 }
 756
 757 static HRESULT WINAPI IDirectSoundBufferImpl_Restore(
 758         LPDIRECTSOUNDBUFFER8 iface
 759 ) {
 760         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 761         FIXME("(%p):stub\n",This);
 762         return DS_OK;
 763 }
 764
 765 static HRESULT WINAPI IDirectSoundBufferImpl_GetFrequency(
 766         LPDIRECTSOUNDBUFFER8 iface,LPDWORD freq
 767 ) {
 768         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 769         TRACE("(%p,%p)\n",This,freq);
 770
 771         if (freq == NULL) {
 772                 WARN("invalid parameter: freq = NULL\n");
 773                 return DSERR_INVALIDPARAM;
 774         }
 775
 776         *freq = This->freq;
 777         TRACE("-> %d\n", *freq);
 778
 779         return DS_OK;
 780 }
 781
 782 static HRESULT WINAPI IDirectSoundBufferImpl_SetFX(
 783         LPDIRECTSOUNDBUFFER8 iface,DWORD dwEffectsCount,LPDSEFFECTDESC pDSFXDesc,LPDWORD pdwResultCodes
 784 ) {
 785         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 786         DWORD u;
 787
 788         FIXME("(%p,%u,%p,%p): stub\n",This,dwEffectsCount,pDSFXDesc,pdwResultCodes);
 789
 790         if (pdwResultCodes)
 791                 for (u=0; u<dwEffectsCount; u++) pdwResultCodes[u] = DSFXR_UNKNOWN;
 792
 793         WARN("control unavailable\n");
 794         return DSERR_CONTROLUNAVAIL;
 795 }
 796
 797 static HRESULT WINAPI IDirectSoundBufferImpl_AcquireResources(
 798         LPDIRECTSOUNDBUFFER8 iface,DWORD dwFlags,DWORD dwEffectsCount,LPDWORD pdwResultCodes
 799 ) {
 800         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 801         DWORD u;
 802
 803         FIXME("(%p,%08u,%u,%p): stub\n",This,dwFlags,dwEffectsCount,pdwResultCodes);
 804
 805         if (pdwResultCodes)
 806                 for (u=0; u<dwEffectsCount; u++) pdwResultCodes[u] = DSFXR_UNKNOWN;
 807
 808         WARN("control unavailable\n");
 809         return DSERR_CONTROLUNAVAIL;
 810 }
 811
 812 static HRESULT WINAPI IDirectSoundBufferImpl_GetObjectInPath(
 813         LPDIRECTSOUNDBUFFER8 iface,REFGUID rguidObject,DWORD dwIndex,REFGUID rguidInterface,LPVOID* ppObject
 814 ) {
 815         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 816
 817         FIXME("(%p,%s,%u,%s,%p): stub\n",This,debugstr_guid(rguidObject),dwIndex,debugstr_guid(rguidInterface),ppObject);
 818
 819         WARN("control unavailable\n");
 820         return DSERR_CONTROLUNAVAIL;
 821 }
 822
 823 static HRESULT WINAPI IDirectSoundBufferImpl_Initialize(
 824         LPDIRECTSOUNDBUFFER8 iface,LPDIRECTSOUND dsound,LPCDSBUFFERDESC dbsd
 825 ) {
 826         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 827         WARN("(%p) already initialized\n", This);
 828         return DSERR_ALREADYINITIALIZED;
 829 }
 830
 831 static HRESULT WINAPI IDirectSoundBufferImpl_GetCaps(
 832         LPDIRECTSOUNDBUFFER8 iface,LPDSBCAPS caps
 833 ) {
 834         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 835         TRACE("(%p)->(%p)\n",This,caps);
 836
 837         if (caps == NULL) {
 838                 WARN("invalid parameter: caps == NULL\n");
 839                 return DSERR_INVALIDPARAM;
 840         }
 841
 842         if (caps->dwSize < sizeof(*caps)) {
 843                 WARN("invalid parameter: caps->dwSize = %d\n",caps->dwSize);
 844                 return DSERR_INVALIDPARAM;
 845         }
 846
 847         caps->dwFlags = This->dsbd.dwFlags;
 848         if (This->hwbuf) caps->dwFlags |= DSBCAPS_LOCHARDWARE;
 849         else caps->dwFlags |= DSBCAPS_LOCSOFTWARE;
 850
 851         caps->dwBufferBytes = This->buflen;
 852
 853         /* According to windows, this is zero*/
 854         caps->dwUnlockTransferRate = 0;
 855         caps->dwPlayCpuOverhead = 0;
 856
 857         return DS_OK;
 858 }
 859
 860 static HRESULT WINAPI IDirectSoundBufferImpl_QueryInterface(
 861         LPDIRECTSOUNDBUFFER8 iface,REFIID riid,LPVOID *ppobj
 862 ) {
 863         IDirectSoundBufferImpl *This = (IDirectSoundBufferImpl *)iface;
 864
 865         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 866
 867         if (ppobj == NULL) {
 868                 WARN("invalid parameter\n");
 869                 return E_INVALIDARG;
 870         }
 871
 872         *ppobj = NULL;  /* assume failure */
 873
 874         if ( IsEqualGUID(riid, &IID_IUnknown) ||
 875              IsEqualGUID(riid, &IID_IDirectSoundBuffer) ||
 876              IsEqualGUID(riid, &IID_IDirectSoundBuffer8) ) {
 877                 if (!This->secondary)
 878                         SecondaryBufferImpl_Create(This, &(This->secondary));
 879                 if (This->secondary) {
 880                         IDirectSoundBuffer8_AddRef((LPDIRECTSOUNDBUFFER8)This->secondary);
 881                         *ppobj = This->secondary;
 882                         return S_OK;
 883                 }
 884                 WARN("IID_IDirectSoundBuffer\n");
 885                 return E_NOINTERFACE;
 886         }
 887
 888         if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
 889                 if (!This->notify)
 890                         IDirectSoundNotifyImpl_Create(This, &(This->notify));
 891                 if (This->notify) {
 892                         IDirectSoundNotify_AddRef((LPDIRECTSOUNDNOTIFY)This->notify);
 893                         *ppobj = This->notify;
 894                         return S_OK;
 895                 }
 896                 WARN("IID_IDirectSoundNotify\n");
 897                 return E_NOINTERFACE;
 898         }
 899
 900         if ( IsEqualGUID( &IID_IDirectSound3DBuffer, riid ) ) {
 901                 if (!This->ds3db)
 902                         IDirectSound3DBufferImpl_Create(This, &(This->ds3db));
 903                 if (This->ds3db) {
 904                         IDirectSound3DBuffer_AddRef((LPDIRECTSOUND3DBUFFER)This->ds3db);
 905                         *ppobj = This->ds3db;
 906                         return S_OK;
 907                 }
 908                 WARN("IID_IDirectSound3DBuffer\n");
 909                 return E_NOINTERFACE;
 910         }
 911
 912         if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
 913                 ERR("app requested IDirectSound3DListener on secondary buffer\n");
 914                 return E_NOINTERFACE;
 915         }
 916
 917         if ( IsEqualGUID( &IID_IKsPropertySet, riid ) ) {
 918                 if (!This->iks)
 919                         IKsBufferPropertySetImpl_Create(This, &(This->iks));
 920                 if (This->iks) {
 921                         IKsPropertySet_AddRef((LPKSPROPERTYSET)This->iks);
 922                         *ppobj = This->iks;
 923                         return S_OK;
 924                 }
 925                 WARN("IID_IKsPropertySet\n");
 926                 return E_NOINTERFACE;
 927         }
 928
 929         FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 930
 931         return E_NOINTERFACE;
 932 }
 933
 934 static const IDirectSoundBuffer8Vtbl dsbvt =
 935 {
 936         IDirectSoundBufferImpl_QueryInterface,
 937         IDirectSoundBufferImpl_AddRef,
 938         IDirectSoundBufferImpl_Release,
 939         IDirectSoundBufferImpl_GetCaps,
 940         IDirectSoundBufferImpl_GetCurrentPosition,
 941         IDirectSoundBufferImpl_GetFormat,
 942         IDirectSoundBufferImpl_GetVolume,
 943         IDirectSoundBufferImpl_GetPan,
 944         IDirectSoundBufferImpl_GetFrequency,
 945         IDirectSoundBufferImpl_GetStatus,
 946         IDirectSoundBufferImpl_Initialize,
 947         IDirectSoundBufferImpl_Lock,
 948         IDirectSoundBufferImpl_Play,
 949         IDirectSoundBufferImpl_SetCurrentPosition,
 950         IDirectSoundBufferImpl_SetFormat,
 951         IDirectSoundBufferImpl_SetVolume,
 952         IDirectSoundBufferImpl_SetPan,
 953         IDirectSoundBufferImpl_SetFrequency,
 954         IDirectSoundBufferImpl_Stop,
 955         IDirectSoundBufferImpl_Unlock,
 956         IDirectSoundBufferImpl_Restore,
 957         IDirectSoundBufferImpl_SetFX,
 958         IDirectSoundBufferImpl_AcquireResources,
 959         IDirectSoundBufferImpl_GetObjectInPath
 960 };
 961
 962 HRESULT IDirectSoundBufferImpl_Create(
 963         DirectSoundDevice * device,
 964         IDirectSoundBufferImpl **pdsb,
 965         LPCDSBUFFERDESC dsbd)
 966 {
 967         IDirectSoundBufferImpl *dsb;
 968         LPWAVEFORMATEX wfex = dsbd->lpwfxFormat;
 969         HRESULT err = DS_OK;
 970         DWORD capf = 0;
 971         int use_hw, alloc_size, cp_size;
 972         TRACE("(%p,%p,%p)\n",device,pdsb,dsbd);
 973
 974         if (dsbd->dwBufferBytes < DSBSIZE_MIN || dsbd->dwBufferBytes > DSBSIZE_MAX) {
 975                 WARN("invalid parameter: dsbd->dwBufferBytes = %d\n", dsbd->dwBufferBytes);
 976                 *pdsb = NULL;
 977                 return DSERR_INVALIDPARAM; /* FIXME: which error? */
 978         }
 979
 980         dsb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb));
 981
 982         if (dsb == 0) {
 983                 WARN("out of memory\n");
 984                 *pdsb = NULL;
 985                 return DSERR_OUTOFMEMORY;
 986         }
 987
 988         TRACE("Created buffer at %p\n", dsb);
 989
 990         dsb->ref = 0;
 991         dsb->secondary = 0;
 992         dsb->device = device;
 993         dsb->lpVtbl = &dsbvt;
 994         dsb->iks = NULL;
 995
 996         /* size depends on version */
 997         CopyMemory(&dsb->dsbd, dsbd, dsbd->dwSize);
 998
 999         /* variable sized struct so calculate size based on format */
1000         if (wfex->wFormatTag == WAVE_FORMAT_PCM) {
1001                 alloc_size = sizeof(WAVEFORMATEX);
1002                 cp_size = sizeof(PCMWAVEFORMAT);
1003         } else
1004                 alloc_size = cp_size = sizeof(WAVEFORMATEX) + wfex->cbSize;
1005
1006         dsb->pwfx = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,alloc_size);
1007         if (dsb->pwfx == NULL) {
1008                 WARN("out of memory\n");
1009                 HeapFree(GetProcessHeap(),0,dsb);
1010                 *pdsb = NULL;
1011                 return DSERR_OUTOFMEMORY;
1012         }
1013
1014         CopyMemory(dsb->pwfx, wfex, cp_size);
1015
1016         if (dsbd->dwBufferBytes % dsbd->lpwfxFormat->nBlockAlign)
1017                 dsb->buflen = dsbd->dwBufferBytes +
1018                         (dsbd->lpwfxFormat->nBlockAlign -
1019                         (dsbd->dwBufferBytes % dsbd->lpwfxFormat->nBlockAlign));
1020         else
1021                 dsb->buflen = dsbd->dwBufferBytes;
1022
1023         dsb->freq = dsbd->lpwfxFormat->nSamplesPerSec;
1024         dsb->notify = NULL;
1025         dsb->notifies = NULL;
1026         dsb->nrofnotifies = 0;
1027         dsb->hwnotify = 0;
1028
1029         /* Check necessary hardware mixing capabilities */
1030         if (wfex->nChannels==2) capf |= DSCAPS_SECONDARYSTEREO;
1031         else capf |= DSCAPS_SECONDARYMONO;
1032         if (wfex->wBitsPerSample==16) capf |= DSCAPS_SECONDARY16BIT;
1033         else capf |= DSCAPS_SECONDARY8BIT;
1034
1035         use_hw = !!(dsbd->dwFlags & DSBCAPS_LOCHARDWARE);
1036         TRACE("use_hw = %d, capf = 0x%08x, device->drvcaps.dwFlags = 0x%08x\n", use_hw, capf, device->drvcaps.dwFlags);
1037         if (use_hw && ((device->drvcaps.dwFlags & capf) != capf || !device->driver))
1038         {
1039                 if (device->driver)
1040                         WARN("Format not supported for hardware buffer\n");
1041                 HeapFree(GetProcessHeap(),0,dsb->pwfx);
1042                 HeapFree(GetProcessHeap(),0,dsb);
1043                 *pdsb = NULL;
1044                 if ((device->drvcaps.dwFlags & capf) != capf)
1045                         return DSERR_BADFORMAT;
1046                 return DSERR_GENERIC;
1047         }
1048
1049         /* FIXME: check hardware sample rate mixing capabilities */
1050         /* FIXME: check app hints for software/hardware buffer (STATIC, LOCHARDWARE, etc) */
1051         /* FIXME: check whether any hardware buffers are left */
1052         /* FIXME: handle DSDHEAP_CREATEHEAP for hardware buffers */
1053
1054         /* Allocate an empty buffer */
1055         dsb->buffer = HeapAlloc(GetProcessHeap(),0,sizeof(*(dsb->buffer)));
1056         if (dsb->buffer == NULL) {
1057                 WARN("out of memory\n");
1058                 HeapFree(GetProcessHeap(),0,dsb->pwfx);
1059                 HeapFree(GetProcessHeap(),0,dsb);
1060                 *pdsb = NULL;
1061                 return DSERR_OUTOFMEMORY;
1062         }
1063
1064         /* Allocate system memory for buffer if applicable */
1065         if ((device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) || !use_hw) {
1066                 dsb->buffer->memory = HeapAlloc(GetProcessHeap(),0,dsb->buflen);
1067                 if (dsb->buffer->memory == NULL) {
1068                         WARN("out of memory\n");
1069                         HeapFree(GetProcessHeap(),0,dsb->pwfx);
1070                         HeapFree(GetProcessHeap(),0,dsb->buffer);
1071                         HeapFree(GetProcessHeap(),0,dsb);
1072                         *pdsb = NULL;
1073                         return DSERR_OUTOFMEMORY;
1074                 }
1075         }
1076
1077         /* Allocate the hardware buffer */
1078         if (use_hw) {
1079                 err = IDsDriver_CreateSoundBuffer(device->driver,wfex,dsbd->dwFlags,0,
1080                                                   &(dsb->buflen),&(dsb->buffer->memory),
1081                                                   (LPVOID*)&(dsb->hwbuf));
1082                 if (FAILED(err))
1083                 {
1084                         WARN("Failed to create hardware secondary buffer: %08x\n", err);
1085                         if (device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY)
1086                                 HeapFree(GetProcessHeap(),0,dsb->buffer->memory);
1087                         HeapFree(GetProcessHeap(),0,dsb->buffer);
1088                         HeapFree(GetProcessHeap(),0,dsb->pwfx);
1089                         HeapFree(GetProcessHeap(),0,dsb);
1090                         *pdsb = NULL;
1091                         return DSERR_GENERIC;
1092                 }
1093         }
1094
1095         dsb->buffer->ref = 1;
1096         list_init(&dsb->buffer->buffers);
1097         list_add_head(&dsb->buffer->buffers, &dsb->entry);
1098         FillMemory(dsb->buffer->memory, dsb->buflen, dsbd->lpwfxFormat->wBitsPerSample == 8 ? 128 : 0);
1099
1100         /* It's not necessary to initialize values to zero since */
1101         /* we allocated this structure with HEAP_ZERO_MEMORY... */
1102         dsb->buf_mixpos = dsb->sec_mixpos = 0;
1103         dsb->state = STATE_STOPPED;
1104
1105         dsb->freqAdjust = ((DWORD64)dsb->freq << DSOUND_FREQSHIFT) / device->pwfx->nSamplesPerSec;
1106         dsb->nAvgBytesPerSec = dsb->freq *
1107                 dsbd->lpwfxFormat->nBlockAlign;
1108
1109         /* calculate fragment size and write lead */
1110         DSOUND_RecalcFormat(dsb);
1111
1112         if (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D) {
1113                 dsb->ds3db_ds3db.dwSize = sizeof(DS3DBUFFER);
1114                 dsb->ds3db_ds3db.vPosition.x = 0.0;
1115                 dsb->ds3db_ds3db.vPosition.y = 0.0;
1116                 dsb->ds3db_ds3db.vPosition.z = 0.0;
1117                 dsb->ds3db_ds3db.vVelocity.x = 0.0;
1118                 dsb->ds3db_ds3db.vVelocity.y = 0.0;
1119                 dsb->ds3db_ds3db.vVelocity.z = 0.0;
1120                 dsb->ds3db_ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
1121                 dsb->ds3db_ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
1122                 dsb->ds3db_ds3db.vConeOrientation.x = 0.0;
1123                 dsb->ds3db_ds3db.vConeOrientation.y = 0.0;
1124                 dsb->ds3db_ds3db.vConeOrientation.z = 0.0;
1125                 dsb->ds3db_ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
1126                 dsb->ds3db_ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
1127                 dsb->ds3db_ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
1128                 dsb->ds3db_ds3db.dwMode = DS3DMODE_NORMAL;
1129
1130                 dsb->ds3db_need_recalc = FALSE;
1131                 DSOUND_Calc3DBuffer(dsb);
1132         } else
1133                 DSOUND_RecalcVolPan(&(dsb->volpan));
1134
1135         RtlInitializeResource(&dsb->lock);
1136
1137         /* register buffer if not primary */
1138         if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
1139                 err = DirectSoundDevice_AddBuffer(device, dsb);
1140                 if (err != DS_OK) {
1141                         HeapFree(GetProcessHeap(),0,dsb->buffer->memory);
1142                         HeapFree(GetProcessHeap(),0,dsb->buffer);
1143                         RtlDeleteResource(&dsb->lock);
1144                         HeapFree(GetProcessHeap(),0,dsb->pwfx);
1145                         HeapFree(GetProcessHeap(),0,dsb);
1146                         dsb = NULL;
1147                 }
1148         }
1149
1150         *pdsb = dsb;
1151         return err;
1152 }
1153
1154 HRESULT IDirectSoundBufferImpl_Destroy(
1155     IDirectSoundBufferImpl *pdsb)
1156 {
1157     TRACE("(%p)\n",pdsb);
1158
1159     /* This keeps the *_Destroy functions from possibly deleting
1160      * this object until it is ready to be deleted */
1161     IDirectSoundBufferImpl_AddRef((LPDIRECTSOUNDBUFFER8)pdsb);
1162
1163     if (pdsb->iks) {
1164         WARN("iks not NULL\n");
1165         IKsBufferPropertySetImpl_Destroy(pdsb->iks);
1166         pdsb->iks = NULL;
1167     }
1168
1169     if (pdsb->ds3db) {
1170         WARN("ds3db not NULL\n");
1171         IDirectSound3DBufferImpl_Destroy(pdsb->ds3db);
1172         pdsb->ds3db = NULL;
1173     }
1174
1175     if (pdsb->notify) {
1176         WARN("notify not NULL\n");
1177         IDirectSoundNotifyImpl_Destroy(pdsb->notify);
1178         pdsb->notify = NULL;
1179     }
1180
1181     if (pdsb->secondary) {
1182         WARN("dsb not NULL\n");
1183         SecondaryBufferImpl_Destroy(pdsb->secondary);
1184         pdsb->secondary = NULL;
1185     }
1186
1187     while (IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)pdsb) > 0);
1188
1189     return S_OK;
1190 }
1191
1192 HRESULT IDirectSoundBufferImpl_Duplicate(
1193     DirectSoundDevice *device,
1194     IDirectSoundBufferImpl **ppdsb,
1195     IDirectSoundBufferImpl *pdsb)
1196 {
1197     IDirectSoundBufferImpl *dsb;
1198     HRESULT hres = DS_OK;
1199     int size;
1200     TRACE("(%p,%p,%p)\n", device, pdsb, pdsb);
1201
1202     dsb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb));
1203
1204     if (dsb == NULL) {
1205         WARN("out of memory\n");
1206         *ppdsb = NULL;
1207         return DSERR_OUTOFMEMORY;
1208     }
1209
1210     CopyMemory(dsb, pdsb, sizeof(IDirectSoundBufferImpl));
1211
1212     if (pdsb->hwbuf) {
1213         TRACE("duplicating hardware buffer\n");
1214
1215         hres = IDsDriver_DuplicateSoundBuffer(device->driver, pdsb->hwbuf,
1216                                               (LPVOID *)&dsb->hwbuf);
1217         if (FAILED(hres)) {
1218             WARN("IDsDriver_DuplicateSoundBuffer failed (%08x)\n", hres);
1219             HeapFree(GetProcessHeap(),0,dsb);
1220             *ppdsb = NULL;
1221             return hres;
1222         }
1223     }
1224
1225     dsb->buffer->ref++;
1226     list_add_head(&dsb->buffer->buffers, &dsb->entry);
1227     dsb->ref = 0;
1228     dsb->state = STATE_STOPPED;
1229     dsb->buf_mixpos = dsb->sec_mixpos = 0;
1230     dsb->device = device;
1231     dsb->ds3db = NULL;
1232     dsb->iks = NULL; /* FIXME? */
1233     dsb->secondary = NULL;
1234     dsb->tmp_buffer = NULL;
1235     DSOUND_RecalcFormat(dsb);
1236     DSOUND_MixToTemporary(dsb, 0, dsb->buflen, FALSE);
1237
1238     /* variable sized struct so calculate size based on format */
1239     size = sizeof(WAVEFORMATEX) + pdsb->pwfx->cbSize;
1240
1241     dsb->pwfx = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
1242     if (dsb->pwfx == NULL) {
1243             WARN("out of memory\n");
1244             HeapFree(GetProcessHeap(),0,dsb->buffer);
1245             HeapFree(GetProcessHeap(),0,dsb);
1246             *ppdsb = NULL;
1247             return DSERR_OUTOFMEMORY;
1248     }
1249
1250     CopyMemory(dsb->pwfx, pdsb->pwfx, size);
1251
1252     RtlInitializeResource(&dsb->lock);
1253
1254     /* register buffer */
1255     hres = DirectSoundDevice_AddBuffer(device, dsb);
1256     if (hres != DS_OK) {
1257         RtlDeleteResource(&dsb->lock);
1258         HeapFree(GetProcessHeap(),0,dsb->tmp_buffer);
1259         HeapFree(GetProcessHeap(),0,dsb->buffer);
1260         HeapFree(GetProcessHeap(),0,dsb->pwfx);
1261         HeapFree(GetProcessHeap(),0,dsb);
1262         *ppdsb = 0;
1263     }
1264
1265     *ppdsb = dsb;
1266     return hres;
1267 }
1268
1269 /*******************************************************************************
1270  *              SecondaryBuffer
1271  */
1272
1273 static HRESULT WINAPI SecondaryBufferImpl_QueryInterface(
1274         LPDIRECTSOUNDBUFFER8 iface,REFIID riid,LPVOID *ppobj)
1275 {
1276         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1277         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
1278
1279         return IDirectSoundBufferImpl_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb,riid,ppobj);
1280 }
1281
1282 static ULONG WINAPI SecondaryBufferImpl_AddRef(LPDIRECTSOUNDBUFFER8 iface)
1283 {
1284     SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1285     ULONG ref = InterlockedIncrement(&(This->ref));
1286     TRACE("(%p) ref was %d\n", This, ref - 1);
1287     return ref;
1288 }
1289
1290 static ULONG WINAPI SecondaryBufferImpl_Release(LPDIRECTSOUNDBUFFER8 iface)
1291 {
1292     SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1293     ULONG ref;
1294     TRACE("(%p)\n", This);
1295     ref = InterlockedDecrement(&(This->ref));
1296     TRACE("ref was %d\n", ref + 1);
1297
1298     if (!ref) {
1299         This->dsb->secondary = NULL;
1300         IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER8)This->dsb);
1301         HeapFree(GetProcessHeap(), 0, This);
1302         TRACE("(%p) released\n", This);
1303     }
1304     return ref;
1305 }
1306
1307 static HRESULT WINAPI SecondaryBufferImpl_GetCaps(
1308         LPDIRECTSOUNDBUFFER8 iface,LPDSBCAPS caps)
1309 {
1310         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1311         TRACE("(%p)->(%p)\n",This,caps);
1312
1313         return IDirectSoundBufferImpl_GetCaps((LPDIRECTSOUNDBUFFER8)This->dsb,caps);
1314 }
1315
1316 static HRESULT WINAPI SecondaryBufferImpl_GetCurrentPosition(
1317         LPDIRECTSOUNDBUFFER8 iface,LPDWORD playpos,LPDWORD writepos)
1318 {
1319         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1320         TRACE("(%p,%p,%p)\n",This,playpos,writepos);
1321
1322         return IDirectSoundBufferImpl_GetCurrentPosition((LPDIRECTSOUNDBUFFER8)This->dsb,playpos,writepos);
1323 }
1324
1325 static HRESULT WINAPI SecondaryBufferImpl_GetFormat(
1326         LPDIRECTSOUNDBUFFER8 iface,LPWAVEFORMATEX lpwf,DWORD wfsize,LPDWORD wfwritten)
1327 {
1328         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1329         TRACE("(%p,%p,%d,%p)\n",This,lpwf,wfsize,wfwritten);
1330
1331         return IDirectSoundBufferImpl_GetFormat((LPDIRECTSOUNDBUFFER8)This->dsb,lpwf,wfsize,wfwritten);
1332 }
1333
1334 static HRESULT WINAPI SecondaryBufferImpl_GetVolume(
1335         LPDIRECTSOUNDBUFFER8 iface,LPLONG vol)
1336 {
1337         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1338         TRACE("(%p,%p)\n",This,vol);
1339
1340         return IDirectSoundBufferImpl_GetVolume((LPDIRECTSOUNDBUFFER8)This->dsb,vol);
1341 }
1342
1343 static HRESULT WINAPI SecondaryBufferImpl_GetPan(
1344         LPDIRECTSOUNDBUFFER8 iface,LPLONG pan)
1345 {
1346         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1347         TRACE("(%p,%p)\n",This,pan);
1348
1349         return IDirectSoundBufferImpl_GetPan((LPDIRECTSOUNDBUFFER8)This->dsb,pan);
1350 }
1351
1352 static HRESULT WINAPI SecondaryBufferImpl_GetFrequency(
1353         LPDIRECTSOUNDBUFFER8 iface,LPDWORD freq)
1354 {
1355         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1356         TRACE("(%p,%p)\n",This,freq);
1357
1358         return IDirectSoundBufferImpl_GetFrequency((LPDIRECTSOUNDBUFFER8)This->dsb,freq);
1359 }
1360
1361 static HRESULT WINAPI SecondaryBufferImpl_GetStatus(
1362         LPDIRECTSOUNDBUFFER8 iface,LPDWORD status)
1363 {
1364         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1365         TRACE("(%p,%p)\n",This,status);
1366
1367         return IDirectSoundBufferImpl_GetStatus((LPDIRECTSOUNDBUFFER8)This->dsb,status);
1368 }
1369
1370 static HRESULT WINAPI SecondaryBufferImpl_Initialize(
1371         LPDIRECTSOUNDBUFFER8 iface,LPDIRECTSOUND dsound,LPCDSBUFFERDESC dbsd)
1372 {
1373         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1374         TRACE("(%p,%p,%p)\n",This,dsound,dbsd);
1375
1376         return IDirectSoundBufferImpl_Initialize((LPDIRECTSOUNDBUFFER8)This->dsb,dsound,dbsd);
1377 }
1378
1379 static HRESULT WINAPI SecondaryBufferImpl_Lock(
1380     LPDIRECTSOUNDBUFFER8 iface,
1381     DWORD writecursor,
1382     DWORD writebytes,
1383     LPVOID *lplpaudioptr1,
1384     LPDWORD audiobytes1,
1385     LPVOID *lplpaudioptr2,
1386     LPDWORD audiobytes2,
1387     DWORD dwFlags)
1388 {
1389     SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1390     TRACE("(%p,%d,%d,%p,%p,%p,%p,0x%08x)\n",
1391         This,writecursor,writebytes,lplpaudioptr1,audiobytes1,lplpaudioptr2,audiobytes2,dwFlags);
1392
1393     return IDirectSoundBufferImpl_Lock((LPDIRECTSOUNDBUFFER8)This->dsb,
1394         writecursor,writebytes,lplpaudioptr1,audiobytes1,lplpaudioptr2,audiobytes2,dwFlags);
1395 }
1396
1397 static HRESULT WINAPI SecondaryBufferImpl_Play(
1398         LPDIRECTSOUNDBUFFER8 iface,DWORD reserved1,DWORD reserved2,DWORD flags)
1399 {
1400         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1401         TRACE("(%p,%08x,%08x,%08x)\n",This,reserved1,reserved2,flags);
1402
1403         return IDirectSoundBufferImpl_Play((LPDIRECTSOUNDBUFFER8)This->dsb,reserved1,reserved2,flags);
1404 }
1405
1406 static HRESULT WINAPI SecondaryBufferImpl_SetCurrentPosition(
1407         LPDIRECTSOUNDBUFFER8 iface,DWORD newpos)
1408 {
1409         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1410         TRACE("(%p,%d)\n",This,newpos);
1411
1412         return IDirectSoundBufferImpl_SetCurrentPosition((LPDIRECTSOUNDBUFFER8)This->dsb,newpos);
1413 }
1414
1415 static HRESULT WINAPI SecondaryBufferImpl_SetFormat(
1416         LPDIRECTSOUNDBUFFER8 iface,LPCWAVEFORMATEX wfex)
1417 {
1418         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1419         TRACE("(%p,%p)\n",This,wfex);
1420
1421         return IDirectSoundBufferImpl_SetFormat((LPDIRECTSOUNDBUFFER8)This->dsb,wfex);
1422 }
1423
1424 static HRESULT WINAPI SecondaryBufferImpl_SetVolume(
1425         LPDIRECTSOUNDBUFFER8 iface,LONG vol)
1426 {
1427         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1428         TRACE("(%p,%d)\n",This,vol);
1429
1430         return IDirectSoundBufferImpl_SetVolume((LPDIRECTSOUNDBUFFER8)This->dsb,vol);
1431 }
1432
1433 static HRESULT WINAPI SecondaryBufferImpl_SetPan(
1434         LPDIRECTSOUNDBUFFER8 iface,LONG pan)
1435 {
1436         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1437         TRACE("(%p,%d)\n",This,pan);
1438
1439         return IDirectSoundBufferImpl_SetPan((LPDIRECTSOUNDBUFFER8)This->dsb,pan);
1440 }
1441
1442 static HRESULT WINAPI SecondaryBufferImpl_SetFrequency(
1443         LPDIRECTSOUNDBUFFER8 iface,DWORD freq)
1444 {
1445         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1446         TRACE("(%p,%d)\n",This,freq);
1447
1448         return IDirectSoundBufferImpl_SetFrequency((LPDIRECTSOUNDBUFFER8)This->dsb,freq);
1449 }
1450
1451 static HRESULT WINAPI SecondaryBufferImpl_Stop(LPDIRECTSOUNDBUFFER8 iface)
1452 {
1453         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1454         TRACE("(%p)\n",This);
1455
1456         return IDirectSoundBufferImpl_Stop((LPDIRECTSOUNDBUFFER8)This->dsb);
1457 }
1458
1459 static HRESULT WINAPI SecondaryBufferImpl_Unlock(
1460     LPDIRECTSOUNDBUFFER8 iface,
1461     LPVOID lpvAudioPtr1,
1462     DWORD dwAudioBytes1,
1463     LPVOID lpvAudioPtr2,
1464     DWORD dwAudioBytes2)
1465 {
1466     SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1467     TRACE("(%p,%p,%d,%p,%d)\n",
1468         This, lpvAudioPtr1, dwAudioBytes1, lpvAudioPtr2, dwAudioBytes2);
1469
1470     return IDirectSoundBufferImpl_Unlock((LPDIRECTSOUNDBUFFER8)This->dsb,
1471         lpvAudioPtr1,dwAudioBytes1,lpvAudioPtr2,dwAudioBytes2);
1472 }
1473
1474 static HRESULT WINAPI SecondaryBufferImpl_Restore(
1475         LPDIRECTSOUNDBUFFER8 iface)
1476 {
1477         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1478         TRACE("(%p)\n",This);
1479
1480         return IDirectSoundBufferImpl_Restore((LPDIRECTSOUNDBUFFER8)This->dsb);
1481 }
1482
1483 static HRESULT WINAPI SecondaryBufferImpl_SetFX(
1484         LPDIRECTSOUNDBUFFER8 iface,DWORD dwEffectsCount,LPDSEFFECTDESC pDSFXDesc,LPDWORD pdwResultCodes)
1485 {
1486         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1487         TRACE("(%p,%u,%p,%p)\n",This,dwEffectsCount,pDSFXDesc,pdwResultCodes);
1488
1489         return IDirectSoundBufferImpl_SetFX((LPDIRECTSOUNDBUFFER8)This->dsb,dwEffectsCount,pDSFXDesc,pdwResultCodes);
1490 }
1491
1492 static HRESULT WINAPI SecondaryBufferImpl_AcquireResources(
1493         LPDIRECTSOUNDBUFFER8 iface,DWORD dwFlags,DWORD dwEffectsCount,LPDWORD pdwResultCodes)
1494 {
1495         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1496         TRACE("(%p,%08u,%u,%p)\n",This,dwFlags,dwEffectsCount,pdwResultCodes);
1497
1498         return IDirectSoundBufferImpl_AcquireResources((LPDIRECTSOUNDBUFFER8)This->dsb,dwFlags,dwEffectsCount,pdwResultCodes);
1499 }
1500
1501 static HRESULT WINAPI SecondaryBufferImpl_GetObjectInPath(
1502         LPDIRECTSOUNDBUFFER8 iface,REFGUID rguidObject,DWORD dwIndex,REFGUID rguidInterface,LPVOID* ppObject)
1503 {
1504         SecondaryBufferImpl *This = (SecondaryBufferImpl *)iface;
1505         TRACE("(%p,%s,%u,%s,%p)\n",This,debugstr_guid(rguidObject),dwIndex,debugstr_guid(rguidInterface),ppObject);
1506
1507         return IDirectSoundBufferImpl_GetObjectInPath((LPDIRECTSOUNDBUFFER8)This->dsb,rguidObject,dwIndex,rguidInterface,ppObject);
1508 }
1509
1510 static const IDirectSoundBuffer8Vtbl sbvt =
1511 {
1512         SecondaryBufferImpl_QueryInterface,
1513         SecondaryBufferImpl_AddRef,
1514         SecondaryBufferImpl_Release,
1515         SecondaryBufferImpl_GetCaps,
1516         SecondaryBufferImpl_GetCurrentPosition,
1517         SecondaryBufferImpl_GetFormat,
1518         SecondaryBufferImpl_GetVolume,
1519         SecondaryBufferImpl_GetPan,
1520         SecondaryBufferImpl_GetFrequency,
1521         SecondaryBufferImpl_GetStatus,
1522         SecondaryBufferImpl_Initialize,
1523         SecondaryBufferImpl_Lock,
1524         SecondaryBufferImpl_Play,
1525         SecondaryBufferImpl_SetCurrentPosition,
1526         SecondaryBufferImpl_SetFormat,
1527         SecondaryBufferImpl_SetVolume,
1528         SecondaryBufferImpl_SetPan,
1529         SecondaryBufferImpl_SetFrequency,
1530         SecondaryBufferImpl_Stop,
1531         SecondaryBufferImpl_Unlock,
1532         SecondaryBufferImpl_Restore,
1533         SecondaryBufferImpl_SetFX,
1534         SecondaryBufferImpl_AcquireResources,
1535         SecondaryBufferImpl_GetObjectInPath
1536 };
1537
1538 HRESULT SecondaryBufferImpl_Create(
1539         IDirectSoundBufferImpl *dsb,
1540         SecondaryBufferImpl **psb)
1541 {
1542         SecondaryBufferImpl *sb;
1543         TRACE("(%p,%p)\n",dsb,psb);
1544
1545         sb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*sb));
1546
1547         if (sb == 0) {
1548                 WARN("out of memory\n");
1549                 *psb = NULL;
1550                 return DSERR_OUTOFMEMORY;
1551         }
1552         sb->ref = 0;
1553         sb->dsb = dsb;
1554         sb->lpVtbl = &sbvt;
1555
1556         IDirectSoundBuffer8_AddRef((LPDIRECTSOUNDBUFFER8)dsb);
1557         *psb = sb;
1558         return S_OK;
1559 }
1560
1561 static HRESULT SecondaryBufferImpl_Destroy(
1562     SecondaryBufferImpl *pdsb)
1563 {
1564     TRACE("(%p)\n",pdsb);
1565
1566     while (SecondaryBufferImpl_Release((LPDIRECTSOUNDBUFFER8)pdsb) > 0);
1567
1568     return S_OK;
1569 }