ReactOS 0.4.17-dev-934-g091855f
Classes | Macros | Typedefs | Functions | Variables
filtergraph.c File Reference
#include <assert.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/heap.h"
#include "wine/list.h"
Include dependency graph for filtergraph.c:

Go to the source code of this file.

Classes

struct  filter_create_params
 
struct  media_event
 
struct  _ITF_CACHE_ENTRY
 
struct  filter
 
struct  filter_graph
 
struct  enum_filters
 

Macros

#define COBJMACROS
 
#define MAX_ITF_CACHE_ENTRIES   3
 

Typedefs

typedef struct _ITF_CACHE_ENTRY ITF_CACHE_ENTRY
 
typedef HRESULT(WINAPI * fnFoundSeek) (struct filter_graph *This, IMediaSeeking *, DWORD_PTR arg)
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (quartz)
 
 DECLARE_CRITICAL_SECTION (message_cs)
 
static HRESULT create_enum_filters (struct filter_graph *graph, struct list *cursor, IEnumFilters **out)
 
static struct enum_filters * impl_from_IEnumFilters (IEnumFilters *iface)
 
static HRESULT WINAPI EnumFilters_QueryInterface (IEnumFilters *iface, REFIID iid, void **out)
 
static ULONG WINAPI EnumFilters_AddRef (IEnumFilters *iface)
 
static ULONG WINAPI EnumFilters_Release (IEnumFilters *iface)
 
static HRESULT WINAPI EnumFilters_Next (IEnumFilters *iface, ULONG count, IBaseFilter **filters, ULONG *fetched)
 
static HRESULT WINAPI EnumFilters_Skip (IEnumFilters *iface, ULONG count)
 
static HRESULT WINAPI EnumFilters_Reset (IEnumFilters *iface)
 
static HRESULT WINAPI EnumFilters_Clone (IEnumFilters *iface, IEnumFilters **out)
 
static BOOL queue_media_event (struct filter_graph *graph, LONG code, LONG_PTR param1, LONG_PTR param2)
 
static void flush_media_events (struct filter_graph *graph)
 
static struct filter_graph * 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 struct filter_graph * impl_from_IFilterGraph2 (IFilterGraph2 *iface)
 
static HRESULT WINAPI FilterGraph2_QueryInterface (IFilterGraph2 *iface, REFIID iid, void **out)
 
static ULONG WINAPI FilterGraph2_AddRef (IFilterGraph2 *iface)
 
static ULONG WINAPI FilterGraph2_Release (IFilterGraph2 *iface)
 
static IBaseFilter * find_filter_by_name (struct filter_graph *graph, const WCHAR *name)
 
static BOOL has_output_pins (IBaseFilter *filter)
 
static void update_seeking (struct filter *filter)
 
static BOOL is_renderer (struct filter *filter)
 
static HRESULT WINAPI FilterGraph2_AddFilter (IFilterGraph2 *iface, IBaseFilter *filter, const WCHAR *name)
 
static HRESULT WINAPI FilterGraph2_RemoveFilter (IFilterGraph2 *iface, IBaseFilter *pFilter)
 
static HRESULT WINAPI FilterGraph2_EnumFilters (IFilterGraph2 *iface, IEnumFilters **out)
 
static HRESULT WINAPI FilterGraph2_FindFilterByName (IFilterGraph2 *iface, const WCHAR *name, IBaseFilter **filter)
 
static HRESULT check_cyclic_connection (IPin *source, IPin *sink)
 
static struct filter * find_sorted_filter (struct filter_graph *graph, IBaseFilter *iface)
 
static void sort_filter_recurse (struct filter_graph *graph, struct filter *filter, struct list *sorted)
 
static void sort_filters (struct filter_graph *graph)
 
static HRESULT WINAPI FilterGraph2_ConnectDirect (IFilterGraph2 *iface, IPin *ppinIn, IPin *ppinOut, const AM_MEDIA_TYPE *pmt)
 
static HRESULT WINAPI FilterGraph2_Reconnect (IFilterGraph2 *iface, IPin *pin)
 
static HRESULT WINAPI FilterGraph2_Disconnect (IFilterGraph2 *iface, IPin *ppin)
 
static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource (IFilterGraph2 *iface)
 
static DWORD WINAPI message_thread_run (void *ctx)
 
static HRESULT create_filter (struct filter_graph *graph, IMoniker *moniker, IBaseFilter **filter)
 
static HRESULT autoplug (struct filter_graph *graph, IPin *source, IPin *sink, BOOL render_to_existing, unsigned int recursion_depth)
 
static HRESULT autoplug_through_sink (struct filter_graph *graph, IPin *source, IBaseFilter *filter, IPin *middle_sink, IPin *sink, BOOL render_to_existing, unsigned int recursion_depth)
 
static HRESULT autoplug_through_filter (struct filter_graph *graph, IPin *source, IBaseFilter *filter, IPin *sink, BOOL render_to_existing, unsigned int recursion_depth)
 
static HRESULT get_autoplug_types (IPin *source, unsigned int *ret_count, GUID **ret_types)
 
static HRESULT WINAPI FilterGraph2_Connect (IFilterGraph2 *iface, IPin *source, IPin *sink)
 
static HRESULT WINAPI FilterGraph2_Render (IFilterGraph2 *iface, IPin *source)
 
static HRESULT WINAPI FilterGraph2_RenderFile (IFilterGraph2 *iface, LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList)
 
static HRESULT WINAPI FilterGraph2_AddSourceFilter (IFilterGraph2 *iface, const WCHAR *filename, const WCHAR *filter_name, IBaseFilter **ret_filter)
 
static HRESULT WINAPI FilterGraph2_SetLogFile (IFilterGraph2 *iface, DWORD_PTR file)
 
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 *pin, const AM_MEDIA_TYPE *mt)
 
static HRESULT WINAPI FilterGraph2_RenderEx (IFilterGraph2 *iface, IPin *source, DWORD flags, DWORD *context)
 
static struct filter_graph * impl_from_IMediaControl (IMediaControl *iface)
 
static HRESULT WINAPI MediaControl_QueryInterface (IMediaControl *iface, REFIID iid, void **out)
 
static ULONG WINAPI MediaControl_AddRef (IMediaControl *iface)
 
static ULONG WINAPI MediaControl_Release (IMediaControl *iface)
 
static HRESULT WINAPI MediaControl_GetTypeInfoCount (IMediaControl *iface, UINT *count)
 
static HRESULT WINAPI MediaControl_GetTypeInfo (IMediaControl *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
 
static HRESULT WINAPI MediaControl_GetIDsOfNames (IMediaControl *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 
static HRESULT WINAPI MediaControl_Invoke (IMediaControl *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 
static void update_render_count (struct filter_graph *graph)
 
static HRESULT graph_start (struct filter_graph *graph, REFERENCE_TIME stream_start)
 
static void CALLBACK async_run_cb (TP_CALLBACK_INSTANCE *instance, void *context, TP_WORK *work)
 
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 timeout, OAFilterState *state)
 
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 void CALLBACK wait_pause_cb (TP_CALLBACK_INSTANCE *instance, void *context)
 
static void CALLBACK wait_stop_cb (TP_CALLBACK_INSTANCE *instance, void *context)
 
static HRESULT WINAPI MediaControl_StopWhenReady (IMediaControl *iface)
 
static struct filter_graph * impl_from_IMediaSeeking (IMediaSeeking *iface)
 
static HRESULT WINAPI MediaSeeking_QueryInterface (IMediaSeeking *iface, REFIID iid, void **out)
 
static ULONG WINAPI MediaSeeking_AddRef (IMediaSeeking *iface)
 
static ULONG WINAPI MediaSeeking_Release (IMediaSeeking *iface)
 
static HRESULT all_renderers_seek (struct filter_graph *This, fnFoundSeek FoundSeek, DWORD_PTR arg)
 
static HRESULT WINAPI FoundCapabilities (struct filter_graph *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 MediaSeeking_GetDuration (IMediaSeeking *iface, LONGLONG *duration)
 
static HRESULT WINAPI MediaSeeking_GetStopPosition (IMediaSeeking *iface, LONGLONG *stop)
 
static HRESULT WINAPI MediaSeeking_GetCurrentPosition (IMediaSeeking *iface, LONGLONG *current)
 
static HRESULT WINAPI MediaSeeking_ConvertTimeFormat (IMediaSeeking *iface, LONGLONG *pTarget, const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
 
static HRESULT WINAPI MediaSeeking_SetPositions (IMediaSeeking *iface, LONGLONG *current_ptr, DWORD current_flags, LONGLONG *stop_ptr, DWORD stop_flags)
 
static HRESULT WINAPI MediaSeeking_GetPositions (IMediaSeeking *iface, LONGLONG *current, LONGLONG *stop)
 
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 struct filter_graph * impl_from_IMediaPosition (IMediaPosition *iface)
 
static HRESULT WINAPI MediaPosition_QueryInterface (IMediaPosition *iface, REFIID iid, void **out)
 
static ULONG WINAPI MediaPosition_AddRef (IMediaPosition *iface)
 
static ULONG WINAPI MediaPosition_Release (IMediaPosition *iface)
 
static HRESULT WINAPI MediaPosition_GetTypeInfoCount (IMediaPosition *iface, UINT *count)
 
static HRESULT WINAPI MediaPosition_GetTypeInfo (IMediaPosition *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
 
static HRESULT WINAPI MediaPosition_GetIDsOfNames (IMediaPosition *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 
static HRESULT WINAPI MediaPosition_Invoke (IMediaPosition *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 
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 struct filter_graph * impl_from_IObjectWithSite (IObjectWithSite *iface)
 
static HRESULT WINAPI ObjectWithSite_QueryInterface (IObjectWithSite *iface, REFIID iid, void **out)
 
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 (struct filter_graph *pGraph, REFIID riid, LPVOID *ppvObj)
 
static struct filter_graph * impl_from_IBasicAudio (IBasicAudio *iface)
 
static HRESULT WINAPI BasicAudio_QueryInterface (IBasicAudio *iface, REFIID iid, void **out)
 
static ULONG WINAPI BasicAudio_AddRef (IBasicAudio *iface)
 
static ULONG WINAPI BasicAudio_Release (IBasicAudio *iface)
 
static HRESULT WINAPI BasicAudio_GetTypeInfoCount (IBasicAudio *iface, UINT *count)
 
static HRESULT WINAPI BasicAudio_GetTypeInfo (IBasicAudio *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
 
static HRESULT WINAPI BasicAudio_GetIDsOfNames (IBasicAudio *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 
static HRESULT WINAPI BasicAudio_Invoke (IBasicAudio *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 
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 struct filter_graph * impl_from_IBasicVideo2 (IBasicVideo2 *iface)
 
static HRESULT WINAPI BasicVideo_QueryInterface (IBasicVideo2 *iface, REFIID iid, void **out)
 
static ULONG WINAPI BasicVideo_AddRef (IBasicVideo2 *iface)
 
static ULONG WINAPI BasicVideo_Release (IBasicVideo2 *iface)
 
static HRESULT WINAPI BasicVideo_GetTypeInfoCount (IBasicVideo2 *iface, UINT *count)
 
static HRESULT WINAPI BasicVideo_GetTypeInfo (IBasicVideo2 *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
 
static HRESULT WINAPI BasicVideo_GetIDsOfNames (IBasicVideo2 *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 
static HRESULT WINAPI BasicVideo_Invoke (IBasicVideo2 *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 
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 struct filter_graph * impl_from_IVideoWindow (IVideoWindow *iface)
 
static HRESULT WINAPI VideoWindow_QueryInterface (IVideoWindow *iface, REFIID iid, void **out)
 
static ULONG WINAPI VideoWindow_AddRef (IVideoWindow *iface)
 
static ULONG WINAPI VideoWindow_Release (IVideoWindow *iface)
 
HRESULT WINAPI VideoWindow_GetTypeInfoCount (IVideoWindow *iface, UINT *count)
 
HRESULT WINAPI VideoWindow_GetTypeInfo (IVideoWindow *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
 
HRESULT WINAPI VideoWindow_GetIDsOfNames (IVideoWindow *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 
static HRESULT WINAPI VideoWindow_Invoke (IVideoWindow *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 
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 struct filter_graph * impl_from_IMediaEventEx (IMediaEventEx *iface)
 
static HRESULT WINAPI MediaEvent_QueryInterface (IMediaEventEx *iface, REFIID iid, void **out)
 
static ULONG WINAPI MediaEvent_AddRef (IMediaEventEx *iface)
 
static ULONG WINAPI MediaEvent_Release (IMediaEventEx *iface)
 
static HRESULT WINAPI MediaEvent_GetTypeInfoCount (IMediaEventEx *iface, UINT *count)
 
static HRESULT WINAPI MediaEvent_GetTypeInfo (IMediaEventEx *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
 
static HRESULT WINAPI MediaEvent_GetIDsOfNames (IMediaEventEx *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
 
static HRESULT WINAPI MediaEvent_Invoke (IMediaEventEx *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
 
static HRESULT WINAPI MediaEvent_GetEventHandle (IMediaEventEx *iface, OAEVENT *event)
 
static HRESULT WINAPI MediaEvent_GetEvent (IMediaEventEx *iface, LONG *code, LONG_PTR *param1, LONG_PTR *param2, LONG timeout)
 
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 code, LONG_PTR param1, LONG_PTR param2)
 
static HRESULT WINAPI MediaEvent_SetNotifyWindow (IMediaEventEx *iface, OAHWND window, LONG message, LONG_PTR lparam)
 
static HRESULT WINAPI MediaEvent_SetNotifyFlags (IMediaEventEx *iface, LONG flags)
 
static HRESULT WINAPI MediaEvent_GetNotifyFlags (IMediaEventEx *iface, LONG *flags)
 
static struct filter_graph * impl_from_IMediaFilter (IMediaFilter *iface)
 
static HRESULT WINAPI MediaFilter_QueryInterface (IMediaFilter *iface, REFIID iid, void **out)
 
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 start)
 
static HRESULT WINAPI MediaFilter_GetState (IMediaFilter *iface, DWORD timeout, FILTER_STATE *state)
 
static HRESULT WINAPI MediaFilter_SetSyncSource (IMediaFilter *iface, IReferenceClock *pClock)
 
static HRESULT WINAPI MediaFilter_GetSyncSource (IMediaFilter *iface, IReferenceClock **ppClock)
 
static struct filter_graph * impl_from_IMediaEventSink (IMediaEventSink *iface)
 
static HRESULT WINAPI MediaEventSink_QueryInterface (IMediaEventSink *iface, REFIID iid, void **out)
 
static ULONG WINAPI MediaEventSink_AddRef (IMediaEventSink *iface)
 
static ULONG WINAPI MediaEventSink_Release (IMediaEventSink *iface)
 
static HRESULT WINAPI MediaEventSink_Notify (IMediaEventSink *iface, LONG code, LONG_PTR param1, LONG_PTR param2)
 
static struct filter_graph * impl_from_IGraphConfig (IGraphConfig *iface)
 
static HRESULT WINAPI GraphConfig_QueryInterface (IGraphConfig *iface, REFIID iid, void **out)
 
static ULONG WINAPI GraphConfig_AddRef (IGraphConfig *iface)
 
static ULONG WINAPI GraphConfig_Release (IGraphConfig *iface)
 
static HRESULT WINAPI GraphConfig_Reconnect (IGraphConfig *iface, IPin *source, IPin *sink, const AM_MEDIA_TYPE *mt, IBaseFilter *filter, HANDLE abort_event, DWORD flags)
 
static HRESULT WINAPI GraphConfig_Reconfigure (IGraphConfig *iface, IGraphConfigCallback *callback, void *context, DWORD flags, HANDLE abort_event)
 
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 *filter, DWORD flags)
 
static HRESULT WINAPI GraphConfig_GetFilterFlags (IGraphConfig *iface, IBaseFilter *pFilter, DWORD *dwFlags)
 
static HRESULT WINAPI GraphConfig_RemoveFilterEx (IGraphConfig *iface, IBaseFilter *filter, DWORD flags)
 
static struct filter_graph * impl_from_IGraphVersion (IGraphVersion *iface)
 
static HRESULT WINAPI GraphVersion_QueryInterface (IGraphVersion *iface, REFIID iid, void **out)
 
static ULONG WINAPI GraphVersion_AddRef (IGraphVersion *iface)
 
static ULONG WINAPI GraphVersion_Release (IGraphVersion *iface)
 
static HRESULT WINAPI GraphVersion_QueryVersion (IGraphVersion *iface, LONG *version)
 
static struct filter_graph * impl_from_IVideoFrameStep (IVideoFrameStep *iface)
 
static HRESULT WINAPI VideoFrameStep_QueryInterface (IVideoFrameStep *iface, REFIID iid, void **out)
 
static ULONG WINAPI VideoFrameStep_AddRef (IVideoFrameStep *iface)
 
static ULONG WINAPI VideoFrameStep_Release (IVideoFrameStep *iface)
 
static HRESULT WINAPI VideoFrameStep_Step (IVideoFrameStep *iface, DWORD frame_count, IUnknown *filter)
 
static HRESULT WINAPI VideoFrameStep_CanStep (IVideoFrameStep *iface, LONG multiple, IUnknown *filter)
 
static HRESULT WINAPI VideoFrameStep_CancelStep (IVideoFrameStep *iface)
 
static HRESULT filter_graph_common_create (IUnknown *outer, IUnknown **out, BOOL threaded)
 
HRESULT filter_graph_create (IUnknown *outer, IUnknown **out)
 
HRESULT filter_graph_no_thread_create (IUnknown *outer, IUnknown **out)
 

Variables

static HANDLE message_thread
 
static HANDLE message_thread_ret
 
static DWORD message_thread_id
 
static unsigned int message_thread_refcount
 
static const IEnumFiltersVtbl EnumFilters_vtbl
 
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 IVideoFrameStepVtbl VideoFrameStep_vtbl
 
static const IUnknownVtbl IInner_VTable
 

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 24 of file filtergraph.c.

◆ MAX_ITF_CACHE_ENTRIES

#define MAX_ITF_CACHE_ENTRIES   3

Definition at line 65 of file filtergraph.c.

Typedef Documentation

◆ fnFoundSeek

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

Definition at line 2125 of file filtergraph.c.

◆ ITF_CACHE_ENTRY

typedef struct _ITF_CACHE_ENTRY ITF_CACHE_ENTRY

Function Documentation

◆ all_renderers_seek()

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

Definition at line 2127 of file filtergraph.c.

2127 {
2128 BOOL allnotimpl = TRUE;
2129 HRESULT hr, hr_return = S_OK;
2130 struct filter *filter;
2131
2132 LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
2133 {
2134 update_seeking(filter);
2135 if (!filter->seeking)
2136 continue;
2137 hr = FoundSeek(This, filter->seeking, arg);
2138 if (hr_return != E_NOTIMPL)
2139 allnotimpl = FALSE;
2140 if (hr_return == S_OK || (FAILED(hr) && hr != E_NOTIMPL && SUCCEEDED(hr_return)))
2141 hr_return = hr;
2142 }
2143
2144 if (allnotimpl)
2145 return E_NOTIMPL;
2146 return hr_return;
2147}
E_NOTIMPL
#define E_NOTIMPL
Definition: ddrawi.h:99
hr
HRESULT hr
Definition: delayimp.cpp:582
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
update_seeking
static void update_seeking(struct filter *filter)
Definition: filtergraph.c:558
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
S_OK
#define S_OK
Definition: intsafe.h:52
SUCCEEDED
#define SUCCEEDED(hr)
Definition: intsafe.h:50
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
entry
uint32_t entry
Definition: isohybrid.c:63
LIST_FOR_EACH_ENTRY
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:236
filter
Definition: filter.c:165
filter::filter
IBaseFilter * filter
Definition: filtergraph.c:75
filter::seeking
IMediaSeeking * seeking
Definition: filtergraph.c:76

Referenced by MediaSeeking_CheckCapabilities(), and MediaSeeking_GetCapabilities().

◆ async_run_cb()

static void CALLBACK async_run_cb ( TP_CALLBACK_INSTANCE *  instance,
void *  context,
TP_WORK *  work 
)
static

Definition at line 1826 of file filtergraph.c.

1827{
1828 struct filter_graph *graph = context;
1829 struct filter *filter;
1830 FILTER_STATE state;
1831 HRESULT hr;
1832
1833 TRACE("Performing asynchronous state change.\n");
1834
1835 /* We can't just call GetState(), since that will return State_Running and
1836 * VFW_S_STATE_INTERMEDIATE regardless of whether we're done pausing yet.
1837 * Instead replicate it here. */
1838
1839 for (;;)
1840 {
1841 IBaseFilter *async_filter = NULL;
1842
1843 hr = S_OK;
1844
1845 EnterCriticalSection(&graph->cs);
1846
1847 if (!graph->needs_async_run)
1848 break;
1849
1850 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1851 {
1852 hr = IBaseFilter_GetState(filter->filter, 0, &state);
1853
1854 if (hr == VFW_S_STATE_INTERMEDIATE)
1855 async_filter = filter->filter;
1856
1857 if (SUCCEEDED(hr) && state != State_Paused)
1858 ERR("Filter %p reported incorrect state %u.\n", filter->filter, state);
1859
1860 if (hr != S_OK)
1861 break;
1862 }
1863
1864 if (hr != VFW_S_STATE_INTERMEDIATE)
1865 break;
1866
1867 LeaveCriticalSection(&graph->cs);
1868
1869 IBaseFilter_GetState(async_filter, 10, &state);
1870 }
1871
1872 if (hr == S_OK && graph->needs_async_run)
1873 {
1874 sort_filters(graph);
1875 graph_start(graph, 0);
1876 graph->needs_async_run = 0;
1877 }
1878
1879 LeaveCriticalSection(&graph->cs);
1880}
state
static int state
Definition: maze.c:121
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
NULL
#define NULL
Definition: types.h:112
sort_filters
static void sort_filters(struct filter_graph *graph)
Definition: filtergraph.c:906
graph_start
static HRESULT graph_start(struct filter_graph *graph, REFERENCE_TIME stream_start)
Definition: filtergraph.c:1774
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
context
Definition: http.c:7252
filter_graph
Definition: filtergraph.c:82
graph
Definition: graph.c:32
VFW_S_STATE_INTERMEDIATE
#define VFW_S_STATE_INTERMEDIATE
Definition: vfwmsgs.h:21
LeaveCriticalSection
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)

Referenced by MediaControl_Run().

◆ autoplug()

static HRESULT autoplug ( struct filter_graph *  graph,
IPin *  source,
IPin *  sink,
BOOL  render_to_existing,
unsigned int  recursion_depth 
)
static

Definition at line 1263 of file filtergraph.c.

1265{
1266 IAMGraphBuilderCallback *callback = NULL;
1267 struct filter *graph_filter;
1268 IEnumMoniker *enummoniker;
1269 unsigned int type_count;
1270 IFilterMapper2 *mapper;
1271 IBaseFilter *filter;
1272 GUID *types = NULL;
1273 IMoniker *moniker;
1274 HRESULT hr;
1275
1276 TRACE("Trying to autoplug %p to %p, recursion depth %u.\n", source, sink, recursion_depth);
1277
1278 if (recursion_depth >= 5)
1279 {
1280 WARN("Recursion depth has reached 5; aborting.\n");
1281 return VFW_E_CANNOT_CONNECT;
1282 }
1283
1284 if (sink)
1285 {
1286 /* Try to connect directly to this sink. */
1287 hr = IFilterGraph2_ConnectDirect(&graph->IFilterGraph2_iface, source, sink, NULL);
1288
1289 /* If direct connection succeeded, we should propagate that return value.
1290 * If it returned VFW_E_NOT_CONNECTED or VFW_E_NO_AUDIO_HARDWARE, then don't
1291 * even bother trying intermediate filters, since they won't succeed. */
1292 if (SUCCEEDED(hr) || hr == VFW_E_NOT_CONNECTED || hr == VFW_E_NO_AUDIO_HARDWARE)
1293 return hr;
1294 }
1295
1296 /* Always prefer filters in the graph. */
1297 LIST_FOR_EACH_ENTRY(graph_filter, &graph->filters, struct filter, entry)
1298 {
1299 if (SUCCEEDED(hr = autoplug_through_filter(graph, source, graph_filter->filter,
1300 sink, render_to_existing, recursion_depth)))
1301 return hr;
1302 }
1303
1304 IUnknown_QueryInterface(graph->punkFilterMapper2, &IID_IFilterMapper2, (void **)&mapper);
1305
1306 if (FAILED(hr = get_autoplug_types(source, &type_count, &types)))
1307 {
1308 IFilterMapper2_Release(mapper);
1309 return hr;
1310 }
1311
1312 if (graph->pSite)
1313 IUnknown_QueryInterface(graph->pSite, &IID_IAMGraphBuilderCallback, (void **)&callback);
1314
1315 if (FAILED(hr = IFilterMapper2_EnumMatchingFilters(mapper, &enummoniker,
1316 0, FALSE, MERIT_UNLIKELY, TRUE, type_count, types, NULL, NULL, FALSE,
1317 render_to_existing, 0, NULL, NULL, NULL)))
1318 goto out;
1319
1320 while (IEnumMoniker_Next(enummoniker, 1, &moniker, NULL) == S_OK)
1321 {
1322 IPropertyBag *bag;
1323 VARIANT var;
1324
1325 VariantInit(&var);
1326 IMoniker_BindToStorage(moniker, NULL, NULL, &IID_IPropertyBag, (void **)&bag);
1327 hr = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
1328 IPropertyBag_Release(bag);
1329 if (FAILED(hr))
1330 {
1331 IMoniker_Release(moniker);
1332 continue;
1333 }
1334
1335 if (callback && FAILED(hr = IAMGraphBuilderCallback_SelectedFilter(callback, moniker)))
1336 {
1337 TRACE("Filter rejected by IAMGraphBuilderCallback::SelectedFilter(), hr %#lx.\n", hr);
1338 IMoniker_Release(moniker);
1339 continue;
1340 }
1341
1342 hr = create_filter(graph, moniker, &filter);
1343 IMoniker_Release(moniker);
1344 if (FAILED(hr))
1345 {
1346 ERR("Failed to create filter for %s, hr %#lx.\n", debugstr_w(V_BSTR(&var)), hr);
1347 VariantClear(&var);
1348 continue;
1349 }
1350
1351 if (callback && FAILED(hr = IAMGraphBuilderCallback_CreatedFilter(callback, filter)))
1352 {
1353 TRACE("Filter rejected by IAMGraphBuilderCallback::CreatedFilter(), hr %#lx.\n", hr);
1354 IBaseFilter_Release(filter);
1355 continue;
1356 }
1357
1358 hr = IFilterGraph2_AddFilter(&graph->IFilterGraph2_iface, filter, V_BSTR(&var));
1359 VariantClear(&var);
1360 if (FAILED(hr))
1361 {
1362 ERR("Failed to add filter, hr %#lx.\n", hr);
1363 IBaseFilter_Release(filter);
1364 continue;
1365 }
1366
1367 hr = autoplug_through_filter(graph, source, filter, sink, render_to_existing, recursion_depth);
1368 if (SUCCEEDED(hr))
1369 {
1370 IBaseFilter_Release(filter);
1371 goto out;
1372 }
1373
1374 IFilterGraph2_RemoveFilter(&graph->IFilterGraph2_iface, filter);
1375 IBaseFilter_Release(filter);
1376 }
1377 IEnumMoniker_Release(enummoniker);
1378
1379 hr = VFW_E_CANNOT_CONNECT;
1380
1381out:
1382 free(types);
1383 if (callback) IAMGraphBuilderCallback_Release(callback);
1384 IFilterMapper2_Release(mapper);
1385 return hr;
1386}
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
free
#define free
Definition: debug_ros.c:5
create_filter
static HRESULT create_filter(struct filter_graph *graph, IMoniker *moniker, IBaseFilter **filter)
Definition: filtergraph.c:1071
get_autoplug_types
static HRESULT get_autoplug_types(IPin *source, unsigned int *ret_count, GUID **ret_types)
Definition: filtergraph.c:1201
autoplug_through_filter
static HRESULT autoplug_through_filter(struct filter_graph *graph, IPin *source, IBaseFilter *filter, IPin *sink, BOOL render_to_existing, unsigned int recursion_depth)
Definition: filtergraph.c:1173
L
#define L(x)
Definition: resources.c:13
sink
GLsizei GLenum GLboolean sink
Definition: glext.h:5672
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
callback
static IPrintDialogCallback callback
Definition: printdlg.c:325
var
const char * var
Definition: shader.c:5879
V_BSTR
#define V_BSTR(A)
Definition: oleauto.h:226
IID_IPropertyBag
const GUID IID_IPropertyBag
graph::IFilterGraph2_iface
IFilterGraph2 IFilterGraph2_iface
Definition: amstream.c:2168
types
Definition: cmds.c:130
VariantClear
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:626
VariantInit
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:547
VFW_E_NO_AUDIO_HARDWARE
#define VFW_E_NO_AUDIO_HARDWARE
Definition: vfwmsgs.h:109
VFW_E_CANNOT_CONNECT
#define VFW_E_CANNOT_CONNECT
Definition: vfwmsgs.h:62
VFW_E_NOT_CONNECTED
#define VFW_E_NOT_CONNECTED
Definition: vfwmsgs.h:48
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383

Referenced by autoplug_through_sink(), FilterGraph2_Connect(), FilterGraph2_Render(), and FilterGraph2_RenderEx().

◆ autoplug_through_filter()

static HRESULT autoplug_through_filter ( struct filter_graph *  graph,
IPin *  source,
IBaseFilter *  filter,
IPin *  sink,
BOOL  render_to_existing,
unsigned int  recursion_depth 
)
static

Definition at line 1173 of file filtergraph.c.

1176{
1177 IEnumPins *sink_enum;
1178 IPin *filter_sink;
1179 HRESULT hr;
1180
1181 TRACE("Trying to autoplug %p to %p through %p.\n", source, sink, filter);
1182
1183 if (FAILED(hr = IBaseFilter_EnumPins(filter, &sink_enum)))
1184 return hr;
1185
1186 while (IEnumPins_Next(sink_enum, 1, &filter_sink, NULL) == S_OK)
1187 {
1188 hr = autoplug_through_sink(graph, source, filter, filter_sink, sink,
1189 render_to_existing, recursion_depth);
1190 IPin_Release(filter_sink);
1191 if (SUCCEEDED(hr))
1192 {
1193 IEnumPins_Release(sink_enum);
1194 return hr;
1195 }
1196 }
1197 IEnumPins_Release(sink_enum);
1198 return VFW_E_CANNOT_CONNECT;
1199}
autoplug_through_sink
static HRESULT autoplug_through_sink(struct filter_graph *graph, IPin *source, IBaseFilter *filter, IPin *middle_sink, IPin *sink, BOOL render_to_existing, unsigned int recursion_depth)
Definition: filtergraph.c:1094
IPin
Definition: axcore.idl:92

Referenced by autoplug().

◆ autoplug_through_sink()

static HRESULT autoplug_through_sink ( struct filter_graph *  graph,
IPin *  source,
IBaseFilter *  filter,
IPin *  middle_sink,
IPin *  sink,
BOOL  render_to_existing,
unsigned int  recursion_depth 
)
static

Definition at line 1094 of file filtergraph.c.

1097{
1098 BOOL any = FALSE, all = TRUE;
1099 IPin *middle_source, *peer;
1100 IEnumPins *source_enum;
1101 PIN_DIRECTION dir;
1102 PIN_INFO info;
1103 HRESULT hr;
1104
1105 TRACE("Trying to autoplug %p to %p through %p.\n", source, sink, middle_sink);
1106
1107 IPin_QueryDirection(middle_sink, &dir);
1108 if (dir != PINDIR_INPUT)
1109 return E_FAIL;
1110
1111 if (IPin_ConnectedTo(middle_sink, &peer) == S_OK)
1112 {
1113 IPin_Release(peer);
1114 return E_FAIL;
1115 }
1116
1117 if (FAILED(hr = IFilterGraph2_ConnectDirect(&graph->IFilterGraph2_iface, source, middle_sink, NULL)))
1118 return E_FAIL;
1119
1120 if (FAILED(hr = IBaseFilter_EnumPins(filter, &source_enum)))
1121 goto err;
1122
1123 while (IEnumPins_Next(source_enum, 1, &middle_source, NULL) == S_OK)
1124 {
1125 IPin_QueryPinInfo(middle_source, &info);
1126 IBaseFilter_Release(info.pFilter);
1127 if (info.dir != PINDIR_OUTPUT)
1128 {
1129 IPin_Release(middle_source);
1130 continue;
1131 }
1132 if (info.achName[0] == '~')
1133 {
1134 TRACE("Skipping non-rendered pin %s.\n", debugstr_w(info.achName));
1135 IPin_Release(middle_source);
1136 continue;
1137 }
1138 if (IPin_ConnectedTo(middle_source, &peer) == S_OK)
1139 {
1140 IPin_Release(peer);
1141 IPin_Release(middle_source);
1142 continue;
1143 }
1144
1145 hr = autoplug(graph, middle_source, sink, render_to_existing, recursion_depth + 1);
1146 IPin_Release(middle_source);
1147 if (SUCCEEDED(hr) && sink)
1148 {
1149 IEnumPins_Release(source_enum);
1150 return hr;
1151 }
1152 if (SUCCEEDED(hr))
1153 any = TRUE;
1154 if (hr != S_OK)
1155 all = FALSE;
1156 }
1157 IEnumPins_Release(source_enum);
1158
1159 if (!sink)
1160 {
1161 if (all)
1162 return S_OK;
1163 if (any)
1164 return VFW_S_PARTIAL_RENDER;
1165 }
1166
1167err:
1168 IFilterGraph2_Disconnect(&graph->IFilterGraph2_iface, source);
1169 IFilterGraph2_Disconnect(&graph->IFilterGraph2_iface, middle_sink);
1170 return E_FAIL;
1171}
dir
unsigned int dir
Definition: maze.c:112
PIN_DIRECTION
enum _PinDirection PIN_DIRECTION
PINDIR_OUTPUT
@ PINDIR_OUTPUT
Definition: axcore.idl:42
PINDIR_INPUT
@ PINDIR_INPUT
Definition: axcore.idl:41
E_FAIL
#define E_FAIL
Definition: ddrawi.h:102
autoplug
static HRESULT autoplug(struct filter_graph *graph, IPin *source, IPin *sink, BOOL render_to_existing, unsigned int recursion_depth)
Definition: filtergraph.c:1263
err
#define err(...)
Definition: reactos_support_code.h:30
PIN_INFO
Definition: sysaudio.h:7
VFW_S_PARTIAL_RENDER
#define VFW_S_PARTIAL_RENDER
Definition: vfwmsgs.h:22

Referenced by autoplug_through_filter().

◆ BasicAudio_AddRef()

static ULONG WINAPI BasicAudio_AddRef ( IBasicAudio *  iface)
static

Definition at line 2919 of file filtergraph.c.

2920{
2921 struct filter_graph *graph = impl_from_IBasicAudio(iface);
2922 return IUnknown_AddRef(graph->outer_unk);
2923}
impl_from_IBasicAudio
static struct filter_graph * impl_from_IBasicAudio(IBasicAudio *iface)
Definition: filtergraph.c:2908

◆ BasicAudio_get_Balance()

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

Definition at line 3040 of file filtergraph.c.

3041{
3042 struct filter_graph *This = impl_from_IBasicAudio(iface);
3043 IBasicAudio* pBasicAudio;
3044 HRESULT hr;
3045
3046 TRACE("(%p/%p)->(%p)\n", This, iface, plBalance);
3047
3048 EnterCriticalSection(&This->cs);
3049
3050 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3051
3052 if (hr == S_OK)
3053 hr = IBasicAudio_get_Balance(pBasicAudio, plBalance);
3054
3055 LeaveCriticalSection(&This->cs);
3056
3057 return hr;
3058}
GetTargetInterface
static HRESULT GetTargetInterface(struct filter_graph *pGraph, REFIID riid, LPVOID *ppvObj)
Definition: filtergraph.c:2863

◆ BasicAudio_get_Volume()

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

Definition at line 3000 of file filtergraph.c.

3001{
3002 struct filter_graph *This = impl_from_IBasicAudio(iface);
3003 IBasicAudio* pBasicAudio;
3004 HRESULT hr;
3005
3006 TRACE("(%p/%p)->(%p)\n", This, iface, plVolume);
3007
3008 EnterCriticalSection(&This->cs);
3009
3010 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3011
3012 if (hr == S_OK)
3013 hr = IBasicAudio_get_Volume(pBasicAudio, plVolume);
3014
3015 LeaveCriticalSection(&This->cs);
3016
3017 return hr;
3018}

◆ BasicAudio_GetIDsOfNames()

static HRESULT WINAPI BasicAudio_GetIDsOfNames ( IBasicAudio *  iface,
REFIID  iid,
LPOLESTR *  names,
UINT  count,
LCID  lcid,
DISPID *  ids 
)
static

Definition at line 2945 of file filtergraph.c.

2947{
2948 ITypeInfo *typeinfo;
2949 HRESULT hr;
2950
2951 TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
2952 iface, debugstr_guid(iid), names, count, lcid, ids);
2953
2954 if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicAudio_tid, &typeinfo)))
2955 {
2956 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
2957 ITypeInfo_Release(typeinfo);
2958 }
2959 return hr;
2960}
lcid
LCID lcid
Definition: locale.c:5660
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
ids
GLuint * ids
Definition: glext.h:5907
names
GLuint GLuint * names
Definition: glext.h:11545
debugstr_guid
#define debugstr_guid
Definition: kernel32.h:35
IBasicAudio_tid
@ IBasicAudio_tid
Definition: strmbase.h:225
strmbase_get_typeinfo
HRESULT strmbase_get_typeinfo(enum strmbase_type_id tid, ITypeInfo **typeinfo)
Definition: dispatch.c:38

◆ BasicAudio_GetTypeInfo()

static HRESULT WINAPI BasicAudio_GetTypeInfo ( IBasicAudio *  iface,
UINT  index,
LCID  lcid,
ITypeInfo **  typeinfo 
)
static

Definition at line 2938 of file filtergraph.c.

2940{
2941 TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
2942 return strmbase_get_typeinfo(IBasicAudio_tid, typeinfo);
2943}
index
GLuint index
Definition: glext.h:6031

◆ BasicAudio_GetTypeInfoCount()

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

Definition at line 2931 of file filtergraph.c.

2932{
2933 TRACE("iface %p, count %p.\n", iface, count);
2934 *count = 1;
2935 return S_OK;
2936}

◆ BasicAudio_Invoke()

static HRESULT WINAPI BasicAudio_Invoke ( IBasicAudio *  iface,
DISPID  id,
REFIID  iid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepinfo,
UINT *  error_arg 
)
static

Definition at line 2962 of file filtergraph.c.

2964{
2965 ITypeInfo *typeinfo;
2966 HRESULT hr;
2967
2968 TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
2969 iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
2970
2971 if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicAudio_tid, &typeinfo)))
2972 {
2973 hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
2974 ITypeInfo_Release(typeinfo);
2975 }
2976 return hr;
2977}
params
GLenum const GLfloat * params
Definition: glext.h:5645
flags
GLbitfield flags
Definition: glext.h:7161
result
GLuint64EXT * result
Definition: glext.h:11304
excepinfo
static EXCEPINFO excepinfo
Definition: automation.c:47

◆ BasicAudio_put_Balance()

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

Definition at line 3020 of file filtergraph.c.

3021{
3022 struct filter_graph *This = impl_from_IBasicAudio(iface);
3023 IBasicAudio* pBasicAudio;
3024 HRESULT hr;
3025
3026 TRACE("graph %p, balance %ld.\n", This, lBalance);
3027
3028 EnterCriticalSection(&This->cs);
3029
3030 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
3031
3032 if (hr == S_OK)
3033 hr = IBasicAudio_put_Balance(pBasicAudio, lBalance);
3034
3035 LeaveCriticalSection(&This->cs);
3036
3037 return hr;
3038}

◆ BasicAudio_put_Volume()

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

Definition at line 2980 of file filtergraph.c.

2981{
2982 struct filter_graph *This = impl_from_IBasicAudio(iface);
2983 IBasicAudio* pBasicAudio;
2984 HRESULT hr;
2985
2986 TRACE("graph %p, volume %ld.\n", This, lVolume);
2987
2988 EnterCriticalSection(&This->cs);
2989
2990 hr = GetTargetInterface(This, &IID_IBasicAudio, (LPVOID*)&pBasicAudio);
2991
2992 if (hr == S_OK)
2993 hr = IBasicAudio_put_Volume(pBasicAudio, lVolume);
2994
2995 LeaveCriticalSection(&This->cs);
2996
2997 return hr;
2998}

◆ BasicAudio_QueryInterface()

static HRESULT WINAPI BasicAudio_QueryInterface ( IBasicAudio *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 2913 of file filtergraph.c.

2914{
2915 struct filter_graph *graph = impl_from_IBasicAudio(iface);
2916 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2917}

◆ BasicAudio_Release()

static ULONG WINAPI BasicAudio_Release ( IBasicAudio *  iface)
static

Definition at line 2925 of file filtergraph.c.

2926{
2927 struct filter_graph *graph = impl_from_IBasicAudio(iface);
2928 return IUnknown_Release(graph->outer_unk);
2929}

◆ BasicVideo2_GetPreferredAspectRatio()

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

Definition at line 3795 of file filtergraph.c.

3797{
3798 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3799 IBasicVideo2 *pBasicVideo2;
3800 HRESULT hr;
3801
3802 TRACE("(%p/%p)->()\n", This, iface);
3803
3804 EnterCriticalSection(&This->cs);
3805
3806 hr = GetTargetInterface(This, &IID_IBasicVideo2, (LPVOID*)&pBasicVideo2);
3807
3808 if (hr == S_OK)
3809 hr = BasicVideo2_GetPreferredAspectRatio(iface, plAspectX, plAspectY);
3810
3811 LeaveCriticalSection(&This->cs);
3812
3813 return hr;
3814}
impl_from_IBasicVideo2
static struct filter_graph * impl_from_IBasicVideo2(IBasicVideo2 *iface)
Definition: filtergraph.c:3075
BasicVideo2_GetPreferredAspectRatio
static HRESULT WINAPI BasicVideo2_GetPreferredAspectRatio(IBasicVideo2 *iface, LONG *plAspectX, LONG *plAspectY)
Definition: filtergraph.c:3795

Referenced by BasicVideo2_GetPreferredAspectRatio().

◆ BasicVideo_AddRef()

static ULONG WINAPI BasicVideo_AddRef ( IBasicVideo2 *  iface)
static

Definition at line 3086 of file filtergraph.c.

3087{
3088 struct filter_graph *graph = impl_from_IBasicVideo2(iface);
3089 return IUnknown_AddRef(graph->outer_unk);
3090}

◆ BasicVideo_get_AvgTimePerFrame()

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

Definition at line 3147 of file filtergraph.c.

3148{
3149 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3150 IBasicVideo *pBasicVideo;
3151 HRESULT hr;
3152
3153 TRACE("(%p/%p)->(%p)\n", This, iface, pAvgTimePerFrame);
3154
3155 EnterCriticalSection(&This->cs);
3156
3157 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3158
3159 if (hr == S_OK)
3160 hr = IBasicVideo_get_AvgTimePerFrame(pBasicVideo, pAvgTimePerFrame);
3161
3162 LeaveCriticalSection(&This->cs);
3163
3164 return hr;
3165}

◆ BasicVideo_get_BitErrorRate()

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

Definition at line 3187 of file filtergraph.c.

3188{
3189 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3190 IBasicVideo *pBasicVideo;
3191 HRESULT hr;
3192
3193 TRACE("(%p/%p)->(%p)\n", This, iface, pBitErrorRate);
3194
3195 EnterCriticalSection(&This->cs);
3196
3197 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3198
3199 if (hr == S_OK)
3200 hr = IBasicVideo_get_BitErrorRate(pBasicVideo, pBitErrorRate);
3201
3202 LeaveCriticalSection(&This->cs);
3203
3204 return hr;
3205}

◆ BasicVideo_get_BitRate()

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

Definition at line 3167 of file filtergraph.c.

3168{
3169 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3170 IBasicVideo *pBasicVideo;
3171 HRESULT hr;
3172
3173 TRACE("(%p/%p)->(%p)\n", This, iface, pBitRate);
3174
3175 EnterCriticalSection(&This->cs);
3176
3177 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3178
3179 if (hr == S_OK)
3180 hr = IBasicVideo_get_BitRate(pBasicVideo, pBitRate);
3181
3182 LeaveCriticalSection(&This->cs);
3183
3184 return hr;
3185}

◆ BasicVideo_get_DestinationHeight()

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

Definition at line 3547 of file filtergraph.c.

3549{
3550 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3551 IBasicVideo *pBasicVideo;
3552 HRESULT hr;
3553
3554 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationHeight);
3555
3556 EnterCriticalSection(&This->cs);
3557
3558 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3559
3560 if (hr == S_OK)
3561 hr = IBasicVideo_get_DestinationHeight(pBasicVideo, pDestinationHeight);
3562
3563 LeaveCriticalSection(&This->cs);
3564
3565 return hr;
3566}

◆ BasicVideo_get_DestinationLeft()

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

Definition at line 3427 of file filtergraph.c.

3428{
3429 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3430 IBasicVideo *pBasicVideo;
3431 HRESULT hr;
3432
3433 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationLeft);
3434
3435 EnterCriticalSection(&This->cs);
3436
3437 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3438
3439 if (hr == S_OK)
3440 hr = IBasicVideo_get_DestinationLeft(pBasicVideo, pDestinationLeft);
3441
3442 LeaveCriticalSection(&This->cs);
3443
3444 return hr;
3445}

◆ BasicVideo_get_DestinationTop()

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

Definition at line 3507 of file filtergraph.c.

3508{
3509 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3510 IBasicVideo *pBasicVideo;
3511 HRESULT hr;
3512
3513 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationTop);
3514
3515 EnterCriticalSection(&This->cs);
3516
3517 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3518
3519 if (hr == S_OK)
3520 hr = IBasicVideo_get_DestinationTop(pBasicVideo, pDestinationTop);
3521
3522 LeaveCriticalSection(&This->cs);
3523
3524 return hr;
3525}

◆ BasicVideo_get_DestinationWidth()

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

Definition at line 3467 of file filtergraph.c.

3468{
3469 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3470 IBasicVideo *pBasicVideo;
3471 HRESULT hr;
3472
3473 TRACE("(%p/%p)->(%p)\n", This, iface, pDestinationWidth);
3474
3475 EnterCriticalSection(&This->cs);
3476
3477 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3478
3479 if (hr == S_OK)
3480 hr = IBasicVideo_get_DestinationWidth(pBasicVideo, pDestinationWidth);
3481
3482 LeaveCriticalSection(&This->cs);
3483
3484 return hr;
3485}

◆ BasicVideo_get_SourceHeight()

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

Definition at line 3387 of file filtergraph.c.

3388{
3389 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3390 IBasicVideo *pBasicVideo;
3391 HRESULT hr;
3392
3393 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceHeight);
3394
3395 EnterCriticalSection(&This->cs);
3396
3397 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3398
3399 if (hr == S_OK)
3400 hr = IBasicVideo_get_SourceHeight(pBasicVideo, pSourceHeight);
3401
3402 LeaveCriticalSection(&This->cs);
3403
3404 return hr;
3405}

◆ BasicVideo_get_SourceLeft()

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

Definition at line 3267 of file filtergraph.c.

3268{
3269 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3270 IBasicVideo *pBasicVideo;
3271 HRESULT hr;
3272
3273 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceLeft);
3274
3275 EnterCriticalSection(&This->cs);
3276
3277 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3278
3279 if (hr == S_OK)
3280 hr = IBasicVideo_get_SourceLeft(pBasicVideo, pSourceLeft);
3281
3282 LeaveCriticalSection(&This->cs);
3283
3284 return hr;
3285}

◆ BasicVideo_get_SourceTop()

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

Definition at line 3347 of file filtergraph.c.

3348{
3349 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3350 IBasicVideo *pBasicVideo;
3351 HRESULT hr;
3352
3353 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceTop);
3354
3355 EnterCriticalSection(&This->cs);
3356
3357 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3358
3359 if (hr == S_OK)
3360 hr = IBasicVideo_get_SourceTop(pBasicVideo, pSourceTop);
3361
3362 LeaveCriticalSection(&This->cs);
3363
3364 return hr;
3365}

◆ BasicVideo_get_SourceWidth()

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

Definition at line 3307 of file filtergraph.c.

3308{
3309 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3310 IBasicVideo *pBasicVideo;
3311 HRESULT hr;
3312
3313 TRACE("(%p/%p)->(%p)\n", This, iface, pSourceWidth);
3314
3315 EnterCriticalSection(&This->cs);
3316
3317 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3318
3319 if (hr == S_OK)
3320 hr = IBasicVideo_get_SourceWidth(pBasicVideo, pSourceWidth);
3321
3322 LeaveCriticalSection(&This->cs);
3323
3324 return hr;
3325}

◆ BasicVideo_get_VideoHeight()

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

Definition at line 3227 of file filtergraph.c.

3228{
3229 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3230 IBasicVideo *pBasicVideo;
3231 HRESULT hr;
3232
3233 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoHeight);
3234
3235 EnterCriticalSection(&This->cs);
3236
3237 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3238
3239 if (hr == S_OK)
3240 hr = IBasicVideo_get_VideoHeight(pBasicVideo, pVideoHeight);
3241
3242 LeaveCriticalSection(&This->cs);
3243
3244 return hr;
3245}

◆ BasicVideo_get_VideoWidth()

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

Definition at line 3207 of file filtergraph.c.

3208{
3209 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3210 IBasicVideo *pBasicVideo;
3211 HRESULT hr;
3212
3213 TRACE("(%p/%p)->(%p)\n", This, iface, pVideoWidth);
3214
3215 EnterCriticalSection(&This->cs);
3216
3217 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3218
3219 if (hr == S_OK)
3220 hr = IBasicVideo_get_VideoWidth(pBasicVideo, pVideoWidth);
3221
3222 LeaveCriticalSection(&This->cs);
3223
3224 return hr;
3225}

◆ BasicVideo_GetCurrentImage()

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

Definition at line 3734 of file filtergraph.c.

3736{
3737 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3738 IBasicVideo *pBasicVideo;
3739 HRESULT hr;
3740
3741 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pBufferSize, pDIBImage);
3742
3743 EnterCriticalSection(&This->cs);
3744
3745 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3746
3747 if (hr == S_OK)
3748 hr = IBasicVideo_GetCurrentImage(pBasicVideo, pBufferSize, pDIBImage);
3749
3750 LeaveCriticalSection(&This->cs);
3751
3752 return hr;
3753}
pBufferSize
_Must_inspect_result_ _In_ ULONG _Out_writes_bytes_ pBufferSize PVOID _Inout_ PULONG pBufferSize
Definition: fsrtlfuncs.h:1165

◆ BasicVideo_GetDestinationPosition()

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

Definition at line 3651 of file filtergraph.c.

3653{
3654 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3655 IBasicVideo *pBasicVideo;
3656 HRESULT hr;
3657
3658 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3659
3660 EnterCriticalSection(&This->cs);
3661
3662 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3663
3664 if (hr == S_OK)
3665 hr = IBasicVideo_GetDestinationPosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3666
3667 LeaveCriticalSection(&This->cs);
3668
3669 return hr;
3670}

◆ BasicVideo_GetIDsOfNames()

static HRESULT WINAPI BasicVideo_GetIDsOfNames ( IBasicVideo2 *  iface,
REFIID  iid,
LPOLESTR *  names,
UINT  count,
LCID  lcid,
DISPID *  ids 
)
static

Definition at line 3112 of file filtergraph.c.

3114{
3115 ITypeInfo *typeinfo;
3116 HRESULT hr;
3117
3118 TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
3119 iface, debugstr_guid(iid), names, count, lcid, ids);
3120
3121 if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicVideo_tid, &typeinfo)))
3122 {
3123 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
3124 ITypeInfo_Release(typeinfo);
3125 }
3126 return hr;
3127}
IBasicVideo_tid
@ IBasicVideo_tid
Definition: strmbase.h:226

