capturebuffer.c File Reference

#include "precomp.h"

Include dependency graph for capturebuffer.c:

Go to the source code of this file.

Classes
struct	CDirectSoundCaptureBufferImpl

Typedefs
typedef struct CDirectSoundCaptureBufferImpl *	LPCDirectSoundCaptureBufferImpl

Functions
DWORD WINAPI	MixerThreadRoutine (LPVOID lpParameter)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_QueryInterface (LPDIRECTSOUNDCAPTUREBUFFER8 iface, IN REFIID riid, LPVOID *ppobj)
ULONG WINAPI	IDirectSoundCaptureBufferImpl_AddRef (LPDIRECTSOUNDCAPTUREBUFFER8 iface)
ULONG WINAPI	IDirectSoundCaptureBufferImpl_Release (LPDIRECTSOUNDCAPTUREBUFFER8 iface)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_GetCaps (LPDIRECTSOUNDCAPTUREBUFFER8 iface, LPDSCBCAPS lpDSCBCaps)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_GetCurrentPosition (LPDIRECTSOUNDCAPTUREBUFFER8 iface, LPDWORD lpdwCapturePosition, LPDWORD lpdwReadPosition)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_GetFormat (LPDIRECTSOUNDCAPTUREBUFFER8 iface, LPWAVEFORMATEX lpwfxFormat, DWORD dwSizeAllocated, LPDWORD lpdwSizeWritten)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_GetStatus (LPDIRECTSOUNDCAPTUREBUFFER8 iface, LPDWORD lpdwStatus)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_Initialize (LPDIRECTSOUNDCAPTUREBUFFER8 iface, LPDIRECTSOUNDCAPTURE lpDSC, LPCDSCBUFFERDESC lpcDSCBDesc)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_Lock (LPDIRECTSOUNDCAPTUREBUFFER8 iface, DWORD dwOffset, DWORD dwBytes, LPVOID *ppvAudioPtr1, LPDWORD pdwAudioBytes1, LPVOID *ppvAudioPtr2, LPDWORD pdwAudioBytes2, DWORD dwFlags)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_Start (LPDIRECTSOUNDCAPTUREBUFFER8 iface, DWORD dwFlags)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_Stop (LPDIRECTSOUNDCAPTUREBUFFER8 iface)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_Unlock (LPDIRECTSOUNDCAPTUREBUFFER8 iface, LPVOID lpvAudioPtr1, DWORD dwAudioBytes1, LPVOID lpvAudioPtr2, DWORD dwAudioBytes2)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_GetObjectInPath (LPDIRECTSOUNDCAPTUREBUFFER8 iface, REFGUID rguidObject, DWORD dwIndex, REFGUID rguidInterface, LPVOID *ppObject)
HRESULT WINAPI	IDirectSoundCaptureBufferImpl_GetFXStatus (LPDIRECTSOUNDCAPTUREBUFFER8 iface, DWORD dwFXCount, LPDWORD pdwFXStatus)
HRESULT	NewDirectSoundCaptureBuffer (LPDIRECTSOUNDCAPTUREBUFFER8 *OutBuffer, LPFILTERINFO Filter, LPCDSCBUFFERDESC lpcDSBufferDesc)

Variables
const GUID	KSINTERFACESETID_Standard = {0x1A8766A0L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}
const GUID	KSMEDIUMSETID_Standard = {0x4747B320L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}
const GUID	KSDATAFORMAT_TYPE_AUDIO = {0x73647561L, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}}
const GUID	KSDATAFORMAT_SPECIFIER_WAVEFORMATEX = {0x05589f81L, 0xc356, 0x11ce, {0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a}}
const GUID	KSPROPSETID_Connection = {0x1D58C920L, 0xAC9B, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}
const GUID	KSEVENTSETID_LoopedStreaming = {0x4682B940L, 0xC6EF, 0x11D0, {0x96, 0xD8, 0x00, 0xAA, 0x00, 0x51, 0xE5, 0x1D}}
static IDirectSoundCaptureBuffer8Vtbl	vt_DirectSoundCaptureBuffer8

