diff --git a/reactos/include/strmif.h b/reactos/include/strmif.h new file mode 100644 index 00000000000..38af6e91110 --- /dev/null +++ b/reactos/include/strmif.h @@ -0,0 +1,7969 @@ +/*** Autogenerated by WIDL 0.1 from strmif.idl - Do not edit ***/ +#include +#include + +#ifndef __WIDL_STRMIF_H +#define __WIDL_STRMIF_H +#ifdef __cplusplus +extern "C" { +#endif +#include +#include +#define CDEF_CLASS_DEFAULT 0x0001 +#define CDEF_BYPASS_CLASS_MANAGER 0x0002 +#define CDEF_CLASS_LEGACY 0x0004 +#define CDEF_MERIT_ABOVE_DO_NOT_USE 0x0008 +#ifndef __ICreateDevEnum_FWD_DEFINED__ +#define __ICreateDevEnum_FWD_DEFINED__ +typedef struct ICreateDevEnum ICreateDevEnum; +#endif + +/***************************************************************************** + * ICreateDevEnum interface + */ +#ifndef __ICreateDevEnum_INTERFACE_DEFINED__ +#define __ICreateDevEnum_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ICreateDevEnum, 0x29840822, 0x5b84, 0x11d0, 0xbd,0x3b, 0x00,0xa0,0xc9,0x11,0xce,0x86); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICreateDevEnum : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateClassEnumerator( + REFCLSID clsidDeviceClass, + IEnumMoniker** ppEnumMoniker, + DWORD dwFlags) = 0; + +}; +#else +typedef struct ICreateDevEnumVtbl ICreateDevEnumVtbl; +struct ICreateDevEnum { + const ICreateDevEnumVtbl* lpVtbl; +}; +struct ICreateDevEnumVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ICreateDevEnum* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ICreateDevEnum* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ICreateDevEnum* This); + + /*** ICreateDevEnum methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateClassEnumerator)( + ICreateDevEnum* This, + REFCLSID clsidDeviceClass, + IEnumMoniker** ppEnumMoniker, + DWORD dwFlags); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ICreateDevEnum_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICreateDevEnum_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICreateDevEnum_Release(p) (p)->lpVtbl->Release(p) +/*** ICreateDevEnum methods ***/ +#define ICreateDevEnum_CreateClassEnumerator(p,a,b,c) (p)->lpVtbl->CreateClassEnumerator(p,a,b,c) +#endif + +#endif + +#define ICreateDevEnum_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** ICreateDevEnum methods ***/ \ + STDMETHOD_(HRESULT,CreateClassEnumerator)(THIS_ REFCLSID clsidDeviceClass, IEnumMoniker** ppEnumMoniker, DWORD dwFlags) PURE; + +HRESULT CALLBACK ICreateDevEnum_CreateClassEnumerator_Proxy( + ICreateDevEnum* This, + REFCLSID clsidDeviceClass, + IEnumMoniker** ppEnumMoniker, + DWORD dwFlags); +void __RPC_STUB ICreateDevEnum_CreateClassEnumerator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ICreateDevEnum_INTERFACE_DEFINED__ */ + +#define CHARS_IN_GUID 39 +#undef GetTimeFormat +typedef struct _AMMediaType { + GUID majortype; + GUID subtype; + BOOL bFixedSizeSamples; + BOOL bTemporalCompression; + ULONG lSampleSize; + GUID formattype; + IUnknown *pUnk; + ULONG cbFormat; + BYTE *pbFormat; +} AM_MEDIA_TYPE; + +typedef enum _PinDirection { + PINDIR_INPUT, + PINDIR_OUTPUT +} PIN_DIRECTION; + +#define MAX_PIN_NAME 128 +#define MAX_FILTER_NAME 128 +typedef LONGLONG REFERENCE_TIME; + +typedef DOUBLE REFTIME; + +typedef DWORD_PTR HSEMAPHORE; + +typedef DWORD_PTR HEVENT; + +typedef struct _AllocatorProperties { + long cBuffers; + long cbBuffer; + long cbAlign; + long cbPrefix; +} ALLOCATOR_PROPERTIES; + +#ifndef __IAMovieSetup_FWD_DEFINED__ +#define __IAMovieSetup_FWD_DEFINED__ +typedef struct IAMovieSetup IAMovieSetup; +#endif + +#ifndef __IEnumFilters_FWD_DEFINED__ +#define __IEnumFilters_FWD_DEFINED__ +typedef struct IEnumFilters IEnumFilters; +#endif + +#ifndef __IEnumMediaTypes_FWD_DEFINED__ +#define __IEnumMediaTypes_FWD_DEFINED__ +typedef struct IEnumMediaTypes IEnumMediaTypes; +#endif + +#ifndef __IEnumPins_FWD_DEFINED__ +#define __IEnumPins_FWD_DEFINED__ +typedef struct IEnumPins IEnumPins; +#endif + +#ifndef __IBaseFilter_FWD_DEFINED__ +#define __IBaseFilter_FWD_DEFINED__ +typedef struct IBaseFilter IBaseFilter; +#endif + +#ifndef __IFilterGraph_FWD_DEFINED__ +#define __IFilterGraph_FWD_DEFINED__ +typedef struct IFilterGraph IFilterGraph; +#endif + +#ifndef __IMediaFilter_FWD_DEFINED__ +#define __IMediaFilter_FWD_DEFINED__ +typedef struct IMediaFilter IMediaFilter; +#endif + +#ifndef __IMediaSample_FWD_DEFINED__ +#define __IMediaSample_FWD_DEFINED__ +typedef struct IMediaSample IMediaSample; +#endif + +#ifndef __IMemAllocator_FWD_DEFINED__ +#define __IMemAllocator_FWD_DEFINED__ +typedef struct IMemAllocator IMemAllocator; +#endif + +#ifndef __IMemAllocatorCallbackTemp_FWD_DEFINED__ +#define __IMemAllocatorCallbackTemp_FWD_DEFINED__ +typedef struct IMemAllocatorCallbackTemp IMemAllocatorCallbackTemp; +#endif + +#ifndef __IMemAllocatorNotifyCallbackTemp_FWD_DEFINED__ +#define __IMemAllocatorNotifyCallbackTemp_FWD_DEFINED__ +typedef struct IMemAllocatorNotifyCallbackTemp IMemAllocatorNotifyCallbackTemp; +#endif + +#ifndef __IMemInputPin_FWD_DEFINED__ +#define __IMemInputPin_FWD_DEFINED__ +typedef struct IMemInputPin IMemInputPin; +#endif + +#ifndef __IPin_FWD_DEFINED__ +#define __IPin_FWD_DEFINED__ +typedef struct IPin IPin; +#endif + +#ifndef __IReferenceClock_FWD_DEFINED__ +#define __IReferenceClock_FWD_DEFINED__ +typedef struct IReferenceClock IReferenceClock; +#endif + +typedef struct _PinInfo { + IBaseFilter *pFilter; + PIN_DIRECTION dir; + WCHAR achName[128]; +} PIN_INFO; + +/***************************************************************************** + * IPin interface + */ +#ifndef __IPin_INTERFACE_DEFINED__ +#define __IPin_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPin, 0x56a86891, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPin : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Connect( + IPin* pReceivePin, + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReceiveConnection( + IPin* pConnector, + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Disconnect( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConnectedTo( + IPin** pPin) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConnectionMediaType( + AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryPinInfo( + PIN_INFO* pInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryDirection( + PIN_DIRECTION* pPinDir) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryId( + LPWSTR* Id) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryAccept( + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumMediaTypes( + IEnumMediaTypes** ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryInternalConnections( + IPin** apPin, + ULONG* nPin) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndOfStream( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginFlush( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndFlush( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE NewSegment( + REFERENCE_TIME tStart, + REFERENCE_TIME tStop, + double dRate) = 0; + +}; +#else +typedef struct IPinVtbl IPinVtbl; +struct IPin { + const IPinVtbl* lpVtbl; +}; +struct IPinVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPin* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPin* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPin* This); + + /*** IPin methods ***/ + HRESULT (STDMETHODCALLTYPE *Connect)( + IPin* This, + IPin* pReceivePin, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *ReceiveConnection)( + IPin* This, + IPin* pConnector, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *Disconnect)( + IPin* This); + + HRESULT (STDMETHODCALLTYPE *ConnectedTo)( + IPin* This, + IPin** pPin); + + HRESULT (STDMETHODCALLTYPE *ConnectionMediaType)( + IPin* This, + AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *QueryPinInfo)( + IPin* This, + PIN_INFO* pInfo); + + HRESULT (STDMETHODCALLTYPE *QueryDirection)( + IPin* This, + PIN_DIRECTION* pPinDir); + + HRESULT (STDMETHODCALLTYPE *QueryId)( + IPin* This, + LPWSTR* Id); + + HRESULT (STDMETHODCALLTYPE *QueryAccept)( + IPin* This, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *EnumMediaTypes)( + IPin* This, + IEnumMediaTypes** ppEnum); + + HRESULT (STDMETHODCALLTYPE *QueryInternalConnections)( + IPin* This, + IPin** apPin, + ULONG* nPin); + + HRESULT (STDMETHODCALLTYPE *EndOfStream)( + IPin* This); + + HRESULT (STDMETHODCALLTYPE *BeginFlush)( + IPin* This); + + HRESULT (STDMETHODCALLTYPE *EndFlush)( + IPin* This); + + HRESULT (STDMETHODCALLTYPE *NewSegment)( + IPin* This, + REFERENCE_TIME tStart, + REFERENCE_TIME tStop, + double dRate); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPin_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPin_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPin_Release(p) (p)->lpVtbl->Release(p) +/*** IPin methods ***/ +#define IPin_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b) +#define IPin_ReceiveConnection(p,a,b) (p)->lpVtbl->ReceiveConnection(p,a,b) +#define IPin_Disconnect(p) (p)->lpVtbl->Disconnect(p) +#define IPin_ConnectedTo(p,a) (p)->lpVtbl->ConnectedTo(p,a) +#define IPin_ConnectionMediaType(p,a) (p)->lpVtbl->ConnectionMediaType(p,a) +#define IPin_QueryPinInfo(p,a) (p)->lpVtbl->QueryPinInfo(p,a) +#define IPin_QueryDirection(p,a) (p)->lpVtbl->QueryDirection(p,a) +#define IPin_QueryId(p,a) (p)->lpVtbl->QueryId(p,a) +#define IPin_QueryAccept(p,a) (p)->lpVtbl->QueryAccept(p,a) +#define IPin_EnumMediaTypes(p,a) (p)->lpVtbl->EnumMediaTypes(p,a) +#define IPin_QueryInternalConnections(p,a,b) (p)->lpVtbl->QueryInternalConnections(p,a,b) +#define IPin_EndOfStream(p) (p)->lpVtbl->EndOfStream(p) +#define IPin_BeginFlush(p) (p)->lpVtbl->BeginFlush(p) +#define IPin_EndFlush(p) (p)->lpVtbl->EndFlush(p) +#define IPin_NewSegment(p,a,b,c) (p)->lpVtbl->NewSegment(p,a,b,c) +#endif + +#endif + +#define IPin_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPin methods ***/ \ + STDMETHOD_(HRESULT,Connect)(THIS_ IPin* pReceivePin, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,ReceiveConnection)(THIS_ IPin* pConnector, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,Disconnect)(THIS) PURE; \ + STDMETHOD_(HRESULT,ConnectedTo)(THIS_ IPin** pPin) PURE; \ + STDMETHOD_(HRESULT,ConnectionMediaType)(THIS_ AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,QueryPinInfo)(THIS_ PIN_INFO* pInfo) PURE; \ + STDMETHOD_(HRESULT,QueryDirection)(THIS_ PIN_DIRECTION* pPinDir) PURE; \ + STDMETHOD_(HRESULT,QueryId)(THIS_ LPWSTR* Id) PURE; \ + STDMETHOD_(HRESULT,QueryAccept)(THIS_ const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,EnumMediaTypes)(THIS_ IEnumMediaTypes** ppEnum) PURE; \ + STDMETHOD_(HRESULT,QueryInternalConnections)(THIS_ IPin** apPin, ULONG* nPin) PURE; \ + STDMETHOD_(HRESULT,EndOfStream)(THIS) PURE; \ + STDMETHOD_(HRESULT,BeginFlush)(THIS) PURE; \ + STDMETHOD_(HRESULT,EndFlush)(THIS) PURE; \ + STDMETHOD_(HRESULT,NewSegment)(THIS_ REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) PURE; + +HRESULT CALLBACK IPin_Connect_Proxy( + IPin* This, + IPin* pReceivePin, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IPin_Connect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_ReceiveConnection_Proxy( + IPin* This, + IPin* pConnector, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IPin_ReceiveConnection_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_Disconnect_Proxy( + IPin* This); +void __RPC_STUB IPin_Disconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_ConnectedTo_Proxy( + IPin* This, + IPin** pPin); +void __RPC_STUB IPin_ConnectedTo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_ConnectionMediaType_Proxy( + IPin* This, + AM_MEDIA_TYPE* pmt); +void __RPC_STUB IPin_ConnectionMediaType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_QueryPinInfo_Proxy( + IPin* This, + PIN_INFO* pInfo); +void __RPC_STUB IPin_QueryPinInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_QueryDirection_Proxy( + IPin* This, + PIN_DIRECTION* pPinDir); +void __RPC_STUB IPin_QueryDirection_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_QueryId_Proxy( + IPin* This, + LPWSTR* Id); +void __RPC_STUB IPin_QueryId_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_QueryAccept_Proxy( + IPin* This, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IPin_QueryAccept_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_EnumMediaTypes_Proxy( + IPin* This, + IEnumMediaTypes** ppEnum); +void __RPC_STUB IPin_EnumMediaTypes_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_QueryInternalConnections_Proxy( + IPin* This, + IPin** apPin, + ULONG* nPin); +void __RPC_STUB IPin_QueryInternalConnections_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_EndOfStream_Proxy( + IPin* This); +void __RPC_STUB IPin_EndOfStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_BeginFlush_Proxy( + IPin* This); +void __RPC_STUB IPin_BeginFlush_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_EndFlush_Proxy( + IPin* This); +void __RPC_STUB IPin_EndFlush_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPin_NewSegment_Proxy( + IPin* This, + REFERENCE_TIME tStart, + REFERENCE_TIME tStop, + double dRate); +void __RPC_STUB IPin_NewSegment_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPin_INTERFACE_DEFINED__ */ + +typedef IPin *PPIN; + +/***************************************************************************** + * IEnumPins interface + */ +#ifndef __IEnumPins_INTERFACE_DEFINED__ +#define __IEnumPins_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumPins, 0x56a86892, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumPins : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cPins, + IPin** ppPins, + ULONG* pcFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cPins) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumPins** ppEnum) = 0; + +}; +#else +typedef struct IEnumPinsVtbl IEnumPinsVtbl; +struct IEnumPins { + const IEnumPinsVtbl* lpVtbl; +}; +struct IEnumPinsVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumPins* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumPins* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumPins* This); + + /*** IEnumPins methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumPins* This, + ULONG cPins, + IPin** ppPins, + ULONG* pcFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumPins* This, + ULONG cPins); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumPins* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumPins* This, + IEnumPins** ppEnum); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumPins_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumPins_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumPins_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumPins methods ***/ +#define IEnumPins_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumPins_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumPins_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumPins_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#endif + +#define IEnumPins_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumPins methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cPins, IPin** ppPins, ULONG* pcFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cPins) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumPins** ppEnum) PURE; + +HRESULT CALLBACK IEnumPins_Next_Proxy( + IEnumPins* This, + ULONG cPins, + IPin** ppPins, + ULONG* pcFetched); +void __RPC_STUB IEnumPins_Next_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumPins_Skip_Proxy( + IEnumPins* This, + ULONG cPins); +void __RPC_STUB IEnumPins_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumPins_Reset_Proxy( + IEnumPins* This); +void __RPC_STUB IEnumPins_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumPins_Clone_Proxy( + IEnumPins* This, + IEnumPins** ppEnum); +void __RPC_STUB IEnumPins_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumPins_INTERFACE_DEFINED__ */ + +typedef IEnumPins *PENUMPINS; + +/***************************************************************************** + * IEnumMediaTypes interface + */ +#ifndef __IEnumMediaTypes_INTERFACE_DEFINED__ +#define __IEnumMediaTypes_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumMediaTypes, 0x89c31040, 0x846b, 0x11ce, 0x97,0xd3, 0x00,0xaa,0x00,0x55,0x59,0x5a); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumMediaTypes : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cMediaTypes, + AM_MEDIA_TYPE** ppMediaTypes, + ULONG* pcFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cMediaTypes) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumMediaTypes** ppEnum) = 0; + +}; +#else +typedef struct IEnumMediaTypesVtbl IEnumMediaTypesVtbl; +struct IEnumMediaTypes { + const IEnumMediaTypesVtbl* lpVtbl; +}; +struct IEnumMediaTypesVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumMediaTypes* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumMediaTypes* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumMediaTypes* This); + + /*** IEnumMediaTypes methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumMediaTypes* This, + ULONG cMediaTypes, + AM_MEDIA_TYPE** ppMediaTypes, + ULONG* pcFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumMediaTypes* This, + ULONG cMediaTypes); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumMediaTypes* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumMediaTypes* This, + IEnumMediaTypes** ppEnum); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumMediaTypes_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumMediaTypes_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumMediaTypes_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumMediaTypes methods ***/ +#define IEnumMediaTypes_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumMediaTypes_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumMediaTypes_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumMediaTypes_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#endif + +#define IEnumMediaTypes_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumMediaTypes methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cMediaTypes, AM_MEDIA_TYPE** ppMediaTypes, ULONG* pcFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cMediaTypes) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumMediaTypes** ppEnum) PURE; + +HRESULT CALLBACK IEnumMediaTypes_Next_Proxy( + IEnumMediaTypes* This, + ULONG cMediaTypes, + AM_MEDIA_TYPE** ppMediaTypes, + ULONG* pcFetched); +void __RPC_STUB IEnumMediaTypes_Next_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumMediaTypes_Skip_Proxy( + IEnumMediaTypes* This, + ULONG cMediaTypes); +void __RPC_STUB IEnumMediaTypes_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumMediaTypes_Reset_Proxy( + IEnumMediaTypes* This); +void __RPC_STUB IEnumMediaTypes_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumMediaTypes_Clone_Proxy( + IEnumMediaTypes* This, + IEnumMediaTypes** ppEnum); +void __RPC_STUB IEnumMediaTypes_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumMediaTypes_INTERFACE_DEFINED__ */ + +typedef IEnumMediaTypes *PENUMMEDIATYPES; + +/***************************************************************************** + * IFilterGraph interface + */ +#ifndef __IFilterGraph_INTERFACE_DEFINED__ +#define __IFilterGraph_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFilterGraph, 0x56a8689f, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFilterGraph : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE AddFilter( + IBaseFilter* pFilter, + LPCWSTR pName) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveFilter( + IBaseFilter* pFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumFilters( + IEnumFilters** ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindFilterByName( + LPCWSTR pName, + IBaseFilter** ppFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConnectDirect( + IPin* ppinOut, + IPin* ppinIn, + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reconnect( + IPin* ppin) = 0; + + virtual HRESULT STDMETHODCALLTYPE Disconnect( + IPin* ppin) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultSyncSource( + ) = 0; + +}; +#else +typedef struct IFilterGraphVtbl IFilterGraphVtbl; +struct IFilterGraph { + const IFilterGraphVtbl* lpVtbl; +}; +struct IFilterGraphVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFilterGraph* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFilterGraph* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFilterGraph* This); + + /*** IFilterGraph methods ***/ + HRESULT (STDMETHODCALLTYPE *AddFilter)( + IFilterGraph* This, + IBaseFilter* pFilter, + LPCWSTR pName); + + HRESULT (STDMETHODCALLTYPE *RemoveFilter)( + IFilterGraph* This, + IBaseFilter* pFilter); + + HRESULT (STDMETHODCALLTYPE *EnumFilters)( + IFilterGraph* This, + IEnumFilters** ppEnum); + + HRESULT (STDMETHODCALLTYPE *FindFilterByName)( + IFilterGraph* This, + LPCWSTR pName, + IBaseFilter** ppFilter); + + HRESULT (STDMETHODCALLTYPE *ConnectDirect)( + IFilterGraph* This, + IPin* ppinOut, + IPin* ppinIn, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *Reconnect)( + IFilterGraph* This, + IPin* ppin); + + HRESULT (STDMETHODCALLTYPE *Disconnect)( + IFilterGraph* This, + IPin* ppin); + + HRESULT (STDMETHODCALLTYPE *SetDefaultSyncSource)( + IFilterGraph* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFilterGraph_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterGraph_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterGraph_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterGraph methods ***/ +#define IFilterGraph_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b) +#define IFilterGraph_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a) +#define IFilterGraph_EnumFilters(p,a) (p)->lpVtbl->EnumFilters(p,a) +#define IFilterGraph_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b) +#define IFilterGraph_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c) +#define IFilterGraph_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a) +#define IFilterGraph_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a) +#define IFilterGraph_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p) +#endif + +#endif + +#define IFilterGraph_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterGraph methods ***/ \ + STDMETHOD_(HRESULT,AddFilter)(THIS_ IBaseFilter* pFilter, LPCWSTR pName) PURE; \ + STDMETHOD_(HRESULT,RemoveFilter)(THIS_ IBaseFilter* pFilter) PURE; \ + STDMETHOD_(HRESULT,EnumFilters)(THIS_ IEnumFilters** ppEnum) PURE; \ + STDMETHOD_(HRESULT,FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter** ppFilter) PURE; \ + STDMETHOD_(HRESULT,ConnectDirect)(THIS_ IPin* ppinOut, IPin* ppinIn, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* ppin) PURE; \ + STDMETHOD_(HRESULT,Disconnect)(THIS_ IPin* ppin) PURE; \ + STDMETHOD_(HRESULT,SetDefaultSyncSource)(THIS) PURE; + +HRESULT CALLBACK IFilterGraph_AddFilter_Proxy( + IFilterGraph* This, + IBaseFilter* pFilter, + LPCWSTR pName); +void __RPC_STUB IFilterGraph_AddFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_RemoveFilter_Proxy( + IFilterGraph* This, + IBaseFilter* pFilter); +void __RPC_STUB IFilterGraph_RemoveFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_EnumFilters_Proxy( + IFilterGraph* This, + IEnumFilters** ppEnum); +void __RPC_STUB IFilterGraph_EnumFilters_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_FindFilterByName_Proxy( + IFilterGraph* This, + LPCWSTR pName, + IBaseFilter** ppFilter); +void __RPC_STUB IFilterGraph_FindFilterByName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_ConnectDirect_Proxy( + IFilterGraph* This, + IPin* ppinOut, + IPin* ppinIn, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IFilterGraph_ConnectDirect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_Reconnect_Proxy( + IFilterGraph* This, + IPin* ppin); +void __RPC_STUB IFilterGraph_Reconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_Disconnect_Proxy( + IFilterGraph* This, + IPin* ppin); +void __RPC_STUB IFilterGraph_Disconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph_SetDefaultSyncSource_Proxy( + IFilterGraph* This); +void __RPC_STUB IFilterGraph_SetDefaultSyncSource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFilterGraph_INTERFACE_DEFINED__ */ + +typedef IFilterGraph *PFILTERGRAPH; + +/***************************************************************************** + * IEnumFilters interface + */ +#ifndef __IEnumFilters_INTERFACE_DEFINED__ +#define __IEnumFilters_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumFilters, 0x56a86893, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumFilters : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cFilters, + IBaseFilter** ppFilter, + ULONG* pcFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cFilters) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumFilters** ppEnum) = 0; + +}; +#else +typedef struct IEnumFiltersVtbl IEnumFiltersVtbl; +struct IEnumFilters { + const IEnumFiltersVtbl* lpVtbl; +}; +struct IEnumFiltersVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumFilters* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumFilters* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumFilters* This); + + /*** IEnumFilters methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumFilters* This, + ULONG cFilters, + IBaseFilter** ppFilter, + ULONG* pcFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumFilters* This, + ULONG cFilters); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumFilters* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumFilters* This, + IEnumFilters** ppEnum); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumFilters_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumFilters_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumFilters_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumFilters methods ***/ +#define IEnumFilters_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumFilters_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumFilters_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumFilters_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#endif + +#define IEnumFilters_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumFilters methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cFilters, IBaseFilter** ppFilter, ULONG* pcFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cFilters) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumFilters** ppEnum) PURE; + +HRESULT CALLBACK IEnumFilters_Next_Proxy( + IEnumFilters* This, + ULONG cFilters, + IBaseFilter** ppFilter, + ULONG* pcFetched); +void __RPC_STUB IEnumFilters_Next_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumFilters_Skip_Proxy( + IEnumFilters* This, + ULONG cFilters); +void __RPC_STUB IEnumFilters_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumFilters_Reset_Proxy( + IEnumFilters* This); +void __RPC_STUB IEnumFilters_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumFilters_Clone_Proxy( + IEnumFilters* This, + IEnumFilters** ppEnum); +void __RPC_STUB IEnumFilters_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumFilters_INTERFACE_DEFINED__ */ + +typedef IEnumFilters *PENUMFILTERS; + +typedef enum _FilterState { + State_Stopped, + State_Paused, + State_Running +} FILTER_STATE; + +/***************************************************************************** + * IMediaFilter interface + */ +#ifndef __IMediaFilter_INTERFACE_DEFINED__ +#define __IMediaFilter_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMediaFilter, 0x56a86899, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMediaFilter : public IPersist +{ + virtual HRESULT STDMETHODCALLTYPE Stop( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Run( + REFERENCE_TIME tStart) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetState( + DWORD dwMilliSecsTimeout, + FILTER_STATE* State) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSyncSource( + IReferenceClock* pClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSyncSource( + IReferenceClock** pClock) = 0; + +}; +#else +typedef struct IMediaFilterVtbl IMediaFilterVtbl; +struct IMediaFilter { + const IMediaFilterVtbl* lpVtbl; +}; +struct IMediaFilterVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMediaFilter* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMediaFilter* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMediaFilter* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IMediaFilter* This, + CLSID* pClassID); + + /*** IMediaFilter methods ***/ + HRESULT (STDMETHODCALLTYPE *Stop)( + IMediaFilter* This); + + HRESULT (STDMETHODCALLTYPE *Pause)( + IMediaFilter* This); + + HRESULT (STDMETHODCALLTYPE *Run)( + IMediaFilter* This, + REFERENCE_TIME tStart); + + HRESULT (STDMETHODCALLTYPE *GetState)( + IMediaFilter* This, + DWORD dwMilliSecsTimeout, + FILTER_STATE* State); + + HRESULT (STDMETHODCALLTYPE *SetSyncSource)( + IMediaFilter* This, + IReferenceClock* pClock); + + HRESULT (STDMETHODCALLTYPE *GetSyncSource)( + IMediaFilter* This, + IReferenceClock** pClock); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMediaFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IMediaFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IMediaFilter methods ***/ +#define IMediaFilter_Stop(p) (p)->lpVtbl->Stop(p) +#define IMediaFilter_Pause(p) (p)->lpVtbl->Pause(p) +#define IMediaFilter_Run(p,a) (p)->lpVtbl->Run(p,a) +#define IMediaFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b) +#define IMediaFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a) +#define IMediaFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a) +#endif + +#endif + +#define IMediaFilter_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPersist methods ***/ \ + STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \ + /*** IMediaFilter methods ***/ \ + STDMETHOD_(HRESULT,Stop)(THIS) PURE; \ + STDMETHOD_(HRESULT,Pause)(THIS) PURE; \ + STDMETHOD_(HRESULT,Run)(THIS_ REFERENCE_TIME tStart) PURE; \ + STDMETHOD_(HRESULT,GetState)(THIS_ DWORD dwMilliSecsTimeout, FILTER_STATE* State) PURE; \ + STDMETHOD_(HRESULT,SetSyncSource)(THIS_ IReferenceClock* pClock) PURE; \ + STDMETHOD_(HRESULT,GetSyncSource)(THIS_ IReferenceClock** pClock) PURE; + +HRESULT CALLBACK IMediaFilter_Stop_Proxy( + IMediaFilter* This); +void __RPC_STUB IMediaFilter_Stop_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaFilter_Pause_Proxy( + IMediaFilter* This); +void __RPC_STUB IMediaFilter_Pause_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaFilter_Run_Proxy( + IMediaFilter* This, + REFERENCE_TIME tStart); +void __RPC_STUB IMediaFilter_Run_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaFilter_GetState_Proxy( + IMediaFilter* This, + DWORD dwMilliSecsTimeout, + FILTER_STATE* State); +void __RPC_STUB IMediaFilter_GetState_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaFilter_SetSyncSource_Proxy( + IMediaFilter* This, + IReferenceClock* pClock); +void __RPC_STUB IMediaFilter_SetSyncSource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaFilter_GetSyncSource_Proxy( + IMediaFilter* This, + IReferenceClock** pClock); +void __RPC_STUB IMediaFilter_GetSyncSource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMediaFilter_INTERFACE_DEFINED__ */ + +typedef IMediaFilter *PMEDIAFILTER; + +typedef struct _FilterInfo { + WCHAR achName[128]; + IFilterGraph *pGraph; +} FILTER_INFO; + +/***************************************************************************** + * IBaseFilter interface + */ +#ifndef __IBaseFilter_INTERFACE_DEFINED__ +#define __IBaseFilter_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IBaseFilter, 0x56a86895, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IBaseFilter : public IMediaFilter +{ + virtual HRESULT STDMETHODCALLTYPE EnumPins( + IEnumPins** ppEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindPin( + LPCWSTR Id, + IPin** ppPin) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryFilterInfo( + FILTER_INFO* pInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE JoinFilterGraph( + IFilterGraph* pGraph, + LPCWSTR pName) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryVendorInfo( + LPWSTR* pVendorInfo) = 0; + +}; +#else +typedef struct IBaseFilterVtbl IBaseFilterVtbl; +struct IBaseFilter { + const IBaseFilterVtbl* lpVtbl; +}; +struct IBaseFilterVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IBaseFilter* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IBaseFilter* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IBaseFilter* This); + + /*** IPersist methods ***/ + HRESULT (STDMETHODCALLTYPE *GetClassID)( + IBaseFilter* This, + CLSID* pClassID); + + /*** IMediaFilter methods ***/ + HRESULT (STDMETHODCALLTYPE *Stop)( + IBaseFilter* This); + + HRESULT (STDMETHODCALLTYPE *Pause)( + IBaseFilter* This); + + HRESULT (STDMETHODCALLTYPE *Run)( + IBaseFilter* This, + REFERENCE_TIME tStart); + + HRESULT (STDMETHODCALLTYPE *GetState)( + IBaseFilter* This, + DWORD dwMilliSecsTimeout, + FILTER_STATE* State); + + HRESULT (STDMETHODCALLTYPE *SetSyncSource)( + IBaseFilter* This, + IReferenceClock* pClock); + + HRESULT (STDMETHODCALLTYPE *GetSyncSource)( + IBaseFilter* This, + IReferenceClock** pClock); + + /*** IBaseFilter methods ***/ + HRESULT (STDMETHODCALLTYPE *EnumPins)( + IBaseFilter* This, + IEnumPins** ppEnum); + + HRESULT (STDMETHODCALLTYPE *FindPin)( + IBaseFilter* This, + LPCWSTR Id, + IPin** ppPin); + + HRESULT (STDMETHODCALLTYPE *QueryFilterInfo)( + IBaseFilter* This, + FILTER_INFO* pInfo); + + HRESULT (STDMETHODCALLTYPE *JoinFilterGraph)( + IBaseFilter* This, + IFilterGraph* pGraph, + LPCWSTR pName); + + HRESULT (STDMETHODCALLTYPE *QueryVendorInfo)( + IBaseFilter* This, + LPWSTR* pVendorInfo); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IBaseFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IBaseFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IBaseFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IPersist methods ***/ +#define IBaseFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a) +/*** IMediaFilter methods ***/ +#define IBaseFilter_Stop(p) (p)->lpVtbl->Stop(p) +#define IBaseFilter_Pause(p) (p)->lpVtbl->Pause(p) +#define IBaseFilter_Run(p,a) (p)->lpVtbl->Run(p,a) +#define IBaseFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b) +#define IBaseFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a) +#define IBaseFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a) +/*** IBaseFilter methods ***/ +#define IBaseFilter_EnumPins(p,a) (p)->lpVtbl->EnumPins(p,a) +#define IBaseFilter_FindPin(p,a,b) (p)->lpVtbl->FindPin(p,a,b) +#define IBaseFilter_QueryFilterInfo(p,a) (p)->lpVtbl->QueryFilterInfo(p,a) +#define IBaseFilter_JoinFilterGraph(p,a,b) (p)->lpVtbl->JoinFilterGraph(p,a,b) +#define IBaseFilter_QueryVendorInfo(p,a) (p)->lpVtbl->QueryVendorInfo(p,a) +#endif + +#endif + +#define IBaseFilter_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPersist methods ***/ \ + STDMETHOD_(HRESULT,GetClassID)(THIS_ CLSID* pClassID) PURE; \ + /*** IMediaFilter methods ***/ \ + STDMETHOD_(HRESULT,Stop)(THIS) PURE; \ + STDMETHOD_(HRESULT,Pause)(THIS) PURE; \ + STDMETHOD_(HRESULT,Run)(THIS_ REFERENCE_TIME tStart) PURE; \ + STDMETHOD_(HRESULT,GetState)(THIS_ DWORD dwMilliSecsTimeout, FILTER_STATE* State) PURE; \ + STDMETHOD_(HRESULT,SetSyncSource)(THIS_ IReferenceClock* pClock) PURE; \ + STDMETHOD_(HRESULT,GetSyncSource)(THIS_ IReferenceClock** pClock) PURE; \ + /*** IBaseFilter methods ***/ \ + STDMETHOD_(HRESULT,EnumPins)(THIS_ IEnumPins** ppEnum) PURE; \ + STDMETHOD_(HRESULT,FindPin)(THIS_ LPCWSTR Id, IPin** ppPin) PURE; \ + STDMETHOD_(HRESULT,QueryFilterInfo)(THIS_ FILTER_INFO* pInfo) PURE; \ + STDMETHOD_(HRESULT,JoinFilterGraph)(THIS_ IFilterGraph* pGraph, LPCWSTR pName) PURE; \ + STDMETHOD_(HRESULT,QueryVendorInfo)(THIS_ LPWSTR* pVendorInfo) PURE; + +HRESULT CALLBACK IBaseFilter_EnumPins_Proxy( + IBaseFilter* This, + IEnumPins** ppEnum); +void __RPC_STUB IBaseFilter_EnumPins_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBaseFilter_FindPin_Proxy( + IBaseFilter* This, + LPCWSTR Id, + IPin** ppPin); +void __RPC_STUB IBaseFilter_FindPin_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBaseFilter_QueryFilterInfo_Proxy( + IBaseFilter* This, + FILTER_INFO* pInfo); +void __RPC_STUB IBaseFilter_QueryFilterInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBaseFilter_JoinFilterGraph_Proxy( + IBaseFilter* This, + IFilterGraph* pGraph, + LPCWSTR pName); +void __RPC_STUB IBaseFilter_JoinFilterGraph_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IBaseFilter_QueryVendorInfo_Proxy( + IBaseFilter* This, + LPWSTR* pVendorInfo); +void __RPC_STUB IBaseFilter_QueryVendorInfo_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IBaseFilter_INTERFACE_DEFINED__ */ + +typedef IBaseFilter *PFILTER; + +/***************************************************************************** + * IReferenceClock interface + */ +#ifndef __IReferenceClock_INTERFACE_DEFINED__ +#define __IReferenceClock_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IReferenceClock, 0x56a86897, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IReferenceClock : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetTime( + REFERENCE_TIME* pTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE AdviseTime( + REFERENCE_TIME baseTime, + REFERENCE_TIME streamTime, + HEVENT hEvent, + DWORD_PTR* pdwAdviseCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE AdvisePeriodic( + REFERENCE_TIME startTime, + REFERENCE_TIME periodTime, + HSEMAPHORE hSemaphore, + DWORD_PTR* pdwAdviseCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unadvise( + DWORD_PTR dwAdviseCookie) = 0; + +}; +#else +typedef struct IReferenceClockVtbl IReferenceClockVtbl; +struct IReferenceClock { + const IReferenceClockVtbl* lpVtbl; +}; +struct IReferenceClockVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IReferenceClock* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IReferenceClock* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IReferenceClock* This); + + /*** IReferenceClock methods ***/ + HRESULT (STDMETHODCALLTYPE *GetTime)( + IReferenceClock* This, + REFERENCE_TIME* pTime); + + HRESULT (STDMETHODCALLTYPE *AdviseTime)( + IReferenceClock* This, + REFERENCE_TIME baseTime, + REFERENCE_TIME streamTime, + HEVENT hEvent, + DWORD_PTR* pdwAdviseCookie); + + HRESULT (STDMETHODCALLTYPE *AdvisePeriodic)( + IReferenceClock* This, + REFERENCE_TIME startTime, + REFERENCE_TIME periodTime, + HSEMAPHORE hSemaphore, + DWORD_PTR* pdwAdviseCookie); + + HRESULT (STDMETHODCALLTYPE *Unadvise)( + IReferenceClock* This, + DWORD_PTR dwAdviseCookie); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IReferenceClock_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IReferenceClock_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IReferenceClock_Release(p) (p)->lpVtbl->Release(p) +/*** IReferenceClock methods ***/ +#define IReferenceClock_GetTime(p,a) (p)->lpVtbl->GetTime(p,a) +#define IReferenceClock_AdviseTime(p,a,b,c,d) (p)->lpVtbl->AdviseTime(p,a,b,c,d) +#define IReferenceClock_AdvisePeriodic(p,a,b,c,d) (p)->lpVtbl->AdvisePeriodic(p,a,b,c,d) +#define IReferenceClock_Unadvise(p,a) (p)->lpVtbl->Unadvise(p,a) +#endif + +#endif + +#define IReferenceClock_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IReferenceClock methods ***/ \ + STDMETHOD_(HRESULT,GetTime)(THIS_ REFERENCE_TIME* pTime) PURE; \ + STDMETHOD_(HRESULT,AdviseTime)(THIS_ REFERENCE_TIME baseTime, REFERENCE_TIME streamTime, HEVENT hEvent, DWORD_PTR* pdwAdviseCookie) PURE; \ + STDMETHOD_(HRESULT,AdvisePeriodic)(THIS_ REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR* pdwAdviseCookie) PURE; \ + STDMETHOD_(HRESULT,Unadvise)(THIS_ DWORD_PTR dwAdviseCookie) PURE; + +HRESULT CALLBACK IReferenceClock_GetTime_Proxy( + IReferenceClock* This, + REFERENCE_TIME* pTime); +void __RPC_STUB IReferenceClock_GetTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IReferenceClock_AdviseTime_Proxy( + IReferenceClock* This, + REFERENCE_TIME baseTime, + REFERENCE_TIME streamTime, + HEVENT hEvent, + DWORD_PTR* pdwAdviseCookie); +void __RPC_STUB IReferenceClock_AdviseTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IReferenceClock_AdvisePeriodic_Proxy( + IReferenceClock* This, + REFERENCE_TIME startTime, + REFERENCE_TIME periodTime, + HSEMAPHORE hSemaphore, + DWORD_PTR* pdwAdviseCookie); +void __RPC_STUB IReferenceClock_AdvisePeriodic_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IReferenceClock_Unadvise_Proxy( + IReferenceClock* This, + DWORD_PTR dwAdviseCookie); +void __RPC_STUB IReferenceClock_Unadvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IReferenceClock_INTERFACE_DEFINED__ */ + +typedef IReferenceClock *PREFERENCECLOCK; + +/***************************************************************************** + * IMediaSample interface + */ +#ifndef __IMediaSample_INTERFACE_DEFINED__ +#define __IMediaSample_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMediaSample, 0x56a8689a, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMediaSample : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetPointer( + BYTE** ppBuffer) = 0; + + virtual long STDMETHODCALLTYPE GetSize( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTime( + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTime( + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsSyncPoint( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSyncPoint( + BOOL bIsSyncPoint) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsPreroll( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreroll( + BOOL bIsPreroll) = 0; + + virtual long STDMETHODCALLTYPE GetActualDataLength( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetActualDataLength( + long length) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaType( + AM_MEDIA_TYPE** ppMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaType( + AM_MEDIA_TYPE* pMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsDiscontinuity( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDiscontinuity( + BOOL bDiscontinuity) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaTime( + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaTime( + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd) = 0; + +}; +#else +typedef struct IMediaSampleVtbl IMediaSampleVtbl; +struct IMediaSample { + const IMediaSampleVtbl* lpVtbl; +}; +struct IMediaSampleVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMediaSample* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMediaSample* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMediaSample* This); + + /*** IMediaSample methods ***/ + HRESULT (STDMETHODCALLTYPE *GetPointer)( + IMediaSample* This, + BYTE** ppBuffer); + + long (STDMETHODCALLTYPE *GetSize)( + IMediaSample* This); + + HRESULT (STDMETHODCALLTYPE *GetTime)( + IMediaSample* This, + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd); + + HRESULT (STDMETHODCALLTYPE *SetTime)( + IMediaSample* This, + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd); + + HRESULT (STDMETHODCALLTYPE *IsSyncPoint)( + IMediaSample* This); + + HRESULT (STDMETHODCALLTYPE *SetSyncPoint)( + IMediaSample* This, + BOOL bIsSyncPoint); + + HRESULT (STDMETHODCALLTYPE *IsPreroll)( + IMediaSample* This); + + HRESULT (STDMETHODCALLTYPE *SetPreroll)( + IMediaSample* This, + BOOL bIsPreroll); + + long (STDMETHODCALLTYPE *GetActualDataLength)( + IMediaSample* This); + + HRESULT (STDMETHODCALLTYPE *SetActualDataLength)( + IMediaSample* This, + long length); + + HRESULT (STDMETHODCALLTYPE *GetMediaType)( + IMediaSample* This, + AM_MEDIA_TYPE** ppMediaType); + + HRESULT (STDMETHODCALLTYPE *SetMediaType)( + IMediaSample* This, + AM_MEDIA_TYPE* pMediaType); + + HRESULT (STDMETHODCALLTYPE *IsDiscontinuity)( + IMediaSample* This); + + HRESULT (STDMETHODCALLTYPE *SetDiscontinuity)( + IMediaSample* This, + BOOL bDiscontinuity); + + HRESULT (STDMETHODCALLTYPE *GetMediaTime)( + IMediaSample* This, + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd); + + HRESULT (STDMETHODCALLTYPE *SetMediaTime)( + IMediaSample* This, + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMediaSample_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaSample_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaSample_Release(p) (p)->lpVtbl->Release(p) +/*** IMediaSample methods ***/ +#define IMediaSample_GetPointer(p,a) (p)->lpVtbl->GetPointer(p,a) +#define IMediaSample_GetSize(p) (p)->lpVtbl->GetSize(p) +#define IMediaSample_GetTime(p,a,b) (p)->lpVtbl->GetTime(p,a,b) +#define IMediaSample_SetTime(p,a,b) (p)->lpVtbl->SetTime(p,a,b) +#define IMediaSample_IsSyncPoint(p) (p)->lpVtbl->IsSyncPoint(p) +#define IMediaSample_SetSyncPoint(p,a) (p)->lpVtbl->SetSyncPoint(p,a) +#define IMediaSample_IsPreroll(p) (p)->lpVtbl->IsPreroll(p) +#define IMediaSample_SetPreroll(p,a) (p)->lpVtbl->SetPreroll(p,a) +#define IMediaSample_GetActualDataLength(p) (p)->lpVtbl->GetActualDataLength(p) +#define IMediaSample_SetActualDataLength(p,a) (p)->lpVtbl->SetActualDataLength(p,a) +#define IMediaSample_GetMediaType(p,a) (p)->lpVtbl->GetMediaType(p,a) +#define IMediaSample_SetMediaType(p,a) (p)->lpVtbl->SetMediaType(p,a) +#define IMediaSample_IsDiscontinuity(p) (p)->lpVtbl->IsDiscontinuity(p) +#define IMediaSample_SetDiscontinuity(p,a) (p)->lpVtbl->SetDiscontinuity(p,a) +#define IMediaSample_GetMediaTime(p,a,b) (p)->lpVtbl->GetMediaTime(p,a,b) +#define IMediaSample_SetMediaTime(p,a,b) (p)->lpVtbl->SetMediaTime(p,a,b) +#endif + +#endif + +#define IMediaSample_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMediaSample methods ***/ \ + STDMETHOD_(HRESULT,GetPointer)(THIS_ BYTE** ppBuffer) PURE; \ + STDMETHOD_(long,GetSize)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \ + STDMETHOD_(HRESULT,SetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \ + STDMETHOD_(HRESULT,IsSyncPoint)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetSyncPoint)(THIS_ BOOL bIsSyncPoint) PURE; \ + STDMETHOD_(HRESULT,IsPreroll)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetPreroll)(THIS_ BOOL bIsPreroll) PURE; \ + STDMETHOD_(long,GetActualDataLength)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetActualDataLength)(THIS_ long length) PURE; \ + STDMETHOD_(HRESULT,GetMediaType)(THIS_ AM_MEDIA_TYPE** ppMediaType) PURE; \ + STDMETHOD_(HRESULT,SetMediaType)(THIS_ AM_MEDIA_TYPE* pMediaType) PURE; \ + STDMETHOD_(HRESULT,IsDiscontinuity)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetDiscontinuity)(THIS_ BOOL bDiscontinuity) PURE; \ + STDMETHOD_(HRESULT,GetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; \ + STDMETHOD_(HRESULT,SetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; + +HRESULT CALLBACK IMediaSample_GetPointer_Proxy( + IMediaSample* This, + BYTE** ppBuffer); +void __RPC_STUB IMediaSample_GetPointer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +long CALLBACK IMediaSample_GetSize_Proxy( + IMediaSample* This); +void __RPC_STUB IMediaSample_GetSize_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_GetTime_Proxy( + IMediaSample* This, + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd); +void __RPC_STUB IMediaSample_GetTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetTime_Proxy( + IMediaSample* This, + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd); +void __RPC_STUB IMediaSample_SetTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_IsSyncPoint_Proxy( + IMediaSample* This); +void __RPC_STUB IMediaSample_IsSyncPoint_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetSyncPoint_Proxy( + IMediaSample* This, + BOOL bIsSyncPoint); +void __RPC_STUB IMediaSample_SetSyncPoint_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_IsPreroll_Proxy( + IMediaSample* This); +void __RPC_STUB IMediaSample_IsPreroll_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetPreroll_Proxy( + IMediaSample* This, + BOOL bIsPreroll); +void __RPC_STUB IMediaSample_SetPreroll_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +long CALLBACK IMediaSample_GetActualDataLength_Proxy( + IMediaSample* This); +void __RPC_STUB IMediaSample_GetActualDataLength_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetActualDataLength_Proxy( + IMediaSample* This, + long length); +void __RPC_STUB IMediaSample_SetActualDataLength_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_GetMediaType_Proxy( + IMediaSample* This, + AM_MEDIA_TYPE** ppMediaType); +void __RPC_STUB IMediaSample_GetMediaType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetMediaType_Proxy( + IMediaSample* This, + AM_MEDIA_TYPE* pMediaType); +void __RPC_STUB IMediaSample_SetMediaType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_IsDiscontinuity_Proxy( + IMediaSample* This); +void __RPC_STUB IMediaSample_IsDiscontinuity_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetDiscontinuity_Proxy( + IMediaSample* This, + BOOL bDiscontinuity); +void __RPC_STUB IMediaSample_SetDiscontinuity_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_GetMediaTime_Proxy( + IMediaSample* This, + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd); +void __RPC_STUB IMediaSample_GetMediaTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample_SetMediaTime_Proxy( + IMediaSample* This, + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd); +void __RPC_STUB IMediaSample_SetMediaTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMediaSample_INTERFACE_DEFINED__ */ + +typedef IMediaSample *PMEDIASAMPLE; + +enum tagAM_SAMPLE_PROPERTY_FLAGS { + AM_SAMPLE_SPLICEPOINT = 0x1, + AM_SAMPLE_PREROLL = 0x2, + AM_SAMPLE_DATADISCONTINUITY = 0x4, + AM_SAMPLE_TYPECHANGED = 0x8, + AM_SAMPLE_TIMEVALID = 0x10, + AM_SAMPLE_TIMEDISCONTINUITY = 0x40, + AM_SAMPLE_FLUSH_ON_PAUSE = 0x80, + AM_SAMPLE_STOPVALID = 0x100, + AM_SAMPLE_ENDOFSTREAM = 0x200, + AM_STREAM_MEDIA = 0, + AM_STREAM_CONTROL = 1 +}; + +typedef struct tagAM_SAMPLE2_PROPERTIES { + DWORD cbData; + DWORD dwTypeSpecificFlags; + DWORD dwSampleFlags; + LONG lActual; + REFERENCE_TIME tStart; + REFERENCE_TIME tStop; + DWORD dwStreamId; + AM_MEDIA_TYPE *pMediaType; + BYTE *pbBuffer; + LONG cbBuffer; +} AM_SAMPLE2_PROPERTIES; + +#ifndef __IMediaSample2_FWD_DEFINED__ +#define __IMediaSample2_FWD_DEFINED__ +typedef struct IMediaSample2 IMediaSample2; +#endif + +/***************************************************************************** + * IMediaSample2 interface + */ +#ifndef __IMediaSample2_INTERFACE_DEFINED__ +#define __IMediaSample2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMediaSample2, 0x36b73884, 0xc2c8, 0x11cf, 0x8b,0x46, 0x00,0x80,0x5f,0x6c,0xef,0x60); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMediaSample2 : public IMediaSample +{ + virtual HRESULT STDMETHODCALLTYPE GetProperties( + DWORD cbProperties, + BYTE* pbProperties) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetProperties( + DWORD cbProperties, + const BYTE* pbProperties) = 0; + +}; +#else +typedef struct IMediaSample2Vtbl IMediaSample2Vtbl; +struct IMediaSample2 { + const IMediaSample2Vtbl* lpVtbl; +}; +struct IMediaSample2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMediaSample2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMediaSample2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMediaSample2* This); + + /*** IMediaSample methods ***/ + HRESULT (STDMETHODCALLTYPE *GetPointer)( + IMediaSample2* This, + BYTE** ppBuffer); + + long (STDMETHODCALLTYPE *GetSize)( + IMediaSample2* This); + + HRESULT (STDMETHODCALLTYPE *GetTime)( + IMediaSample2* This, + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd); + + HRESULT (STDMETHODCALLTYPE *SetTime)( + IMediaSample2* This, + REFERENCE_TIME* pTimeStart, + REFERENCE_TIME* pTimeEnd); + + HRESULT (STDMETHODCALLTYPE *IsSyncPoint)( + IMediaSample2* This); + + HRESULT (STDMETHODCALLTYPE *SetSyncPoint)( + IMediaSample2* This, + BOOL bIsSyncPoint); + + HRESULT (STDMETHODCALLTYPE *IsPreroll)( + IMediaSample2* This); + + HRESULT (STDMETHODCALLTYPE *SetPreroll)( + IMediaSample2* This, + BOOL bIsPreroll); + + long (STDMETHODCALLTYPE *GetActualDataLength)( + IMediaSample2* This); + + HRESULT (STDMETHODCALLTYPE *SetActualDataLength)( + IMediaSample2* This, + long length); + + HRESULT (STDMETHODCALLTYPE *GetMediaType)( + IMediaSample2* This, + AM_MEDIA_TYPE** ppMediaType); + + HRESULT (STDMETHODCALLTYPE *SetMediaType)( + IMediaSample2* This, + AM_MEDIA_TYPE* pMediaType); + + HRESULT (STDMETHODCALLTYPE *IsDiscontinuity)( + IMediaSample2* This); + + HRESULT (STDMETHODCALLTYPE *SetDiscontinuity)( + IMediaSample2* This, + BOOL bDiscontinuity); + + HRESULT (STDMETHODCALLTYPE *GetMediaTime)( + IMediaSample2* This, + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd); + + HRESULT (STDMETHODCALLTYPE *SetMediaTime)( + IMediaSample2* This, + LONGLONG* pTimeStart, + LONGLONG* pTimeEnd); + + /*** IMediaSample2 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetProperties)( + IMediaSample2* This, + DWORD cbProperties, + BYTE* pbProperties); + + HRESULT (STDMETHODCALLTYPE *SetProperties)( + IMediaSample2* This, + DWORD cbProperties, + const BYTE* pbProperties); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMediaSample2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaSample2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaSample2_Release(p) (p)->lpVtbl->Release(p) +/*** IMediaSample methods ***/ +#define IMediaSample2_GetPointer(p,a) (p)->lpVtbl->GetPointer(p,a) +#define IMediaSample2_GetSize(p) (p)->lpVtbl->GetSize(p) +#define IMediaSample2_GetTime(p,a,b) (p)->lpVtbl->GetTime(p,a,b) +#define IMediaSample2_SetTime(p,a,b) (p)->lpVtbl->SetTime(p,a,b) +#define IMediaSample2_IsSyncPoint(p) (p)->lpVtbl->IsSyncPoint(p) +#define IMediaSample2_SetSyncPoint(p,a) (p)->lpVtbl->SetSyncPoint(p,a) +#define IMediaSample2_IsPreroll(p) (p)->lpVtbl->IsPreroll(p) +#define IMediaSample2_SetPreroll(p,a) (p)->lpVtbl->SetPreroll(p,a) +#define IMediaSample2_GetActualDataLength(p) (p)->lpVtbl->GetActualDataLength(p) +#define IMediaSample2_SetActualDataLength(p,a) (p)->lpVtbl->SetActualDataLength(p,a) +#define IMediaSample2_GetMediaType(p,a) (p)->lpVtbl->GetMediaType(p,a) +#define IMediaSample2_SetMediaType(p,a) (p)->lpVtbl->SetMediaType(p,a) +#define IMediaSample2_IsDiscontinuity(p) (p)->lpVtbl->IsDiscontinuity(p) +#define IMediaSample2_SetDiscontinuity(p,a) (p)->lpVtbl->SetDiscontinuity(p,a) +#define IMediaSample2_GetMediaTime(p,a,b) (p)->lpVtbl->GetMediaTime(p,a,b) +#define IMediaSample2_SetMediaTime(p,a,b) (p)->lpVtbl->SetMediaTime(p,a,b) +/*** IMediaSample2 methods ***/ +#define IMediaSample2_GetProperties(p,a,b) (p)->lpVtbl->GetProperties(p,a,b) +#define IMediaSample2_SetProperties(p,a,b) (p)->lpVtbl->SetProperties(p,a,b) +#endif + +#endif + +#define IMediaSample2_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMediaSample methods ***/ \ + STDMETHOD_(HRESULT,GetPointer)(THIS_ BYTE** ppBuffer) PURE; \ + STDMETHOD_(long,GetSize)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \ + STDMETHOD_(HRESULT,SetTime)(THIS_ REFERENCE_TIME* pTimeStart, REFERENCE_TIME* pTimeEnd) PURE; \ + STDMETHOD_(HRESULT,IsSyncPoint)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetSyncPoint)(THIS_ BOOL bIsSyncPoint) PURE; \ + STDMETHOD_(HRESULT,IsPreroll)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetPreroll)(THIS_ BOOL bIsPreroll) PURE; \ + STDMETHOD_(long,GetActualDataLength)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetActualDataLength)(THIS_ long length) PURE; \ + STDMETHOD_(HRESULT,GetMediaType)(THIS_ AM_MEDIA_TYPE** ppMediaType) PURE; \ + STDMETHOD_(HRESULT,SetMediaType)(THIS_ AM_MEDIA_TYPE* pMediaType) PURE; \ + STDMETHOD_(HRESULT,IsDiscontinuity)(THIS) PURE; \ + STDMETHOD_(HRESULT,SetDiscontinuity)(THIS_ BOOL bDiscontinuity) PURE; \ + STDMETHOD_(HRESULT,GetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; \ + STDMETHOD_(HRESULT,SetMediaTime)(THIS_ LONGLONG* pTimeStart, LONGLONG* pTimeEnd) PURE; \ + /*** IMediaSample2 methods ***/ \ + STDMETHOD_(HRESULT,GetProperties)(THIS_ DWORD cbProperties, BYTE* pbProperties) PURE; \ + STDMETHOD_(HRESULT,SetProperties)(THIS_ DWORD cbProperties, const BYTE* pbProperties) PURE; + +HRESULT CALLBACK IMediaSample2_GetProperties_Proxy( + IMediaSample2* This, + DWORD cbProperties, + BYTE* pbProperties); +void __RPC_STUB IMediaSample2_GetProperties_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSample2_SetProperties_Proxy( + IMediaSample2* This, + DWORD cbProperties, + const BYTE* pbProperties); +void __RPC_STUB IMediaSample2_SetProperties_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMediaSample2_INTERFACE_DEFINED__ */ + +typedef IMediaSample2 *PMEDIASAMPLE2; + +#define AM_GBF_PREVFRAMESKIPPED 1 +#define AM_GBF_NOTASYNCPOINT 2 +#define AM_GBF_NOWAIT 4 +/***************************************************************************** + * IMemAllocator interface + */ +#ifndef __IMemAllocator_INTERFACE_DEFINED__ +#define __IMemAllocator_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMemAllocator, 0x56a8689c, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMemAllocator : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetProperties( + ALLOCATOR_PROPERTIES* pRequest, + ALLOCATOR_PROPERTIES* pActual) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProperties( + ALLOCATOR_PROPERTIES* pProps) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Decommit( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBuffer( + IMediaSample** ppBuffer, + REFERENCE_TIME* pStartTime, + REFERENCE_TIME* pEndTime, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseBuffer( + IMediaSample* pBuffer) = 0; + +}; +#else +typedef struct IMemAllocatorVtbl IMemAllocatorVtbl; +struct IMemAllocator { + const IMemAllocatorVtbl* lpVtbl; +}; +struct IMemAllocatorVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMemAllocator* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMemAllocator* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMemAllocator* This); + + /*** IMemAllocator methods ***/ + HRESULT (STDMETHODCALLTYPE *SetProperties)( + IMemAllocator* This, + ALLOCATOR_PROPERTIES* pRequest, + ALLOCATOR_PROPERTIES* pActual); + + HRESULT (STDMETHODCALLTYPE *GetProperties)( + IMemAllocator* This, + ALLOCATOR_PROPERTIES* pProps); + + HRESULT (STDMETHODCALLTYPE *Commit)( + IMemAllocator* This); + + HRESULT (STDMETHODCALLTYPE *Decommit)( + IMemAllocator* This); + + HRESULT (STDMETHODCALLTYPE *GetBuffer)( + IMemAllocator* This, + IMediaSample** ppBuffer, + REFERENCE_TIME* pStartTime, + REFERENCE_TIME* pEndTime, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *ReleaseBuffer)( + IMemAllocator* This, + IMediaSample* pBuffer); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMemAllocator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMemAllocator_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMemAllocator_Release(p) (p)->lpVtbl->Release(p) +/*** IMemAllocator methods ***/ +#define IMemAllocator_SetProperties(p,a,b) (p)->lpVtbl->SetProperties(p,a,b) +#define IMemAllocator_GetProperties(p,a) (p)->lpVtbl->GetProperties(p,a) +#define IMemAllocator_Commit(p) (p)->lpVtbl->Commit(p) +#define IMemAllocator_Decommit(p) (p)->lpVtbl->Decommit(p) +#define IMemAllocator_GetBuffer(p,a,b,c,d) (p)->lpVtbl->GetBuffer(p,a,b,c,d) +#define IMemAllocator_ReleaseBuffer(p,a) (p)->lpVtbl->ReleaseBuffer(p,a) +#endif + +#endif + +#define IMemAllocator_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMemAllocator methods ***/ \ + STDMETHOD_(HRESULT,SetProperties)(THIS_ ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual) PURE; \ + STDMETHOD_(HRESULT,GetProperties)(THIS_ ALLOCATOR_PROPERTIES* pProps) PURE; \ + STDMETHOD_(HRESULT,Commit)(THIS) PURE; \ + STDMETHOD_(HRESULT,Decommit)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetBuffer)(THIS_ IMediaSample** ppBuffer, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,ReleaseBuffer)(THIS_ IMediaSample* pBuffer) PURE; + +HRESULT CALLBACK IMemAllocator_SetProperties_Proxy( + IMemAllocator* This, + ALLOCATOR_PROPERTIES* pRequest, + ALLOCATOR_PROPERTIES* pActual); +void __RPC_STUB IMemAllocator_SetProperties_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemAllocator_GetProperties_Proxy( + IMemAllocator* This, + ALLOCATOR_PROPERTIES* pProps); +void __RPC_STUB IMemAllocator_GetProperties_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemAllocator_Commit_Proxy( + IMemAllocator* This); +void __RPC_STUB IMemAllocator_Commit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemAllocator_Decommit_Proxy( + IMemAllocator* This); +void __RPC_STUB IMemAllocator_Decommit_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemAllocator_GetBuffer_Proxy( + IMemAllocator* This, + IMediaSample** ppBuffer, + REFERENCE_TIME* pStartTime, + REFERENCE_TIME* pEndTime, + DWORD dwFlags); +void __RPC_STUB IMemAllocator_GetBuffer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemAllocator_ReleaseBuffer_Proxy( + IMemAllocator* This, + IMediaSample* pBuffer); +void __RPC_STUB IMemAllocator_ReleaseBuffer_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMemAllocator_INTERFACE_DEFINED__ */ + +typedef IMemAllocator *PMEMALLOCATOR; + +/***************************************************************************** + * IMemAllocatorCallbackTemp interface + */ +#ifndef __IMemAllocatorCallbackTemp_INTERFACE_DEFINED__ +#define __IMemAllocatorCallbackTemp_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMemAllocatorCallbackTemp, 0x379a0cf0, 0xc1de, 0x11d2, 0xab,0xf5, 0x00,0xa0,0xc9,0x05,0xf3,0x75); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMemAllocatorCallbackTemp : public IMemAllocator +{ + virtual HRESULT STDMETHODCALLTYPE SetNotify( + IMemAllocatorNotifyCallbackTemp* pNotify) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFreeCount( + LONG* plBuffersFree) = 0; + +}; +#else +typedef struct IMemAllocatorCallbackTempVtbl IMemAllocatorCallbackTempVtbl; +struct IMemAllocatorCallbackTemp { + const IMemAllocatorCallbackTempVtbl* lpVtbl; +}; +struct IMemAllocatorCallbackTempVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMemAllocatorCallbackTemp* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMemAllocatorCallbackTemp* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMemAllocatorCallbackTemp* This); + + /*** IMemAllocator methods ***/ + HRESULT (STDMETHODCALLTYPE *SetProperties)( + IMemAllocatorCallbackTemp* This, + ALLOCATOR_PROPERTIES* pRequest, + ALLOCATOR_PROPERTIES* pActual); + + HRESULT (STDMETHODCALLTYPE *GetProperties)( + IMemAllocatorCallbackTemp* This, + ALLOCATOR_PROPERTIES* pProps); + + HRESULT (STDMETHODCALLTYPE *Commit)( + IMemAllocatorCallbackTemp* This); + + HRESULT (STDMETHODCALLTYPE *Decommit)( + IMemAllocatorCallbackTemp* This); + + HRESULT (STDMETHODCALLTYPE *GetBuffer)( + IMemAllocatorCallbackTemp* This, + IMediaSample** ppBuffer, + REFERENCE_TIME* pStartTime, + REFERENCE_TIME* pEndTime, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *ReleaseBuffer)( + IMemAllocatorCallbackTemp* This, + IMediaSample* pBuffer); + + /*** IMemAllocatorCallbackTemp methods ***/ + HRESULT (STDMETHODCALLTYPE *SetNotify)( + IMemAllocatorCallbackTemp* This, + IMemAllocatorNotifyCallbackTemp* pNotify); + + HRESULT (STDMETHODCALLTYPE *GetFreeCount)( + IMemAllocatorCallbackTemp* This, + LONG* plBuffersFree); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMemAllocatorCallbackTemp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMemAllocatorCallbackTemp_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMemAllocatorCallbackTemp_Release(p) (p)->lpVtbl->Release(p) +/*** IMemAllocator methods ***/ +#define IMemAllocatorCallbackTemp_SetProperties(p,a,b) (p)->lpVtbl->SetProperties(p,a,b) +#define IMemAllocatorCallbackTemp_GetProperties(p,a) (p)->lpVtbl->GetProperties(p,a) +#define IMemAllocatorCallbackTemp_Commit(p) (p)->lpVtbl->Commit(p) +#define IMemAllocatorCallbackTemp_Decommit(p) (p)->lpVtbl->Decommit(p) +#define IMemAllocatorCallbackTemp_GetBuffer(p,a,b,c,d) (p)->lpVtbl->GetBuffer(p,a,b,c,d) +#define IMemAllocatorCallbackTemp_ReleaseBuffer(p,a) (p)->lpVtbl->ReleaseBuffer(p,a) +/*** IMemAllocatorCallbackTemp methods ***/ +#define IMemAllocatorCallbackTemp_SetNotify(p,a) (p)->lpVtbl->SetNotify(p,a) +#define IMemAllocatorCallbackTemp_GetFreeCount(p,a) (p)->lpVtbl->GetFreeCount(p,a) +#endif + +#endif + +#define IMemAllocatorCallbackTemp_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMemAllocator methods ***/ \ + STDMETHOD_(HRESULT,SetProperties)(THIS_ ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual) PURE; \ + STDMETHOD_(HRESULT,GetProperties)(THIS_ ALLOCATOR_PROPERTIES* pProps) PURE; \ + STDMETHOD_(HRESULT,Commit)(THIS) PURE; \ + STDMETHOD_(HRESULT,Decommit)(THIS) PURE; \ + STDMETHOD_(HRESULT,GetBuffer)(THIS_ IMediaSample** ppBuffer, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,ReleaseBuffer)(THIS_ IMediaSample* pBuffer) PURE; \ + /*** IMemAllocatorCallbackTemp methods ***/ \ + STDMETHOD_(HRESULT,SetNotify)(THIS_ IMemAllocatorNotifyCallbackTemp* pNotify) PURE; \ + STDMETHOD_(HRESULT,GetFreeCount)(THIS_ LONG* plBuffersFree) PURE; + +HRESULT CALLBACK IMemAllocatorCallbackTemp_SetNotify_Proxy( + IMemAllocatorCallbackTemp* This, + IMemAllocatorNotifyCallbackTemp* pNotify); +void __RPC_STUB IMemAllocatorCallbackTemp_SetNotify_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemAllocatorCallbackTemp_GetFreeCount_Proxy( + IMemAllocatorCallbackTemp* This, + LONG* plBuffersFree); +void __RPC_STUB IMemAllocatorCallbackTemp_GetFreeCount_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMemAllocatorCallbackTemp_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMemAllocatorNotifyCallbackTemp interface + */ +#ifndef __IMemAllocatorNotifyCallbackTemp_INTERFACE_DEFINED__ +#define __IMemAllocatorNotifyCallbackTemp_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMemAllocatorNotifyCallbackTemp, 0x92980b30, 0xc1de, 0x11d2, 0xab,0xf5, 0x00,0xa0,0xc9,0x05,0xf3,0x75); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMemAllocatorNotifyCallbackTemp : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE NotifyRelease( + ) = 0; + +}; +#else +typedef struct IMemAllocatorNotifyCallbackTempVtbl IMemAllocatorNotifyCallbackTempVtbl; +struct IMemAllocatorNotifyCallbackTemp { + const IMemAllocatorNotifyCallbackTempVtbl* lpVtbl; +}; +struct IMemAllocatorNotifyCallbackTempVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMemAllocatorNotifyCallbackTemp* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMemAllocatorNotifyCallbackTemp* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMemAllocatorNotifyCallbackTemp* This); + + /*** IMemAllocatorNotifyCallbackTemp methods ***/ + HRESULT (STDMETHODCALLTYPE *NotifyRelease)( + IMemAllocatorNotifyCallbackTemp* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMemAllocatorNotifyCallbackTemp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMemAllocatorNotifyCallbackTemp_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMemAllocatorNotifyCallbackTemp_Release(p) (p)->lpVtbl->Release(p) +/*** IMemAllocatorNotifyCallbackTemp methods ***/ +#define IMemAllocatorNotifyCallbackTemp_NotifyRelease(p) (p)->lpVtbl->NotifyRelease(p) +#endif + +#endif + +#define IMemAllocatorNotifyCallbackTemp_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMemAllocatorNotifyCallbackTemp methods ***/ \ + STDMETHOD_(HRESULT,NotifyRelease)(THIS) PURE; + +HRESULT CALLBACK IMemAllocatorNotifyCallbackTemp_NotifyRelease_Proxy( + IMemAllocatorNotifyCallbackTemp* This); +void __RPC_STUB IMemAllocatorNotifyCallbackTemp_NotifyRelease_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMemAllocatorNotifyCallbackTemp_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IMemInputPin interface + */ +#ifndef __IMemInputPin_INTERFACE_DEFINED__ +#define __IMemInputPin_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMemInputPin, 0x56a8689d, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMemInputPin : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetAllocator( + IMemAllocator** ppAllocator) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyAllocator( + IMemAllocator* pAllocator, + BOOL bReadOnly) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAllocatorRequirements( + ALLOCATOR_PROPERTIES* pProps) = 0; + + virtual HRESULT STDMETHODCALLTYPE Receive( + IMediaSample* pSample) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReceiveMultiple( + IMediaSample** pSamples, + long nSamples, + long* nSamplesProcessed) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReceiveCanBlock( + ) = 0; + +}; +#else +typedef struct IMemInputPinVtbl IMemInputPinVtbl; +struct IMemInputPin { + const IMemInputPinVtbl* lpVtbl; +}; +struct IMemInputPinVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMemInputPin* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMemInputPin* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMemInputPin* This); + + /*** IMemInputPin methods ***/ + HRESULT (STDMETHODCALLTYPE *GetAllocator)( + IMemInputPin* This, + IMemAllocator** ppAllocator); + + HRESULT (STDMETHODCALLTYPE *NotifyAllocator)( + IMemInputPin* This, + IMemAllocator* pAllocator, + BOOL bReadOnly); + + HRESULT (STDMETHODCALLTYPE *GetAllocatorRequirements)( + IMemInputPin* This, + ALLOCATOR_PROPERTIES* pProps); + + HRESULT (STDMETHODCALLTYPE *Receive)( + IMemInputPin* This, + IMediaSample* pSample); + + HRESULT (STDMETHODCALLTYPE *ReceiveMultiple)( + IMemInputPin* This, + IMediaSample** pSamples, + long nSamples, + long* nSamplesProcessed); + + HRESULT (STDMETHODCALLTYPE *ReceiveCanBlock)( + IMemInputPin* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMemInputPin_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMemInputPin_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMemInputPin_Release(p) (p)->lpVtbl->Release(p) +/*** IMemInputPin methods ***/ +#define IMemInputPin_GetAllocator(p,a) (p)->lpVtbl->GetAllocator(p,a) +#define IMemInputPin_NotifyAllocator(p,a,b) (p)->lpVtbl->NotifyAllocator(p,a,b) +#define IMemInputPin_GetAllocatorRequirements(p,a) (p)->lpVtbl->GetAllocatorRequirements(p,a) +#define IMemInputPin_Receive(p,a) (p)->lpVtbl->Receive(p,a) +#define IMemInputPin_ReceiveMultiple(p,a,b,c) (p)->lpVtbl->ReceiveMultiple(p,a,b,c) +#define IMemInputPin_ReceiveCanBlock(p) (p)->lpVtbl->ReceiveCanBlock(p) +#endif + +#endif + +#define IMemInputPin_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMemInputPin methods ***/ \ + STDMETHOD_(HRESULT,GetAllocator)(THIS_ IMemAllocator** ppAllocator) PURE; \ + STDMETHOD_(HRESULT,NotifyAllocator)(THIS_ IMemAllocator* pAllocator, BOOL bReadOnly) PURE; \ + STDMETHOD_(HRESULT,GetAllocatorRequirements)(THIS_ ALLOCATOR_PROPERTIES* pProps) PURE; \ + STDMETHOD_(HRESULT,Receive)(THIS_ IMediaSample* pSample) PURE; \ + STDMETHOD_(HRESULT,ReceiveMultiple)(THIS_ IMediaSample** pSamples, long nSamples, long* nSamplesProcessed) PURE; \ + STDMETHOD_(HRESULT,ReceiveCanBlock)(THIS) PURE; + +HRESULT CALLBACK IMemInputPin_GetAllocator_Proxy( + IMemInputPin* This, + IMemAllocator** ppAllocator); +void __RPC_STUB IMemInputPin_GetAllocator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemInputPin_NotifyAllocator_Proxy( + IMemInputPin* This, + IMemAllocator* pAllocator, + BOOL bReadOnly); +void __RPC_STUB IMemInputPin_NotifyAllocator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemInputPin_GetAllocatorRequirements_Proxy( + IMemInputPin* This, + ALLOCATOR_PROPERTIES* pProps); +void __RPC_STUB IMemInputPin_GetAllocatorRequirements_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemInputPin_Receive_Proxy( + IMemInputPin* This, + IMediaSample* pSample); +void __RPC_STUB IMemInputPin_Receive_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemInputPin_ReceiveMultiple_Proxy( + IMemInputPin* This, + IMediaSample** pSamples, + long nSamples, + long* nSamplesProcessed); +void __RPC_STUB IMemInputPin_ReceiveMultiple_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMemInputPin_ReceiveCanBlock_Proxy( + IMemInputPin* This); +void __RPC_STUB IMemInputPin_ReceiveCanBlock_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMemInputPin_INTERFACE_DEFINED__ */ + +typedef IMemInputPin *PMEMINPUTPIN; + +/***************************************************************************** + * IAMovieSetup interface + */ +#ifndef __IAMovieSetup_INTERFACE_DEFINED__ +#define __IAMovieSetup_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMovieSetup, 0xa3d8cec0, 0x7e5a, 0x11cf, 0xbb,0xc5, 0x00,0x80,0x5f,0x6c,0xef,0x20); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAMovieSetup : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Register( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unregister( + ) = 0; + +}; +#else +typedef struct IAMovieSetupVtbl IAMovieSetupVtbl; +struct IAMovieSetup { + const IAMovieSetupVtbl* lpVtbl; +}; +struct IAMovieSetupVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMovieSetup* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMovieSetup* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMovieSetup* This); + + /*** IAMovieSetup methods ***/ + HRESULT (STDMETHODCALLTYPE *Register)( + IAMovieSetup* This); + + HRESULT (STDMETHODCALLTYPE *Unregister)( + IAMovieSetup* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAMovieSetup_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAMovieSetup_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAMovieSetup_Release(p) (p)->lpVtbl->Release(p) +/*** IAMovieSetup methods ***/ +#define IAMovieSetup_Register(p) (p)->lpVtbl->Register(p) +#define IAMovieSetup_Unregister(p) (p)->lpVtbl->Unregister(p) +#endif + +#endif + +#define IAMovieSetup_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IAMovieSetup methods ***/ \ + STDMETHOD_(HRESULT,Register)(THIS) PURE; \ + STDMETHOD_(HRESULT,Unregister)(THIS) PURE; + +HRESULT CALLBACK IAMovieSetup_Register_Proxy( + IAMovieSetup* This); +void __RPC_STUB IAMovieSetup_Register_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAMovieSetup_Unregister_Proxy( + IAMovieSetup* This); +void __RPC_STUB IAMovieSetup_Unregister_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMovieSetup_INTERFACE_DEFINED__ */ + +typedef IAMovieSetup *PAMOVIESETUP; + +typedef enum AM_SEEKING_SeekingFlags { + AM_SEEKING_NoPositioning = 0x0, + AM_SEEKING_AbsolutePositioning = 0x1, + AM_SEEKING_RelativePositioning = 0x2, + AM_SEEKING_IncrementalPositioning = 0x3, + AM_SEEKING_PositioningBitsMask = 0x3, + AM_SEEKING_SeekToKeyFrame = 0x4, + AM_SEEKING_ReturnTime = 0x8, + AM_SEEKING_Segment = 0x10, + AM_SEEKING_NoFlush = 0x20 +} AM_SEEKING_SEEKING_FLAGS; + +typedef enum AM_SEEKING_SeekingCapabilities { + AM_SEEKING_CanSeekAbsolute = 0x1, + AM_SEEKING_CanSeekForwards = 0x2, + AM_SEEKING_CanSeekBackwards = 0x4, + AM_SEEKING_CanGetCurrentPos = 0x8, + AM_SEEKING_CanGetStopPos = 0x10, + AM_SEEKING_CanGetDuration = 0x20, + AM_SEEKING_CanPlayBackwards = 0x40, + AM_SEEKING_CanDoSegments = 0x80, + AM_SEEKING_Source = 0x100 +} AM_SEEKING_SEEKING_CAPABILITIES; + +#ifndef __IMediaSeeking_FWD_DEFINED__ +#define __IMediaSeeking_FWD_DEFINED__ +typedef struct IMediaSeeking IMediaSeeking; +#endif + +/***************************************************************************** + * IMediaSeeking interface + */ +#ifndef __IMediaSeeking_INTERFACE_DEFINED__ +#define __IMediaSeeking_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMediaSeeking, 0x36b73880, 0xc2c8, 0x11cf, 0x8b,0x46, 0x00,0x80,0x5f,0x6c,0xef,0x60); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMediaSeeking : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetCapabilities( + DWORD* pCapabilities) = 0; + + virtual HRESULT STDMETHODCALLTYPE CheckCapabilities( + DWORD* pCapabilities) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsFormatSupported( + const GUID* pFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryPreferredFormat( + GUID* pFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeFormat( + GUID* pFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsUsingTimeFormat( + const GUID* pFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimeFormat( + const GUID* pFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDuration( + LONGLONG* pDuration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStopPosition( + LONGLONG* pStop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentPosition( + LONGLONG* pCurrent) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConvertTimeFormat( + LONGLONG* pTarget, + const GUID* pTargetFormat, + LONGLONG Source, + const GUID* pSourceFormat) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPositions( + LONGLONG* pCurrent, + DWORD dwCurrentFlags, + LONGLONG* pStop, + DWORD dwStopFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPositions( + LONGLONG* pCurrent, + LONGLONG* pStop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAvailable( + LONGLONG* pEarliest, + LONGLONG* pLatest) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRate( + double dRate) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRate( + double* pdRate) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPreroll( + LONGLONG* pllPreroll) = 0; + +}; +#else +typedef struct IMediaSeekingVtbl IMediaSeekingVtbl; +struct IMediaSeeking { + const IMediaSeekingVtbl* lpVtbl; +}; +struct IMediaSeekingVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMediaSeeking* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMediaSeeking* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMediaSeeking* This); + + /*** IMediaSeeking methods ***/ + HRESULT (STDMETHODCALLTYPE *GetCapabilities)( + IMediaSeeking* This, + DWORD* pCapabilities); + + HRESULT (STDMETHODCALLTYPE *CheckCapabilities)( + IMediaSeeking* This, + DWORD* pCapabilities); + + HRESULT (STDMETHODCALLTYPE *IsFormatSupported)( + IMediaSeeking* This, + const GUID* pFormat); + + HRESULT (STDMETHODCALLTYPE *QueryPreferredFormat)( + IMediaSeeking* This, + GUID* pFormat); + + HRESULT (STDMETHODCALLTYPE *GetTimeFormat)( + IMediaSeeking* This, + GUID* pFormat); + + HRESULT (STDMETHODCALLTYPE *IsUsingTimeFormat)( + IMediaSeeking* This, + const GUID* pFormat); + + HRESULT (STDMETHODCALLTYPE *SetTimeFormat)( + IMediaSeeking* This, + const GUID* pFormat); + + HRESULT (STDMETHODCALLTYPE *GetDuration)( + IMediaSeeking* This, + LONGLONG* pDuration); + + HRESULT (STDMETHODCALLTYPE *GetStopPosition)( + IMediaSeeking* This, + LONGLONG* pStop); + + HRESULT (STDMETHODCALLTYPE *GetCurrentPosition)( + IMediaSeeking* This, + LONGLONG* pCurrent); + + HRESULT (STDMETHODCALLTYPE *ConvertTimeFormat)( + IMediaSeeking* This, + LONGLONG* pTarget, + const GUID* pTargetFormat, + LONGLONG Source, + const GUID* pSourceFormat); + + HRESULT (STDMETHODCALLTYPE *SetPositions)( + IMediaSeeking* This, + LONGLONG* pCurrent, + DWORD dwCurrentFlags, + LONGLONG* pStop, + DWORD dwStopFlags); + + HRESULT (STDMETHODCALLTYPE *GetPositions)( + IMediaSeeking* This, + LONGLONG* pCurrent, + LONGLONG* pStop); + + HRESULT (STDMETHODCALLTYPE *GetAvailable)( + IMediaSeeking* This, + LONGLONG* pEarliest, + LONGLONG* pLatest); + + HRESULT (STDMETHODCALLTYPE *SetRate)( + IMediaSeeking* This, + double dRate); + + HRESULT (STDMETHODCALLTYPE *GetRate)( + IMediaSeeking* This, + double* pdRate); + + HRESULT (STDMETHODCALLTYPE *GetPreroll)( + IMediaSeeking* This, + LONGLONG* pllPreroll); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMediaSeeking_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaSeeking_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaSeeking_Release(p) (p)->lpVtbl->Release(p) +/*** IMediaSeeking methods ***/ +#define IMediaSeeking_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a) +#define IMediaSeeking_CheckCapabilities(p,a) (p)->lpVtbl->CheckCapabilities(p,a) +#define IMediaSeeking_IsFormatSupported(p,a) (p)->lpVtbl->IsFormatSupported(p,a) +#define IMediaSeeking_QueryPreferredFormat(p,a) (p)->lpVtbl->QueryPreferredFormat(p,a) +#define IMediaSeeking_GetTimeFormat(p,a) (p)->lpVtbl->GetTimeFormat(p,a) +#define IMediaSeeking_IsUsingTimeFormat(p,a) (p)->lpVtbl->IsUsingTimeFormat(p,a) +#define IMediaSeeking_SetTimeFormat(p,a) (p)->lpVtbl->SetTimeFormat(p,a) +#define IMediaSeeking_GetDuration(p,a) (p)->lpVtbl->GetDuration(p,a) +#define IMediaSeeking_GetStopPosition(p,a) (p)->lpVtbl->GetStopPosition(p,a) +#define IMediaSeeking_GetCurrentPosition(p,a) (p)->lpVtbl->GetCurrentPosition(p,a) +#define IMediaSeeking_ConvertTimeFormat(p,a,b,c,d) (p)->lpVtbl->ConvertTimeFormat(p,a,b,c,d) +#define IMediaSeeking_SetPositions(p,a,b,c,d) (p)->lpVtbl->SetPositions(p,a,b,c,d) +#define IMediaSeeking_GetPositions(p,a,b) (p)->lpVtbl->GetPositions(p,a,b) +#define IMediaSeeking_GetAvailable(p,a,b) (p)->lpVtbl->GetAvailable(p,a,b) +#define IMediaSeeking_SetRate(p,a) (p)->lpVtbl->SetRate(p,a) +#define IMediaSeeking_GetRate(p,a) (p)->lpVtbl->GetRate(p,a) +#define IMediaSeeking_GetPreroll(p,a) (p)->lpVtbl->GetPreroll(p,a) +#endif + +#endif + +#define IMediaSeeking_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMediaSeeking methods ***/ \ + STDMETHOD_(HRESULT,GetCapabilities)(THIS_ DWORD* pCapabilities) PURE; \ + STDMETHOD_(HRESULT,CheckCapabilities)(THIS_ DWORD* pCapabilities) PURE; \ + STDMETHOD_(HRESULT,IsFormatSupported)(THIS_ const GUID* pFormat) PURE; \ + STDMETHOD_(HRESULT,QueryPreferredFormat)(THIS_ GUID* pFormat) PURE; \ + STDMETHOD_(HRESULT,GetTimeFormat)(THIS_ GUID* pFormat) PURE; \ + STDMETHOD_(HRESULT,IsUsingTimeFormat)(THIS_ const GUID* pFormat) PURE; \ + STDMETHOD_(HRESULT,SetTimeFormat)(THIS_ const GUID* pFormat) PURE; \ + STDMETHOD_(HRESULT,GetDuration)(THIS_ LONGLONG* pDuration) PURE; \ + STDMETHOD_(HRESULT,GetStopPosition)(THIS_ LONGLONG* pStop) PURE; \ + STDMETHOD_(HRESULT,GetCurrentPosition)(THIS_ LONGLONG* pCurrent) PURE; \ + STDMETHOD_(HRESULT,ConvertTimeFormat)(THIS_ LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat) PURE; \ + STDMETHOD_(HRESULT,SetPositions)(THIS_ LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags) PURE; \ + STDMETHOD_(HRESULT,GetPositions)(THIS_ LONGLONG* pCurrent, LONGLONG* pStop) PURE; \ + STDMETHOD_(HRESULT,GetAvailable)(THIS_ LONGLONG* pEarliest, LONGLONG* pLatest) PURE; \ + STDMETHOD_(HRESULT,SetRate)(THIS_ double dRate) PURE; \ + STDMETHOD_(HRESULT,GetRate)(THIS_ double* pdRate) PURE; \ + STDMETHOD_(HRESULT,GetPreroll)(THIS_ LONGLONG* pllPreroll) PURE; + +HRESULT CALLBACK IMediaSeeking_GetCapabilities_Proxy( + IMediaSeeking* This, + DWORD* pCapabilities); +void __RPC_STUB IMediaSeeking_GetCapabilities_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_CheckCapabilities_Proxy( + IMediaSeeking* This, + DWORD* pCapabilities); +void __RPC_STUB IMediaSeeking_CheckCapabilities_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_IsFormatSupported_Proxy( + IMediaSeeking* This, + const GUID* pFormat); +void __RPC_STUB IMediaSeeking_IsFormatSupported_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_QueryPreferredFormat_Proxy( + IMediaSeeking* This, + GUID* pFormat); +void __RPC_STUB IMediaSeeking_QueryPreferredFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetTimeFormat_Proxy( + IMediaSeeking* This, + GUID* pFormat); +void __RPC_STUB IMediaSeeking_GetTimeFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_IsUsingTimeFormat_Proxy( + IMediaSeeking* This, + const GUID* pFormat); +void __RPC_STUB IMediaSeeking_IsUsingTimeFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_SetTimeFormat_Proxy( + IMediaSeeking* This, + const GUID* pFormat); +void __RPC_STUB IMediaSeeking_SetTimeFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetDuration_Proxy( + IMediaSeeking* This, + LONGLONG* pDuration); +void __RPC_STUB IMediaSeeking_GetDuration_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetStopPosition_Proxy( + IMediaSeeking* This, + LONGLONG* pStop); +void __RPC_STUB IMediaSeeking_GetStopPosition_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetCurrentPosition_Proxy( + IMediaSeeking* This, + LONGLONG* pCurrent); +void __RPC_STUB IMediaSeeking_GetCurrentPosition_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_ConvertTimeFormat_Proxy( + IMediaSeeking* This, + LONGLONG* pTarget, + const GUID* pTargetFormat, + LONGLONG Source, + const GUID* pSourceFormat); +void __RPC_STUB IMediaSeeking_ConvertTimeFormat_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_SetPositions_Proxy( + IMediaSeeking* This, + LONGLONG* pCurrent, + DWORD dwCurrentFlags, + LONGLONG* pStop, + DWORD dwStopFlags); +void __RPC_STUB IMediaSeeking_SetPositions_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetPositions_Proxy( + IMediaSeeking* This, + LONGLONG* pCurrent, + LONGLONG* pStop); +void __RPC_STUB IMediaSeeking_GetPositions_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetAvailable_Proxy( + IMediaSeeking* This, + LONGLONG* pEarliest, + LONGLONG* pLatest); +void __RPC_STUB IMediaSeeking_GetAvailable_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_SetRate_Proxy( + IMediaSeeking* This, + double dRate); +void __RPC_STUB IMediaSeeking_SetRate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetRate_Proxy( + IMediaSeeking* This, + double* pdRate); +void __RPC_STUB IMediaSeeking_GetRate_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IMediaSeeking_GetPreroll_Proxy( + IMediaSeeking* This, + LONGLONG* pllPreroll); +void __RPC_STUB IMediaSeeking_GetPreroll_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMediaSeeking_INTERFACE_DEFINED__ */ + +typedef IMediaSeeking *PMEDIASEEKING; + +enum tagAM_MEDIAEVENT_FLAGS { + AM_MEDIAEVENT_NONOTIFY = 0x1 +}; + +#ifndef __IAMAnalogVideoDecoder_FWD_DEFINED__ +#define __IAMAnalogVideoDecoder_FWD_DEFINED__ +typedef struct IAMAnalogVideoDecoder IAMAnalogVideoDecoder; +#endif + +#ifndef __IAMAnalogVideoEncoder_FWD_DEFINED__ +#define __IAMAnalogVideoEncoder_FWD_DEFINED__ +typedef struct IAMAnalogVideoEncoder IAMAnalogVideoEncoder; +#endif + +#ifndef __IAMAudioInputMixer_FWD_DEFINED__ +#define __IAMAudioInputMixer_FWD_DEFINED__ +typedef struct IAMAudioInputMixer IAMAudioInputMixer; +#endif + +#ifndef __IAMAudioRendererStats_FWD_DEFINED__ +#define __IAMAudioRendererStats_FWD_DEFINED__ +typedef struct IAMAudioRendererStats IAMAudioRendererStats; +#endif + +#ifndef __IAMBufferNegotiation_FWD_DEFINED__ +#define __IAMBufferNegotiation_FWD_DEFINED__ +typedef struct IAMBufferNegotiation IAMBufferNegotiation; +#endif + +#ifndef __IAMCameraControl_FWD_DEFINED__ +#define __IAMCameraControl_FWD_DEFINED__ +typedef struct IAMCameraControl IAMCameraControl; +#endif + +#ifndef __IAMCopyCaptureFileProgress_FWD_DEFINED__ +#define __IAMCopyCaptureFileProgress_FWD_DEFINED__ +typedef struct IAMCopyCaptureFileProgress IAMCopyCaptureFileProgress; +#endif + +#ifndef __IAMCrossbar_FWD_DEFINED__ +#define __IAMCrossbar_FWD_DEFINED__ +typedef struct IAMCrossbar IAMCrossbar; +#endif + +#ifndef __IAMDevMemoryAllocator_FWD_DEFINED__ +#define __IAMDevMemoryAllocator_FWD_DEFINED__ +typedef struct IAMDevMemoryAllocator IAMDevMemoryAllocator; +#endif + +#ifndef __IAMDevMemoryControl_FWD_DEFINED__ +#define __IAMDevMemoryControl_FWD_DEFINED__ +typedef struct IAMDevMemoryControl IAMDevMemoryControl; +#endif + +#ifndef __IAMDroppedFrames_FWD_DEFINED__ +#define __IAMDroppedFrames_FWD_DEFINED__ +typedef struct IAMDroppedFrames IAMDroppedFrames; +#endif + +#ifndef __IAMExtDevice_FWD_DEFINED__ +#define __IAMExtDevice_FWD_DEFINED__ +typedef struct IAMExtDevice IAMExtDevice; +#endif + +#ifndef __IAMExtTransport_FWD_DEFINED__ +#define __IAMExtTransport_FWD_DEFINED__ +typedef struct IAMExtTransport IAMExtTransport; +#endif + +#ifndef __IAMGraphStreams_FWD_DEFINED__ +#define __IAMGraphStreams_FWD_DEFINED__ +typedef struct IAMGraphStreams IAMGraphStreams; +#endif + +#ifndef __IAMLatency_FWD_DEFINED__ +#define __IAMLatency_FWD_DEFINED__ +typedef struct IAMLatency IAMLatency; +#endif + +#ifndef __IAMOpenProgress_FWD_DEFINED__ +#define __IAMOpenProgress_FWD_DEFINED__ +typedef struct IAMOpenProgress IAMOpenProgress; +#endif + +#ifndef __IAMOverlayFX_FWD_DEFINED__ +#define __IAMOverlayFX_FWD_DEFINED__ +typedef struct IAMOverlayFX IAMOverlayFX; +#endif + +#ifndef __IAMPhysicalPinInfo_FWD_DEFINED__ +#define __IAMPhysicalPinInfo_FWD_DEFINED__ +typedef struct IAMPhysicalPinInfo IAMPhysicalPinInfo; +#endif + +#ifndef __IAMPushSource_FWD_DEFINED__ +#define __IAMPushSource_FWD_DEFINED__ +typedef struct IAMPushSource IAMPushSource; +#endif + +#ifndef __IAMStreamConfig_FWD_DEFINED__ +#define __IAMStreamConfig_FWD_DEFINED__ +typedef struct IAMStreamConfig IAMStreamConfig; +#endif + +#ifndef __IAMTimecodeDisplay_FWD_DEFINED__ +#define __IAMTimecodeDisplay_FWD_DEFINED__ +typedef struct IAMTimecodeDisplay IAMTimecodeDisplay; +#endif + +#ifndef __IAMTimecodeGenerator_FWD_DEFINED__ +#define __IAMTimecodeGenerator_FWD_DEFINED__ +typedef struct IAMTimecodeGenerator IAMTimecodeGenerator; +#endif + +#ifndef __IAMTimecodeReader_FWD_DEFINED__ +#define __IAMTimecodeReader_FWD_DEFINED__ +typedef struct IAMTimecodeReader IAMTimecodeReader; +#endif + +#ifndef __IAMTVTuner_FWD_DEFINED__ +#define __IAMTVTuner_FWD_DEFINED__ +typedef struct IAMTVTuner IAMTVTuner; +#endif + +#ifndef __IAMVfwCaptureDialogs_FWD_DEFINED__ +#define __IAMVfwCaptureDialogs_FWD_DEFINED__ +typedef struct IAMVfwCaptureDialogs IAMVfwCaptureDialogs; +#endif + +#ifndef __IAMVfwCompressDialogs_FWD_DEFINED__ +#define __IAMVfwCompressDialogs_FWD_DEFINED__ +typedef struct IAMVfwCompressDialogs IAMVfwCompressDialogs; +#endif + +#ifndef __IAMVideoCompression_FWD_DEFINED__ +#define __IAMVideoCompression_FWD_DEFINED__ +typedef struct IAMVideoCompression IAMVideoCompression; +#endif + +#ifndef __IAMVideoDecimationProperties_FWD_DEFINED__ +#define __IAMVideoDecimationProperties_FWD_DEFINED__ +typedef struct IAMVideoDecimationProperties IAMVideoDecimationProperties; +#endif + +#ifndef __IAMVideoProcAmp_FWD_DEFINED__ +#define __IAMVideoProcAmp_FWD_DEFINED__ +typedef struct IAMVideoProcAmp IAMVideoProcAmp; +#endif + +#ifndef __ICaptureGraphBuilder_FWD_DEFINED__ +#define __ICaptureGraphBuilder_FWD_DEFINED__ +typedef struct ICaptureGraphBuilder ICaptureGraphBuilder; +#endif + +#ifndef __ICaptureGraphBuilder2_FWD_DEFINED__ +#define __ICaptureGraphBuilder2_FWD_DEFINED__ +typedef struct ICaptureGraphBuilder2 ICaptureGraphBuilder2; +#endif + +#ifndef __IConfigAviMux_FWD_DEFINED__ +#define __IConfigAviMux_FWD_DEFINED__ +typedef struct IConfigAviMux IConfigAviMux; +#endif + +#ifndef __IConfigInterleaving_FWD_DEFINED__ +#define __IConfigInterleaving_FWD_DEFINED__ +typedef struct IConfigInterleaving IConfigInterleaving; +#endif + +#ifndef __IDecimateVideoImage_FWD_DEFINED__ +#define __IDecimateVideoImage_FWD_DEFINED__ +typedef struct IDecimateVideoImage IDecimateVideoImage; +#endif + +#ifndef __IDrawVideoImage_FWD_DEFINED__ +#define __IDrawVideoImage_FWD_DEFINED__ +typedef struct IDrawVideoImage IDrawVideoImage; +#endif + +#ifndef __IEnumRegFilters_FWD_DEFINED__ +#define __IEnumRegFilters_FWD_DEFINED__ +typedef struct IEnumRegFilters IEnumRegFilters; +#endif + +#ifndef __IEnumStreamIdMap_FWD_DEFINED__ +#define __IEnumStreamIdMap_FWD_DEFINED__ +typedef struct IEnumStreamIdMap IEnumStreamIdMap; +#endif + +#ifndef __IFileSourceFilter_FWD_DEFINED__ +#define __IFileSourceFilter_FWD_DEFINED__ +typedef struct IFileSourceFilter IFileSourceFilter; +#endif + +#ifndef __IFileSinkFilter_FWD_DEFINED__ +#define __IFileSinkFilter_FWD_DEFINED__ +typedef struct IFileSinkFilter IFileSinkFilter; +#endif + +#ifndef __IFileSinkFilter2_FWD_DEFINED__ +#define __IFileSinkFilter2_FWD_DEFINED__ +typedef struct IFileSinkFilter2 IFileSinkFilter2; +#endif + +#ifndef __IFilterMapper_FWD_DEFINED__ +#define __IFilterMapper_FWD_DEFINED__ +typedef struct IFilterMapper IFilterMapper; +#endif + +#ifndef __IFilterMapper2_FWD_DEFINED__ +#define __IFilterMapper2_FWD_DEFINED__ +typedef struct IFilterMapper2 IFilterMapper2; +#endif + +#ifndef __IGraphBuilder_FWD_DEFINED__ +#define __IGraphBuilder_FWD_DEFINED__ +typedef struct IGraphBuilder IGraphBuilder; +#endif + +#ifndef __IKsPropertySet_FWD_DEFINED__ +#define __IKsPropertySet_FWD_DEFINED__ +typedef struct IKsPropertySet IKsPropertySet; +#endif + +#ifndef __IMediaEventSink_FWD_DEFINED__ +#define __IMediaEventSink_FWD_DEFINED__ +typedef struct IMediaEventSink IMediaEventSink; +#endif + +#ifndef __IMpeg2Demultiplexer_FWD_DEFINED__ +#define __IMpeg2Demultiplexer_FWD_DEFINED__ +typedef struct IMpeg2Demultiplexer IMpeg2Demultiplexer; +#endif + +#ifndef __IMPEG2StreamIdMap_FWD_DEFINED__ +#define __IMPEG2StreamIdMap_FWD_DEFINED__ +typedef struct IMPEG2StreamIdMap IMPEG2StreamIdMap; +#endif + +#ifndef __IOverlay_FWD_DEFINED__ +#define __IOverlay_FWD_DEFINED__ +typedef struct IOverlay IOverlay; +#endif + +#ifndef __IOverlayNotify_FWD_DEFINED__ +#define __IOverlayNotify_FWD_DEFINED__ +typedef struct IOverlayNotify IOverlayNotify; +#endif + +#ifndef __IOverlayNotify2_FWD_DEFINED__ +#define __IOverlayNotify2_FWD_DEFINED__ +typedef struct IOverlayNotify2 IOverlayNotify2; +#endif + +#ifndef __IQualityControl_FWD_DEFINED__ +#define __IQualityControl_FWD_DEFINED__ +typedef struct IQualityControl IQualityControl; +#endif + +#ifndef __ISeekingPassThru_FWD_DEFINED__ +#define __ISeekingPassThru_FWD_DEFINED__ +typedef struct ISeekingPassThru ISeekingPassThru; +#endif + +typedef struct { + CLSID Clsid; + LPWSTR Name; +} REGFILTER; + +/***************************************************************************** + * IEnumRegFilters interface + */ +#ifndef __IEnumRegFilters_INTERFACE_DEFINED__ +#define __IEnumRegFilters_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IEnumRegFilters, 0x56a868a4, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IEnumRegFilters : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Next( + ULONG cFilters, + REGFILTER** apRegFilter, + ULONG* pcFetched) = 0; + + virtual HRESULT STDMETHODCALLTYPE Skip( + ULONG cFilters) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + IEnumRegFilters** ppEnum) = 0; + +}; +#else +typedef struct IEnumRegFiltersVtbl IEnumRegFiltersVtbl; +struct IEnumRegFilters { + const IEnumRegFiltersVtbl* lpVtbl; +}; +struct IEnumRegFiltersVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IEnumRegFilters* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IEnumRegFilters* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IEnumRegFilters* This); + + /*** IEnumRegFilters methods ***/ + HRESULT (STDMETHODCALLTYPE *Next)( + IEnumRegFilters* This, + ULONG cFilters, + REGFILTER** apRegFilter, + ULONG* pcFetched); + + HRESULT (STDMETHODCALLTYPE *Skip)( + IEnumRegFilters* This, + ULONG cFilters); + + HRESULT (STDMETHODCALLTYPE *Reset)( + IEnumRegFilters* This); + + HRESULT (STDMETHODCALLTYPE *Clone)( + IEnumRegFilters* This, + IEnumRegFilters** ppEnum); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IEnumRegFilters_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IEnumRegFilters_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IEnumRegFilters_Release(p) (p)->lpVtbl->Release(p) +/*** IEnumRegFilters methods ***/ +#define IEnumRegFilters_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c) +#define IEnumRegFilters_Skip(p,a) (p)->lpVtbl->Skip(p,a) +#define IEnumRegFilters_Reset(p) (p)->lpVtbl->Reset(p) +#define IEnumRegFilters_Clone(p,a) (p)->lpVtbl->Clone(p,a) +#endif + +#endif + +#define IEnumRegFilters_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IEnumRegFilters methods ***/ \ + STDMETHOD_(HRESULT,Next)(THIS_ ULONG cFilters, REGFILTER** apRegFilter, ULONG* pcFetched) PURE; \ + STDMETHOD_(HRESULT,Skip)(THIS_ ULONG cFilters) PURE; \ + STDMETHOD_(HRESULT,Reset)(THIS) PURE; \ + STDMETHOD_(HRESULT,Clone)(THIS_ IEnumRegFilters** ppEnum) PURE; + +HRESULT CALLBACK IEnumRegFilters_Next_Proxy( + IEnumRegFilters* This, + ULONG cFilters, + REGFILTER** apRegFilter, + ULONG* pcFetched); +void __RPC_STUB IEnumRegFilters_Next_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumRegFilters_Skip_Proxy( + IEnumRegFilters* This, + ULONG cFilters); +void __RPC_STUB IEnumRegFilters_Skip_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumRegFilters_Reset_Proxy( + IEnumRegFilters* This); +void __RPC_STUB IEnumRegFilters_Reset_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IEnumRegFilters_Clone_Proxy( + IEnumRegFilters* This, + IEnumRegFilters** ppEnum); +void __RPC_STUB IEnumRegFilters_Clone_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IEnumRegFilters_INTERFACE_DEFINED__ */ + +typedef IEnumRegFilters *PENUMREGFILTERS; + +enum { + MERIT_PREFERRED = 0x800000, + MERIT_NORMAL = 0x600000, + MERIT_UNLIKELY = 0x400000, + MERIT_DO_NOT_USE = 0x200000, + MERIT_SW_COMPRESSOR = 0x100000, + MERIT_HW_COMPRESSOR = 0x100050 +}; + +/***************************************************************************** + * IFilterMapper interface + */ +#ifndef __IFilterMapper_INTERFACE_DEFINED__ +#define __IFilterMapper_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFilterMapper, 0x56a868a3, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFilterMapper : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE RegisterFilter( + CLSID clsid, + LPCWSTR Name, + DWORD dwMerit) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterFilterInstance( + CLSID clsid, + LPCWSTR Name, + CLSID* MRId) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterPin( + CLSID Filter, + LPCWSTR Name, + BOOL bRendered, + BOOL bOutput, + BOOL bZero, + BOOL bMany, + CLSID ConnectsToFilter, + LPCWSTR ConnectsToPin) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterPinType( + CLSID clsFilter, + LPCWSTR strName, + CLSID clsMajorType, + CLSID clsSubType) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterFilter( + CLSID Filter) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterFilterInstance( + CLSID MRId) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterPin( + CLSID Filter, + LPCWSTR Name) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumMatchingFilters( + IEnumRegFilters** ppEnum, + DWORD dwMerit, + BOOL bInputNeeded, + CLSID clsInMaj, + CLSID clsInSub, + BOOL bRender, + BOOL bOututNeeded, + CLSID clsOutMaj, + CLSID clsOutSub) = 0; + +}; +#else +typedef struct IFilterMapperVtbl IFilterMapperVtbl; +struct IFilterMapper { + const IFilterMapperVtbl* lpVtbl; +}; +struct IFilterMapperVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFilterMapper* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFilterMapper* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFilterMapper* This); + + /*** IFilterMapper methods ***/ + HRESULT (STDMETHODCALLTYPE *RegisterFilter)( + IFilterMapper* This, + CLSID clsid, + LPCWSTR Name, + DWORD dwMerit); + + HRESULT (STDMETHODCALLTYPE *RegisterFilterInstance)( + IFilterMapper* This, + CLSID clsid, + LPCWSTR Name, + CLSID* MRId); + + HRESULT (STDMETHODCALLTYPE *RegisterPin)( + IFilterMapper* This, + CLSID Filter, + LPCWSTR Name, + BOOL bRendered, + BOOL bOutput, + BOOL bZero, + BOOL bMany, + CLSID ConnectsToFilter, + LPCWSTR ConnectsToPin); + + HRESULT (STDMETHODCALLTYPE *RegisterPinType)( + IFilterMapper* This, + CLSID clsFilter, + LPCWSTR strName, + CLSID clsMajorType, + CLSID clsSubType); + + HRESULT (STDMETHODCALLTYPE *UnregisterFilter)( + IFilterMapper* This, + CLSID Filter); + + HRESULT (STDMETHODCALLTYPE *UnregisterFilterInstance)( + IFilterMapper* This, + CLSID MRId); + + HRESULT (STDMETHODCALLTYPE *UnregisterPin)( + IFilterMapper* This, + CLSID Filter, + LPCWSTR Name); + + HRESULT (STDMETHODCALLTYPE *EnumMatchingFilters)( + IFilterMapper* This, + IEnumRegFilters** ppEnum, + DWORD dwMerit, + BOOL bInputNeeded, + CLSID clsInMaj, + CLSID clsInSub, + BOOL bRender, + BOOL bOututNeeded, + CLSID clsOutMaj, + CLSID clsOutSub); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFilterMapper_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterMapper_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterMapper_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterMapper methods ***/ +#define IFilterMapper_RegisterFilter(p,a,b,c) (p)->lpVtbl->RegisterFilter(p,a,b,c) +#define IFilterMapper_RegisterFilterInstance(p,a,b,c) (p)->lpVtbl->RegisterFilterInstance(p,a,b,c) +#define IFilterMapper_RegisterPin(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->RegisterPin(p,a,b,c,d,e,f,g,h) +#define IFilterMapper_RegisterPinType(p,a,b,c,d) (p)->lpVtbl->RegisterPinType(p,a,b,c,d) +#define IFilterMapper_UnregisterFilter(p,a) (p)->lpVtbl->UnregisterFilter(p,a) +#define IFilterMapper_UnregisterFilterInstance(p,a) (p)->lpVtbl->UnregisterFilterInstance(p,a) +#define IFilterMapper_UnregisterPin(p,a,b) (p)->lpVtbl->UnregisterPin(p,a,b) +#define IFilterMapper_EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i) +#endif + +#endif + +#define IFilterMapper_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterMapper methods ***/ \ + STDMETHOD_(HRESULT,RegisterFilter)(THIS_ CLSID clsid, LPCWSTR Name, DWORD dwMerit) PURE; \ + STDMETHOD_(HRESULT,RegisterFilterInstance)(THIS_ CLSID clsid, LPCWSTR Name, CLSID* MRId) PURE; \ + STDMETHOD_(HRESULT,RegisterPin)(THIS_ CLSID Filter, LPCWSTR Name, BOOL bRendered, BOOL bOutput, BOOL bZero, BOOL bMany, CLSID ConnectsToFilter, LPCWSTR ConnectsToPin) PURE; \ + STDMETHOD_(HRESULT,RegisterPinType)(THIS_ CLSID clsFilter, LPCWSTR strName, CLSID clsMajorType, CLSID clsSubType) PURE; \ + STDMETHOD_(HRESULT,UnregisterFilter)(THIS_ CLSID Filter) PURE; \ + STDMETHOD_(HRESULT,UnregisterFilterInstance)(THIS_ CLSID MRId) PURE; \ + STDMETHOD_(HRESULT,UnregisterPin)(THIS_ CLSID Filter, LPCWSTR Name) PURE; \ + STDMETHOD_(HRESULT,EnumMatchingFilters)(THIS_ IEnumRegFilters** ppEnum, DWORD dwMerit, BOOL bInputNeeded, CLSID clsInMaj, CLSID clsInSub, BOOL bRender, BOOL bOututNeeded, CLSID clsOutMaj, CLSID clsOutSub) PURE; + +HRESULT CALLBACK IFilterMapper_RegisterFilter_Proxy( + IFilterMapper* This, + CLSID clsid, + LPCWSTR Name, + DWORD dwMerit); +void __RPC_STUB IFilterMapper_RegisterFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_RegisterFilterInstance_Proxy( + IFilterMapper* This, + CLSID clsid, + LPCWSTR Name, + CLSID* MRId); +void __RPC_STUB IFilterMapper_RegisterFilterInstance_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_RegisterPin_Proxy( + IFilterMapper* This, + CLSID Filter, + LPCWSTR Name, + BOOL bRendered, + BOOL bOutput, + BOOL bZero, + BOOL bMany, + CLSID ConnectsToFilter, + LPCWSTR ConnectsToPin); +void __RPC_STUB IFilterMapper_RegisterPin_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_RegisterPinType_Proxy( + IFilterMapper* This, + CLSID clsFilter, + LPCWSTR strName, + CLSID clsMajorType, + CLSID clsSubType); +void __RPC_STUB IFilterMapper_RegisterPinType_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_UnregisterFilter_Proxy( + IFilterMapper* This, + CLSID Filter); +void __RPC_STUB IFilterMapper_UnregisterFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_UnregisterFilterInstance_Proxy( + IFilterMapper* This, + CLSID MRId); +void __RPC_STUB IFilterMapper_UnregisterFilterInstance_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_UnregisterPin_Proxy( + IFilterMapper* This, + CLSID Filter, + LPCWSTR Name); +void __RPC_STUB IFilterMapper_UnregisterPin_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper_EnumMatchingFilters_Proxy( + IFilterMapper* This, + IEnumRegFilters** ppEnum, + DWORD dwMerit, + BOOL bInputNeeded, + CLSID clsInMaj, + CLSID clsInSub, + BOOL bRender, + BOOL bOututNeeded, + CLSID clsOutMaj, + CLSID clsOutSub); +void __RPC_STUB IFilterMapper_EnumMatchingFilters_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFilterMapper_INTERFACE_DEFINED__ */ + +typedef struct { + const CLSID *clsMajorType; + const CLSID *clsMinorType; +} REGPINTYPES; + +typedef struct { + LPWSTR strName; + BOOL bRendered; + BOOL bOutput; + BOOL bZero; + BOOL bMany; + const CLSID *clsConnectsToFilter; + const WCHAR *strConnectsToPin; + UINT nMediaTypes; + const REGPINTYPES *lpMediaType; +} REGFILTERPINS; + +typedef struct { + CLSID clsMedium; + DWORD dw1; + DWORD dw2; +} REGPINMEDIUM; + +enum { + REG_PINFLAG_B_ZERO = 0x1, + REG_PINFLAG_B_RENDERER = 0x2, + REG_PINFLAG_B_MANY = 0x4, + REG_PINFLAG_B_OUTPUT = 0x8 +}; + +typedef struct { + DWORD dwFlags; + UINT cInstances; + UINT nMediaTypes; + const REGPINTYPES *lpMediaType; + UINT nMediums; + const REGPINMEDIUM *lpMedium; + const CLSID *clsPinCategory; +} REGFILTERPINS2; + +typedef struct { + DWORD dwVersion; + DWORD dwMerit; + union { + struct { + ULONG cPins; + const REGFILTERPINS *rgPins; + } DUMMYSTRUCTNAME; + struct { + ULONG cPins2; + const REGFILTERPINS2 *rgPins2; + } DUMMYSTRUCTNAME1; + } DUMMYUNIONNAME; +} REGFILTER2; + +/***************************************************************************** + * IFilterMapper2 interface + */ +#ifndef __IFilterMapper2_INTERFACE_DEFINED__ +#define __IFilterMapper2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFilterMapper2, 0xb79bb0b0, 0x33c1, 0x11d1, 0xab,0xe1, 0x00,0xa0,0xc9,0x05,0xf3,0x75); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFilterMapper2 : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateCategory( + REFCLSID clsidCategory, + DWORD dwCategoryMerit, + LPCWSTR Description) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterFilter( + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + REFCLSID Filter) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterFilter( + REFCLSID clsidFilter, + LPCWSTR Name, + IMoniker** ppMoniker, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + const REGFILTER2* prf2) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumMatchingFilters( + IEnumMoniker** ppEnum, + DWORD dwFlags, + BOOL bExactMatch, + DWORD dwMerit, + BOOL bInputNeeded, + DWORD cInputTypes, + const GUID* pInputTypes, + const REGPINMEDIUM* pMedIn, + const CLSID* pPinCategoryIn, + BOOL bRender, + BOOL bOutputNeeded, + DWORD cOutputTypes, + const GUID* pOutputTypes, + const REGPINMEDIUM* pMedOut, + const CLSID* pPinCategoryOut) = 0; + +}; +#else +typedef struct IFilterMapper2Vtbl IFilterMapper2Vtbl; +struct IFilterMapper2 { + const IFilterMapper2Vtbl* lpVtbl; +}; +struct IFilterMapper2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFilterMapper2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFilterMapper2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFilterMapper2* This); + + /*** IFilterMapper2 methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateCategory)( + IFilterMapper2* This, + REFCLSID clsidCategory, + DWORD dwCategoryMerit, + LPCWSTR Description); + + HRESULT (STDMETHODCALLTYPE *UnregisterFilter)( + IFilterMapper2* This, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + REFCLSID Filter); + + HRESULT (STDMETHODCALLTYPE *RegisterFilter)( + IFilterMapper2* This, + REFCLSID clsidFilter, + LPCWSTR Name, + IMoniker** ppMoniker, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + const REGFILTER2* prf2); + + HRESULT (STDMETHODCALLTYPE *EnumMatchingFilters)( + IFilterMapper2* This, + IEnumMoniker** ppEnum, + DWORD dwFlags, + BOOL bExactMatch, + DWORD dwMerit, + BOOL bInputNeeded, + DWORD cInputTypes, + const GUID* pInputTypes, + const REGPINMEDIUM* pMedIn, + const CLSID* pPinCategoryIn, + BOOL bRender, + BOOL bOutputNeeded, + DWORD cOutputTypes, + const GUID* pOutputTypes, + const REGPINMEDIUM* pMedOut, + const CLSID* pPinCategoryOut); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFilterMapper2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterMapper2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterMapper2_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterMapper2 methods ***/ +#define IFilterMapper2_CreateCategory(p,a,b,c) (p)->lpVtbl->CreateCategory(p,a,b,c) +#define IFilterMapper2_UnregisterFilter(p,a,b,c) (p)->lpVtbl->UnregisterFilter(p,a,b,c) +#define IFilterMapper2_RegisterFilter(p,a,b,c,d,e,f) (p)->lpVtbl->RegisterFilter(p,a,b,c,d,e,f) +#define IFilterMapper2_EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (p)->lpVtbl->EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) +#endif + +#endif + +#define IFilterMapper2_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterMapper2 methods ***/ \ + STDMETHOD_(HRESULT,CreateCategory)(THIS_ REFCLSID clsidCategory, DWORD dwCategoryMerit, LPCWSTR Description) PURE; \ + STDMETHOD_(HRESULT,UnregisterFilter)(THIS_ const CLSID* pclsidCategory, const OLECHAR* szInstance, REFCLSID Filter) PURE; \ + STDMETHOD_(HRESULT,RegisterFilter)(THIS_ REFCLSID clsidFilter, LPCWSTR Name, IMoniker** ppMoniker, const CLSID* pclsidCategory, const OLECHAR* szInstance, const REGFILTER2* prf2) PURE; \ + STDMETHOD_(HRESULT,EnumMatchingFilters)(THIS_ IEnumMoniker** ppEnum, DWORD dwFlags, BOOL bExactMatch, DWORD dwMerit, BOOL bInputNeeded, DWORD cInputTypes, const GUID* pInputTypes, const REGPINMEDIUM* pMedIn, const CLSID* pPinCategoryIn, BOOL bRender, BOOL bOutputNeeded, DWORD cOutputTypes, const GUID* pOutputTypes, const REGPINMEDIUM* pMedOut, const CLSID* pPinCategoryOut) PURE; + +HRESULT CALLBACK IFilterMapper2_CreateCategory_Proxy( + IFilterMapper2* This, + REFCLSID clsidCategory, + DWORD dwCategoryMerit, + LPCWSTR Description); +void __RPC_STUB IFilterMapper2_CreateCategory_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper2_UnregisterFilter_Proxy( + IFilterMapper2* This, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + REFCLSID Filter); +void __RPC_STUB IFilterMapper2_UnregisterFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper2_RegisterFilter_Proxy( + IFilterMapper2* This, + REFCLSID clsidFilter, + LPCWSTR Name, + IMoniker** ppMoniker, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + const REGFILTER2* prf2); +void __RPC_STUB IFilterMapper2_RegisterFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterMapper2_EnumMatchingFilters_Proxy( + IFilterMapper2* This, + IEnumMoniker** ppEnum, + DWORD dwFlags, + BOOL bExactMatch, + DWORD dwMerit, + BOOL bInputNeeded, + DWORD cInputTypes, + const GUID* pInputTypes, + const REGPINMEDIUM* pMedIn, + const CLSID* pPinCategoryIn, + BOOL bRender, + BOOL bOutputNeeded, + DWORD cOutputTypes, + const GUID* pOutputTypes, + const REGPINMEDIUM* pMedOut, + const CLSID* pPinCategoryOut); +void __RPC_STUB IFilterMapper2_EnumMatchingFilters_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFilterMapper2_INTERFACE_DEFINED__ */ + +#ifndef __IFilterMapper3_FWD_DEFINED__ +#define __IFilterMapper3_FWD_DEFINED__ +typedef struct IFilterMapper3 IFilterMapper3; +#endif + +/***************************************************************************** + * IFilterMapper3 interface + */ +#ifndef __IFilterMapper3_INTERFACE_DEFINED__ +#define __IFilterMapper3_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFilterMapper3, 0xb79bb0b1, 0x33c1, 0x11d1, 0xab,0xe1, 0x00,0xa0,0xc9,0x05,0xf3,0x75); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFilterMapper3 : public IFilterMapper2 +{ + virtual HRESULT STDMETHODCALLTYPE GetICreateDevEnum( + ICreateDevEnum** ppEnum) = 0; + +}; +#else +typedef struct IFilterMapper3Vtbl IFilterMapper3Vtbl; +struct IFilterMapper3 { + const IFilterMapper3Vtbl* lpVtbl; +}; +struct IFilterMapper3Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFilterMapper3* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFilterMapper3* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFilterMapper3* This); + + /*** IFilterMapper2 methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateCategory)( + IFilterMapper3* This, + REFCLSID clsidCategory, + DWORD dwCategoryMerit, + LPCWSTR Description); + + HRESULT (STDMETHODCALLTYPE *UnregisterFilter)( + IFilterMapper3* This, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + REFCLSID Filter); + + HRESULT (STDMETHODCALLTYPE *RegisterFilter)( + IFilterMapper3* This, + REFCLSID clsidFilter, + LPCWSTR Name, + IMoniker** ppMoniker, + const CLSID* pclsidCategory, + const OLECHAR* szInstance, + const REGFILTER2* prf2); + + HRESULT (STDMETHODCALLTYPE *EnumMatchingFilters)( + IFilterMapper3* This, + IEnumMoniker** ppEnum, + DWORD dwFlags, + BOOL bExactMatch, + DWORD dwMerit, + BOOL bInputNeeded, + DWORD cInputTypes, + const GUID* pInputTypes, + const REGPINMEDIUM* pMedIn, + const CLSID* pPinCategoryIn, + BOOL bRender, + BOOL bOutputNeeded, + DWORD cOutputTypes, + const GUID* pOutputTypes, + const REGPINMEDIUM* pMedOut, + const CLSID* pPinCategoryOut); + + /*** IFilterMapper3 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetICreateDevEnum)( + IFilterMapper3* This, + ICreateDevEnum** ppEnum); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFilterMapper3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterMapper3_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterMapper3_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterMapper2 methods ***/ +#define IFilterMapper3_CreateCategory(p,a,b,c) (p)->lpVtbl->CreateCategory(p,a,b,c) +#define IFilterMapper3_UnregisterFilter(p,a,b,c) (p)->lpVtbl->UnregisterFilter(p,a,b,c) +#define IFilterMapper3_RegisterFilter(p,a,b,c,d,e,f) (p)->lpVtbl->RegisterFilter(p,a,b,c,d,e,f) +#define IFilterMapper3_EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) (p)->lpVtbl->EnumMatchingFilters(p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) +/*** IFilterMapper3 methods ***/ +#define IFilterMapper3_GetICreateDevEnum(p,a) (p)->lpVtbl->GetICreateDevEnum(p,a) +#endif + +#endif + +#define IFilterMapper3_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterMapper2 methods ***/ \ + STDMETHOD_(HRESULT,CreateCategory)(THIS_ REFCLSID clsidCategory, DWORD dwCategoryMerit, LPCWSTR Description) PURE; \ + STDMETHOD_(HRESULT,UnregisterFilter)(THIS_ const CLSID* pclsidCategory, const OLECHAR* szInstance, REFCLSID Filter) PURE; \ + STDMETHOD_(HRESULT,RegisterFilter)(THIS_ REFCLSID clsidFilter, LPCWSTR Name, IMoniker** ppMoniker, const CLSID* pclsidCategory, const OLECHAR* szInstance, const REGFILTER2* prf2) PURE; \ + STDMETHOD_(HRESULT,EnumMatchingFilters)(THIS_ IEnumMoniker** ppEnum, DWORD dwFlags, BOOL bExactMatch, DWORD dwMerit, BOOL bInputNeeded, DWORD cInputTypes, const GUID* pInputTypes, const REGPINMEDIUM* pMedIn, const CLSID* pPinCategoryIn, BOOL bRender, BOOL bOutputNeeded, DWORD cOutputTypes, const GUID* pOutputTypes, const REGPINMEDIUM* pMedOut, const CLSID* pPinCategoryOut) PURE; \ + /*** IFilterMapper3 methods ***/ \ + STDMETHOD_(HRESULT,GetICreateDevEnum)(THIS_ ICreateDevEnum** ppEnum) PURE; + +HRESULT CALLBACK IFilterMapper3_GetICreateDevEnum_Proxy( + IFilterMapper3* This, + ICreateDevEnum** ppEnum); +void __RPC_STUB IFilterMapper3_GetICreateDevEnum_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFilterMapper3_INTERFACE_DEFINED__ */ + +typedef enum tagQualityMessageType { + Famine, + Flood +} QualityMessageType; + +typedef struct tagQuality { + QualityMessageType Type; + long Proportion; + REFERENCE_TIME Late; + REFERENCE_TIME TimeStamp; +} Quality; + +typedef IQualityControl *PQUALITYCONTROL; + +/***************************************************************************** + * IQualityControl interface + */ +#ifndef __IQualityControl_INTERFACE_DEFINED__ +#define __IQualityControl_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IQualityControl, 0x56a868a5, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IQualityControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Notify( + IBaseFilter* pSelf, + Quality q) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSink( + IQualityControl* piqc) = 0; + +}; +#else +typedef struct IQualityControlVtbl IQualityControlVtbl; +struct IQualityControl { + const IQualityControlVtbl* lpVtbl; +}; +struct IQualityControlVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IQualityControl* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IQualityControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IQualityControl* This); + + /*** IQualityControl methods ***/ + HRESULT (STDMETHODCALLTYPE *Notify)( + IQualityControl* This, + IBaseFilter* pSelf, + Quality q); + + HRESULT (STDMETHODCALLTYPE *SetSink)( + IQualityControl* This, + IQualityControl* piqc); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IQualityControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IQualityControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IQualityControl_Release(p) (p)->lpVtbl->Release(p) +/*** IQualityControl methods ***/ +#define IQualityControl_Notify(p,a,b) (p)->lpVtbl->Notify(p,a,b) +#define IQualityControl_SetSink(p,a) (p)->lpVtbl->SetSink(p,a) +#endif + +#endif + +#define IQualityControl_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IQualityControl methods ***/ \ + STDMETHOD_(HRESULT,Notify)(THIS_ IBaseFilter* pSelf, Quality q) PURE; \ + STDMETHOD_(HRESULT,SetSink)(THIS_ IQualityControl* piqc) PURE; + +HRESULT CALLBACK IQualityControl_Notify_Proxy( + IQualityControl* This, + IBaseFilter* pSelf, + Quality q); +void __RPC_STUB IQualityControl_Notify_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IQualityControl_SetSink_Proxy( + IQualityControl* This, + IQualityControl* piqc); +void __RPC_STUB IQualityControl_SetSink_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IQualityControl_INTERFACE_DEFINED__ */ + +enum { + CK_NOCOLORKEY = 0x0, + CK_INDEX = 0x1, + CK_RGB = 0x2 +}; + +typedef struct tagCOLORKEY { + DWORD KeyType; + DWORD PaletteIndex; + COLORREF LowColorValue; + COLORREF HighColorValue; +} COLORKEY; + +enum { + ADVISE_NONE = 0x0, + ADVISE_CLIPPING = 0x1, + ADVISE_PALETTE = 0x2, + ADVISE_COLORKEY = 0x4, + ADVISE_POSITION = 0x8, + ADVISE_DISPLAY_CHANGE = 0x10 +}; + +#define ADVISE_ALL (((ADVISE_CLIPPING | ADVISE_PALETTE) | ADVISE_COLORKEY) | ADVISE_POSITION) + +#define ADVISE_ALL2 (ADVISE_ALL | ADVISE_DISPLAY_CHANGE) + +#ifndef __W32API_VERSION +#ifndef _WINGDI_ + + +typedef struct _RGNDATAHEADER { + DWORD dwSize; + DWORD iType; + DWORD nCount; + DWORD nRgnSize; + RECT rcBound; +} RGNDATAHEADER; + + +typedef struct _RGNDATA { + RGNDATAHEADER rdh; + char Buffer[1]; +} RGNDATA; + +#endif /* _WINGDI_ for wine */ +#endif +/***************************************************************************** + * IOverlayNotify interface + */ +#ifndef __IOverlayNotify_INTERFACE_DEFINED__ +#define __IOverlayNotify_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOverlayNotify, 0x56a868a0, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOverlayNotify : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE OnPaletteChange( + DWORD dwColors, + const PALETTEENTRY* pPalette) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnClipChange( + const RECT* pSourceRect, + const RECT* pDestinationRect, + const RGNDATA* pRgnData) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnColorKeyChange( + const COLORKEY* pColorKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnPositionChange( + const RECT* pSourceRect, + const RECT* pDestinationRect) = 0; + +}; +#else +typedef struct IOverlayNotifyVtbl IOverlayNotifyVtbl; +struct IOverlayNotify { + const IOverlayNotifyVtbl* lpVtbl; +}; +struct IOverlayNotifyVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOverlayNotify* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOverlayNotify* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOverlayNotify* This); + + /*** IOverlayNotify methods ***/ + HRESULT (STDMETHODCALLTYPE *OnPaletteChange)( + IOverlayNotify* This, + DWORD dwColors, + const PALETTEENTRY* pPalette); + + HRESULT (STDMETHODCALLTYPE *OnClipChange)( + IOverlayNotify* This, + const RECT* pSourceRect, + const RECT* pDestinationRect, + const RGNDATA* pRgnData); + + HRESULT (STDMETHODCALLTYPE *OnColorKeyChange)( + IOverlayNotify* This, + const COLORKEY* pColorKey); + + HRESULT (STDMETHODCALLTYPE *OnPositionChange)( + IOverlayNotify* This, + const RECT* pSourceRect, + const RECT* pDestinationRect); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IOverlayNotify_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOverlayNotify_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOverlayNotify_Release(p) (p)->lpVtbl->Release(p) +/*** IOverlayNotify methods ***/ +#define IOverlayNotify_OnPaletteChange(p,a,b) (p)->lpVtbl->OnPaletteChange(p,a,b) +#define IOverlayNotify_OnClipChange(p,a,b,c) (p)->lpVtbl->OnClipChange(p,a,b,c) +#define IOverlayNotify_OnColorKeyChange(p,a) (p)->lpVtbl->OnColorKeyChange(p,a) +#define IOverlayNotify_OnPositionChange(p,a,b) (p)->lpVtbl->OnPositionChange(p,a,b) +#endif + +#endif + +#define IOverlayNotify_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOverlayNotify methods ***/ \ + STDMETHOD_(HRESULT,OnPaletteChange)(THIS_ DWORD dwColors, const PALETTEENTRY* pPalette) PURE; \ + STDMETHOD_(HRESULT,OnClipChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect, const RGNDATA* pRgnData) PURE; \ + STDMETHOD_(HRESULT,OnColorKeyChange)(THIS_ const COLORKEY* pColorKey) PURE; \ + STDMETHOD_(HRESULT,OnPositionChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect) PURE; + +HRESULT CALLBACK IOverlayNotify_OnPaletteChange_Proxy( + IOverlayNotify* This, + DWORD dwColors, + const PALETTEENTRY* pPalette); +void __RPC_STUB IOverlayNotify_OnPaletteChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlayNotify_OnClipChange_Proxy( + IOverlayNotify* This, + const RECT* pSourceRect, + const RECT* pDestinationRect, + const RGNDATA* pRgnData); +void __RPC_STUB IOverlayNotify_OnClipChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlayNotify_OnColorKeyChange_Proxy( + IOverlayNotify* This, + const COLORKEY* pColorKey); +void __RPC_STUB IOverlayNotify_OnColorKeyChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlayNotify_OnPositionChange_Proxy( + IOverlayNotify* This, + const RECT* pSourceRect, + const RECT* pDestinationRect); +void __RPC_STUB IOverlayNotify_OnPositionChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOverlayNotify_INTERFACE_DEFINED__ */ + +typedef IOverlayNotify *POVERLAYNOTIFY; + +#if 0 +typedef HANDLE HMONITOR; + +#endif /* 0 */ +/***************************************************************************** + * IOverlayNotify2 interface + */ +#ifndef __IOverlayNotify2_INTERFACE_DEFINED__ +#define __IOverlayNotify2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOverlayNotify2, 0x680efa10, 0xd535, 0x11d1, 0x87,0xc8, 0x00,0xa0,0xc9,0x22,0x31,0x96); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOverlayNotify2 : public IOverlayNotify +{ + virtual HRESULT STDMETHODCALLTYPE OnDisplayChange( + HMONITOR hMonitor) = 0; + +}; +#else +typedef struct IOverlayNotify2Vtbl IOverlayNotify2Vtbl; +struct IOverlayNotify2 { + const IOverlayNotify2Vtbl* lpVtbl; +}; +struct IOverlayNotify2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOverlayNotify2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOverlayNotify2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOverlayNotify2* This); + + /*** IOverlayNotify methods ***/ + HRESULT (STDMETHODCALLTYPE *OnPaletteChange)( + IOverlayNotify2* This, + DWORD dwColors, + const PALETTEENTRY* pPalette); + + HRESULT (STDMETHODCALLTYPE *OnClipChange)( + IOverlayNotify2* This, + const RECT* pSourceRect, + const RECT* pDestinationRect, + const RGNDATA* pRgnData); + + HRESULT (STDMETHODCALLTYPE *OnColorKeyChange)( + IOverlayNotify2* This, + const COLORKEY* pColorKey); + + HRESULT (STDMETHODCALLTYPE *OnPositionChange)( + IOverlayNotify2* This, + const RECT* pSourceRect, + const RECT* pDestinationRect); + + /*** IOverlayNotify2 methods ***/ + HRESULT (STDMETHODCALLTYPE *OnDisplayChange)( + IOverlayNotify2* This, + HMONITOR hMonitor); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IOverlayNotify2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOverlayNotify2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOverlayNotify2_Release(p) (p)->lpVtbl->Release(p) +/*** IOverlayNotify methods ***/ +#define IOverlayNotify2_OnPaletteChange(p,a,b) (p)->lpVtbl->OnPaletteChange(p,a,b) +#define IOverlayNotify2_OnClipChange(p,a,b,c) (p)->lpVtbl->OnClipChange(p,a,b,c) +#define IOverlayNotify2_OnColorKeyChange(p,a) (p)->lpVtbl->OnColorKeyChange(p,a) +#define IOverlayNotify2_OnPositionChange(p,a,b) (p)->lpVtbl->OnPositionChange(p,a,b) +/*** IOverlayNotify2 methods ***/ +#define IOverlayNotify2_OnDisplayChange(p,a) (p)->lpVtbl->OnDisplayChange(p,a) +#endif + +#endif + +#define IOverlayNotify2_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOverlayNotify methods ***/ \ + STDMETHOD_(HRESULT,OnPaletteChange)(THIS_ DWORD dwColors, const PALETTEENTRY* pPalette) PURE; \ + STDMETHOD_(HRESULT,OnClipChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect, const RGNDATA* pRgnData) PURE; \ + STDMETHOD_(HRESULT,OnColorKeyChange)(THIS_ const COLORKEY* pColorKey) PURE; \ + STDMETHOD_(HRESULT,OnPositionChange)(THIS_ const RECT* pSourceRect, const RECT* pDestinationRect) PURE; \ + /*** IOverlayNotify2 methods ***/ \ + STDMETHOD_(HRESULT,OnDisplayChange)(THIS_ HMONITOR hMonitor) PURE; + +HRESULT CALLBACK IOverlayNotify2_OnDisplayChange_Proxy( + IOverlayNotify2* This, + HMONITOR hMonitor); +void __RPC_STUB IOverlayNotify2_OnDisplayChange_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOverlayNotify2_INTERFACE_DEFINED__ */ + +typedef IOverlayNotify2 *POVERLAYNOTIFY2; + +/***************************************************************************** + * IOverlay interface + */ +#ifndef __IOverlay_INTERFACE_DEFINED__ +#define __IOverlay_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IOverlay, 0x56a868a1, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IOverlay : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetPalette( + DWORD* pdwColors, + PALETTEENTRY** ppPalette) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPalette( + DWORD dwColors, + PALETTEENTRY* pPalette) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultColorKey( + COLORKEY* pColorKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetColorKey( + COLORKEY* pColorKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetColorKey( + COLORKEY* pColorKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetWindowHandle( + HWND* pHwnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetClipList( + RECT* pSourceRect, + RECT* pDestinationRect, + RGNDATA** ppRgnData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoPosition( + RECT* pSourceRect, + RECT* pDestinationRect) = 0; + + virtual HRESULT STDMETHODCALLTYPE Advise( + IOverlayNotify* pOverlayNotify, + DWORD dwInterests) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unadvise( + ) = 0; + +}; +#else +typedef struct IOverlayVtbl IOverlayVtbl; +struct IOverlay { + const IOverlayVtbl* lpVtbl; +}; +struct IOverlayVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IOverlay* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IOverlay* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IOverlay* This); + + /*** IOverlay methods ***/ + HRESULT (STDMETHODCALLTYPE *GetPalette)( + IOverlay* This, + DWORD* pdwColors, + PALETTEENTRY** ppPalette); + + HRESULT (STDMETHODCALLTYPE *SetPalette)( + IOverlay* This, + DWORD dwColors, + PALETTEENTRY* pPalette); + + HRESULT (STDMETHODCALLTYPE *GetDefaultColorKey)( + IOverlay* This, + COLORKEY* pColorKey); + + HRESULT (STDMETHODCALLTYPE *GetColorKey)( + IOverlay* This, + COLORKEY* pColorKey); + + HRESULT (STDMETHODCALLTYPE *SetColorKey)( + IOverlay* This, + COLORKEY* pColorKey); + + HRESULT (STDMETHODCALLTYPE *GetWindowHandle)( + IOverlay* This, + HWND* pHwnd); + + HRESULT (STDMETHODCALLTYPE *GetClipList)( + IOverlay* This, + RECT* pSourceRect, + RECT* pDestinationRect, + RGNDATA** ppRgnData); + + HRESULT (STDMETHODCALLTYPE *GetVideoPosition)( + IOverlay* This, + RECT* pSourceRect, + RECT* pDestinationRect); + + HRESULT (STDMETHODCALLTYPE *Advise)( + IOverlay* This, + IOverlayNotify* pOverlayNotify, + DWORD dwInterests); + + HRESULT (STDMETHODCALLTYPE *Unadvise)( + IOverlay* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IOverlay_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IOverlay_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IOverlay_Release(p) (p)->lpVtbl->Release(p) +/*** IOverlay methods ***/ +#define IOverlay_GetPalette(p,a,b) (p)->lpVtbl->GetPalette(p,a,b) +#define IOverlay_SetPalette(p,a,b) (p)->lpVtbl->SetPalette(p,a,b) +#define IOverlay_GetDefaultColorKey(p,a) (p)->lpVtbl->GetDefaultColorKey(p,a) +#define IOverlay_GetColorKey(p,a) (p)->lpVtbl->GetColorKey(p,a) +#define IOverlay_SetColorKey(p,a) (p)->lpVtbl->SetColorKey(p,a) +#define IOverlay_GetWindowHandle(p,a) (p)->lpVtbl->GetWindowHandle(p,a) +#define IOverlay_GetClipList(p,a,b,c) (p)->lpVtbl->GetClipList(p,a,b,c) +#define IOverlay_GetVideoPosition(p,a,b) (p)->lpVtbl->GetVideoPosition(p,a,b) +#define IOverlay_Advise(p,a,b) (p)->lpVtbl->Advise(p,a,b) +#define IOverlay_Unadvise(p) (p)->lpVtbl->Unadvise(p) +#endif + +#endif + +#define IOverlay_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IOverlay methods ***/ \ + STDMETHOD_(HRESULT,GetPalette)(THIS_ DWORD* pdwColors, PALETTEENTRY** ppPalette) PURE; \ + STDMETHOD_(HRESULT,SetPalette)(THIS_ DWORD dwColors, PALETTEENTRY* pPalette) PURE; \ + STDMETHOD_(HRESULT,GetDefaultColorKey)(THIS_ COLORKEY* pColorKey) PURE; \ + STDMETHOD_(HRESULT,GetColorKey)(THIS_ COLORKEY* pColorKey) PURE; \ + STDMETHOD_(HRESULT,SetColorKey)(THIS_ COLORKEY* pColorKey) PURE; \ + STDMETHOD_(HRESULT,GetWindowHandle)(THIS_ HWND* pHwnd) PURE; \ + STDMETHOD_(HRESULT,GetClipList)(THIS_ RECT* pSourceRect, RECT* pDestinationRect, RGNDATA** ppRgnData) PURE; \ + STDMETHOD_(HRESULT,GetVideoPosition)(THIS_ RECT* pSourceRect, RECT* pDestinationRect) PURE; \ + STDMETHOD_(HRESULT,Advise)(THIS_ IOverlayNotify* pOverlayNotify, DWORD dwInterests) PURE; \ + STDMETHOD_(HRESULT,Unadvise)(THIS) PURE; + +HRESULT CALLBACK IOverlay_GetPalette_Proxy( + IOverlay* This, + DWORD* pdwColors, + PALETTEENTRY** ppPalette); +void __RPC_STUB IOverlay_GetPalette_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_SetPalette_Proxy( + IOverlay* This, + DWORD dwColors, + PALETTEENTRY* pPalette); +void __RPC_STUB IOverlay_SetPalette_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_GetDefaultColorKey_Proxy( + IOverlay* This, + COLORKEY* pColorKey); +void __RPC_STUB IOverlay_GetDefaultColorKey_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_GetColorKey_Proxy( + IOverlay* This, + COLORKEY* pColorKey); +void __RPC_STUB IOverlay_GetColorKey_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_SetColorKey_Proxy( + IOverlay* This, + COLORKEY* pColorKey); +void __RPC_STUB IOverlay_SetColorKey_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_GetWindowHandle_Proxy( + IOverlay* This, + HWND* pHwnd); +void __RPC_STUB IOverlay_GetWindowHandle_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_GetClipList_Proxy( + IOverlay* This, + RECT* pSourceRect, + RECT* pDestinationRect, + RGNDATA** ppRgnData); +void __RPC_STUB IOverlay_GetClipList_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_GetVideoPosition_Proxy( + IOverlay* This, + RECT* pSourceRect, + RECT* pDestinationRect); +void __RPC_STUB IOverlay_GetVideoPosition_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_Advise_Proxy( + IOverlay* This, + IOverlayNotify* pOverlayNotify, + DWORD dwInterests); +void __RPC_STUB IOverlay_Advise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IOverlay_Unadvise_Proxy( + IOverlay* This); +void __RPC_STUB IOverlay_Unadvise_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IOverlay_INTERFACE_DEFINED__ */ + +typedef IOverlay *POVERLAY; + +/***************************************************************************** + * IMediaEventSink interface + */ +#ifndef __IMediaEventSink_INTERFACE_DEFINED__ +#define __IMediaEventSink_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMediaEventSink, 0x56a868a2, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IMediaEventSink : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Notify( + long EventCode, + LONG_PTR EventParam1, + LONG_PTR EventParam2) = 0; + +}; +#else +typedef struct IMediaEventSinkVtbl IMediaEventSinkVtbl; +struct IMediaEventSink { + const IMediaEventSinkVtbl* lpVtbl; +}; +struct IMediaEventSinkVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMediaEventSink* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMediaEventSink* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMediaEventSink* This); + + /*** IMediaEventSink methods ***/ + HRESULT (STDMETHODCALLTYPE *Notify)( + IMediaEventSink* This, + long EventCode, + LONG_PTR EventParam1, + LONG_PTR EventParam2); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IMediaEventSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IMediaEventSink_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IMediaEventSink_Release(p) (p)->lpVtbl->Release(p) +/*** IMediaEventSink methods ***/ +#define IMediaEventSink_Notify(p,a,b,c) (p)->lpVtbl->Notify(p,a,b,c) +#endif + +#endif + +#define IMediaEventSink_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IMediaEventSink methods ***/ \ + STDMETHOD_(HRESULT,Notify)(THIS_ long EventCode, LONG_PTR EventParam1, LONG_PTR EventParam2) PURE; + +HRESULT CALLBACK IMediaEventSink_Notify_Proxy( + IMediaEventSink* This, + long EventCode, + LONG_PTR EventParam1, + LONG_PTR EventParam2); +void __RPC_STUB IMediaEventSink_Notify_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMediaEventSink_INTERFACE_DEFINED__ */ + +typedef IMediaEventSink *PMEDIAEVENTSINK; + +/***************************************************************************** + * IFileSourceFilter interface + */ +#ifndef __IFileSourceFilter_INTERFACE_DEFINED__ +#define __IFileSourceFilter_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFileSourceFilter, 0x56a868a6, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFileSourceFilter : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Load( + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurFile( + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt) = 0; + +}; +#else +typedef struct IFileSourceFilterVtbl IFileSourceFilterVtbl; +struct IFileSourceFilter { + const IFileSourceFilterVtbl* lpVtbl; +}; +struct IFileSourceFilterVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFileSourceFilter* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFileSourceFilter* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFileSourceFilter* This); + + /*** IFileSourceFilter methods ***/ + HRESULT (STDMETHODCALLTYPE *Load)( + IFileSourceFilter* This, + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *GetCurFile)( + IFileSourceFilter* This, + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFileSourceFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFileSourceFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFileSourceFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IFileSourceFilter methods ***/ +#define IFileSourceFilter_Load(p,a,b) (p)->lpVtbl->Load(p,a,b) +#define IFileSourceFilter_GetCurFile(p,a,b) (p)->lpVtbl->GetCurFile(p,a,b) +#endif + +#endif + +#define IFileSourceFilter_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFileSourceFilter methods ***/ \ + STDMETHOD_(HRESULT,Load)(THIS_ LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,GetCurFile)(THIS_ LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt) PURE; + +HRESULT CALLBACK IFileSourceFilter_Load_Proxy( + IFileSourceFilter* This, + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IFileSourceFilter_Load_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFileSourceFilter_GetCurFile_Proxy( + IFileSourceFilter* This, + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt); +void __RPC_STUB IFileSourceFilter_GetCurFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFileSourceFilter_INTERFACE_DEFINED__ */ + +typedef IFileSourceFilter *PFILTERFILESOURCE; + +/***************************************************************************** + * IFileSinkFilter interface + */ +#ifndef __IFileSinkFilter_INTERFACE_DEFINED__ +#define __IFileSinkFilter_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFileSinkFilter, 0xa2104830, 0x7c70, 0x11cf, 0x8b,0xce, 0x00,0xaa,0x00,0xa3,0xf1,0xa6); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFileSinkFilter : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetFileName( + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurFile( + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt) = 0; + +}; +#else +typedef struct IFileSinkFilterVtbl IFileSinkFilterVtbl; +struct IFileSinkFilter { + const IFileSinkFilterVtbl* lpVtbl; +}; +struct IFileSinkFilterVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFileSinkFilter* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFileSinkFilter* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFileSinkFilter* This); + + /*** IFileSinkFilter methods ***/ + HRESULT (STDMETHODCALLTYPE *SetFileName)( + IFileSinkFilter* This, + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *GetCurFile)( + IFileSinkFilter* This, + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFileSinkFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFileSinkFilter_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFileSinkFilter_Release(p) (p)->lpVtbl->Release(p) +/*** IFileSinkFilter methods ***/ +#define IFileSinkFilter_SetFileName(p,a,b) (p)->lpVtbl->SetFileName(p,a,b) +#define IFileSinkFilter_GetCurFile(p,a,b) (p)->lpVtbl->GetCurFile(p,a,b) +#endif + +#endif + +#define IFileSinkFilter_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFileSinkFilter methods ***/ \ + STDMETHOD_(HRESULT,SetFileName)(THIS_ LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,GetCurFile)(THIS_ LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt) PURE; + +HRESULT CALLBACK IFileSinkFilter_SetFileName_Proxy( + IFileSinkFilter* This, + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IFileSinkFilter_SetFileName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFileSinkFilter_GetCurFile_Proxy( + IFileSinkFilter* This, + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt); +void __RPC_STUB IFileSinkFilter_GetCurFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFileSinkFilter_INTERFACE_DEFINED__ */ + +typedef IFileSinkFilter *PFILTERFILESINK; + +/***************************************************************************** + * IFileSinkFilter2 interface + */ +#ifndef __IFileSinkFilter2_INTERFACE_DEFINED__ +#define __IFileSinkFilter2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFileSinkFilter2, 0x00855b90, 0xce1b, 0x11d0, 0xbd,0x4f, 0x00,0xa0,0xc9,0x11,0xce,0x86); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFileSinkFilter2 : public IFileSinkFilter +{ + virtual HRESULT STDMETHODCALLTYPE SetMode( + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMode( + DWORD* pdwFlags) = 0; + +}; +#else +typedef struct IFileSinkFilter2Vtbl IFileSinkFilter2Vtbl; +struct IFileSinkFilter2 { + const IFileSinkFilter2Vtbl* lpVtbl; +}; +struct IFileSinkFilter2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFileSinkFilter2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFileSinkFilter2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFileSinkFilter2* This); + + /*** IFileSinkFilter methods ***/ + HRESULT (STDMETHODCALLTYPE *SetFileName)( + IFileSinkFilter2* This, + LPCOLESTR pszFileName, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *GetCurFile)( + IFileSinkFilter2* This, + LPOLESTR* ppszFileName, + AM_MEDIA_TYPE* pmt); + + /*** IFileSinkFilter2 methods ***/ + HRESULT (STDMETHODCALLTYPE *SetMode)( + IFileSinkFilter2* This, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *GetMode)( + IFileSinkFilter2* This, + DWORD* pdwFlags); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFileSinkFilter2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFileSinkFilter2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFileSinkFilter2_Release(p) (p)->lpVtbl->Release(p) +/*** IFileSinkFilter methods ***/ +#define IFileSinkFilter2_SetFileName(p,a,b) (p)->lpVtbl->SetFileName(p,a,b) +#define IFileSinkFilter2_GetCurFile(p,a,b) (p)->lpVtbl->GetCurFile(p,a,b) +/*** IFileSinkFilter2 methods ***/ +#define IFileSinkFilter2_SetMode(p,a) (p)->lpVtbl->SetMode(p,a) +#define IFileSinkFilter2_GetMode(p,a) (p)->lpVtbl->GetMode(p,a) +#endif + +#endif + +#define IFileSinkFilter2_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFileSinkFilter methods ***/ \ + STDMETHOD_(HRESULT,SetFileName)(THIS_ LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,GetCurFile)(THIS_ LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt) PURE; \ + /*** IFileSinkFilter2 methods ***/ \ + STDMETHOD_(HRESULT,SetMode)(THIS_ DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,GetMode)(THIS_ DWORD* pdwFlags) PURE; + +HRESULT CALLBACK IFileSinkFilter2_SetMode_Proxy( + IFileSinkFilter2* This, + DWORD dwFlags); +void __RPC_STUB IFileSinkFilter2_SetMode_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFileSinkFilter2_GetMode_Proxy( + IFileSinkFilter2* This, + DWORD* pdwFlags); +void __RPC_STUB IFileSinkFilter2_GetMode_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFileSinkFilter2_INTERFACE_DEFINED__ */ + +typedef IFileSinkFilter2 *PFILESINKFILTER2; + +typedef enum { + AM_FILE_OVERWRITE = 0x1 +} AM_FILESINK_FLAGS; + +/***************************************************************************** + * IGraphBuilder interface + */ +#ifndef __IGraphBuilder_INTERFACE_DEFINED__ +#define __IGraphBuilder_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IGraphBuilder, 0x56a868a9, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IGraphBuilder : public IFilterGraph +{ + virtual HRESULT STDMETHODCALLTYPE Connect( + IPin* ppinOut, + IPin* ppinIn) = 0; + + virtual HRESULT STDMETHODCALLTYPE Render( + IPin* ppinOut) = 0; + + virtual HRESULT STDMETHODCALLTYPE RenderFile( + LPCWSTR lpcwstrFile, + LPCWSTR lpcwstrPlayList) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddSourceFilter( + LPCWSTR lpcwstrFileName, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLogFile( + DWORD_PTR hFile) = 0; + + virtual HRESULT STDMETHODCALLTYPE Abort( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE ShouldOperationContinue( + ) = 0; + +}; +#else +typedef struct IGraphBuilderVtbl IGraphBuilderVtbl; +struct IGraphBuilder { + const IGraphBuilderVtbl* lpVtbl; +}; +struct IGraphBuilderVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IGraphBuilder* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IGraphBuilder* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IGraphBuilder* This); + + /*** IFilterGraph methods ***/ + HRESULT (STDMETHODCALLTYPE *AddFilter)( + IGraphBuilder* This, + IBaseFilter* pFilter, + LPCWSTR pName); + + HRESULT (STDMETHODCALLTYPE *RemoveFilter)( + IGraphBuilder* This, + IBaseFilter* pFilter); + + HRESULT (STDMETHODCALLTYPE *EnumFilters)( + IGraphBuilder* This, + IEnumFilters** ppEnum); + + HRESULT (STDMETHODCALLTYPE *FindFilterByName)( + IGraphBuilder* This, + LPCWSTR pName, + IBaseFilter** ppFilter); + + HRESULT (STDMETHODCALLTYPE *ConnectDirect)( + IGraphBuilder* This, + IPin* ppinOut, + IPin* ppinIn, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *Reconnect)( + IGraphBuilder* This, + IPin* ppin); + + HRESULT (STDMETHODCALLTYPE *Disconnect)( + IGraphBuilder* This, + IPin* ppin); + + HRESULT (STDMETHODCALLTYPE *SetDefaultSyncSource)( + IGraphBuilder* This); + + /*** IGraphBuilder methods ***/ + HRESULT (STDMETHODCALLTYPE *Connect)( + IGraphBuilder* This, + IPin* ppinOut, + IPin* ppinIn); + + HRESULT (STDMETHODCALLTYPE *Render)( + IGraphBuilder* This, + IPin* ppinOut); + + HRESULT (STDMETHODCALLTYPE *RenderFile)( + IGraphBuilder* This, + LPCWSTR lpcwstrFile, + LPCWSTR lpcwstrPlayList); + + HRESULT (STDMETHODCALLTYPE *AddSourceFilter)( + IGraphBuilder* This, + LPCWSTR lpcwstrFileName, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter); + + HRESULT (STDMETHODCALLTYPE *SetLogFile)( + IGraphBuilder* This, + DWORD_PTR hFile); + + HRESULT (STDMETHODCALLTYPE *Abort)( + IGraphBuilder* This); + + HRESULT (STDMETHODCALLTYPE *ShouldOperationContinue)( + IGraphBuilder* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IGraphBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IGraphBuilder_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IGraphBuilder_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterGraph methods ***/ +#define IGraphBuilder_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b) +#define IGraphBuilder_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a) +#define IGraphBuilder_EnumFilters(p,a) (p)->lpVtbl->EnumFilters(p,a) +#define IGraphBuilder_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b) +#define IGraphBuilder_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c) +#define IGraphBuilder_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a) +#define IGraphBuilder_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a) +#define IGraphBuilder_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p) +/*** IGraphBuilder methods ***/ +#define IGraphBuilder_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b) +#define IGraphBuilder_Render(p,a) (p)->lpVtbl->Render(p,a) +#define IGraphBuilder_RenderFile(p,a,b) (p)->lpVtbl->RenderFile(p,a,b) +#define IGraphBuilder_AddSourceFilter(p,a,b,c) (p)->lpVtbl->AddSourceFilter(p,a,b,c) +#define IGraphBuilder_SetLogFile(p,a) (p)->lpVtbl->SetLogFile(p,a) +#define IGraphBuilder_Abort(p) (p)->lpVtbl->Abort(p) +#define IGraphBuilder_ShouldOperationContinue(p) (p)->lpVtbl->ShouldOperationContinue(p) +#endif + +#endif + +#define IGraphBuilder_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterGraph methods ***/ \ + STDMETHOD_(HRESULT,AddFilter)(THIS_ IBaseFilter* pFilter, LPCWSTR pName) PURE; \ + STDMETHOD_(HRESULT,RemoveFilter)(THIS_ IBaseFilter* pFilter) PURE; \ + STDMETHOD_(HRESULT,EnumFilters)(THIS_ IEnumFilters** ppEnum) PURE; \ + STDMETHOD_(HRESULT,FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter** ppFilter) PURE; \ + STDMETHOD_(HRESULT,ConnectDirect)(THIS_ IPin* ppinOut, IPin* ppinIn, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* ppin) PURE; \ + STDMETHOD_(HRESULT,Disconnect)(THIS_ IPin* ppin) PURE; \ + STDMETHOD_(HRESULT,SetDefaultSyncSource)(THIS) PURE; \ + /*** IGraphBuilder methods ***/ \ + STDMETHOD_(HRESULT,Connect)(THIS_ IPin* ppinOut, IPin* ppinIn) PURE; \ + STDMETHOD_(HRESULT,Render)(THIS_ IPin* ppinOut) PURE; \ + STDMETHOD_(HRESULT,RenderFile)(THIS_ LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList) PURE; \ + STDMETHOD_(HRESULT,AddSourceFilter)(THIS_ LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter) PURE; \ + STDMETHOD_(HRESULT,SetLogFile)(THIS_ DWORD_PTR hFile) PURE; \ + STDMETHOD_(HRESULT,Abort)(THIS) PURE; \ + STDMETHOD_(HRESULT,ShouldOperationContinue)(THIS) PURE; + +HRESULT CALLBACK IGraphBuilder_Connect_Proxy( + IGraphBuilder* This, + IPin* ppinOut, + IPin* ppinIn); +void __RPC_STUB IGraphBuilder_Connect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphBuilder_Render_Proxy( + IGraphBuilder* This, + IPin* ppinOut); +void __RPC_STUB IGraphBuilder_Render_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphBuilder_RenderFile_Proxy( + IGraphBuilder* This, + LPCWSTR lpcwstrFile, + LPCWSTR lpcwstrPlayList); +void __RPC_STUB IGraphBuilder_RenderFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphBuilder_AddSourceFilter_Proxy( + IGraphBuilder* This, + LPCWSTR lpcwstrFileName, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter); +void __RPC_STUB IGraphBuilder_AddSourceFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphBuilder_SetLogFile_Proxy( + IGraphBuilder* This, + DWORD_PTR hFile); +void __RPC_STUB IGraphBuilder_SetLogFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphBuilder_Abort_Proxy( + IGraphBuilder* This); +void __RPC_STUB IGraphBuilder_Abort_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphBuilder_ShouldOperationContinue_Proxy( + IGraphBuilder* This); +void __RPC_STUB IGraphBuilder_ShouldOperationContinue_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IGraphBuilder_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ICaptureGraphBuilder interface + */ +#ifndef __ICaptureGraphBuilder_INTERFACE_DEFINED__ +#define __ICaptureGraphBuilder_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ICaptureGraphBuilder, 0xbf87b6e0, 0x8c27, 0x11d0, 0xb3,0xf0, 0x00,0xaa,0x00,0x37,0x61,0xc5); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICaptureGraphBuilder : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetFiltergraph( + IGraphBuilder* pfg) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFiltergraph( + IGraphBuilder** ppfg) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputFileName( + const GUID* pType, + LPCOLESTR lpstrFile, + IBaseFilter** ppf, + IFileSinkFilter** ppSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindInterface( + const GUID* pCategory, + IBaseFilter* pf, + REFIID riid, + void** ppint) = 0; + + virtual HRESULT STDMETHODCALLTYPE RenderStream( + const GUID* pCategory, + IUnknown* pSource, + IBaseFilter* pfCompressor, + IBaseFilter* pfRenderer) = 0; + + virtual HRESULT STDMETHODCALLTYPE ControlStream( + const GUID* pCategory, + IBaseFilter* pFilter, + REFERENCE_TIME* pstart, + REFERENCE_TIME* pstop, + WORD wStartCookie, + WORD wStopCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE AllocCapFile( + LPCOLESTR lpstr, + DWORDLONG dwlSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyCaptureFile( + LPOLESTR lpwstrOld, + LPOLESTR lpwstrNew, + int fAllowEscAbort, + IAMCopyCaptureFileProgress* pCallback) = 0; + +}; +#else +typedef struct ICaptureGraphBuilderVtbl ICaptureGraphBuilderVtbl; +struct ICaptureGraphBuilder { + const ICaptureGraphBuilderVtbl* lpVtbl; +}; +struct ICaptureGraphBuilderVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ICaptureGraphBuilder* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ICaptureGraphBuilder* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ICaptureGraphBuilder* This); + + /*** ICaptureGraphBuilder methods ***/ + HRESULT (STDMETHODCALLTYPE *SetFiltergraph)( + ICaptureGraphBuilder* This, + IGraphBuilder* pfg); + + HRESULT (STDMETHODCALLTYPE *GetFiltergraph)( + ICaptureGraphBuilder* This, + IGraphBuilder** ppfg); + + HRESULT (STDMETHODCALLTYPE *SetOutputFileName)( + ICaptureGraphBuilder* This, + const GUID* pType, + LPCOLESTR lpstrFile, + IBaseFilter** ppf, + IFileSinkFilter** ppSink); + + HRESULT (STDMETHODCALLTYPE *FindInterface)( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IBaseFilter* pf, + REFIID riid, + void** ppint); + + HRESULT (STDMETHODCALLTYPE *RenderStream)( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IUnknown* pSource, + IBaseFilter* pfCompressor, + IBaseFilter* pfRenderer); + + HRESULT (STDMETHODCALLTYPE *ControlStream)( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IBaseFilter* pFilter, + REFERENCE_TIME* pstart, + REFERENCE_TIME* pstop, + WORD wStartCookie, + WORD wStopCookie); + + HRESULT (STDMETHODCALLTYPE *AllocCapFile)( + ICaptureGraphBuilder* This, + LPCOLESTR lpstr, + DWORDLONG dwlSize); + + HRESULT (STDMETHODCALLTYPE *CopyCaptureFile)( + ICaptureGraphBuilder* This, + LPOLESTR lpwstrOld, + LPOLESTR lpwstrNew, + int fAllowEscAbort, + IAMCopyCaptureFileProgress* pCallback); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ICaptureGraphBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICaptureGraphBuilder_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICaptureGraphBuilder_Release(p) (p)->lpVtbl->Release(p) +/*** ICaptureGraphBuilder methods ***/ +#define ICaptureGraphBuilder_SetFiltergraph(p,a) (p)->lpVtbl->SetFiltergraph(p,a) +#define ICaptureGraphBuilder_GetFiltergraph(p,a) (p)->lpVtbl->GetFiltergraph(p,a) +#define ICaptureGraphBuilder_SetOutputFileName(p,a,b,c,d) (p)->lpVtbl->SetOutputFileName(p,a,b,c,d) +#define ICaptureGraphBuilder_FindInterface(p,a,b,c,d) (p)->lpVtbl->FindInterface(p,a,b,c,d) +#define ICaptureGraphBuilder_RenderStream(p,a,b,c,d) (p)->lpVtbl->RenderStream(p,a,b,c,d) +#define ICaptureGraphBuilder_ControlStream(p,a,b,c,d,e,f) (p)->lpVtbl->ControlStream(p,a,b,c,d,e,f) +#define ICaptureGraphBuilder_AllocCapFile(p,a,b) (p)->lpVtbl->AllocCapFile(p,a,b) +#define ICaptureGraphBuilder_CopyCaptureFile(p,a,b,c,d) (p)->lpVtbl->CopyCaptureFile(p,a,b,c,d) +#endif + +#endif + +#define ICaptureGraphBuilder_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** ICaptureGraphBuilder methods ***/ \ + STDMETHOD_(HRESULT,SetFiltergraph)(THIS_ IGraphBuilder* pfg) PURE; \ + STDMETHOD_(HRESULT,GetFiltergraph)(THIS_ IGraphBuilder** ppfg) PURE; \ + STDMETHOD_(HRESULT,SetOutputFileName)(THIS_ const GUID* pType, LPCOLESTR lpstrFile, IBaseFilter** ppf, IFileSinkFilter** ppSink) PURE; \ + STDMETHOD_(HRESULT,FindInterface)(THIS_ const GUID* pCategory, IBaseFilter* pf, REFIID riid, void** ppint) PURE; \ + STDMETHOD_(HRESULT,RenderStream)(THIS_ const GUID* pCategory, IUnknown* pSource, IBaseFilter* pfCompressor, IBaseFilter* pfRenderer) PURE; \ + STDMETHOD_(HRESULT,ControlStream)(THIS_ const GUID* pCategory, IBaseFilter* pFilter, REFERENCE_TIME* pstart, REFERENCE_TIME* pstop, WORD wStartCookie, WORD wStopCookie) PURE; \ + STDMETHOD_(HRESULT,AllocCapFile)(THIS_ LPCOLESTR lpstr, DWORDLONG dwlSize) PURE; \ + STDMETHOD_(HRESULT,CopyCaptureFile)(THIS_ LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress* pCallback) PURE; + +HRESULT CALLBACK ICaptureGraphBuilder_SetFiltergraph_Proxy( + ICaptureGraphBuilder* This, + IGraphBuilder* pfg); +void __RPC_STUB ICaptureGraphBuilder_SetFiltergraph_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_GetFiltergraph_Proxy( + ICaptureGraphBuilder* This, + IGraphBuilder** ppfg); +void __RPC_STUB ICaptureGraphBuilder_GetFiltergraph_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_SetOutputFileName_Proxy( + ICaptureGraphBuilder* This, + const GUID* pType, + LPCOLESTR lpstrFile, + IBaseFilter** ppf, + IFileSinkFilter** ppSink); +void __RPC_STUB ICaptureGraphBuilder_SetOutputFileName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_RemoteFindInterface_Proxy( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IBaseFilter* pf, + REFIID riid, + IUnknown** ppint); +void __RPC_STUB ICaptureGraphBuilder_RemoteFindInterface_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_FindInterface_Proxy( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IBaseFilter* pf, + REFIID riid, + void** ppint); +HRESULT __RPC_STUB ICaptureGraphBuilder_FindInterface_Stub( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IBaseFilter* pf, + REFIID riid, + IUnknown** ppint); +HRESULT CALLBACK ICaptureGraphBuilder_RenderStream_Proxy( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IUnknown* pSource, + IBaseFilter* pfCompressor, + IBaseFilter* pfRenderer); +void __RPC_STUB ICaptureGraphBuilder_RenderStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_ControlStream_Proxy( + ICaptureGraphBuilder* This, + const GUID* pCategory, + IBaseFilter* pFilter, + REFERENCE_TIME* pstart, + REFERENCE_TIME* pstop, + WORD wStartCookie, + WORD wStopCookie); +void __RPC_STUB ICaptureGraphBuilder_ControlStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_AllocCapFile_Proxy( + ICaptureGraphBuilder* This, + LPCOLESTR lpstr, + DWORDLONG dwlSize); +void __RPC_STUB ICaptureGraphBuilder_AllocCapFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder_CopyCaptureFile_Proxy( + ICaptureGraphBuilder* This, + LPOLESTR lpwstrOld, + LPOLESTR lpwstrNew, + int fAllowEscAbort, + IAMCopyCaptureFileProgress* pCallback); +void __RPC_STUB ICaptureGraphBuilder_CopyCaptureFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ICaptureGraphBuilder_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAMCopyCaptureFileProgress interface + */ +#ifndef __IAMCopyCaptureFileProgress_INTERFACE_DEFINED__ +#define __IAMCopyCaptureFileProgress_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMCopyCaptureFileProgress, 0x670d1d20, 0xa068, 0x11d0, 0xb3,0xf0, 0x00,0xaa,0x00,0x37,0x61,0xc5); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAMCopyCaptureFileProgress : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Progress( + int iProgress) = 0; + +}; +#else +typedef struct IAMCopyCaptureFileProgressVtbl IAMCopyCaptureFileProgressVtbl; +struct IAMCopyCaptureFileProgress { + const IAMCopyCaptureFileProgressVtbl* lpVtbl; +}; +struct IAMCopyCaptureFileProgressVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMCopyCaptureFileProgress* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMCopyCaptureFileProgress* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMCopyCaptureFileProgress* This); + + /*** IAMCopyCaptureFileProgress methods ***/ + HRESULT (STDMETHODCALLTYPE *Progress)( + IAMCopyCaptureFileProgress* This, + int iProgress); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAMCopyCaptureFileProgress_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAMCopyCaptureFileProgress_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAMCopyCaptureFileProgress_Release(p) (p)->lpVtbl->Release(p) +/*** IAMCopyCaptureFileProgress methods ***/ +#define IAMCopyCaptureFileProgress_Progress(p,a) (p)->lpVtbl->Progress(p,a) +#endif + +#endif + +#define IAMCopyCaptureFileProgress_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IAMCopyCaptureFileProgress methods ***/ \ + STDMETHOD_(HRESULT,Progress)(THIS_ int iProgress) PURE; + +HRESULT CALLBACK IAMCopyCaptureFileProgress_Progress_Proxy( + IAMCopyCaptureFileProgress* This, + int iProgress); +void __RPC_STUB IAMCopyCaptureFileProgress_Progress_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMCopyCaptureFileProgress_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * ICaptureGraphBuilder2 interface + */ +#ifndef __ICaptureGraphBuilder2_INTERFACE_DEFINED__ +#define __ICaptureGraphBuilder2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_ICaptureGraphBuilder2, 0x93e5a4e0, 0x2d50, 0x11d2, 0xab,0xfa, 0x00,0xa0,0xc9,0xc6,0xe3,0x8d); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct ICaptureGraphBuilder2 : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetFiltergraph( + IGraphBuilder* pfg) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFiltergraph( + IGraphBuilder** ppfg) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputFileName( + const GUID* pType, + LPCOLESTR lpstrFile, + IBaseFilter** ppf, + IFileSinkFilter** ppSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindInterface( + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pf, + REFIID riid, + void** ppint) = 0; + + virtual HRESULT STDMETHODCALLTYPE RenderStream( + const GUID* pCategory, + const GUID* pType, + IUnknown* pSource, + IBaseFilter* pfCompressor, + IBaseFilter* pfRenderer) = 0; + + virtual HRESULT STDMETHODCALLTYPE ControlStream( + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pFilter, + REFERENCE_TIME* pstart, + REFERENCE_TIME* pstop, + WORD wStartCookie, + WORD wStopCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE AllocCapFile( + LPCOLESTR lpstr, + DWORDLONG dwlSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyCaptureFile( + LPOLESTR lpwstrOld, + LPOLESTR lpwstrNew, + int fAllowEscAbort, + IAMCopyCaptureFileProgress* pCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindPin( + IUnknown* pSource, + PIN_DIRECTION pindir, + const GUID* pCategory, + const GUID* pType, + BOOL fUnconnected, + int num, + IPin** ppPin) = 0; + +}; +#else +typedef struct ICaptureGraphBuilder2Vtbl ICaptureGraphBuilder2Vtbl; +struct ICaptureGraphBuilder2 { + const ICaptureGraphBuilder2Vtbl* lpVtbl; +}; +struct ICaptureGraphBuilder2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + ICaptureGraphBuilder2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + ICaptureGraphBuilder2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + ICaptureGraphBuilder2* This); + + /*** ICaptureGraphBuilder2 methods ***/ + HRESULT (STDMETHODCALLTYPE *SetFiltergraph)( + ICaptureGraphBuilder2* This, + IGraphBuilder* pfg); + + HRESULT (STDMETHODCALLTYPE *GetFiltergraph)( + ICaptureGraphBuilder2* This, + IGraphBuilder** ppfg); + + HRESULT (STDMETHODCALLTYPE *SetOutputFileName)( + ICaptureGraphBuilder2* This, + const GUID* pType, + LPCOLESTR lpstrFile, + IBaseFilter** ppf, + IFileSinkFilter** ppSink); + + HRESULT (STDMETHODCALLTYPE *FindInterface)( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pf, + REFIID riid, + void** ppint); + + HRESULT (STDMETHODCALLTYPE *RenderStream)( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IUnknown* pSource, + IBaseFilter* pfCompressor, + IBaseFilter* pfRenderer); + + HRESULT (STDMETHODCALLTYPE *ControlStream)( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pFilter, + REFERENCE_TIME* pstart, + REFERENCE_TIME* pstop, + WORD wStartCookie, + WORD wStopCookie); + + HRESULT (STDMETHODCALLTYPE *AllocCapFile)( + ICaptureGraphBuilder2* This, + LPCOLESTR lpstr, + DWORDLONG dwlSize); + + HRESULT (STDMETHODCALLTYPE *CopyCaptureFile)( + ICaptureGraphBuilder2* This, + LPOLESTR lpwstrOld, + LPOLESTR lpwstrNew, + int fAllowEscAbort, + IAMCopyCaptureFileProgress* pCallback); + + HRESULT (STDMETHODCALLTYPE *FindPin)( + ICaptureGraphBuilder2* This, + IUnknown* pSource, + PIN_DIRECTION pindir, + const GUID* pCategory, + const GUID* pType, + BOOL fUnconnected, + int num, + IPin** ppPin); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define ICaptureGraphBuilder2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define ICaptureGraphBuilder2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define ICaptureGraphBuilder2_Release(p) (p)->lpVtbl->Release(p) +/*** ICaptureGraphBuilder2 methods ***/ +#define ICaptureGraphBuilder2_SetFiltergraph(p,a) (p)->lpVtbl->SetFiltergraph(p,a) +#define ICaptureGraphBuilder2_GetFiltergraph(p,a) (p)->lpVtbl->GetFiltergraph(p,a) +#define ICaptureGraphBuilder2_SetOutputFileName(p,a,b,c,d) (p)->lpVtbl->SetOutputFileName(p,a,b,c,d) +#define ICaptureGraphBuilder2_FindInterface(p,a,b,c,d,e) (p)->lpVtbl->FindInterface(p,a,b,c,d,e) +#define ICaptureGraphBuilder2_RenderStream(p,a,b,c,d,e) (p)->lpVtbl->RenderStream(p,a,b,c,d,e) +#define ICaptureGraphBuilder2_ControlStream(p,a,b,c,d,e,f,g) (p)->lpVtbl->ControlStream(p,a,b,c,d,e,f,g) +#define ICaptureGraphBuilder2_AllocCapFile(p,a,b) (p)->lpVtbl->AllocCapFile(p,a,b) +#define ICaptureGraphBuilder2_CopyCaptureFile(p,a,b,c,d) (p)->lpVtbl->CopyCaptureFile(p,a,b,c,d) +#define ICaptureGraphBuilder2_FindPin(p,a,b,c,d,e,f,g) (p)->lpVtbl->FindPin(p,a,b,c,d,e,f,g) +#endif + +#endif + +#define ICaptureGraphBuilder2_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** ICaptureGraphBuilder2 methods ***/ \ + STDMETHOD_(HRESULT,SetFiltergraph)(THIS_ IGraphBuilder* pfg) PURE; \ + STDMETHOD_(HRESULT,GetFiltergraph)(THIS_ IGraphBuilder** ppfg) PURE; \ + STDMETHOD_(HRESULT,SetOutputFileName)(THIS_ const GUID* pType, LPCOLESTR lpstrFile, IBaseFilter** ppf, IFileSinkFilter** ppSink) PURE; \ + STDMETHOD_(HRESULT,FindInterface)(THIS_ const GUID* pCategory, const GUID* pType, IBaseFilter* pf, REFIID riid, void** ppint) PURE; \ + STDMETHOD_(HRESULT,RenderStream)(THIS_ const GUID* pCategory, const GUID* pType, IUnknown* pSource, IBaseFilter* pfCompressor, IBaseFilter* pfRenderer) PURE; \ + STDMETHOD_(HRESULT,ControlStream)(THIS_ const GUID* pCategory, const GUID* pType, IBaseFilter* pFilter, REFERENCE_TIME* pstart, REFERENCE_TIME* pstop, WORD wStartCookie, WORD wStopCookie) PURE; \ + STDMETHOD_(HRESULT,AllocCapFile)(THIS_ LPCOLESTR lpstr, DWORDLONG dwlSize) PURE; \ + STDMETHOD_(HRESULT,CopyCaptureFile)(THIS_ LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress* pCallback) PURE; \ + STDMETHOD_(HRESULT,FindPin)(THIS_ IUnknown* pSource, PIN_DIRECTION pindir, const GUID* pCategory, const GUID* pType, BOOL fUnconnected, int num, IPin** ppPin) PURE; + +HRESULT CALLBACK ICaptureGraphBuilder2_SetFiltergraph_Proxy( + ICaptureGraphBuilder2* This, + IGraphBuilder* pfg); +void __RPC_STUB ICaptureGraphBuilder2_SetFiltergraph_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_GetFiltergraph_Proxy( + ICaptureGraphBuilder2* This, + IGraphBuilder** ppfg); +void __RPC_STUB ICaptureGraphBuilder2_GetFiltergraph_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_SetOutputFileName_Proxy( + ICaptureGraphBuilder2* This, + const GUID* pType, + LPCOLESTR lpstrFile, + IBaseFilter** ppf, + IFileSinkFilter** ppSink); +void __RPC_STUB ICaptureGraphBuilder2_SetOutputFileName_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_RemoteFindInterface_Proxy( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pf, + REFIID riid, + IUnknown** ppint); +void __RPC_STUB ICaptureGraphBuilder2_RemoteFindInterface_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_FindInterface_Proxy( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pf, + REFIID riid, + void** ppint); +HRESULT __RPC_STUB ICaptureGraphBuilder2_FindInterface_Stub( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pf, + REFIID riid, + IUnknown** ppint); +HRESULT CALLBACK ICaptureGraphBuilder2_RenderStream_Proxy( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IUnknown* pSource, + IBaseFilter* pfCompressor, + IBaseFilter* pfRenderer); +void __RPC_STUB ICaptureGraphBuilder2_RenderStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_ControlStream_Proxy( + ICaptureGraphBuilder2* This, + const GUID* pCategory, + const GUID* pType, + IBaseFilter* pFilter, + REFERENCE_TIME* pstart, + REFERENCE_TIME* pstop, + WORD wStartCookie, + WORD wStopCookie); +void __RPC_STUB ICaptureGraphBuilder2_ControlStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_AllocCapFile_Proxy( + ICaptureGraphBuilder2* This, + LPCOLESTR lpstr, + DWORDLONG dwlSize); +void __RPC_STUB ICaptureGraphBuilder2_AllocCapFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_CopyCaptureFile_Proxy( + ICaptureGraphBuilder2* This, + LPOLESTR lpwstrOld, + LPOLESTR lpwstrNew, + int fAllowEscAbort, + IAMCopyCaptureFileProgress* pCallback); +void __RPC_STUB ICaptureGraphBuilder2_CopyCaptureFile_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK ICaptureGraphBuilder2_FindPin_Proxy( + ICaptureGraphBuilder2* This, + IUnknown* pSource, + PIN_DIRECTION pindir, + const GUID* pCategory, + const GUID* pType, + BOOL fUnconnected, + int num, + IPin** ppPin); +void __RPC_STUB ICaptureGraphBuilder2_FindPin_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __ICaptureGraphBuilder2_INTERFACE_DEFINED__ */ + +enum _AM_RENSDEREXFLAGS { + AM_RENDEREX_RENDERTOEXISTINGRENDERERS = 0x1 +}; + +#ifndef __IFilterGraph2_FWD_DEFINED__ +#define __IFilterGraph2_FWD_DEFINED__ +typedef struct IFilterGraph2 IFilterGraph2; +#endif + +/***************************************************************************** + * IFilterGraph2 interface + */ +#ifndef __IFilterGraph2_INTERFACE_DEFINED__ +#define __IFilterGraph2_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFilterGraph2, 0x36b73882, 0xc2c8, 0x11cf, 0x8b,0x46, 0x00,0x80,0x5f,0x6c,0xef,0x60); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFilterGraph2 : public IGraphBuilder +{ + virtual HRESULT STDMETHODCALLTYPE AddSourceFilterForMoniker( + IMoniker* pMoniker, + IBindCtx* pCtx, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReconnectEx( + IPin* ppin, + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE RenderEx( + IPin* pPinOut, + DWORD dwFlags, + DWORD* pvContext) = 0; + +}; +#else +typedef struct IFilterGraph2Vtbl IFilterGraph2Vtbl; +struct IFilterGraph2 { + const IFilterGraph2Vtbl* lpVtbl; +}; +struct IFilterGraph2Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFilterGraph2* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFilterGraph2* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFilterGraph2* This); + + /*** IFilterGraph methods ***/ + HRESULT (STDMETHODCALLTYPE *AddFilter)( + IFilterGraph2* This, + IBaseFilter* pFilter, + LPCWSTR pName); + + HRESULT (STDMETHODCALLTYPE *RemoveFilter)( + IFilterGraph2* This, + IBaseFilter* pFilter); + + HRESULT (STDMETHODCALLTYPE *EnumFilters)( + IFilterGraph2* This, + IEnumFilters** ppEnum); + + HRESULT (STDMETHODCALLTYPE *FindFilterByName)( + IFilterGraph2* This, + LPCWSTR pName, + IBaseFilter** ppFilter); + + HRESULT (STDMETHODCALLTYPE *ConnectDirect)( + IFilterGraph2* This, + IPin* ppinOut, + IPin* ppinIn, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *Reconnect)( + IFilterGraph2* This, + IPin* ppin); + + HRESULT (STDMETHODCALLTYPE *Disconnect)( + IFilterGraph2* This, + IPin* ppin); + + HRESULT (STDMETHODCALLTYPE *SetDefaultSyncSource)( + IFilterGraph2* This); + + /*** IGraphBuilder methods ***/ + HRESULT (STDMETHODCALLTYPE *Connect)( + IFilterGraph2* This, + IPin* ppinOut, + IPin* ppinIn); + + HRESULT (STDMETHODCALLTYPE *Render)( + IFilterGraph2* This, + IPin* ppinOut); + + HRESULT (STDMETHODCALLTYPE *RenderFile)( + IFilterGraph2* This, + LPCWSTR lpcwstrFile, + LPCWSTR lpcwstrPlayList); + + HRESULT (STDMETHODCALLTYPE *AddSourceFilter)( + IFilterGraph2* This, + LPCWSTR lpcwstrFileName, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter); + + HRESULT (STDMETHODCALLTYPE *SetLogFile)( + IFilterGraph2* This, + DWORD_PTR hFile); + + HRESULT (STDMETHODCALLTYPE *Abort)( + IFilterGraph2* This); + + HRESULT (STDMETHODCALLTYPE *ShouldOperationContinue)( + IFilterGraph2* This); + + /*** IFilterGraph2 methods ***/ + HRESULT (STDMETHODCALLTYPE *AddSourceFilterForMoniker)( + IFilterGraph2* This, + IMoniker* pMoniker, + IBindCtx* pCtx, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter); + + HRESULT (STDMETHODCALLTYPE *ReconnectEx)( + IFilterGraph2* This, + IPin* ppin, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *RenderEx)( + IFilterGraph2* This, + IPin* pPinOut, + DWORD dwFlags, + DWORD* pvContext); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFilterGraph2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterGraph2_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterGraph2_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterGraph methods ***/ +#define IFilterGraph2_AddFilter(p,a,b) (p)->lpVtbl->AddFilter(p,a,b) +#define IFilterGraph2_RemoveFilter(p,a) (p)->lpVtbl->RemoveFilter(p,a) +#define IFilterGraph2_EnumFilters(p,a) (p)->lpVtbl->EnumFilters(p,a) +#define IFilterGraph2_FindFilterByName(p,a,b) (p)->lpVtbl->FindFilterByName(p,a,b) +#define IFilterGraph2_ConnectDirect(p,a,b,c) (p)->lpVtbl->ConnectDirect(p,a,b,c) +#define IFilterGraph2_Reconnect(p,a) (p)->lpVtbl->Reconnect(p,a) +#define IFilterGraph2_Disconnect(p,a) (p)->lpVtbl->Disconnect(p,a) +#define IFilterGraph2_SetDefaultSyncSource(p) (p)->lpVtbl->SetDefaultSyncSource(p) +/*** IGraphBuilder methods ***/ +#define IFilterGraph2_Connect(p,a,b) (p)->lpVtbl->Connect(p,a,b) +#define IFilterGraph2_Render(p,a) (p)->lpVtbl->Render(p,a) +#define IFilterGraph2_RenderFile(p,a,b) (p)->lpVtbl->RenderFile(p,a,b) +#define IFilterGraph2_AddSourceFilter(p,a,b,c) (p)->lpVtbl->AddSourceFilter(p,a,b,c) +#define IFilterGraph2_SetLogFile(p,a) (p)->lpVtbl->SetLogFile(p,a) +#define IFilterGraph2_Abort(p) (p)->lpVtbl->Abort(p) +#define IFilterGraph2_ShouldOperationContinue(p) (p)->lpVtbl->ShouldOperationContinue(p) +/*** IFilterGraph2 methods ***/ +#define IFilterGraph2_AddSourceFilterForMoniker(p,a,b,c,d) (p)->lpVtbl->AddSourceFilterForMoniker(p,a,b,c,d) +#define IFilterGraph2_ReconnectEx(p,a,b) (p)->lpVtbl->ReconnectEx(p,a,b) +#define IFilterGraph2_RenderEx(p,a,b,c) (p)->lpVtbl->RenderEx(p,a,b,c) +#endif + +#endif + +#define IFilterGraph2_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterGraph methods ***/ \ + STDMETHOD_(HRESULT,AddFilter)(THIS_ IBaseFilter* pFilter, LPCWSTR pName) PURE; \ + STDMETHOD_(HRESULT,RemoveFilter)(THIS_ IBaseFilter* pFilter) PURE; \ + STDMETHOD_(HRESULT,EnumFilters)(THIS_ IEnumFilters** ppEnum) PURE; \ + STDMETHOD_(HRESULT,FindFilterByName)(THIS_ LPCWSTR pName, IBaseFilter** ppFilter) PURE; \ + STDMETHOD_(HRESULT,ConnectDirect)(THIS_ IPin* ppinOut, IPin* ppinIn, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* ppin) PURE; \ + STDMETHOD_(HRESULT,Disconnect)(THIS_ IPin* ppin) PURE; \ + STDMETHOD_(HRESULT,SetDefaultSyncSource)(THIS) PURE; \ + /*** IGraphBuilder methods ***/ \ + STDMETHOD_(HRESULT,Connect)(THIS_ IPin* ppinOut, IPin* ppinIn) PURE; \ + STDMETHOD_(HRESULT,Render)(THIS_ IPin* ppinOut) PURE; \ + STDMETHOD_(HRESULT,RenderFile)(THIS_ LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList) PURE; \ + STDMETHOD_(HRESULT,AddSourceFilter)(THIS_ LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter) PURE; \ + STDMETHOD_(HRESULT,SetLogFile)(THIS_ DWORD_PTR hFile) PURE; \ + STDMETHOD_(HRESULT,Abort)(THIS) PURE; \ + STDMETHOD_(HRESULT,ShouldOperationContinue)(THIS) PURE; \ + /*** IFilterGraph2 methods ***/ \ + STDMETHOD_(HRESULT,AddSourceFilterForMoniker)(THIS_ IMoniker* pMoniker, IBindCtx* pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter) PURE; \ + STDMETHOD_(HRESULT,ReconnectEx)(THIS_ IPin* ppin, const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,RenderEx)(THIS_ IPin* pPinOut, DWORD dwFlags, DWORD* pvContext) PURE; + +HRESULT CALLBACK IFilterGraph2_AddSourceFilterForMoniker_Proxy( + IFilterGraph2* This, + IMoniker* pMoniker, + IBindCtx* pCtx, + LPCWSTR lpcwstrFilterName, + IBaseFilter** ppFilter); +void __RPC_STUB IFilterGraph2_AddSourceFilterForMoniker_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph2_ReconnectEx_Proxy( + IFilterGraph2* This, + IPin* ppin, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IFilterGraph2_ReconnectEx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterGraph2_RenderEx_Proxy( + IFilterGraph2* This, + IPin* pPinOut, + DWORD dwFlags, + DWORD* pvContext); +void __RPC_STUB IFilterGraph2_RenderEx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFilterGraph2_INTERFACE_DEFINED__ */ + +#ifndef __IStreamBuilder_FWD_DEFINED__ +#define __IStreamBuilder_FWD_DEFINED__ +typedef struct IStreamBuilder IStreamBuilder; +#endif + +/***************************************************************************** + * IStreamBuilder interface + */ +#ifndef __IStreamBuilder_INTERFACE_DEFINED__ +#define __IStreamBuilder_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IStreamBuilder, 0x56a868bf, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IStreamBuilder : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Render( + IPin* ppinOut, + IGraphBuilder* pGraph) = 0; + + virtual HRESULT STDMETHODCALLTYPE Backout( + IPin* ppinOut, + IGraphBuilder* pGraph) = 0; + +}; +#else +typedef struct IStreamBuilderVtbl IStreamBuilderVtbl; +struct IStreamBuilder { + const IStreamBuilderVtbl* lpVtbl; +}; +struct IStreamBuilderVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IStreamBuilder* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IStreamBuilder* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IStreamBuilder* This); + + /*** IStreamBuilder methods ***/ + HRESULT (STDMETHODCALLTYPE *Render)( + IStreamBuilder* This, + IPin* ppinOut, + IGraphBuilder* pGraph); + + HRESULT (STDMETHODCALLTYPE *Backout)( + IStreamBuilder* This, + IPin* ppinOut, + IGraphBuilder* pGraph); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IStreamBuilder_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IStreamBuilder_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IStreamBuilder_Release(p) (p)->lpVtbl->Release(p) +/*** IStreamBuilder methods ***/ +#define IStreamBuilder_Render(p,a,b) (p)->lpVtbl->Render(p,a,b) +#define IStreamBuilder_Backout(p,a,b) (p)->lpVtbl->Backout(p,a,b) +#endif + +#endif + +#define IStreamBuilder_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IStreamBuilder methods ***/ \ + STDMETHOD_(HRESULT,Render)(THIS_ IPin* ppinOut, IGraphBuilder* pGraph) PURE; \ + STDMETHOD_(HRESULT,Backout)(THIS_ IPin* ppinOut, IGraphBuilder* pGraph) PURE; + +HRESULT CALLBACK IStreamBuilder_Render_Proxy( + IStreamBuilder* This, + IPin* ppinOut, + IGraphBuilder* pGraph); +void __RPC_STUB IStreamBuilder_Render_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IStreamBuilder_Backout_Proxy( + IStreamBuilder* This, + IPin* ppinOut, + IGraphBuilder* pGraph); +void __RPC_STUB IStreamBuilder_Backout_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IStreamBuilder_INTERFACE_DEFINED__ */ + +#ifndef __IAsyncReader_FWD_DEFINED__ +#define __IAsyncReader_FWD_DEFINED__ +typedef struct IAsyncReader IAsyncReader; +#endif + +/***************************************************************************** + * IAsyncReader interface + */ +#ifndef __IAsyncReader_INTERFACE_DEFINED__ +#define __IAsyncReader_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAsyncReader, 0x56a868aa, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IAsyncReader : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE RequestAllocator( + IMemAllocator* pPreferred, + ALLOCATOR_PROPERTIES* pProps, + IMemAllocator** ppActual) = 0; + + virtual HRESULT STDMETHODCALLTYPE Request( + IMediaSample* pSample, + DWORD_PTR dwUser) = 0; + + virtual HRESULT STDMETHODCALLTYPE WaitForNext( + DWORD dwTimeout, + IMediaSample** ppSample, + DWORD_PTR* pdwUser) = 0; + + virtual HRESULT STDMETHODCALLTYPE SyncReadAligned( + IMediaSample* pSample) = 0; + + virtual HRESULT STDMETHODCALLTYPE SyncRead( + LONGLONG llPosition, + LONG lLength, + BYTE* pBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE Length( + LONGLONG* pTotal, + LONGLONG* pAvailable) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginFlush( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndFlush( + ) = 0; + +}; +#else +typedef struct IAsyncReaderVtbl IAsyncReaderVtbl; +struct IAsyncReader { + const IAsyncReaderVtbl* lpVtbl; +}; +struct IAsyncReaderVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAsyncReader* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAsyncReader* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAsyncReader* This); + + /*** IAsyncReader methods ***/ + HRESULT (STDMETHODCALLTYPE *RequestAllocator)( + IAsyncReader* This, + IMemAllocator* pPreferred, + ALLOCATOR_PROPERTIES* pProps, + IMemAllocator** ppActual); + + HRESULT (STDMETHODCALLTYPE *Request)( + IAsyncReader* This, + IMediaSample* pSample, + DWORD_PTR dwUser); + + HRESULT (STDMETHODCALLTYPE *WaitForNext)( + IAsyncReader* This, + DWORD dwTimeout, + IMediaSample** ppSample, + DWORD_PTR* pdwUser); + + HRESULT (STDMETHODCALLTYPE *SyncReadAligned)( + IAsyncReader* This, + IMediaSample* pSample); + + HRESULT (STDMETHODCALLTYPE *SyncRead)( + IAsyncReader* This, + LONGLONG llPosition, + LONG lLength, + BYTE* pBuffer); + + HRESULT (STDMETHODCALLTYPE *Length)( + IAsyncReader* This, + LONGLONG* pTotal, + LONGLONG* pAvailable); + + HRESULT (STDMETHODCALLTYPE *BeginFlush)( + IAsyncReader* This); + + HRESULT (STDMETHODCALLTYPE *EndFlush)( + IAsyncReader* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IAsyncReader_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IAsyncReader_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IAsyncReader_Release(p) (p)->lpVtbl->Release(p) +/*** IAsyncReader methods ***/ +#define IAsyncReader_RequestAllocator(p,a,b,c) (p)->lpVtbl->RequestAllocator(p,a,b,c) +#define IAsyncReader_Request(p,a,b) (p)->lpVtbl->Request(p,a,b) +#define IAsyncReader_WaitForNext(p,a,b,c) (p)->lpVtbl->WaitForNext(p,a,b,c) +#define IAsyncReader_SyncReadAligned(p,a) (p)->lpVtbl->SyncReadAligned(p,a) +#define IAsyncReader_SyncRead(p,a,b,c) (p)->lpVtbl->SyncRead(p,a,b,c) +#define IAsyncReader_Length(p,a,b) (p)->lpVtbl->Length(p,a,b) +#define IAsyncReader_BeginFlush(p) (p)->lpVtbl->BeginFlush(p) +#define IAsyncReader_EndFlush(p) (p)->lpVtbl->EndFlush(p) +#endif + +#endif + +#define IAsyncReader_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IAsyncReader methods ***/ \ + STDMETHOD_(HRESULT,RequestAllocator)(THIS_ IMemAllocator* pPreferred, ALLOCATOR_PROPERTIES* pProps, IMemAllocator** ppActual) PURE; \ + STDMETHOD_(HRESULT,Request)(THIS_ IMediaSample* pSample, DWORD_PTR dwUser) PURE; \ + STDMETHOD_(HRESULT,WaitForNext)(THIS_ DWORD dwTimeout, IMediaSample** ppSample, DWORD_PTR* pdwUser) PURE; \ + STDMETHOD_(HRESULT,SyncReadAligned)(THIS_ IMediaSample* pSample) PURE; \ + STDMETHOD_(HRESULT,SyncRead)(THIS_ LONGLONG llPosition, LONG lLength, BYTE* pBuffer) PURE; \ + STDMETHOD_(HRESULT,Length)(THIS_ LONGLONG* pTotal, LONGLONG* pAvailable) PURE; \ + STDMETHOD_(HRESULT,BeginFlush)(THIS) PURE; \ + STDMETHOD_(HRESULT,EndFlush)(THIS) PURE; + +HRESULT CALLBACK IAsyncReader_RequestAllocator_Proxy( + IAsyncReader* This, + IMemAllocator* pPreferred, + ALLOCATOR_PROPERTIES* pProps, + IMemAllocator** ppActual); +void __RPC_STUB IAsyncReader_RequestAllocator_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_Request_Proxy( + IAsyncReader* This, + IMediaSample* pSample, + DWORD_PTR dwUser); +void __RPC_STUB IAsyncReader_Request_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_WaitForNext_Proxy( + IAsyncReader* This, + DWORD dwTimeout, + IMediaSample** ppSample, + DWORD_PTR* pdwUser); +void __RPC_STUB IAsyncReader_WaitForNext_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_SyncReadAligned_Proxy( + IAsyncReader* This, + IMediaSample* pSample); +void __RPC_STUB IAsyncReader_SyncReadAligned_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_SyncRead_Proxy( + IAsyncReader* This, + LONGLONG llPosition, + LONG lLength, + BYTE* pBuffer); +void __RPC_STUB IAsyncReader_SyncRead_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_Length_Proxy( + IAsyncReader* This, + LONGLONG* pTotal, + LONGLONG* pAvailable); +void __RPC_STUB IAsyncReader_Length_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_BeginFlush_Proxy( + IAsyncReader* This); +void __RPC_STUB IAsyncReader_BeginFlush_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IAsyncReader_EndFlush_Proxy( + IAsyncReader* This); +void __RPC_STUB IAsyncReader_EndFlush_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAsyncReader_INTERFACE_DEFINED__ */ + +#ifndef __IGraphVersion_FWD_DEFINED__ +#define __IGraphVersion_FWD_DEFINED__ +typedef struct IGraphVersion IGraphVersion; +#endif + +/***************************************************************************** + * IGraphVersion interface + */ +#ifndef __IGraphVersion_INTERFACE_DEFINED__ +#define __IGraphVersion_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IGraphVersion, 0x56a868ab, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IGraphVersion : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE QueryVersion( + LONG* pVersion) = 0; + +}; +#else +typedef struct IGraphVersionVtbl IGraphVersionVtbl; +struct IGraphVersion { + const IGraphVersionVtbl* lpVtbl; +}; +struct IGraphVersionVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IGraphVersion* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IGraphVersion* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IGraphVersion* This); + + /*** IGraphVersion methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryVersion)( + IGraphVersion* This, + LONG* pVersion); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IGraphVersion_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IGraphVersion_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IGraphVersion_Release(p) (p)->lpVtbl->Release(p) +/*** IGraphVersion methods ***/ +#define IGraphVersion_QueryVersion(p,a) (p)->lpVtbl->QueryVersion(p,a) +#endif + +#endif + +#define IGraphVersion_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IGraphVersion methods ***/ \ + STDMETHOD_(HRESULT,QueryVersion)(THIS_ LONG* pVersion) PURE; + +HRESULT CALLBACK IGraphVersion_QueryVersion_Proxy( + IGraphVersion* This, + LONG* pVersion); +void __RPC_STUB IGraphVersion_QueryVersion_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IGraphVersion_INTERFACE_DEFINED__ */ + +#ifndef __IResourceConsumer_FWD_DEFINED__ +#define __IResourceConsumer_FWD_DEFINED__ +typedef struct IResourceConsumer IResourceConsumer; +#endif + +/***************************************************************************** + * IResourceConsumer interface + */ +#ifndef __IResourceConsumer_INTERFACE_DEFINED__ +#define __IResourceConsumer_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IResourceConsumer, 0x56a868ad, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IResourceConsumer : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE AcquireResource( + LONG idResource) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseResource( + LONG idResource) = 0; + +}; +#else +typedef struct IResourceConsumerVtbl IResourceConsumerVtbl; +struct IResourceConsumer { + const IResourceConsumerVtbl* lpVtbl; +}; +struct IResourceConsumerVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IResourceConsumer* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IResourceConsumer* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IResourceConsumer* This); + + /*** IResourceConsumer methods ***/ + HRESULT (STDMETHODCALLTYPE *AcquireResource)( + IResourceConsumer* This, + LONG idResource); + + HRESULT (STDMETHODCALLTYPE *ReleaseResource)( + IResourceConsumer* This, + LONG idResource); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IResourceConsumer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IResourceConsumer_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IResourceConsumer_Release(p) (p)->lpVtbl->Release(p) +/*** IResourceConsumer methods ***/ +#define IResourceConsumer_AcquireResource(p,a) (p)->lpVtbl->AcquireResource(p,a) +#define IResourceConsumer_ReleaseResource(p,a) (p)->lpVtbl->ReleaseResource(p,a) +#endif + +#endif + +#define IResourceConsumer_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IResourceConsumer methods ***/ \ + STDMETHOD_(HRESULT,AcquireResource)(THIS_ LONG idResource) PURE; \ + STDMETHOD_(HRESULT,ReleaseResource)(THIS_ LONG idResource) PURE; + +HRESULT CALLBACK IResourceConsumer_AcquireResource_Proxy( + IResourceConsumer* This, + LONG idResource); +void __RPC_STUB IResourceConsumer_AcquireResource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceConsumer_ReleaseResource_Proxy( + IResourceConsumer* This, + LONG idResource); +void __RPC_STUB IResourceConsumer_ReleaseResource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IResourceConsumer_INTERFACE_DEFINED__ */ + +#ifndef __IResourceManager_FWD_DEFINED__ +#define __IResourceManager_FWD_DEFINED__ +typedef struct IResourceManager IResourceManager; +#endif + +/***************************************************************************** + * IResourceManager interface + */ +#ifndef __IResourceManager_INTERFACE_DEFINED__ +#define __IResourceManager_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IResourceManager, 0x56a868ac, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IResourceManager : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Register( + LPCWSTR pName, + LONG cResource, + LONG* plToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterGroup( + LPCWSTR pName, + LONG cResource, + LONG* palTokens, + LONG* plToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE RequestResource( + LONG idResource, + IUnknown* pFocusObject, + IResourceConsumer* pConsumer) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyAcquire( + LONG idResource, + IResourceConsumer* pConsumer, + HRESULT hr) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyRelease( + LONG idResource, + IResourceConsumer* pConsumer, + BOOL bStillWant) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelRequest( + LONG idResource, + IResourceConsumer* pConsumer) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFocus( + IUnknown* pFocusObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseFocus( + IUnknown* pFocusObject) = 0; + +}; +#else +typedef struct IResourceManagerVtbl IResourceManagerVtbl; +struct IResourceManager { + const IResourceManagerVtbl* lpVtbl; +}; +struct IResourceManagerVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IResourceManager* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IResourceManager* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IResourceManager* This); + + /*** IResourceManager methods ***/ + HRESULT (STDMETHODCALLTYPE *Register)( + IResourceManager* This, + LPCWSTR pName, + LONG cResource, + LONG* plToken); + + HRESULT (STDMETHODCALLTYPE *RegisterGroup)( + IResourceManager* This, + LPCWSTR pName, + LONG cResource, + LONG* palTokens, + LONG* plToken); + + HRESULT (STDMETHODCALLTYPE *RequestResource)( + IResourceManager* This, + LONG idResource, + IUnknown* pFocusObject, + IResourceConsumer* pConsumer); + + HRESULT (STDMETHODCALLTYPE *NotifyAcquire)( + IResourceManager* This, + LONG idResource, + IResourceConsumer* pConsumer, + HRESULT hr); + + HRESULT (STDMETHODCALLTYPE *NotifyRelease)( + IResourceManager* This, + LONG idResource, + IResourceConsumer* pConsumer, + BOOL bStillWant); + + HRESULT (STDMETHODCALLTYPE *CancelRequest)( + IResourceManager* This, + LONG idResource, + IResourceConsumer* pConsumer); + + HRESULT (STDMETHODCALLTYPE *SetFocus)( + IResourceManager* This, + IUnknown* pFocusObject); + + HRESULT (STDMETHODCALLTYPE *ReleaseFocus)( + IResourceManager* This, + IUnknown* pFocusObject); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IResourceManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IResourceManager_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IResourceManager_Release(p) (p)->lpVtbl->Release(p) +/*** IResourceManager methods ***/ +#define IResourceManager_Register(p,a,b,c) (p)->lpVtbl->Register(p,a,b,c) +#define IResourceManager_RegisterGroup(p,a,b,c,d) (p)->lpVtbl->RegisterGroup(p,a,b,c,d) +#define IResourceManager_RequestResource(p,a,b,c) (p)->lpVtbl->RequestResource(p,a,b,c) +#define IResourceManager_NotifyAcquire(p,a,b,c) (p)->lpVtbl->NotifyAcquire(p,a,b,c) +#define IResourceManager_NotifyRelease(p,a,b,c) (p)->lpVtbl->NotifyRelease(p,a,b,c) +#define IResourceManager_CancelRequest(p,a,b) (p)->lpVtbl->CancelRequest(p,a,b) +#define IResourceManager_SetFocus(p,a) (p)->lpVtbl->SetFocus(p,a) +#define IResourceManager_ReleaseFocus(p,a) (p)->lpVtbl->ReleaseFocus(p,a) +#endif + +#endif + +#define IResourceManager_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IResourceManager methods ***/ \ + STDMETHOD_(HRESULT,Register)(THIS_ LPCWSTR pName, LONG cResource, LONG* plToken) PURE; \ + STDMETHOD_(HRESULT,RegisterGroup)(THIS_ LPCWSTR pName, LONG cResource, LONG* palTokens, LONG* plToken) PURE; \ + STDMETHOD_(HRESULT,RequestResource)(THIS_ LONG idResource, IUnknown* pFocusObject, IResourceConsumer* pConsumer) PURE; \ + STDMETHOD_(HRESULT,NotifyAcquire)(THIS_ LONG idResource, IResourceConsumer* pConsumer, HRESULT hr) PURE; \ + STDMETHOD_(HRESULT,NotifyRelease)(THIS_ LONG idResource, IResourceConsumer* pConsumer, BOOL bStillWant) PURE; \ + STDMETHOD_(HRESULT,CancelRequest)(THIS_ LONG idResource, IResourceConsumer* pConsumer) PURE; \ + STDMETHOD_(HRESULT,SetFocus)(THIS_ IUnknown* pFocusObject) PURE; \ + STDMETHOD_(HRESULT,ReleaseFocus)(THIS_ IUnknown* pFocusObject) PURE; + +HRESULT CALLBACK IResourceManager_Register_Proxy( + IResourceManager* This, + LPCWSTR pName, + LONG cResource, + LONG* plToken); +void __RPC_STUB IResourceManager_Register_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_RegisterGroup_Proxy( + IResourceManager* This, + LPCWSTR pName, + LONG cResource, + LONG* palTokens, + LONG* plToken); +void __RPC_STUB IResourceManager_RegisterGroup_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_RequestResource_Proxy( + IResourceManager* This, + LONG idResource, + IUnknown* pFocusObject, + IResourceConsumer* pConsumer); +void __RPC_STUB IResourceManager_RequestResource_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_NotifyAcquire_Proxy( + IResourceManager* This, + LONG idResource, + IResourceConsumer* pConsumer, + HRESULT hr); +void __RPC_STUB IResourceManager_NotifyAcquire_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_NotifyRelease_Proxy( + IResourceManager* This, + LONG idResource, + IResourceConsumer* pConsumer, + BOOL bStillWant); +void __RPC_STUB IResourceManager_NotifyRelease_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_CancelRequest_Proxy( + IResourceManager* This, + LONG idResource, + IResourceConsumer* pConsumer); +void __RPC_STUB IResourceManager_CancelRequest_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_SetFocus_Proxy( + IResourceManager* This, + IUnknown* pFocusObject); +void __RPC_STUB IResourceManager_SetFocus_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IResourceManager_ReleaseFocus_Proxy( + IResourceManager* This, + IUnknown* pFocusObject); +void __RPC_STUB IResourceManager_ReleaseFocus_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IResourceManager_INTERFACE_DEFINED__ */ + +#ifndef _IKsPropertySet_ +#define _IKsPropertySet_ +#define KSPROPERTY_SUPPORT_GET 1 +#define KSPROPERTY_SUPPORT_SET 2 +/***************************************************************************** + * IKsPropertySet interface + */ +#ifndef __IKsPropertySet_INTERFACE_DEFINED__ +#define __IKsPropertySet_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IKsPropertySet, 0x31efac30, 0x515c, 0x11d0, 0xa9,0xaa, 0x00,0xaa,0x00,0x61,0xbe,0x93); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IKsPropertySet : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Set( + REFGUID guidPropSet, + DWORD dwPropID, + LPVOID pInstanceData, + DWORD cbInstanceData, + LPVOID pPropData, + DWORD cbPropData) = 0; + + virtual HRESULT STDMETHODCALLTYPE Get( + REFGUID guidPropSet, + DWORD dwPropID, + LPVOID pInstanceData, + DWORD cbInstanceData, + LPVOID pPropData, + DWORD cbPropData, + DWORD* pcbReturned) = 0; + + virtual HRESULT STDMETHODCALLTYPE QuerySupported( + REFGUID guidPropSet, + DWORD dwPropID, + DWORD* pTypeSupport) = 0; + +}; +#else +typedef struct IKsPropertySetVtbl IKsPropertySetVtbl; +struct IKsPropertySet { + const IKsPropertySetVtbl* lpVtbl; +}; +struct IKsPropertySetVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IKsPropertySet* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IKsPropertySet* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IKsPropertySet* This); + + /*** IKsPropertySet methods ***/ + HRESULT (STDMETHODCALLTYPE *Set)( + IKsPropertySet* This, + REFGUID guidPropSet, + DWORD dwPropID, + LPVOID pInstanceData, + DWORD cbInstanceData, + LPVOID pPropData, + DWORD cbPropData); + + HRESULT (STDMETHODCALLTYPE *Get)( + IKsPropertySet* This, + REFGUID guidPropSet, + DWORD dwPropID, + LPVOID pInstanceData, + DWORD cbInstanceData, + LPVOID pPropData, + DWORD cbPropData, + DWORD* pcbReturned); + + HRESULT (STDMETHODCALLTYPE *QuerySupported)( + IKsPropertySet* This, + REFGUID guidPropSet, + DWORD dwPropID, + DWORD* pTypeSupport); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IKsPropertySet_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IKsPropertySet_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IKsPropertySet_Release(p) (p)->lpVtbl->Release(p) +/*** IKsPropertySet methods ***/ +#define IKsPropertySet_Set(p,a,b,c,d,e,f) (p)->lpVtbl->Set(p,a,b,c,d,e,f) +#define IKsPropertySet_Get(p,a,b,c,d,e,f,g) (p)->lpVtbl->Get(p,a,b,c,d,e,f,g) +#define IKsPropertySet_QuerySupported(p,a,b,c) (p)->lpVtbl->QuerySupported(p,a,b,c) +#endif + +#endif + +#define IKsPropertySet_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IKsPropertySet methods ***/ \ + STDMETHOD_(HRESULT,Set)(THIS_ REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData) PURE; \ + STDMETHOD_(HRESULT,Get)(THIS_ REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD* pcbReturned) PURE; \ + STDMETHOD_(HRESULT,QuerySupported)(THIS_ REFGUID guidPropSet, DWORD dwPropID, DWORD* pTypeSupport) PURE; + +HRESULT CALLBACK IKsPropertySet_Set_Proxy( + IKsPropertySet* This, + REFGUID guidPropSet, + DWORD dwPropID, + LPVOID pInstanceData, + DWORD cbInstanceData, + LPVOID pPropData, + DWORD cbPropData); +void __RPC_STUB IKsPropertySet_Set_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IKsPropertySet_Get_Proxy( + IKsPropertySet* This, + REFGUID guidPropSet, + DWORD dwPropID, + LPVOID pInstanceData, + DWORD cbInstanceData, + LPVOID pPropData, + DWORD cbPropData, + DWORD* pcbReturned); +void __RPC_STUB IKsPropertySet_Get_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IKsPropertySet_QuerySupported_Proxy( + IKsPropertySet* This, + REFGUID guidPropSet, + DWORD dwPropID, + DWORD* pTypeSupport); +void __RPC_STUB IKsPropertySet_QuerySupported_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IKsPropertySet_INTERFACE_DEFINED__ */ + +#endif /* _IKsPropertySet_ */ +#ifndef __IPinConnection_FWD_DEFINED__ +#define __IPinConnection_FWD_DEFINED__ +typedef struct IPinConnection IPinConnection; +#endif + +#ifndef __IPinFlowControl_FWD_DEFINED__ +#define __IPinFlowControl_FWD_DEFINED__ +typedef struct IPinFlowControl IPinFlowControl; +#endif + +#ifndef __IGraphConfig_FWD_DEFINED__ +#define __IGraphConfig_FWD_DEFINED__ +typedef struct IGraphConfig IGraphConfig; +#endif + +#ifndef __IGraphConfigCallback_FWD_DEFINED__ +#define __IGraphConfigCallback_FWD_DEFINED__ +typedef struct IGraphConfigCallback IGraphConfigCallback; +#endif + +/***************************************************************************** + * IPinConnection interface + */ +#ifndef __IPinConnection_INTERFACE_DEFINED__ +#define __IPinConnection_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPinConnection, 0x4a9a62d3, 0x27d4, 0x403d, 0x91,0xe9, 0x89,0xf5,0x40,0xe5,0x55,0x34); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPinConnection : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE DynamicQueryAccept( + const AM_MEDIA_TYPE* pmt) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyEndOfStream( + HANDLE hNotifyEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsEndPin( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE DynamicDisconnect( + ) = 0; + +}; +#else +typedef struct IPinConnectionVtbl IPinConnectionVtbl; +struct IPinConnection { + const IPinConnectionVtbl* lpVtbl; +}; +struct IPinConnectionVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPinConnection* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPinConnection* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPinConnection* This); + + /*** IPinConnection methods ***/ + HRESULT (STDMETHODCALLTYPE *DynamicQueryAccept)( + IPinConnection* This, + const AM_MEDIA_TYPE* pmt); + + HRESULT (STDMETHODCALLTYPE *NotifyEndOfStream)( + IPinConnection* This, + HANDLE hNotifyEvent); + + HRESULT (STDMETHODCALLTYPE *IsEndPin)( + IPinConnection* This); + + HRESULT (STDMETHODCALLTYPE *DynamicDisconnect)( + IPinConnection* This); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPinConnection_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPinConnection_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPinConnection_Release(p) (p)->lpVtbl->Release(p) +/*** IPinConnection methods ***/ +#define IPinConnection_DynamicQueryAccept(p,a) (p)->lpVtbl->DynamicQueryAccept(p,a) +#define IPinConnection_NotifyEndOfStream(p,a) (p)->lpVtbl->NotifyEndOfStream(p,a) +#define IPinConnection_IsEndPin(p) (p)->lpVtbl->IsEndPin(p) +#define IPinConnection_DynamicDisconnect(p) (p)->lpVtbl->DynamicDisconnect(p) +#endif + +#endif + +#define IPinConnection_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPinConnection methods ***/ \ + STDMETHOD_(HRESULT,DynamicQueryAccept)(THIS_ const AM_MEDIA_TYPE* pmt) PURE; \ + STDMETHOD_(HRESULT,NotifyEndOfStream)(THIS_ HANDLE hNotifyEvent) PURE; \ + STDMETHOD_(HRESULT,IsEndPin)(THIS) PURE; \ + STDMETHOD_(HRESULT,DynamicDisconnect)(THIS) PURE; + +HRESULT CALLBACK IPinConnection_DynamicQueryAccept_Proxy( + IPinConnection* This, + const AM_MEDIA_TYPE* pmt); +void __RPC_STUB IPinConnection_DynamicQueryAccept_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPinConnection_NotifyEndOfStream_Proxy( + IPinConnection* This, + HANDLE hNotifyEvent); +void __RPC_STUB IPinConnection_NotifyEndOfStream_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPinConnection_IsEndPin_Proxy( + IPinConnection* This); +void __RPC_STUB IPinConnection_IsEndPin_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IPinConnection_DynamicDisconnect_Proxy( + IPinConnection* This); +void __RPC_STUB IPinConnection_DynamicDisconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPinConnection_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IPinFlowControl interface + */ +#ifndef __IPinFlowControl_INTERFACE_DEFINED__ +#define __IPinFlowControl_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPinFlowControl, 0xc56e9858, 0xdbf3, 0x4f6b, 0x81,0x19, 0x38,0x4a,0xf2,0x06,0x0d,0xeb); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IPinFlowControl : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Block( + DWORD dwBlockFlags, + HANDLE hEvent) = 0; + +}; +#else +typedef struct IPinFlowControlVtbl IPinFlowControlVtbl; +struct IPinFlowControl { + const IPinFlowControlVtbl* lpVtbl; +}; +struct IPinFlowControlVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPinFlowControl* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPinFlowControl* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPinFlowControl* This); + + /*** IPinFlowControl methods ***/ + HRESULT (STDMETHODCALLTYPE *Block)( + IPinFlowControl* This, + DWORD dwBlockFlags, + HANDLE hEvent); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IPinFlowControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IPinFlowControl_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IPinFlowControl_Release(p) (p)->lpVtbl->Release(p) +/*** IPinFlowControl methods ***/ +#define IPinFlowControl_Block(p,a,b) (p)->lpVtbl->Block(p,a,b) +#endif + +#endif + +#define IPinFlowControl_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IPinFlowControl methods ***/ \ + STDMETHOD_(HRESULT,Block)(THIS_ DWORD dwBlockFlags, HANDLE hEvent) PURE; + +HRESULT CALLBACK IPinFlowControl_Block_Proxy( + IPinFlowControl* This, + DWORD dwBlockFlags, + HANDLE hEvent); +void __RPC_STUB IPinFlowControl_Block_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPinFlowControl_INTERFACE_DEFINED__ */ + +enum _AM_PIN_FLOW_CONTROL_BLOCK_FLAGS { + AM_PIN_FLOW_CONTROL_BLOCK = 0x1 +}; + +typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS { + AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = 0x1, + AM_GRAPH_CONFIG_RECONNECT_CACHE_REMOVED_FILTERS = 0x2, + AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = 0x4 +} AM_GRAPH_CONFIG_RECONNECT_FLAGS; + +enum _REM_FILTER_FLAGS { + REMFILTERF_LEAVECONNECTED = 0x1 +}; + +typedef enum _AM_FILTER_FLAGS { + AM_FILTER_FLAGS_REMOVABLE = 0x1 +} AM_FILTER_FLAGS; + +/***************************************************************************** + * IGraphConfig interface + */ +#ifndef __IGraphConfig_INTERFACE_DEFINED__ +#define __IGraphConfig_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IGraphConfig, 0x03a1eb8e, 0x32bf, 0x4245, 0x85,0x02, 0x11,0x4d,0x08,0xa9,0xcb,0x88); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IGraphConfig : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Reconnect( + IPin* pOutputPin, + IPin* pInputPin, + const AM_MEDIA_TYPE* pmtFirstConnection, + IBaseFilter* pUsingFilter, + HANDLE hAbortEvent, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reconfigure( + IGraphConfigCallback* pCallback, + PVOID pvContext, + DWORD dwFlags, + HANDLE hAbortEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddFilterToCache( + IBaseFilter* pFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnumCacheFilter( + IEnumFilters** pEnum) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveFilterFromCache( + IBaseFilter* pFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStartTime( + REFERENCE_TIME* prtStart) = 0; + + virtual HRESULT STDMETHODCALLTYPE PushThroughData( + IPin* pOutputPin, + IPinConnection* pConnection, + HANDLE hEventAbort) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetFilterFlags( + IBaseFilter* pFilter, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFilterFlags( + IBaseFilter* pFilter, + DWORD* pdwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveFilterEx( + IBaseFilter* pFilter, + DWORD Flags) = 0; + +}; +#else +typedef struct IGraphConfigVtbl IGraphConfigVtbl; +struct IGraphConfig { + const IGraphConfigVtbl* lpVtbl; +}; +struct IGraphConfigVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IGraphConfig* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IGraphConfig* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IGraphConfig* This); + + /*** IGraphConfig methods ***/ + HRESULT (STDMETHODCALLTYPE *Reconnect)( + IGraphConfig* This, + IPin* pOutputPin, + IPin* pInputPin, + const AM_MEDIA_TYPE* pmtFirstConnection, + IBaseFilter* pUsingFilter, + HANDLE hAbortEvent, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *Reconfigure)( + IGraphConfig* This, + IGraphConfigCallback* pCallback, + PVOID pvContext, + DWORD dwFlags, + HANDLE hAbortEvent); + + HRESULT (STDMETHODCALLTYPE *AddFilterToCache)( + IGraphConfig* This, + IBaseFilter* pFilter); + + HRESULT (STDMETHODCALLTYPE *EnumCacheFilter)( + IGraphConfig* This, + IEnumFilters** pEnum); + + HRESULT (STDMETHODCALLTYPE *RemoveFilterFromCache)( + IGraphConfig* This, + IBaseFilter* pFilter); + + HRESULT (STDMETHODCALLTYPE *GetStartTime)( + IGraphConfig* This, + REFERENCE_TIME* prtStart); + + HRESULT (STDMETHODCALLTYPE *PushThroughData)( + IGraphConfig* This, + IPin* pOutputPin, + IPinConnection* pConnection, + HANDLE hEventAbort); + + HRESULT (STDMETHODCALLTYPE *SetFilterFlags)( + IGraphConfig* This, + IBaseFilter* pFilter, + DWORD dwFlags); + + HRESULT (STDMETHODCALLTYPE *GetFilterFlags)( + IGraphConfig* This, + IBaseFilter* pFilter, + DWORD* pdwFlags); + + HRESULT (STDMETHODCALLTYPE *RemoveFilterEx)( + IGraphConfig* This, + IBaseFilter* pFilter, + DWORD Flags); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IGraphConfig_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IGraphConfig_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IGraphConfig_Release(p) (p)->lpVtbl->Release(p) +/*** IGraphConfig methods ***/ +#define IGraphConfig_Reconnect(p,a,b,c,d,e,f) (p)->lpVtbl->Reconnect(p,a,b,c,d,e,f) +#define IGraphConfig_Reconfigure(p,a,b,c,d) (p)->lpVtbl->Reconfigure(p,a,b,c,d) +#define IGraphConfig_AddFilterToCache(p,a) (p)->lpVtbl->AddFilterToCache(p,a) +#define IGraphConfig_EnumCacheFilter(p,a) (p)->lpVtbl->EnumCacheFilter(p,a) +#define IGraphConfig_RemoveFilterFromCache(p,a) (p)->lpVtbl->RemoveFilterFromCache(p,a) +#define IGraphConfig_GetStartTime(p,a) (p)->lpVtbl->GetStartTime(p,a) +#define IGraphConfig_PushThroughData(p,a,b,c) (p)->lpVtbl->PushThroughData(p,a,b,c) +#define IGraphConfig_SetFilterFlags(p,a,b) (p)->lpVtbl->SetFilterFlags(p,a,b) +#define IGraphConfig_GetFilterFlags(p,a,b) (p)->lpVtbl->GetFilterFlags(p,a,b) +#define IGraphConfig_RemoveFilterEx(p,a,b) (p)->lpVtbl->RemoveFilterEx(p,a,b) +#endif + +#endif + +#define IGraphConfig_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IGraphConfig methods ***/ \ + STDMETHOD_(HRESULT,Reconnect)(THIS_ IPin* pOutputPin, IPin* pInputPin, const AM_MEDIA_TYPE* pmtFirstConnection, IBaseFilter* pUsingFilter, HANDLE hAbortEvent, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,Reconfigure)(THIS_ IGraphConfigCallback* pCallback, PVOID pvContext, DWORD dwFlags, HANDLE hAbortEvent) PURE; \ + STDMETHOD_(HRESULT,AddFilterToCache)(THIS_ IBaseFilter* pFilter) PURE; \ + STDMETHOD_(HRESULT,EnumCacheFilter)(THIS_ IEnumFilters** pEnum) PURE; \ + STDMETHOD_(HRESULT,RemoveFilterFromCache)(THIS_ IBaseFilter* pFilter) PURE; \ + STDMETHOD_(HRESULT,GetStartTime)(THIS_ REFERENCE_TIME* prtStart) PURE; \ + STDMETHOD_(HRESULT,PushThroughData)(THIS_ IPin* pOutputPin, IPinConnection* pConnection, HANDLE hEventAbort) PURE; \ + STDMETHOD_(HRESULT,SetFilterFlags)(THIS_ IBaseFilter* pFilter, DWORD dwFlags) PURE; \ + STDMETHOD_(HRESULT,GetFilterFlags)(THIS_ IBaseFilter* pFilter, DWORD* pdwFlags) PURE; \ + STDMETHOD_(HRESULT,RemoveFilterEx)(THIS_ IBaseFilter* pFilter, DWORD Flags) PURE; + +HRESULT CALLBACK IGraphConfig_Reconnect_Proxy( + IGraphConfig* This, + IPin* pOutputPin, + IPin* pInputPin, + const AM_MEDIA_TYPE* pmtFirstConnection, + IBaseFilter* pUsingFilter, + HANDLE hAbortEvent, + DWORD dwFlags); +void __RPC_STUB IGraphConfig_Reconnect_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_Reconfigure_Proxy( + IGraphConfig* This, + IGraphConfigCallback* pCallback, + PVOID pvContext, + DWORD dwFlags, + HANDLE hAbortEvent); +void __RPC_STUB IGraphConfig_Reconfigure_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_AddFilterToCache_Proxy( + IGraphConfig* This, + IBaseFilter* pFilter); +void __RPC_STUB IGraphConfig_AddFilterToCache_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_EnumCacheFilter_Proxy( + IGraphConfig* This, + IEnumFilters** pEnum); +void __RPC_STUB IGraphConfig_EnumCacheFilter_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_RemoveFilterFromCache_Proxy( + IGraphConfig* This, + IBaseFilter* pFilter); +void __RPC_STUB IGraphConfig_RemoveFilterFromCache_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_GetStartTime_Proxy( + IGraphConfig* This, + REFERENCE_TIME* prtStart); +void __RPC_STUB IGraphConfig_GetStartTime_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_PushThroughData_Proxy( + IGraphConfig* This, + IPin* pOutputPin, + IPinConnection* pConnection, + HANDLE hEventAbort); +void __RPC_STUB IGraphConfig_PushThroughData_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_SetFilterFlags_Proxy( + IGraphConfig* This, + IBaseFilter* pFilter, + DWORD dwFlags); +void __RPC_STUB IGraphConfig_SetFilterFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_GetFilterFlags_Proxy( + IGraphConfig* This, + IBaseFilter* pFilter, + DWORD* pdwFlags); +void __RPC_STUB IGraphConfig_GetFilterFlags_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IGraphConfig_RemoveFilterEx_Proxy( + IGraphConfig* This, + IBaseFilter* pFilter, + DWORD Flags); +void __RPC_STUB IGraphConfig_RemoveFilterEx_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IGraphConfig_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IGraphConfigCallback interface + */ +#ifndef __IGraphConfigCallback_INTERFACE_DEFINED__ +#define __IGraphConfigCallback_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IGraphConfigCallback, 0xade0fd60, 0xd19d, 0x11d2, 0xab,0xf6, 0x00,0xa0,0xc9,0x05,0xf3,0x75); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IGraphConfigCallback : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE Reconfigure( + PVOID pvContext, + DWORD dwFlags) = 0; + +}; +#else +typedef struct IGraphConfigCallbackVtbl IGraphConfigCallbackVtbl; +struct IGraphConfigCallback { + const IGraphConfigCallbackVtbl* lpVtbl; +}; +struct IGraphConfigCallbackVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IGraphConfigCallback* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IGraphConfigCallback* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IGraphConfigCallback* This); + + /*** IGraphConfigCallback methods ***/ + HRESULT (STDMETHODCALLTYPE *Reconfigure)( + IGraphConfigCallback* This, + PVOID pvContext, + DWORD dwFlags); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IGraphConfigCallback_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IGraphConfigCallback_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IGraphConfigCallback_Release(p) (p)->lpVtbl->Release(p) +/*** IGraphConfigCallback methods ***/ +#define IGraphConfigCallback_Reconfigure(p,a,b) (p)->lpVtbl->Reconfigure(p,a,b) +#endif + +#endif + +#define IGraphConfigCallback_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IGraphConfigCallback methods ***/ \ + STDMETHOD_(HRESULT,Reconfigure)(THIS_ PVOID pvContext, DWORD dwFlags) PURE; + +HRESULT CALLBACK IGraphConfigCallback_Reconfigure_Proxy( + IGraphConfigCallback* This, + PVOID pvContext, + DWORD dwFlags); +void __RPC_STUB IGraphConfigCallback_Reconfigure_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IGraphConfigCallback_INTERFACE_DEFINED__ */ + +#ifndef __IFilterChain_FWD_DEFINED__ +#define __IFilterChain_FWD_DEFINED__ +typedef struct IFilterChain IFilterChain; +#endif + +/***************************************************************************** + * IFilterChain interface + */ +#ifndef __IFilterChain_INTERFACE_DEFINED__ +#define __IFilterChain_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IFilterChain, 0xdcfbdcf6, 0x0dc2, 0x45f5, 0x9a,0xb2, 0x7c,0x33,0x0e,0xa0,0x9c,0x29); +#if defined(__cplusplus) && !defined(CINTERFACE) +struct IFilterChain : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE StartChain( + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE PauseChain( + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopChain( + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveChain( + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter) = 0; + +}; +#else +typedef struct IFilterChainVtbl IFilterChainVtbl; +struct IFilterChain { + const IFilterChainVtbl* lpVtbl; +}; +struct IFilterChainVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IFilterChain* This, + REFIID riid, + void** ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IFilterChain* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IFilterChain* This); + + /*** IFilterChain methods ***/ + HRESULT (STDMETHODCALLTYPE *StartChain)( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); + + HRESULT (STDMETHODCALLTYPE *PauseChain)( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); + + HRESULT (STDMETHODCALLTYPE *StopChain)( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); + + HRESULT (STDMETHODCALLTYPE *RemoveChain)( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); + + END_INTERFACE +}; + +#ifdef COBJMACROS +/*** IUnknown methods ***/ +#define IFilterChain_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b) +#define IFilterChain_AddRef(p) (p)->lpVtbl->AddRef(p) +#define IFilterChain_Release(p) (p)->lpVtbl->Release(p) +/*** IFilterChain methods ***/ +#define IFilterChain_StartChain(p,a,b) (p)->lpVtbl->StartChain(p,a,b) +#define IFilterChain_PauseChain(p,a,b) (p)->lpVtbl->PauseChain(p,a,b) +#define IFilterChain_StopChain(p,a,b) (p)->lpVtbl->StopChain(p,a,b) +#define IFilterChain_RemoveChain(p,a,b) (p)->lpVtbl->RemoveChain(p,a,b) +#endif + +#endif + +#define IFilterChain_METHODS \ + /*** IUnknown methods ***/ \ + STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \ + STDMETHOD_(ULONG,AddRef)(THIS) PURE; \ + STDMETHOD_(ULONG,Release)(THIS) PURE; \ + /*** IFilterChain methods ***/ \ + STDMETHOD_(HRESULT,StartChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; \ + STDMETHOD_(HRESULT,PauseChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; \ + STDMETHOD_(HRESULT,StopChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; \ + STDMETHOD_(HRESULT,RemoveChain)(THIS_ IBaseFilter* pStartFilter, IBaseFilter* pEndFilter) PURE; + +HRESULT CALLBACK IFilterChain_StartChain_Proxy( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); +void __RPC_STUB IFilterChain_StartChain_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterChain_PauseChain_Proxy( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); +void __RPC_STUB IFilterChain_PauseChain_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterChain_StopChain_Proxy( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); +void __RPC_STUB IFilterChain_StopChain_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT CALLBACK IFilterChain_RemoveChain_Proxy( + IFilterChain* This, + IBaseFilter* pStartFilter, + IBaseFilter* pEndFilter); +void __RPC_STUB IFilterChain_RemoveChain_Stub( + struct IRpcStubBuffer* This, + struct IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IFilterChain_INTERFACE_DEFINED__ */ + +#ifdef __cplusplus +} +#endif +#endif /* __WIDL_STRMIF_H */ diff --git a/reactos/include/uuids.h b/reactos/include/uuids.h new file mode 100644 index 00000000000..bcd2a9658f5 --- /dev/null +++ b/reactos/include/uuids.h @@ -0,0 +1,275 @@ +/* + * Copyright (C) 2002 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef OUR_GUID_ENTRY +#define OUR_GUID_ENTRY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ + DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8); +#endif + +#define MEDIATYPE_NULL GUID_NULL +#define MEDIASUBTYPE_NULL GUID_NULL + +OUR_GUID_ENTRY(MEDIASUBTYPE_None, 0xe436eb8e, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIATYPE_Video, 0x73646976, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_Audio, 0x73647561, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_Text, 0x73747874, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_Midi, 0x7364696d, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_Stream, 0xe436eb83, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIATYPE_Interleaved, 0x73766169, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_File, 0x656c6966, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_ScriptCommand, 0x73636d64, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_AUXLine21Data, 0x670aea80, 0x3a82, 0x11d0, 0xb7, 0x9b, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7) +OUR_GUID_ENTRY(MEDIATYPE_Timecode, 0x0482dee3, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIATYPE_LMRT, 0x74726c6d, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_URL_STREAM, 0x736c7275, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_YVU9, 0x39555659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_Y411, 0x31313459, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_Y41P, 0x50313459, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_YUY2, 0x32595559, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_YVYU, 0x55595659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_UYVY, 0x59565955, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_Y211, 0x31313259, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_YV12, 0x32315659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_CLJR, 0x524a4c43, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_IF09, 0x39304649, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_CPLA, 0x414c5043, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_MJPG, 0x47504a4d, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_TVMJ, 0x4a4d5654, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_WAKE, 0x454b4157, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_CFCC, 0x43434643, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_IJPG, 0x47504a49, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_Plum, 0x6d756c50, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_DVCS, 0x53435644, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_DVSD, 0x44535644, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_MDVF, 0x4656444d, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB1, 0xe436eb78, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB4, 0xe436eb79, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB8, 0xe436eb7a, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB565, 0xe436eb7b, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB555, 0xe436eb7c, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB24, 0xe436eb7d, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_RGB32, 0xe436eb7e, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_Overlay, 0xe436eb7f, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1Packet, 0xe436eb80, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1Payload, 0xe436eb81, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1AudioPayload, 0x00000050, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIATYPE_MPEG1SystemStream, 0xe436eb82, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1System, 0xe436eb84, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1VideoCD, 0xe436eb85, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1Video, 0xe436eb86, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_MPEG1Audio, 0xe436eb87, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_Avi, 0xe436eb88, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_Asf, 0x3db80f90, 0x9412, 0x11d1, 0xad, 0xed, 0x00, 0x00, 0xf8, 0x75, 0x4b, 0x99) +OUR_GUID_ENTRY(MEDIASUBTYPE_QTMovie, 0xe436eb89, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_QTRpza, 0x617a7072, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_QTSmc, 0x20636d73, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_QTRle, 0x20656c72, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_QTJpeg, 0x6765706a, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_PCMAudio_Obsolete, 0xe436eb8a, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_WAVE, 0xe436eb8b, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_AU, 0xe436eb8c, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_AIFF, 0xe436eb8d, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(MEDIASUBTYPE_dvsd, 0x64737664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_dvhd, 0x64687664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_dvsl, 0x6c737664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71) +OUR_GUID_ENTRY(MEDIASUBTYPE_Line21_BytePair, 0x6e8d4a22, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7) +OUR_GUID_ENTRY(MEDIASUBTYPE_Line21_GOPPacket, 0x6e8d4a23, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7) +OUR_GUID_ENTRY(MEDIASUBTYPE_Line21_VBIRawData, 0x6e8d4a24, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7) +OUR_GUID_ENTRY(MEDIASUBTYPE_DssVideo, 0xa0af4f81, 0xe163, 0x11d0, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(MEDIASUBTYPE_DssAudio, 0xa0af4f82, 0xe163, 0x11d0, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(MEDIASUBTYPE_VPVideo, 0x5a9b6a40, 0x1a22, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(MEDIASUBTYPE_VPVBI, 0x5a9b6a41, 0x1a22, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(IID_IAMCutListElement, 0xcde29520, 0x3418, 0x11cf, 0xa5, 0xb0, 0x00, 0x20, 0xaf, 0x05, 0x3d, 0x8f) +OUR_GUID_ENTRY(IID_IAMFileCutListElement, 0xf0947070, 0x276c, 0x11d0, 0x83, 0x16, 0x00, 0x20, 0xaf, 0x11, 0xc0, 0x10) +OUR_GUID_ENTRY(IID_IAMVideoCutListElement, 0xcde29522, 0x3418, 0x11cf, 0xa5, 0xb0, 0x00, 0x20, 0xaf, 0x05, 0x3d, 0x8f) +OUR_GUID_ENTRY(IID_IAMAudioCutListElement, 0xcde29524, 0x3418, 0x11cf, 0xa5, 0xb0, 0x00, 0x20, 0xaf, 0x05, 0x3d, 0x8f) +OUR_GUID_ENTRY(CLSID_CutListSource, 0xa5ea8d20, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(IID_IStandardCutList, 0xa5ea8d29, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(IID_IFileClip, 0xa5ea8d2a, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(IID_ICutListGraphBuilder, 0xa5ea8d2c, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_CutListGraphBuilder, 0xa5ea8d2f, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_SimpleCutList, 0xa5ea8d30, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_VideoFileClip, 0xa5ea8d31, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_AudioFileClip, 0xa5ea8d32, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_CutListCacheMemory, 0xa5ea8d33, 0x253d, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_CaptureGraphBuilder, 0xbf87b6e0, 0x8c27, 0x11d0, 0xb3, 0xf0, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_CaptureGraphBuilder2, 0xbf87b6e1, 0x8c27, 0x11d0, 0xb3, 0xf0, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_ProtoFilterGraph, 0xe436ebb0, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_SystemClock, 0xe436ebb1, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_FilterMapper, 0xe436ebb2, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_FilterGraph, 0xe436ebb3, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_FilterGraphNoThread, 0xe436ebb8, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_MPEG1Doc, 0xe4bbd160, 0x4269, 0x11ce, 0x83, 0x8d, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_FileSource, 0x701722e0, 0x8ae3, 0x11ce, 0xa8, 0x5c, 0x00, 0xaa, 0x00, 0x2f, 0xea, 0xb5) +OUR_GUID_ENTRY(CLSID_MPEG1PacketPlayer, 0x26c25940, 0x4ca9, 0x11ce, 0xa8, 0x28, 0x00, 0xaa, 0x00, 0x2f, 0xea, 0xb5) +OUR_GUID_ENTRY(CLSID_MPEG1Splitter, 0x336475d0, 0x942a, 0x11ce, 0xa8, 0x70, 0x00, 0xaa, 0x00, 0x2f, 0xea, 0xb5) +OUR_GUID_ENTRY(CLSID_CMpegVideoCodec, 0xfeb50740, 0x7bef, 0x11ce, 0x9b, 0xd9, 0x00, 0x00, 0xe2, 0x02, 0x59, 0x9c) +OUR_GUID_ENTRY(CLSID_CMpegAudioCodec, 0x4a2286e0, 0x7bef, 0x11ce, 0x9b, 0xd9, 0x00, 0x00, 0xe2, 0x02, 0x59, 0x9c) +OUR_GUID_ENTRY(CLSID_TextRender, 0xe30629d3, 0x27e5, 0x11ce, 0x87, 0x5d, 0x00, 0x60, 0x8c, 0xb7, 0x80, 0x66) +OUR_GUID_ENTRY(CLSID_InfTee, 0xf8388a40, 0xd5bb, 0x11d0, 0xbe, 0x5a, 0x00, 0x80, 0xc7, 0x06, 0x56, 0x8e) +OUR_GUID_ENTRY(CLSID_AviSplitter, 0x1b544c20, 0xfd0b, 0x11ce, 0x8c, 0x63, 0x00, 0xaa, 0x00, 0x44, 0xb5, 0x1e) +OUR_GUID_ENTRY(CLSID_AviReader, 0x1b544c21, 0xfd0b, 0x11ce, 0x8c, 0x63, 0x00, 0xaa, 0x00, 0x44, 0xb5, 0x1e) +OUR_GUID_ENTRY(CLSID_VfwCapture, 0x1b544c22, 0xfd0b, 0x11ce, 0x8c, 0x63, 0x00, 0xaa, 0x00, 0x44, 0xb5, 0x1e) +OUR_GUID_ENTRY(CLSID_CaptureProperties, 0x1b544c22, 0xfd0b, 0x11ce, 0x8c, 0x63, 0x00, 0xaa, 0x00, 0x44, 0xb5, 0x1f) +OUR_GUID_ENTRY(CLSID_FGControl, 0xe436ebb4, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_MOVReader, 0x44584800, 0xf8ee, 0x11ce, 0xb2, 0xd4, 0x00, 0xdd, 0x01, 0x10, 0x1b, 0x85) +OUR_GUID_ENTRY(CLSID_QuickTimeParser, 0xd51bd5a0, 0x7548, 0x11cf, 0xa5, 0x20, 0x00, 0x80, 0xc7, 0x7e, 0xf5, 0x8a) +OUR_GUID_ENTRY(CLSID_QTDec, 0xfdfe9681, 0x74a3, 0x11d0, 0xaf, 0xa7, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_AVIDoc, 0xd3588ab0, 0x0781, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_AVIDocWriter, 0xd3588ab1, 0x0781, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_VideoRenderer, 0x70e102b0, 0x5556, 0x11ce, 0x97, 0xc0, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_Colour, 0x1643e180, 0x90f5, 0x11ce, 0x97, 0xd5, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_Dither, 0x1da08500, 0x9edc, 0x11cf, 0xbc, 0x10, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(CLSID_ModexRenderer, 0x07167665, 0x5011, 0x11cf, 0xbf, 0x33, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_AudioRender, 0xe30629d1, 0x27e5, 0x11ce, 0x87, 0x5d, 0x00, 0x60, 0x8c, 0xb7, 0x80, 0x66) +OUR_GUID_ENTRY(CLSID_AudioProperties, 0x05589faf, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_DSoundRender, 0x79376820, 0x07d0, 0x11cf, 0xa2, 0x4d, 0x00, 0x20, 0xaf, 0xd7, 0x97, 0x67) +OUR_GUID_ENTRY(CLSID_AudioRecord, 0xe30629d2, 0x27e5, 0x11ce, 0x87, 0x5d, 0x00, 0x60, 0x8c, 0xb7, 0x80, 0x66) +OUR_GUID_ENTRY(CLSID_AudioInputMixerProperties, 0x2ca8ca52, 0x3c3f, 0x11d2, 0xb7, 0x3d, 0x00, 0xc0, 0x4f, 0xb6, 0xbd, 0x3d) +OUR_GUID_ENTRY(CLSID_AVIDec, 0xcf49d4e0, 0x1115, 0x11ce, 0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_AVIDraw, 0xa888df60, 0x1e90, 0x11cf, 0xac, 0x98, 0x00, 0xaa, 0x00, 0x4c, 0x0f, 0xa9) +OUR_GUID_ENTRY(CLSID_ACMWrapper, 0x6a08cf80, 0x0e18, 0x11cf, 0xa2, 0x4d, 0x00, 0x20, 0xaf, 0xd7, 0x97, 0x67) +OUR_GUID_ENTRY(CLSID_AsyncReader, 0xe436ebb5, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_URLReader, 0xe436ebb6, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_PersistMonikerPID, 0xe436ebb7, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70) +OUR_GUID_ENTRY(CLSID_AMovie, 0x5f2759c0, 0x7685, 0x11cf, 0x8b, 0x23, 0x00, 0x80, 0x5f, 0x6c, 0xef, 0x60) +OUR_GUID_ENTRY(CLSID_AVICo, 0xd76e2820, 0x1563, 0x11cf, 0xac, 0x98, 0x00, 0xaa, 0x00, 0x4c, 0x0f, 0xa9) +OUR_GUID_ENTRY(CLSID_FileWriter, 0x8596e5f0, 0x0da5, 0x11d0, 0xbd, 0x21, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_AviDest, 0xe2510970, 0xf137, 0x11ce, 0x8b, 0x67, 0x00, 0xaa, 0x00, 0xa3, 0xf1, 0xa6) +OUR_GUID_ENTRY(CLSID_AsfMux, 0xf560ae42, 0x6cdd, 0x11d1, 0xad, 0xe2, 0x00, 0x00, 0xf8, 0x75, 0x4b, 0x99) +OUR_GUID_ENTRY(CLSID_AviMuxProptyPage, 0xc647b5c0, 0x157c, 0x11d0, 0xbd, 0x23, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_AviMuxProptyPage1, 0x0a9ae910, 0x85c0, 0x11d0, 0xbd, 0x42, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_AVIMIDIRender, 0x07b65360, 0xc445, 0x11ce, 0xaf, 0xde, 0x00, 0xaa, 0x00, 0x6c, 0x14, 0xf4) +OUR_GUID_ENTRY(CLSID_DVVideoCodec, 0xb1b77c00, 0xc3e4, 0x11cf, 0xaf, 0x79, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_DVVideoEnc, 0x13aa3650, 0xbb6f, 0x11d0, 0xaf, 0xb9, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_DVSplitter, 0x4eb31670, 0x9fc6, 0x11cf, 0xaf, 0x6e, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_DVMux, 0x129d7e40, 0xc10d, 0x11d0, 0xaf, 0xb9, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_SeekingPassThru, 0x060af76c, 0x68dd, 0x11d0, 0x8f, 0xc1, 0x00, 0xc0, 0x4f, 0xd9, 0x18, 0x9d) +OUR_GUID_ENTRY(CLSID_Line21Decoder, 0x6e8d4a20, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7) +OUR_GUID_ENTRY(CLSID_OverlayMixer, 0xcd8743a1, 0x3736, 0x11d0, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(CLSID_VBISurfaces, 0x814b9800, 0x1c88, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(CLSID_SystemDeviceEnum, 0x62be5d10, 0x60eb, 0x11d0, 0xbd, 0x3b, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CDeviceMoniker, 0x4315d437, 0x5b8c, 0x11d0, 0xbd, 0x3b, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_VideoInputDeviceCategory, 0x860bb310, 0x5d01, 0x11d0, 0xbd, 0x3b, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CVidCapClassManager, 0x860bb310, 0x5d01, 0x11d0, 0xbd, 0x3b, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_LegacyAmFilterCategory, 0x083863f1, 0x70de, 0x11d0, 0xbd, 0x40, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CQzFilterClassManager, 0x083863f1, 0x70de, 0x11d0, 0xbd, 0x40, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_VideoCompressorCategory, 0x33d9a760, 0x90c8, 0x11d0, 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CIcmCoClassManager, 0x33d9a760, 0x90c8, 0x11d0, 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_AudioCompressorCategory, 0x33d9a761, 0x90c8, 0x11d0, 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CAcmCoClassManager, 0x33d9a761, 0x90c8, 0x11d0, 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_AudioInputDeviceCategory, 0x33d9a762, 0x90c8, 0x11d0, 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CWaveinClassManager, 0x33d9a762, 0x90c8, 0x11d0, 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_AudioRendererCategory, 0xe0f158e1, 0xcb04, 0x11d0, 0xbd, 0x4e, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_CWaveOutClassManager, 0xe0f158e1, 0xcb04, 0x11d0, 0xbd, 0x4e, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_MidiRendererCategory, 0x4efe2452, 0x168a, 0x11d1, 0xbc, 0x76, 0x00, 0xc0, 0x4f, 0xb9, 0x45, 0x3b) +OUR_GUID_ENTRY(CLSID_CMidiOutClassManager, 0x4efe2452, 0x168a, 0x11d1, 0xbc, 0x76, 0x00, 0xc0, 0x4f, 0xb9, 0x45, 0x3b) +OUR_GUID_ENTRY(CLSID_TransmitCategory, 0xcc7bfb41, 0xf175, 0x11d1, 0xa3, 0x92, 0x00, 0xe0, 0x29, 0x1f, 0x39, 0x59) +OUR_GUID_ENTRY(CLSID_DeviceControlCategory, 0xcc7bfb46, 0xf175, 0x11d1, 0xa3, 0x92, 0x00, 0xe0, 0x29, 0x1f, 0x39, 0x59) +OUR_GUID_ENTRY(CLSID_ActiveMovieCategories, 0xda4e3da0, 0xd07d, 0x11d0, 0xbd, 0x50, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_DVDHWDecodersCategory, 0x2721ae20, 0x7e70, 0x11d0, 0xa5, 0xd6, 0x28, 0xdb, 0x04, 0xc1, 0x00, 0x00) +OUR_GUID_ENTRY(CLSID_FilterMapper2, 0xcda42200, 0xbd88, 0x11d0, 0xbd, 0x4e, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_MemoryAllocator, 0x1e651cc0, 0xb199, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45) +OUR_GUID_ENTRY(CLSID_MediaPropertyBag, 0xcdbd8d00, 0xc193, 0x11d0, 0xbd, 0x4e, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86) +OUR_GUID_ENTRY(CLSID_DvdGraphBuilder, 0xfcc152b7, 0xf372, 0x11d0, 0x8e, 0x00, 0x00, 0xc0, 0x4f, 0xd7, 0xc0, 0x8b) +OUR_GUID_ENTRY(CLSID_DVDNavigator, 0x9b8c4620, 0x2c1a, 0x11d0, 0x84, 0x93, 0x00, 0xa0, 0x24, 0x38, 0xad, 0x48) +OUR_GUID_ENTRY(CLSID_SmartTee, 0xcc58e280, 0x8aa1, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(FORMAT_None, 0x0f6417d6, 0xc318, 0x11d0, 0xa4, 0x3f, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96) +OUR_GUID_ENTRY(FORMAT_VideoInfo, 0x05589f80, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(FORMAT_VideoInfo2, 0xf72a76a0, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(FORMAT_WaveFormatEx, 0x05589f81, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(FORMAT_MPEGVideo, 0x05589f82, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(FORMAT_MPEGStreams, 0x05589f83, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(FORMAT_DvInfo, 0x05589f84, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_DirectDrawProperties, 0x944d4c00, 0xdd52, 0x11ce, 0xbf, 0x0e, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(CLSID_PerformanceProperties, 0x59ce6880, 0xacf8, 0x11cf, 0xb5, 0x6e, 0x00, 0x80, 0xc7, 0xc4, 0xb6, 0x8a) +OUR_GUID_ENTRY(CLSID_QualityProperties, 0x418afb70, 0xf8b8, 0x11ce, 0xaa, 0xc6, 0x00, 0x20, 0xaf, 0x0b, 0x99, 0xa3) +OUR_GUID_ENTRY(IID_IBaseVideoMixer, 0x61ded640, 0xe912, 0x11ce, 0xa0, 0x99, 0x00, 0xaa, 0x00, 0x47, 0x9a, 0x58) +OUR_GUID_ENTRY(IID_IDirectDrawVideo, 0x36d39eb0, 0xdd75, 0x11ce, 0xbf, 0x0e, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(IID_IQualProp, 0x1bd0ecb0, 0xf8e2, 0x11ce, 0xaa, 0xc6, 0x00, 0x20, 0xaf, 0x0b, 0x99, 0xa3) +OUR_GUID_ENTRY(CLSID_VPObject, 0xce292861, 0xfc88, 0x11d0, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(IID_IVPObject, 0xce292862, 0xfc88, 0x11d0, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(IID_IVPControl, 0x25df12c1, 0x3de0, 0x11d1, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(CLSID_VPVBIObject, 0x814b9801, 0x1c88, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(IID_IVPVBIObject, 0x814b9802, 0x1c88, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(IID_IVPConfig, 0xbc29a660, 0x30e3, 0x11d0, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(IID_IVPNotify, 0xc76794a1, 0xd6c5, 0x11d0, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(IID_IVPNotify2, 0xebf47183, 0x8764, 0x11d1, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(IID_IVPVBIConfig, 0xec529b00, 0x1a1f, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(IID_IVPVBINotify, 0xec529b01, 0x1a1f, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a) +OUR_GUID_ENTRY(IID_IMixerPinConfig, 0x593cdde1, 0x0759, 0x11d1, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(IID_IMixerPinConfig2, 0xebf47182, 0x8764, 0x11d1, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b) +OUR_GUID_ENTRY(CLSID_ModexProperties, 0x0618aa30, 0x6bc4, 0x11cf, 0xbf, 0x36, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(IID_IFullScreenVideo, 0xdd1d7110, 0x7836, 0x11cf, 0xbf, 0x47, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a) +OUR_GUID_ENTRY(IID_IFullScreenVideoEx, 0x53479470, 0xf1dd, 0x11cf, 0xbc, 0x42, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(CLSID_DVDecPropertiesPage, 0x101193c0, 0x0bfe, 0x11d0, 0xaf, 0x91, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_DVEncPropertiesPage, 0x4150f050, 0xbb6f, 0x11d0, 0xaf, 0xb9, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(CLSID_DVMuxPropertyPage, 0x4db880e0, 0xc10d, 0x11d0, 0xaf, 0xb9, 0x00, 0xaa, 0x00, 0xb6, 0x7a, 0x42) +OUR_GUID_ENTRY(IID_IAMDirectSound, 0x546f4260, 0xd53e, 0x11cf, 0xb3, 0xf0, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(IID_IMpegAudioDecoder, 0xb45dd570, 0x3c77, 0x11d1, 0xab, 0xe1, 0x00, 0xa0, 0xc9, 0x05, 0xf3, 0x75) +OUR_GUID_ENTRY(IID_IAMLine21Decoder, 0x6e8d4a21, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7) +OUR_GUID_ENTRY(FORMAT_AnalogVideo, 0x0482dde0, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIATYPE_AnalogVideo, 0x0482dde1, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_NTSC_M, 0x0482dde2, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_B, 0x0482dde5, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_D, 0x0482dde6, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_G, 0x0482dde7, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_H, 0x0482dde8, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_I, 0x0482dde9, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_M, 0x0482ddea, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_PAL_N, 0x0482ddeb, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_B, 0x0482ddf0, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_D, 0x0482ddf1, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_G, 0x0482ddf2, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_H, 0x0482ddf3, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_K, 0x0482ddf4, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_K1, 0x0482ddf5, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIASUBTYPE_AnalogVideo_SECAM_L, 0x0482ddf6, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(MEDIATYPE_AnalogAudio, 0x0482dee1, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(TIME_FORMAT_NONE, 0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00) +OUR_GUID_ENTRY(TIME_FORMAT_FRAME, 0x7b785570, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(TIME_FORMAT_BYTE, 0x7b785571, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(TIME_FORMAT_SAMPLE, 0x7b785572, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(TIME_FORMAT_FIELD, 0x7b785573, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(TIME_FORMAT_MEDIA_TIME, 0x7b785574, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6) +OUR_GUID_ENTRY(AMPROPSETID_Pin, 0x9b00f101, 0x1567, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(PIN_CATEGORY_CAPTURE, 0xfb6c4281, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_PREVIEW, 0xfb6c4282, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_ANALOGVIDEOIN, 0xfb6c4283, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_VBI, 0xfb6c4284, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_VIDEOPORT, 0xfb6c4285, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_NABTS, 0xfb6c4286, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_EDS, 0xfb6c4287, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_TELETEXT, 0xfb6c4288, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_CC, 0xfb6c4289, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_STILL, 0xfb6c428a, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_TIMECODE, 0xfb6c428b, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(PIN_CATEGORY_VIDEOPORT_VBI, 0xfb6c428c, 0x0353, 0x11d1, 0x90, 0x5f, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba) +OUR_GUID_ENTRY(LOOK_UPSTREAM_ONLY, 0xac798be0, 0x98e3, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(LOOK_DOWNSTREAM_ONLY, 0xac798be1, 0x98e3, 0x11d1, 0xb3, 0xf1, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5) +OUR_GUID_ENTRY(CLSID_TVTunerFilterPropertyPage, 0x266eee41, 0x6c63, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65) +OUR_GUID_ENTRY(CLSID_CrossbarFilterPropertyPage, 0x71f96461, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(CLSID_TVAudioFilterPropertyPage, 0x71f96463, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(CLSID_VideoProcAmpPropertyPage, 0x71f96464, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(CLSID_CameraControlPropertyPage, 0x71f96465, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(CLSID_AnalogVideoDecoderPropertyPage, 0x71f96466, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(CLSID_VideoStreamConfigPropertyPage, 0x71f96467, 0x78f3, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56) +OUR_GUID_ENTRY(CLSID_HTMLDocument, 0x25336920, 0x03f9, 0x11cf, 0x8f, 0xd0, 0x00, 0xaa, 0x00, 0x68, 0x6f, 0x13) + +#undef OUR_GUID_ENTRY diff --git a/reactos/include/vfwmsgs.h b/reactos/include/vfwmsgs.h new file mode 100644 index 00000000000..5a3ab814378 --- /dev/null +++ b/reactos/include/vfwmsgs.h @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2002 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define VFW_S_NO_MORE_ITEMS ((HRESULT)0x00040103) +#define VFW_S_DUPLICATE_NAME ((HRESULT)0x0004022D) +#define VFW_S_STATE_INTERMEDIATE ((HRESULT)0x00040237) +#define VFW_S_PARTIAL_RENDER ((HRESULT)0x00040242) +#define VFW_S_SOME_DATA_IGNORED ((HRESULT)0x00040245) +#define VFW_S_CONNECTIONS_DEFERRED ((HRESULT)0x00040246) +#define VFW_S_RESOURCE_NOT_NEEDED ((HRESULT)0x00040250) +#define VFW_S_MEDIA_TYPE_IGNORED ((HRESULT)0x00040254) +#define VFW_S_VIDEO_NOT_RENDERED ((HRESULT)0x00040257) +#define VFW_S_AUDIO_NOT_RENDERED ((HRESULT)0x00040258) +#define VFW_S_RPZA ((HRESULT)0x0004025A) +#define VFW_S_ESTIMATED ((HRESULT)0x00040260) +#define VFW_S_RESERVED ((HRESULT)0x00040263) +#define VFW_S_STREAM_OFF ((HRESULT)0x00040267) +#define VFW_S_CANT_CUE ((HRESULT)0x00040268) +#define VFW_S_NO_STOP_TIME ((HRESULT)0x00040270) +#define VFW_S_NOPREVIEWPIN ((HRESULT)0x0004027E) +#define VFW_E_INVALIDMEDIATYPE ((HRESULT)0x80040200) +#define VFW_E_INVALIDSUBTYPE ((HRESULT)0x80040201) +#define VFW_E_NEED_OWNER ((HRESULT)0x80040202) +#define VFW_E_ENUM_OUT_OF_SYNC ((HRESULT)0x80040203) +#define VFW_E_ALREADY_CONNECTED ((HRESULT)0x80040204) +#define VFW_E_FILTER_ACTIVE ((HRESULT)0x80040205) +#define VFW_E_NO_TYPES ((HRESULT)0x80040206) +#define VFW_E_NO_ACCEPTABLE_TYPES ((HRESULT)0x80040207) +#define VFW_E_INVALID_DIRECTION ((HRESULT)0x80040208) +#define VFW_E_NOT_CONNECTED ((HRESULT)0x80040209) +#define VFW_E_NO_ALLOCATOR ((HRESULT)0x8004020A) +#define VFW_E_RUNTIME_ERROR ((HRESULT)0x8004020B) +#define VFW_E_BUFFER_NOTSET ((HRESULT)0x8004020C) +#define VFW_E_BUFFER_OVERFLOW ((HRESULT)0x8004020D) +#define VFW_E_BADALIGN ((HRESULT)0x8004020E) +#define VFW_E_ALREADY_COMMITTED ((HRESULT)0x8004020F) +#define VFW_E_BUFFERS_OUTSTANDING ((HRESULT)0x80040210) +#define VFW_E_NOT_COMMITTED ((HRESULT)0x80040211) +#define VFW_E_SIZENOTSET ((HRESULT)0x80040212) +#define VFW_E_NO_CLOCK ((HRESULT)0x80040213) +#define VFW_E_NO_SINK ((HRESULT)0x80040214) +#define VFW_E_NO_INTERFACE ((HRESULT)0x80040215) +#define VFW_E_NOT_FOUND ((HRESULT)0x80040216) +#define VFW_E_CANNOT_CONNECT ((HRESULT)0x80040217) +#define VFW_E_CANNOT_RENDER ((HRESULT)0x80040218) +#define VFW_E_CHANGING_FORMAT ((HRESULT)0x80040219) +#define VFW_E_NO_COLOR_KEY_SET ((HRESULT)0x8004021A) +#define VFW_E_NOT_OVERLAY_CONNECTION ((HRESULT)0x8004021B) +#define VFW_E_NOT_SAMPLE_CONNECTION ((HRESULT)0x8004021C) +#define VFW_E_PALETTE_SET ((HRESULT)0x8004021D) +#define VFW_E_COLOR_KEY_SET ((HRESULT)0x8004021E) +#define VFW_E_NO_COLOR_KEY_FOUND ((HRESULT)0x8004021F) +#define VFW_E_NO_PALETTE_AVAILABLE ((HRESULT)0x80040220) +#define VFW_E_NO_DISPLAY_PALETTE ((HRESULT)0x80040221) +#define VFW_E_TOO_MANY_COLORS ((HRESULT)0x80040222) +#define VFW_E_STATE_CHANGED ((HRESULT)0x80040223) +#define VFW_E_NOT_STOPPED ((HRESULT)0x80040224) +#define VFW_E_NOT_PAUSED ((HRESULT)0x80040225) +#define VFW_E_NOT_RUNNING ((HRESULT)0x80040226) +#define VFW_E_WRONG_STATE ((HRESULT)0x80040227) +#define VFW_E_START_TIME_AFTER_END ((HRESULT)0x80040228) +#define VFW_E_INVALID_RECT ((HRESULT)0x80040229) +#define VFW_E_TYPE_NOT_ACCEPTED ((HRESULT)0x8004022A) +#define VFW_E_SAMPLE_REJECTED ((HRESULT)0x8004022B) +#define VFW_E_SAMPLE_REJECTED_EOS ((HRESULT)0x8004022C) +#define VFW_E_DUPLICATE_NAME ((HRESULT)0x8004022D) +#define VFW_E_TIMEOUT ((HRESULT)0x8004022E) +#define VFW_E_INVALID_FILE_FORMAT ((HRESULT)0x8004022F) +#define VFW_E_ENUM_OUT_OF_RANGE ((HRESULT)0x80040230) +#define VFW_E_CIRCULAR_GRAPH ((HRESULT)0x80040231) +#define VFW_E_NOT_ALLOWED_TO_SAVE ((HRESULT)0x80040232) +#define VFW_E_TIME_ALREADY_PASSED ((HRESULT)0x80040233) +#define VFW_E_ALREADY_CANCELLED ((HRESULT)0x80040234) +#define VFW_E_CORRUPT_GRAPH_FILE ((HRESULT)0x80040235) +#define VFW_E_ADVISE_ALREADY_SET ((HRESULT)0x80040236) +#define VFW_E_NO_MODEX_AVAILABLE ((HRESULT)0x80040238) +#define VFW_E_NO_ADVISE_SET ((HRESULT)0x80040239) +#define VFW_E_NO_FULLSCREEN ((HRESULT)0x8004023A) +#define VFW_E_IN_FULLSCREEN_MODE ((HRESULT)0x8004023B) +#define VFW_E_UNKNOWN_FILE_TYPE ((HRESULT)0x80040240) +#define VFW_E_CANNOT_LOAD_SOURCE_FILTER ((HRESULT)0x80040241) +#define VFW_E_FILE_TOO_SHORT ((HRESULT)0x80040243) +#define VFW_E_INVALID_FILE_VERSION ((HRESULT)0x80040244) +#define VFW_E_INVALID_CLSID ((HRESULT)0x80040247) +#define VFW_E_INVALID_MEDIA_TYPE ((HRESULT)0x80040248) +#define VFW_E_SAMPLE_TIME_NOT_SET ((HRESULT)0x80040249) +#define VFW_E_MEDIA_TIME_NOT_SET ((HRESULT)0x80040251) +#define VFW_E_NO_TIME_FORMAT_SET ((HRESULT)0x80040252) +#define VFW_E_MONO_AUDIO_HW ((HRESULT)0x80040253) +#define VFW_E_NO_DECOMPRESSOR ((HRESULT)0x80040255) +#define VFW_E_NO_AUDIO_HARDWARE ((HRESULT)0x80040256) +#define VFW_E_RPZA ((HRESULT)0x80040259) +#define VFW_E_PROCESSOR_NOT_SUITABLE ((HRESULT)0x8004025B) +#define VFW_E_UNSUPPORTED_AUDIO ((HRESULT)0x8004025C) +#define VFW_E_UNSUPPORTED_VIDEO ((HRESULT)0x8004025D) +#define VFW_E_MPEG_NOT_CONSTRAINED ((HRESULT)0x8004025E) +#define VFW_E_NOT_IN_GRAPH ((HRESULT)0x8004025F) +#define VFW_E_NO_TIME_FORMAT ((HRESULT)0x80040261) +#define VFW_E_READ_ONLY ((HRESULT)0x80040262) +#define VFW_E_BUFFER_UNDERFLOW ((HRESULT)0x80040264) +#define VFW_E_UNSUPPORTED_STREAM ((HRESULT)0x80040265) +#define VFW_E_NO_TRANSPORT ((HRESULT)0x80040266) +#define VFW_E_BAD_VIDEOCD ((HRESULT)0x80040269) +#define VFW_E_OUT_OF_VIDEO_MEMORY ((HRESULT)0x80040271) +#define VFW_E_VP_NEGOTIATION_FAILED ((HRESULT)0x80040272) +#define VFW_E_DDRAW_CAPS_NOT_SUITABLE ((HRESULT)0x80040273) +#define VFW_E_NO_VP_HARDWARE ((HRESULT)0x80040274) +#define VFW_E_NO_CAPTURE_HARDWARE ((HRESULT)0x80040275) +#define VFW_E_DVD_OPERATION_INHIBITED ((HRESULT)0x80040276) +#define VFW_E_DVD_INVALIDDOMAIN ((HRESULT)0x80040277) +#define VFW_E_DVD_NO_BUTTON ((HRESULT)0x80040278) +#define VFW_E_DVD_GRAPHNOTREADY ((HRESULT)0x80040279) +#define VFW_E_DVD_RENDERFAIL ((HRESULT)0x8004027A) +#define VFW_E_DVD_DECNOTENOUGH ((HRESULT)0x8004027B) +#define VFW_E_DDRAW_VERSION_NOT_SUITABLE ((HRESULT)0x8004027C) +#define VFW_E_COPYPROT_FAILED ((HRESULT)0x8004027D) +#define VFW_E_TIME_EXPIRED ((HRESULT)0x8004027F) +#define VFW_E_BAD_KEY ((HRESULT)0x800403F2) + +#ifndef E_PROP_ID_UNSUPPORTED +#define E_PROP_ID_UNSUPPORTED ((HRESULT)0x80070490) +#endif +#ifndef E_PROP_SET_UNSUPPORTED +#define E_PROP_SET_UNSUPPORTED ((HRESULT)0x80070492) +#endif