/* * Modified for use with MPlayer, detailed changelog at * http://svn.mplayerhq.hu/mplayer/trunk/ * $Id$ */#include "config.h"#if (C_HAS_DIRECTSHOW)#include "inputpin.h"#include "mediatype.h"#include "wine/winerror.h"/*********** * 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;    LOG_MSG("CEnumPins_Next(%p) called", 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){    LOG_MSG("CEnumPins_Skip(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CEnumPins_Reset(%p) called", 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){    LOG_MSG("CEnumPins_Clone(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_Connect(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_ReceiveConnection(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_Disconnect(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_ConnectedTo(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_ConnectionMediaType(%p) called", 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;    LOG_MSG("CInputPin_QueryPinInfo(%p) called", 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;    LOG_MSG("CInputPin_QueryDirection(%p) called", 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){    LOG_MSG("CInputPin_QueryId(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_QueryAccept(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_EnumMediaTypes(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_QueryInternalConnections(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_EndOfStream(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_BeginFlush(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CInputPin_EndFlush(%p) (UNIMPLEMENTED)", 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