Typedef Documentation

LPCDirectSoundCaptureBufferImpl

typedef struct CDirectSoundCaptureBufferImpl * LPCDirectSoundCaptureBufferImpl

Function Documentation

IDirectSoundCaptureBufferImpl_AddRef()

ULONG WINAPI IDirectSoundCaptureBufferImpl_AddRef

(

LPDIRECTSOUNDCAPTUREBUFFER8

iface

)

Definition at line 191 of file capturebuffer.c.

{
    ULONG ref;
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    /* increment reference count */
    ref = InterlockedIncrement(&This->ref);
 
    return ref;
 
}

IDirectSoundCaptureBufferImpl_GetCaps()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetCaps	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		LPDSCBCAPS	lpDSCBCaps
	)

Definition at line 249 of file capturebuffer.c.

{
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    if (!lpDSCBCaps)
    {
        /* invalid parameter */
        return DSERR_INVALIDPARAM;
    }
 
    if (lpDSCBCaps->dwSize != sizeof(DSCBCAPS))
    {
        /* invalid parameter */
        return DSERR_INVALIDPARAM;
    }
 
    lpDSCBCaps->dwBufferBytes = This->BufferSize;
    lpDSCBCaps->dwReserved = 0;
    //lpDSCBCaps->dwFlags =  DSCBCAPS_WAVEMAPPED;
 
    return DS_OK;
}

IDirectSoundCaptureBufferImpl_GetCurrentPosition()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetCurrentPosition	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		LPDWORD	lpdwCapturePosition,
		LPDWORD	lpdwReadPosition
	)

Definition at line 276 of file capturebuffer.c.

{
    KSAUDIO_POSITION Position;
    KSPROPERTY Request;
    DWORD Result;
    DWORD Value;
 
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    if (!This->hPin)
    {
        if (lpdwCapturePosition)
            *lpdwCapturePosition = 0;
 
        if (lpdwReadPosition)
            *lpdwReadPosition = 0;
 
        DPRINT("No Audio Pin\n");
        return DS_OK;
    }
 
    if (This->bMix)
    {
        /* read current position */
        Value = InterlockedCompareExchange(&This->CurrentMixPosition, 0, 0);
 
        if (lpdwCapturePosition)
            *lpdwCapturePosition = (DWORD)Value;
 
        if (lpdwReadPosition)
            *lpdwReadPosition = (DWORD)Value;
 
        return DS_OK;
    }
 
    /* setup audio position property request */
    Request.Id = KSPROPERTY_AUDIO_POSITION;
    Request.Set = KSPROPSETID_Audio;
    Request.Flags = KSPROPERTY_TYPE_GET;
 
 
    Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSPROPERTY), (PVOID)&Position, sizeof(KSAUDIO_POSITION), NULL);
 
    if (Result != ERROR_SUCCESS)
    {
        DPRINT("GetPosition failed with %x\n", Result);
        return DSERR_UNSUPPORTED;
    }
 
    //DPRINT("Play %I64u Write %I64u \n", Position.PlayOffset, Position.WriteOffset);
 
    if (lpdwCapturePosition)
        *lpdwCapturePosition = (DWORD)Position.PlayOffset;
 
    if (lpdwReadPosition)
        *lpdwReadPosition = (DWORD)Position.WriteOffset;
 
    return DS_OK;
}

IDirectSoundCaptureBufferImpl_GetFormat()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetFormat	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		LPWAVEFORMATEX	lpwfxFormat,
		DWORD	dwSizeAllocated,
		LPDWORD	lpdwSizeWritten
	)

Definition at line 342 of file capturebuffer.c.

