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