interface IVLCControl;\r
interface IVLCAudio;\r
interface IVLCInput;\r
+ interface IVLCLog;\r
+ interface IVLCMessage;\r
+ interface IVLCMessageIterator;\r
+ interface IVLCMessages;\r
interface IVLCPlaylist;\r
interface IVLCVideo;\r
interface IVLCControl2;\r
HRESULT mute([in] VARIANT_BOOL muted);\r
\r
[propget, helpstring("Returns/sets audio volume as a percent value.")]\r
- HRESULT volume([out, retval] int* volume);\r
+ HRESULT volume([out, retval] long* volume);\r
[propput, helpstring("Returns/sets audio volume as a percent value.")]\r
- HRESULT volume([in] int volume);\r
+ HRESULT volume([in] long volume);\r
\r
[helpstring("Mute/unmute audio playback.")]\r
HRESULT toggleMute();\r
HRESULT length([out, retval] double* length);\r
\r
[propget, helpstring("Returns/sets playback position in current clip. Position is ranging from 0.0 to 1.0.")]\r
- HRESULT position([out, retval] float* position);\r
+ HRESULT position([out, retval] double* position);\r
[propput, helpstring("Returns/sets playback position in the current clip. Position ranging from 0.0 to 1.0.")]\r
- HRESULT position([in] float position);\r
+ HRESULT position([in] double position);\r
\r
[propget, helpstring("Returns/sets playback time in current clip, in milliseconds.")]\r
HRESULT time([out, retval] double* time);\r
HRESULT time([in] double time);\r
\r
[propget, helpstring("Returns current playback state.")]\r
- HRESULT state([out, retval] int* state);\r
+ HRESULT state([out, retval] long* state);\r
\r
[propget, helpstring("Returns/sets current playback rate, normal rate is 1.0 ")]\r
- HRESULT rate([out, retval] float* rate);\r
+ HRESULT rate([out, retval] double* rate);\r
[propput, helpstring("Returns/sets current playback rate, normal rate is 1.0.")]\r
- HRESULT rate([in] float rate);\r
+ HRESULT rate([in] double rate);\r
\r
[propget, helpstring("Returns current playback frames per seconds if available.")]\r
- HRESULT fps([out, retval] float* fps);\r
+ HRESULT fps([out, retval] double* fps);\r
\r
[propget, helpstring("Returns whether current playback displays video.")]\r
HRESULT hasVout([out, retval] VARIANT_BOOL* hasVout);\r
};\r
\r
+ [\r
+ odl,\r
+ uuid(9ED00AFA-7BCD-4FFF-8D48-7DD4DB2C800D),\r
+ helpstring("VLC Log Message"),\r
+ hidden,\r
+ dual,\r
+ nonextensible,\r
+ oleautomation\r
+ ]\r
+ interface IVLCMessage: IDispatch\r
+ {\r
+ [id(DISPID_VALUE), propget]\r
+ HRESULT _Value([out, retval] VARIANT* message);\r
+\r
+ [propget, helpstring("Returns message severity.")]\r
+ HRESULT severity([out, retval] long* level);\r
+\r
+ [propget, helpstring("Returns message issuer type.")]\r
+ HRESULT type([out, retval] BSTR* type);\r
+\r
+ [propget, helpstring("Returns message issuer name.")]\r
+ HRESULT name([out, retval] BSTR* name);\r
+\r
+ [propget, helpstring("Returns message header.")]\r
+ HRESULT header([out, retval] BSTR* header);\r
+\r
+ [propget, helpstring("Returns message content.")]\r
+ HRESULT message([out, retval] BSTR* message);\r
+ };\r
+\r
+ [\r
+ odl,\r
+ uuid(15179CD8-CC12-4242-A58E-E412217FF343),\r
+ helpstring("VLC Log iterator"),\r
+ hidden,\r
+ dual,\r
+ nonextensible,\r
+ oleautomation\r
+ ]\r
+ interface IVLCMessageIterator : IDispatch\r
+ {\r
+ [propget, helpstring("Returns whether a message is available.")]\r
+ HRESULT hasNext([out, retval] VARIANT_BOOL* hasNext);\r
+\r
+ [helpstring("Returns next message.")]\r
+ HRESULT next([out, retval] IVLCMessage** msg);\r
+ };\r
+\r
+ [\r
+ odl,\r
+ uuid(6C5CE55D-2D6C-4AAD-8299-C62D2371F106),\r
+ helpstring("VLC Log APIs"),\r
+ hidden,\r
+ dual,\r
+ nonextensible,\r
+ oleautomation\r
+ ]\r
+ interface IVLCMessages : IDispatch\r
+ {\r
+ [id(DISPID_NEWENUM), propget]\r
+ HRESULT _NewEnum([out, retval] IUnknown** _NewEnum);\r
+\r
+ [helpstring("Clear all messages from log.")]\r
+ HRESULT clear();\r
+\r
+ [propget, helpstring("Returns the number of messages.")]\r
+ HRESULT count([out, retval] long* count);\r
+\r
+ [helpstring("Returns an iterator for messages in log")]\r
+ HRESULT iterator([out, retval] IVLCMessageIterator** iter);\r
+ };\r
+\r
+ [\r
+ odl,\r
+ uuid(8E3BC3D9-62E9-48FB-8A6D-993F9ABC4A0A),\r
+ helpstring("VLC Log APIs"),\r
+ hidden,\r
+ dual,\r
+ nonextensible,\r
+ oleautomation\r
+ ]\r
+ interface IVLCLog : IDispatch\r
+ {\r
+ [propget, helpstring("Returns messages in log")]\r
+ HRESULT messages([out, retval] IVLCMessages** iter);\r
+\r
+ [propget, helpstring("Returns/Sets the log versbosity level.")]\r
+ HRESULT verbosity([out, retval] long* level);\r
+ [propput, helpstring("Returns/Sets the log versbosity level.")]\r
+ HRESULT verbosity([in] long level);\r
+ };\r
+\r
[\r
odl,\r
uuid(54613049-40BF-4035-9E70-0A9312C0188D),\r
interface IVLCPlaylist : IDispatch\r
{\r
[propget, helpstring("Returns number of items in playlist.")]\r
- HRESULT itemCount([out, retval] int* count);\r
+ HRESULT itemCount([out, retval] long* count);\r
\r
[propget, helpstring("Returns whether playback displays video.")]\r
HRESULT isPlaying([out, retval] VARIANT_BOOL* playing);\r
\r
[helpstring("Add a playlist item.")]\r
- HRESULT add([in] BSTR uri, [in, optional] VARIANT name, [in, optional] VARIANT options, [out, retval] int* item);\r
+ HRESULT add([in] BSTR uri, [in, optional] VARIANT name, [in, optional] VARIANT options, [out, retval] long* item);\r
\r
[helpstring("Play/Resume the playlist.")]\r
HRESULT play();\r
\r
[helpstring("Play item in playlist.")]\r
- HRESULT playItem([in] int item);\r
+ HRESULT playItem([in] long item);\r
\r
[helpstring("Play/Pause current clip.")]\r
HRESULT togglePause();\r
HRESULT clear();\r
\r
[helpstring("remove item from playlist.")]\r
- HRESULT removeItem([in] int item);\r
+ HRESULT removeItem([in] long item);\r
};\r
\r
[\r
HRESULT fullscreen([in] VARIANT_BOOL fullscreen);\r
\r
[propget, helpstring("Returns video original width.")]\r
- HRESULT width([out, retval] int* width);\r
+ HRESULT width([out, retval] long* width);\r
\r
[propget, helpstring("Returns video original height.")]\r
- HRESULT height([out, retval] int* height);\r
+ HRESULT height([out, retval] long* height);\r
\r
[helpstring("toggle fullscreen/windowed state.")]\r
HRESULT toggleFullscreen();\r
HRESULT BaseURL([in] BSTR url);\r
\r
[id(DISPID_StartTime), propget, helpstring("Returns/sets playback start time of URL.")]\r
- HRESULT StartTime([out, retval] int* seconds);\r
+ HRESULT StartTime([out, retval] long* seconds);\r
[id(DISPID_StartTime), propput, helpstring("Returns/sets playback start time of URL.")]\r
- HRESULT StartTime([in] int seconds);\r
+ HRESULT StartTime([in] long seconds);\r
\r
[id(DISPID_MRL), propget, helpstring("Returns/sets the default MRL in playlist")]\r
HRESULT MRL([out, retval] BSTR* mrl);\r
HRESULT Visible([in] VARIANT_BOOL visible);\r
\r
[id(DISPID_Volume), propget, helpstring("Returns/sets default audio volume.")]\r
- HRESULT Volume([out, retval] int* volume);\r
+ HRESULT Volume([out, retval] long* volume);\r
[id(DISPID_Volume), propput, helpstring("Returns/sets default audio volume.")]\r
- HRESULT Volume([in] int volume);\r
+ HRESULT Volume([in] long volume);\r
\r
[propget, helpstring("Returns the audio object.")]\r
HRESULT audio([out, retval] IVLCAudio** obj);\r
[propget, helpstring("Returns the audio object.")]\r
HRESULT input([out, retval] IVLCInput** obj);\r
\r
+ [propget, helpstring("Returns the log object.")]\r
+ HRESULT log([out, retval] IVLCLog** obj);\r
+\r
[propget, helpstring("Returns the playlist object.")]\r
HRESULT playlist([out, retval] IVLCPlaylist** obj);\r
\r
DEFINE_GUID(DIID_DVLCEvents, 0xdf48072f, 0x5ef8, 0x434e, 0x9b,0x40, 0xe2,0xf3,0xae,0x75,0x9b,0x5f);
DEFINE_GUID(IID_IVLCAudio, 0x9e0bd17b, 0x2d3c, 0x4656, 0xb9,0x4d, 0x03,0x08,0x4f,0x3f,0xd9,0xd4);
DEFINE_GUID(IID_IVLCInput, 0x49e0dbd1, 0x9440, 0x466c, 0x9c,0x97, 0x95,0xc6,0x71,0x90,0xc6,0x03);
+DEFINE_GUID(IID_IVLCMessage, 0x9ed00afa, 0x7bcd, 0x4fff, 0x8d,0x48, 0x7d,0xd4,0xdb,0x2c,0x80,0x0d);
+DEFINE_GUID(IID_IVLCMessageIterator, 0x15179cd8, 0xcc12, 0x4242, 0xa5,0x8e, 0xe4,0x12,0x21,0x7f,0xf3,0x43);
+DEFINE_GUID(IID_IVLCMessages, 0x6c5ce55d, 0x2d6c, 0x4aad, 0x82,0x99, 0xc6,0x2d,0x23,0x71,0xf1,0x06);
+DEFINE_GUID(IID_IVLCLog, 0x8e3bc3d9, 0x62e9, 0x48fb, 0x8a,0x6d, 0x99,0x3f,0x9a,0xbc,0x4a,0x0a);
DEFINE_GUID(IID_IVLCPlaylist, 0x54613049, 0x40bf, 0x4035, 0x9e,0x70, 0x0a,0x93,0x12,0xc0,0x18,0x8d);
DEFINE_GUID(IID_IVLCVideo, 0x0aaedf0b, 0xd333, 0x4b27, 0xa0,0xc6, 0xbb,0xf3,0x14,0x13,0xa4,0x2e);
DEFINE_GUID(IID_IVLCControl2, 0x2d719729, 0x5333, 0x406c, 0xbf,0x12, 0x8d,0xe7,0x87,0xfd,0x65,0xe3);
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;
VARIANT_BOOL muted) = 0;
virtual HRESULT STDMETHODCALLTYPE get_volume(
- int* volume) = 0;
+ long* volume) = 0;
virtual HRESULT STDMETHODCALLTYPE put_volume(
- int volume) = 0;
+ long volume) = 0;
virtual HRESULT STDMETHODCALLTYPE toggleMute(
) = 0;
HRESULT (STDMETHODCALLTYPE *get_volume)(
IVLCAudio* This,
- int* volume);
+ long* volume);
HRESULT (STDMETHODCALLTYPE *put_volume)(
IVLCAudio* This,
- int volume);
+ long volume);
HRESULT (STDMETHODCALLTYPE *toggleMute)(
IVLCAudio* This);
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCAudio_get_volume_Proxy(
IVLCAudio* This,
- int* volume);
+ long* volume);
void __RPC_STUB IVLCAudio_get_volume_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCAudio_put_volume_Proxy(
IVLCAudio* This,
- int volume);
+ long volume);
void __RPC_STUB IVLCAudio_put_volume_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
double* length) = 0;
virtual HRESULT STDMETHODCALLTYPE get_position(
- float* position) = 0;
+ double* position) = 0;
virtual HRESULT STDMETHODCALLTYPE put_position(
- float position) = 0;
+ double position) = 0;
virtual HRESULT STDMETHODCALLTYPE get_time(
double* time) = 0;
double time) = 0;
virtual HRESULT STDMETHODCALLTYPE get_state(
- int* state) = 0;
+ long* state) = 0;
virtual HRESULT STDMETHODCALLTYPE get_rate(
- float* rate) = 0;
+ double* rate) = 0;
virtual HRESULT STDMETHODCALLTYPE put_rate(
- float rate) = 0;
+ double rate) = 0;
virtual HRESULT STDMETHODCALLTYPE get_fps(
- float* fps) = 0;
+ double* fps) = 0;
virtual HRESULT STDMETHODCALLTYPE get_hasVout(
VARIANT_BOOL* hasVout) = 0;
HRESULT (STDMETHODCALLTYPE *get_position)(
IVLCInput* This,
- float* position);
+ double* position);
HRESULT (STDMETHODCALLTYPE *put_position)(
IVLCInput* This,
- float position);
+ double position);
HRESULT (STDMETHODCALLTYPE *get_time)(
IVLCInput* This,
HRESULT (STDMETHODCALLTYPE *get_state)(
IVLCInput* This,
- int* state);
+ long* state);
HRESULT (STDMETHODCALLTYPE *get_rate)(
IVLCInput* This,
- float* rate);
+ double* rate);
HRESULT (STDMETHODCALLTYPE *put_rate)(
IVLCInput* This,
- float rate);
+ double rate);
HRESULT (STDMETHODCALLTYPE *get_fps)(
IVLCInput* This,
- float* fps);
+ double* fps);
HRESULT (STDMETHODCALLTYPE *get_hasVout)(
IVLCInput* This,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_position_Proxy(
IVLCInput* This,
- float* position);
+ double* position);
void __RPC_STUB IVLCInput_get_position_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_put_position_Proxy(
IVLCInput* This,
- float position);
+ double position);
void __RPC_STUB IVLCInput_put_position_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_state_Proxy(
IVLCInput* This,
- int* state);
+ long* state);
void __RPC_STUB IVLCInput_get_state_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_rate_Proxy(
IVLCInput* This,
- float* rate);
+ double* rate);
void __RPC_STUB IVLCInput_get_rate_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_put_rate_Proxy(
IVLCInput* This,
- float rate);
+ double rate);
void __RPC_STUB IVLCInput_put_rate_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCInput_get_fps_Proxy(
IVLCInput* This,
- float* fps);
+ double* fps);
void __RPC_STUB IVLCInput_get_fps_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
#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__ */
+
/*****************************************************************************
* IVLCPlaylist interface
*/
interface IVLCPlaylist : public IDispatch
{
virtual HRESULT STDMETHODCALLTYPE get_itemCount(
- int* count) = 0;
+ long* count) = 0;
virtual HRESULT STDMETHODCALLTYPE get_isPlaying(
VARIANT_BOOL* playing) = 0;
BSTR uri,
VARIANT name,
VARIANT options,
- int* item) = 0;
+ long* item) = 0;
virtual HRESULT STDMETHODCALLTYPE play(
) = 0;
virtual HRESULT STDMETHODCALLTYPE playItem(
- int item) = 0;
+ long item) = 0;
virtual HRESULT STDMETHODCALLTYPE togglePause(
) = 0;
) = 0;
virtual HRESULT STDMETHODCALLTYPE removeItem(
- int item) = 0;
+ long item) = 0;
};
#else
/*** IVLCPlaylist methods ***/
HRESULT (STDMETHODCALLTYPE *get_itemCount)(
IVLCPlaylist* This,
- int* count);
+ long* count);
HRESULT (STDMETHODCALLTYPE *get_isPlaying)(
IVLCPlaylist* This,
BSTR uri,
VARIANT name,
VARIANT options,
- int* item);
+ long* item);
HRESULT (STDMETHODCALLTYPE *play)(
IVLCPlaylist* This);
HRESULT (STDMETHODCALLTYPE *playItem)(
IVLCPlaylist* This,
- int item);
+ long item);
HRESULT (STDMETHODCALLTYPE *togglePause)(
IVLCPlaylist* This);
HRESULT (STDMETHODCALLTYPE *removeItem)(
IVLCPlaylist* This,
- int item);
+ long item);
END_INTERFACE
} IVLCPlaylistVtbl;
HRESULT CALLBACK IVLCPlaylist_get_itemCount_Proxy(
IVLCPlaylist* This,
- int* count);
+ long* count);
void __RPC_STUB IVLCPlaylist_get_itemCount_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
BSTR uri,
VARIANT name,
VARIANT options,
- int* item);
+ long* item);
void __RPC_STUB IVLCPlaylist_add_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_playItem_Proxy(
IVLCPlaylist* This,
- int item);
+ long item);
void __RPC_STUB IVLCPlaylist_playItem_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCPlaylist_removeItem_Proxy(
IVLCPlaylist* This,
- int item);
+ long item);
void __RPC_STUB IVLCPlaylist_removeItem_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
VARIANT_BOOL fullscreen) = 0;
virtual HRESULT STDMETHODCALLTYPE get_width(
- int* width) = 0;
+ long* width) = 0;
virtual HRESULT STDMETHODCALLTYPE get_height(
- int* height) = 0;
+ long* height) = 0;
virtual HRESULT STDMETHODCALLTYPE toggleFullscreen(
) = 0;
HRESULT (STDMETHODCALLTYPE *get_width)(
IVLCVideo* This,
- int* width);
+ long* width);
HRESULT (STDMETHODCALLTYPE *get_height)(
IVLCVideo* This,
- int* height);
+ long* height);
HRESULT (STDMETHODCALLTYPE *toggleFullscreen)(
IVLCVideo* This);
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_get_width_Proxy(
IVLCVideo* This,
- int* width);
+ long* width);
void __RPC_STUB IVLCVideo_get_width_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCVideo_get_height_Proxy(
IVLCVideo* This,
- int* height);
+ long* height);
void __RPC_STUB IVLCVideo_get_height_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
BSTR url) = 0;
virtual HRESULT STDMETHODCALLTYPE get_StartTime(
- int* seconds) = 0;
+ long* seconds) = 0;
virtual HRESULT STDMETHODCALLTYPE put_StartTime(
- int seconds) = 0;
+ long seconds) = 0;
virtual HRESULT STDMETHODCALLTYPE get_MRL(
BSTR* mrl) = 0;
VARIANT_BOOL visible) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Volume(
- int* volume) = 0;
+ long* volume) = 0;
virtual HRESULT STDMETHODCALLTYPE put_Volume(
- int volume) = 0;
+ 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;
HRESULT (STDMETHODCALLTYPE *get_StartTime)(
IVLCControl2* This,
- int* seconds);
+ long* seconds);
HRESULT (STDMETHODCALLTYPE *put_StartTime)(
IVLCControl2* This,
- int seconds);
+ long seconds);
HRESULT (STDMETHODCALLTYPE *get_MRL)(
IVLCControl2* This,
HRESULT (STDMETHODCALLTYPE *get_Volume)(
IVLCControl2* This,
- int* volume);
+ long* volume);
HRESULT (STDMETHODCALLTYPE *put_Volume)(
IVLCControl2* This,
- int volume);
+ long volume);
HRESULT (STDMETHODCALLTYPE *get_audio)(
IVLCControl2* This,
IVLCControl2* This,
IVLCInput** obj);
+ HRESULT (STDMETHODCALLTYPE *get_log)(
+ IVLCControl2* This,
+ IVLCLog** obj);
+
HRESULT (STDMETHODCALLTYPE *get_playlist)(
IVLCControl2* This,
IVLCPlaylist** obj);
#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
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_StartTime_Proxy(
IVLCControl2* This,
- int* seconds);
+ long* seconds);
void __RPC_STUB IVLCControl2_get_StartTime_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_StartTime_Proxy(
IVLCControl2* This,
- int seconds);
+ long seconds);
void __RPC_STUB IVLCControl2_put_StartTime_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_get_Volume_Proxy(
IVLCControl2* This,
- int* volume);
+ long* volume);
void __RPC_STUB IVLCControl2_get_Volume_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
DWORD* pdwStubPhase);
HRESULT CALLBACK IVLCControl2_put_Volume_Proxy(
IVLCControl2* This,
- int volume);
+ long volume);
void __RPC_STUB IVLCControl2_put_Volume_Stub(
IRpcStubBuffer* This,
IRpcChannelBuffer* pRpcChannelBuffer,
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);
{
if( (riid == IID_IVLCAudio)
|| (riid == IID_IVLCInput)
+ || (riid == IID_IVLCLog)
+ || (riid == IID_IVLCMessage)
+ || (riid == IID_IVLCMessageIterator)
+ || (riid == IID_IVLCMessages)
|| (riid == IID_IVLCPlaylist)
|| (riid == IID_IVLCVideo)
|| (riid == IID_IVLCControl2) )
var timeHour = Math.round(timeVal / 1000);\r
var timeSec = timeHour % 60;\r
if( timeSec < 10 )\r
- timeSec = '0'+timeSec;\r
+ timeSec = '0'+timeSec;\r
timeHour = (timeHour - timeSec)/60;\r
var timeMin = timeHour % 60;\r
if( timeMin < 10 )\r
- timeMin = '0'+timeMin;\r
+ timeMin = '0'+timeMin;\r
timeHour = (timeHour - timeMin)/60;\r
if( timeHour > 0 )\r
- return timeHour+":"+timeMin+":"+timeSec;\r
+ return timeHour+":"+timeMin+":"+timeSec;\r
else\r
- return timeMin+":"+timeSec;\r
+ return timeMin+":"+timeSec;\r
};\r
function monitor()\r
{\r
var vlc = document.getElementById("vlc");\r
var newState = vlc.input.state;\r
+ if( vlc.log.messages.count > 0 )\r
+ {\r
+ var iter = vlc.log.messages.iterator();\r
+ while( iter.hasNext )\r
+ {\r
+ var msg = iter.next();\r
+ alert( msg );\r
+ }\r
+ vlc.log.messages.clear();\r
+ }\r
if( prevState != newState )\r
{\r
- if( newState == 0 )\r
- {\r
- // current media has stopped \r
- onStop();\r
- }\r
- else if( newState == 1 )\r
- {\r
- // current media is openning/connecting\r
- onOpen();\r
- }\r
- else if( newState == 2 )\r
- {\r
- // current media is buffering data\r
- onBuffer();\r
- }\r
- else if( newState == 3 )\r
- {\r
- // current media is now playing\r
- onPlay();\r
- }\r
- else if( vlc.input.state == 4 )\r
- {\r
- // current media is now paused\r
- onPause();\r
- }\r
- prevState = newState;\r
+ if( newState == 0 )\r
+ {\r
+ // current media has stopped \r
+ onStop();\r
+ }\r
+ else if( newState == 1 )\r
+ {\r
+ // current media is openning/connecting\r
+ onOpen();\r
+ }\r
+ else if( newState == 2 )\r
+ {\r
+ // current media is buffering data\r
+ onBuffer();\r
+ }\r
+ else if( newState == 3 )\r
+ {\r
+ // current media is now playing\r
+ onPlay();\r
+ }\r
+ else if( vlc.input.state == 4 )\r
+ {\r
+ // current media is now paused\r
+ onPause();\r
+ }\r
+ prevState = newState;\r
}\r
else if( newState == 3 )\r
{\r
- // current media is playing\r
- onPlaying();\r
+ // current media is playing\r
+ onPlaying();\r
}\r
monitorTimerId = setTimeout("monitor()", 1000);\r
};\r
function doGo(targetURL)\r
{\r
var vlc = document.getElementById("vlc");\r
- var options = new Array(":vout-filter=deinterlace", ":deinterlace-mode=linear");\r
+ var options = new Array(":vout=directx");\r
vlc.playlist.clear();\r
//vlc.playlist.add(targetURL, null, options);\r
vlc.playlist.add(targetURL);\r
vlc.playlist.play();\r
+ vlc.log.verbosity = 3;\r
+ vlc.log.messages.clear();\r
if( monitorTimerId == 0 )\r
{\r
- monitor();\r
+ monitor();\r
}\r
};\r
function doPlayOrPause()\r
var vlc = document.getElementById("vlc");\r
if( vlc.playlist.isPlaying )\r
{\r
- vlc.playlist.togglePause();\r
+ vlc.playlist.togglePause();\r
}\r
else\r
{\r
- vlc.playlist.play();\r
- if( monitorTimerId == 0 )\r
- {\r
- monitor();\r
- }\r
+ vlc.log.messages.clear();\r
+ vlc.playlist.play();\r
+ if( monitorTimerId == 0 )\r
+ {\r
+ monitor();\r
+ }\r
}\r
};\r
function doStop()\r
document.getElementById("vlc").playlist.stop();\r
if( monitorTimerId != 0 )\r
{\r
- clearTimeout(monitorTimerId);\r
- monitorTimerId = 0;\r
+ clearTimeout(monitorTimerId);\r
+ monitorTimerId = 0;\r
}\r
onStop();\r
};\r
{\r
if( ! sliderScrolling )\r
{\r
- var slider = document.getElementById("slider");\r
- if( vlc.input.length > 0 )\r
- {\r
- // seekable media\r
- slider.Enabled = true;\r
- slider.Max = slider.width;\r
- ignoreSliderChange = true;\r
- slider.Value = vlc.input.position*slider.width;\r
- ignoreSliderChange = false;\r
- document.getElementById("info").innerHTML = formatTime(vlc.input.time)+"/"+formatTime(vlc.input.length);\r
- }\r
- else\r
- {\r
- // non-seekable "live" media\r
- if( slider.Enabled )\r
- {\r
- slider.Value = slider.Min;\r
- slider.Enabled = false;\r
- }\r
+ var slider = document.getElementById("slider");\r
+ if( vlc.input.length > 0 )\r
+ {\r
+ // seekable media\r
+ slider.Enabled = true;\r
+ slider.Max = slider.width;\r
+ ignoreSliderChange = true;\r
+ slider.Value = vlc.input.position*slider.width;\r
+ ignoreSliderChange = false;\r
+ document.getElementById("info").innerHTML = formatTime(vlc.input.time)+"/"+formatTime(vlc.input.length);\r
+ }\r
+ else\r
+ {\r
+ // non-seekable "live" media\r
+ if( slider.Enabled )\r
+ {\r
+ slider.Value = slider.Min;\r
+ slider.Enabled = false;\r
+ }\r
liveFeedRoll = liveFeedRoll & 3;\r
document.getElementById("info").innerHTML = liveFeedText[liveFeedRoll++];\r
- }\r
+ }\r
}\r
};\r
function onPause()\r
};\r
function onStop()\r
{\r
+ vlc.log.verbosity = -1;\r
if( slider.Enabled )\r
{\r
slider.Value = slider.Min;\r
if( (vlc.input.state == 3) && (oldPos != newPos) )\r
{\r
vlc.input.position = newPos;\r
- slider.Text = formatTime(vlc.input.time);\r
- document.getElementById("info").innerHTML = slider.Text+"/"+formatTime(vlc.input.length);\r
+ slider.Text = formatTime(vlc.input.time);\r
+ document.getElementById("info").innerHTML = slider.Text+"/"+formatTime(vlc.input.length);\r
}\r
sliderScrolling = true;\r
};\r
const char *versionStr = VLC_Version();
if( NULL != versionStr )
{
- *version = BSTRFromCStr(_p_instance->getCodePage(), versionStr);
+ *version = BSTRFromCStr(CP_UTF8, versionStr);
return NULL == *version ? E_OUTOFMEMORY : NOERROR;
}
return hr;
};
-STDMETHODIMP VLCAudio::get_volume(int* volume)
+STDMETHODIMP VLCAudio::get_volume(long* volume)
{
if( NULL == volume )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCAudio::put_volume(int volume)
+STDMETHODIMP VLCAudio::put_volume(long volume)
{
libvlc_instance_t* p_libvlc;
HRESULT hr = _p_instance->getVLC(&p_libvlc);
return hr;
};
-STDMETHODIMP VLCInput::get_position(float* position)
+STDMETHODIMP VLCInput::get_position(double* position)
{
if( NULL == position )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCInput::put_position(float position)
+STDMETHODIMP VLCInput::put_position(double position)
{
libvlc_instance_t* p_libvlc;
HRESULT hr = _p_instance->getVLC(&p_libvlc);
return hr;
};
-STDMETHODIMP VLCInput::get_state(int* state)
+STDMETHODIMP VLCInput::get_state(long* state)
{
if( NULL == state )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCInput::get_rate(float* rate)
+STDMETHODIMP VLCInput::get_rate(double* rate)
{
if( NULL == rate )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCInput::put_rate(float rate)
+STDMETHODIMP VLCInput::put_rate(double rate)
{
libvlc_instance_t* p_libvlc;
HRESULT hr = _p_instance->getVLC(&p_libvlc);
return hr;
};
-STDMETHODIMP VLCInput::get_fps(float* fps)
+STDMETHODIMP VLCInput::get_fps(double* fps)
{
if( NULL == fps )
return E_POINTER;
/*******************************************************************************/
+VLCLog::~VLCLog()
+{
+ if( _p_log )
+ libvlc_log_close(_p_log, NULL);
+
+ if( _p_typeinfo )
+ _p_typeinfo->Release();
+};
+
+HRESULT VLCLog::loadTypeInfo(void)
+{
+ HRESULT hr = NOERROR;
+ if( NULL == _p_typeinfo )
+ {
+ ITypeLib *p_typelib;
+
+ hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
+ if( SUCCEEDED(hr) )
+ {
+ hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCLog, &_p_typeinfo);
+ if( FAILED(hr) )
+ {
+ _p_typeinfo = NULL;
+ }
+ p_typelib->Release();
+ }
+ }
+ return hr;
+};
+
+STDMETHODIMP VLCLog::GetTypeInfoCount(UINT* pctInfo)
+{
+ if( NULL == pctInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ *pctInfo = 1;
+ else
+ *pctInfo = 0;
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCLog::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
+{
+ if( NULL == ppTInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ _p_typeinfo->AddRef();
+ *ppTInfo = _p_typeinfo;
+ return NOERROR;
+ }
+ *ppTInfo = NULL;
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCLog::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
+ UINT cNames, LCID lcid, DISPID* rgDispID)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCLog::Invoke(DISPID dispIdMember, REFIID riid,
+ LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
+ VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
+ pVarResult, pExcepInfo, puArgErr);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCLog::get_messages(IVLCMessages** obj)
+{
+ if( NULL == obj )
+ return E_POINTER;
+
+ *obj = _p_vlcmessages;
+ if( NULL != _p_vlcmessages )
+ {
+ _p_vlcmessages->AddRef();
+ return NOERROR;
+ }
+ return E_OUTOFMEMORY;
+};
+
+STDMETHODIMP VLCLog::get_verbosity(long* level)
+{
+ if( NULL == level )
+ return E_POINTER;
+
+ if( _p_log )
+ {
+ libvlc_instance_t* p_libvlc;
+ HRESULT hr = _p_instance->getVLC(&p_libvlc);
+ if( SUCCEEDED(hr) )
+ {
+ libvlc_exception_t ex;
+ libvlc_exception_init(&ex);
+
+ *level = libvlc_get_log_verbosity(p_libvlc, &ex);
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ return hr;
+ }
+ else
+ {
+ /* log is not enabled, return -1 */
+ *level = -1;
+ return NOERROR;
+ }
+};
+
+STDMETHODIMP VLCLog::put_verbosity(long verbosity)
+{
+ libvlc_exception_t ex;
+ libvlc_exception_init(&ex);
+
+ libvlc_instance_t* p_libvlc;
+ HRESULT hr = _p_instance->getVLC(&p_libvlc);
+ if( SUCCEEDED(hr) )
+ {
+ if( verbosity >= 0 )
+ {
+ if( ! _p_log )
+ {
+ _p_log = libvlc_log_open(p_libvlc, &ex);
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ libvlc_set_log_verbosity(p_libvlc, (unsigned)verbosity, &ex);
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ else if( _p_log )
+ {
+ /* close log when verbosity is set to -1 */
+ libvlc_log_close(_p_log, &ex);
+ _p_log = NULL;
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ }
+ return hr;
+};
+
+/*******************************************************************************/
+
+VLCMessages::~VLCMessages()
+{
+ if( _p_typeinfo )
+ _p_typeinfo->Release();
+};
+
+HRESULT VLCMessages::loadTypeInfo(void)
+{
+ HRESULT hr = NOERROR;
+ if( NULL == _p_typeinfo )
+ {
+ ITypeLib *p_typelib;
+
+ hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
+ if( SUCCEEDED(hr) )
+ {
+ hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCMessages, &_p_typeinfo);
+ if( FAILED(hr) )
+ {
+ _p_typeinfo = NULL;
+ }
+ p_typelib->Release();
+ }
+ }
+ return hr;
+};
+
+STDMETHODIMP VLCMessages::GetTypeInfoCount(UINT* pctInfo)
+{
+ if( NULL == pctInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ *pctInfo = 1;
+ else
+ *pctInfo = 0;
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessages::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
+{
+ if( NULL == ppTInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ _p_typeinfo->AddRef();
+ *ppTInfo = _p_typeinfo;
+ return NOERROR;
+ }
+ *ppTInfo = NULL;
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessages::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
+ UINT cNames, LCID lcid, DISPID* rgDispID)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessages::Invoke(DISPID dispIdMember, REFIID riid,
+ LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
+ VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
+ pVarResult, pExcepInfo, puArgErr);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessages::get__NewEnum(LPUNKNOWN* _NewEnum)
+{
+ if( NULL == _NewEnum )
+ return E_POINTER;
+
+ // TODO
+ *_NewEnum = NULL;
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessages::clear()
+{
+ libvlc_log_t *p_log = _p_vlclog->_p_log;
+ if( p_log )
+ {
+ libvlc_exception_t ex;
+ libvlc_exception_init(&ex);
+
+ libvlc_log_clear(p_log, &ex);
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCMessages, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessages::get_count(long* count)
+{
+ if( NULL == count )
+ return E_POINTER;
+
+ libvlc_log_t *p_log = _p_vlclog->_p_log;
+ if( p_log )
+ {
+ libvlc_exception_t ex;
+ libvlc_exception_init(&ex);
+
+ *count = libvlc_log_count(p_log, &ex);
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCMessages, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ else
+ *count = 0;
+ return S_OK;
+};
+
+STDMETHODIMP VLCMessages::iterator(IVLCMessageIterator** iter)
+{
+ if( NULL == iter )
+ return E_POINTER;
+
+ *iter = new VLCMessageIterator(_p_instance, _p_vlclog);
+
+ return *iter ? S_OK : E_OUTOFMEMORY;
+};
+
+/*******************************************************************************/
+
+VLCMessageIterator::VLCMessageIterator(VLCPlugin *p_instance, VLCLog* p_vlclog ) :
+ _p_instance(p_instance),
+ _p_typeinfo(NULL),
+ _refcount(1),
+ _p_vlclog(p_vlclog)
+{
+ if( p_vlclog->_p_log )
+ {
+ _p_iter = libvlc_log_get_iterator(p_vlclog->_p_log, NULL);
+ }
+ else
+ _p_iter = NULL;
+};
+
+VLCMessageIterator::~VLCMessageIterator()
+{
+ if( _p_iter )
+ libvlc_log_iterator_free(_p_iter, NULL);
+
+ if( _p_typeinfo )
+ _p_typeinfo->Release();
+};
+
+HRESULT VLCMessageIterator::loadTypeInfo(void)
+{
+ HRESULT hr = NOERROR;
+ if( NULL == _p_typeinfo )
+ {
+ ITypeLib *p_typelib;
+
+ hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
+ if( SUCCEEDED(hr) )
+ {
+ hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCMessageIterator, &_p_typeinfo);
+ if( FAILED(hr) )
+ {
+ _p_typeinfo = NULL;
+ }
+ p_typelib->Release();
+ }
+ }
+ return hr;
+};
+
+STDMETHODIMP VLCMessageIterator::GetTypeInfoCount(UINT* pctInfo)
+{
+ if( NULL == pctInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ *pctInfo = 1;
+ else
+ *pctInfo = 0;
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessageIterator::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
+{
+ if( NULL == ppTInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ _p_typeinfo->AddRef();
+ *ppTInfo = _p_typeinfo;
+ return NOERROR;
+ }
+ *ppTInfo = NULL;
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessageIterator::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
+ UINT cNames, LCID lcid, DISPID* rgDispID)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessageIterator::Invoke(DISPID dispIdMember, REFIID riid,
+ LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
+ VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
+ pVarResult, pExcepInfo, puArgErr);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessageIterator::get_hasNext(VARIANT_BOOL* hasNext)
+{
+ if( NULL == hasNext )
+ return E_POINTER;
+
+ if( _p_iter && _p_vlclog->_p_log )
+ {
+ libvlc_exception_t ex;
+ libvlc_exception_init(&ex);
+
+ *hasNext = libvlc_log_iterator_has_next(_p_iter, &ex) ? VARIANT_TRUE : VARIANT_FALSE;
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCMessageIterator, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ }
+ else
+ {
+ *hasNext = VARIANT_FALSE;
+ }
+ return S_OK;
+};
+
+STDMETHODIMP VLCMessageIterator::next(IVLCMessage** message)
+{
+ if( NULL == message )
+ return E_POINTER;
+
+ if( _p_iter && _p_vlclog->_p_log )
+ {
+ struct libvlc_log_message_t buffer;
+
+ buffer.sizeof_msg = sizeof(buffer);
+
+ libvlc_exception_t ex;
+ libvlc_exception_init(&ex);
+
+ libvlc_log_iterator_next(_p_iter, &buffer, &ex);
+ if( libvlc_exception_raised(&ex) )
+ {
+ _p_instance->setErrorInfo(IID_IVLCMessageIterator, libvlc_exception_get_message(&ex));
+ libvlc_exception_clear(&ex);
+ return E_FAIL;
+ }
+ *message = new VLCMessage(_p_instance, buffer);
+ return *message ? NOERROR : E_OUTOFMEMORY;
+ }
+ return E_FAIL;
+};
+
+/*******************************************************************************/
+
+VLCMessage::~VLCMessage()
+{
+ if( _p_typeinfo )
+ _p_typeinfo->Release();
+};
+
+HRESULT VLCMessage::loadTypeInfo(void)
+{
+ HRESULT hr = NOERROR;
+ if( NULL == _p_typeinfo )
+ {
+ ITypeLib *p_typelib;
+
+ hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
+ if( SUCCEEDED(hr) )
+ {
+ hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCMessage, &_p_typeinfo);
+ if( FAILED(hr) )
+ {
+ _p_typeinfo = NULL;
+ }
+ p_typelib->Release();
+ }
+ }
+ return hr;
+};
+
+STDMETHODIMP VLCMessage::GetTypeInfoCount(UINT* pctInfo)
+{
+ if( NULL == pctInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ *pctInfo = 1;
+ else
+ *pctInfo = 0;
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessage::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
+{
+ if( NULL == ppTInfo )
+ return E_INVALIDARG;
+
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ _p_typeinfo->AddRef();
+ *ppTInfo = _p_typeinfo;
+ return NOERROR;
+ }
+ *ppTInfo = NULL;
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessage::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
+ UINT cNames, LCID lcid, DISPID* rgDispID)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
+ }
+ return E_NOTIMPL;
+};
+
+STDMETHODIMP VLCMessage::Invoke(DISPID dispIdMember, REFIID riid,
+ LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
+ VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+ if( SUCCEEDED(loadTypeInfo()) )
+ {
+ return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
+ pVarResult, pExcepInfo, puArgErr);
+ }
+ return E_NOTIMPL;
+};
+
+inline const char *msgSeverity(int sev)
+{
+ switch( sev )
+ {
+ case 0:
+ return "info";
+ case 1:
+ return "error";
+ case 2:
+ return "warning";
+ default:
+ return "debug";
+ }
+};
+
+STDMETHODIMP VLCMessage::get__Value(VARIANT* _Value)
+{
+ if( NULL == _Value )
+ return E_POINTER;
+
+ char buffer[256];
+
+ snprintf(buffer, sizeof(buffer), "%s %s %s: %s",
+ _msg.psz_type, _msg.psz_name, msgSeverity(_msg.i_severity), _msg.psz_message);
+
+ V_VT(_Value) = VT_BSTR;
+ V_BSTR(_Value) = BSTRFromCStr(CP_UTF8, buffer);
+
+ return S_OK;
+};
+
+STDMETHODIMP VLCMessage::get_severity(long* level)
+{
+ if( NULL == level )
+ return E_POINTER;
+
+ *level = _msg.i_severity;
+
+ return S_OK;
+};
+
+STDMETHODIMP VLCMessage::get_type(BSTR* type)
+{
+ if( NULL == type )
+ return E_POINTER;
+
+ *type = BSTRFromCStr(CP_UTF8, _msg.psz_type);
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessage::get_name(BSTR* name)
+{
+ if( NULL == name )
+ return E_POINTER;
+
+ *name = BSTRFromCStr(CP_UTF8, _msg.psz_name);
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessage::get_header(BSTR* header)
+{
+ if( NULL == header )
+ return E_POINTER;
+
+ *header = BSTRFromCStr(CP_UTF8, _msg.psz_header);
+
+ return NOERROR;
+};
+
+STDMETHODIMP VLCMessage::get_message(BSTR* message)
+{
+ if( NULL == message )
+ return E_POINTER;
+
+ *message = BSTRFromCStr(CP_UTF8, _msg.psz_message);
+
+ return NOERROR;
+};
+
+/*******************************************************************************/
+
VLCPlaylist::~VLCPlaylist()
{
if( _p_typeinfo )
return E_NOTIMPL;
};
-STDMETHODIMP VLCPlaylist::get_itemCount(int* count)
+STDMETHODIMP VLCPlaylist::get_itemCount(long* count)
{
if( NULL == count )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCPlaylist::add(BSTR uri, VARIANT name, VARIANT options, int* item)
+STDMETHODIMP VLCPlaylist::add(BSTR uri, VARIANT name, VARIANT options, long* item)
{
if( NULL == item )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCPlaylist::playItem(int item)
+STDMETHODIMP VLCPlaylist::playItem(long item)
{
libvlc_instance_t* p_libvlc;
HRESULT hr = _p_instance->getVLC(&p_libvlc);
return hr;
};
-STDMETHODIMP VLCPlaylist::removeItem(int item)
+STDMETHODIMP VLCPlaylist::removeItem(long item)
{
libvlc_instance_t* p_libvlc;
HRESULT hr = _p_instance->getVLC(&p_libvlc);
return hr;
};
-STDMETHODIMP VLCVideo::get_width(int* width)
+STDMETHODIMP VLCVideo::get_width(long* width)
{
if( NULL == width )
return E_POINTER;
return hr;
};
-STDMETHODIMP VLCVideo::get_height(int* height)
+STDMETHODIMP VLCVideo::get_height(long* height)
{
if( NULL == height )
return E_POINTER;
{
_p_vlcaudio = new VLCAudio(p_instance);
_p_vlcinput = new VLCInput(p_instance);
+ _p_vlclog = new VLCLog(p_instance);
_p_vlcplaylist = new VLCPlaylist(p_instance);
_p_vlcvideo = new VLCVideo(p_instance);
};
{
delete _p_vlcvideo;
delete _p_vlcplaylist;
+ delete _p_vlclog;
delete _p_vlcinput;
delete _p_vlcaudio;
if( _p_typeinfo )
return S_OK;
};
-STDMETHODIMP VLCControl2::get_StartTime(int *seconds)
+STDMETHODIMP VLCControl2::get_StartTime(long *seconds)
{
if( NULL == seconds )
return E_POINTER;
return S_OK;
};
-STDMETHODIMP VLCControl2::put_StartTime(int seconds)
+STDMETHODIMP VLCControl2::put_StartTime(long seconds)
{
_p_instance->setStartTime(seconds);
return NOERROR;
};
-STDMETHODIMP VLCControl2::get_Volume(int *volume)
+STDMETHODIMP VLCControl2::get_Volume(long *volume)
{
if( NULL == volume )
return E_POINTER;
return NOERROR;
};
-STDMETHODIMP VLCControl2::put_Volume(int volume)
+STDMETHODIMP VLCControl2::put_Volume(long volume)
{
_p_instance->setVolume(volume);
return NOERROR;
return E_OUTOFMEMORY;
};
+STDMETHODIMP VLCControl2::get_log(IVLCLog** obj)
+{
+ if( NULL == obj )
+ return E_POINTER;
+
+ *obj = _p_vlclog;
+ if( NULL != _p_vlclog )
+ {
+ _p_vlclog->AddRef();
+ return NOERROR;
+ }
+ return E_OUTOFMEMORY;
+};
+
STDMETHODIMP VLCControl2::get_playlist(IVLCPlaylist** obj)
{
if( NULL == obj )
#include "axvlc_idl.h"
+#include <vlc/libvlc.h>
+
class VLCAudio : public IVLCAudio
{
public:
// IVLCAudio methods
STDMETHODIMP get_mute(VARIANT_BOOL*);
STDMETHODIMP put_mute(VARIANT_BOOL);
- STDMETHODIMP get_volume(int*);
- STDMETHODIMP put_volume(int);
+ STDMETHODIMP get_volume(long*);
+ STDMETHODIMP put_volume(long);
STDMETHODIMP toggleMute();
protected:
// IVLCInput methods
STDMETHODIMP get_length(double*);
- STDMETHODIMP get_position(float*);
- STDMETHODIMP put_position(float);
+ STDMETHODIMP get_position(double*);
+ STDMETHODIMP put_position(double);
STDMETHODIMP get_time(double*);
STDMETHODIMP put_time(double);
- STDMETHODIMP get_state(int*);
- STDMETHODIMP get_rate(float*);
- STDMETHODIMP put_rate(float);
- STDMETHODIMP get_fps(float*);
+ STDMETHODIMP get_state(long*);
+ STDMETHODIMP get_rate(double*);
+ STDMETHODIMP put_rate(double);
+ STDMETHODIMP get_fps(double*);
STDMETHODIMP get_hasVout(VARIANT_BOOL*);
protected:
};
+class VLCMessage: public IVLCMessage
+{
+public:
+
+ VLCMessage(VLCPlugin *p_instance, struct libvlc_log_message_t &msg) :
+ _p_instance(p_instance),
+ _p_typeinfo(NULL),
+ _refcount(1),
+ _msg(msg) {};
+ virtual ~VLCMessage();
+
+ // IUnknown methods
+ STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+ {
+ if( NULL == ppv )
+ return E_POINTER;
+ if( (IID_IUnknown == riid)
+ || (IID_IDispatch == riid)
+ || (IID_IVLCMessage == riid) )
+ {
+ AddRef();
+ *ppv = reinterpret_cast<LPVOID>(this);
+ return NOERROR;
+ }
+ // behaves as a standalone object
+ return E_NOINTERFACE;
+ };
+
+ STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
+ STDMETHODIMP_(ULONG) Release(void)
+ {
+ ULONG refcount = InterlockedDecrement(&_refcount);
+ if( 0 == refcount )
+ {
+ delete this;
+ return 0;
+ }
+ return refcount;
+ };
+
+ // IDispatch methods
+ STDMETHODIMP GetTypeInfoCount(UINT*);
+ STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
+ STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
+ STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
+
+ // IVLCMessage methods
+ STDMETHODIMP get__Value(VARIANT *);
+ STDMETHODIMP get_severity(long *);
+ STDMETHODIMP get_type(BSTR *);
+ STDMETHODIMP get_name(BSTR *);
+ STDMETHODIMP get_header(BSTR *);
+ STDMETHODIMP get_message(BSTR *);
+
+protected:
+ HRESULT loadTypeInfo();
+
+private:
+ VLCPlugin* _p_instance;
+ ITypeInfo* _p_typeinfo;
+ LONG _refcount;
+
+ struct libvlc_log_message_t _msg;
+};
+
+class VLCLog;
+
+class VLCMessageIterator : public IVLCMessageIterator
+{
+public:
+
+ VLCMessageIterator(VLCPlugin *p_instance, VLCLog* p_vlclog);
+ virtual ~VLCMessageIterator();
+
+ // IUnknown methods
+ STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+ {
+ if( NULL == ppv )
+ return E_POINTER;
+ if( (IID_IUnknown == riid)
+ || (IID_IDispatch == riid)
+ || (IID_IVLCMessageIterator == riid) )
+ {
+ AddRef();
+ *ppv = reinterpret_cast<LPVOID>(this);
+ return NOERROR;
+ }
+ // behaves as a standalone object
+ return E_NOINTERFACE;
+ };
+
+ STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
+ STDMETHODIMP_(ULONG) Release(void)
+ {
+ ULONG refcount = InterlockedDecrement(&_refcount);
+ if( 0 == refcount )
+ {
+ delete this;
+ return 0;
+ }
+ return refcount;
+ };
+
+ // IDispatch methods
+ STDMETHODIMP GetTypeInfoCount(UINT*);
+ STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
+ STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
+ STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
+
+ // IVLCMessageIterator methods
+ STDMETHODIMP get_hasNext(VARIANT_BOOL*);
+ STDMETHODIMP next(IVLCMessage**);
+
+protected:
+ HRESULT loadTypeInfo();
+
+private:
+ VLCPlugin* _p_instance;
+ ITypeInfo* _p_typeinfo;
+ LONG _refcount;
+
+ VLCLog* _p_vlclog;
+ libvlc_log_iterator_t* _p_iter;
+};
+
+class VLCMessages : public IVLCMessages
+{
+public:
+
+ VLCMessages(VLCPlugin *p_instance, VLCLog *p_vlclog) :
+ _p_instance(p_instance),
+ _p_typeinfo(NULL),
+ _p_vlclog(p_vlclog) {};
+ virtual ~VLCMessages();
+
+ // IUnknown methods
+ STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+ {
+ if( NULL == ppv )
+ return E_POINTER;
+ if( (IID_IUnknown == riid)
+ || (IID_IDispatch == riid)
+ || (IID_IVLCMessages == riid) )
+ {
+ AddRef();
+ *ppv = reinterpret_cast<LPVOID>(this);
+ return NOERROR;
+ }
+ // behaves as a standalone object
+ return E_NOINTERFACE;
+ };
+
+ STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
+ STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
+
+ // IDispatch methods
+ STDMETHODIMP GetTypeInfoCount(UINT*);
+ STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
+ STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
+ STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
+
+ // IVLCMessages methods
+ STDMETHODIMP get__NewEnum(LPUNKNOWN*);
+ STDMETHODIMP clear();
+ STDMETHODIMP get_count(long*);
+ STDMETHODIMP iterator(IVLCMessageIterator**);
+
+protected:
+ HRESULT loadTypeInfo();
+
+ VLCLog* _p_vlclog;
+
+private:
+ VLCPlugin* _p_instance;
+ ITypeInfo* _p_typeinfo;
+};
+
+class VLCLog : public IVLCLog
+{
+public:
+
+ friend class VLCMessages;
+ friend class VLCMessageIterator;
+
+ VLCLog(VLCPlugin *p_instance) :
+ _p_instance(p_instance),
+ _p_typeinfo(NULL),
+ _p_log(NULL)
+ {
+ _p_vlcmessages = new VLCMessages(p_instance, this);
+ };
+ virtual ~VLCLog();
+
+ // IUnknown methods
+ STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
+ {
+ if( NULL == ppv )
+ return E_POINTER;
+ if( (IID_IUnknown == riid)
+ || (IID_IDispatch == riid)
+ || (IID_IVLCLog == riid) )
+ {
+ AddRef();
+ *ppv = reinterpret_cast<LPVOID>(this);
+ return NOERROR;
+ }
+ // behaves as a standalone object
+ return E_NOINTERFACE;
+ };
+
+ STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
+ STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
+
+ // IDispatch methods
+ STDMETHODIMP GetTypeInfoCount(UINT*);
+ STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
+ STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
+ STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
+
+ // IVLCLog methods
+ STDMETHODIMP get_messages(IVLCMessages**);
+ STDMETHODIMP get_verbosity(long *);
+ STDMETHODIMP put_verbosity(long);
+
+protected:
+ HRESULT loadTypeInfo();
+
+ libvlc_log_t *_p_log;
+
+private:
+ VLCPlugin* _p_instance;
+ ITypeInfo* _p_typeinfo;
+
+ VLCMessages* _p_vlcmessages;
+};
+
class VLCPlaylist : public IVLCPlaylist
{
public:
STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
// IVLCPlaylist methods
- STDMETHODIMP get_itemCount(int*);
+ STDMETHODIMP get_itemCount(long*);
STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
- STDMETHODIMP add(BSTR, VARIANT, VARIANT, int*);
+ STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
STDMETHODIMP play();
- STDMETHODIMP playItem(int);
+ STDMETHODIMP playItem(long);
STDMETHODIMP togglePause();
STDMETHODIMP stop();
STDMETHODIMP next();
STDMETHODIMP prev();
STDMETHODIMP clear();
- STDMETHODIMP removeItem(int);
+ STDMETHODIMP removeItem(long);
protected:
HRESULT loadTypeInfo();
// IVLCVideo methods
STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
STDMETHODIMP put_fullscreen(VARIANT_BOOL);
- STDMETHODIMP get_width(int*);
- STDMETHODIMP get_height(int*);
+ STDMETHODIMP get_width(long*);
+ STDMETHODIMP get_height(long*);
STDMETHODIMP toggleFullscreen();
protected:
STDMETHODIMP put_BaseURL(BSTR url);
STDMETHODIMP get_MRL(BSTR *mrl);
STDMETHODIMP put_MRL(BSTR mrl);
- STDMETHODIMP get_StartTime(int *seconds);
- STDMETHODIMP put_StartTime(int seconds);
+ STDMETHODIMP get_StartTime(long *seconds);
+ STDMETHODIMP put_StartTime(long seconds);
STDMETHODIMP get_VersionInfo(BSTR *version);
STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
STDMETHODIMP put_Visible(VARIANT_BOOL visible);
- STDMETHODIMP get_Volume(int *volume);
- STDMETHODIMP put_Volume(int volume);
+ STDMETHODIMP get_Volume(long *volume);
+ STDMETHODIMP put_Volume(long volume);
STDMETHODIMP get_audio(IVLCAudio**);
STDMETHODIMP get_input(IVLCInput**);
+ STDMETHODIMP get_log(IVLCLog**);
STDMETHODIMP get_playlist(IVLCPlaylist**);
STDMETHODIMP get_video(IVLCVideo**);
VLCAudio* _p_vlcaudio;
VLCInput* _p_vlcinput;
+ VLCLog * _p_vlclog;
VLCPlaylist* _p_vlcplaylist;
VLCVideo* _p_vlcvideo;
};
projects / vlc / commitdiff