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