git.sesse.net Git - vlc/blob - 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  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifndef _VLCCONTROL2_H_
  24 #define _VLCCONTROL2_H_
  25
  26 #include "axvlc_idl.h"
  27
  28 #include <vlc/libvlc.h>
  29
  30 class VLCAudio : public IVLCAudio
  31 {
  32 public:
  33     VLCAudio(VLCPlugin *p_instance) :
  34         _p_instance(p_instance), _p_typeinfo(NULL) {};
  35     virtual ~VLCAudio();
  36
  37     // IUnknown methods
  38     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  39     {
  40         if( NULL == ppv )
  41           return E_POINTER;
  42         if( (IID_IUnknown == riid)
  43          || (IID_IDispatch == riid)
  44          || (IID_IVLCAudio == riid) )
  45         {
  46             AddRef();
  47             *ppv = reinterpret_cast<LPVOID>(this);
  48             return NOERROR;
  49         }
  50         // behaves as a standalone object
  51         return E_NOINTERFACE;
  52     };
  53
  54     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
  55     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
  56
  57     // IDispatch methods
  58     STDMETHODIMP GetTypeInfoCount(UINT*);
  59     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
  60     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
  61     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
  62
  63     // IVLCAudio methods
  64     STDMETHODIMP get_mute(VARIANT_BOOL*);
  65     STDMETHODIMP put_mute(VARIANT_BOOL);
  66     STDMETHODIMP get_volume(long*);
  67     STDMETHODIMP put_volume(long);
  68     STDMETHODIMP toggleMute();
  69
  70 protected:
  71     HRESULT loadTypeInfo();
  72
  73 private:
  74     VLCPlugin*      _p_instance;
  75     ITypeInfo*      _p_typeinfo;
  76
  77 };
  78
  79 class VLCInput : public IVLCInput
  80 {
  81 public:
  82
  83     VLCInput(VLCPlugin *p_instance) :
  84         _p_instance(p_instance), _p_typeinfo(NULL) {};
  85     virtual ~VLCInput();
  86
  87     // IUnknown methods
  88     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
  89     {
  90         if( NULL == ppv )
  91           return E_POINTER;
  92         if( (IID_IUnknown == riid)
  93          || (IID_IDispatch == riid)
  94          || (IID_IVLCInput == riid) )
  95         {
  96             AddRef();
  97             *ppv = reinterpret_cast<LPVOID>(this);
  98             return NOERROR;
  99         }
 100         // behaves as a standalone object
 101         return E_NOINTERFACE;
 102     };
 103
 104     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 105     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 106
 107     // IDispatch methods
 108     STDMETHODIMP GetTypeInfoCount(UINT*);
 109     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 110     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 111     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 112
 113     // IVLCInput methods
 114     STDMETHODIMP get_length(double*);
 115     STDMETHODIMP get_position(double*);
 116     STDMETHODIMP put_position(double);
 117     STDMETHODIMP get_time(double*);
 118     STDMETHODIMP put_time(double);
 119     STDMETHODIMP get_state(long*);
 120     STDMETHODIMP get_rate(double*);
 121     STDMETHODIMP put_rate(double);
 122     STDMETHODIMP get_fps(double*);
 123     STDMETHODIMP get_hasVout(VARIANT_BOOL*);
 124
 125 protected:
 126     HRESULT loadTypeInfo();
 127
 128 private:
 129     VLCPlugin*      _p_instance;
 130     ITypeInfo*      _p_typeinfo;
 131
 132 };
 133
 134 class VLCMessage: public IVLCMessage
 135 {
 136 public:
 137
 138     VLCMessage(VLCPlugin *p_instance, struct libvlc_log_message_t &msg) :
 139         _p_instance(p_instance),
 140         _p_typeinfo(NULL),
 141         _refcount(1),
 142         _msg(msg) {};
 143     virtual ~VLCMessage();
 144
 145     // IUnknown methods
 146     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 147     {
 148         if( NULL == ppv )
 149           return E_POINTER;
 150         if( (IID_IUnknown == riid)
 151          || (IID_IDispatch == riid)
 152          || (IID_IVLCMessage == riid) )
 153         {
 154             AddRef();
 155             *ppv = reinterpret_cast<LPVOID>(this);
 156             return NOERROR;
 157         }
 158         // behaves as a standalone object
 159         return E_NOINTERFACE;
 160     };
 161
 162     STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
 163     STDMETHODIMP_(ULONG) Release(void)
 164     {
 165         ULONG refcount = InterlockedDecrement(&_refcount);
 166         if( 0 == refcount )
 167         {
 168             delete this;
 169             return 0;
 170         }
 171         return refcount;
 172     };
 173
 174     // IDispatch methods
 175     STDMETHODIMP GetTypeInfoCount(UINT*);
 176     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 177     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 178     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 179
 180     // IVLCMessage methods
 181     STDMETHODIMP get__Value(VARIANT *);
 182     STDMETHODIMP get_severity(long *);
 183     STDMETHODIMP get_type(BSTR *);
 184     STDMETHODIMP get_name(BSTR *);
 185     STDMETHODIMP get_header(BSTR *);
 186     STDMETHODIMP get_message(BSTR *);
 187
 188 protected:
 189     HRESULT loadTypeInfo();
 190
 191 private:
 192     VLCPlugin*      _p_instance;
 193     ITypeInfo*      _p_typeinfo;
 194     LONG            _refcount;
 195
 196     struct libvlc_log_message_t _msg;
 197 };
 198
 199 class VLCLog;
 200
 201 class VLCMessageIterator : public IVLCMessageIterator
 202 {
 203 public:
 204
 205     VLCMessageIterator(VLCPlugin *p_instance, VLCLog* p_vlclog);
 206     virtual ~VLCMessageIterator();
 207
 208     // IUnknown methods
 209     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 210     {
 211         if( NULL == ppv )
 212           return E_POINTER;
 213         if( (IID_IUnknown == riid)
 214          || (IID_IDispatch == riid)
 215          || (IID_IVLCMessageIterator == riid) )
 216         {
 217             AddRef();
 218             *ppv = reinterpret_cast<LPVOID>(this);
 219             return NOERROR;
 220         }
 221         // behaves as a standalone object
 222         return E_NOINTERFACE;
 223     };
 224
 225     STDMETHODIMP_(ULONG) AddRef(void) { return InterlockedIncrement(&_refcount); };
 226     STDMETHODIMP_(ULONG) Release(void)
 227     {
 228         ULONG refcount = InterlockedDecrement(&_refcount);
 229         if( 0 == refcount )
 230         {
 231             delete this;
 232             return 0;
 233         }
 234         return refcount;
 235     };
 236
 237     // IDispatch methods
 238     STDMETHODIMP GetTypeInfoCount(UINT*);
 239     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 240     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 241     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 242
 243     // IVLCMessageIterator methods
 244     STDMETHODIMP get_hasNext(VARIANT_BOOL*);
 245     STDMETHODIMP next(IVLCMessage**);
 246
 247 protected:
 248     HRESULT loadTypeInfo();
 249
 250 private:
 251     VLCPlugin*      _p_instance;
 252     ITypeInfo*      _p_typeinfo;
 253     LONG            _refcount;
 254
 255     VLCLog*                 _p_vlclog;
 256     libvlc_log_iterator_t*  _p_iter;
 257 };
 258
 259 class VLCMessages : public IVLCMessages
 260 {
 261 public:
 262
 263     VLCMessages(VLCPlugin *p_instance, VLCLog *p_vlclog) :
 264         _p_vlclog(p_vlclog),
 265         _p_instance(p_instance),
 266         _p_typeinfo(NULL) {}
 267     virtual ~VLCMessages();
 268
 269     // IUnknown methods
 270     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 271     {
 272         if( NULL == ppv )
 273           return E_POINTER;
 274         if( (IID_IUnknown == riid)
 275          || (IID_IDispatch == riid)
 276          || (IID_IVLCMessages == riid) )
 277         {
 278             AddRef();
 279             *ppv = reinterpret_cast<LPVOID>(this);
 280             return NOERROR;
 281         }
 282         // behaves as a standalone object
 283         return E_NOINTERFACE;
 284     };
 285
 286     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 287     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 288
 289     // IDispatch methods
 290     STDMETHODIMP GetTypeInfoCount(UINT*);
 291     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 292     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 293     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 294
 295     // IVLCMessages methods
 296     STDMETHODIMP get__NewEnum(LPUNKNOWN*);
 297     STDMETHODIMP clear();
 298     STDMETHODIMP get_count(long*);
 299     STDMETHODIMP iterator(IVLCMessageIterator**);
 300
 301 protected:
 302     HRESULT loadTypeInfo();
 303
 304     VLCLog*     _p_vlclog;
 305
 306 private:
 307     VLCPlugin*  _p_instance;
 308     ITypeInfo*  _p_typeinfo;
 309 };
 310
 311 class VLCLog : public IVLCLog
 312 {
 313 public:
 314
 315     friend class VLCMessages;
 316     friend class VLCMessageIterator;
 317
 318     VLCLog(VLCPlugin *p_instance) :
 319         _p_log(NULL),
 320         _p_instance(p_instance),
 321         _p_typeinfo(NULL),
 322         _p_vlcmessages(NULL)
 323     {
 324         _p_vlcmessages = new VLCMessages(p_instance, this);
 325     };
 326     virtual ~VLCLog();
 327
 328     // IUnknown methods
 329     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 330     {
 331         if( NULL == ppv )
 332           return E_POINTER;
 333         if( (IID_IUnknown == riid)
 334          || (IID_IDispatch == riid)
 335          || (IID_IVLCLog == riid) )
 336         {
 337             AddRef();
 338             *ppv = reinterpret_cast<LPVOID>(this);
 339             return NOERROR;
 340         }
 341         // behaves as a standalone object
 342         return E_NOINTERFACE;
 343     };
 344
 345     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 346     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 347
 348     // IDispatch methods
 349     STDMETHODIMP GetTypeInfoCount(UINT*);
 350     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 351     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 352     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 353
 354     // IVLCLog methods
 355     STDMETHODIMP get_messages(IVLCMessages**);
 356     STDMETHODIMP get_verbosity(long *);
 357     STDMETHODIMP put_verbosity(long);
 358
 359 protected:
 360     HRESULT loadTypeInfo();
 361
 362     libvlc_log_t    *_p_log;
 363
 364 private:
 365     VLCPlugin*      _p_instance;
 366     ITypeInfo*      _p_typeinfo;
 367
 368     VLCMessages*    _p_vlcmessages;
 369 };
 370
 371 class VLCPlaylistItems : public IVLCPlaylistItems
 372 {
 373 public:
 374     VLCPlaylistItems(VLCPlugin *p_instance) :
 375         _p_instance(p_instance), _p_typeinfo(NULL) {};
 376     virtual ~VLCPlaylistItems();
 377
 378     // IUnknown methods
 379     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 380     {
 381         if( NULL == ppv )
 382           return E_POINTER;
 383         if( (IID_IUnknown == riid)
 384          || (IID_IDispatch == riid)
 385          || (IID_IVLCPlaylistItems == riid) )
 386         {
 387             AddRef();
 388             *ppv = reinterpret_cast<LPVOID>(this);
 389             return NOERROR;
 390         }
 391         // behaves as a standalone object
 392         return E_NOINTERFACE;
 393     };
 394
 395     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 396     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 397
 398     // IDispatch methods
 399     STDMETHODIMP GetTypeInfoCount(UINT*);
 400     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 401     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 402     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 403
 404     // IVLCPlaylistItems methods
 405     STDMETHODIMP get_count(long*);
 406     STDMETHODIMP clear();
 407     STDMETHODIMP remove(long);
 408
 409 protected:
 410     HRESULT loadTypeInfo();
 411
 412 private:
 413     VLCPlugin*  _p_instance;
 414     ITypeInfo*  _p_typeinfo;
 415
 416 };
 417
 418 class VLCPlaylist : public IVLCPlaylist
 419 {
 420 public:
 421     VLCPlaylist(VLCPlugin *p_instance) :
 422         _p_instance(p_instance),
 423         _p_typeinfo(NULL),
 424         _p_vlcplaylistitems(NULL)
 425     {
 426         _p_vlcplaylistitems = new VLCPlaylistItems(p_instance);
 427     };
 428     virtual ~VLCPlaylist();
 429
 430     // IUnknown methods
 431     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 432     {
 433         if( NULL == ppv )
 434           return E_POINTER;
 435         if( (IID_IUnknown == riid)
 436          || (IID_IDispatch == riid)
 437          || (IID_IVLCPlaylist == riid) )
 438         {
 439             AddRef();
 440             *ppv = reinterpret_cast<LPVOID>(this);
 441             return NOERROR;
 442         }
 443         // behaves as a standalone object
 444         return E_NOINTERFACE;
 445     };
 446
 447     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 448     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 449
 450     // IDispatch methods
 451     STDMETHODIMP GetTypeInfoCount(UINT*);
 452     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 453     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 454     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 455
 456     // IVLCPlaylist methods
 457     STDMETHODIMP get_itemCount(long*);
 458     STDMETHODIMP get_isPlaying(VARIANT_BOOL*);
 459     STDMETHODIMP add(BSTR, VARIANT, VARIANT, long*);
 460     STDMETHODIMP play();
 461     STDMETHODIMP playItem(long);
 462     STDMETHODIMP togglePause();
 463     STDMETHODIMP stop();
 464     STDMETHODIMP next();
 465     STDMETHODIMP prev();
 466     STDMETHODIMP clear();
 467     STDMETHODIMP removeItem(long);
 468     STDMETHODIMP get_items(IVLCPlaylistItems**);
 469
 470 protected:
 471     HRESULT loadTypeInfo();
 472
 473 private:
 474     VLCPlugin*  _p_instance;
 475     ITypeInfo*  _p_typeinfo;
 476
 477     VLCPlaylistItems*    _p_vlcplaylistitems;
 478 };
 479
 480 class VLCVideo : public IVLCVideo
 481 {
 482 public:
 483     VLCVideo(VLCPlugin *p_instance) :
 484         _p_instance(p_instance), _p_typeinfo(NULL) {};
 485     virtual ~VLCVideo();
 486
 487     // IUnknown methods
 488     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 489     {
 490         if( NULL == ppv )
 491           return E_POINTER;
 492         if( (IID_IUnknown == riid)
 493          || (IID_IDispatch == riid)
 494          || (IID_IVLCVideo == riid) )
 495         {
 496             AddRef();
 497             *ppv = reinterpret_cast<LPVOID>(this);
 498             return NOERROR;
 499         }
 500         // behaves as a standalone object
 501         return E_NOINTERFACE;
 502     };
 503
 504     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 505     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 506
 507     // IDispatch methods
 508     STDMETHODIMP GetTypeInfoCount(UINT*);
 509     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 510     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 511     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 512
 513     // IVLCVideo methods
 514     STDMETHODIMP get_fullscreen(VARIANT_BOOL*);
 515     STDMETHODIMP put_fullscreen(VARIANT_BOOL);
 516     STDMETHODIMP get_width(long*);
 517     STDMETHODIMP get_height(long*);
 518     STDMETHODIMP get_aspectRatio(BSTR*);
 519     STDMETHODIMP put_aspectRatio(BSTR);
 520     STDMETHODIMP toggleFullscreen();
 521
 522 protected:
 523     HRESULT loadTypeInfo();
 524
 525 private:
 526     VLCPlugin*      _p_instance;
 527     ITypeInfo*      _p_typeinfo;
 528
 529 };
 530
 531 class VLCControl2 : public IVLCControl2
 532 {
 533
 534 public:
 535
 536     VLCControl2(VLCPlugin *p_instance);
 537     virtual ~VLCControl2();
 538
 539     // IUnknown methods
 540     STDMETHODIMP QueryInterface(REFIID riid, void **ppv)
 541     {
 542         if( NULL == ppv )
 543           return E_POINTER;
 544         if( (IID_IUnknown == riid)
 545          || (IID_IDispatch == riid)
 546          || (IID_IVLCControl2 == riid) )
 547         {
 548             AddRef();
 549             *ppv = reinterpret_cast<LPVOID>(this);
 550             return NOERROR;
 551         }
 552         return _p_instance->pUnkOuter->QueryInterface(riid, ppv);
 553     };
 554
 555     STDMETHODIMP_(ULONG) AddRef(void) { return _p_instance->pUnkOuter->AddRef(); };
 556     STDMETHODIMP_(ULONG) Release(void) { return _p_instance->pUnkOuter->Release(); };
 557
 558     // IDispatch methods
 559     STDMETHODIMP GetTypeInfoCount(UINT*);
 560     STDMETHODIMP GetTypeInfo(UINT, LCID, LPTYPEINFO*);
 561     STDMETHODIMP GetIDsOfNames(REFIID,LPOLESTR*,UINT,LCID,DISPID*);
 562     STDMETHODIMP Invoke(DISPID,REFIID,LCID,WORD,DISPPARAMS*,VARIANT*,EXCEPINFO*,UINT*);
 563
 564     // IVLCControl2 methods
 565     STDMETHODIMP get_AutoLoop(VARIANT_BOOL *autoloop);
 566     STDMETHODIMP put_AutoLoop(VARIANT_BOOL autoloop);
 567     STDMETHODIMP get_AutoPlay(VARIANT_BOOL *autoplay);
 568     STDMETHODIMP put_AutoPlay(VARIANT_BOOL autoplay);
 569     STDMETHODIMP get_BaseURL(BSTR *url);
 570     STDMETHODIMP put_BaseURL(BSTR url);
 571     STDMETHODIMP get_MRL(BSTR *mrl);
 572     STDMETHODIMP put_MRL(BSTR mrl);
 573     STDMETHODIMP get_StartTime(long *seconds);
 574     STDMETHODIMP put_StartTime(long seconds);
 575     STDMETHODIMP get_VersionInfo(BSTR *version);
 576     STDMETHODIMP get_Visible(VARIANT_BOOL *visible);
 577     STDMETHODIMP put_Visible(VARIANT_BOOL visible);
 578     STDMETHODIMP get_Volume(long *volume);
 579     STDMETHODIMP put_Volume(long volume);
 580
 581     STDMETHODIMP get_audio(IVLCAudio**);
 582     STDMETHODIMP get_input(IVLCInput**);
 583     STDMETHODIMP get_log(IVLCLog**);
 584     STDMETHODIMP get_playlist(IVLCPlaylist**);
 585     STDMETHODIMP get_video(IVLCVideo**);
 586
 587 protected:
 588     HRESULT loadTypeInfo();
 589
 590 private:
 591     VLCPlugin*      _p_instance;
 592     ITypeInfo*      _p_typeinfo;
 593
 594     VLCAudio*       _p_vlcaudio;
 595     VLCInput*       _p_vlcinput;
 596     VLCLog  *       _p_vlclog;
 597     VLCPlaylist*    _p_vlcplaylist;
 598     VLCVideo*       _p_vlcvideo;
 599 };
 600
 601 #endif
 602