pin.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	PullPin

Macros
#define	ALIGNDOWN(value, boundary)   ((value)/(boundary)*(boundary))
#define	ALIGNUP(value, boundary)   (ALIGNDOWN((value)+(boundary)-1, (boundary)))
#define	Req_Sleepy   0
#define	Req_Die   1
#define	Req_Run   2
#define	Req_Pause   3

Typedefs
typedef HRESULT(*	SAMPLEPROC_PULL) (LPVOID userdata, IMediaSample *pSample, DWORD_PTR cookie)
typedef HRESULT(*	QUERYACCEPTPROC) (LPVOID userdata, const AM_MEDIA_TYPE *pmt)
typedef HRESULT(*	PRECONNECTPROC) (IPin *iface, IPin *pConnectPin, ALLOCATOR_PROPERTIES *props)
typedef HRESULT(*	CLEANUPPROC) (LPVOID userdata)
typedef HRESULT(*	REQUESTPROC) (LPVOID userdata)
typedef HRESULT(*	STOPPROCESSPROC) (LPVOID userdata)
typedef struct PullPin	PullPin

Functions
HRESULT	PullPin_Construct (const IPinVtbl *PullPin_Vtbl, const PIN_INFO *pPinInfo, SAMPLEPROC_PULL pSampleProc, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, CLEANUPPROC pCleanUp, REQUESTPROC pCustomRequest, STOPPROCESSPROC pDone, LPCRITICAL_SECTION pCritSec, IPin **ppPin)
HRESULT WINAPI	PullPin_ReceiveConnection (IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
HRESULT WINAPI	PullPin_Disconnect (IPin *iface)
HRESULT WINAPI	PullPin_QueryInterface (IPin *iface, REFIID riid, LPVOID *ppv)
ULONG WINAPI	PullPin_Release (IPin *iface)
HRESULT WINAPI	PullPin_EndOfStream (IPin *iface)
HRESULT WINAPI	PullPin_QueryAccept (IPin *iface, const AM_MEDIA_TYPE *pmt)
HRESULT WINAPI	PullPin_BeginFlush (IPin *iface)
HRESULT WINAPI	PullPin_EndFlush (IPin *iface)
HRESULT WINAPI	PullPin_NewSegment (IPin *iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
HRESULT	PullPin_StartProcessing (PullPin *This)
HRESULT	PullPin_PauseProcessing (PullPin *This)
HRESULT	PullPin_WaitForStateChange (PullPin *This, DWORD dwMilliseconds)
static PullPin *	impl_PullPin_from_IPin (IPin *iface)

Macro Definition Documentation

ALIGNDOWN

#define ALIGNDOWN	(		value,
			boundary
	)		((value)/(boundary)*(boundary))

Definition at line 67 of file pin.h.

ALIGNUP

#define ALIGNUP	(		value,
			boundary
	)		(ALIGNDOWN((value)+(boundary)-1, (boundary)))

Definition at line 68 of file pin.h.

Req_Die

#define Req_Die   1

Definition at line 102 of file pin.h.

Req_Pause

#define Req_Pause   3

Definition at line 104 of file pin.h.

Req_Run

#define Req_Run   2

Definition at line 103 of file pin.h.

Req_Sleepy

#define Req_Sleepy   0

Definition at line 101 of file pin.h.

Typedef Documentation

CLEANUPPROC

typedef HRESULT(* CLEANUPPROC) (LPVOID userdata)

Definition at line 50 of file pin.h.

PRECONNECTPROC

typedef HRESULT(* PRECONNECTPROC) (IPin *iface, IPin *pConnectPin, ALLOCATOR_PROPERTIES *props)

Definition at line 43 of file pin.h.

PullPin

typedef struct PullPin PullPin

QUERYACCEPTPROC

typedef HRESULT(* QUERYACCEPTPROC) (LPVOID userdata, const AM_MEDIA_TYPE *pmt)

Definition at line 35 of file pin.h.

REQUESTPROC

