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

#ifndef __WIDL_AMVIDEO_H
#define __WIDL_AMVIDEO_H
#ifdef __cplusplus
extern "C" {
#endif
#include <objidl.h>
#if 0
typedef void *LPDIRECTDRAW;

typedef void DDSURFACEDESC, DDCAPS;

typedef DWORD RGBQUAD;

typedef LONGLONG REFERENCE_TIME;

typedef struct {
    DWORD biSize;
    LONG biWidth;
    LONG biHeight;
    WORD biPlanes;
    WORD biBitCount;
    DWORD biCompression;
    DWORD biSizeImage;
    LONG biXPelsPerMeter;
    LONG biYPelsPerMeter;
    DWORD biClrUsed;
    DWORD biClrImportant;
} BITMAPINFOHEADER, *PBITMAPINFOHEADER, *LPBITMAPINFOHEADER;

#endif
#include <ddraw.h>
#define AMDDS_NONE 0x00
#define AMDDS_DCIPS 0x01
#define AMDDS_PS 0x02
#define AMDDS_RGBOVR 0x04
#define AMDDS_YUVOVR 0x08
#define AMDDS_RGBOFF 0x10
#define AMDDS_YUVOFF 0x20
#define AMDDS_RGBFLP 0x40
#define AMDDS_YUVFLP 0x80
#define AMDDS_ALL 0xFF
#define AMDDS_DEFAULT AMDDS_ALL
#define AMDDS_YUV (AMDDS_YUVOFF | AMDDS_YUVOVR | AMDDS_YUVFLP)
#define AMDDS_RGB (AMDDS_RGBOFF | AMDDS_RGBOVR | AMDDS_RGBFLP)
#define AMDSS_PRIMARY (AMDDS_DCIPS | AMDDS_PS)
#ifndef __IDirectDrawVideo_FWD_DEFINED__
#define __IDirectDrawVideo_FWD_DEFINED__
typedef struct IDirectDrawVideo IDirectDrawVideo;
#endif

/*****************************************************************************
 * IDirectDrawVideo interface
 */
#ifndef __IDirectDrawVideo_INTERFACE_DEFINED__
#define __IDirectDrawVideo_INTERFACE_DEFINED__

#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDirectDrawVideo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetSwitches(
        DWORD* pSwitches) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSwitches(
        DWORD Switches) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCaps(
        DDCAPS* pCaps) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetEmulatedCaps(
        DDCAPS* pCaps) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSurfaceDesc(
        DDSURFACEDESC* pSurfaceDesc) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFourCCCodes(
        DWORD* pCount,
        DWORD* pCodes) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDirectDraw(
        LPDIRECTDRAW pDirectDraw) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDirectDraw(
        LPDIRECTDRAW* ppDirectDraw) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSurfaceType(
        DWORD* pSurfaceType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDefault(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE UseScanLine(
        long UseScanLine) = 0;

    virtual HRESULT STDMETHODCALLTYPE CanUseScanLine(
        long* UseScanLine) = 0;

    virtual HRESULT STDMETHODCALLTYPE UseOverlayStretch(
        long UseOverlayStretch) = 0;

    virtual HRESULT STDMETHODCALLTYPE CanUseOverlayStretch(
        long* UseOverlayStretch) = 0;

    virtual HRESULT STDMETHODCALLTYPE UseWhenFullScreen(
        long UseWhenFullScreen) = 0;

    virtual HRESULT STDMETHODCALLTYPE WillUseFullScreen(
        long* UseWhenFullScreen) = 0;

};
#else
typedef struct IDirectDrawVideoVtbl IDirectDrawVideoVtbl;
struct IDirectDrawVideo {
    const IDirectDrawVideoVtbl* lpVtbl;
};
struct IDirectDrawVideoVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IDirectDrawVideo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IDirectDrawVideo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IDirectDrawVideo* This);

    /*** IDirectDrawVideo methods ***/
    HRESULT (STDMETHODCALLTYPE *GetSwitches)(
        IDirectDrawVideo* This,
        DWORD* pSwitches);

    HRESULT (STDMETHODCALLTYPE *SetSwitches)(
        IDirectDrawVideo* This,
        DWORD Switches);

    HRESULT (STDMETHODCALLTYPE *GetCaps)(
        IDirectDrawVideo* This,
        DDCAPS* pCaps);

    HRESULT (STDMETHODCALLTYPE *GetEmulatedCaps)(
        IDirectDrawVideo* This,
        DDCAPS* pCaps);

    HRESULT (STDMETHODCALLTYPE *GetSurfaceDesc)(
        IDirectDrawVideo* This,
        DDSURFACEDESC* pSurfaceDesc);

    HRESULT (STDMETHODCALLTYPE *GetFourCCCodes)(
        IDirectDrawVideo* This,
        DWORD* pCount,
        DWORD* pCodes);

    HRESULT (STDMETHODCALLTYPE *SetDirectDraw)(
        IDirectDrawVideo* This,
        LPDIRECTDRAW pDirectDraw);

    HRESULT (STDMETHODCALLTYPE *GetDirectDraw)(
        IDirectDrawVideo* This,
        LPDIRECTDRAW* ppDirectDraw);

    HRESULT (STDMETHODCALLTYPE *GetSurfaceType)(
        IDirectDrawVideo* This,
        DWORD* pSurfaceType);

    HRESULT (STDMETHODCALLTYPE *SetDefault)(
        IDirectDrawVideo* This);

    HRESULT (STDMETHODCALLTYPE *UseScanLine)(
        IDirectDrawVideo* This,
        long UseScanLine);

    HRESULT (STDMETHODCALLTYPE *CanUseScanLine)(
        IDirectDrawVideo* This,
        long* UseScanLine);

    HRESULT (STDMETHODCALLTYPE *UseOverlayStretch)(
        IDirectDrawVideo* This,
        long UseOverlayStretch);

    HRESULT (STDMETHODCALLTYPE *CanUseOverlayStretch)(
        IDirectDrawVideo* This,
        long* UseOverlayStretch);

    HRESULT (STDMETHODCALLTYPE *UseWhenFullScreen)(
        IDirectDrawVideo* This,
        long UseWhenFullScreen);

    HRESULT (STDMETHODCALLTYPE *WillUseFullScreen)(
        IDirectDrawVideo* This,
        long* UseWhenFullScreen);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IDirectDrawVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDirectDrawVideo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDirectDrawVideo_Release(p) (p)->lpVtbl->Release(p)
