- add log APIs to Activex
authorDamien Fouilleul <damienf@videolan.org>
Fri, 27 Oct 2006 16:09:02 +0000 (16:09 +0000)
committerDamien Fouilleul <damienf@videolan.org>
Fri, 27 Oct 2006 16:09:02 +0000 (16:09 +0000)
- cleanup

activex/axvlc.idl
activex/axvlc.tlb
activex/axvlc_idl.c
activex/axvlc_idl.h
activex/supporterrorinfo.cpp
activex/test.html
activex/vlccontrol.cpp
activex/vlccontrol2.cpp
activex/vlccontrol2.h

index b29ee07..25b401b 100644 (file)
@@ -36,6 +36,10 @@ library AXVLC
     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
@@ -192,9 +196,9 @@ library AXVLC
         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
@@ -215,9 +219,9 @@ library AXVLC
         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
@@ -225,20 +229,112 @@ library AXVLC
         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
@@ -251,19 +347,19 @@ library AXVLC
     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
@@ -281,7 +377,7 @@ library AXVLC
         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
@@ -301,10 +397,10 @@ library AXVLC
         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
@@ -336,9 +432,9 @@ library AXVLC
         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
@@ -354,9 +450,9 @@ library AXVLC
         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
@@ -364,6 +460,9 @@ library AXVLC
         [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
index 011039e..7d16cb6 100644 (file)
Binary files a/activex/axvlc.tlb and b/activex/axvlc.tlb differ
index b2cba3e..456cfca 100644 (file)
@@ -15,6 +15,10 @@ DEFINE_GUID(IID_IVLCControl, 0xc2fa41d0, 0xb113, 0x476e, 0xac,0x8c, 0x9b,0xd1,0x
 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);
index 3a6a7b6..838d20f 100644 (file)
@@ -26,6 +26,26 @@ typedef interface IVLCAudio IVLCAudio;
 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;
@@ -786,10 +806,10 @@ interface IVLCAudio : public IDispatch
         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;
@@ -852,11 +872,11 @@ typedef struct IVLCAudioVtbl {
 
     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);
@@ -905,7 +925,7 @@ void __RPC_STUB IVLCAudio_put_mute_Stub(
     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,
@@ -913,7 +933,7 @@ void __RPC_STUB IVLCAudio_get_volume_Stub(
     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,
@@ -943,10 +963,10 @@ interface IVLCInput : public IDispatch
         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;
@@ -955,16 +975,16 @@ interface IVLCInput : public IDispatch
         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;
@@ -1023,11 +1043,11 @@ typedef struct IVLCInputVtbl {
 
     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,
@@ -1039,19 +1059,19 @@ typedef struct IVLCInputVtbl {
 
     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,
@@ -1098,7 +1118,7 @@ void __RPC_STUB IVLCInput_get_length_Stub(
     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,
@@ -1106,7 +1126,7 @@ void __RPC_STUB IVLCInput_get_position_Stub(
     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,
@@ -1130,7 +1150,7 @@ void __RPC_STUB IVLCInput_put_time_Stub(
     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,
@@ -1138,7 +1158,7 @@ void __RPC_STUB IVLCInput_get_state_Stub(
     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,
@@ -1146,7 +1166,7 @@ void __RPC_STUB IVLCInput_get_rate_Stub(
     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,
@@ -1154,7 +1174,7 @@ void __RPC_STUB IVLCInput_put_rate_Stub(
     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,
@@ -1171,6 +1191,572 @@ void __RPC_STUB IVLCInput_get_hasVout_Stub(
 
 #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
  */
@@ -1182,7 +1768,7 @@ DEFINE_GUID(IID_IVLCPlaylist, 0x54613049, 0x40bf, 0x4035, 0x9e,0x70, 0x0a,0x93,0
 interface IVLCPlaylist : public IDispatch
 {
     virtual HRESULT STDMETHODCALLTYPE get_itemCount(
-        int* count) = 0;
+        long* count) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE get_isPlaying(
         VARIANT_BOOL* playing) = 0;
@@ -1191,13 +1777,13 @@ interface IVLCPlaylist : public IDispatch
         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;
@@ -1215,7 +1801,7 @@ interface IVLCPlaylist : public IDispatch
         ) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE removeItem(
-        int item) = 0;
+        long item) = 0;
 
 };
 #else
@@ -1267,7 +1853,7 @@ typedef struct IVLCPlaylistVtbl {
     /*** IVLCPlaylist methods ***/
     HRESULT (STDMETHODCALLTYPE *get_itemCount)(
         IVLCPlaylist* This,
-        int* count);
+        long* count);
 
     HRESULT (STDMETHODCALLTYPE *get_isPlaying)(
         IVLCPlaylist* This,
@@ -1278,14 +1864,14 @@ typedef struct IVLCPlaylistVtbl {
         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);
@@ -1304,7 +1890,7 @@ typedef struct IVLCPlaylistVtbl {
 
     HRESULT (STDMETHODCALLTYPE *removeItem)(
         IVLCPlaylist* This,
-        int item);
+        long item);
 
     END_INTERFACE
 } IVLCPlaylistVtbl;
@@ -1340,7 +1926,7 @@ interface IVLCPlaylist {
 
 HRESULT CALLBACK IVLCPlaylist_get_itemCount_Proxy(
     IVLCPlaylist* This,
-    int* count);
+    long* count);
 void __RPC_STUB IVLCPlaylist_get_itemCount_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
@@ -1359,7 +1945,7 @@ HRESULT CALLBACK IVLCPlaylist_add_Proxy(
     BSTR uri,
     VARIANT name,
     VARIANT options,
-    int* item);
+    long* item);
 void __RPC_STUB IVLCPlaylist_add_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
@@ -1374,7 +1960,7 @@ void __RPC_STUB IVLCPlaylist_play_Stub(
     DWORD* pdwStubPhase);
 HRESULT CALLBACK IVLCPlaylist_playItem_Proxy(
     IVLCPlaylist* This,
-    int item);
+    long item);
 void __RPC_STUB IVLCPlaylist_playItem_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
@@ -1417,7 +2003,7 @@ void __RPC_STUB IVLCPlaylist_clear_Stub(
     DWORD* pdwStubPhase);
 HRESULT CALLBACK IVLCPlaylist_removeItem_Proxy(
     IVLCPlaylist* This,
-    int item);
+    long item);
 void __RPC_STUB IVLCPlaylist_removeItem_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
@@ -1443,10 +2029,10 @@ interface IVLCVideo : public IDispatch
         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;
@@ -1509,11 +2095,11 @@ typedef struct IVLCVideoVtbl {
 
     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);
@@ -1562,7 +2148,7 @@ void __RPC_STUB IVLCVideo_put_fullscreen_Stub(
     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,
@@ -1570,7 +2156,7 @@ void __RPC_STUB IVLCVideo_get_width_Stub(
     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,
@@ -1615,10 +2201,10 @@ interface IVLCControl2 : public IDispatch
         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;
@@ -1636,10 +2222,10 @@ interface IVLCControl2 : public IDispatch
         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;
@@ -1647,6 +2233,9 @@ interface IVLCControl2 : public IDispatch
     virtual HRESULT STDMETHODCALLTYPE get_input(
         IVLCInput** obj) = 0;
 
+    virtual HRESULT STDMETHODCALLTYPE get_log(
+        IVLCLog** obj) = 0;
+
     virtual HRESULT STDMETHODCALLTYPE get_playlist(
         IVLCPlaylist** obj) = 0;
 
@@ -1727,11 +2316,11 @@ typedef struct IVLCControl2Vtbl {
 
     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,
@@ -1755,11 +2344,11 @@ typedef struct IVLCControl2Vtbl {
 
     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,
@@ -1769,6 +2358,10 @@ typedef struct IVLCControl2Vtbl {
         IVLCControl2* This,
         IVLCInput** obj);
 
+    HRESULT (STDMETHODCALLTYPE *get_log)(
+        IVLCControl2* This,
+        IVLCLog** obj);
+
     HRESULT (STDMETHODCALLTYPE *get_playlist)(
         IVLCControl2* This,
         IVLCPlaylist** obj);
@@ -1811,6 +2404,7 @@ interface IVLCControl2 {
 #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
@@ -1867,7 +2461,7 @@ void __RPC_STUB IVLCControl2_put_BaseURL_Stub(
     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,
@@ -1875,7 +2469,7 @@ void __RPC_STUB IVLCControl2_get_StartTime_Stub(
     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,
@@ -1923,7 +2517,7 @@ void __RPC_STUB IVLCControl2_put_Visible_Stub(
     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,
@@ -1931,7 +2525,7 @@ void __RPC_STUB IVLCControl2_get_Volume_Stub(
     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,
@@ -1953,6 +2547,14 @@ void __RPC_STUB IVLCControl2_get_input_Stub(
     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);
index 6982558..37136dd 100755 (executable)
@@ -32,6 +32,10 @@ STDMETHODIMP VLCSupportErrorInfo::InterfaceSupportsErrorInfo(REFIID  riid)
 {
     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) )
index 3d5aa85..2dc4f69 100644 (file)
@@ -81,54 +81,64 @@ function formatTime(timeVal)
     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
@@ -138,14 +148,16 @@ function monitor()
 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
@@ -153,15 +165,16 @@ function doPlayOrPause()
     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
@@ -169,8 +182,8 @@ function doStop()
     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
@@ -208,28 +221,28 @@ function onPlaying()
 {\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
@@ -238,6 +251,7 @@ function onPause()
 };\r
 function onStop()\r
 {\r
+    vlc.log.verbosity = -1;\r
     if( slider.Enabled )\r
     {\r
         slider.Value = slider.Min;\r
@@ -268,8 +282,8 @@ function slider::Scroll()
     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
index f45760b..66b0109 100644 (file)
@@ -845,7 +845,7 @@ STDMETHODIMP VLCControl::get_VersionInfo(BSTR *version)
     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;
     }
index de0b288..711c26f 100755 (executable)
@@ -150,7 +150,7 @@ STDMETHODIMP VLCAudio::put_mute(VARIANT_BOOL mute)
     return hr;
 };
 
-STDMETHODIMP VLCAudio::get_volume(int* volume)
+STDMETHODIMP VLCAudio::get_volume(long* volume)
 {
     if( NULL == volume )
         return E_POINTER;
@@ -174,7 +174,7 @@ STDMETHODIMP VLCAudio::get_volume(int* volume)
     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);
@@ -324,7 +324,7 @@ STDMETHODIMP VLCInput::get_length(double* length)
     return hr;
 };
 
-STDMETHODIMP VLCInput::get_position(float* position)
+STDMETHODIMP VLCInput::get_position(double* position)
 {
     if( NULL == position )
         return E_POINTER;
@@ -353,7 +353,7 @@ STDMETHODIMP VLCInput::get_position(float* position)
     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);
@@ -434,7 +434,7 @@ STDMETHODIMP VLCInput::put_time(double time)
     return hr;
 };
 
-STDMETHODIMP VLCInput::get_state(int* state)
+STDMETHODIMP VLCInput::get_state(long* state)
 {
     if( NULL == state )
         return E_POINTER;
@@ -464,7 +464,7 @@ STDMETHODIMP VLCInput::get_state(int* state)
     return hr;
 };
 
-STDMETHODIMP VLCInput::get_rate(float* rate)
+STDMETHODIMP VLCInput::get_rate(double* rate)
 {
     if( NULL == rate )
         return E_POINTER;
@@ -493,7 +493,7 @@ STDMETHODIMP VLCInput::get_rate(float* rate)
     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);
@@ -519,7 +519,7 @@ STDMETHODIMP VLCInput::put_rate(float rate)
     return hr;
 };
 
-STDMETHODIMP VLCInput::get_fps(float* fps)
+STDMETHODIMP VLCInput::get_fps(double* fps)
 {
     if( NULL == fps )
         return E_POINTER;
@@ -579,6 +579,629 @@ STDMETHODIMP VLCInput::get_hasVout(VARIANT_BOOL* hasVout)
 
 /*******************************************************************************/
 
+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 )
@@ -656,7 +1279,7 @@ STDMETHODIMP VLCPlaylist::Invoke(DISPID dispIdMember, REFIID riid,
     return E_NOTIMPL;
 };
 
-STDMETHODIMP VLCPlaylist::get_itemCount(int* count)
+STDMETHODIMP VLCPlaylist::get_itemCount(long* count)
 {
     if( NULL == count )
         return E_POINTER;
@@ -706,7 +1329,7 @@ STDMETHODIMP VLCPlaylist::get_isPlaying(VARIANT_BOOL* isPlaying)
     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;
@@ -789,7 +1412,7 @@ STDMETHODIMP VLCPlaylist::play()
     return hr;
 };
 
-STDMETHODIMP VLCPlaylist::playItem(int item)
+STDMETHODIMP VLCPlaylist::playItem(long item)
 {
     libvlc_instance_t* p_libvlc;
     HRESULT hr = _p_instance->getVLC(&p_libvlc);
@@ -921,7 +1544,7 @@ STDMETHODIMP VLCPlaylist::clear()
     return hr;
 };
 
-STDMETHODIMP VLCPlaylist::removeItem(int item)
+STDMETHODIMP VLCPlaylist::removeItem(long item)
 {
     libvlc_instance_t* p_libvlc;
     HRESULT hr = _p_instance->getVLC(&p_libvlc);
@@ -1077,7 +1700,7 @@ STDMETHODIMP VLCVideo::put_fullscreen(VARIANT_BOOL fullscreen)
     return hr;
 };
 
-STDMETHODIMP VLCVideo::get_width(int* width)
+STDMETHODIMP VLCVideo::get_width(long* width)
 {
     if( NULL == width )
         return E_POINTER;
@@ -1106,7 +1729,7 @@ STDMETHODIMP VLCVideo::get_width(int* width)
     return hr;
 };
 
-STDMETHODIMP VLCVideo::get_height(int* height)
+STDMETHODIMP VLCVideo::get_height(long* height)
 {
     if( NULL == height )
         return E_POINTER;
@@ -1173,6 +1796,7 @@ VLCControl2::VLCControl2(VLCPlugin *p_instance) :
 {
     _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);
 };
@@ -1181,6 +1805,7 @@ VLCControl2::~VLCControl2()
 {
     delete _p_vlcvideo;
     delete _p_vlcplaylist;
+    delete _p_vlclog;
     delete _p_vlcinput;
     delete _p_vlcaudio;
     if( _p_typeinfo )
@@ -1322,7 +1947,7 @@ STDMETHODIMP VLCControl2::put_MRL(BSTR mrl)
     return S_OK;
 };
 
-STDMETHODIMP VLCControl2::get_StartTime(int *seconds)
+STDMETHODIMP VLCControl2::get_StartTime(long *seconds)
 {
     if( NULL == seconds )
         return E_POINTER;
@@ -1332,7 +1957,7 @@ STDMETHODIMP VLCControl2::get_StartTime(int *seconds)
     return S_OK;
 };
      
-STDMETHODIMP VLCControl2::put_StartTime(int seconds)
+STDMETHODIMP VLCControl2::put_StartTime(long seconds)
 {
     _p_instance->setStartTime(seconds);
 
@@ -1372,7 +1997,7 @@ STDMETHODIMP VLCControl2::put_Visible(VARIANT_BOOL isVisible)
     return NOERROR;
 };
 
-STDMETHODIMP VLCControl2::get_Volume(int *volume)
+STDMETHODIMP VLCControl2::get_Volume(long *volume)
 {
     if( NULL == volume )
         return E_POINTER;
@@ -1381,7 +2006,7 @@ STDMETHODIMP VLCControl2::get_Volume(int *volume)
     return NOERROR;
 };
         
-STDMETHODIMP VLCControl2::put_Volume(int volume)
+STDMETHODIMP VLCControl2::put_Volume(long volume)
 {
     _p_instance->setVolume(volume);
     return NOERROR;
@@ -1415,6 +2040,20 @@ STDMETHODIMP VLCControl2::get_input(IVLCInput** obj)
     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 )
index 8b75bbe..a1b7481 100755 (executable)
@@ -25,6 +25,8 @@
 
 #include "axvlc_idl.h"
 
+#include <vlc/libvlc.h>
+
 class VLCAudio : public IVLCAudio
 {
 public:
@@ -61,8 +63,8 @@ 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:
@@ -110,14 +112,14 @@ public:
 
     // 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:
@@ -129,6 +131,242 @@ private:
 
 };
  
+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:
@@ -163,17 +401,17 @@ 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();
@@ -220,8 +458,8 @@ public:
     // 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:
@@ -275,16 +513,17 @@ public:
     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**);
 
@@ -297,6 +536,7 @@ private:
 
     VLCAudio*       _p_vlcaudio;
     VLCInput*       _p_vlcinput;
+    VLCLog  *       _p_vlclog;
     VLCPlaylist*    _p_vlcplaylist;
     VLCVideo*       _p_vlcvideo;
 };