◆ BasicVideo_GetSourcePosition()

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

Definition at line 3589 of file filtergraph.c.

3591{
3592 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3593 IBasicVideo *pBasicVideo;
3594 HRESULT hr;
3595
3596 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
3597
3598 EnterCriticalSection(&This->cs);
3599
3600 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3601
3602 if (hr == S_OK)
3603 hr = IBasicVideo_GetSourcePosition(pBasicVideo, pLeft, pTop, pWidth, pHeight);
3604
3605 LeaveCriticalSection(&This->cs);
3606
3607 return hr;
3608}

◆ BasicVideo_GetTypeInfo()

static HRESULT WINAPI BasicVideo_GetTypeInfo ( IBasicVideo2 *  iface,
UINT  index,
LCID  lcid,
ITypeInfo **  typeinfo 
)
static

Definition at line 3105 of file filtergraph.c.

3107{
3108 TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
3109 return strmbase_get_typeinfo(IBasicVideo_tid, typeinfo);
3110}

◆ BasicVideo_GetTypeInfoCount()

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

Definition at line 3098 of file filtergraph.c.

3099{
3100 TRACE("iface %p, count %p.\n", iface, count);
3101 *count = 1;
3102 return S_OK;
3103}

◆ BasicVideo_GetVideoPaletteEntries()

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

Definition at line 3712 of file filtergraph.c.

3714{
3715 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3716 IBasicVideo *pBasicVideo;
3717 HRESULT hr;
3718
3719 TRACE("graph %p, start_index %ld, count %ld, ret_count %p, entries %p.\n",
3720 This, StartIndex, Entries, pRetrieved, pPalette);
3721
3722 EnterCriticalSection(&This->cs);
3723
3724 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3725
3726 if (hr == S_OK)
3727 hr = IBasicVideo_GetVideoPaletteEntries(pBasicVideo, StartIndex, Entries, pRetrieved, pPalette);
3728
3729 LeaveCriticalSection(&This->cs);
3730
3731 return hr;
3732}
Entries
static const ENTRY Entries[]
Definition: MultiByteToWideChar.c:42

◆ BasicVideo_GetVideoSize()

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

Definition at line 3692 of file filtergraph.c.

3693{
3694 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3695 IBasicVideo *pBasicVideo;
3696 HRESULT hr;
3697
3698 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
3699
3700 EnterCriticalSection(&This->cs);
3701
3702 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3703
3704 if (hr == S_OK)
3705 hr = IBasicVideo_GetVideoSize(pBasicVideo, pWidth, pHeight);
3706
3707 LeaveCriticalSection(&This->cs);
3708
3709 return hr;
3710}

◆ BasicVideo_Invoke()

static HRESULT WINAPI BasicVideo_Invoke ( IBasicVideo2 *  iface,
DISPID  id,
REFIID  iid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepinfo,
UINT *  error_arg 
)
static

Definition at line 3129 of file filtergraph.c.

3131{
3132 ITypeInfo *typeinfo;
3133 HRESULT hr;
3134
3135 TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
3136 iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
3137
3138 if (SUCCEEDED(hr = strmbase_get_typeinfo(IBasicVideo_tid, &typeinfo)))
3139 {
3140 hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
3141 ITypeInfo_Release(typeinfo);
3142 }
3143 return hr;
3144}

◆ BasicVideo_IsUsingDefaultDestination()

static HRESULT WINAPI BasicVideo_IsUsingDefaultDestination ( IBasicVideo2 *  iface)
static

Definition at line 3775 of file filtergraph.c.

3776{
3777 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3778 IBasicVideo *pBasicVideo;
3779 HRESULT hr;
3780
3781 TRACE("(%p/%p)->()\n", This, iface);
3782
3783 EnterCriticalSection(&This->cs);
3784
3785 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3786
3787 if (hr == S_OK)
3788 hr = IBasicVideo_IsUsingDefaultDestination(pBasicVideo);
3789
3790 LeaveCriticalSection(&This->cs);
3791
3792 return hr;
3793}

◆ BasicVideo_IsUsingDefaultSource()

static HRESULT WINAPI BasicVideo_IsUsingDefaultSource ( IBasicVideo2 *  iface)
static

Definition at line 3755 of file filtergraph.c.

3756{
3757 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3758 IBasicVideo *pBasicVideo;
3759 HRESULT hr;
3760
3761 TRACE("(%p/%p)->()\n", This, iface);
3762
3763 EnterCriticalSection(&This->cs);
3764
3765 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3766
3767 if (hr == S_OK)
3768 hr = IBasicVideo_IsUsingDefaultSource(pBasicVideo);
3769
3770 LeaveCriticalSection(&This->cs);
3771
3772 return hr;
3773}

◆ BasicVideo_put_DestinationHeight()

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

Definition at line 3527 of file filtergraph.c.

3528{
3529 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3530 IBasicVideo *pBasicVideo;
3531 HRESULT hr;
3532
3533 TRACE("graph %p, height %ld.\n", This, DestinationHeight);
3534
3535 EnterCriticalSection(&This->cs);
3536
3537 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3538
3539 if (hr == S_OK)
3540 hr = IBasicVideo_put_DestinationHeight(pBasicVideo, DestinationHeight);
3541
3542 LeaveCriticalSection(&This->cs);
3543
3544 return hr;
3545}

◆ BasicVideo_put_DestinationLeft()

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

Definition at line 3407 of file filtergraph.c.

3408{
3409 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3410 IBasicVideo *pBasicVideo;
3411 HRESULT hr;
3412
3413 TRACE("graph %p, left %ld.\n", This, DestinationLeft);
3414
3415 EnterCriticalSection(&This->cs);
3416
3417 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3418
3419 if (hr == S_OK)
3420 hr = IBasicVideo_put_DestinationLeft(pBasicVideo, DestinationLeft);
3421
3422 LeaveCriticalSection(&This->cs);
3423
3424 return hr;
3425}

◆ BasicVideo_put_DestinationTop()

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

Definition at line 3487 of file filtergraph.c.

3488{
3489 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3490 IBasicVideo *pBasicVideo;
3491 HRESULT hr;
3492
3493 TRACE("graph %p, top %ld.\n", This, DestinationTop);
3494
3495 EnterCriticalSection(&This->cs);
3496
3497 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3498
3499 if (hr == S_OK)
3500 hr = IBasicVideo_put_DestinationTop(pBasicVideo, DestinationTop);
3501
3502 LeaveCriticalSection(&This->cs);
3503
3504 return hr;
3505}

◆ BasicVideo_put_DestinationWidth()

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

Definition at line 3447 of file filtergraph.c.

3448{
3449 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3450 IBasicVideo *pBasicVideo;
3451 HRESULT hr;
3452
3453 TRACE("graph %p, width %ld.\n", This, DestinationWidth);
3454
3455 EnterCriticalSection(&This->cs);
3456
3457 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3458
3459 if (hr == S_OK)
3460 hr = IBasicVideo_put_DestinationWidth(pBasicVideo, DestinationWidth);
3461
3462 LeaveCriticalSection(&This->cs);
3463
3464 return hr;
3465}

◆ BasicVideo_put_SourceHeight()

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

Definition at line 3367 of file filtergraph.c.

3368{
3369 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3370 IBasicVideo *pBasicVideo;
3371 HRESULT hr;
3372
3373 TRACE("graph %p, height %ld.\n", This, SourceHeight);
3374
3375 EnterCriticalSection(&This->cs);
3376
3377 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3378
3379 if (hr == S_OK)
3380 hr = IBasicVideo_put_SourceHeight(pBasicVideo, SourceHeight);
3381
3382 LeaveCriticalSection(&This->cs);
3383
3384 return hr;
3385}
SourceHeight
_In_ UINT _In_ UINT SourceHeight
Definition: dispmprt.h:1457

◆ BasicVideo_put_SourceLeft()

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

Definition at line 3247 of file filtergraph.c.

3248{
3249 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3250 IBasicVideo *pBasicVideo;
3251 HRESULT hr;
3252
3253 TRACE("graph %p, left %ld.\n", This, SourceLeft);
3254
3255 EnterCriticalSection(&This->cs);
3256
3257 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3258
3259 if (hr == S_OK)
3260 hr = IBasicVideo_put_SourceLeft(pBasicVideo, SourceLeft);
3261
3262 LeaveCriticalSection(&This->cs);
3263
3264 return hr;
3265}

◆ BasicVideo_put_SourceTop()

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

Definition at line 3327 of file filtergraph.c.

3328{
3329 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3330 IBasicVideo *pBasicVideo;
3331 HRESULT hr;
3332
3333 TRACE("graph %p, top %ld.\n", This, SourceTop);
3334
3335 EnterCriticalSection(&This->cs);
3336
3337 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3338
3339 if (hr == S_OK)
3340 hr = IBasicVideo_put_SourceTop(pBasicVideo, SourceTop);
3341
3342 LeaveCriticalSection(&This->cs);
3343
3344 return hr;
3345}

◆ BasicVideo_put_SourceWidth()

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

Definition at line 3287 of file filtergraph.c.

3288{
3289 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3290 IBasicVideo *pBasicVideo;
3291 HRESULT hr;
3292
3293 TRACE("graph %p, width %ld.\n", This, SourceWidth);
3294
3295 EnterCriticalSection(&This->cs);
3296
3297 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3298
3299 if (hr == S_OK)
3300 hr = IBasicVideo_put_SourceWidth(pBasicVideo, SourceWidth);
3301
3302 LeaveCriticalSection(&This->cs);
3303
3304 return hr;
3305}
SourceWidth
_In_ UINT SourceWidth
Definition: dispmprt.h:1456

◆ BasicVideo_QueryInterface()

static HRESULT WINAPI BasicVideo_QueryInterface ( IBasicVideo2 *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 3080 of file filtergraph.c.

3081{
3082 struct filter_graph *graph = impl_from_IBasicVideo2(iface);
3083 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
3084}

◆ BasicVideo_Release()

static ULONG WINAPI BasicVideo_Release ( IBasicVideo2 *  iface)
static

Definition at line 3092 of file filtergraph.c.

3093{
3094 struct filter_graph *graph = impl_from_IBasicVideo2(iface);
3095 return IUnknown_Release(graph->outer_unk);
3096}

◆ BasicVideo_SetDefaultDestinationPosition()

static HRESULT WINAPI BasicVideo_SetDefaultDestinationPosition ( IBasicVideo2 *  iface)
static

Definition at line 3672 of file filtergraph.c.

3673{
3674 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3675 IBasicVideo *pBasicVideo;
3676 HRESULT hr;
3677
3678 TRACE("(%p/%p)->()\n", This, iface);
3679
3680 EnterCriticalSection(&This->cs);
3681
3682 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3683
3684 if (hr == S_OK)
3685 hr = IBasicVideo_SetDefaultDestinationPosition(pBasicVideo);
3686
3687 LeaveCriticalSection(&This->cs);
3688
3689 return hr;
3690}

◆ BasicVideo_SetDefaultSourcePosition()

static HRESULT WINAPI BasicVideo_SetDefaultSourcePosition ( IBasicVideo2 *  iface)
static

Definition at line 3610 of file filtergraph.c.

3611{
3612 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3613 IBasicVideo *pBasicVideo;
3614 HRESULT hr;
3615
3616 TRACE("(%p/%p)->()\n", This, iface);
3617
3618 EnterCriticalSection(&This->cs);
3619
3620 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3621
3622 if (hr == S_OK)
3623 hr = IBasicVideo_SetDefaultSourcePosition(pBasicVideo);
3624
3625 LeaveCriticalSection(&This->cs);
3626
3627 return hr;
3628}

◆ BasicVideo_SetDestinationPosition()

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

Definition at line 3630 of file filtergraph.c.

3632{
3633 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3634 IBasicVideo *pBasicVideo;
3635 HRESULT hr;
3636
3637 TRACE("graph %p, left %ld, top %ld, width %ld, height %ld.\n", This, Left, Top, Width, Height);
3638
3639 EnterCriticalSection(&This->cs);
3640
3641 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3642
3643 if (hr == S_OK)
3644 hr = IBasicVideo_SetDestinationPosition(pBasicVideo, Left, Top, Width, Height);
3645
3646 LeaveCriticalSection(&This->cs);
3647
3648 return hr;
3649}
Top
static LPHIST_ENTRY Top
Definition: history.c:53
Height
_Check_return_ _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID _In_ PDXGKARG_SYSTEM_DISPLAY_ENABLE_FLAGS _Out_ UINT _Out_ UINT * Height
Definition: dispmprt.h:1445
Width
_Check_return_ _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID _In_ PDXGKARG_SYSTEM_DISPLAY_ENABLE_FLAGS _Out_ UINT * Width
Definition: dispmprt.h:1444

◆ BasicVideo_SetSourcePosition()

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

Definition at line 3568 of file filtergraph.c.

3570{
3571 struct filter_graph *This = impl_from_IBasicVideo2(iface);
3572 IBasicVideo *pBasicVideo;
3573 HRESULT hr;
3574
3575 TRACE("graph %p, left %ld, top %ld, width %ld, height %ld.\n", This, Left, Top, Width, Height);
3576
3577 EnterCriticalSection(&This->cs);
3578
3579 hr = GetTargetInterface(This, &IID_IBasicVideo, (LPVOID*)&pBasicVideo);
3580
3581 if (hr == S_OK)
3582 hr = IBasicVideo_SetSourcePosition(pBasicVideo, Left, Top, Width, Height);
3583
3584 LeaveCriticalSection(&This->cs);
3585
3586 return hr;
3587}

◆ check_cyclic_connection()

static HRESULT check_cyclic_connection ( IPin *  source,
IPin *  sink 
)
static

Definition at line 792 of file filtergraph.c.

793{
794 IPin *upstream_source, *upstream_sink;
795 PIN_INFO source_info, sink_info;
796 IEnumPins *enumpins;
797 HRESULT hr;
798
799 hr = IPin_QueryPinInfo(sink, &sink_info);
800 if (FAILED(hr))
801 {
802 ERR("Failed to query pin, hr %#lx.\n", hr);
803 return hr;
804 }
805 IBaseFilter_Release(sink_info.pFilter);
806
807 hr = IPin_QueryPinInfo(source, &source_info);
808 if (FAILED(hr))
809 {
810 ERR("Failed to query pin, hr %#lx.\n", hr);
811 return hr;
812 }
813
814 if (sink_info.pFilter == source_info.pFilter)
815 {
816 WARN("Cyclic connection detected; returning VFW_E_CIRCULAR_GRAPH.\n");
817 IBaseFilter_Release(source_info.pFilter);
818 return VFW_E_CIRCULAR_GRAPH;
819 }
820
821 hr = IBaseFilter_EnumPins(source_info.pFilter, &enumpins);
822 if (FAILED(hr))
823 {
824 ERR("Failed to enumerate pins, hr %#lx.\n", hr);
825 IBaseFilter_Release(source_info.pFilter);
826 return hr;
827 }
828
829 while ((hr = IEnumPins_Next(enumpins, 1, &upstream_sink, NULL)) == S_OK)
830 {
831 PIN_DIRECTION dir = PINDIR_OUTPUT;
832
833 IPin_QueryDirection(upstream_sink, &dir);
834 if (dir == PINDIR_INPUT && IPin_ConnectedTo(upstream_sink, &upstream_source) == S_OK)
835 {
836 hr = check_cyclic_connection(upstream_source, sink);
837 IPin_Release(upstream_source);
838 if (FAILED(hr))
839 {
840 IPin_Release(upstream_sink);
841 IEnumPins_Release(enumpins);
842 IBaseFilter_Release(source_info.pFilter);
843 return hr;
844 }
845 }
846 IPin_Release(upstream_sink);
847 }
848 IEnumPins_Release(enumpins);
849
850 IBaseFilter_Release(source_info.pFilter);
851 return S_OK;
852}
check_cyclic_connection
static HRESULT check_cyclic_connection(IPin *source, IPin *sink)
Definition: filtergraph.c:792
VFW_E_CIRCULAR_GRAPH
#define VFW_E_CIRCULAR_GRAPH
Definition: vfwmsgs.h:88

Referenced by check_cyclic_connection(), and FilterGraph2_ConnectDirect().

◆ ConvertFromREFTIME()

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

Definition at line 2650 of file filtergraph.c.

2651{
2652 GUID time_format;
2653 HRESULT hr;
2654
2655 hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2656 if (FAILED(hr))
2657 return hr;
2658 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2659 {
2660 FIXME("Unsupported time format.\n");
2661 return E_NOTIMPL;
2662 }
2663
2664 *time_out = (LONGLONG) (time_in * 10000000); /* convert from 1 second intervals to 100 ns intervals */
2665 return S_OK;
2666}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
MediaSeeking_GetTimeFormat
static HRESULT WINAPI MediaSeeking_GetTimeFormat(IMediaSeeking *iface, GUID *pFormat)
Definition: filtergraph.c:2241
IsEqualGUID
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
seek
int seek(void *fd, ulong off, int mode)
Definition: pe.c:51
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68

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 2668 of file filtergraph.c.

2669{
2670 GUID time_format;
2671 HRESULT hr;
2672
2673 hr = MediaSeeking_GetTimeFormat(seek, &time_format);
2674 if (FAILED(hr))
2675 return hr;
2676 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, &time_format))
2677 {
2678 FIXME("Unsupported time format.\n");
2679 return E_NOTIMPL;
2680 }
2681
2682 *time_out = (REFTIME)time_in / 10000000; /* convert from 100 ns intervals to 1 second intervals */
2683 return S_OK;
2684}
REFTIME
DOUBLE REFTIME
Definition: axcore.idl:57

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

◆ create_enum_filters()

static HRESULT create_enum_filters ( struct filter_graph *  graph,
struct list *  cursor,
IEnumFilters **  out 
)
static

Definition at line 300 of file filtergraph.c.

301{
302 struct enum_filters *enum_filters;
303
304 if (!(enum_filters = heap_alloc(sizeof(*enum_filters))))
305 return E_OUTOFMEMORY;
306
307 enum_filters->IEnumFilters_iface.lpVtbl = &EnumFilters_vtbl;
308 enum_filters->ref = 1;
309 enum_filters->cursor = cursor;
310 enum_filters->graph = graph;
311 IUnknown_AddRef(graph->outer_unk);
312 enum_filters->version = graph->version;
313
314 *out = &enum_filters->IEnumFilters_iface;
315 return S_OK;
316}
heap_alloc
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
EnumFilters_vtbl
static const IEnumFiltersVtbl EnumFilters_vtbl
Definition: filtergraph.c:289
cursor
const char cursor[]
Definition: icontest.c:13
enum_filters
Definition: filtergraph.c:159
enum_filters::version
LONG version
Definition: filtergraph.c:163
enum_filters::graph
struct filter_graph * graph
Definition: filtergraph.c:162
enum_filters::ref
LONG ref
Definition: filtergraph.c:161
enum_filters::cursor
struct list * cursor
Definition: filtergraph.c:164
enum_filters::IEnumFilters_iface
IEnumFilters IEnumFilters_iface
Definition: filtergraph.c:160

Referenced by EnumFilters_Clone(), and FilterGraph2_EnumFilters().

◆ create_filter()

static HRESULT create_filter ( struct filter_graph *  graph,
IMoniker *  moniker,
IBaseFilter **  filter 
)
static

Definition at line 1071 of file filtergraph.c.

1072{
1073 if (graph->threaded)
1074 {
1075 struct filter_create_params params;
1076
1077 params.moniker = moniker;
1078
1079 EnterCriticalSection(&message_cs);
1080 PostThreadMessageW(message_thread_id, WM_USER, (WPARAM)&params, 0);
1081 WaitForSingleObject(message_thread_ret, INFINITE);
1082 LeaveCriticalSection(&message_cs);
1083
1084 *filter = params.filter;
1085 return params.hr;
1086 }
1087 else
1088 return IMoniker_BindToObject(moniker, NULL, NULL, &IID_IBaseFilter, (void **)filter);
1089}
IID_IBaseFilter
const GUID IID_IBaseFilter
Definition: devicecontrol.cpp:20
message_thread_ret
static HANDLE message_thread_ret
Definition: filtergraph.c:54
message_thread_id
static DWORD message_thread_id
Definition: filtergraph.c:55
INFINITE
#define INFINITE
Definition: serial.h:102
WPARAM
UINT_PTR WPARAM
Definition: minwindef.h:174
PostThreadMessageW
BOOL WINAPI PostThreadMessageW(_In_ DWORD, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
WM_USER
#define WM_USER
Definition: winuser.h:1923
filter_create_params
Definition: filtergraph.c:48
filter_create_params::moniker
IMoniker * moniker
Definition: filtergraph.c:50
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82

Referenced by autoplug().

◆ DECLARE_CRITICAL_SECTION()

DECLARE_CRITICAL_SECTION ( message_cs  )

◆ EnumFilters_AddRef()

static ULONG WINAPI EnumFilters_AddRef ( IEnumFilters *  iface)
static

Definition at line 190 of file filtergraph.c.

191{
192 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
193 ULONG ref = InterlockedIncrement(&enum_filters->ref);
194
195 TRACE("%p increasing refcount to %lu.\n", enum_filters, ref);
196
197 return ref;
198}
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
impl_from_IEnumFilters
static struct enum_filters * impl_from_IEnumFilters(IEnumFilters *iface)
Definition: filtergraph.c:169
ref
Definition: send.c:48
ULONG
uint32_t ULONG
Definition: typedefs.h:59

◆ EnumFilters_Clone()

static HRESULT WINAPI EnumFilters_Clone ( IEnumFilters *  iface,
IEnumFilters **  out 
)
static

Definition at line 280 of file filtergraph.c.

281{
282 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
283
284 TRACE("enum_filters %p, out %p.\n", enum_filters, out);
285
286 return create_enum_filters(enum_filters->graph, enum_filters->cursor, out);
287}
create_enum_filters
static HRESULT create_enum_filters(struct filter_graph *graph, struct list *cursor, IEnumFilters **out)
Definition: filtergraph.c:300

◆ EnumFilters_Next()

static HRESULT WINAPI EnumFilters_Next ( IEnumFilters *  iface,
ULONG  count,
IBaseFilter **  filters,
ULONG *  fetched 
)
static

Definition at line 216 of file filtergraph.c.

218{
219 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
220 unsigned int i = 0;
221
222 TRACE("enum_filters %p, count %lu, filters %p, fetched %p.\n",
223 enum_filters, count, filters, fetched);
224
225 if (enum_filters->version != enum_filters->graph->version)
226 return VFW_E_ENUM_OUT_OF_SYNC;
227
228 if (!filters)
229 return E_POINTER;
230
231 for (i = 0; i < count; ++i)
232 {
233 struct filter *filter = LIST_ENTRY(enum_filters->cursor, struct filter, entry);
234
235 if (!enum_filters->cursor)
236 break;
237
238 IBaseFilter_AddRef(filters[i] = filter->filter);
239 enum_filters->cursor = list_next(&enum_filters->graph->filters, enum_filters->cursor);
240 }
241
242 if (fetched)
243 *fetched = i;
244
245 return (i == count) ? S_OK : S_FALSE;
246}
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
list_next
__WINE_SERVER_LIST_INLINE struct list * list_next(const struct list *list, const struct list *elem)
Definition: list.h:117
LIST_ENTRY
#define LIST_ENTRY(type)
Definition: queue.h:175
VFW_E_ENUM_OUT_OF_SYNC
#define VFW_E_ENUM_OUT_OF_SYNC
Definition: vfwmsgs.h:42
S_FALSE
#define S_FALSE
Definition: winerror.h:3451
E_POINTER
#define E_POINTER
Definition: winerror.h:3480

◆ EnumFilters_QueryInterface()

static HRESULT WINAPI EnumFilters_QueryInterface ( IEnumFilters *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 174 of file filtergraph.c.

175{
176 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
177 TRACE("enum_filters %p, iid %s, out %p.\n", enum_filters, qzdebugstr_guid(iid), out);
178
179 if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumFilters))
180 {
181 IEnumFilters_AddRef(*out = iface);
182 return S_OK;
183 }
184
185 WARN("%s not implemented, returning E_NOINTERFACE.\n", qzdebugstr_guid(iid));
186 *out = NULL;
187 return E_NOINTERFACE;
188}
IID_IUnknown
const GUID IID_IUnknown
Definition: classfactory.cpp:11
qzdebugstr_guid
const char * qzdebugstr_guid(const GUID *id)
Definition: main.c:671
E_NOINTERFACE
#define E_NOINTERFACE
Definition: winerror.h:3479