{
    DWORD FormatSize;
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    FormatSize = sizeof(WAVEFORMATEX) + This->Format->cbSize;
 
    if (!lpwfxFormat && !lpdwSizeWritten)
    {
        /* invalid parameter */
        return DSERR_INVALIDPARAM;
    }
 
    if (!lpwfxFormat)
    {
        /* return required format size */
        *lpdwSizeWritten = FormatSize;
        return DS_OK;
    }
    else
    {
        if (dwSizeAllocated >= FormatSize)
        {
            /* copy format */
            CopyMemory(lpwfxFormat, This->Format, FormatSize);
 
            if (lpdwSizeWritten)
                *lpdwSizeWritten = FormatSize;
 
            return DS_OK;
        }
        /* buffer too small */
        if (lpdwSizeWritten)
            *lpdwSizeWritten = 0;
        return DSERR_INVALIDPARAM;
    }
}

IDirectSoundCaptureBufferImpl_GetFXStatus()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetFXStatus	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		DWORD	dwFXCount,
		LPDWORD	pdwFXStatus
	)

Definition at line 650 of file capturebuffer.c.

{
    UNIMPLEMENTED;
    return DSERR_INVALIDPARAM;
}

IDirectSoundCaptureBufferImpl_GetObjectInPath()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetObjectInPath	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		REFGUID	rguidObject,
		DWORD	dwIndex,
		REFGUID	rguidInterface,
		LPVOID *	ppObject
	)

Definition at line 637 of file capturebuffer.c.

{
    UNIMPLEMENTED;
    return DSERR_INVALIDPARAM;
}

IDirectSoundCaptureBufferImpl_GetStatus()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_GetStatus	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		LPDWORD	lpdwStatus
	)

Definition at line 386 of file capturebuffer.c.

{
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    if (!lpdwStatus)
    {
        /* invalid parameter */
        return DSERR_INVALIDPARAM;
    }
 
    /* reset flags */
    *lpdwStatus = 0;
 
    /* check if pin is running */
    if (This->State == KSSTATE_RUN)
        *lpdwStatus |= DSCBSTATUS_CAPTURING;
 
    /* check if a looped buffer is used */
    if (This->bLoop)
        *lpdwStatus |= DSCBSTATUS_LOOPING;
 
    /* done */
    return DS_OK;
}

IDirectSoundCaptureBufferImpl_Initialize()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_Initialize	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		LPDIRECTSOUNDCAPTURE	lpDSC,
		LPCDSCBUFFERDESC	lpcDSCBDesc
	)

Definition at line 415 of file capturebuffer.c.

{
    /* capture buffer is already initialized */
    return DSERR_ALREADYINITIALIZED;
}

IDirectSoundCaptureBufferImpl_Lock()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_Lock	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		DWORD	dwOffset,
		DWORD	dwBytes,
		LPVOID *	ppvAudioPtr1,
		LPDWORD	pdwAudioBytes1,
		LPVOID *	ppvAudioPtr2,
		LPDWORD	pdwAudioBytes2,
		DWORD	dwFlags
	)

Definition at line 426 of file capturebuffer.c.

{
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    DPRINT("This %p dwOffset %u dwBytes %u ppvAudioPtr1 %p pdwAudioBytes1 %p ppvAudioPtr2 %p pdwAudioBytes2 %p dwFlags %x This->BufferSize %u\n",
           This, dwOffset, dwBytes, ppvAudioPtr1, pdwAudioBytes1, ppvAudioPtr2, pdwAudioBytes2, dwFlags, This->BufferSize);
 
    if (dwFlags == DSBLOCK_ENTIREBUFFER)
    {
        *ppvAudioPtr1 = (LPVOID)This->Buffer;
        *pdwAudioBytes1 = This->BufferSize;
        if (ppvAudioPtr2)
            *ppvAudioPtr2 = NULL;
        if (pdwAudioBytes2)
            *pdwAudioBytes2 = 0;
 
        return DS_OK;
    }
    else
    {
        ASSERT(dwOffset < This->BufferSize);
        ASSERT(dwBytes < This->BufferSize);
        ASSERT(dwBytes + dwOffset <= This->BufferSize);
 
        *ppvAudioPtr1 = This->Buffer + dwOffset;
        *pdwAudioBytes1 = dwBytes;
        if (ppvAudioPtr2)
            *ppvAudioPtr2 = NULL;
        if (pdwAudioBytes2)
            *pdwAudioBytes2 = 0;
 
        return DS_OK;
    }
}

