dlls/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 COBJMACROS
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winuser.h"
  35 #include "mmsystem.h"
  36 #include "mmddk.h"
  37 #include "winternl.h"
  38 #include "winnls.h"
  39 #include "wine/debug.h"
  40 #include "dsound.h"
  41 #include "dsound_private.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  44
  45 typedef struct DirectSoundCaptureDevice      DirectSoundCaptureDevice;
  46
  47 /* IDirectSoundCaptureBuffer implementation structure */
  48 typedef struct IDirectSoundCaptureBufferImpl
  49 {
  50     IDirectSoundCaptureBuffer8          IDirectSoundCaptureBuffer8_iface;
  51     IDirectSoundNotify                  IDirectSoundNotify_iface;
  52     LONG                                numIfaces; /* "in use interfaces" refcount */
  53     LONG                                ref, refn, has_dsc8;
  54     /* IDirectSoundCaptureBuffer fields */
  55     DirectSoundCaptureDevice            *device;
  56     DSCBUFFERDESC                       *pdscbd;
  57     DWORD                               flags;
  58     /* IDirectSoundNotify fields */
  59     DSBPOSITIONNOTIFY                   *notifies;
  60     int                                 nrofnotifies;
  61     HANDLE thread;
  62     HANDLE sleepev;
  63 } IDirectSoundCaptureBufferImpl;
  64
  65 /* DirectSoundCaptureDevice implementation structure */
  66 struct DirectSoundCaptureDevice
  67 {
  68     GUID                          guid;
  69     LONG                          ref;
  70     DSCCAPS                       drvcaps;
  71     BYTE                          *buffer;
  72     DWORD                         buflen, write_pos_bytes;
  73     WAVEFORMATEX                  *pwfx;
  74     IDirectSoundCaptureBufferImpl *capture_buffer;
  75     DWORD                         state;
  76     CRITICAL_SECTION              lock;
  77     IMMDevice                     *mmdevice;
  78     IAudioClient                  *client;
  79     IAudioCaptureClient           *capture;
  80     struct list                   entry;
  81 };
  82
  83 static DWORD WINAPI DSOUND_capture_thread(void *user);
  84
  85 static void capturebuffer_destroy(IDirectSoundCaptureBufferImpl *This)
  86 {
  87     if (This->device->state == STATE_CAPTURING)
  88         This->device->state = STATE_STOPPING;
  89
  90     if(This->thread){
  91         SetEvent(This->sleepev);
  92         WaitForSingleObject(This->thread, INFINITE);
  93         CloseHandle(This->thread);
  94     }
  95     CloseHandle(This->sleepev);
  96
  97     HeapFree(GetProcessHeap(),0, This->pdscbd);
  98
  99     if (This->device->client) {
 100         IAudioClient_Release(This->device->client);
 101         This->device->client = NULL;
 102     }
 103
 104     if (This->device->capture) {
 105         IAudioCaptureClient_Release(This->device->capture);
 106         This->device->capture = NULL;
 107     }
 108
 109     /* remove from DirectSoundCaptureDevice */
 110     This->device->capture_buffer = NULL;
 111
 112     HeapFree(GetProcessHeap(), 0, This->notifies);
 113     HeapFree(GetProcessHeap(), 0, This);
 114     TRACE("(%p) released\n", This);
 115 }
 116
 117 /*******************************************************************************
 118  * IDirectSoundNotify
 119  */
 120 static inline struct IDirectSoundCaptureBufferImpl *impl_from_IDirectSoundNotify(IDirectSoundNotify *iface)
 121 {
 122     return CONTAINING_RECORD(iface, IDirectSoundCaptureBufferImpl, IDirectSoundNotify_iface);
 123 }
 124
 125 static HRESULT WINAPI IDirectSoundNotifyImpl_QueryInterface(IDirectSoundNotify *iface, REFIID riid,
 126         void **ppobj)
 127 {
 128     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundNotify(iface);
 129
 130     TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj);
 131
 132     return IDirectSoundCaptureBuffer_QueryInterface(&This->IDirectSoundCaptureBuffer8_iface, riid, ppobj);
 133 }
 134
 135 static ULONG WINAPI IDirectSoundNotifyImpl_AddRef(IDirectSoundNotify *iface)
 136 {
 137     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundNotify(iface);
 138     ULONG ref = InterlockedIncrement(&This->refn);
 139
 140     TRACE("(%p) ref was %d\n", This, ref - 1);
 141
 142     if(ref == 1)
 143         InterlockedIncrement(&This->numIfaces);
 144
 145     return ref;
 146 }
 147
 148 static ULONG WINAPI IDirectSoundNotifyImpl_Release(IDirectSoundNotify *iface)
 149 {
 150     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundNotify(iface);
 151     ULONG ref = InterlockedDecrement(&This->refn);
 152
 153     TRACE("(%p) ref was %d\n", This, ref + 1);
 154
 155     if (!ref && !InterlockedDecrement(&This->numIfaces))
 156         capturebuffer_destroy(This);
 157
 158     return ref;
 159 }
 160
 161 static HRESULT WINAPI IDirectSoundNotifyImpl_SetNotificationPositions(IDirectSoundNotify *iface,
 162         DWORD howmuch, const DSBPOSITIONNOTIFY *notify)
 163 {
 164     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundNotify(iface);
 165     TRACE("(%p,0x%08x,%p)\n",This,howmuch,notify);
 166
 167     if (howmuch > 0 && notify == NULL) {
 168         WARN("invalid parameter: notify == NULL\n");
 169         return DSERR_INVALIDPARAM;
 170     }
 171
 172     if (TRACE_ON(dsound)) {
 173         unsigned int i;
 174         for (i=0;i<howmuch;i++)
 175             TRACE("notify at %d to %p\n",
 176             notify[i].dwOffset,notify[i].hEventNotify);
 177     }
 178
 179     if (howmuch > 0) {
 180         /* Make an internal copy of the caller-supplied array.
 181          * Replace the existing copy if one is already present. */
 182         if (This->notifies)
 183             This->notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->notifies,
 184                     howmuch * sizeof(DSBPOSITIONNOTIFY));
 185         else
 186             This->notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 187                     howmuch * sizeof(DSBPOSITIONNOTIFY));
 188
 189         if (!This->notifies) {
 190             WARN("out of memory\n");
 191             return DSERR_OUTOFMEMORY;
 192         }
 193         CopyMemory(This->notifies, notify, howmuch * sizeof(DSBPOSITIONNOTIFY));
 194         This->nrofnotifies = howmuch;
 195     } else {
 196         HeapFree(GetProcessHeap(), 0, This->notifies);
 197         This->notifies = NULL;
 198         This->nrofnotifies = 0;
 199     }
 200
 201     return S_OK;
 202 }
 203
 204 static const IDirectSoundNotifyVtbl dscnvt =
 205 {
 206     IDirectSoundNotifyImpl_QueryInterface,
 207     IDirectSoundNotifyImpl_AddRef,
 208     IDirectSoundNotifyImpl_Release,
 209     IDirectSoundNotifyImpl_SetNotificationPositions
 210 };
 211
 212
 213 static const char * const captureStateString[] = {
 214     "STATE_STOPPED",
 215     "STATE_STARTING",
 216     "STATE_CAPTURING",
 217     "STATE_STOPPING"
 218 };
 219
 220
 221 /*******************************************************************************
 222  * IDirectSoundCaptureBuffer
 223  */
 224 static inline IDirectSoundCaptureBufferImpl *impl_from_IDirectSoundCaptureBuffer8(IDirectSoundCaptureBuffer8 *iface)
 225 {
 226     return CONTAINING_RECORD(iface, IDirectSoundCaptureBufferImpl, IDirectSoundCaptureBuffer8_iface);
 227 }
 228
 229 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_QueryInterface(IDirectSoundCaptureBuffer8 *iface,
 230         REFIID riid, void **ppobj)
 231 {
 232     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 233
 234     TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
 235
 236     if (ppobj == NULL) {
 237         WARN("invalid parameter\n");
 238         return E_INVALIDARG;
 239     }
 240
 241     *ppobj = NULL;
 242
 243     if ( IsEqualIID( &IID_IUnknown, riid ) ||
 244          IsEqualIID( &IID_IDirectSoundCaptureBuffer, riid ) ||
 245          (This->has_dsc8 && IsEqualIID( &IID_IDirectSoundCaptureBuffer8, riid )) ) {
 246         IDirectSoundCaptureBuffer8_AddRef(iface);
 247         *ppobj = iface;
 248         return S_OK;
 249     }
 250
 251     if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
 252         IDirectSoundNotify_AddRef(&This->IDirectSoundNotify_iface);
 253         *ppobj = &This->IDirectSoundNotify_iface;
 254         return S_OK;
 255     }
 256
 257     FIXME("(%p,%s,%p) unsupported GUID\n", This, debugstr_guid(riid), ppobj);
 258     return E_NOINTERFACE;
 259 }
 260
 261 static ULONG WINAPI IDirectSoundCaptureBufferImpl_AddRef(IDirectSoundCaptureBuffer8 *iface)
 262 {
 263     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 264     ULONG ref = InterlockedIncrement(&This->ref);
 265
 266     TRACE("(%p) ref was %d\n", This, ref - 1);
 267
 268     if(ref == 1)
 269         InterlockedIncrement(&This->numIfaces);
 270
 271     return ref;
 272 }
 273
 274 static ULONG WINAPI IDirectSoundCaptureBufferImpl_Release(IDirectSoundCaptureBuffer8 *iface)
 275 {
 276     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 277     ULONG ref = InterlockedDecrement(&This->ref);
 278
 279     TRACE("(%p) ref was %d\n", This, ref + 1);
 280
 281     if (!ref && !InterlockedDecrement(&This->numIfaces))
 282         capturebuffer_destroy(This);
 283
 284     return ref;
 285 }
 286
 287 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetCaps(IDirectSoundCaptureBuffer8 *iface,
 288         DSCBCAPS *lpDSCBCaps)
 289 {
 290     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 291     TRACE( "(%p,%p)\n", This, lpDSCBCaps );
 292
 293     if (lpDSCBCaps == NULL) {
 294         WARN("invalid parameter: lpDSCBCaps == NULL\n");
 295         return DSERR_INVALIDPARAM;
 296     }
 297
 298     if (lpDSCBCaps->dwSize < sizeof(DSCBCAPS)) {
 299         WARN("invalid parameter: lpDSCBCaps->dwSize = %d\n", lpDSCBCaps->dwSize);
 300         return DSERR_INVALIDPARAM;
 301     }
 302
 303     if (This->device == NULL) {
 304         WARN("invalid parameter: This->device == NULL\n");
 305         return DSERR_INVALIDPARAM;
 306     }
 307
 308     lpDSCBCaps->dwSize = sizeof(DSCBCAPS);
 309     lpDSCBCaps->dwFlags = This->flags;
 310     lpDSCBCaps->dwBufferBytes = This->pdscbd->dwBufferBytes;
 311     lpDSCBCaps->dwReserved = 0;
 312
 313     TRACE("returning DS_OK\n");
 314     return DS_OK;
 315 }
 316
 317 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetCurrentPosition(IDirectSoundCaptureBuffer8 *iface,
 318         DWORD *lpdwCapturePosition, DWORD *lpdwReadPosition)
 319 {
 320     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 321
 322     TRACE( "(%p,%p,%p)\n", This, lpdwCapturePosition, lpdwReadPosition );
 323
 324     if (This->device == NULL) {
 325         WARN("invalid parameter: This->device == NULL\n");
 326         return DSERR_INVALIDPARAM;
 327     }
 328
 329     EnterCriticalSection(&This->device->lock);
 330
 331     if (!This->device->client) {
 332         LeaveCriticalSection(&This->device->lock);
 333         WARN("no driver\n");
 334         return DSERR_NODRIVER;
 335     }
 336
 337     if(lpdwCapturePosition)
 338         *lpdwCapturePosition = This->device->write_pos_bytes;
 339
 340     if(lpdwReadPosition)
 341         *lpdwReadPosition = This->device->write_pos_bytes;
 342
 343     LeaveCriticalSection(&This->device->lock);
 344
 345     TRACE("cappos=%d readpos=%d\n", (lpdwCapturePosition?*lpdwCapturePosition:-1), (lpdwReadPosition?*lpdwReadPosition:-1));
 346     TRACE("returning DS_OK\n");
 347
 348     return DS_OK;
 349 }
 350
 351 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetFormat(IDirectSoundCaptureBuffer8 *iface,
 352         WAVEFORMATEX *lpwfxFormat, DWORD dwSizeAllocated, DWORD *lpdwSizeWritten)
 353 {
 354     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 355     HRESULT hres = DS_OK;
 356
 357     TRACE("(%p,%p,0x%08x,%p)\n", This, lpwfxFormat, dwSizeAllocated, lpdwSizeWritten);
 358
 359     if (This->device == NULL) {
 360         WARN("invalid parameter: This->device == NULL\n");
 361         return DSERR_INVALIDPARAM;
 362     }
 363
 364     if (dwSizeAllocated > (sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize))
 365         dwSizeAllocated = sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize;
 366
 367     if (lpwfxFormat) { /* NULL is valid (just want size) */
 368         CopyMemory(lpwfxFormat, This->device->pwfx, dwSizeAllocated);
 369         if (lpdwSizeWritten)
 370             *lpdwSizeWritten = dwSizeAllocated;
 371     } else {
 372         if (lpdwSizeWritten)
 373             *lpdwSizeWritten = sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize;
 374         else {
 375             TRACE("invalid parameter: lpdwSizeWritten = NULL\n");
 376             hres = DSERR_INVALIDPARAM;
 377         }
 378     }
 379
 380     TRACE("returning %08x\n", hres);
 381     return hres;
 382 }
 383
 384 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetStatus(IDirectSoundCaptureBuffer8 *iface,
 385         DWORD *lpdwStatus)
 386 {
 387     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 388
 389     TRACE( "(%p, %p), thread is %04x\n", This, lpdwStatus, GetCurrentThreadId() );
 390
 391     if (This->device == NULL) {
 392         WARN("invalid parameter: This->device == NULL\n");
 393         return DSERR_INVALIDPARAM;
 394     }
 395
 396     if (lpdwStatus == NULL) {
 397         WARN("invalid parameter: lpdwStatus == NULL\n");
 398         return DSERR_INVALIDPARAM;
 399     }
 400
 401     *lpdwStatus = 0;
 402     EnterCriticalSection(&(This->device->lock));
 403
 404     TRACE("old This->device->state=%s, old lpdwStatus=%08x\n",
 405         captureStateString[This->device->state],*lpdwStatus);
 406     if ((This->device->state == STATE_STARTING) ||
 407         (This->device->state == STATE_CAPTURING)) {
 408         *lpdwStatus |= DSCBSTATUS_CAPTURING;
 409         if (This->flags & DSCBSTART_LOOPING)
 410             *lpdwStatus |= DSCBSTATUS_LOOPING;
 411     }
 412     TRACE("new This->device->state=%s, new lpdwStatus=%08x\n",
 413         captureStateString[This->device->state],*lpdwStatus);
 414     LeaveCriticalSection(&(This->device->lock));
 415
 416     TRACE("status=%x\n", *lpdwStatus);
 417     TRACE("returning DS_OK\n");
 418     return DS_OK;
 419 }
 420
 421 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_Initialize(IDirectSoundCaptureBuffer8 *iface,
 422         IDirectSoundCapture *lpDSC, const DSCBUFFERDESC *lpcDSCBDesc)
 423 {
 424     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 425
 426     FIXME( "(%p,%p,%p): stub\n", This, lpDSC, lpcDSCBDesc );
 427
 428     return DS_OK;
 429 }
 430
 431 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_Lock(IDirectSoundCaptureBuffer8 *iface,
 432         DWORD dwReadCusor, DWORD dwReadBytes, void **lplpvAudioPtr1, DWORD *lpdwAudioBytes1,
 433         void **lplpvAudioPtr2, DWORD *lpdwAudioBytes2, DWORD dwFlags)
 434 {
 435     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 436     HRESULT hres = DS_OK;
 437
 438     TRACE( "(%p,%08u,%08u,%p,%p,%p,%p,0x%08x) at %d\n", This, dwReadCusor,
 439         dwReadBytes, lplpvAudioPtr1, lpdwAudioBytes1, lplpvAudioPtr2,
 440         lpdwAudioBytes2, dwFlags, GetTickCount() );
 441
 442     if (This->device == NULL) {
 443         WARN("invalid parameter: This->device == NULL\n");
 444         return DSERR_INVALIDPARAM;
 445     }
 446
 447     if (lplpvAudioPtr1 == NULL) {
 448         WARN("invalid parameter: lplpvAudioPtr1 == NULL\n");
 449         return DSERR_INVALIDPARAM;
 450     }
 451
 452     if (lpdwAudioBytes1 == NULL) {
 453         WARN("invalid parameter: lpdwAudioBytes1 == NULL\n");
 454         return DSERR_INVALIDPARAM;
 455     }
 456
 457     EnterCriticalSection(&(This->device->lock));
 458
 459     if (This->device->client) {
 460         *lplpvAudioPtr1 = This->device->buffer + dwReadCusor;
 461         if ( (dwReadCusor + dwReadBytes) > This->device->buflen) {
 462             *lpdwAudioBytes1 = This->device->buflen - dwReadCusor;
 463             if (lplpvAudioPtr2)
 464                 *lplpvAudioPtr2 = This->device->buffer;
 465             if (lpdwAudioBytes2)
 466                 *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1;
 467         } else {
 468             *lpdwAudioBytes1 = dwReadBytes;
 469             if (lplpvAudioPtr2)
 470                 *lplpvAudioPtr2 = 0;
 471             if (lpdwAudioBytes2)
 472                 *lpdwAudioBytes2 = 0;
 473         }
 474     } else {
 475         TRACE("invalid call\n");
 476         hres = DSERR_INVALIDCALL;   /* DSERR_NODRIVER ? */
 477     }
 478
 479     LeaveCriticalSection(&(This->device->lock));
 480
 481     TRACE("returning %08x\n", hres);
 482     return hres;
 483 }
 484
 485 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_Start(IDirectSoundCaptureBuffer8 *iface,
 486         DWORD dwFlags)
 487 {
 488     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 489     HRESULT hres;
 490
 491     TRACE( "(%p,0x%08x)\n", This, dwFlags );
 492
 493     if (This->device == NULL) {
 494         WARN("invalid parameter: This->device == NULL\n");
 495         return DSERR_INVALIDPARAM;
 496     }
 497
 498     if ( !This->device->client ) {
 499         WARN("no driver\n");
 500         return DSERR_NODRIVER;
 501     }
 502
 503     EnterCriticalSection(&(This->device->lock));
 504
 505     if (This->device->state == STATE_STOPPED)
 506         This->device->state = STATE_STARTING;
 507     else if (This->device->state == STATE_STOPPING)
 508         This->device->state = STATE_CAPTURING;
 509     else
 510         goto out;
 511     TRACE("new This->device->state=%s\n",captureStateString[This->device->state]);
 512     This->flags = dwFlags;
 513
 514     if (This->device->buffer)
 515         FillMemory(This->device->buffer, This->device->buflen, (This->device->pwfx->wBitsPerSample == 8) ? 128 : 0);
 516
 517     hres = IAudioClient_Start(This->device->client);
 518     if(FAILED(hres)){
 519         WARN("Start failed: %08x\n", hres);
 520         LeaveCriticalSection(&This->device->lock);
 521         return hres;
 522     }
 523
 524 out:
 525     LeaveCriticalSection(&This->device->lock);
 526
 527     TRACE("returning DS_OK\n");
 528     return DS_OK;
 529 }
 530
 531 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_Stop(IDirectSoundCaptureBuffer8 *iface)
 532 {
 533     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 534     HRESULT hres;
 535
 536     TRACE("(%p)\n", This);
 537
 538     if (This->device == NULL) {
 539         WARN("invalid parameter: This->device == NULL\n");
 540         return DSERR_INVALIDPARAM;
 541     }
 542
 543     EnterCriticalSection(&(This->device->lock));
 544
 545     TRACE("old This->device->state=%s\n",captureStateString[This->device->state]);
 546     if (This->device->state == STATE_CAPTURING)
 547         This->device->state = STATE_STOPPING;
 548     else if (This->device->state == STATE_STARTING)
 549         This->device->state = STATE_STOPPED;
 550     TRACE("new This->device->state=%s\n",captureStateString[This->device->state]);
 551
 552     if(This->device->client){
 553         hres = IAudioClient_Stop(This->device->client);
 554         if(FAILED(hres)){
 555             LeaveCriticalSection(&This->device->lock);
 556             return hres;
 557         }
 558     }
 559
 560     LeaveCriticalSection(&(This->device->lock));
 561
 562     TRACE("returning DS_OK\n");
 563     return DS_OK;
 564 }
 565
 566 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_Unlock(IDirectSoundCaptureBuffer8 *iface,
 567         void *lpvAudioPtr1, DWORD dwAudioBytes1, void *lpvAudioPtr2, DWORD dwAudioBytes2)
 568 {
 569     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 570     HRESULT hres = DS_OK;
 571
 572     TRACE( "(%p,%p,%08u,%p,%08u)\n", This, lpvAudioPtr1, dwAudioBytes1,
 573         lpvAudioPtr2, dwAudioBytes2 );
 574
 575     if (lpvAudioPtr1 == NULL) {
 576         WARN("invalid parameter: lpvAudioPtr1 == NULL\n");
 577         return DSERR_INVALIDPARAM;
 578     }
 579
 580     if (!This->device->client) {
 581         WARN("invalid call\n");
 582         hres = DSERR_INVALIDCALL;
 583     }
 584
 585     TRACE("returning %08x\n", hres);
 586     return hres;
 587 }
 588
 589 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetObjectInPath(IDirectSoundCaptureBuffer8 *iface,
 590         REFGUID rguidObject, DWORD dwIndex, REFGUID rguidInterface, void **ppObject)
 591 {
 592     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 593
 594     FIXME( "(%p,%s,%u,%s,%p): stub\n", This, debugstr_guid(rguidObject),
 595         dwIndex, debugstr_guid(rguidInterface), ppObject );
 596
 597     if (!ppObject)
 598         return DSERR_INVALIDPARAM;
 599
 600     *ppObject = NULL;
 601     return DSERR_CONTROLUNAVAIL;
 602 }
 603
 604 static HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetFXStatus(IDirectSoundCaptureBuffer8 *iface,
 605         DWORD dwFXCount, DWORD *pdwFXStatus)
 606 {
 607     IDirectSoundCaptureBufferImpl *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 608
 609     FIXME( "(%p,%u,%p): stub\n", This, dwFXCount, pdwFXStatus );
 610
 611     return DS_OK;
 612 }
 613
 614 static const IDirectSoundCaptureBuffer8Vtbl dscbvt =
 615 {
 616     /* IUnknown methods */
 617     IDirectSoundCaptureBufferImpl_QueryInterface,
 618     IDirectSoundCaptureBufferImpl_AddRef,
 619     IDirectSoundCaptureBufferImpl_Release,
 620
 621     /* IDirectSoundCaptureBuffer methods */
 622     IDirectSoundCaptureBufferImpl_GetCaps,
 623     IDirectSoundCaptureBufferImpl_GetCurrentPosition,
 624     IDirectSoundCaptureBufferImpl_GetFormat,
 625     IDirectSoundCaptureBufferImpl_GetStatus,
 626     IDirectSoundCaptureBufferImpl_Initialize,
 627     IDirectSoundCaptureBufferImpl_Lock,
 628     IDirectSoundCaptureBufferImpl_Start,
 629     IDirectSoundCaptureBufferImpl_Stop,
 630     IDirectSoundCaptureBufferImpl_Unlock,
 631
 632     /* IDirectSoundCaptureBuffer methods */
 633     IDirectSoundCaptureBufferImpl_GetObjectInPath,
 634     IDirectSoundCaptureBufferImpl_GetFXStatus
 635 };
 636
 637 static void capture_CheckNotify(IDirectSoundCaptureBufferImpl *This, DWORD from, DWORD len)
 638 {
 639     int i;
 640     for (i = 0; i < This->nrofnotifies; ++i) {
 641         LPDSBPOSITIONNOTIFY event = This->notifies + i;
 642         DWORD offset = event->dwOffset;
 643         TRACE("checking %d, position %d, event = %p\n", i, offset, event->hEventNotify);
 644
 645         if (offset == DSBPN_OFFSETSTOP) {
 646             if (!from && !len) {
 647                 SetEvent(event->hEventNotify);
 648                 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
 649                 return;
 650             }
 651             else return;
 652         }
 653
 654         if (offset >= from && offset < (from + len))
 655         {
 656             TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
 657             SetEvent(event->hEventNotify);
 658         }
 659     }
 660 }
 661
 662 static HRESULT IDirectSoundCaptureBufferImpl_Create(
 663     DirectSoundCaptureDevice *device,
 664     IDirectSoundCaptureBufferImpl ** ppobj,
 665     LPCDSCBUFFERDESC lpcDSCBufferDesc)
 666 {
 667     LPWAVEFORMATEX  wfex;
 668     IDirectSoundCaptureBufferImpl *This;
 669     TRACE( "(%p,%p,%p)\n", device, ppobj, lpcDSCBufferDesc);
 670
 671     if (ppobj == NULL) {
 672         WARN("invalid parameter: ppobj == NULL\n");
 673         return DSERR_INVALIDPARAM;
 674     }
 675
 676     *ppobj = NULL;
 677
 678     if (!device) {
 679         WARN("not initialized\n");
 680         return DSERR_UNINITIALIZED;
 681     }
 682
 683     if (lpcDSCBufferDesc == NULL) {
 684         WARN("invalid parameter: lpcDSCBufferDesc == NULL\n");
 685         return DSERR_INVALIDPARAM;
 686     }
 687
 688     if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) &&
 689           (lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) ||
 690         (lpcDSCBufferDesc->dwBufferBytes == 0) ||
 691         (lpcDSCBufferDesc->lpwfxFormat == NULL) ) { /* FIXME: DSERR_BADFORMAT ? */
 692         WARN("invalid lpcDSCBufferDesc\n");
 693         return DSERR_INVALIDPARAM;
 694     }
 695
 696     wfex = lpcDSCBufferDesc->lpwfxFormat;
 697
 698     TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
 699         "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
 700         wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
 701         wfex->nAvgBytesPerSec, wfex->nBlockAlign,
 702         wfex->wBitsPerSample, wfex->cbSize);
 703
 704     device->pwfx = DSOUND_CopyFormat(wfex);
 705     if ( device->pwfx == NULL )
 706         return DSERR_OUTOFMEMORY;
 707
 708     This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
 709         sizeof(IDirectSoundCaptureBufferImpl));
 710
 711     if ( This == NULL ) {
 712         WARN("out of memory\n");
 713         return DSERR_OUTOFMEMORY;
 714     } else {
 715         HRESULT err = DS_OK;
 716         LPBYTE newbuf;
 717         DWORD buflen;
 718
 719         This->numIfaces = 0;
 720         This->ref = 0;
 721         This->refn = 0;
 722         This->device = device;
 723         This->device->capture_buffer = This;
 724         This->nrofnotifies = 0;
 725
 726         This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
 727             lpcDSCBufferDesc->dwSize);
 728         if (This->pdscbd)
 729             CopyMemory(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);
 730         else {
 731             WARN("no memory\n");
 732             This->device->capture_buffer = 0;
 733             HeapFree( GetProcessHeap(), 0, This );
 734             return DSERR_OUTOFMEMORY;
 735         }
 736
 737         This->IDirectSoundCaptureBuffer8_iface.lpVtbl = &dscbvt;
 738         This->IDirectSoundNotify_iface.lpVtbl = &dscnvt;
 739
 740         err = IMMDevice_Activate(device->mmdevice, &IID_IAudioClient,
 741                 CLSCTX_INPROC_SERVER, NULL, (void**)&device->client);
 742         if(FAILED(err)){
 743             WARN("Activate failed: %08x\n", err);
 744             HeapFree(GetProcessHeap(), 0, This->pdscbd);
 745             This->device->capture_buffer = 0;
 746             HeapFree( GetProcessHeap(), 0, This );
 747             return err;
 748         }
 749
 750         err = IAudioClient_Initialize(device->client,
 751                 AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_NOPERSIST | AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
 752                 200 * 100000, 0, device->pwfx, NULL);
 753         if(FAILED(err)){
 754             WARN("Initialize failed: %08x\n", err);
 755             IAudioClient_Release(device->client);
 756             device->client = NULL;
 757             HeapFree(GetProcessHeap(), 0, This->pdscbd);
 758             This->device->capture_buffer = 0;
 759             HeapFree( GetProcessHeap(), 0, This );
 760             if(err == AUDCLNT_E_UNSUPPORTED_FORMAT)
 761                 return DSERR_BADFORMAT;
 762             return err;
 763         }
 764
 765         This->sleepev = CreateEventW(NULL, 0, 0, NULL);
 766
 767         err = IAudioClient_SetEventHandle(device->client, This->sleepev);
 768         if(FAILED(err)){
 769             WARN("SetEventHandle failed: %08x\n", err);
 770             IAudioClient_Release(device->client);
 771             device->client = NULL;
 772             CloseHandle(This->sleepev);
 773             HeapFree(GetProcessHeap(), 0, This->pdscbd);
 774             This->device->capture_buffer = 0;
 775             HeapFree( GetProcessHeap(), 0, This );
 776             return err;
 777         }
 778
 779         err = IAudioClient_GetService(device->client, &IID_IAudioCaptureClient,
 780                 (void**)&device->capture);
 781         if(FAILED(err)){
 782             WARN("GetService failed: %08x\n", err);
 783             IAudioClient_Release(device->client);
 784             device->client = NULL;
 785             CloseHandle(This->sleepev);
 786             HeapFree(GetProcessHeap(), 0, This->pdscbd);
 787             This->device->capture_buffer = 0;
 788             HeapFree( GetProcessHeap(), 0, This );
 789             return err;
 790         }
 791
 792         buflen = lpcDSCBufferDesc->dwBufferBytes;
 793         TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
 794         if (device->buffer)
 795             newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
 796         else
 797             newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
 798         if (newbuf == NULL) {
 799             IAudioClient_Release(device->client);
 800             device->client = NULL;
 801             IAudioCaptureClient_Release(device->capture);
 802             device->capture = NULL;
 803             CloseHandle(This->sleepev);
 804             HeapFree(GetProcessHeap(), 0, This->pdscbd);
 805             This->device->capture_buffer = 0;
 806             HeapFree( GetProcessHeap(), 0, This );
 807             return DSERR_OUTOFMEMORY;
 808         }
 809         device->buffer = newbuf;
 810         device->buflen = buflen;
 811         This->thread = CreateThread(NULL, 0, DSOUND_capture_thread, This, 0, NULL);
 812     }
 813
 814     IDirectSoundCaptureBuffer_AddRef(&This->IDirectSoundCaptureBuffer8_iface);
 815     *ppobj = This;
 816
 817     TRACE("returning DS_OK\n");
 818     return DS_OK;
 819 }
 820
 821
 822 /*******************************************************************************
 823  * DirectSoundCaptureDevice
 824  */
 825 static HRESULT DirectSoundCaptureDevice_Create(
 826     DirectSoundCaptureDevice ** ppDevice)
 827 {
 828     DirectSoundCaptureDevice * device;
 829     TRACE("(%p)\n", ppDevice);
 830
 831     /* Allocate memory */
 832     device = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DirectSoundCaptureDevice));
 833
 834     if (device == NULL) {
 835         WARN("out of memory\n");
 836         return DSERR_OUTOFMEMORY;
 837     }
 838
 839     device->ref = 1;
 840     device->state = STATE_STOPPED;
 841
 842     InitializeCriticalSection( &(device->lock) );
 843     device->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DirectSoundCaptureDevice.lock");
 844
 845     *ppDevice = device;
 846
 847     return DS_OK;
 848 }
 849
 850 static ULONG DirectSoundCaptureDevice_Release(
 851     DirectSoundCaptureDevice * device)
 852 {
 853     ULONG ref = InterlockedDecrement(&(device->ref));
 854     TRACE("(%p) ref was %d\n", device, ref + 1);
 855
 856     if (!ref) {
 857         TRACE("deleting object\n");
 858
 859         EnterCriticalSection(&DSOUND_capturers_lock);
 860         list_remove(&device->entry);
 861         LeaveCriticalSection(&DSOUND_capturers_lock);
 862
 863         if (device->capture_buffer)
 864             IDirectSoundCaptureBufferImpl_Release(&device->capture_buffer->IDirectSoundCaptureBuffer8_iface);
 865
 866         if(device->mmdevice)
 867             IMMDevice_Release(device->mmdevice);
 868         HeapFree(GetProcessHeap(), 0, device->pwfx);
 869         device->lock.DebugInfo->Spare[0] = 0;
 870         DeleteCriticalSection( &(device->lock) );
 871         HeapFree(GetProcessHeap(), 0, device);
 872         TRACE("(%p) released\n", device);
 873     }
 874     return ref;
 875 }
 876
 877 static HRESULT DSOUND_capture_data(DirectSoundCaptureDevice *device)
 878 {
 879     if(!device->capture_buffer || device->state == STATE_STOPPED)
 880         return S_FALSE;
 881
 882     if(device->state == STATE_STOPPING){
 883         device->state = STATE_STOPPED;
 884         return S_FALSE;
 885     }
 886
 887     if(device->state == STATE_STARTING)
 888         device->state = STATE_CAPTURING;
 889
 890     while(1){
 891         HRESULT hr;
 892         UINT32 packet_frames, packet_bytes, avail_bytes, skip_bytes = 0;
 893         DWORD flags;
 894         BYTE *buf;
 895
 896         hr = IAudioCaptureClient_GetBuffer(device->capture, &buf, &packet_frames,
 897                 &flags, NULL, NULL);
 898         if(FAILED(hr)){
 899             WARN("GetBuffer failed: %08x\n", hr);
 900             return hr;
 901         }
 902         if(hr == AUDCLNT_S_BUFFER_EMPTY)
 903             break;
 904
 905         packet_bytes = packet_frames * device->pwfx->nBlockAlign;
 906         if(packet_bytes > device->buflen){
 907             TRACE("audio glitch: dsound buffer too small for data\n");
 908             skip_bytes = packet_bytes - device->buflen;
 909             packet_bytes = device->buflen;
 910         }
 911
 912         avail_bytes = device->buflen - device->write_pos_bytes;
 913         if(avail_bytes > packet_bytes)
 914             avail_bytes = packet_bytes;
 915
 916         memcpy(device->buffer + device->write_pos_bytes, buf + skip_bytes, avail_bytes);
 917         capture_CheckNotify(device->capture_buffer, device->write_pos_bytes, avail_bytes);
 918
 919         packet_bytes -= avail_bytes;
 920         if(packet_bytes > 0){
 921             if(device->capture_buffer->flags & DSCBSTART_LOOPING){
 922                 memcpy(device->buffer, buf + skip_bytes + avail_bytes, packet_bytes);
 923                 capture_CheckNotify(device->capture_buffer, 0, packet_bytes);
 924             }else{
 925                 device->state = STATE_STOPPED;
 926                 capture_CheckNotify(device->capture_buffer, 0, 0);
 927             }
 928         }
 929
 930         device->write_pos_bytes += avail_bytes + packet_bytes;
 931         device->write_pos_bytes %= device->buflen;
 932
 933         hr = IAudioCaptureClient_ReleaseBuffer(device->capture, packet_frames);
 934         if(FAILED(hr)){
 935             WARN("ReleaseBuffer failed: %08x\n", hr);
 936             return hr;
 937         }
 938     }
 939
 940     return S_OK;
 941 }
 942
 943 static DWORD WINAPI DSOUND_capture_thread(void *user)
 944 {
 945     IDirectSoundCaptureBufferImpl *buffer = user;
 946     HRESULT hr;
 947     DWORD ret, wait_ms;
 948     REFERENCE_TIME period;
 949
 950     hr = IAudioClient_GetDevicePeriod(buffer->device->client, &period, NULL);
 951     if(FAILED(hr)){
 952         WARN("GetDevicePeriod failed: %08x\n", hr);
 953         wait_ms = 5;
 954     }else
 955         wait_ms = MulDiv(5, period, 10000);
 956
 957     while(buffer->ref){
 958         ret = WaitForSingleObject(buffer->sleepev, wait_ms);
 959
 960         if(!buffer->device->ref)
 961             break;
 962
 963         if(ret == WAIT_OBJECT_0){
 964             EnterCriticalSection(&buffer->device->lock);
 965
 966             DSOUND_capture_data(buffer->device);
 967
 968             LeaveCriticalSection(&buffer->device->lock);
 969         }else if(ret != WAIT_TIMEOUT)
 970             WARN("WaitForSingleObject failed: %u\n", GetLastError());
 971     }
 972
 973     return 0;
 974 }
 975
 976 static struct _TestFormat {
 977     DWORD flag;
 978     DWORD rate;
 979     DWORD depth;
 980     WORD channels;
 981 } formats_to_test[] = {
 982     { WAVE_FORMAT_1M08, 11025, 8, 1 },
 983     { WAVE_FORMAT_1M16, 11025, 16, 1 },
 984     { WAVE_FORMAT_1S08, 11025, 8, 2 },
 985     { WAVE_FORMAT_1S16, 11025, 16, 2 },
 986     { WAVE_FORMAT_2M08, 22050, 8, 1 },
 987     { WAVE_FORMAT_2M16, 22050, 16, 1 },
 988     { WAVE_FORMAT_2S08, 22050, 8, 2 },
 989     { WAVE_FORMAT_2S16, 22050, 16, 2 },
 990     { WAVE_FORMAT_4M08, 44100, 8, 1 },
 991     { WAVE_FORMAT_4M16, 44100, 16, 1 },
 992     { WAVE_FORMAT_4S08, 44100, 8, 2 },
 993     { WAVE_FORMAT_4S16, 44100, 16, 2 },
 994     { WAVE_FORMAT_48M08, 48000, 8, 1 },
 995     { WAVE_FORMAT_48M16, 48000, 16, 1 },
 996     { WAVE_FORMAT_48S08, 48000, 8, 2 },
 997     { WAVE_FORMAT_48S16, 48000, 16, 2 },
 998     { WAVE_FORMAT_96M08, 96000, 8, 1 },
 999     { WAVE_FORMAT_96M16, 96000, 16, 1 },
1000     { WAVE_FORMAT_96S08, 96000, 8, 2 },
1001     { WAVE_FORMAT_96S16, 96000, 16, 2 },
1002     {0}
1003 };
1004
1005 static HRESULT DirectSoundCaptureDevice_Initialize(
1006     DirectSoundCaptureDevice ** ppDevice,
1007     LPCGUID lpcGUID)
1008 {
1009     HRESULT hr;
1010     GUID devGUID;
1011     IMMDevice *mmdevice;
1012     struct _TestFormat *fmt;
1013     DirectSoundCaptureDevice *device;
1014     IAudioClient *client;
1015
1016     TRACE("(%p, %s)\n", ppDevice, debugstr_guid(lpcGUID));
1017
1018     /* Default device? */
1019     if ( !lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL) )
1020         lpcGUID = &DSDEVID_DefaultCapture;
1021
1022     if(IsEqualGUID(lpcGUID, &DSDEVID_DefaultPlayback) ||
1023             IsEqualGUID(lpcGUID, &DSDEVID_DefaultVoicePlayback))
1024         return DSERR_NODRIVER;
1025
1026     if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
1027         WARN("invalid parameter: lpcGUID\n");
1028         return DSERR_INVALIDPARAM;
1029     }
1030
1031     hr = get_mmdevice(eCapture, &devGUID, &mmdevice);
1032     if(FAILED(hr))
1033         return hr;
1034
1035     EnterCriticalSection(&DSOUND_capturers_lock);
1036
1037     hr = DirectSoundCaptureDevice_Create(&device);
1038     if (hr != DS_OK) {
1039         WARN("DirectSoundCaptureDevice_Create failed\n");
1040         LeaveCriticalSection(&DSOUND_capturers_lock);
1041         return hr;
1042     }
1043
1044     device->guid = devGUID;
1045
1046     device->mmdevice = mmdevice;
1047
1048     device->drvcaps.dwFlags = 0;
1049
1050     device->drvcaps.dwFormats = 0;
1051     device->drvcaps.dwChannels = 0;
1052     hr = IMMDevice_Activate(mmdevice, &IID_IAudioClient,
1053             CLSCTX_INPROC_SERVER, NULL, (void**)&client);
1054     if(FAILED(hr)){
1055         device->lock.DebugInfo->Spare[0] = 0;
1056         DeleteCriticalSection(&device->lock);
1057         HeapFree(GetProcessHeap(), 0, device);
1058         LeaveCriticalSection(&DSOUND_capturers_lock);
1059         return DSERR_NODRIVER;
1060     }
1061
1062     for(fmt = formats_to_test; fmt->flag; ++fmt){
1063         if(DSOUND_check_supported(client, fmt->rate, fmt->depth, fmt->channels)){
1064             device->drvcaps.dwFormats |= fmt->flag;
1065             if(fmt->channels > device->drvcaps.dwChannels)
1066                 device->drvcaps.dwChannels = fmt->channels;
1067         }
1068     }
1069     IAudioClient_Release(client);
1070
1071     list_add_tail(&DSOUND_capturers, &device->entry);
1072
1073     *ppDevice = device;
1074
1075     LeaveCriticalSection(&DSOUND_capturers_lock);
1076
1077     return S_OK;
1078 }
1079
1080
1081 /*****************************************************************************
1082  * IDirectSoundCapture implementation structure
1083  */
1084 typedef struct IDirectSoundCaptureImpl
1085 {
1086     IUnknown                 IUnknown_inner;
1087     IDirectSoundCapture      IDirectSoundCapture_iface;
1088     LONG                     ref, refdsc, numIfaces;
1089     IUnknown                 *outer_unk;        /* internal */
1090     DirectSoundCaptureDevice *device;
1091     BOOL                     has_dsc8;
1092 } IDirectSoundCaptureImpl;
1093
1094 static void capture_destroy(IDirectSoundCaptureImpl *This)
1095 {
1096     if (This->device)
1097         DirectSoundCaptureDevice_Release(This->device);
1098     HeapFree(GetProcessHeap(),0,This);
1099     TRACE("(%p) released\n", This);
1100 }
1101
1102 /*******************************************************************************
1103  *      IUnknown Implementation for DirectSoundCapture
1104  */
1105 static inline IDirectSoundCaptureImpl *impl_from_IUnknown(IUnknown *iface)
1106 {
1107     return CONTAINING_RECORD(iface, IDirectSoundCaptureImpl, IUnknown_inner);
1108 }
1109
1110 static HRESULT WINAPI IUnknownImpl_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
1111 {
1112     IDirectSoundCaptureImpl *This = impl_from_IUnknown(iface);
1113
1114     TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppv);
1115
1116     if (!ppv) {
1117         WARN("invalid parameter\n");
1118         return E_INVALIDARG;
1119     }
1120     *ppv = NULL;
1121
1122     if (IsEqualIID(riid, &IID_IUnknown))
1123         *ppv = &This->IUnknown_inner;
1124     else if (IsEqualIID(riid, &IID_IDirectSoundCapture))
1125         *ppv = &This->IDirectSoundCapture_iface;
1126     else {
1127         WARN("unknown IID %s\n", debugstr_guid(riid));
1128         return E_NOINTERFACE;
1129     }
1130
1131     IUnknown_AddRef((IUnknown*)*ppv);
1132     return S_OK;
1133 }
1134
1135 static ULONG WINAPI IUnknownImpl_AddRef(IUnknown *iface)
1136 {
1137     IDirectSoundCaptureImpl *This = impl_from_IUnknown(iface);
1138     ULONG ref = InterlockedIncrement(&This->ref);
1139
1140     TRACE("(%p) ref=%d\n", This, ref);
1141
1142     if(ref == 1)
1143         InterlockedIncrement(&This->numIfaces);
1144     return ref;
1145 }
1146
1147 static ULONG WINAPI IUnknownImpl_Release(IUnknown *iface)
1148 {
1149     IDirectSoundCaptureImpl *This = impl_from_IUnknown(iface);
1150     ULONG ref = InterlockedDecrement(&This->ref);
1151
1152     TRACE("(%p) ref=%d\n", This, ref);
1153
1154     if (!ref && !InterlockedDecrement(&This->numIfaces))
1155         capture_destroy(This);
1156     return ref;
1157 }
1158
1159 static const IUnknownVtbl unk_vtbl =
1160 {
1161     IUnknownImpl_QueryInterface,
1162     IUnknownImpl_AddRef,
1163     IUnknownImpl_Release
1164 };
1165
1166 /***************************************************************************
1167  * IDirectSoundCaptureImpl
1168  */
1169 static inline struct IDirectSoundCaptureImpl *impl_from_IDirectSoundCapture(IDirectSoundCapture *iface)
1170 {
1171     return CONTAINING_RECORD(iface, struct IDirectSoundCaptureImpl, IDirectSoundCapture_iface);
1172 }
1173
1174 static HRESULT WINAPI IDirectSoundCaptureImpl_QueryInterface(IDirectSoundCapture *iface,
1175         REFIID riid, void **ppv)
1176 {
1177     IDirectSoundCaptureImpl *This = impl_from_IDirectSoundCapture(iface);
1178     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(riid), ppv);
1179     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
1180 }
1181
1182 static ULONG WINAPI IDirectSoundCaptureImpl_AddRef(IDirectSoundCapture *iface)
1183 {
1184     IDirectSoundCaptureImpl *This = impl_from_IDirectSoundCapture(iface);
1185     ULONG ref = InterlockedIncrement(&This->refdsc);
1186
1187     TRACE("(%p) ref=%d\n", This, ref);
1188
1189     if(ref == 1)
1190         InterlockedIncrement(&This->numIfaces);
1191     return ref;
1192 }
1193
1194 static ULONG WINAPI IDirectSoundCaptureImpl_Release(IDirectSoundCapture *iface)
1195 {
1196     IDirectSoundCaptureImpl *This = impl_from_IDirectSoundCapture(iface);
1197     ULONG ref = InterlockedDecrement(&This->refdsc);
1198
1199     TRACE("(%p) ref=%d\n", This, ref);
1200
1201     if (!ref && !InterlockedDecrement(&This->numIfaces))
1202         capture_destroy(This);
1203     return ref;
1204 }
1205
1206 static HRESULT WINAPI IDirectSoundCaptureImpl_CreateCaptureBuffer(IDirectSoundCapture *iface,
1207         LPCDSCBUFFERDESC lpcDSCBufferDesc, IDirectSoundCaptureBuffer **lplpDSCaptureBuffer,
1208         IUnknown *pUnk)
1209 {
1210     IDirectSoundCaptureImpl *This = impl_from_IDirectSoundCapture(iface);
1211     HRESULT hr;
1212
1213     TRACE( "(%p,%p,%p,%p)\n",iface,lpcDSCBufferDesc,lplpDSCaptureBuffer,pUnk);
1214
1215     if (pUnk) {
1216         WARN("invalid parameter: pUnk != NULL\n");
1217         return DSERR_NOAGGREGATION;
1218     }
1219
1220     if (lpcDSCBufferDesc == NULL) {
1221         WARN("invalid parameter: lpcDSCBufferDesc == NULL)\n");
1222         return DSERR_INVALIDPARAM;
1223     }
1224
1225     if (lplpDSCaptureBuffer == NULL) {
1226         WARN("invalid parameter: lplpDSCaptureBuffer == NULL\n");
1227         return DSERR_INVALIDPARAM;
1228     }
1229
1230     /* FIXME: We can only have one buffer so what do we do here? */
1231     if (This->device->capture_buffer) {
1232         WARN("invalid parameter: already has buffer\n");
1233         return DSERR_INVALIDPARAM;    /* DSERR_GENERIC ? */
1234     }
1235
1236     hr = IDirectSoundCaptureBufferImpl_Create(This->device,
1237         (IDirectSoundCaptureBufferImpl **)lplpDSCaptureBuffer, lpcDSCBufferDesc);
1238
1239     if (hr != DS_OK)
1240         WARN("IDirectSoundCaptureBufferImpl_Create failed\n");
1241     else
1242         This->device->capture_buffer->has_dsc8 = This->has_dsc8;
1243
1244     return hr;
1245 }
1246
1247 static HRESULT WINAPI IDirectSoundCaptureImpl_GetCaps(IDirectSoundCapture *iface,
1248         LPDSCCAPS lpDSCCaps)
1249 {
1250     IDirectSoundCaptureImpl *This = impl_from_IDirectSoundCapture(iface);
1251
1252     TRACE("(%p,%p)\n",This,lpDSCCaps);
1253
1254     if (This->device == NULL) {
1255         WARN("not initialized\n");
1256         return DSERR_UNINITIALIZED;
1257     }
1258
1259     if (lpDSCCaps== NULL) {
1260         WARN("invalid parameter: lpDSCCaps== NULL\n");
1261         return DSERR_INVALIDPARAM;
1262     }
1263
1264     if (lpDSCCaps->dwSize < sizeof(*lpDSCCaps)) {
1265         WARN("invalid parameter: lpDSCCaps->dwSize = %d\n", lpDSCCaps->dwSize);
1266         return DSERR_INVALIDPARAM;
1267     }
1268
1269     lpDSCCaps->dwFlags = This->device->drvcaps.dwFlags;
1270     lpDSCCaps->dwFormats = This->device->drvcaps.dwFormats;
1271     lpDSCCaps->dwChannels = This->device->drvcaps.dwChannels;
1272
1273     TRACE("(flags=0x%08x,format=0x%08x,channels=%d)\n",lpDSCCaps->dwFlags,
1274         lpDSCCaps->dwFormats, lpDSCCaps->dwChannels);
1275
1276     return DS_OK;
1277 }
1278
1279 static HRESULT WINAPI IDirectSoundCaptureImpl_Initialize(IDirectSoundCapture *iface,
1280         LPCGUID lpcGUID)
1281 {
1282     IDirectSoundCaptureImpl *This = impl_from_IDirectSoundCapture(iface);
1283
1284     TRACE("(%p,%s)\n", This, debugstr_guid(lpcGUID));
1285
1286     if (This->device != NULL) {
1287         WARN("already initialized\n");
1288         return DSERR_ALREADYINITIALIZED;
1289     }
1290     return DirectSoundCaptureDevice_Initialize(&This->device, lpcGUID);
1291 }
1292
1293 static const IDirectSoundCaptureVtbl dscvt =
1294 {
1295     /* IUnknown methods */
1296     IDirectSoundCaptureImpl_QueryInterface,
1297     IDirectSoundCaptureImpl_AddRef,
1298     IDirectSoundCaptureImpl_Release,
1299
1300     /* IDirectSoundCapture methods */
1301     IDirectSoundCaptureImpl_CreateCaptureBuffer,
1302     IDirectSoundCaptureImpl_GetCaps,
1303     IDirectSoundCaptureImpl_Initialize
1304 };
1305
1306 HRESULT IDirectSoundCaptureImpl_Create(IUnknown *outer_unk, REFIID riid, void **ppv, BOOL has_dsc8)
1307 {
1308     IDirectSoundCaptureImpl *obj;
1309     HRESULT hr;
1310
1311     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
1312
1313     *ppv = NULL;
1314     obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*obj));
1315     if (obj == NULL) {
1316         WARN("out of memory\n");
1317         return DSERR_OUTOFMEMORY;
1318     }
1319
1320     setup_dsound_options();
1321
1322     obj->IUnknown_inner.lpVtbl = &unk_vtbl;
1323     obj->IDirectSoundCapture_iface.lpVtbl = &dscvt;
1324     obj->ref = 1;
1325     obj->refdsc = 0;
1326     obj->numIfaces = 1;
1327     obj->device = NULL;
1328     obj->has_dsc8 = has_dsc8;
1329
1330     /* COM aggregation supported only internally */
1331     if (outer_unk)
1332         obj->outer_unk = outer_unk;
1333     else
1334         obj->outer_unk = &obj->IUnknown_inner;
1335
1336     hr = IUnknown_QueryInterface(&obj->IUnknown_inner, riid, ppv);
1337     IUnknown_Release(&obj->IUnknown_inner);
1338
1339     return hr;
1340 }
1341
1342 HRESULT DSOUND_CaptureCreate(REFIID riid, void **ppv)
1343 {
1344     return IDirectSoundCaptureImpl_Create(NULL, riid, ppv, FALSE);
1345 }
1346
1347 HRESULT DSOUND_CaptureCreate8(REFIID riid, void **ppv)
1348 {
1349     return IDirectSoundCaptureImpl_Create(NULL, riid, ppv, TRUE);
1350 }
1351
1352 /***************************************************************************
1353  * DirectSoundCaptureCreate [DSOUND.6]
1354  *
1355  * Create and initialize a DirectSoundCapture interface.
1356  *
1357  * PARAMS
1358  *    lpcGUID   [I] Address of the GUID that identifies the sound capture device.
1359  *    lplpDSC   [O] Address of a variable to receive the interface pointer.
1360  *    pUnkOuter [I] Must be NULL.
1361  *
1362  * RETURNS
1363  *    Success: DS_OK
1364  *    Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
1365  *             DSERR_OUTOFMEMORY
1366  *
1367  * NOTES
1368  *    lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
1369  *    or NULL for the default device or DSDEVID_DefaultCapture or
1370  *    DSDEVID_DefaultVoiceCapture.
1371  *
1372  *    DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
1373  */
1374 HRESULT WINAPI DirectSoundCaptureCreate(LPCGUID lpcGUID, IDirectSoundCapture **ppDSC,
1375         IUnknown *pUnkOuter)
1376 {
1377     HRESULT hr;
1378     IDirectSoundCapture *pDSC;
1379
1380     TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), ppDSC, pUnkOuter);
1381
1382     if (ppDSC == NULL) {
1383         WARN("invalid parameter: ppDSC == NULL\n");
1384         return DSERR_INVALIDPARAM;
1385     }
1386
1387     if (pUnkOuter) {
1388         WARN("invalid parameter: pUnkOuter != NULL\n");
1389         return DSERR_NOAGGREGATION;
1390     }
1391
1392     hr = DSOUND_CaptureCreate(&IID_IDirectSoundCapture, (void**)&pDSC);
1393     if (hr == DS_OK) {
1394         hr = IDirectSoundCapture_Initialize(pDSC, lpcGUID);
1395         if (hr != DS_OK) {
1396             IDirectSoundCapture_Release(pDSC);
1397             pDSC = 0;
1398         }
1399     }
1400
1401     *ppDSC = pDSC;
1402
1403     return hr;
1404 }
1405
1406 /***************************************************************************
1407  * DirectSoundCaptureCreate8 [DSOUND.12]
1408  *
1409  * Create and initialize a DirectSoundCapture interface.
1410  *
1411  * PARAMS
1412  *    lpcGUID   [I] Address of the GUID that identifies the sound capture device.
1413  *    lplpDSC   [O] Address of a variable to receive the interface pointer.
1414  *    pUnkOuter [I] Must be NULL.
1415  *
1416  * RETURNS
1417  *    Success: DS_OK
1418  *    Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
1419  *             DSERR_OUTOFMEMORY
1420  *
1421  * NOTES
1422  *    lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
1423  *    or NULL for the default device or DSDEVID_DefaultCapture or
1424  *    DSDEVID_DefaultVoiceCapture.
1425  *
1426  *    DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
1427  */
1428 HRESULT WINAPI DirectSoundCaptureCreate8(
1429     LPCGUID lpcGUID,
1430     LPDIRECTSOUNDCAPTURE8 *ppDSC8,
1431     LPUNKNOWN pUnkOuter)
1432 {
1433     HRESULT hr;
1434     LPDIRECTSOUNDCAPTURE8 pDSC8;
1435     TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), ppDSC8, pUnkOuter);
1436
1437     if (ppDSC8 == NULL) {
1438         WARN("invalid parameter: ppDSC8 == NULL\n");
1439         return DSERR_INVALIDPARAM;
1440     }
1441
1442     if (pUnkOuter) {
1443         WARN("invalid parameter: pUnkOuter != NULL\n");
1444         *ppDSC8 = NULL;
1445         return DSERR_NOAGGREGATION;
1446     }
1447
1448     hr = DSOUND_CaptureCreate8(&IID_IDirectSoundCapture8, (void**)&pDSC8);
1449     if (hr == DS_OK) {
1450         hr = IDirectSoundCapture_Initialize(pDSC8, lpcGUID);
1451         if (hr != DS_OK) {
1452             IDirectSoundCapture_Release(pDSC8);
1453             pDSC8 = 0;
1454         }
1455     }
1456
1457     *ppDSC8 = pDSC8;
1458
1459     return hr;
1460 }