/*** Autogenerated by WIDL 0.1 from strmif.idl - Do not edit ***/
#include <rpc.h>
#include <rpcndr.h>

#ifndef __WIDL_STRMIF_H
#define __WIDL_STRMIF_H
#ifdef __cplusplus
extern "C" {
#endif
#include <objidl.h>
#include <oaidl.h>
#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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 _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_ */
/*****************************************************************************
 * 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 */