typedef HRESULT(* REQUESTPROC) (LPVOID userdata)

Definition at line 60 of file pin.h.

SAMPLEPROC_PULL

typedef HRESULT(* SAMPLEPROC_PULL) (LPVOID userdata, IMediaSample *pSample, DWORD_PTR cookie)

Definition at line 29 of file pin.h.

STOPPROCESSPROC

typedef HRESULT(* STOPPROCESSPROC) (LPVOID userdata)

Definition at line 65 of file pin.h.

Function Documentation

impl_PullPin_from_IPin()

static PullPin * impl_PullPin_from_IPin ( IPin *  iface )

inlinestatic

Definition at line 132 of file pin.h.

{
    return CONTAINING_RECORD(iface, PullPin, pin.IPin_iface);
}

Referenced by AVISplitter_InputPin_PreConnect(), AVISplitter_ProcessIndex(), MPEGSplitter_pre_connect(), Parser_GetState(), Parser_Pause(), Parser_PullPin_Disconnect(), Parser_PullPin_QueryInterface(), Parser_Run(), Parser_SetSyncSource(), Parser_Stop(), PullPin_BeginFlush(), PullPin_Disconnect(), PullPin_EndFlush(), PullPin_EndOfStream(), PullPin_QueryAccept(), PullPin_QueryInterface(), PullPin_ReceiveConnection(), PullPin_Release(), and WAVEParser_InputPin_PreConnect().

PullPin_BeginFlush()

HRESULT WINAPI PullPin_BeginFlush

(

IPin *

iface

)

Definition at line 739 of file pin.c.

{
    PullPin *This = impl_PullPin_from_IPin(iface);
    TRACE("(%p)->()\n", This);
 
    EnterCriticalSection(This->pin.pCritSec);
    {
        SendFurther( iface, deliver_beginflush, NULL, NULL );
    }
    LeaveCriticalSection(This->pin.pCritSec);
 
    EnterCriticalSection(&This->thread_lock);
    {
        if (This->pReader)
            IAsyncReader_BeginFlush(This->pReader);
        PullPin_WaitForStateChange(This, INFINITE);
 
        if (This->hThread && This->state == Req_Run)
        {
            PullPin_PauseProcessing(This);
            PullPin_WaitForStateChange(This, INFINITE);
        }
    }
    LeaveCriticalSection(&This->thread_lock);
 
    EnterCriticalSection(This->pin.pCritSec);
    {
        This->fnCleanProc(This->pUserData);
    }
    LeaveCriticalSection(This->pin.pCritSec);
 
    return S_OK;
}

PullPin_Construct()

HRESULT PullPin_Construct	(	const IPinVtbl *	PullPin_Vtbl,
		const PIN_INFO *	pPinInfo,
		SAMPLEPROC_PULL	pSampleProc,
		LPVOID	pUserData,
		QUERYACCEPTPROC	pQueryAccept,
		CLEANUPPROC	pCleanUp,
		REQUESTPROC	pCustomRequest,
		STOPPROCESSPROC	pDone,
		LPCRITICAL_SECTION	pCritSec,
		IPin **	ppPin
	)

Definition at line 221 of file pin.c.

{
    PullPin * pPinImpl;
 
    *ppPin = NULL;
 
    if (pPinInfo->dir != PINDIR_INPUT)
    {
        ERR("Pin direction(%x) != PINDIR_INPUT\n", pPinInfo->dir);
        return E_INVALIDARG;
    }
 
    pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl));
 
    if (!pPinImpl)
        return E_OUTOFMEMORY;
 
    if (SUCCEEDED(PullPin_Init(PullPin_Vtbl, pPinInfo, pSampleProc, pUserData, pQueryAccept, pCleanUp, pCustomRequest, pDone, pCritSec, pPinImpl)))
    {
        *ppPin = &pPinImpl->pin.IPin_iface;
        return S_OK;
    }
 
    CoTaskMemFree(pPinImpl);
    return E_FAIL;
}

