mirror of https://github.com/mpv-player/mpv
1496 lines
40 KiB
C
1496 lines
40 KiB
C
/*
|
|
* Modified for use with MPlayer, detailed changelog at
|
|
* http://svn.mplayerhq.hu/mplayer/trunk/
|
|
* $Id$
|
|
*/
|
|
|
|
#include "inputpin.h"
|
|
#include "mediatype.h"
|
|
#include "wine/winerror.h"
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
static inline int unimplemented(const char* s, void* p)
|
|
{
|
|
Debug printf("%s(%p) called (UNIMPLEMENTED)", s, p);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/***********
|
|
* EnumPins
|
|
***********/
|
|
|
|
typedef struct
|
|
{
|
|
IEnumPins_vt* vt;
|
|
DECLARE_IUNKNOWN();
|
|
IPin* pin1;
|
|
IPin* pin2;
|
|
int counter;
|
|
GUID interfaces[2];
|
|
} CEnumPins;
|
|
|
|
/**
|
|
* \brief IEnumPins:Next (retrives a specified number of pins )
|
|
*
|
|
* \param[in] This pointer to CEnumPins object
|
|
* \param[in] cMediaTypes number of pins to retrive
|
|
* \param[out] ppMediaTypes array of IPin interface pointers of size cMediaTypes
|
|
* \param[out] pcFetched address of variables that receives number of returned pins
|
|
*
|
|
* \return S_OK - success
|
|
* \return S_FALSE - did not return as meny pins as requested
|
|
* \return E_INVALIDARG Invalid argument
|
|
* \return E_POINTER Null pointer
|
|
* \return VFW_E_ENUM_OUT_OF_SYNC - filter's state has changed and is now inconsistent with enumerator
|
|
*
|
|
*/
|
|
static long STDCALL CEnumPins_Next(IEnumPins* This,
|
|
/* [in] */ unsigned long cMediaTypes,
|
|
/* [size_is][out] */ IPin** ppMediaTypes,
|
|
/* [out] */ unsigned long* pcFetched)
|
|
{
|
|
CEnumPins* pin = (CEnumPins*)This;
|
|
|
|
Debug printf("CEnumPins_Next(%p) called\n", This);
|
|
if (!ppMediaTypes)
|
|
return E_INVALIDARG;
|
|
if (!pcFetched && (cMediaTypes!=1))
|
|
return E_INVALIDARG;
|
|
if (cMediaTypes<=0)
|
|
return 0;
|
|
|
|
//lcounter = ((CEnumPins*)This)->counter;
|
|
//lpin1 = ((CEnumPins*)This)->pin1;
|
|
//lpin2 = ((CEnumPins*)This)->pin2;
|
|
if (((pin->counter == 2) && pin->pin2)
|
|
|| ((pin->counter == 1) && !pin->pin2))
|
|
{
|
|
if (pcFetched)
|
|
*pcFetched=0;
|
|
return 1;
|
|
}
|
|
|
|
if (pcFetched)
|
|
*pcFetched=1;
|
|
if (pin->counter==0)
|
|
{
|
|
*ppMediaTypes = pin->pin1;
|
|
pin->pin1->vt->AddRef((IUnknown*)pin->pin1);
|
|
}
|
|
else
|
|
{
|
|
*ppMediaTypes = pin->pin2;
|
|
pin->pin2->vt->AddRef((IUnknown*)pin->pin2);
|
|
}
|
|
pin->counter++;
|
|
if (cMediaTypes == 1)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* \brief IEnumPins::Skip (skips over a specified number of pins)
|
|
*
|
|
* \param[in] This pointer to CEnumPinss object
|
|
* \param[in] cMediaTypes number of pins to skip
|
|
*
|
|
* \return S_OK - success
|
|
* \return S_FALSE - skipped past the end of the sequence
|
|
* \return VFW_E_ENUM_OUT_OF_SYNC - filter's state has changed and is now inconsistent with enumerator
|
|
*
|
|
*/
|
|
static long STDCALL CEnumPins_Skip(IEnumPins* This,
|
|
/* [in] */ unsigned long cMediaTypes)
|
|
{
|
|
Debug unimplemented("CEnumPins_Skip", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IEnumPins::Reset (resets enumeration sequence to beginning)
|
|
*
|
|
* \param[in] This pointer to CEnumPins object
|
|
*
|
|
* \return S_OK - success
|
|
*
|
|
*/
|
|
static long STDCALL CEnumPins_Reset(IEnumPins* This)
|
|
{
|
|
Debug printf("CEnumPins_Reset(%p) called\n", This);
|
|
((CEnumPins*)This)->counter = 0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IEnumPins::Clone (makes a copy of enumerator, returned object
|
|
* starts at the same position as original)
|
|
*
|
|
* \param[in] This pointer to CEnumPins object
|
|
* \param[out] ppEnum address of variable that receives pointer to IEnumPins interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_OUTOFMEMRY - Insufficient memory
|
|
* \return E_POINTER - Null pointer
|
|
* \return VFW_E_ENUM_OUT_OF_SYNC - filter's state has changed and is now inconsistent with enumerator
|
|
*
|
|
*/
|
|
static long STDCALL CEnumPins_Clone(IEnumPins* This,
|
|
/* [out] */ IEnumPins** ppEnum)
|
|
{
|
|
Debug unimplemented("CEnumPins_Clone", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief CEnumPins destructor
|
|
*
|
|
* \param[in] This pointer to CEnumPins object
|
|
*
|
|
*/
|
|
static void CEnumPins_Destroy(CEnumPins* This)
|
|
{
|
|
free(This->vt);
|
|
free(This);
|
|
}
|
|
|
|
IMPLEMENT_IUNKNOWN(CEnumPins)
|
|
|
|
/**
|
|
* \brief CEnumPins constructor
|
|
*
|
|
* \param[in] p first pin for enumerator
|
|
* \param[in] pp second pin for enumerator
|
|
*
|
|
* \return pointer to CEnumPins object or NULL if error occured
|
|
*
|
|
*/
|
|
static CEnumPins* CEnumPinsCreate(IPin* p, IPin* pp)
|
|
{
|
|
CEnumPins* This = (CEnumPins*) malloc(sizeof(CEnumPins));
|
|
|
|
if (!This)
|
|
return NULL;
|
|
|
|
This->refcount = 1;
|
|
This->pin1 = p;
|
|
This->pin2 = pp;
|
|
This->counter = 0;
|
|
|
|
This->vt = (IEnumPins_vt*) malloc(sizeof(IEnumPins_vt));
|
|
if (!This->vt)
|
|
{
|
|
free(This);
|
|
return NULL;
|
|
}
|
|
This->vt->QueryInterface = CEnumPins_QueryInterface;
|
|
This->vt->AddRef = CEnumPins_AddRef;
|
|
This->vt->Release = CEnumPins_Release;
|
|
This->vt->Next = CEnumPins_Next;
|
|
This->vt->Skip = CEnumPins_Skip;
|
|
This->vt->Reset = CEnumPins_Reset;
|
|
This->vt->Clone = CEnumPins_Clone;
|
|
|
|
This->interfaces[0] = IID_IUnknown;
|
|
This->interfaces[1] = IID_IEnumPins;
|
|
|
|
return This;
|
|
}
|
|
|
|
|
|
|
|
/***********
|
|
* InputPin
|
|
*
|
|
* WARNING:
|
|
* This is implementation of OUTPUT pin in DirectShow's terms
|
|
*
|
|
***********/
|
|
|
|
/**
|
|
* \brief IPin::Connect (connects pin to another pin)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[in] pReceivePin pointer to IPin interface of remote pin
|
|
* \param[in] pmt suggested media type for link. Can be NULL (any media type)
|
|
*
|
|
* \return S_OK - success.
|
|
* \return VFW_E_ALREADY_CONNECTED - pin already connected
|
|
* \return VFW_E_NOT_STOPPED - filter is active
|
|
* \return VFW_E_TYPE_NOT_ACCEPT - type is not acceptable
|
|
* \return Apropriate error code otherwise.
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_Connect(IPin* This,
|
|
/* [in] */ IPin* pReceivePin,
|
|
/* [in] */ AM_MEDIA_TYPE* pmt)
|
|
{
|
|
Debug unimplemented("CInputPin_Connect", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::ReceiveConnection (accepts a connection from another pin)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[in] pConnector connecting pin's IPin interface
|
|
* \param[in] pmt suggested media type for connection
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
* \return VFW_E_ALREADY_CONNECTED - pin already connected
|
|
* \return VFW_E_NOT_STOPPED - filter is active
|
|
* \return VFW_E_TYPE_NOT_ACCEPT - type is not acceptable
|
|
*
|
|
* \note
|
|
* When returning S_OK method should also do the following:
|
|
* - store media type and return the same type in IPin::ConnectionMediaType
|
|
* - store pConnector and return it in IPin::ConnectedTo
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_ReceiveConnection(IPin* This,
|
|
/* [in] */ IPin* pConnector,
|
|
/* [in] */ const AM_MEDIA_TYPE *pmt)
|
|
{
|
|
Debug unimplemented("CInputPin_ReceiveConnection", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::Disconnect (accepts a connection from another pin)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return S_FALSE - pin was not connected
|
|
* \return VFW_E_NOT_STOPPED - filter is active
|
|
*
|
|
* \note
|
|
* To break connection you have to also call Disconnect on other pin
|
|
*/
|
|
static long STDCALL CInputPin_Disconnect(IPin* This)
|
|
{
|
|
Debug unimplemented("CInputPin_Disconnect", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::ConnectedTo (retrieves pointer to the connected pin, if such exist)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pPin pointer to remote pin's IPin interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
* \return VFW_E_NOT_CONNECTED - pin is not connected
|
|
*
|
|
* \note
|
|
* Caller must call Release on received IPin, when done
|
|
*/
|
|
static long STDCALL CInputPin_ConnectedTo(IPin* This,
|
|
/* [out] */ IPin** pPin)
|
|
{
|
|
Debug unimplemented("CInputPin_ConnectedTo", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::ConnectionMediaType (retrieves media type for connection, if such exist)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pmt pointer to AM_MEDIA_TYPE, that receives connection media type
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
* \return VFW_E_NOT_CONNECTED - pin is not connected
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_ConnectionMediaType(IPin* This,
|
|
/* [out] */ AM_MEDIA_TYPE *pmt)
|
|
{
|
|
Debug printf("CInputPin_ConnectionMediaType(%p) called\n", This);
|
|
if (!pmt)
|
|
return E_INVALIDARG;
|
|
CopyMediaType(pmt,&(((CInputPin*)This)->type));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryPinInfo (retrieves information about the pin)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pInfo pointer to PIN_INFO structure, that receives pin info
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
* \note
|
|
* If pInfo->pFilter is not NULL, then caller must call Release on pInfo->pFilter when done
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_QueryPinInfo(IPin* This,
|
|
/* [out] */ PIN_INFO *pInfo)
|
|
{
|
|
CBaseFilter* lparent=((CInputPin*)This)->parent;
|
|
Debug printf("CInputPin_QueryPinInfo(%p) called\n", This);
|
|
pInfo->dir = PINDIR_OUTPUT;
|
|
pInfo->pFilter = (IBaseFilter*) lparent;
|
|
lparent->vt->AddRef((IUnknown*)lparent);
|
|
pInfo->achName[0] = 0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryDirection (retrieves pin direction)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pPinDir pointer to variable, that receives pin direction (PINDIR_INPUT,PINDIR_OUTPUT)
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_QueryDirection(IPin* This,
|
|
/* [out] */ PIN_DIRECTION *pPinDir)
|
|
{
|
|
*pPinDir = PINDIR_OUTPUT;
|
|
Debug printf("CInputPin_QueryDirection(%p) called\n", This);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryId (retrieves pin identificator)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] Id adress of variable, that receives string with pin's Id.
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_OUTOFMEMORY - Insufficient memory
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
* \note
|
|
* Pin's Id is not the same as pin's name
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_QueryId(IPin* This,
|
|
/* [out] */ unsigned short* *Id)
|
|
{
|
|
Debug unimplemented("CInputPin_QueryId", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryAccept (determines can media type be accepted or not)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[in] pmt Media type to check
|
|
*
|
|
* \return S_OK - success
|
|
* \return S_FALSE - pin rejects media type
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_QueryAccept(IPin* This,
|
|
/* [in] */ const AM_MEDIA_TYPE* pmt)
|
|
{
|
|
Debug unimplemented("CInputPin_QueryAccept", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::EnumMediaTypes (enumerates the pin's preferred media types)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] ppEnum adress of variable that receives pointer to IEnumMEdiaTypes interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_OUTOFMEMORY - Insufficient memory
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
* \note
|
|
* Caller must call Release on received interface when done
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_EnumMediaTypes(IPin* This,
|
|
/* [out] */ IEnumMediaTypes** ppEnum)
|
|
{
|
|
Debug unimplemented("CInputPin_EnumMediaTypes", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryInternalConnections (retries pin's internal connections)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] apPin Array that receives pins, internally connected to this
|
|
* \param[in,out] nPint Size of an array
|
|
*
|
|
* \return S_OK - success
|
|
* \return S_FALSE - pin rejects media type
|
|
* \return E_NOTIMPL - not implemented
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_QueryInternalConnections(IPin* This,
|
|
/* [out] */ IPin** apPin,
|
|
/* [out][in] */ unsigned long *nPin)
|
|
{
|
|
Debug unimplemented("CInputPin_QueryInternalConnections", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::EndOfStream (notifies pin, that no data is expected, until new run command)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_UNEXPECTED - The pin is output pin
|
|
*
|
|
* \note
|
|
* IMemoryInputPin::Receive,IMemoryInputPin::ReceiveMultiple, IMemoryInputPin::EndOfStream,
|
|
* IMemAllocator::GetBuffer runs in different (streaming) thread then other
|
|
* methods (application thread).
|
|
* IMemoryInputPin::NewSegment runs either in streaming or application thread.
|
|
* Developer must use critical sections for thread-safing work.
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_EndOfStream(IPin * This)
|
|
{
|
|
Debug unimplemented("CInputPin_EndOfStream", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief IPin::BeginFlush (begins a flush operation)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_UNEXPECTED - The pin is output pin
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_BeginFlush(IPin * This)
|
|
{
|
|
Debug unimplemented("CInputPin_BeginFlush", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief IPin::EndFlush (ends a flush operation)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_UNEXPECTED - The pin is output pin
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_EndFlush(IPin* This)
|
|
{
|
|
Debug unimplemented("CInputPin_EndFlush", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::NewSegment (media sample received after this call grouped as segment with common
|
|
* start,stop time and rate)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[in] tStart start time of new segment
|
|
* \param[in] tStop end time of new segment
|
|
* \param[in] dRate rate at wich segment should be processed
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_UNEXPECTED - The pin is output pin
|
|
*
|
|
*/
|
|
static long STDCALL CInputPin_NewSegment(IPin* This,
|
|
/* [in] */ REFERENCE_TIME tStart,
|
|
/* [in] */ REFERENCE_TIME tStop,
|
|
/* [in] */ double dRate)
|
|
{
|
|
Debug unimplemented("CInputPin_NewSegment", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief CInputPin destructor
|
|
*
|
|
* \param[in] This pointer to CInputPin class
|
|
*
|
|
*/
|
|
static void CInputPin_Destroy(CInputPin* This)
|
|
{
|
|
free(This->vt);
|
|
FreeMediaType(&(This->type));
|
|
free(This);
|
|
}
|
|
|
|
IMPLEMENT_IUNKNOWN(CInputPin)
|
|
|
|
/**
|
|
* \brief CInputPin constructor
|
|
*
|
|
* \param[in] amt media type for pin
|
|
*
|
|
* \return pointer to CInputPin if success
|
|
* \return NULL if error occured
|
|
*
|
|
*/
|
|
CInputPin* CInputPinCreate(CBaseFilter* p, const AM_MEDIA_TYPE* amt)
|
|
{
|
|
CInputPin* This = (CInputPin*) malloc(sizeof(CInputPin));
|
|
|
|
if (!This)
|
|
return NULL;
|
|
|
|
This->refcount = 1;
|
|
This->parent = p;
|
|
CopyMediaType(&(This->type),amt);
|
|
|
|
This->vt= (IPin_vt*) malloc(sizeof(IPin_vt));
|
|
|
|
if (!This->vt)
|
|
{
|
|
free(This);
|
|
return NULL;
|
|
}
|
|
|
|
This->vt->QueryInterface = CInputPin_QueryInterface;
|
|
This->vt->AddRef = CInputPin_AddRef;
|
|
This->vt->Release = CInputPin_Release;
|
|
This->vt->Connect = CInputPin_Connect;
|
|
This->vt->ReceiveConnection = CInputPin_ReceiveConnection;
|
|
This->vt->Disconnect = CInputPin_Disconnect;
|
|
This->vt->ConnectedTo = CInputPin_ConnectedTo;
|
|
This->vt->ConnectionMediaType = CInputPin_ConnectionMediaType;
|
|
This->vt->QueryPinInfo = CInputPin_QueryPinInfo;
|
|
This->vt->QueryDirection = CInputPin_QueryDirection;
|
|
This->vt->QueryId = CInputPin_QueryId;
|
|
This->vt->QueryAccept = CInputPin_QueryAccept;
|
|
This->vt->EnumMediaTypes = CInputPin_EnumMediaTypes;
|
|
This->vt->QueryInternalConnections = CInputPin_QueryInternalConnections;
|
|
This->vt->EndOfStream = CInputPin_EndOfStream;
|
|
This->vt->BeginFlush = CInputPin_BeginFlush;
|
|
This->vt->EndFlush = CInputPin_EndFlush;
|
|
This->vt->NewSegment = CInputPin_NewSegment;
|
|
|
|
This->interfaces[0]=IID_IUnknown;
|
|
|
|
return This;
|
|
}
|
|
|
|
|
|
/*************
|
|
* BaseFilter
|
|
*************/
|
|
|
|
static long STDCALL CBaseFilter_GetClassID(IBaseFilter * This,
|
|
/* [out] */ CLSID *pClassID)
|
|
{
|
|
Debug unimplemented("CBaseFilter_GetClassID", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::Stop (stops the filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
*
|
|
* \return S_OK success
|
|
* \return S_FALSE transition is not complete
|
|
*
|
|
* \remarks
|
|
* When filter is stopped it does onot deliver or process any samples and rejects any samples
|
|
* from upstream filter.
|
|
* Transition may be asynchronous. In this case method should return S_FALSE.
|
|
* Method always sets filter's state to State_Stopped even if error occured.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_Stop(IBaseFilter* This)
|
|
{
|
|
Debug unimplemented("CBaseFilter_Stop", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::Pause (pauses filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
*
|
|
* \return S_OK success
|
|
* \return S_FALSE transition is not complete
|
|
*
|
|
* \remarks
|
|
* When filter is paused it can receive, process and deliver samples.
|
|
* Live source filters do not deliver any samples while paused.
|
|
* Transition may be asynchronous. In this case method should return S_FALSE.
|
|
* Method always sets filter's state to State_Stopped even if error occured.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_Pause(IBaseFilter* This)
|
|
{
|
|
Debug unimplemented("CBaseFilter_Pause", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::Run (runs the filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] tStart Reference time corresponding to stream time 0.
|
|
*
|
|
* \return S_OK success
|
|
* \return S_FALSE transition is not complete
|
|
*
|
|
* \remarks
|
|
* When filter is running it can receive, process and deliver samples. Source filters
|
|
* generatesnew samples, and renderers renders them.
|
|
* Stream time is calculated as the current reference time minus tStart.
|
|
* Graph Manager sets tStart slightly in the future according to graph latency.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_Run(IBaseFilter* This, REFERENCE_TIME tStart)
|
|
{
|
|
Debug unimplemented("CBaseFilter_Run", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::GetState (retrieves the filter's state (running, stopped or paused))
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] dwMilliSecsTimeout Timeout interval in milliseconds. To block indifinitely pass
|
|
* INFINITE.
|
|
* \param[out] State pointer to variable that receives a member of FILTER_STATE enumeration.
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
* \return VFW_S_STATE_INTERMEDATE Intermediate state
|
|
* \return VFW_S_CANT_CUE The filter is active, but cannot deliver data.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_GetState(IBaseFilter* This,
|
|
/* [in] */ unsigned long dwMilliSecsTimeout,
|
|
// /* [out] */ FILTER_STATE *State)
|
|
void* State)
|
|
{
|
|
Debug unimplemented("CBaseFilter_GetState", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::SetSyncSource (sets the reference clock)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] pClock IReferenceClock interface of reference clock
|
|
*
|
|
* \return S_OK success
|
|
* \return apripriate error otherwise
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_SetSyncSource(IBaseFilter* This,
|
|
/* [in] */ IReferenceClock *pClock)
|
|
{
|
|
Debug unimplemented("CBaseFilter_SetSyncSource", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediafilter::GetSyncSource (gets current reference clock)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] pClock address of variable that receives pointer to clock's
|
|
* IReferenceClock interface
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_GetSyncSource(IBaseFilter* This,
|
|
/* [out] */ IReferenceClock **pClock)
|
|
{
|
|
Debug unimplemented("CBaseFilter_GetSyncSource", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief IBaseFilter::EnumPins (enumerates the pins of this filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] ppEnum address of variable that receives pointer to IEnumPins interface
|
|
*
|
|
* \return S_OK success
|
|
* \return E_OUTOFMEMORY Insufficient memory
|
|
* \return E_POINTER Null pointer
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_EnumPins(IBaseFilter* This,
|
|
/* [out] */ IEnumPins **ppEnum)
|
|
{
|
|
Debug printf("CBaseFilter_EnumPins(%p) called\n", This);
|
|
*ppEnum = (IEnumPins*) CEnumPinsCreate(((CBaseFilter*)This)->pin, ((CBaseFilter*)This)->unused_pin);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::FindPin (retrieves the pin with specified id)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] Id constant wide string, containing pin id
|
|
* \param[out] ppPin address of variable that receives pointer to pin's IPin interface
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
* \return VFW_E_NOT_FOUND Could not find a pin with specified id
|
|
*
|
|
* \note
|
|
* Be sure to release the interface after use.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_FindPin(IBaseFilter* This,
|
|
/* [string][in] */ const unsigned short* Id,
|
|
/* [out] */ IPin **ppPin)
|
|
{
|
|
Debug unimplemented("CBaseFilter_FindPin\n", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::QueryFilterInfo (retrieves information aboud the filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] pInfo pointer to FILTER_INFO structure
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
*
|
|
* \note
|
|
* If pGraph member of FILTER_INFO is not NULL, be sure to release IFilterGraph interface after use.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_QueryFilterInfo(IBaseFilter* This,
|
|
// /* [out] */ FILTER_INFO *pInfo)
|
|
void* pInfo)
|
|
{
|
|
Debug unimplemented("CBaseFilter_QueryFilterInfo", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::JoinFilterGraph (notifies the filter that it has joined of left filter graph)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] pInfo pointer to graph's IFilterGraph interface or NULL if filter is leaving graph
|
|
* \param[in] pName pointer to wide character string that specifies a name for the filter
|
|
*
|
|
* \return S_OK success
|
|
* \return apropriate error code otherwise
|
|
*
|
|
* \remarks
|
|
* Filter should not call to graph's AddRef method.
|
|
* The IFilterGraph is guaranteed to be valid until graph manager calls this method again with
|
|
* the value NULL.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_JoinFilterGraph(IBaseFilter* This,
|
|
/* [in] */ IFilterGraph* pGraph,
|
|
/* [string][in] */ const unsigned short* pName)
|
|
{
|
|
Debug unimplemented("CBaseFilter_JoinFilterGraph", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::QueryVendorInfo (retrieves a string containing vendor info)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] address of variable that receives pointer to a string containing vendor info
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
* \return E_NOTIMPL Not implemented
|
|
*
|
|
* \remarks
|
|
* Call to CoTaskMemFree to free memory allocated for string
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter_QueryVendorInfo(IBaseFilter* This,
|
|
/* [string][out] */ unsigned short** pVendorInfo)
|
|
{
|
|
Debug unimplemented("CBaseFilter_QueryVendorInfo", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief CBaseFilter::GetPin (gets used pin)
|
|
*
|
|
* \param[in] This pointer to CBaseFilter object
|
|
*
|
|
* \return pointer to used pin's IPin interface
|
|
*
|
|
*/
|
|
static IPin* CBaseFilter_GetPin(CBaseFilter* This)
|
|
{
|
|
return This->pin;
|
|
}
|
|
|
|
/**
|
|
* \brief CBaseFilter::GetUnusedPin (gets used pin)
|
|
*
|
|
* \param[in] This pointer to CBaseFilter object
|
|
*
|
|
* \return pointer to unused pin's IPin interface
|
|
*
|
|
*/
|
|
static IPin* CBaseFilter_GetUnusedPin(CBaseFilter* This)
|
|
{
|
|
return This->unused_pin;
|
|
}
|
|
|
|
/**
|
|
* \brief CBaseFilter destructor
|
|
*
|
|
* \param[in] This pointer to CBaseFilter object
|
|
*
|
|
*/
|
|
static void CBaseFilter_Destroy(CBaseFilter* This)
|
|
{
|
|
if (This->vt)
|
|
free(This->vt);
|
|
if (This->pin)
|
|
This->pin->vt->Release((IUnknown*)This->pin);
|
|
if (This->unused_pin)
|
|
This->unused_pin->vt->Release((IUnknown*)This->unused_pin);
|
|
free(This);
|
|
}
|
|
|
|
IMPLEMENT_IUNKNOWN(CBaseFilter)
|
|
|
|
/**
|
|
* \brief CBaseFilter constructor
|
|
*
|
|
* \param[in] type Pointer to media type for connection
|
|
* \param[in] parent Pointer to parent CBaseFilter2 object
|
|
*
|
|
* \return pointer to CBaseFilter object or NULL if error occured
|
|
*
|
|
*/
|
|
CBaseFilter* CBaseFilterCreate(const AM_MEDIA_TYPE* type, CBaseFilter2* parent)
|
|
{
|
|
CBaseFilter* This = (CBaseFilter*) malloc(sizeof(CBaseFilter));
|
|
if (!This)
|
|
return NULL;
|
|
|
|
This->refcount = 1;
|
|
|
|
This->pin = (IPin*) CInputPinCreate(This, type);
|
|
This->unused_pin = (IPin*) CRemotePinCreate(This, parent->GetPin(parent));
|
|
|
|
This->vt = (IBaseFilter_vt*) malloc(sizeof(IBaseFilter_vt));
|
|
if (!This->vt || !This->pin || !This->unused_pin)
|
|
{
|
|
CBaseFilter_Destroy(This);
|
|
return NULL;
|
|
}
|
|
|
|
This->vt->QueryInterface = CBaseFilter_QueryInterface;
|
|
This->vt->AddRef = CBaseFilter_AddRef;
|
|
This->vt->Release = CBaseFilter_Release;
|
|
This->vt->GetClassID = CBaseFilter_GetClassID;
|
|
This->vt->Stop = CBaseFilter_Stop;
|
|
This->vt->Pause = CBaseFilter_Pause;
|
|
This->vt->Run = CBaseFilter_Run;
|
|
This->vt->GetState = CBaseFilter_GetState;
|
|
This->vt->SetSyncSource = CBaseFilter_SetSyncSource;
|
|
This->vt->GetSyncSource = CBaseFilter_GetSyncSource;
|
|
This->vt->EnumPins = CBaseFilter_EnumPins;
|
|
This->vt->FindPin = CBaseFilter_FindPin;
|
|
This->vt->QueryFilterInfo = CBaseFilter_QueryFilterInfo;
|
|
This->vt->JoinFilterGraph = CBaseFilter_JoinFilterGraph;
|
|
This->vt->QueryVendorInfo = CBaseFilter_QueryVendorInfo;
|
|
|
|
This->interfaces[0] = IID_IUnknown;
|
|
This->interfaces[1] = IID_IBaseFilter;
|
|
|
|
This->GetPin = CBaseFilter_GetPin;
|
|
This->GetUnusedPin = CBaseFilter_GetUnusedPin;
|
|
|
|
return This;
|
|
}
|
|
|
|
|
|
/**************
|
|
* BaseFilter2
|
|
**************/
|
|
|
|
|
|
static long STDCALL CBaseFilter2_GetClassID(IBaseFilter* This,
|
|
/* [out] */ CLSID* pClassID)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_GetClassID", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::Stop (stops the filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
*
|
|
* \return S_OK success
|
|
* \return S_FALSE transition is not complete
|
|
*
|
|
* \remarks
|
|
* When filter is stopped it does onot deliver or process any samples and rejects any samples
|
|
* from upstream filter.
|
|
* Transition may be asynchronous. In this case method should return S_FALSE.
|
|
* Method always sets filter's state to State_Stopped even if error occured.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_Stop(IBaseFilter* This)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_Stop", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::Pause (pauses filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
*
|
|
* \return S_OK success
|
|
* \return S_FALSE transition is not complete
|
|
*
|
|
* \remarks
|
|
* When filter is paused it can receive, process and deliver samples.
|
|
* Live source filters do not deliver any samples while paused.
|
|
* Transition may be asynchronous. In this case method should return S_FALSE.
|
|
* Method always sets filter's state to State_Stopped even if error occured.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_Pause(IBaseFilter* This)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_Pause", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::Run (runs the filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] tStart Reference time corresponding to stream time 0.
|
|
*
|
|
* \return S_OK success
|
|
* \return S_FALSE transition is not complete
|
|
*
|
|
* \remarks
|
|
* When filter is running it can receive, process and deliver samples. Source filters
|
|
* generatesnew samples, and renderers renders them.
|
|
* Stream time is calculated as the current reference time minus tStart.
|
|
* Graph Manager sets tStart slightly in the future according to graph latency.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_Run(IBaseFilter* This, REFERENCE_TIME tStart)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_Run", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
/**
|
|
* \brief IMediaFilter::GetState (retrieves the filter's state (running, stopped or paused))
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] dwMilliSecsTimeout Timeout interval in milliseconds. To block indifinitely pass
|
|
* INFINITE.
|
|
* \param[out] State pointer to variable that receives a member of FILTER_STATE enumeration.
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
* \return VFW_S_STATE_INTERMEDATE Intermediate state
|
|
* \return VFW_S_CANT_CUE The filter is active, but cannot deliver data.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_GetState(IBaseFilter* This,
|
|
/* [in] */ unsigned long dwMilliSecsTimeout,
|
|
// /* [out] */ FILTER_STATE *State)
|
|
void* State)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_GetState", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediaFilter::SetSyncSource (sets the reference clock)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] pClock IReferenceClock interface of reference clock
|
|
*
|
|
* \return S_OK success
|
|
* \return apripriate error otherwise
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_SetSyncSource(IBaseFilter* This,
|
|
/* [in] */ IReferenceClock* pClock)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_SetSyncSource", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IMediafilter::GetSyncSource (gets current reference clock)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] pClock address of variable that receives pointer to clock's
|
|
* IReferenceClock interface
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_GetSyncSource(IBaseFilter* This,
|
|
/* [out] */ IReferenceClock** pClock)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_GetSyncSource", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::EnumPins (enumerates the pins of this filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] ppEnum address of variable that receives pointer to IEnumPins interface
|
|
*
|
|
* \return S_OK success
|
|
* \return E_OUTOFMEMORY Insufficient memory
|
|
* \return E_POINTER Null pointer
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_EnumPins(IBaseFilter* This,
|
|
/* [out] */ IEnumPins** ppEnum)
|
|
{
|
|
Debug printf("CBaseFilter2_EnumPins(%p) called\n", This);
|
|
*ppEnum = (IEnumPins*) CEnumPinsCreate(((CBaseFilter2*)This)->pin, 0);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::FindPin (retrieves the pin with specified id)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] Id constant wide string, containing pin id
|
|
* \param[out] ppPin address of variable that receives pointer to pin's IPin interface
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
* \return VFW_E_NOT_FOUND Could not find a pin with specified id
|
|
*
|
|
* \note
|
|
* Be sure to release the interface after use.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_FindPin(IBaseFilter* This,
|
|
/* [string][in] */ const unsigned short* Id,
|
|
/* [out] */ IPin** ppPin)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_FindPin", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::QueryFilterInfo (retrieves information aboud the filter)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] pInfo pointer to FILTER_INFO structure
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
*
|
|
* \note
|
|
* If pGraph member of FILTER_INFO is not NULL, be sure to release IFilterGraph interface after use.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_QueryFilterInfo(IBaseFilter* This,
|
|
// /* [out] */ FILTER_INFO *pInfo)
|
|
void* pInfo)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_QueryFilterInfo", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::JoinFilterGraph (notifies the filter that it has joined of left filter graph)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[in] pInfo pointer to graph's IFilterGraph interface or NULL if filter is leaving graph
|
|
* \param[in] pName pointer to wide character string that specifies a name for the filter
|
|
*
|
|
* \return S_OK success
|
|
* \return apropriate error code otherwise
|
|
*
|
|
* \remarks
|
|
* Filter should not call to graph's AddRef method.
|
|
* The IFilterGraph is guaranteed to be valid until graph manager calls this method again with
|
|
* the value NULL.
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_JoinFilterGraph(IBaseFilter* This,
|
|
/* [in] */ IFilterGraph* pGraph,
|
|
/* [string][in] */
|
|
const unsigned short* pName)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_JoinFilterGraph", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IBaseFilter::QueryVendorInfo (retrieves a string containing vendor info)
|
|
*
|
|
* \param[in] This pointer to IBaseFilter interface
|
|
* \param[out] address of variable that receives pointer to a string containing vendor info
|
|
*
|
|
* \return S_OK success
|
|
* \return E_POINTER Null pointer
|
|
* \return E_NOTIMPL Not implemented
|
|
*
|
|
* \remarks
|
|
* Call to CoTaskMemFree to free memory allocated for string
|
|
*
|
|
*/
|
|
static long STDCALL CBaseFilter2_QueryVendorInfo(IBaseFilter* This,
|
|
/* [string][out] */
|
|
unsigned short** pVendorInfo)
|
|
{
|
|
Debug unimplemented("CBaseFilter2_QueryVendorInfo", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief CBaseFilter2::GetPin (gets used pin)
|
|
*
|
|
* \param[in] This pointer to CBaseFilter2 object
|
|
*
|
|
* \return pointer to used pin's IPin interface
|
|
*
|
|
*/
|
|
static IPin* CBaseFilter2_GetPin(CBaseFilter2* This)
|
|
{
|
|
return This->pin;
|
|
}
|
|
|
|
/**
|
|
* \brief CBaseFilter2 destructor
|
|
*
|
|
* \param[in] This pointer to CBaseFilter2 object
|
|
*
|
|
*/
|
|
static void CBaseFilter2_Destroy(CBaseFilter2* This)
|
|
{
|
|
Debug printf("CBaseFilter2_Destroy(%p) called\n", This);
|
|
if (This->pin)
|
|
This->pin->vt->Release((IUnknown*) This->pin);
|
|
if (This->vt)
|
|
free(This->vt);
|
|
free(This);
|
|
}
|
|
|
|
IMPLEMENT_IUNKNOWN(CBaseFilter2)
|
|
|
|
static GUID CBaseFilter2_interf1 =
|
|
{0x76c61a30, 0xebe1, 0x11cf, {0x89, 0xf9, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb}};
|
|
/// IID_IAMNetShowPreroll
|
|
static GUID CBaseFilter2_interf2 =
|
|
{0xaae7e4e2, 0x6388, 0x11d1, {0x8d, 0x93, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2}};
|
|
/// IID_IAMRebuild
|
|
static GUID CBaseFilter2_interf3 =
|
|
{0x02ef04dd, 0x7580, 0x11d1, {0xbe, 0xce, 0x00, 0xc0, 0x4f, 0xb6, 0xe9, 0x37}};
|
|
|
|
/**
|
|
* \brief CBaseFilter2 constructor
|
|
*
|
|
* \return pointer to CBaseFilter2 object or NULL if error occured
|
|
*
|
|
*/
|
|
CBaseFilter2* CBaseFilter2Create()
|
|
{
|
|
CBaseFilter2* This = (CBaseFilter2*) malloc(sizeof(CBaseFilter2));
|
|
|
|
if (!This)
|
|
return NULL;
|
|
|
|
This->refcount = 1;
|
|
This->pin = (IPin*) CRemotePin2Create(This);
|
|
|
|
This->vt = (IBaseFilter_vt*) malloc(sizeof(IBaseFilter_vt));
|
|
|
|
if (!This->pin || !This->vt)
|
|
{
|
|
CBaseFilter2_Destroy(This);
|
|
return NULL;
|
|
}
|
|
|
|
memset(This->vt, 0, sizeof(IBaseFilter_vt));
|
|
This->vt->QueryInterface = CBaseFilter2_QueryInterface;
|
|
This->vt->AddRef = CBaseFilter2_AddRef;
|
|
This->vt->Release = CBaseFilter2_Release;
|
|
This->vt->GetClassID = CBaseFilter2_GetClassID;
|
|
This->vt->Stop = CBaseFilter2_Stop;
|
|
This->vt->Pause = CBaseFilter2_Pause;
|
|
This->vt->Run = CBaseFilter2_Run;
|
|
This->vt->GetState = CBaseFilter2_GetState;
|
|
This->vt->SetSyncSource = CBaseFilter2_SetSyncSource;
|
|
This->vt->GetSyncSource = CBaseFilter2_GetSyncSource;
|
|
This->vt->EnumPins = CBaseFilter2_EnumPins;
|
|
This->vt->FindPin = CBaseFilter2_FindPin;
|
|
This->vt->QueryFilterInfo = CBaseFilter2_QueryFilterInfo;
|
|
This->vt->JoinFilterGraph = CBaseFilter2_JoinFilterGraph;
|
|
This->vt->QueryVendorInfo = CBaseFilter2_QueryVendorInfo;
|
|
|
|
This->GetPin = CBaseFilter2_GetPin;
|
|
|
|
This->interfaces[0] = IID_IUnknown;
|
|
This->interfaces[1] = IID_IBaseFilter;
|
|
This->interfaces[2] = CBaseFilter2_interf1;
|
|
This->interfaces[3] = CBaseFilter2_interf2;
|
|
This->interfaces[4] = CBaseFilter2_interf3;
|
|
|
|
return This;
|
|
}
|
|
|
|
|
|
/*************
|
|
* CRemotePin
|
|
*************/
|
|
|
|
|
|
/**
|
|
* \brief IPin::ConnectedTo (retrieves pointer to the connected pin, if such exist)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pPin pointer to remote pin's IPin interface
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
* \return VFW_E_NOT_CONNECTED - pin is not connected
|
|
*
|
|
* \note
|
|
* Caller must call Release on received IPin, when done
|
|
*/
|
|
static long STDCALL CRemotePin_ConnectedTo(IPin* This, /* [out] */ IPin** pPin)
|
|
{
|
|
Debug printf("CRemotePin_ConnectedTo(%p) called\n", This);
|
|
if (!pPin)
|
|
return E_INVALIDARG;
|
|
*pPin = ((CRemotePin*)This)->remote_pin;
|
|
(*pPin)->vt->AddRef((IUnknown*)(*pPin));
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryDirection (retrieves pin direction)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pPinDir pointer to variable, that receives pin direction (PINDIR_INPUT,PINDIR_OUTPUT)
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
*/
|
|
static long STDCALL CRemotePin_QueryDirection(IPin* This,
|
|
/* [out] */ PIN_DIRECTION* pPinDir)
|
|
{
|
|
Debug printf("CRemotePin_QueryDirection(%p) called\n", This);
|
|
if (!pPinDir)
|
|
return E_INVALIDARG;
|
|
*pPinDir=PINDIR_INPUT;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::ConnectionMediaType (retrieves media type for connection, if such exist)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pmt pointer to AM_MEDIA_TYPE, that receives connection media type
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
* \return VFW_E_NOT_CONNECTED - pin is not connected
|
|
*
|
|
*/
|
|
static long STDCALL CRemotePin_ConnectionMediaType(IPin* This, /* [out] */ AM_MEDIA_TYPE* pmt)
|
|
{
|
|
Debug unimplemented("CRemotePin_ConnectionMediaType", This);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
/**
|
|
* \brief IPin::QueryPinInfo (retrieves information about the pin)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pInfo pointer to PIN_INFO structure, that receives pin info
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
* \note
|
|
* If pInfo->pFilter is not NULL, then caller must call Release on pInfo->pFilter when done
|
|
*
|
|
*/
|
|
static long STDCALL CRemotePin_QueryPinInfo(IPin* This, /* [out] */ PIN_INFO* pInfo)
|
|
{
|
|
CBaseFilter* lparent = ((CRemotePin*)This)->parent;
|
|
Debug printf("CRemotePin_QueryPinInfo(%p) called\n", This);
|
|
pInfo->dir= PINDIR_INPUT;
|
|
pInfo->pFilter = (IBaseFilter*) lparent;
|
|
lparent->vt->AddRef((IUnknown*)lparent);
|
|
pInfo->achName[0]=0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief CRemotePin destructor
|
|
*
|
|
* \param[in] This pointer to CRemotePin object
|
|
*
|
|
*/
|
|
static void CRemotePin_Destroy(CRemotePin* This)
|
|
{
|
|
Debug printf("CRemotePin_Destroy(%p) called\n", This);
|
|
free(This->vt);
|
|
free(This);
|
|
}
|
|
|
|
IMPLEMENT_IUNKNOWN(CRemotePin)
|
|
|
|
/**
|
|
* \brief CRemotePin constructor
|
|
*
|
|
* \param[in] pt parent filter
|
|
* \param[in] rpin remote pin
|
|
*
|
|
* \return pointer to CRemotePin or NULL if error occured
|
|
*
|
|
*/
|
|
CRemotePin* CRemotePinCreate(CBaseFilter* pt, IPin* rpin)
|
|
{
|
|
CRemotePin* This = (CRemotePin*) malloc(sizeof(CRemotePin));
|
|
|
|
if (!This)
|
|
return NULL;
|
|
|
|
Debug printf("CRemotePinCreate() called -> %p\n", This);
|
|
|
|
This->parent = pt;
|
|
This->remote_pin = rpin;
|
|
This->refcount = 1;
|
|
|
|
This->vt = (IPin_vt*) malloc(sizeof(IPin_vt));
|
|
|
|
if (!This->vt)
|
|
{
|
|
free(This);
|
|
return NULL;
|
|
}
|
|
|
|
memset(This->vt, 0, sizeof(IPin_vt));
|
|
This->vt->QueryInterface = CRemotePin_QueryInterface;
|
|
This->vt->AddRef = CRemotePin_AddRef;
|
|
This->vt->Release = CRemotePin_Release;
|
|
This->vt->QueryDirection = CRemotePin_QueryDirection;
|
|
This->vt->ConnectedTo = CRemotePin_ConnectedTo;
|
|
This->vt->ConnectionMediaType = CRemotePin_ConnectionMediaType;
|
|
This->vt->QueryPinInfo = CRemotePin_QueryPinInfo;
|
|
|
|
This->interfaces[0] = IID_IUnknown;
|
|
|
|
return This;
|
|
}
|
|
|
|
|
|
/*************
|
|
* CRemotePin2
|
|
*************/
|
|
|
|
|
|
/**
|
|
* \brief IPin::QueryPinInfo (retrieves information about the pin)
|
|
*
|
|
* \param[in] This pointer to IPin interface
|
|
* \param[out] pInfo pointer to PIN_INFO structure, that receives pin info
|
|
*
|
|
* \return S_OK - success
|
|
* \return E_POINTER - Null pointer
|
|
*
|
|
* \note
|
|
* If pInfo->pFilter is not NULL, then caller must call Release on pInfo->pFilter when done
|
|
*
|
|
*/
|
|
static long STDCALL CRemotePin2_QueryPinInfo(IPin* This,
|
|
/* [out] */ PIN_INFO* pInfo)
|
|
{
|
|
CBaseFilter2* lparent=((CRemotePin2*)This)->parent;
|
|
Debug printf("CRemotePin2_QueryPinInfo(%p) called\n", This);
|
|
pInfo->pFilter=(IBaseFilter*)lparent;
|
|
lparent->vt->AddRef((IUnknown*)lparent);
|
|
pInfo->dir=PINDIR_OUTPUT;
|
|
pInfo->achName[0]=0;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* \brief CremotePin2 destructor
|
|
*
|
|
* \param This pointer to CRemotePin2 object
|
|
*
|
|
* FIXME - not being released!
|
|
*/
|
|
static void CRemotePin2_Destroy(CRemotePin2* This)
|
|
{
|
|
Debug printf("CRemotePin2_Destroy(%p) called\n", This);
|
|
free(This->vt);
|
|
free(This);
|
|
}
|
|
|
|
IMPLEMENT_IUNKNOWN(CRemotePin2)
|
|
|
|
/**
|
|
* \brief CRemotePin2 contructor
|
|
*
|
|
* \param[in] p pointer to parent CBaseFilter2 object
|
|
*
|
|
* \return pointer to CRemotePin2 object or NULL if error occured
|
|
*
|
|
*/
|
|
CRemotePin2* CRemotePin2Create(CBaseFilter2* p)
|
|
{
|
|
CRemotePin2* This = (CRemotePin2*) malloc(sizeof(CRemotePin2));
|
|
|
|
if (!This)
|
|
return NULL;
|
|
|
|
Debug printf("CRemotePin2Create() called -> %p\n", This);
|
|
|
|
This->parent = p;
|
|
This->refcount = 1;
|
|
|
|
This->vt = (IPin_vt*) malloc(sizeof(IPin_vt));
|
|
|
|
if (!This->vt)
|
|
{
|
|
free(This);
|
|
return NULL;
|
|
}
|
|
|
|
memset(This->vt, 0, sizeof(IPin_vt));
|
|
This->vt->QueryInterface = CRemotePin2_QueryInterface;
|
|
This->vt->AddRef = CRemotePin2_AddRef;
|
|
This->vt->Release = CRemotePin2_Release;
|
|
This->vt->QueryPinInfo = CRemotePin2_QueryPinInfo;
|
|
|
|
This->interfaces[0] = IID_IUnknown;
|
|
|
|
return This;
|
|
}
|