capture.c

   1 /* DirectSound capture buffer interface
   2  *
   3  * Copyright 2009 Maarten Lankhorst
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #ifdef __WINESRC__
  23
  24 #define COBJMACROS
  25 #define NONAMELESSSTRUCT
  26 #define NONAMELESSUNION
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "winreg.h"
  32 #include "mmsystem.h"
  33 #include "winternl.h"
  34 #include "mmddk.h"
  35 #include "wine/debug.h"
  36 #include "dsound.h"
  37
  38 #include "dsound_private.h"
  39
  40 #include "ks.h"
  41 #include "ksmedia.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  44
  45 #else
  46
  47 #define WINVER 0x0600
  48 #include <windows.h>
  49 #include <dsound.h>
  50
  51 #include "dsound_private.h"
  52
  53 #ifndef DSCBPN_OFFSET_STOP
  54 #define DSCBPN_OFFSET_STOP          0xffffffff
  55 #endif
  56
  57 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  58
  59 #endif
  60
  61 /* IDirectSoundCapture and IDirectSoundCapture8 are aliases */
  62 HRESULT DSOUND_CaptureCreate(REFIID riid, IDirectSoundCapture **cap)
  63 {
  64     return DSOUND_CaptureCreate8(riid, cap);
  65 }
  66
  67 typedef struct DSCImpl DSCImpl;
  68 typedef struct DSCBuffer DSCBuffer;
  69
  70 struct DSCImpl {
  71     IDirectSoundCapture8 IDirectSoundCapture8_iface;
  72     LONG ref;
  73
  74     ALCchar *device;
  75     DSCBuffer *buf;
  76     UINT timer_id;
  77     DWORD timer_res;
  78     CRITICAL_SECTION crst;
  79 };
  80
  81 struct DSCBuffer {
  82     IDirectSoundCaptureBuffer8 IDirectSoundCaptureBuffer8_iface;
  83     IDirectSoundNotify IDirectSoundNotify_iface;
  84     LONG ref, not_ref;
  85     LONG all_ref;
  86
  87     DSCImpl *parent;
  88     ALCdevice *dev;
  89     DWORD buf_size;
  90     BYTE *buf;
  91     WAVEFORMATEX *format;
  92     DSBPOSITIONNOTIFY *notify;
  93     DWORD nnotify;
  94
  95     DWORD pos;
  96     BOOL playing, looping;
  97 };
  98
  99 static const IDirectSoundCaptureVtbl DSC_Vtbl;
 100 static const IDirectSoundCaptureBuffer8Vtbl DSCBuffer_Vtbl;
 101 static const IDirectSoundNotifyVtbl DSCNot_Vtbl;
 102
 103 static void DSCImpl_Destroy(DSCImpl *This);
 104
 105 static HRESULT DSCBuffer_Create(DSCBuffer **buf)
 106 {
 107     DSCBuffer *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 108     if (!This) return E_OUTOFMEMORY;
 109
 110     This->IDirectSoundCaptureBuffer8_iface.lpVtbl = &DSCBuffer_Vtbl;
 111     This->IDirectSoundNotify_iface.lpVtbl = &DSCNot_Vtbl;
 112     This->all_ref = This->ref = 1;
 113
 114     *buf = This;
 115     return S_OK;
 116 }
 117
 118 static void trigger_notifies(DSCBuffer *buf, DWORD lastpos, DWORD curpos)
 119 {
 120     DWORD i;
 121
 122     if (lastpos == curpos)
 123         return;
 124
 125     for (i = 0; i < buf->nnotify; ++i)
 126     {
 127         DSBPOSITIONNOTIFY *not = &buf->notify[i];
 128         HANDLE event = not->hEventNotify;
 129         DWORD ofs = not->dwOffset;
 130
 131         if (ofs == DSCBPN_OFFSET_STOP)
 132             continue;
 133
 134         /* Wraparound case */
 135         if (curpos < lastpos)
 136         {
 137             if (ofs < curpos || ofs >= lastpos)
 138                 SetEvent(event);
 139             continue;
 140         }
 141
 142         /* Normal case */
 143         if (ofs >= lastpos && ofs < curpos)
 144             SetEvent(event);
 145     }
 146 }
 147
 148 static void CALLBACK DSCBuffer_timer(UINT timerID, UINT msg, DWORD_PTR dwUser,
 149                                      DWORD_PTR dw1, DWORD_PTR dw2)
 150 {
 151     DSCImpl *This = (DSCImpl*)dwUser;
 152     ALCint avail = 0;
 153     DSCBuffer *buf;
 154     (void)timerID;
 155     (void)msg;
 156     (void)dw1;
 157     (void)dw2;
 158
 159     EnterCriticalSection(&This->crst);
 160     buf = This->buf;
 161     if (!buf || !buf->dev || !buf->playing)
 162         goto out;
 163
 164     alcGetIntegerv(buf->dev, ALC_CAPTURE_SAMPLES, 1, &avail);
 165     if (avail)
 166     {
 167         avail *= buf->format->nBlockAlign;
 168         if (avail + buf->pos > buf->buf_size)
 169             avail = buf->buf_size - buf->pos;
 170
 171         alcCaptureSamples(buf->dev, buf->buf + buf->pos, avail/buf->format->nBlockAlign);
 172         trigger_notifies(buf, buf->pos, buf->pos + avail);
 173         buf->pos += avail;
 174
 175         if (buf->pos == buf->buf_size)
 176         {
 177             buf->pos = 0;
 178             if (!buf->looping)
 179                 IDirectSoundCaptureBuffer_Stop((IDirectSoundCaptureBuffer*)buf);
 180             else
 181             {
 182                 avail = 0;
 183                 alcGetIntegerv(buf->dev, ALC_CAPTURE_SAMPLES, 1, &avail);
 184                 avail *= buf->format->nBlockAlign;
 185                 if ((ALCuint)avail >= buf->buf_size)
 186                 {
 187                     ERR("TOO MUCH AVAIL: %u/%u\n", avail, buf->buf_size);
 188                     avail = buf->buf_size;
 189                 }
 190
 191                 if (avail)
 192                 {
 193                     alcCaptureSamples(buf->dev, buf->buf + buf->pos, avail/buf->format->nBlockAlign);
 194                     trigger_notifies(buf, buf->pos, buf->pos + avail);
 195                     buf->pos += avail;
 196                 }
 197             }
 198         }
 199     }
 200
 201 out:
 202     LeaveCriticalSection(&This->crst);
 203     return;
 204 }
 205
 206 static void DSCBuffer_starttimer(DSCImpl *prim)
 207 {
 208     TIMECAPS time;
 209     ALint refresh = FAKE_REFRESH_COUNT;
 210     DWORD triggertime, res = DS_TIME_RES;
 211
 212     if (prim->timer_id)
 213         return;
 214
 215     timeGetDevCaps(&time, sizeof(TIMECAPS));
 216     triggertime = 1000 / refresh;
 217     if (triggertime < time.wPeriodMin)
 218         triggertime = time.wPeriodMin;
 219     TRACE("Calling timer every %u ms for %i refreshes per second\n", triggertime, refresh);
 220     if (res < time.wPeriodMin)
 221         res = time.wPeriodMin;
 222     if (timeBeginPeriod(res) == TIMERR_NOCANDO)
 223         WARN("Could not set minimum resolution, don't expect sound\n");
 224     prim->timer_res = res;
 225     prim->timer_id = timeSetEvent(triggertime, res, DSCBuffer_timer, (DWORD_PTR)prim, TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
 226 }
 227
 228 static void DSCBuffer_Destroy(DSCBuffer *This)
 229 {
 230     if(This->dev)
 231     {
 232         if(This->playing)
 233             alcCaptureStop(This->dev);
 234         alcCaptureCloseDevice(This->dev);
 235     }
 236     if(This->parent)
 237         This->parent->buf = NULL;
 238     HeapFree(GetProcessHeap(), 0, This->notify);
 239     HeapFree(GetProcessHeap(), 0, This->format);
 240     HeapFree(GetProcessHeap(), 0, This->buf);
 241     HeapFree(GetProcessHeap(), 0, This);
 242 }
 243
 244 static inline DSCBuffer *impl_from_IDirectSoundCaptureBuffer8(IDirectSoundCaptureBuffer8 *iface)
 245 {
 246     return CONTAINING_RECORD(iface, DSCBuffer, IDirectSoundCaptureBuffer8_iface);
 247 }
 248
 249 static HRESULT WINAPI DSCBuffer_QueryInterface(IDirectSoundCaptureBuffer8 *iface, REFIID riid, void **ppv)
 250 {
 251     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 252
 253     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 254
 255     if(!ppv)
 256         return E_POINTER;
 257     *ppv = NULL;
 258
 259     if (IsEqualIID(riid, &IID_IDirectSoundNotify))
 260         *ppv = &This->IDirectSoundNotify_iface;
 261     else if (IsEqualIID(riid, &IID_IUnknown) ||
 262              IsEqualIID(riid, &IID_IDirectSoundCaptureBuffer) ||
 263              IsEqualIID(riid, &IID_IDirectSoundCaptureBuffer8))
 264         *ppv = &This->IDirectSoundCaptureBuffer8_iface;
 265
 266     if (!*ppv)
 267         return E_NOINTERFACE;
 268     IUnknown_AddRef((IUnknown*)*ppv);
 269     return S_OK;
 270 }
 271
 272 static ULONG WINAPI DSCBuffer_AddRef(IDirectSoundCaptureBuffer8 *iface)
 273 {
 274     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 275     LONG ref;
 276
 277     InterlockedIncrement(&This->all_ref);
 278     ref = InterlockedIncrement(&This->ref);
 279     TRACE("Reference count incremented to %i\n", ref);
 280
 281     return ref;
 282 }
 283
 284 static ULONG WINAPI DSCBuffer_Release(IDirectSoundCaptureBuffer8 *iface)
 285 {
 286     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 287     LONG ref;
 288
 289     ref = InterlockedDecrement(&This->ref);
 290     TRACE("Reference count decremented to %i\n", ref);
 291     if(InterlockedDecrement(&This->all_ref) == 0)
 292         DSCBuffer_Destroy(This);
 293
 294     return ref;
 295 }
 296
 297 static HRESULT WINAPI DSCBuffer_GetCaps(IDirectSoundCaptureBuffer8 *iface, DSCBCAPS *caps)
 298 {
 299     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 300
 301     if (!caps || caps->dwSize < sizeof(*caps))
 302         return DSERR_INVALIDPARAM;
 303     caps->dwSize = sizeof(*caps);
 304     caps->dwFlags = 0;
 305     caps->dwBufferBytes = This->buf_size;
 306     return S_OK;
 307 }
 308
 309 static HRESULT WINAPI DSCBuffer_GetCurrentPosition(IDirectSoundCaptureBuffer8 *iface, DWORD *cappos, DWORD *readpos)
 310 {
 311     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 312     DWORD pos1, pos2;
 313
 314     EnterCriticalSection(&This->parent->crst);
 315     pos1 = This->pos;
 316     if (This->playing)
 317     {
 318         pos2 = This->format->nSamplesPerSec / 100;
 319         pos2 *= This->format->nBlockAlign;
 320         pos2 += pos1;
 321         if (!This->looping && pos2 >= This->buf_size)
 322             pos2 = 0;
 323         else
 324             pos2 %= This->buf_size;
 325     }
 326     else
 327         pos2 = pos1;
 328     LeaveCriticalSection(&This->parent->crst);
 329
 330     if(cappos) *cappos = pos1;
 331     if(readpos) *readpos = pos2;
 332
 333     return S_OK;
 334 }
 335
 336 static HRESULT WINAPI DSCBuffer_GetFormat(IDirectSoundCaptureBuffer8 *iface, WAVEFORMATEX *wfx, DWORD size, DWORD *written)
 337 {
 338     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 339     TRACE("(%p,%p,%u,%p)\n", This, wfx, size, written);
 340
 341     if (size > sizeof(WAVEFORMATEX) + This->format->cbSize)
 342         size = sizeof(WAVEFORMATEX) + This->format->cbSize;
 343
 344     if (wfx)
 345     {
 346         CopyMemory(wfx, This->format, size);
 347         if (written)
 348             *written = size;
 349     }
 350     else if (written)
 351         *written = sizeof(WAVEFORMATEX) + This->format->cbSize;
 352     else
 353         return DSERR_INVALIDPARAM;
 354
 355     return S_OK;
 356 }
 357
 358 static HRESULT WINAPI DSCBuffer_GetStatus(IDirectSoundCaptureBuffer8 *iface, DWORD *status)
 359 {
 360     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 361     TRACE("(%p)->(%p)\n", This, status);
 362
 363     if (!status)
 364         return DSERR_INVALIDPARAM;
 365     EnterCriticalSection(&This->parent->crst);
 366     *status = 0;
 367     if (This->playing)
 368     {
 369         *status |= DSCBSTATUS_CAPTURING;
 370         if (This->looping)
 371             *status |= DSCBSTATUS_LOOPING;
 372     }
 373     LeaveCriticalSection(&This->parent->crst);
 374
 375     return S_OK;
 376 }
 377
 378 static HRESULT WINAPI DSCBuffer_Initialize(IDirectSoundCaptureBuffer8 *iface, IDirectSoundCapture *parent, const DSCBUFFERDESC *desc)
 379 {
 380     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 381     WAVEFORMATEX *format;
 382     ALenum buf_format = -1;
 383
 384     if (This->parent)
 385         return DSERR_ALREADYINITIALIZED;
 386     This->parent = (DSCImpl*)parent;
 387
 388     if (!desc->lpwfxFormat)
 389         return DSERR_INVALIDPARAM;
 390
 391     format = desc->lpwfxFormat;
 392     if (format->nChannels > 2)
 393     {
 394         WARN("nChannels > 2 not supported for recording\n");
 395         return DSERR_INVALIDPARAM;
 396     }
 397
 398     if (!This->format)
 399         This->format = HeapAlloc(GetProcessHeap(), 0, sizeof(WAVEFORMATEXTENSIBLE));
 400     if (!This->format)
 401         return DSERR_OUTOFMEMORY;
 402
 403     if (format->wFormatTag == WAVE_FORMAT_PCM ||
 404         format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 405     {
 406         if (format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 407         {
 408             WAVEFORMATEXTENSIBLE *wfe = (WAVEFORMATEXTENSIBLE*)format;
 409             if (format->cbSize < sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX))
 410                 return DSERR_INVALIDPARAM;
 411             else if (format->cbSize > sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX)
 412                 && format->cbSize != sizeof(WAVEFORMATEXTENSIBLE))
 413                 return DSERR_CONTROLUNAVAIL;
 414             else if (!IsEqualGUID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 415                 return DSERR_BADFORMAT;
 416         }
 417
 418         if (format->nChannels == 1)
 419         {
 420             switch (format->wBitsPerSample)
 421             {
 422                 case 8: buf_format = AL_FORMAT_MONO8; break;
 423                 case 16: buf_format = AL_FORMAT_MONO16; break;
 424                 default:
 425                     WARN("Unsupported bpp %u\n", format->wBitsPerSample);
 426                     return DSERR_BADFORMAT;
 427             }
 428         }
 429         else if (format->nChannels == 2)
 430         {
 431             switch (format->wBitsPerSample)
 432             {
 433                 case 8: buf_format = AL_FORMAT_STEREO8; break;
 434                 case 16: buf_format = AL_FORMAT_STEREO16; break;
 435                 default:
 436                     WARN("Unsupported bpp %u\n", format->wBitsPerSample);
 437                     return DSERR_BADFORMAT;
 438             }
 439         }
 440         memcpy(This->format, format, sizeof(*format) + format->cbSize);
 441         if (format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 442             This->format->cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 443         else
 444             This->format->cbSize = 0;
 445         This->format->nBlockAlign = This->format->wBitsPerSample * This->format->nChannels / 8;
 446         This->format->nAvgBytesPerSec = This->format->nSamplesPerSec * This->format->nBlockAlign;
 447     }
 448     else if (format->wFormatTag)
 449         WARN("Unhandled formattag %x\n", format->wFormatTag);
 450
 451     This->buf_size = desc->dwBufferBytes;
 452     if(buf_format <= 0)
 453     {
 454         WARN("Could not get OpenAL format\n");
 455         return DSERR_INVALIDPARAM;
 456     }
 457
 458     This->dev = alcCaptureOpenDevice(This->parent->device, This->format->nSamplesPerSec, buf_format, This->buf_size / This->format->nBlockAlign);
 459     if (!This->dev)
 460     {
 461         ERR("couldn't open device %s %x@%u, reason: %04x\n", This->parent->device, buf_format, This->format->nSamplesPerSec, alcGetError(NULL));
 462         return DSERR_INVALIDPARAM;
 463     }
 464
 465     This->buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->buf_size);
 466     if (!This->buf)
 467     {
 468         alcCaptureCloseDevice(This->dev);
 469         WARN("Out of memory\n");
 470         return DSERR_INVALIDPARAM;
 471     }
 472
 473     return S_OK;
 474 }
 475
 476 static HRESULT WINAPI DSCBuffer_Lock(IDirectSoundCaptureBuffer8 *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
 477 {
 478     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 479     HRESULT hr;
 480     DWORD remain;
 481     TRACE("(%p)->(%u, %u, %p, %p, %p, %p, %#x)\n", This, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 482
 483     EnterCriticalSection(&This->parent->crst);
 484     hr = DSERR_INVALIDPARAM;
 485
 486     if(ptr1) *ptr1 = NULL;
 487     if(len1) *len1 = 0;
 488     if(ptr2) *ptr2 = NULL;
 489     if(len2) *len2 = 0;
 490
 491     if (ofs >= This->buf_size)
 492     {
 493         WARN("Invalid ofs %u\n", ofs);
 494         goto out;
 495     }
 496     if (!ptr1 || !len1)
 497     {
 498         WARN("Invalid pointer/len %p %p\n", ptr1, len1);
 499         goto out;
 500     }
 501     if((flags&DSCBLOCK_ENTIREBUFFER))
 502         bytes = This->buf_size;
 503     else if(bytes > This->buf_size)
 504     {
 505         WARN("Invalid size %u\n", bytes);
 506         goto out;
 507     }
 508
 509     if (ofs + bytes >= This->buf_size)
 510     {
 511         *len1 = This->buf_size - ofs;
 512         remain = bytes - *len1;
 513     }
 514     else
 515     {
 516         *len1 = bytes;
 517         remain = 0;
 518     }
 519     *ptr1 = This->buf + ofs;
 520
 521     if (ptr2 && len2 && remain)
 522     {
 523         *ptr2 = This->buf;
 524         *len2 = remain;
 525     }
 526     hr = S_OK;
 527
 528 out:
 529     LeaveCriticalSection(&This->parent->crst);
 530     return hr;
 531 }
 532
 533 static HRESULT WINAPI DSCBuffer_Start(IDirectSoundCaptureBuffer8 *iface, DWORD flags)
 534 {
 535     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 536     TRACE("(%p)->(%08x)\n", This, flags);
 537
 538     EnterCriticalSection(&This->parent->crst);
 539     if (!This->playing)
 540     {
 541         DSCBuffer_starttimer(This->parent);
 542         This->playing = 1;
 543         alcCaptureStart(This->dev);
 544     }
 545     This->looping = !!(flags & DSCBSTART_LOOPING);
 546     LeaveCriticalSection(&This->parent->crst);
 547     return S_OK;
 548 }
 549
 550 static HRESULT WINAPI DSCBuffer_Stop(IDirectSoundCaptureBuffer8 *iface)
 551 {
 552     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 553     TRACE("(%p)\n", This);
 554
 555     EnterCriticalSection(&This->parent->crst);
 556     if (This->playing)
 557     {
 558         DWORD i;
 559
 560         for (i = 0; i < This->nnotify; ++i)
 561             if (This->notify[i].dwOffset == DSCBPN_OFFSET_STOP)
 562             {
 563                 SetEvent(This->notify[i].hEventNotify);
 564                 break;
 565             }
 566         This->playing = This->looping = 0;
 567         alcCaptureStop(This->dev);
 568     }
 569     LeaveCriticalSection(&This->parent->crst);
 570     return S_OK;
 571 }
 572
 573 static HRESULT WINAPI DSCBuffer_Unlock(IDirectSoundCaptureBuffer8 *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
 574 {
 575     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 576     TRACE("(%p)->(%p,%u,%p,%u)\n", This, ptr1, len1, ptr2, len2);
 577
 578     if (!ptr1)
 579         return DSERR_INVALIDPARAM;
 580     return S_OK;
 581 }
 582
 583 static HRESULT WINAPI DSCBuffer_GetObjectInPath(IDirectSoundCaptureBuffer8 *iface, REFGUID guid, DWORD num, REFGUID riid, void **ppv)
 584 {
 585     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 586     FIXME("(%p)->(%s %u %s %p) stub\n", This, debugstr_guid(guid), num, debugstr_guid(riid), ppv);
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI DSCBuffer_GetFXStatus(IDirectSoundCaptureBuffer8 *iface, DWORD count, DWORD *status)
 591 {
 592     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 593     FIXME("(%p)->(%u %p) stub\n", This, count, status);
 594     return E_NOTIMPL;
 595 }
 596
 597 static const IDirectSoundCaptureBuffer8Vtbl DSCBuffer_Vtbl =
 598 {
 599     DSCBuffer_QueryInterface,
 600     DSCBuffer_AddRef,
 601     DSCBuffer_Release,
 602     DSCBuffer_GetCaps,
 603     DSCBuffer_GetCurrentPosition,
 604     DSCBuffer_GetFormat,
 605     DSCBuffer_GetStatus,
 606     DSCBuffer_Initialize,
 607     DSCBuffer_Lock,
 608     DSCBuffer_Start,
 609     DSCBuffer_Stop,
 610     DSCBuffer_Unlock,
 611     DSCBuffer_GetObjectInPath,
 612     DSCBuffer_GetFXStatus
 613 };
 614
 615 static inline DSCBuffer *impl_from_IDirectSoundNotify(IDirectSoundNotify *iface)
 616 {
 617     return CONTAINING_RECORD(iface, DSCBuffer, IDirectSoundNotify_iface);
 618 }
 619
 620 static HRESULT WINAPI DSCBufferNot_QueryInterface(IDirectSoundNotify *iface, REFIID riid, void **ppv)
 621 {
 622     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 623     return IDirectSoundCaptureBuffer_QueryInterface((IDirectSoundCaptureBuffer*)This, riid, ppv);
 624 }
 625
 626 static ULONG WINAPI DSCBufferNot_AddRef(IDirectSoundNotify *iface)
 627 {
 628     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 629     LONG ret;
 630
 631     InterlockedIncrement(&This->all_ref);
 632     ret = InterlockedIncrement(&This->not_ref);
 633     TRACE("new refcount %d\n", ret);
 634     return ret;
 635 }
 636
 637 static ULONG WINAPI DSCBufferNot_Release(IDirectSoundNotify *iface)
 638 {
 639     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 640     LONG ret;
 641
 642     ret = InterlockedDecrement(&This->not_ref);
 643     TRACE("new refcount %d\n", ret);
 644     if(InterlockedDecrement(&This->all_ref) == 0)
 645         DSCBuffer_Destroy(This);
 646
 647     return ret;
 648 }
 649
 650 static HRESULT WINAPI DSCBufferNot_SetNotificationPositions(IDirectSoundNotify *iface, DWORD count, const DSBPOSITIONNOTIFY *notifications)
 651 {
 652     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 653     DSBPOSITIONNOTIFY *nots;
 654     HRESULT hr;
 655     DWORD state;
 656
 657     EnterCriticalSection(&This->parent->crst);
 658     hr = DSERR_INVALIDPARAM;
 659     if (count && !notifications)
 660         goto out;
 661
 662     hr = DSCBuffer_GetStatus(&This->IDirectSoundCaptureBuffer8_iface, &state);
 663     if (FAILED(hr))
 664         goto out;
 665
 666     hr = DSERR_INVALIDCALL;
 667     if (state & DSCBSTATUS_CAPTURING)
 668         goto out;
 669
 670     if (!count)
 671     {
 672         HeapFree(GetProcessHeap(), 0, This->notify);
 673         This->notify = 0;
 674         This->nnotify = 0;
 675     }
 676     else
 677     {
 678         DWORD i;
 679         hr = DSERR_INVALIDPARAM;
 680         for (i = 0; i < count; ++i)
 681         {
 682             if (notifications[i].dwOffset >= This->buf_size
 683                 && notifications[i].dwOffset != DSCBPN_OFFSET_STOP)
 684                 goto out;
 685         }
 686         hr = E_OUTOFMEMORY;
 687         nots = HeapAlloc(GetProcessHeap(), 0, count*sizeof(*nots));
 688         if (!nots)
 689             goto out;
 690         memcpy(nots, notifications, count*sizeof(*nots));
 691         HeapFree(GetProcessHeap(), 0, This->notify);
 692         This->notify = nots;
 693         This->nnotify = count;
 694         hr = S_OK;
 695     }
 696
 697 out:
 698     LeaveCriticalSection(&This->parent->crst);
 699     return hr;
 700 }
 701
 702 static const IDirectSoundNotifyVtbl DSCNot_Vtbl =
 703 {
 704     DSCBufferNot_QueryInterface,
 705     DSCBufferNot_AddRef,
 706     DSCBufferNot_Release,
 707     DSCBufferNot_SetNotificationPositions
 708 };
 709
 710 HRESULT DSOUND_CaptureCreate8(REFIID riid, IDirectSoundCapture8 **cap)
 711 {
 712     DSCImpl *This;
 713
 714     *cap = NULL;
 715
 716     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 717     if(!This) return DSERR_OUTOFMEMORY;
 718
 719     This->IDirectSoundCapture8_iface.lpVtbl = &DSC_Vtbl;
 720
 721     InitializeCriticalSection(&This->crst);
 722     This->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DSCImpl.crst");
 723
 724     if(FAILED(IDirectSoundCapture_QueryInterface(&This->IDirectSoundCapture8_iface, riid, (void**)cap)))
 725     {
 726         DSCImpl_Destroy(This);
 727         return E_NOINTERFACE;
 728     }
 729     return S_OK;
 730 }
 731
 732 static void DSCImpl_Destroy(DSCImpl *This)
 733 {
 734     if (This->timer_id)
 735     {
 736         timeKillEvent(This->timer_id);
 737         timeEndPeriod(This->timer_res);
 738     }
 739
 740     EnterCriticalSection(&This->crst);
 741     if (This->buf)
 742         DSCBuffer_Destroy(This->buf);
 743     LeaveCriticalSection(&This->crst);
 744
 745     HeapFree(GetProcessHeap(), 0, This->device);
 746
 747     This->crst.DebugInfo->Spare[0] = 0;
 748     DeleteCriticalSection(&This->crst);
 749
 750     HeapFree(GetProcessHeap(), 0, This);
 751 }
 752
 753 static HRESULT WINAPI DSCImpl_QueryInterface(IDirectSoundCapture *iface, REFIID riid, void **ppv)
 754 {
 755     *ppv = NULL;
 756     if(IsEqualIID(riid, &IID_IUnknown) ||
 757        IsEqualIID(riid, &IID_IDirectSoundCapture))
 758         *ppv = iface;
 759
 760     if(!*ppv)
 761         return E_NOINTERFACE;
 762     IUnknown_AddRef((IUnknown*)*ppv);
 763     return S_OK;
 764 }
 765
 766 static ULONG WINAPI DSCImpl_AddRef(IDirectSoundCapture8 *iface)
 767 {
 768     DSCImpl *This = (DSCImpl*)iface;
 769     LONG ref;
 770
 771     ref = InterlockedIncrement(&This->ref);
 772     TRACE("Reference count incremented to %i\n", ref);
 773
 774     return ref;
 775 }
 776
 777 static ULONG WINAPI DSCImpl_Release(IDirectSoundCapture8 *iface)
 778 {
 779     DSCImpl *This = (DSCImpl*)iface;
 780     LONG ref;
 781
 782     ref = InterlockedDecrement(&This->ref);
 783     TRACE("Reference count decremented to %i\n", ref);
 784     if(!ref)
 785         DSCImpl_Destroy(This);
 786
 787     return ref;
 788 }
 789
 790 static HRESULT WINAPI DSCImpl_CreateCaptureBuffer(IDirectSoundCapture8 *iface, const DSCBUFFERDESC *desc, IDirectSoundCaptureBuffer **ppv, IUnknown *unk)
 791 {
 792     DSCImpl *This = (DSCImpl*)iface;
 793     HRESULT hr;
 794     TRACE("(%p)->(%p,%p,%p)\n", This, desc, ppv, unk);
 795
 796     if (unk)
 797     {
 798         WARN("Aggregation isn't supported\n");
 799         return DSERR_NOAGGREGATION;
 800     }
 801
 802     if (!desc || desc->dwSize < sizeof(DSCBUFFERDESC1))
 803     {
 804         WARN("Passed invalid description %p %u\n", desc, desc?desc->dwSize:0);
 805         return DSERR_INVALIDPARAM;
 806     }
 807     if (!ppv)
 808     {
 809         WARN("Passed null pointer\n");
 810         return DSERR_INVALIDPARAM;
 811     }
 812     *ppv = NULL;
 813
 814     EnterCriticalSection(&This->crst);
 815     if (!This->device)
 816     {
 817         hr = DSERR_UNINITIALIZED;
 818         WARN("Not initialized\n");
 819         goto out;
 820     }
 821     if (This->buf)
 822     {
 823         hr = DSERR_ALLOCATED;
 824         WARN("Capture buffer already allocated\n");
 825         goto out;
 826     }
 827
 828     hr = DSCBuffer_Create(&This->buf);
 829     if (SUCCEEDED(hr))
 830     {
 831         hr = IDirectSoundCaptureBuffer_Initialize((IDirectSoundCaptureBuffer*)This->buf, iface, desc);
 832         if (FAILED(hr))
 833         {
 834             DSCBuffer_Destroy(This->buf);
 835             This->buf = NULL;
 836         }
 837     }
 838     *ppv = (IDirectSoundCaptureBuffer*)This->buf;
 839 out:
 840     LeaveCriticalSection(&This->crst);
 841     return hr;
 842 }
 843
 844 static HRESULT WINAPI DSCImpl_GetCaps(IDirectSoundCapture8 *iface, DSCCAPS *caps)
 845 {
 846     DSCImpl *This = (DSCImpl*)iface;
 847     TRACE("(%p,%p)\n", This, caps);
 848
 849     if (!This->device) {
 850         WARN("Not initialized\n");
 851         return DSERR_UNINITIALIZED;
 852     }
 853
 854     if (!caps) {
 855         WARN("Caps is null\n");
 856         return DSERR_INVALIDPARAM;
 857     }
 858
 859     if (caps->dwSize < sizeof(*caps)) {
 860         WARN("Invalid size %d\n", caps->dwSize);
 861         return DSERR_INVALIDPARAM;
 862     }
 863
 864     caps->dwFlags = 0;
 865     /* Support all WAVE_FORMAT formats specified in mmsystem.h */
 866     caps->dwFormats = 0x000fffff;
 867     caps->dwChannels = 2;
 868
 869     return DS_OK;
 870 }
 871
 872 static HRESULT WINAPI DSCImpl_Initialize(IDirectSoundCapture8 *iface, const GUID *devguid)
 873 {
 874     DSCImpl *This = (DSCImpl*)iface;
 875     HRESULT hr;
 876     const ALCchar *devs, *drv_name;
 877     GUID guid;
 878     UINT n;
 879     TRACE("(%p,%p)\n", This, devguid);
 880
 881     if (!openal_loaded)
 882     {
 883         ERR("OpenAL not loaded!\n");
 884         return DSERR_NODRIVER;
 885     }
 886
 887     if (This->device) {
 888         WARN("Already initialized\n");
 889         return DSERR_ALREADYINITIALIZED;
 890     }
 891
 892     if (!devguid)
 893         devguid = &DSDEVID_DefaultCapture;
 894
 895     hr = GetDeviceID(devguid, &guid);
 896     if (FAILED(hr))
 897         return DSERR_INVALIDPARAM;
 898     devguid = &guid;
 899
 900     EnterCriticalSection(&This->crst);
 901     EnterCriticalSection(&openal_crst);
 902     devs = DSOUND_getcapturedevicestrings();
 903     n = guid.Data4[7];
 904
 905     hr = DSERR_NODRIVER;
 906     if(memcmp(devguid, &DSOUND_capture_guid, sizeof(GUID)-1) ||
 907        !devs || !*devs)
 908     {
 909         WARN("No driver found\n");
 910         goto out;
 911     }
 912
 913     if(n)
 914     {
 915         const ALCchar *str = devs;
 916         while (n--)
 917         {
 918             str += strlen(str) + 1;
 919             if (!*str)
 920             {
 921                 WARN("No driver string found\n");
 922                 goto out;
 923             }
 924         }
 925         drv_name = str;
 926     }
 927     else
 928         drv_name = devs;
 929
 930     This->device = HeapAlloc(GetProcessHeap(), 0, strlen(drv_name)+1);
 931     if (!This->device)
 932     {
 933         WARN("Out of memory to allocate %s\n", drv_name);
 934         goto out;
 935     }
 936     strcpy(This->device, drv_name);
 937
 938     hr = S_OK;
 939 out:
 940     LeaveCriticalSection(&openal_crst);
 941     LeaveCriticalSection(&This->crst);
 942     return hr;
 943 }
 944
 945 static const IDirectSoundCaptureVtbl DSC_Vtbl =
 946 {
 947     DSCImpl_QueryInterface,
 948     DSCImpl_AddRef,
 949     DSCImpl_Release,
 950     DSCImpl_CreateCaptureBuffer,
 951     DSCImpl_GetCaps,
 952     DSCImpl_Initialize
 953 };