Referenced by Parser_Create().

PullPin_Disconnect()

HRESULT WINAPI PullPin_Disconnect

(

IPin *

iface

)

Definition at line 803 of file pin.c.

{
    HRESULT hr;
    PullPin *This = impl_PullPin_from_IPin(iface);
 
    TRACE("()\n");
 
    EnterCriticalSection(This->pin.pCritSec);
    {
        if (FAILED(hr = IMemAllocator_Decommit(This->pAlloc)))
            ERR("Allocator decommit failed with error %x. Possible memory leak\n", hr);
 
        if (This->pin.pConnectedTo)
        {
            IPin_Release(This->pin.pConnectedTo);
            This->pin.pConnectedTo = NULL;
            PullPin_StopProcessing(This);
 
            FreeMediaType(&This->pin.mtCurrent);
            ZeroMemory(&This->pin.mtCurrent, sizeof(This->pin.mtCurrent));
            hr = S_OK;
        }
        else
            hr = S_FALSE;
    }
    LeaveCriticalSection(This->pin.pCritSec);
 
    WaitForSingleObject(This->hThread, INFINITE);
    CloseHandle(This->hThread);
    This->hThread = NULL;
 
    return hr;
}

Referenced by Parser_PullPin_Disconnect().

PullPin_EndFlush()

HRESULT WINAPI PullPin_EndFlush

(

IPin *

iface

)

Definition at line 773 of file pin.c.

{
    PullPin *This = impl_PullPin_from_IPin(iface);
 
    TRACE("(%p)->()\n", iface);
 
    /* Send further first: Else a race condition might terminate processing early */
    EnterCriticalSection(This->pin.pCritSec);
    SendFurther( iface, deliver_endflush, NULL, NULL );
    LeaveCriticalSection(This->pin.pCritSec);
 
    EnterCriticalSection(&This->thread_lock);
    {
        FILTER_STATE state;
 
        if (This->pReader)
            IAsyncReader_EndFlush(This->pReader);
 
        IBaseFilter_GetState(This->pin.pinInfo.pFilter, INFINITE, &state);
 
        if (state != State_Stopped)
            PullPin_StartProcessing(This);
 
        PullPin_WaitForStateChange(This, INFINITE);
    }
    LeaveCriticalSection(&This->thread_lock);
 
    return S_OK;
}

PullPin_EndOfStream()

HRESULT WINAPI PullPin_EndOfStream

(

IPin *

iface

)

Definition at line 724 of file pin.c.

{
    PullPin *This = impl_PullPin_from_IPin(iface);
    HRESULT hr = S_FALSE;
 
    TRACE("(%p)->()\n", iface);
 
    EnterCriticalSection(This->pin.pCritSec);
    hr = SendFurther( iface, deliver_endofstream, NULL, NULL );
    SetEvent(This->hEventStateChanged);
    LeaveCriticalSection(This->pin.pCritSec);
 
    return hr;
}

PullPin_NewSegment()

HRESULT WINAPI PullPin_NewSegment	(	IPin *	iface,
		REFERENCE_TIME	tStart,
		REFERENCE_TIME	tStop,
		double	dRate
	)

Definition at line 837 of file pin.c.

{
    newsegmentargs args;
    FIXME("(%p)->(%s, %s, %g) stub\n", iface, wine_dbgstr_longlong(tStart), wine_dbgstr_longlong(tStop), dRate);
 
    args.tStart = tStart;
    args.tStop = tStop;
    args.rate = dRate;
 
    return SendFurther( iface, deliver_newsegment, &args, NULL );
}

PullPin_PauseProcessing()

HRESULT PullPin_PauseProcessing

(

PullPin *

This

)

Definition at line 646 of file pin.c.

