filtergraph.c File Reference

#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winreg.h"
#include "shlwapi.h"
#include "dshow.h"
#include "wine/debug.h"
#include "quartz_private.h"
#include "ole2.h"
#include "olectl.h"
#include "strmif.h"
#include "vfwmsgs.h"
#include "evcode.h"
#include "wine/unicode.h"

Include dependency graph for filtergraph.c:

Go to the source code of this file.

Classes
struct	WndNotify
struct	Event
struct	EventsQueue
struct	_ITF_CACHE_ENTRY
struct	_IFilterGraphImpl
struct	pos_args

Macros
#define	COBJMACROS
#define	EVENTS_RING_BUFFER_INCREMENT   64
#define	MAX_ITF_CACHE_ENTRIES   3

Typedefs
typedef struct _ITF_CACHE_ENTRY	ITF_CACHE_ENTRY
typedef struct _IFilterGraphImpl	IFilterGraphImpl
typedef HRESULT(WINAPI *	fnFoundFilter) (IBaseFilter *, DWORD_PTR data)
typedef HRESULT(WINAPI *	fnFoundSeek) (IFilterGraphImpl *This, IMediaSeeking *, DWORD_PTR arg)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
static int	EventsQueue_Init (EventsQueue *omr)
static int	EventsQueue_Destroy (EventsQueue *omr)
static BOOL	EventsQueue_PutEvent (EventsQueue *omr, const Event *evt)
static BOOL	EventsQueue_GetEvent (EventsQueue *omr, Event *evt, LONG msTimeOut)
static IFilterGraphImpl *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	FilterGraphInner_QueryInterface (IUnknown *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	FilterGraphInner_AddRef (IUnknown *iface)
static ULONG WINAPI	FilterGraphInner_Release (IUnknown *iface)
static IFilterGraphImpl *	impl_from_IFilterGraph2 (IFilterGraph2 *iface)
static HRESULT WINAPI	FilterGraph2_QueryInterface (IFilterGraph2 *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	FilterGraph2_AddRef (IFilterGraph2 *iface)
static ULONG WINAPI	FilterGraph2_Release (IFilterGraph2 *iface)
static HRESULT WINAPI	FilterGraph2_AddFilter (IFilterGraph2 *iface, IBaseFilter *pFilter, LPCWSTR pName)
static HRESULT WINAPI	FilterGraph2_RemoveFilter (IFilterGraph2 *iface, IBaseFilter *pFilter)
static HRESULT WINAPI	FilterGraph2_EnumFilters (IFilterGraph2 *iface, IEnumFilters **ppEnum)
static HRESULT WINAPI	FilterGraph2_FindFilterByName (IFilterGraph2 *iface, LPCWSTR pName, IBaseFilter **ppFilter)
static HRESULT	CheckCircularConnection (IFilterGraphImpl *This, IPin *out, IPin *in)
static HRESULT WINAPI	FilterGraph2_ConnectDirect (IFilterGraph2 *iface, IPin *ppinIn, IPin *ppinOut, const AM_MEDIA_TYPE *pmt)
static HRESULT WINAPI	FilterGraph2_Reconnect (IFilterGraph2 *iface, IPin *ppin)
static HRESULT WINAPI	FilterGraph2_Disconnect (IFilterGraph2 *iface, IPin *ppin)
static HRESULT WINAPI	FilterGraph2_SetDefaultSyncSource (IFilterGraph2 *iface)
static HRESULT	GetFilterInfo (IMoniker *pMoniker, VARIANT *pvar)
static HRESULT	GetInternalConnections (IBaseFilter *pfilter, IPin *pinputpin, IPin ***pppins, ULONG *pnb)
static HRESULT WINAPI	FilterGraph2_Connect (IFilterGraph2 *iface, IPin *ppinOut, IPin *ppinIn)
static HRESULT	FilterGraph2_RenderRecurse (IFilterGraphImpl *This, IPin *ppinOut)
static HRESULT WINAPI	FilterGraph2_Render (IFilterGraph2 *iface, IPin *ppinOut)
static HRESULT WINAPI	FilterGraph2_RenderFile (IFilterGraph2 *iface, LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList)
static HRESULT	CreateFilterInstanceAndLoadFile (GUID *clsid, LPCOLESTR pszFileName, IBaseFilter **filter)
static HRESULT	GetFileSourceFilter (LPCOLESTR pszFileName, IBaseFilter **filter)
static HRESULT WINAPI	FilterGraph2_AddSourceFilter (IFilterGraph2 *iface, LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
static HRESULT WINAPI	FilterGraph2_SetLogFile (IFilterGraph2 *iface, DWORD_PTR hFile)
static HRESULT WINAPI	FilterGraph2_Abort (IFilterGraph2 *iface)
static HRESULT WINAPI	FilterGraph2_ShouldOperationContinue (IFilterGraph2 *iface)
static HRESULT WINAPI	FilterGraph2_AddSourceFilterForMoniker (IFilterGraph2 *iface, IMoniker *pMoniker, IBindCtx *pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
static HRESULT WINAPI	FilterGraph2_ReconnectEx (IFilterGraph2 *iface, IPin *ppin, const AM_MEDIA_TYPE *pmt)
static HRESULT WINAPI	FilterGraph2_RenderEx (IFilterGraph2 *iface, IPin *pPinOut, DWORD dwFlags, DWORD *pvContext)
static IFilterGraphImpl *	impl_from_IMediaControl (IMediaControl *iface)
static HRESULT WINAPI	MediaControl_QueryInterface (IMediaControl *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	MediaControl_AddRef (IMediaControl *iface)
static ULONG WINAPI	MediaControl_Release (IMediaControl *iface)
static HRESULT WINAPI	MediaControl_GetTypeInfoCount (IMediaControl *iface, UINT *pctinfo)
static HRESULT WINAPI	MediaControl_GetTypeInfo (IMediaControl *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	MediaControl_GetIDsOfNames (IMediaControl *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	MediaControl_Invoke (IMediaControl *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
static HRESULT	ExploreGraph (IFilterGraphImpl *pGraph, IPin *pOutputPin, fnFoundFilter FoundFilter, DWORD_PTR data)
static HRESULT WINAPI	SendRun (IBaseFilter *pFilter, DWORD_PTR data)
static HRESULT WINAPI	SendPause (IBaseFilter *pFilter, DWORD_PTR data)
static HRESULT WINAPI	SendStop (IBaseFilter *pFilter, DWORD_PTR data)
static HRESULT WINAPI	SendGetState (IBaseFilter *pFilter, DWORD_PTR data)
static HRESULT	SendFilterMessage (IFilterGraphImpl *This, fnFoundFilter FoundFilter, DWORD_PTR data)
static HRESULT WINAPI	MediaControl_Run (IMediaControl *iface)
static HRESULT WINAPI	MediaControl_Pause (IMediaControl *iface)
static HRESULT WINAPI	MediaControl_Stop (IMediaControl *iface)
static HRESULT WINAPI	MediaControl_GetState (IMediaControl *iface, LONG msTimeout, OAFilterState *pfs)
static HRESULT WINAPI	MediaControl_RenderFile (IMediaControl *iface, BSTR strFilename)
static HRESULT WINAPI	MediaControl_AddSourceFilter (IMediaControl *iface, BSTR strFilename, IDispatch **ppUnk)
static HRESULT WINAPI	MediaControl_get_FilterCollection (IMediaControl *iface, IDispatch **ppUnk)
static HRESULT WINAPI	MediaControl_get_RegFilterCollection (IMediaControl *iface, IDispatch **ppUnk)
static HRESULT WINAPI	MediaControl_StopWhenReady (IMediaControl *iface)
static IFilterGraphImpl *	impl_from_IMediaSeeking (IMediaSeeking *iface)
static HRESULT WINAPI	MediaSeeking_QueryInterface (IMediaSeeking *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	MediaSeeking_AddRef (IMediaSeeking *iface)
static ULONG WINAPI	MediaSeeking_Release (IMediaSeeking *iface)
static HRESULT	all_renderers_seek (IFilterGraphImpl *This, fnFoundSeek FoundSeek, DWORD_PTR arg)
static HRESULT WINAPI	FoundCapabilities (IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pcaps)
static HRESULT WINAPI	MediaSeeking_GetCapabilities (IMediaSeeking *iface, DWORD *pCapabilities)
static HRESULT WINAPI	MediaSeeking_CheckCapabilities (IMediaSeeking *iface, DWORD *pCapabilities)
static HRESULT WINAPI	MediaSeeking_IsFormatSupported (IMediaSeeking *iface, const GUID *pFormat)
static HRESULT WINAPI	MediaSeeking_QueryPreferredFormat (IMediaSeeking *iface, GUID *pFormat)
static HRESULT WINAPI	MediaSeeking_GetTimeFormat (IMediaSeeking *iface, GUID *pFormat)
static HRESULT WINAPI	MediaSeeking_IsUsingTimeFormat (IMediaSeeking *iface, const GUID *pFormat)
static HRESULT WINAPI	MediaSeeking_SetTimeFormat (IMediaSeeking *iface, const GUID *pFormat)
static HRESULT WINAPI	FoundDuration (IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pduration)
static HRESULT WINAPI	MediaSeeking_GetDuration (IMediaSeeking *iface, LONGLONG *pDuration)
static HRESULT WINAPI	MediaSeeking_ConvertTimeFormat (IMediaSeeking *iface, LONGLONG *pTarget, const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
static HRESULT WINAPI	found_setposition (IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pargs)
static HRESULT WINAPI	MediaSeeking_SetPositions (IMediaSeeking *iface, LONGLONG *pCurrent, DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags)
static HRESULT WINAPI	found_getposition (IFilterGraphImpl *This, IMediaSeeking *seek, DWORD_PTR pargs)
static HRESULT WINAPI	MediaSeeking_GetPositions (IMediaSeeking *iface, LONGLONG *pCurrent, LONGLONG *pStop)
static HRESULT WINAPI	MediaSeeking_GetCurrentPosition (IMediaSeeking *iface, LONGLONG *pCurrent)
static HRESULT WINAPI	MediaSeeking_GetStopPosition (IMediaSeeking *iface, LONGLONG *pStop)
static HRESULT WINAPI	MediaSeeking_GetAvailable (IMediaSeeking *iface, LONGLONG *pEarliest, LONGLONG *pLatest)
static HRESULT WINAPI	MediaSeeking_SetRate (IMediaSeeking *iface, double dRate)
static HRESULT WINAPI	MediaSeeking_GetRate (IMediaSeeking *iface, double *pdRate)
static HRESULT WINAPI	MediaSeeking_GetPreroll (IMediaSeeking *iface, LONGLONG *pllPreroll)
static IFilterGraphImpl *	impl_from_IMediaPosition (IMediaPosition *iface)
static HRESULT WINAPI	MediaPosition_QueryInterface (IMediaPosition *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	MediaPosition_AddRef (IMediaPosition *iface)
static ULONG WINAPI	MediaPosition_Release (IMediaPosition *iface)
static HRESULT WINAPI	MediaPosition_GetTypeInfoCount (IMediaPosition *iface, UINT *pctinfo)
static HRESULT WINAPI	MediaPosition_GetTypeInfo (IMediaPosition *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	MediaPosition_GetIDsOfNames (IMediaPosition *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	MediaPosition_Invoke (IMediaPosition *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
static HRESULT	ConvertFromREFTIME (IMediaSeeking *seek, REFTIME time_in, LONGLONG *time_out)
static HRESULT	ConvertToREFTIME (IMediaSeeking *seek, LONGLONG time_in, REFTIME *time_out)
static HRESULT WINAPI	MediaPosition_get_Duration (IMediaPosition *iface, REFTIME *plength)
static HRESULT WINAPI	MediaPosition_put_CurrentPosition (IMediaPosition *iface, REFTIME llTime)
static HRESULT WINAPI	MediaPosition_get_CurrentPosition (IMediaPosition *iface, REFTIME *pllTime)
static HRESULT WINAPI	MediaPosition_get_StopTime (IMediaPosition *iface, REFTIME *pllTime)
static HRESULT WINAPI	MediaPosition_put_StopTime (IMediaPosition *iface, REFTIME llTime)
static HRESULT WINAPI	MediaPosition_get_PrerollTime (IMediaPosition *iface, REFTIME *pllTime)
static HRESULT WINAPI	MediaPosition_put_PrerollTime (IMediaPosition *iface, REFTIME llTime)
static HRESULT WINAPI	MediaPosition_put_Rate (IMediaPosition *iface, double dRate)
static HRESULT WINAPI	MediaPosition_get_Rate (IMediaPosition *iface, double *pdRate)
static HRESULT WINAPI	MediaPosition_CanSeekForward (IMediaPosition *iface, LONG *pCanSeekForward)
static HRESULT WINAPI	MediaPosition_CanSeekBackward (IMediaPosition *iface, LONG *pCanSeekBackward)
static IFilterGraphImpl *	impl_from_IObjectWithSite (IObjectWithSite *iface)
static HRESULT WINAPI	ObjectWithSite_QueryInterface (IObjectWithSite *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	ObjectWithSite_AddRef (IObjectWithSite *iface)
static ULONG WINAPI	ObjectWithSite_Release (IObjectWithSite *iface)
static HRESULT WINAPI	ObjectWithSite_SetSite (IObjectWithSite *iface, IUnknown *pUnkSite)
static HRESULT WINAPI	ObjectWithSite_GetSite (IObjectWithSite *iface, REFIID riid, PVOID *ppvSite)
static HRESULT	GetTargetInterface (IFilterGraphImpl *pGraph, REFIID riid, LPVOID *ppvObj)
static IFilterGraphImpl *	impl_from_IBasicAudio (IBasicAudio *iface)
static HRESULT WINAPI	BasicAudio_QueryInterface (IBasicAudio *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	BasicAudio_AddRef (IBasicAudio *iface)
static ULONG WINAPI	BasicAudio_Release (IBasicAudio *iface)
static HRESULT WINAPI	BasicAudio_GetTypeInfoCount (IBasicAudio *iface, UINT *pctinfo)
static HRESULT WINAPI	BasicAudio_GetTypeInfo (IBasicAudio *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	BasicAudio_GetIDsOfNames (IBasicAudio *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	BasicAudio_Invoke (IBasicAudio *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
static HRESULT WINAPI	BasicAudio_put_Volume (IBasicAudio *iface, LONG lVolume)
static HRESULT WINAPI	BasicAudio_get_Volume (IBasicAudio *iface, LONG *plVolume)
static HRESULT WINAPI	BasicAudio_put_Balance (IBasicAudio *iface, LONG lBalance)
static HRESULT WINAPI	BasicAudio_get_Balance (IBasicAudio *iface, LONG *plBalance)
static IFilterGraphImpl *	impl_from_IBasicVideo2 (IBasicVideo2 *iface)
static HRESULT WINAPI	BasicVideo_QueryInterface (IBasicVideo2 *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	BasicVideo_AddRef (IBasicVideo2 *iface)
static ULONG WINAPI	BasicVideo_Release (IBasicVideo2 *iface)
static HRESULT WINAPI	BasicVideo_GetTypeInfoCount (IBasicVideo2 *iface, UINT *pctinfo)
static HRESULT WINAPI	BasicVideo_GetTypeInfo (IBasicVideo2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	BasicVideo_GetIDsOfNames (IBasicVideo2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	BasicVideo_Invoke (IBasicVideo2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
static HRESULT WINAPI	BasicVideo_get_AvgTimePerFrame (IBasicVideo2 *iface, REFTIME *pAvgTimePerFrame)
static HRESULT WINAPI	BasicVideo_get_BitRate (IBasicVideo2 *iface, LONG *pBitRate)
static HRESULT WINAPI	BasicVideo_get_BitErrorRate (IBasicVideo2 *iface, LONG *pBitErrorRate)
static HRESULT WINAPI	BasicVideo_get_VideoWidth (IBasicVideo2 *iface, LONG *pVideoWidth)
static HRESULT WINAPI	BasicVideo_get_VideoHeight (IBasicVideo2 *iface, LONG *pVideoHeight)
static HRESULT WINAPI	BasicVideo_put_SourceLeft (IBasicVideo2 *iface, LONG SourceLeft)
static HRESULT WINAPI	BasicVideo_get_SourceLeft (IBasicVideo2 *iface, LONG *pSourceLeft)
static HRESULT WINAPI	BasicVideo_put_SourceWidth (IBasicVideo2 *iface, LONG SourceWidth)
static HRESULT WINAPI	BasicVideo_get_SourceWidth (IBasicVideo2 *iface, LONG *pSourceWidth)
static HRESULT WINAPI	BasicVideo_put_SourceTop (IBasicVideo2 *iface, LONG SourceTop)
static HRESULT WINAPI	BasicVideo_get_SourceTop (IBasicVideo2 *iface, LONG *pSourceTop)
static HRESULT WINAPI	BasicVideo_put_SourceHeight (IBasicVideo2 *iface, LONG SourceHeight)
static HRESULT WINAPI	BasicVideo_get_SourceHeight (IBasicVideo2 *iface, LONG *pSourceHeight)
static HRESULT WINAPI	BasicVideo_put_DestinationLeft (IBasicVideo2 *iface, LONG DestinationLeft)
static HRESULT WINAPI	BasicVideo_get_DestinationLeft (IBasicVideo2 *iface, LONG *pDestinationLeft)
static HRESULT WINAPI	BasicVideo_put_DestinationWidth (IBasicVideo2 *iface, LONG DestinationWidth)
static HRESULT WINAPI	BasicVideo_get_DestinationWidth (IBasicVideo2 *iface, LONG *pDestinationWidth)
static HRESULT WINAPI	BasicVideo_put_DestinationTop (IBasicVideo2 *iface, LONG DestinationTop)
static HRESULT WINAPI	BasicVideo_get_DestinationTop (IBasicVideo2 *iface, LONG *pDestinationTop)
static HRESULT WINAPI	BasicVideo_put_DestinationHeight (IBasicVideo2 *iface, LONG DestinationHeight)
static HRESULT WINAPI	BasicVideo_get_DestinationHeight (IBasicVideo2 *iface, LONG *pDestinationHeight)
static HRESULT WINAPI	BasicVideo_SetSourcePosition (IBasicVideo2 *iface, LONG Left, LONG Top, LONG Width, LONG Height)
static HRESULT WINAPI	BasicVideo_GetSourcePosition (IBasicVideo2 *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	BasicVideo_SetDefaultSourcePosition (IBasicVideo2 *iface)
static HRESULT WINAPI	BasicVideo_SetDestinationPosition (IBasicVideo2 *iface, LONG Left, LONG Top, LONG Width, LONG Height)
static HRESULT WINAPI	BasicVideo_GetDestinationPosition (IBasicVideo2 *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	BasicVideo_SetDefaultDestinationPosition (IBasicVideo2 *iface)
static HRESULT WINAPI	BasicVideo_GetVideoSize (IBasicVideo2 *iface, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	BasicVideo_GetVideoPaletteEntries (IBasicVideo2 *iface, LONG StartIndex, LONG Entries, LONG *pRetrieved, LONG *pPalette)
static HRESULT WINAPI	BasicVideo_GetCurrentImage (IBasicVideo2 *iface, LONG *pBufferSize, LONG *pDIBImage)
static HRESULT WINAPI	BasicVideo_IsUsingDefaultSource (IBasicVideo2 *iface)
static HRESULT WINAPI	BasicVideo_IsUsingDefaultDestination (IBasicVideo2 *iface)
static HRESULT WINAPI	BasicVideo2_GetPreferredAspectRatio (IBasicVideo2 *iface, LONG *plAspectX, LONG *plAspectY)
static IFilterGraphImpl *	impl_from_IVideoWindow (IVideoWindow *iface)
static HRESULT WINAPI	VideoWindow_QueryInterface (IVideoWindow *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	VideoWindow_AddRef (IVideoWindow *iface)
static ULONG WINAPI	VideoWindow_Release (IVideoWindow *iface)
static HRESULT WINAPI	VideoWindow_GetTypeInfoCount (IVideoWindow *iface, UINT *pctinfo)
static HRESULT WINAPI	VideoWindow_GetTypeInfo (IVideoWindow *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	VideoWindow_GetIDsOfNames (IVideoWindow *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	VideoWindow_Invoke (IVideoWindow *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
static HRESULT WINAPI	VideoWindow_put_Caption (IVideoWindow *iface, BSTR strCaption)
static HRESULT WINAPI	VideoWindow_get_Caption (IVideoWindow *iface, BSTR *strCaption)
static HRESULT WINAPI	VideoWindow_put_WindowStyle (IVideoWindow *iface, LONG WindowStyle)
static HRESULT WINAPI	VideoWindow_get_WindowStyle (IVideoWindow *iface, LONG *WindowStyle)
static HRESULT WINAPI	VideoWindow_put_WindowStyleEx (IVideoWindow *iface, LONG WindowStyleEx)
static HRESULT WINAPI	VideoWindow_get_WindowStyleEx (IVideoWindow *iface, LONG *WindowStyleEx)
static HRESULT WINAPI	VideoWindow_put_AutoShow (IVideoWindow *iface, LONG AutoShow)
static HRESULT WINAPI	VideoWindow_get_AutoShow (IVideoWindow *iface, LONG *AutoShow)
static HRESULT WINAPI	VideoWindow_put_WindowState (IVideoWindow *iface, LONG WindowState)
static HRESULT WINAPI	VideoWindow_get_WindowState (IVideoWindow *iface, LONG *WindowState)
static HRESULT WINAPI	VideoWindow_put_BackgroundPalette (IVideoWindow *iface, LONG BackgroundPalette)
static HRESULT WINAPI	VideoWindow_get_BackgroundPalette (IVideoWindow *iface, LONG *pBackgroundPalette)
static HRESULT WINAPI	VideoWindow_put_Visible (IVideoWindow *iface, LONG Visible)
static HRESULT WINAPI	VideoWindow_get_Visible (IVideoWindow *iface, LONG *pVisible)
static HRESULT WINAPI	VideoWindow_put_Left (IVideoWindow *iface, LONG Left)
static HRESULT WINAPI	VideoWindow_get_Left (IVideoWindow *iface, LONG *pLeft)
static HRESULT WINAPI	VideoWindow_put_Width (IVideoWindow *iface, LONG Width)
static HRESULT WINAPI	VideoWindow_get_Width (IVideoWindow *iface, LONG *pWidth)
static HRESULT WINAPI	VideoWindow_put_Top (IVideoWindow *iface, LONG Top)
static HRESULT WINAPI	VideoWindow_get_Top (IVideoWindow *iface, LONG *pTop)
static HRESULT WINAPI	VideoWindow_put_Height (IVideoWindow *iface, LONG Height)
static HRESULT WINAPI	VideoWindow_get_Height (IVideoWindow *iface, LONG *pHeight)
static HRESULT WINAPI	VideoWindow_put_Owner (IVideoWindow *iface, OAHWND Owner)
static HRESULT WINAPI	VideoWindow_get_Owner (IVideoWindow *iface, OAHWND *Owner)
static HRESULT WINAPI	VideoWindow_put_MessageDrain (IVideoWindow *iface, OAHWND Drain)
static HRESULT WINAPI	VideoWindow_get_MessageDrain (IVideoWindow *iface, OAHWND *Drain)
static HRESULT WINAPI	VideoWindow_get_BorderColor (IVideoWindow *iface, LONG *Color)
static HRESULT WINAPI	VideoWindow_put_BorderColor (IVideoWindow *iface, LONG Color)
static HRESULT WINAPI	VideoWindow_get_FullScreenMode (IVideoWindow *iface, LONG *FullScreenMode)
static HRESULT WINAPI	VideoWindow_put_FullScreenMode (IVideoWindow *iface, LONG FullScreenMode)
static HRESULT WINAPI	VideoWindow_SetWindowForeground (IVideoWindow *iface, LONG Focus)
static HRESULT WINAPI	VideoWindow_NotifyOwnerMessage (IVideoWindow *iface, OAHWND hwnd, LONG uMsg, LONG_PTR wParam, LONG_PTR lParam)
static HRESULT WINAPI	VideoWindow_SetWindowPosition (IVideoWindow *iface, LONG Left, LONG Top, LONG Width, LONG Height)
static HRESULT WINAPI	VideoWindow_GetWindowPosition (IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	VideoWindow_GetMinIdealImageSize (IVideoWindow *iface, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	VideoWindow_GetMaxIdealImageSize (IVideoWindow *iface, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	VideoWindow_GetRestorePosition (IVideoWindow *iface, LONG *pLeft, LONG *pTop, LONG *pWidth, LONG *pHeight)
static HRESULT WINAPI	VideoWindow_HideCursor (IVideoWindow *iface, LONG HideCursor)
static HRESULT WINAPI	VideoWindow_IsCursorHidden (IVideoWindow *iface, LONG *CursorHidden)
static IFilterGraphImpl *	impl_from_IMediaEventEx (IMediaEventEx *iface)
static HRESULT WINAPI	MediaEvent_QueryInterface (IMediaEventEx *iface, REFIID riid, void **ppvObj)
static ULONG WINAPI	MediaEvent_AddRef (IMediaEventEx *iface)
static ULONG WINAPI	MediaEvent_Release (IMediaEventEx *iface)
static HRESULT WINAPI	MediaEvent_GetTypeInfoCount (IMediaEventEx *iface, UINT *pctinfo)
static HRESULT WINAPI	MediaEvent_GetTypeInfo (IMediaEventEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
static HRESULT WINAPI	MediaEvent_GetIDsOfNames (IMediaEventEx *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
static HRESULT WINAPI	MediaEvent_Invoke (IMediaEventEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExepInfo, UINT *puArgErr)
static HRESULT WINAPI	MediaEvent_GetEventHandle (IMediaEventEx *iface, OAEVENT *hEvent)
static HRESULT WINAPI	MediaEvent_GetEvent (IMediaEventEx *iface, LONG *lEventCode, LONG_PTR *lParam1, LONG_PTR *lParam2, LONG msTimeout)
static HRESULT WINAPI	MediaEvent_WaitForCompletion (IMediaEventEx *iface, LONG msTimeout, LONG *pEvCode)
static HRESULT WINAPI	MediaEvent_CancelDefaultHandling (IMediaEventEx *iface, LONG lEvCode)
static HRESULT WINAPI	MediaEvent_RestoreDefaultHandling (IMediaEventEx *iface, LONG lEvCode)
static HRESULT WINAPI	MediaEvent_FreeEventParams (IMediaEventEx *iface, LONG lEvCode, LONG_PTR lParam1, LONG_PTR lParam2)
static HRESULT WINAPI	MediaEvent_SetNotifyWindow (IMediaEventEx *iface, OAHWND hwnd, LONG lMsg, LONG_PTR lInstanceData)
static HRESULT WINAPI	MediaEvent_SetNotifyFlags (IMediaEventEx *iface, LONG lNoNotifyFlags)
static HRESULT WINAPI	MediaEvent_GetNotifyFlags (IMediaEventEx *iface, LONG *lplNoNotifyFlags)
static IFilterGraphImpl *	impl_from_IMediaFilter (IMediaFilter *iface)
static HRESULT WINAPI	MediaFilter_QueryInterface (IMediaFilter *iface, REFIID riid, void **ppv)
static ULONG WINAPI	MediaFilter_AddRef (IMediaFilter *iface)
static ULONG WINAPI	MediaFilter_Release (IMediaFilter *iface)
static HRESULT WINAPI	MediaFilter_GetClassID (IMediaFilter *iface, CLSID *pClassID)
static HRESULT WINAPI	MediaFilter_Stop (IMediaFilter *iface)
static HRESULT WINAPI	MediaFilter_Pause (IMediaFilter *iface)
static HRESULT WINAPI	MediaFilter_Run (IMediaFilter *iface, REFERENCE_TIME tStart)
static HRESULT WINAPI	MediaFilter_GetState (IMediaFilter *iface, DWORD dwMsTimeout, FILTER_STATE *pState)
static HRESULT WINAPI	MediaFilter_SetSyncSource (IMediaFilter *iface, IReferenceClock *pClock)
static HRESULT WINAPI	MediaFilter_GetSyncSource (IMediaFilter *iface, IReferenceClock **ppClock)
static IFilterGraphImpl *	impl_from_IMediaEventSink (IMediaEventSink *iface)
static HRESULT WINAPI	MediaEventSink_QueryInterface (IMediaEventSink *iface, REFIID riid, void **ppv)
static ULONG WINAPI	MediaEventSink_AddRef (IMediaEventSink *iface)
static ULONG WINAPI	MediaEventSink_Release (IMediaEventSink *iface)
static HRESULT WINAPI	MediaEventSink_Notify (IMediaEventSink *iface, LONG EventCode, LONG_PTR EventParam1, LONG_PTR EventParam2)
static IFilterGraphImpl *	impl_from_IGraphConfig (IGraphConfig *iface)
static HRESULT WINAPI	GraphConfig_QueryInterface (IGraphConfig *iface, REFIID riid, void **ppv)
static ULONG WINAPI	GraphConfig_AddRef (IGraphConfig *iface)
static ULONG WINAPI	GraphConfig_Release (IGraphConfig *iface)
static HRESULT WINAPI	GraphConfig_Reconnect (IGraphConfig *iface, IPin *pOutputPin, IPin *pInputPin, const AM_MEDIA_TYPE *pmtFirstConnection, IBaseFilter *pUsingFilter, HANDLE hAbortEvent, DWORD dwFlags)
static HRESULT WINAPI	GraphConfig_Reconfigure (IGraphConfig *iface, IGraphConfigCallback *pCallback, void *pvContext, DWORD dwFlags, HANDLE hAbortEvent)
static HRESULT WINAPI	GraphConfig_AddFilterToCache (IGraphConfig *iface, IBaseFilter *pFilter)
static HRESULT WINAPI	GraphConfig_EnumCacheFilter (IGraphConfig *iface, IEnumFilters **pEnum)
static HRESULT WINAPI	GraphConfig_RemoveFilterFromCache (IGraphConfig *iface, IBaseFilter *pFilter)
static HRESULT WINAPI	GraphConfig_GetStartTime (IGraphConfig *iface, REFERENCE_TIME *prtStart)
static HRESULT WINAPI	GraphConfig_PushThroughData (IGraphConfig *iface, IPin *pOutputPin, IPinConnection *pConnection, HANDLE hEventAbort)
static HRESULT WINAPI	GraphConfig_SetFilterFlags (IGraphConfig *iface, IBaseFilter *pFilter, DWORD dwFlags)
static HRESULT WINAPI	GraphConfig_GetFilterFlags (IGraphConfig *iface, IBaseFilter *pFilter, DWORD *dwFlags)
static HRESULT WINAPI	GraphConfig_RemoveFilterEx (IGraphConfig *iface, IBaseFilter *pFilter, DWORD dwFlags)
static IFilterGraphImpl *	impl_from_IGraphVersion (IGraphVersion *iface)
static HRESULT WINAPI	GraphVersion_QueryInterface (IGraphVersion *iface, REFIID riid, void **ppv)
static ULONG WINAPI	GraphVersion_AddRef (IGraphVersion *iface)
static ULONG WINAPI	GraphVersion_Release (IGraphVersion *iface)
static HRESULT WINAPI	GraphVersion_QueryVersion (IGraphVersion *iface, LONG *pVersion)
HRESULT	FilterGraph_create (IUnknown *pUnkOuter, LPVOID *ppObj)
HRESULT	FilterGraphNoThread_create (IUnknown *pUnkOuter, LPVOID *ppObj)

Variables
static const IFilterGraph2Vtbl	IFilterGraph2_VTable
static const IMediaControlVtbl	IMediaControl_VTable
static const IMediaSeekingVtbl	IMediaSeeking_VTable
static const IMediaPositionVtbl	IMediaPosition_VTable
static const IObjectWithSiteVtbl	IObjectWithSite_VTable
static const IBasicAudioVtbl	IBasicAudio_VTable
static const IBasicVideo2Vtbl	IBasicVideo_VTable
static const IVideoWindowVtbl	IVideoWindow_VTable
static const IMediaEventExVtbl	IMediaEventEx_VTable
static const IMediaFilterVtbl	IMediaFilter_VTable
static const IMediaEventSinkVtbl	IMediaEventSink_VTable
static const IGraphConfigVtbl	IGraphConfig_VTable
static const IGraphVersionVtbl	IGraphVersion_VTable
static const IUnknownVtbl	IInner_VTable

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 24 of file filtergraph.c.

EVENTS_RING_BUFFER_INCREMENT

#define EVENTS_RING_BUFFER_INCREMENT   64

Definition at line 58 of file filtergraph.c.

MAX_ITF_CACHE_ENTRIES

#define MAX_ITF_CACHE_ENTRIES   3

Definition at line 144 of file filtergraph.c.

Typedef Documentation

fnFoundFilter

typedef HRESULT(WINAPI * fnFoundFilter) (IBaseFilter *, DWORD_PTR data)

Definition at line 1915 of file filtergraph.c.

fnFoundSeek

typedef HRESULT(WINAPI * fnFoundSeek) (IFilterGraphImpl *This, IMediaSeeking *, DWORD_PTR arg)

Definition at line 2269 of file filtergraph.c.

IFilterGraphImpl

typedef struct _IFilterGraphImpl IFilterGraphImpl

ITF_CACHE_ENTRY

typedef struct _ITF_CACHE_ENTRY ITF_CACHE_ENTRY

Function Documentation

all_renderers_seek()

static HRESULT all_renderers_seek ( IFilterGraphImpl *  This, fnFoundSeek  FoundSeek, DWORD_PTR  arg  )

static

Definition at line 2271 of file filtergraph.c.

                                                                                                {
    BOOL allnotimpl = TRUE;
    int i;
    HRESULT hr, hr_return = S_OK;
 
    TRACE("(%p)->(%p %08lx)\n", This, FoundSeek, arg);
    /* Send a message to all renderers, they are responsible for broadcasting it further */
 
    for(i = 0; i < This->nFilters; i++)
    {
        IMediaSeeking *seek = NULL;
        IBaseFilter* pfilter = This->ppFiltersInGraph[i];
        IAMFilterMiscFlags *flags = NULL;
        ULONG filterflags;
        IBaseFilter_QueryInterface(pfilter, &IID_IAMFilterMiscFlags, (void**)&flags);
        if (!flags)
            continue;
        filterflags = IAMFilterMiscFlags_GetMiscFlags(flags);
        IAMFilterMiscFlags_Release(flags);
        if (filterflags != AM_FILTER_MISC_FLAGS_IS_RENDERER)
            continue;
 
        IBaseFilter_QueryInterface(pfilter, &IID_IMediaSeeking, (void**)&seek);
        if (!seek)
            continue;
        hr = FoundSeek(This, seek, arg);
        IMediaSeeking_Release(seek);
        if (hr_return != E_NOTIMPL)
            allnotimpl = FALSE;
        if (hr_return == S_OK || (FAILED(hr) && hr != E_NOTIMPL && SUCCEEDED(hr_return)))
            hr_return = hr;
    }
 
    if (allnotimpl)
        return E_NOTIMPL;
    return hr_return;
}

Referenced by MediaSeeking_CheckCapabilities(), MediaSeeking_GetCapabilities(), MediaSeeking_GetDuration(), MediaSeeking_GetPositions(), and MediaSeeking_SetPositions().

BasicAudio_AddRef()

static ULONG WINAPI BasicAudio_AddRef ( IBasicAudio *  iface )

static

Definition at line 3023 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    return IUnknown_AddRef(This->outer_unk);
}

BasicAudio_get_Balance()

static HRESULT WINAPI BasicAudio_get_Balance ( IBasicAudio *  iface, LONG *  plBalance  )

static

Definition at line 3189 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_get_Balance(pBasicAudio, plBalance);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_get_Volume()

static HRESULT WINAPI BasicAudio_get_Volume ( IBasicAudio *  iface, LONG *  plVolume  )

static

Definition at line 3149 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_get_Volume(pBasicAudio, plVolume);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_GetIDsOfNames()

static HRESULT WINAPI BasicAudio_GetIDsOfNames ( IBasicAudio *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 3083 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%s, %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), rgszNames, cNames,
            lcid, rgDispId);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_GetIDsOfNames(pBasicAudio, riid, rgszNames, cNames, lcid, rgDispId);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_GetTypeInfo()

static HRESULT WINAPI BasicAudio_GetTypeInfo ( IBasicAudio *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 3062 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_GetTypeInfo(pBasicAudio, iTInfo, lcid, ppTInfo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_GetTypeInfoCount()

static HRESULT WINAPI BasicAudio_GetTypeInfoCount ( IBasicAudio *  iface, UINT *  pctinfo  )

static

Definition at line 3042 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_GetTypeInfoCount(pBasicAudio, pctinfo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_Invoke()

static HRESULT WINAPI BasicAudio_Invoke ( IBasicAudio *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExepInfo, UINT *  puArgErr  )

static

Definition at line 3105 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p)\n", This, iface, dispIdMember,
            debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_Invoke(pBasicAudio, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_put_Balance()

static HRESULT WINAPI BasicAudio_put_Balance ( IBasicAudio *  iface, LONG  lBalance  )

static

Definition at line 3169 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, lBalance);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_put_Balance(pBasicAudio, lBalance);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_put_Volume()

static HRESULT WINAPI BasicAudio_put_Volume ( IBasicAudio *  iface, LONG  lVolume  )

static

Definition at line 3129 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
    IBasicAudio* pBasicAudio;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, lVolume);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
 
    if (hr == S_OK)
        hr = IBasicAudio_put_Volume(pBasicAudio, lVolume);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicAudio_QueryInterface()

static HRESULT WINAPI BasicAudio_QueryInterface ( IBasicAudio *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 3014 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
 
    TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
 
    return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
}

BasicAudio_Release()

static ULONG WINAPI BasicAudio_Release ( IBasicAudio *  iface )

static

Definition at line 3032 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicAudio(iface);
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    return IUnknown_Release(This->outer_unk);
}

BasicVideo2_GetPreferredAspectRatio()

static HRESULT WINAPI BasicVideo2_GetPreferredAspectRatio ( IBasicVideo2 *  iface, LONG *  plAspectX, LONG *  plAspectY  )

static

Definition at line 3991 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo2 *pBasicVideo2;
    HRESULT hr;
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo2, (LPVOID*)&pBasicVideo2);
 
    if (hr == S_OK)
        hr = BasicVideo2_GetPreferredAspectRatio(iface, plAspectX, plAspectY);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

Referenced by BasicVideo2_GetPreferredAspectRatio().

BasicVideo_AddRef()

static ULONG WINAPI BasicVideo_AddRef ( IBasicVideo2 *  iface )

static

Definition at line 3238 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    return IUnknown_AddRef(This->outer_unk);
}

BasicVideo_get_AvgTimePerFrame()

static HRESULT WINAPI BasicVideo_get_AvgTimePerFrame ( IBasicVideo2 *  iface, REFTIME *  pAvgTimePerFrame  )

static

Definition at line 3344 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_AvgTimePerFrame(pBasicVideo, pAvgTimePerFrame);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_BitErrorRate()

static HRESULT WINAPI BasicVideo_get_BitErrorRate ( IBasicVideo2 *  iface, LONG *  pBitErrorRate  )

static

Definition at line 3384 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pBitErrorRate);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_BitErrorRate(pBasicVideo, pBitErrorRate);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_BitRate()

static HRESULT WINAPI BasicVideo_get_BitRate ( IBasicVideo2 *  iface, LONG *  pBitRate  )

static

Definition at line 3364 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pBitRate);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_BitRate(pBasicVideo, pBitRate);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_DestinationHeight()

static HRESULT WINAPI BasicVideo_get_DestinationHeight ( IBasicVideo2 *  iface, LONG *  pDestinationHeight  )

static

Definition at line 3744 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_DestinationHeight(pBasicVideo, pDestinationHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_DestinationLeft()

static HRESULT WINAPI BasicVideo_get_DestinationLeft ( IBasicVideo2 *  iface, LONG *  pDestinationLeft  )

static

Definition at line 3624 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_DestinationLeft(pBasicVideo, pDestinationLeft);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_DestinationTop()

static HRESULT WINAPI BasicVideo_get_DestinationTop ( IBasicVideo2 *  iface, LONG *  pDestinationTop  )

static

Definition at line 3704 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_DestinationTop(pBasicVideo, pDestinationTop);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_DestinationWidth()

static HRESULT WINAPI BasicVideo_get_DestinationWidth ( IBasicVideo2 *  iface, LONG *  pDestinationWidth  )

static

Definition at line 3664 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_DestinationWidth(pBasicVideo, pDestinationWidth);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_SourceHeight()

static HRESULT WINAPI BasicVideo_get_SourceHeight ( IBasicVideo2 *  iface, LONG *  pSourceHeight  )

static

Definition at line 3584 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_SourceHeight(pBasicVideo, pSourceHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_SourceLeft()

static HRESULT WINAPI BasicVideo_get_SourceLeft ( IBasicVideo2 *  iface, LONG *  pSourceLeft  )

static

Definition at line 3464 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_SourceLeft(pBasicVideo, pSourceLeft);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_SourceTop()

static HRESULT WINAPI BasicVideo_get_SourceTop ( IBasicVideo2 *  iface, LONG *  pSourceTop  )

static

Definition at line 3544 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_SourceTop(pBasicVideo, pSourceTop);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_SourceWidth()

static HRESULT WINAPI BasicVideo_get_SourceWidth ( IBasicVideo2 *  iface, LONG *  pSourceWidth  )

static

Definition at line 3504 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_SourceWidth(pBasicVideo, pSourceWidth);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_VideoHeight()

static HRESULT WINAPI BasicVideo_get_VideoHeight ( IBasicVideo2 *  iface, LONG *  pVideoHeight  )

static

Definition at line 3424 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_VideoHeight(pBasicVideo, pVideoHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_get_VideoWidth()

static HRESULT WINAPI BasicVideo_get_VideoWidth ( IBasicVideo2 *  iface, LONG *  pVideoWidth  )

static

Definition at line 3404 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_get_VideoWidth(pBasicVideo, pVideoWidth);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetCurrentImage()

static HRESULT WINAPI BasicVideo_GetCurrentImage ( IBasicVideo2 *  iface, LONG *  pBufferSize, LONG *  pDIBImage  )

static

Definition at line 3930 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p, %p)\n", This, iface, pBufferSize, pDIBImage);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetCurrentImage(pBasicVideo, pBufferSize, pDIBImage);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetDestinationPosition()

static HRESULT WINAPI BasicVideo_GetDestinationPosition ( IBasicVideo2 *  iface, LONG *  pLeft, LONG *  pTop, LONG *  pWidth, LONG *  pHeight  )

static

Definition at line 3848 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetDestinationPosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetIDsOfNames()

static HRESULT WINAPI BasicVideo_GetIDsOfNames ( IBasicVideo2 *  iface, REFIID  riid, LPOLESTR *  rgszNames, UINT  cNames, LCID  lcid, DISPID *  rgDispId  )

static

Definition at line 3298 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%s, %p, %d, %d, %p)\n", This, iface, debugstr_guid(riid), rgszNames, cNames,
            lcid, rgDispId);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetIDsOfNames(pBasicVideo, riid, rgszNames, cNames, lcid, rgDispId);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetSourcePosition()

static HRESULT WINAPI BasicVideo_GetSourcePosition ( IBasicVideo2 *  iface, LONG *  pLeft, LONG *  pTop, LONG *  pWidth, LONG *  pHeight  )

static

Definition at line 3786 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetSourcePosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetTypeInfo()

static HRESULT WINAPI BasicVideo_GetTypeInfo ( IBasicVideo2 *  iface, UINT  iTInfo, LCID  lcid, ITypeInfo **  ppTInfo  )

static

Definition at line 3277 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %d, %p)\n", This, iface, iTInfo, lcid, ppTInfo);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetTypeInfo(pBasicVideo, iTInfo, lcid, ppTInfo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetTypeInfoCount()

static HRESULT WINAPI BasicVideo_GetTypeInfoCount ( IBasicVideo2 *  iface, UINT *  pctinfo  )

static

Definition at line 3257 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pctinfo);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetTypeInfoCount(pBasicVideo, pctinfo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetVideoPaletteEntries()

static HRESULT WINAPI BasicVideo_GetVideoPaletteEntries ( IBasicVideo2 *  iface, LONG  StartIndex, LONG  Entries, LONG *  pRetrieved, LONG *  pPalette  )

static

Definition at line 3909 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %d, %p, %p)\n", This, iface, StartIndex, Entries, pRetrieved, pPalette);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetVideoPaletteEntries(pBasicVideo, StartIndex, Entries, pRetrieved, pPalette);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_GetVideoSize()

static HRESULT WINAPI BasicVideo_GetVideoSize ( IBasicVideo2 *  iface, LONG *  pWidth, LONG *  pHeight  )

static

Definition at line 3889 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_GetVideoSize(pBasicVideo, pWidth, pHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_Invoke()

static HRESULT WINAPI BasicVideo_Invoke ( IBasicVideo2 *  iface, DISPID  dispIdMember, REFIID  riid, LCID  lcid, WORD  wFlags, DISPPARAMS *  pDispParams, VARIANT *  pVarResult, EXCEPINFO *  pExepInfo, UINT *  puArgErr  )

static

Definition at line 3320 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %s, %d, %04x, %p, %p, %p, %p)\n", This, iface, dispIdMember,
            debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_Invoke(pBasicVideo, dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExepInfo, puArgErr);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_IsUsingDefaultDestination()

static HRESULT WINAPI BasicVideo_IsUsingDefaultDestination ( IBasicVideo2 *  iface )

static

Definition at line 3971 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_IsUsingDefaultDestination(pBasicVideo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_IsUsingDefaultSource()

static HRESULT WINAPI BasicVideo_IsUsingDefaultSource ( IBasicVideo2 *  iface )

static

Definition at line 3951 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_IsUsingDefaultSource(pBasicVideo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_DestinationHeight()

static HRESULT WINAPI BasicVideo_put_DestinationHeight ( IBasicVideo2 *  iface, LONG  DestinationHeight  )

static

Definition at line 3724 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, DestinationHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_DestinationHeight(pBasicVideo, DestinationHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_DestinationLeft()

static HRESULT WINAPI BasicVideo_put_DestinationLeft ( IBasicVideo2 *  iface, LONG  DestinationLeft  )

static

Definition at line 3604 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, DestinationLeft);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_DestinationLeft(pBasicVideo, DestinationLeft);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_DestinationTop()

static HRESULT WINAPI BasicVideo_put_DestinationTop ( IBasicVideo2 *  iface, LONG  DestinationTop  )

static

Definition at line 3684 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, DestinationTop);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_DestinationTop(pBasicVideo, DestinationTop);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_DestinationWidth()

static HRESULT WINAPI BasicVideo_put_DestinationWidth ( IBasicVideo2 *  iface, LONG  DestinationWidth  )

static

Definition at line 3644 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, DestinationWidth);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_DestinationWidth(pBasicVideo, DestinationWidth);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_SourceHeight()

static HRESULT WINAPI BasicVideo_put_SourceHeight ( IBasicVideo2 *  iface, LONG  SourceHeight  )

static

Definition at line 3564 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, SourceHeight);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_SourceHeight(pBasicVideo, SourceHeight);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_SourceLeft()

static HRESULT WINAPI BasicVideo_put_SourceLeft ( IBasicVideo2 *  iface, LONG  SourceLeft  )

static

Definition at line 3444 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, SourceLeft);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_SourceLeft(pBasicVideo, SourceLeft);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_SourceTop()

static HRESULT WINAPI BasicVideo_put_SourceTop ( IBasicVideo2 *  iface, LONG  SourceTop  )

static

Definition at line 3524 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, SourceTop);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_SourceTop(pBasicVideo, SourceTop);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_put_SourceWidth()

static HRESULT WINAPI BasicVideo_put_SourceWidth ( IBasicVideo2 *  iface, LONG  SourceWidth  )

static

Definition at line 3484 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d)\n", This, iface, SourceWidth);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_put_SourceWidth(pBasicVideo, SourceWidth);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_QueryInterface()

static HRESULT WINAPI BasicVideo_QueryInterface ( IBasicVideo2 *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 3229 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
 
    TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
 
    return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
}

BasicVideo_Release()

static ULONG WINAPI BasicVideo_Release ( IBasicVideo2 *  iface )

static

Definition at line 3247 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    return IUnknown_Release(This->outer_unk);
}

BasicVideo_SetDefaultDestinationPosition()

static HRESULT WINAPI BasicVideo_SetDefaultDestinationPosition ( IBasicVideo2 *  iface )

static

Definition at line 3869 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_SetDefaultDestinationPosition(pBasicVideo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_SetDefaultSourcePosition()

static HRESULT WINAPI BasicVideo_SetDefaultSourcePosition ( IBasicVideo2 *  iface )

static

Definition at line 3807 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_SetDefaultSourcePosition(pBasicVideo);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_SetDestinationPosition()

static HRESULT WINAPI BasicVideo_SetDestinationPosition ( IBasicVideo2 *  iface, LONG  Left, LONG  Top, LONG  Width, LONG  Height  )

static

Definition at line 3827 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_SetDestinationPosition(pBasicVideo, Left, Top, Width, Height);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

BasicVideo_SetSourcePosition()

static HRESULT WINAPI BasicVideo_SetSourcePosition ( IBasicVideo2 *  iface, LONG  Left, LONG  Top, LONG  Width, LONG  Height  )

static

Definition at line 3765 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IBasicVideo2(iface);
    IBasicVideo *pBasicVideo;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%d, %d, %d, %d)\n", This, iface, Left, Top, Width, Height);
 
    EnterCriticalSection(&This->cs);
 
    hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
 
    if (hr == S_OK)
        hr = IBasicVideo_SetSourcePosition(pBasicVideo, Left, Top, Width, Height);
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

CheckCircularConnection()

static HRESULT CheckCircularConnection ( IFilterGraphImpl *  This, IPin *  out, IPin *  in  )

static

Definition at line 597 of file filtergraph.c.

{
#if 1
    HRESULT hr;
    PIN_INFO info_out, info_in;
 
    hr = IPin_QueryPinInfo(out, &info_out);
    if (FAILED(hr))
        return hr;
    if (info_out.dir != PINDIR_OUTPUT)
    {
        IBaseFilter_Release(info_out.pFilter);
        return VFW_E_CANNOT_CONNECT;
    }
 
    hr = IPin_QueryPinInfo(in, &info_in);
    if (SUCCEEDED(hr))
        IBaseFilter_Release(info_in.pFilter);
    if (FAILED(hr))
        goto out;
    if (info_in.dir != PINDIR_INPUT)
    {
        hr = VFW_E_CANNOT_CONNECT;
        goto out;
    }
 
    if (info_out.pFilter == info_in.pFilter)
        hr = VFW_E_CIRCULAR_GRAPH;
    else
    {
        IEnumPins *enumpins;
        IPin *test;
 
        hr = IBaseFilter_EnumPins(info_out.pFilter, &enumpins);
        if (FAILED(hr))
            goto out;
 
        IEnumPins_Reset(enumpins);
        while ((hr = IEnumPins_Next(enumpins, 1, &test, NULL)) == S_OK)
        {
            PIN_DIRECTION dir = PINDIR_OUTPUT;
            IPin_QueryDirection(test, &dir);
            if (dir == PINDIR_INPUT)
            {
                IPin *victim = NULL;
                IPin_ConnectedTo(test, &victim);
                if (victim)
                {
                    hr = CheckCircularConnection(This, victim, in);
                    IPin_Release(victim);
                    if (FAILED(hr))
                    {
                        IPin_Release(test);
                        break;
                    }
                }
            }
            IPin_Release(test);
        }
        IEnumPins_Release(enumpins);
    }
 
out:
    IBaseFilter_Release(info_out.pFilter);
    if (FAILED(hr))
        ERR("Checking filtergraph returned %08x, something's not right!\n", hr);
    return hr;
#else
    /* Debugging filtergraphs not enabled */
    return S_OK;
#endif
}

Referenced by CheckCircularConnection(), FilterGraph2_Connect(), and FilterGraph2_ConnectDirect().

ConvertFromREFTIME()

static HRESULT ConvertFromREFTIME ( IMediaSeeking *  seek, REFTIME  time_in, LONGLONG *  time_out  )

static

Definition at line 2742 of file filtergraph.c.

{
    GUID time_format;
    HRESULT hr;
 
    hr = MediaSeeking_GetTimeFormat(seek, &time_format);
    if (FAILED(hr))
        return hr;
    if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
    {
        FIXME("Unsupported time format.\n");
        return E_NOTIMPL;
    }
 
    *time_out = (LONGLONG) (time_in * 10000000); /* convert from 1 second intervals to 100 ns intervals */
    return S_OK;
}

Referenced by MediaPosition_put_CurrentPosition(), and MediaPosition_put_StopTime().

ConvertToREFTIME()

static HRESULT ConvertToREFTIME ( IMediaSeeking *  seek, LONGLONG  time_in, REFTIME *  time_out  )

static

Definition at line 2760 of file filtergraph.c.

{
    GUID time_format;
    HRESULT hr;
 
    hr = MediaSeeking_GetTimeFormat(seek, &time_format);
    if (FAILED(hr))
        return hr;
    if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
    {
        FIXME("Unsupported time format.\n");
        return E_NOTIMPL;
    }
 
    *time_out = (REFTIME)time_in / 10000000; /* convert from 100 ns intervals to 1 second intervals */
    return S_OK;
}

Referenced by MediaPosition_get_CurrentPosition(), MediaPosition_get_Duration(), and MediaPosition_get_StopTime().

CreateFilterInstanceAndLoadFile()

static HRESULT CreateFilterInstanceAndLoadFile ( GUID *  clsid, LPCOLESTR  pszFileName, IBaseFilter **  filter  )

static

Definition at line 1585 of file filtergraph.c.

{
    IFileSourceFilter *source = NULL;
    HRESULT hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)filter);
    TRACE("CLSID: %s\n", debugstr_guid(clsid));
    if (FAILED(hr))
        return hr;
 
    hr = IBaseFilter_QueryInterface(*filter, &IID_IFileSourceFilter, (LPVOID*)&source);
    if (FAILED(hr))
    {
        IBaseFilter_Release(*filter);
        return hr;
    }
 
    /* Load the file in the file source filter */
    hr = IFileSourceFilter_Load(source, pszFileName, NULL);
    IFileSourceFilter_Release(source);
    if (FAILED(hr)) {
        WARN("Load (%x)\n", hr);
        IBaseFilter_Release(*filter);
        return hr;
    }
 
    return hr;
}

Referenced by GetFileSourceFilter().

EventsQueue_Destroy()

static int EventsQueue_Destroy ( EventsQueue *  omr )

static

Definition at line 82 of file filtergraph.c.

{
    CloseHandle(omr->msg_event);
    CoTaskMemFree(omr->messages);
    omr->msg_crst.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&omr->msg_crst);
    return TRUE;
}

Referenced by FilterGraph_create(), and FilterGraphInner_Release().

EventsQueue_GetEvent()

static BOOL EventsQueue_GetEvent ( EventsQueue *  omr, Event *  evt, LONG  msTimeOut  )

static

Definition at line 120 of file filtergraph.c.

{
    if (WaitForSingleObject(omr->msg_event, msTimeOut) != WAIT_OBJECT_0)
    return FALSE;
    
    EnterCriticalSection(&omr->msg_crst);
 
    if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
    {
        LeaveCriticalSection(&omr->msg_crst);
    return FALSE;
    }
 
    *evt = omr->messages[omr->msg_toget];
    omr->msg_toget = (omr->msg_toget + 1) % omr->ring_buffer_size;
 
    /* Mark the buffer as empty if needed */
    if (omr->msg_toget == omr->msg_tosave) /* buffer empty ? */
    ResetEvent(omr->msg_event);
 
    LeaveCriticalSection(&omr->msg_crst);
    return TRUE;
}

Referenced by MediaEvent_GetEvent().

EventsQueue_Init()

static int EventsQueue_Init ( EventsQueue *  omr )

static

Definition at line 68 of file filtergraph.c.

{
    omr->msg_toget = 0;
    omr->msg_tosave = 0;
    omr->msg_event = CreateEventW(NULL, TRUE, FALSE, NULL);
    omr->ring_buffer_size = EVENTS_RING_BUFFER_INCREMENT;
    omr->messages = CoTaskMemAlloc(omr->ring_buffer_size * sizeof(Event));
    ZeroMemory(omr->messages, omr->ring_buffer_size * sizeof(Event));
 
    InitializeCriticalSection(&omr->msg_crst);
    omr->msg_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": EventsQueue.msg_crst");
    return TRUE;
}

Referenced by FilterGraph_create().

EventsQueue_PutEvent()

static BOOL EventsQueue_PutEvent ( EventsQueue *  omr, const Event *  evt  )

static

Definition at line 91 of file filtergraph.c.

{
    EnterCriticalSection(&omr->msg_crst);
    if (omr->msg_toget == ((omr->msg_tosave + 1) % omr->ring_buffer_size))
    {
    int old_ring_buffer_size = omr->ring_buffer_size;
    omr->ring_buffer_size += EVENTS_RING_BUFFER_INCREMENT;
    TRACE("omr->ring_buffer_size=%d\n",omr->ring_buffer_size);
    omr->messages = CoTaskMemRealloc(omr->messages, omr->ring_buffer_size * sizeof(Event));
    /* Now we need to rearrange the ring buffer so that the new
       buffers just allocated are in between omr->msg_tosave and
       omr->msg_toget.
    */
    if (omr->msg_tosave < omr->msg_toget)
    {
        memmove(&(omr->messages[omr->msg_toget + EVENTS_RING_BUFFER_INCREMENT]),
            &(omr->messages[omr->msg_toget]),
            sizeof(Event)*(old_ring_buffer_size - omr->msg_toget)
            );
        omr->msg_toget += EVENTS_RING_BUFFER_INCREMENT;
    }
    }
    omr->messages[omr->msg_tosave] = *evt;
    SetEvent(omr->msg_event);
    omr->msg_tosave = (omr->msg_tosave + 1) % omr->ring_buffer_size;
    LeaveCriticalSection(&omr->msg_crst);
    return TRUE;
}

Referenced by MediaEventSink_Notify().

ExploreGraph()

static HRESULT ExploreGraph ( IFilterGraphImpl *  pGraph, IPin *  pOutputPin, fnFoundFilter  FoundFilter, DWORD_PTR  data  )

static

Definition at line 1917 of file filtergraph.c.

{
    HRESULT hr;
    IPin* pInputPin;
    IPin** ppPins;
    ULONG nb;
    ULONG i;
    PIN_INFO PinInfo;
 
    TRACE("%p %p\n", pGraph, pOutputPin);
    PinInfo.pFilter = NULL;
 
    hr = IPin_ConnectedTo(pOutputPin, &pInputPin);
 
    if (SUCCEEDED(hr))
    {
        hr = IPin_QueryPinInfo(pInputPin, &PinInfo);
        if (SUCCEEDED(hr))
            hr = GetInternalConnections(PinInfo.pFilter, pInputPin, &ppPins, &nb);
        IPin_Release(pInputPin);
    }
 
    if (SUCCEEDED(hr))
    {
        if (nb == 0)
        {
            TRACE("Reached a renderer\n");
            /* Count renderers for end of stream notification */
            pGraph->nRenderers++;
        }
        else
        {
            for(i = 0; i < nb; i++)
            {
                /* Explore the graph downstream from this pin
                 * FIXME: We should prevent exploring from a pin more than once. This can happens when
                 * several input pins are connected to the same output (a MUX for instance). */
                ExploreGraph(pGraph, ppPins[i], FoundFilter, data);
                IPin_Release(ppPins[i]);
            }
 
            CoTaskMemFree(ppPins);
        }
        TRACE("Doing stuff with filter %p\n", PinInfo.pFilter);
 
        FoundFilter(PinInfo.pFilter, data);
    }
 
    if (PinInfo.pFilter) IBaseFilter_Release(PinInfo.pFilter);
    return hr;
}

Referenced by ExploreGraph(), and SendFilterMessage().

FilterGraph2_Abort()

static HRESULT WINAPI FilterGraph2_Abort ( IFilterGraph2 *  iface )

static

Definition at line 1745 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 
    return S_OK;
}

FilterGraph2_AddFilter()

static HRESULT WINAPI FilterGraph2_AddFilter ( IFilterGraph2 *  iface, IBaseFilter *  pFilter, LPCWSTR  pName  )

static

Definition at line 368 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    HRESULT hr;
    int i,j;
    WCHAR* wszFilterName = NULL;
    BOOL duplicate_name = FALSE;
 
    TRACE("(%p/%p)->(%p, %s (%p))\n", This, iface, pFilter, debugstr_w(pName), pName);
 
    if (!pFilter)
        return E_POINTER;
 
    wszFilterName = CoTaskMemAlloc( (pName ? strlenW(pName) + 6 : 5) * sizeof(WCHAR) );
 
    if (pName)
    {
    /* Check if name already exists */
        for(i = 0; i < This->nFilters; i++)
        if (!strcmpW(This->pFilterNames[i], pName))
        {
        duplicate_name = TRUE;
        break;
        }
    }
 
    /* If no name given or name already existing, generate one */
    if (!pName || duplicate_name)
    {
    static const WCHAR wszFmt1[] = {'%','s',' ','%','0','4','d',0};
    static const WCHAR wszFmt2[] = {'%','0','4','d',0};
 
    for (j = 0; j < 10000 ; j++)
    {
        /* Create name */
        if (pName)
        sprintfW(wszFilterName, wszFmt1, pName, This->nameIndex);
        else
        sprintfW(wszFilterName, wszFmt2, This->nameIndex);
        TRACE("Generated name %s\n", debugstr_w(wszFilterName));
 
        /* Check if the generated name already exists */
        for(i = 0; i < This->nFilters; i++)
            if (!strcmpW(This->pFilterNames[i], wszFilterName))
            break;
 
        /* Compute next index and exit if generated name is suitable */
        if (This->nameIndex++ == 10000)
        This->nameIndex = 1;
        if (i == This->nFilters)
        break;
    }
    /* Unable to find a suitable name */
    if (j == 10000)
    {
        CoTaskMemFree(wszFilterName);
        return VFW_E_DUPLICATE_NAME;
    }
    }
    else
    memcpy(wszFilterName, pName, (strlenW(pName) + 1) * sizeof(WCHAR));
 
    if (This->nFilters + 1 > This->filterCapacity)
    {
        int newCapacity = This->filterCapacity ? 2 * This->filterCapacity : 1;
        IBaseFilter ** ppNewFilters = CoTaskMemAlloc(newCapacity * sizeof(IBaseFilter*));
        LPWSTR * pNewNames = CoTaskMemAlloc(newCapacity * sizeof(LPWSTR));
        memcpy(ppNewFilters, This->ppFiltersInGraph, This->nFilters * sizeof(IBaseFilter*));
        memcpy(pNewNames, This->pFilterNames, This->nFilters * sizeof(LPWSTR));
        if (This->filterCapacity)
        {
            CoTaskMemFree(This->ppFiltersInGraph);
            CoTaskMemFree(This->pFilterNames);
        }
        This->ppFiltersInGraph = ppNewFilters;
        This->pFilterNames = pNewNames;
        This->filterCapacity = newCapacity;
    }
 
    hr = IBaseFilter_JoinFilterGraph(pFilter, (IFilterGraph *)&This->IFilterGraph2_iface, wszFilterName);
 
    if (SUCCEEDED(hr))
    {
        IBaseFilter_AddRef(pFilter);
        This->ppFiltersInGraph[This->nFilters] = pFilter;
        This->pFilterNames[This->nFilters] = wszFilterName;
        This->nFilters++;
        This->version++;
        IBaseFilter_SetSyncSource(pFilter, This->refClock);
    }
    else
        CoTaskMemFree(wszFilterName);
 
    if (SUCCEEDED(hr) && duplicate_name)
        return VFW_S_DUPLICATE_NAME;
 
    return hr;
}

FilterGraph2_AddRef()

static ULONG WINAPI FilterGraph2_AddRef ( IFilterGraph2 *  iface )

static

Definition at line 349 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    return IUnknown_AddRef(This->outer_unk);
}

FilterGraph2_AddSourceFilter()

static HRESULT WINAPI FilterGraph2_AddSourceFilter ( IFilterGraph2 *  iface, LPCWSTR  lpcwstrFileName, LPCWSTR  lpcwstrFilterName, IBaseFilter **  ppFilter  )

static

Definition at line 1678 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    HRESULT hr;
    IBaseFilter* preader;
    IFileSourceFilter* pfile = NULL;
    AM_MEDIA_TYPE mt;
    WCHAR* filename;
 
    TRACE("(%p/%p)->(%s, %s, %p)\n", This, iface, debugstr_w(lpcwstrFileName), debugstr_w(lpcwstrFilterName), ppFilter);
 
    /* Try from file name first, then fall back to default asynchronous reader */
    hr = GetFileSourceFilter(lpcwstrFileName, &preader);
    if (FAILED(hr)) {
        WARN("Unable to create file source filter (%x)\n", hr);
        return hr;
    }
 
    hr = IFilterGraph2_AddFilter(iface, preader, lpcwstrFilterName);
    if (FAILED(hr)) {
        WARN("Unable add filter (%x)\n", hr);
        IBaseFilter_Release(preader);
        return hr;
    }
 
    hr = IBaseFilter_QueryInterface(preader, &IID_IFileSourceFilter, (LPVOID*)&pfile);
    if (FAILED(hr)) {
        WARN("Unable to get IFileSourceInterface (%x)\n", hr);
        goto error;
    }
 
    /* The file has been already loaded */
    hr = IFileSourceFilter_GetCurFile(pfile, &filename, &mt);
    if (FAILED(hr)) {
        WARN("GetCurFile (%x)\n", hr);
        goto error;
    }
 
    TRACE("File %s\n", debugstr_w(filename));
    TRACE("MajorType %s\n", debugstr_guid(&mt.majortype));
    TRACE("SubType %s\n", debugstr_guid(&mt.subtype));
 
    if (ppFilter)
        *ppFilter = preader;
    IFileSourceFilter_Release(pfile);
 
    return S_OK;
 
error:
    if (pfile)
        IFileSourceFilter_Release(pfile);
    IFilterGraph2_RemoveFilter(iface, preader);
    IBaseFilter_Release(preader);
 
    return hr;
}

FilterGraph2_AddSourceFilterForMoniker()

static HRESULT WINAPI FilterGraph2_AddSourceFilterForMoniker ( IFilterGraph2 *  iface, IMoniker *  pMoniker, IBindCtx *  pCtx, LPCWSTR  lpcwstrFilterName, IBaseFilter **  ppFilter  )

static

Definition at line 1764 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    HRESULT hr;
    IBaseFilter* pfilter;
 
    TRACE("(%p/%p)->(%p %p %s %p)\n", This, iface, pMoniker, pCtx, debugstr_w(lpcwstrFilterName), ppFilter);
 
    hr = IMoniker_BindToObject(pMoniker, pCtx, NULL, &IID_IBaseFilter, (void**)&pfilter);
    if(FAILED(hr)) {
        WARN("Unable to bind moniker to filter object (%x)\n", hr);
        return hr;
    }
 
    hr = IFilterGraph2_AddFilter(iface, pfilter, lpcwstrFilterName);
    if (FAILED(hr)) {
        WARN("Unable to add filter (%x)\n", hr);
        IBaseFilter_Release(pfilter);
        return hr;
    }
 
    if(ppFilter)
        *ppFilter = pfilter;
    else IBaseFilter_Release(pfilter);
 
    return S_OK;
}

FilterGraph2_Connect()

static HRESULT WINAPI FilterGraph2_Connect ( IFilterGraph2 *  iface, IPin *  ppinOut, IPin *  ppinIn  )

static

Definition at line 894 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    HRESULT hr;
    AM_MEDIA_TYPE* mt = NULL;
    IEnumMediaTypes* penummt = NULL;
    ULONG nbmt;
    IEnumPins* penumpins;
    IEnumMoniker* pEnumMoniker;
    GUID tab[2];
    ULONG nb = 0;
    IMoniker* pMoniker;
    ULONG pin;
    PIN_INFO PinInfo;
    CLSID FilterCLSID;
    PIN_DIRECTION dir;
    unsigned int i = 0;
    IFilterMapper2 *pFilterMapper2 = NULL;
 
    TRACE("(%p/%p)->(%p, %p)\n", This, iface, ppinOut, ppinIn);
 
    if(!ppinOut || !ppinIn)
        return E_POINTER;
 
    if (TRACE_ON(quartz))
    {
        hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
        if (FAILED(hr))
            return hr;
 
        TRACE("Filter owning ppinIn(%p) => %p\n", ppinIn, PinInfo.pFilter);
        IBaseFilter_Release(PinInfo.pFilter);
 
        hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
        if (FAILED(hr))
            return hr;
 
        TRACE("Filter owning ppinOut(%p) => %p\n", ppinOut, PinInfo.pFilter);
        IBaseFilter_Release(PinInfo.pFilter);
    }
 
    EnterCriticalSection(&This->cs);
    ++This->recursioncount;
    if (This->recursioncount >= 5)
    {
        WARN("Recursion count has reached %d\n", This->recursioncount);
        hr = VFW_E_CANNOT_CONNECT;
        goto out;
    }
 
    hr = IPin_QueryDirection(ppinOut, &dir);
    if (FAILED(hr))
        goto out;
 
    if (dir == PINDIR_INPUT)
    {
        IPin *temp;
 
        TRACE("Directions seem backwards, swapping pins\n");
 
        temp = ppinIn;
        ppinIn = ppinOut;
        ppinOut = temp;
    }
 
    hr = CheckCircularConnection(This, ppinOut, ppinIn);
    if (FAILED(hr))
        goto out;
 
    /* Try direct connection first */
    hr = IPin_Connect(ppinOut, ppinIn, NULL);
    if (SUCCEEDED(hr))
        goto out;
 
    TRACE("Direct connection failed, trying to render using extra filters\n");
 
    hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
    if (FAILED(hr))
        goto out;
 
    hr = IBaseFilter_GetClassID(PinInfo.pFilter, &FilterCLSID);
    IBaseFilter_Release(PinInfo.pFilter);
    if (FAILED(hr))
        goto out;
 
    /* Find the appropriate transform filter than can transform the minor media type of output pin of the upstream 
     * filter to the minor mediatype of input pin of the renderer */
    hr = IPin_EnumMediaTypes(ppinOut, &penummt);
    if (FAILED(hr))
    {
        WARN("EnumMediaTypes (%x)\n", hr);
        goto out;
    }
 
    hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
    if (FAILED(hr)) {
        WARN("IEnumMediaTypes_Next (%x)\n", hr);
        goto out;
    }
 
    if (!nbmt)
    {
        WARN("No media type found!\n");
        hr = VFW_E_INVALIDMEDIATYPE;
        goto out;
    }
    TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
    TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
 
    hr = IUnknown_QueryInterface(This->punkFilterMapper2, &IID_IFilterMapper2, (void**)&pFilterMapper2);
    if (FAILED(hr)) {
        WARN("Unable to get IFilterMapper2 (%x)\n", hr);
        goto out;
    }
 
    /* Try to find a suitable filter that can connect to the pin to render */
    tab[0] = mt->majortype;
    tab[1] = mt->subtype;
    hr = IFilterMapper2_EnumMatchingFilters(pFilterMapper2, &pEnumMoniker, 0, FALSE, MERIT_UNLIKELY, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
    if (FAILED(hr)) {
        WARN("Unable to enum filters (%x)\n", hr);
        goto out;
    }
 
    hr = VFW_E_CANNOT_RENDER;
    while(IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
    {
        VARIANT var;
        GUID clsid;
        IPin** ppins = NULL;
        IPin* ppinfilter = NULL;
        IBaseFilter* pfilter = NULL;
        IAMGraphBuilderCallback *callback = NULL;
 
        hr = GetFilterInfo(pMoniker, &var);
        if (FAILED(hr)) {
            WARN("Unable to retrieve filter info (%x)\n", hr);
            goto error;
        }
 
        hr = IMoniker_BindToObject(pMoniker, NULL, NULL, &IID_IBaseFilter, (LPVOID*)&pfilter);
        IMoniker_Release(pMoniker);
        if (FAILED(hr)) {
            WARN("Unable to create filter (%x), trying next one\n", hr);
            goto error;
        }
 
        hr = IBaseFilter_GetClassID(pfilter, &clsid);
        if (FAILED(hr))
        {
            IBaseFilter_Release(pfilter);
            goto error;
    }
 
        if (IsEqualGUID(&clsid, &FilterCLSID)) {
            /* Skip filter (same as the one the output pin belongs to) */
            IBaseFilter_Release(pfilter);
            pfilter = NULL;
            goto error;
        }
 
        if (This->pSite)
        {
            IUnknown_QueryInterface(This->pSite, &IID_IAMGraphBuilderCallback, (LPVOID*)&callback);
            if (callback)
            {
                HRESULT rc;
                rc = IAMGraphBuilderCallback_SelectedFilter(callback, pMoniker);
                if (FAILED(rc))
                {
                    TRACE("Filter rejected by IAMGraphBuilderCallback_SelectedFilter\n");
                    IAMGraphBuilderCallback_Release(callback);
                    goto error;
                }
            }
        }
 
        if (callback)
        {
            HRESULT rc;
            rc = IAMGraphBuilderCallback_CreatedFilter(callback, pfilter);
            IAMGraphBuilderCallback_Release(callback);
            if (FAILED(rc))
            {
                IBaseFilter_Release(pfilter);
                pfilter = NULL;
                TRACE("Filter rejected by IAMGraphBuilderCallback_CreatedFilter\n");
                goto error;
            }
        }
 
        hr = IFilterGraph2_AddFilter(iface, pfilter, V_BSTR(&var));
        if (FAILED(hr)) {
            WARN("Unable to add filter (%x)\n", hr);
            IBaseFilter_Release(pfilter);
            pfilter = NULL;
            goto error;
        }
 
        VariantClear(&var);
 
        hr = IBaseFilter_EnumPins(pfilter, &penumpins);
        if (FAILED(hr)) {
            WARN("Enumpins (%x)\n", hr);
            goto error;
        }
 
        hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin);
        IEnumPins_Release(penumpins);
 
        if (FAILED(hr)) {
            WARN("Obtaining next pin: (%x)\n", hr);
            goto error;
        }
        if (pin == 0) {
            WARN("Cannot use this filter: no pins\n");
            goto error;
        }
 
        hr = IPin_Connect(ppinOut, ppinfilter, NULL);
        if (FAILED(hr)) {
            TRACE("Cannot connect to filter (%x), trying next one\n", hr);
            goto error;
        }
        TRACE("Successfully connected to filter, follow chain...\n");
 
        /* Render all output pins of the filter by calling IFilterGraph2_Connect on each of them */
        hr = GetInternalConnections(pfilter, ppinfilter, &ppins, &nb);
 
        if (SUCCEEDED(hr)) {
            if (nb == 0) {
                IPin_Disconnect(ppinfilter);
                IPin_Disconnect(ppinOut);
                goto error;
            }
            TRACE("pins to consider: %d\n", nb);
            for(i = 0; i < nb; i++)
            {
                LPWSTR pinname = NULL;
 
                TRACE("Processing pin %u\n", i);
 
                hr = IPin_QueryId(ppins[i], &pinname);
                if (SUCCEEDED(hr))
                {
                    if (pinname[0] == '~')
                    {
                        TRACE("Pinname=%s, skipping\n", debugstr_w(pinname));
                        hr = E_FAIL;
                    }
                    else
                        hr = IFilterGraph2_Connect(iface, ppins[i], ppinIn);
                    CoTaskMemFree(pinname);
                }
 
                if (FAILED(hr)) {
                   TRACE("Cannot connect pin %p (%x)\n", ppinfilter, hr);
                }
                IPin_Release(ppins[i]);
                if (SUCCEEDED(hr)) break;
            }
            while (++i < nb) IPin_Release(ppins[i]);
            CoTaskMemFree(ppins);
            IPin_Release(ppinfilter);
            IBaseFilter_Release(pfilter);
            if (FAILED(hr))
            {
                IPin_Disconnect(ppinfilter);
                IPin_Disconnect(ppinOut);
                IFilterGraph2_RemoveFilter(iface, pfilter);
                continue;
            }
            break;
        }
 
error:
        VariantClear(&var);
        if (ppinfilter) IPin_Release(ppinfilter);
        if (pfilter) {
            IFilterGraph2_RemoveFilter(iface, pfilter);
            IBaseFilter_Release(pfilter);
        }
        while (++i < nb) IPin_Release(ppins[i]);
        CoTaskMemFree(ppins);
    }
 
    IEnumMoniker_Release(pEnumMoniker);
 
out:
    if (pFilterMapper2)
        IFilterMapper2_Release(pFilterMapper2);
    if (penummt)
        IEnumMediaTypes_Release(penummt);
    if (mt)
        DeleteMediaType(mt);
    --This->recursioncount;
    LeaveCriticalSection(&This->cs);
    TRACE("--> %08x\n", hr);
    return SUCCEEDED(hr) ? S_OK : hr;
}

FilterGraph2_ConnectDirect()

static HRESULT WINAPI FilterGraph2_ConnectDirect ( IFilterGraph2 *  iface, IPin *  ppinIn, IPin *  ppinOut, const AM_MEDIA_TYPE *  pmt  )

static

Definition at line 673 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    PIN_DIRECTION dir;
    HRESULT hr;
 
    TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
 
    /* FIXME: check pins are in graph */
 
    if (TRACE_ON(quartz))
    {
        PIN_INFO PinInfo;
 
        hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
        if (FAILED(hr))
            return hr;
 
        TRACE("Filter owning ppinIn(%p) => %p\n", ppinIn, PinInfo.pFilter);
        IBaseFilter_Release(PinInfo.pFilter);
 
        hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
        if (FAILED(hr))
            return hr;
 
        TRACE("Filter owning ppinOut(%p) => %p\n", ppinOut, PinInfo.pFilter);
        IBaseFilter_Release(PinInfo.pFilter);
    }
 
    hr = IPin_QueryDirection(ppinIn, &dir);
    if (SUCCEEDED(hr))
    {
        if (dir == PINDIR_INPUT)
        {
            hr = CheckCircularConnection(This, ppinOut, ppinIn);
            if (SUCCEEDED(hr))
                hr = IPin_Connect(ppinOut, ppinIn, pmt);
        }
        else
        {
            hr = CheckCircularConnection(This, ppinIn, ppinOut);
            if (SUCCEEDED(hr))
                hr = IPin_Connect(ppinIn, ppinOut, pmt);
        }
    }
 
    return hr;
}

Referenced by FilterGraph2_Render().

FilterGraph2_Disconnect()

static HRESULT WINAPI FilterGraph2_Disconnect ( IFilterGraph2 *  iface, IPin *  ppin  )

static

Definition at line 752 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
 
    if (!ppin)
       return E_POINTER;
 
    return IPin_Disconnect(ppin);
}

FilterGraph2_EnumFilters()

static HRESULT WINAPI FilterGraph2_EnumFilters ( IFilterGraph2 *  iface, IEnumFilters **  ppEnum  )

static

Definition at line 560 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(%p)\n", This, iface, ppEnum);
 
    return IEnumFiltersImpl_Construct(&This->IGraphVersion_iface, &This->ppFiltersInGraph, &This->nFilters, ppEnum);
}

FilterGraph2_FindFilterByName()

static HRESULT WINAPI FilterGraph2_FindFilterByName ( IFilterGraph2 *  iface, LPCWSTR  pName, IBaseFilter **  ppFilter  )

static

Definition at line 569 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    int i;
 
    TRACE("(%p/%p)->(%s (%p), %p)\n", This, iface, debugstr_w(pName), pName, ppFilter);
 
    if (!ppFilter)
        return E_POINTER;
 
    for (i = 0; i < This->nFilters; i++)
    {
        if (!strcmpW(pName, This->pFilterNames[i]))
        {
            *ppFilter = This->ppFiltersInGraph[i];
            IBaseFilter_AddRef(*ppFilter);
            return S_OK;
        }
    }
 
    *ppFilter = NULL;
    return VFW_E_NOT_FOUND;
}

FilterGraph2_QueryInterface()

static HRESULT WINAPI FilterGraph2_QueryInterface ( IFilterGraph2 *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 340 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(%s, %p)\n", This, iface, debugstr_guid(riid), ppvObj);
 
    return IUnknown_QueryInterface(This->outer_unk, riid, ppvObj);
}

FilterGraph2_Reconnect()

static HRESULT WINAPI FilterGraph2_Reconnect ( IFilterGraph2 *  iface, IPin *  ppin  )

static

Definition at line 723 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    IPin *pConnectedTo = NULL;
    HRESULT hr;
    PIN_DIRECTION pindir;
 
    IPin_QueryDirection(ppin, &pindir);
    hr = IPin_ConnectedTo(ppin, &pConnectedTo);
 
    TRACE("(%p/%p)->(%p) -- %p\n", This, iface, ppin, pConnectedTo);
 
    if (FAILED(hr)) {
        TRACE("Querying connected to failed: %x\n", hr);
        return hr; 
    }
    IPin_Disconnect(ppin);
    IPin_Disconnect(pConnectedTo);
    if (pindir == PINDIR_INPUT)
        hr = IPin_Connect(pConnectedTo, ppin, NULL);
    else
        hr = IPin_Connect(ppin, pConnectedTo, NULL);
    IPin_Release(pConnectedTo);
    if (FAILED(hr))
        WARN("Reconnecting pins failed, pins are not connected now..\n");
    TRACE("-> %08x\n", hr);
    return hr;
}

FilterGraph2_ReconnectEx()

static HRESULT WINAPI FilterGraph2_ReconnectEx ( IFilterGraph2 *  iface, IPin *  ppin, const AM_MEDIA_TYPE *  pmt  )

static

Definition at line 1793 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(%p %p): stub !!!\n", This, iface, ppin, pmt);
 
    return S_OK;
}

FilterGraph2_Release()

static ULONG WINAPI FilterGraph2_Release ( IFilterGraph2 *  iface )

static

Definition at line 358 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->()\n", This, iface);
 
    return IUnknown_Release(This->outer_unk);
}

FilterGraph2_RemoveFilter()

static HRESULT WINAPI FilterGraph2_RemoveFilter ( IFilterGraph2 *  iface, IBaseFilter *  pFilter  )

static

Definition at line 468 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    int i;
    HRESULT hr = E_FAIL;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
 
    /* FIXME: check graph is stopped */
 
    for (i = 0; i < This->nFilters; i++)
    {
        if (This->ppFiltersInGraph[i] == pFilter)
        {
            IEnumPins *penumpins = NULL;
            FILTER_STATE state;
 
            if (This->defaultclock && This->refClockProvider == pFilter)
            {
                IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, NULL);
                This->defaultclock = TRUE;
            }
 
            TRACE("Removing filter %s\n", debugstr_w(This->pFilterNames[i]));
            IBaseFilter_GetState(pFilter, 0, &state);
            if (state == State_Running)
                IBaseFilter_Pause(pFilter);
            if (state != State_Stopped)
                IBaseFilter_Stop(pFilter);
 
            hr = IBaseFilter_EnumPins(pFilter, &penumpins);
            if (SUCCEEDED(hr)) {
                IPin *ppin;
                while(IEnumPins_Next(penumpins, 1, &ppin, NULL) == S_OK)
                {
                    IPin *victim = NULL;
                    HRESULT h;
                    IPin_ConnectedTo(ppin, &victim);
                    if (victim)
                    {
                        h = IPin_Disconnect(victim);
                        TRACE("Disconnect other side: %08x\n", h);
                        if (h == VFW_E_NOT_STOPPED)
                        {
                            PIN_INFO pinfo;
                            IPin_QueryPinInfo(victim, &pinfo);
 
                            IBaseFilter_GetState(pinfo.pFilter, 0, &state);
                            if (state == State_Running)
                                IBaseFilter_Pause(pinfo.pFilter);
                            IBaseFilter_Stop(pinfo.pFilter);
                            IBaseFilter_Release(pinfo.pFilter);
                            h = IPin_Disconnect(victim);
                            TRACE("Disconnect retry: %08x\n", h);
                        }
                        IPin_Release(victim);
                    }
                    h = IPin_Disconnect(ppin);
                    TRACE("Disconnect 2: %08x\n", h);
 
                    IPin_Release(ppin);
                }
                IEnumPins_Release(penumpins);
            }
 
            hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, This->pFilterNames[i]);
            if (SUCCEEDED(hr))
            {
                IBaseFilter_SetSyncSource(pFilter, NULL);
                IBaseFilter_Release(pFilter);
                CoTaskMemFree(This->pFilterNames[i]);
                memmove(This->ppFiltersInGraph+i, This->ppFiltersInGraph+i+1, sizeof(IBaseFilter*)*(This->nFilters - 1 - i));
                memmove(This->pFilterNames+i, This->pFilterNames+i+1, sizeof(LPWSTR)*(This->nFilters - 1 - i));
                This->nFilters--;
                This->version++;
                /* Invalidate interfaces in the cache */
                for (i = 0; i < This->nItfCacheEntries; i++)
                    if (pFilter == This->ItfCacheEntries[i].filter)
                    {
                        IUnknown_Release(This->ItfCacheEntries[i].iface);
                        This->ItfCacheEntries[i].iface = NULL;
                        This->ItfCacheEntries[i].filter = NULL;
                    }
                return S_OK;
            }
            break;
        }
    }
 
    return hr; /* FIXME: check this error code */
}

FilterGraph2_Render()

static HRESULT WINAPI FilterGraph2_Render ( IFilterGraph2 *  iface, IPin *  ppinOut  )

static

Definition at line 1267 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    IEnumMediaTypes* penummt;
    AM_MEDIA_TYPE* mt;
    ULONG nbmt;
    HRESULT hr;
 
    IEnumMoniker* pEnumMoniker;
    GUID tab[4];
    ULONG nb;
    IMoniker* pMoniker;
    INT x;
    IFilterMapper2 *pFilterMapper2 = NULL;
 
    TRACE("(%p/%p)->(%p)\n", This, iface, ppinOut);
 
    if (TRACE_ON(quartz))
    {
        PIN_INFO PinInfo;
 
        hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
        if (FAILED(hr))
            return hr;
 
        TRACE("Filter owning pin => %p\n", PinInfo.pFilter);
        IBaseFilter_Release(PinInfo.pFilter);
    }
 
    /* Try to find out if there is a renderer for the specified subtype already, and use that
     */
    EnterCriticalSection(&This->cs);
    for (x = 0; x < This->nFilters; ++x)
    {
        IEnumPins *enumpins = NULL;
        IPin *pin = NULL;
 
        hr = IBaseFilter_EnumPins(This->ppFiltersInGraph[x], &enumpins);
 
        if (FAILED(hr) || !enumpins)
            continue;
 
        IEnumPins_Reset(enumpins);
        while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
        {
            IPin *to = NULL;
            PIN_DIRECTION dir = PINDIR_OUTPUT;
 
            IPin_QueryDirection(pin, &dir);
            if (dir != PINDIR_INPUT)
            {
                IPin_Release(pin);
                continue;
            }
            IPin_ConnectedTo(pin, &to);
 
            if (to == NULL)
            {
                hr = FilterGraph2_ConnectDirect(iface, ppinOut, pin, NULL);
                if (SUCCEEDED(hr))
                {
                    TRACE("Connected successfully %p/%p, %08x look if we should render more!\n", ppinOut, pin, hr);
                    IPin_Release(pin);
 
                    hr = FilterGraph2_RenderRecurse(This, pin);
                    if (FAILED(hr))
                    {
                        IPin_Disconnect(ppinOut);
                        IPin_Disconnect(pin);
                        continue;
                    }
                    IEnumPins_Release(enumpins);
                    LeaveCriticalSection(&This->cs);
                    return hr;
                }
                WARN("Could not connect!\n");
            }
            else
                IPin_Release(to);
 
            IPin_Release(pin);
        }
        IEnumPins_Release(enumpins);
    }
 
    LeaveCriticalSection(&This->cs);
 
    hr = IPin_EnumMediaTypes(ppinOut, &penummt);
    if (FAILED(hr)) {
        WARN("EnumMediaTypes (%x)\n", hr);
        return hr;
    }
 
    IEnumMediaTypes_Reset(penummt);
 
    /* Looks like no existing renderer of the kind exists
     * Try adding new ones
     */
    tab[0] = tab[1] = GUID_NULL;
    while (SUCCEEDED(hr))
    {
        hr = IEnumMediaTypes_Next(penummt, 1, &mt, &nbmt);
        if (FAILED(hr)) {
            WARN("IEnumMediaTypes_Next (%x)\n", hr);
            break;
        }
        if (!nbmt)
        {
            hr = VFW_E_CANNOT_RENDER;
            break;
        }
        else
        {
            TRACE("MajorType %s\n", debugstr_guid(&mt->majortype));
            TRACE("SubType %s\n", debugstr_guid(&mt->subtype));
 
            /* Only enumerate once, this doesn't account for all previous ones, but this should be enough nonetheless */
            if (IsEqualIID(&tab[0], &mt->majortype) && IsEqualIID(&tab[1], &mt->subtype))
            {
                DeleteMediaType(mt);
                continue;
            }
 
            if (pFilterMapper2 == NULL)
            {
                hr = IUnknown_QueryInterface(This->punkFilterMapper2, &IID_IFilterMapper2, (void**)&pFilterMapper2);
                if (FAILED(hr))
                {
                    WARN("Unable to query IFilterMapper2 (%x)\n", hr);
                    break;
                }
            }
 
            /* Try to find a suitable renderer with the same media type */
            tab[0] = mt->majortype;
            tab[1] = mt->subtype;
            hr = IFilterMapper2_EnumMatchingFilters(pFilterMapper2, &pEnumMoniker, 0, FALSE, MERIT_UNLIKELY, TRUE, 1, tab, NULL, NULL, FALSE, FALSE, 0, NULL, NULL, NULL);
            if (FAILED(hr))
            {
                WARN("Unable to enum filters (%x)\n", hr);
                break;
            }
        }
        hr = E_FAIL;
 
        while (IEnumMoniker_Next(pEnumMoniker, 1, &pMoniker, &nb) == S_OK)
        {
            VARIANT var;
            IPin* ppinfilter;
            IBaseFilter* pfilter = NULL;
            IEnumPins* penumpins = NULL;
            ULONG pin;
 
            hr = GetFilterInfo(pMoniker, &var);
            if (FAILED(hr)) {
                WARN("Unable to retrieve filter info (%x)\n", hr);
                goto error;
            }
 
            hr = IMoniker_BindToObject(pMoniker, NULL, NULL, &IID_IBaseFilter, (LPVOID*)&pfilter);
            IMoniker_Release(pMoniker);
            if (FAILED(hr))
            {
                WARN("Unable to create filter (%x), trying next one\n", hr);
                goto error;
            }
 
            hr = IFilterGraph2_AddFilter(iface, pfilter, V_BSTR(&var));
            if (FAILED(hr)) {
                WARN("Unable to add filter (%x)\n", hr);
                IBaseFilter_Release(pfilter);
                pfilter = NULL;
                goto error;
            }
 
            hr = IBaseFilter_EnumPins(pfilter, &penumpins);
            if (FAILED(hr)) {
                WARN("Splitter Enumpins (%x)\n", hr);
                goto error;
            }
 
            while ((hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin)) == S_OK)
            {
                PIN_DIRECTION dir;
 
                if (pin == 0) {
                    WARN("No Pin\n");
                    hr = E_FAIL;
                    goto error;
                }
 
                hr = IPin_QueryDirection(ppinfilter, &dir);
                if (FAILED(hr)) {
                    IPin_Release(ppinfilter);
                    WARN("QueryDirection failed (%x)\n", hr);
                    goto error;
                }
                if (dir != PINDIR_INPUT) {
                    IPin_Release(ppinfilter);
                    continue; /* Wrong direction */
                }
 
                /* Connect the pin to the "Renderer" */
                hr = IPin_Connect(ppinOut, ppinfilter, NULL);
                IPin_Release(ppinfilter);
 
                if (FAILED(hr)) {
                    WARN("Unable to connect %s to renderer (%x)\n", debugstr_w(V_BSTR(&var)), hr);
                    goto error;
                }
                TRACE("Connected, recursing %s\n",  debugstr_w(V_BSTR(&var)));
 
                VariantClear(&var);
 
                hr = FilterGraph2_RenderRecurse(This, ppinfilter);
                if (FAILED(hr)) {
                    WARN("Unable to connect recursively (%x)\n", hr);
                    goto error;
                }
                IBaseFilter_Release(pfilter);
                break;
            }
            if (SUCCEEDED(hr)) {
                IEnumPins_Release(penumpins);
                break; /* out of IEnumMoniker_Next loop */
            }
 
            /* IEnumPins_Next failed, all other failure case caught by goto error */
            WARN("IEnumPins_Next (%x)\n", hr);
            /* goto error */
 
error:
            VariantClear(&var);
            if (penumpins)
                IEnumPins_Release(penumpins);
            if (pfilter) {
                IFilterGraph2_RemoveFilter(iface, pfilter);
                IBaseFilter_Release(pfilter);
            }
            if (SUCCEEDED(hr)) DebugBreak();
        }
 
        IEnumMoniker_Release(pEnumMoniker);
        if (nbmt)
            DeleteMediaType(mt);
        if (SUCCEEDED(hr))
            break;
        hr = S_OK;
    }
 
    if (pFilterMapper2)
        IFilterMapper2_Release(pFilterMapper2);
 
    IEnumMediaTypes_Release(penummt);
    return hr;
}

FilterGraph2_RenderEx()

static HRESULT WINAPI FilterGraph2_RenderEx ( IFilterGraph2 *  iface, IPin *  pPinOut, DWORD  dwFlags, DWORD *  pvContext  )

static

Definition at line 1803 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(%p %08x %p): stub !!!\n", This, iface, pPinOut, dwFlags, pvContext);
 
    return S_OK;
}