IDirectSoundCaptureBufferImpl_QueryInterface()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_QueryInterface	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		IN REFIID	riid,
		LPVOID *	ppobj
	)

Definition at line 143 of file capturebuffer.c.

{
    LPOLESTR pStr;
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    /* check if requested interface is supported */
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IDirectSoundCaptureBuffer) ||
        IsEqualIID(riid, &IID_IDirectSoundCaptureBuffer8))
    {
        *ppobj = (LPVOID)&This->lpVtbl;
        InterlockedIncrement(&This->ref);
        return S_OK;
    }
 
    /* check if the interface is supported */
    if (IsEqualIID(riid, &IID_IDirectSoundNotify))
    {
        if (!This->Notify)
        {
            HRESULT hr = NewDirectSoundNotify(&This->Notify, This->bLoop, This->bMix, This->hPin, This->BufferSize);
            if (FAILED(hr))
                return hr;
 
            *ppobj = (LPVOID)This->Notify;
            return S_OK;
        }
 
        /* increment reference count on existing notify object */
        IDirectSoundNotify_AddRef(This->Notify);
        *ppobj = (LPVOID)This->Notify;
        return S_OK;
    }
 
    /* interface not supported */
    if (SUCCEEDED(StringFromIID(riid, &pStr)))
    {
        DPRINT("No Interface for class %s\n", pStr);
        CoTaskMemFree(pStr);
    }
    return E_NOINTERFACE;
}

IDirectSoundCaptureBufferImpl_Release()

ULONG WINAPI IDirectSoundCaptureBufferImpl_Release

(

LPDIRECTSOUNDCAPTUREBUFFER8

iface

)

Definition at line 206 of file capturebuffer.c.