◆ EnumFilters_Release()

static ULONG WINAPI EnumFilters_Release ( IEnumFilters *  iface)
static

Definition at line 200 of file filtergraph.c.

201{
202 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
203 ULONG ref = InterlockedDecrement(&enum_filters->ref);
204
205 TRACE("%p decreasing refcount to %lu.\n", enum_filters, ref);
206
207 if (!ref)
208 {
209 IUnknown_Release(enum_filters->graph->outer_unk);
210 heap_free(enum_filters);
211 }
212
213 return ref;
214}
heap_free
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52

◆ EnumFilters_Reset()

static HRESULT WINAPI EnumFilters_Reset ( IEnumFilters *  iface)
static

Definition at line 269 of file filtergraph.c.

270{
271 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
272
273 TRACE("enum_filters %p.\n", enum_filters);
274
275 enum_filters->cursor = list_head(&enum_filters->graph->filters);
276 enum_filters->version = enum_filters->graph->version;
277 return S_OK;
278}
list_head
Definition: list.h:15

◆ EnumFilters_Skip()

static HRESULT WINAPI EnumFilters_Skip ( IEnumFilters *  iface,
ULONG  count 
)
static

Definition at line 248 of file filtergraph.c.

249{
250 struct enum_filters *enum_filters = impl_from_IEnumFilters(iface);
251
252 TRACE("enum_filters %p, count %lu.\n", enum_filters, count);
253
254 if (enum_filters->version != enum_filters->graph->version)
255 return VFW_E_ENUM_OUT_OF_SYNC;
256
257 if (!enum_filters->cursor)
258 return E_INVALIDARG;
259
260 while (count--)
261 {
262 if (!(enum_filters->cursor = list_next(&enum_filters->graph->filters, enum_filters->cursor)))
263 return count ? S_FALSE : S_OK;
264 }
265
266 return S_OK;
267}
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101

◆ filter_graph_common_create()

static HRESULT filter_graph_common_create ( IUnknown *  outer,
IUnknown **  out,
BOOL  threaded 
)
static

Definition at line 5682 of file filtergraph.c.

5683{
5684 struct filter_graph *object;
5685 HRESULT hr;
5686
5687 *out = NULL;
5688
5689 if (!(object = calloc(1, sizeof(*object))))
5690 return E_OUTOFMEMORY;
5691
5692 object->IBasicAudio_iface.lpVtbl = &IBasicAudio_VTable;
5693 object->IBasicVideo2_iface.lpVtbl = &IBasicVideo_VTable;
5694 object->IFilterGraph2_iface.lpVtbl = &IFilterGraph2_VTable;
5695 object->IGraphConfig_iface.lpVtbl = &IGraphConfig_VTable;
5696 object->IGraphVersion_iface.lpVtbl = &IGraphVersion_VTable;
5697 object->IMediaControl_iface.lpVtbl = &IMediaControl_VTable;
5698 object->IMediaEventEx_iface.lpVtbl = &IMediaEventEx_VTable;
5699 object->IMediaEventSink_iface.lpVtbl = &IMediaEventSink_VTable;
5700 object->IMediaFilter_iface.lpVtbl = &IMediaFilter_VTable;
5701 object->IMediaPosition_iface.lpVtbl = &IMediaPosition_VTable;
5702 object->IMediaSeeking_iface.lpVtbl = &IMediaSeeking_VTable;
5703 object->IObjectWithSite_iface.lpVtbl = &IObjectWithSite_VTable;
5704 object->IUnknown_inner.lpVtbl = &IInner_VTable;
5705 object->IVideoFrameStep_iface.lpVtbl = &VideoFrameStep_vtbl;
5706 object->IVideoWindow_iface.lpVtbl = &IVideoWindow_VTable;
5707 object->ref = 1;
5708 object->outer_unk = outer ? outer : &object->IUnknown_inner;
5709
5710 if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, object->outer_unk,
5711 CLSCTX_INPROC_SERVER, &IID_IUnknown, (void **)&object->punkFilterMapper2)))
5712 {
5713 ERR("Failed to create filter mapper, hr %#lx.\n", hr);
5714 free(object);
5715 return hr;
5716 }
5717
5718 InitializeCriticalSectionEx(&object->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
5719 object->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": filter_graph.cs");
5720 InitializeCriticalSectionEx(&object->event_cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
5721 object->event_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": filter_graph.event_cs");
5722
5723 object->defaultclock = TRUE;
5724
5725 object->media_event_handle = CreateEventW(NULL, TRUE, FALSE, NULL);
5726 list_init(&object->media_events);
5727 list_init(&object->filters);
5728 object->HandleEcClockChanged = TRUE;
5729 object->HandleEcComplete = TRUE;
5730 object->HandleEcRepaint = TRUE;
5731 object->hEventCompletion = CreateEventW(0, TRUE, FALSE, 0);
5732
5733 object->name_index = 1;
5734 object->timeformatseek = TIME_FORMAT_MEDIA_TIME;
5735
5736 object->threaded = !!threaded;
5737
5738 EnterCriticalSection(&message_cs);
5739 if (threaded && !message_thread_refcount++)
5740 {
5741 message_thread_ret = CreateEventW(NULL, FALSE, FALSE, NULL);
5742 message_thread = CreateThread(NULL, 0, message_thread_run, object, 0, &message_thread_id);
5743 WaitForSingleObject(message_thread_ret, INFINITE);
5744 }
5745 LeaveCriticalSection(&message_cs);
5746
5747 TRACE("Created %sthreaded filter graph %p.\n", threaded ? "" : "non-", object);
5748 *out = &object->IUnknown_inner;
5749 return S_OK;
5750}
list_init
static void list_init(struct list_entry *head)
Definition: list.h:51
IMediaEventEx_VTable
static const IMediaEventExVtbl IMediaEventEx_VTable
Definition: filtergraph.c:5010
IBasicAudio_VTable
static const IBasicAudioVtbl IBasicAudio_VTable
Definition: filtergraph.c:3060
IFilterGraph2_VTable
static const IFilterGraph2Vtbl IFilterGraph2_VTable
Definition: filtergraph.c:1663
IMediaSeeking_VTable
static const IMediaSeekingVtbl IMediaSeeking_VTable
Definition: filtergraph.c:2554
IMediaControl_VTable
static const IMediaControlVtbl IMediaControl_VTable
Definition: filtergraph.c:2082
IMediaEventSink_VTable
static const IMediaEventSinkVtbl IMediaEventSink_VTable
Definition: filtergraph.c:5419
IVideoWindow_VTable
static const IVideoWindowVtbl IVideoWindow_VTable
Definition: filtergraph.c:4727
message_thread
static HANDLE message_thread
Definition: filtergraph.c:54
VideoFrameStep_vtbl
static const IVideoFrameStepVtbl VideoFrameStep_vtbl
Definition: filtergraph.c:5665
message_thread_refcount
static unsigned int message_thread_refcount
Definition: filtergraph.c:56
IBasicVideo_VTable
static const IBasicVideo2Vtbl IBasicVideo_VTable
Definition: filtergraph.c:3816
IMediaPosition_VTable
static const IMediaPositionVtbl IMediaPosition_VTable
Definition: filtergraph.c:2782
IGraphVersion_VTable
static const IGraphVersionVtbl IGraphVersion_VTable
Definition: filtergraph.c:5616
IGraphConfig_VTable
static const IGraphConfigVtbl IGraphConfig_VTable
Definition: filtergraph.c:5560
IMediaFilter_VTable
static const IMediaFilterVtbl IMediaFilter_VTable
Definition: filtergraph.c:5344
IInner_VTable
static const IUnknownVtbl IInner_VTable
Definition: filtergraph.c:5675
message_thread_run
static DWORD WINAPI message_thread_run(void *ctx)
Definition: filtergraph.c:1032
IObjectWithSite_VTable
static const IObjectWithSiteVtbl IObjectWithSite_VTable
Definition: filtergraph.c:2854
CoCreateInstance
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, IUnknown *outer, DWORD cls_context, REFIID riid, void **obj)
Definition: combase.c:1685
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
InitializeCriticalSectionEx
BOOL WINAPI InitializeCriticalSectionEx(OUT LPCRITICAL_SECTION lpCriticalSection, IN DWORD dwSpinCount, IN DWORD flags)
Definition: sync.c:107
outer
static IUnknown * outer
Definition: compobj.c:82
calloc
#define calloc
Definition: rosglue.h:14
filter_graph::threaded
unsigned int threaded
Definition: filtergraph.c:155
CreateEventW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:587
DWORD_PTR
#define DWORD_PTR
Definition: treelist.c:76
RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO
#define RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO
Definition: winnt_old.h:1156

Referenced by filter_graph_create(), and filter_graph_no_thread_create().

◆ filter_graph_create()

HRESULT filter_graph_create ( IUnknown *  outer,
IUnknown **  out 
)

Definition at line 5752 of file filtergraph.c.

5753{
5754 return filter_graph_common_create(outer, out, TRUE);
5755}
filter_graph_common_create
static HRESULT filter_graph_common_create(IUnknown *outer, IUnknown **out, BOOL threaded)
Definition: filtergraph.c:5682

◆ filter_graph_no_thread_create()

HRESULT filter_graph_no_thread_create ( IUnknown *  outer,
IUnknown **  out 
)

Definition at line 5757 of file filtergraph.c.

5758{
5759 return filter_graph_common_create(outer, out, FALSE);
5760}

◆ FilterGraph2_Abort()

static HRESULT WINAPI FilterGraph2_Abort ( IFilterGraph2 *  iface)
static

Definition at line 1569 of file filtergraph.c.

1570{
1571 struct filter_graph *This = impl_from_IFilterGraph2(iface);
1572
1573 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1574
1575 return S_OK;
1576}
impl_from_IFilterGraph2
static struct filter_graph * impl_from_IFilterGraph2(IFilterGraph2 *iface)
Definition: filtergraph.c:498

◆ FilterGraph2_AddFilter()

static HRESULT WINAPI FilterGraph2_AddFilter ( IFilterGraph2 *  iface,
IBaseFilter *  filter,
const WCHAR *  name 
)
static

Definition at line 608 of file filtergraph.c.

610{
611 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
612 BOOL duplicate_name = FALSE;
613 struct filter *entry;
614 unsigned int i;
615 HRESULT hr;
616
617 TRACE("graph %p, filter %p, name %s.\n", graph, filter, debugstr_w(name));
618
619 if (!filter)
620 return E_POINTER;
621
622 if (!(entry = heap_alloc(sizeof(*entry))))
623 return E_OUTOFMEMORY;
624
625 if (!(entry->name = CoTaskMemAlloc((name ? wcslen(name) + 6 : 5) * sizeof(WCHAR))))
626 {
627 heap_free(entry);
628 return E_OUTOFMEMORY;
629 }
630
631 if (name && find_filter_by_name(graph, name))
632 duplicate_name = TRUE;
633
634 if (!name || duplicate_name)
635 {
636 for (i = 0; i < 10000 ; ++i)
637 {
638 if (name)
639 swprintf(entry->name, name ? wcslen(name) + 6 : 5, L"%s %04u", name, graph->name_index);
640 else
641 swprintf(entry->name, name ? wcslen(name) + 6 : 5, L"%04u", graph->name_index);
642
643 graph->name_index = (graph->name_index + 1) % 10000;
644
645 if (!find_filter_by_name(graph, entry->name))
646 break;
647 }
648
649 if (i == 10000)
650 {
651 CoTaskMemFree(entry->name);
652 heap_free(entry);
653 return VFW_E_DUPLICATE_NAME;
654 }
655 }
656 else
657 wcscpy(entry->name, name);
658
659 if (FAILED(hr = IBaseFilter_JoinFilterGraph(filter,
660 (IFilterGraph *)&graph->IFilterGraph2_iface, entry->name)))
661 {
662 CoTaskMemFree(entry->name);
663 heap_free(entry);
664 return hr;
665 }
666
667 IBaseFilter_SetSyncSource(filter, graph->refClock);
668
669 IBaseFilter_AddRef(entry->filter = filter);
670
671 list_add_head(&graph->filters, &entry->entry);
672 entry->sorting = FALSE;
673 entry->seeking = NULL;
674 ++graph->version;
675
676 return duplicate_name ? VFW_S_DUPLICATE_NAME : hr;
677}
list_add_head
static void list_add_head(struct list_entry *head, struct list_entry *entry)
Definition: list.h:76
find_filter_by_name
static IBaseFilter * find_filter_by_name(struct filter_graph *graph, const WCHAR *name)
Definition: filtergraph.c:521
CoTaskMemAlloc
void *WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: malloc.c:381
CoTaskMemFree
void WINAPI CoTaskMemFree(void *ptr)
Definition: malloc.c:389
wcslen
_ACRTIMP size_t __cdecl wcslen(const wchar_t *)
Definition: wcs.c:2988
swprintf
#define swprintf
Definition: precomp.h:40
WCHAR
short WCHAR
Definition: pedump.c:58
wcscpy
wcscpy
Definition: corecrt_wstring.h:120
name
Definition: name.c:39
VFW_E_DUPLICATE_NAME
#define VFW_E_DUPLICATE_NAME
Definition: vfwmsgs.h:84
VFW_S_DUPLICATE_NAME
#define VFW_S_DUPLICATE_NAME
Definition: vfwmsgs.h:20

◆ FilterGraph2_AddRef()

static ULONG WINAPI FilterGraph2_AddRef ( IFilterGraph2 *  iface)
static

Definition at line 509 of file filtergraph.c.

510{
511 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
512 return IUnknown_AddRef(graph->outer_unk);
513}

◆ FilterGraph2_AddSourceFilter()

static HRESULT WINAPI FilterGraph2_AddSourceFilter ( IFilterGraph2 *  iface,
const WCHAR *  filename,
const WCHAR *  filter_name,
IBaseFilter **  ret_filter 
)
static

Definition at line 1507 of file filtergraph.c.

1509{
1510 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1511 IFileSourceFilter *filesource;
1512 IBaseFilter *filter;
1513 HRESULT hr;
1514 GUID clsid;
1515
1516 TRACE("graph %p, filename %s, filter_name %s, ret_filter %p.\n",
1517 graph, debugstr_w(filename), debugstr_w(filter_name), ret_filter);
1518
1519 if (!*filename)
1520 return VFW_E_NOT_FOUND;
1521
1522 if (!get_media_type(filename, NULL, NULL, &clsid))
1523 clsid = CLSID_AsyncReader;
1524 TRACE("Using source filter %s.\n", debugstr_guid(&clsid));
1525
1526 if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER,
1527 &IID_IBaseFilter, (void **)&filter)))
1528 {
1529 WARN("Failed to create filter, hr %#lx.\n", hr);
1530 return hr;
1531 }
1532
1533 if (FAILED(hr = IBaseFilter_QueryInterface(filter, &IID_IFileSourceFilter, (void **)&filesource)))
1534 {
1535 WARN("Failed to get IFileSourceFilter, hr %#lx.\n", hr);
1536 IBaseFilter_Release(filter);
1537 return hr;
1538 }
1539
1540 hr = IFileSourceFilter_Load(filesource, filename, NULL);
1541 IFileSourceFilter_Release(filesource);
1542 if (FAILED(hr))
1543 {
1544 WARN("Failed to load file, hr %#lx.\n", hr);
1545 IBaseFilter_Release(filter);
1546 return hr;
1547 }
1548
1549 if (FAILED(hr = IFilterGraph2_AddFilter(iface, filter, filter_name)))
1550 {
1551 IBaseFilter_Release(filter);
1552 return hr;
1553 }
1554
1555 if (ret_filter)
1556 *ret_filter = filter;
1557 return S_OK;
1558}
get_media_type
BOOL get_media_type(const WCHAR *filename, GUID *majortype, GUID *subtype, GUID *source_clsid)
Definition: filesource.c:198
filename
const char * filename
Definition: ioapi.h:137
clsid
const CLSID * clsid
Definition: msctf.cpp:50
VFW_E_NOT_FOUND
#define VFW_E_NOT_FOUND
Definition: vfwmsgs.h:61

◆ FilterGraph2_AddSourceFilterForMoniker()

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

Definition at line 1588 of file filtergraph.c.

1590{
1591 struct filter_graph *This = impl_from_IFilterGraph2(iface);
1592 HRESULT hr;
1593 IBaseFilter* pfilter;
1594
1595 TRACE("(%p/%p)->(%p %p %s %p)\n", This, iface, pMoniker, pCtx, debugstr_w(lpcwstrFilterName), ppFilter);
1596
1597 hr = IMoniker_BindToObject(pMoniker, pCtx, NULL, &IID_IBaseFilter, (void**)&pfilter);
1598 if(FAILED(hr)) {
1599 WARN("Failed to bind moniker, hr %#lx.\n", hr);
1600 return hr;
1601 }
1602
1603 hr = IFilterGraph2_AddFilter(iface, pfilter, lpcwstrFilterName);
1604 if (FAILED(hr)) {
1605 WARN("Failed to add filter, hr %#lx.\n", hr);
1606 IBaseFilter_Release(pfilter);
1607 return hr;
1608 }
1609
1610 if(ppFilter)
1611 *ppFilter = pfilter;
1612 else IBaseFilter_Release(pfilter);
1613
1614 return S_OK;
1615}

◆ FilterGraph2_Connect()

static HRESULT WINAPI FilterGraph2_Connect ( IFilterGraph2 *  iface,
IPin *  source,
IPin *  sink 
)
static

Definition at line 1388 of file filtergraph.c.

1389{
1390 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1391 PIN_DIRECTION dir;
1392 HRESULT hr;
1393
1394 TRACE("graph %p, source %p, sink %p.\n", graph, source, sink);
1395
1396 if (!source || !sink)
1397 return E_POINTER;
1398
1399 if (FAILED(hr = IPin_QueryDirection(source, &dir)))
1400 return hr;
1401
1402 if (dir == PINDIR_INPUT)
1403 {
1404 IPin *temp;
1405
1406 TRACE("Directions seem backwards, swapping pins\n");
1407
1408 temp = sink;
1409 sink = source;
1410 source = temp;
1411 }
1412
1413 EnterCriticalSection(&graph->cs);
1414
1415 hr = autoplug(graph, source, sink, TRUE, 0);
1416
1417 LeaveCriticalSection(&graph->cs);
1418
1419 TRACE("Returning %#lx.\n", hr);
1420 return hr;
1421}
temp
static calc_node_t temp
Definition: rpn_ieee.c:38

◆ FilterGraph2_ConnectDirect()

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

Definition at line 921 of file filtergraph.c.

923{
924 struct filter_graph *This = impl_from_IFilterGraph2(iface);
925 PIN_DIRECTION dir;
926 HRESULT hr;
927
928 TRACE("(%p/%p)->(%p, %p, %p)\n", This, iface, ppinIn, ppinOut, pmt);
929 strmbase_dump_media_type(pmt);
930
931 /* FIXME: check pins are in graph */
932
933 if (TRACE_ON(quartz))
934 {
935 PIN_INFO PinInfo;
936
937 hr = IPin_QueryPinInfo(ppinIn, &PinInfo);
938 if (FAILED(hr))
939 return hr;
940
941 TRACE("Filter owning ppinIn(%p) => %p\n", ppinIn, PinInfo.pFilter);
942 IBaseFilter_Release(PinInfo.pFilter);
943
944 hr = IPin_QueryPinInfo(ppinOut, &PinInfo);
945 if (FAILED(hr))
946 return hr;
947
948 TRACE("Filter owning ppinOut(%p) => %p\n", ppinOut, PinInfo.pFilter);
949 IBaseFilter_Release(PinInfo.pFilter);
950 }
951
952 hr = IPin_QueryDirection(ppinIn, &dir);
953 if (SUCCEEDED(hr))
954 {
955 if (dir == PINDIR_INPUT)
956 {
957 hr = check_cyclic_connection(ppinOut, ppinIn);
958 if (SUCCEEDED(hr))
959 hr = IPin_Connect(ppinOut, ppinIn, pmt);
960 }
961 else
962 {
963 hr = check_cyclic_connection(ppinIn, ppinOut);
964 if (SUCCEEDED(hr))
965 hr = IPin_Connect(ppinIn, ppinOut, pmt);
966 }
967 }
968
969 return hr;
970}
TRACE_ON
#define TRACE_ON(x)
Definition: compat.h:75
strmbase_dump_media_type
void strmbase_dump_media_type(const AM_MEDIA_TYPE *mt)
Definition: mediatype.c:58

◆ FilterGraph2_Disconnect()

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

Definition at line 981 of file filtergraph.c.

982{
983 struct filter_graph *This = impl_from_IFilterGraph2(iface);
984
985 TRACE("(%p/%p)->(%p)\n", This, iface, ppin);
986
987 if (!ppin)
988 return E_POINTER;
989
990 return IPin_Disconnect(ppin);
991}

◆ FilterGraph2_EnumFilters()

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

Definition at line 764 of file filtergraph.c.

765{
766 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
767
768 TRACE("graph %p, out %p.\n", graph, out);
769
770 return create_enum_filters(graph, list_head(&graph->filters), out);
771}

◆ FilterGraph2_FindFilterByName()

static HRESULT WINAPI FilterGraph2_FindFilterByName ( IFilterGraph2 *  iface,
const WCHAR *  name,
IBaseFilter **  filter 
)
static

Definition at line 773 of file filtergraph.c.

775{
776 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
777
778 TRACE("graph %p, name %s, filter %p.\n", graph, debugstr_w(name), filter);
779
780 if (!filter)
781 return E_POINTER;
782
783 if ((*filter = find_filter_by_name(graph, name)))
784 {
785 IBaseFilter_AddRef(*filter);
786 return S_OK;
787 }
788
789 return VFW_E_NOT_FOUND;
790}

◆ FilterGraph2_QueryInterface()

static HRESULT WINAPI FilterGraph2_QueryInterface ( IFilterGraph2 *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 503 of file filtergraph.c.

504{
505 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
506 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
507}

◆ FilterGraph2_Reconnect()

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

Definition at line 972 of file filtergraph.c.

973{
974 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
975
976 TRACE("graph %p, pin %p.\n", graph, pin);
977
978 return IFilterGraph2_ReconnectEx(iface, pin, NULL);
979}

◆ FilterGraph2_ReconnectEx()

static HRESULT WINAPI FilterGraph2_ReconnectEx ( IFilterGraph2 *  iface,
IPin *  pin,
const AM_MEDIA_TYPE *  mt 
)
static

Definition at line 1617 of file filtergraph.c.

1618{
1619 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1620 PIN_DIRECTION dir;
1621 HRESULT hr;
1622 IPin *peer;
1623
1624 TRACE("graph %p, pin %p, mt %p.\n", graph, pin, mt);
1625
1626 if (FAILED(hr = IPin_ConnectedTo(pin, &peer)))
1627 return hr;
1628
1629 IPin_QueryDirection(pin, &dir);
1630 IFilterGraph2_Disconnect(iface, peer);
1631 IFilterGraph2_Disconnect(iface, pin);
1632
1633 if (dir == PINDIR_INPUT)
1634 hr = IFilterGraph2_ConnectDirect(iface, peer, pin, mt);
1635 else
1636 hr = IFilterGraph2_ConnectDirect(iface, pin, peer, mt);
1637
1638 IPin_Release(peer);
1639 return hr;
1640}

◆ FilterGraph2_Release()

static ULONG WINAPI FilterGraph2_Release ( IFilterGraph2 *  iface)
static

Definition at line 515 of file filtergraph.c.

516{
517 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
518 return IUnknown_Release(graph->outer_unk);
519}

◆ FilterGraph2_RemoveFilter()

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

Definition at line 679 of file filtergraph.c.

680{
681 struct filter_graph *This = impl_from_IFilterGraph2(iface);
682 struct filter *entry;
683 int i;
684 HRESULT hr = E_FAIL;
685
686 TRACE("(%p/%p)->(%p)\n", This, iface, pFilter);
687
688 LIST_FOR_EACH_ENTRY(entry, &This->filters, struct filter, entry)
689 {
690 if (entry->filter == pFilter)
691 {
692 IEnumPins *penumpins = NULL;
693
694 if (This->defaultclock && This->refClockProvider == pFilter)
695 {
696 IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, NULL);
697 This->defaultclock = TRUE;
698 }
699
700 TRACE("Removing filter %s.\n", debugstr_w(entry->name));
701
702 hr = IBaseFilter_EnumPins(pFilter, &penumpins);
703 if (SUCCEEDED(hr)) {
704 IPin *ppin;
705 while(IEnumPins_Next(penumpins, 1, &ppin, NULL) == S_OK)
706 {
707 IPin *peer = NULL;
708 HRESULT hr;
709
710 IPin_ConnectedTo(ppin, &peer);
711 if (peer)
712 {
713 if (FAILED(hr = IPin_Disconnect(peer)))
714 {
715 WARN("Failed to disconnect peer %p, hr %#lx.\n", peer, hr);
716 IPin_Release(peer);
717 IPin_Release(ppin);
718 IEnumPins_Release(penumpins);
719 return hr;
720 }
721 IPin_Release(peer);
722
723 if (FAILED(hr = IPin_Disconnect(ppin)))
724 {
725 WARN("Failed to disconnect pin %p, hr %#lx.\n", ppin, hr);
726 IPin_Release(ppin);
727 IEnumPins_Release(penumpins);
728 return hr;
729 }
730 }
731 IPin_Release(ppin);
732 }
733 IEnumPins_Release(penumpins);
734 }
735
736 hr = IBaseFilter_JoinFilterGraph(pFilter, NULL, NULL);
737 if (SUCCEEDED(hr))
738 {
739 IBaseFilter_SetSyncSource(pFilter, NULL);
740 IBaseFilter_Release(pFilter);
741 if (entry->seeking)
742 IMediaSeeking_Release(entry->seeking);
743 list_remove(&entry->entry);
744 CoTaskMemFree(entry->name);
745 heap_free(entry);
746 This->version++;
747 /* Invalidate interfaces in the cache */
748 for (i = 0; i < This->nItfCacheEntries; i++)
749 if (pFilter == This->ItfCacheEntries[i].filter)
750 {
751 IUnknown_Release(This->ItfCacheEntries[i].iface);
752 This->ItfCacheEntries[i].iface = NULL;
753 This->ItfCacheEntries[i].filter = NULL;
754 }
755 return S_OK;
756 }
757 break;
758 }
759 }
760
761 return hr; /* FIXME: check this error code */
762}
list_remove
static void list_remove(struct list_entry *entry)
Definition: list.h:90

◆ FilterGraph2_Render()

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

Definition at line 1423 of file filtergraph.c.

1424{
1425 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1426 HRESULT hr;
1427
1428 TRACE("graph %p, source %p.\n", graph, source);
1429
1430 EnterCriticalSection(&graph->cs);
1431 hr = autoplug(graph, source, NULL, FALSE, 0);
1432 LeaveCriticalSection(&graph->cs);
1433 if (hr == VFW_E_CANNOT_CONNECT)
1434 hr = VFW_E_CANNOT_RENDER;
1435
1436 TRACE("Returning %#lx.\n", hr);
1437 return hr;
1438}
VFW_E_CANNOT_RENDER
#define VFW_E_CANNOT_RENDER
Definition: vfwmsgs.h:63

◆ FilterGraph2_RenderEx()

static HRESULT WINAPI FilterGraph2_RenderEx ( IFilterGraph2 *  iface,
IPin *  source,
DWORD  flags,
DWORD *  context 
)
static

Definition at line 1642 of file filtergraph.c.

1643{
1644 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1645 HRESULT hr;
1646
1647 TRACE("graph %p, source %p, flags %#lx, context %p.\n", graph, source, flags, context);
1648
1649 if (flags & ~AM_RENDEREX_RENDERTOEXISTINGRENDERERS)
1650 FIXME("Unknown flags %#lx.\n", flags);
1651
1652 EnterCriticalSection(&graph->cs);
1653 hr = autoplug(graph, source, NULL, !!(flags & AM_RENDEREX_RENDERTOEXISTINGRENDERERS), 0);
1654 LeaveCriticalSection(&graph->cs);
1655 if (hr == VFW_E_CANNOT_CONNECT)
1656 hr = VFW_E_CANNOT_RENDER;
1657
1658 TRACE("Returning %#lx.\n", hr);
1659 return hr;
1660}
AM_RENDEREX_RENDERTOEXISTINGRENDERERS
@ AM_RENDEREX_RENDERTOEXISTINGRENDERERS
Definition: axextend.idl:860

◆ FilterGraph2_RenderFile()

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

Definition at line 1440 of file filtergraph.c.

1442{
1443 struct filter_graph *This = impl_from_IFilterGraph2(iface);
1444 IBaseFilter* preader = NULL;
1445 IPin* ppinreader = NULL;
1446 IEnumPins* penumpins = NULL;
1447 struct filter *filter;
1448 HRESULT hr;
1449 BOOL partial = FALSE;
1450 BOOL any = FALSE;
1451
1452 TRACE("(%p/%p)->(%s, %s)\n", This, iface, debugstr_w(lpcwstrFile), debugstr_w(lpcwstrPlayList));
1453
1454 if (lpcwstrPlayList != NULL)
1455 return E_INVALIDARG;
1456
1457 hr = IFilterGraph2_AddSourceFilter(iface, lpcwstrFile, L"Reader", &preader);
1458 if (FAILED(hr))
1459 return hr;
1460
1461 hr = IBaseFilter_EnumPins(preader, &penumpins);
1462 if (SUCCEEDED(hr))
1463 {
1464 while (IEnumPins_Next(penumpins, 1, &ppinreader, NULL) == S_OK)
1465 {
1466 PIN_DIRECTION dir;
1467
1468 IPin_QueryDirection(ppinreader, &dir);
1469 if (dir == PINDIR_OUTPUT)
1470 {
1471 hr = IFilterGraph2_Render(iface, ppinreader);
1472
1473 TRACE("Filters in chain:\n");
1474 LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
1475 TRACE("- %s.\n", debugstr_w(filter->name));
1476
1477 if (SUCCEEDED(hr))
1478 any = TRUE;
1479 if (hr != S_OK)
1480 partial = TRUE;
1481 }
1482 IPin_Release(ppinreader);
1483 }
1484 IEnumPins_Release(penumpins);
1485
1486 if (!any)
1487 {
1488 if (FAILED(hr = IFilterGraph2_RemoveFilter(iface, preader)))
1489 ERR("Failed to remove source filter, hr %#lx.\n", hr);
1490 hr = VFW_E_CANNOT_RENDER;
1491 }
1492 else if (partial)
1493 {
1494 hr = VFW_S_PARTIAL_RENDER;
1495 }
1496 else
1497 {
1498 hr = S_OK;
1499 }
1500 }
1501 IBaseFilter_Release(preader);
1502
1503 TRACE("Returning %#lx.\n", hr);
1504 return hr;
1505}
filter::name
WCHAR name[128]
Definition: filter.c:172

◆ FilterGraph2_SetDefaultSyncSource()

static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource ( IFilterGraph2 *  iface)
static

Definition at line 993 of file filtergraph.c.

994{
995 struct filter_graph *This = impl_from_IFilterGraph2(iface);
996 IReferenceClock *pClock = NULL;
997 struct filter *filter;
998 HRESULT hr = S_OK;
999
1000 TRACE("(%p/%p)->() live sources not handled properly!\n", This, iface);
1001
1002 EnterCriticalSection(&This->cs);
1003
1004 LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
1005 {
1006 if (IBaseFilter_QueryInterface(filter->filter, &IID_IReferenceClock, (void **)&pClock) == S_OK)
1007 break;
1008 }
1009
1010 if (!pClock)
1011 {
1012 hr = CoCreateInstance(&CLSID_SystemClock, NULL, CLSCTX_INPROC_SERVER, &IID_IReferenceClock, (LPVOID*)&pClock);
1013 This->refClockProvider = NULL;
1014 }
1015 else
1016 {
1017 filter = LIST_ENTRY(list_tail(&This->filters), struct filter, entry);
1018 This->refClockProvider = filter->filter;
1019 }
1020
1021 if (SUCCEEDED(hr))
1022 {
1023 hr = IMediaFilter_SetSyncSource(&This->IMediaFilter_iface, pClock);
1024 This->defaultclock = TRUE;
1025 IReferenceClock_Release(pClock);
1026 }
1027 LeaveCriticalSection(&This->cs);
1028
1029 return hr;
1030}
list_tail
__WINE_SERVER_LIST_INLINE struct list * list_tail(const struct list *list)
Definition: list.h:139

◆ FilterGraph2_SetLogFile()

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

Definition at line 1560 of file filtergraph.c.

1561{
1562 struct filter_graph *graph = impl_from_IFilterGraph2(iface);
1563
1564 TRACE("graph %p, file %#Ix.\n", graph, file);
1565
1566 return S_OK;
1567}
file
Definition: fci.c:123

◆ FilterGraph2_ShouldOperationContinue()

static HRESULT WINAPI FilterGraph2_ShouldOperationContinue ( IFilterGraph2 *  iface)
static

Definition at line 1578 of file filtergraph.c.

1579{
1580 struct filter_graph *This = impl_from_IFilterGraph2(iface);
1581
1582 TRACE("(%p/%p)->(): stub !!!\n", This, iface);
1583
1584 return S_OK;
1585}

◆ FilterGraphInner_AddRef()

static ULONG WINAPI FilterGraphInner_AddRef ( IUnknown *  iface)
static

Definition at line 430 of file filtergraph.c.

431{
432 struct filter_graph *graph = impl_from_IUnknown(iface);
433 ULONG refcount = InterlockedIncrement(&graph->ref);
434
435 TRACE("%p increasing refcount to %lu.\n", graph, refcount);
436
437 return refcount;
438}
impl_from_IUnknown
static struct filter_graph * impl_from_IUnknown(IUnknown *iface)
Definition: filtergraph.c:351
graph::ref
LONG ref
Definition: graph.c:35

◆ FilterGraphInner_QueryInterface()

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

Definition at line 356 of file filtergraph.c.

357{
358 struct filter_graph *This = impl_from_IUnknown(iface);
359 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObj);
360
361 if (IsEqualGUID(&IID_IUnknown, riid)) {
362 *ppvObj = &This->IUnknown_inner;
363 TRACE(" returning IUnknown interface (%p)\n", *ppvObj);
364 } else if (IsEqualGUID(&IID_IFilterGraph, riid) ||
365 IsEqualGUID(&IID_IFilterGraph2, riid) ||
366 IsEqualGUID(&IID_IGraphBuilder, riid)) {
367 *ppvObj = &This->IFilterGraph2_iface;
368 TRACE(" returning IGraphBuilder interface (%p)\n", *ppvObj);
369 } else if (IsEqualGUID(&IID_IMediaControl, riid)) {
370 *ppvObj = &This->IMediaControl_iface;
371 TRACE(" returning IMediaControl interface (%p)\n", *ppvObj);
372 } else if (IsEqualGUID(&IID_IMediaSeeking, riid)) {
373 *ppvObj = &This->IMediaSeeking_iface;
374 TRACE(" returning IMediaSeeking interface (%p)\n", *ppvObj);
375 } else if (IsEqualGUID(&IID_IBasicAudio, riid)) {
376 *ppvObj = &This->IBasicAudio_iface;
377 TRACE(" returning IBasicAudio interface (%p)\n", *ppvObj);
378 } else if (IsEqualGUID(&IID_IBasicVideo, riid) ||
379 IsEqualGUID(&IID_IBasicVideo2, riid)) {
380 *ppvObj = &This->IBasicVideo2_iface;
381 TRACE(" returning IBasicVideo2 interface (%p)\n", *ppvObj);
382 } else if (IsEqualGUID(&IID_IVideoWindow, riid)) {
383 *ppvObj = &This->IVideoWindow_iface;
384 TRACE(" returning IVideoWindow interface (%p)\n", *ppvObj);
385 } else if (IsEqualGUID(&IID_IMediaEvent, riid) ||
386 IsEqualGUID(&IID_IMediaEventEx, riid)) {
387 *ppvObj = &This->IMediaEventEx_iface;
388 TRACE(" returning IMediaEvent(Ex) interface (%p)\n", *ppvObj);
389 } else if (IsEqualGUID(&IID_IMediaFilter, riid) ||
390 IsEqualGUID(&IID_IPersist, riid)) {
391 *ppvObj = &This->IMediaFilter_iface;
392 TRACE(" returning IMediaFilter interface (%p)\n", *ppvObj);
393 } else if (IsEqualGUID(&IID_IMediaEventSink, riid)) {
394 *ppvObj = &This->IMediaEventSink_iface;
395 TRACE(" returning IMediaEventSink interface (%p)\n", *ppvObj);
396 } else if (IsEqualGUID(&IID_IGraphConfig, riid)) {
397 *ppvObj = &This->IGraphConfig_iface;
398 TRACE(" returning IGraphConfig interface (%p)\n", *ppvObj);
399 } else if (IsEqualGUID(&IID_IMediaPosition, riid)) {
400 *ppvObj = &This->IMediaPosition_iface;
401 TRACE(" returning IMediaPosition interface (%p)\n", *ppvObj);
402 } else if (IsEqualGUID(&IID_IObjectWithSite, riid)) {
403 *ppvObj = &This->IObjectWithSite_iface;
404 TRACE(" returning IObjectWithSite interface (%p)\n", *ppvObj);
405 } else if (IsEqualGUID(&IID_IFilterMapper, riid)) {
406 TRACE(" requesting IFilterMapper interface from aggregated filtermapper (%p)\n", *ppvObj);
407 return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
408 } else if (IsEqualGUID(&IID_IFilterMapper2, riid)) {
409 TRACE(" returning IFilterMapper2 interface from aggregated filtermapper (%p)\n", *ppvObj);
410 return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
411 } else if (IsEqualGUID(&IID_IFilterMapper3, riid)) {
412 TRACE(" returning IFilterMapper3 interface from aggregated filtermapper (%p)\n", *ppvObj);
413 return IUnknown_QueryInterface(This->punkFilterMapper2, riid, ppvObj);
414 } else if (IsEqualGUID(&IID_IGraphVersion, riid)) {
415 *ppvObj = &This->IGraphVersion_iface;
416 TRACE(" returning IGraphVersion interface (%p)\n", *ppvObj);
417 } else if (IsEqualGUID(&IID_IVideoFrameStep, riid)) {
418 *ppvObj = &This->IVideoFrameStep_iface;
419 TRACE(" returning IVideoFrameStep interface (%p)\n", *ppvObj);
420 } else {
421 *ppvObj = NULL;
422 FIXME("unknown interface %s\n", debugstr_guid(riid));
423 return E_NOINTERFACE;
424 }
425
426 IUnknown_AddRef((IUnknown *)*ppvObj);
427 return S_OK;
428}
riid
REFIID riid
Definition: atlbase.h:39
IID_IObjectWithSite
const IID IID_IObjectWithSite
IID_IPersist
const GUID IID_IPersist
Definition: proxy.cpp:14