FilterGraph2_RenderFile()

static HRESULT WINAPI FilterGraph2_RenderFile ( IFilterGraph2 *  iface, LPCWSTR  lpcwstrFile, LPCWSTR  lpcwstrPlayList  )

static

Definition at line 1524 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    static const WCHAR string[] = {'R','e','a','d','e','r',0};
    IBaseFilter* preader = NULL;
    IPin* ppinreader = NULL;
    IEnumPins* penumpins = NULL;
    HRESULT hr;
    BOOL partial = FALSE;
    BOOL any = FALSE;
 
    TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
 
    if (lpcwstrPlayList != NULL)
        return E_INVALIDARG;
 
    hr = IFilterGraph2_AddSourceFilter(iface, lpcwstrFile, string, &preader);
    if (FAILED(hr))
        return hr;
 
    hr = IBaseFilter_EnumPins(preader, &penumpins);
    if (SUCCEEDED(hr))
    {
        while (IEnumPins_Next(penumpins, 1, &ppinreader, NULL) == S_OK)
        {
            PIN_DIRECTION dir;
 
            IPin_QueryDirection(ppinreader, &dir);
            if (dir == PINDIR_OUTPUT)
            {
                INT i;
 
                hr = IFilterGraph2_Render(iface, ppinreader);
                TRACE("Render %08x\n", hr);
 
                for (i = 0; i < This->nFilters; ++i)
                    TRACE("Filters in chain: %s\n", debugstr_w(This->pFilterNames[i]));
 
                if (SUCCEEDED(hr))
                    any = TRUE;
                if (hr != S_OK)
                    partial = TRUE;
            }
            IPin_Release(ppinreader);
        }
        IEnumPins_Release(penumpins);
 
        if (!any)
            hr = VFW_E_CANNOT_RENDER;
        else if (partial)
            hr = VFW_S_PARTIAL_RENDER;
        else
            hr = S_OK;
    }
    IBaseFilter_Release(preader);
 
    TRACE("--> %08x\n", hr);
    return hr;
}

