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