/*** IDirectDrawVideo methods ***/
#define IDirectDrawVideo_GetSwitches(p,a) (p)->lpVtbl->GetSwitches(p,a)
#define IDirectDrawVideo_SetSwitches(p,a) (p)->lpVtbl->SetSwitches(p,a)
#define IDirectDrawVideo_GetCaps(p,a) (p)->lpVtbl->GetCaps(p,a)
#define IDirectDrawVideo_GetEmulatedCaps(p,a) (p)->lpVtbl->GetEmulatedCaps(p,a)
#define IDirectDrawVideo_GetSurfaceDesc(p,a) (p)->lpVtbl->GetSurfaceDesc(p,a)
#define IDirectDrawVideo_GetFourCCCodes(p,a,b) (p)->lpVtbl->GetFourCCCodes(p,a,b)
#define IDirectDrawVideo_SetDirectDraw(p,a) (p)->lpVtbl->SetDirectDraw(p,a)
#define IDirectDrawVideo_GetDirectDraw(p,a) (p)->lpVtbl->GetDirectDraw(p,a)
#define IDirectDrawVideo_GetSurfaceType(p,a) (p)->lpVtbl->GetSurfaceType(p,a)
#define IDirectDrawVideo_SetDefault(p) (p)->lpVtbl->SetDefault(p)
#define IDirectDrawVideo_UseScanLine(p,a) (p)->lpVtbl->UseScanLine(p,a)
#define IDirectDrawVideo_CanUseScanLine(p,a) (p)->lpVtbl->CanUseScanLine(p,a)
#define IDirectDrawVideo_UseOverlayStretch(p,a) (p)->lpVtbl->UseOverlayStretch(p,a)
#define IDirectDrawVideo_CanUseOverlayStretch(p,a) (p)->lpVtbl->CanUseOverlayStretch(p,a)
#define IDirectDrawVideo_UseWhenFullScreen(p,a) (p)->lpVtbl->UseWhenFullScreen(p,a)
#define IDirectDrawVideo_WillUseFullScreen(p,a) (p)->lpVtbl->WillUseFullScreen(p,a)
#endif

#endif

HRESULT CALLBACK IDirectDrawVideo_GetSwitches_Proxy(
    IDirectDrawVideo* This,
    DWORD* pSwitches);
void __RPC_STUB IDirectDrawVideo_GetSwitches_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_SetSwitches_Proxy(
    IDirectDrawVideo* This,
    DWORD Switches);
void __RPC_STUB IDirectDrawVideo_SetSwitches_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_GetCaps_Proxy(
    IDirectDrawVideo* This,
    DDCAPS* pCaps);
void __RPC_STUB IDirectDrawVideo_GetCaps_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_GetEmulatedCaps_Proxy(
    IDirectDrawVideo* This,
    DDCAPS* pCaps);
void __RPC_STUB IDirectDrawVideo_GetEmulatedCaps_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_GetSurfaceDesc_Proxy(
    IDirectDrawVideo* This,
    DDSURFACEDESC* pSurfaceDesc);
void __RPC_STUB IDirectDrawVideo_GetSurfaceDesc_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_GetFourCCCodes_Proxy(
    IDirectDrawVideo* This,
    DWORD* pCount,
    DWORD* pCodes);
void __RPC_STUB IDirectDrawVideo_GetFourCCCodes_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_SetDirectDraw_Proxy(
    IDirectDrawVideo* This,
    LPDIRECTDRAW pDirectDraw);
void __RPC_STUB IDirectDrawVideo_SetDirectDraw_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_GetDirectDraw_Proxy(
    IDirectDrawVideo* This,
    LPDIRECTDRAW* ppDirectDraw);