FilterGraph2_RenderRecurse()

static HRESULT FilterGraph2_RenderRecurse ( IFilterGraphImpl *  This, IPin *  ppinOut  )

static

Definition at line 1195 of file filtergraph.c.

{
    /* This pin has been connected now, try to call render on all pins that aren't connected */
    IPin *to = NULL;
    PIN_INFO info;
    IEnumPins *enumpins = NULL;
    BOOL renderany = FALSE;
    BOOL renderall = TRUE;
 
    IPin_QueryPinInfo(ppinOut, &info);
 
    IBaseFilter_EnumPins(info.pFilter, &enumpins);
    /* Don't need to hold a reference, IEnumPins does */
    IBaseFilter_Release(info.pFilter);
 
    IEnumPins_Reset(enumpins);
    while (IEnumPins_Next(enumpins, 1, &to, NULL) == S_OK)
    {
        PIN_DIRECTION dir = PINDIR_INPUT;
 
        IPin_QueryDirection(to, &dir);
 
        if (dir == PINDIR_OUTPUT)
        {
            IPin *out = NULL;
 
            IPin_ConnectedTo(to, &out);
            if (!out)
            {
                HRESULT hr;
                hr = IFilterGraph2_Render(&This->IFilterGraph2_iface, to);
                if (SUCCEEDED(hr))
                    renderany = TRUE;
                else
                    renderall = FALSE;
            }
            else
                IPin_Release(out);
        }
 
        IPin_Release(to);
    }
 
    IEnumPins_Release(enumpins);
 
    if (renderall)
        return S_OK;
 
    if (renderany)
        return VFW_S_PARTIAL_RENDER;
 
    return VFW_E_CANNOT_RENDER;
}