{
    ULONG ref;
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    /* release reference count */
    ref = InterlockedDecrement(&(This->ref));
 
    if (!ref)
    {
        if (This->hPin)
        {
            /* close pin handle */
            CloseHandle(This->hPin);
        }
 
        if (This->hStopEvent)
        {
            /* close stop event handle */
            CloseHandle(This->hStopEvent);
        }
 
        if (This->MixBuffer)
        {
            /* free mix buffer */
            HeapFree(GetProcessHeap(), 0, This->MixBuffer);
        }
 
        /* free capture buffer */
        HeapFree(GetProcessHeap(), 0, This->Buffer);
        /* free wave format */
        HeapFree(GetProcessHeap(), 0, This->Format);
        /* free capture buffer */
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

IDirectSoundCaptureBufferImpl_Start()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_Start	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		DWORD	dwFlags
	)

Definition at line 471 of file capturebuffer.c.

{
    KSPROPERTY Property;
    KSSTREAM_HEADER Header;
    DWORD Result, BytesTransferred;
    OVERLAPPED Overlapped;
    KSSTATE State;
    HANDLE hThread;
 
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    DPRINT("IDirectSoundCaptureBufferImpl_Start Flags %x\n", dwFlags);
    ASSERT(dwFlags == DSCBSTART_LOOPING);
 
    /* check if pin is already running */
    if (This->State == KSSTATE_RUN)
        return DS_OK;
 
 
    /* check if there is a pin instance */
    if (!This->hPin)
        return DSERR_GENERIC;
 
    /* setup request */
    Property.Set = KSPROPSETID_Connection;
    Property.Id = KSPROPERTY_CONNECTION_STATE;
    Property.Flags = KSPROPERTY_TYPE_SET;
    State = KSSTATE_RUN;
 
    /* set pin to run */
    Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&State, sizeof(KSSTATE), &BytesTransferred);
 
    ASSERT(Result == ERROR_SUCCESS);
 
    if (Result == ERROR_SUCCESS)
    {
        /* store result */
        This->State = State;
    }
 
    /* initialize overlapped struct */
    ZeroMemory(&Overlapped, sizeof(OVERLAPPED));
    Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    /* clear stream header */
    ZeroMemory(&Header, sizeof(KSSTREAM_HEADER));
 
    /* initialize stream header */
    Header.FrameExtent = This->BufferSize;
    Header.DataUsed = 0;
    Header.Data = (This->bMix ? This->MixBuffer : This->Buffer);
    Header.Size = sizeof(KSSTREAM_HEADER);
    Header.PresentationTime.Numerator = 1;
    Header.PresentationTime.Denominator = 1;
 
    Result = DeviceIoControl(This->hPin, IOCTL_KS_WRITE_STREAM, NULL, 0, &Header, sizeof(KSSTREAM_HEADER), &BytesTransferred, &Overlapped);
 
    if (Result != ERROR_SUCCESS)
    {
        DPRINT("Failed submit buffer with %lx\n", Result);
        return DSERR_GENERIC;
    }
 
    if (This->bMix)
    {
        if (!This->hStopEvent)
        {
            /* create stop event */
            This->hStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
            if (!This->hStopEvent)
            {
                DPRINT1("Failed to create event object with %x\n", GetLastError());
                return DSERR_GENERIC;
            }
        }
 
        /* set state to stop false */
        This->StopMixerThread = FALSE;
 
        hThread = CreateThread(NULL, 0, MixerThreadRoutine, (PVOID)This, 0, NULL);
        if (!hThread)
        {
            DPRINT1("Failed to create thread with %x\n", GetLastError());
            return DSERR_GENERIC;
        }
 
        /* close thread handle */
        CloseHandle(hThread);
    }
 
 
    return DS_OK;
}

IDirectSoundCaptureBufferImpl_Stop()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_Stop

(

LPDIRECTSOUNDCAPTUREBUFFER8

iface

)

Definition at line 569 of file capturebuffer.c.

{
    KSPROPERTY Property;
    DWORD Result;
    KSSTATE State;
 
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)CONTAINING_RECORD(iface, CDirectSoundCaptureBufferImpl, lpVtbl);
 
    if (This->State == KSSTATE_STOP)
    {
        /* stream has already been stopped */
        return DS_OK;
    }
 
    if (!This->hPin)
        return DSERR_GENERIC;
 
    /* setup request */
    Property.Set = KSPROPSETID_Connection;
    Property.Id = KSPROPERTY_CONNECTION_STATE;
    Property.Flags = KSPROPERTY_TYPE_SET;
    State = KSSTATE_STOP;
 
 
    /* set pin to stop */
    Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&State, sizeof(KSSTATE), NULL);
 
    ASSERT(Result == ERROR_SUCCESS);
 
 
    if (This->bMix)
    {
        /* sanity check */
        ASSERT(This->hStopEvent);
        /* reset event */
        ResetEvent(This->hStopEvent);
        /* signal event to stop */
        This->StopMixerThread = TRUE;
        /* Wait for the event to stop */
        WaitForSingleObject(This->hStopEvent, INFINITE);
    }
 
 
    if (Result == ERROR_SUCCESS)
    {
        /* store result */
        This->State = State;
        return DS_OK;
    }
 
    DPRINT("Failed to stop pin\n");
    return DSERR_GENERIC;
}

IDirectSoundCaptureBufferImpl_Unlock()

HRESULT WINAPI IDirectSoundCaptureBufferImpl_Unlock	(	LPDIRECTSOUNDCAPTUREBUFFER8	iface,
		LPVOID	lpvAudioPtr1,
		DWORD	dwAudioBytes1,
		LPVOID	lpvAudioPtr2,
		DWORD	dwAudioBytes2
	)