void __RPC_STUB IDirectDrawVideo_GetDirectDraw_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_GetSurfaceType_Proxy(
    IDirectDrawVideo* This,
    DWORD* pSurfaceType);
void __RPC_STUB IDirectDrawVideo_GetSurfaceType_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_SetDefault_Proxy(
    IDirectDrawVideo* This);
void __RPC_STUB IDirectDrawVideo_SetDefault_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_UseScanLine_Proxy(
    IDirectDrawVideo* This,
    long UseScanLine);
void __RPC_STUB IDirectDrawVideo_UseScanLine_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_CanUseScanLine_Proxy(
    IDirectDrawVideo* This,
    long* UseScanLine);
void __RPC_STUB IDirectDrawVideo_CanUseScanLine_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_UseOverlayStretch_Proxy(
    IDirectDrawVideo* This,
    long UseOverlayStretch);
void __RPC_STUB IDirectDrawVideo_UseOverlayStretch_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_CanUseOverlayStretch_Proxy(
    IDirectDrawVideo* This,
    long* UseOverlayStretch);
void __RPC_STUB IDirectDrawVideo_CanUseOverlayStretch_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_UseWhenFullScreen_Proxy(
    IDirectDrawVideo* This,
    long UseWhenFullScreen);
void __RPC_STUB IDirectDrawVideo_UseWhenFullScreen_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawVideo_WillUseFullScreen_Proxy(
    IDirectDrawVideo* This,
    long* UseWhenFullScreen);
void __RPC_STUB IDirectDrawVideo_WillUseFullScreen_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDirectDrawVideo_INTERFACE_DEFINED__ */

#ifndef __IQualProp_FWD_DEFINED__
#define __IQualProp_FWD_DEFINED__
typedef struct IQualProp IQualProp;
#endif

/*****************************************************************************
 * IQualProp interface
 */
#ifndef __IQualProp_INTERFACE_DEFINED__
#define __IQualProp_INTERFACE_DEFINED__

#if defined(__cplusplus) && !defined(CINTERFACE)
struct IQualProp : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE get_FramesDroppedInRenderer(
        int* pcFrames) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_FramesDrawn(
        int* pcFramesDrawn) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_AvgFrameRate(
        int* piAvgFrameRate) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Jitter(
        int* iJitter) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_AvgSyncOffset(
        int* piAvg) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_DevSyncOffset(
        int* piDev) = 0;

};
#else
typedef struct IQualPropVtbl IQualPropVtbl;
struct IQualProp {
    const IQualPropVtbl* lpVtbl;
};
struct IQualPropVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IQualProp* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IQualProp* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IQualProp* This);

    /*** IQualProp methods ***/
    HRESULT (STDMETHODCALLTYPE *get_FramesDroppedInRenderer)(
        IQualProp* This,
        int* pcFrames);

    HRESULT (STDMETHODCALLTYPE *get_FramesDrawn)(
        IQualProp* This,
        int* pcFramesDrawn);

    HRESULT (STDMETHODCALLTYPE *get_AvgFrameRate)(
        IQualProp* This,
        int* piAvgFrameRate);

    HRESULT (STDMETHODCALLTYPE *get_Jitter)(
        IQualProp* This,
        int* iJitter);

    HRESULT (STDMETHODCALLTYPE *get_AvgSyncOffset)(
        IQualProp* This,
        int* piAvg);

    HRESULT (STDMETHODCALLTYPE *get_DevSyncOffset)(
        IQualProp* This,
        int* piDev);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IQualProp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IQualProp_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IQualProp_Release(p) (p)->lpVtbl->Release(p)
/*** IQualProp methods ***/
#define IQualProp_get_FramesDroppedInRenderer(p,a) (p)->lpVtbl->get_FramesDroppedInRenderer(p,a)
#define IQualProp_get_FramesDrawn(p,a) (p)->lpVtbl->get_FramesDrawn(p,a)
#define IQualProp_get_AvgFrameRate(p,a) (p)->lpVtbl->get_AvgFrameRate(p,a)
#define IQualProp_get_Jitter(p,a) (p)->lpVtbl->get_Jitter(p,a)
#define IQualProp_get_AvgSyncOffset(p,a) (p)->lpVtbl->get_AvgSyncOffset(p,a)
#define IQualProp_get_DevSyncOffset(p,a) (p)->lpVtbl->get_DevSyncOffset(p,a)
#endif

#endif

HRESULT CALLBACK IQualProp_get_FramesDroppedInRenderer_Proxy(
    IQualProp* This,
    int* pcFrames);
void __RPC_STUB IQualProp_get_FramesDroppedInRenderer_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IQualProp_get_FramesDrawn_Proxy(
    IQualProp* This,
    int* pcFramesDrawn);
void __RPC_STUB IQualProp_get_FramesDrawn_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IQualProp_get_AvgFrameRate_Proxy(
    IQualProp* This,
    int* piAvgFrameRate);
void __RPC_STUB IQualProp_get_AvgFrameRate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IQualProp_get_Jitter_Proxy(
    IQualProp* This,
    int* iJitter);