Referenced by FilterGraph2_Render().

FilterGraph2_SetDefaultSyncSource()

static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource ( IFilterGraph2 *  iface )

static

Definition at line 764 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
    IReferenceClock *pClock = NULL;
    HRESULT hr = S_OK;
    int i;
 
    TRACE("(%p/%p)->() live sources not handled properly!\n", This, iface);
 
    EnterCriticalSection(&This->cs);
 
    for (i = 0; i < This->nFilters; ++i)
    {
        DWORD miscflags;
        IAMFilterMiscFlags *flags = NULL;
        IBaseFilter_QueryInterface(This->ppFiltersInGraph[i], &IID_IAMFilterMiscFlags, (void**)&flags);
        if (!flags)
            continue;
        miscflags = IAMFilterMiscFlags_GetMiscFlags(flags);
        IAMFilterMiscFlags_Release(flags);
        if (miscflags == AM_FILTER_MISC_FLAGS_IS_RENDERER)
            IBaseFilter_QueryInterface(This->ppFiltersInGraph[i], &IID_IReferenceClock, (void**)&pClock);
        if (pClock)
            break;
    }
 
    if (!pClock)
    {
        hr = CoCreateInstance(&CLSID_SystemClock, NULL, CLSCTX_INPROC_SERVER, &IID_IReferenceClock, (LPVOID*)&pClock);
        This->refClockProvider = NULL;
    }
    else
        This->refClockProvider = This->ppFiltersInGraph[i];
 
    if (SUCCEEDED(hr))
    {
        hr = IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, pClock);
        This->defaultclock = TRUE;
        IReferenceClock_Release(pClock);
    }
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

