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

#ifndef __WIDL_CONTROL_H
#define __WIDL_CONTROL_H
#ifdef __cplusplus
extern "C" {
#endif
#if 0
#include <shldisp.h>
#include <strmif.h>
#endif
#ifndef __IMediaControl_FWD_DEFINED__
#define __IMediaControl_FWD_DEFINED__
typedef interface IMediaControl IMediaControl;
#endif

#ifndef __IBasicAudio_FWD_DEFINED__
#define __IBasicAudio_FWD_DEFINED__
typedef interface IBasicAudio IBasicAudio;
#endif

#ifndef __IBasicVideo_FWD_DEFINED__
#define __IBasicVideo_FWD_DEFINED__
typedef interface IBasicVideo IBasicVideo;
#endif

#ifndef __IVideoWindow_FWD_DEFINED__
#define __IVideoWindow_FWD_DEFINED__
typedef interface IVideoWindow IVideoWindow;
#endif

#ifndef __IMediaEvent_FWD_DEFINED__
#define __IMediaEvent_FWD_DEFINED__
typedef interface IMediaEvent IMediaEvent;
#endif

#ifndef __IMediaEventEx_FWD_DEFINED__
#define __IMediaEventEx_FWD_DEFINED__
typedef interface IMediaEventEx IMediaEventEx;
#endif

#ifndef __IMediaPosition_FWD_DEFINED__
#define __IMediaPosition_FWD_DEFINED__
typedef interface IMediaPosition IMediaPosition;
#endif

typedef long OAFilterState;
typedef LONG_PTR OAHWND;
typedef LONG_PTR OAEVENT;
/*****************************************************************************
 * IMediaControl interface
 */
#ifndef __IMediaControl_INTERFACE_DEFINED__
#define __IMediaControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMediaControl, 0x56a868b1, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMediaControl : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE Run(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Pause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetState(
        LONG msTimeout,
        OAFilterState *pfs) = 0;

    virtual HRESULT STDMETHODCALLTYPE RenderFile(
        BSTR strFilename) = 0;

    virtual HRESULT STDMETHODCALLTYPE AddSourceFilter(
        BSTR strFilename,
        IDispatch **ppUnk) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_FilterCollection(
        IDispatch **ppUnk) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_RegFilterCollection(
        IDispatch **ppUnk) = 0;

    virtual HRESULT STDMETHODCALLTYPE StopWhenReady(
        ) = 0;

};
#else
typedef struct IMediaControlVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IMediaControl* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IMediaControl* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IMediaControl* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMediaControl* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IMediaControl methods ***/
    HRESULT (STDMETHODCALLTYPE *Run)(
        IMediaControl* This);

    HRESULT (STDMETHODCALLTYPE *Pause)(
        IMediaControl* This);

    HRESULT (STDMETHODCALLTYPE *Stop)(
        IMediaControl* This);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IMediaControl* This,
        LONG msTimeout,
        OAFilterState *pfs);

    HRESULT (STDMETHODCALLTYPE *RenderFile)(
        IMediaControl* This,
        BSTR strFilename);

    HRESULT (STDMETHODCALLTYPE *AddSourceFilter)(
        IMediaControl* This,
        BSTR strFilename,
        IDispatch **ppUnk);

    HRESULT (STDMETHODCALLTYPE *get_FilterCollection)(
        IMediaControl* This,
        IDispatch **ppUnk);

    HRESULT (STDMETHODCALLTYPE *get_RegFilterCollection)(
        IMediaControl* This,
        IDispatch **ppUnk);

    HRESULT (STDMETHODCALLTYPE *StopWhenReady)(
        IMediaControl* This);

    END_INTERFACE
} IMediaControlVtbl;
interface IMediaControl {
    CONST_VTBL IMediaControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMediaControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMediaControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMediaControl_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IMediaControl_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IMediaControl_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IMediaControl_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IMediaControl_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IMediaControl methods ***/
#define IMediaControl_Run(p) (p)->lpVtbl->Run(p)
#define IMediaControl_Pause(p) (p)->lpVtbl->Pause(p)
#define IMediaControl_Stop(p) (p)->lpVtbl->Stop(p)
#define IMediaControl_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
#define IMediaControl_RenderFile(p,a) (p)->lpVtbl->RenderFile(p,a)
#define IMediaControl_AddSourceFilter(p,a,b) (p)->lpVtbl->AddSourceFilter(p,a,b)
#define IMediaControl_get_FilterCollection(p,a) (p)->lpVtbl->get_FilterCollection(p,a)
#define IMediaControl_get_RegFilterCollection(p,a) (p)->lpVtbl->get_RegFilterCollection(p,a)
#define IMediaControl_StopWhenReady(p) (p)->lpVtbl->StopWhenReady(p)
#endif

#endif

HRESULT CALLBACK IMediaControl_Run_Proxy(
    IMediaControl* This);
void __RPC_STUB IMediaControl_Run_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_Pause_Proxy(
    IMediaControl* This);
void __RPC_STUB IMediaControl_Pause_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_Stop_Proxy(
    IMediaControl* This);
void __RPC_STUB IMediaControl_Stop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_GetState_Proxy(
    IMediaControl* This,
    LONG msTimeout,
    OAFilterState *pfs);
void __RPC_STUB IMediaControl_GetState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_RenderFile_Proxy(
    IMediaControl* This,
    BSTR strFilename);
void __RPC_STUB IMediaControl_RenderFile_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_AddSourceFilter_Proxy(
    IMediaControl* This,
    BSTR strFilename,
    IDispatch **ppUnk);
void __RPC_STUB IMediaControl_AddSourceFilter_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_get_FilterCollection_Proxy(
    IMediaControl* This,
    IDispatch **ppUnk);
void __RPC_STUB IMediaControl_get_FilterCollection_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_get_RegFilterCollection_Proxy(
    IMediaControl* This,
    IDispatch **ppUnk);
void __RPC_STUB IMediaControl_get_RegFilterCollection_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaControl_StopWhenReady_Proxy(
    IMediaControl* This);
void __RPC_STUB IMediaControl_StopWhenReady_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMediaControl_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IBasicAudio interface
 */
#ifndef __IBasicAudio_INTERFACE_DEFINED__
#define __IBasicAudio_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBasicAudio, 0x56a868b3, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IBasicAudio : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE put_Volume(
        long lVolume) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Volume(
        long *plVolume) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Balance(
        long lBalance) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Balance(
        long *plBalance) = 0;

};
#else
typedef struct IBasicAudioVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IBasicAudio* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IBasicAudio* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IBasicAudio* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IBasicAudio* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IBasicAudio methods ***/
    HRESULT (STDMETHODCALLTYPE *put_Volume)(
        IBasicAudio* This,
        long lVolume);

    HRESULT (STDMETHODCALLTYPE *get_Volume)(
        IBasicAudio* This,
        long *plVolume);

    HRESULT (STDMETHODCALLTYPE *put_Balance)(
        IBasicAudio* This,
        long lBalance);

    HRESULT (STDMETHODCALLTYPE *get_Balance)(
        IBasicAudio* This,
        long *plBalance);

    END_INTERFACE
} IBasicAudioVtbl;
interface IBasicAudio {
    CONST_VTBL IBasicAudioVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IBasicAudio_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBasicAudio_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBasicAudio_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IBasicAudio_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IBasicAudio_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IBasicAudio_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IBasicAudio_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IBasicAudio methods ***/
#define IBasicAudio_put_Volume(p,a) (p)->lpVtbl->put_Volume(p,a)
#define IBasicAudio_get_Volume(p,a) (p)->lpVtbl->get_Volume(p,a)
#define IBasicAudio_put_Balance(p,a) (p)->lpVtbl->put_Balance(p,a)
#define IBasicAudio_get_Balance(p,a) (p)->lpVtbl->get_Balance(p,a)
#endif

#endif

HRESULT CALLBACK IBasicAudio_put_Volume_Proxy(
    IBasicAudio* This,
    long lVolume);
void __RPC_STUB IBasicAudio_put_Volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicAudio_get_Volume_Proxy(
    IBasicAudio* This,
    long *plVolume);
void __RPC_STUB IBasicAudio_get_Volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicAudio_put_Balance_Proxy(
    IBasicAudio* This,
    long lBalance);
void __RPC_STUB IBasicAudio_put_Balance_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicAudio_get_Balance_Proxy(
    IBasicAudio* This,
    long *plBalance);
void __RPC_STUB IBasicAudio_get_Balance_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBasicAudio_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVideoWindow interface
 */
#ifndef __IVideoWindow_INTERFACE_DEFINED__
#define __IVideoWindow_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVideoWindow, 0x56a868b4, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVideoWindow : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE put_Caption(
        BSTR strCaption) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Caption(
        BSTR *strCaption) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_WindowStyle(
        long WindowStyle) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_WindowStyle(
        long *WindowStyle) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_WindowStyleEx(
        long WindowStyleEx) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_WindowStyleEx(
        long *WindowStyleEx) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_AutoShow(
        long AutoShow) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_AutoShow(
        long *AutoShow) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_WindowState(
        long WindowState) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_WindowState(
        long *WindowState) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_BackgroundPalette(
        long BackgroundPalette) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_BackgroundPalette(
        long *pBackgroundPalette) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Visible(
        long Visible) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Visible(
        long *pVisible) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Left(
        long Left) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Left(
        long *pLeft) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Width(
        long Width) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Width(
        long *pWidth) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Top(
        long Top) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Top(
        long *pTop) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Height(
        long Height) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Height(
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Owner(
        OAHWND Owner) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Owner(
        OAHWND *Owner) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_MessageDrain(
        OAHWND Drain) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_MessageDrain(
        OAHWND *Drain) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_BorderColor(
        long *Color) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_BorderColor(
        long Color) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_FullScreenMode(
        long *FullScreenMode) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_FullScreenMode(
        long FullScreenMode) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetWindowForeground(
        long Focus) = 0;

    virtual HRESULT STDMETHODCALLTYPE NotifyOwnerMessage(
        OAHWND hwnd,
        long uMsg,
        LONG_PTR wParam,
        LONG_PTR lParam) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetWindowPosition(
        long Left,
        long Top,
        long Width,
        long Height) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetWindowPosition(
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMinIdealImageSize(
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMaxIdealImageSize(
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRestorePosition(
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE HideCursor(
        long HideCursor) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsCursorHidden(
        long *CursorHidden) = 0;

};
#else
typedef struct IVideoWindowVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IVideoWindow* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IVideoWindow* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IVideoWindow* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IVideoWindow* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IVideoWindow methods ***/
    HRESULT (STDMETHODCALLTYPE *put_Caption)(
        IVideoWindow* This,
        BSTR strCaption);

    HRESULT (STDMETHODCALLTYPE *get_Caption)(
        IVideoWindow* This,
        BSTR *strCaption);

    HRESULT (STDMETHODCALLTYPE *put_WindowStyle)(
        IVideoWindow* This,
        long WindowStyle);

    HRESULT (STDMETHODCALLTYPE *get_WindowStyle)(
        IVideoWindow* This,
        long *WindowStyle);

    HRESULT (STDMETHODCALLTYPE *put_WindowStyleEx)(
        IVideoWindow* This,
        long WindowStyleEx);

    HRESULT (STDMETHODCALLTYPE *get_WindowStyleEx)(
        IVideoWindow* This,
        long *WindowStyleEx);

    HRESULT (STDMETHODCALLTYPE *put_AutoShow)(
        IVideoWindow* This,
        long AutoShow);

    HRESULT (STDMETHODCALLTYPE *get_AutoShow)(
        IVideoWindow* This,
        long *AutoShow);

    HRESULT (STDMETHODCALLTYPE *put_WindowState)(
        IVideoWindow* This,
        long WindowState);

    HRESULT (STDMETHODCALLTYPE *get_WindowState)(
        IVideoWindow* This,
        long *WindowState);

    HRESULT (STDMETHODCALLTYPE *put_BackgroundPalette)(
        IVideoWindow* This,
        long BackgroundPalette);

    HRESULT (STDMETHODCALLTYPE *get_BackgroundPalette)(
        IVideoWindow* This,
        long *pBackgroundPalette);

    HRESULT (STDMETHODCALLTYPE *put_Visible)(
        IVideoWindow* This,
        long Visible);

    HRESULT (STDMETHODCALLTYPE *get_Visible)(
        IVideoWindow* This,
        long *pVisible);

    HRESULT (STDMETHODCALLTYPE *put_Left)(
        IVideoWindow* This,
        long Left);

    HRESULT (STDMETHODCALLTYPE *get_Left)(
        IVideoWindow* This,
        long *pLeft);

    HRESULT (STDMETHODCALLTYPE *put_Width)(
        IVideoWindow* This,
        long Width);

    HRESULT (STDMETHODCALLTYPE *get_Width)(
        IVideoWindow* This,
        long *pWidth);

    HRESULT (STDMETHODCALLTYPE *put_Top)(
        IVideoWindow* This,
        long Top);

    HRESULT (STDMETHODCALLTYPE *get_Top)(
        IVideoWindow* This,
        long *pTop);

    HRESULT (STDMETHODCALLTYPE *put_Height)(
        IVideoWindow* This,
        long Height);

    HRESULT (STDMETHODCALLTYPE *get_Height)(
        IVideoWindow* This,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *put_Owner)(
        IVideoWindow* This,
        OAHWND Owner);

    HRESULT (STDMETHODCALLTYPE *get_Owner)(
        IVideoWindow* This,
        OAHWND *Owner);

    HRESULT (STDMETHODCALLTYPE *put_MessageDrain)(
        IVideoWindow* This,
        OAHWND Drain);

    HRESULT (STDMETHODCALLTYPE *get_MessageDrain)(
        IVideoWindow* This,
        OAHWND *Drain);

    HRESULT (STDMETHODCALLTYPE *get_BorderColor)(
        IVideoWindow* This,
        long *Color);

    HRESULT (STDMETHODCALLTYPE *put_BorderColor)(
        IVideoWindow* This,
        long Color);

    HRESULT (STDMETHODCALLTYPE *get_FullScreenMode)(
        IVideoWindow* This,
        long *FullScreenMode);

    HRESULT (STDMETHODCALLTYPE *put_FullScreenMode)(
        IVideoWindow* This,
        long FullScreenMode);

    HRESULT (STDMETHODCALLTYPE *SetWindowForeground)(
        IVideoWindow* This,
        long Focus);

    HRESULT (STDMETHODCALLTYPE *NotifyOwnerMessage)(
        IVideoWindow* This,
        OAHWND hwnd,
        long uMsg,
        LONG_PTR wParam,
        LONG_PTR lParam);

    HRESULT (STDMETHODCALLTYPE *SetWindowPosition)(
        IVideoWindow* This,
        long Left,
        long Top,
        long Width,
        long Height);

    HRESULT (STDMETHODCALLTYPE *GetWindowPosition)(
        IVideoWindow* This,
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *GetMinIdealImageSize)(
        IVideoWindow* This,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *GetMaxIdealImageSize)(
        IVideoWindow* This,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *GetRestorePosition)(
        IVideoWindow* This,
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *HideCursor)(
        IVideoWindow* This,
        long HideCursor);

    HRESULT (STDMETHODCALLTYPE *IsCursorHidden)(
        IVideoWindow* This,
        long *CursorHidden);

    END_INTERFACE
} IVideoWindowVtbl;
interface IVideoWindow {
    CONST_VTBL IVideoWindowVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVideoWindow_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVideoWindow_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVideoWindow_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVideoWindow_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVideoWindow_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVideoWindow_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVideoWindow_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVideoWindow methods ***/
#define IVideoWindow_put_Caption(p,a) (p)->lpVtbl->put_Caption(p,a)
#define IVideoWindow_get_Caption(p,a) (p)->lpVtbl->get_Caption(p,a)
#define IVideoWindow_put_WindowStyle(p,a) (p)->lpVtbl->put_WindowStyle(p,a)
#define IVideoWindow_get_WindowStyle(p,a) (p)->lpVtbl->get_WindowStyle(p,a)
#define IVideoWindow_put_WindowStyleEx(p,a) (p)->lpVtbl->put_WindowStyleEx(p,a)
#define IVideoWindow_get_WindowStyleEx(p,a) (p)->lpVtbl->get_WindowStyleEx(p,a)
#define IVideoWindow_put_AutoShow(p,a) (p)->lpVtbl->put_AutoShow(p,a)
#define IVideoWindow_get_AutoShow(p,a) (p)->lpVtbl->get_AutoShow(p,a)
#define IVideoWindow_put_WindowState(p,a) (p)->lpVtbl->put_WindowState(p,a)
#define IVideoWindow_get_WindowState(p,a) (p)->lpVtbl->get_WindowState(p,a)
#define IVideoWindow_put_BackgroundPalette(p,a) (p)->lpVtbl->put_BackgroundPalette(p,a)
#define IVideoWindow_get_BackgroundPalette(p,a) (p)->lpVtbl->get_BackgroundPalette(p,a)
#define IVideoWindow_put_Visible(p,a) (p)->lpVtbl->put_Visible(p,a)
#define IVideoWindow_get_Visible(p,a) (p)->lpVtbl->get_Visible(p,a)
#define IVideoWindow_put_Left(p,a) (p)->lpVtbl->put_Left(p,a)
#define IVideoWindow_get_Left(p,a) (p)->lpVtbl->get_Left(p,a)
#define IVideoWindow_put_Width(p,a) (p)->lpVtbl->put_Width(p,a)
#define IVideoWindow_get_Width(p,a) (p)->lpVtbl->get_Width(p,a)
#define IVideoWindow_put_Top(p,a) (p)->lpVtbl->put_Top(p,a)
#define IVideoWindow_get_Top(p,a) (p)->lpVtbl->get_Top(p,a)
#define IVideoWindow_put_Height(p,a) (p)->lpVtbl->put_Height(p,a)
#define IVideoWindow_get_Height(p,a) (p)->lpVtbl->get_Height(p,a)
#define IVideoWindow_put_Owner(p,a) (p)->lpVtbl->put_Owner(p,a)
#define IVideoWindow_get_Owner(p,a) (p)->lpVtbl->get_Owner(p,a)
#define IVideoWindow_put_MessageDrain(p,a) (p)->lpVtbl->put_MessageDrain(p,a)
#define IVideoWindow_get_MessageDrain(p,a) (p)->lpVtbl->get_MessageDrain(p,a)
#define IVideoWindow_get_BorderColor(p,a) (p)->lpVtbl->get_BorderColor(p,a)
#define IVideoWindow_put_BorderColor(p,a) (p)->lpVtbl->put_BorderColor(p,a)
#define IVideoWindow_get_FullScreenMode(p,a) (p)->lpVtbl->get_FullScreenMode(p,a)
#define IVideoWindow_put_FullScreenMode(p,a) (p)->lpVtbl->put_FullScreenMode(p,a)
#define IVideoWindow_SetWindowForeground(p,a) (p)->lpVtbl->SetWindowForeground(p,a)
#define IVideoWindow_NotifyOwnerMessage(p,a,b,c,d) (p)->lpVtbl->NotifyOwnerMessage(p,a,b,c,d)
#define IVideoWindow_SetWindowPosition(p,a,b,c,d) (p)->lpVtbl->SetWindowPosition(p,a,b,c,d)
#define IVideoWindow_GetWindowPosition(p,a,b,c,d) (p)->lpVtbl->GetWindowPosition(p,a,b,c,d)
#define IVideoWindow_GetMinIdealImageSize(p,a,b) (p)->lpVtbl->GetMinIdealImageSize(p,a,b)
#define IVideoWindow_GetMaxIdealImageSize(p,a,b) (p)->lpVtbl->GetMaxIdealImageSize(p,a,b)
#define IVideoWindow_GetRestorePosition(p,a,b,c,d) (p)->lpVtbl->GetRestorePosition(p,a,b,c,d)
#define IVideoWindow_HideCursor(p,a) (p)->lpVtbl->HideCursor(p,a)
#define IVideoWindow_IsCursorHidden(p,a) (p)->lpVtbl->IsCursorHidden(p,a)
#endif

#endif

HRESULT CALLBACK IVideoWindow_put_Caption_Proxy(
    IVideoWindow* This,
    BSTR strCaption);
void __RPC_STUB IVideoWindow_put_Caption_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Caption_Proxy(
    IVideoWindow* This,
    BSTR *strCaption);
void __RPC_STUB IVideoWindow_get_Caption_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_WindowStyle_Proxy(
    IVideoWindow* This,
    long WindowStyle);
void __RPC_STUB IVideoWindow_put_WindowStyle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_WindowStyle_Proxy(
    IVideoWindow* This,
    long *WindowStyle);
void __RPC_STUB IVideoWindow_get_WindowStyle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_WindowStyleEx_Proxy(
    IVideoWindow* This,
    long WindowStyleEx);
void __RPC_STUB IVideoWindow_put_WindowStyleEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_WindowStyleEx_Proxy(
    IVideoWindow* This,
    long *WindowStyleEx);
void __RPC_STUB IVideoWindow_get_WindowStyleEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_AutoShow_Proxy(
    IVideoWindow* This,
    long AutoShow);
void __RPC_STUB IVideoWindow_put_AutoShow_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_AutoShow_Proxy(
    IVideoWindow* This,
    long *AutoShow);
void __RPC_STUB IVideoWindow_get_AutoShow_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_WindowState_Proxy(
    IVideoWindow* This,
    long WindowState);
void __RPC_STUB IVideoWindow_put_WindowState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_WindowState_Proxy(
    IVideoWindow* This,
    long *WindowState);
void __RPC_STUB IVideoWindow_get_WindowState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_BackgroundPalette_Proxy(
    IVideoWindow* This,
    long BackgroundPalette);
void __RPC_STUB IVideoWindow_put_BackgroundPalette_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_BackgroundPalette_Proxy(
    IVideoWindow* This,
    long *pBackgroundPalette);
void __RPC_STUB IVideoWindow_get_BackgroundPalette_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_Visible_Proxy(
    IVideoWindow* This,
    long Visible);
void __RPC_STUB IVideoWindow_put_Visible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Visible_Proxy(
    IVideoWindow* This,
    long *pVisible);
void __RPC_STUB IVideoWindow_get_Visible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_Left_Proxy(
    IVideoWindow* This,
    long Left);
void __RPC_STUB IVideoWindow_put_Left_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Left_Proxy(
    IVideoWindow* This,
    long *pLeft);
void __RPC_STUB IVideoWindow_get_Left_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_Width_Proxy(
    IVideoWindow* This,
    long Width);
void __RPC_STUB IVideoWindow_put_Width_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Width_Proxy(
    IVideoWindow* This,
    long *pWidth);
void __RPC_STUB IVideoWindow_get_Width_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_Top_Proxy(
    IVideoWindow* This,
    long Top);
void __RPC_STUB IVideoWindow_put_Top_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Top_Proxy(
    IVideoWindow* This,
    long *pTop);
void __RPC_STUB IVideoWindow_get_Top_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_Height_Proxy(
    IVideoWindow* This,
    long Height);
void __RPC_STUB IVideoWindow_put_Height_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Height_Proxy(
    IVideoWindow* This,
    long *pHeight);
void __RPC_STUB IVideoWindow_get_Height_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_Owner_Proxy(
    IVideoWindow* This,
    OAHWND Owner);
void __RPC_STUB IVideoWindow_put_Owner_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_Owner_Proxy(
    IVideoWindow* This,
    OAHWND *Owner);
void __RPC_STUB IVideoWindow_get_Owner_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_MessageDrain_Proxy(
    IVideoWindow* This,
    OAHWND Drain);
void __RPC_STUB IVideoWindow_put_MessageDrain_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_MessageDrain_Proxy(
    IVideoWindow* This,
    OAHWND *Drain);
void __RPC_STUB IVideoWindow_get_MessageDrain_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_BorderColor_Proxy(
    IVideoWindow* This,
    long *Color);
void __RPC_STUB IVideoWindow_get_BorderColor_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_BorderColor_Proxy(
    IVideoWindow* This,
    long Color);
void __RPC_STUB IVideoWindow_put_BorderColor_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_get_FullScreenMode_Proxy(
    IVideoWindow* This,
    long *FullScreenMode);
void __RPC_STUB IVideoWindow_get_FullScreenMode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_put_FullScreenMode_Proxy(
    IVideoWindow* This,
    long FullScreenMode);
void __RPC_STUB IVideoWindow_put_FullScreenMode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_SetWindowForeground_Proxy(
    IVideoWindow* This,
    long Focus);
void __RPC_STUB IVideoWindow_SetWindowForeground_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_NotifyOwnerMessage_Proxy(
    IVideoWindow* This,
    OAHWND hwnd,
    long uMsg,
    LONG_PTR wParam,
    LONG_PTR lParam);
void __RPC_STUB IVideoWindow_NotifyOwnerMessage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_SetWindowPosition_Proxy(
    IVideoWindow* This,
    long Left,
    long Top,
    long Width,
    long Height);
void __RPC_STUB IVideoWindow_SetWindowPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_GetWindowPosition_Proxy(
    IVideoWindow* This,
    long *pLeft,
    long *pTop,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IVideoWindow_GetWindowPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_GetMinIdealImageSize_Proxy(
    IVideoWindow* This,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IVideoWindow_GetMinIdealImageSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_GetMaxIdealImageSize_Proxy(
    IVideoWindow* This,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IVideoWindow_GetMaxIdealImageSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_GetRestorePosition_Proxy(
    IVideoWindow* This,
    long *pLeft,
    long *pTop,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IVideoWindow_GetRestorePosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_HideCursor_Proxy(
    IVideoWindow* This,
    long HideCursor);
void __RPC_STUB IVideoWindow_HideCursor_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVideoWindow_IsCursorHidden_Proxy(
    IVideoWindow* This,
    long *CursorHidden);
void __RPC_STUB IVideoWindow_IsCursorHidden_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVideoWindow_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IBasicVideo interface
 */
#ifndef __IBasicVideo_INTERFACE_DEFINED__
#define __IBasicVideo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IBasicVideo, 0x56a868b5, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IBasicVideo : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_AvgTimePerFrame(
        REFTIME *pAvgTimePerFrame) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_BitRate(
        long *pBitRate) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_BitErrorRate(
        long *pBitErrorRate) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_VideoWidth(
        long *pVideoWidth) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_VideoHeight(
        long *pVideoHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_SourceLeft(
        long SourceLeft) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_SourceLeft(
        long *pSourceLeft) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_SourceWidth(
        long SourceWidth) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_SourceWidth(
        long *pSourceWidth) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_SourceTop(
        long SourceTop) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_SourceTop(
        long *pSourceTop) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_SourceHeight(
        long SourceHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_SourceHeight(
        long *pSourceHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_DestinationLeft(
        long DestinationLeft) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_DestinationLeft(
        long *pDestinationLeft) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_DestinationWidth(
        long DestinationWidth) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_DestinationWidth(
        long *pDestinationWidth) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_DestinationTop(
        long DestinationTop) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_DestinationTop(
        long *pDestinationTop) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_DestinationHeight(
        long DestinationHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_DestinationHeight(
        long *pDestinationHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSourcePosition(
        long Left,
        long Top,
        long Width,
        long Height) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSourcePosition(
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDefaultSourcePosition(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDestinationPosition(
        long Left,
        long Top,
        long Width,
        long Height) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDestinationPosition(
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDefaultDestinationPosition(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVideoSize(
        long *pWidth,
        long *pHeight) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVideoPaletteEntries(
        long StartIndex,
        long Entries,
        long *pRetrieved,
        long *pPalette) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentImage(
        long *pBufferSize,
        long *pDIBImage) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsUsingDefaultSource(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsUsingDefaultDestination(
        ) = 0;

};
#else
typedef struct IBasicVideoVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IBasicVideo* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IBasicVideo* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IBasicVideo* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IBasicVideo* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IBasicVideo methods ***/
    HRESULT (STDMETHODCALLTYPE *get_AvgTimePerFrame)(
        IBasicVideo* This,
        REFTIME *pAvgTimePerFrame);

    HRESULT (STDMETHODCALLTYPE *get_BitRate)(
        IBasicVideo* This,
        long *pBitRate);

    HRESULT (STDMETHODCALLTYPE *get_BitErrorRate)(
        IBasicVideo* This,
        long *pBitErrorRate);

    HRESULT (STDMETHODCALLTYPE *get_VideoWidth)(
        IBasicVideo* This,
        long *pVideoWidth);

    HRESULT (STDMETHODCALLTYPE *get_VideoHeight)(
        IBasicVideo* This,
        long *pVideoHeight);

    HRESULT (STDMETHODCALLTYPE *put_SourceLeft)(
        IBasicVideo* This,
        long SourceLeft);

    HRESULT (STDMETHODCALLTYPE *get_SourceLeft)(
        IBasicVideo* This,
        long *pSourceLeft);

    HRESULT (STDMETHODCALLTYPE *put_SourceWidth)(
        IBasicVideo* This,
        long SourceWidth);

    HRESULT (STDMETHODCALLTYPE *get_SourceWidth)(
        IBasicVideo* This,
        long *pSourceWidth);

    HRESULT (STDMETHODCALLTYPE *put_SourceTop)(
        IBasicVideo* This,
        long SourceTop);

    HRESULT (STDMETHODCALLTYPE *get_SourceTop)(
        IBasicVideo* This,
        long *pSourceTop);

    HRESULT (STDMETHODCALLTYPE *put_SourceHeight)(
        IBasicVideo* This,
        long SourceHeight);

    HRESULT (STDMETHODCALLTYPE *get_SourceHeight)(
        IBasicVideo* This,
        long *pSourceHeight);

    HRESULT (STDMETHODCALLTYPE *put_DestinationLeft)(
        IBasicVideo* This,
        long DestinationLeft);

    HRESULT (STDMETHODCALLTYPE *get_DestinationLeft)(
        IBasicVideo* This,
        long *pDestinationLeft);

    HRESULT (STDMETHODCALLTYPE *put_DestinationWidth)(
        IBasicVideo* This,
        long DestinationWidth);

    HRESULT (STDMETHODCALLTYPE *get_DestinationWidth)(
        IBasicVideo* This,
        long *pDestinationWidth);

    HRESULT (STDMETHODCALLTYPE *put_DestinationTop)(
        IBasicVideo* This,
        long DestinationTop);

    HRESULT (STDMETHODCALLTYPE *get_DestinationTop)(
        IBasicVideo* This,
        long *pDestinationTop);

    HRESULT (STDMETHODCALLTYPE *put_DestinationHeight)(
        IBasicVideo* This,
        long DestinationHeight);

    HRESULT (STDMETHODCALLTYPE *get_DestinationHeight)(
        IBasicVideo* This,
        long *pDestinationHeight);

    HRESULT (STDMETHODCALLTYPE *SetSourcePosition)(
        IBasicVideo* This,
        long Left,
        long Top,
        long Width,
        long Height);

    HRESULT (STDMETHODCALLTYPE *GetSourcePosition)(
        IBasicVideo* This,
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *SetDefaultSourcePosition)(
        IBasicVideo* This);

    HRESULT (STDMETHODCALLTYPE *SetDestinationPosition)(
        IBasicVideo* This,
        long Left,
        long Top,
        long Width,
        long Height);

    HRESULT (STDMETHODCALLTYPE *GetDestinationPosition)(
        IBasicVideo* This,
        long *pLeft,
        long *pTop,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *SetDefaultDestinationPosition)(
        IBasicVideo* This);

    HRESULT (STDMETHODCALLTYPE *GetVideoSize)(
        IBasicVideo* This,
        long *pWidth,
        long *pHeight);

    HRESULT (STDMETHODCALLTYPE *GetVideoPaletteEntries)(
        IBasicVideo* This,
        long StartIndex,
        long Entries,
        long *pRetrieved,
        long *pPalette);

    HRESULT (STDMETHODCALLTYPE *GetCurrentImage)(
        IBasicVideo* This,
        long *pBufferSize,
        long *pDIBImage);

    HRESULT (STDMETHODCALLTYPE *IsUsingDefaultSource)(
        IBasicVideo* This);

    HRESULT (STDMETHODCALLTYPE *IsUsingDefaultDestination)(
        IBasicVideo* This);

    END_INTERFACE
} IBasicVideoVtbl;
interface IBasicVideo {
    CONST_VTBL IBasicVideoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IBasicVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IBasicVideo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IBasicVideo_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IBasicVideo_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IBasicVideo_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IBasicVideo_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IBasicVideo_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IBasicVideo methods ***/
#define IBasicVideo_get_AvgTimePerFrame(p,a) (p)->lpVtbl->get_AvgTimePerFrame(p,a)
#define IBasicVideo_get_BitRate(p,a) (p)->lpVtbl->get_BitRate(p,a)
#define IBasicVideo_get_BitErrorRate(p,a) (p)->lpVtbl->get_BitErrorRate(p,a)
#define IBasicVideo_get_VideoWidth(p,a) (p)->lpVtbl->get_VideoWidth(p,a)
#define IBasicVideo_get_VideoHeight(p,a) (p)->lpVtbl->get_VideoHeight(p,a)
#define IBasicVideo_put_SourceLeft(p,a) (p)->lpVtbl->put_SourceLeft(p,a)
#define IBasicVideo_get_SourceLeft(p,a) (p)->lpVtbl->get_SourceLeft(p,a)
#define IBasicVideo_put_SourceWidth(p,a) (p)->lpVtbl->put_SourceWidth(p,a)
#define IBasicVideo_get_SourceWidth(p,a) (p)->lpVtbl->get_SourceWidth(p,a)
#define IBasicVideo_put_SourceTop(p,a) (p)->lpVtbl->put_SourceTop(p,a)
#define IBasicVideo_get_SourceTop(p,a) (p)->lpVtbl->get_SourceTop(p,a)
#define IBasicVideo_put_SourceHeight(p,a) (p)->lpVtbl->put_SourceHeight(p,a)
#define IBasicVideo_get_SourceHeight(p,a) (p)->lpVtbl->get_SourceHeight(p,a)
#define IBasicVideo_put_DestinationLeft(p,a) (p)->lpVtbl->put_DestinationLeft(p,a)
#define IBasicVideo_get_DestinationLeft(p,a) (p)->lpVtbl->get_DestinationLeft(p,a)
#define IBasicVideo_put_DestinationWidth(p,a) (p)->lpVtbl->put_DestinationWidth(p,a)
#define IBasicVideo_get_DestinationWidth(p,a) (p)->lpVtbl->get_DestinationWidth(p,a)
#define IBasicVideo_put_DestinationTop(p,a) (p)->lpVtbl->put_DestinationTop(p,a)
#define IBasicVideo_get_DestinationTop(p,a) (p)->lpVtbl->get_DestinationTop(p,a)
#define IBasicVideo_put_DestinationHeight(p,a) (p)->lpVtbl->put_DestinationHeight(p,a)
#define IBasicVideo_get_DestinationHeight(p,a) (p)->lpVtbl->get_DestinationHeight(p,a)
#define IBasicVideo_SetSourcePosition(p,a,b,c,d) (p)->lpVtbl->SetSourcePosition(p,a,b,c,d)
#define IBasicVideo_GetSourcePosition(p,a,b,c,d) (p)->lpVtbl->GetSourcePosition(p,a,b,c,d)
#define IBasicVideo_SetDefaultSourcePosition(p) (p)->lpVtbl->SetDefaultSourcePosition(p)
#define IBasicVideo_SetDestinationPosition(p,a,b,c,d) (p)->lpVtbl->SetDestinationPosition(p,a,b,c,d)
#define IBasicVideo_GetDestinationPosition(p,a,b,c,d) (p)->lpVtbl->GetDestinationPosition(p,a,b,c,d)
#define IBasicVideo_SetDefaultDestinationPosition(p) (p)->lpVtbl->SetDefaultDestinationPosition(p)
#define IBasicVideo_GetVideoSize(p,a,b) (p)->lpVtbl->GetVideoSize(p,a,b)
#define IBasicVideo_GetVideoPaletteEntries(p,a,b,c,d) (p)->lpVtbl->GetVideoPaletteEntries(p,a,b,c,d)
#define IBasicVideo_GetCurrentImage(p,a,b) (p)->lpVtbl->GetCurrentImage(p,a,b)
#define IBasicVideo_IsUsingDefaultSource(p) (p)->lpVtbl->IsUsingDefaultSource(p)
#define IBasicVideo_IsUsingDefaultDestination(p) (p)->lpVtbl->IsUsingDefaultDestination(p)
#endif

#endif

HRESULT CALLBACK IBasicVideo_get_AvgTimePerFrame_Proxy(
    IBasicVideo* This,
    REFTIME *pAvgTimePerFrame);
void __RPC_STUB IBasicVideo_get_AvgTimePerFrame_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_BitRate_Proxy(
    IBasicVideo* This,
    long *pBitRate);
void __RPC_STUB IBasicVideo_get_BitRate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_BitErrorRate_Proxy(
    IBasicVideo* This,
    long *pBitErrorRate);
void __RPC_STUB IBasicVideo_get_BitErrorRate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_VideoWidth_Proxy(
    IBasicVideo* This,
    long *pVideoWidth);
void __RPC_STUB IBasicVideo_get_VideoWidth_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_VideoHeight_Proxy(
    IBasicVideo* This,
    long *pVideoHeight);
void __RPC_STUB IBasicVideo_get_VideoHeight_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_SourceLeft_Proxy(
    IBasicVideo* This,
    long SourceLeft);
void __RPC_STUB IBasicVideo_put_SourceLeft_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_SourceLeft_Proxy(
    IBasicVideo* This,
    long *pSourceLeft);
void __RPC_STUB IBasicVideo_get_SourceLeft_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_SourceWidth_Proxy(
    IBasicVideo* This,
    long SourceWidth);
void __RPC_STUB IBasicVideo_put_SourceWidth_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_SourceWidth_Proxy(
    IBasicVideo* This,
    long *pSourceWidth);
void __RPC_STUB IBasicVideo_get_SourceWidth_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_SourceTop_Proxy(
    IBasicVideo* This,
    long SourceTop);
void __RPC_STUB IBasicVideo_put_SourceTop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_SourceTop_Proxy(
    IBasicVideo* This,
    long *pSourceTop);
void __RPC_STUB IBasicVideo_get_SourceTop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_SourceHeight_Proxy(
    IBasicVideo* This,
    long SourceHeight);
void __RPC_STUB IBasicVideo_put_SourceHeight_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_SourceHeight_Proxy(
    IBasicVideo* This,
    long *pSourceHeight);
void __RPC_STUB IBasicVideo_get_SourceHeight_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_DestinationLeft_Proxy(
    IBasicVideo* This,
    long DestinationLeft);
void __RPC_STUB IBasicVideo_put_DestinationLeft_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_DestinationLeft_Proxy(
    IBasicVideo* This,
    long *pDestinationLeft);
void __RPC_STUB IBasicVideo_get_DestinationLeft_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_DestinationWidth_Proxy(
    IBasicVideo* This,
    long DestinationWidth);
void __RPC_STUB IBasicVideo_put_DestinationWidth_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_DestinationWidth_Proxy(
    IBasicVideo* This,
    long *pDestinationWidth);
void __RPC_STUB IBasicVideo_get_DestinationWidth_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_DestinationTop_Proxy(
    IBasicVideo* This,
    long DestinationTop);
void __RPC_STUB IBasicVideo_put_DestinationTop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_DestinationTop_Proxy(
    IBasicVideo* This,
    long *pDestinationTop);
void __RPC_STUB IBasicVideo_get_DestinationTop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_put_DestinationHeight_Proxy(
    IBasicVideo* This,
    long DestinationHeight);
void __RPC_STUB IBasicVideo_put_DestinationHeight_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_get_DestinationHeight_Proxy(
    IBasicVideo* This,
    long *pDestinationHeight);
void __RPC_STUB IBasicVideo_get_DestinationHeight_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_SetSourcePosition_Proxy(
    IBasicVideo* This,
    long Left,
    long Top,
    long Width,
    long Height);
void __RPC_STUB IBasicVideo_SetSourcePosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_GetSourcePosition_Proxy(
    IBasicVideo* This,
    long *pLeft,
    long *pTop,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IBasicVideo_GetSourcePosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_SetDefaultSourcePosition_Proxy(
    IBasicVideo* This);
void __RPC_STUB IBasicVideo_SetDefaultSourcePosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_SetDestinationPosition_Proxy(
    IBasicVideo* This,
    long Left,
    long Top,
    long Width,
    long Height);
void __RPC_STUB IBasicVideo_SetDestinationPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_GetDestinationPosition_Proxy(
    IBasicVideo* This,
    long *pLeft,
    long *pTop,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IBasicVideo_GetDestinationPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_SetDefaultDestinationPosition_Proxy(
    IBasicVideo* This);
void __RPC_STUB IBasicVideo_SetDefaultDestinationPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_GetVideoSize_Proxy(
    IBasicVideo* This,
    long *pWidth,
    long *pHeight);
void __RPC_STUB IBasicVideo_GetVideoSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_GetVideoPaletteEntries_Proxy(
    IBasicVideo* This,
    long StartIndex,
    long Entries,
    long *pRetrieved,
    long *pPalette);
void __RPC_STUB IBasicVideo_GetVideoPaletteEntries_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_GetCurrentImage_Proxy(
    IBasicVideo* This,
    long *pBufferSize,
    long *pDIBImage);
void __RPC_STUB IBasicVideo_GetCurrentImage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_IsUsingDefaultSource_Proxy(
    IBasicVideo* This);
void __RPC_STUB IBasicVideo_IsUsingDefaultSource_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IBasicVideo_IsUsingDefaultDestination_Proxy(
    IBasicVideo* This);
void __RPC_STUB IBasicVideo_IsUsingDefaultDestination_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IBasicVideo_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMediaEvent interface
 */
#ifndef __IMediaEvent_INTERFACE_DEFINED__
#define __IMediaEvent_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMediaEvent, 0x56a868b6, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMediaEvent : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE GetEventHandle(
        OAEVENT *hEvent) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetEvent(
        long *lEventCode,
        LONG_PTR *lParam1,
        LONG_PTR *lParam2,
        long msTimeout) = 0;

    virtual HRESULT STDMETHODCALLTYPE WaitForCompletion(
        long msTimeout,
        long *pEvCode) = 0;

    virtual HRESULT STDMETHODCALLTYPE CancelDefaultHandling(
        long lEvCode) = 0;

    virtual HRESULT STDMETHODCALLTYPE RestoreDefaultHandling(
        long lEvCode) = 0;

    virtual HRESULT STDMETHODCALLTYPE FreeEventParams(
        long lEvCode,
        LONG_PTR lParam1,
        LONG_PTR lParam2) = 0;

};
#else
typedef struct IMediaEventVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IMediaEvent* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IMediaEvent* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IMediaEvent* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMediaEvent* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IMediaEvent methods ***/
    HRESULT (STDMETHODCALLTYPE *GetEventHandle)(
        IMediaEvent* This,
        OAEVENT *hEvent);

    HRESULT (STDMETHODCALLTYPE *GetEvent)(
        IMediaEvent* This,
        long *lEventCode,
        LONG_PTR *lParam1,
        LONG_PTR *lParam2,
        long msTimeout);

    HRESULT (STDMETHODCALLTYPE *WaitForCompletion)(
        IMediaEvent* This,
        long msTimeout,
        long *pEvCode);

    HRESULT (STDMETHODCALLTYPE *CancelDefaultHandling)(
        IMediaEvent* This,
        long lEvCode);

    HRESULT (STDMETHODCALLTYPE *RestoreDefaultHandling)(
        IMediaEvent* This,
        long lEvCode);

    HRESULT (STDMETHODCALLTYPE *FreeEventParams)(
        IMediaEvent* This,
        long lEvCode,
        LONG_PTR lParam1,
        LONG_PTR lParam2);

    END_INTERFACE
} IMediaEventVtbl;
interface IMediaEvent {
    CONST_VTBL IMediaEventVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMediaEvent_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMediaEvent_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMediaEvent_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IMediaEvent_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IMediaEvent_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IMediaEvent_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IMediaEvent_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IMediaEvent methods ***/
#define IMediaEvent_GetEventHandle(p,a) (p)->lpVtbl->GetEventHandle(p,a)
#define IMediaEvent_GetEvent(p,a,b,c,d) (p)->lpVtbl->GetEvent(p,a,b,c,d)
#define IMediaEvent_WaitForCompletion(p,a,b) (p)->lpVtbl->WaitForCompletion(p,a,b)
#define IMediaEvent_CancelDefaultHandling(p,a) (p)->lpVtbl->CancelDefaultHandling(p,a)
#define IMediaEvent_RestoreDefaultHandling(p,a) (p)->lpVtbl->RestoreDefaultHandling(p,a)
#define IMediaEvent_FreeEventParams(p,a,b,c) (p)->lpVtbl->FreeEventParams(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IMediaEvent_GetEventHandle_Proxy(
    IMediaEvent* This,
    OAEVENT *hEvent);
void __RPC_STUB IMediaEvent_GetEventHandle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEvent_GetEvent_Proxy(
    IMediaEvent* This,
    long *lEventCode,
    LONG_PTR *lParam1,
    LONG_PTR *lParam2,
    long msTimeout);
void __RPC_STUB IMediaEvent_GetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEvent_WaitForCompletion_Proxy(
    IMediaEvent* This,
    long msTimeout,
    long *pEvCode);
void __RPC_STUB IMediaEvent_WaitForCompletion_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEvent_CancelDefaultHandling_Proxy(
    IMediaEvent* This,
    long lEvCode);
void __RPC_STUB IMediaEvent_CancelDefaultHandling_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEvent_RestoreDefaultHandling_Proxy(
    IMediaEvent* This,
    long lEvCode);
void __RPC_STUB IMediaEvent_RestoreDefaultHandling_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEvent_FreeEventParams_Proxy(
    IMediaEvent* This,
    long lEvCode,
    LONG_PTR lParam1,
    LONG_PTR lParam2);
void __RPC_STUB IMediaEvent_FreeEventParams_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMediaEvent_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMediaEventEx interface
 */
#ifndef __IMediaEventEx_INTERFACE_DEFINED__
#define __IMediaEventEx_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMediaEventEx, 0x56a868c0, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMediaEventEx : public IMediaEvent
{
    virtual HRESULT STDMETHODCALLTYPE SetNotifyWindow(
        OAHWND hwnd,
        long lMsg,
        LONG_PTR lInstanceData) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetNotifyFlags(
        long lNoNotifyFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNotifyFlags(
        long *lplNoNotifyFlags) = 0;

};
#else
typedef struct IMediaEventExVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IMediaEventEx* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IMediaEventEx* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IMediaEventEx* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMediaEventEx* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IMediaEvent methods ***/
    HRESULT (STDMETHODCALLTYPE *GetEventHandle)(
        IMediaEventEx* This,
        OAEVENT *hEvent);

    HRESULT (STDMETHODCALLTYPE *GetEvent)(
        IMediaEventEx* This,
        long *lEventCode,
        LONG_PTR *lParam1,
        LONG_PTR *lParam2,
        long msTimeout);

    HRESULT (STDMETHODCALLTYPE *WaitForCompletion)(
        IMediaEventEx* This,
        long msTimeout,
        long *pEvCode);

    HRESULT (STDMETHODCALLTYPE *CancelDefaultHandling)(
        IMediaEventEx* This,
        long lEvCode);

    HRESULT (STDMETHODCALLTYPE *RestoreDefaultHandling)(
        IMediaEventEx* This,
        long lEvCode);

    HRESULT (STDMETHODCALLTYPE *FreeEventParams)(
        IMediaEventEx* This,
        long lEvCode,
        LONG_PTR lParam1,
        LONG_PTR lParam2);

    /*** IMediaEventEx methods ***/
    HRESULT (STDMETHODCALLTYPE *SetNotifyWindow)(
        IMediaEventEx* This,
        OAHWND hwnd,
        long lMsg,
        LONG_PTR lInstanceData);

    HRESULT (STDMETHODCALLTYPE *SetNotifyFlags)(
        IMediaEventEx* This,
        long lNoNotifyFlags);

    HRESULT (STDMETHODCALLTYPE *GetNotifyFlags)(
        IMediaEventEx* This,
        long *lplNoNotifyFlags);

    END_INTERFACE
} IMediaEventExVtbl;
interface IMediaEventEx {
    CONST_VTBL IMediaEventExVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMediaEventEx_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMediaEventEx_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMediaEventEx_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IMediaEventEx_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IMediaEventEx_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IMediaEventEx_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IMediaEventEx_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IMediaEvent methods ***/
#define IMediaEventEx_GetEventHandle(p,a) (p)->lpVtbl->GetEventHandle(p,a)
#define IMediaEventEx_GetEvent(p,a,b,c,d) (p)->lpVtbl->GetEvent(p,a,b,c,d)
#define IMediaEventEx_WaitForCompletion(p,a,b) (p)->lpVtbl->WaitForCompletion(p,a,b)
#define IMediaEventEx_CancelDefaultHandling(p,a) (p)->lpVtbl->CancelDefaultHandling(p,a)
#define IMediaEventEx_RestoreDefaultHandling(p,a) (p)->lpVtbl->RestoreDefaultHandling(p,a)
#define IMediaEventEx_FreeEventParams(p,a,b,c) (p)->lpVtbl->FreeEventParams(p,a,b,c)
/*** IMediaEventEx methods ***/
#define IMediaEventEx_SetNotifyWindow(p,a,b,c) (p)->lpVtbl->SetNotifyWindow(p,a,b,c)
#define IMediaEventEx_SetNotifyFlags(p,a) (p)->lpVtbl->SetNotifyFlags(p,a)
#define IMediaEventEx_GetNotifyFlags(p,a) (p)->lpVtbl->GetNotifyFlags(p,a)
#endif

#endif

HRESULT CALLBACK IMediaEventEx_SetNotifyWindow_Proxy(
    IMediaEventEx* This,
    OAHWND hwnd,
    long lMsg,
    LONG_PTR lInstanceData);
void __RPC_STUB IMediaEventEx_SetNotifyWindow_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEventEx_SetNotifyFlags_Proxy(
    IMediaEventEx* This,
    long lNoNotifyFlags);
void __RPC_STUB IMediaEventEx_SetNotifyFlags_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaEventEx_GetNotifyFlags_Proxy(
    IMediaEventEx* This,
    long *lplNoNotifyFlags);
void __RPC_STUB IMediaEventEx_GetNotifyFlags_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMediaEventEx_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMediaPosition interface
 */
#ifndef __IMediaPosition_INTERFACE_DEFINED__
#define __IMediaPosition_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMediaPosition, 0x56a868b2, 0x0ad4, 0x11ce, 0xb0,0x3a, 0x00,0x20,0xaf,0x0b,0xa7,0x70);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMediaPosition : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_Duration(
        REFTIME *plength) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_CurrentPosition(
        REFTIME llTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_CurrentPosition(
        REFTIME *pllTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_StopTime(
        REFTIME *pllTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_StopTime(
        REFTIME llTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_PrerollTime(
        REFTIME *pllTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_PrerollTime(
        REFTIME llTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Rate(
        double dRate) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Rate(
        double *pdRate) = 0;

    virtual HRESULT STDMETHODCALLTYPE CanSeekForward(
        LONG *pCanSeekForward) = 0;

    virtual HRESULT STDMETHODCALLTYPE CanSeekBackward(
        LONG *pCanSeekBackward) = 0;

};
#else
typedef struct IMediaPositionVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDispatch methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
        IMediaPosition* This,
        UINT *pctinfo);

    HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
        IMediaPosition* This,
        UINT iTInfo,
        LCID lcid,
        ITypeInfo **ppTInfo);

    HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
        IMediaPosition* This,
        REFIID riid,
        LPOLESTR *rgszNames,
        UINT cNames,
        LCID lcid,
        DISPID *rgDispId);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMediaPosition* This,
        DISPID dispIdMember,
        REFIID riid,
        LCID lcid,
        WORD wFlags,
        DISPPARAMS *pDispParams,
        VARIANT *pVarResult,
        EXCEPINFO *pExcepInfo,
        UINT *puArgErr);

    /*** IMediaPosition methods ***/
    HRESULT (STDMETHODCALLTYPE *get_Duration)(
        IMediaPosition* This,
        REFTIME *plength);

    HRESULT (STDMETHODCALLTYPE *put_CurrentPosition)(
        IMediaPosition* This,
        REFTIME llTime);

    HRESULT (STDMETHODCALLTYPE *get_CurrentPosition)(
        IMediaPosition* This,
        REFTIME *pllTime);

    HRESULT (STDMETHODCALLTYPE *get_StopTime)(
        IMediaPosition* This,
        REFTIME *pllTime);

    HRESULT (STDMETHODCALLTYPE *put_StopTime)(
        IMediaPosition* This,
        REFTIME llTime);

    HRESULT (STDMETHODCALLTYPE *get_PrerollTime)(
        IMediaPosition* This,
        REFTIME *pllTime);

    HRESULT (STDMETHODCALLTYPE *put_PrerollTime)(
        IMediaPosition* This,
        REFTIME llTime);

    HRESULT (STDMETHODCALLTYPE *put_Rate)(
        IMediaPosition* This,
        double dRate);

    HRESULT (STDMETHODCALLTYPE *get_Rate)(
        IMediaPosition* This,
        double *pdRate);

    HRESULT (STDMETHODCALLTYPE *CanSeekForward)(
        IMediaPosition* This,
        LONG *pCanSeekForward);

    HRESULT (STDMETHODCALLTYPE *CanSeekBackward)(
        IMediaPosition* This,
        LONG *pCanSeekBackward);

    END_INTERFACE
} IMediaPositionVtbl;
interface IMediaPosition {
    CONST_VTBL IMediaPositionVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMediaPosition_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMediaPosition_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMediaPosition_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IMediaPosition_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IMediaPosition_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IMediaPosition_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IMediaPosition_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IMediaPosition methods ***/
#define IMediaPosition_get_Duration(p,a) (p)->lpVtbl->get_Duration(p,a)
#define IMediaPosition_put_CurrentPosition(p,a) (p)->lpVtbl->put_CurrentPosition(p,a)
#define IMediaPosition_get_CurrentPosition(p,a) (p)->lpVtbl->get_CurrentPosition(p,a)
#define IMediaPosition_get_StopTime(p,a) (p)->lpVtbl->get_StopTime(p,a)
#define IMediaPosition_put_StopTime(p,a) (p)->lpVtbl->put_StopTime(p,a)
#define IMediaPosition_get_PrerollTime(p,a) (p)->lpVtbl->get_PrerollTime(p,a)
#define IMediaPosition_put_PrerollTime(p,a) (p)->lpVtbl->put_PrerollTime(p,a)
#define IMediaPosition_put_Rate(p,a) (p)->lpVtbl->put_Rate(p,a)
#define IMediaPosition_get_Rate(p,a) (p)->lpVtbl->get_Rate(p,a)
#define IMediaPosition_CanSeekForward(p,a) (p)->lpVtbl->CanSeekForward(p,a)
#define IMediaPosition_CanSeekBackward(p,a) (p)->lpVtbl->CanSeekBackward(p,a)
#endif

#endif

HRESULT CALLBACK IMediaPosition_get_Duration_Proxy(
    IMediaPosition* This,
    REFTIME *plength);
void __RPC_STUB IMediaPosition_get_Duration_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_put_CurrentPosition_Proxy(
    IMediaPosition* This,
    REFTIME llTime);
void __RPC_STUB IMediaPosition_put_CurrentPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_get_CurrentPosition_Proxy(
    IMediaPosition* This,
    REFTIME *pllTime);
void __RPC_STUB IMediaPosition_get_CurrentPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_get_StopTime_Proxy(
    IMediaPosition* This,
    REFTIME *pllTime);
void __RPC_STUB IMediaPosition_get_StopTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_put_StopTime_Proxy(
    IMediaPosition* This,
    REFTIME llTime);
void __RPC_STUB IMediaPosition_put_StopTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_get_PrerollTime_Proxy(
    IMediaPosition* This,
    REFTIME *pllTime);
void __RPC_STUB IMediaPosition_get_PrerollTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_put_PrerollTime_Proxy(
    IMediaPosition* This,
    REFTIME llTime);
void __RPC_STUB IMediaPosition_put_PrerollTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_put_Rate_Proxy(
    IMediaPosition* This,
    double dRate);
void __RPC_STUB IMediaPosition_put_Rate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_get_Rate_Proxy(
    IMediaPosition* This,
    double *pdRate);
void __RPC_STUB IMediaPosition_get_Rate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_CanSeekForward_Proxy(
    IMediaPosition* This,
    LONG *pCanSeekForward);
void __RPC_STUB IMediaPosition_CanSeekForward_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaPosition_CanSeekBackward_Proxy(
    IMediaPosition* This,
    LONG *pCanSeekBackward);
void __RPC_STUB IMediaPosition_CanSeekBackward_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMediaPosition_INTERFACE_DEFINED__ */

/* Begin additional prototypes for all interfaces */

ULONG           __RPC_USER BSTR_UserSize     (ULONG *, ULONG, BSTR *);
unsigned char * __RPC_USER BSTR_UserMarshal  (ULONG *, unsigned char *, BSTR *);
unsigned char * __RPC_USER BSTR_UserUnmarshal(ULONG *, unsigned char *, BSTR *);
void            __RPC_USER BSTR_UserFree     (ULONG *, BSTR *);

/* End additional prototypes */

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_CONTROL_H */
