git.sesse.net Git - vlc/blob - projects/activex/vlccontrol2.h

   1 /*****************************************************************************
   2  * vlccontrol.h: ActiveX control for VLC
   3  *****************************************************************************
   4  * Copyright (C) 2006 the VideoLAN team
   5  * Copyright (C) 2010 M2X BV
   6  *
   7  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
   8  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #ifndef _VLCCONTROL2_H_
  26 #define _VLCCONTROL2_H_
  27
  28 #include "axvlc_idl.h"
  29
  30 #include <vlc/libvlc.h>
  31 #include <ole2.h>
  32
  33 class VLCInterfaceBase {
  34 public:
  35     VLCInterfaceBase(VLCPlugin *p): _plug(p), _ti(NULL) { }
  36     virtual ~VLCInterfaceBase() { if( _ti ) _ti->Release(); }
  37
  38     VLCPlugin *Instance() const { return _plug; }
  39     HRESULT getVLC(libvlc_instance_t **pp) const { return _plug->getVLC(pp); }
  40     HRESULT getMD(libvlc_media_player_t **pp) const { return _plug->getMD(pp); }
  41
  42 protected:
  43     HRESULT report_exception(REFIID riid, libvlc_exception_t *ex);
  44     HRESULT loadTypeInfo(REFIID riid);
  45     ITypeInfo *TypeInfo() const { return _ti; }
  46
  47     STDMETHODIMP_(ULONG) AddRef(void) { return _plug->pUnkOuter->AddRef(); };
  48     STDMETHODIMP_(ULONG) Release(void) { return _plug->pUnkOuter->Release(); };
  49 private:
  50     VLCPlugin *_plug;
  51     ITypeInfo *_ti;
  52 };
  53
  54 template<class T,class I>
  55 class VLCInterface: public I, private VLCInterfaceBase
  56 {
  57 private:
  58     typedef VLCInterfaceBase Base;
  59           T *This()       { return static_cast<      T *>(this); }
  60     const T *This() const { return static_cast<const T *>(this); }
  61
  62     HRESULT loadTypeInfo()
  63     {
  64         return TypeInfo() ? NOERROR : Base::loadTypeInfo(_riid);
  65     }
  66
  67 public:
  68     VLCInterface(VLCPlugin *p): Base(p) { }
  69     VLCPlugin *Instance() const { return Base::Instance(); }
  70
  71     HRESULT getVLC(libvlc_instance_t **pp) const { return Base::getVLC(pp); }
  72     HRESULT getMD(libvlc_media_player_t **pp) const { return Base::getMD(pp); }
  73
  74     HRESULT exception_bridge(libvlc_exception_t *ex)
  75     {
  76         return libvlc_exception_raised(ex) ?
  77             Base::report_exception(_riid,ex) : NOERROR;
  78     }
  79
  80     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  81     {
  82         if( NULL == ppv ) return E_POINTER;
  83
  84         if( (IID_IUnknown == riid)
  85          || (IID_IDispatch == riid)
  86          || (_riid == riid) )
  87         {
  88             This()->AddRef();
  89             *ppv = reinterpret_cast<LPVOID>(This());
  90             return NOERROR;
  91         }
  92         // behaves as a standalone object
  93         return E_NOINTERFACE;
  94     }
  95
  96     STDMETHODIMP GetTypeInfoCount(UINT* pctInfo)
  97     {
  98         if( NULL == pctInfo )
  99             return E_INVALIDARG;
 100         *pctInfo = SUCCEEDED(loadTypeInfo()) ? 1 : 0;
 101         return NOERROR;
 102     }
 103     STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
 104     {
 105         if( NULL == ppTInfo )
 106             return E_INVALIDARG;
 107
 108         if( SUCCEEDED(loadTypeInfo()) )
 109         {
 110             (*ppTInfo = TypeInfo())->AddRef();
 111             return NOERROR;
 112         }
 113         *ppTInfo = NULL;
 114         return E_NOTIMPL;
 115     }
 116
 117     STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
 118             UINT cNames, LCID lcid, DISPID* rgDispID)
 119     {
 120         return FAILED(loadTypeInfo()) ? E_NOTIMPL :
 121             DispGetIDsOfNames(TypeInfo(), rgszNames, cNames, rgDispID);
 122     }
 123
 124     STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid,
 125         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 126         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 127     {
 128         return FAILED(loadTypeInfo()) ? E_NOTIMPL :
 129             DispInvoke(This(), TypeInfo(), dispIdMember, wFlags,
 130                        pDispParams, pVarResult, pExcepInfo, puArgErr);
 131     }
 132
 133     STDMETHODIMP_(ULONG) AddRef(void)  { return Base::AddRef(); };
 134     STDMETHODIMP_(ULONG) Release(void) { return Base::Release(); };
 135 private:
 136     static REFIID _riid;
 137 };
 138
 139 class VLCAudio : public VLCInterface<VLCAudio,IVLCAudio>
 140 {
 141 public:
 142     VLCAudio(VLCPlugin *p): VLCInterface<VLCAudio,IVLCAudio>(p) { }
 143
 144     // IVLCAudio methods
 145     STDMETHODIMP get_mute(VARIANT_BOOL*);
 146     STDMETHODIMP put_mute(VARIANT_BOOL);
 147     STDMETHODIMP get_volume(long*);
 148     STDMETHODIMP put_volume(long);
 149     STDMETHODIMP get_track(long*);
 150     STDMETHODIMP put_track(long);
 151     STDMETHODIMP get_count(long*);
 152     STDMETHODIMP get_channel(long*);
 153     STDMETHODIMP put_channel(long);
 154     STDMETHODIMP toggleMute();
 155     STDMETHODIMP description(long, BSTR*);
 156 };
 157
 158 class VLCInput: public VLCInterface<VLCInput,IVLCInput>
 159 {
 160 public:
 161     VLCInput(VLCPlugin *p): VLCInterface<VLCInput,IVLCInput>(p) { }
 162
 163     // IVLCInput methods
 164     STDMETHODIMP get_length(double*);
 165     STDMETHODIMP get_position(double*);
 166     STDMETHODIMP put_position(double);
 167     STDMETHODIMP get_time(double*);
 168     STDMETHODIMP put_time(double);
 169     STDMETHODIMP get_state(long*);
 170     STDMETHODIMP get_rate(double*);
 171     STDMETHODIMP put_rate(double);
 172     STDMETHODIMP get_fps(double*);
 173     STDMETHODIMP get_hasVout(VARIANT_BOOL*);
 174 };
 175
 176 class VLCMarquee: public VLCInterface<VLCMarquee,IVLCMarquee>
 177 {
 178 public:
 179     VLCMarquee(VLCPlugin *p): VLCInterface<VLCMarquee,IVLCMarquee>(p) { }
 180
 181     // IVLCMarquee methods
 182     STDMETHODIMP enable()  { return do_put_int(libvlc_marquee_Enable, true); }
 183     STDMETHODIMP disable() { return do_put_int(libvlc_marquee_Enable, false); }
 184
 185     STDMETHODIMP get_text(BSTR *);
 186     STDMETHODIMP put_text(BSTR);
 187     STDMETHODIMP get_position(BSTR *);
 188     STDMETHODIMP put_position(BSTR);
 189
 190 #define PROP_INT( a, b ) \
 191         STDMETHODIMP get_##a(LONG *val) { return do_get_int(b,val); } \
 192         STDMETHODIMP put_##a(LONG val)  { return do_put_int(b,val); }
 193
 194     PROP_INT( color,    libvlc_marquee_Color )
 195     PROP_INT( opacity,  libvlc_marquee_Opacity )
 196     PROP_INT( refresh,  libvlc_marquee_Refresh )
 197     PROP_INT( size,     libvlc_marquee_Size )
 198     PROP_INT( timeout,  libvlc_marquee_Timeout )
 199     PROP_INT( x,        libvlc_marquee_X )
 200     PROP_INT( y,        libvlc_marquee_Y )
 201
 202 #undef  PROP_INT
 203
 204 private:
 205     HRESULT do_put_int(unsigned idx, LONG val);
 206     HRESULT do_get_int(unsigned idx, LONG *val);
 207 };
 208
 209
 210 class VLCLogo: public VLCInterface<VLCLogo,IVLCLogo>
 211 {
 212 public:
 213     VLCLogo(VLCPlugin *p): VLCInterface<VLCLogo,IVLCLogo>(p) { }
 214
 215     STDMETHODIMP enable()  { return do_put_int(libvlc_logo_enable, true); }
 216     STDMETHODIMP disable() { return do_put_int(libvlc_logo_enable, false); }
 217
 218     STDMETHODIMP file(BSTR fname);
 219
 220 #define PROP_INT( a ) \
 221         STDMETHODIMP get_##a(LONG *val) \
 222             { return do_get_int(libvlc_logo_##a,val); } \
 223         STDMETHODIMP put_##a(LONG val) \
 224             { return do_put_int(libvlc_logo_##a,val); }
 225
 226     PROP_INT( delay )
 227     PROP_INT( repeat )
 228     PROP_INT( opacity )
 229     PROP_INT( x )
 230     PROP_INT( y )
 231
 232 #undef  PROP_INT
 233
 234     STDMETHODIMP get_position(BSTR* val);
 235     STDMETHODIMP put_position(BSTR val);
 236
 237 private:
 238     HRESULT do_put_int(unsigned idx, LONG val);
 239     HRESULT do_get_int(unsigned idx, LONG *val);
 240 };
 241
 242
 243 class VLCDeinterlace: public VLCInterface<VLCDeinterlace,IVLCDeinterlace>
 244 {
 245 public:
 246     VLCDeinterlace(VLCPlugin *p):
 247         VLCInterface<VLCDeinterlace,IVLCDeinterlace>(p) { }
 248
 249     STDMETHODIMP enable(BSTR val);
 250     STDMETHODIMP disable();
 251 };
 252
 253
 254 class VLCPlaylistItems: public VLCInterface<VLCPlaylistItems,IVLCPlaylistItems>
 255 {
 256 public:
 257     VLCPlaylistItems(VLCPlugin *p):
 258         VLCInterface<VLCPlaylistItems,IVLCPlaylistItems>(p) { }
 259
 260     // IVLCPlaylistItems methods
 261     STDMETHODIMP get_count(long*);
 262     STDMETHODIMP clear();
 263     STDMETHODIMP remove(long);
 264 };
 265
 266 class VLCPlaylist: public VLCInterface<VLCPlaylist,IVLCPlaylist>
 267 {
 268 public:
 269     VLCPlaylist(VLCPlugin *p):
 270         VLCInterface<VLCPlaylist,IVLCPlaylist>(p),
 271         _p_vlcplaylistitems(new VLCPlaylistItems(p)) { }
 272     virtual ~VLCPlaylist() { delete _p_vlcplaylistitems; }
 273
 274     // IVLCPlaylist methods
 275     STDMETHODIMP get_itemCount(long*);
 276     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 277     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 278     STDMETHODIMP play();
 279     STDMETHODIMP playItem(long);
 280     STDMETHODIMP togglePause();
 281     STDMETHODIMP stop();
 282     STDMETHODIMP next();
 283     STDMETHODIMP prev();
 284     STDMETHODIMP clear();
 285     STDMETHODIMP removeItem(long);
 286     STDMETHODIMP get_items(IVLCPlaylistItems**);
 287
 288 private:
 289     VLCPlaylistItems*    _p_vlcplaylistitems;
 290 };
 291
 292 class VLCSubtitle: public VLCInterface<VLCSubtitle,IVLCSubtitle>
 293 {
 294 public:
 295     VLCSubtitle(VLCPlugin *p): VLCInterface<VLCSubtitle,IVLCSubtitle>(p) { }
 296
 297     // IVLCSubtitle methods
 298     STDMETHODIMP get_track(long*);
 299     STDMETHODIMP put_track(long);
 300     STDMETHODIMP get_count(long*);
 301     STDMETHODIMP description(long, BSTR*);
 302 };
 303
 304 class VLCVideo: public VLCInterface<VLCVideo,IVLCVideo>
 305 {
 306 public:
 307     VLCVideo(VLCPlugin *p): VLCInterface<VLCVideo,IVLCVideo>(p),
 308         _p_vlcmarquee(new VLCMarquee(p)), _p_vlclogo(new VLCLogo(p)),
 309         _p_vlcdeint(new VLCDeinterlace(p)) { }
 310     virtual ~VLCVideo() {
 311         delete _p_vlcmarquee;
 312         delete _p_vlclogo;
 313         delete _p_vlcdeint;
 314     }
 315
 316     // IVLCVideo methods
 317     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 318     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 319     STDMETHODIMP get_width(long*);
 320     STDMETHODIMP get_height(long*);
 321     STDMETHODIMP get_aspectRatio(BSTR*);
 322     STDMETHODIMP put_aspectRatio(BSTR);
 323     STDMETHODIMP get_subtitle(long*);
 324     STDMETHODIMP put_subtitle(long);
 325     STDMETHODIMP get_crop(BSTR*);
 326     STDMETHODIMP put_crop(BSTR);
 327     STDMETHODIMP get_teletext(long*);
 328     STDMETHODIMP put_teletext(long);
 329     STDMETHODIMP get_marquee(IVLCMarquee**);
 330     STDMETHODIMP get_logo(IVLCLogo**);
 331     STDMETHODIMP get_deinterlace(IVLCDeinterlace**);
 332     STDMETHODIMP takeSnapshot(LPPICTUREDISP*);
 333     STDMETHODIMP toggleFullscreen();
 334     STDMETHODIMP toggleTeletext();
 335
 336 private:
 337     IVLCMarquee     *_p_vlcmarquee;
 338     IVLCLogo        *_p_vlclogo;
 339     IVLCDeinterlace *_p_vlcdeint;
 340 };
 341
 342 class VLCControl2 : public IVLCControl2
 343 {
 344 public:
 345
 346     VLCControl2(VLCPlugin *p_instance);
 347     virtual ~VLCControl2();
 348
 349     // IUnknown methods
 350     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 351     {
 352         if( NULL == ppv )
 353           return E_POINTER;
 354         if( (IID_IUnknown == riid)
 355          || (IID_IDispatch == riid)
 356          || (IID_IVLCControl2 == riid) )
 357         {
 358             AddRef();
 359             *ppv = reinterpret_cast<LPVOID>(this);
 360             return NOERROR;
 361         }
 362         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 363     };
 364
 365     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 366     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 367
 368     // IDispatch methods
 369     STDMETHODIMP GetTypeInfoCount(UINT*);
 370     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 371     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 372     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 373
 374     // IVLCControl2 methods
 375     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 376     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 377     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 378     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 379     STDMETHODIMP get_BaseURL(BSTR *url);
 380     STDMETHODIMP put_BaseURL(BSTR url);
 381     STDMETHODIMP get_MRL(BSTR *mrl);
 382     STDMETHODIMP put_MRL(BSTR mrl);
 383     STDMETHODIMP get_Toolbar(VARIANT_BOOL *visible);
 384     STDMETHODIMP put_Toolbar(VARIANT_BOOL visible);
 385     STDMETHODIMP get_StartTime(long *seconds);
 386     STDMETHODIMP put_StartTime(long seconds);
 387     STDMETHODIMP get_VersionInfo(BSTR *version);
 388     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 389     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 390     STDMETHODIMP get_Volume(long *volume);
 391     STDMETHODIMP put_Volume(long volume);
 392     STDMETHODIMP get_BackColor(OLE_COLOR *backcolor);
 393     STDMETHODIMP put_BackColor(OLE_COLOR backcolor);
 394
 395     STDMETHODIMP get_audio(IVLCAudio**);
 396     STDMETHODIMP get_input(IVLCInput**);
 397     STDMETHODIMP get_playlist(IVLCPlaylist**);
 398     STDMETHODIMP get_subtitle(IVLCSubtitle**);
 399     STDMETHODIMP get_video(IVLCVideo**);
 400
 401 protected:
 402     HRESULT loadTypeInfo();
 403
 404 private:
 405     VLCPlugin    *_p_instance;
 406     ITypeInfo    *_p_typeinfo;
 407
 408     IVLCAudio    *_p_vlcaudio;
 409     IVLCInput    *_p_vlcinput;
 410     IVLCPlaylist *_p_vlcplaylist;
 411     IVLCSubtitle *_p_vlcsubtitle;
 412     IVLCVideo    *_p_vlcvideo;
 413 };
 414
 415 #endif