FilterGraph2_SetLogFile()

static HRESULT WINAPI FilterGraph2_SetLogFile ( IFilterGraph2 *  iface, DWORD_PTR  hFile  )

static

Definition at line 1736 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(%08x): stub !!!\n", This, iface, (DWORD) hFile);
 
    return S_OK;
}

FilterGraph2_ShouldOperationContinue()

static HRESULT WINAPI FilterGraph2_ShouldOperationContinue ( IFilterGraph2 *  iface )

static

Definition at line 1754 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IFilterGraph2(iface);
 
    TRACE("(%p/%p)->(): stub !!!\n", This, iface);
 
    return S_OK;
}

FilterGraph_create()

HRESULT FilterGraph_create	(	IUnknown *	pUnkOuter,
		LPVOID *	ppObj
	)

Definition at line 5689 of file filtergraph.c.

{
    IFilterGraphImpl *fimpl;
    HRESULT hr;
 
    TRACE("(%p,%p)\n", pUnkOuter, ppObj);
 
    *ppObj = NULL;
 
    fimpl = CoTaskMemAlloc(sizeof(*fimpl));
    fimpl->defaultclock = TRUE;
    fimpl->IUnknown_inner.lpVtbl = &IInner_VTable;
    fimpl->IFilterGraph2_iface.lpVtbl = &IFilterGraph2_VTable;
    fimpl->IMediaControl_iface.lpVtbl = &IMediaControl_VTable;
    fimpl->IMediaSeeking_iface.lpVtbl = &IMediaSeeking_VTable;
    fimpl->IBasicAudio_iface.lpVtbl = &IBasicAudio_VTable;
    fimpl->IBasicVideo2_iface.lpVtbl = &IBasicVideo_VTable;
    fimpl->IVideoWindow_iface.lpVtbl = &IVideoWindow_VTable;
    fimpl->IMediaEventEx_iface.lpVtbl = &IMediaEventEx_VTable;
    fimpl->IMediaFilter_iface.lpVtbl = &IMediaFilter_VTable;
    fimpl->IMediaEventSink_iface.lpVtbl = &IMediaEventSink_VTable;
    fimpl->IGraphConfig_iface.lpVtbl = &IGraphConfig_VTable;
    fimpl->IMediaPosition_iface.lpVtbl = &IMediaPosition_VTable;
    fimpl->IObjectWithSite_iface.lpVtbl = &IObjectWithSite_VTable;
    fimpl->IGraphVersion_iface.lpVtbl = &IGraphVersion_VTable;
    fimpl->ref = 1;
    fimpl->ppFiltersInGraph = NULL;
    fimpl->pFilterNames = NULL;
    fimpl->nFilters = 0;
    fimpl->filterCapacity = 0;
    fimpl->nameIndex = 1;
    fimpl->refClock = NULL;
    fimpl->hEventCompletion = CreateEventW(0, TRUE, FALSE, 0);
    fimpl->HandleEcComplete = TRUE;
    fimpl->HandleEcRepaint = TRUE;
    fimpl->HandleEcClockChanged = TRUE;
    fimpl->notif.hWnd = 0;
    fimpl->notif.disabled = FALSE;
    fimpl->nRenderers = 0;
    fimpl->EcCompleteCount = 0;
    fimpl->refClockProvider = NULL;
    fimpl->state = State_Stopped;
    fimpl->pSite = NULL;
    EventsQueue_Init(&fimpl->evqueue);
    InitializeCriticalSection(&fimpl->cs);
    fimpl->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IFilterGraphImpl.cs");
    fimpl->nItfCacheEntries = 0;
    memcpy(&fimpl->timeformatseek, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
    fimpl->start_time = fimpl->pause_time = 0;
    fimpl->punkFilterMapper2 = NULL;
    fimpl->recursioncount = 0;
    fimpl->version = 0;
 
    if (pUnkOuter)
        fimpl->outer_unk = pUnkOuter;
    else
        fimpl->outer_unk = &fimpl->IUnknown_inner;
 
    /* create Filtermapper aggregated. */
    hr = CoCreateInstance(&CLSID_FilterMapper2, fimpl->outer_unk, CLSCTX_INPROC_SERVER,
            &IID_IUnknown, (void**)&fimpl->punkFilterMapper2);
 
    if (FAILED(hr)) {
        ERR("Unable to create filter mapper (%x)\n", hr);
        if (fimpl->punkFilterMapper2) IUnknown_Release(fimpl->punkFilterMapper2);
        CloseHandle(fimpl->hEventCompletion);
        EventsQueue_Destroy(&fimpl->evqueue);
        fimpl->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&fimpl->cs);
        CoTaskMemFree(fimpl);
        return hr;
    }
 
    *ppObj = &fimpl->IUnknown_inner;
    return S_OK;
}