Definition at line 625 of file capturebuffer.c.

{
    return DS_OK;
}

MixerThreadRoutine()

DWORD WINAPI MixerThreadRoutine

(

LPVOID

lpParameter

)

Definition at line 48 of file capturebuffer.c.

{
    KSPROPERTY Request;
    KSAUDIO_POSITION Position;
    DWORD Result, MixPosition, BufferPosition, BytesWritten, BytesRead, MixLength, BufferLength;
    LPCDirectSoundCaptureBufferImpl This = (LPCDirectSoundCaptureBufferImpl)lpParameter;
 
    /* setup audio position property request */
    Request.Id = KSPROPERTY_AUDIO_POSITION;
    Request.Set = KSPROPSETID_Audio;
    Request.Flags = KSPROPERTY_TYPE_GET;
 
    MixPosition = 0;
    BufferPosition = 0;
    do
    {
        /* query current position */
        Result = SyncOverlappedDeviceIoControl(This->hPin, IOCTL_KS_PROPERTY, (PVOID)&Request, sizeof(KSPROPERTY), (PVOID)&Position, sizeof(KSAUDIO_POSITION), NULL);
 
        /* sanity check */
        ASSERT(Result == ERROR_SUCCESS);
 
        /* FIXME implement samplerate conversion */
        ASSERT(This->MixFormat.nSamplesPerSec == This->Format->nSamplesPerSec);
 
        /* FIXME implement bitrate conversion */
        ASSERT(This->MixFormat.wBitsPerSample == This->Format->wBitsPerSample);
 
        /* sanity check */
        ASSERT(BufferPosition <= This->BufferSize);
        ASSERT(MixPosition  <= This->MixBufferSize);
 
        if (BufferPosition == This->BufferSize)
        {
            /* restart from front */
            BufferPosition = 0;
        }
 
        if (MixPosition == This->MixBufferSize)
        {
            /* restart from front */
            MixPosition = 0;
        }
 
        if (This->MixFormat.nChannels != This->Format->nChannels)
        {
            if ((DWORD)Position.PlayOffset >= MixPosition)
            {
                /* calculate buffer position difference */
                MixLength = Position.PlayOffset - MixPosition;
            }
            else
            {
                /* buffer overlap */
                MixLength = This->MixBufferSize - MixPosition;
            }
 
            BufferLength = This->BufferSize - BufferPosition;
 
            /* convert the format */
            PerformChannelConversion(&This->MixBuffer[MixPosition], MixLength, &BytesRead, This->MixFormat.nChannels, This->Format->nChannels, This->Format->wBitsPerSample, &This->Buffer[BufferPosition], BufferLength, &BytesWritten);
 
            /* update buffer offsets */
            MixPosition += BytesRead;
            BufferPosition += BytesWritten;
            DPRINT("MixPosition %u BufferPosition %u BytesRead %u BytesWritten %u MixLength %u BufferLength %u\n", MixPosition, BufferPosition, BytesRead, BytesWritten, MixLength, BufferLength);
        }
 
        /* Notify Events */
        if (This->Notify)
        {
            DoNotifyPositionEvents(This->Notify, This->CurrentMixPosition, BufferPosition);
        }
 
        /* update offset */
        InterlockedExchange(&This->CurrentMixPosition, (LONG)BufferPosition);
 
        /* FIXME use timer */
        Sleep(10);
 
    }while(InterlockedCompareExchange(&This->StopMixerThread, 0, 0) == 0);
 
 
    /* signal stop event */
    SetEvent(This->hStopEvent);
 
    /* done */
    return 0;
}

Referenced by IDirectSoundCaptureBufferImpl_Start().

NewDirectSoundCaptureBuffer()

HRESULT NewDirectSoundCaptureBuffer	(	LPDIRECTSOUNDCAPTUREBUFFER8 *	OutBuffer,
		LPFILTERINFO	Filter,
		LPCDSCBUFFERDESC	lpcDSBufferDesc
	)