◆ FilterGraphInner_Release()

static ULONG WINAPI FilterGraphInner_Release ( IUnknown *  iface)
static

Definition at line 440 of file filtergraph.c.

441{
442 struct filter_graph *This = impl_from_IUnknown(iface);
443 ULONG refcount = InterlockedDecrement(&This->ref);
444 struct list *cursor;
445
446 TRACE("%p decreasing refcount to %lu.\n", This, refcount);
447
448 if (!refcount)
449 {
450 int i;
451
452 This->ref = 1; /* guard against reentrancy (aggregation). */
453
454 IMediaControl_Stop(&This->IMediaControl_iface);
455
456 while ((cursor = list_head(&This->filters)))
457 {
458 struct filter *filter = LIST_ENTRY(cursor, struct filter, entry);
459
460 IFilterGraph2_RemoveFilter(&This->IFilterGraph2_iface, filter->filter);
461 }
462
463 if (This->refClock)
464 IReferenceClock_Release(This->refClock);
465
466 for (i = 0; i < This->nItfCacheEntries; i++)
467 {
468 if (This->ItfCacheEntries[i].iface)
469 IUnknown_Release(This->ItfCacheEntries[i].iface);
470 }
471
472 IUnknown_Release(This->punkFilterMapper2);
473
474 if (This->pSite) IUnknown_Release(This->pSite);
475
476 flush_media_events(This);
477 CloseHandle(This->media_event_handle);
478
479 EnterCriticalSection(&message_cs);
480 if (This->threaded && !--message_thread_refcount)
481 {
482 PostThreadMessageW(message_thread_id, WM_USER + 1, 0, 0);
483 WaitForSingleObject(message_thread, INFINITE);
484 CloseHandle(message_thread);
485 CloseHandle(message_thread_ret);
486 }
487 LeaveCriticalSection(&message_cs);
488
489 This->event_cs.DebugInfo->Spare[0] = 0;
490 DeleteCriticalSection(&This->event_cs);
491 This->cs.DebugInfo->Spare[0] = 0;
492 DeleteCriticalSection(&This->cs);
493 free(This);
494 }
495 return refcount;
496}
list
Definition: list.h:39
flush_media_events
static void flush_media_events(struct filter_graph *graph)
Definition: filtergraph.c:338
CloseHandle
#define CloseHandle
Definition: compat.h:739
filter::refcount
LONG refcount
Definition: filter.c:168
DeleteCriticalSection
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)

◆ find_filter_by_name()

static IBaseFilter * find_filter_by_name ( struct filter_graph *  graph,
const WCHAR *  name 
)
static

Definition at line 521 of file filtergraph.c.

522{
523 struct filter *filter;
524
525 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
526 {
527 if (!wcscmp(filter->name, name))
528 return filter->filter;
529 }
530
531 return NULL;
532}
wcscmp
_ACRTIMP int __cdecl wcscmp(const wchar_t *, const wchar_t *)
Definition: wcs.c:1977

Referenced by FilterGraph2_AddFilter(), and FilterGraph2_FindFilterByName().

◆ find_sorted_filter()

static struct filter * find_sorted_filter ( struct filter_graph *  graph,
IBaseFilter *  iface 
)
static

Definition at line 854 of file filtergraph.c.

855{
856 struct filter *filter;
857
858 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
859 {
860 if (filter->filter == iface)
861 return filter;
862 }
863
864 return NULL;
865}

Referenced by sort_filter_recurse().

◆ flush_media_events()

static void flush_media_events ( struct filter_graph *  graph)
static

Definition at line 338 of file filtergraph.c.

339{
340 struct list *cursor;
341
342 while ((cursor = list_head(&graph->media_events)))
343 {
344 struct media_event *event = LIST_ENTRY(cursor, struct media_event, entry);
345
346 list_remove(&event->entry);
347 free(event);
348 }
349}
event
Definition: filter.c:185
event::entry
struct list entry
Definition: filter.c:186
media_event
Definition: filtergraph.c:59

Referenced by FilterGraphInner_Release(), and MediaEvent_SetNotifyFlags().

◆ FoundCapabilities()

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

Definition at line 2149 of file filtergraph.c.

2150{
2151 HRESULT hr;
2152 DWORD caps = 0;
2153
2154 hr = IMediaSeeking_GetCapabilities(seek, &caps);
2155 if (FAILED(hr))
2156 return hr;
2157
2158 /* Only add common capabilities everything supports */
2159 *(DWORD*)pcaps &= caps;
2160
2161 return hr;
2162}
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95

Referenced by MediaSeeking_CheckCapabilities(), and MediaSeeking_GetCapabilities().

◆ get_autoplug_types()

static HRESULT get_autoplug_types ( IPin *  source,
unsigned int *  ret_count,
GUID **  ret_types 
)
static

Definition at line 1201 of file filtergraph.c.

1202{
1203 unsigned int i, mt_count = 0, mt_capacity = 16;
1204 AM_MEDIA_TYPE **mts = NULL;
1205 IEnumMediaTypes *enummt;
1206 GUID *types = NULL;
1207 HRESULT hr;
1208
1209 if (FAILED(hr = IPin_EnumMediaTypes(source, &enummt)))
1210 {
1211 ERR("Failed to enumerate media types, hr %#lx.\n", hr);
1212 return hr;
1213 }
1214
1215 for (;;)
1216 {
1217 ULONG count;
1218
1219 if (!(mts = realloc(mts, mt_capacity * sizeof(*mts))))
1220 {
1221 hr = E_OUTOFMEMORY;
1222 goto out;
1223 }
1224
1225 if (FAILED(hr = IEnumMediaTypes_Next(enummt, mt_capacity - mt_count, mts + mt_count, &count)))
1226 {
1227 ERR("Failed to get media types, hr %#lx.\n", hr);
1228 goto out;
1229 }
1230
1231 mt_count += count;
1232 if (hr == S_FALSE)
1233 break;
1234
1235 mt_capacity *= 2;
1236 }
1237
1238 if (!(types = malloc(mt_count * 2 * sizeof(*types))))
1239 {
1240 hr = E_OUTOFMEMORY;
1241 goto out;
1242 }
1243
1244 for (i = 0; i < mt_count; ++i)
1245 {
1246 types[i * 2] = mts[i]->majortype;
1247 types[i * 2 + 1] = mts[i]->subtype;
1248 DeleteMediaType(mts[i]);
1249 }
1250
1251 *ret_count = mt_count;
1252 *ret_types = types;
1253
1254 hr = S_OK;
1255out:
1256 free(mts);
1257 IEnumMediaTypes_Release(enummt);
1258 return hr;
1259}
realloc
#define realloc
Definition: debug_ros.c:6
malloc
#define malloc
Definition: debug_ros.c:4
DeleteMediaType
void WINAPI DeleteMediaType(AM_MEDIA_TYPE *pMediaType)
Definition: mediatype.c:193
AM_MEDIA_TYPE
Definition: vmr9.idl:28

Referenced by autoplug().

◆ GetTargetInterface()

static HRESULT GetTargetInterface ( struct filter_graph *  pGraph,
REFIID  riid,
LPVOID *  ppvObj 
)
static

Definition at line 2863 of file filtergraph.c.

2864{
2865 struct filter *filter;
2866 HRESULT hr;
2867 int entry;
2868
2869 /* Check if the interface type is already registered */
2870 for (entry = 0; entry < pGraph->nItfCacheEntries; entry++)
2871 if (riid == pGraph->ItfCacheEntries[entry].riid)
2872 {
2873 if (pGraph->ItfCacheEntries[entry].iface)
2874 {
2875 /* Return the interface if available */
2876 *ppvObj = pGraph->ItfCacheEntries[entry].iface;
2877 return S_OK;
2878 }
2879 break;
2880 }
2881
2882 if (entry >= MAX_ITF_CACHE_ENTRIES)
2883 {
2884 FIXME("Not enough space to store interface in the cache\n");
2885 return E_OUTOFMEMORY;
2886 }
2887
2888 /* Find a filter supporting the requested interface */
2889 LIST_FOR_EACH_ENTRY(filter, &pGraph->filters, struct filter, entry)
2890 {
2891 hr = IBaseFilter_QueryInterface(filter->filter, riid, ppvObj);
2892 if (hr == S_OK)
2893 {
2894 pGraph->ItfCacheEntries[entry].riid = riid;
2895 pGraph->ItfCacheEntries[entry].filter = filter->filter;
2896 pGraph->ItfCacheEntries[entry].iface = *ppvObj;
2897 if (entry >= pGraph->nItfCacheEntries)
2898 pGraph->nItfCacheEntries++;
2899 return S_OK;
2900 }
2901 if (hr != E_NOINTERFACE)
2902 return hr;
2903 }
2904
2905 return IsEqualGUID(riid, &IID_IBasicAudio) ? E_NOTIMPL : E_NOINTERFACE;
2906}
MAX_ITF_CACHE_ENTRIES
#define MAX_ITF_CACHE_ENTRIES
Definition: filtergraph.c:65
_ITF_CACHE_ENTRY::iface
IUnknown * iface
Definition: filtergraph.c:69
_ITF_CACHE_ENTRY::riid
const IID * riid
Definition: filtergraph.c:67
_ITF_CACHE_ENTRY::filter
IBaseFilter * filter
Definition: filtergraph.c:68
filter_graph::nItfCacheEntries
int nItfCacheEntries
Definition: filtergraph.c:142
filter_graph::ItfCacheEntries
ITF_CACHE_ENTRY ItfCacheEntries[MAX_ITF_CACHE_ENTRIES]
Definition: filtergraph.c:141
filter_graph::filters
struct list filters
Definition: filtergraph.c:111

Referenced by BasicAudio_get_Balance(), BasicAudio_get_Volume(), BasicAudio_put_Balance(), BasicAudio_put_Volume(), BasicVideo2_GetPreferredAspectRatio(), BasicVideo_get_AvgTimePerFrame(), BasicVideo_get_BitErrorRate(), BasicVideo_get_BitRate(), BasicVideo_get_DestinationHeight(), BasicVideo_get_DestinationLeft(), BasicVideo_get_DestinationTop(), BasicVideo_get_DestinationWidth(), BasicVideo_get_SourceHeight(), BasicVideo_get_SourceLeft(), BasicVideo_get_SourceTop(), BasicVideo_get_SourceWidth(), BasicVideo_get_VideoHeight(), BasicVideo_get_VideoWidth(), BasicVideo_GetCurrentImage(), BasicVideo_GetDestinationPosition(), BasicVideo_GetSourcePosition(), BasicVideo_GetVideoPaletteEntries(), BasicVideo_GetVideoSize(), BasicVideo_IsUsingDefaultDestination(), BasicVideo_IsUsingDefaultSource(), BasicVideo_put_DestinationHeight(), BasicVideo_put_DestinationLeft(), BasicVideo_put_DestinationTop(), BasicVideo_put_DestinationWidth(), BasicVideo_put_SourceHeight(), BasicVideo_put_SourceLeft(), BasicVideo_put_SourceTop(), BasicVideo_put_SourceWidth(), BasicVideo_SetDefaultDestinationPosition(), BasicVideo_SetDefaultSourcePosition(), BasicVideo_SetDestinationPosition(), BasicVideo_SetSourcePosition(), VideoWindow_get_AutoShow(), VideoWindow_get_BackgroundPalette(), VideoWindow_get_BorderColor(), VideoWindow_get_Caption(), VideoWindow_get_FullScreenMode(), VideoWindow_get_Height(), VideoWindow_get_Left(), VideoWindow_get_MessageDrain(), VideoWindow_get_Owner(), VideoWindow_get_Top(), VideoWindow_get_Visible(), VideoWindow_get_Width(), VideoWindow_get_WindowState(), VideoWindow_get_WindowStyle(), VideoWindow_get_WindowStyleEx(), VideoWindow_GetMaxIdealImageSize(), VideoWindow_GetMinIdealImageSize(), VideoWindow_GetRestorePosition(), VideoWindow_GetWindowPosition(), VideoWindow_HideCursor(), VideoWindow_IsCursorHidden(), VideoWindow_NotifyOwnerMessage(), VideoWindow_put_AutoShow(), VideoWindow_put_BackgroundPalette(), VideoWindow_put_BorderColor(), VideoWindow_put_Caption(), VideoWindow_put_FullScreenMode(), VideoWindow_put_Height(), VideoWindow_put_Left(), VideoWindow_put_MessageDrain(), VideoWindow_put_Owner(), VideoWindow_put_Top(), VideoWindow_put_Visible(), VideoWindow_put_Width(), VideoWindow_put_WindowState(), VideoWindow_put_WindowStyle(), VideoWindow_put_WindowStyleEx(), VideoWindow_SetWindowForeground(), and VideoWindow_SetWindowPosition().

◆ graph_start()

static HRESULT graph_start ( struct filter_graph *  graph,
REFERENCE_TIME  stream_start 
)
static

Definition at line 1774 of file filtergraph.c.

1775{
1776 struct media_event *event, *next;
1777 REFERENCE_TIME stream_stop;
1778 struct filter *filter;
1779 HRESULT hr = S_OK;
1780
1781 EnterCriticalSection(&graph->event_cs);
1782 graph->EcCompleteCount = 0;
1783 update_render_count(graph);
1784 LeaveCriticalSection(&graph->event_cs);
1785
1786 LIST_FOR_EACH_ENTRY_SAFE(event, next, &graph->media_events, struct media_event, entry)
1787 {
1788 if (event->code == EC_COMPLETE)
1789 {
1790 list_remove(&event->entry);
1791 free(event);
1792 }
1793 }
1794 if (list_empty(&graph->media_events))
1795 ResetEvent(graph->media_event_handle);
1796
1797 if (graph->defaultclock && !graph->refClock)
1798 IFilterGraph2_SetDefaultSyncSource(&graph->IFilterGraph2_iface);
1799
1800 if (!stream_start && graph->refClock)
1801 {
1802 IReferenceClock_GetTime(graph->refClock, &graph->stream_start);
1803 stream_start = graph->stream_start - graph->stream_elapsed;
1804 /* Delay presentation time by 200 ms, to give filters time to
1805 * initialize. */
1806 stream_start += 200 * 10000;
1807 }
1808
1809 if (SUCCEEDED(IMediaSeeking_GetStopPosition(&graph->IMediaSeeking_iface, &stream_stop)))
1810 graph->stream_stop = stream_stop;
1811
1812 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1813 {
1814 HRESULT filter_hr = IBaseFilter_Run(filter->filter, stream_start);
1815 if (hr == S_OK)
1816 hr = filter_hr;
1817 TRACE("Filter %p returned %#lx.\n", filter->filter, filter_hr);
1818 }
1819
1820 if (FAILED(hr))
1821 WARN("Failed to start stream, hr %#lx.\n", hr);
1822
1823 return hr;
1824}
list_empty
static int list_empty(struct list_entry *head)
Definition: list.h:58
update_render_count
static void update_render_count(struct filter_graph *graph)
Definition: filtergraph.c:1760
REFERENCE_TIME
LONGLONG REFERENCE_TIME
Definition: dmusicks.h:9
EC_COMPLETE
#define EC_COMPLETE
Definition: evcode.h:17
next
static unsigned __int64 next
Definition: rand_nt.c:6
LIST_FOR_EACH_ENTRY_SAFE
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:242
ResetEvent
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:650

Referenced by async_run_cb(), MediaControl_Run(), and MediaFilter_Run().

◆ GraphConfig_AddFilterToCache()

static HRESULT WINAPI GraphConfig_AddFilterToCache ( IGraphConfig *  iface,
IBaseFilter *  pFilter 
)
static

Definition at line 5486 of file filtergraph.c.

5487{
5488 struct filter_graph *This = impl_from_IGraphConfig(iface);
5489
5490 FIXME("(%p)->(%p): stub!\n", This, pFilter);
5491
5492 return E_NOTIMPL;
5493}
impl_from_IGraphConfig
static struct filter_graph * impl_from_IGraphConfig(IGraphConfig *iface)
Definition: filtergraph.c:5427

◆ GraphConfig_AddRef()

static ULONG WINAPI GraphConfig_AddRef ( IGraphConfig *  iface)
static

Definition at line 5439 of file filtergraph.c.

5440{
5441 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5442
5443 return IUnknown_AddRef(graph->outer_unk);
5444}

◆ GraphConfig_EnumCacheFilter()

static HRESULT WINAPI GraphConfig_EnumCacheFilter ( IGraphConfig *  iface,
IEnumFilters **  pEnum 
)
static

Definition at line 5495 of file filtergraph.c.

5496{
5497 struct filter_graph *This = impl_from_IGraphConfig(iface);
5498
5499 FIXME("(%p)->(%p): stub!\n", This, pEnum);
5500
5501 return E_NOTIMPL;
5502}

◆ GraphConfig_GetFilterFlags()

static HRESULT WINAPI GraphConfig_GetFilterFlags ( IGraphConfig *  iface,
IBaseFilter *  pFilter,
DWORD *  dwFlags 
)
static

Definition at line 5541 of file filtergraph.c.

5543{
5544 struct filter_graph *This = impl_from_IGraphConfig(iface);
5545
5546 FIXME("(%p)->(%p, %p): stub!\n", This, pFilter, dwFlags);
5547
5548 return E_NOTIMPL;
5549}
dwFlags
_In_ LPWSTR _In_ DWORD _In_ DWORD _In_ DWORD dwFlags
Definition: netsh.h:141

◆ GraphConfig_GetStartTime()

static HRESULT WINAPI GraphConfig_GetStartTime ( IGraphConfig *  iface,
REFERENCE_TIME *  prtStart 
)
static

Definition at line 5513 of file filtergraph.c.

5514{
5515 struct filter_graph *This = impl_from_IGraphConfig(iface);
5516
5517 FIXME("(%p)->(%p): stub!\n", This, prtStart);
5518
5519 return E_NOTIMPL;
5520}

◆ GraphConfig_PushThroughData()

static HRESULT WINAPI GraphConfig_PushThroughData ( IGraphConfig *  iface,
IPin *  pOutputPin,
IPinConnection *  pConnection,
HANDLE  hEventAbort 
)
static

Definition at line 5522 of file filtergraph.c.

5524{
5525 struct filter_graph *This = impl_from_IGraphConfig(iface);
5526
5527 FIXME("(%p)->(%p, %p, %p): stub!\n", This, pOutputPin, pConnection, hEventAbort);
5528
5529 return E_NOTIMPL;
5530}

◆ GraphConfig_QueryInterface()

static HRESULT WINAPI GraphConfig_QueryInterface ( IGraphConfig *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 5432 of file filtergraph.c.

5433{
5434 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5435
5436 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5437}

◆ GraphConfig_Reconfigure()

static HRESULT WINAPI GraphConfig_Reconfigure ( IGraphConfig *  iface,
IGraphConfigCallback *  callback,
void *  context,
DWORD  flags,
HANDLE  abort_event 
)
static

Definition at line 5465 of file filtergraph.c.

5467{
5468 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5469 HRESULT hr;
5470
5471 TRACE("graph %p, callback %p, context %p, flags %#lx, abort_event %p.\n",
5472 graph, callback, context, flags, abort_event);
5473
5474 if (abort_event)
5475 FIXME("The parameter hAbortEvent is not handled!\n");
5476
5477 EnterCriticalSection(&graph->cs);
5478
5479 hr = IGraphConfigCallback_Reconfigure(callback, context, flags);
5480
5481 LeaveCriticalSection(&graph->cs);
5482
5483 return hr;
5484}

◆ GraphConfig_Reconnect()

static HRESULT WINAPI GraphConfig_Reconnect ( IGraphConfig *  iface,
IPin *  source,
IPin *  sink,
const AM_MEDIA_TYPE *  mt,
IBaseFilter *  filter,
HANDLE  abort_event,
DWORD  flags 
)
static

Definition at line 5453 of file filtergraph.c.

5455{
5456 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5457
5458 FIXME("graph %p, source %p, sink %p, mt %p, filter %p, abort_event %p, flags %#lx, stub!\n",
5459 graph, source, sink, mt, filter, abort_event, flags);
5460 strmbase_dump_media_type(mt);
5461
5462 return E_NOTIMPL;
5463}

◆ GraphConfig_Release()

static ULONG WINAPI GraphConfig_Release ( IGraphConfig *  iface)
static

Definition at line 5446 of file filtergraph.c.

5447{
5448 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5449
5450 return IUnknown_Release(graph->outer_unk);
5451}

◆ GraphConfig_RemoveFilterEx()

static HRESULT WINAPI GraphConfig_RemoveFilterEx ( IGraphConfig *  iface,
IBaseFilter *  filter,
DWORD  flags 
)
static

Definition at line 5551 of file filtergraph.c.

5552{
5553 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5554
5555 FIXME("graph %p, filter %p, flags %#lx, stub!\n", graph, filter, flags);
5556
5557 return E_NOTIMPL;
5558}

◆ GraphConfig_RemoveFilterFromCache()

static HRESULT WINAPI GraphConfig_RemoveFilterFromCache ( IGraphConfig *  iface,
IBaseFilter *  pFilter 
)
static

Definition at line 5504 of file filtergraph.c.

5505{
5506 struct filter_graph *This = impl_from_IGraphConfig(iface);
5507
5508 FIXME("(%p)->(%p): stub!\n", This, pFilter);
5509
5510 return E_NOTIMPL;
5511}

◆ GraphConfig_SetFilterFlags()

static HRESULT WINAPI GraphConfig_SetFilterFlags ( IGraphConfig *  iface,
IBaseFilter *  filter,
DWORD  flags 
)
static

Definition at line 5532 of file filtergraph.c.

5533{
5534 struct filter_graph *graph = impl_from_IGraphConfig(iface);
5535
5536 FIXME("graph %p, filter %p, flags %#lx, stub!\n", graph, filter, flags);
5537
5538 return E_NOTIMPL;
5539}

◆ GraphVersion_AddRef()

static ULONG WINAPI GraphVersion_AddRef ( IGraphVersion *  iface)
static

Definition at line 5589 of file filtergraph.c.

5590{
5591 struct filter_graph *graph = impl_from_IGraphVersion(iface);
5592
5593 return IUnknown_AddRef(graph->outer_unk);
5594}
impl_from_IGraphVersion
static struct filter_graph * impl_from_IGraphVersion(IGraphVersion *iface)
Definition: filtergraph.c:5577

◆ GraphVersion_QueryInterface()

static HRESULT WINAPI GraphVersion_QueryInterface ( IGraphVersion *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 5582 of file filtergraph.c.

5583{
5584 struct filter_graph *graph = impl_from_IGraphVersion(iface);
5585
5586 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5587}

◆ GraphVersion_QueryVersion()

static HRESULT WINAPI GraphVersion_QueryVersion ( IGraphVersion *  iface,
LONG *  version 
)
static

Definition at line 5603 of file filtergraph.c.

5604{
5605 struct filter_graph *graph = impl_from_IGraphVersion(iface);
5606
5607 TRACE("graph %p, version %p, returning %ld.\n", graph, version, graph->version);
5608
5609 if (!version)
5610 return E_POINTER;
5611
5612 *version = graph->version;
5613 return S_OK;
5614}
version
static const WCHAR version[]
Definition: asmname.c:66

◆ GraphVersion_Release()

static ULONG WINAPI GraphVersion_Release ( IGraphVersion *  iface)
static

Definition at line 5596 of file filtergraph.c.

5597{
5598 struct filter_graph *graph = impl_from_IGraphVersion(iface);
5599
5600 return IUnknown_Release(graph->outer_unk);
5601}

◆ has_output_pins()

static BOOL has_output_pins ( IBaseFilter *  filter)
static

Definition at line 534 of file filtergraph.c.

535{
536 IEnumPins *enumpins;
537 PIN_DIRECTION dir;
538 IPin *pin;
539
540 if (FAILED(IBaseFilter_EnumPins(filter, &enumpins)))
541 return FALSE;
542
543 while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
544 {
545 IPin_QueryDirection(pin, &dir);
546 IPin_Release(pin);
547 if (dir == PINDIR_OUTPUT)
548 {
549 IEnumPins_Release(enumpins);
550 return TRUE;
551 }
552 }
553
554 IEnumPins_Release(enumpins);
555 return FALSE;
556}

Referenced by is_renderer().

◆ impl_from_IBasicAudio()

static struct filter_graph * impl_from_IBasicAudio ( IBasicAudio *  iface)
static

Definition at line 2908 of file filtergraph.c.

2909{
2910 return CONTAINING_RECORD(iface, struct filter_graph, IBasicAudio_iface);
2911}
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by BasicAudio_AddRef(), BasicAudio_get_Balance(), BasicAudio_get_Volume(), BasicAudio_put_Balance(), BasicAudio_put_Volume(), BasicAudio_QueryInterface(), and BasicAudio_Release().

◆ impl_from_IBasicVideo2()

static struct filter_graph * impl_from_IBasicVideo2 ( IBasicVideo2 *  iface)
static

Definition at line 3075 of file filtergraph.c.

3076{
3077 return CONTAINING_RECORD(iface, struct filter_graph, IBasicVideo2_iface);
3078}

Referenced by BasicVideo2_GetPreferredAspectRatio(), BasicVideo_AddRef(), BasicVideo_get_AvgTimePerFrame(), BasicVideo_get_BitErrorRate(), BasicVideo_get_BitRate(), BasicVideo_get_DestinationHeight(), BasicVideo_get_DestinationLeft(), BasicVideo_get_DestinationTop(), BasicVideo_get_DestinationWidth(), BasicVideo_get_SourceHeight(), BasicVideo_get_SourceLeft(), BasicVideo_get_SourceTop(), BasicVideo_get_SourceWidth(), BasicVideo_get_VideoHeight(), BasicVideo_get_VideoWidth(), BasicVideo_GetCurrentImage(), BasicVideo_GetDestinationPosition(), BasicVideo_GetSourcePosition(), BasicVideo_GetVideoPaletteEntries(), BasicVideo_GetVideoSize(), BasicVideo_IsUsingDefaultDestination(), BasicVideo_IsUsingDefaultSource(), BasicVideo_put_DestinationHeight(), BasicVideo_put_DestinationLeft(), BasicVideo_put_DestinationTop(), BasicVideo_put_DestinationWidth(), BasicVideo_put_SourceHeight(), BasicVideo_put_SourceLeft(), BasicVideo_put_SourceTop(), BasicVideo_put_SourceWidth(), BasicVideo_QueryInterface(), BasicVideo_Release(), BasicVideo_SetDefaultDestinationPosition(), BasicVideo_SetDefaultSourcePosition(), BasicVideo_SetDestinationPosition(), and BasicVideo_SetSourcePosition().

◆ impl_from_IEnumFilters()

static struct enum_filters * impl_from_IEnumFilters ( IEnumFilters *  iface)
inlinestatic

Definition at line 169 of file filtergraph.c.

170{
171 return CONTAINING_RECORD(iface, struct enum_filters, IEnumFilters_iface);
172}

Referenced by EnumFilters_AddRef(), EnumFilters_Clone(), EnumFilters_Next(), EnumFilters_QueryInterface(), EnumFilters_Release(), EnumFilters_Reset(), and EnumFilters_Skip().

◆ impl_from_IFilterGraph2()

static struct filter_graph * impl_from_IFilterGraph2 ( IFilterGraph2 *  iface)
static

Definition at line 498 of file filtergraph.c.

499{
500 return CONTAINING_RECORD(iface, struct filter_graph, IFilterGraph2_iface);
501}

Referenced by FilterGraph2_Abort(), FilterGraph2_AddFilter(), FilterGraph2_AddRef(), FilterGraph2_AddSourceFilter(), FilterGraph2_AddSourceFilterForMoniker(), FilterGraph2_Connect(), FilterGraph2_ConnectDirect(), FilterGraph2_Disconnect(), FilterGraph2_EnumFilters(), FilterGraph2_FindFilterByName(), FilterGraph2_QueryInterface(), FilterGraph2_Reconnect(), FilterGraph2_ReconnectEx(), FilterGraph2_Release(), FilterGraph2_RemoveFilter(), FilterGraph2_Render(), FilterGraph2_RenderEx(), FilterGraph2_RenderFile(), FilterGraph2_SetDefaultSyncSource(), FilterGraph2_SetLogFile(), and FilterGraph2_ShouldOperationContinue().

◆ impl_from_IGraphConfig()

static struct filter_graph * impl_from_IGraphConfig ( IGraphConfig *  iface)
static

Definition at line 5427 of file filtergraph.c.

5428{
5429 return CONTAINING_RECORD(iface, struct filter_graph, IGraphConfig_iface);
5430}

Referenced by GraphConfig_AddFilterToCache(), GraphConfig_AddRef(), GraphConfig_EnumCacheFilter(), GraphConfig_GetFilterFlags(), GraphConfig_GetStartTime(), GraphConfig_PushThroughData(), GraphConfig_QueryInterface(), GraphConfig_Reconfigure(), GraphConfig_Reconnect(), GraphConfig_Release(), GraphConfig_RemoveFilterEx(), GraphConfig_RemoveFilterFromCache(), and GraphConfig_SetFilterFlags().

◆ impl_from_IGraphVersion()

static struct filter_graph * impl_from_IGraphVersion ( IGraphVersion *  iface)
static

Definition at line 5577 of file filtergraph.c.

5578{
5579 return CONTAINING_RECORD(iface, struct filter_graph, IGraphVersion_iface);
5580}

Referenced by GraphVersion_AddRef(), GraphVersion_QueryInterface(), GraphVersion_QueryVersion(), and GraphVersion_Release().

◆ impl_from_IMediaControl()

static struct filter_graph * impl_from_IMediaControl ( IMediaControl *  iface)
static

Definition at line 1688 of file filtergraph.c.

1689{
1690 return CONTAINING_RECORD(iface, struct filter_graph, IMediaControl_iface);
1691}

Referenced by MediaControl_AddRef(), MediaControl_AddSourceFilter(), MediaControl_get_FilterCollection(), MediaControl_get_RegFilterCollection(), MediaControl_GetState(), MediaControl_Pause(), MediaControl_QueryInterface(), MediaControl_Release(), MediaControl_RenderFile(), MediaControl_Run(), MediaControl_Stop(), and MediaControl_StopWhenReady().

◆ impl_from_IMediaEventEx()

static struct filter_graph * impl_from_IMediaEventEx ( IMediaEventEx *  iface)
static

Definition at line 4777 of file filtergraph.c.

4778{
4779 return CONTAINING_RECORD(iface, struct filter_graph, IMediaEventEx_iface);
4780}

Referenced by MediaEvent_AddRef(), MediaEvent_CancelDefaultHandling(), MediaEvent_FreeEventParams(), MediaEvent_GetEvent(), MediaEvent_GetEventHandle(), MediaEvent_GetNotifyFlags(), MediaEvent_QueryInterface(), MediaEvent_Release(), MediaEvent_RestoreDefaultHandling(), MediaEvent_SetNotifyFlags(), MediaEvent_SetNotifyWindow(), and MediaEvent_WaitForCompletion().

◆ impl_from_IMediaEventSink()

static struct filter_graph * impl_from_IMediaEventSink ( IMediaEventSink *  iface)
static

Definition at line 5358 of file filtergraph.c.

5359{
5360 return CONTAINING_RECORD(iface, struct filter_graph, IMediaEventSink_iface);
5361}

Referenced by MediaEventSink_AddRef(), MediaEventSink_Notify(), MediaEventSink_QueryInterface(), and MediaEventSink_Release().

◆ impl_from_IMediaFilter()

static struct filter_graph * impl_from_IMediaFilter ( IMediaFilter *  iface)
static

Definition at line 5031 of file filtergraph.c.

5032{
5033 return CONTAINING_RECORD(iface, struct filter_graph, IMediaFilter_iface);
5034}

Referenced by MediaFilter_AddRef(), MediaFilter_GetState(), MediaFilter_GetSyncSource(), MediaFilter_Pause(), MediaFilter_QueryInterface(), MediaFilter_Release(), MediaFilter_Run(), MediaFilter_SetSyncSource(), and MediaFilter_Stop().

◆ impl_from_IMediaPosition()

static struct filter_graph * impl_from_IMediaPosition ( IMediaPosition *  iface)
static

Definition at line 2578 of file filtergraph.c.

2579{
2580 return CONTAINING_RECORD(iface, struct filter_graph, IMediaPosition_iface);
2581}

Referenced by MediaPosition_AddRef(), MediaPosition_get_CurrentPosition(), MediaPosition_get_Duration(), MediaPosition_get_Rate(), MediaPosition_get_StopTime(), MediaPosition_put_CurrentPosition(), MediaPosition_put_Rate(), MediaPosition_put_StopTime(), MediaPosition_QueryInterface(), MediaPosition_Release(), testpos_AddRef(), testpos_QueryInterface(), and testpos_Release().

◆ impl_from_IMediaSeeking()

static struct filter_graph * impl_from_IMediaSeeking ( IMediaSeeking *  iface)
static

Definition at line 2102 of file filtergraph.c.

2103{
2104 return CONTAINING_RECORD(iface, struct filter_graph, IMediaSeeking_iface);
2105}

Referenced by MediaSeeking_AddRef(), MediaSeeking_CheckCapabilities(), MediaSeeking_ConvertTimeFormat(), MediaSeeking_GetAvailable(), MediaSeeking_GetCapabilities(), MediaSeeking_GetCurrentPosition(), MediaSeeking_GetDuration(), MediaSeeking_GetPositions(), MediaSeeking_GetPreroll(), MediaSeeking_GetRate(), MediaSeeking_GetStopPosition(), MediaSeeking_GetTimeFormat(), MediaSeeking_IsFormatSupported(), MediaSeeking_IsUsingTimeFormat(), MediaSeeking_QueryInterface(), MediaSeeking_QueryPreferredFormat(), MediaSeeking_Release(), MediaSeeking_SetPositions(), MediaSeeking_SetRate(), MediaSeeking_SetTimeFormat(), testseek_AddRef(), testseek_GetCapabilities(), testseek_GetCurrentPosition(), testseek_GetDuration(), testseek_GetStopPosition(), testseek_IsFormatSupported(), testseek_QueryInterface(), testseek_Release(), testseek_SetPositions(), testseek_SetRate(), and testseek_SetTimeFormat().

◆ impl_from_IObjectWithSite()

static struct filter_graph * impl_from_IObjectWithSite ( IObjectWithSite *  iface)
static

Definition at line 2804 of file filtergraph.c.

2805{
2806 return CONTAINING_RECORD(iface, struct filter_graph, IObjectWithSite_iface);
2807}

Referenced by ObjectWithSite_AddRef(), ObjectWithSite_GetSite(), ObjectWithSite_QueryInterface(), ObjectWithSite_Release(), and ObjectWithSite_SetSite().

◆ impl_from_IUnknown()

static struct filter_graph * impl_from_IUnknown ( IUnknown *  iface)
static

Definition at line 351 of file filtergraph.c.

352{
353 return CONTAINING_RECORD(iface, struct filter_graph, IUnknown_inner);
354}

Referenced by FilterGraphInner_AddRef(), FilterGraphInner_QueryInterface(), and FilterGraphInner_Release().

◆ impl_from_IVideoFrameStep()

static struct filter_graph * impl_from_IVideoFrameStep ( IVideoFrameStep *  iface)
static

Definition at line 5624 of file filtergraph.c.

5625{
5626 return CONTAINING_RECORD(iface, struct filter_graph, IVideoFrameStep_iface);
5627}

Referenced by VideoFrameStep_AddRef(), VideoFrameStep_QueryInterface(), and VideoFrameStep_Release().

◆ impl_from_IVideoWindow()

static struct filter_graph * impl_from_IVideoWindow ( IVideoWindow *  iface)
static

Definition at line 3860 of file filtergraph.c.

3861{
3862 return CONTAINING_RECORD(iface, struct filter_graph, IVideoWindow_iface);
3863}

Referenced by VideoWindow_AddRef(), VideoWindow_get_AutoShow(), VideoWindow_get_BackgroundPalette(), VideoWindow_get_BorderColor(), VideoWindow_get_Caption(), VideoWindow_get_FullScreenMode(), VideoWindow_get_Height(), VideoWindow_get_Left(), VideoWindow_get_MessageDrain(), VideoWindow_get_Owner(), VideoWindow_get_Top(), VideoWindow_get_Visible(), VideoWindow_get_Width(), VideoWindow_get_WindowState(), VideoWindow_get_WindowStyle(), VideoWindow_get_WindowStyleEx(), VideoWindow_GetMaxIdealImageSize(), VideoWindow_GetMinIdealImageSize(), VideoWindow_GetRestorePosition(), VideoWindow_GetWindowPosition(), VideoWindow_HideCursor(), VideoWindow_IsCursorHidden(), VideoWindow_NotifyOwnerMessage(), VideoWindow_put_AutoShow(), VideoWindow_put_BackgroundPalette(), VideoWindow_put_BorderColor(), VideoWindow_put_Caption(), VideoWindow_put_FullScreenMode(), VideoWindow_put_Height(), VideoWindow_put_Left(), VideoWindow_put_MessageDrain(), VideoWindow_put_Owner(), VideoWindow_put_Top(), VideoWindow_put_Visible(), VideoWindow_put_Width(), VideoWindow_put_WindowState(), VideoWindow_put_WindowStyle(), VideoWindow_put_WindowStyleEx(), VideoWindow_QueryInterface(), VideoWindow_Release(), VideoWindow_SetWindowForeground(), and VideoWindow_SetWindowPosition().

◆ is_renderer()

static BOOL is_renderer ( struct filter *  filter)
static

Definition at line 580 of file filtergraph.c.

581{
582 IMediaPosition *media_position;
583 IAMFilterMiscFlags *flags;
584 BOOL ret = FALSE;
585
586 if (SUCCEEDED(IBaseFilter_QueryInterface(filter->filter, &IID_IAMFilterMiscFlags, (void **)&flags)))
587 {
588 if (IAMFilterMiscFlags_GetMiscFlags(flags) & AM_FILTER_MISC_FLAGS_IS_RENDERER)
589 ret = TRUE;
590 IAMFilterMiscFlags_Release(flags);
591 }
592 else if (SUCCEEDED(IBaseFilter_QueryInterface(filter->filter, &IID_IMediaPosition, (void **)&media_position)))
593 {
594 if (!has_output_pins(filter->filter))
595 ret = TRUE;
596 IMediaPosition_Release(media_position);
597 }
598 else
599 {
600 update_seeking(filter);
601 if (filter->seeking && !has_output_pins(filter->filter))
602 ret = TRUE;
603 }
604 return ret;
605}
AM_FILTER_MISC_FLAGS_IS_RENDERER
@ AM_FILTER_MISC_FLAGS_IS_RENDERER
Definition: axextend.idl:1244
has_output_pins
static BOOL has_output_pins(IBaseFilter *filter)
Definition: filtergraph.c:534
ret
return ret
Definition: mutex.c:147

Referenced by update_render_count().

◆ MediaControl_AddRef()

static ULONG WINAPI MediaControl_AddRef ( IMediaControl *  iface)
static

Definition at line 1699 of file filtergraph.c.

1700{
1701 struct filter_graph *graph = impl_from_IMediaControl(iface);
1702 return IUnknown_AddRef(graph->outer_unk);
1703}
impl_from_IMediaControl
static struct filter_graph * impl_from_IMediaControl(IMediaControl *iface)
Definition: filtergraph.c:1688

◆ MediaControl_AddSourceFilter()

static HRESULT WINAPI MediaControl_AddSourceFilter ( IMediaControl *  iface,
BSTR  strFilename,
IDispatch **  ppUnk 
)
static

Definition at line 1992 of file filtergraph.c.

1994{
1995 struct filter_graph *This = impl_from_IMediaControl(iface);
1996
1997 FIXME("(%p/%p)->(%s (%p), %p): stub !!!\n", This, iface, debugstr_w(strFilename), strFilename, ppUnk);
1998
1999 return S_OK;
2000}

◆ MediaControl_get_FilterCollection()

static HRESULT WINAPI MediaControl_get_FilterCollection ( IMediaControl *  iface,
IDispatch **  ppUnk 
)
static

Definition at line 2002 of file filtergraph.c.

2003{
2004 struct filter_graph *This = impl_from_IMediaControl(iface);
2005
2006 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
2007
2008 return S_OK;
2009}

◆ MediaControl_get_RegFilterCollection()

static HRESULT WINAPI MediaControl_get_RegFilterCollection ( IMediaControl *  iface,
IDispatch **  ppUnk 
)
static

Definition at line 2011 of file filtergraph.c.

2012{
2013 struct filter_graph *This = impl_from_IMediaControl(iface);
2014
2015 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, ppUnk);
2016
2017 return S_OK;
2018}

◆ MediaControl_GetIDsOfNames()

static HRESULT WINAPI MediaControl_GetIDsOfNames ( IMediaControl *  iface,
REFIID  iid,
LPOLESTR *  names,
UINT  count,
LCID  lcid,
DISPID *  ids 
)
static

Definition at line 1726 of file filtergraph.c.

1728{
1729 ITypeInfo *typeinfo;
1730 HRESULT hr;
1731
1732 TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
1733 iface, debugstr_guid(iid), names, count, lcid, ids);
1734
1735 if (SUCCEEDED(hr = strmbase_get_typeinfo(IMediaControl_tid, &typeinfo)))
1736 {
1737 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
1738 ITypeInfo_Release(typeinfo);
1739 }
1740 return hr;
1741}
IMediaControl_tid
@ IMediaControl_tid
Definition: strmbase.h:227