{
    /* if we are connected */
    TRACE("(%p)->()\n", This);
    if(This->pAlloc)
    {
        assert(This->hThread);
 
        PullPin_WaitForStateChange(This, INFINITE);
 
        EnterCriticalSection(This->pin.pCritSec);
 
        assert(!This->stop_playback);
        assert(This->state == Req_Run|| This->state == Req_Sleepy);
 
        assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
 
        This->state = Req_Pause;
        This->stop_playback = TRUE;
        ResetEvent(This->hEventStateChanged);
        SetEvent(This->thread_sleepy);
 
        /* Release any outstanding samples */
        if (This->pReader)
        {
            IMediaSample *pSample;
            DWORD_PTR dwUser;
 
            do
            {
                pSample = NULL;
                IAsyncReader_WaitForNext(This->pReader, 0, &pSample, &dwUser);
                if (pSample)
                    IMediaSample_Release(pSample);
            } while(pSample);
        }
 
        LeaveCriticalSection(This->pin.pCritSec);
    }
 
    return S_OK;
}

Referenced by Parser_Stop(), and PullPin_BeginFlush().

PullPin_QueryAccept()

HRESULT WINAPI PullPin_QueryAccept	(	IPin *	iface,
		const AM_MEDIA_TYPE *	pmt
	)

Definition at line 715 of file pin.c.

{
    PullPin *This = impl_PullPin_from_IPin(iface);
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 
    return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE);
}

PullPin_QueryInterface()

HRESULT WINAPI PullPin_QueryInterface	(	IPin *	iface,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 345 of file pin.c.

{
    PullPin *This = impl_PullPin_from_IPin(iface);
 
    TRACE("(%p/%p)->(%s, %p)\n", This, iface, qzdebugstr_guid(riid), ppv);
 
    *ppv = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown))
        *ppv = iface;
    else if (IsEqualIID(riid, &IID_IPin))
        *ppv = iface;
    else if (IsEqualIID(riid, &IID_IMediaSeeking) ||
             IsEqualIID(riid, &IID_IQualityControl))
    {
        return IBaseFilter_QueryInterface(This->pin.pinInfo.pFilter, riid, ppv);
    }
 
    if (*ppv)
    {
        IUnknown_AddRef((IUnknown *)(*ppv));
        return S_OK;
    }
 
    FIXME("No interface for %s!\n", qzdebugstr_guid(riid));
 
    return E_NOINTERFACE;
}

Referenced by Parser_PullPin_QueryInterface().

PullPin_ReceiveConnection()

HRESULT WINAPI PullPin_ReceiveConnection	(	IPin *	iface,
		IPin *	pReceivePin,
		const AM_MEDIA_TYPE *	pmt
	)

Definition at line 253 of file pin.c.