Definition at line 687 of file capturebuffer.c.

{
    DWORD FormatSize, MixBufferSize;
    ULONG DeviceId = 0, PinId;
    DWORD Result = ERROR_SUCCESS;
    WAVEFORMATEX MixFormat;
 
    LPCDirectSoundCaptureBufferImpl This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CDirectSoundCaptureBufferImpl));
 
    if (!This)
    {
        /* not enough memory */
        return DSERR_OUTOFMEMORY;
    }
 
     /* calculate format size */
    FormatSize = sizeof(WAVEFORMATEX) + lpcDSBufferDesc->lpwfxFormat->cbSize;
    /* allocate format struct */
    This->Format = HeapAlloc(GetProcessHeap(), 0, FormatSize);
    if (!This->Format)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, This);
        return DSERR_OUTOFMEMORY;
    }
 
    /* sanity check */
    ASSERT(lpcDSBufferDesc->dwBufferBytes);
 
    /* allocate capture buffer */
    This->Buffer = HeapAlloc(GetProcessHeap(), 0, lpcDSBufferDesc->dwBufferBytes);
    if (!This->Buffer)
    {
        /* not enough memory */
        HeapFree(GetProcessHeap(), 0, This->Format);
        HeapFree(GetProcessHeap(), 0, This);
        return DSERR_OUTOFMEMORY;
    }
 
    /* store buffer size */
    This->BufferSize = lpcDSBufferDesc->dwBufferBytes;
    ASSERT(lpcDSBufferDesc->lpwfxFormat->cbSize == 0);
 
    do
    {
        /* try all available recording pins on that filter */
        PinId = GetPinIdFromFilter(Filter, TRUE, DeviceId);
 
        if (PinId == ULONG_MAX)
            break;
 
        Result = OpenPin(Filter->hFilter, PinId, lpcDSBufferDesc->lpwfxFormat, &This->hPin, TRUE);
        if (Result == ERROR_SUCCESS)
            break;
 
        DeviceId++;
    }while(TRUE);
 
    if (Result != ERROR_SUCCESS)
    {
        /* failed to instantiate the capture pin with the native format
         * try to compute a compatible format and use that
         * we could use the mixer api for this purpose but... the kmixer isnt working very good atm
         */
 
       DeviceId = 0;
       do
       {
           /* try all available recording pins on that filter */
            PinId = GetPinIdFromFilter(Filter, TRUE, DeviceId);
            DPRINT("PinId %u DeviceId %u\n", PinId, DeviceId);
 
            if (PinId == ULONG_MAX)
                break;
 
            if (CreateCompatiblePin(Filter->hFilter, PinId, TRUE, lpcDSBufferDesc->lpwfxFormat, &MixFormat, &This->hPin))
            {
                This->bMix = TRUE;
                CopyMemory(&This->MixFormat, &MixFormat, sizeof(WAVEFORMATEX));
                break;
            }
 
            DeviceId++;
        }while(TRUE);
 
 
        if (!This->bMix)
        {
            /* FIXME should not happen */
            DPRINT("failed to compute a compatible format\n");
            HeapFree(GetProcessHeap(), 0, This->MixBuffer);
            HeapFree(GetProcessHeap(), 0, This->Buffer);
            HeapFree(GetProcessHeap(), 0, This->Format);
            HeapFree(GetProcessHeap(), 0, This);
            return DSERR_GENERIC;
        }
 
        MixBufferSize = lpcDSBufferDesc->dwBufferBytes;
        MixBufferSize /= lpcDSBufferDesc->lpwfxFormat->nChannels;
        MixBufferSize /= (lpcDSBufferDesc->lpwfxFormat->wBitsPerSample/8);
 
        MixBufferSize *= This->MixFormat.nChannels;
        MixBufferSize *= (This->MixFormat.wBitsPerSample/8);
 
        /* allocate buffer for mixing */
        This->MixBuffer = HeapAlloc(GetProcessHeap(), 0, MixBufferSize);
        if (!This->Buffer)
        {
            /* not enough memory */
            CloseHandle(This->hPin);
            HeapFree(GetProcessHeap(), 0, This->Buffer);
            HeapFree(GetProcessHeap(), 0, This->Format);
            HeapFree(GetProcessHeap(), 0, This);
            return DSERR_OUTOFMEMORY;
        }
        This->MixBufferSize = MixBufferSize;
        DPRINT1("MixBufferSize %u BufferSize %u\n", MixBufferSize, This->BufferSize);
    }
 
    /* initialize capture buffer */
    This->ref = 1;
    This->lpVtbl = &vt_DirectSoundCaptureBuffer8;
    This->Filter = Filter;
    This->State = KSSTATE_STOP;
    This->bLoop = TRUE;
 
    RtlMoveMemory(This->Format, lpcDSBufferDesc->lpwfxFormat, FormatSize);
 
    *OutBuffer = (LPDIRECTSOUNDCAPTUREBUFFER8)&This->lpVtbl;
    return DS_OK;
}