◆ MediaControl_GetState()

static HRESULT WINAPI MediaControl_GetState ( IMediaControl *  iface,
LONG  timeout,
OAFilterState *  state 
)
static

Definition at line 1972 of file filtergraph.c.

1973{
1974 struct filter_graph *graph = impl_from_IMediaControl(iface);
1975
1976 TRACE("graph %p, timeout %ld, state %p.\n", graph, timeout, state);
1977
1978 if (timeout < 0) timeout = INFINITE;
1979
1980 return IMediaFilter_GetState(&graph->IMediaFilter_iface, timeout, (FILTER_STATE *)state);
1981}
timeout
Definition: dhcpd.h:248

◆ MediaControl_GetTypeInfo()

static HRESULT WINAPI MediaControl_GetTypeInfo ( IMediaControl *  iface,
UINT  index,
LCID  lcid,
ITypeInfo **  typeinfo 
)
static

Definition at line 1719 of file filtergraph.c.

1721{
1722 TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
1723 return strmbase_get_typeinfo(IMediaControl_tid, typeinfo);
1724}

◆ MediaControl_GetTypeInfoCount()

static HRESULT WINAPI MediaControl_GetTypeInfoCount ( IMediaControl *  iface,
UINT *  count 
)
static

Definition at line 1712 of file filtergraph.c.

1713{
1714 TRACE("iface %p, count %p.\n", iface, count);
1715 *count = 1;
1716 return S_OK;
1717}

◆ MediaControl_Invoke()

static HRESULT WINAPI MediaControl_Invoke ( IMediaControl *  iface,
DISPID  id,
REFIID  iid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepinfo,
UINT *  error_arg 
)
static

Definition at line 1743 of file filtergraph.c.

1745{
1746 ITypeInfo *typeinfo;
1747 HRESULT hr;
1748
1749 TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
1750 iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
1751
1752 if (SUCCEEDED(hr = strmbase_get_typeinfo(IMediaControl_tid, &typeinfo)))
1753 {
1754 hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
1755 ITypeInfo_Release(typeinfo);
1756 }
1757 return hr;
1758}

◆ MediaControl_Pause()

static HRESULT WINAPI MediaControl_Pause ( IMediaControl *  iface)
static

Definition at line 1954 of file filtergraph.c.

1955{
1956 struct filter_graph *graph = impl_from_IMediaControl(iface);
1957
1958 TRACE("graph %p.\n", graph);
1959
1960 return IMediaFilter_Pause(&graph->IMediaFilter_iface);
1961}

◆ MediaControl_QueryInterface()

static HRESULT WINAPI MediaControl_QueryInterface ( IMediaControl *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 1693 of file filtergraph.c.

1694{
1695 struct filter_graph *graph = impl_from_IMediaControl(iface);
1696 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
1697}

◆ MediaControl_Release()

static ULONG WINAPI MediaControl_Release ( IMediaControl *  iface)
static

Definition at line 1705 of file filtergraph.c.

1706{
1707 struct filter_graph *graph = impl_from_IMediaControl(iface);
1708 return IUnknown_Release(graph->outer_unk);
1709
1710}

◆ MediaControl_RenderFile()

static HRESULT WINAPI MediaControl_RenderFile ( IMediaControl *  iface,
BSTR  strFilename 
)
static

Definition at line 1983 of file filtergraph.c.

1984{
1985 struct filter_graph *This = impl_from_IMediaControl(iface);
1986
1987 TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strFilename), strFilename);
1988
1989 return IFilterGraph2_RenderFile(&This->IFilterGraph2_iface, strFilename, NULL);
1990}

◆ MediaControl_Run()

static HRESULT WINAPI MediaControl_Run ( IMediaControl *  iface)
static

Definition at line 1882 of file filtergraph.c.

1883{
1884 struct filter_graph *graph = impl_from_IMediaControl(iface);
1885 BOOL need_async_run = TRUE;
1886 struct filter *filter;
1887 FILTER_STATE state;
1888 HRESULT hr = S_OK;
1889
1890 TRACE("graph %p.\n", graph);
1891
1892 EnterCriticalSection(&graph->cs);
1893
1894 if (graph->state == State_Running)
1895 {
1896 LeaveCriticalSection(&graph->cs);
1897 return S_OK;
1898 }
1899
1900 sort_filters(graph);
1901
1902 EnterCriticalSection(&graph->event_cs);
1903 update_render_count(graph);
1904 LeaveCriticalSection(&graph->event_cs);
1905
1906 if (graph->state == State_Stopped)
1907 {
1908 if (graph->defaultclock && !graph->refClock)
1909 IFilterGraph2_SetDefaultSyncSource(&graph->IFilterGraph2_iface);
1910
1911 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1912 {
1913 HRESULT filter_hr = IBaseFilter_Pause(filter->filter);
1914 if (hr == S_OK)
1915 hr = filter_hr;
1916 TRACE("Filter %p returned %#lx.\n", filter->filter, filter_hr);
1917
1918 /* If a filter returns VFW_S_CANT_CUE, we shouldn't wait for a
1919 * paused state. */
1920 filter_hr = IBaseFilter_GetState(filter->filter, 0, &state);
1921 if (filter_hr != S_OK && filter_hr != VFW_S_STATE_INTERMEDIATE)
1922 need_async_run = FALSE;
1923 }
1924
1925 if (FAILED(hr))
1926 {
1927 LeaveCriticalSection(&graph->cs);
1928 WARN("Failed to pause, hr %#lx.\n", hr);
1929 return hr;
1930 }
1931 }
1932
1933 graph->state = State_Running;
1934
1935 if (SUCCEEDED(hr))
1936 {
1937 if (hr != S_OK && need_async_run)
1938 {
1939 if (!graph->async_run_work)
1940 graph->async_run_work = CreateThreadpoolWork(async_run_cb, graph, NULL);
1941 graph->needs_async_run = 1;
1942 SubmitThreadpoolWork(graph->async_run_work);
1943 }
1944 else
1945 {
1946 hr = graph_start(graph, 0);
1947 }
1948 }
1949
1950 LeaveCriticalSection(&graph->cs);
1951 return hr;
1952}
async_run_cb
static void CALLBACK async_run_cb(TP_CALLBACK_INSTANCE *instance, void *context, TP_WORK *work)
Definition: filtergraph.c:1826
CreateThreadpoolWork
PTP_WORK WINAPI DECLSPEC_HOTPATCH CreateThreadpoolWork(PTP_WORK_CALLBACK callback, PVOID userdata, TP_CALLBACK_ENVIRON *environment)
Definition: threadpool.c:82
SubmitThreadpoolWork
WINBASEAPI VOID WINAPI SubmitThreadpoolWork(_Inout_ PTP_WORK pwk)

◆ MediaControl_Stop()

static HRESULT WINAPI MediaControl_Stop ( IMediaControl *  iface)
static

Definition at line 1963 of file filtergraph.c.

1964{
1965 struct filter_graph *graph = impl_from_IMediaControl(iface);
1966
1967 TRACE("graph %p.\n", graph);
1968
1969 return IMediaFilter_Stop(&graph->IMediaFilter_iface);
1970}

◆ MediaControl_StopWhenReady()

static HRESULT WINAPI MediaControl_StopWhenReady ( IMediaControl *  iface)
static

Definition at line 2050 of file filtergraph.c.

2051{
2052 struct filter_graph *graph = impl_from_IMediaControl(iface);
2053 HRESULT hr;
2054
2055 TRACE("graph %p.\n", graph);
2056
2057 /* Even if we are already stopped, we still pause. */
2058 hr = IMediaControl_Pause(iface);
2059 if (FAILED(hr))
2060 return hr;
2061 else if (hr == S_FALSE)
2062 {
2063 IMediaControl_AddRef(iface);
2064 TrySubmitThreadpoolCallback(wait_pause_cb, iface, NULL);
2065 return S_FALSE;
2066 }
2067
2068 hr = IMediaControl_Stop(iface);
2069 if (FAILED(hr))
2070 return hr;
2071 else if (hr == S_FALSE)
2072 {
2073 IMediaControl_AddRef(iface);
2074 TrySubmitThreadpoolCallback(wait_stop_cb, iface, NULL);
2075 return S_FALSE;
2076 }
2077
2078 return S_OK;
2079}
wait_pause_cb
static void CALLBACK wait_pause_cb(TP_CALLBACK_INSTANCE *instance, void *context)
Definition: filtergraph.c:2020
wait_stop_cb
static void CALLBACK wait_stop_cb(TP_CALLBACK_INSTANCE *instance, void *context)
Definition: filtergraph.c:2038
TrySubmitThreadpoolCallback
BOOL WINAPI DECLSPEC_HOTPATCH TrySubmitThreadpoolCallback(PTP_SIMPLE_CALLBACK callback, PVOID userdata, TP_CALLBACK_ENVIRON *environment)
Definition: threadpool.c:99

◆ MediaEvent_AddRef()

static ULONG WINAPI MediaEvent_AddRef ( IMediaEventEx *  iface)
static

Definition at line 4788 of file filtergraph.c.

4789{
4790 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4791 return IUnknown_AddRef(graph->outer_unk);
4792}
impl_from_IMediaEventEx
static struct filter_graph * impl_from_IMediaEventEx(IMediaEventEx *iface)
Definition: filtergraph.c:4777

◆ MediaEvent_CancelDefaultHandling()

static HRESULT WINAPI MediaEvent_CancelDefaultHandling ( IMediaEventEx *  iface,
LONG  lEvCode 
)
static

Definition at line 4911 of file filtergraph.c.

4912{
4913 struct filter_graph *This = impl_from_IMediaEventEx(iface);
4914
4915 TRACE("graph %p, code %#lx.\n", This, lEvCode);
4916
4917 if (lEvCode == EC_COMPLETE)
4918 This->HandleEcComplete = FALSE;
4919 else if (lEvCode == EC_REPAINT)
4920 This->HandleEcRepaint = FALSE;
4921 else if (lEvCode == EC_CLOCK_CHANGED)
4922 This->HandleEcClockChanged = FALSE;
4923 else
4924 return S_FALSE;
4925
4926 return S_OK;
4927}
EC_REPAINT
#define EC_REPAINT
Definition: evcode.h:36
EC_CLOCK_CHANGED
#define EC_CLOCK_CHANGED
Definition: evcode.h:15

◆ MediaEvent_FreeEventParams()

static HRESULT WINAPI MediaEvent_FreeEventParams ( IMediaEventEx *  iface,
LONG  code,
LONG_PTR  param1,
LONG_PTR  param2 
)
static

Definition at line 4947 of file filtergraph.c.

4949{
4950 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4951
4952 WARN("graph %p, code %#lx, param1 %Id, param2 %Id, stub!\n", graph, code, param1, param2);
4953
4954 return S_OK;
4955}
code
Definition: inflate.c:139

◆ MediaEvent_GetEvent()

static HRESULT WINAPI MediaEvent_GetEvent ( IMediaEventEx *  iface,
LONG *  code,
LONG_PTR *  param1,
LONG_PTR *  param2,
LONG  timeout 
)
static

Definition at line 4858 of file filtergraph.c.

4860{
4861 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4862 struct media_event *event;
4863 struct list *entry;
4864
4865 TRACE("graph %p, code %p, param1 %p, param2 %p, timeout %ld.\n", graph, code, param1, param2, timeout);
4866
4867 *code = 0;
4868
4869 if (WaitForSingleObject(graph->media_event_handle, timeout))
4870 return E_ABORT;
4871
4872 EnterCriticalSection(&graph->event_cs);
4873
4874 if (!(entry = list_head(&graph->media_events)))
4875 {
4876 ResetEvent(graph->media_event_handle);
4877 LeaveCriticalSection(&graph->event_cs);
4878 return E_ABORT;
4879 }
4880 event = LIST_ENTRY(entry, struct media_event, entry);
4881 list_remove(&event->entry);
4882 *code = event->code;
4883 *param1 = event->param1;
4884 *param2 = event->param2;
4885 free(event);
4886
4887 LeaveCriticalSection(&graph->event_cs);
4888 return S_OK;
4889}
E_ABORT
#define E_ABORT
Definition: winerror.h:3481

◆ MediaEvent_GetEventHandle()

static HRESULT WINAPI MediaEvent_GetEventHandle ( IMediaEventEx *  iface,
OAEVENT *  event 
)
static

Definition at line 4848 of file filtergraph.c.

4849{
4850 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4851
4852 TRACE("graph %p, event %p.\n", graph, event);
4853
4854 *event = (OAEVENT)graph->media_event_handle;
4855 return S_OK;
4856}
QuartzTypeLib::OAEVENT
LONG_PTR OAEVENT
Definition: control.idl:32

◆ MediaEvent_GetIDsOfNames()

static HRESULT WINAPI MediaEvent_GetIDsOfNames ( IMediaEventEx *  iface,
REFIID  iid,
LPOLESTR *  names,
UINT  count,
LCID  lcid,
DISPID *  ids 
)
static

Definition at line 4814 of file filtergraph.c.

4816{
4817 ITypeInfo *typeinfo;
4818 HRESULT hr;
4819
4820 TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
4821 iface, debugstr_guid(iid), names, count, lcid, ids);
4822
4823 if (SUCCEEDED(hr = strmbase_get_typeinfo(IMediaEvent_tid, &typeinfo)))
4824 {
4825 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
4826 ITypeInfo_Release(typeinfo);
4827 }
4828 return hr;
4829}
IMediaEvent_tid
@ IMediaEvent_tid
Definition: strmbase.h:228

◆ MediaEvent_GetNotifyFlags()

static HRESULT WINAPI MediaEvent_GetNotifyFlags ( IMediaEventEx *  iface,
LONG *  flags 
)
static

Definition at line 4995 of file filtergraph.c.

4996{
4997 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4998
4999 TRACE("graph %p, flags %p.\n", graph, flags);
5000
5001 if (!flags)
5002 return E_POINTER;
5003
5004 *flags = graph->media_events_disabled;
5005
5006 return S_OK;
5007}

◆ MediaEvent_GetTypeInfo()

static HRESULT WINAPI MediaEvent_GetTypeInfo ( IMediaEventEx *  iface,
UINT  index,
LCID  lcid,
ITypeInfo **  typeinfo 
)
static

Definition at line 4807 of file filtergraph.c.

4809{
4810 TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
4811 return strmbase_get_typeinfo(IMediaEvent_tid, typeinfo);
4812}

◆ MediaEvent_GetTypeInfoCount()

static HRESULT WINAPI MediaEvent_GetTypeInfoCount ( IMediaEventEx *  iface,
UINT *  count 
)
static

Definition at line 4800 of file filtergraph.c.

4801{
4802 TRACE("iface %p, count %p.\n", iface, count);
4803 *count = 1;
4804 return S_OK;
4805}

◆ MediaEvent_Invoke()

static HRESULT WINAPI MediaEvent_Invoke ( IMediaEventEx *  iface,
DISPID  id,
REFIID  iid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepinfo,
UINT *  error_arg 
)
static

Definition at line 4831 of file filtergraph.c.

4833{
4834 ITypeInfo *typeinfo;
4835 HRESULT hr;
4836
4837 TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
4838 iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
4839
4840 if (SUCCEEDED(hr = strmbase_get_typeinfo(IMediaEvent_tid, &typeinfo)))
4841 {
4842 hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
4843 ITypeInfo_Release(typeinfo);
4844 }
4845 return hr;
4846}

◆ MediaEvent_QueryInterface()

