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 typedef struct DSCImpl DSCImpl;
  62 typedef struct DSCBuffer DSCBuffer;
  63
  64 struct DSCImpl {
  65     /* IDirectSoundCapture and IDirectSoundCapture8 are aliases */
  66     IDirectSoundCapture IDirectSoundCapture_iface;
  67     LONG ref;
  68
  69     ALCchar *device;
  70     DSCBuffer *buf;
  71
  72     CRITICAL_SECTION crst;
  73 };
  74
  75 struct DSCBuffer {
  76     IDirectSoundCaptureBuffer8 IDirectSoundCaptureBuffer8_iface;
  77     IDirectSoundNotify IDirectSoundNotify_iface;
  78     LONG ref, not_ref;
  79     LONG all_ref;
  80
  81     DSCImpl *parent;
  82     ALCdevice *dev;
  83
  84     DWORD buf_size;
  85     BYTE *buf;
  86
  87     LONG locked;
  88
  89     WAVEFORMATEXTENSIBLE format;
  90
  91     DSBPOSITIONNOTIFY *notify;
  92     DWORD nnotify;
  93
  94     UINT timer_id;
  95     DWORD timer_res;
  96     HANDLE thread_hdl;
  97     DWORD thread_id;
  98
  99     DWORD pos;
 100     BOOL playing, looping;
 101 };
 102
 103 static const IDirectSoundCaptureVtbl DSC_Vtbl;
 104 static const IDirectSoundCaptureBuffer8Vtbl DSCBuffer_Vtbl;
 105 static const IDirectSoundNotifyVtbl DSCNot_Vtbl;
 106
 107 static void DSCImpl_Destroy(DSCImpl *This);
 108
 109 static void trigger_notifies(DSCBuffer *buf, DWORD lastpos, DWORD curpos)
 110 {
 111     DWORD i;
 112
 113     if(lastpos == curpos)
 114         return;
 115
 116     for(i = 0;i < buf->nnotify;++i)
 117     {
 118         DSBPOSITIONNOTIFY *not = &buf->notify[i];
 119         HANDLE event = not->hEventNotify;
 120         DWORD ofs = not->dwOffset;
 121
 122         if (ofs == DSCBPN_OFFSET_STOP)
 123             continue;
 124
 125         /* Wraparound case */
 126         if(curpos < lastpos)
 127         {
 128             if(ofs < curpos || ofs >= lastpos)
 129             {
 130                 TRACE("Triggering notification %"LONGFMT"u (%"LONGFMT"u) from buffer %p\n", i, ofs, buf);
 131                 SetEvent(event);
 132             }
 133             continue;
 134         }
 135
 136         /* Normal case */
 137         if(ofs >= lastpos && ofs < curpos)
 138         {
 139             TRACE("Triggering notification %"LONGFMT"u (%"LONGFMT"u) from buffer %p\n", i, ofs, buf);
 140             SetEvent(event);
 141         }
 142     }
 143 }
 144
 145 static DWORD CALLBACK DSCBuffer_thread(void *param)
 146 {
 147     DSCImpl *This = param;
 148     DSCBuffer *buf;
 149     ALCint avail;
 150     MSG msg;
 151
 152     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
 153
 154     while(GetMessageA(&msg, NULL, 0, 0))
 155     {
 156         if(msg.message != WM_USER)
 157             continue;
 158
 159         avail = 0;
 160         buf = This->buf;
 161         alcGetIntegerv(buf->dev, ALC_CAPTURE_SAMPLES, 1, &avail);
 162         if(avail == 0)
 163             continue;
 164
 165         EnterCriticalSection(&This->crst);
 166     more_samples:
 167         avail *= buf->format.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.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                 IDirectSoundCaptureBuffer8_Stop(&buf->IDirectSoundCaptureBuffer8_iface);
 180             else
 181             {
 182                 alcGetIntegerv(buf->dev, ALC_CAPTURE_SAMPLES, 1, &avail);
 183                 if(avail) goto more_samples;
 184             }
 185         }
 186
 187         LeaveCriticalSection(&This->crst);
 188     }
 189
 190     return 0;
 191 }
 192
 193
 194 static void CALLBACK DSCBuffer_timer(UINT timerID, UINT msg, DWORD_PTR dwUser,
 195                                      DWORD_PTR dw1, DWORD_PTR dw2)
 196 {
 197     (void)timerID;
 198     (void)msg;
 199     (void)dw1;
 200     (void)dw2;
 201     PostThreadMessageA(dwUser, WM_USER, 0, 0);
 202 }
 203
 204 static void DSCBuffer_starttimer(DSCBuffer *This)
 205 {
 206     TIMECAPS time;
 207     ALint refresh = FAKE_REFRESH_COUNT;
 208     DWORD triggertime, res = DS_TIME_RES;
 209
 210     if(This->timer_id)
 211         return;
 212
 213     timeGetDevCaps(&time, sizeof(TIMECAPS));
 214     triggertime = 1000 / refresh;
 215     if (triggertime < time.wPeriodMin)
 216         triggertime = time.wPeriodMin;
 217     TRACE("Calling timer every %"LONGFMT"u ms for %i refreshes per second\n", triggertime, refresh);
 218     if (res < time.wPeriodMin)
 219         res = time.wPeriodMin;
 220     if (timeBeginPeriod(res) == TIMERR_NOCANDO)
 221         WARN("Could not set minimum resolution, don't expect sound\n");
 222     This->timer_res = res;
 223     This->timer_id = timeSetEvent(triggertime, res, DSCBuffer_timer, This->thread_id, TIME_PERIODIC|TIME_KILL_SYNCHRONOUS);
 224 }
 225
 226 static HRESULT DSCBuffer_Create(DSCBuffer **buf, DSCImpl *parent)
 227 {
 228     DSCBuffer *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 229     if(!This) return E_OUTOFMEMORY;
 230
 231     This->IDirectSoundCaptureBuffer8_iface.lpVtbl = (IDirectSoundCaptureBuffer8Vtbl*)&DSCBuffer_Vtbl;
 232     This->IDirectSoundNotify_iface.lpVtbl = (IDirectSoundNotifyVtbl*)&DSCNot_Vtbl;
 233
 234     This->all_ref = This->ref = 1;
 235
 236     This->parent = parent;
 237
 238     This->thread_hdl = CreateThread(NULL, 0, DSCBuffer_thread, This->parent, 0, &This->thread_id);
 239     if(This->thread_hdl == NULL)
 240     {
 241         HeapFree(GetProcessHeap(), 0, This);
 242         return DSERR_OUTOFMEMORY;
 243     }
 244
 245     *buf = This;
 246     return S_OK;
 247 }
 248
 249 static void DSCBuffer_Destroy(DSCBuffer *This)
 250 {
 251     if(This->timer_id)
 252     {
 253         timeKillEvent(This->timer_id);
 254         timeEndPeriod(This->timer_res);
 255     }
 256     if(This->thread_hdl)
 257     {
 258         PostThreadMessageA(This->thread_id, WM_QUIT, 0, 0);
 259         if(WaitForSingleObject(This->thread_hdl, 1000) != WAIT_OBJECT_0)
 260             ERR("Thread wait timed out");
 261         CloseHandle(This->thread_hdl);
 262     }
 263
 264     if(This->dev)
 265     {
 266         if(This->playing)
 267             alcCaptureStop(This->dev);
 268         alcCaptureCloseDevice(This->dev);
 269     }
 270     This->parent->buf = NULL;
 271
 272     HeapFree(GetProcessHeap(), 0, This->notify);
 273     HeapFree(GetProcessHeap(), 0, This->buf);
 274     HeapFree(GetProcessHeap(), 0, This);
 275 }
 276
 277 static inline DSCBuffer *impl_from_IDirectSoundCaptureBuffer8(IDirectSoundCaptureBuffer8 *iface)
 278 {
 279     return CONTAINING_RECORD(iface, DSCBuffer, IDirectSoundCaptureBuffer8_iface);
 280 }
 281
 282 static HRESULT WINAPI DSCBuffer_QueryInterface(IDirectSoundCaptureBuffer8 *iface, REFIID riid, void **ppv)
 283 {
 284     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 285
 286     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 287
 288     if(!ppv)
 289         return E_POINTER;
 290     *ppv = NULL;
 291
 292     if (IsEqualIID(riid, &IID_IDirectSoundNotify))
 293         *ppv = &This->IDirectSoundNotify_iface;
 294     else if (IsEqualIID(riid, &IID_IUnknown) ||
 295              IsEqualIID(riid, &IID_IDirectSoundCaptureBuffer) ||
 296              IsEqualIID(riid, &IID_IDirectSoundCaptureBuffer8))
 297         *ppv = &This->IDirectSoundCaptureBuffer8_iface;
 298
 299     if (!*ppv)
 300         return E_NOINTERFACE;
 301     IUnknown_AddRef((IUnknown*)*ppv);
 302     return S_OK;
 303 }
 304
 305 static ULONG WINAPI DSCBuffer_AddRef(IDirectSoundCaptureBuffer8 *iface)
 306 {
 307     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 308     LONG ref;
 309
 310     InterlockedIncrement(&This->all_ref);
 311     ref = InterlockedIncrement(&This->ref);
 312     TRACE("Reference count incremented to %"LONGFMT"i\n", ref);
 313
 314     return ref;
 315 }
 316
 317 static ULONG WINAPI DSCBuffer_Release(IDirectSoundCaptureBuffer8 *iface)
 318 {
 319     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 320     LONG ref;
 321
 322     ref = InterlockedDecrement(&This->ref);
 323     TRACE("Reference count decremented to %"LONGFMT"i\n", ref);
 324     if(InterlockedDecrement(&This->all_ref) == 0)
 325         DSCBuffer_Destroy(This);
 326
 327     return ref;
 328 }
 329
 330 static HRESULT WINAPI DSCBuffer_GetCaps(IDirectSoundCaptureBuffer8 *iface, DSCBCAPS *caps)
 331 {
 332     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 333
 334     if (!caps || caps->dwSize < sizeof(*caps))
 335         return DSERR_INVALIDPARAM;
 336     caps->dwSize = sizeof(*caps);
 337     caps->dwFlags = 0;
 338     caps->dwBufferBytes = This->buf_size;
 339     return S_OK;
 340 }
 341
 342 static HRESULT WINAPI DSCBuffer_GetCurrentPosition(IDirectSoundCaptureBuffer8 *iface, DWORD *cappos, DWORD *readpos)
 343 {
 344     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 345     DWORD pos1, pos2;
 346
 347     EnterCriticalSection(&This->parent->crst);
 348     pos1 = This->pos;
 349     if(This->playing)
 350     {
 351         pos2 = This->format.Format.nSamplesPerSec / 100;
 352         pos2 *= This->format.Format.nBlockAlign;
 353         pos2 += pos1;
 354         if (!This->looping && pos2 >= This->buf_size)
 355             pos2 = 0;
 356         else
 357             pos2 %= This->buf_size;
 358     }
 359     else
 360         pos2 = pos1;
 361     LeaveCriticalSection(&This->parent->crst);
 362
 363     if(cappos) *cappos = pos1;
 364     if(readpos) *readpos = pos2;
 365
 366     return S_OK;
 367 }
 368
 369 static HRESULT WINAPI DSCBuffer_GetFormat(IDirectSoundCaptureBuffer8 *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
 370 {
 371     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 372     HRESULT hr = DS_OK;
 373     UINT size;
 374
 375     TRACE("(%p)->(%p, %"LONGFMT"u, %p)\n", iface, wfx, allocated, written);
 376
 377     if(!wfx && !written)
 378     {
 379         WARN("Cannot report format or format size\n");
 380         return DSERR_INVALIDPARAM;
 381     }
 382
 383     size = sizeof(This->format.Format) + This->format.Format.cbSize;
 384     if(wfx)
 385     {
 386         if(allocated < size)
 387             hr = DSERR_INVALIDPARAM;
 388         else
 389             memcpy(wfx, &This->format.Format, size);
 390     }
 391     if(written)
 392         *written = size;
 393
 394     return hr;
 395 }
 396
 397 static HRESULT WINAPI DSCBuffer_GetStatus(IDirectSoundCaptureBuffer8 *iface, DWORD *status)
 398 {
 399     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 400
 401     TRACE("(%p)->(%p)\n", iface, status);
 402
 403     if (!status)
 404         return DSERR_INVALIDPARAM;
 405     EnterCriticalSection(&This->parent->crst);
 406     *status = 0;
 407     if (This->playing)
 408     {
 409         *status |= DSCBSTATUS_CAPTURING;
 410         if (This->looping)
 411             *status |= DSCBSTATUS_LOOPING;
 412     }
 413     LeaveCriticalSection(&This->parent->crst);
 414
 415     return S_OK;
 416 }
 417
 418 static HRESULT WINAPI DSCBuffer_Initialize(IDirectSoundCaptureBuffer8 *iface, IDirectSoundCapture *parent, const DSCBUFFERDESC *desc)
 419 {
 420     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 421     WAVEFORMATEX *format;
 422     ALenum buf_format = -1;
 423
 424     TRACE("(%p)->(%p, %p)\n", iface, parent, desc);
 425
 426     if(This->dev)
 427         return DSERR_ALREADYINITIALIZED;
 428
 429     if (!desc->lpwfxFormat)
 430         return DSERR_INVALIDPARAM;
 431
 432     format = desc->lpwfxFormat;
 433     if(format->nChannels > 2)
 434     {
 435         WARN("nChannels > 2 not supported for recording\n");
 436         return DSERR_INVALIDPARAM;
 437     }
 438
 439     if(format->wFormatTag == WAVE_FORMAT_PCM)
 440     {
 441         if(format->nChannels == 1)
 442         {
 443             switch(format->wBitsPerSample)
 444             {
 445                 case 8: buf_format = AL_FORMAT_MONO8; break;
 446                 case 16: buf_format = AL_FORMAT_MONO16; break;
 447                 default:
 448                     WARN("Unsupported bpp %u\n", format->wBitsPerSample);
 449                     return DSERR_BADFORMAT;
 450             }
 451         }
 452         else if(format->nChannels == 2)
 453         {
 454             switch(format->wBitsPerSample)
 455             {
 456                 case 8: buf_format = AL_FORMAT_STEREO8; break;
 457                 case 16: buf_format = AL_FORMAT_STEREO16; break;
 458                 default:
 459                     WARN("Unsupported bpp %u\n", format->wBitsPerSample);
 460                     return DSERR_BADFORMAT;
 461             }
 462         }
 463         else
 464             WARN("Unsupported channels: %d\n", format->nChannels);
 465
 466         memcpy(&This->format.Format, format, sizeof(This->format.Format));
 467         This->format.Format.nBlockAlign = This->format.Format.wBitsPerSample * This->format.Format.nChannels / 8;
 468         This->format.Format.nAvgBytesPerSec = This->format.Format.nSamplesPerSec * This->format.Format.nBlockAlign;
 469         This->format.Format.cbSize = 0;
 470     }
 471     else if(format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 472     {
 473         WAVEFORMATEXTENSIBLE *wfe;
 474
 475         if(format->cbSize < sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX))
 476             return DSERR_INVALIDPARAM;
 477         else if(format->cbSize > sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX) &&
 478                 format->cbSize != sizeof(WAVEFORMATEXTENSIBLE))
 479             return DSERR_CONTROLUNAVAIL;
 480
 481         wfe = CONTAINING_RECORD(format, WAVEFORMATEXTENSIBLE, Format);
 482         if(!IsEqualGUID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 483             return DSERR_BADFORMAT;
 484         if(wfe->Samples.wValidBitsPerSample &&
 485            wfe->Samples.wValidBitsPerSample != wfe->Format.wBitsPerSample)
 486             return DSERR_BADFORMAT;
 487
 488         if(wfe->Format.nChannels == 1 && wfe->dwChannelMask == SPEAKER_FRONT_CENTER)
 489         {
 490             switch(wfe->Format.wBitsPerSample)
 491             {
 492                 case 8: buf_format = AL_FORMAT_MONO8; break;
 493                 case 16: buf_format = AL_FORMAT_MONO16; break;
 494                 default:
 495                     WARN("Unsupported bpp %u\n", wfe->Format.wBitsPerSample);
 496                     return DSERR_BADFORMAT;
 497             }
 498         }
 499         else if(wfe->Format.nChannels == 2 && wfe->dwChannelMask == (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT))
 500         {
 501             switch(wfe->Format.wBitsPerSample)
 502             {
 503                 case 8: buf_format = AL_FORMAT_STEREO8; break;
 504                 case 16: buf_format = AL_FORMAT_STEREO16; break;
 505                 default:
 506                     WARN("Unsupported bpp %u\n", wfe->Format.wBitsPerSample);
 507                     return DSERR_BADFORMAT;
 508             }
 509         }
 510         else
 511             WARN("Unsupported channels: %d -- 0x%08"LONGFMT"u\n", wfe->Format.nChannels, wfe->dwChannelMask);
 512
 513         memcpy(&This->format, wfe, sizeof(This->format));
 514         This->format.Format.cbSize = sizeof(This->format) - sizeof(This->format.Format);
 515         This->format.Format.nBlockAlign = This->format.Format.wBitsPerSample * This->format.Format.nChannels / 8;
 516         This->format.Format.nAvgBytesPerSec = This->format.Format.nSamplesPerSec * This->format.Format.nBlockAlign;
 517     }
 518     else
 519         WARN("Unhandled formattag %x\n", format->wFormatTag);
 520
 521     if(buf_format <= 0)
 522     {
 523         WARN("Could not get OpenAL format\n");
 524         return DSERR_INVALIDPARAM;
 525     }
 526
 527     This->buf_size = desc->dwBufferBytes;
 528     This->buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->buf_size);
 529     if(!This->buf)
 530     {
 531         WARN("Out of memory\n");
 532         return DSERR_INVALIDPARAM;
 533     }
 534
 535     This->dev = alcCaptureOpenDevice(This->parent->device, This->format.Format.nSamplesPerSec, buf_format, This->buf_size / This->format.Format.nBlockAlign);
 536     if(!This->dev)
 537     {
 538         ERR("Couldn't open device %s 0x%x@%"LONGFMT"u, reason: %04x\n", This->parent->device, buf_format, This->format.Format.nSamplesPerSec, alcGetError(NULL));
 539         return DSERR_INVALIDPARAM;
 540     }
 541
 542     return S_OK;
 543 }
 544
 545 static HRESULT WINAPI DSCBuffer_Lock(IDirectSoundCaptureBuffer8 *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
 546 {
 547     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 548     DWORD remain;
 549
 550     TRACE("(%p)->(%"LONGFMT"u, %"LONGFMT"u, %p, %p, %p, %p, %#"LONGFMT"x)\n", iface, ofs, bytes, ptr1, len1, ptr2, len2, flags);
 551
 552     if(!ptr1 || !len1)
 553     {
 554         WARN("Invalid pointer/len %p %p\n", ptr1, len1);
 555         return DSERR_INVALIDPARAM;
 556     }
 557
 558     *ptr1 = NULL;
 559     *len1 = 0;
 560     if(ptr2) *ptr2 = NULL;
 561     if(len2) *len2 = 0;
 562
 563     if(ofs >= This->buf_size)
 564     {
 565         WARN("Invalid ofs %"LONGFMT"u\n", ofs);
 566         return DSERR_INVALIDPARAM;
 567     }
 568
 569     if((flags&DSCBLOCK_ENTIREBUFFER))
 570         bytes = This->buf_size;
 571     else if(bytes > This->buf_size)
 572     {
 573         WARN("Invalid size %"LONGFMT"u\n", bytes);
 574         return DSERR_INVALIDPARAM;
 575     }
 576
 577     if(InterlockedExchange(&This->locked, TRUE) == TRUE)
 578     {
 579         WARN("Already locked\n");
 580         return DSERR_INVALIDPARAM;
 581     }
 582
 583     if(ofs + bytes >= This->buf_size)
 584     {
 585         *len1 = This->buf_size - ofs;
 586         remain = bytes - *len1;
 587     }
 588     else
 589     {
 590         *len1 = bytes;
 591         remain = 0;
 592     }
 593     *ptr1 = This->buf + ofs;
 594
 595     if(ptr2 && len2 && remain)
 596     {
 597         *ptr2 = This->buf;
 598         *len2 = remain;
 599     }
 600
 601     return DS_OK;
 602 }
 603
 604 static HRESULT WINAPI DSCBuffer_Start(IDirectSoundCaptureBuffer8 *iface, DWORD flags)
 605 {
 606     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 607
 608     TRACE("(%p)->(%08"LONGFMT"x)\n", iface, flags);
 609
 610     EnterCriticalSection(&This->parent->crst);
 611     if(!This->playing)
 612     {
 613         DSCBuffer_starttimer(This);
 614         This->playing = 1;
 615         alcCaptureStart(This->dev);
 616     }
 617     This->looping = !!(flags & DSCBSTART_LOOPING);
 618     LeaveCriticalSection(&This->parent->crst);
 619     return S_OK;
 620 }
 621
 622 static HRESULT WINAPI DSCBuffer_Stop(IDirectSoundCaptureBuffer8 *iface)
 623 {
 624     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 625
 626     TRACE("(%p)->()\n", iface);
 627
 628     EnterCriticalSection(&This->parent->crst);
 629     if(This->playing)
 630     {
 631         DWORD i;
 632         for(i = 0;i < This->nnotify;++i)
 633         {
 634             if(This->notify[i].dwOffset == DSCBPN_OFFSET_STOP)
 635                 SetEvent(This->notify[i].hEventNotify);
 636         }
 637
 638         This->playing = This->looping = 0;
 639         alcCaptureStop(This->dev);
 640     }
 641     LeaveCriticalSection(&This->parent->crst);
 642     return S_OK;
 643 }
 644
 645 static HRESULT WINAPI DSCBuffer_Unlock(IDirectSoundCaptureBuffer8 *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
 646 {
 647     DSCBuffer *This = impl_from_IDirectSoundCaptureBuffer8(iface);
 648     DWORD_PTR ofs1, ofs2;
 649     DWORD_PTR boundary = (DWORD_PTR)This->buf;
 650
 651     TRACE("(%p)->(%p, %"LONGFMT"u, %p, %"LONGFMT"u)\n", iface, ptr1, len1, ptr2, len2);
 652
 653     if(InterlockedExchange(&This->locked, FALSE) == FALSE)
 654     {
 655         WARN("Not locked\n");
 656         return DSERR_INVALIDPARAM;
 657     }
 658
 659     /* Make sure offset is between boundary and boundary + bufsize */
 660     ofs1 = (DWORD_PTR)ptr1;
 661     ofs2 = (DWORD_PTR)ptr2;
 662     if(ofs1 < boundary)
 663         return DSERR_INVALIDPARAM;
 664     if(ofs2 && ofs2 != boundary)
 665         return DSERR_INVALIDPARAM;
 666
 667     ofs1 -= boundary;
 668     ofs2 = 0;
 669     if(This->buf_size-ofs1 < len1 || len2 > ofs1)
 670         return DSERR_INVALIDPARAM;
 671
 672     return DS_OK;
 673 }
 674
 675 static HRESULT WINAPI DSCBuffer_GetObjectInPath(IDirectSoundCaptureBuffer8 *iface, REFGUID guid, DWORD num, REFGUID riid, void **ppv)
 676 {
 677     FIXME("(%p)->(%s, %"LONGFMT"u, %s, %p) stub\n", iface, debugstr_guid(guid), num, debugstr_guid(riid), ppv);
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI DSCBuffer_GetFXStatus(IDirectSoundCaptureBuffer8 *iface, DWORD count, DWORD *status)
 682 {
 683     FIXME("(%p)->(%"LONGFMT"u, %p) stub\n", iface, count, status);
 684     return E_NOTIMPL;
 685 }
 686
 687 static const IDirectSoundCaptureBuffer8Vtbl DSCBuffer_Vtbl =
 688 {
 689     DSCBuffer_QueryInterface,
 690     DSCBuffer_AddRef,
 691     DSCBuffer_Release,
 692     DSCBuffer_GetCaps,
 693     DSCBuffer_GetCurrentPosition,
 694     DSCBuffer_GetFormat,
 695     DSCBuffer_GetStatus,
 696     DSCBuffer_Initialize,
 697     DSCBuffer_Lock,
 698     DSCBuffer_Start,
 699     DSCBuffer_Stop,
 700     DSCBuffer_Unlock,
 701     DSCBuffer_GetObjectInPath,
 702     DSCBuffer_GetFXStatus
 703 };
 704
 705 static inline DSCBuffer *impl_from_IDirectSoundNotify(IDirectSoundNotify *iface)
 706 {
 707     return CONTAINING_RECORD(iface, DSCBuffer, IDirectSoundNotify_iface);
 708 }
 709
 710 static HRESULT WINAPI DSCBufferNot_QueryInterface(IDirectSoundNotify *iface, REFIID riid, void **ppv)
 711 {
 712     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 713     return IDirectSoundCaptureBuffer_QueryInterface((IDirectSoundCaptureBuffer*)This, riid, ppv);
 714 }
 715
 716 static ULONG WINAPI DSCBufferNot_AddRef(IDirectSoundNotify *iface)
 717 {
 718     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 719     LONG ret;
 720
 721     InterlockedIncrement(&This->all_ref);
 722     ret = InterlockedIncrement(&This->not_ref);
 723     TRACE("new refcount %"LONGFMT"d\n", ret);
 724     return ret;
 725 }
 726
 727 static ULONG WINAPI DSCBufferNot_Release(IDirectSoundNotify *iface)
 728 {
 729     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 730     LONG ret;
 731
 732     ret = InterlockedDecrement(&This->not_ref);
 733     TRACE("new refcount %"LONGFMT"d\n", ret);
 734     if(InterlockedDecrement(&This->all_ref) == 0)
 735         DSCBuffer_Destroy(This);
 736
 737     return ret;
 738 }
 739
 740 static HRESULT WINAPI DSCBufferNot_SetNotificationPositions(IDirectSoundNotify *iface, DWORD count, const DSBPOSITIONNOTIFY *notifications)
 741 {
 742     DSCBuffer *This = impl_from_IDirectSoundNotify(iface);
 743     DSBPOSITIONNOTIFY *nots;
 744     HRESULT hr;
 745     DWORD state;
 746
 747     TRACE("(%p)->(%"LONGFMT"u, %p))\n", iface, count, notifications);
 748
 749     EnterCriticalSection(&This->parent->crst);
 750     hr = DSERR_INVALIDPARAM;
 751     if (count && !notifications)
 752         goto out;
 753
 754     hr = DSCBuffer_GetStatus(&This->IDirectSoundCaptureBuffer8_iface, &state);
 755     if (FAILED(hr))
 756         goto out;
 757
 758     hr = DSERR_INVALIDCALL;
 759     if (state & DSCBSTATUS_CAPTURING)
 760         goto out;
 761
 762     if (!count)
 763     {
 764         HeapFree(GetProcessHeap(), 0, This->notify);
 765         This->notify = 0;
 766         This->nnotify = 0;
 767     }
 768     else
 769     {
 770         DWORD i;
 771         hr = DSERR_INVALIDPARAM;
 772         for (i = 0; i < count; ++i)
 773         {
 774             if (notifications[i].dwOffset >= This->buf_size
 775                 && notifications[i].dwOffset != DSCBPN_OFFSET_STOP)
 776                 goto out;
 777         }
 778         hr = E_OUTOFMEMORY;
 779         nots = HeapAlloc(GetProcessHeap(), 0, count*sizeof(*nots));
 780         if (!nots)
 781             goto out;
 782         memcpy(nots, notifications, count*sizeof(*nots));
 783         HeapFree(GetProcessHeap(), 0, This->notify);
 784         This->notify = nots;
 785         This->nnotify = count;
 786         hr = S_OK;
 787     }
 788
 789 out:
 790     LeaveCriticalSection(&This->parent->crst);
 791     return hr;
 792 }
 793
 794 static const IDirectSoundNotifyVtbl DSCNot_Vtbl =
 795 {
 796     DSCBufferNot_QueryInterface,
 797     DSCBufferNot_AddRef,
 798     DSCBufferNot_Release,
 799     DSCBufferNot_SetNotificationPositions
 800 };
 801
 802
 803 static inline DSCImpl *impl_from_IDirectSoundCapture(IDirectSoundCapture *iface)
 804 {
 805     return CONTAINING_RECORD(iface, DSCImpl, IDirectSoundCapture_iface);
 806 }
 807
 808 HRESULT DSOUND_CaptureCreate(REFIID riid, void **cap)
 809 {
 810     DSCImpl *This;
 811
 812     *cap = NULL;
 813
 814     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
 815     if(!This) return DSERR_OUTOFMEMORY;
 816
 817     This->IDirectSoundCapture_iface.lpVtbl = (IDirectSoundCaptureVtbl*)&DSC_Vtbl;
 818
 819     InitializeCriticalSection(&This->crst);
 820     This->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DSCImpl.crst");
 821
 822     if(FAILED(IDirectSoundCapture_QueryInterface(&This->IDirectSoundCapture_iface, riid, cap)))
 823     {
 824         DSCImpl_Destroy(This);
 825         return E_NOINTERFACE;
 826     }
 827     return S_OK;
 828 }
 829
 830 static void DSCImpl_Destroy(DSCImpl *This)
 831 {
 832     EnterCriticalSection(&This->crst);
 833     if (This->buf)
 834         DSCBuffer_Destroy(This->buf);
 835     LeaveCriticalSection(&This->crst);
 836
 837     HeapFree(GetProcessHeap(), 0, This->device);
 838
 839     This->crst.DebugInfo->Spare[0] = 0;
 840     DeleteCriticalSection(&This->crst);
 841
 842     HeapFree(GetProcessHeap(), 0, This);
 843 }
 844
 845 static HRESULT WINAPI DSCImpl_QueryInterface(IDirectSoundCapture *iface, REFIID riid, void **ppv)
 846 {
 847     DSCImpl *This = impl_from_IDirectSoundCapture(iface);
 848
 849     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 850
 851     *ppv = NULL;
 852     if(IsEqualIID(riid, &IID_IUnknown) ||
 853        IsEqualIID(riid, &IID_IDirectSoundCapture))
 854         *ppv = &This->IDirectSoundCapture_iface;
 855     else
 856         FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
 857
 858     if(*ppv)
 859     {
 860         IUnknown_AddRef((IUnknown*)*ppv);
 861         return S_OK;
 862     }
 863
 864     return E_NOINTERFACE;
 865 }
 866
 867 static ULONG WINAPI DSCImpl_AddRef(IDirectSoundCapture *iface)
 868 {
 869     DSCImpl *This = impl_from_IDirectSoundCapture(iface);
 870     LONG ref;
 871
 872     ref = InterlockedIncrement(&This->ref);
 873     TRACE("Reference count incremented to %"LONGFMT"i\n", ref);
 874
 875     return ref;
 876 }
 877
 878 static ULONG WINAPI DSCImpl_Release(IDirectSoundCapture *iface)
 879 {
 880     DSCImpl *This = impl_from_IDirectSoundCapture(iface);
 881     LONG ref;
 882
 883     ref = InterlockedDecrement(&This->ref);
 884     TRACE("Reference count decremented to %"LONGFMT"i\n", ref);
 885     if(!ref)
 886         DSCImpl_Destroy(This);
 887
 888     return ref;
 889 }
 890
 891 static HRESULT WINAPI DSCImpl_CreateCaptureBuffer(IDirectSoundCapture *iface, const DSCBUFFERDESC *desc, IDirectSoundCaptureBuffer **ppv, IUnknown *unk)
 892 {
 893     DSCImpl *This = impl_from_IDirectSoundCapture(iface);
 894     HRESULT hr;
 895
 896     TRACE("(%p)->(%p, %p, %p)\n", iface, desc, ppv, unk);
 897
 898     if(unk)
 899     {
 900         WARN("Aggregation isn't supported\n");
 901         return DSERR_NOAGGREGATION;
 902     }
 903
 904     if(!desc || desc->dwSize < sizeof(DSCBUFFERDESC1))
 905     {
 906         WARN("Passed invalid description %p %"LONGFMT"u\n", desc, desc?desc->dwSize:0);
 907         return DSERR_INVALIDPARAM;
 908     }
 909     if(!ppv)
 910     {
 911         WARN("Passed null pointer\n");
 912         return DSERR_INVALIDPARAM;
 913     }
 914     *ppv = NULL;
 915
 916     EnterCriticalSection(&This->crst);
 917     if(!This->device)
 918     {
 919         hr = DSERR_UNINITIALIZED;
 920         WARN("Not initialized\n");
 921         goto out;
 922     }
 923     if(This->buf)
 924     {
 925         hr = DSERR_ALLOCATED;
 926         WARN("Capture buffer already allocated\n");
 927         goto out;
 928     }
 929
 930     hr = DSCBuffer_Create(&This->buf, This);
 931     if(SUCCEEDED(hr))
 932     {
 933         hr = IDirectSoundCaptureBuffer8_Initialize(&This->buf->IDirectSoundCaptureBuffer8_iface, iface, desc);
 934         if(SUCCEEDED(hr))
 935             *ppv = (IDirectSoundCaptureBuffer*)&This->buf->IDirectSoundCaptureBuffer8_iface;
 936         else
 937         {
 938             DSCBuffer_Destroy(This->buf);
 939             This->buf = NULL;
 940         }
 941     }
 942
 943 out:
 944     LeaveCriticalSection(&This->crst);
 945     return hr;
 946 }
 947
 948 static HRESULT WINAPI DSCImpl_GetCaps(IDirectSoundCapture *iface, DSCCAPS *caps)
 949 {
 950     DSCImpl *This = impl_from_IDirectSoundCapture(iface);
 951
 952     TRACE("(%p)->(%p)\n", iface, caps);
 953
 954     if(!This->device) {
 955         WARN("Not initialized\n");
 956         return DSERR_UNINITIALIZED;
 957     }
 958
 959     if(!caps) {
 960         WARN("Caps is null\n");
 961         return DSERR_INVALIDPARAM;
 962     }
 963     if(caps->dwSize < sizeof(*caps)) {
 964         WARN("Invalid size %"LONGFMT"d\n", caps->dwSize);
 965         return DSERR_INVALIDPARAM;
 966     }
 967
 968     caps->dwFlags = 0;
 969     /* Support all WAVE_FORMAT formats specified in mmsystem.h */
 970     caps->dwFormats = 0x000fffff;
 971     caps->dwChannels = 2;
 972
 973     return DS_OK;
 974 }
 975
 976 static HRESULT WINAPI DSCImpl_Initialize(IDirectSoundCapture *iface, const GUID *devguid)
 977 {
 978     DSCImpl *This = impl_from_IDirectSoundCapture(iface);
 979     HRESULT hr;
 980     const ALCchar *devs, *drv_name;
 981     GUID guid;
 982     UINT n;
 983
 984     TRACE("(%p)->(%p)\n", iface, devguid);
 985
 986     if(!openal_loaded)
 987     {
 988         ERR("OpenAL not loaded!\n");
 989         return DSERR_NODRIVER;
 990     }
 991
 992     if(This->device) {
 993         WARN("Already initialized\n");
 994         return DSERR_ALREADYINITIALIZED;
 995     }
 996
 997     if(!devguid || IsEqualGUID(devguid, &GUID_NULL))
 998         devguid = &DSDEVID_DefaultCapture;
 999
1000     hr = GetDeviceID(devguid, &guid);
1001     if (FAILED(hr))
1002         return DSERR_INVALIDPARAM;
1003     devguid = &guid;
1004
1005     EnterCriticalSection(&This->crst);
1006     EnterCriticalSection(&openal_crst);
1007     devs = DSOUND_getcapturedevicestrings();
1008     n = guid.Data4[7];
1009
1010     hr = DSERR_NODRIVER;
1011     if(memcmp(devguid, &DSOUND_capture_guid, sizeof(GUID)-1) ||
1012        !devs || !*devs)
1013     {
1014         WARN("No driver found\n");
1015         goto out;
1016     }
1017
1018     if(n)
1019     {
1020         const ALCchar *str = devs;
1021         while (n--)
1022         {
1023             str += strlen(str) + 1;
1024             if (!*str)
1025             {
1026                 WARN("No driver string found\n");
1027                 goto out;
1028             }
1029         }
1030         drv_name = str;
1031     }
1032     else
1033         drv_name = devs;
1034
1035     This->device = HeapAlloc(GetProcessHeap(), 0, strlen(drv_name)+1);
1036     if(!This->device)
1037     {
1038         WARN("Out of memory to allocate %s\n", drv_name);
1039         goto out;
1040     }
1041     strcpy(This->device, drv_name);
1042
1043     hr = S_OK;
1044 out:
1045     LeaveCriticalSection(&openal_crst);
1046     LeaveCriticalSection(&This->crst);
1047     return hr;
1048 }
1049
1050 static const IDirectSoundCaptureVtbl DSC_Vtbl =
1051 {
1052     DSCImpl_QueryInterface,
1053     DSCImpl_AddRef,
1054     DSCImpl_Release,
1055     DSCImpl_CreateCaptureBuffer,
1056     DSCImpl_GetCaps,
1057     DSCImpl_Initialize
1058 };