Referenced by CDirectSoundCapture_fnCreateCaptureBuffer().

Variable Documentation

KSDATAFORMAT_SPECIFIER_WAVEFORMATEX

const GUID KSDATAFORMAT_SPECIFIER_WAVEFORMATEX = {0x05589f81L, 0xc356, 0x11ce, {0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a}}

Definition at line 16 of file capturebuffer.c.

KSDATAFORMAT_TYPE_AUDIO

const GUID KSDATAFORMAT_TYPE_AUDIO = {0x73647561L, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}}

Definition at line 15 of file capturebuffer.c.

KSEVENTSETID_LoopedStreaming

const GUID KSEVENTSETID_LoopedStreaming = {0x4682B940L, 0xC6EF, 0x11D0, {0x96, 0xD8, 0x00, 0xAA, 0x00, 0x51, 0xE5, 0x1D}}

Definition at line 18 of file capturebuffer.c.

KSINTERFACESETID_Standard

const GUID KSINTERFACESETID_Standard = {0x1A8766A0L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}

Definition at line 13 of file capturebuffer.c.

KSMEDIUMSETID_Standard

const GUID KSMEDIUMSETID_Standard = {0x4747B320L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}

Definition at line 14 of file capturebuffer.c.

KSPROPSETID_Connection

const GUID KSPROPSETID_Connection = {0x1D58C920L, 0xAC9B, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}}

Definition at line 17 of file capturebuffer.c.

Referenced by IDirectSoundCaptureBufferImpl_Start(), and IDirectSoundCaptureBufferImpl_Stop().

vt_DirectSoundCaptureBuffer8

IDirectSoundCaptureBuffer8Vtbl vt_DirectSoundCaptureBuffer8

static

Initial value:

=
{
    
    IDirectSoundCaptureBufferImpl_QueryInterface,
    IDirectSoundCaptureBufferImpl_AddRef,
    IDirectSoundCaptureBufferImpl_Release,
 
    
    IDirectSoundCaptureBufferImpl_GetCaps,
    IDirectSoundCaptureBufferImpl_GetCurrentPosition,
    IDirectSoundCaptureBufferImpl_GetFormat,
    IDirectSoundCaptureBufferImpl_GetStatus,
    IDirectSoundCaptureBufferImpl_Initialize,
    IDirectSoundCaptureBufferImpl_Lock,
    IDirectSoundCaptureBufferImpl_Start,
    IDirectSoundCaptureBufferImpl_Stop,
    IDirectSoundCaptureBufferImpl_Unlock,
 
    
    IDirectSoundCaptureBufferImpl_GetObjectInPath,
    IDirectSoundCaptureBufferImpl_GetFXStatus
}

Definition at line 660 of file capturebuffer.c.

Referenced by NewDirectSoundCaptureBuffer().