/*** Autogenerated by WIDL 0.9.22 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

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

/* Begin additional prototypes for all interfaces */

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

/* End additional prototypes */

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