Referenced by FilterGraphNoThread_create().

FilterGraphInner_AddRef()

static ULONG WINAPI FilterGraphInner_AddRef ( IUnknown *  iface )

static

Definition at line 284 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IUnknown(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p)->(): new ref = %d\n", This, ref);
 
    return ref;
}

FilterGraphInner_QueryInterface()

static HRESULT WINAPI FilterGraphInner_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppvObj  )

static

Definition at line 213 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IUnknown(iface);
    TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObj);
 
    if (IsEqualGUID(&IID_IUnknown, riid)) {
        *ppvObj = &This->IUnknown_inner;
        TRACE("   returning IUnknown interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IFilterGraph, riid) ||
    IsEqualGUID(&IID_IFilterGraph2, riid) ||
    IsEqualGUID(&IID_IGraphBuilder, riid)) {
        *ppvObj = &This->IFilterGraph2_iface;
        TRACE("   returning IGraphBuilder interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
        *ppvObj = &This->IMediaControl_iface;
        TRACE("   returning IMediaControl interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
        *ppvObj = &This->IMediaSeeking_iface;
        TRACE("   returning IMediaSeeking interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
        *ppvObj = &This->IBasicAudio_iface;
        TRACE("   returning IBasicAudio interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IBasicVideo, riid) ||
               IsEqualGUID(&IID_IBasicVideo2, riid)) {
        *ppvObj = &This->IBasicVideo2_iface;
        TRACE("   returning IBasicVideo2 interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
        *ppvObj = &This->IVideoWindow_iface;
        TRACE("   returning IVideoWindow interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
       IsEqualGUID(&IID_IMediaEventEx, riid)) {
        *ppvObj = &This->IMediaEventEx_iface;
        TRACE("   returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
          IsEqualGUID(&IID_IPersist, riid)) {
        *ppvObj = &This->IMediaFilter_iface;
        TRACE("   returning IMediaFilter interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
        *ppvObj = &This->IMediaEventSink_iface;
        TRACE("   returning IMediaEventSink interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IGraphConfig, riid)) {
        *ppvObj = &This->IGraphConfig_iface;
        TRACE("   returning IGraphConfig interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IMediaPosition, riid)) {
        *ppvObj = &This->IMediaPosition_iface;
        TRACE("   returning IMediaPosition interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IObjectWithSite, riid)) {
        *ppvObj = &This->IObjectWithSite_iface;
        TRACE("   returning IObjectWithSite interface (%p)\n", *ppvObj);
    } else if (IsEqualGUID(&IID_IFilterMapper, riid)) {
        TRACE("   requesting IFilterMapper interface from aggregated filtermapper (%p)\n", *ppvObj);
        return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
    } else if (IsEqualGUID(&IID_IFilterMapper2, riid)) {
        TRACE("   returning IFilterMapper2 interface from aggregated filtermapper (%p)\n", *ppvObj);
        return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
    } else if (IsEqualGUID(&IID_IFilterMapper3, riid)) {
        TRACE("   returning IFilterMapper3 interface from aggregated filtermapper (%p)\n", *ppvObj);
        return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
    } else if (IsEqualGUID(&IID_IGraphVersion, riid)) {
        *ppvObj = &This->IGraphConfig_iface;
        TRACE("   returning IGraphConfig interface (%p)\n", *ppvObj);
    } else {
        *ppvObj = NULL;
    FIXME("unknown interface %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown *)*ppvObj);
    return S_OK;
}

FilterGraphInner_Release()

static ULONG WINAPI FilterGraphInner_Release ( IUnknown *  iface )

static

Definition at line 294 of file filtergraph.c.

{
    IFilterGraphImpl *This = impl_from_IUnknown(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(): new ref = %d\n", This, ref);
 
    if (ref == 0) {
        int i;
 
        This->ref = 1; /* guard against reentrancy (aggregation). */
 
        IMediaControl_Stop(&This->IMediaControl_iface);
 
        while (This->nFilters)
            IFilterGraph2_RemoveFilter(&This->IFilterGraph2_iface, This->ppFiltersInGraph[0]);
 
        if (This->refClock)
            IReferenceClock_Release(This->refClock);
 
        for (i = 0; i < This->nItfCacheEntries; i++)
        {
            if (This->ItfCacheEntries[i].iface)
                IUnknown_Release(This->ItfCacheEntries[i].iface);
        }
 
        IUnknown_Release(This->punkFilterMapper2);
 
        if (This->pSite) IUnknown_Release(This->pSite);
 
    CloseHandle(This->hEventCompletion);
    EventsQueue_Destroy(&This->evqueue);
        This->cs.DebugInfo->Spare[0] = 0;
    DeleteCriticalSection(&This->cs);
    CoTaskMemFree(This->ppFiltersInGraph);
    CoTaskMemFree(This->pFilterNames);
    CoTaskMemFree(This);
    }
    return ref;
}

FilterGraphNoThread_create()

HRESULT FilterGraphNoThread_create	(	IUnknown *	pUnkOuter,
		LPVOID *	ppObj
	)

Definition at line 5766 of file filtergraph.c.

{
    FIXME("CLSID_FilterGraphNoThread partially implemented - Forwarding to CLSID_FilterGraph\n");
    return FilterGraph_create(pUnkOuter, ppObj);
}

found_getposition()

static HRESULT WINAPI found_getposition ( IFilterGraphImpl *  This, IMediaSeeking *  seek, DWORD_PTR  pargs  )

static

Definition at line 2551 of file filtergraph.c.

{
    struct pos_args *args = (void*)pargs;
 
    return IMediaSeeking_GetPositions(seek, args->current, args->stop);
}

Referenced by MediaSeeking_GetPositions().

found_setposition()

static HRESULT WINAPI found_setposition ( IFilterGraphImpl *  This, IMediaSeeking *  seek, DWORD_PTR  pargs  )

static

Definition at line 2509 of file filtergraph.c.

{
    struct pos_args *args = (void*)pargs;
 
    return IMediaSeeking_SetPositions(seek, args->current, args->curflags, args->stop, args->stopflags);
}

Referenced by MediaSeeking_SetPositions().

FoundCapabilities()

static HRESULT WINAPI FoundCapabilities ( IFilterGraphImpl *  This, IMediaSeeking *  seek, DWORD_PTR  pcaps  )

static

Definition at line 2309 of file filtergraph.c.

{
    HRESULT hr;
    DWORD caps = 0;
 
    hr = IMediaSeeking_GetCapabilities(seek, &caps);
    if (FAILED(hr))
        return hr;
 
    /* Only add common capabilities everything supports */
    *(DWORD*)pcaps &= caps;
 
    return hr;
}

Referenced by MediaSeeking_CheckCapabilities(), and MediaSeeking_GetCapabilities().

FoundDuration()

static HRESULT WINAPI FoundDuration ( IFilterGraphImpl *  This, IMediaSeeking *  seek, DWORD_PTR  pduration  )

static

Definition at line 2449 of file filtergraph.c.

{
    HRESULT hr;
    LONGLONG duration = 0, *pdur = (LONGLONG*)pduration;
 
    hr = IMediaSeeking_GetDuration(seek, &duration);
    if (FAILED(hr))
        return hr;
 
    if (*pdur < duration)
        *pdur = duration;
    return hr;
}

Referenced by MediaSeeking_GetDuration().

GetFileSourceFilter()

static HRESULT GetFileSourceFilter ( LPCOLESTR  pszFileName, IBaseFilter **  filter  )

static

Definition at line 1613 of file filtergraph.c.

{
    HRESULT hr;
    GUID clsid;
    IAsyncReader * pReader = NULL;
    IFileSourceFilter* pSource = NULL;
    IPin * pOutputPin = NULL;
    static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 };
 
    /* Try to find a match without reading the file first */
    hr = GetClassMediaFile(NULL, pszFileName, NULL, NULL, &clsid);
 
    if (hr == S_OK)
        return CreateFilterInstanceAndLoadFile(&clsid, pszFileName, filter);
 
    /* Now create a AyncReader instance, to check for signature bytes in the file */
    hr = CoCreateInstance(&CLSID_AsyncReader, NULL, CLSCTX_INPROC_SERVER, &IID_IBaseFilter, (LPVOID*)filter);
    if (FAILED(hr))
        return hr;
 
    hr = IBaseFilter_QueryInterface(*filter, &IID_IFileSourceFilter, (LPVOID *)&pSource);
    if (FAILED(hr))
    {
        IBaseFilter_Release(*filter);
        return hr;
    }
 
    hr = IFileSourceFilter_Load(pSource, pszFileName, NULL);
    IFileSourceFilter_Release(pSource);
    if (FAILED(hr))
    {
        IBaseFilter_Release(*filter);
        return hr;
    }
 
    hr = IBaseFilter_FindPin(*filter, wszOutputPinName, &pOutputPin);
    if (FAILED(hr))
    {
        IBaseFilter_Release(*filter);
        return hr;
    }
 
    hr = IPin_QueryInterface(pOutputPin, &IID_IAsyncReader, (LPVOID *)&pReader);
    IPin_Release(pOutputPin);
    if (FAILED(hr))
    {
        IBaseFilter_Release(*filter);
        return hr;
    }
 
    /* Try again find a match */
    hr = GetClassMediaFile(pReader, pszFileName, NULL, NULL, &clsid);
    IAsyncReader_Release(pReader);
 
    if (hr == S_OK)
    {
        /* Release the AsyncReader filter and create the matching one */
        IBaseFilter_Release(*filter);
        return CreateFilterInstanceAndLoadFile(&clsid, pszFileName, filter);
    }
 
    /* Return the AsyncReader filter */
    return S_OK;
}

Referenced by FilterGraph2_AddSourceFilter().

GetFilterInfo()

static HRESULT GetFilterInfo ( IMoniker *  pMoniker, VARIANT *  pvar  )

static

Definition at line 809 of file filtergraph.c.

{
    static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};