static HRESULT WINAPI MediaEvent_QueryInterface ( IMediaEventEx *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 4782 of file filtergraph.c.

4783{
4784 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4785 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
4786}

◆ MediaEvent_Release()

static ULONG WINAPI MediaEvent_Release ( IMediaEventEx *  iface)
static

Definition at line 4794 of file filtergraph.c.

4795{
4796 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4797 return IUnknown_Release(graph->outer_unk);
4798}

◆ MediaEvent_RestoreDefaultHandling()

static HRESULT WINAPI MediaEvent_RestoreDefaultHandling ( IMediaEventEx *  iface,
LONG  lEvCode 
)
static

Definition at line 4929 of file filtergraph.c.

4930{
4931 struct filter_graph *This = impl_from_IMediaEventEx(iface);
4932
4933 TRACE("graph %p, code %#lx.\n", This, lEvCode);
4934
4935 if (lEvCode == EC_COMPLETE)
4936 This->HandleEcComplete = TRUE;
4937 else if (lEvCode == EC_REPAINT)
4938 This->HandleEcRepaint = TRUE;
4939 else if (lEvCode == EC_CLOCK_CHANGED)
4940 This->HandleEcClockChanged = TRUE;
4941 else
4942 return S_FALSE;
4943
4944 return S_OK;
4945}

◆ MediaEvent_SetNotifyFlags()

static HRESULT WINAPI MediaEvent_SetNotifyFlags ( IMediaEventEx *  iface,
LONG  flags 
)
static

Definition at line 4972 of file filtergraph.c.

4973{
4974 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4975
4976 TRACE("graph %p, flags %#lx.\n", graph, flags);
4977
4978 if (flags & ~AM_MEDIAEVENT_NONOTIFY)
4979 {
4980 WARN("Invalid flags %#lx, returning E_INVALIDARG.\n", flags);
4981 return E_INVALIDARG;
4982 }
4983
4984 graph->media_events_disabled = flags;
4985
4986 if (flags)
4987 {
4988 flush_media_events(graph);
4989 ResetEvent(graph->media_event_handle);
4990 }
4991
4992 return S_OK;
4993}
AM_MEDIAEVENT_NONOTIFY
@ AM_MEDIAEVENT_NONOTIFY
Definition: axcore.idl:670

◆ MediaEvent_SetNotifyWindow()

static HRESULT WINAPI MediaEvent_SetNotifyWindow ( IMediaEventEx *  iface,
OAHWND  window,
LONG  message,
LONG_PTR  lparam 
)
static

Definition at line 4958 of file filtergraph.c.

4960{
4961 struct filter_graph *graph = impl_from_IMediaEventEx(iface);
4962
4963 TRACE("graph %p, window %#Ix, message %#lx, lparam %#Ix.\n", graph, window, message, lparam);
4964
4965 graph->media_event_window = (HWND)window;
4966 graph->media_event_message = message;
4967 graph->media_event_lparam = lparam;
4968
4969 return S_OK;
4970}
lparam
@ lparam
Definition: SystemMenu.c:31
HWND
HANDLE HWND
Definition: compat.h:19
window
static IHTMLWindow2 * window
Definition: events.c:77
message
Definition: tftpd.h:60

◆ MediaEvent_WaitForCompletion()

static HRESULT WINAPI MediaEvent_WaitForCompletion ( IMediaEventEx *  iface,
LONG  msTimeout,
LONG *  pEvCode 
)
static

Definition at line 4891 of file filtergraph.c.

4893{
4894 struct filter_graph *This = impl_from_IMediaEventEx(iface);
4895
4896 TRACE("graph %p, timeout %ld, code %p.\n", This, msTimeout, pEvCode);
4897
4898 if (This->state != State_Running)
4899 return VFW_E_WRONG_STATE;
4900
4901 if (WaitForSingleObject(This->hEventCompletion, msTimeout) == WAIT_OBJECT_0)
4902 {
4903 *pEvCode = This->CompletionStatus;
4904 return S_OK;
4905 }
4906
4907 *pEvCode = 0;
4908 return E_ABORT;
4909}
VFW_E_WRONG_STATE
#define VFW_E_WRONG_STATE
Definition: vfwmsgs.h:78
WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:383

◆ MediaEventSink_AddRef()

static ULONG WINAPI MediaEventSink_AddRef ( IMediaEventSink *  iface)
static

Definition at line 5370 of file filtergraph.c.

5371{
5372 struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5373
5374 return IUnknown_AddRef(graph->outer_unk);
5375}
impl_from_IMediaEventSink
static struct filter_graph * impl_from_IMediaEventSink(IMediaEventSink *iface)
Definition: filtergraph.c:5358

◆ MediaEventSink_Notify()

static HRESULT WINAPI MediaEventSink_Notify ( IMediaEventSink *  iface,
LONG  code,
LONG_PTR  param1,
LONG_PTR  param2 
)
static

Definition at line 5384 of file filtergraph.c.

5386{
5387 struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5388
5389 TRACE("graph %p, code %#lx, param1 %#Ix, param2 %#Ix.\n", graph, code, param1, param2);
5390
5391 EnterCriticalSection(&graph->event_cs);
5392
5393 if (code == EC_COMPLETE && graph->HandleEcComplete)
5394 {
5395 if (++graph->EcCompleteCount == graph->nRenderers)
5396 {
5397 if (graph->media_events_disabled)
5398 SetEvent(graph->media_event_handle);
5399 else
5400 queue_media_event(graph, EC_COMPLETE, S_OK, 0);
5401 graph->CompletionStatus = EC_COMPLETE;
5402 graph->got_ec_complete = 1;
5403 SetEvent(graph->hEventCompletion);
5404 }
5405 }
5406 else if ((code == EC_REPAINT) && graph->HandleEcRepaint)
5407 {
5408 FIXME("EC_REPAINT is not handled.\n");
5409 }
5410 else if (!graph->media_events_disabled)
5411 {
5412 queue_media_event(graph, code, param1, param2);
5413 }
5414
5415 LeaveCriticalSection(&graph->event_cs);
5416 return S_OK;
5417}
queue_media_event
static BOOL queue_media_event(struct filter_graph *graph, LONG code, LONG_PTR param1, LONG_PTR param2)
Definition: filtergraph.c:318
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:669

◆ MediaEventSink_QueryInterface()

static HRESULT WINAPI MediaEventSink_QueryInterface ( IMediaEventSink *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 5363 of file filtergraph.c.

5364{
5365 struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5366
5367 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5368}

◆ MediaEventSink_Release()

static ULONG WINAPI MediaEventSink_Release ( IMediaEventSink *  iface)
static

Definition at line 5377 of file filtergraph.c.

5378{
5379 struct filter_graph *graph = impl_from_IMediaEventSink(iface);
5380
5381 return IUnknown_Release(graph->outer_unk);
5382}

◆ MediaFilter_AddRef()

static ULONG WINAPI MediaFilter_AddRef ( IMediaFilter *  iface)
static

Definition at line 5043 of file filtergraph.c.

5044{
5045 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5046
5047 return IUnknown_AddRef(graph->outer_unk);
5048}
impl_from_IMediaFilter
static struct filter_graph * impl_from_IMediaFilter(IMediaFilter *iface)
Definition: filtergraph.c:5031

◆ MediaFilter_GetClassID()

static HRESULT WINAPI MediaFilter_GetClassID ( IMediaFilter *  iface,
CLSID *  pClassID 
)
static

Definition at line 5057 of file filtergraph.c.

5058{
5059 FIXME("(%p): stub\n", pClassID);
5060
5061 return E_NOTIMPL;
5062}

◆ MediaFilter_GetState()

static HRESULT WINAPI MediaFilter_GetState ( IMediaFilter *  iface,
DWORD  timeout,
FILTER_STATE *  state 
)
static

Definition at line 5196 of file filtergraph.c.

5197{
5198 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5199 DWORD end = GetTickCount() + timeout;
5200 HRESULT hr;
5201
5202 TRACE("graph %p, timeout %lu, state %p.\n", graph, timeout, state);
5203
5204 if (!state)
5205 return E_POINTER;
5206
5207 /* Thread safety is a little tricky here. GetState() shouldn't block other
5208 * functions from being called on the filter graph. However, we can't just
5209 * call IBaseFilter::GetState() in one loop and drop the lock on every
5210 * iteration, since the filter list might change beneath us. So instead we
5211 * do what native does, and poll for it every 10 ms. */
5212
5213 EnterCriticalSection(&graph->cs);
5214 *state = graph->state;
5215
5216 for (;;)
5217 {
5218 IBaseFilter *async_filter = NULL;
5219 FILTER_STATE filter_state;
5220 struct filter *filter;
5221
5222 hr = S_OK;
5223
5224 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5225 {
5226 HRESULT filter_hr = IBaseFilter_GetState(filter->filter, 0, &filter_state);
5227
5228 TRACE("Filter %p returned hr %#lx, state %u.\n", filter->filter, filter_hr, filter_state);
5229
5230 if (filter_hr == VFW_S_STATE_INTERMEDIATE)
5231 async_filter = filter->filter;
5232
5233 if (hr == S_OK && filter_hr == VFW_S_STATE_INTERMEDIATE)
5234 hr = VFW_S_STATE_INTERMEDIATE;
5235 else if (filter_hr != S_OK && filter_hr != VFW_S_STATE_INTERMEDIATE)
5236 hr = filter_hr;
5237
5238 if (hr == S_OK && filter_state == State_Paused && graph->state != State_Paused)
5239 {
5240 async_filter = filter->filter;
5241 hr = VFW_S_STATE_INTERMEDIATE;
5242 }
5243 else if (filter_state != graph->state && filter_state != State_Paused)
5244 hr = E_FAIL;
5245
5246 if (graph->needs_async_run)
5247 {
5248 if (filter_state != State_Paused && filter_state != State_Running)
5249 ERR("Filter %p reported incorrect state %u (expected %u or %u).\n",
5250 filter->filter, filter_state, State_Paused, State_Running);
5251 }
5252 else
5253 {
5254 if (filter_state != graph->state)
5255 ERR("Filter %p reported incorrect state %u (expected %u).\n",
5256 filter->filter, filter_state, graph->state);
5257 }
5258 }
5259
5260 LeaveCriticalSection(&graph->cs);
5261
5262 if (hr != VFW_S_STATE_INTERMEDIATE || (timeout != INFINITE && GetTickCount() >= end))
5263 break;
5264
5265 IBaseFilter_GetState(async_filter, 10, &filter_state);
5266
5267 EnterCriticalSection(&graph->cs);
5268 }
5269
5270 TRACE("Returning %#lx, state %u.\n", hr, *state);
5271 return hr;
5272}
GetTickCount
ULONG WINAPI DECLSPEC_HOTPATCH GetTickCount(void)
Definition: sync.c:182
end
GLuint GLuint end
Definition: gl.h:1545
filter_state
static DWORD filter_state
Definition: protocol.c:164

◆ MediaFilter_GetSyncSource()

static HRESULT WINAPI MediaFilter_GetSyncSource ( IMediaFilter *  iface,
IReferenceClock **  ppClock 
)
static

Definition at line 5324 of file filtergraph.c.

5325{
5326 struct filter_graph *This = impl_from_IMediaFilter(iface);
5327
5328 TRACE("(%p/%p)->(%p)\n", This, iface, ppClock);
5329
5330 if (!ppClock)
5331 return E_POINTER;
5332
5333 EnterCriticalSection(&This->cs);
5334 {
5335 *ppClock = This->refClock;
5336 if (*ppClock)
5337 IReferenceClock_AddRef(*ppClock);
5338 }
5339 LeaveCriticalSection(&This->cs);
5340
5341 return S_OK;
5342}

◆ MediaFilter_Pause()

static HRESULT WINAPI MediaFilter_Pause ( IMediaFilter *  iface)
static

Definition at line 5117 of file filtergraph.c.

5118{
5119 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5120 HRESULT hr = S_OK, filter_hr;
5121 struct filter *filter;
5122 TP_WORK *work;
5123
5124 TRACE("graph %p.\n", graph);
5125
5126 EnterCriticalSection(&graph->cs);
5127
5128 if (graph->state == State_Paused)
5129 {
5130 LeaveCriticalSection(&graph->cs);
5131 return S_OK;
5132 }
5133
5134 sort_filters(graph);
5135
5136 EnterCriticalSection(&graph->event_cs);
5137 update_render_count(graph);
5138 LeaveCriticalSection(&graph->event_cs);
5139
5140 if (graph->defaultclock && !graph->refClock)
5141 IFilterGraph2_SetDefaultSyncSource(&graph->IFilterGraph2_iface);
5142
5143 if (graph->state == State_Running && !graph->needs_async_run && graph->refClock)
5144 {
5145 REFERENCE_TIME time;
5146 IReferenceClock_GetTime(graph->refClock, &time);
5147 graph->stream_elapsed += time - graph->stream_start;
5148 graph->current_pos += graph->stream_elapsed;
5149 }
5150
5151 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5152 {
5153 filter_hr = IBaseFilter_Pause(filter->filter);
5154 if (hr == S_OK)
5155 hr = filter_hr;
5156 }
5157
5158 graph->state = State_Paused;
5159 graph->needs_async_run = 0;
5160 work = graph->async_run_work;
5161
5162 LeaveCriticalSection(&graph->cs);
5163
5164 if (work)
5165 WaitForThreadpoolWorkCallbacks(work, TRUE);
5166
5167 return hr;
5168}
time
__u16 time
Definition: mkdosfs.c:8
WaitForThreadpoolWorkCallbacks
WINBASEAPI VOID WINAPI WaitForThreadpoolWorkCallbacks(_Inout_ PTP_WORK pwk, _In_ BOOL fCancelPendingCallbacks)
TP_WORK
struct _TP_WORK TP_WORK
Definition: winnt_old.h:4758

◆ MediaFilter_QueryInterface()

static HRESULT WINAPI MediaFilter_QueryInterface ( IMediaFilter *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 5036 of file filtergraph.c.

5037{
5038 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5039
5040 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5041}

◆ MediaFilter_Release()

static ULONG WINAPI MediaFilter_Release ( IMediaFilter *  iface)
static

Definition at line 5050 of file filtergraph.c.

5051{
5052 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5053
5054 return IUnknown_Release(graph->outer_unk);
5055}

◆ MediaFilter_Run()

static HRESULT WINAPI MediaFilter_Run ( IMediaFilter *  iface,
REFERENCE_TIME  start 
)
static

Definition at line 5170 of file filtergraph.c.

5171{
5172 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5173 HRESULT hr;
5174
5175 TRACE("graph %p, start %s.\n", graph, debugstr_time(start));
5176
5177 EnterCriticalSection(&graph->cs);
5178
5179 if (graph->state == State_Running)
5180 {
5181 LeaveCriticalSection(&graph->cs);
5182 return S_OK;
5183 }
5184
5185 sort_filters(graph);
5186
5187 hr = graph_start(graph, start);
5188
5189 graph->state = State_Running;
5190 graph->needs_async_run = 0;
5191
5192 LeaveCriticalSection(&graph->cs);
5193 return hr;
5194}
start
GLuint start
Definition: gl.h:1545
debugstr_time
static const char * debugstr_time(REFERENCE_TIME time)
Definition: strmbase.h:32

◆ MediaFilter_SetSyncSource()

static HRESULT WINAPI MediaFilter_SetSyncSource ( IMediaFilter *  iface,
IReferenceClock *  pClock 
)
static

Definition at line 5274 of file filtergraph.c.

5275{
5276 struct filter_graph *This = impl_from_IMediaFilter(iface);
5277 struct filter *filter;
5278 HRESULT hr = S_OK;
5279
5280 TRACE("(%p/%p)->(%p)\n", This, iface, pClock);
5281
5282 EnterCriticalSection(&This->cs);
5283 {
5284 LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
5285 {
5286 hr = IBaseFilter_SetSyncSource(filter->filter, pClock);
5287 if (FAILED(hr))
5288 break;
5289 }
5290
5291 if (FAILED(hr))
5292 {
5293 LIST_FOR_EACH_ENTRY(filter, &This->filters, struct filter, entry)
5294 IBaseFilter_SetSyncSource(filter->filter, This->refClock);
5295 }
5296 else
5297 {
5298 if (This->refClock)
5299 IReferenceClock_Release(This->refClock);
5300 This->refClock = pClock;
5301 if (This->refClock)
5302 IReferenceClock_AddRef(This->refClock);
5303 This->defaultclock = FALSE;
5304
5305 if (This->HandleEcClockChanged)
5306 {
5307 IMediaEventSink *pEventSink;
5308 HRESULT eshr;
5309
5310 eshr = IMediaFilter_QueryInterface(iface, &IID_IMediaEventSink, (void **)&pEventSink);
5311 if (SUCCEEDED(eshr))
5312 {
5313 IMediaEventSink_Notify(pEventSink, EC_CLOCK_CHANGED, 0, 0);
5314 IMediaEventSink_Release(pEventSink);
5315 }
5316 }
5317 }
5318 }
5319 LeaveCriticalSection(&This->cs);
5320
5321 return hr;
5322}

◆ MediaFilter_Stop()

static HRESULT WINAPI MediaFilter_Stop ( IMediaFilter *  iface)
static

Definition at line 5064 of file filtergraph.c.

5065{
5066 struct filter_graph *graph = impl_from_IMediaFilter(iface);
5067 HRESULT hr = S_OK, filter_hr;
5068 struct filter *filter;
5069 TP_WORK *work;
5070
5071 TRACE("graph %p.\n", graph);
5072
5073 EnterCriticalSection(&graph->cs);
5074
5075 if (graph->state == State_Stopped)
5076 {
5077 LeaveCriticalSection(&graph->cs);
5078 return S_OK;
5079 }
5080
5081 sort_filters(graph);
5082
5083 if (graph->state == State_Running)
5084 {
5085 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5086 {
5087 filter_hr = IBaseFilter_Pause(filter->filter);
5088 if (hr == S_OK)
5089 hr = filter_hr;
5090 }
5091 }
5092
5093 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
5094 {
5095 filter_hr = IBaseFilter_Stop(filter->filter);
5096 if (hr == S_OK)
5097 hr = filter_hr;
5098 }
5099
5100 graph->state = State_Stopped;
5101 graph->needs_async_run = 0;
5102 work = graph->async_run_work;
5103 graph->got_ec_complete = 0;
5104
5105 /* Update the current position, probably to synchronize multiple streams. */
5106 IMediaSeeking_SetPositions(&graph->IMediaSeeking_iface, &graph->current_pos,
5107 AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
5108
5109 LeaveCriticalSection(&graph->cs);
5110
5111 if (work)
5112 WaitForThreadpoolWorkCallbacks(work, TRUE);
5113
5114 return hr;
5115}
AM_SEEKING_NoPositioning
@ AM_SEEKING_NoPositioning
Definition: axcore.idl:591
AM_SEEKING_AbsolutePositioning
@ AM_SEEKING_AbsolutePositioning
Definition: axcore.idl:592

◆ MediaPosition_AddRef()

static ULONG WINAPI MediaPosition_AddRef ( IMediaPosition *  iface)
static

Definition at line 2590 of file filtergraph.c.

2591{
2592 struct filter_graph *graph = impl_from_IMediaPosition(iface);
2593 return IUnknown_AddRef(graph->outer_unk);
2594}
impl_from_IMediaPosition
static struct filter_graph * impl_from_IMediaPosition(IMediaPosition *iface)
Definition: filtergraph.c:2578

◆ MediaPosition_CanSeekBackward()

static HRESULT WINAPI MediaPosition_CanSeekBackward ( IMediaPosition *  iface,
LONG *  pCanSeekBackward 
)
static

Definition at line 2775 of file filtergraph.c.

2776{
2777 FIXME("(%p)->(%p) stub!\n", iface, pCanSeekBackward);
2778 return E_NOTIMPL;
2779}

◆ MediaPosition_CanSeekForward()

static HRESULT WINAPI MediaPosition_CanSeekForward ( IMediaPosition *  iface,
LONG *  pCanSeekForward 
)
static

Definition at line 2769 of file filtergraph.c.

2770{
2771 FIXME("(%p)->(%p) stub!\n", iface, pCanSeekForward);
2772 return E_NOTIMPL;
2773}

◆ MediaPosition_get_CurrentPosition()

static HRESULT WINAPI MediaPosition_get_CurrentPosition ( IMediaPosition *  iface,
REFTIME *  pllTime 
)
static

Definition at line 2710 of file filtergraph.c.

2711{
2712 struct filter_graph *This = impl_from_IMediaPosition( iface );
2713 LONGLONG pos;
2714 HRESULT hr;
2715
2716 hr = IMediaSeeking_GetCurrentPosition(&This->IMediaSeeking_iface, &pos);
2717 if (FAILED(hr))
2718 return hr;
2719 return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2720}
ConvertToREFTIME
static HRESULT ConvertToREFTIME(IMediaSeeking *seek, LONGLONG time_in, REFTIME *time_out)
Definition: filtergraph.c:2668

◆ MediaPosition_get_Duration()

static HRESULT WINAPI MediaPosition_get_Duration ( IMediaPosition *  iface,
REFTIME *  plength 
)
static

Definition at line 2687 of file filtergraph.c.

2688{
2689 LONGLONG duration;
2690 struct filter_graph *This = impl_from_IMediaPosition( iface );
2691 HRESULT hr = IMediaSeeking_GetDuration(&This->IMediaSeeking_iface, &duration);
2692 if (FAILED(hr))
2693 return hr;
2694 return ConvertToREFTIME(&This->IMediaSeeking_iface, duration, plength);
2695}

◆ MediaPosition_get_PrerollTime()

static HRESULT WINAPI MediaPosition_get_PrerollTime ( IMediaPosition *  iface,
REFTIME *  pllTime 
)
static

Definition at line 2745 of file filtergraph.c.

2746{
2747 FIXME("(%p)->(%p) stub!\n", iface, pllTime);
2748 return E_NOTIMPL;
2749}

◆ MediaPosition_get_Rate()

static HRESULT WINAPI MediaPosition_get_Rate ( IMediaPosition *  iface,
double *  pdRate 
)
static

Definition at line 2763 of file filtergraph.c.

2764{
2765 struct filter_graph *This = impl_from_IMediaPosition( iface );
2766 return IMediaSeeking_GetRate(&This->IMediaSeeking_iface, pdRate);
2767}

◆ MediaPosition_get_StopTime()

static HRESULT WINAPI MediaPosition_get_StopTime ( IMediaPosition *  iface,
REFTIME *  pllTime 
)
static

Definition at line 2722 of file filtergraph.c.

2723{
2724 struct filter_graph *This = impl_from_IMediaPosition( iface );
2725 LONGLONG pos;
2726 HRESULT hr = IMediaSeeking_GetStopPosition(&This->IMediaSeeking_iface, &pos);
2727 if (FAILED(hr))
2728 return hr;
2729 return ConvertToREFTIME(&This->IMediaSeeking_iface, pos, pllTime);
2730}

◆ MediaPosition_GetIDsOfNames()

static HRESULT WINAPI MediaPosition_GetIDsOfNames ( IMediaPosition *  iface,
REFIID  iid,
LPOLESTR *  names,
UINT  count,
LCID  lcid,
DISPID *  ids 
)
static

Definition at line 2616 of file filtergraph.c.

2618{
2619 ITypeInfo *typeinfo;
2620 HRESULT hr;
2621
2622 TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
2623 iface, debugstr_guid(iid), names, count, lcid, ids);
2624
2625 if (SUCCEEDED(hr = strmbase_get_typeinfo(IMediaPosition_tid, &typeinfo)))
2626 {
2627 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
2628 ITypeInfo_Release(typeinfo);
2629 }
2630 return hr;
2631}
IMediaPosition_tid
@ IMediaPosition_tid
Definition: strmbase.h:229

◆ MediaPosition_GetTypeInfo()

static HRESULT WINAPI MediaPosition_GetTypeInfo ( IMediaPosition *  iface,
UINT  index,
LCID  lcid,
ITypeInfo **  typeinfo 
)
static

Definition at line 2609 of file filtergraph.c.

2611{
2612 TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
2613 return strmbase_get_typeinfo(IMediaPosition_tid, typeinfo);
2614}

◆ MediaPosition_GetTypeInfoCount()

static HRESULT WINAPI MediaPosition_GetTypeInfoCount ( IMediaPosition *  iface,
UINT *  count 
)
static

Definition at line 2602 of file filtergraph.c.

2603{
2604 TRACE("iface %p, count %p.\n", iface, count);
2605 *count = 1;
2606 return S_OK;
2607}

◆ MediaPosition_Invoke()

static HRESULT WINAPI MediaPosition_Invoke ( IMediaPosition *  iface,
DISPID  id,
REFIID  iid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepinfo,
UINT *  error_arg 
)
static

Definition at line 2633 of file filtergraph.c.

2635{
2636 ITypeInfo *typeinfo;
2637 HRESULT hr;
2638
2639 TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
2640 iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
2641
2642 if (SUCCEEDED(hr = strmbase_get_typeinfo(IMediaPosition_tid, &typeinfo)))
2643 {
2644 hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
2645 ITypeInfo_Release(typeinfo);
2646 }
2647 return hr;
2648}

◆ MediaPosition_put_CurrentPosition()

static HRESULT WINAPI MediaPosition_put_CurrentPosition ( IMediaPosition *  iface,
REFTIME  llTime 
)
static

Definition at line 2697 of file filtergraph.c.

2698{
2699 struct filter_graph *This = impl_from_IMediaPosition( iface );
2700 LONGLONG reftime;
2701 HRESULT hr;
2702
2703 hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2704 if (FAILED(hr))
2705 return hr;
2706 return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, &reftime,
2707 AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
2708}
ConvertFromREFTIME
static HRESULT ConvertFromREFTIME(IMediaSeeking *seek, REFTIME time_in, LONGLONG *time_out)
Definition: filtergraph.c:2650

◆ MediaPosition_put_PrerollTime()

static HRESULT WINAPI MediaPosition_put_PrerollTime ( IMediaPosition *  iface,
REFTIME  llTime 
)
static

Definition at line 2751 of file filtergraph.c.

2752{
2753 FIXME("(%p)->(%f) stub!\n", iface, llTime);
2754 return E_NOTIMPL;
2755}

◆ MediaPosition_put_Rate()

static HRESULT WINAPI MediaPosition_put_Rate ( IMediaPosition *  iface,
double  dRate 
)
static

Definition at line 2757 of file filtergraph.c.

2758{
2759 struct filter_graph *This = impl_from_IMediaPosition( iface );
2760 return IMediaSeeking_SetRate(&This->IMediaSeeking_iface, dRate);
2761}

◆ MediaPosition_put_StopTime()

static HRESULT WINAPI MediaPosition_put_StopTime ( IMediaPosition *  iface,
REFTIME  llTime 
)
static

Definition at line 2732 of file filtergraph.c.

2733{
2734 struct filter_graph *This = impl_from_IMediaPosition( iface );
2735 LONGLONG reftime;
2736 HRESULT hr;
2737
2738 hr = ConvertFromREFTIME(&This->IMediaSeeking_iface, llTime, &reftime);
2739 if (FAILED(hr))
2740 return hr;
2741 return IMediaSeeking_SetPositions(&This->IMediaSeeking_iface, NULL, AM_SEEKING_NoPositioning,
2742 &reftime, AM_SEEKING_AbsolutePositioning);
2743}

◆ MediaPosition_QueryInterface()

static HRESULT WINAPI MediaPosition_QueryInterface ( IMediaPosition *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 2584 of file filtergraph.c.

2585{
2586 struct filter_graph *graph = impl_from_IMediaPosition(iface);
2587 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2588}

◆ MediaPosition_Release()

static ULONG WINAPI MediaPosition_Release ( IMediaPosition *  iface)
static

Definition at line 2596 of file filtergraph.c.

2597{
2598 struct filter_graph *graph = impl_from_IMediaPosition(iface);
2599 return IUnknown_Release(graph->outer_unk);
2600}

◆ MediaSeeking_AddRef()

static ULONG WINAPI MediaSeeking_AddRef ( IMediaSeeking *  iface)
static

Definition at line 2113 of file filtergraph.c.

2114{
2115 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2116 return IUnknown_AddRef(graph->outer_unk);
2117}
impl_from_IMediaSeeking
static struct filter_graph * impl_from_IMediaSeeking(IMediaSeeking *iface)
Definition: filtergraph.c:2102

◆ MediaSeeking_CheckCapabilities()

static HRESULT WINAPI MediaSeeking_CheckCapabilities ( IMediaSeeking *  iface,
DWORD *  pCapabilities 
)
static

Definition at line 2184 of file filtergraph.c.

2185{
2186 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2187 DWORD originalcaps;
2188 HRESULT hr;
2189
2190 TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2191
2192 if (!pCapabilities)
2193 return E_POINTER;
2194
2195 EnterCriticalSection(&This->cs);
2196 originalcaps = *pCapabilities;
2197 hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2198 LeaveCriticalSection(&This->cs);
2199
2200 if (FAILED(hr))
2201 return hr;
2202
2203 if (!*pCapabilities)
2204 return E_FAIL;
2205 if (*pCapabilities != originalcaps)
2206 return S_FALSE;
2207 return S_OK;
2208}
FoundCapabilities
static HRESULT WINAPI FoundCapabilities(struct filter_graph *This, IMediaSeeking *seek, DWORD_PTR pcaps)
Definition: filtergraph.c:2149
all_renderers_seek
static HRESULT all_renderers_seek(struct filter_graph *This, fnFoundSeek FoundSeek, DWORD_PTR arg)
Definition: filtergraph.c:2127
DWORD_PTR
uint32_t DWORD_PTR
Definition: typedefs.h:65

◆ MediaSeeking_ConvertTimeFormat()

static HRESULT WINAPI MediaSeeking_ConvertTimeFormat ( IMediaSeeking *  iface,
LONGLONG *  pTarget,
const GUID *  pTargetFormat,
LONGLONG  Source,
const GUID *  pSourceFormat 
)
static

Definition at line 2401 of file filtergraph.c.

2403{
2404 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2405
2406 TRACE("(%p/%p)->(%p, %s, 0x%s, %s)\n", This, iface, pTarget,
2407 debugstr_guid(pTargetFormat), wine_dbgstr_longlong(Source), debugstr_guid(pSourceFormat));
2408
2409 if (!pSourceFormat)
2410 pSourceFormat = &This->timeformatseek;
2411
2412 if (!pTargetFormat)
2413 pTargetFormat = &This->timeformatseek;
2414
2415 if (IsEqualGUID(pTargetFormat, pSourceFormat))
2416 *pTarget = Source;
2417 else
2418 FIXME("conversion %s->%s not supported\n", debugstr_guid(pSourceFormat), debugstr_guid(pTargetFormat));
2419
2420 return S_OK;
2421}
wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
pTarget
FxIoTarget * pTarget
Definition: fxdeviceapi.cpp:97
Source
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3169

◆ MediaSeeking_GetAvailable()

static HRESULT WINAPI MediaSeeking_GetAvailable ( IMediaSeeking *  iface,
LONGLONG *  pEarliest,
LONGLONG *  pLatest 
)
static

Definition at line 2511 of file filtergraph.c.

2513{
2514 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2515
2516 FIXME("(%p/%p)->(%p, %p): stub !!!\n", This, iface, pEarliest, pLatest);
2517
2518 return S_OK;
2519}

◆ MediaSeeking_GetCapabilities()

static HRESULT WINAPI MediaSeeking_GetCapabilities ( IMediaSeeking *  iface,
DWORD *  pCapabilities 
)
static

Definition at line 2165 of file filtergraph.c.

2166{
2167 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2168 HRESULT hr;
2169
2170 TRACE("(%p/%p)->(%p)\n", This, iface, pCapabilities);
2171
2172 if (!pCapabilities)
2173 return E_POINTER;
2174
2175 EnterCriticalSection(&This->cs);
2176 *pCapabilities = 0xffffffff;
2177
2178 hr = all_renderers_seek(This, FoundCapabilities, (DWORD_PTR)pCapabilities);
2179 LeaveCriticalSection(&This->cs);
2180
2181 return hr;
2182}

◆ MediaSeeking_GetCurrentPosition()

static HRESULT WINAPI MediaSeeking_GetCurrentPosition ( IMediaSeeking *  iface,
LONGLONG *  current 
)
static

Definition at line 2369 of file filtergraph.c.

2370{
2371 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2372 LONGLONG ret = graph->current_pos;
2373
2374 TRACE("graph %p, current %p.\n", graph, current);
2375
2376 if (!current)
2377 return E_POINTER;
2378
2379 EnterCriticalSection(&graph->cs);
2380
2381 if (graph->got_ec_complete)
2382 {
2383 ret = graph->stream_stop;
2384 }
2385 else if (graph->state == State_Running && !graph->needs_async_run && graph->refClock)
2386 {
2387 REFERENCE_TIME time;
2388 IReferenceClock_GetTime(graph->refClock, &time);
2389 if (time)
2390 ret += time - graph->stream_start;
2391 }
2392
2393 LeaveCriticalSection(&graph->cs);
2394
2395 TRACE("Returning %s (%s seconds).\n", wine_dbgstr_longlong(ret), debugstr_time(ret));
2396 *current = ret;
2397
2398 return S_OK;
2399}
current
struct task_struct * current
Definition: linux.c:32

◆ MediaSeeking_GetDuration()

static HRESULT WINAPI MediaSeeking_GetDuration ( IMediaSeeking *  iface,
LONGLONG *  duration 
)
static

Definition at line 2286 of file filtergraph.c.

2287{
2288 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2289 HRESULT hr = E_NOTIMPL, filter_hr;
2290 LONGLONG filter_duration;
2291 struct filter *filter;
2292
2293 TRACE("graph %p, duration %p.\n", graph, duration);
2294
2295 if (!duration)
2296 return E_POINTER;
2297
2298 *duration = 0;
2299
2300 EnterCriticalSection(&graph->cs);
2301
2302 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
2303 {
2304 update_seeking(filter);
2305 if (!filter->seeking)
2306 continue;
2307
2308 filter_hr = IMediaSeeking_GetDuration(filter->seeking, &filter_duration);
2309 if (SUCCEEDED(filter_hr))
2310 {
2311 hr = S_OK;
2312 *duration = max(*duration, filter_duration);
2313 }
2314 else if (filter_hr != E_NOTIMPL)
2315 {
2316 LeaveCriticalSection(&graph->cs);
2317 return filter_hr;
2318 }
2319 }
2320
2321 LeaveCriticalSection(&graph->cs);
2322
2323 TRACE("Returning hr %#lx, duration %s (%s seconds).\n", hr,
2324 wine_dbgstr_longlong(*duration), debugstr_time(*duration));
2325 return hr;
2326}
max
#define max(a, b)
Definition: svc.c:63

◆ MediaSeeking_GetPositions()

static HRESULT WINAPI MediaSeeking_GetPositions ( IMediaSeeking *  iface,
LONGLONG *  current,
LONGLONG *  stop 
)
static

Definition at line 2495 of file filtergraph.c.

2497{
2498 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2499 HRESULT hr = S_OK;
2500
2501 TRACE("graph %p, current %p, stop %p.\n", graph, current, stop);
2502
2503 if (current)
2504 hr = IMediaSeeking_GetCurrentPosition(iface, current);
2505 if (SUCCEEDED(hr) && stop)
2506 hr = IMediaSeeking_GetStopPosition(iface, stop);
2507
2508 return hr;
2509}

◆ MediaSeeking_GetPreroll()

static HRESULT WINAPI MediaSeeking_GetPreroll ( IMediaSeeking *  iface,
LONGLONG *  pllPreroll 
)
static

Definition at line 2544 of file filtergraph.c.

2545{
2546 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2547
2548 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pllPreroll);
2549
2550 return S_OK;
2551}

◆ MediaSeeking_GetRate()

static HRESULT WINAPI MediaSeeking_GetRate ( IMediaSeeking *  iface,
double *  pdRate 
)
static

Definition at line 2530 of file filtergraph.c.

2531{
2532 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2533
2534 FIXME("(%p/%p)->(%p): stub !!!\n", This, iface, pdRate);
2535
2536 if (!pdRate)
2537 return E_POINTER;
2538
2539 *pdRate = 1.0;
2540
2541 return S_OK;
2542}

◆ MediaSeeking_GetStopPosition()

static HRESULT WINAPI MediaSeeking_GetStopPosition ( IMediaSeeking *  iface,
LONGLONG *  stop 
)
static

Definition at line 2328 of file filtergraph.c.

2329{
2330 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2331 HRESULT hr = E_NOTIMPL, filter_hr;
2332 struct filter *filter;
2333 LONGLONG filter_stop;
2334
2335 TRACE("graph %p, stop %p.\n", graph, stop);
2336
2337 if (!stop)
2338 return E_POINTER;
2339
2340 *stop = 0;
2341
2342 EnterCriticalSection(&graph->cs);
2343
2344 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
2345 {
2346 update_seeking(filter);
2347 if (!filter->seeking)
2348 continue;
2349
2350 filter_hr = IMediaSeeking_GetStopPosition(filter->seeking, &filter_stop);
2351 if (SUCCEEDED(filter_hr))
2352 {
2353 hr = S_OK;
2354 *stop = max(*stop, filter_stop);
2355 }
2356 else if (filter_hr != E_NOTIMPL)
2357 {
2358 LeaveCriticalSection(&graph->cs);
2359 return filter_hr;
2360 }
2361 }
2362
2363 LeaveCriticalSection(&graph->cs);
2364
2365 TRACE("Returning %s (%s seconds).\n", wine_dbgstr_longlong(*stop), debugstr_time(*stop));
2366 return hr;
2367}

◆ MediaSeeking_GetTimeFormat()

static HRESULT WINAPI MediaSeeking_GetTimeFormat ( IMediaSeeking *  iface,
GUID *  pFormat 
)
static

Definition at line 2241 of file filtergraph.c.

2242{
2243 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2244
2245 if (!pFormat)
2246 return E_POINTER;
2247
2248 TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2249 memcpy(pFormat, &This->timeformatseek, sizeof(GUID));
2250
2251 return S_OK;
2252}
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by ConvertFromREFTIME(), and ConvertToREFTIME().

◆ MediaSeeking_IsFormatSupported()

static HRESULT WINAPI MediaSeeking_IsFormatSupported ( IMediaSeeking *  iface,
const GUID *  pFormat 
)
static

Definition at line 2210 of file filtergraph.c.

2211{
2212 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2213
2214 if (!pFormat)
2215 return E_POINTER;
2216
2217 TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2218
2219 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2220 {
2221 WARN("Unhandled time format %s\n", debugstr_guid(pFormat));
2222 return S_FALSE;
2223 }
2224
2225 return S_OK;
2226}

◆ MediaSeeking_IsUsingTimeFormat()

static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat ( IMediaSeeking *  iface,
const GUID *  pFormat 
)
static

Definition at line 2254 of file filtergraph.c.

2255{
2256 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2257
2258 TRACE("(%p/%p)->(%p)\n", This, iface, pFormat);
2259 if (!pFormat)
2260 return E_POINTER;
2261
2262 if (memcmp(pFormat, &This->timeformatseek, sizeof(GUID)))
2263 return S_FALSE;
2264
2265 return S_OK;
2266}
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2807

◆ MediaSeeking_QueryInterface()

static HRESULT WINAPI MediaSeeking_QueryInterface ( IMediaSeeking *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 2107 of file filtergraph.c.

2108{
2109 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2110 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2111}

◆ MediaSeeking_QueryPreferredFormat()

static HRESULT WINAPI MediaSeeking_QueryPreferredFormat ( IMediaSeeking *  iface,
GUID *  pFormat 
)
static

Definition at line 2228 of file filtergraph.c.

2229{
2230 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2231
2232 if (!pFormat)
2233 return E_POINTER;
2234
2235 FIXME("(%p/%p)->(%p): semi-stub !!!\n", This, iface, pFormat);
2236 memcpy(pFormat, &TIME_FORMAT_MEDIA_TIME, sizeof(GUID));
2237
2238 return S_OK;
2239}

◆ MediaSeeking_Release()

static ULONG WINAPI MediaSeeking_Release ( IMediaSeeking *  iface)
static

Definition at line 2119 of file filtergraph.c.

2120{
2121 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2122 return IUnknown_Release(graph->outer_unk);
2123}

◆ MediaSeeking_SetPositions()

static HRESULT WINAPI MediaSeeking_SetPositions ( IMediaSeeking *  iface,
LONGLONG *  current_ptr,
DWORD  current_flags,
LONGLONG *  stop_ptr,
DWORD  stop_flags 
)
static

Definition at line 2423 of file filtergraph.c.

2425{
2426 struct filter_graph *graph = impl_from_IMediaSeeking(iface);
2427 HRESULT hr = E_NOTIMPL, filter_hr;
2428 struct filter *filter;
2429 FILTER_STATE state;
2430
2431 TRACE("graph %p, current %s, current_flags %#lx, stop %s, stop_flags %#lx.\n", graph,
2432 current_ptr ? wine_dbgstr_longlong(*current_ptr) : "<null>", current_flags,
2433 stop_ptr ? wine_dbgstr_longlong(*stop_ptr): "<null>", stop_flags);
2434 if (current_ptr)
2435 TRACE("Setting current position to %s (%s seconds).\n",
2436 wine_dbgstr_longlong(*current_ptr), debugstr_time(*current_ptr));
2437 if (stop_ptr)
2438 TRACE("Setting stop position to %s (%s seconds).\n",
2439 wine_dbgstr_longlong(*stop_ptr), debugstr_time(*stop_ptr));
2440
2441 if ((current_flags & 0x7) != AM_SEEKING_AbsolutePositioning
2442 && (current_flags & 0x7) != AM_SEEKING_NoPositioning)
2443 FIXME("Unhandled current_flags %#lx.\n", current_flags & 0x7);
2444
2445 if ((stop_flags & 0x7) != AM_SEEKING_NoPositioning
2446 && (stop_flags & 0x7) != AM_SEEKING_AbsolutePositioning)
2447 FIXME("Unhandled stop_flags %#lx.\n", stop_flags & 0x7);
2448
2449 EnterCriticalSection(&graph->cs);
2450
2451 state = graph->state;
2452 if (state == State_Running && !graph->needs_async_run)
2453 IMediaControl_Pause(&graph->IMediaControl_iface);
2454
2455 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
2456 {
2457 LONGLONG current = current_ptr ? *current_ptr : 0, stop = stop_ptr ? *stop_ptr : 0;
2458
2459 update_seeking(filter);
2460 if (!filter->seeking)
2461 continue;
2462
2463 filter_hr = IMediaSeeking_SetPositions(filter->seeking, &current,
2464 current_flags | AM_SEEKING_ReturnTime, &stop, stop_flags);
2465 if (SUCCEEDED(filter_hr))
2466 {
2467 hr = S_OK;
2468
2469 if (current_ptr && (current_flags & AM_SEEKING_ReturnTime))
2470 *current_ptr = current;
2471 if (stop_ptr && (stop_flags & AM_SEEKING_ReturnTime))
2472 *stop_ptr = stop;
2473 graph->current_pos = current;
2474 }
2475 else if (filter_hr != E_NOTIMPL)
2476 {
2477 LeaveCriticalSection(&graph->cs);
2478 return filter_hr;
2479 }
2480 }
2481
2482 if ((current_flags & 0x7) != AM_SEEKING_NoPositioning && graph->refClock)
2483 {
2484 IReferenceClock_GetTime(graph->refClock, &graph->stream_start);
2485 graph->stream_elapsed = 0;
2486 }
2487
2488 if (state == State_Running && !graph->needs_async_run)
2489 IMediaControl_Run(&graph->IMediaControl_iface);
2490
2491 LeaveCriticalSection(&graph->cs);
2492 return hr;
2493}
AM_SEEKING_ReturnTime
@ AM_SEEKING_ReturnTime
Definition: axcore.idl:597

◆ MediaSeeking_SetRate()

static HRESULT WINAPI MediaSeeking_SetRate ( IMediaSeeking *  iface,
double  dRate 
)
static

Definition at line 2521 of file filtergraph.c.

2522{
2523 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2524
2525 FIXME("(%p/%p)->(%f): stub !!!\n", This, iface, dRate);
2526
2527 return S_OK;
2528}

◆ MediaSeeking_SetTimeFormat()

static HRESULT WINAPI MediaSeeking_SetTimeFormat ( IMediaSeeking *  iface,
const GUID *  pFormat 
)
static

Definition at line 2268 of file filtergraph.c.

2269{
2270 struct filter_graph *This = impl_from_IMediaSeeking(iface);
2271
2272 if (!pFormat)
2273 return E_POINTER;
2274
2275 TRACE("(%p/%p)->(%s)\n", This, iface, debugstr_guid(pFormat));
2276
2277 if (!IsEqualGUID(&TIME_FORMAT_MEDIA_TIME, pFormat))
2278 {
2279 FIXME("Unhandled time format %s\n", debugstr_guid(pFormat));
2280 return E_INVALIDARG;
2281 }
2282
2283 return S_OK;
2284}

◆ message_thread_run()

static DWORD WINAPI message_thread_run ( void *  ctx)
static

Definition at line 1032 of file filtergraph.c.

1033{
1034 MSG msg;
1035
1036 SetThreadDescription(GetCurrentThread(), L"wine_qz_graph_worker");
1037
1038 /* Make sure we have a message queue. */
1039 PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
1040 SetEvent(message_thread_ret);
1041
1042 CoInitializeEx(NULL, COINIT_MULTITHREADED);
1043
1044 for (;;)
1045 {
1046 GetMessageW(&msg, NULL, 0, 0);
1047
1048 if (!msg.hwnd && msg.message == WM_USER)
1049 {
1050 struct filter_create_params *params = (struct filter_create_params *)msg.wParam;
1051
1052 params->hr = IMoniker_BindToObject(params->moniker, NULL, NULL,
1053 &IID_IBaseFilter, (void **)&params->filter);
1054 SetEvent(message_thread_ret);
1055 }
1056 else if (!msg.hwnd && msg.message == WM_USER + 1)
1057 {
1058 break;
1059 }
1060 else
1061 {
1062 TranslateMessage(&msg);
1063 DispatchMessageW(&msg);
1064 }
1065 }
1066
1067 CoUninitialize();
1068 return 0;
1069}
SetThreadDescription
HRESULT WINAPI DECLSPEC_HOTPATCH SetThreadDescription(_In_ HANDLE hThread, _In_ PCWSTR lpThreadDescription)
Definition: ThreadDescription.c:79
msg
#define msg(x)
Definition: auth_time.c:54
CoInitializeEx
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(void *reserved, DWORD model)
Definition: combase.c:2803
CoUninitialize
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: combase.c:2842
COINIT_MULTITHREADED
@ COINIT_MULTITHREADED
Definition: objbase.h:280
TranslateMessage
BOOL WINAPI TranslateMessage(_In_ const MSG *)
GetMessageW
BOOL WINAPI GetMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT)
PeekMessageW
BOOL WINAPI PeekMessageW(_Out_ LPMSG, _In_opt_ HWND, _In_ UINT, _In_ UINT, _In_ UINT)
DispatchMessageW
LRESULT WINAPI DispatchMessageW(_In_ const MSG *)
PM_NOREMOVE
#define PM_NOREMOVE
Definition: winuser.h:1206
MSG
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
GetCurrentThread
HANDLE WINAPI GetCurrentThread(void)
Definition: proc.c:1195

Referenced by filter_graph_common_create().

◆ ObjectWithSite_AddRef()

static ULONG WINAPI ObjectWithSite_AddRef ( IObjectWithSite *  iface)
static

Definition at line 2816 of file filtergraph.c.

2817{
2818 struct filter_graph *graph = impl_from_IObjectWithSite(iface);
2819 return IUnknown_AddRef(graph->outer_unk);
2820}
impl_from_IObjectWithSite
static struct filter_graph * impl_from_IObjectWithSite(IObjectWithSite *iface)
Definition: filtergraph.c:2804

◆ ObjectWithSite_GetSite()

static HRESULT WINAPI ObjectWithSite_GetSite ( IObjectWithSite *  iface,
REFIID  riid,
PVOID *  ppvSite 
)
static

Definition at line 2841 of file filtergraph.c.

2842{
2843 struct filter_graph *This = impl_from_IObjectWithSite( iface );
2844
2845 TRACE("(%p/%p)->(%s)\n", This, iface,debugstr_guid(riid));
2846
2847 *ppvSite = NULL;
2848 if (!This->pSite)
2849 return E_FAIL;
2850 else
2851 return IUnknown_QueryInterface(This->pSite, riid, ppvSite);
2852}

◆ ObjectWithSite_QueryInterface()

static HRESULT WINAPI ObjectWithSite_QueryInterface ( IObjectWithSite *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 2810 of file filtergraph.c.

2811{
2812 struct filter_graph *graph = impl_from_IObjectWithSite(iface);
2813 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
2814}

◆ ObjectWithSite_Release()

static ULONG WINAPI ObjectWithSite_Release ( IObjectWithSite *  iface)
static

Definition at line 2822 of file filtergraph.c.

2823{
2824 struct filter_graph *graph = impl_from_IObjectWithSite(iface);
2825 return IUnknown_Release(graph->outer_unk);
2826}

◆ ObjectWithSite_SetSite()

static HRESULT WINAPI ObjectWithSite_SetSite ( IObjectWithSite *  iface,
IUnknown *  pUnkSite 
)
static

Definition at line 2830 of file filtergraph.c.

2831{
2832 struct filter_graph *This = impl_from_IObjectWithSite( iface );
2833
2834 TRACE("(%p/%p)->()\n", This, iface);
2835 if (This->pSite) IUnknown_Release(This->pSite);
2836 This->pSite = pUnkSite;
2837 IUnknown_AddRef(This->pSite);
2838 return S_OK;
2839}

◆ queue_media_event()

static BOOL queue_media_event ( struct filter_graph *  graph,
LONG  code,
LONG_PTR  param1,
LONG_PTR  param2 
)
static

Definition at line 318 of file filtergraph.c.

320{
321 struct media_event *event;
322
323 if (!(event = malloc(sizeof(*event))))
324 return FALSE;
325
326 event->code = code;
327 event->param1 = param1;
328 event->param2 = param2;
329 list_add_tail(&graph->media_events, &event->entry);
330
331 SetEvent(graph->media_event_handle);
332 if (graph->media_event_window)
333 PostMessageW(graph->media_event_window, graph->media_event_message, 0, graph->media_event_lparam);
334
335 return TRUE;
336}
list_add_tail
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
PostMessageW
BOOL WINAPI PostMessageW(_In_opt_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
media_event::param2
LONG_PTR param2
Definition: filtergraph.c:62
media_event::param1
LONG_PTR param1
Definition: filtergraph.c:62
media_event::code
LONG code
Definition: filtergraph.c:61

Referenced by MediaEventSink_Notify().

◆ sort_filter_recurse()

static void sort_filter_recurse ( struct filter_graph *  graph,
struct filter *  filter,
struct list *  sorted 
)
static

Definition at line 867 of file filtergraph.c.

868{
869 struct filter *peer_filter;
870 IEnumPins *enumpins;
871 PIN_DIRECTION dir;
872 IPin *pin, *peer;
873 PIN_INFO info;
874
875 TRACE("Sorting filter %p.\n", filter->filter);
876
877 /* Cyclic connections should be caught by check_cyclic_connection(). */
878 assert(!filter->sorting);
879
880 filter->sorting = TRUE;
881
882 IBaseFilter_EnumPins(filter->filter, &enumpins);
883 while (IEnumPins_Next(enumpins, 1, &pin, NULL) == S_OK)
884 {
885 IPin_QueryDirection(pin, &dir);
886
887 if (dir == PINDIR_INPUT && IPin_ConnectedTo(pin, &peer) == S_OK)
888 {
889 IPin_QueryPinInfo(peer, &info);
890 /* Note that the filter may have already been sorted. */
891 if ((peer_filter = find_sorted_filter(graph, info.pFilter)))
892 sort_filter_recurse(graph, peer_filter, sorted);
893 IBaseFilter_Release(info.pFilter);
894 IPin_Release(peer);
895 }
896 IPin_Release(pin);
897 }
898 IEnumPins_Release(enumpins);
899
900 filter->sorting = FALSE;
901
902 list_remove(&filter->entry);
903 list_add_head(sorted, &filter->entry);
904}
find_sorted_filter
static struct filter * find_sorted_filter(struct filter_graph *graph, IBaseFilter *iface)
Definition: filtergraph.c:854
sort_filter_recurse
static void sort_filter_recurse(struct filter_graph *graph, struct filter *filter, struct list *sorted)
Definition: filtergraph.c:867
assert
#define assert(_expr)
Definition: assert.h:32
filter::sorting
BOOL sorting
Definition: filtergraph.c:78
filter::entry
struct list entry
Definition: filtergraph.c:74

Referenced by sort_filter_recurse(), and sort_filters().

◆ sort_filters()

static void sort_filters ( struct filter_graph *  graph)
static

Definition at line 906 of file filtergraph.c.

907{
908 struct list sorted = LIST_INIT(sorted), *cursor;
909
910 while ((cursor = list_head(&graph->filters)))
911 {
912 struct filter *filter = LIST_ENTRY(cursor, struct filter, entry);
913 sort_filter_recurse(graph, filter, &sorted);
914 }
915
916 list_move_tail(&graph->filters, &sorted);
917}
list_move_tail
static void list_move_tail(struct list_head *list, struct list_head *head)
Definition: list.h:122
LIST_INIT
#define LIST_INIT(head)
Definition: queue.h:197

Referenced by async_run_cb(), MediaControl_Run(), MediaFilter_Pause(), MediaFilter_Run(), and MediaFilter_Stop().

◆ update_render_count()

static void update_render_count ( struct filter_graph *  graph)
static

Definition at line 1760 of file filtergraph.c.

1761{
1762 /* Some filters (e.g. MediaStreamFilter) can become renderers when they are
1763 * already in the graph. */
1764 struct filter *filter;
1765 graph->nRenderers = 0;
1766 LIST_FOR_EACH_ENTRY(filter, &graph->filters, struct filter, entry)
1767 {
1768 if (is_renderer(filter))
1769 ++graph->nRenderers;
1770 }
1771}
is_renderer
static BOOL is_renderer(struct filter *filter)
Definition: filtergraph.c:580

Referenced by graph_start(), MediaControl_Run(), and MediaFilter_Pause().

◆ update_seeking()

static void update_seeking ( struct filter *  filter)
static

Definition at line 558 of file filtergraph.c.

559{
560 IMediaSeeking *seeking;
561
562 if (!filter->seeking)
563 {
564 /* The Legend of Heroes: Trails of Cold Steel II destroys its filter when
565 * its IMediaSeeking interface is released, so cache the interface instead
566 * of querying for it every time.
567 * Some filters (e.g. MediaStreamFilter) can become seekable when they are
568 * already in the graph, so always try to query IMediaSeeking if it's not
569 * cached yet. */
570 if (SUCCEEDED(IBaseFilter_QueryInterface(filter->filter, &IID_IMediaSeeking, (void **)&seeking)))
571 {
572 if (IMediaSeeking_IsFormatSupported(seeking, &TIME_FORMAT_MEDIA_TIME) == S_OK)
573 filter->seeking = seeking;
574 else
575 IMediaSeeking_Release(seeking);
576 }
577 }
578}

Referenced by all_renderers_seek(), is_renderer(), MediaSeeking_GetDuration(), MediaSeeking_GetStopPosition(), and MediaSeeking_SetPositions().

◆ VideoFrameStep_AddRef()

static ULONG WINAPI VideoFrameStep_AddRef ( IVideoFrameStep *  iface)
static

Definition at line 5635 of file filtergraph.c.

5636{
5637 struct filter_graph *graph = impl_from_IVideoFrameStep(iface);
5638 return IUnknown_AddRef(graph->outer_unk);
5639}
impl_from_IVideoFrameStep
static struct filter_graph * impl_from_IVideoFrameStep(IVideoFrameStep *iface)
Definition: filtergraph.c:5624

◆ VideoFrameStep_CancelStep()

static HRESULT WINAPI VideoFrameStep_CancelStep ( IVideoFrameStep *  iface)
static

Definition at line 5659 of file filtergraph.c.

5660{
5661 FIXME("iface %p, stub!\n", iface);
5662 return E_NOTIMPL;
5663}

◆ VideoFrameStep_CanStep()

static HRESULT WINAPI VideoFrameStep_CanStep ( IVideoFrameStep *  iface,
LONG  multiple,
IUnknown *  filter 
)
static

Definition at line 5653 of file filtergraph.c.

5654{
5655 FIXME("iface %p, multiple %ld, filter %p, stub!\n", iface, multiple, filter);
5656 return E_NOTIMPL;
5657}

◆ VideoFrameStep_QueryInterface()

static HRESULT WINAPI VideoFrameStep_QueryInterface ( IVideoFrameStep *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 5629 of file filtergraph.c.

5630{
5631 struct filter_graph *graph = impl_from_IVideoFrameStep(iface);
5632 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
5633}

◆ VideoFrameStep_Release()

static ULONG WINAPI VideoFrameStep_Release ( IVideoFrameStep *  iface)
static

Definition at line 5641 of file filtergraph.c.

5642{
5643 struct filter_graph *graph = impl_from_IVideoFrameStep(iface);
5644 return IUnknown_Release(graph->outer_unk);
5645}

◆ VideoFrameStep_Step()

static HRESULT WINAPI VideoFrameStep_Step ( IVideoFrameStep *  iface,
DWORD  frame_count,
IUnknown *  filter 
)
static

Definition at line 5647 of file filtergraph.c.

5648{
5649 FIXME("iface %p, frame_count %lu, filter %p, stub!\n", iface, frame_count, filter);
5650 return E_NOTIMPL;
5651}

◆ VideoWindow_AddRef()

static ULONG WINAPI VideoWindow_AddRef ( IVideoWindow *  iface)
static

Definition at line 3871 of file filtergraph.c.

3872{
3873 struct filter_graph *graph = impl_from_IVideoWindow(iface);
3874 return IUnknown_AddRef(graph->outer_unk);
3875}
impl_from_IVideoWindow
static struct filter_graph * impl_from_IVideoWindow(IVideoWindow *iface)
Definition: filtergraph.c:3860

◆ VideoWindow_get_AutoShow()

static HRESULT WINAPI VideoWindow_get_AutoShow ( IVideoWindow *  iface,
LONG *  AutoShow 
)
static

Definition at line 4072 of file filtergraph.c.

4073{
4074 struct filter_graph *This = impl_from_IVideoWindow(iface);
4075 IVideoWindow *pVideoWindow;
4076 HRESULT hr;
4077
4078 TRACE("(%p/%p)->(%p)\n", This, iface, AutoShow);
4079
4080 EnterCriticalSection(&This->cs);
4081
4082 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4083
4084 if (hr == S_OK)
4085 hr = IVideoWindow_get_AutoShow(pVideoWindow, AutoShow);
4086
4087 LeaveCriticalSection(&This->cs);
4088
4089 return hr;
4090}

◆ VideoWindow_get_BackgroundPalette()

static HRESULT WINAPI VideoWindow_get_BackgroundPalette ( IVideoWindow *  iface,
LONG *  pBackgroundPalette 
)
static

Definition at line 4152 of file filtergraph.c.

4154{
4155 struct filter_graph *This = impl_from_IVideoWindow(iface);
4156 IVideoWindow *pVideoWindow;
4157 HRESULT hr;
4158
4159 TRACE("(%p/%p)->(%p)\n", This, iface, pBackgroundPalette);
4160
4161 EnterCriticalSection(&This->cs);
4162
4163 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4164
4165 if (hr == S_OK)
4166 hr = IVideoWindow_get_BackgroundPalette(pVideoWindow, pBackgroundPalette);
4167
4168 LeaveCriticalSection(&This->cs);
4169
4170 return hr;
4171}

◆ VideoWindow_get_BorderColor()

static HRESULT WINAPI VideoWindow_get_BorderColor ( IVideoWindow *  iface,
LONG *  Color 
)
static

Definition at line 4453 of file filtergraph.c.

4454{
4455 struct filter_graph *This = impl_from_IVideoWindow(iface);
4456 IVideoWindow *pVideoWindow;
4457 HRESULT hr;
4458
4459 TRACE("(%p/%p)->(%p)\n", This, iface, Color);
4460
4461 EnterCriticalSection(&This->cs);
4462
4463 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4464
4465 if (hr == S_OK)
4466 hr = IVideoWindow_get_BorderColor(pVideoWindow, Color);
4467
4468 LeaveCriticalSection(&This->cs);
4469
4470 return hr;
4471}

◆ VideoWindow_get_Caption()

static HRESULT WINAPI VideoWindow_get_Caption ( IVideoWindow *  iface,
BSTR *  strCaption 
)
static

Definition at line 3952 of file filtergraph.c.

3953{
3954 struct filter_graph *This = impl_from_IVideoWindow(iface);
3955 IVideoWindow *pVideoWindow;
3956 HRESULT hr;
3957
3958 TRACE("(%p/%p)->(%p)\n", This, iface, strCaption);
3959
3960 EnterCriticalSection(&This->cs);
3961
3962 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3963
3964 if (hr == S_OK)
3965 hr = IVideoWindow_get_Caption(pVideoWindow, strCaption);
3966
3967 LeaveCriticalSection(&This->cs);
3968
3969 return hr;
3970}

◆ VideoWindow_get_FullScreenMode()

static HRESULT WINAPI VideoWindow_get_FullScreenMode ( IVideoWindow *  iface,
LONG *  FullScreenMode 
)
static

Definition at line 4493 of file filtergraph.c.

4494{
4495 struct filter_graph *This = impl_from_IVideoWindow(iface);
4496 IVideoWindow *pVideoWindow;
4497 HRESULT hr;
4498
4499 TRACE("(%p/%p)->(%p)\n", This, iface, FullScreenMode);
4500
4501 EnterCriticalSection(&This->cs);
4502
4503 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4504
4505 if (hr == S_OK)
4506 hr = IVideoWindow_get_FullScreenMode(pVideoWindow, FullScreenMode);
4507 if (hr == E_NOTIMPL)
4508 {
4509 *FullScreenMode = OAFALSE;
4510 hr = S_OK;
4511 }
4512
4513 LeaveCriticalSection(&This->cs);
4514
4515 return hr;
4516}
OAFALSE
#define OAFALSE
Definition: dshow.h:53

◆ VideoWindow_get_Height()

static HRESULT WINAPI VideoWindow_get_Height ( IVideoWindow *  iface,
LONG *  pHeight 
)
static

Definition at line 4353 of file filtergraph.c.

4354{
4355 struct filter_graph *This = impl_from_IVideoWindow(iface);
4356 IVideoWindow *pVideoWindow;
4357 HRESULT hr;
4358
4359 TRACE("(%p/%p)->(%p)\n", This, iface, pHeight);
4360
4361 EnterCriticalSection(&This->cs);
4362
4363 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4364
4365 if (hr == S_OK)
4366 hr = IVideoWindow_get_Height(pVideoWindow, pHeight);
4367
4368 LeaveCriticalSection(&This->cs);
4369
4370 return hr;
4371}

◆ VideoWindow_get_Left()

static HRESULT WINAPI VideoWindow_get_Left ( IVideoWindow *  iface,
LONG *  pLeft 
)
static

Definition at line 4233 of file filtergraph.c.

4234{
4235 struct filter_graph *This = impl_from_IVideoWindow(iface);
4236 IVideoWindow *pVideoWindow;
4237 HRESULT hr;
4238
4239 TRACE("(%p/%p)->(%p)\n", This, iface, pLeft);
4240
4241 EnterCriticalSection(&This->cs);
4242
4243 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4244
4245 if (hr == S_OK)
4246 hr = IVideoWindow_get_Left(pVideoWindow, pLeft);
4247
4248 LeaveCriticalSection(&This->cs);
4249
4250 return hr;
4251}

◆ VideoWindow_get_MessageDrain()

static HRESULT WINAPI VideoWindow_get_MessageDrain ( IVideoWindow *  iface,
OAHWND *  Drain 
)
static

Definition at line 4433 of file filtergraph.c.

4434{
4435 struct filter_graph *This = impl_from_IVideoWindow(iface);
4436 IVideoWindow *pVideoWindow;
4437 HRESULT hr;
4438
4439 TRACE("(%p/%p)->(%p)\n", This, iface, Drain);
4440
4441 EnterCriticalSection(&This->cs);
4442
4443 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4444
4445 if (hr == S_OK)
4446 hr = IVideoWindow_get_MessageDrain(pVideoWindow, Drain);
4447
4448 LeaveCriticalSection(&This->cs);
4449
4450 return hr;
4451}

◆ VideoWindow_get_Owner()

static HRESULT WINAPI VideoWindow_get_Owner ( IVideoWindow *  iface,
OAHWND *  Owner 
)
static

Definition at line 4393 of file filtergraph.c.

4394{
4395 struct filter_graph *This = impl_from_IVideoWindow(iface);
4396 IVideoWindow *pVideoWindow;
4397 HRESULT hr;
4398
4399 TRACE("(%p/%p)->(%p)\n", This, iface, Owner);
4400
4401 EnterCriticalSection(&This->cs);
4402
4403 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4404
4405 if (hr == S_OK)
4406 hr = IVideoWindow_get_Owner(pVideoWindow, Owner);
4407
4408 LeaveCriticalSection(&This->cs);
4409
4410 return hr;
4411}
Owner
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1629

◆ VideoWindow_get_Top()

static HRESULT WINAPI VideoWindow_get_Top ( IVideoWindow *  iface,
LONG *  pTop 
)
static

Definition at line 4313 of file filtergraph.c.

4314{
4315 struct filter_graph *This = impl_from_IVideoWindow(iface);
4316 IVideoWindow *pVideoWindow;
4317 HRESULT hr;
4318
4319 TRACE("(%p/%p)->(%p)\n", This, iface, pTop);
4320
4321 EnterCriticalSection(&This->cs);
4322
4323 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4324
4325 if (hr == S_OK)
4326 hr = IVideoWindow_get_Top(pVideoWindow, pTop);
4327
4328 LeaveCriticalSection(&This->cs);
4329
4330 return hr;
4331}

◆ VideoWindow_get_Visible()

static HRESULT WINAPI VideoWindow_get_Visible ( IVideoWindow *  iface,
LONG *  pVisible 
)
static

Definition at line 4193 of file filtergraph.c.

4194{
4195 struct filter_graph *This = impl_from_IVideoWindow(iface);
4196 IVideoWindow *pVideoWindow;
4197 HRESULT hr;
4198
4199 TRACE("(%p/%p)->(%p)\n", This, iface, pVisible);
4200
4201 EnterCriticalSection(&This->cs);
4202
4203 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4204
4205 if (hr == S_OK)
4206 hr = IVideoWindow_get_Visible(pVideoWindow, pVisible);
4207
4208 LeaveCriticalSection(&This->cs);
4209
4210 return hr;
4211}

◆ VideoWindow_get_Width()

static HRESULT WINAPI VideoWindow_get_Width ( IVideoWindow *  iface,
LONG *  pWidth 
)
static

Definition at line 4273 of file filtergraph.c.

4274{
4275 struct filter_graph *This = impl_from_IVideoWindow(iface);
4276 IVideoWindow *pVideoWindow;
4277 HRESULT hr;
4278
4279 TRACE("(%p/%p)->(%p)\n", This, iface, pWidth);
4280
4281 EnterCriticalSection(&This->cs);
4282
4283 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4284
4285 if (hr == S_OK)
4286 hr = IVideoWindow_get_Width(pVideoWindow, pWidth);
4287
4288 LeaveCriticalSection(&This->cs);
4289
4290 return hr;
4291}

◆ VideoWindow_get_WindowState()

static HRESULT WINAPI VideoWindow_get_WindowState ( IVideoWindow *  iface,
LONG *  WindowState 
)
static

Definition at line 4112 of file filtergraph.c.

4113{
4114 struct filter_graph *This = impl_from_IVideoWindow(iface);
4115 IVideoWindow *pVideoWindow;
4116 HRESULT hr;
4117
4118 TRACE("(%p/%p)->(%p)\n", This, iface, WindowState);
4119
4120 EnterCriticalSection(&This->cs);
4121
4122 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4123
4124 if (hr == S_OK)
4125 hr = IVideoWindow_get_WindowState(pVideoWindow, WindowState);
4126
4127 LeaveCriticalSection(&This->cs);
4128
4129 return hr;
4130}

◆ VideoWindow_get_WindowStyle()

static HRESULT WINAPI VideoWindow_get_WindowStyle ( IVideoWindow *  iface,
LONG *  WindowStyle 
)
static

Definition at line 3992 of file filtergraph.c.

3993{
3994 struct filter_graph *This = impl_from_IVideoWindow(iface);
3995 IVideoWindow *pVideoWindow;
3996 HRESULT hr;
3997
3998 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyle);
3999
4000 EnterCriticalSection(&This->cs);
4001
4002 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4003
4004 if (hr == S_OK)
4005 hr = IVideoWindow_get_WindowStyle(pVideoWindow, WindowStyle);
4006
4007 LeaveCriticalSection(&This->cs);
4008
4009 return hr;
4010}

◆ VideoWindow_get_WindowStyleEx()

static HRESULT WINAPI VideoWindow_get_WindowStyleEx ( IVideoWindow *  iface,
LONG *  WindowStyleEx 
)
static

Definition at line 4032 of file filtergraph.c.

4033{
4034 struct filter_graph *This = impl_from_IVideoWindow(iface);
4035 IVideoWindow *pVideoWindow;
4036 HRESULT hr;
4037
4038 TRACE("(%p/%p)->(%p)\n", This, iface, WindowStyleEx);
4039
4040 EnterCriticalSection(&This->cs);
4041
4042 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4043
4044 if (hr == S_OK)
4045 hr = IVideoWindow_get_WindowStyleEx(pVideoWindow, WindowStyleEx);
4046
4047 LeaveCriticalSection(&This->cs);
4048
4049 return hr;
4050}

◆ VideoWindow_GetIDsOfNames()

HRESULT WINAPI VideoWindow_GetIDsOfNames ( IVideoWindow *  iface,
REFIID  iid,
LPOLESTR *  names,
UINT  count,
LCID  lcid,
DISPID *  ids 
)

Definition at line 3897 of file filtergraph.c.

3899{
3900 ITypeInfo *typeinfo;
3901 HRESULT hr;
3902
3903 TRACE("iface %p, iid %s, names %p, count %u, lcid %#lx, ids %p.\n",
3904 iface, debugstr_guid(iid), names, count, lcid, ids);
3905
3906 if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
3907 {
3908 hr = ITypeInfo_GetIDsOfNames(typeinfo, names, count, ids);
3909 ITypeInfo_Release(typeinfo);
3910 }
3911 return hr;
3912}
IVideoWindow_tid
@ IVideoWindow_tid
Definition: strmbase.h:230

◆ VideoWindow_GetMaxIdealImageSize()

static HRESULT WINAPI VideoWindow_GetMaxIdealImageSize ( IVideoWindow *  iface,
LONG *  pWidth,
LONG *  pHeight 
)
static

Definition at line 4644 of file filtergraph.c.

4646{
4647 struct filter_graph *This = impl_from_IVideoWindow(iface);
4648 IVideoWindow *pVideoWindow;
4649 HRESULT hr;
4650
4651 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4652
4653 EnterCriticalSection(&This->cs);
4654
4655 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4656
4657 if (hr == S_OK)
4658 hr = IVideoWindow_GetMaxIdealImageSize(pVideoWindow, pWidth, pHeight);
4659
4660 LeaveCriticalSection(&This->cs);
4661
4662 return hr;
4663}

◆ VideoWindow_GetMinIdealImageSize()

static HRESULT WINAPI VideoWindow_GetMinIdealImageSize ( IVideoWindow *  iface,
LONG *  pWidth,
LONG *  pHeight 
)
static

Definition at line 4623 of file filtergraph.c.

4625{
4626 struct filter_graph *This = impl_from_IVideoWindow(iface);
4627 IVideoWindow *pVideoWindow;
4628 HRESULT hr;
4629
4630 TRACE("(%p/%p)->(%p, %p)\n", This, iface, pWidth, pHeight);
4631
4632 EnterCriticalSection(&This->cs);
4633
4634 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4635
4636 if (hr == S_OK)
4637 hr = IVideoWindow_GetMinIdealImageSize(pVideoWindow, pWidth, pHeight);
4638
4639 LeaveCriticalSection(&This->cs);
4640
4641 return hr;
4642}

◆ VideoWindow_GetRestorePosition()

static HRESULT WINAPI VideoWindow_GetRestorePosition ( IVideoWindow *  iface,
LONG *  pLeft,
LONG *  pTop,
LONG *  pWidth,
LONG *  pHeight 
)
static

Definition at line 4665 of file filtergraph.c.

4667{
4668 struct filter_graph *This = impl_from_IVideoWindow(iface);
4669 IVideoWindow *pVideoWindow;
4670 HRESULT hr;
4671
4672 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4673
4674 EnterCriticalSection(&This->cs);
4675
4676 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4677
4678 if (hr == S_OK)
4679 hr = IVideoWindow_GetRestorePosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4680
4681 LeaveCriticalSection(&This->cs);
4682
4683 return hr;
4684}

◆ VideoWindow_GetTypeInfo()

HRESULT WINAPI VideoWindow_GetTypeInfo ( IVideoWindow *  iface,
UINT  index,
LCID  lcid,
ITypeInfo **  typeinfo 
)

Definition at line 3890 of file filtergraph.c.

3892{
3893 TRACE("iface %p, index %u, lcid %#lx, typeinfo %p.\n", iface, index, lcid, typeinfo);
3894 return strmbase_get_typeinfo(IVideoWindow_tid, typeinfo);
3895}

◆ VideoWindow_GetTypeInfoCount()

HRESULT WINAPI VideoWindow_GetTypeInfoCount ( IVideoWindow *  iface,
UINT *  count 
)

Definition at line 3883 of file filtergraph.c.

3884{
3885 TRACE("iface %p, count %p.\n", iface, count);
3886 *count = 1;
3887 return S_OK;
3888}

◆ VideoWindow_GetWindowPosition()

static HRESULT WINAPI VideoWindow_GetWindowPosition ( IVideoWindow *  iface,
LONG *  pLeft,
LONG *  pTop,
LONG *  pWidth,
LONG *  pHeight 
)
static

Definition at line 4602 of file filtergraph.c.

4604{
4605 struct filter_graph *This = impl_from_IVideoWindow(iface);
4606 IVideoWindow *pVideoWindow;
4607 HRESULT hr;
4608
4609 TRACE("(%p/%p)->(%p, %p, %p, %p)\n", This, iface, pLeft, pTop, pWidth, pHeight);
4610
4611 EnterCriticalSection(&This->cs);
4612
4613 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4614
4615 if (hr == S_OK)
4616 hr = IVideoWindow_GetWindowPosition(pVideoWindow, pLeft, pTop, pWidth, pHeight);
4617
4618 LeaveCriticalSection(&This->cs);
4619
4620 return hr;
4621}

◆ VideoWindow_HideCursor()

static HRESULT WINAPI VideoWindow_HideCursor ( IVideoWindow *  iface,
LONG  HideCursor 
)
static

Definition at line 4686 of file filtergraph.c.

4687{
4688 struct filter_graph *This = impl_from_IVideoWindow(iface);
4689 IVideoWindow *pVideoWindow;
4690 HRESULT hr;
4691
4692 TRACE("graph %p, hide %ld.\n", This, HideCursor);
4693
4694 EnterCriticalSection(&This->cs);
4695
4696 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4697
4698 if (hr == S_OK)
4699 hr = IVideoWindow_HideCursor(pVideoWindow, HideCursor);
4700
4701 LeaveCriticalSection(&This->cs);
4702
4703 return hr;
4704}

◆ VideoWindow_Invoke()

static HRESULT WINAPI VideoWindow_Invoke ( IVideoWindow *  iface,
DISPID  id,
REFIID  iid,
LCID  lcid,
WORD  flags,
DISPPARAMS *  params,
VARIANT *  result,
EXCEPINFO *  excepinfo,
UINT *  error_arg 
)
static

Definition at line 3914 of file filtergraph.c.

3916{
3917 ITypeInfo *typeinfo;
3918 HRESULT hr;
3919
3920 TRACE("iface %p, id %ld, iid %s, lcid %#lx, flags %#x, params %p, result %p, excepinfo %p, error_arg %p.\n",
3921 iface, id, debugstr_guid(iid), lcid, flags, params, result, excepinfo, error_arg);
3922
3923 if (SUCCEEDED(hr = strmbase_get_typeinfo(IVideoWindow_tid, &typeinfo)))
3924 {
3925 hr = ITypeInfo_Invoke(typeinfo, iface, id, flags, params, result, excepinfo, error_arg);
3926 ITypeInfo_Release(typeinfo);
3927 }
3928 return hr;
3929}

◆ VideoWindow_IsCursorHidden()

static HRESULT WINAPI VideoWindow_IsCursorHidden ( IVideoWindow *  iface,
LONG *  CursorHidden 
)
static

Definition at line 4706 of file filtergraph.c.

4707{
4708 struct filter_graph *This = impl_from_IVideoWindow(iface);
4709 IVideoWindow *pVideoWindow;
4710 HRESULT hr;
4711
4712 TRACE("(%p/%p)->(%p)\n", This, iface, CursorHidden);
4713
4714 EnterCriticalSection(&This->cs);
4715
4716 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4717
4718 if (hr == S_OK)
4719 hr = IVideoWindow_IsCursorHidden(pVideoWindow, CursorHidden);
4720
4721 LeaveCriticalSection(&This->cs);
4722
4723 return hr;
4724}

◆ VideoWindow_NotifyOwnerMessage()

static HRESULT WINAPI VideoWindow_NotifyOwnerMessage ( IVideoWindow *  iface,
OAHWND  hwnd,
LONG  uMsg,
LONG_PTR  wParam,
LONG_PTR  lParam 
)
static

Definition at line 4560 of file filtergraph.c.

4562{
4563 struct filter_graph *This = impl_from_IVideoWindow(iface);
4564 IVideoWindow *pVideoWindow;
4565 HRESULT hr;
4566
4567 TRACE("graph %p, hwnd %#Ix, message %#lx, wparam %#Ix, lparam %#Ix.\n", This, hwnd, uMsg, wParam, lParam);
4568
4569 EnterCriticalSection(&This->cs);
4570
4571 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4572
4573 if (hr == S_OK)
4574 hr = IVideoWindow_NotifyOwnerMessage(pVideoWindow, hwnd, uMsg, wParam, lParam);
4575
4576 LeaveCriticalSection(&This->cs);
4577
4578 return hr;
4579}
wParam
WPARAM wParam
Definition: combotst.c:138
lParam
LPARAM lParam
Definition: combotst.c:139
hwnd
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

◆ VideoWindow_put_AutoShow()

static HRESULT WINAPI VideoWindow_put_AutoShow ( IVideoWindow *  iface,
LONG  AutoShow 
)
static

Definition at line 4052 of file filtergraph.c.

4053{
4054 struct filter_graph *This = impl_from_IVideoWindow(iface);
4055 IVideoWindow *pVideoWindow;
4056 HRESULT hr;
4057
4058 TRACE("graph %p, show %#lx.\n", This, AutoShow);
4059
4060 EnterCriticalSection(&This->cs);
4061
4062 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4063
4064 if (hr == S_OK)
4065 hr = IVideoWindow_put_AutoShow(pVideoWindow, AutoShow);
4066
4067 LeaveCriticalSection(&This->cs);
4068
4069 return hr;
4070}

◆ VideoWindow_put_BackgroundPalette()

static HRESULT WINAPI VideoWindow_put_BackgroundPalette ( IVideoWindow *  iface,
LONG  BackgroundPalette 
)
static

Definition at line 4132 of file filtergraph.c.

4133{
4134 struct filter_graph *This = impl_from_IVideoWindow(iface);
4135 IVideoWindow *pVideoWindow;
4136 HRESULT hr;
4137
4138 TRACE("graph %p, palette %ld.\n", This, BackgroundPalette);
4139
4140 EnterCriticalSection(&This->cs);
4141
4142 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4143
4144 if (hr == S_OK)
4145 hr = IVideoWindow_put_BackgroundPalette(pVideoWindow, BackgroundPalette);
4146
4147 LeaveCriticalSection(&This->cs);
4148
4149 return hr;
4150}

◆ VideoWindow_put_BorderColor()

static HRESULT WINAPI VideoWindow_put_BorderColor ( IVideoWindow *  iface,
LONG  Color 
)
static

Definition at line 4473 of file filtergraph.c.

4474{
4475 struct filter_graph *This = impl_from_IVideoWindow(iface);
4476 IVideoWindow *pVideoWindow;
4477 HRESULT hr;
4478
4479 TRACE("graph %p, colour %#lx.\n", This, Color);
4480
4481 EnterCriticalSection(&This->cs);
4482
4483 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4484
4485 if (hr == S_OK)
4486 hr = IVideoWindow_put_BorderColor(pVideoWindow, Color);
4487
4488 LeaveCriticalSection(&This->cs);
4489
4490 return hr;
4491}

◆ VideoWindow_put_Caption()

static HRESULT WINAPI VideoWindow_put_Caption ( IVideoWindow *  iface,
BSTR  strCaption 
)
static

Definition at line 3932 of file filtergraph.c.

3933{
3934 struct filter_graph *This = impl_from_IVideoWindow(iface);
3935 IVideoWindow *pVideoWindow;
3936 HRESULT hr;
3937
3938 TRACE("(%p/%p)->(%s (%p))\n", This, iface, debugstr_w(strCaption), strCaption);
3939
3940 EnterCriticalSection(&This->cs);
3941
3942 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3943
3944 if (hr == S_OK)
3945 hr = IVideoWindow_put_Caption(pVideoWindow, strCaption);
3946
3947 LeaveCriticalSection(&This->cs);
3948
3949 return hr;
3950}

◆ VideoWindow_put_FullScreenMode()

static HRESULT WINAPI VideoWindow_put_FullScreenMode ( IVideoWindow *  iface,
LONG  FullScreenMode 
)
static

Definition at line 4518 of file filtergraph.c.

4519{
4520 struct filter_graph *This = impl_from_IVideoWindow(iface);
4521 IVideoWindow *pVideoWindow;
4522 HRESULT hr;
4523
4524 TRACE("graph %p, fullscreen %ld.\n", This, FullScreenMode);
4525
4526 EnterCriticalSection(&This->cs);
4527
4528 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4529
4530 if (hr == S_OK)
4531 hr = IVideoWindow_put_FullScreenMode(pVideoWindow, FullScreenMode);
4532 if (hr == E_NOTIMPL && FullScreenMode == OAFALSE)
4533 hr = S_FALSE;
4534
4535 LeaveCriticalSection(&This->cs);
4536
4537 return hr;
4538}

◆ VideoWindow_put_Height()

static HRESULT WINAPI VideoWindow_put_Height ( IVideoWindow *  iface,
LONG  Height 
)
static

Definition at line 4333 of file filtergraph.c.

4334{
4335 struct filter_graph *This = impl_from_IVideoWindow(iface);
4336 IVideoWindow *pVideoWindow;
4337 HRESULT hr;
4338
4339 TRACE("graph %p, height %ld.\n", This, Height);
4340
4341 EnterCriticalSection(&This->cs);
4342
4343 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4344
4345 if (hr == S_OK)
4346 hr = IVideoWindow_put_Height(pVideoWindow, Height);
4347
4348 LeaveCriticalSection(&This->cs);
4349
4350 return hr;
4351}

◆ VideoWindow_put_Left()

static HRESULT WINAPI VideoWindow_put_Left ( IVideoWindow *  iface,
LONG  Left 
)
static

Definition at line 4213 of file filtergraph.c.

4214{
4215 struct filter_graph *This = impl_from_IVideoWindow(iface);
4216 IVideoWindow *pVideoWindow;
4217 HRESULT hr;
4218
4219 TRACE("graph %p, left %ld.\n", This, Left);
4220
4221 EnterCriticalSection(&This->cs);
4222
4223 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4224
4225 if (hr == S_OK)
4226 hr = IVideoWindow_put_Left(pVideoWindow, Left);
4227
4228 LeaveCriticalSection(&This->cs);
4229
4230 return hr;
4231}

◆ VideoWindow_put_MessageDrain()

static HRESULT WINAPI VideoWindow_put_MessageDrain ( IVideoWindow *  iface,
OAHWND  Drain 
)
static

Definition at line 4413 of file filtergraph.c.

4414{
4415 struct filter_graph *This = impl_from_IVideoWindow(iface);
4416 IVideoWindow *pVideoWindow;
4417 HRESULT hr;
4418
4419 TRACE("graph %p, drain %#Ix.\n", This, Drain);
4420
4421 EnterCriticalSection(&This->cs);
4422
4423 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4424
4425 if (hr == S_OK)
4426 hr = IVideoWindow_put_MessageDrain(pVideoWindow, Drain);
4427
4428 LeaveCriticalSection(&This->cs);
4429
4430 return hr;
4431}

◆ VideoWindow_put_Owner()

static HRESULT WINAPI VideoWindow_put_Owner ( IVideoWindow *  iface,
OAHWND  Owner 
)
static

Definition at line 4373 of file filtergraph.c.

4374{
4375 struct filter_graph *This = impl_from_IVideoWindow(iface);
4376 IVideoWindow *pVideoWindow;
4377 HRESULT hr;
4378
4379 TRACE("graph %p, owner %#Ix.\n", This, Owner);
4380
4381 EnterCriticalSection(&This->cs);
4382
4383 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4384
4385 if (hr == S_OK)
4386 hr = IVideoWindow_put_Owner(pVideoWindow, Owner);
4387
4388 LeaveCriticalSection(&This->cs);
4389
4390 return hr;
4391}

◆ VideoWindow_put_Top()

static HRESULT WINAPI VideoWindow_put_Top ( IVideoWindow *  iface,
LONG  Top 
)
static

Definition at line 4293 of file filtergraph.c.

4294{
4295 struct filter_graph *This = impl_from_IVideoWindow(iface);
4296 IVideoWindow *pVideoWindow;
4297 HRESULT hr;
4298
4299 TRACE("graph %p, top %ld.\n", This, Top);
4300
4301 EnterCriticalSection(&This->cs);
4302
4303 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4304
4305 if (hr == S_OK)
4306 hr = IVideoWindow_put_Top(pVideoWindow, Top);
4307
4308 LeaveCriticalSection(&This->cs);
4309
4310 return hr;
4311}

◆ VideoWindow_put_Visible()

static HRESULT WINAPI VideoWindow_put_Visible ( IVideoWindow *  iface,
LONG  Visible 
)
static

Definition at line 4173 of file filtergraph.c.

4174{
4175 struct filter_graph *This = impl_from_IVideoWindow(iface);
4176 IVideoWindow *pVideoWindow;
4177 HRESULT hr;
4178
4179 TRACE("graph %p, visible %ld.\n", This, Visible);
4180
4181 EnterCriticalSection(&This->cs);
4182
4183 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4184
4185 if (hr == S_OK)
4186 hr = IVideoWindow_put_Visible(pVideoWindow, Visible);
4187
4188 LeaveCriticalSection(&This->cs);
4189
4190 return hr;
4191}

◆ VideoWindow_put_Width()

static HRESULT WINAPI VideoWindow_put_Width ( IVideoWindow *  iface,
LONG  Width 
)
static

Definition at line 4253 of file filtergraph.c.

4254{
4255 struct filter_graph *This = impl_from_IVideoWindow(iface);
4256 IVideoWindow *pVideoWindow;
4257 HRESULT hr;
4258
4259 TRACE("graph %p, width %ld.\n", This, Width);
4260
4261 EnterCriticalSection(&This->cs);
4262
4263 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4264
4265 if (hr == S_OK)
4266 hr = IVideoWindow_put_Width(pVideoWindow, Width);
4267
4268 LeaveCriticalSection(&This->cs);
4269
4270 return hr;
4271}

◆ VideoWindow_put_WindowState()

static HRESULT WINAPI VideoWindow_put_WindowState ( IVideoWindow *  iface,
LONG  WindowState 
)
static

Definition at line 4092 of file filtergraph.c.

4093{
4094 struct filter_graph *This = impl_from_IVideoWindow(iface);
4095 IVideoWindow *pVideoWindow;
4096 HRESULT hr;
4097
4098 TRACE("graph %p, state %ld.\n", This, WindowState);
4099
4100 EnterCriticalSection(&This->cs);
4101
4102 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4103
4104 if (hr == S_OK)
4105 hr = IVideoWindow_put_WindowState(pVideoWindow, WindowState);
4106
4107 LeaveCriticalSection(&This->cs);
4108
4109 return hr;
4110}

◆ VideoWindow_put_WindowStyle()

static HRESULT WINAPI VideoWindow_put_WindowStyle ( IVideoWindow *  iface,
LONG  WindowStyle 
)
static

Definition at line 3972 of file filtergraph.c.

3973{
3974 struct filter_graph *This = impl_from_IVideoWindow(iface);
3975 IVideoWindow *pVideoWindow;
3976 HRESULT hr;
3977
3978 TRACE("graph %p, style %#lx.\n", This, WindowStyle);
3979
3980 EnterCriticalSection(&This->cs);
3981
3982 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
3983
3984 if (hr == S_OK)
3985 hr = IVideoWindow_put_WindowStyle(pVideoWindow, WindowStyle);
3986
3987 LeaveCriticalSection(&This->cs);
3988
3989 return hr;
3990}

◆ VideoWindow_put_WindowStyleEx()

static HRESULT WINAPI VideoWindow_put_WindowStyleEx ( IVideoWindow *  iface,
LONG  WindowStyleEx 
)
static

Definition at line 4012 of file filtergraph.c.

4013{
4014 struct filter_graph *This = impl_from_IVideoWindow(iface);
4015 IVideoWindow *pVideoWindow;
4016 HRESULT hr;
4017
4018 TRACE("graph %p, style %#lx.\n", This, WindowStyleEx);
4019
4020 EnterCriticalSection(&This->cs);
4021
4022 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4023
4024 if (hr == S_OK)
4025 hr = IVideoWindow_put_WindowStyleEx(pVideoWindow, WindowStyleEx);
4026
4027 LeaveCriticalSection(&This->cs);
4028
4029 return hr;
4030}

◆ VideoWindow_QueryInterface()

static HRESULT WINAPI VideoWindow_QueryInterface ( IVideoWindow *  iface,
REFIID  iid,
void **  out 
)
static

Definition at line 3865 of file filtergraph.c.

3866{
3867 struct filter_graph *graph = impl_from_IVideoWindow(iface);
3868 return IUnknown_QueryInterface(graph->outer_unk, iid, out);
3869}

◆ VideoWindow_Release()

static ULONG WINAPI VideoWindow_Release ( IVideoWindow *  iface)
static

Definition at line 3877 of file filtergraph.c.

3878{
3879 struct filter_graph *graph = impl_from_IVideoWindow(iface);
3880 return IUnknown_Release(graph->outer_unk);
3881}

◆ VideoWindow_SetWindowForeground()

static HRESULT WINAPI VideoWindow_SetWindowForeground ( IVideoWindow *  iface,
LONG  Focus 
)
static

Definition at line 4540 of file filtergraph.c.

4541{
4542 struct filter_graph *This = impl_from_IVideoWindow(iface);
4543 IVideoWindow *pVideoWindow;
4544 HRESULT hr;
4545
4546 TRACE("graph %p, focus %ld.\n", This, Focus);
4547
4548 EnterCriticalSection(&This->cs);
4549
4550 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4551
4552 if (hr == S_OK)
4553 hr = IVideoWindow_SetWindowForeground(pVideoWindow, Focus);
4554
4555 LeaveCriticalSection(&This->cs);
4556
4557 return hr;
4558}

◆ VideoWindow_SetWindowPosition()

static HRESULT WINAPI VideoWindow_SetWindowPosition ( IVideoWindow *  iface,
LONG  Left,
LONG  Top,
LONG  Width,
LONG  Height 
)
static

Definition at line 4581 of file filtergraph.c.

4583{
4584 struct filter_graph *This = impl_from_IVideoWindow(iface);
4585 IVideoWindow *pVideoWindow;
4586 HRESULT hr;
4587
4588 TRACE("graph %p, left %ld, top %ld, width %ld, height %ld.\n", This, Left, Top, Width, Height);
4589
4590 EnterCriticalSection(&This->cs);
4591
4592 hr = GetTargetInterface(This, &IID_IVideoWindow, (LPVOID*)&pVideoWindow);
4593
4594 if (hr == S_OK)
4595 hr = IVideoWindow_SetWindowPosition(pVideoWindow, Left, Top, Width, Height);
4596
4597 LeaveCriticalSection(&This->cs);
4598
4599 return hr;
4600}

◆ wait_pause_cb()

static void CALLBACK wait_pause_cb ( TP_CALLBACK_INSTANCE *  instance,
void *  context 
)
static

Definition at line 2020 of file filtergraph.c.

2021{
2022 IMediaControl *control = context;
2023 OAFilterState state;
2024 HRESULT hr;
2025
2026 if ((hr = IMediaControl_GetState(control, INFINITE, &state)) != S_OK)
2027 ERR("Failed to get paused state, hr %#lx.\n", hr);
2028
2029 if (FAILED(hr = IMediaControl_Stop(control)))
2030 ERR("Failed to stop, hr %#lx.\n", hr);
2031
2032 if ((hr = IMediaControl_GetState(control, INFINITE, &state)) != S_OK)
2033 ERR("Failed to get paused state, hr %#lx.\n", hr);
2034
2035 IMediaControl_Release(control);
2036}
QuartzTypeLib::OAFilterState
LONG OAFilterState
Definition: control.idl:30
control
Definition: dialog.c:52

Referenced by MediaControl_StopWhenReady().

◆ wait_stop_cb()

static void CALLBACK wait_stop_cb ( TP_CALLBACK_INSTANCE *  instance,
void *  context 
)
static

Definition at line 2038 of file filtergraph.c.

2039{
2040 IMediaControl *control = context;
2041 OAFilterState state;
2042 HRESULT hr;
2043
2044 if ((hr = IMediaControl_GetState(control, INFINITE, &state)) != S_OK)
2045 ERR("Failed to get state, hr %#lx.\n", hr);
2046
2047 IMediaControl_Release(control);
2048}

Referenced by MediaControl_StopWhenReady().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( quartz  )

Variable Documentation

◆ EnumFilters_vtbl

const IEnumFiltersVtbl EnumFilters_vtbl
static
Initial value:
=
{
EnumFilters_QueryInterface,
EnumFilters_AddRef,
EnumFilters_Release,
EnumFilters_Next,
EnumFilters_Skip,
EnumFilters_Reset,
EnumFilters_Clone,
}
EnumFilters_Skip
static HRESULT WINAPI EnumFilters_Skip(IEnumFilters *iface, ULONG count)
Definition: filtergraph.c:248
EnumFilters_QueryInterface
static HRESULT WINAPI EnumFilters_QueryInterface(IEnumFilters *iface, REFIID iid, void **out)
Definition: filtergraph.c:174
EnumFilters_AddRef
static ULONG WINAPI EnumFilters_AddRef(IEnumFilters *iface)
Definition: filtergraph.c:190
EnumFilters_Release
static ULONG WINAPI EnumFilters_Release(IEnumFilters *iface)
Definition: filtergraph.c:200
EnumFilters_Next
static HRESULT WINAPI EnumFilters_Next(IEnumFilters *iface, ULONG count, IBaseFilter **filters, ULONG *fetched)
Definition: filtergraph.c:216
EnumFilters_Reset
static HRESULT WINAPI EnumFilters_Reset(IEnumFilters *iface)
Definition: filtergraph.c:269
EnumFilters_Clone
static HRESULT WINAPI EnumFilters_Clone(IEnumFilters *iface, IEnumFilters **out)
Definition: filtergraph.c:280

Definition at line 289 of file filtergraph.c.

Referenced by create_enum_filters().

◆ IBasicAudio_VTable

const IBasicAudioVtbl IBasicAudio_VTable
static
Initial value:
=
{
BasicAudio_QueryInterface,
BasicAudio_AddRef,
BasicAudio_Release,
BasicAudio_GetTypeInfoCount,
BasicAudio_GetTypeInfo,
BasicAudio_GetIDsOfNames,
BasicAudio_Invoke,
BasicAudio_put_Volume,
BasicAudio_get_Volume,
BasicAudio_put_Balance,
BasicAudio_get_Balance
}
BasicAudio_QueryInterface
static HRESULT WINAPI BasicAudio_QueryInterface(IBasicAudio *iface, REFIID iid, void **out)
Definition: filtergraph.c:2913
BasicAudio_GetTypeInfo
static HRESULT WINAPI BasicAudio_GetTypeInfo(IBasicAudio *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
Definition: filtergraph.c:2938
BasicAudio_get_Volume
static HRESULT WINAPI BasicAudio_get_Volume(IBasicAudio *iface, LONG *plVolume)
Definition: filtergraph.c:3000
BasicAudio_GetTypeInfoCount
static HRESULT WINAPI BasicAudio_GetTypeInfoCount(IBasicAudio *iface, UINT *count)
Definition: filtergraph.c:2931
BasicAudio_GetIDsOfNames
static HRESULT WINAPI BasicAudio_GetIDsOfNames(IBasicAudio *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
Definition: filtergraph.c:2945
BasicAudio_put_Volume
static HRESULT WINAPI BasicAudio_put_Volume(IBasicAudio *iface, LONG lVolume)
Definition: filtergraph.c:2980
BasicAudio_put_Balance
static HRESULT WINAPI BasicAudio_put_Balance(IBasicAudio *iface, LONG lBalance)
Definition: filtergraph.c:3020
BasicAudio_AddRef
static ULONG WINAPI BasicAudio_AddRef(IBasicAudio *iface)
Definition: filtergraph.c:2919
BasicAudio_get_Balance
static HRESULT WINAPI BasicAudio_get_Balance(IBasicAudio *iface, LONG *plBalance)
Definition: filtergraph.c:3040
BasicAudio_Invoke
static HRESULT WINAPI BasicAudio_Invoke(IBasicAudio *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
Definition: filtergraph.c:2962
BasicAudio_Release
static ULONG WINAPI BasicAudio_Release(IBasicAudio *iface)
Definition: filtergraph.c:2925

Definition at line 3060 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IBasicVideo_VTable

const IBasicVideo2Vtbl IBasicVideo_VTable
static

Definition at line 3816 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IFilterGraph2_VTable

const IFilterGraph2Vtbl IFilterGraph2_VTable
static
Initial value:
=
{
FilterGraph2_QueryInterface,
FilterGraph2_AddRef,
FilterGraph2_Release,
FilterGraph2_AddFilter,
FilterGraph2_RemoveFilter,
FilterGraph2_EnumFilters,
FilterGraph2_FindFilterByName,
FilterGraph2_ConnectDirect,
FilterGraph2_Reconnect,
FilterGraph2_Disconnect,
FilterGraph2_SetDefaultSyncSource,
FilterGraph2_Connect,
FilterGraph2_Render,
FilterGraph2_RenderFile,
FilterGraph2_AddSourceFilter,
FilterGraph2_SetLogFile,
FilterGraph2_Abort,
FilterGraph2_ShouldOperationContinue,
FilterGraph2_AddSourceFilterForMoniker,
FilterGraph2_ReconnectEx,
FilterGraph2_RenderEx
}
FilterGraph2_ReconnectEx
static HRESULT WINAPI FilterGraph2_ReconnectEx(IFilterGraph2 *iface, IPin *pin, const AM_MEDIA_TYPE *mt)
Definition: filtergraph.c:1617
FilterGraph2_EnumFilters
static HRESULT WINAPI FilterGraph2_EnumFilters(IFilterGraph2 *iface, IEnumFilters **out)
Definition: filtergraph.c:764
FilterGraph2_Release
static ULONG WINAPI FilterGraph2_Release(IFilterGraph2 *iface)
Definition: filtergraph.c:515
FilterGraph2_AddRef
static ULONG WINAPI FilterGraph2_AddRef(IFilterGraph2 *iface)
Definition: filtergraph.c:509
FilterGraph2_RenderFile
static HRESULT WINAPI FilterGraph2_RenderFile(IFilterGraph2 *iface, LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList)
Definition: filtergraph.c:1440
FilterGraph2_SetLogFile
static HRESULT WINAPI FilterGraph2_SetLogFile(IFilterGraph2 *iface, DWORD_PTR file)
Definition: filtergraph.c:1560
FilterGraph2_Abort
static HRESULT WINAPI FilterGraph2_Abort(IFilterGraph2 *iface)
Definition: filtergraph.c:1569
FilterGraph2_AddSourceFilterForMoniker
static HRESULT WINAPI FilterGraph2_AddSourceFilterForMoniker(IFilterGraph2 *iface, IMoniker *pMoniker, IBindCtx *pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter **ppFilter)
Definition: filtergraph.c:1588
FilterGraph2_Connect
static HRESULT WINAPI FilterGraph2_Connect(IFilterGraph2 *iface, IPin *source, IPin *sink)
Definition: filtergraph.c:1388
FilterGraph2_Render
static HRESULT WINAPI FilterGraph2_Render(IFilterGraph2 *iface, IPin *source)
Definition: filtergraph.c:1423
FilterGraph2_ShouldOperationContinue
static HRESULT WINAPI FilterGraph2_ShouldOperationContinue(IFilterGraph2 *iface)
Definition: filtergraph.c:1578
FilterGraph2_AddSourceFilter
static HRESULT WINAPI FilterGraph2_AddSourceFilter(IFilterGraph2 *iface, const WCHAR *filename, const WCHAR *filter_name, IBaseFilter **ret_filter)
Definition: filtergraph.c:1507
FilterGraph2_ConnectDirect
static HRESULT WINAPI FilterGraph2_ConnectDirect(IFilterGraph2 *iface, IPin *ppinIn, IPin *ppinOut, const AM_MEDIA_TYPE *pmt)
Definition: filtergraph.c:921
FilterGraph2_SetDefaultSyncSource
static HRESULT WINAPI FilterGraph2_SetDefaultSyncSource(IFilterGraph2 *iface)
Definition: filtergraph.c:993
FilterGraph2_QueryInterface
static HRESULT WINAPI FilterGraph2_QueryInterface(IFilterGraph2 *iface, REFIID iid, void **out)
Definition: filtergraph.c:503
FilterGraph2_AddFilter
static HRESULT WINAPI FilterGraph2_AddFilter(IFilterGraph2 *iface, IBaseFilter *filter, const WCHAR *name)
Definition: filtergraph.c:608
FilterGraph2_FindFilterByName
static HRESULT WINAPI FilterGraph2_FindFilterByName(IFilterGraph2 *iface, const WCHAR *name, IBaseFilter **filter)
Definition: filtergraph.c:773
FilterGraph2_RemoveFilter
static HRESULT WINAPI FilterGraph2_RemoveFilter(IFilterGraph2 *iface, IBaseFilter *pFilter)
Definition: filtergraph.c:679
FilterGraph2_RenderEx
static HRESULT WINAPI FilterGraph2_RenderEx(IFilterGraph2 *iface, IPin *source, DWORD flags, DWORD *context)
Definition: filtergraph.c:1642
FilterGraph2_Disconnect
static HRESULT WINAPI FilterGraph2_Disconnect(IFilterGraph2 *iface, IPin *ppin)
Definition: filtergraph.c:981
FilterGraph2_Reconnect
static HRESULT WINAPI FilterGraph2_Reconnect(IFilterGraph2 *iface, IPin *pin)
Definition: filtergraph.c:972

Definition at line 1663 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IGraphConfig_VTable

const IGraphConfigVtbl IGraphConfig_VTable
static
Initial value:
=
{
GraphConfig_QueryInterface,
GraphConfig_AddRef,
GraphConfig_Release,
GraphConfig_Reconnect,
GraphConfig_Reconfigure,
GraphConfig_AddFilterToCache,
GraphConfig_EnumCacheFilter,
GraphConfig_RemoveFilterFromCache,
GraphConfig_GetStartTime,
GraphConfig_PushThroughData,
GraphConfig_SetFilterFlags,
GraphConfig_GetFilterFlags,
GraphConfig_RemoveFilterEx
}
GraphConfig_Reconnect
static HRESULT WINAPI GraphConfig_Reconnect(IGraphConfig *iface, IPin *source, IPin *sink, const AM_MEDIA_TYPE *mt, IBaseFilter *filter, HANDLE abort_event, DWORD flags)
Definition: filtergraph.c:5453
GraphConfig_RemoveFilterFromCache
static HRESULT WINAPI GraphConfig_RemoveFilterFromCache(IGraphConfig *iface, IBaseFilter *pFilter)
Definition: filtergraph.c:5504
GraphConfig_RemoveFilterEx
static HRESULT WINAPI GraphConfig_RemoveFilterEx(IGraphConfig *iface, IBaseFilter *filter, DWORD flags)
Definition: filtergraph.c:5551
GraphConfig_Release
static ULONG WINAPI GraphConfig_Release(IGraphConfig *iface)
Definition: filtergraph.c:5446
GraphConfig_SetFilterFlags
static HRESULT WINAPI GraphConfig_SetFilterFlags(IGraphConfig *iface, IBaseFilter *filter, DWORD flags)
Definition: filtergraph.c:5532
GraphConfig_AddFilterToCache
static HRESULT WINAPI GraphConfig_AddFilterToCache(IGraphConfig *iface, IBaseFilter *pFilter)
Definition: filtergraph.c:5486
GraphConfig_GetFilterFlags
static HRESULT WINAPI GraphConfig_GetFilterFlags(IGraphConfig *iface, IBaseFilter *pFilter, DWORD *dwFlags)
Definition: filtergraph.c:5541
GraphConfig_QueryInterface
static HRESULT WINAPI GraphConfig_QueryInterface(IGraphConfig *iface, REFIID iid, void **out)
Definition: filtergraph.c:5432
GraphConfig_AddRef
static ULONG WINAPI GraphConfig_AddRef(IGraphConfig *iface)
Definition: filtergraph.c:5439
GraphConfig_Reconfigure
static HRESULT WINAPI GraphConfig_Reconfigure(IGraphConfig *iface, IGraphConfigCallback *callback, void *context, DWORD flags, HANDLE abort_event)
Definition: filtergraph.c:5465
GraphConfig_EnumCacheFilter
static HRESULT WINAPI GraphConfig_EnumCacheFilter(IGraphConfig *iface, IEnumFilters **pEnum)
Definition: filtergraph.c:5495
GraphConfig_PushThroughData
static HRESULT WINAPI GraphConfig_PushThroughData(IGraphConfig *iface, IPin *pOutputPin, IPinConnection *pConnection, HANDLE hEventAbort)
Definition: filtergraph.c:5522
GraphConfig_GetStartTime
static HRESULT WINAPI GraphConfig_GetStartTime(IGraphConfig *iface, REFERENCE_TIME *prtStart)
Definition: filtergraph.c:5513

Definition at line 5560 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IGraphVersion_VTable

const IGraphVersionVtbl IGraphVersion_VTable
static
Initial value:
=
{
GraphVersion_QueryInterface,
GraphVersion_AddRef,
GraphVersion_Release,
GraphVersion_QueryVersion,
}
GraphVersion_Release
static ULONG WINAPI GraphVersion_Release(IGraphVersion *iface)
Definition: filtergraph.c:5596
GraphVersion_QueryVersion
static HRESULT WINAPI GraphVersion_QueryVersion(IGraphVersion *iface, LONG *version)
Definition: filtergraph.c:5603
GraphVersion_AddRef
static ULONG WINAPI GraphVersion_AddRef(IGraphVersion *iface)
Definition: filtergraph.c:5589
GraphVersion_QueryInterface
static HRESULT WINAPI GraphVersion_QueryInterface(IGraphVersion *iface, REFIID iid, void **out)
Definition: filtergraph.c:5582

Definition at line 5616 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IInner_VTable

const IUnknownVtbl IInner_VTable
static
Initial value:
=
{
FilterGraphInner_QueryInterface,
FilterGraphInner_AddRef,
FilterGraphInner_Release
}
FilterGraphInner_Release
static ULONG WINAPI FilterGraphInner_Release(IUnknown *iface)
Definition: filtergraph.c:440
FilterGraphInner_AddRef
static ULONG WINAPI FilterGraphInner_AddRef(IUnknown *iface)
Definition: filtergraph.c:430
FilterGraphInner_QueryInterface
static HRESULT WINAPI FilterGraphInner_QueryInterface(IUnknown *iface, REFIID riid, void **ppvObj)
Definition: filtergraph.c:356

Definition at line 5675 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IMediaControl_VTable

const IMediaControlVtbl IMediaControl_VTable
static
Initial value:
=
{
MediaControl_QueryInterface,
MediaControl_AddRef,
MediaControl_Release,
MediaControl_GetTypeInfoCount,
MediaControl_GetTypeInfo,
MediaControl_GetIDsOfNames,
MediaControl_Invoke,
MediaControl_Run,
MediaControl_Pause,
MediaControl_Stop,
MediaControl_GetState,
MediaControl_RenderFile,
MediaControl_AddSourceFilter,
MediaControl_get_FilterCollection,
MediaControl_get_RegFilterCollection,
MediaControl_StopWhenReady
}
MediaControl_GetTypeInfoCount
static HRESULT WINAPI MediaControl_GetTypeInfoCount(IMediaControl *iface, UINT *count)
Definition: filtergraph.c:1712
MediaControl_RenderFile
static HRESULT WINAPI MediaControl_RenderFile(IMediaControl *iface, BSTR strFilename)
Definition: filtergraph.c:1983
MediaControl_GetState
static HRESULT WINAPI MediaControl_GetState(IMediaControl *iface, LONG timeout, OAFilterState *state)
Definition: filtergraph.c:1972
MediaControl_Run
static HRESULT WINAPI MediaControl_Run(IMediaControl *iface)
Definition: filtergraph.c:1882
MediaControl_Release
static ULONG WINAPI MediaControl_Release(IMediaControl *iface)
Definition: filtergraph.c:1705
MediaControl_AddSourceFilter
static HRESULT WINAPI MediaControl_AddSourceFilter(IMediaControl *iface, BSTR strFilename, IDispatch **ppUnk)
Definition: filtergraph.c:1992
MediaControl_QueryInterface
static HRESULT WINAPI MediaControl_QueryInterface(IMediaControl *iface, REFIID iid, void **out)
Definition: filtergraph.c:1693
MediaControl_get_RegFilterCollection
static HRESULT WINAPI MediaControl_get_RegFilterCollection(IMediaControl *iface, IDispatch **ppUnk)
Definition: filtergraph.c:2011
MediaControl_get_FilterCollection
static HRESULT WINAPI MediaControl_get_FilterCollection(IMediaControl *iface, IDispatch **ppUnk)
Definition: filtergraph.c:2002
MediaControl_GetIDsOfNames
static HRESULT WINAPI MediaControl_GetIDsOfNames(IMediaControl *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
Definition: filtergraph.c:1726
MediaControl_Pause
static HRESULT WINAPI MediaControl_Pause(IMediaControl *iface)
Definition: filtergraph.c:1954
MediaControl_Stop
static HRESULT WINAPI MediaControl_Stop(IMediaControl *iface)
Definition: filtergraph.c:1963
MediaControl_StopWhenReady
static HRESULT WINAPI MediaControl_StopWhenReady(IMediaControl *iface)
Definition: filtergraph.c:2050
MediaControl_AddRef
static ULONG WINAPI MediaControl_AddRef(IMediaControl *iface)
Definition: filtergraph.c:1699
MediaControl_Invoke
static HRESULT WINAPI MediaControl_Invoke(IMediaControl *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
Definition: filtergraph.c:1743
MediaControl_GetTypeInfo
static HRESULT WINAPI MediaControl_GetTypeInfo(IMediaControl *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
Definition: filtergraph.c:1719

Definition at line 2082 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IMediaEventEx_VTable

const IMediaEventExVtbl IMediaEventEx_VTable
static
Initial value:
=
{
MediaEvent_QueryInterface,
MediaEvent_AddRef,
MediaEvent_Release,
MediaEvent_GetTypeInfoCount,
MediaEvent_GetTypeInfo,
MediaEvent_GetIDsOfNames,
MediaEvent_Invoke,
MediaEvent_GetEventHandle,
MediaEvent_GetEvent,
MediaEvent_WaitForCompletion,
MediaEvent_CancelDefaultHandling,
MediaEvent_RestoreDefaultHandling,
MediaEvent_FreeEventParams,
MediaEvent_SetNotifyWindow,
MediaEvent_SetNotifyFlags,
MediaEvent_GetNotifyFlags
}
MediaEvent_SetNotifyWindow
static HRESULT WINAPI MediaEvent_SetNotifyWindow(IMediaEventEx *iface, OAHWND window, LONG message, LONG_PTR lparam)
Definition: filtergraph.c:4958
MediaEvent_Release
static ULONG WINAPI MediaEvent_Release(IMediaEventEx *iface)
Definition: filtergraph.c:4794
MediaEvent_GetTypeInfo
static HRESULT WINAPI MediaEvent_GetTypeInfo(IMediaEventEx *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
Definition: filtergraph.c:4807
MediaEvent_GetNotifyFlags
static HRESULT WINAPI MediaEvent_GetNotifyFlags(IMediaEventEx *iface, LONG *flags)
Definition: filtergraph.c:4995
MediaEvent_FreeEventParams
static HRESULT WINAPI MediaEvent_FreeEventParams(IMediaEventEx *iface, LONG code, LONG_PTR param1, LONG_PTR param2)
Definition: filtergraph.c:4947
MediaEvent_GetIDsOfNames
static HRESULT WINAPI MediaEvent_GetIDsOfNames(IMediaEventEx *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
Definition: filtergraph.c:4814
MediaEvent_GetEvent
static HRESULT WINAPI MediaEvent_GetEvent(IMediaEventEx *iface, LONG *code, LONG_PTR *param1, LONG_PTR *param2, LONG timeout)
Definition: filtergraph.c:4858
MediaEvent_WaitForCompletion
static HRESULT WINAPI MediaEvent_WaitForCompletion(IMediaEventEx *iface, LONG msTimeout, LONG *pEvCode)
Definition: filtergraph.c:4891
MediaEvent_Invoke
static HRESULT WINAPI MediaEvent_Invoke(IMediaEventEx *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
Definition: filtergraph.c:4831
MediaEvent_GetTypeInfoCount
static HRESULT WINAPI MediaEvent_GetTypeInfoCount(IMediaEventEx *iface, UINT *count)
Definition: filtergraph.c:4800
MediaEvent_RestoreDefaultHandling
static HRESULT WINAPI MediaEvent_RestoreDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
Definition: filtergraph.c:4929
MediaEvent_QueryInterface
static HRESULT WINAPI MediaEvent_QueryInterface(IMediaEventEx *iface, REFIID iid, void **out)
Definition: filtergraph.c:4782
MediaEvent_CancelDefaultHandling
static HRESULT WINAPI MediaEvent_CancelDefaultHandling(IMediaEventEx *iface, LONG lEvCode)
Definition: filtergraph.c:4911
MediaEvent_AddRef
static ULONG WINAPI MediaEvent_AddRef(IMediaEventEx *iface)
Definition: filtergraph.c:4788
MediaEvent_SetNotifyFlags
static HRESULT WINAPI MediaEvent_SetNotifyFlags(IMediaEventEx *iface, LONG flags)
Definition: filtergraph.c:4972
MediaEvent_GetEventHandle
static HRESULT WINAPI MediaEvent_GetEventHandle(IMediaEventEx *iface, OAEVENT *event)
Definition: filtergraph.c:4848

Definition at line 5010 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IMediaEventSink_VTable

const IMediaEventSinkVtbl IMediaEventSink_VTable
static
Initial value:
=
{
MediaEventSink_QueryInterface,
MediaEventSink_AddRef,
MediaEventSink_Release,
MediaEventSink_Notify
}
MediaEventSink_Notify
static HRESULT WINAPI MediaEventSink_Notify(IMediaEventSink *iface, LONG code, LONG_PTR param1, LONG_PTR param2)
Definition: filtergraph.c:5384
MediaEventSink_Release
static ULONG WINAPI MediaEventSink_Release(IMediaEventSink *iface)
Definition: filtergraph.c:5377
MediaEventSink_AddRef
static ULONG WINAPI MediaEventSink_AddRef(IMediaEventSink *iface)
Definition: filtergraph.c:5370
MediaEventSink_QueryInterface
static HRESULT WINAPI MediaEventSink_QueryInterface(IMediaEventSink *iface, REFIID iid, void **out)
Definition: filtergraph.c:5363

Definition at line 5419 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IMediaFilter_VTable

const IMediaFilterVtbl IMediaFilter_VTable
static
Initial value:
=
{
MediaFilter_QueryInterface,
MediaFilter_AddRef,
MediaFilter_Release,
MediaFilter_GetClassID,
MediaFilter_Stop,
MediaFilter_Pause,
MediaFilter_Run,
MediaFilter_GetState,
MediaFilter_SetSyncSource,
MediaFilter_GetSyncSource
}
MediaFilter_GetState
static HRESULT WINAPI MediaFilter_GetState(IMediaFilter *iface, DWORD timeout, FILTER_STATE *state)
Definition: filtergraph.c:5196
MediaFilter_AddRef
static ULONG WINAPI MediaFilter_AddRef(IMediaFilter *iface)
Definition: filtergraph.c:5043
MediaFilter_Pause
static HRESULT WINAPI MediaFilter_Pause(IMediaFilter *iface)
Definition: filtergraph.c:5117
MediaFilter_Run
static HRESULT WINAPI MediaFilter_Run(IMediaFilter *iface, REFERENCE_TIME start)
Definition: filtergraph.c:5170
MediaFilter_GetSyncSource
static HRESULT WINAPI MediaFilter_GetSyncSource(IMediaFilter *iface, IReferenceClock **ppClock)
Definition: filtergraph.c:5324
MediaFilter_QueryInterface
static HRESULT WINAPI MediaFilter_QueryInterface(IMediaFilter *iface, REFIID iid, void **out)
Definition: filtergraph.c:5036
MediaFilter_Stop
static HRESULT WINAPI MediaFilter_Stop(IMediaFilter *iface)
Definition: filtergraph.c:5064
MediaFilter_SetSyncSource
static HRESULT WINAPI MediaFilter_SetSyncSource(IMediaFilter *iface, IReferenceClock *pClock)
Definition: filtergraph.c:5274
MediaFilter_Release
static ULONG WINAPI MediaFilter_Release(IMediaFilter *iface)
Definition: filtergraph.c:5050
MediaFilter_GetClassID
static HRESULT WINAPI MediaFilter_GetClassID(IMediaFilter *iface, CLSID *pClassID)
Definition: filtergraph.c:5057

Definition at line 5344 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IMediaPosition_VTable

const IMediaPositionVtbl IMediaPosition_VTable
static
Initial value:
=
{
MediaPosition_QueryInterface,
MediaPosition_AddRef,
MediaPosition_Release,
MediaPosition_GetTypeInfoCount,
MediaPosition_GetTypeInfo,
MediaPosition_GetIDsOfNames,
MediaPosition_Invoke,
MediaPosition_get_Duration,
MediaPosition_put_CurrentPosition,
MediaPosition_get_CurrentPosition,
MediaPosition_get_StopTime,
MediaPosition_put_StopTime,
MediaPosition_get_PrerollTime,
MediaPosition_put_PrerollTime,
MediaPosition_put_Rate,
MediaPosition_get_Rate,
MediaPosition_CanSeekForward,
MediaPosition_CanSeekBackward
}
MediaPosition_Invoke
static HRESULT WINAPI MediaPosition_Invoke(IMediaPosition *iface, DISPID id, REFIID iid, LCID lcid, WORD flags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *error_arg)
Definition: filtergraph.c:2633
MediaPosition_put_StopTime
static HRESULT WINAPI MediaPosition_put_StopTime(IMediaPosition *iface, REFTIME llTime)
Definition: filtergraph.c:2732
MediaPosition_CanSeekBackward
static HRESULT WINAPI MediaPosition_CanSeekBackward(IMediaPosition *iface, LONG *pCanSeekBackward)
Definition: filtergraph.c:2775
MediaPosition_AddRef
static ULONG WINAPI MediaPosition_AddRef(IMediaPosition *iface)
Definition: filtergraph.c:2590
MediaPosition_put_Rate
static HRESULT WINAPI MediaPosition_put_Rate(IMediaPosition *iface, double dRate)
Definition: filtergraph.c:2757
MediaPosition_get_Duration
static HRESULT WINAPI MediaPosition_get_Duration(IMediaPosition *iface, REFTIME *plength)
Definition: filtergraph.c:2687
MediaPosition_GetIDsOfNames
static HRESULT WINAPI MediaPosition_GetIDsOfNames(IMediaPosition *iface, REFIID iid, LPOLESTR *names, UINT count, LCID lcid, DISPID *ids)
Definition: filtergraph.c:2616
MediaPosition_get_PrerollTime
static HRESULT WINAPI MediaPosition_get_PrerollTime(IMediaPosition *iface, REFTIME *pllTime)
Definition: filtergraph.c:2745
MediaPosition_put_PrerollTime
static HRESULT WINAPI MediaPosition_put_PrerollTime(IMediaPosition *iface, REFTIME llTime)
Definition: filtergraph.c:2751
MediaPosition_get_StopTime
static HRESULT WINAPI MediaPosition_get_StopTime(IMediaPosition *iface, REFTIME *pllTime)
Definition: filtergraph.c:2722
MediaPosition_get_CurrentPosition
static HRESULT WINAPI MediaPosition_get_CurrentPosition(IMediaPosition *iface, REFTIME *pllTime)
Definition: filtergraph.c:2710
MediaPosition_put_CurrentPosition
static HRESULT WINAPI MediaPosition_put_CurrentPosition(IMediaPosition *iface, REFTIME llTime)
Definition: filtergraph.c:2697
MediaPosition_GetTypeInfo
static HRESULT WINAPI MediaPosition_GetTypeInfo(IMediaPosition *iface, UINT index, LCID lcid, ITypeInfo **typeinfo)
Definition: filtergraph.c:2609
MediaPosition_QueryInterface
static HRESULT WINAPI MediaPosition_QueryInterface(IMediaPosition *iface, REFIID iid, void **out)
Definition: filtergraph.c:2584
MediaPosition_CanSeekForward
static HRESULT WINAPI MediaPosition_CanSeekForward(IMediaPosition *iface, LONG *pCanSeekForward)
Definition: filtergraph.c:2769
MediaPosition_GetTypeInfoCount
static HRESULT WINAPI MediaPosition_GetTypeInfoCount(IMediaPosition *iface, UINT *count)
Definition: filtergraph.c:2602
MediaPosition_get_Rate
static HRESULT WINAPI MediaPosition_get_Rate(IMediaPosition *iface, double *pdRate)
Definition: filtergraph.c:2763
MediaPosition_Release
static ULONG WINAPI MediaPosition_Release(IMediaPosition *iface)
Definition: filtergraph.c:2596

Definition at line 2782 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IMediaSeeking_VTable

const IMediaSeekingVtbl IMediaSeeking_VTable
static
Initial value:
=
{
MediaSeeking_QueryInterface,
MediaSeeking_AddRef,
MediaSeeking_Release,
MediaSeeking_GetCapabilities,
MediaSeeking_CheckCapabilities,
MediaSeeking_IsFormatSupported,
MediaSeeking_QueryPreferredFormat,
MediaSeeking_GetTimeFormat,
MediaSeeking_IsUsingTimeFormat,
MediaSeeking_SetTimeFormat,
MediaSeeking_GetDuration,
MediaSeeking_GetStopPosition,
MediaSeeking_GetCurrentPosition,
MediaSeeking_ConvertTimeFormat,
MediaSeeking_SetPositions,
MediaSeeking_GetPositions,
MediaSeeking_GetAvailable,
MediaSeeking_SetRate,
MediaSeeking_GetRate,
MediaSeeking_GetPreroll
}
MediaSeeking_GetCapabilities
static HRESULT WINAPI MediaSeeking_GetCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
Definition: filtergraph.c:2165
MediaSeeking_GetAvailable
static HRESULT WINAPI MediaSeeking_GetAvailable(IMediaSeeking *iface, LONGLONG *pEarliest, LONGLONG *pLatest)
Definition: filtergraph.c:2511
MediaSeeking_IsFormatSupported
static HRESULT WINAPI MediaSeeking_IsFormatSupported(IMediaSeeking *iface, const GUID *pFormat)
Definition: filtergraph.c:2210
MediaSeeking_GetPositions
static HRESULT WINAPI MediaSeeking_GetPositions(IMediaSeeking *iface, LONGLONG *current, LONGLONG *stop)
Definition: filtergraph.c:2495
MediaSeeking_CheckCapabilities
static HRESULT WINAPI MediaSeeking_CheckCapabilities(IMediaSeeking *iface, DWORD *pCapabilities)
Definition: filtergraph.c:2184
MediaSeeking_IsUsingTimeFormat
static HRESULT WINAPI MediaSeeking_IsUsingTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
Definition: filtergraph.c:2254
MediaSeeking_GetPreroll
static HRESULT WINAPI MediaSeeking_GetPreroll(IMediaSeeking *iface, LONGLONG *pllPreroll)
Definition: filtergraph.c:2544
MediaSeeking_SetRate
static HRESULT WINAPI MediaSeeking_SetRate(IMediaSeeking *iface, double dRate)
Definition: filtergraph.c:2521
MediaSeeking_GetDuration
static HRESULT WINAPI MediaSeeking_GetDuration(IMediaSeeking *iface, LONGLONG *duration)
Definition: filtergraph.c:2286
MediaSeeking_GetRate
static HRESULT WINAPI MediaSeeking_GetRate(IMediaSeeking *iface, double *pdRate)
Definition: filtergraph.c:2530
MediaSeeking_QueryInterface
static HRESULT WINAPI MediaSeeking_QueryInterface(IMediaSeeking *iface, REFIID iid, void **out)
Definition: filtergraph.c:2107
MediaSeeking_AddRef
static ULONG WINAPI MediaSeeking_AddRef(IMediaSeeking *iface)
Definition: filtergraph.c:2113
MediaSeeking_SetTimeFormat
static HRESULT WINAPI MediaSeeking_SetTimeFormat(IMediaSeeking *iface, const GUID *pFormat)
Definition: filtergraph.c:2268
MediaSeeking_SetPositions
static HRESULT WINAPI MediaSeeking_SetPositions(IMediaSeeking *iface, LONGLONG *current_ptr, DWORD current_flags, LONGLONG *stop_ptr, DWORD stop_flags)
Definition: filtergraph.c:2423
MediaSeeking_QueryPreferredFormat
static HRESULT WINAPI MediaSeeking_QueryPreferredFormat(IMediaSeeking *iface, GUID *pFormat)
Definition: filtergraph.c:2228
MediaSeeking_Release
static ULONG WINAPI MediaSeeking_Release(IMediaSeeking *iface)
Definition: filtergraph.c:2119
MediaSeeking_GetCurrentPosition
static HRESULT WINAPI MediaSeeking_GetCurrentPosition(IMediaSeeking *iface, LONGLONG *current)
Definition: filtergraph.c:2369
MediaSeeking_GetStopPosition
static HRESULT WINAPI MediaSeeking_GetStopPosition(IMediaSeeking *iface, LONGLONG *stop)
Definition: filtergraph.c:2328
MediaSeeking_ConvertTimeFormat
static HRESULT WINAPI MediaSeeking_ConvertTimeFormat(IMediaSeeking *iface, LONGLONG *pTarget, const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat)
Definition: filtergraph.c:2401

Definition at line 2554 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IObjectWithSite_VTable

const IObjectWithSiteVtbl IObjectWithSite_VTable
static
Initial value:
=
{
ObjectWithSite_QueryInterface,
ObjectWithSite_AddRef,
ObjectWithSite_Release,
ObjectWithSite_SetSite,
ObjectWithSite_GetSite,
}
ObjectWithSite_Release
static ULONG WINAPI ObjectWithSite_Release(IObjectWithSite *iface)
Definition: filtergraph.c:2822
ObjectWithSite_QueryInterface
static HRESULT WINAPI ObjectWithSite_QueryInterface(IObjectWithSite *iface, REFIID iid, void **out)
Definition: filtergraph.c:2810
ObjectWithSite_AddRef
static ULONG WINAPI ObjectWithSite_AddRef(IObjectWithSite *iface)
Definition: filtergraph.c:2816
ObjectWithSite_GetSite
static HRESULT WINAPI ObjectWithSite_GetSite(IObjectWithSite *iface, REFIID riid, PVOID *ppvSite)
Definition: filtergraph.c:2841
ObjectWithSite_SetSite
static HRESULT WINAPI ObjectWithSite_SetSite(IObjectWithSite *iface, IUnknown *pUnkSite)
Definition: filtergraph.c:2830

Definition at line 2854 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ IVideoWindow_VTable

const IVideoWindowVtbl IVideoWindow_VTable
static

Definition at line 4727 of file filtergraph.c.

Referenced by filter_graph_common_create().

◆ message_thread

HANDLE message_thread
static

Definition at line 54 of file filtergraph.c.

Referenced by filter_graph_common_create(), FilterGraphInner_Release(), and performance_CloseDown().

◆ message_thread_id

DWORD message_thread_id
static

Definition at line 55 of file filtergraph.c.

Referenced by create_filter(), filter_graph_common_create(), and FilterGraphInner_Release().

◆ message_thread_refcount

unsigned int message_thread_refcount
static

Definition at line 56 of file filtergraph.c.

Referenced by filter_graph_common_create(), and FilterGraphInner_Release().

◆ message_thread_ret

HANDLE message_thread_ret
static

Definition at line 54 of file filtergraph.c.

Referenced by create_filter(), filter_graph_common_create(), FilterGraphInner_Release(), and message_thread_run().

◆ VideoFrameStep_vtbl

const IVideoFrameStepVtbl VideoFrameStep_vtbl
static
Initial value:
=
{
VideoFrameStep_QueryInterface,
VideoFrameStep_AddRef,
VideoFrameStep_Release,
VideoFrameStep_Step,
VideoFrameStep_CanStep,
VideoFrameStep_CancelStep
}
VideoFrameStep_AddRef
static ULONG WINAPI VideoFrameStep_AddRef(IVideoFrameStep *iface)
Definition: filtergraph.c:5635
VideoFrameStep_QueryInterface
static HRESULT WINAPI VideoFrameStep_QueryInterface(IVideoFrameStep *iface, REFIID iid, void **out)
Definition: filtergraph.c:5629
VideoFrameStep_CanStep
static HRESULT WINAPI VideoFrameStep_CanStep(IVideoFrameStep *iface, LONG multiple, IUnknown *filter)
Definition: filtergraph.c:5653
VideoFrameStep_Step
static HRESULT WINAPI VideoFrameStep_Step(IVideoFrameStep *iface, DWORD frame_count, IUnknown *filter)
Definition: filtergraph.c:5647
VideoFrameStep_Release
static ULONG WINAPI VideoFrameStep_Release(IVideoFrameStep *iface)
Definition: filtergraph.c:5641
VideoFrameStep_CancelStep
static HRESULT WINAPI VideoFrameStep_CancelStep(IVideoFrameStep *iface)
Definition: filtergraph.c:5659

Definition at line 5665 of file filtergraph.c.

Referenced by filter_graph_common_create().