One step closer to getting hardware accelerated capture working.
diff --git a/dlls/winmm/wineoss/dscapture.c b/dlls/winmm/wineoss/dscapture.c
index cfc7c84..e93b050 100644
--- a/dlls/winmm/wineoss/dscapture.c
+++ b/dlls/winmm/wineoss/dscapture.c
@@ -54,7 +54,7 @@
#include "audio.h"
-WINE_DEFAULT_DEBUG_CHANNEL(wave);
+WINE_DEFAULT_DEBUG_CHANNEL(dscapture);
#ifdef HAVE_OSS
@@ -104,11 +104,16 @@
/* IDsCaptureDriverBufferImpl fields */
IDsCaptureDriverImpl* drv;
- DWORD buflen;
- LPBYTE buffer;
- DWORD writeptr;
- LPBYTE mapping;
- DWORD maplen;
+ LPBYTE buffer; /* user buffer */
+ DWORD buflen; /* user buffer length */
+ LPBYTE mapping; /* DMA buffer */
+ DWORD maplen; /* DMA buffer length */
+ BOOL is_direct_map; /* DMA == user ? */
+ DWORD fragsize;
+ DWORD map_writepos; /* DMA write offset */
+ DWORD map_readpos; /* DMA read offset */
+ DWORD writeptr; /* user write offset */
+ DWORD readptr; /* user read offset */
/* IDsDriverNotifyImpl fields */
IDsCaptureDriverNotifyImpl* notify;
@@ -121,6 +126,13 @@
BOOL is_capturing;
BOOL is_looping;
+ WAVEFORMATEX wfx;
+ HANDLE hThread;
+ DWORD dwThreadID;
+ HANDLE hStartUpEvent;
+ HANDLE hExitEvent;
+ int pipe_fd[2];
+ int fd;
};
static HRESULT WINAPI IDsCaptureDriverPropertySetImpl_Create(
@@ -297,7 +309,7 @@
return DSERR_INVALIDPARAM;
}
- if (TRACE_ON(wave)) {
+ if (TRACE_ON(dscapture)) {
int i;
for (i=0;i<howmuch;i++)
TRACE("notify at %ld to 0x%08lx\n",
@@ -343,7 +355,8 @@
dscdb, strerror(errno));
return DSERR_GENERIC;
}
- TRACE("(%p): sound device has been mapped for direct access at %p, size=%ld\n", dscdb, dscdb->mapping, dscdb->maplen);
+ TRACE("(%p): sound device has been mapped for direct access at %p, "
+ "size=%ld\n", dscdb, dscdb->mapping, dscdb->maplen);
}
return DS_OK;
}
@@ -421,7 +434,31 @@
ref = InterlockedDecrement(&(This->ref));
if (ref == 0) {
+ WINE_WAVEIN* wwi;
+
+ wwi = &WInDev[This->drv->wDevID];
+
+ if (This->hThread) {
+ int x = 0;
+
+ /* request thread termination */
+ write(This->pipe_fd[1], &x, sizeof(x));
+
+ /* wait for reply */
+ WaitForSingleObject(This->hExitEvent, INFINITE);
+ CloseHandle(This->hExitEvent);
+ }
+
+ close(This->pipe_fd[0]);
+ close(This->pipe_fd[1]);
+
DSCDB_UnmapBuffer(This);
+
+ OSS_CloseDevice(wwi->ossdev);
+ wwi->state = WINE_WS_CLOSED;
+ wwi->dwFragmentSize = 0;
+ This->drv->capture_buffer = NULL;
+
if (This->notifies != NULL)
HeapFree(GetProcessHeap(), 0, This->notifies);
HeapFree(GetProcessHeap(),0,This);
@@ -441,8 +478,49 @@
DWORD dwFlags)
{
IDsCaptureDriverBufferImpl *This = (IDsCaptureDriverBufferImpl *)iface;
- FIXME("(%p,%p,%p,%p,%p,%ld,%ld,0x%08lx): stub!\n",This,ppvAudio1,pdwLen1,
+ TRACE("(%p,%p,%p,%p,%p,%ld,%ld,0x%08lx)\n",This,ppvAudio1,pdwLen1,
ppvAudio2,pdwLen2,dwWritePosition,dwWriteLen,dwFlags);
+
+ if (This->is_direct_map) {
+ if (ppvAudio1)
+ *ppvAudio1 = This->mapping + dwWritePosition;
+
+ if (dwWritePosition + dwWriteLen < This->maplen) {
+ if (pdwLen1)
+ *pdwLen1 = dwWriteLen;
+ if (ppvAudio2)
+ *ppvAudio2 = 0;
+ if (pdwLen2)
+ *pdwLen2 = 0;
+ } else {
+ if (pdwLen1)
+ *pdwLen1 = This->maplen - dwWritePosition;
+ if (ppvAudio2)
+ *ppvAudio2 = 0;
+ if (pdwLen2)
+ *pdwLen2 = dwWriteLen - (This->maplen - dwWritePosition);
+ }
+ } else {
+ if (ppvAudio1)
+ *ppvAudio1 = This->buffer + dwWritePosition;
+
+ if (dwWritePosition + dwWriteLen < This->buflen) {
+ if (pdwLen1)
+ *pdwLen1 = dwWriteLen;
+ if (ppvAudio2)
+ *ppvAudio2 = 0;
+ if (pdwLen2)
+ *pdwLen2 = 0;
+ } else {
+ if (pdwLen1)
+ *pdwLen1 = This->buflen - dwWritePosition;
+ if (ppvAudio2)
+ *ppvAudio2 = 0;
+ if (pdwLen2)
+ *pdwLen2 = dwWriteLen - (This->buflen - dwWritePosition);
+ }
+ }
+
return DS_OK;
}
@@ -454,7 +532,13 @@
DWORD dwLen2)
{
IDsCaptureDriverBufferImpl *This = (IDsCaptureDriverBufferImpl *)iface;
- FIXME("(%p,%p,%ld,%p,%ld): stub!\n",This,pvAudio1,dwLen1,pvAudio2,dwLen2);
+ TRACE("(%p,%p,%ld,%p,%ld)\n",This,pvAudio1,dwLen1,pvAudio2,dwLen2);
+
+ if (This->is_direct_map)
+ This->map_readpos = (This->map_readpos + dwLen1 + dwLen2) % This->maplen;
+ else
+ This->readptr = (This->readptr + dwLen1 + dwLen2) % This->buflen;
+
return DS_OK;
}
@@ -464,8 +548,6 @@
LPDWORD lpdwRead)
{
IDsCaptureDriverBufferImpl *This = (IDsCaptureDriverBufferImpl *)iface;
- count_info info;
- DWORD ptr;
TRACE("(%p,%p,%p)\n",This,lpdwCapture,lpdwRead);
if (WInDev[This->drv->wDevID].state == WINE_WS_CLOSED) {
@@ -480,23 +562,21 @@
*lpdwRead = 0;
}
- if (ioctl(WInDev[This->drv->wDevID].ossdev->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
- ERR("ioctl(%s, SNDCTL_DSP_GETIPTR) failed (%s)\n",
- WInDev[This->drv->wDevID].ossdev->dev_name, strerror(errno));
- return DSERR_GENERIC;
+ if (This->is_direct_map) {
+ if (lpdwCapture)
+ *lpdwCapture = This->map_writepos;
+ if (lpdwRead) {
+ *lpdwRead = This->map_readpos;
+ }
+ } else {
+ if (lpdwCapture)
+ *lpdwCapture = This->writeptr;
+ if (lpdwRead)
+ *lpdwRead = This->readptr;
}
- ptr = info.ptr & ~3; /* align the pointer, just in case */
- if (lpdwCapture) *lpdwCapture = ptr;
- if (lpdwRead) {
- /* add some safety margin (not strictly necessary, but...) */
- if (WInDev[This->drv->wDevID].ossdev->in_caps_support & WAVECAPS_SAMPLEACCURATE)
- *lpdwRead = ptr + 32;
- else
- *lpdwRead = ptr + WInDev[This->drv->wDevID].dwFragmentSize;
- while (*lpdwRead > This->buflen)
- *lpdwRead -= This->buflen;
- }
- TRACE("capturepos=%ld, readpos=%ld\n", lpdwCapture?*lpdwCapture:0, lpdwRead?*lpdwRead:0);
+
+ TRACE("capturepos=%ld, readpos=%ld\n", lpdwCapture?*lpdwCapture:0,
+ lpdwRead?*lpdwRead:0);
return DS_OK;
}
@@ -588,11 +668,16 @@
This->is_capturing = FALSE;
This->is_looping = FALSE;
- /* Most OSS drivers just can't stop capturing without closing the device...
- * so we need to somehow signal to our DirectSound implementation
- * that it should completely recreate this HW buffer...
- * this unexpected error code should do the trick... */
- return DSERR_BUFFERLOST;
+ if (This->hThread) {
+ int x = 0;
+ write(This->pipe_fd[1], &x, sizeof(x));
+ WaitForSingleObject(This->hExitEvent, INFINITE);
+ CloseHandle(This->hExitEvent);
+ This->hExitEvent = INVALID_HANDLE_VALUE;
+ This->hThread = 0;
+ }
+
+ return DS_OK;
}
static HRESULT WINAPI IDsCaptureDriverBufferImpl_SetFormat(
@@ -677,7 +762,6 @@
/* copy version from driver */
memcpy(pDesc, &(WInDev[This->wDevID].ossdev->ds_desc), sizeof(DSDRIVERDESC));
- pDesc->dwFlags |= DSDDESC_USESYSTEMMEMORY;
pDesc->dnDevNode = WInDev[This->wDevID].waveDesc.dnDevNode;
pDesc->wVxdId = 0;
pDesc->wReserved = 0;
@@ -720,6 +804,167 @@
return DS_OK;
}
+static void DSCDB_CheckEvent(
+ IDsCaptureDriverBufferImpl *dscb,
+ DWORD writepos,
+ DWORD len,
+ DWORD buflen)
+{
+ LPDSBPOSITIONNOTIFY event = dscb->notifies + dscb->notify_index;
+ DWORD offset = event->dwOffset;
+ TRACE("(%p,%ld,%ld,%ld)\n", dscb, writepos, len, buflen);
+
+ TRACE("(%p) buflen = %ld, writeptr = %ld\n",
+ dscb, dscb->buflen, dscb->writeptr);
+ TRACE("checking %d, position %ld, event = %p\n",
+ dscb->notify_index, offset, event->hEventNotify);
+
+ if ((writepos + len) > offset) {
+ TRACE("signalled event %p (%d) %ld\n",
+ event->hEventNotify, dscb->notify_index, offset);
+ SetEvent(event->hEventNotify);
+ dscb->notify_index = (dscb->notify_index + 1) % dscb->nrofnotifies;
+ return;
+ } else if ((writepos + len) > buflen) {
+ writepos = writepos + len - buflen;
+ if ((writepos + len) > offset) {
+ TRACE("signalled event %p (%d) %ld\n",
+ event->hEventNotify, dscb->notify_index, offset);
+ SetEvent(event->hEventNotify);
+ dscb->notify_index = (dscb->notify_index + 1) % dscb->nrofnotifies;
+ return;
+ }
+ }
+
+ return;
+}
+
+/* FIXME: using memcpy can cause strange crashes so use this fake one */
+static void * my_memcpy(void * dst, const void * src, int length)
+{
+ int i;
+ for (i = 0; i < length; i++)
+ ((char *)dst)[i] = ((char *)src)[i];
+ return dst;
+}
+
+static DWORD CALLBACK DSCDB_Thread(LPVOID lpParameter)
+{
+ IDsCaptureDriverBufferImpl *This = (IDsCaptureDriverBufferImpl *)lpParameter;
+ struct pollfd poll_list[2];
+ int retval;
+ DWORD offset = 0;
+ DWORD map_offset = 0;
+ TRACE("(%p)\n", lpParameter);
+
+ poll_list[0].fd = This->fd; /* data available */
+ poll_list[1].fd = This->pipe_fd[0]; /* message from parent process */
+ poll_list[0].events = POLLIN;
+ poll_list[1].events = POLLIN;
+
+ /* let other process know we are running */
+ SetEvent(This->hStartUpEvent);
+
+ while (1) {
+ /* wait for something to happen */
+ retval = poll(poll_list,(unsigned long)2,-1);
+ /* Retval will always be greater than 0 or -1 in this case.
+ * Since we're doing it while blocking
+ */
+ if (retval < 0) {
+ ERR("Error while polling: %s\n",strerror(errno));
+ continue;
+ }
+
+ /* check for exit command */
+ if ((poll_list[1].revents & POLLIN) == POLLIN) {
+ TRACE("(%p) done\n", lpParameter);
+ /* acknowledge command and exit */
+ SetEvent(This->hExitEvent);
+ ExitThread(0);
+ return 0;
+ }
+
+ /* check for data */
+ if ((poll_list[0].revents & POLLIN) == POLLIN) {
+ count_info info;
+ int fragsize, first, second;
+
+ /* get the current DMA position */
+ if (ioctl(This->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
+ ERR("ioctl(%s, SNDCTL_DSP_GETIPTR) failed (%s)\n",
+ WInDev[This->drv->wDevID].ossdev->dev_name, strerror(errno));
+ return DSERR_GENERIC;
+ }
+
+ if (This->is_direct_map) {
+ offset = This->map_writepos;
+ This->map_writepos = info.ptr;
+
+ if (info.ptr < offset)
+ fragsize = info.ptr + This->maplen - offset;
+ else
+ fragsize = info.ptr - offset;
+
+ DSCDB_CheckEvent(This, offset, fragsize, This->maplen);
+ } else {
+ map_offset = This->map_writepos;
+ offset = This->writeptr;
+
+ /* test for mmap buffer wrap */
+ if (info.ptr < map_offset) {
+ /* mmap buffer wrapped */
+ fragsize = info.ptr + This->maplen - map_offset;
+
+ /* check for user buffer wrap */
+ if ((offset + fragsize) > This->buflen) {
+ /* both buffers wrapped
+ * figure out which wrapped first
+ */
+ if ((This->maplen - map_offset) > (This->buflen - offset)) {
+ /* user buffer wrapped first */
+ first = This->buflen - offset;
+ second = (This->maplen - map_offset) - first;
+ my_memcpy(This->buffer + offset, This->mapping + map_offset, first);
+ my_memcpy(This->buffer, This->mapping + map_offset + first, second);
+ my_memcpy(This->buffer + second, This->mapping, fragsize - (first + second));
+ } else {
+ /* mmap buffer wrapped first */
+ first = This->maplen - map_offset;
+ second = (This->buflen - offset) - first;
+ my_memcpy(This->buffer + offset, This->mapping + map_offset, first);
+ my_memcpy(This->buffer + offset + first, This->mapping, second);
+ my_memcpy(This->buffer, This->mapping + second, fragsize - (first + second));
+ }
+ } else {
+ /* only mmap buffer wrapped */
+ first = This->maplen - map_offset;
+ my_memcpy(This->buffer + offset, This->mapping + map_offset, first);
+ my_memcpy(This->buffer + offset + first, This->mapping, fragsize - first);
+ }
+ } else {
+ /* mmap buffer didn't wrap */
+ fragsize = info.ptr - map_offset;
+
+ /* check for user buffer wrap */
+ if ((offset + fragsize) > This->buflen) {
+ first = This->buflen - offset;
+ my_memcpy(This->buffer + offset, This->mapping + map_offset, first);
+ my_memcpy(This->buffer, This->mapping + map_offset + first, fragsize - first);
+ } else
+ my_memcpy(This->buffer + offset, This->mapping + map_offset, fragsize);
+ }
+
+ This->map_writepos = info.ptr;
+ This->writeptr = (This->writeptr + fragsize) % This->buflen;
+ DSCDB_CheckEvent(This, offset, fragsize, This->buflen);
+ }
+ }
+ }
+
+ return TRUE;
+}
+
static HRESULT WINAPI IDsCaptureDriverImpl_CreateCaptureBuffer(
PIDSCDRIVER iface,
LPWAVEFORMATEX pwfx,
@@ -733,7 +978,9 @@
IDsCaptureDriverBufferImpl** ippdscdb = (IDsCaptureDriverBufferImpl**)ppvObj;
HRESULT err;
audio_buf_info info;
- int enable;
+ int audio_fragment, fsize, shift, ret;
+ BOOL bNewBuffer = FALSE;
+ WINE_WAVEIN* wwi;
TRACE("(%p,%p,%lx,%lx,%p,%p,%p)\n",This,pwfx,dwFlags,dwCardAddress,
pdwcbBufferSize,ppbBuffer,ppvObj);
@@ -742,13 +989,32 @@
return DSERR_ALLOCATED;
}
- *ippdscdb = (IDsCaptureDriverBufferImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDsCaptureDriverBufferImpl));
+ /* must be given a buffer size */
+ if (pdwcbBufferSize == NULL || *pdwcbBufferSize == 0) {
+ TRACE("invalid parameter: pdwcbBufferSize\n");
+ return DSERR_INVALIDPARAM;
+ }
+
+ /* must be given a buffer pointer */
+ if (ppbBuffer == NULL) {
+ TRACE("invalid parameter: ppbBuffer\n");
+ return DSERR_INVALIDPARAM;
+ }
+
+ /* may or may not be given a buffer */
+ if (*ppbBuffer == NULL) {
+ TRACE("creating buffer\n");
+ bNewBuffer = TRUE; /* not given a buffer so create one */
+ } else
+ TRACE("using supplied buffer\n");
+
+ *ippdscdb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDsCaptureDriverBufferImpl));
if (*ippdscdb == NULL) {
TRACE("out of memory\n");
return DSERR_OUTOFMEMORY;
}
- (*ippdscdb)->lpVtbl = &dscdbvt;
+ (*ippdscdb)->lpVtbl = &dscdbvt;
(*ippdscdb)->ref = 1;
(*ippdscdb)->drv = This;
(*ippdscdb)->notify = NULL;
@@ -758,55 +1024,192 @@
(*ippdscdb)->property_set = NULL;
(*ippdscdb)->is_capturing = FALSE;
(*ippdscdb)->is_looping = FALSE;
+ (*ippdscdb)->wfx = *pwfx;
+ (*ippdscdb)->buflen = *pdwcbBufferSize;
- if (WInDev[This->wDevID].state == WINE_WS_CLOSED) {
- WAVEOPENDESC desc;
- desc.hWave = 0;
- desc.lpFormat = pwfx;
- desc.dwCallback = 0;
- desc.dwInstance = 0;
- desc.uMappedDeviceID = 0;
- desc.dnDevNode = 0;
- err = widOpen(This->wDevID, &desc, dwFlags | WAVE_DIRECTSOUND);
- if (err != MMSYSERR_NOERROR) {
- TRACE("widOpen failed\n");
- return err;
+ if (bNewBuffer)
+ (*ippdscdb)->buffer = NULL;
+ else
+ (*ippdscdb)->buffer = *ppbBuffer;
+
+ wwi = &WInDev[This->wDevID];
+
+ if (wwi->state == WINE_WS_CLOSED) {
+ unsigned int frag_size;
+
+ if (wwi->ossdev->open_count > 0) {
+ /* opened already so use existing fragment size */
+ audio_fragment = wwi->ossdev->audio_fragment;
+ } else {
+ /* calculate a fragment size */
+ unsigned int mask = 0xffffffff;
+
+ /* calculate largest fragment size less than 10 ms. */
+ fsize = pwfx->nAvgBytesPerSec / 100; /* 10 ms chunk */
+ shift = 0;
+ while ((1 << shift) <= fsize)
+ shift++;
+ shift--;
+ fsize = 1 << shift;
+ TRACE("shift = %d, fragment size = %d\n", shift, fsize);
+ TRACE("BufferSize=%ld(%08lx)\n", *pdwcbBufferSize, *pdwcbBufferSize);
+
+ /* See if we can directly map the buffer first.
+ * (buffer length is multiple of a power of 2)
+ */
+ mask = (mask >> (32 - shift));
+ TRACE("mask=%08x\n", mask);
+ if (*pdwcbBufferSize & mask) {
+ /* no so try a smaller fragment size greater than 1 ms */
+ int new_shift = shift - 1;
+ int min_shift = 0;
+ int min_fsize = pwfx->nAvgBytesPerSec / 1000;
+ BOOL found_one = FALSE;
+ while ((1 << min_shift) <= min_fsize)
+ min_shift++;
+ min_shift--;
+ while (new_shift > min_shift) {
+ if (*pdwcbBufferSize & (-1 >> (32 - new_shift))) {
+ new_shift--;
+ continue;
+ } else {
+ found_one = TRUE;
+ break;
+ }
+ }
+ if (found_one) {
+ /* found a smaller one that will work */
+ audio_fragment = ((*pdwcbBufferSize >> new_shift) << 16) | new_shift;
+ (*ippdscdb)->is_direct_map = TRUE;
+ TRACE("new shift = %d, fragment size = %d\n",
+ new_shift, 1 << (audio_fragment & 0xffff));
+ } else {
+ /* buffer can't be direct mapped */
+ audio_fragment = 0x00100000 + shift; /* 16 fragments of 2^shift */
+ (*ippdscdb)->is_direct_map = FALSE;
+ }
+ } else {
+ /* good fragment size */
+ audio_fragment = ((*pdwcbBufferSize >> shift) << 16) | shift;
+ (*ippdscdb)->is_direct_map = TRUE;
+ }
+ }
+ frag_size = 1 << (audio_fragment & 0xffff);
+ TRACE("is_direct_map = %s\n", (*ippdscdb)->is_direct_map ? "TRUE" : "FALSE");
+ TRACE("requesting %d %d byte fragments (%d bytes) (%ld ms/fragment)\n",
+ audio_fragment >> 16, frag_size, frag_size * (audio_fragment >> 16),
+ (frag_size * 1000) / pwfx->nAvgBytesPerSec);
+
+ ret = OSS_OpenDevice(wwi->ossdev, O_RDWR, &audio_fragment, 1,
+ pwfx->nSamplesPerSec,
+ (pwfx->nChannels > 1) ? 1 : 0,
+ (pwfx->wBitsPerSample == 16)
+ ? AFMT_S16_LE : AFMT_U8);
+
+ if (ret != 0) {
+ WARN("OSS_OpenDevice failed\n");
+ HeapFree(GetProcessHeap(),0,*ippdscdb);
+ *ippdscdb = NULL;
+ return DSERR_GENERIC;
+ }
+
+ wwi->state = WINE_WS_STOPPED;
+
+ /* find out what fragment and buffer sizes OSS gave us */
+ if (ioctl(wwi->ossdev->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
+ ERR("ioctl(%s, SNDCTL_DSP_GETISPACE) failed (%s)\n",
+ wwi->ossdev->dev_name, strerror(errno));
+ OSS_CloseDevice(wwi->ossdev);
+ wwi->state = WINE_WS_CLOSED;
+ HeapFree(GetProcessHeap(),0,*ippdscdb);
+ *ippdscdb = NULL;
+ return DSERR_GENERIC;
+ }
+
+ TRACE("got %d %d byte fragments (%d bytes) (%ld ms/fragment)\n",
+ info.fragstotal, info.fragsize, info.fragstotal * info.fragsize,
+ info.fragsize * 1000 / pwfx->nAvgBytesPerSec);
+
+ wwi->dwTotalRecorded = 0;
+ memcpy(&wwi->waveFormat, pwfx, sizeof(PCMWAVEFORMAT));
+ wwi->dwFragmentSize = info.fragsize;
+
+ /* make sure we got what we asked for */
+ if ((*ippdscdb)->buflen != info.fragstotal * info.fragsize) {
+ TRACE("Couldn't create requested buffer\n");
+ if ((*ippdscdb)->is_direct_map) {
+ (*ippdscdb)->is_direct_map = FALSE;
+ TRACE("is_direct_map = FALSE\n");
+ }
+ } else if (info.fragsize != frag_size) {
+ TRACE("same buffer length but different fragment size\n");
}
}
+ (*ippdscdb)->fd = WInDev[This->wDevID].ossdev->fd;
- /* check how big the DMA buffer is now */
- if (ioctl(WInDev[This->wDevID].ossdev->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
- ERR("ioctl(%s, SNDCTL_DSP_GETISPACE) failed (%s)\n",
- WInDev[This->wDevID].ossdev->dev_name, strerror(errno));
+ if (pipe((*ippdscdb)->pipe_fd) < 0) {
+ TRACE("pipe() failed (%s)\n", strerror(errno));
+ OSS_CloseDevice(wwi->ossdev);
+ wwi->state = WINE_WS_CLOSED;
HeapFree(GetProcessHeap(),0,*ippdscdb);
*ippdscdb = NULL;
return DSERR_GENERIC;
}
- (*ippdscdb)->maplen = (*ippdscdb)->buflen = info.fragstotal * info.fragsize;
+
+ /* check how big the DMA buffer is now */
+ if (ioctl(wwi->ossdev->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
+ ERR("ioctl(%s, SNDCTL_DSP_GETISPACE) failed (%s)\n",
+ wwi->ossdev->dev_name, strerror(errno));
+ OSS_CloseDevice(wwi->ossdev);
+ wwi->state = WINE_WS_CLOSED;
+ close((*ippdscdb)->pipe_fd[0]);
+ close((*ippdscdb)->pipe_fd[1]);
+ HeapFree(GetProcessHeap(),0,*ippdscdb);
+ *ippdscdb = NULL;
+ return DSERR_GENERIC;
+ }
+
+ (*ippdscdb)->maplen = info.fragstotal * info.fragsize;
+ (*ippdscdb)->fragsize = info.fragsize;
+ (*ippdscdb)->map_writepos = 0;
+ (*ippdscdb)->map_readpos = 0;
/* map the DMA buffer */
err = DSCDB_MapBuffer(*ippdscdb);
if (err != DS_OK) {
+ OSS_CloseDevice(wwi->ossdev);
+ wwi->state = WINE_WS_CLOSED;
+ close((*ippdscdb)->pipe_fd[0]);
+ close((*ippdscdb)->pipe_fd[1]);
HeapFree(GetProcessHeap(),0,*ippdscdb);
*ippdscdb = NULL;
return err;
}
- /* capture buffer is ready to go */
- *pdwcbBufferSize = (*ippdscdb)->maplen;
- *ppbBuffer = (*ippdscdb)->mapping;
+ /* create the buffer if necessary */
+ if (!(*ippdscdb)->buffer)
+ (*ippdscdb)->buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,(*ippdscdb)->buflen);
- /* some drivers need some extra nudging after mapping */
- WInDev[This->wDevID].ossdev->bInputEnabled = FALSE;
- enable = getEnables(WInDev[This->wDevID].ossdev);
- if (ioctl(WInDev[This->wDevID].ossdev->fd, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
- ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n",
- WInDev[This->wDevID].ossdev->dev_name, strerror(errno));
- return DSERR_GENERIC;
+ if ((*ippdscdb)->buffer == NULL) {
+ OSS_CloseDevice(wwi->ossdev);
+ wwi->state = WINE_WS_CLOSED;
+ close((*ippdscdb)->pipe_fd[0]);
+ close((*ippdscdb)->pipe_fd[1]);
+ HeapFree(GetProcessHeap(),0,*ippdscdb);
+ *ippdscdb = NULL;
+ return DSERR_OUTOFMEMORY;
}
This->capture_buffer = *ippdscdb;
+ (*ippdscdb)->hStartUpEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+ (*ippdscdb)->hExitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+
+ (*ippdscdb)->hThread = CreateThread(NULL, 0, DSCDB_Thread, (LPVOID)(*ippdscdb), 0, &((*ippdscdb)->dwThreadID));
+ WaitForSingleObject((*ippdscdb)->hStartUpEvent, INFINITE);
+ CloseHandle((*ippdscdb)->hStartUpEvent);
+ (*ippdscdb)->hStartUpEvent = INVALID_HANDLE_VALUE;
+
return DS_OK;
}
