dll/directx/dsound/capture.c

   1 /*              DirectSoundCapture
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998 Rob Riggs
   5  * Copyright 2000-2001 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  * TODO:
  23  *      Implement FX support.
  24  *      Implement both IDirectSoundCaptureBuffer and IDirectSoundCaptureBuffer8
  25  *      Make DirectSoundCaptureCreate and DirectSoundCaptureCreate8 behave differently
  26  */
  27
  28 #include <stdarg.h>
  29
  30 #define WIN32_NO_STATUS
  31 #define _INC_WINDOWS
  32 #define COM_NO_WINDOWS_H
  33
  34 #define NONAMELESSSTRUCT
  35 #define NONAMELESSUNION
  36 #include <windef.h>
  37 //#include "winbase.h"
  38 //#include "winuser.h"
  39 //#include "mmsystem.h"
  40 #include <mmddk.h>
  41 #include <winternl.h>
  42 #include <winnls.h>
  43 #include <wine/debug.h>
  44 #include <dsound.h>
  45 #include <dsdriver.h>
  46 #include "dsound_private.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  49
  50 /*****************************************************************************
  51  * IDirectSoundCapture implementation structure
  52  */
  53 struct IDirectSoundCaptureImpl
  54 {
  55     /* IUnknown fields */
  56     const IDirectSoundCaptureVtbl     *lpVtbl;
  57     LONG                               ref;
  58
  59     DirectSoundCaptureDevice          *device;
  60 };
  61
  62 static HRESULT IDirectSoundCaptureImpl_Create(LPDIRECTSOUNDCAPTURE8 * ppds);
  63
  64
  65 /*****************************************************************************
  66  * IDirectSoundCaptureNotify implementation structure
  67  */
  68 struct IDirectSoundCaptureNotifyImpl
  69 {
  70     /* IUnknown fields */
  71     const IDirectSoundNotifyVtbl       *lpVtbl;
  72     LONG                                ref;
  73     IDirectSoundCaptureBufferImpl*      dscb;
  74 };
  75
  76 static HRESULT IDirectSoundCaptureNotifyImpl_Create(IDirectSoundCaptureBufferImpl *dscb,
  77                                                     IDirectSoundCaptureNotifyImpl ** pdscn);
  78
  79
  80 DirectSoundCaptureDevice * DSOUND_capture[MAXWAVEDRIVERS];
  81
  82 static HRESULT DirectSoundCaptureDevice_Create(DirectSoundCaptureDevice ** ppDevice);
  83
  84 static const char * const captureStateString[] = {
  85     "STATE_STOPPED",
  86     "STATE_STARTING",
  87     "STATE_CAPTURING",
  88     "STATE_STOPPING"
  89 };
  90
  91 HRESULT DSOUND_CaptureCreate(
  92     REFIID riid,
  93     LPDIRECTSOUNDCAPTURE *ppDSC)
  94 {
  95     LPDIRECTSOUNDCAPTURE pDSC;
  96     HRESULT hr;
  97     TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSC);
  98
  99     if (!IsEqualIID(riid, &IID_IUnknown) &&
 100         !IsEqualIID(riid, &IID_IDirectSoundCapture)) {
 101         *ppDSC = 0;
 102         return E_NOINTERFACE;
 103     }
 104
 105     /* Get dsound configuration */
 106     setup_dsound_options();
 107
 108     hr = IDirectSoundCaptureImpl_Create(&pDSC);
 109     if (hr == DS_OK) {
 110         IDirectSoundCapture_AddRef(pDSC);
 111         *ppDSC = pDSC;
 112     } else {
 113         WARN("IDirectSoundCaptureImpl_Create failed\n");
 114         *ppDSC = 0;
 115     }
 116
 117     return hr;
 118 }
 119
 120 HRESULT DSOUND_CaptureCreate8(
 121     REFIID riid,
 122     LPDIRECTSOUNDCAPTURE8 *ppDSC8)
 123 {
 124     LPDIRECTSOUNDCAPTURE8 pDSC8;
 125     HRESULT hr;
 126     TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSC8);
 127
 128     if (!IsEqualIID(riid, &IID_IUnknown) &&
 129         !IsEqualIID(riid, &IID_IDirectSoundCapture8)) {
 130         *ppDSC8 = 0;
 131         return E_NOINTERFACE;
 132     }
 133
 134     /* Get dsound configuration */
 135     setup_dsound_options();
 136
 137     hr = IDirectSoundCaptureImpl_Create(&pDSC8);
 138     if (hr == DS_OK) {
 139         IDirectSoundCapture_AddRef(pDSC8);
 140         *ppDSC8 = pDSC8;
 141     } else {
 142         WARN("IDirectSoundCaptureImpl_Create failed\n");
 143         *ppDSC8 = 0;
 144     }
 145
 146     return hr;
 147 }
 148
 149 /***************************************************************************
 150  * DirectSoundCaptureCreate [DSOUND.6]
 151  *
 152  * Create and initialize a DirectSoundCapture interface.
 153  *
 154  * PARAMS
 155  *    lpcGUID   [I] Address of the GUID that identifies the sound capture device.
 156  *    lplpDSC   [O] Address of a variable to receive the interface pointer.
 157  *    pUnkOuter [I] Must be NULL.
 158  *
 159  * RETURNS
 160  *    Success: DS_OK
 161  *    Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
 162  *             DSERR_OUTOFMEMORY
 163  *
 164  * NOTES
 165  *    lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
 166  *    or NULL for the default device or DSDEVID_DefaultCapture or
 167  *    DSDEVID_DefaultVoiceCapture.
 168  *
 169  *    DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
 170  */
 171 HRESULT WINAPI DirectSoundCaptureCreate(
 172     LPCGUID lpcGUID,
 173     LPDIRECTSOUNDCAPTURE *ppDSC,
 174     LPUNKNOWN pUnkOuter)
 175 {
 176     HRESULT hr;
 177     LPDIRECTSOUNDCAPTURE pDSC;
 178     TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), ppDSC, pUnkOuter);
 179
 180     if (ppDSC == NULL) {
 181         WARN("invalid parameter: ppDSC == NULL\n");
 182         return DSERR_INVALIDPARAM;
 183     }
 184
 185     if (pUnkOuter) {
 186         WARN("invalid parameter: pUnkOuter != NULL\n");
 187         *ppDSC = NULL;
 188         return DSERR_NOAGGREGATION;
 189     }
 190
 191     hr = DSOUND_CaptureCreate(&IID_IDirectSoundCapture, &pDSC);
 192     if (hr == DS_OK) {
 193         hr = IDirectSoundCapture_Initialize(pDSC, lpcGUID);
 194         if (hr != DS_OK) {
 195             IDirectSoundCapture_Release(pDSC);
 196             pDSC = 0;
 197         }
 198     }
 199
 200     *ppDSC = pDSC;
 201
 202     return hr;
 203 }
 204
 205 /***************************************************************************
 206  * DirectSoundCaptureCreate8 [DSOUND.12]
 207  *
 208  * Create and initialize a DirectSoundCapture interface.
 209  *
 210  * PARAMS
 211  *    lpcGUID   [I] Address of the GUID that identifies the sound capture device.
 212  *    lplpDSC   [O] Address of a variable to receive the interface pointer.
 213  *    pUnkOuter [I] Must be NULL.
 214  *
 215  * RETURNS
 216  *    Success: DS_OK
 217  *    Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
 218  *             DSERR_OUTOFMEMORY
 219  *
 220  * NOTES
 221  *    lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
 222  *    or NULL for the default device or DSDEVID_DefaultCapture or
 223  *    DSDEVID_DefaultVoiceCapture.
 224  *
 225  *    DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
 226  */
 227 HRESULT WINAPI DirectSoundCaptureCreate8(
 228     LPCGUID lpcGUID,
 229     LPDIRECTSOUNDCAPTURE8 *ppDSC8,
 230     LPUNKNOWN pUnkOuter)
 231 {
 232     HRESULT hr;
 233     LPDIRECTSOUNDCAPTURE8 pDSC8;
 234     TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), ppDSC8, pUnkOuter);
 235
 236     if (ppDSC8 == NULL) {
 237         WARN("invalid parameter: ppDSC8 == NULL\n");
 238         return DSERR_INVALIDPARAM;
 239     }
 240
 241     if (pUnkOuter) {
 242         WARN("invalid parameter: pUnkOuter != NULL\n");
 243         *ppDSC8 = NULL;
 244         return DSERR_NOAGGREGATION;
 245     }
 246
 247     hr = DSOUND_CaptureCreate8(&IID_IDirectSoundCapture8, &pDSC8);
 248     if (hr == DS_OK) {
 249         hr = IDirectSoundCapture_Initialize(pDSC8, lpcGUID);
 250         if (hr != DS_OK) {
 251             IDirectSoundCapture_Release(pDSC8);
 252             pDSC8 = 0;
 253         }
 254     }
 255
 256     *ppDSC8 = pDSC8;
 257
 258     return hr;
 259 }
 260
 261 /***************************************************************************
 262  * DirectSoundCaptureEnumerateA [DSOUND.7]
 263  *
 264  * Enumerate all DirectSound drivers installed in the system.
 265  *
 266  * PARAMS
 267  *    lpDSEnumCallback  [I] Address of callback function.
 268  *    lpContext         [I] Address of user defined context passed to callback function.
 269  *
 270  * RETURNS
 271  *    Success: DS_OK
 272  *    Failure: DSERR_INVALIDPARAM
 273  */
 274 HRESULT WINAPI
 275 DirectSoundCaptureEnumerateA(
 276     LPDSENUMCALLBACKA lpDSEnumCallback,
 277     LPVOID lpContext)
 278 {
 279     unsigned devs, wid;
 280     DSDRIVERDESC desc;
 281     GUID guid;
 282     int err;
 283
 284     TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
 285
 286     if (lpDSEnumCallback == NULL) {
 287         WARN("invalid parameter: lpDSEnumCallback == NULL\n");
 288         return DSERR_INVALIDPARAM;
 289     }
 290
 291     devs = waveInGetNumDevs();
 292     if (devs > 0) {
 293         if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
 294             for (wid = 0; wid < devs; ++wid) {
 295                 if (IsEqualGUID( &guid, &DSOUND_capture_guids[wid] ) ) {
 296                     err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
 297                     if (err == DS_OK) {
 298                         TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
 299                               "Primary Sound Capture Driver",desc.szDrvname,lpContext);
 300                         if (lpDSEnumCallback(NULL, "Primary Sound Capture Driver", desc.szDrvname, lpContext) == FALSE)
 301                             return DS_OK;
 302                     }
 303                 }
 304             }
 305         }
 306     }
 307
 308     for (wid = 0; wid < devs; ++wid) {
 309         err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
 310         if (err == DS_OK) {
 311             TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
 312                   debugstr_guid(&DSOUND_capture_guids[wid]),desc.szDesc,desc.szDrvname,lpContext);
 313             if (lpDSEnumCallback(&DSOUND_capture_guids[wid], desc.szDesc, desc.szDrvname, lpContext) == FALSE)
 314                 return DS_OK;
 315         }
 316     }
 317
 318     return DS_OK;
 319 }
 320
 321 /***************************************************************************
 322  * DirectSoundCaptureEnumerateW [DSOUND.8]
 323  *
 324  * Enumerate all DirectSound drivers installed in the system.
 325  *
 326  * PARAMS
 327  *    lpDSEnumCallback  [I] Address of callback function.
 328  *    lpContext         [I] Address of user defined context passed to callback function.
 329  *
 330  * RETURNS
 331  *    Success: DS_OK
 332  *    Failure: DSERR_INVALIDPARAM
 333  */
 334 HRESULT WINAPI
 335 DirectSoundCaptureEnumerateW(
 336     LPDSENUMCALLBACKW lpDSEnumCallback,
 337     LPVOID lpContext)
 338 {
 339     unsigned devs, wid;
 340     DSDRIVERDESC desc;
 341     GUID guid;
 342     int err;
 343     WCHAR wDesc[MAXPNAMELEN];
 344     WCHAR wName[MAXPNAMELEN];
 345
 346     TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
 347
 348     if (lpDSEnumCallback == NULL) {
 349         WARN("invalid parameter: lpDSEnumCallback == NULL\n");
 350         return DSERR_INVALIDPARAM;
 351     }
 352
 353     devs = waveInGetNumDevs();
 354     if (devs > 0) {
 355         if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
 356             for (wid = 0; wid < devs; ++wid) {
 357                 if (IsEqualGUID( &guid, &DSOUND_capture_guids[wid] ) ) {
 358                     err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
 359                     if (err == DS_OK) {
 360                         TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
 361                               "Primary Sound Capture Driver",desc.szDrvname,lpContext);
 362                         MultiByteToWideChar( CP_ACP, 0, "Primary Sound Capture Driver", -1,
 363                                              wDesc, sizeof(wDesc)/sizeof(WCHAR) );
 364                         MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
 365                                              wName, sizeof(wName)/sizeof(WCHAR) );
 366                         if (lpDSEnumCallback(NULL, wDesc, wName, lpContext) == FALSE)
 367                             return DS_OK;
 368                     }
 369                 }
 370             }
 371         }
 372     }
 373
 374     for (wid = 0; wid < devs; ++wid) {
 375         err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
 376         if (err == DS_OK) {
 377             TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
 378                   debugstr_guid(&DSOUND_capture_guids[wid]),desc.szDesc,desc.szDrvname,lpContext);
 379             MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
 380                                  wDesc, sizeof(wDesc)/sizeof(WCHAR) );
 381             MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
 382                                  wName, sizeof(wName)/sizeof(WCHAR) );
 383             if (lpDSEnumCallback(&DSOUND_capture_guids[wid], wDesc, wName, lpContext) == FALSE)
 384                 return DS_OK;
 385         }
 386     }
 387
 388     return DS_OK;
 389 }
 390
 391 static void capture_CheckNotify(IDirectSoundCaptureBufferImpl *This, DWORD from, DWORD len)
 392 {
 393     int i;
 394     for (i = 0; i < This->nrofnotifies; ++i) {
 395         LPDSBPOSITIONNOTIFY event = This->notifies + i;
 396         DWORD offset = event->dwOffset;
 397         TRACE("checking %d, position %d, event = %p\n", i, offset, event->hEventNotify);
 398
 399         if (offset == DSBPN_OFFSETSTOP) {
 400             if (!from && !len) {
 401                 SetEvent(event->hEventNotify);
 402                 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
 403                 return;
 404             }
 405             else return;
 406         }
 407
 408         if (offset >= from && offset < (from + len))
 409         {
 410             TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
 411             SetEvent(event->hEventNotify);
 412         }
 413     }
 414 }
 415
 416 static void CALLBACK
 417 DSOUND_capture_callback(HWAVEIN hwi, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1,
 418                         DWORD_PTR dw2)
 419 {
 420     DirectSoundCaptureDevice * This = (DirectSoundCaptureDevice*)dwUser;
 421     IDirectSoundCaptureBufferImpl * Moi = This->capture_buffer;
 422     TRACE("(%p,%08x(%s),%08lx,%08lx,%08lx) entering at %d\n",hwi,msg,
 423         msg == MM_WIM_OPEN ? "MM_WIM_OPEN" : msg == MM_WIM_CLOSE ? "MM_WIM_CLOSE" :
 424         msg == MM_WIM_DATA ? "MM_WIM_DATA" : "UNKNOWN",dwUser,dw1,dw2,GetTickCount());
 425
 426     if (msg == MM_WIM_DATA) {
 427         EnterCriticalSection( &(This->lock) );
 428         TRACE("DirectSoundCapture msg=MM_WIM_DATA, old This->state=%s, old This->index=%d\n",
 429             captureStateString[This->state],This->index);
 430         if (This->state != STATE_STOPPED) {
 431             int index = This->index;
 432             if (This->state == STATE_STARTING)
 433                 This->state = STATE_CAPTURING;
 434             capture_CheckNotify(Moi, (DWORD_PTR)This->pwave[index].lpData - (DWORD_PTR)This->buffer, This->pwave[index].dwBufferLength);
 435             This->index = (This->index + 1) % This->nrofpwaves;
 436             if ( (This->index == 0) && !(This->capture_buffer->flags & DSCBSTART_LOOPING) ) {
 437                 TRACE("end of buffer\n");
 438                 This->state = STATE_STOPPED;
 439                 capture_CheckNotify(Moi, 0, 0);
 440             } else {
 441                 if (This->state == STATE_CAPTURING) {
 442                     waveInUnprepareHeader(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
 443                     waveInPrepareHeader(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
 444                     waveInAddBuffer(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
 445                 } else if (This->state == STATE_STOPPING) {
 446                     TRACE("stopping\n");
 447                     This->state = STATE_STOPPED;
 448                 }
 449             }
 450         }
 451         TRACE("DirectSoundCapture new This->state=%s, new This->index=%d\n",
 452             captureStateString[This->state],This->index);
 453         LeaveCriticalSection( &(This->lock) );
 454     }
 455
 456     TRACE("completed\n");
 457 }
 458
 459 /***************************************************************************
 460  * IDirectSoundCaptureImpl
 461  */
 462 static HRESULT WINAPI
 463 IDirectSoundCaptureImpl_QueryInterface(
 464     LPDIRECTSOUNDCAPTURE iface,
 465     REFIID riid,
 466     LPVOID* ppobj )
 467 {
 468     IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
 469     TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
 470
 471     if (ppobj == NULL) {
 472         WARN("invalid parameter\n");
 473         return E_INVALIDARG;
 474     }
 475
 476     *ppobj = NULL;
 477
 478     if (IsEqualIID(riid, &IID_IUnknown)) {
 479         IDirectSoundCapture_AddRef((LPDIRECTSOUNDCAPTURE)This);
 480         *ppobj = This;
 481         return DS_OK;
 482     } else if (IsEqualIID(riid, &IID_IDirectSoundCapture)) {
 483         IDirectSoundCapture_AddRef((LPDIRECTSOUNDCAPTURE)This);
 484         *ppobj = This;
 485         return DS_OK;
 486     }
 487
 488     WARN("unsupported riid: %s\n", debugstr_guid(riid));
 489     return E_NOINTERFACE;
 490 }
 491
 492 static ULONG WINAPI
 493 IDirectSoundCaptureImpl_AddRef( LPDIRECTSOUNDCAPTURE iface )
 494 {
 495     IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
 496     ULONG ref = InterlockedIncrement(&(This->ref));
 497     TRACE("(%p) ref was %d\n", This, ref - 1);
 498     return ref;
 499 }
 500
 501 static ULONG WINAPI
 502 IDirectSoundCaptureImpl_Release( LPDIRECTSOUNDCAPTURE iface )
 503 {
 504     IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
 505     ULONG ref = InterlockedDecrement(&(This->ref));
 506     TRACE("(%p) ref was %d\n", This, ref + 1);
 507
 508     if (!ref) {
 509         if (This->device)
 510             DirectSoundCaptureDevice_Release(This->device);
 511
 512         HeapFree( GetProcessHeap(), 0, This );
 513         TRACE("(%p) released\n", This);
 514     }
 515     return ref;
 516 }
 517
 518 HRESULT WINAPI IDirectSoundCaptureImpl_CreateCaptureBuffer(
 519     LPDIRECTSOUNDCAPTURE iface,
 520     LPCDSCBUFFERDESC lpcDSCBufferDesc,
 521     LPDIRECTSOUNDCAPTUREBUFFER* lplpDSCaptureBuffer,
 522     LPUNKNOWN pUnk )
 523 {
 524     HRESULT hr;
 525     IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
 526
 527     TRACE( "(%p,%p,%p,%p)\n",iface,lpcDSCBufferDesc,lplpDSCaptureBuffer,pUnk);
 528
 529     if (lpcDSCBufferDesc == NULL) {
 530         WARN("invalid parameter: lpcDSCBufferDesc == NULL)\n");
 531         return DSERR_INVALIDPARAM;
 532     }
 533
 534     if (lplpDSCaptureBuffer == NULL) {
 535         WARN("invalid parameter: lplpDSCaptureBuffer == NULL\n");
 536         return DSERR_INVALIDPARAM;
 537     }
 538
 539     if (pUnk != NULL) {
 540         WARN("invalid parameter: pUnk != NULL\n");
 541         return DSERR_INVALIDPARAM;
 542     }
 543
 544     /* FIXME: We can only have one buffer so what do we do here? */
 545     if (This->device->capture_buffer) {
 546         WARN("lnvalid parameter: already has buffer\n");
 547         return DSERR_INVALIDPARAM;    /* DSERR_GENERIC ? */
 548     }
 549
 550     hr = IDirectSoundCaptureBufferImpl_Create(This->device,
 551         (IDirectSoundCaptureBufferImpl **)lplpDSCaptureBuffer, lpcDSCBufferDesc);
 552
 553     if (hr != DS_OK)
 554         WARN("IDirectSoundCaptureBufferImpl_Create failed\n");
 555
 556     return hr;
 557 }
 558
 559 HRESULT WINAPI IDirectSoundCaptureImpl_GetCaps(
 560     LPDIRECTSOUNDCAPTURE iface,
 561     LPDSCCAPS lpDSCCaps )
 562 {
 563     IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
 564     TRACE("(%p,%p)\n",This,lpDSCCaps);
 565
 566     if (This->device == NULL) {
 567         WARN("not initialized\n");
 568         return DSERR_UNINITIALIZED;
 569     }
 570
 571     if (lpDSCCaps== NULL) {
 572         WARN("invalid parameter: lpDSCCaps== NULL\n");
 573         return DSERR_INVALIDPARAM;
 574     }
 575
 576     if (lpDSCCaps->dwSize < sizeof(*lpDSCCaps)) {
 577         WARN("invalid parameter: lpDSCCaps->dwSize = %d\n", lpDSCCaps->dwSize);
 578         return DSERR_INVALIDPARAM;
 579     }
 580
 581     lpDSCCaps->dwFlags = This->device->drvcaps.dwFlags;
 582     lpDSCCaps->dwFormats = This->device->drvcaps.dwFormats;
 583     lpDSCCaps->dwChannels = This->device->drvcaps.dwChannels;
 584
 585     TRACE("(flags=0x%08x,format=0x%08x,channels=%d)\n",lpDSCCaps->dwFlags,
 586         lpDSCCaps->dwFormats, lpDSCCaps->dwChannels);
 587
 588     return DS_OK;
 589 }
 590
 591 HRESULT WINAPI IDirectSoundCaptureImpl_Initialize(
 592     LPDIRECTSOUNDCAPTURE iface,
 593     LPCGUID lpcGUID )
 594 {
 595     IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
 596     TRACE("(%p,%s)\n", This, debugstr_guid(lpcGUID));
 597
 598     if (This->device != NULL) {
 599         WARN("already initialized\n");
 600         return DSERR_ALREADYINITIALIZED;
 601     }
 602     return DirectSoundCaptureDevice_Initialize(&This->device, lpcGUID);
 603 }
 604
 605 static const IDirectSoundCaptureVtbl dscvt =
 606 {
 607     /* IUnknown methods */
 608     IDirectSoundCaptureImpl_QueryInterface,
 609     IDirectSoundCaptureImpl_AddRef,
 610     IDirectSoundCaptureImpl_Release,
 611
 612     /* IDirectSoundCapture methods */
 613     IDirectSoundCaptureImpl_CreateCaptureBuffer,
 614     IDirectSoundCaptureImpl_GetCaps,
 615     IDirectSoundCaptureImpl_Initialize
 616 };
 617
 618 static HRESULT IDirectSoundCaptureImpl_Create(
 619     LPDIRECTSOUNDCAPTURE8 * ppDSC)
 620 {
 621     IDirectSoundCaptureImpl *pDSC;
 622     TRACE("(%p)\n", ppDSC);
 623
 624     /* Allocate memory */
 625     pDSC = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundCaptureImpl));
 626     if (pDSC == NULL) {
 627         WARN("out of memory\n");
 628         *ppDSC = NULL;
 629         return DSERR_OUTOFMEMORY;
 630     }
 631
 632     pDSC->lpVtbl = &dscvt;
 633     pDSC->ref    = 0;
 634     pDSC->device = NULL;
 635
 636     *ppDSC = (LPDIRECTSOUNDCAPTURE8)pDSC;
 637
 638     return DS_OK;
 639 }
 640
 641 /*******************************************************************************
 642  *              IDirectSoundCaptureNotify
 643  */
 644 static HRESULT WINAPI IDirectSoundCaptureNotifyImpl_QueryInterface(
 645     LPDIRECTSOUNDNOTIFY iface,
 646     REFIID riid,
 647     LPVOID *ppobj)
 648 {
 649     IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
 650     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 651
 652     if (This->dscb == NULL) {
 653         WARN("invalid parameter\n");
 654         return E_INVALIDARG;
 655     }
 656
 657     return IDirectSoundCaptureBuffer_QueryInterface((LPDIRECTSOUNDCAPTUREBUFFER)This->dscb, riid, ppobj);
 658 }
 659
 660 static ULONG WINAPI IDirectSoundCaptureNotifyImpl_AddRef(LPDIRECTSOUNDNOTIFY iface)
 661 {
 662     IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
 663     ULONG ref = InterlockedIncrement(&(This->ref));
 664     TRACE("(%p) ref was %d\n", This, ref - 1);
 665     return ref;
 666 }
 667
 668 static ULONG WINAPI IDirectSoundCaptureNotifyImpl_Release(LPDIRECTSOUNDNOTIFY iface)
 669 {
 670     IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
 671     ULONG ref = InterlockedDecrement(&(This->ref));
 672     TRACE("(%p) ref was %d\n", This, ref + 1);
 673
 674     if (!ref) {
 675         if (This->dscb->hwnotify)
 676             IDsDriverNotify_Release(This->dscb->hwnotify);
 677         This->dscb->notify=NULL;
 678         IDirectSoundCaptureBuffer_Release((LPDIRECTSOUNDCAPTUREBUFFER)This->dscb);
 679         HeapFree(GetProcessHeap(),0,This);
 680         TRACE("(%p) released\n", This);
 681     }
 682     return ref;
 683 }
 684
 685 static HRESULT WINAPI IDirectSoundCaptureNotifyImpl_SetNotificationPositions(
 686     LPDIRECTSOUNDNOTIFY iface,
 687     DWORD howmuch,
 688     LPCDSBPOSITIONNOTIFY notify)
 689 {
 690     IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
 691     TRACE("(%p,0x%08x,%p)\n",This,howmuch,notify);
 692
 693     if (howmuch > 0 && notify == NULL) {
 694         WARN("invalid parameter: notify == NULL\n");
 695         return DSERR_INVALIDPARAM;
 696     }
 697
 698     if (TRACE_ON(dsound)) {
 699         unsigned int i;
 700         for (i=0;i<howmuch;i++)
 701             TRACE("notify at %d to %p\n",
 702             notify[i].dwOffset,notify[i].hEventNotify);
 703     }
 704
 705     if (This->dscb->hwnotify) {
 706         HRESULT hres;
 707         hres = IDsDriverNotify_SetNotificationPositions(This->dscb->hwnotify, howmuch, notify);
 708         if (hres != DS_OK)
 709             WARN("IDsDriverNotify_SetNotificationPositions failed\n");
 710         return hres;
 711     } else if (howmuch > 0) {
 712         /* Make an internal copy of the caller-supplied array.
 713          * Replace the existing copy if one is already present. */
 714         if (This->dscb->notifies)
 715             This->dscb->notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 716                 This->dscb->notifies, howmuch * sizeof(DSBPOSITIONNOTIFY));
 717         else
 718             This->dscb->notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 719                 howmuch * sizeof(DSBPOSITIONNOTIFY));
 720
 721         if (This->dscb->notifies == NULL) {
 722             WARN("out of memory\n");
 723             return DSERR_OUTOFMEMORY;
 724         }
 725         CopyMemory(This->dscb->notifies, notify, howmuch * sizeof(DSBPOSITIONNOTIFY));
 726         This->dscb->nrofnotifies = howmuch;
 727     } else {
 728         HeapFree(GetProcessHeap(), 0, This->dscb->notifies);
 729         This->dscb->notifies = NULL;
 730         This->dscb->nrofnotifies = 0;
 731     }
 732
 733     return S_OK;
 734 }
 735
 736 static const IDirectSoundNotifyVtbl dscnvt =
 737 {
 738     IDirectSoundCaptureNotifyImpl_QueryInterface,
 739     IDirectSoundCaptureNotifyImpl_AddRef,
 740     IDirectSoundCaptureNotifyImpl_Release,
 741     IDirectSoundCaptureNotifyImpl_SetNotificationPositions,
 742 };
 743
 744 static HRESULT IDirectSoundCaptureNotifyImpl_Create(
 745     IDirectSoundCaptureBufferImpl *dscb,
 746     IDirectSoundCaptureNotifyImpl **pdscn)
 747 {
 748     IDirectSoundCaptureNotifyImpl * dscn;
 749     TRACE("(%p,%p)\n",dscb,pdscn);
 750
 751     dscn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dscn));
 752
 753     if (dscn == NULL) {
 754         WARN("out of memory\n");
 755         return DSERR_OUTOFMEMORY;
 756     }
 757
 758     dscn->ref = 0;
 759     dscn->lpVtbl = &dscnvt;
 760     dscn->dscb = dscb;
 761     dscb->notify = dscn;
 762     IDirectSoundCaptureBuffer_AddRef((LPDIRECTSOUNDCAPTUREBUFFER)dscb);
 763
 764     *pdscn = dscn;
 765     return DS_OK;
 766 }
 767
 768 /*******************************************************************************
 769  *              IDirectSoundCaptureBuffer
 770  */
 771 static HRESULT WINAPI
 772 IDirectSoundCaptureBufferImpl_QueryInterface(
 773     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
 774     REFIID riid,
 775     LPVOID* ppobj )
 776 {
 777     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 778     HRESULT hres;
 779     TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
 780
 781     if (ppobj == NULL) {
 782         WARN("invalid parameter\n");
 783         return E_INVALIDARG;
 784     }
 785
 786     *ppobj = NULL;
 787
 788     if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
 789         if (!This->notify)
 790             hres = IDirectSoundCaptureNotifyImpl_Create(This, &This->notify);
 791         if (This->notify) {
 792             IDirectSoundNotify_AddRef((LPDIRECTSOUNDNOTIFY)This->notify);
 793             if (This->device->hwbuf && !This->hwnotify) {
 794                 hres = IDsCaptureDriverBuffer_QueryInterface(This->device->hwbuf,
 795                     &IID_IDsDriverNotify, (LPVOID*)&(This->hwnotify));
 796                 if (hres != DS_OK) {
 797                     WARN("IDsCaptureDriverBuffer_QueryInterface failed\n");
 798                     IDirectSoundNotify_Release((LPDIRECTSOUNDNOTIFY)This->notify);
 799                     *ppobj = 0;
 800                     return hres;
 801                 }
 802             }
 803
 804             *ppobj = This->notify;
 805             return DS_OK;
 806         }
 807
 808         WARN("IID_IDirectSoundNotify\n");
 809         return E_FAIL;
 810     }
 811
 812     if ( IsEqualGUID( &IID_IDirectSoundCaptureBuffer, riid ) ||
 813          IsEqualGUID( &IID_IDirectSoundCaptureBuffer8, riid ) ) {
 814         IDirectSoundCaptureBuffer8_AddRef(iface);
 815         *ppobj = This;
 816         return NO_ERROR;
 817     }
 818
 819     FIXME("(%p,%s,%p) unsupported GUID\n", This, debugstr_guid(riid), ppobj);
 820     return E_NOINTERFACE;
 821 }
 822
 823 static ULONG WINAPI
 824 IDirectSoundCaptureBufferImpl_AddRef( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
 825 {
 826     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 827     ULONG ref = InterlockedIncrement(&(This->ref));
 828     TRACE("(%p) ref was %d\n", This, ref - 1);
 829     return ref;
 830 }
 831
 832 static ULONG WINAPI
 833 IDirectSoundCaptureBufferImpl_Release( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
 834 {
 835     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 836     ULONG ref = InterlockedDecrement(&(This->ref));
 837     TRACE("(%p) ref was %d\n", This, ref + 1);
 838
 839     if (!ref) {
 840         TRACE("deleting object\n");
 841         if (This->device->state == STATE_CAPTURING)
 842             This->device->state = STATE_STOPPING;
 843
 844         HeapFree(GetProcessHeap(),0, This->pdscbd);
 845
 846         if (This->device->hwi) {
 847             waveInReset(This->device->hwi);
 848             waveInClose(This->device->hwi);
 849             HeapFree(GetProcessHeap(),0, This->device->pwave);
 850             This->device->pwave = 0;
 851             This->device->hwi = 0;
 852         }
 853
 854         if (This->device->hwbuf)
 855             IDsCaptureDriverBuffer_Release(This->device->hwbuf);
 856
 857         /* remove from DirectSoundCaptureDevice */
 858         This->device->capture_buffer = NULL;
 859
 860         if (This->notify)
 861             IDirectSoundNotify_Release((LPDIRECTSOUNDNOTIFY)This->notify);
 862
 863         /* If driver manages its own buffer, IDsCaptureDriverBuffer_Release
 864            should have freed the buffer. Prevent freeing it again in
 865            IDirectSoundCaptureBufferImpl_Create */
 866         if (!(This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY))
 867             This->device->buffer = NULL;
 868
 869         HeapFree(GetProcessHeap(), 0, This->notifies);
 870         HeapFree( GetProcessHeap(), 0, This );
 871         TRACE("(%p) released\n", This);
 872     }
 873     return ref;
 874 }
 875
 876 static HRESULT WINAPI
 877 IDirectSoundCaptureBufferImpl_GetCaps(
 878     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
 879     LPDSCBCAPS lpDSCBCaps )
 880 {
 881     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 882     TRACE( "(%p,%p)\n", This, lpDSCBCaps );
 883
 884     if (lpDSCBCaps == NULL) {
 885         WARN("invalid parameter: lpDSCBCaps == NULL\n");
 886         return DSERR_INVALIDPARAM;
 887     }
 888
 889     if (lpDSCBCaps->dwSize < sizeof(DSCBCAPS)) {
 890         WARN("invalid parameter: lpDSCBCaps->dwSize = %d\n", lpDSCBCaps->dwSize);
 891         return DSERR_INVALIDPARAM;
 892     }
 893
 894     if (This->device == NULL) {
 895         WARN("invalid parameter: This->device == NULL\n");
 896         return DSERR_INVALIDPARAM;
 897     }
 898
 899     lpDSCBCaps->dwSize = sizeof(DSCBCAPS);
 900     lpDSCBCaps->dwFlags = This->flags;
 901     lpDSCBCaps->dwBufferBytes = This->pdscbd->dwBufferBytes;
 902     lpDSCBCaps->dwReserved = 0;
 903
 904     TRACE("returning DS_OK\n");
 905     return DS_OK;
 906 }
 907
 908 static HRESULT WINAPI
 909 IDirectSoundCaptureBufferImpl_GetCurrentPosition(
 910     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
 911     LPDWORD lpdwCapturePosition,
 912     LPDWORD lpdwReadPosition )
 913 {
 914     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 915     HRESULT hres = DS_OK;
 916     TRACE( "(%p,%p,%p)\n", This, lpdwCapturePosition, lpdwReadPosition );
 917
 918     if (This->device == NULL) {
 919         WARN("invalid parameter: This->device == NULL\n");
 920         return DSERR_INVALIDPARAM;
 921     }
 922
 923     if (This->device->driver) {
 924         hres = IDsCaptureDriverBuffer_GetPosition(This->device->hwbuf, lpdwCapturePosition, lpdwReadPosition );
 925         if (hres != DS_OK)
 926             WARN("IDsCaptureDriverBuffer_GetPosition failed\n");
 927     } else if (This->device->hwi) {
 928         DWORD pos;
 929
 930         EnterCriticalSection(&This->device->lock);
 931         pos = (DWORD_PTR)This->device->pwave[This->device->index].lpData - (DWORD_PTR)This->device->buffer;
 932         if (lpdwCapturePosition)
 933             *lpdwCapturePosition = (This->device->pwave[This->device->index].dwBufferLength + pos) % This->device->buflen;
 934         if (lpdwReadPosition)
 935             *lpdwReadPosition = pos;
 936         LeaveCriticalSection(&This->device->lock);
 937
 938     } else {
 939         WARN("no driver\n");
 940         hres = DSERR_NODRIVER;
 941     }
 942
 943     TRACE("cappos=%d readpos=%d\n", (lpdwCapturePosition?*lpdwCapturePosition:-1), (lpdwReadPosition?*lpdwReadPosition:-1));
 944     TRACE("returning %08x\n", hres);
 945     return hres;
 946 }
 947
 948 static HRESULT WINAPI
 949 IDirectSoundCaptureBufferImpl_GetFormat(
 950     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
 951     LPWAVEFORMATEX lpwfxFormat,
 952     DWORD dwSizeAllocated,
 953     LPDWORD lpdwSizeWritten )
 954 {
 955     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 956     HRESULT hres = DS_OK;
 957     TRACE( "(%p,%p,0x%08x,%p)\n", This, lpwfxFormat, dwSizeAllocated,
 958         lpdwSizeWritten );
 959
 960     if (This->device == NULL) {
 961         WARN("invalid parameter: This->device == NULL\n");
 962         return DSERR_INVALIDPARAM;
 963     }
 964
 965     if (dwSizeAllocated > (sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize))
 966         dwSizeAllocated = sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize;
 967
 968     if (lpwfxFormat) { /* NULL is valid (just want size) */
 969         CopyMemory(lpwfxFormat, This->device->pwfx, dwSizeAllocated);
 970         if (lpdwSizeWritten)
 971             *lpdwSizeWritten = dwSizeAllocated;
 972     } else {
 973         if (lpdwSizeWritten)
 974             *lpdwSizeWritten = sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize;
 975         else {
 976             TRACE("invalid parameter: lpdwSizeWritten = NULL\n");
 977             hres = DSERR_INVALIDPARAM;
 978         }
 979     }
 980
 981     TRACE("returning %08x\n", hres);
 982     return hres;
 983 }
 984
 985 static HRESULT WINAPI
 986 IDirectSoundCaptureBufferImpl_GetStatus(
 987     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
 988     LPDWORD lpdwStatus )
 989 {
 990     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
 991     TRACE( "(%p, %p), thread is %04x\n", This, lpdwStatus, GetCurrentThreadId() );
 992
 993     if (This->device == NULL) {
 994         WARN("invalid parameter: This->device == NULL\n");
 995         return DSERR_INVALIDPARAM;
 996     }
 997
 998     if (lpdwStatus == NULL) {
 999         WARN("invalid parameter: lpdwStatus == NULL\n");
1000         return DSERR_INVALIDPARAM;
1001     }
1002
1003     *lpdwStatus = 0;
1004     EnterCriticalSection(&(This->device->lock));
1005
1006     TRACE("old This->device->state=%s, old lpdwStatus=%08x\n",
1007         captureStateString[This->device->state],*lpdwStatus);
1008     if ((This->device->state == STATE_STARTING) ||
1009         (This->device->state == STATE_CAPTURING)) {
1010         *lpdwStatus |= DSCBSTATUS_CAPTURING;
1011         if (This->flags & DSCBSTART_LOOPING)
1012             *lpdwStatus |= DSCBSTATUS_LOOPING;
1013     }
1014     TRACE("new This->device->state=%s, new lpdwStatus=%08x\n",
1015         captureStateString[This->device->state],*lpdwStatus);
1016     LeaveCriticalSection(&(This->device->lock));
1017
1018     TRACE("status=%x\n", *lpdwStatus);
1019     TRACE("returning DS_OK\n");
1020     return DS_OK;
1021 }
1022
1023 static HRESULT WINAPI
1024 IDirectSoundCaptureBufferImpl_Initialize(
1025     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1026     LPDIRECTSOUNDCAPTURE lpDSC,
1027     LPCDSCBUFFERDESC lpcDSCBDesc )
1028 {
1029     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1030
1031     FIXME( "(%p,%p,%p): stub\n", This, lpDSC, lpcDSCBDesc );
1032
1033     return DS_OK;
1034 }
1035
1036 static HRESULT WINAPI
1037 IDirectSoundCaptureBufferImpl_Lock(
1038     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1039     DWORD dwReadCusor,
1040     DWORD dwReadBytes,
1041     LPVOID* lplpvAudioPtr1,
1042     LPDWORD lpdwAudioBytes1,
1043     LPVOID* lplpvAudioPtr2,
1044     LPDWORD lpdwAudioBytes2,
1045     DWORD dwFlags )
1046 {
1047     HRESULT hres = DS_OK;
1048     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1049     TRACE( "(%p,%08u,%08u,%p,%p,%p,%p,0x%08x) at %d\n", This, dwReadCusor,
1050         dwReadBytes, lplpvAudioPtr1, lpdwAudioBytes1, lplpvAudioPtr2,
1051         lpdwAudioBytes2, dwFlags, GetTickCount() );
1052
1053     if (This->device == NULL) {
1054         WARN("invalid parameter: This->device == NULL\n");
1055         return DSERR_INVALIDPARAM;
1056     }
1057
1058     if (lplpvAudioPtr1 == NULL) {
1059         WARN("invalid parameter: lplpvAudioPtr1 == NULL\n");
1060         return DSERR_INVALIDPARAM;
1061     }
1062
1063     if (lpdwAudioBytes1 == NULL) {
1064         WARN("invalid parameter: lpdwAudioBytes1 == NULL\n");
1065         return DSERR_INVALIDPARAM;
1066     }
1067
1068     EnterCriticalSection(&(This->device->lock));
1069
1070     if (This->device->driver) {
1071         hres = IDsCaptureDriverBuffer_Lock(This->device->hwbuf, lplpvAudioPtr1,
1072                                            lpdwAudioBytes1, lplpvAudioPtr2,
1073                                            lpdwAudioBytes2, dwReadCusor,
1074                                            dwReadBytes, dwFlags);
1075         if (hres != DS_OK)
1076             WARN("IDsCaptureDriverBuffer_Lock failed\n");
1077     } else if (This->device->hwi) {
1078         *lplpvAudioPtr1 = This->device->buffer + dwReadCusor;
1079         if ( (dwReadCusor + dwReadBytes) > This->device->buflen) {
1080             *lpdwAudioBytes1 = This->device->buflen - dwReadCusor;
1081             if (lplpvAudioPtr2)
1082                 *lplpvAudioPtr2 = This->device->buffer;
1083             if (lpdwAudioBytes2)
1084                 *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1;
1085         } else {
1086             *lpdwAudioBytes1 = dwReadBytes;
1087             if (lplpvAudioPtr2)
1088                 *lplpvAudioPtr2 = 0;
1089             if (lpdwAudioBytes2)
1090                 *lpdwAudioBytes2 = 0;
1091         }
1092     } else {
1093         TRACE("invalid call\n");
1094         hres = DSERR_INVALIDCALL;   /* DSERR_NODRIVER ? */
1095     }
1096
1097     LeaveCriticalSection(&(This->device->lock));
1098
1099     TRACE("returning %08x\n", hres);
1100     return hres;
1101 }
1102
1103 static HRESULT WINAPI
1104 IDirectSoundCaptureBufferImpl_Start(
1105     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1106     DWORD dwFlags )
1107 {
1108     HRESULT hres = DS_OK;
1109     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1110     TRACE( "(%p,0x%08x)\n", This, dwFlags );
1111
1112     if (This->device == NULL) {
1113         WARN("invalid parameter: This->device == NULL\n");
1114         return DSERR_INVALIDPARAM;
1115     }
1116
1117     if ( (This->device->driver == 0) && (This->device->hwi == 0) ) {
1118         WARN("no driver\n");
1119         return DSERR_NODRIVER;
1120     }
1121
1122     EnterCriticalSection(&(This->device->lock));
1123
1124     This->flags = dwFlags;
1125     TRACE("old This->state=%s\n",captureStateString[This->device->state]);
1126     if (This->device->state == STATE_STOPPED)
1127         This->device->state = STATE_STARTING;
1128     else if (This->device->state == STATE_STOPPING)
1129         This->device->state = STATE_CAPTURING;
1130     TRACE("new This->device->state=%s\n",captureStateString[This->device->state]);
1131
1132     LeaveCriticalSection(&(This->device->lock));
1133
1134     if (This->device->driver) {
1135         hres = IDsCaptureDriverBuffer_Start(This->device->hwbuf, dwFlags);
1136         if (hres != DS_OK)
1137             WARN("IDsCaptureDriverBuffer_Start failed\n");
1138     } else if (This->device->hwi) {
1139         DirectSoundCaptureDevice *device = This->device;
1140
1141         if (device->buffer) {
1142             int c;
1143             DWORD blocksize = DSOUND_fraglen(device->pwfx->nSamplesPerSec, device->pwfx->nBlockAlign);
1144             device->nrofpwaves = device->buflen / blocksize + !!(device->buflen % blocksize);
1145             TRACE("nrofpwaves=%d\n", device->nrofpwaves);
1146
1147             /* prepare headers */
1148             if (device->pwave)
1149                 device->pwave = HeapReAlloc(GetProcessHeap(), 0,device->pwave, device->nrofpwaves*sizeof(WAVEHDR));
1150             else
1151                 device->pwave = HeapAlloc(GetProcessHeap(), 0, device->nrofpwaves*sizeof(WAVEHDR));
1152
1153             for (c = 0; c < device->nrofpwaves; ++c) {
1154                 device->pwave[c].lpData = (char *)device->buffer + c * blocksize;
1155                 if (c + 1 == device->nrofpwaves)
1156                     device->pwave[c].dwBufferLength = device->buflen - c * blocksize;
1157                 else
1158                     device->pwave[c].dwBufferLength = blocksize;
1159                 device->pwave[c].dwBytesRecorded = 0;
1160                 device->pwave[c].dwUser = (DWORD_PTR)device;
1161                 device->pwave[c].dwFlags = 0;
1162                 device->pwave[c].dwLoops = 0;
1163                 hres = mmErr(waveInPrepareHeader(device->hwi, &(device->pwave[c]),sizeof(WAVEHDR)));
1164                 if (hres != DS_OK) {
1165                     WARN("waveInPrepareHeader failed\n");
1166                     while (c--)
1167                         waveInUnprepareHeader(device->hwi, &(device->pwave[c]),sizeof(WAVEHDR));
1168                     break;
1169                 }
1170
1171                 hres = mmErr(waveInAddBuffer(device->hwi, &(device->pwave[c]), sizeof(WAVEHDR)));
1172                 if (hres != DS_OK) {
1173                     WARN("waveInAddBuffer failed\n");
1174                     while (c--)
1175                         waveInUnprepareHeader(device->hwi, &(device->pwave[c]),sizeof(WAVEHDR));
1176                     break;
1177                 }
1178             }
1179
1180             FillMemory(device->buffer, device->buflen, (device->pwfx->wBitsPerSample == 8) ? 128 : 0);
1181         }
1182
1183         device->index = 0;
1184
1185         if (hres == DS_OK) {
1186             /* start filling the first buffer */
1187             hres = mmErr(waveInStart(device->hwi));
1188             if (hres != DS_OK)
1189                 WARN("waveInStart failed\n");
1190         }
1191
1192         if (hres != DS_OK) {
1193             WARN("calling waveInClose because of error\n");
1194             waveInClose(device->hwi);
1195             device->hwi = 0;
1196         }
1197     } else {
1198         WARN("no driver\n");
1199         hres = DSERR_NODRIVER;
1200     }
1201
1202     TRACE("returning %08x\n", hres);
1203     return hres;
1204 }
1205
1206 static HRESULT WINAPI
1207 IDirectSoundCaptureBufferImpl_Stop( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
1208 {
1209     HRESULT hres = DS_OK;
1210     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1211     TRACE( "(%p)\n", This );
1212
1213     if (This->device == NULL) {
1214         WARN("invalid parameter: This->device == NULL\n");
1215         return DSERR_INVALIDPARAM;
1216     }
1217
1218     EnterCriticalSection(&(This->device->lock));
1219
1220     TRACE("old This->device->state=%s\n",captureStateString[This->device->state]);
1221     if (This->device->state == STATE_CAPTURING)
1222         This->device->state = STATE_STOPPING;
1223     else if (This->device->state == STATE_STARTING)
1224         This->device->state = STATE_STOPPED;
1225     TRACE("new This->device->state=%s\n",captureStateString[This->device->state]);
1226
1227     LeaveCriticalSection(&(This->device->lock));
1228
1229     if (This->device->driver) {
1230         hres = IDsCaptureDriverBuffer_Stop(This->device->hwbuf);
1231         if (hres != DS_OK)
1232             WARN("IDsCaptureDriverBuffer_Stop() failed\n");
1233     } else if (This->device->hwi) {
1234         hres = mmErr(waveInReset(This->device->hwi));
1235         if (hres != DS_OK)
1236             WARN("waveInReset() failed\n");
1237     } else {
1238         WARN("no driver\n");
1239         hres = DSERR_NODRIVER;
1240     }
1241
1242     TRACE("returning %08x\n", hres);
1243     return hres;
1244 }
1245
1246 static HRESULT WINAPI
1247 IDirectSoundCaptureBufferImpl_Unlock(
1248     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1249     LPVOID lpvAudioPtr1,
1250     DWORD dwAudioBytes1,
1251     LPVOID lpvAudioPtr2,
1252     DWORD dwAudioBytes2 )
1253 {
1254     HRESULT hres = DS_OK;
1255     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1256     TRACE( "(%p,%p,%08u,%p,%08u)\n", This, lpvAudioPtr1, dwAudioBytes1,
1257         lpvAudioPtr2, dwAudioBytes2 );
1258
1259     if (lpvAudioPtr1 == NULL) {
1260         WARN("invalid parameter: lpvAudioPtr1 == NULL\n");
1261         return DSERR_INVALIDPARAM;
1262     }
1263
1264     if (This->device->driver) {
1265         hres = IDsCaptureDriverBuffer_Unlock(This->device->hwbuf, lpvAudioPtr1,
1266                                              dwAudioBytes1, lpvAudioPtr2, dwAudioBytes2);
1267         if (hres != DS_OK)
1268             WARN("IDsCaptureDriverBuffer_Unlock failed\n");
1269     } else if (!This->device->hwi) {
1270         WARN("invalid call\n");
1271         hres = DSERR_INVALIDCALL;
1272     }
1273
1274     TRACE("returning %08x\n", hres);
1275     return hres;
1276 }
1277
1278 static HRESULT WINAPI
1279 IDirectSoundCaptureBufferImpl_GetObjectInPath(
1280     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1281     REFGUID rguidObject,
1282     DWORD dwIndex,
1283     REFGUID rguidInterface,
1284     LPVOID* ppObject )
1285 {
1286     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1287
1288     FIXME( "(%p,%s,%u,%s,%p): stub\n", This, debugstr_guid(rguidObject),
1289         dwIndex, debugstr_guid(rguidInterface), ppObject );
1290
1291     return DS_OK;
1292 }
1293
1294 static HRESULT WINAPI
1295 IDirectSoundCaptureBufferImpl_GetFXStatus(
1296     LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1297     DWORD dwFXCount,
1298     LPDWORD pdwFXStatus )
1299 {
1300     IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1301
1302     FIXME( "(%p,%u,%p): stub\n", This, dwFXCount, pdwFXStatus );
1303
1304     return DS_OK;
1305 }
1306
1307 static const IDirectSoundCaptureBuffer8Vtbl dscbvt =
1308 {
1309     /* IUnknown methods */
1310     IDirectSoundCaptureBufferImpl_QueryInterface,
1311     IDirectSoundCaptureBufferImpl_AddRef,
1312     IDirectSoundCaptureBufferImpl_Release,
1313
1314     /* IDirectSoundCaptureBuffer methods */
1315     IDirectSoundCaptureBufferImpl_GetCaps,
1316     IDirectSoundCaptureBufferImpl_GetCurrentPosition,
1317     IDirectSoundCaptureBufferImpl_GetFormat,
1318     IDirectSoundCaptureBufferImpl_GetStatus,
1319     IDirectSoundCaptureBufferImpl_Initialize,
1320     IDirectSoundCaptureBufferImpl_Lock,
1321     IDirectSoundCaptureBufferImpl_Start,
1322     IDirectSoundCaptureBufferImpl_Stop,
1323     IDirectSoundCaptureBufferImpl_Unlock,
1324
1325     /* IDirectSoundCaptureBuffer methods */
1326     IDirectSoundCaptureBufferImpl_GetObjectInPath,
1327     IDirectSoundCaptureBufferImpl_GetFXStatus
1328 };
1329
1330 HRESULT IDirectSoundCaptureBufferImpl_Create(
1331     DirectSoundCaptureDevice *device,
1332     IDirectSoundCaptureBufferImpl ** ppobj,
1333     LPCDSCBUFFERDESC lpcDSCBufferDesc)
1334 {
1335     LPWAVEFORMATEX  wfex;
1336     TRACE( "(%p,%p,%p)\n", device, ppobj, lpcDSCBufferDesc);
1337
1338     if (ppobj == NULL) {
1339         WARN("invalid parameter: ppobj == NULL\n");
1340         return DSERR_INVALIDPARAM;
1341     }
1342
1343     if (!device) {
1344         WARN("not initialized\n");
1345         *ppobj = NULL;
1346         return DSERR_UNINITIALIZED;
1347     }
1348
1349     if (lpcDSCBufferDesc == NULL) {
1350         WARN("invalid parameter: lpcDSCBufferDesc == NULL\n");
1351         *ppobj = NULL;
1352         return DSERR_INVALIDPARAM;
1353     }
1354
1355     if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) &&
1356           (lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) ||
1357         (lpcDSCBufferDesc->dwBufferBytes == 0) ||
1358         (lpcDSCBufferDesc->lpwfxFormat == NULL) ) {
1359         WARN("invalid lpcDSCBufferDesc\n");
1360         *ppobj = NULL;
1361         return DSERR_INVALIDPARAM;
1362     }
1363
1364     wfex = lpcDSCBufferDesc->lpwfxFormat;
1365
1366     if (wfex) {
1367         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
1368             "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1369             wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
1370             wfex->nAvgBytesPerSec, wfex->nBlockAlign,
1371             wfex->wBitsPerSample, wfex->cbSize);
1372
1373         if (wfex->wFormatTag == WAVE_FORMAT_PCM) {
1374             device->pwfx = HeapAlloc(GetProcessHeap(),0,sizeof(WAVEFORMATEX));
1375             *device->pwfx = *wfex;
1376             device->pwfx->cbSize = 0;
1377         } else {
1378             device->pwfx = HeapAlloc(GetProcessHeap(),0,sizeof(WAVEFORMATEX)+wfex->cbSize);
1379             CopyMemory(device->pwfx, wfex, sizeof(WAVEFORMATEX)+wfex->cbSize);
1380         }
1381     } else {
1382         WARN("lpcDSCBufferDesc->lpwfxFormat == 0\n");
1383         *ppobj = NULL;
1384         return DSERR_INVALIDPARAM; /* FIXME: DSERR_BADFORMAT ? */
1385     }
1386
1387     *ppobj = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
1388         sizeof(IDirectSoundCaptureBufferImpl));
1389
1390     if ( *ppobj == NULL ) {
1391         WARN("out of memory\n");
1392         *ppobj = NULL;
1393         return DSERR_OUTOFMEMORY;
1394     } else {
1395         HRESULT err = DS_OK;
1396         LPBYTE newbuf;
1397         DWORD buflen;
1398         IDirectSoundCaptureBufferImpl *This = *ppobj;
1399
1400         This->ref = 1;
1401         This->device = device;
1402         This->device->capture_buffer = This;
1403         This->notify = NULL;
1404         This->nrofnotifies = 0;
1405         This->hwnotify = NULL;
1406
1407         This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
1408             lpcDSCBufferDesc->dwSize);
1409         if (This->pdscbd)
1410             CopyMemory(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);
1411         else {
1412             WARN("no memory\n");
1413             This->device->capture_buffer = 0;
1414             HeapFree( GetProcessHeap(), 0, This );
1415             *ppobj = NULL;
1416             return DSERR_OUTOFMEMORY;
1417         }
1418
1419         This->lpVtbl = &dscbvt;
1420
1421         if (device->driver) {
1422             if (This->device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
1423                 FIXME("DSDDESC_DOMMSYSTEMOPEN not supported\n");
1424
1425             if (This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) {
1426                 /* allocate buffer from system memory */
1427                 buflen = lpcDSCBufferDesc->dwBufferBytes;
1428                 TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
1429                 if (device->buffer)
1430                     newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
1431                 else
1432                     newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
1433
1434                 if (newbuf == NULL) {
1435                     WARN("failed to allocate capture buffer\n");
1436                     err = DSERR_OUTOFMEMORY;
1437                     /* but the old buffer might still exist and must be re-prepared */
1438                 } else {
1439                     device->buffer = newbuf;
1440                     device->buflen = buflen;
1441                 }
1442             } else {
1443                 /* let driver allocate memory */
1444                 device->buflen = lpcDSCBufferDesc->dwBufferBytes;
1445                 /* FIXME: */
1446                 HeapFree( GetProcessHeap(), 0, device->buffer);
1447                 device->buffer = NULL;
1448             }
1449
1450             err = IDsCaptureDriver_CreateCaptureBuffer(device->driver,
1451                 device->pwfx,0,0,&(device->buflen),&(device->buffer),(LPVOID*)&(device->hwbuf));
1452             if (err != DS_OK) {
1453                 WARN("IDsCaptureDriver_CreateCaptureBuffer failed\n");
1454                 This->device->capture_buffer = 0;
1455                 HeapFree( GetProcessHeap(), 0, This );
1456                 *ppobj = NULL;
1457                 return err;
1458             }
1459         } else {
1460             DWORD flags = CALLBACK_FUNCTION;
1461             err = mmErr(waveInOpen(&(device->hwi),
1462                 device->drvdesc.dnDevNode, device->pwfx,
1463                 (DWORD_PTR)DSOUND_capture_callback, (DWORD_PTR)device, flags));
1464             if (err != DS_OK) {
1465                 WARN("waveInOpen failed\n");
1466                 This->device->capture_buffer = 0;
1467                 HeapFree( GetProcessHeap(), 0, This );
1468                 *ppobj = NULL;
1469                 return err;
1470             }
1471
1472             buflen = lpcDSCBufferDesc->dwBufferBytes;
1473             TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
1474             if (device->buffer)
1475                 newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
1476             else
1477                 newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
1478             if (newbuf == NULL) {
1479                 WARN("failed to allocate capture buffer\n");
1480                 err = DSERR_OUTOFMEMORY;
1481                 /* but the old buffer might still exist and must be re-prepared */
1482             } else {
1483                 device->buffer = newbuf;
1484                 device->buflen = buflen;
1485             }
1486         }
1487     }
1488
1489     TRACE("returning DS_OK\n");
1490     return DS_OK;
1491 }
1492
1493 /*******************************************************************************
1494  * DirectSoundCaptureDevice
1495  */
1496 HRESULT DirectSoundCaptureDevice_Initialize(
1497     DirectSoundCaptureDevice ** ppDevice,
1498     LPCGUID lpcGUID)
1499 {
1500     HRESULT err = DSERR_INVALIDPARAM;
1501     unsigned wid, widn;
1502     BOOLEAN found = FALSE;
1503     GUID devGUID;
1504     DirectSoundCaptureDevice *device = *ppDevice;
1505     TRACE("(%p, %s)\n", ppDevice, debugstr_guid(lpcGUID));
1506
1507     /* Default device? */
1508     if ( !lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL) )
1509         lpcGUID = &DSDEVID_DefaultCapture;
1510
1511     if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
1512         WARN("invalid parameter: lpcGUID\n");
1513         return DSERR_INVALIDPARAM;
1514     }
1515
1516     widn = waveInGetNumDevs();
1517     if (!widn) {
1518         WARN("no audio devices found\n");
1519         return DSERR_NODRIVER;
1520     }
1521
1522     /* enumerate WINMM audio devices and find the one we want */
1523     for (wid=0; wid<widn; wid++) {
1524         if (IsEqualGUID( &devGUID, &DSOUND_capture_guids[wid]) ) {
1525             found = TRUE;
1526             break;
1527         }
1528     }
1529
1530     if (found == FALSE) {
1531         WARN("No device found matching given ID!\n");
1532         return DSERR_NODRIVER;
1533     }
1534
1535     if (DSOUND_capture[wid]) {
1536         WARN("already in use\n");
1537         return DSERR_ALLOCATED;
1538     }
1539
1540     err = DirectSoundCaptureDevice_Create(&(device));
1541     if (err != DS_OK) {
1542         WARN("DirectSoundCaptureDevice_Create failed\n");
1543         return err;
1544     }
1545
1546     *ppDevice = device;
1547     device->guid = devGUID;
1548
1549     /* Disable the direct sound driver to force emulation if requested. */
1550     device->driver = NULL;
1551     if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
1552     {
1553         err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&device->driver,0));
1554         if ( (err != DS_OK) && (err != DSERR_UNSUPPORTED) ) {
1555             WARN("waveInMessage failed; err=%x\n",err);
1556             return err;
1557         }
1558     }
1559     err = DS_OK;
1560
1561     /* Get driver description */
1562     if (device->driver) {
1563         TRACE("using DirectSound driver\n");
1564         err = IDsCaptureDriver_GetDriverDesc(device->driver, &(device->drvdesc));
1565         if (err != DS_OK) {
1566             WARN("IDsCaptureDriver_GetDriverDesc failed\n");
1567             return err;
1568         }
1569     } else {
1570         TRACE("using WINMM\n");
1571         /* if no DirectSound interface available, use WINMM API instead */
1572         device->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN |
1573             DSDDESC_DOMMSYSTEMSETFORMAT;
1574     }
1575
1576     device->drvdesc.dnDevNode = wid;
1577
1578     /* open the DirectSound driver if available */
1579     if (device->driver && (err == DS_OK))
1580         err = IDsCaptureDriver_Open(device->driver);
1581
1582     if (err == DS_OK) {
1583         *ppDevice = device;
1584
1585         /* the driver is now open, so it's now allowed to call GetCaps */
1586         if (device->driver) {
1587             device->drvcaps.dwSize = sizeof(device->drvcaps);
1588             err = IDsCaptureDriver_GetCaps(device->driver,&(device->drvcaps));
1589             if (err != DS_OK) {
1590                 WARN("IDsCaptureDriver_GetCaps failed\n");
1591                 return err;
1592             }
1593         } else /*if (device->hwi)*/ {
1594             WAVEINCAPSA    wic;
1595             err = mmErr(waveInGetDevCapsA((UINT)device->drvdesc.dnDevNode, &wic, sizeof(wic)));
1596
1597             if (err == DS_OK) {
1598                 device->drvcaps.dwFlags = 0;
1599                 lstrcpynA(device->drvdesc.szDrvname, wic.szPname,
1600                           sizeof(device->drvdesc.szDrvname));
1601
1602                 device->drvcaps.dwFlags |= DSCCAPS_EMULDRIVER;
1603                 device->drvcaps.dwFormats = wic.dwFormats;
1604                 device->drvcaps.dwChannels = wic.wChannels;
1605             }
1606         }
1607     }
1608
1609     return err;
1610 }
1611
1612 static HRESULT DirectSoundCaptureDevice_Create(
1613     DirectSoundCaptureDevice ** ppDevice)
1614 {
1615     DirectSoundCaptureDevice * device;
1616     TRACE("(%p)\n", ppDevice);
1617
1618     /* Allocate memory */
1619     device = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DirectSoundCaptureDevice));
1620
1621     if (device == NULL) {
1622         WARN("out of memory\n");
1623         return DSERR_OUTOFMEMORY;
1624     }
1625
1626     device->ref = 1;
1627     device->state = STATE_STOPPED;
1628
1629     InitializeCriticalSection( &(device->lock) );
1630     device->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DirectSoundCaptureDevice.lock");
1631
1632     *ppDevice = device;
1633
1634     return DS_OK;
1635 }
1636
1637 ULONG DirectSoundCaptureDevice_Release(
1638     DirectSoundCaptureDevice * device)
1639 {
1640     ULONG ref = InterlockedDecrement(&(device->ref));
1641     TRACE("(%p) ref was %d\n", device, ref + 1);
1642
1643     if (!ref) {
1644         TRACE("deleting object\n");
1645         if (device->capture_buffer)
1646             IDirectSoundCaptureBufferImpl_Release(
1647                 (LPDIRECTSOUNDCAPTUREBUFFER8) device->capture_buffer);
1648
1649         if (device->driver) {
1650             IDsCaptureDriver_Close(device->driver);
1651             IDsCaptureDriver_Release(device->driver);
1652         }
1653
1654         HeapFree(GetProcessHeap(), 0, device->pwfx);
1655         device->lock.DebugInfo->Spare[0] = 0;
1656         DeleteCriticalSection( &(device->lock) );
1657         DSOUND_capture[device->drvdesc.dnDevNode] = NULL;
1658         HeapFree(GetProcessHeap(), 0, device);
1659         TRACE("(%p) released\n", device);
1660     }
1661     return ref;
1662 }