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