| /* DirectSoundCapture |
| * |
| * Copyright 1998 Marcus Meissner |
| * Copyright 1998 Rob Riggs |
| * Copyright 2000-2001 TransGaming Technologies, Inc. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| /* |
| * TODO: |
| * Implement DirectSoundCapture API |
| */ |
| |
| #include "config.h" |
| #include <assert.h> |
| #include <stdio.h> |
| #include <sys/types.h> |
| #include <sys/fcntl.h> |
| #ifdef HAVE_UNISTD_H |
| # include <unistd.h> |
| #endif |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wingdi.h" |
| #include "winuser.h" |
| #include "winerror.h" |
| #include "mmsystem.h" |
| #include "mmddk.h" |
| #include "winternl.h" |
| #include "winnls.h" |
| #include "wine/debug.h" |
| #include "dsound.h" |
| #include "dsdriver.h" |
| #include "dsound_private.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(dsound); |
| |
| static HRESULT WINAPI IDirectSoundCaptureImpl_Initialize( |
| LPDIRECTSOUNDCAPTURE iface, |
| LPCGUID lpcGUID ); |
| static HRESULT DSOUND_CreateDirectSoundCaptureBuffer( |
| IDirectSoundCaptureImpl *ipDSC, |
| LPCDSCBUFFERDESC lpcDSCBufferDesc, |
| LPVOID* ppobj ); |
| |
| static ICOM_VTABLE(IDirectSoundCapture) dscvt; |
| static ICOM_VTABLE(IDirectSoundCaptureBuffer8) dscbvt; |
| |
| |
| /*************************************************************************** |
| * DirectSoundCaptureCreate [DSOUND.6] |
| * |
| * Create and initialize a DirectSoundCapture interface |
| * |
| * RETURNS |
| * Success: DS_OK |
| * Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM, |
| * DSERR_OUTOFMEMORY |
| */ |
| HRESULT WINAPI |
| DirectSoundCaptureCreate8( |
| LPCGUID lpcGUID, |
| LPDIRECTSOUNDCAPTURE* lplpDSC, |
| LPUNKNOWN pUnkOuter ) |
| { |
| TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), lplpDSC, pUnkOuter); |
| |
| if ( pUnkOuter ) { |
| TRACE("pUnkOuter != 0\n"); |
| return DSERR_NOAGGREGATION; |
| } |
| |
| if ( !lplpDSC ) { |
| TRACE("invalid parameter: lplpDSC == NULL\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| /* Default device? */ |
| if ( !lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL) || |
| IsEqualGUID(lpcGUID, &DSDEVID_DefaultCapture) || |
| IsEqualGUID(lpcGUID, &DSDEVID_DefaultVoiceCapture) ) { |
| IDirectSoundCaptureImpl** ippDSC=(IDirectSoundCaptureImpl**)lplpDSC; |
| |
| *ippDSC = (IDirectSoundCaptureImpl*)HeapAlloc(GetProcessHeap(), |
| HEAP_ZERO_MEMORY, sizeof(IDirectSoundCaptureImpl)); |
| |
| if (*ippDSC == NULL) { |
| TRACE("couldn't allocate memory\n"); |
| return DSERR_OUTOFMEMORY; |
| } |
| else |
| { |
| ICOM_THIS(IDirectSoundCaptureImpl, *ippDSC); |
| |
| This->ref = 1; |
| This->state = STATE_STOPPED; |
| |
| if (lpcGUID) |
| This->guid = *lpcGUID; |
| else |
| This->guid = GUID_NULL; |
| |
| InitializeCriticalSection( &(This->lock) ); |
| |
| ICOM_VTBL(This) = &dscvt; |
| |
| /* FIXME: should this be defered because we can't return no driver ? */ |
| return IDirectSoundCaptureImpl_Initialize( (LPDIRECTSOUNDCAPTURE)This, lpcGUID ); |
| } |
| } |
| |
| FIXME( "Unknown GUID %s\n", debugstr_guid(lpcGUID) ); |
| *lplpDSC = NULL; |
| |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| /*************************************************************************** |
| * DirectSoundCaptureEnumerateA [DSOUND.7] |
| * |
| * Enumerate all DirectSound drivers installed in the system |
| * |
| * RETURNS |
| * Success: DS_OK |
| * Failure: DSERR_INVALIDPARAM |
| */ |
| HRESULT WINAPI |
| DirectSoundCaptureEnumerateA( |
| LPDSENUMCALLBACKA lpDSEnumCallback, |
| LPVOID lpContext) |
| { |
| WAVEINCAPSA wcaps; |
| unsigned devs, wid; |
| |
| TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext ); |
| |
| if (lpDSEnumCallback == NULL) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| devs = waveInGetNumDevs(); |
| for (wid = 0; wid < devs; ++wid) { |
| waveInGetDevCapsA(wid, &wcaps, sizeof(wcaps)); |
| if (lpDSEnumCallback) { |
| lpDSEnumCallback(NULL, "WINE Sound Capture Driver", |
| wcaps.szPname ,lpContext); |
| return DS_OK; |
| } |
| } |
| |
| return DS_OK; |
| } |
| |
| /*************************************************************************** |
| * DirectSoundCaptureEnumerateW [DSOUND.8] |
| * |
| * Enumerate all DirectSound drivers installed in the system |
| * |
| * RETURNS |
| * Success: DS_OK |
| * Failure: DSERR_INVALIDPARAM |
| */ |
| HRESULT WINAPI |
| DirectSoundCaptureEnumerateW( |
| LPDSENUMCALLBACKW lpDSEnumCallback, |
| LPVOID lpContext) |
| { |
| WAVEINCAPSW wcaps; |
| unsigned devs, wid; |
| WCHAR desc[MAXPNAMELEN]; |
| |
| TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext ); |
| |
| if (lpDSEnumCallback == NULL) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| devs = waveInGetNumDevs(); |
| for (wid = 0; wid < devs; ++wid) { |
| waveInGetDevCapsW(wid, &wcaps, sizeof(wcaps)); |
| if (lpDSEnumCallback) { |
| MultiByteToWideChar( CP_ACP, 0, "WINE Sound Capture Driver", -1, |
| desc, sizeof(desc)/sizeof(WCHAR) ); |
| lpDSEnumCallback(NULL, desc, wcaps.szPname ,lpContext); |
| return DS_OK; |
| } |
| } |
| |
| return DS_OK; |
| } |
| |
| static void CALLBACK |
| DSOUND_capture_callback( |
| HWAVEIN hwi, |
| UINT msg, |
| DWORD dwUser, |
| DWORD dw1, |
| DWORD dw2 ) |
| { |
| IDirectSoundCaptureImpl* This = (IDirectSoundCaptureImpl*)dwUser; |
| TRACE("entering at %ld, msg=%08x\n", GetTickCount(), msg); |
| |
| if (msg == MM_WIM_DATA) { |
| This->index = (This->index + 1) % This->capture_buffer->nrofnotifies; |
| waveInUnprepareHeader(hwi,&(This->pwave[This->index]),sizeof(WAVEHDR)); |
| SetEvent(This->capture_buffer->notifies[This->index].hEventNotify); |
| waveInPrepareHeader(hwi,&(This->pwave[This->index]),sizeof(WAVEHDR)); |
| waveInAddBuffer(hwi, &(This->pwave[This->index]), sizeof(WAVEHDR)); |
| } |
| |
| TRACE("completed\n"); |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureImpl_QueryInterface( |
| LPDIRECTSOUNDCAPTURE iface, |
| REFIID riid, |
| LPVOID* ppobj ) |
| { |
| ICOM_THIS(IDirectSoundCaptureImpl,iface); |
| TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj ); |
| |
| if (This->driver) |
| return IDsCaptureDriver_QueryInterface(This->driver, riid, ppobj); |
| |
| return E_FAIL; |
| } |
| |
| static ULONG WINAPI |
| IDirectSoundCaptureImpl_AddRef( LPDIRECTSOUNDCAPTURE iface ) |
| { |
| ULONG uRef; |
| ICOM_THIS(IDirectSoundCaptureImpl,iface); |
| |
| EnterCriticalSection( &This->lock ); |
| |
| TRACE( "(%p) was 0x%08lx\n", This, This->ref ); |
| uRef = ++(This->ref); |
| |
| if (This->driver) |
| IDsCaptureDriver_AddRef(This->driver); |
| |
| LeaveCriticalSection( &This->lock ); |
| |
| return uRef; |
| } |
| |
| static ULONG WINAPI |
| IDirectSoundCaptureImpl_Release( LPDIRECTSOUNDCAPTURE iface ) |
| { |
| ULONG uRef; |
| ICOM_THIS(IDirectSoundCaptureImpl,iface); |
| |
| EnterCriticalSection( &This->lock ); |
| |
| TRACE( "(%p) was 0x%08lx\n", This, This->ref ); |
| uRef = --(This->ref); |
| |
| LeaveCriticalSection( &This->lock ); |
| |
| if ( uRef == 0 ) { |
| TRACE("deleting object\n"); |
| if (This->capture_buffer) |
| IDirectSoundCaptureBuffer8_Release( |
| (LPDIRECTSOUNDCAPTUREBUFFER8)This->capture_buffer); |
| |
| if (This->driver) |
| IDsDriver_Close(This->driver); |
| |
| if (This->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) |
| waveInClose(This->hwi); |
| |
| if (This->driver) |
| IDsDriver_Release(This->driver); |
| |
| DeleteCriticalSection( &This->lock ); |
| HeapFree( GetProcessHeap(), 0, This ); |
| } |
| |
| return uRef; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureImpl_CreateCaptureBuffer( |
| LPDIRECTSOUNDCAPTURE iface, |
| LPCDSCBUFFERDESC lpcDSCBufferDesc, |
| LPDIRECTSOUNDCAPTUREBUFFER* lplpDSCaptureBuffer, |
| LPUNKNOWN pUnk ) |
| { |
| HRESULT hr; |
| ICOM_THIS(IDirectSoundCaptureImpl,iface); |
| |
| TRACE( "(%p,%p,%p,%p)\n", This, lpcDSCBufferDesc, lplpDSCaptureBuffer, |
| pUnk ); |
| |
| if ( (This == NULL) || (lpcDSCBufferDesc== NULL) || |
| (lplpDSCaptureBuffer == NULL) || pUnk ) { |
| TRACE("invalid parameters\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| /* FIXME: We can only have one buffer so what do we do here? */ |
| if (This->capture_buffer) { |
| TRACE("already has buffer\n"); |
| return DSERR_INVALIDPARAM; /* DSERR_GENERIC ? */ |
| } |
| |
| hr = DSOUND_CreateDirectSoundCaptureBuffer( This, lpcDSCBufferDesc, |
| (LPVOID*)lplpDSCaptureBuffer ); |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureImpl_GetCaps( |
| LPDIRECTSOUNDCAPTURE iface, |
| LPDSCCAPS lpDSCCaps ) |
| { |
| ICOM_THIS(IDirectSoundCaptureImpl,iface); |
| TRACE("(%p,%p)\n",This,lpDSCCaps); |
| |
| if ( (lpDSCCaps== NULL) || (lpDSCCaps->dwSize != sizeof(*lpDSCCaps)) ) { |
| TRACE("invalid parameters\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if ( !(This->initialized) ) { |
| TRACE("not initialized\n"); |
| return DSERR_UNINITIALIZED; |
| } |
| |
| if ( (This->driver = 0) || (This->hwi == 0) ) { |
| TRACE("no driver\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| lpDSCCaps->dwFlags = This->drvcaps.dwFlags; |
| lpDSCCaps->dwFormats = This->formats; |
| lpDSCCaps->dwChannels = This->channels; |
| |
| TRACE("(flags=0x%08lx,format=0x%08lx,channels=%ld)\n",lpDSCCaps->dwFlags, |
| lpDSCCaps->dwFormats, lpDSCCaps->dwChannels); |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureImpl_Initialize( |
| LPDIRECTSOUNDCAPTURE iface, |
| LPCGUID lpcGUID ) |
| { |
| HRESULT err = DS_OK; |
| unsigned wid, widn; |
| ICOM_THIS(IDirectSoundCaptureImpl,iface); |
| TRACE("(%p)\n", This); |
| |
| if (!This) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (This->initialized) { |
| TRACE("already initialized\n"); |
| return DSERR_ALREADYINITIALIZED; |
| } |
| |
| widn = waveInGetNumDevs(); |
| |
| if (!widn) { |
| TRACE("no audio devices found\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| /* FIXME: should enumerate WINMM audio devices and find the one we want */ |
| wid = 0; |
| |
| err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD)&(This->driver),0)); |
| if ( (err != DS_OK) && (err != DSERR_UNSUPPORTED) ) { |
| TRACE("waveInMessage failed; err=%lx\n",err); |
| return err; |
| } |
| err = DS_OK; |
| |
| /* Get driver description */ |
| if (This->driver) { |
| TRACE("using DirectSound driver\n"); |
| IDsDriver_GetDriverDesc(This->driver, &(This->drvdesc)); |
| } else { |
| TRACE("using WINMM\n"); |
| /* if no DirectSound interface available, use WINMM API instead */ |
| This->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | |
| DSDDESC_DOMMSYSTEMSETFORMAT; |
| This->drvdesc.dnDevNode = wid; /* FIXME? */ |
| } |
| |
| /* If the driver requests being opened through MMSYSTEM |
| * (which is recommended by the DDK), it is supposed to happen |
| * before the DirectSound interface is opened */ |
| if (This->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) |
| { |
| /* FIXME: is this right? */ |
| This->drvdesc.dnDevNode = 0; |
| |
| #if 0 /* this returns an uninitialized structure so don't use */ |
| /* query the wave format */ |
| err = mmErr(waveInOpen(NULL, This->drvdesc.dnDevNode, &(This->wfx), |
| 0, 0, WAVE_FORMAT_QUERY)); |
| #else |
| /* Set default wave format for waveInOpen */ |
| This->wfx.wFormatTag = WAVE_FORMAT_PCM; |
| /* We rely on the sound driver to return the actual sound format of |
| * the device if it does not support 22050x8x2 and is given the |
| * WAVE_DIRECTSOUND flag. |
| */ |
| This->wfx.nSamplesPerSec = 22050; |
| This->wfx.wBitsPerSample = 8; |
| This->wfx.nChannels = 2; |
| This->wfx.nBlockAlign = This->wfx.wBitsPerSample * |
| This->wfx.nChannels / 8; |
| This->wfx.nAvgBytesPerSec = This->wfx.nSamplesPerSec * |
| This->wfx.nBlockAlign; |
| This->wfx.cbSize = 0; |
| #endif |
| err = mmErr(waveInOpen(&(This->hwi), |
| This->drvdesc.dnDevNode, &(This->wfx), |
| (DWORD)DSOUND_capture_callback, (DWORD)This, |
| CALLBACK_FUNCTION | WAVE_DIRECTSOUND)); |
| } |
| |
| /* open the DirectSound driver if available */ |
| if (This->driver && (err == DS_OK)) |
| err = IDsDriver_Open(This->driver); |
| |
| if (err == DS_OK) { |
| This->initialized = TRUE; |
| |
| /* the driver is now open, so it's now allowed to call GetCaps */ |
| if (This->driver) { |
| IDsDriver_GetCaps(This->driver,&(This->drvcaps)); |
| } else if (This->hwi) { |
| WAVEINCAPSA wic; |
| err = mmErr(waveInGetDevCapsA((UINT)This->hwi, &wic, sizeof(wic))); |
| |
| if (err == DS_OK) { |
| This->drvcaps.dwFlags = 0; |
| strncpy(This->drvdesc.szDrvName, wic.szPname, |
| sizeof(This->drvdesc.szDrvName)); |
| |
| This->formats = wic.dwFormats; |
| This->channels = wic.wChannels; |
| |
| if (ds_emuldriver) |
| This->drvcaps.dwFlags |= DSCCAPS_EMULDRIVER; |
| } |
| } else { |
| TRACE("no audio devices found\n"); |
| return DSERR_NODRIVER; |
| } |
| } |
| |
| return err; |
| } |
| |
| static ICOM_VTABLE(IDirectSoundCapture) dscvt = |
| { |
| ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE |
| /* IUnknown methods */ |
| IDirectSoundCaptureImpl_QueryInterface, |
| IDirectSoundCaptureImpl_AddRef, |
| IDirectSoundCaptureImpl_Release, |
| |
| /* IDirectSoundCapture methods */ |
| IDirectSoundCaptureImpl_CreateCaptureBuffer, |
| IDirectSoundCaptureImpl_GetCaps, |
| IDirectSoundCaptureImpl_Initialize |
| }; |
| |
| static HRESULT |
| DSOUND_CreateDirectSoundCaptureBuffer( |
| IDirectSoundCaptureImpl *ipDSC, |
| LPCDSCBUFFERDESC lpcDSCBufferDesc, |
| LPVOID* ppobj ) |
| { |
| LPWAVEFORMATEX wfex; |
| TRACE( "(%p,%p)\n", lpcDSCBufferDesc, ppobj ); |
| |
| if ( (ipDSC == NULL) || (lpcDSCBufferDesc == NULL) || (ppobj == NULL) ) { |
| TRACE("invalid parameters\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if ( (lpcDSCBufferDesc->dwSize < sizeof(DSCBUFFERDESC)) || |
| (lpcDSCBufferDesc->dwBufferBytes == 0) || |
| (lpcDSCBufferDesc->lpwfxFormat == NULL) ) { |
| TRACE("invalid lpcDSCBufferDesc\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if ( !ipDSC->initialized ) { |
| TRACE("not initialized\n"); |
| |
| return DSERR_UNINITIALIZED; |
| } |
| |
| if ( (ipDSC->driver == 0) && (ipDSC->hwi == 0) ) { |
| TRACE("no driver\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| wfex = lpcDSCBufferDesc->lpwfxFormat; |
| |
| if (wfex) { |
| TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld," |
| "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n", |
| wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec, |
| wfex->nAvgBytesPerSec, wfex->nBlockAlign, |
| wfex->wBitsPerSample, wfex->cbSize); |
| |
| if (wfex->cbSize == 0) |
| memcpy(&(ipDSC->wfx), wfex, sizeof(*wfex) + wfex->cbSize); |
| else { |
| ERR("non PCM formats not supported\n"); |
| return DSERR_BADFORMAT; /* FIXME: DSERR_INVALIDPARAM ? */ |
| } |
| } else { |
| TRACE("lpcDSCBufferDesc->lpwfxFormat == 0\n"); |
| return DSERR_INVALIDPARAM; /* FIXME: DSERR_BADFORMAT ? */ |
| } |
| |
| *ppobj = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, |
| sizeof(IDirectSoundCaptureBufferImpl)); |
| |
| if ( *ppobj == NULL ) { |
| TRACE("out of memory\n"); |
| return DSERR_OUTOFMEMORY; |
| } else { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,*ppobj); |
| |
| This->ref = 1; |
| This->dsound = ipDSC; |
| This->dsound->capture_buffer = This; |
| |
| This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, |
| lpcDSCBufferDesc->dwSize); |
| if (This->pdscbd) |
| memcpy(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize); |
| else { |
| TRACE("no memory\n"); |
| This->dsound->capture_buffer = 0; |
| HeapFree( GetProcessHeap(), 0, This ); |
| *ppobj = NULL; |
| return DSERR_OUTOFMEMORY; |
| } |
| |
| ICOM_VTBL(This) = &dscbvt; |
| |
| InitializeCriticalSection( &This->lock ); |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_QueryInterface( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| REFIID riid, |
| LPVOID* ppobj ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj ); |
| |
| if (IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) { |
| IDirectSoundNotifyImpl *dsn; |
| |
| dsn = (IDirectSoundNotifyImpl*)HeapAlloc(GetProcessHeap(),0, |
| sizeof(*dsn)); |
| dsn->ref = 1; |
| dsn->dsb = 0; |
| dsn->dscb = This; |
| IDirectSoundCaptureBuffer8_AddRef(iface); |
| ICOM_VTBL(dsn) = &dsnvt; |
| *ppobj = (LPVOID)dsn; |
| return DS_OK; |
| } |
| |
| FIXME("(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj); |
| |
| return E_FAIL; |
| } |
| |
| static ULONG WINAPI |
| IDirectSoundCaptureBufferImpl_AddRef( LPDIRECTSOUNDCAPTUREBUFFER8 iface ) |
| { |
| ULONG uRef; |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p)\n", This ); |
| |
| EnterCriticalSection( &This->lock ); |
| |
| TRACE( "(%p) was 0x%08lx\n", This, This->ref ); |
| uRef = ++(This->ref); |
| |
| LeaveCriticalSection( &This->lock ); |
| |
| return uRef; |
| } |
| |
| static ULONG WINAPI |
| IDirectSoundCaptureBufferImpl_Release( LPDIRECTSOUNDCAPTUREBUFFER8 iface ) |
| { |
| ULONG uRef; |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p)\n", This ); |
| |
| EnterCriticalSection( &This->lock ); |
| |
| TRACE( "(%p) was 0x%08lx\n", This, This->ref ); |
| uRef = --(This->ref); |
| |
| LeaveCriticalSection( &This->lock ); |
| |
| if ( uRef == 0 ) { |
| if (This->pdscbd) |
| HeapFree(GetProcessHeap(),0, This->pdscbd); |
| |
| /* remove from IDirectSoundCaptureImpl */ |
| if (This->dsound) |
| This->dsound->capture_buffer = NULL; |
| else |
| ERR("does not reference dsound\n"); |
| |
| if (This->notifies) |
| HeapFree(GetProcessHeap(),0, This->notifies); |
| |
| DeleteCriticalSection( &This->lock ); |
| HeapFree( GetProcessHeap(), 0, This ); |
| } |
| |
| return uRef; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_GetCaps( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| LPDSCBCAPS lpDSCBCaps ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,%p)\n", This, lpDSCBCaps ); |
| |
| if ( (This == NULL) || (lpDSCBCaps == NULL) ) { |
| TRACE("invalid parameters\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if ( (lpDSCBCaps->dwSize < sizeof(DSCBCAPS)) || (This->dsound == NULL) ) { |
| TRACE("invalid parameters\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| lpDSCBCaps->dwSize = sizeof(DSCBCAPS); |
| lpDSCBCaps->dwFlags = This->flags; |
| lpDSCBCaps->dwBufferBytes = This->pdscbd->dwBufferBytes; |
| lpDSCBCaps->dwReserved = 0; |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_GetCurrentPosition( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| LPDWORD lpdwCapturePosition, |
| LPDWORD lpdwReadPosition ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,%p,%p)\n", This, lpdwCapturePosition, lpdwReadPosition ); |
| |
| if ( (This == NULL) || (This->dsound == NULL) || |
| (lpdwReadPosition == NULL) ) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (This->dsound->driver) { |
| FIXME( "(%p,%p,%p): direct sound driver not supported\n", |
| This, lpdwCapturePosition, lpdwReadPosition ); |
| return DSERR_NODRIVER; |
| } else if (This->dsound->hwi) { |
| if (lpdwCapturePosition) { |
| MMTIME mtime; |
| mtime.wType = TIME_BYTES; |
| waveInGetPosition(This->dsound->hwi, &mtime, sizeof(mtime)); |
| mtime.u.cb = mtime.u.cb % This->dsound->buflen; |
| *lpdwCapturePosition = mtime.u.cb; |
| } |
| |
| if (lpdwReadPosition) { |
| if (This->dsound->state == STATE_STARTING) { |
| This->dsound->read_position = *lpdwCapturePosition; |
| This->dsound->state = STATE_CAPTURING; |
| } |
| *lpdwReadPosition = This->dsound->read_position; |
| } |
| } else { |
| TRACE("no driver\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_GetFormat( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| LPWAVEFORMATEX lpwfxFormat, |
| DWORD dwSizeAllocated, |
| LPDWORD lpdwSizeWritten ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,%p,0x%08lx,%p)\n", This, lpwfxFormat, dwSizeAllocated, |
| lpdwSizeWritten ); |
| |
| if ( (This == NULL) || (This->dsound == NULL) ) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| /* FIXME: use real size for extended formats someday */ |
| if (dwSizeAllocated > sizeof(This->dsound->wfx)) |
| dwSizeAllocated = sizeof(This->dsound->wfx); |
| if (lpwfxFormat) { /* NULL is valid (just want size) */ |
| memcpy(lpwfxFormat,&(This->dsound->wfx),dwSizeAllocated); |
| if (lpdwSizeWritten) |
| *lpdwSizeWritten = dwSizeAllocated; |
| } else { |
| if (lpdwSizeWritten) |
| *lpdwSizeWritten = sizeof(This->dsound->wfx); |
| else { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_GetStatus( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| LPDWORD lpdwStatus ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p, %p)\n", This, lpdwStatus ); |
| |
| if ( (This == NULL ) || (This->dsound == NULL) || (lpdwStatus == NULL) ) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| *lpdwStatus = 0; |
| if ((This->dsound->state == STATE_STARTING) || |
| (This->dsound->state == STATE_CAPTURING)) { |
| *lpdwStatus |= DSCBSTATUS_CAPTURING; |
| if (This->flags & DSCBSTART_LOOPING) |
| *lpdwStatus |= DSCBSTATUS_LOOPING; |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_Initialize( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| LPDIRECTSOUNDCAPTURE lpDSC, |
| LPCDSCBUFFERDESC lpcDSCBDesc ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| |
| FIXME( "(%p,%p,%p): stub\n", This, lpDSC, lpcDSCBDesc ); |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_Lock( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| DWORD dwReadCusor, |
| DWORD dwReadBytes, |
| LPVOID* lplpvAudioPtr1, |
| LPDWORD lpdwAudioBytes1, |
| LPVOID* lplpvAudioPtr2, |
| LPDWORD lpdwAudioBytes2, |
| DWORD dwFlags ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,%08lu,%08lu,%p,%p,%p,%p,0x%08lx)\n", This, dwReadCusor, |
| dwReadBytes, lplpvAudioPtr1, lpdwAudioBytes1, lplpvAudioPtr2, |
| lpdwAudioBytes2, dwFlags ); |
| |
| if ( (This == NULL) || (This->dsound == NULL) || (lplpvAudioPtr1 == NULL) || |
| (lpdwAudioBytes1 == NULL) || (lplpvAudioPtr2 == NULL) || |
| (lpdwAudioBytes2 == NULL) ) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (This->dsound->driver) { |
| FIXME("direct sound driver not supported\n"); |
| return DSERR_INVALIDCALL; /* DSERR_NODRIVER ? */ |
| } else if (This->dsound->hwi) { |
| *lplpvAudioPtr1 = This->dsound->buffer + dwReadCusor; |
| if ( (dwReadCusor + dwReadBytes) > This->dsound->buflen) { |
| *lpdwAudioBytes1 = This->dsound->buflen - dwReadCusor; |
| *lplpvAudioPtr2 = This->dsound->buffer; |
| *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1; |
| } else { |
| *lpdwAudioBytes1 = dwReadBytes; |
| *lplpvAudioPtr2 = 0; |
| *lpdwAudioBytes2 = 0; |
| } |
| } else { |
| TRACE("invalid call\n"); |
| return DSERR_INVALIDCALL; /* DSERR_NODRIVER ? */ |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_Start( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| DWORD dwFlags ) |
| { |
| HRESULT err = DS_OK; |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,0x%08lx)\n", This, dwFlags ); |
| |
| if ( (This == NULL) || (dwFlags != DSCBSTART_LOOPING) || |
| (This->dsound == NULL) ) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if ( (This->dsound->driver == 0) && (This->dsound->hwi == 0) ) { |
| TRACE("no driver\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| EnterCriticalSection(&(This->lock)); |
| |
| This->flags = dwFlags; |
| if (This->dsound->state == STATE_STOPPED) |
| This->dsound->state = STATE_STARTING; |
| else if (This->dsound->state == STATE_STOPPING) |
| This->dsound->state = STATE_CAPTURING; |
| |
| if (This->dsound->driver) { |
| FIXME("direct sound driver not supported\n"); |
| LeaveCriticalSection(&(This->lock)); |
| return DSERR_NODRIVER; |
| } else { |
| LPBYTE newbuf; |
| DWORD buflen; |
| |
| IDirectSoundCaptureImpl* ipDSC = This->dsound; |
| |
| /* FIXME: do this only if formats different */ |
| err = mmErr(waveInClose(ipDSC->hwi)); |
| if (err != DS_OK) { |
| TRACE("waveInClose failed\n"); |
| return DSERR_GENERIC; |
| } |
| |
| err = mmErr(waveInOpen(&(ipDSC->hwi), |
| ipDSC->drvdesc.dnDevNode, &(ipDSC->wfx), |
| (DWORD)DSOUND_capture_callback, (DWORD)ipDSC, |
| CALLBACK_FUNCTION | WAVE_DIRECTSOUND)); |
| if (err != DS_OK) { |
| TRACE("waveInOpen failed\n"); |
| return DSERR_GENERIC; |
| } |
| |
| buflen = This->pdscbd->dwBufferBytes; |
| TRACE("desired buflen=%ld, old buffer=%p\n", buflen, ipDSC->buffer); |
| newbuf = (LPBYTE)HeapReAlloc(GetProcessHeap(),0,ipDSC->buffer,buflen); |
| |
| if (newbuf == NULL) { |
| ERR("failed to allocate capture buffer\n"); |
| err = DSERR_OUTOFMEMORY; |
| /* but the old buffer might still exist and must be re-prepared */ |
| } else { |
| ipDSC->buffer = newbuf; |
| ipDSC->buflen = buflen; |
| } |
| |
| if (ipDSC->buffer) { |
| unsigned c; |
| |
| if (This->nrofnotifies) |
| { |
| /* prepare headers */ |
| ipDSC->pwave = HeapReAlloc(GetProcessHeap(),0,ipDSC->pwave, |
| This->nrofnotifies*sizeof(WAVEHDR)); |
| |
| for (c = 0; c < This->nrofnotifies; c++) { |
| if (c == 0) { |
| ipDSC->pwave[0].lpData = ipDSC->buffer; |
| ipDSC->pwave[0].dwBufferLength = |
| This->notifies[0].dwOffset + 1; |
| } else { |
| ipDSC->pwave[c].lpData = ipDSC->buffer + |
| This->notifies[c-1].dwOffset + 1; |
| ipDSC->pwave[c].dwBufferLength = |
| This->notifies[c].dwOffset - |
| This->notifies[c-1].dwOffset; |
| } |
| ipDSC->pwave[c].dwUser = (DWORD)ipDSC; |
| ipDSC->pwave[c].dwFlags = 0; |
| ipDSC->pwave[c].dwLoops = 0; |
| err = mmErr(waveInPrepareHeader(ipDSC->hwi, |
| &(ipDSC->pwave[c]),sizeof(WAVEHDR))); |
| if (err != DS_OK) { |
| while (c--) |
| waveInUnprepareHeader(ipDSC->hwi, |
| &(ipDSC->pwave[c]),sizeof(WAVEHDR)); |
| break; |
| } |
| #if 0 |
| err = mmErr(waveInAddBuffer(ipDSC->hwi, &(ipDSC->pwave[c]), |
| sizeof(WAVEHDR))); |
| if (err != DS_OK) { |
| while (c--) |
| waveInUnprepareHeader(ipDSC->hwi,&(ipDSC->pwave[c]), |
| sizeof(WAVEHDR)); |
| break; |
| } |
| #endif |
| } |
| |
| memset(ipDSC->buffer, |
| (ipDSC->wfx.wBitsPerSample == 16) ? 0 : 128, ipDSC->buflen); |
| } |
| } |
| |
| ipDSC->index = 0; |
| ipDSC->read_position = 0; |
| err = mmErr(waveInAddBuffer(ipDSC->hwi, &(ipDSC->pwave[ipDSC->index]), |
| sizeof(WAVEHDR))); |
| if (err == DS_OK) |
| err = mmErr(waveInStart(ipDSC->hwi)); |
| } |
| |
| if (err != DS_OK) { |
| FIXME("cleanup\n"); |
| if (This->dsound->driver) { |
| FIXME("direct sound driver not supported\n"); |
| } |
| if (This->dsound->hwi) { |
| waveInClose(This->dsound->hwi); |
| } |
| LeaveCriticalSection(&(This->lock)); |
| return err; |
| } |
| |
| LeaveCriticalSection(&(This->lock)); |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_Stop( LPDIRECTSOUNDCAPTUREBUFFER8 iface ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p)\n", This ); |
| |
| if ( (This == NULL) || (This->dsound == NULL) ) { |
| TRACE("invalid parameter\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (This->dsound->driver) { |
| FIXME("direct sound driver not supported\n"); |
| return DSERR_NODRIVER; |
| } else if (This->dsound->hwi) { |
| TRACE("stopping winmm\n"); |
| waveInStop(This->dsound->hwi); |
| } else { |
| TRACE("no driver\n"); |
| return DSERR_NODRIVER; |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_Unlock( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| LPVOID lpvAudioPtr1, |
| DWORD dwAudioBytes1, |
| LPVOID lpvAudioPtr2, |
| DWORD dwAudioBytes2 ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| TRACE( "(%p,%p,%08lu,%p,%08lu)\n", This, lpvAudioPtr1, dwAudioBytes1, |
| lpvAudioPtr2, dwAudioBytes2 ); |
| |
| if ( (This == NULL) || (lpvAudioPtr1 == NULL) ) { |
| TRACE("invalid parameters\n"); |
| return DSERR_INVALIDPARAM; |
| } |
| |
| if (This->dsound->driver) { |
| TRACE("direct sound driver not supported\n"); |
| return DSERR_INVALIDCALL; |
| } else if (This->dsound->hwi) { |
| This->dsound->read_position = (This->dsound->read_position + |
| (dwAudioBytes1 + dwAudioBytes2)) % This->dsound->buflen; |
| } else { |
| TRACE("invalid call\n"); |
| return DSERR_INVALIDCALL; |
| } |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_GetObjectInPath( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| REFGUID rguidObject, |
| DWORD dwIndex, |
| REFGUID rguidInterface, |
| LPVOID* ppObject ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| |
| FIXME( "(%p,%s,%lu,%s,%p): stub\n", This, debugstr_guid(rguidObject), |
| dwIndex, debugstr_guid(rguidInterface), ppObject ); |
| |
| return DS_OK; |
| } |
| |
| static HRESULT WINAPI |
| IDirectSoundCaptureBufferImpl_GetFXStatus( |
| LPDIRECTSOUNDCAPTUREBUFFER8 iface, |
| DWORD dwFXCount, |
| LPDWORD pdwFXStatus ) |
| { |
| ICOM_THIS(IDirectSoundCaptureBufferImpl,iface); |
| |
| FIXME( "(%p,%lu,%p): stub\n", This, dwFXCount, pdwFXStatus ); |
| |
| return DS_OK; |
| } |
| |
| static ICOM_VTABLE(IDirectSoundCaptureBuffer8) dscbvt = |
| { |
| ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE |
| /* IUnknown methods */ |
| IDirectSoundCaptureBufferImpl_QueryInterface, |
| IDirectSoundCaptureBufferImpl_AddRef, |
| IDirectSoundCaptureBufferImpl_Release, |
| |
| /* IDirectSoundCaptureBuffer methods */ |
| IDirectSoundCaptureBufferImpl_GetCaps, |
| IDirectSoundCaptureBufferImpl_GetCurrentPosition, |
| IDirectSoundCaptureBufferImpl_GetFormat, |
| IDirectSoundCaptureBufferImpl_GetStatus, |
| IDirectSoundCaptureBufferImpl_Initialize, |
| IDirectSoundCaptureBufferImpl_Lock, |
| IDirectSoundCaptureBufferImpl_Start, |
| IDirectSoundCaptureBufferImpl_Stop, |
| IDirectSoundCaptureBufferImpl_Unlock, |
| |
| /* IDirectSoundCaptureBuffer methods */ |
| IDirectSoundCaptureBufferImpl_GetObjectInPath, |
| IDirectSoundCaptureBufferImpl_GetFXStatus |
| }; |
