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

#ifndef __WIDL_AXVLC_IDL_H
#define __WIDL_AXVLC_IDL_H
#ifdef __cplusplus
extern "C" {
#endif
#include <oaidl.h>

DEFINE_GUID(LIBID_AXVLC, 0xdf2bbe39, 0x40a8, 0x433b, 0xa2,0x79, 0x07,0x3f,0x48,0xda,0x94,0xb6);

#ifndef __IVLCControl_FWD_DEFINED__
#define __IVLCControl_FWD_DEFINED__
typedef interface IVLCControl IVLCControl;
#endif

#ifndef __IVLCAudio_FWD_DEFINED__
#define __IVLCAudio_FWD_DEFINED__
typedef interface IVLCAudio IVLCAudio;
#endif

#ifndef __IVLCInput_FWD_DEFINED__
#define __IVLCInput_FWD_DEFINED__
typedef interface IVLCInput IVLCInput;
#endif

#ifndef __IVLCLog_FWD_DEFINED__
#define __IVLCLog_FWD_DEFINED__
typedef interface IVLCLog IVLCLog;
#endif

#ifndef __IVLCMessage_FWD_DEFINED__
#define __IVLCMessage_FWD_DEFINED__
typedef interface IVLCMessage IVLCMessage;
#endif

#ifndef __IVLCMessageIterator_FWD_DEFINED__
#define __IVLCMessageIterator_FWD_DEFINED__
typedef interface IVLCMessageIterator IVLCMessageIterator;
#endif

#ifndef __IVLCMessages_FWD_DEFINED__
#define __IVLCMessages_FWD_DEFINED__
typedef interface IVLCMessages IVLCMessages;
#endif

#ifndef __IVLCPlaylist_FWD_DEFINED__
#define __IVLCPlaylist_FWD_DEFINED__
typedef interface IVLCPlaylist IVLCPlaylist;
#endif

#ifndef __IVLCVideo_FWD_DEFINED__
#define __IVLCVideo_FWD_DEFINED__
typedef interface IVLCVideo IVLCVideo;
#endif

#ifndef __IVLCControl2_FWD_DEFINED__
#define __IVLCControl2_FWD_DEFINED__
typedef interface IVLCControl2 IVLCControl2;
#endif

#ifndef __DVLCEvents_FWD_DEFINED__
#define __DVLCEvents_FWD_DEFINED__
typedef interface DVLCEvents DVLCEvents;
#endif

typedef enum VLCPlaylistMode {
    VLCPlayListInsert = 1,
    VLCPlayListInsertAndGo = 9,
    VLCPlayListReplace = 2,
    VLCPlayListReplaceAndGo = 10,
    VLCPlayListAppend = 4,
    VLCPlayListAppendAndGo = 12,
    VLCPlayListCheckInsert = 16
} eVLCPlaylistMode;
#define VLCPlayListEnd (-666)

#define DISPID_Visible (100)

#define DISPID_Playing (101)

#define DISPID_Position (102)

#define DISPID_Time (103)

#define DISPID_Length (104)

#define DISPID_Volume (105)

#define DISPID_MRL (106)

#define DISPID_AutoPlay (107)

#define DISPID_AutoLoop (108)

#define DISPID_StartTime (109)

#define DISPID_BaseURL (110)

/*****************************************************************************
 * IVLCControl interface
 */
#ifndef __IVLCControl_INTERFACE_DEFINED__
#define __IVLCControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCControl, 0xc2fa41d0, 0xb113, 0x476e, 0xac,0x8c, 0x9b,0xd1,0x49,0x99,0xc1,0xc1);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCControl : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_Visible(
        VARIANT_BOOL* visible) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Visible(
        VARIANT_BOOL visible) = 0;

    virtual HRESULT STDMETHODCALLTYPE play(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE pause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Playing(
        VARIANT_BOOL* isPlaying) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Position(
        float* position) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Position(
        float position) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Time(
        int* seconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Time(
        int seconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE shuttle(
        int seconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE fullscreen(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Length(
        int* seconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE playFaster(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE playSlower(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Volume(
        int* volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Volume(
        int volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE toggleMute(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE setVariable(
        BSTR name,
        VARIANT value) = 0;

    virtual HRESULT STDMETHODCALLTYPE getVariable(
        BSTR name,
        VARIANT* value) = 0;

    virtual HRESULT STDMETHODCALLTYPE addTarget(
        BSTR uri,
        VARIANT options,
        enum VLCPlaylistMode mode,
        int position) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_PlaylistIndex(
        int* index) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_PlaylistCount(
        int* index) = 0;

    virtual HRESULT STDMETHODCALLTYPE playlistNext(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE playlistPrev(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE playlistClear(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_VersionInfo(
        BSTR* version) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_MRL(
        BSTR* mrl) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_MRL(
        BSTR mrl) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_AutoPlay(
        VARIANT_BOOL* autoplay) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_AutoPlay(
        VARIANT_BOOL autoplay) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_AutoLoop(
        VARIANT_BOOL* autoloop) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_AutoLoop(
        VARIANT_BOOL autoloop) = 0;

};
#else
typedef struct IVLCControlVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCControl methods ***/
    HRESULT (STDMETHODCALLTYPE *get_Visible)(
        IVLCControl* This,
        VARIANT_BOOL* visible);

    HRESULT (STDMETHODCALLTYPE *put_Visible)(
        IVLCControl* This,
        VARIANT_BOOL visible);

    HRESULT (STDMETHODCALLTYPE *play)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *pause)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *stop)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *get_Playing)(
        IVLCControl* This,
        VARIANT_BOOL* isPlaying);

    HRESULT (STDMETHODCALLTYPE *get_Position)(
        IVLCControl* This,
        float* position);

    HRESULT (STDMETHODCALLTYPE *put_Position)(
        IVLCControl* This,
        float position);

    HRESULT (STDMETHODCALLTYPE *get_Time)(
        IVLCControl* This,
        int* seconds);

    HRESULT (STDMETHODCALLTYPE *put_Time)(
        IVLCControl* This,
        int seconds);

    HRESULT (STDMETHODCALLTYPE *shuttle)(
        IVLCControl* This,
        int seconds);

    HRESULT (STDMETHODCALLTYPE *fullscreen)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *get_Length)(
        IVLCControl* This,
        int* seconds);

    HRESULT (STDMETHODCALLTYPE *playFaster)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *playSlower)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *get_Volume)(
        IVLCControl* This,
        int* volume);

    HRESULT (STDMETHODCALLTYPE *put_Volume)(
        IVLCControl* This,
        int volume);

    HRESULT (STDMETHODCALLTYPE *toggleMute)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *setVariable)(
        IVLCControl* This,
        BSTR name,
        VARIANT value);

    HRESULT (STDMETHODCALLTYPE *getVariable)(
        IVLCControl* This,
        BSTR name,
        VARIANT* value);

    HRESULT (STDMETHODCALLTYPE *addTarget)(
        IVLCControl* This,
        BSTR uri,
        VARIANT options,
        enum VLCPlaylistMode mode,
        int position);

    HRESULT (STDMETHODCALLTYPE *get_PlaylistIndex)(
        IVLCControl* This,
        int* index);

    HRESULT (STDMETHODCALLTYPE *get_PlaylistCount)(
        IVLCControl* This,
        int* index);

    HRESULT (STDMETHODCALLTYPE *playlistNext)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *playlistPrev)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *playlistClear)(
        IVLCControl* This);

    HRESULT (STDMETHODCALLTYPE *get_VersionInfo)(
        IVLCControl* This,
        BSTR* version);

    HRESULT (STDMETHODCALLTYPE *get_MRL)(
        IVLCControl* This,
        BSTR* mrl);

    HRESULT (STDMETHODCALLTYPE *put_MRL)(
        IVLCControl* This,
        BSTR mrl);

    HRESULT (STDMETHODCALLTYPE *get_AutoPlay)(
        IVLCControl* This,
        VARIANT_BOOL* autoplay);

    HRESULT (STDMETHODCALLTYPE *put_AutoPlay)(
        IVLCControl* This,
        VARIANT_BOOL autoplay);

    HRESULT (STDMETHODCALLTYPE *get_AutoLoop)(
        IVLCControl* This,
        VARIANT_BOOL* autoloop);

    HRESULT (STDMETHODCALLTYPE *put_AutoLoop)(
        IVLCControl* This,
        VARIANT_BOOL autoloop);

    END_INTERFACE
} IVLCControlVtbl;
interface IVLCControl {
    const IVLCControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCControl_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCControl_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCControl_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCControl_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCControl_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCControl_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCControl_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCControl methods ***/
#define IVLCControl_get_Visible(p,a) (p)->lpVtbl->get_Visible(p,a)
#define IVLCControl_put_Visible(p,a) (p)->lpVtbl->put_Visible(p,a)
#define IVLCControl_play(p) (p)->lpVtbl->play(p)
#define IVLCControl_pause(p) (p)->lpVtbl->pause(p)
#define IVLCControl_stop(p) (p)->lpVtbl->stop(p)
#define IVLCControl_get_Playing(p,a) (p)->lpVtbl->get_Playing(p,a)
#define IVLCControl_get_Position(p,a) (p)->lpVtbl->get_Position(p,a)
#define IVLCControl_put_Position(p,a) (p)->lpVtbl->put_Position(p,a)
#define IVLCControl_get_Time(p,a) (p)->lpVtbl->get_Time(p,a)
#define IVLCControl_put_Time(p,a) (p)->lpVtbl->put_Time(p,a)
#define IVLCControl_shuttle(p,a) (p)->lpVtbl->shuttle(p,a)
#define IVLCControl_fullscreen(p) (p)->lpVtbl->fullscreen(p)
#define IVLCControl_get_Length(p,a) (p)->lpVtbl->get_Length(p,a)
#define IVLCControl_playFaster(p) (p)->lpVtbl->playFaster(p)
#define IVLCControl_playSlower(p) (p)->lpVtbl->playSlower(p)
#define IVLCControl_get_Volume(p,a) (p)->lpVtbl->get_Volume(p,a)
#define IVLCControl_put_Volume(p,a) (p)->lpVtbl->put_Volume(p,a)
#define IVLCControl_toggleMute(p) (p)->lpVtbl->toggleMute(p)
#define IVLCControl_setVariable(p,a,b) (p)->lpVtbl->setVariable(p,a,b)
#define IVLCControl_getVariable(p,a,b) (p)->lpVtbl->getVariable(p,a,b)
#define IVLCControl_addTarget(p,a,b,c,d) (p)->lpVtbl->addTarget(p,a,b,c,d)
#define IVLCControl_get_PlaylistIndex(p,a) (p)->lpVtbl->get_PlaylistIndex(p,a)
#define IVLCControl_get_PlaylistCount(p,a) (p)->lpVtbl->get_PlaylistCount(p,a)
#define IVLCControl_playlistNext(p) (p)->lpVtbl->playlistNext(p)
#define IVLCControl_playlistPrev(p) (p)->lpVtbl->playlistPrev(p)
#define IVLCControl_playlistClear(p) (p)->lpVtbl->playlistClear(p)
#define IVLCControl_get_VersionInfo(p,a) (p)->lpVtbl->get_VersionInfo(p,a)
#define IVLCControl_get_MRL(p,a) (p)->lpVtbl->get_MRL(p,a)
#define IVLCControl_put_MRL(p,a) (p)->lpVtbl->put_MRL(p,a)
#define IVLCControl_get_AutoPlay(p,a) (p)->lpVtbl->get_AutoPlay(p,a)
#define IVLCControl_put_AutoPlay(p,a) (p)->lpVtbl->put_AutoPlay(p,a)
#define IVLCControl_get_AutoLoop(p,a) (p)->lpVtbl->get_AutoLoop(p,a)
#define IVLCControl_put_AutoLoop(p,a) (p)->lpVtbl->put_AutoLoop(p,a)
#endif

#endif

HRESULT CALLBACK IVLCControl_get_Visible_Proxy(
    IVLCControl* This,
    VARIANT_BOOL* visible);
void __RPC_STUB IVLCControl_get_Visible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_Visible_Proxy(
    IVLCControl* This,
    VARIANT_BOOL visible);
void __RPC_STUB IVLCControl_put_Visible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_play_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_play_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_pause_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_pause_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_stop_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_stop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_Playing_Proxy(
    IVLCControl* This,
    VARIANT_BOOL* isPlaying);
void __RPC_STUB IVLCControl_get_Playing_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_Position_Proxy(
    IVLCControl* This,
    float* position);
void __RPC_STUB IVLCControl_get_Position_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_Position_Proxy(
    IVLCControl* This,
    float position);
void __RPC_STUB IVLCControl_put_Position_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_Time_Proxy(
    IVLCControl* This,
    int* seconds);
void __RPC_STUB IVLCControl_get_Time_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_Time_Proxy(
    IVLCControl* This,
    int seconds);
void __RPC_STUB IVLCControl_put_Time_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_shuttle_Proxy(
    IVLCControl* This,
    int seconds);
void __RPC_STUB IVLCControl_shuttle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_fullscreen_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_fullscreen_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_Length_Proxy(
    IVLCControl* This,
    int* seconds);
void __RPC_STUB IVLCControl_get_Length_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_playFaster_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_playFaster_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_playSlower_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_playSlower_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_Volume_Proxy(
    IVLCControl* This,
    int* volume);
void __RPC_STUB IVLCControl_get_Volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_Volume_Proxy(
    IVLCControl* This,
    int volume);
void __RPC_STUB IVLCControl_put_Volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_toggleMute_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_toggleMute_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_setVariable_Proxy(
    IVLCControl* This,
    BSTR name,
    VARIANT value);
void __RPC_STUB IVLCControl_setVariable_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_getVariable_Proxy(
    IVLCControl* This,
    BSTR name,
    VARIANT* value);
void __RPC_STUB IVLCControl_getVariable_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_addTarget_Proxy(
    IVLCControl* This,
    BSTR uri,
    VARIANT options,
    enum VLCPlaylistMode mode,
    int position);
void __RPC_STUB IVLCControl_addTarget_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_PlaylistIndex_Proxy(
    IVLCControl* This,
    int* index);
void __RPC_STUB IVLCControl_get_PlaylistIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_PlaylistCount_Proxy(
    IVLCControl* This,
    int* index);
void __RPC_STUB IVLCControl_get_PlaylistCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_playlistNext_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_playlistNext_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_playlistPrev_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_playlistPrev_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_playlistClear_Proxy(
    IVLCControl* This);
void __RPC_STUB IVLCControl_playlistClear_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_VersionInfo_Proxy(
    IVLCControl* This,
    BSTR* version);
void __RPC_STUB IVLCControl_get_VersionInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_MRL_Proxy(
    IVLCControl* This,
    BSTR* mrl);
void __RPC_STUB IVLCControl_get_MRL_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_MRL_Proxy(
    IVLCControl* This,
    BSTR mrl);
void __RPC_STUB IVLCControl_put_MRL_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_AutoPlay_Proxy(
    IVLCControl* This,
    VARIANT_BOOL* autoplay);
void __RPC_STUB IVLCControl_get_AutoPlay_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_AutoPlay_Proxy(
    IVLCControl* This,
    VARIANT_BOOL autoplay);
void __RPC_STUB IVLCControl_put_AutoPlay_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_get_AutoLoop_Proxy(
    IVLCControl* This,
    VARIANT_BOOL* autoloop);
void __RPC_STUB IVLCControl_get_AutoLoop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl_put_AutoLoop_Proxy(
    IVLCControl* This,
    VARIANT_BOOL autoloop);
void __RPC_STUB IVLCControl_put_AutoLoop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCControl_INTERFACE_DEFINED__ */

#define DISPID_PlayEvent (100)

#define DISPID_PauseEvent (101)

#define DISPID_StopEvent (102)

/*****************************************************************************
 * DVLCEvents dispinterface
 */
#ifndef __DVLCEvents_DISPINTERFACE_DEFINED__
#define __DVLCEvents_DISPINTERFACE_DEFINED__

DEFINE_GUID(DIID_DVLCEvents, 0xdf48072f, 0x5ef8, 0x434e, 0x9b,0x40, 0xe2,0xf3,0xae,0x75,0x9b,0x5f);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface DVLCEvents : public IDispatch
{
};
#else
typedef struct DVLCEventsVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    END_INTERFACE
} DVLCEventsVtbl;
interface DVLCEvents {
    const DVLCEventsVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define DVLCEvents_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define DVLCEvents_AddRef(p) (p)->lpVtbl->AddRef(p)
#define DVLCEvents_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define DVLCEvents_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define DVLCEvents_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define DVLCEvents_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define DVLCEvents_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
#endif

#endif

#endif  /* __DVLCEvents_DISPINTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCAudio interface
 */
#ifndef __IVLCAudio_INTERFACE_DEFINED__
#define __IVLCAudio_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCAudio, 0x9e0bd17b, 0x2d3c, 0x4656, 0xb9,0x4d, 0x03,0x08,0x4f,0x3f,0xd9,0xd4);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCAudio : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_mute(
        VARIANT_BOOL* muted) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_mute(
        VARIANT_BOOL muted) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_volume(
        long* volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_volume(
        long volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE toggleMute(
        ) = 0;

};
#else
typedef struct IVLCAudioVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCAudio methods ***/
    HRESULT (STDMETHODCALLTYPE *get_mute)(
        IVLCAudio* This,
        VARIANT_BOOL* muted);

    HRESULT (STDMETHODCALLTYPE *put_mute)(
        IVLCAudio* This,
        VARIANT_BOOL muted);

    HRESULT (STDMETHODCALLTYPE *get_volume)(
        IVLCAudio* This,
        long* volume);

    HRESULT (STDMETHODCALLTYPE *put_volume)(
        IVLCAudio* This,
        long volume);

    HRESULT (STDMETHODCALLTYPE *toggleMute)(
        IVLCAudio* This);

    END_INTERFACE
} IVLCAudioVtbl;
interface IVLCAudio {
    const IVLCAudioVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCAudio_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCAudio_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCAudio_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCAudio_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCAudio_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCAudio_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCAudio_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCAudio methods ***/
#define IVLCAudio_get_mute(p,a) (p)->lpVtbl->get_mute(p,a)
#define IVLCAudio_put_mute(p,a) (p)->lpVtbl->put_mute(p,a)
#define IVLCAudio_get_volume(p,a) (p)->lpVtbl->get_volume(p,a)
#define IVLCAudio_put_volume(p,a) (p)->lpVtbl->put_volume(p,a)
#define IVLCAudio_toggleMute(p) (p)->lpVtbl->toggleMute(p)
#endif

#endif

HRESULT CALLBACK IVLCAudio_get_mute_Proxy(
    IVLCAudio* This,
    VARIANT_BOOL* muted);
void __RPC_STUB IVLCAudio_get_mute_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCAudio_put_mute_Proxy(
    IVLCAudio* This,
    VARIANT_BOOL muted);
void __RPC_STUB IVLCAudio_put_mute_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCAudio_get_volume_Proxy(
    IVLCAudio* This,
    long* volume);
void __RPC_STUB IVLCAudio_get_volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCAudio_put_volume_Proxy(
    IVLCAudio* This,
    long volume);
void __RPC_STUB IVLCAudio_put_volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCAudio_toggleMute_Proxy(
    IVLCAudio* This);
void __RPC_STUB IVLCAudio_toggleMute_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCAudio_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCInput interface
 */
#ifndef __IVLCInput_INTERFACE_DEFINED__
#define __IVLCInput_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCInput, 0x49e0dbd1, 0x9440, 0x466c, 0x9c,0x97, 0x95,0xc6,0x71,0x90,0xc6,0x03);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCInput : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_length(
        double* length) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_position(
        double* position) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_position(
        double position) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_time(
        double* time) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_time(
        double time) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_state(
        long* state) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_rate(
        double* rate) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_rate(
        double rate) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_fps(
        double* fps) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_hasVout(
        VARIANT_BOOL* hasVout) = 0;

};
#else
typedef struct IVLCInputVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCInput methods ***/
    HRESULT (STDMETHODCALLTYPE *get_length)(
        IVLCInput* This,
        double* length);

    HRESULT (STDMETHODCALLTYPE *get_position)(
        IVLCInput* This,
        double* position);

    HRESULT (STDMETHODCALLTYPE *put_position)(
        IVLCInput* This,
        double position);

    HRESULT (STDMETHODCALLTYPE *get_time)(
        IVLCInput* This,
        double* time);

    HRESULT (STDMETHODCALLTYPE *put_time)(
        IVLCInput* This,
        double time);

    HRESULT (STDMETHODCALLTYPE *get_state)(
        IVLCInput* This,
        long* state);

    HRESULT (STDMETHODCALLTYPE *get_rate)(
        IVLCInput* This,
        double* rate);

    HRESULT (STDMETHODCALLTYPE *put_rate)(
        IVLCInput* This,
        double rate);

    HRESULT (STDMETHODCALLTYPE *get_fps)(
        IVLCInput* This,
        double* fps);

    HRESULT (STDMETHODCALLTYPE *get_hasVout)(
        IVLCInput* This,
        VARIANT_BOOL* hasVout);

    END_INTERFACE
} IVLCInputVtbl;
interface IVLCInput {
    const IVLCInputVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCInput_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCInput_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCInput_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCInput_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCInput_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCInput_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCInput_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCInput methods ***/
#define IVLCInput_get_length(p,a) (p)->lpVtbl->get_length(p,a)
#define IVLCInput_get_position(p,a) (p)->lpVtbl->get_position(p,a)
#define IVLCInput_put_position(p,a) (p)->lpVtbl->put_position(p,a)
#define IVLCInput_get_time(p,a) (p)->lpVtbl->get_time(p,a)
#define IVLCInput_put_time(p,a) (p)->lpVtbl->put_time(p,a)
#define IVLCInput_get_state(p,a) (p)->lpVtbl->get_state(p,a)
#define IVLCInput_get_rate(p,a) (p)->lpVtbl->get_rate(p,a)
#define IVLCInput_put_rate(p,a) (p)->lpVtbl->put_rate(p,a)
#define IVLCInput_get_fps(p,a) (p)->lpVtbl->get_fps(p,a)
#define IVLCInput_get_hasVout(p,a) (p)->lpVtbl->get_hasVout(p,a)
#endif

#endif

HRESULT CALLBACK IVLCInput_get_length_Proxy(
    IVLCInput* This,
    double* length);
void __RPC_STUB IVLCInput_get_length_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_position_Proxy(
    IVLCInput* This,
    double* position);
void __RPC_STUB IVLCInput_get_position_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_put_position_Proxy(
    IVLCInput* This,
    double position);
void __RPC_STUB IVLCInput_put_position_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_time_Proxy(
    IVLCInput* This,
    double* time);
void __RPC_STUB IVLCInput_get_time_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_put_time_Proxy(
    IVLCInput* This,
    double time);
void __RPC_STUB IVLCInput_put_time_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_state_Proxy(
    IVLCInput* This,
    long* state);
void __RPC_STUB IVLCInput_get_state_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_rate_Proxy(
    IVLCInput* This,
    double* rate);
void __RPC_STUB IVLCInput_get_rate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_put_rate_Proxy(
    IVLCInput* This,
    double rate);
void __RPC_STUB IVLCInput_put_rate_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_fps_Proxy(
    IVLCInput* This,
    double* fps);
void __RPC_STUB IVLCInput_get_fps_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_hasVout_Proxy(
    IVLCInput* This,
    VARIANT_BOOL* hasVout);
void __RPC_STUB IVLCInput_get_hasVout_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCInput_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCMessage interface
 */
#ifndef __IVLCMessage_INTERFACE_DEFINED__
#define __IVLCMessage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCMessage, 0x9ed00afa, 0x7bcd, 0x4fff, 0x8d,0x48, 0x7d,0xd4,0xdb,0x2c,0x80,0x0d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCMessage : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get__Value(
        VARIANT* message) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_severity(
        long* level) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_type(
        BSTR* type) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_name(
        BSTR* name) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_header(
        BSTR* header) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_message(
        BSTR* message) = 0;

};
#else
typedef struct IVLCMessageVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCMessage methods ***/
    HRESULT (STDMETHODCALLTYPE *get__Value)(
        IVLCMessage* This,
        VARIANT* message);

    HRESULT (STDMETHODCALLTYPE *get_severity)(
        IVLCMessage* This,
        long* level);

    HRESULT (STDMETHODCALLTYPE *get_type)(
        IVLCMessage* This,
        BSTR* type);

    HRESULT (STDMETHODCALLTYPE *get_name)(
        IVLCMessage* This,
        BSTR* name);

    HRESULT (STDMETHODCALLTYPE *get_header)(
        IVLCMessage* This,
        BSTR* header);

    HRESULT (STDMETHODCALLTYPE *get_message)(
        IVLCMessage* This,
        BSTR* message);

    END_INTERFACE
} IVLCMessageVtbl;
interface IVLCMessage {
    const IVLCMessageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCMessage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCMessage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCMessage_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCMessage_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCMessage_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCMessage_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCMessage_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCMessage methods ***/
#define IVLCMessage_get__Value(p,a) (p)->lpVtbl->get__Value(p,a)
#define IVLCMessage_get_severity(p,a) (p)->lpVtbl->get_severity(p,a)
#define IVLCMessage_get_type(p,a) (p)->lpVtbl->get_type(p,a)
#define IVLCMessage_get_name(p,a) (p)->lpVtbl->get_name(p,a)
#define IVLCMessage_get_header(p,a) (p)->lpVtbl->get_header(p,a)
#define IVLCMessage_get_message(p,a) (p)->lpVtbl->get_message(p,a)
#endif

#endif

HRESULT CALLBACK IVLCMessage_get__Value_Proxy(
    IVLCMessage* This,
    VARIANT* message);
void __RPC_STUB IVLCMessage_get__Value_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessage_get_severity_Proxy(
    IVLCMessage* This,
    long* level);
void __RPC_STUB IVLCMessage_get_severity_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessage_get_type_Proxy(
    IVLCMessage* This,
    BSTR* type);
void __RPC_STUB IVLCMessage_get_type_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessage_get_name_Proxy(
    IVLCMessage* This,
    BSTR* name);
void __RPC_STUB IVLCMessage_get_name_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessage_get_header_Proxy(
    IVLCMessage* This,
    BSTR* header);
void __RPC_STUB IVLCMessage_get_header_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessage_get_message_Proxy(
    IVLCMessage* This,
    BSTR* message);
void __RPC_STUB IVLCMessage_get_message_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCMessage_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCMessageIterator interface
 */
#ifndef __IVLCMessageIterator_INTERFACE_DEFINED__
#define __IVLCMessageIterator_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCMessageIterator, 0x15179cd8, 0xcc12, 0x4242, 0xa5,0x8e, 0xe4,0x12,0x21,0x7f,0xf3,0x43);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCMessageIterator : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_hasNext(
        VARIANT_BOOL* hasNext) = 0;

    virtual HRESULT STDMETHODCALLTYPE next(
        IVLCMessage** msg) = 0;

};
#else
typedef struct IVLCMessageIteratorVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCMessageIterator methods ***/
    HRESULT (STDMETHODCALLTYPE *get_hasNext)(
        IVLCMessageIterator* This,
        VARIANT_BOOL* hasNext);

    HRESULT (STDMETHODCALLTYPE *next)(
        IVLCMessageIterator* This,
        IVLCMessage** msg);

    END_INTERFACE
} IVLCMessageIteratorVtbl;
interface IVLCMessageIterator {
    const IVLCMessageIteratorVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCMessageIterator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCMessageIterator_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCMessageIterator_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCMessageIterator_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCMessageIterator_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCMessageIterator_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCMessageIterator_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCMessageIterator methods ***/
#define IVLCMessageIterator_get_hasNext(p,a) (p)->lpVtbl->get_hasNext(p,a)
#define IVLCMessageIterator_next(p,a) (p)->lpVtbl->next(p,a)
#endif

#endif

HRESULT CALLBACK IVLCMessageIterator_get_hasNext_Proxy(
    IVLCMessageIterator* This,
    VARIANT_BOOL* hasNext);
void __RPC_STUB IVLCMessageIterator_get_hasNext_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessageIterator_next_Proxy(
    IVLCMessageIterator* This,
    IVLCMessage** msg);
void __RPC_STUB IVLCMessageIterator_next_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCMessageIterator_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCMessages interface
 */
#ifndef __IVLCMessages_INTERFACE_DEFINED__
#define __IVLCMessages_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCMessages, 0x6c5ce55d, 0x2d6c, 0x4aad, 0x82,0x99, 0xc6,0x2d,0x23,0x71,0xf1,0x06);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCMessages : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get__NewEnum(
        IUnknown** _NewEnum) = 0;

    virtual HRESULT STDMETHODCALLTYPE clear(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_count(
        long* count) = 0;

    virtual HRESULT STDMETHODCALLTYPE iterator(
        IVLCMessageIterator** iter) = 0;

};
#else
typedef struct IVLCMessagesVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCMessages methods ***/
    HRESULT (STDMETHODCALLTYPE *get__NewEnum)(
        IVLCMessages* This,
        IUnknown** _NewEnum);

    HRESULT (STDMETHODCALLTYPE *clear)(
        IVLCMessages* This);

    HRESULT (STDMETHODCALLTYPE *get_count)(
        IVLCMessages* This,
        long* count);

    HRESULT (STDMETHODCALLTYPE *iterator)(
        IVLCMessages* This,
        IVLCMessageIterator** iter);

    END_INTERFACE
} IVLCMessagesVtbl;
interface IVLCMessages {
    const IVLCMessagesVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCMessages_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCMessages_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCMessages_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCMessages_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCMessages_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCMessages_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCMessages_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCMessages methods ***/
#define IVLCMessages_get__NewEnum(p,a) (p)->lpVtbl->get__NewEnum(p,a)
#define IVLCMessages_clear(p) (p)->lpVtbl->clear(p)
#define IVLCMessages_get_count(p,a) (p)->lpVtbl->get_count(p,a)
#define IVLCMessages_iterator(p,a) (p)->lpVtbl->iterator(p,a)
#endif

#endif

HRESULT CALLBACK IVLCMessages_get__NewEnum_Proxy(
    IVLCMessages* This,
    IUnknown** _NewEnum);
void __RPC_STUB IVLCMessages_get__NewEnum_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessages_clear_Proxy(
    IVLCMessages* This);
void __RPC_STUB IVLCMessages_clear_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessages_get_count_Proxy(
    IVLCMessages* This,
    long* count);
void __RPC_STUB IVLCMessages_get_count_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCMessages_iterator_Proxy(
    IVLCMessages* This,
    IVLCMessageIterator** iter);
void __RPC_STUB IVLCMessages_iterator_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCMessages_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCLog interface
 */
#ifndef __IVLCLog_INTERFACE_DEFINED__
#define __IVLCLog_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCLog, 0x8e3bc3d9, 0x62e9, 0x48fb, 0x8a,0x6d, 0x99,0x3f,0x9a,0xbc,0x4a,0x0a);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCLog : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_messages(
        IVLCMessages** iter) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_verbosity(
        long* level) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_verbosity(
        long level) = 0;

};
#else
typedef struct IVLCLogVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCLog methods ***/
    HRESULT (STDMETHODCALLTYPE *get_messages)(
        IVLCLog* This,
        IVLCMessages** iter);

    HRESULT (STDMETHODCALLTYPE *get_verbosity)(
        IVLCLog* This,
        long* level);

    HRESULT (STDMETHODCALLTYPE *put_verbosity)(
        IVLCLog* This,
        long level);

    END_INTERFACE
} IVLCLogVtbl;
interface IVLCLog {
    const IVLCLogVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCLog_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCLog_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCLog_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCLog_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCLog_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCLog_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCLog_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCLog methods ***/
#define IVLCLog_get_messages(p,a) (p)->lpVtbl->get_messages(p,a)
#define IVLCLog_get_verbosity(p,a) (p)->lpVtbl->get_verbosity(p,a)
#define IVLCLog_put_verbosity(p,a) (p)->lpVtbl->put_verbosity(p,a)
#endif

#endif

HRESULT CALLBACK IVLCLog_get_messages_Proxy(
    IVLCLog* This,
    IVLCMessages** iter);
void __RPC_STUB IVLCLog_get_messages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCLog_get_verbosity_Proxy(
    IVLCLog* This,
    long* level);
void __RPC_STUB IVLCLog_get_verbosity_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCLog_put_verbosity_Proxy(
    IVLCLog* This,
    long level);
void __RPC_STUB IVLCLog_put_verbosity_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCLog_INTERFACE_DEFINED__ */

#ifndef __IVLCPlaylistItems_FWD_DEFINED__
#define __IVLCPlaylistItems_FWD_DEFINED__
typedef interface IVLCPlaylistItems IVLCPlaylistItems;
#endif

/*****************************************************************************
 * IVLCPlaylistItems interface
 */
#ifndef __IVLCPlaylistItems_INTERFACE_DEFINED__
#define __IVLCPlaylistItems_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCPlaylistItems, 0xfd37fe32, 0x82bc, 0x4a25, 0xb0,0x56, 0x31,0x5f,0x4d,0xbb,0x19,0x4d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCPlaylistItems : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_count(
        long* count) = 0;

    virtual HRESULT STDMETHODCALLTYPE clear(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE remove(
        long itemId) = 0;

};
#else
typedef struct IVLCPlaylistItemsVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCPlaylistItems methods ***/
    HRESULT (STDMETHODCALLTYPE *get_count)(
        IVLCPlaylistItems* This,
        long* count);

    HRESULT (STDMETHODCALLTYPE *clear)(
        IVLCPlaylistItems* This);

    HRESULT (STDMETHODCALLTYPE *remove)(
        IVLCPlaylistItems* This,
        long itemId);

    END_INTERFACE
} IVLCPlaylistItemsVtbl;
interface IVLCPlaylistItems {
    const IVLCPlaylistItemsVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCPlaylistItems_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCPlaylistItems_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCPlaylistItems_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCPlaylistItems_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCPlaylistItems_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCPlaylistItems_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCPlaylistItems_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCPlaylistItems methods ***/
#define IVLCPlaylistItems_get_count(p,a) (p)->lpVtbl->get_count(p,a)
#define IVLCPlaylistItems_clear(p) (p)->lpVtbl->clear(p)
#define IVLCPlaylistItems_remove(p,a) (p)->lpVtbl->remove(p,a)
#endif

#endif

HRESULT CALLBACK IVLCPlaylistItems_get_count_Proxy(
    IVLCPlaylistItems* This,
    long* count);
void __RPC_STUB IVLCPlaylistItems_get_count_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylistItems_clear_Proxy(
    IVLCPlaylistItems* This);
void __RPC_STUB IVLCPlaylistItems_clear_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylistItems_remove_Proxy(
    IVLCPlaylistItems* This,
    long itemId);
void __RPC_STUB IVLCPlaylistItems_remove_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCPlaylistItems_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCPlaylist interface
 */
#ifndef __IVLCPlaylist_INTERFACE_DEFINED__
#define __IVLCPlaylist_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCPlaylist, 0x54613049, 0x40bf, 0x4035, 0x9e,0x70, 0x0a,0x93,0x12,0xc0,0x18,0x8d);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCPlaylist : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_itemCount(
        long* count) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_isPlaying(
        VARIANT_BOOL* playing) = 0;

    virtual HRESULT STDMETHODCALLTYPE add(
        BSTR uri,
        VARIANT name,
        VARIANT options,
        long* itemId) = 0;

    virtual HRESULT STDMETHODCALLTYPE play(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE playItem(
        long itemId) = 0;

    virtual HRESULT STDMETHODCALLTYPE togglePause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE next(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE prev(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE clear(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE removeItem(
        long item) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_items(
        IVLCPlaylistItems** obj) = 0;

};
#else
typedef struct IVLCPlaylistVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCPlaylist methods ***/
    HRESULT (STDMETHODCALLTYPE *get_itemCount)(
        IVLCPlaylist* This,
        long* count);

    HRESULT (STDMETHODCALLTYPE *get_isPlaying)(
        IVLCPlaylist* This,
        VARIANT_BOOL* playing);

    HRESULT (STDMETHODCALLTYPE *add)(
        IVLCPlaylist* This,
        BSTR uri,
        VARIANT name,
        VARIANT options,
        long* itemId);

    HRESULT (STDMETHODCALLTYPE *play)(
        IVLCPlaylist* This);

    HRESULT (STDMETHODCALLTYPE *playItem)(
        IVLCPlaylist* This,
        long itemId);

    HRESULT (STDMETHODCALLTYPE *togglePause)(
        IVLCPlaylist* This);

    HRESULT (STDMETHODCALLTYPE *stop)(
        IVLCPlaylist* This);

    HRESULT (STDMETHODCALLTYPE *next)(
        IVLCPlaylist* This);

    HRESULT (STDMETHODCALLTYPE *prev)(
        IVLCPlaylist* This);

    HRESULT (STDMETHODCALLTYPE *clear)(
        IVLCPlaylist* This);

    HRESULT (STDMETHODCALLTYPE *removeItem)(
        IVLCPlaylist* This,
        long item);

    HRESULT (STDMETHODCALLTYPE *get_items)(
        IVLCPlaylist* This,
        IVLCPlaylistItems** obj);

    END_INTERFACE
} IVLCPlaylistVtbl;
interface IVLCPlaylist {
    const IVLCPlaylistVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCPlaylist_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCPlaylist_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCPlaylist_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCPlaylist_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCPlaylist_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCPlaylist_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCPlaylist_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCPlaylist methods ***/
#define IVLCPlaylist_get_itemCount(p,a) (p)->lpVtbl->get_itemCount(p,a)
#define IVLCPlaylist_get_isPlaying(p,a) (p)->lpVtbl->get_isPlaying(p,a)
#define IVLCPlaylist_add(p,a,b,c,d) (p)->lpVtbl->add(p,a,b,c,d)
#define IVLCPlaylist_play(p) (p)->lpVtbl->play(p)
#define IVLCPlaylist_playItem(p,a) (p)->lpVtbl->playItem(p,a)
#define IVLCPlaylist_togglePause(p) (p)->lpVtbl->togglePause(p)
#define IVLCPlaylist_stop(p) (p)->lpVtbl->stop(p)
#define IVLCPlaylist_next(p) (p)->lpVtbl->next(p)
#define IVLCPlaylist_prev(p) (p)->lpVtbl->prev(p)
#define IVLCPlaylist_clear(p) (p)->lpVtbl->clear(p)
#define IVLCPlaylist_removeItem(p,a) (p)->lpVtbl->removeItem(p,a)
#define IVLCPlaylist_get_items(p,a) (p)->lpVtbl->get_items(p,a)
#endif

#endif

HRESULT CALLBACK IVLCPlaylist_get_itemCount_Proxy(
    IVLCPlaylist* This,
    long* count);
void __RPC_STUB IVLCPlaylist_get_itemCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_get_isPlaying_Proxy(
    IVLCPlaylist* This,
    VARIANT_BOOL* playing);
void __RPC_STUB IVLCPlaylist_get_isPlaying_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_add_Proxy(
    IVLCPlaylist* This,
    BSTR uri,
    VARIANT name,
    VARIANT options,
    long* itemId);
void __RPC_STUB IVLCPlaylist_add_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_play_Proxy(
    IVLCPlaylist* This);
void __RPC_STUB IVLCPlaylist_play_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_playItem_Proxy(
    IVLCPlaylist* This,
    long itemId);
void __RPC_STUB IVLCPlaylist_playItem_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_togglePause_Proxy(
    IVLCPlaylist* This);
void __RPC_STUB IVLCPlaylist_togglePause_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_stop_Proxy(
    IVLCPlaylist* This);
void __RPC_STUB IVLCPlaylist_stop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_next_Proxy(
    IVLCPlaylist* This);
void __RPC_STUB IVLCPlaylist_next_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_prev_Proxy(
    IVLCPlaylist* This);
void __RPC_STUB IVLCPlaylist_prev_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_clear_Proxy(
    IVLCPlaylist* This);
void __RPC_STUB IVLCPlaylist_clear_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_removeItem_Proxy(
    IVLCPlaylist* This,
    long item);
void __RPC_STUB IVLCPlaylist_removeItem_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_get_items_Proxy(
    IVLCPlaylist* This,
    IVLCPlaylistItems** obj);
void __RPC_STUB IVLCPlaylist_get_items_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCPlaylist_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCVideo interface
 */
#ifndef __IVLCVideo_INTERFACE_DEFINED__
#define __IVLCVideo_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCVideo, 0x0aaedf0b, 0xd333, 0x4b27, 0xa0,0xc6, 0xbb,0xf3,0x14,0x13,0xa4,0x2e);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCVideo : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_fullscreen(
        VARIANT_BOOL* fullscreen) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_fullscreen(
        VARIANT_BOOL fullscreen) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_width(
        long* width) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_height(
        long* height) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_aspectRatio(
        BSTR* aspect) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_aspectRatio(
        BSTR aspect) = 0;

    virtual HRESULT STDMETHODCALLTYPE toggleFullscreen(
        ) = 0;

};
#else
typedef struct IVLCVideoVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCVideo methods ***/
    HRESULT (STDMETHODCALLTYPE *get_fullscreen)(
        IVLCVideo* This,
        VARIANT_BOOL* fullscreen);

    HRESULT (STDMETHODCALLTYPE *put_fullscreen)(
        IVLCVideo* This,
        VARIANT_BOOL fullscreen);

    HRESULT (STDMETHODCALLTYPE *get_width)(
        IVLCVideo* This,
        long* width);

    HRESULT (STDMETHODCALLTYPE *get_height)(
        IVLCVideo* This,
        long* height);

    HRESULT (STDMETHODCALLTYPE *get_aspectRatio)(
        IVLCVideo* This,
        BSTR* aspect);

    HRESULT (STDMETHODCALLTYPE *put_aspectRatio)(
        IVLCVideo* This,
        BSTR aspect);

    HRESULT (STDMETHODCALLTYPE *toggleFullscreen)(
        IVLCVideo* This);

    END_INTERFACE
} IVLCVideoVtbl;
interface IVLCVideo {
    const IVLCVideoVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCVideo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCVideo_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCVideo_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCVideo_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCVideo_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCVideo_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCVideo_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCVideo methods ***/
#define IVLCVideo_get_fullscreen(p,a) (p)->lpVtbl->get_fullscreen(p,a)
#define IVLCVideo_put_fullscreen(p,a) (p)->lpVtbl->put_fullscreen(p,a)
#define IVLCVideo_get_width(p,a) (p)->lpVtbl->get_width(p,a)
#define IVLCVideo_get_height(p,a) (p)->lpVtbl->get_height(p,a)
#define IVLCVideo_get_aspectRatio(p,a) (p)->lpVtbl->get_aspectRatio(p,a)
#define IVLCVideo_put_aspectRatio(p,a) (p)->lpVtbl->put_aspectRatio(p,a)
#define IVLCVideo_toggleFullscreen(p) (p)->lpVtbl->toggleFullscreen(p)
#endif

#endif

HRESULT CALLBACK IVLCVideo_get_fullscreen_Proxy(
    IVLCVideo* This,
    VARIANT_BOOL* fullscreen);
void __RPC_STUB IVLCVideo_get_fullscreen_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_put_fullscreen_Proxy(
    IVLCVideo* This,
    VARIANT_BOOL fullscreen);
void __RPC_STUB IVLCVideo_put_fullscreen_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_get_width_Proxy(
    IVLCVideo* This,
    long* width);
void __RPC_STUB IVLCVideo_get_width_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_get_height_Proxy(
    IVLCVideo* This,
    long* height);
void __RPC_STUB IVLCVideo_get_height_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_get_aspectRatio_Proxy(
    IVLCVideo* This,
    BSTR* aspect);
void __RPC_STUB IVLCVideo_get_aspectRatio_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_put_aspectRatio_Proxy(
    IVLCVideo* This,
    BSTR aspect);
void __RPC_STUB IVLCVideo_put_aspectRatio_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_toggleFullscreen_Proxy(
    IVLCVideo* This);
void __RPC_STUB IVLCVideo_toggleFullscreen_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCVideo_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IVLCControl2 interface
 */
#ifndef __IVLCControl2_INTERFACE_DEFINED__
#define __IVLCControl2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IVLCControl2, 0x2d719729, 0x5333, 0x406c, 0xbf,0x12, 0x8d,0xe7,0x87,0xfd,0x65,0xe3);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IVLCControl2 : public IDispatch
{
    virtual HRESULT STDMETHODCALLTYPE get_AutoLoop(
        VARIANT_BOOL* autoloop) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_AutoLoop(
        VARIANT_BOOL autoloop) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_AutoPlay(
        VARIANT_BOOL* autoplay) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_AutoPlay(
        VARIANT_BOOL autoplay) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_BaseURL(
        BSTR* url) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_BaseURL(
        BSTR url) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_StartTime(
        long* seconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_StartTime(
        long seconds) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_MRL(
        BSTR* mrl) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_MRL(
        BSTR mrl) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_VersionInfo(
        BSTR* version) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_Visible(
        VARIANT_BOOL* visible) = 0;

    virtual HRESULT STDMETHODCALLTYPE put_Visible(
        VARIANT_BOOL visible) = 0;

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

    virtual HRESULT STDMETHODCALLTYPE put_Volume(
        long volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_audio(
        IVLCAudio** obj) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_input(
        IVLCInput** obj) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_log(
        IVLCLog** obj) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_playlist(
        IVLCPlaylist** obj) = 0;

    virtual HRESULT STDMETHODCALLTYPE get_video(
        IVLCVideo** obj) = 0;

};
#else
typedef struct IVLCControl2Vtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

    /*** IVLCControl2 methods ***/
    HRESULT (STDMETHODCALLTYPE *get_AutoLoop)(
        IVLCControl2* This,
        VARIANT_BOOL* autoloop);

    HRESULT (STDMETHODCALLTYPE *put_AutoLoop)(
        IVLCControl2* This,
        VARIANT_BOOL autoloop);

    HRESULT (STDMETHODCALLTYPE *get_AutoPlay)(
        IVLCControl2* This,
        VARIANT_BOOL* autoplay);

    HRESULT (STDMETHODCALLTYPE *put_AutoPlay)(
        IVLCControl2* This,
        VARIANT_BOOL autoplay);

    HRESULT (STDMETHODCALLTYPE *get_BaseURL)(
        IVLCControl2* This,
        BSTR* url);

    HRESULT (STDMETHODCALLTYPE *put_BaseURL)(
        IVLCControl2* This,
        BSTR url);

    HRESULT (STDMETHODCALLTYPE *get_StartTime)(
        IVLCControl2* This,
        long* seconds);

    HRESULT (STDMETHODCALLTYPE *put_StartTime)(
        IVLCControl2* This,
        long seconds);

    HRESULT (STDMETHODCALLTYPE *get_MRL)(
        IVLCControl2* This,
        BSTR* mrl);

    HRESULT (STDMETHODCALLTYPE *put_MRL)(
        IVLCControl2* This,
        BSTR mrl);

    HRESULT (STDMETHODCALLTYPE *get_VersionInfo)(
        IVLCControl2* This,
        BSTR* version);

    HRESULT (STDMETHODCALLTYPE *get_Visible)(
        IVLCControl2* This,
        VARIANT_BOOL* visible);

    HRESULT (STDMETHODCALLTYPE *put_Visible)(
        IVLCControl2* This,
        VARIANT_BOOL visible);

    HRESULT (STDMETHODCALLTYPE *get_Volume)(
        IVLCControl2* This,
        long* volume);

    HRESULT (STDMETHODCALLTYPE *put_Volume)(
        IVLCControl2* This,
        long volume);

    HRESULT (STDMETHODCALLTYPE *get_audio)(
        IVLCControl2* This,
        IVLCAudio** obj);

    HRESULT (STDMETHODCALLTYPE *get_input)(
        IVLCControl2* This,
        IVLCInput** obj);

    HRESULT (STDMETHODCALLTYPE *get_log)(
        IVLCControl2* This,
        IVLCLog** obj);

    HRESULT (STDMETHODCALLTYPE *get_playlist)(
        IVLCControl2* This,
        IVLCPlaylist** obj);

    HRESULT (STDMETHODCALLTYPE *get_video)(
        IVLCControl2* This,
        IVLCVideo** obj);

    END_INTERFACE
} IVLCControl2Vtbl;
interface IVLCControl2 {
    const IVLCControl2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IVLCControl2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IVLCControl2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IVLCControl2_Release(p) (p)->lpVtbl->Release(p)
/*** IDispatch methods ***/
#define IVLCControl2_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
#define IVLCControl2_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
#define IVLCControl2_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
#define IVLCControl2_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
/*** IVLCControl2 methods ***/
#define IVLCControl2_get_AutoLoop(p,a) (p)->lpVtbl->get_AutoLoop(p,a)
#define IVLCControl2_put_AutoLoop(p,a) (p)->lpVtbl->put_AutoLoop(p,a)
#define IVLCControl2_get_AutoPlay(p,a) (p)->lpVtbl->get_AutoPlay(p,a)
#define IVLCControl2_put_AutoPlay(p,a) (p)->lpVtbl->put_AutoPlay(p,a)
#define IVLCControl2_get_BaseURL(p,a) (p)->lpVtbl->get_BaseURL(p,a)
#define IVLCControl2_put_BaseURL(p,a) (p)->lpVtbl->put_BaseURL(p,a)
#define IVLCControl2_get_StartTime(p,a) (p)->lpVtbl->get_StartTime(p,a)
#define IVLCControl2_put_StartTime(p,a) (p)->lpVtbl->put_StartTime(p,a)
#define IVLCControl2_get_MRL(p,a) (p)->lpVtbl->get_MRL(p,a)
#define IVLCControl2_put_MRL(p,a) (p)->lpVtbl->put_MRL(p,a)
#define IVLCControl2_get_VersionInfo(p,a) (p)->lpVtbl->get_VersionInfo(p,a)
#define IVLCControl2_get_Visible(p,a) (p)->lpVtbl->get_Visible(p,a)
#define IVLCControl2_put_Visible(p,a) (p)->lpVtbl->put_Visible(p,a)
#define IVLCControl2_get_Volume(p,a) (p)->lpVtbl->get_Volume(p,a)
#define IVLCControl2_put_Volume(p,a) (p)->lpVtbl->put_Volume(p,a)
#define IVLCControl2_get_audio(p,a) (p)->lpVtbl->get_audio(p,a)
#define IVLCControl2_get_input(p,a) (p)->lpVtbl->get_input(p,a)
#define IVLCControl2_get_log(p,a) (p)->lpVtbl->get_log(p,a)
#define IVLCControl2_get_playlist(p,a) (p)->lpVtbl->get_playlist(p,a)
#define IVLCControl2_get_video(p,a) (p)->lpVtbl->get_video(p,a)
#endif

#endif

HRESULT CALLBACK IVLCControl2_get_AutoLoop_Proxy(
    IVLCControl2* This,
    VARIANT_BOOL* autoloop);
void __RPC_STUB IVLCControl2_get_AutoLoop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_AutoLoop_Proxy(
    IVLCControl2* This,
    VARIANT_BOOL autoloop);
void __RPC_STUB IVLCControl2_put_AutoLoop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_AutoPlay_Proxy(
    IVLCControl2* This,
    VARIANT_BOOL* autoplay);
void __RPC_STUB IVLCControl2_get_AutoPlay_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_AutoPlay_Proxy(
    IVLCControl2* This,
    VARIANT_BOOL autoplay);
void __RPC_STUB IVLCControl2_put_AutoPlay_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_BaseURL_Proxy(
    IVLCControl2* This,
    BSTR* url);
void __RPC_STUB IVLCControl2_get_BaseURL_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_BaseURL_Proxy(
    IVLCControl2* This,
    BSTR url);
void __RPC_STUB IVLCControl2_put_BaseURL_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_StartTime_Proxy(
    IVLCControl2* This,
    long* seconds);
void __RPC_STUB IVLCControl2_get_StartTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_StartTime_Proxy(
    IVLCControl2* This,
    long seconds);
void __RPC_STUB IVLCControl2_put_StartTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_MRL_Proxy(
    IVLCControl2* This,
    BSTR* mrl);
void __RPC_STUB IVLCControl2_get_MRL_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_MRL_Proxy(
    IVLCControl2* This,
    BSTR mrl);
void __RPC_STUB IVLCControl2_put_MRL_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_VersionInfo_Proxy(
    IVLCControl2* This,
    BSTR* version);
void __RPC_STUB IVLCControl2_get_VersionInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_Visible_Proxy(
    IVLCControl2* This,
    VARIANT_BOOL* visible);
void __RPC_STUB IVLCControl2_get_Visible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_Visible_Proxy(
    IVLCControl2* This,
    VARIANT_BOOL visible);
void __RPC_STUB IVLCControl2_put_Visible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_Volume_Proxy(
    IVLCControl2* This,
    long* volume);
void __RPC_STUB IVLCControl2_get_Volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_Volume_Proxy(
    IVLCControl2* This,
    long volume);
void __RPC_STUB IVLCControl2_put_Volume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_audio_Proxy(
    IVLCControl2* This,
    IVLCAudio** obj);
void __RPC_STUB IVLCControl2_get_audio_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_input_Proxy(
    IVLCControl2* This,
    IVLCInput** obj);
void __RPC_STUB IVLCControl2_get_input_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_log_Proxy(
    IVLCControl2* This,
    IVLCLog** obj);
void __RPC_STUB IVLCControl2_get_log_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_playlist_Proxy(
    IVLCControl2* This,
    IVLCPlaylist** obj);
void __RPC_STUB IVLCControl2_get_playlist_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_video_Proxy(
    IVLCControl2* This,
    IVLCVideo** obj);
void __RPC_STUB IVLCControl2_get_video_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IVLCControl2_INTERFACE_DEFINED__ */

/*****************************************************************************
 * VLCPlugin coclass
 */

DEFINE_GUID(CLSID_VLCPlugin, 0xe23fe9c6, 0x778e, 0x49d4, 0xb5,0x37, 0x38,0xfc,0xde,0x48,0x87,0xd8);

#ifndef __VLCPlugin_FWD_DEFINED__
#define __VLCPlugin_FWD_DEFINED__
typedef struct VLCPlugin VLCPlugin;
#endif /* defined __VLCPlugin_FWD_DEFINED__ */

/*****************************************************************************
 * VLCPlugin2 coclass
 */

DEFINE_GUID(CLSID_VLCPlugin2, 0x9be31822, 0xfdad, 0x461b, 0xad,0x51, 0xbe,0x1d,0x1c,0x15,0x99,0x21);

#ifndef __VLCPlugin2_FWD_DEFINED__
#define __VLCPlugin2_FWD_DEFINED__
typedef struct VLCPlugin2 VLCPlugin2;
#endif /* defined __VLCPlugin2_FWD_DEFINED__ */

/* Begin additional prototypes for all interfaces */

unsigned long   __RPC_USER VARIANT_UserSize     (unsigned long *, unsigned long,   VARIANT *);
unsigned char * __RPC_USER VARIANT_UserMarshal  (unsigned long *, unsigned char *, VARIANT *);
unsigned char * __RPC_USER VARIANT_UserUnmarshal(unsigned long *, unsigned char *, VARIANT *);
void            __RPC_USER VARIANT_UserFree     (unsigned long *, VARIANT *);
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_AXVLC_IDL_H */
