* \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){    LOG_MSG("CInputPin_NewSegment(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_GetClassID(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_Stop(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_Pause(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_Run(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_GetState(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_SetSyncSource(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_GetSyncSource(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_EnumPins(%p) called", 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){    LOG_MSG("CBaseFilter_FindPin(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_QueryFilterInfo(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_JoinFilterGraph(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter_QueryVendorInfo(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter2_GetClassID(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter2_Stop(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter2_Pause(%p) (UNIMPLEMENTED)", 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){    LOG_MSG("CBaseFilter2_Run(%p) (UNIMPLEMENTED)", This);    return E_NOTIMPL;}