void __RPC_STUB IQualProp_get_Jitter_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IQualProp_get_AvgSyncOffset_Proxy(
    IQualProp* This,
    int* piAvg);
void __RPC_STUB IQualProp_get_AvgSyncOffset_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IQualProp_get_DevSyncOffset_Proxy(
    IQualProp* This,
    int* piDev);
void __RPC_STUB IQualProp_get_DevSyncOffset_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IQualProp_INTERFACE_DEFINED__ */

#ifndef __IFullScreenVideo_FWD_DEFINED__
#define __IFullScreenVideo_FWD_DEFINED__
typedef struct IFullScreenVideo IFullScreenVideo;
#endif

/*****************************************************************************
 * IFullScreenVideo interface
 */
#ifndef __IFullScreenVideo_INTERFACE_DEFINED__
#define __IFullScreenVideo_INTERFACE_DEFINED__

#if defined(__cplusplus) && !defined(CINTERFACE)
struct IFullScreenVideo : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CountModes(
        long* pModes) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetModeInfo(
        long Mode,
        long* pWidth,
        long* pHeight,
        long* pDepth) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentMode(
        long* pMode) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsModeAvailable(
        long Mode) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsModeEnabled(
        long Mode) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetEnabled(
        long Mode,
        long bEnabled) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetClipFactor(
        long* pClipFactor) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetClipFactor(
        long ClipFactor) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMessageDrain(
        HWND hwnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMessageDrain(
        HWND* hwnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMonitor(
        long Monitor) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMonitor(
        long* Monitor) = 0;

    virtual HRESULT STDMETHODCALLTYPE HideOnDeactivate(
        long Hide) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsHideOnDeactivate(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCaption(
        BSTR strCaption) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCaption(
        BSTR* pstrCaption) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDefault(
        ) = 0;

};
#else
typedef struct IFullScreenVideoVtbl IFullScreenVideoVtbl;
struct IFullScreenVideo {
    const IFullScreenVideoVtbl* lpVtbl;
};
struct IFullScreenVideoVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IFullScreenVideo* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IFullScreenVideo* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IFullScreenVideo* This);

    /*** IFullScreenVideo methods ***/
    HRESULT (STDMETHODCALLTYPE *CountModes)(
        IFullScreenVideo* This,
        long* pModes);

    HRESULT (STDMETHODCALLTYPE *GetModeInfo)(
        IFullScreenVideo* This,
        long Mode,
        long* pWidth,
        long* pHeight,
        long* pDepth);

    HRESULT (STDMETHODCALLTYPE *GetCurrentMode)(
        IFullScreenVideo* This,
        long* pMode);

    HRESULT (STDMETHODCALLTYPE *IsModeAvailable)(
        IFullScreenVideo* This,
        long Mode);

    HRESULT (STDMETHODCALLTYPE *IsModeEnabled)(
        IFullScreenVideo* This,
        long Mode);

    HRESULT (STDMETHODCALLTYPE *SetEnabled)(
        IFullScreenVideo* This,
        long Mode,
        long bEnabled);

    HRESULT (STDMETHODCALLTYPE *GetClipFactor)(
        IFullScreenVideo* This,
        long* pClipFactor);

    HRESULT (STDMETHODCALLTYPE *SetClipFactor)(
        IFullScreenVideo* This,
        long ClipFactor);

    HRESULT (STDMETHODCALLTYPE *SetMessageDrain)(
        IFullScreenVideo* This,
        HWND hwnd);

    HRESULT (STDMETHODCALLTYPE *GetMessageDrain)(
        IFullScreenVideo* This,
        HWND* hwnd);

    HRESULT (STDMETHODCALLTYPE *SetMonitor)(
        IFullScreenVideo* This,
        long Monitor);

    HRESULT (STDMETHODCALLTYPE *GetMonitor)(
        IFullScreenVideo* This,
        long* Monitor);

    HRESULT (STDMETHODCALLTYPE *HideOnDeactivate)(
        IFullScreenVideo* This,
        long Hide);

    HRESULT (STDMETHODCALLTYPE *IsHideOnDeactivate)(
        IFullScreenVideo* This);

    HRESULT (STDMETHODCALLTYPE *SetCaption)(
        IFullScreenVideo* This,
        BSTR strCaption);

    HRESULT (STDMETHODCALLTYPE *GetCaption)(
        IFullScreenVideo* This,
        BSTR* pstrCaption);

    HRESULT (STDMETHODCALLTYPE *SetDefault)(
        IFullScreenVideo* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IFullScreenVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IFullScreenVideo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IFullScreenVideo_Release(p) (p)->lpVtbl->Release(p)
/*** IFullScreenVideo methods ***/
#define IFullScreenVideo_CountModes(p,a) (p)->lpVtbl->CountModes(p,a)
#define IFullScreenVideo_GetModeInfo(p,a,b,c,d) (p)->lpVtbl->GetModeInfo(p,a,b,c,d)
#define IFullScreenVideo_GetCurrentMode(p,a) (p)->lpVtbl->GetCurrentMode(p,a)
#define IFullScreenVideo_IsModeAvailable(p,a) (p)->lpVtbl->IsModeAvailable(p,a)
#define IFullScreenVideo_IsModeEnabled(p,a) (p)->lpVtbl->IsModeEnabled(p,a)
#define IFullScreenVideo_SetEnabled(p,a,b) (p)->lpVtbl->SetEnabled(p,a,b)
#define IFullScreenVideo_GetClipFactor(p,a) (p)->lpVtbl->GetClipFactor(p,a)
#define IFullScreenVideo_SetClipFactor(p,a) (p)->lpVtbl->SetClipFactor(p,a)
#define IFullScreenVideo_SetMessageDrain(p,a) (p)->lpVtbl->SetMessageDrain(p,a)
#define IFullScreenVideo_GetMessageDrain(p,a) (p)->lpVtbl->GetMessageDrain(p,a)
#define IFullScreenVideo_SetMonitor(p,a) (p)->lpVtbl->SetMonitor(p,a)
#define IFullScreenVideo_GetMonitor(p,a) (p)->lpVtbl->GetMonitor(p,a)
#define IFullScreenVideo_HideOnDeactivate(p,a) (p)->lpVtbl->HideOnDeactivate(p,a)
#define IFullScreenVideo_IsHideOnDeactivate(p) (p)->lpVtbl->IsHideOnDeactivate(p)
#define IFullScreenVideo_SetCaption(p,a) (p)->lpVtbl->SetCaption(p,a)
#define IFullScreenVideo_GetCaption(p,a) (p)->lpVtbl->GetCaption(p,a)
#define IFullScreenVideo_SetDefault(p) (p)->lpVtbl->SetDefault(p)
#endif

#endif

HRESULT CALLBACK IFullScreenVideo_CountModes_Proxy(
    IFullScreenVideo* This,
    long* pModes);
void __RPC_STUB IFullScreenVideo_CountModes_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_GetModeInfo_Proxy(
    IFullScreenVideo* This,
    long Mode,
    long* pWidth,
    long* pHeight,
    long* pDepth);
void __RPC_STUB IFullScreenVideo_GetModeInfo_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_GetCurrentMode_Proxy(
    IFullScreenVideo* This,
    long* pMode);
void __RPC_STUB IFullScreenVideo_GetCurrentMode_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_IsModeAvailable_Proxy(
    IFullScreenVideo* This,
    long Mode);
void __RPC_STUB IFullScreenVideo_IsModeAvailable_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_IsModeEnabled_Proxy(
    IFullScreenVideo* This,
    long Mode);
void __RPC_STUB IFullScreenVideo_IsModeEnabled_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_SetEnabled_Proxy(
    IFullScreenVideo* This,
    long Mode,
    long bEnabled);
void __RPC_STUB IFullScreenVideo_SetEnabled_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_GetClipFactor_Proxy(
    IFullScreenVideo* This,
    long* pClipFactor);
void __RPC_STUB IFullScreenVideo_GetClipFactor_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_SetClipFactor_Proxy(
    IFullScreenVideo* This,
    long ClipFactor);
void __RPC_STUB IFullScreenVideo_SetClipFactor_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_SetMessageDrain_Proxy(
    IFullScreenVideo* This,
    HWND hwnd);
void __RPC_STUB IFullScreenVideo_SetMessageDrain_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_GetMessageDrain_Proxy(
    IFullScreenVideo* This,
    HWND* hwnd);
void __RPC_STUB IFullScreenVideo_GetMessageDrain_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_SetMonitor_Proxy(
    IFullScreenVideo* This,
    long Monitor);
void __RPC_STUB IFullScreenVideo_SetMonitor_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_GetMonitor_Proxy(
    IFullScreenVideo* This,
    long* Monitor);
void __RPC_STUB IFullScreenVideo_GetMonitor_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_HideOnDeactivate_Proxy(
    IFullScreenVideo* This,
    long Hide);
void __RPC_STUB IFullScreenVideo_HideOnDeactivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_IsHideOnDeactivate_Proxy(
    IFullScreenVideo* This);
void __RPC_STUB IFullScreenVideo_IsHideOnDeactivate_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_SetCaption_Proxy(
    IFullScreenVideo* This,
    BSTR strCaption);
void __RPC_STUB IFullScreenVideo_SetCaption_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_GetCaption_Proxy(
    IFullScreenVideo* This,
    BSTR* pstrCaption);
void __RPC_STUB IFullScreenVideo_GetCaption_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideo_SetDefault_Proxy(
    IFullScreenVideo* This);
void __RPC_STUB IFullScreenVideo_SetDefault_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IFullScreenVideo_INTERFACE_DEFINED__ */

#ifndef __IFullScreenVideoEx_FWD_DEFINED__
#define __IFullScreenVideoEx_FWD_DEFINED__
typedef struct IFullScreenVideoEx IFullScreenVideoEx;
#endif

/*****************************************************************************
 * IFullScreenVideoEx interface
 */
#ifndef __IFullScreenVideoEx_INTERFACE_DEFINED__
#define __IFullScreenVideoEx_INTERFACE_DEFINED__

#if defined(__cplusplus) && !defined(CINTERFACE)
struct IFullScreenVideoEx : public IFullScreenVideo
{
    virtual HRESULT STDMETHODCALLTYPE SetAcceleratorTable(
        HWND hwnd,
        HACCEL hAccel) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetAcceleratorTable(
        HWND* phwnd,
        HACCEL* phAccel) = 0;

    virtual HRESULT STDMETHODCALLTYPE KeepPixelAspectRatio(
        long KeepAspect) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsKeepPixelAspectRatio(
        long* pKeepAspect) = 0;

};
#else
typedef struct IFullScreenVideoExVtbl IFullScreenVideoExVtbl;
struct IFullScreenVideoEx {
    const IFullScreenVideoExVtbl* lpVtbl;
};
struct IFullScreenVideoExVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IFullScreenVideoEx* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IFullScreenVideoEx* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IFullScreenVideoEx* This);

    /*** IFullScreenVideo methods ***/
    HRESULT (STDMETHODCALLTYPE *CountModes)(
        IFullScreenVideoEx* This,
        long* pModes);

    HRESULT (STDMETHODCALLTYPE *GetModeInfo)(
        IFullScreenVideoEx* This,
        long Mode,
        long* pWidth,
        long* pHeight,
        long* pDepth);

    HRESULT (STDMETHODCALLTYPE *GetCurrentMode)(
        IFullScreenVideoEx* This,
        long* pMode);

    HRESULT (STDMETHODCALLTYPE *IsModeAvailable)(
        IFullScreenVideoEx* This,
        long Mode);

    HRESULT (STDMETHODCALLTYPE *IsModeEnabled)(
        IFullScreenVideoEx* This,
        long Mode);

    HRESULT (STDMETHODCALLTYPE *SetEnabled)(
        IFullScreenVideoEx* This,
        long Mode,
        long bEnabled);

    HRESULT (STDMETHODCALLTYPE *GetClipFactor)(
        IFullScreenVideoEx* This,
        long* pClipFactor);

    HRESULT (STDMETHODCALLTYPE *SetClipFactor)(
        IFullScreenVideoEx* This,
        long ClipFactor);

    HRESULT (STDMETHODCALLTYPE *SetMessageDrain)(
        IFullScreenVideoEx* This,
        HWND hwnd);

    HRESULT (STDMETHODCALLTYPE *GetMessageDrain)(
        IFullScreenVideoEx* This,
        HWND* hwnd);

    HRESULT (STDMETHODCALLTYPE *SetMonitor)(
        IFullScreenVideoEx* This,
        long Monitor);

    HRESULT (STDMETHODCALLTYPE *GetMonitor)(
        IFullScreenVideoEx* This,
        long* Monitor);

    HRESULT (STDMETHODCALLTYPE *HideOnDeactivate)(
        IFullScreenVideoEx* This,
        long Hide);

    HRESULT (STDMETHODCALLTYPE *IsHideOnDeactivate)(
        IFullScreenVideoEx* This);

    HRESULT (STDMETHODCALLTYPE *SetCaption)(
        IFullScreenVideoEx* This,
        BSTR strCaption);

    HRESULT (STDMETHODCALLTYPE *GetCaption)(
        IFullScreenVideoEx* This,
        BSTR* pstrCaption);

    HRESULT (STDMETHODCALLTYPE *SetDefault)(
        IFullScreenVideoEx* This);

    /*** IFullScreenVideoEx methods ***/
    HRESULT (STDMETHODCALLTYPE *SetAcceleratorTable)(
        IFullScreenVideoEx* This,
        HWND hwnd,
        HACCEL hAccel);

    HRESULT (STDMETHODCALLTYPE *GetAcceleratorTable)(
        IFullScreenVideoEx* This,
        HWND* phwnd,
        HACCEL* phAccel);

    HRESULT (STDMETHODCALLTYPE *KeepPixelAspectRatio)(
        IFullScreenVideoEx* This,
        long KeepAspect);

    HRESULT (STDMETHODCALLTYPE *IsKeepPixelAspectRatio)(
        IFullScreenVideoEx* This,
        long* pKeepAspect);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IFullScreenVideoEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IFullScreenVideoEx_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IFullScreenVideoEx_Release(p) (p)->lpVtbl->Release(p)
/*** IFullScreenVideo methods ***/
#define IFullScreenVideoEx_CountModes(p,a) (p)->lpVtbl->CountModes(p,a)
#define IFullScreenVideoEx_GetModeInfo(p,a,b,c,d) (p)->lpVtbl->GetModeInfo(p,a,b,c,d)
#define IFullScreenVideoEx_GetCurrentMode(p,a) (p)->lpVtbl->GetCurrentMode(p,a)
#define IFullScreenVideoEx_IsModeAvailable(p,a) (p)->lpVtbl->IsModeAvailable(p,a)
#define IFullScreenVideoEx_IsModeEnabled(p,a) (p)->lpVtbl->IsModeEnabled(p,a)
#define IFullScreenVideoEx_SetEnabled(p,a,b) (p)->lpVtbl->SetEnabled(p,a,b)
#define IFullScreenVideoEx_GetClipFactor(p,a) (p)->lpVtbl->GetClipFactor(p,a)
#define IFullScreenVideoEx_SetClipFactor(p,a) (p)->lpVtbl->SetClipFactor(p,a)
#define IFullScreenVideoEx_SetMessageDrain(p,a) (p)->lpVtbl->SetMessageDrain(p,a)
#define IFullScreenVideoEx_GetMessageDrain(p,a) (p)->lpVtbl->GetMessageDrain(p,a)
#define IFullScreenVideoEx_SetMonitor(p,a) (p)->lpVtbl->SetMonitor(p,a)
#define IFullScreenVideoEx_GetMonitor(p,a) (p)->lpVtbl->GetMonitor(p,a)
#define IFullScreenVideoEx_HideOnDeactivate(p,a) (p)->lpVtbl->HideOnDeactivate(p,a)
#define IFullScreenVideoEx_IsHideOnDeactivate(p) (p)->lpVtbl->IsHideOnDeactivate(p)
#define IFullScreenVideoEx_SetCaption(p,a) (p)->lpVtbl->SetCaption(p,a)
#define IFullScreenVideoEx_GetCaption(p,a) (p)->lpVtbl->GetCaption(p,a)
#define IFullScreenVideoEx_SetDefault(p) (p)->lpVtbl->SetDefault(p)
/*** IFullScreenVideoEx methods ***/
#define IFullScreenVideoEx_SetAcceleratorTable(p,a,b) (p)->lpVtbl->SetAcceleratorTable(p,a,b)
#define IFullScreenVideoEx_GetAcceleratorTable(p,a,b) (p)->lpVtbl->GetAcceleratorTable(p,a,b)
#define IFullScreenVideoEx_KeepPixelAspectRatio(p,a) (p)->lpVtbl->KeepPixelAspectRatio(p,a)
#define IFullScreenVideoEx_IsKeepPixelAspectRatio(p,a) (p)->lpVtbl->IsKeepPixelAspectRatio(p,a)
#endif

#endif

HRESULT CALLBACK IFullScreenVideoEx_SetAcceleratorTable_Proxy(
    IFullScreenVideoEx* This,
    HWND hwnd,
    HACCEL hAccel);
void __RPC_STUB IFullScreenVideoEx_SetAcceleratorTable_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideoEx_GetAcceleratorTable_Proxy(
    IFullScreenVideoEx* This,
    HWND* phwnd,
    HACCEL* phAccel);
void __RPC_STUB IFullScreenVideoEx_GetAcceleratorTable_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideoEx_KeepPixelAspectRatio_Proxy(
    IFullScreenVideoEx* This,
    long KeepAspect);
void __RPC_STUB IFullScreenVideoEx_KeepPixelAspectRatio_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IFullScreenVideoEx_IsKeepPixelAspectRatio_Proxy(
    IFullScreenVideoEx* This,
    long* pKeepAspect);
void __RPC_STUB IFullScreenVideoEx_IsKeepPixelAspectRatio_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IFullScreenVideoEx_INTERFACE_DEFINED__ */

#ifndef __IBaseVideoMixer_FWD_DEFINED__
#define __IBaseVideoMixer_FWD_DEFINED__
typedef struct IBaseVideoMixer IBaseVideoMixer;
#endif

/*****************************************************************************
 * IBaseVideoMixer interface
 */
#ifndef __IBaseVideoMixer_INTERFACE_DEFINED__
#define __IBaseVideoMixer_INTERFACE_DEFINED__

#if defined(__cplusplus) && !defined(CINTERFACE)
struct IBaseVideoMixer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetLeadPin(
        int iPin) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetLeadPin(
        int* piPin) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetInputPinCount(
        int* piPinCount) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsUsingClock(
        int* pbValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetUsingClock(
        int bValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetClockPeriod(
        int* pbValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetClockPeriod(
        int bValue) = 0;

};
#else
typedef struct IBaseVideoMixerVtbl IBaseVideoMixerVtbl;
struct IBaseVideoMixer {
    const IBaseVideoMixerVtbl* lpVtbl;
};
struct IBaseVideoMixerVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IBaseVideoMixer* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IBaseVideoMixer* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IBaseVideoMixer* This);

    /*** IBaseVideoMixer methods ***/
    HRESULT (STDMETHODCALLTYPE *SetLeadPin)(
        IBaseVideoMixer* This,
        int iPin);

    HRESULT (STDMETHODCALLTYPE *GetLeadPin)(
        IBaseVideoMixer* This,
        int* piPin);

    HRESULT (STDMETHODCALLTYPE *GetInputPinCount)(
        IBaseVideoMixer* This,
        int* piPinCount);

    HRESULT (STDMETHODCALLTYPE *IsUsingClock)(
        IBaseVideoMixer* This,
        int* pbValue);

    HRESULT (STDMETHODCALLTYPE *SetUsingClock)(
        IBaseVideoMixer* This,
        int bValue);

    HRESULT (STDMETHODCALLTYPE *GetClockPeriod)(
        IBaseVideoMixer* This,
        int* pbValue);

    HRESULT (STDMETHODCALLTYPE *SetClockPeriod)(
        IBaseVideoMixer* This,
        int bValue);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IBaseVideoMixer_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBaseVideoMixer_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBaseVideoMixer_Release(p) (p)->lpVtbl->Release(p)
/*** IBaseVideoMixer methods ***/
#define IBaseVideoMixer_SetLeadPin(p,a) (p)->lpVtbl->SetLeadPin(p,a)
#define IBaseVideoMixer_GetLeadPin(p,a) (p)->lpVtbl->GetLeadPin(p,a)
#define IBaseVideoMixer_GetInputPinCount(p,a) (p)->lpVtbl->GetInputPinCount(p,a)
#define IBaseVideoMixer_IsUsingClock(p,a) (p)->lpVtbl->IsUsingClock(p,a)
#define IBaseVideoMixer_SetUsingClock(p,a) (p)->lpVtbl->SetUsingClock(p,a)
#define IBaseVideoMixer_GetClockPeriod(p,a) (p)->lpVtbl->GetClockPeriod(p,a)
#define IBaseVideoMixer_SetClockPeriod(p,a) (p)->lpVtbl->SetClockPeriod(p,a)
#endif

#endif

HRESULT CALLBACK IBaseVideoMixer_SetLeadPin_Proxy(
    IBaseVideoMixer* This,
    int iPin);
void __RPC_STUB IBaseVideoMixer_SetLeadPin_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBaseVideoMixer_GetLeadPin_Proxy(
    IBaseVideoMixer* This,
    int* piPin);
void __RPC_STUB IBaseVideoMixer_GetLeadPin_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBaseVideoMixer_GetInputPinCount_Proxy(
    IBaseVideoMixer* This,
    int* piPinCount);
void __RPC_STUB IBaseVideoMixer_GetInputPinCount_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBaseVideoMixer_IsUsingClock_Proxy(
    IBaseVideoMixer* This,
    int* pbValue);
void __RPC_STUB IBaseVideoMixer_IsUsingClock_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBaseVideoMixer_SetUsingClock_Proxy(
    IBaseVideoMixer* This,
    int bValue);
void __RPC_STUB IBaseVideoMixer_SetUsingClock_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBaseVideoMixer_GetClockPeriod_Proxy(
    IBaseVideoMixer* This,
    int* pbValue);
void __RPC_STUB IBaseVideoMixer_GetClockPeriod_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBaseVideoMixer_SetClockPeriod_Proxy(
    IBaseVideoMixer* This,
    int bValue);
void __RPC_STUB IBaseVideoMixer_SetClockPeriod_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBaseVideoMixer_INTERFACE_DEFINED__ */

#define iPALETTE_COLORS 256
#define iEGA_COLORS 16
#define iMASK_COLORS 3
#define iTRUECOLOR 16
#define iRED 0
#define iGREEN 1
#define iBLUE 2
#define iPALETTE 8
#define iMAXBITS 8
typedef struct tag_TRUECOLORINFO {
    DWORD dwBitMasks[3];
    RGBQUAD bmiColors[256];
} TRUECOLORINFO;

typedef struct tagVIDEOINFOHEADER {
    RECT rcSource;
    RECT rcTarget;
    DWORD dwBitRate;
    DWORD dwBitErrorRate;
    REFERENCE_TIME AvgTimePerFrame;
    BITMAPINFOHEADER bmiHeader;
} VIDEOINFOHEADER;

typedef struct tagVIDEOINFO {
    RECT rcSource;
    RECT rcTarget;
    DWORD dwBitRate;
    DWORD dwBitErrorRate;
    REFERENCE_TIME AvgTimePerFrame;
    BITMAPINFOHEADER bmiHeader;
    union {
        RGBQUAD bmiColors[256];
        DWORD dwBitMasks[3];
        TRUECOLORINFO TrueColorInfo;
    } DUMMYUNIONNAME;
} VIDEOINFO;

typedef struct tagMPEG1VIDEOINFO {
    VIDEOINFOHEADER hdr;
    DWORD dwStartTimeCode;
    DWORD cbSequenceHeader;
    BYTE bSequenceHeader[1];
} MPEG1VIDEOINFO;

#define MAX_SIZE_MPEG1_SEQUENCE_INFO 140
#define MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader)
typedef struct tagAnalogVideoInfo {
    RECT rcSource;
    RECT rcTarget;
    DWORD dwActiveWidth;
    DWORD dwActiveHeight;
    REFERENCE_TIME AvgTimePerFrame;
} ANALOGVIDEOINFO;

typedef enum {
    AM_PROPERTY_FRAMESTEP_STEP = 0x1,
    AM_PROPERTY_FRAMESTEP_CANCEL = 0x2,
    AM_PROPERTY_FRAMESTEP_CANSTEP = 0x3,
    AM_PROPERTY_FRAMESTEP_CANSTEPMULTIPLE = 0x4
} AM_PROPERTY_FRAMESTEP;

typedef struct _AM_FRAMESTEP_STEP {
    DWORD dwFramesToStep;
} AM_FRAMESTEP_STEP;

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_AMVIDEO_H */