{
    PIN_DIRECTION pindirReceive;
    HRESULT hr = S_OK;
    PullPin *This = impl_PullPin_from_IPin(iface);
 
    TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
    dump_AM_MEDIA_TYPE(pmt);
 
    EnterCriticalSection(This->pin.pCritSec);
    if (!This->pin.pConnectedTo)
    {
        ALLOCATOR_PROPERTIES props;
 
        props.cBuffers = 3;
        props.cbBuffer = 64 * 1024; /* 64 KB */
        props.cbAlign = 1;
        props.cbPrefix = 0;
 
        if (This->fnQueryAccept(This->pUserData, pmt) != S_OK)
            hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto 
                                           * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
 
        if (SUCCEEDED(hr))
        {
            IPin_QueryDirection(pReceivePin, &pindirReceive);
 
            if (pindirReceive != PINDIR_OUTPUT)
            {
                ERR("Can't connect from non-output pin\n");
                hr = VFW_E_INVALID_DIRECTION;
            }
        }
 
        This->pReader = NULL;
        This->pAlloc = NULL;
        This->prefAlloc = NULL;
        if (SUCCEEDED(hr))
        {
            hr = IPin_QueryInterface(pReceivePin, &IID_IAsyncReader, (LPVOID *)&This->pReader);
        }
 
        if (SUCCEEDED(hr) && This->fnPreConnect)
        {
            hr = This->fnPreConnect(iface, pReceivePin, &props);
        }
 
        /*
         * Some custom filters (such as the one used by Fallout 3
         * and Fallout: New Vegas) expect to be passed a non-NULL
         * preferred allocator.
         */
        if (SUCCEEDED(hr))
        {
            hr = StdMemAllocator_create(NULL, (LPVOID *) &This->prefAlloc);
        }
 
        if (SUCCEEDED(hr))
        {
            hr = IAsyncReader_RequestAllocator(This->pReader, This->prefAlloc, &props, &This->pAlloc);
        }
 
        if (SUCCEEDED(hr))
        {
            CopyMediaType(&This->pin.mtCurrent, pmt);
            This->pin.pConnectedTo = pReceivePin;
            IPin_AddRef(pReceivePin);
            hr = IMemAllocator_Commit(This->pAlloc);
        }
 
        if (SUCCEEDED(hr))
            hr = PullPin_InitProcessing(This);
 
        if (FAILED(hr))
        {
             if (This->pReader)
                 IAsyncReader_Release(This->pReader);
             This->pReader = NULL;
             if (This->prefAlloc)
                 IMemAllocator_Release(This->prefAlloc);
             This->prefAlloc = NULL;
             if (This->pAlloc)
                 IMemAllocator_Release(This->pAlloc);
             This->pAlloc = NULL;
        }
    }
    else
        hr = VFW_E_ALREADY_CONNECTED;
    LeaveCriticalSection(This->pin.pCritSec);
    return hr;
}

Referenced by Parser_PullPin_ReceiveConnection().

PullPin_Release()

ULONG WINAPI PullPin_Release

(

IPin *

iface

)

Definition at line 374 of file pin.c.

{
    PullPin *This = impl_PullPin_from_IPin(iface);
    ULONG refCount = InterlockedDecrement(&This->pin.refCount);
 
    TRACE("(%p)->() Release from %d\n", This, refCount + 1);
 
    if (!refCount)
    {
        WaitForSingleObject(This->hEventStateChanged, INFINITE);
        assert(!This->hThread);
 
        if(This->prefAlloc)
            IMemAllocator_Release(This->prefAlloc);
        if(This->pAlloc)
            IMemAllocator_Release(This->pAlloc);
        if(This->pReader)
            IAsyncReader_Release(This->pReader);
        CloseHandle(This->thread_sleepy);
        CloseHandle(This->hEventStateChanged);
        This->thread_lock.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->thread_lock);
        CoTaskMemFree(This);
        return 0;
    }
    return refCount;
}

PullPin_StartProcessing()

HRESULT PullPin_StartProcessing

(

PullPin *

This

)

Definition at line 623 of file pin.c.

{
    /* if we are connected */
    TRACE("(%p)->()\n", This);
    if(This->pAlloc)
    {
        assert(This->hThread);
 
        PullPin_WaitForStateChange(This, INFINITE);
 
        assert(This->state == Req_Sleepy);
 
        /* Wake up! */
        assert(WaitForSingleObject(This->thread_sleepy, 0) == WAIT_TIMEOUT);
        This->state = Req_Run;
        This->stop_playback = FALSE;
        ResetEvent(This->hEventStateChanged);
        SetEvent(This->thread_sleepy);
    }
 
    return S_OK;
}

Referenced by Parser_Run(), and PullPin_EndFlush().

PullPin_WaitForStateChange()

HRESULT PullPin_WaitForStateChange	(	PullPin *	This,
		DWORD	dwMilliseconds
	)

Definition at line 708 of file pin.c.

{
    if (WaitForSingleObject(This->hEventStateChanged, dwMilliseconds) == WAIT_TIMEOUT)
        return S_FALSE;
    return S_OK;
}

Referenced by Parser_Destroy(), Parser_GetState(), Parser_Stop(), PullPin_BeginFlush(), PullPin_EndFlush(), PullPin_PauseProcessing(), PullPin_StartProcessing(), and PullPin_StopProcessing().