activex/vlccontrol2.cpp

   1 /*****************************************************************************
   2  * vlccontrol2.cpp: 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
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #include "plugin.h"
  25 #include "vlccontrol2.h"
  26 #include "vlccontrol.h"
  27
  28 #include "utils.h"
  29
  30 #include <shlwapi.h>
  31 #include <wininet.h>
  32 #include <tchar.h>
  33
  34 using namespace std;
  35
  36 VLCAudio::~VLCAudio()
  37 {
  38     if( _p_typeinfo )
  39         _p_typeinfo->Release();
  40 };
  41
  42 HRESULT VLCAudio::loadTypeInfo(void)
  43 {
  44     HRESULT hr = NOERROR;
  45     if( NULL == _p_typeinfo )
  46     {
  47         ITypeLib *p_typelib;
  48
  49         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
  50         if( SUCCEEDED(hr) )
  51         {
  52             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCAudio, &_p_typeinfo);
  53             if( FAILED(hr) )
  54             {
  55                 _p_typeinfo = NULL;
  56             }
  57             p_typelib->Release();
  58         }
  59     }
  60     return hr;
  61 };
  62
  63 STDMETHODIMP VLCAudio::GetTypeInfoCount(UINT* pctInfo)
  64 {
  65     if( NULL == pctInfo )
  66         return E_INVALIDARG;
  67
  68     if( SUCCEEDED(loadTypeInfo()) )
  69         *pctInfo = 1;
  70     else
  71         *pctInfo = 0;
  72
  73     return NOERROR;
  74 };
  75
  76 STDMETHODIMP VLCAudio::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
  77 {
  78     if( NULL == ppTInfo )
  79         return E_INVALIDARG;
  80
  81     if( SUCCEEDED(loadTypeInfo()) )
  82     {
  83         _p_typeinfo->AddRef();
  84         *ppTInfo = _p_typeinfo;
  85         return NOERROR;
  86     }
  87     *ppTInfo = NULL;
  88     return E_NOTIMPL;
  89 };
  90
  91 STDMETHODIMP VLCAudio::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
  92         UINT cNames, LCID lcid, DISPID* rgDispID)
  93 {
  94     if( SUCCEEDED(loadTypeInfo()) )
  95     {
  96         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
  97     }
  98     return E_NOTIMPL;
  99 };
 100
 101 STDMETHODIMP VLCAudio::Invoke(DISPID dispIdMember, REFIID riid,
 102         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 103         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 104 {
 105     if( SUCCEEDED(loadTypeInfo()) )
 106     {
 107         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
 108                 pVarResult, pExcepInfo, puArgErr);
 109     }
 110     return E_NOTIMPL;
 111 };
 112
 113 STDMETHODIMP VLCAudio::get_mute(VARIANT_BOOL* mute)
 114 {
 115     if( NULL == mute )
 116         return E_POINTER;
 117
 118     libvlc_instance_t* p_libvlc;
 119     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 120     if( SUCCEEDED(hr) )
 121     {
 122         libvlc_exception_t ex;
 123         libvlc_exception_init(&ex);
 124
 125         *mute = libvlc_audio_get_mute(p_libvlc, &ex) ? VARIANT_TRUE : VARIANT_FALSE;
 126         if( libvlc_exception_raised(&ex) )
 127         {
 128             _p_instance->setErrorInfo(IID_IVLCAudio, libvlc_exception_get_message(&ex));
 129             libvlc_exception_clear(&ex);
 130             return E_FAIL;
 131         }
 132         return NOERROR;
 133     }
 134     return hr;
 135 };
 136
 137 STDMETHODIMP VLCAudio::put_mute(VARIANT_BOOL mute)
 138 {
 139     libvlc_instance_t* p_libvlc;
 140     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 141     if( SUCCEEDED(hr) )
 142     {
 143         libvlc_exception_t ex;
 144         libvlc_exception_init(&ex);
 145
 146         libvlc_audio_set_mute(p_libvlc, VARIANT_FALSE != mute, &ex);
 147         if( libvlc_exception_raised(&ex) )
 148         {
 149             _p_instance->setErrorInfo(IID_IVLCAudio, libvlc_exception_get_message(&ex));
 150             libvlc_exception_clear(&ex);
 151             return E_FAIL;
 152         }
 153         return NOERROR;
 154     }
 155     return hr;
 156 };
 157
 158 STDMETHODIMP VLCAudio::get_volume(long* volume)
 159 {
 160     if( NULL == volume )
 161         return E_POINTER;
 162
 163     libvlc_instance_t* p_libvlc;
 164     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 165     if( SUCCEEDED(hr) )
 166     {
 167         libvlc_exception_t ex;
 168         libvlc_exception_init(&ex);
 169
 170         *volume = libvlc_audio_get_volume(p_libvlc, &ex);
 171         if( libvlc_exception_raised(&ex) )
 172         {
 173             _p_instance->setErrorInfo(IID_IVLCAudio, libvlc_exception_get_message(&ex));
 174             libvlc_exception_clear(&ex);
 175             return E_FAIL;
 176         }
 177         return NOERROR;
 178     }
 179     return hr;
 180 };
 181
 182 STDMETHODIMP VLCAudio::put_volume(long volume)
 183 {
 184     libvlc_instance_t* p_libvlc;
 185     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 186     if( SUCCEEDED(hr) )
 187     {
 188         libvlc_exception_t ex;
 189         libvlc_exception_init(&ex);
 190
 191         libvlc_audio_set_volume(p_libvlc, volume, &ex);
 192         if( libvlc_exception_raised(&ex) )
 193         {
 194             _p_instance->setErrorInfo(IID_IVLCAudio,
 195                          libvlc_exception_get_message(&ex));
 196             libvlc_exception_clear(&ex);
 197             return E_FAIL;
 198         }
 199         return NOERROR;
 200     }
 201     return hr;
 202 };
 203
 204 STDMETHODIMP VLCAudio::get_track(long* track)
 205 {
 206     if( NULL == track )
 207         return E_POINTER;
 208
 209     libvlc_instance_t* p_libvlc;
 210     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 211     if( SUCCEEDED(hr) )
 212     {
 213         libvlc_exception_t ex;
 214         libvlc_exception_init(&ex);
 215
 216         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 217         *track = libvlc_audio_get_track(p_md, &ex);
 218         libvlc_media_instance_release(p_md);
 219         if( libvlc_exception_raised(&ex) )
 220         {
 221             _p_instance->setErrorInfo(IID_IVLCAudio,
 222                          libvlc_exception_get_message(&ex));
 223             libvlc_exception_clear(&ex);
 224             return E_FAIL;
 225         }
 226         return NOERROR;
 227     }
 228     return hr;
 229 };
 230
 231 STDMETHODIMP VLCAudio::put_track(long track)
 232 {
 233     libvlc_instance_t* p_libvlc;
 234     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 235     if( SUCCEEDED(hr) )
 236     {
 237         libvlc_exception_t ex;
 238         libvlc_exception_init(&ex);
 239
 240         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 241         libvlc_audio_set_track(p_md, track, &ex);
 242         libvlc_media_instance_release(p_md);
 243         if( libvlc_exception_raised(&ex) )
 244         {
 245             _p_instance->setErrorInfo(IID_IVLCAudio,
 246                          libvlc_exception_get_message(&ex));
 247             libvlc_exception_clear(&ex);
 248             return E_FAIL;
 249         }
 250         return NOERROR;
 251     }
 252     return hr;
 253 };
 254
 255 STDMETHODIMP VLCAudio::get_channel(long *channel)
 256 {
 257     if( NULL == channel )
 258         return E_POINTER;
 259
 260     libvlc_instance_t* p_libvlc;
 261     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 262     if( SUCCEEDED(hr) )
 263     {
 264         libvlc_exception_t ex;
 265         libvlc_exception_init(&ex);
 266
 267         *channel = libvlc_audio_get_channel(p_libvlc, &ex);
 268         if( libvlc_exception_raised(&ex) )
 269         {
 270             _p_instance->setErrorInfo(IID_IVLCAudio,
 271                         libvlc_exception_get_message(&ex));
 272             libvlc_exception_clear(&ex);
 273             return E_FAIL;
 274         }
 275         return NOERROR;
 276     }
 277     return hr;
 278 };
 279
 280 STDMETHODIMP VLCAudio::put_channel(long channel)
 281 {
 282     libvlc_instance_t* p_libvlc;
 283     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 284     if( SUCCEEDED(hr) )
 285     {
 286         libvlc_exception_t ex;
 287         libvlc_exception_init(&ex);
 288
 289         libvlc_audio_set_channel(p_libvlc, channel, &ex);
 290         if( libvlc_exception_raised(&ex) )
 291         {
 292             _p_instance->setErrorInfo(IID_IVLCAudio,
 293                          libvlc_exception_get_message(&ex));
 294             libvlc_exception_clear(&ex);
 295             return E_FAIL;
 296         }
 297         return NOERROR;
 298     }
 299     return hr;
 300 };
 301
 302 STDMETHODIMP VLCAudio::toggleMute()
 303 {
 304     libvlc_instance_t* p_libvlc;
 305     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 306     if( SUCCEEDED(hr) )
 307     {
 308         libvlc_exception_t ex;
 309         libvlc_exception_init(&ex);
 310
 311         libvlc_audio_toggle_mute(p_libvlc, &ex);
 312         if( libvlc_exception_raised(&ex) )
 313         {
 314             _p_instance->setErrorInfo(IID_IVLCAudio,
 315                          libvlc_exception_get_message(&ex));
 316             libvlc_exception_clear(&ex);
 317             return E_FAIL;
 318         }
 319         return NOERROR;
 320     }
 321     return hr;
 322 };
 323
 324 /*******************************************************************************/
 325
 326 VLCInput::~VLCInput()
 327 {
 328     if( _p_typeinfo )
 329         _p_typeinfo->Release();
 330 };
 331
 332 HRESULT VLCInput::loadTypeInfo(void)
 333 {
 334     HRESULT hr = NOERROR;
 335     if( NULL == _p_typeinfo )
 336     {
 337         ITypeLib *p_typelib;
 338
 339         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
 340         if( SUCCEEDED(hr) )
 341         {
 342             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCInput, &_p_typeinfo);
 343             if( FAILED(hr) )
 344             {
 345                 _p_typeinfo = NULL;
 346             }
 347             p_typelib->Release();
 348         }
 349     }
 350     return hr;
 351 };
 352
 353 STDMETHODIMP VLCInput::GetTypeInfoCount(UINT* pctInfo)
 354 {
 355     if( NULL == pctInfo )
 356         return E_INVALIDARG;
 357
 358     if( SUCCEEDED(loadTypeInfo()) )
 359         *pctInfo = 1;
 360     else
 361         *pctInfo = 0;
 362
 363     return NOERROR;
 364 };
 365
 366 STDMETHODIMP VLCInput::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
 367 {
 368     if( NULL == ppTInfo )
 369         return E_INVALIDARG;
 370
 371     if( SUCCEEDED(loadTypeInfo()) )
 372     {
 373         _p_typeinfo->AddRef();
 374         *ppTInfo = _p_typeinfo;
 375         return NOERROR;
 376     }
 377     *ppTInfo = NULL;
 378     return E_NOTIMPL;
 379 };
 380
 381 STDMETHODIMP VLCInput::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
 382         UINT cNames, LCID lcid, DISPID* rgDispID)
 383 {
 384     if( SUCCEEDED(loadTypeInfo()) )
 385     {
 386         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
 387     }
 388     return E_NOTIMPL;
 389 };
 390
 391 STDMETHODIMP VLCInput::Invoke(DISPID dispIdMember, REFIID riid,
 392         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 393         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 394 {
 395     if( SUCCEEDED(loadTypeInfo()) )
 396     {
 397         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
 398                 pVarResult, pExcepInfo, puArgErr);
 399     }
 400     return E_NOTIMPL;
 401 };
 402
 403 STDMETHODIMP VLCInput::get_length(double* length)
 404 {
 405     if( NULL == length )
 406         return E_POINTER;
 407
 408     libvlc_instance_t* p_libvlc;
 409     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 410     if( SUCCEEDED(hr) )
 411     {
 412         libvlc_exception_t ex;
 413         libvlc_exception_init(&ex);
 414
 415         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 416         if( ! libvlc_exception_raised(&ex) )
 417         {
 418             *length = (double)libvlc_media_instance_get_length(p_md, &ex);
 419             libvlc_media_instance_release(p_md);
 420             if( ! libvlc_exception_raised(&ex) )
 421             {
 422                 return NOERROR;
 423             }
 424         }
 425         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 426         libvlc_exception_clear(&ex);
 427         return E_FAIL;
 428     }
 429     return hr;
 430 };
 431
 432 STDMETHODIMP VLCInput::get_position(double* position)
 433 {
 434     if( NULL == position )
 435         return E_POINTER;
 436
 437     libvlc_instance_t* p_libvlc;
 438     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 439     if( SUCCEEDED(hr) )
 440     {
 441         libvlc_exception_t ex;
 442         libvlc_exception_init(&ex);
 443
 444         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 445         if( ! libvlc_exception_raised(&ex) )
 446         {
 447             *position = libvlc_media_instance_get_position(p_md, &ex);
 448             libvlc_media_instance_release(p_md);
 449             if( ! libvlc_exception_raised(&ex) )
 450             {
 451                 return NOERROR;
 452             }
 453         }
 454         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 455         libvlc_exception_clear(&ex);
 456         return E_FAIL;
 457     }
 458     return hr;
 459 };
 460
 461 STDMETHODIMP VLCInput::put_position(double position)
 462 {
 463     libvlc_instance_t* p_libvlc;
 464     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 465     if( SUCCEEDED(hr) )
 466     {
 467         libvlc_exception_t ex;
 468         libvlc_exception_init(&ex);
 469
 470         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 471         if( ! libvlc_exception_raised(&ex) )
 472         {
 473             libvlc_media_instance_set_position(p_md, position, &ex);
 474             libvlc_media_instance_release(p_md);
 475             if( ! libvlc_exception_raised(&ex) )
 476             {
 477                 return NOERROR;
 478             }
 479         }
 480         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 481         libvlc_exception_clear(&ex);
 482         return E_FAIL;
 483     }
 484     return hr;
 485 };
 486
 487 STDMETHODIMP VLCInput::get_time(double* time)
 488 {
 489     if( NULL == time )
 490         return E_POINTER;
 491
 492     libvlc_instance_t* p_libvlc;
 493     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 494     if( SUCCEEDED(hr) )
 495     {
 496         libvlc_exception_t ex;
 497         libvlc_exception_init(&ex);
 498
 499         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 500         if( ! libvlc_exception_raised(&ex) )
 501         {
 502             *time = (double)libvlc_media_instance_get_time(p_md, &ex);
 503             libvlc_media_instance_release(p_md);
 504             if( ! libvlc_exception_raised(&ex) )
 505             {
 506                 return NOERROR;
 507             }
 508         }
 509         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 510         libvlc_exception_clear(&ex);
 511         return E_FAIL;
 512     }
 513     return hr;
 514 };
 515
 516 STDMETHODIMP VLCInput::put_time(double time)
 517 {
 518     libvlc_instance_t* p_libvlc;
 519     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 520     if( SUCCEEDED(hr) )
 521     {
 522         libvlc_exception_t ex;
 523         libvlc_exception_init(&ex);
 524
 525         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 526         if( ! libvlc_exception_raised(&ex) )
 527         {
 528             libvlc_media_instance_set_time(p_md, (vlc_int64_t)time, &ex);
 529             libvlc_media_instance_release(p_md);
 530             if( ! libvlc_exception_raised(&ex) )
 531             {
 532                 return NOERROR;
 533             }
 534         }
 535         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 536         libvlc_exception_clear(&ex);
 537         return E_FAIL;
 538     }
 539     return hr;
 540 };
 541
 542 STDMETHODIMP VLCInput::get_state(long* state)
 543 {
 544     if( NULL == state )
 545         return E_POINTER;
 546
 547     libvlc_instance_t* p_libvlc;
 548     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 549     if( SUCCEEDED(hr) )
 550     {
 551         libvlc_exception_t ex;
 552         libvlc_exception_init(&ex);
 553
 554         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 555         if( ! libvlc_exception_raised(&ex) )
 556         {
 557             *state = libvlc_media_instance_get_state(p_md, &ex);
 558             libvlc_media_instance_release(p_md);
 559             if( ! libvlc_exception_raised(&ex) )
 560             {
 561                 return NOERROR;
 562             }
 563         }
 564         libvlc_exception_clear(&ex);
 565         // don't fail, just return the idle state
 566         *state = 0;
 567         return NOERROR;
 568     }
 569     return hr;
 570 };
 571
 572 STDMETHODIMP VLCInput::get_rate(double* rate)
 573 {
 574     if( NULL == rate )
 575         return E_POINTER;
 576
 577     libvlc_instance_t* p_libvlc;
 578     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 579     if( SUCCEEDED(hr) )
 580     {
 581         libvlc_exception_t ex;
 582         libvlc_exception_init(&ex);
 583
 584         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 585         if( ! libvlc_exception_raised(&ex) )
 586         {
 587             *rate = libvlc_media_instance_get_rate(p_md, &ex);
 588             libvlc_media_instance_release(p_md);
 589             if( ! libvlc_exception_raised(&ex) )
 590             {
 591                 return NOERROR;
 592             }
 593         }
 594         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 595         libvlc_exception_clear(&ex);
 596         return E_FAIL;
 597     }
 598     return hr;
 599 };
 600
 601 STDMETHODIMP VLCInput::put_rate(double rate)
 602 {
 603     libvlc_instance_t* p_libvlc;
 604     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 605     if( SUCCEEDED(hr) )
 606     {
 607         libvlc_exception_t ex;
 608         libvlc_exception_init(&ex);
 609
 610         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 611         if( ! libvlc_exception_raised(&ex) )
 612         {
 613             libvlc_media_instance_set_rate(p_md, rate, &ex);
 614             libvlc_media_instance_release(p_md);
 615             if( ! libvlc_exception_raised(&ex) )
 616             {
 617                 return NOERROR;
 618             }
 619         }
 620         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 621         libvlc_exception_clear(&ex);
 622         return E_FAIL;
 623     }
 624     return hr;
 625 };
 626
 627 STDMETHODIMP VLCInput::get_fps(double* fps)
 628 {
 629     if( NULL == fps )
 630         return E_POINTER;
 631
 632     *fps = 0.0;
 633     libvlc_instance_t* p_libvlc;
 634     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 635     if( SUCCEEDED(hr) )
 636     {
 637         libvlc_exception_t ex;
 638         libvlc_exception_init(&ex);
 639
 640         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 641         if( ! libvlc_exception_raised(&ex) )
 642         {
 643             *fps = libvlc_media_instance_get_fps(p_md, &ex);
 644             libvlc_media_instance_release(p_md);
 645             if( ! libvlc_exception_raised(&ex) )
 646             {
 647                 return NOERROR;
 648             }
 649         }
 650         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 651         libvlc_exception_clear(&ex);
 652         return E_FAIL;
 653     }
 654     return hr;
 655 };
 656
 657 STDMETHODIMP VLCInput::get_hasVout(VARIANT_BOOL* hasVout)
 658 {
 659     if( NULL == hasVout )
 660         return E_POINTER;
 661
 662     libvlc_instance_t* p_libvlc;
 663     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 664     if( SUCCEEDED(hr) )
 665     {
 666         libvlc_exception_t ex;
 667         libvlc_exception_init(&ex);
 668
 669         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
 670         if( ! libvlc_exception_raised(&ex) )
 671         {
 672             *hasVout = libvlc_media_instance_has_vout(p_md, &ex) ? VARIANT_TRUE : VARIANT_FALSE;
 673             libvlc_media_instance_release(p_md);
 674             if( ! libvlc_exception_raised(&ex) )
 675             {
 676                 return NOERROR;
 677             }
 678         }
 679         _p_instance->setErrorInfo(IID_IVLCInput, libvlc_exception_get_message(&ex));
 680         libvlc_exception_clear(&ex);
 681         return E_FAIL;
 682     }
 683     return hr;
 684 };
 685
 686 /*******************************************************************************/
 687
 688 VLCLog::~VLCLog()
 689 {
 690     delete _p_vlcmessages;
 691     if( _p_log )
 692         libvlc_log_close(_p_log, NULL);
 693
 694     if( _p_typeinfo )
 695         _p_typeinfo->Release();
 696 };
 697
 698 HRESULT VLCLog::loadTypeInfo(void)
 699 {
 700     HRESULT hr = NOERROR;
 701     if( NULL == _p_typeinfo )
 702     {
 703         ITypeLib *p_typelib;
 704
 705         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
 706         if( SUCCEEDED(hr) )
 707         {
 708             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCLog, &_p_typeinfo);
 709             if( FAILED(hr) )
 710             {
 711                 _p_typeinfo = NULL;
 712             }
 713             p_typelib->Release();
 714         }
 715     }
 716     return hr;
 717 };
 718
 719 STDMETHODIMP VLCLog::GetTypeInfoCount(UINT* pctInfo)
 720 {
 721     if( NULL == pctInfo )
 722         return E_INVALIDARG;
 723
 724     if( SUCCEEDED(loadTypeInfo()) )
 725         *pctInfo = 1;
 726     else
 727         *pctInfo = 0;
 728
 729     return NOERROR;
 730 };
 731
 732 STDMETHODIMP VLCLog::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
 733 {
 734     if( NULL == ppTInfo )
 735         return E_INVALIDARG;
 736
 737     if( SUCCEEDED(loadTypeInfo()) )
 738     {
 739         _p_typeinfo->AddRef();
 740         *ppTInfo = _p_typeinfo;
 741         return NOERROR;
 742     }
 743     *ppTInfo = NULL;
 744     return E_NOTIMPL;
 745 };
 746
 747 STDMETHODIMP VLCLog::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
 748         UINT cNames, LCID lcid, DISPID* rgDispID)
 749 {
 750     if( SUCCEEDED(loadTypeInfo()) )
 751     {
 752         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
 753     }
 754     return E_NOTIMPL;
 755 };
 756
 757 STDMETHODIMP VLCLog::Invoke(DISPID dispIdMember, REFIID riid,
 758         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
 759         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 760 {
 761     if( SUCCEEDED(loadTypeInfo()) )
 762     {
 763         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
 764                 pVarResult, pExcepInfo, puArgErr);
 765     }
 766     return E_NOTIMPL;
 767 };
 768
 769 STDMETHODIMP VLCLog::get_messages(IVLCMessages** obj)
 770 {
 771     if( NULL == obj )
 772         return E_POINTER;
 773
 774     *obj = _p_vlcmessages;
 775     if( NULL != _p_vlcmessages )
 776     {
 777         _p_vlcmessages->AddRef();
 778         return NOERROR;
 779     }
 780     return E_OUTOFMEMORY;
 781 };
 782
 783 STDMETHODIMP VLCLog::get_verbosity(long* level)
 784 {
 785     if( NULL == level )
 786         return E_POINTER;
 787
 788     if( _p_log )
 789     {
 790         libvlc_instance_t* p_libvlc;
 791         HRESULT hr = _p_instance->getVLC(&p_libvlc);
 792         if( SUCCEEDED(hr) )
 793         {
 794             libvlc_exception_t ex;
 795             libvlc_exception_init(&ex);
 796
 797             *level = libvlc_get_log_verbosity(p_libvlc, &ex);
 798             if( libvlc_exception_raised(&ex) )
 799             {
 800                 _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
 801                 libvlc_exception_clear(&ex);
 802                 return E_FAIL;
 803             }
 804         }
 805         return hr;
 806     }
 807     else
 808     {
 809         /* log is not enabled, return -1 */
 810         *level = -1;
 811         return NOERROR;
 812     }
 813 };
 814
 815 STDMETHODIMP VLCLog::put_verbosity(long verbosity)
 816 {
 817     libvlc_exception_t ex;
 818     libvlc_exception_init(&ex);
 819
 820     libvlc_instance_t* p_libvlc;
 821     HRESULT hr = _p_instance->getVLC(&p_libvlc);
 822     if( SUCCEEDED(hr) )
 823     {
 824         if( verbosity >= 0 )
 825         {
 826             if( ! _p_log )
 827             {
 828                 _p_log = libvlc_log_open(p_libvlc, &ex);
 829                 if( libvlc_exception_raised(&ex) )
 830                 {
 831                     _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
 832                     libvlc_exception_clear(&ex);
 833                     return E_FAIL;
 834                 }
 835             }
 836             libvlc_set_log_verbosity(p_libvlc, (unsigned)verbosity, &ex);
 837             if( libvlc_exception_raised(&ex) )
 838             {
 839                 _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
 840                 libvlc_exception_clear(&ex);
 841                 return E_FAIL;
 842             }
 843         }
 844         else if( _p_log )
 845         {
 846             /* close log  when verbosity is set to -1 */
 847             libvlc_log_close(_p_log, &ex);
 848             _p_log = NULL;
 849             if( libvlc_exception_raised(&ex) )
 850             {
 851                 _p_instance->setErrorInfo(IID_IVLCLog, libvlc_exception_get_message(&ex));
 852                 libvlc_exception_clear(&ex);
 853                 return E_FAIL;
 854             }
 855         }
 856     }
 857     return hr;
 858 };
 859
 860 /*******************************************************************************/
 861
 862 /* STL forward iterator used by VLCEnumIterator class to implement IEnumVARIANT */
 863
 864 class VLCMessageSTLIterator
 865 {
 866
 867 public:
 868
 869     VLCMessageSTLIterator(IVLCMessageIterator* iter) : iter(iter), msg(NULL)
 870     {
 871         // get first message
 872         operator++();
 873     };
 874
 875     VLCMessageSTLIterator(const VLCMessageSTLIterator& other)
 876     {
 877         iter = other.iter;
 878         if( iter )
 879             iter->AddRef();
 880         msg = other.msg;
 881         if( msg )
 882             msg->AddRef();
 883     };
 884
 885     virtual ~VLCMessageSTLIterator()
 886     {
 887         if( msg )
 888             msg->Release();
 889
 890         if( iter )
 891             iter->Release();
 892     };
 893
 894     // we only need prefix ++ operator
 895     VLCMessageSTLIterator& operator++()
 896     {
 897         VARIANT_BOOL hasNext = VARIANT_FALSE;
 898         if( iter )
 899         {
 900             iter->get_hasNext(&hasNext);
 901
 902             if( msg )
 903             {
 904                 msg->Release();
 905                 msg = NULL;
 906             }
 907             if( VARIANT_TRUE == hasNext ) {
 908                 iter->next(&msg);
 909             }
 910         }
 911         return *this;
 912     };
 913
 914     VARIANT operator*() const
 915     {
 916         VARIANT v;
 917         VariantInit(&v);
 918         if( msg )
 919         {
 920             if( SUCCEEDED(msg->QueryInterface(IID_IDispatch, (LPVOID*)&V_DISPATCH(&v))) )
 921             {
 922                 V_VT(&v) = VT_DISPATCH;
 923             }
 924         }
 925         return v;
 926     };
 927
 928     bool operator==(const VLCMessageSTLIterator& other) const
 929     {
 930         return msg == other.msg;
 931     };
 932
 933     bool operator!=(const VLCMessageSTLIterator& other) const
 934     {
 935         return msg != other.msg;
 936     };
 937
 938 private:
 939     IVLCMessageIterator* iter;
 940     IVLCMessage*         msg;
 941 };
 942
 943 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 944
 945 VLCMessages::~VLCMessages()
 946 {
 947     if( _p_typeinfo )
 948         _p_typeinfo->Release();
 949 };
 950
 951 HRESULT VLCMessages::loadTypeInfo(void)
 952 {
 953     HRESULT hr = NOERROR;
 954     if( NULL == _p_typeinfo )
 955     {
 956         ITypeLib *p_typelib;
 957
 958         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
 959         if( SUCCEEDED(hr) )
 960         {
 961             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCMessages, &_p_typeinfo);
 962             if( FAILED(hr) )
 963             {
 964                 _p_typeinfo = NULL;
 965             }
 966             p_typelib->Release();
 967         }
 968     }
 969     return hr;
 970 };
 971
 972 STDMETHODIMP VLCMessages::GetTypeInfoCount(UINT* pctInfo)
 973 {
 974     if( NULL == pctInfo )
 975         return E_INVALIDARG;
 976
 977     if( SUCCEEDED(loadTypeInfo()) )
 978         *pctInfo = 1;
 979     else
 980         *pctInfo = 0;
 981
 982     return NOERROR;
 983 };
 984
 985 STDMETHODIMP VLCMessages::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
 986 {
 987     if( NULL == ppTInfo )
 988         return E_INVALIDARG;
 989
 990     if( SUCCEEDED(loadTypeInfo()) )
 991     {
 992         _p_typeinfo->AddRef();
 993         *ppTInfo = _p_typeinfo;
 994         return NOERROR;
 995     }
 996     *ppTInfo = NULL;
 997     return E_NOTIMPL;
 998 };
 999
1000 STDMETHODIMP VLCMessages::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
1001         UINT cNames, LCID lcid, DISPID* rgDispID)
1002 {
1003     if( SUCCEEDED(loadTypeInfo()) )
1004     {
1005         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
1006     }
1007     return E_NOTIMPL;
1008 };
1009
1010 STDMETHODIMP VLCMessages::Invoke(DISPID dispIdMember, REFIID riid,
1011         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1012         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1013 {
1014     if( SUCCEEDED(loadTypeInfo()) )
1015     {
1016         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
1017                 pVarResult, pExcepInfo, puArgErr);
1018     }
1019     return E_NOTIMPL;
1020 };
1021
1022 STDMETHODIMP VLCMessages::get__NewEnum(LPUNKNOWN* _NewEnum)
1023 {
1024     if( NULL == _NewEnum )
1025         return E_POINTER;
1026
1027     IVLCMessageIterator* iter = NULL;
1028     iterator(&iter);
1029
1030     *_NewEnum= new VLCEnumIterator<IID_IEnumVARIANT,
1031                        IEnumVARIANT,
1032                        VARIANT,
1033                        VLCMessageSTLIterator>
1034                        (VLCMessageSTLIterator(iter), VLCMessageSTLIterator(NULL));
1035
1036     return *_NewEnum ? S_OK : E_OUTOFMEMORY;
1037 };
1038
1039 STDMETHODIMP VLCMessages::clear()
1040 {
1041     libvlc_log_t *p_log = _p_vlclog->_p_log;
1042     if( p_log )
1043     {
1044         libvlc_exception_t ex;
1045         libvlc_exception_init(&ex);
1046
1047         libvlc_log_clear(p_log, &ex);
1048         if( libvlc_exception_raised(&ex) )
1049         {
1050             _p_instance->setErrorInfo(IID_IVLCMessages, libvlc_exception_get_message(&ex));
1051             libvlc_exception_clear(&ex);
1052             return E_FAIL;
1053         }
1054     }
1055     return NOERROR;
1056 };
1057
1058 STDMETHODIMP VLCMessages::get_count(long* count)
1059 {
1060     if( NULL == count )
1061         return E_POINTER;
1062
1063     libvlc_log_t *p_log = _p_vlclog->_p_log;
1064     if( p_log )
1065     {
1066         libvlc_exception_t ex;
1067         libvlc_exception_init(&ex);
1068
1069         *count = libvlc_log_count(p_log, &ex);
1070         if( libvlc_exception_raised(&ex) )
1071         {
1072             _p_instance->setErrorInfo(IID_IVLCMessages, libvlc_exception_get_message(&ex));
1073             libvlc_exception_clear(&ex);
1074             return E_FAIL;
1075         }
1076     }
1077     else
1078         *count = 0;
1079     return S_OK;
1080 };
1081
1082 STDMETHODIMP VLCMessages::iterator(IVLCMessageIterator** iter)
1083 {
1084     if( NULL == iter )
1085         return E_POINTER;
1086
1087     *iter = new VLCMessageIterator(_p_instance, _p_vlclog);
1088
1089     return *iter ? S_OK : E_OUTOFMEMORY;
1090 };
1091
1092 /*******************************************************************************/
1093
1094 VLCMessageIterator::VLCMessageIterator(VLCPlugin *p_instance, VLCLog* p_vlclog ) :
1095     _p_instance(p_instance),
1096     _p_typeinfo(NULL),
1097     _refcount(1),
1098     _p_vlclog(p_vlclog)
1099 {
1100     if( p_vlclog->_p_log )
1101     {
1102         _p_iter = libvlc_log_get_iterator(p_vlclog->_p_log, NULL);
1103     }
1104     else
1105         _p_iter = NULL;
1106 };
1107
1108 VLCMessageIterator::~VLCMessageIterator()
1109 {
1110     if( _p_iter )
1111         libvlc_log_iterator_free(_p_iter, NULL);
1112
1113     if( _p_typeinfo )
1114         _p_typeinfo->Release();
1115 };
1116
1117 HRESULT VLCMessageIterator::loadTypeInfo(void)
1118 {
1119     HRESULT hr = NOERROR;
1120     if( NULL == _p_typeinfo )
1121     {
1122         ITypeLib *p_typelib;
1123
1124         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
1125         if( SUCCEEDED(hr) )
1126         {
1127             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCMessageIterator, &_p_typeinfo);
1128             if( FAILED(hr) )
1129             {
1130                 _p_typeinfo = NULL;
1131             }
1132             p_typelib->Release();
1133         }
1134     }
1135     return hr;
1136 };
1137
1138 STDMETHODIMP VLCMessageIterator::GetTypeInfoCount(UINT* pctInfo)
1139 {
1140     if( NULL == pctInfo )
1141         return E_INVALIDARG;
1142
1143     if( SUCCEEDED(loadTypeInfo()) )
1144         *pctInfo = 1;
1145     else
1146         *pctInfo = 0;
1147
1148     return NOERROR;
1149 };
1150
1151 STDMETHODIMP VLCMessageIterator::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
1152 {
1153     if( NULL == ppTInfo )
1154         return E_INVALIDARG;
1155
1156     if( SUCCEEDED(loadTypeInfo()) )
1157     {
1158         _p_typeinfo->AddRef();
1159         *ppTInfo = _p_typeinfo;
1160         return NOERROR;
1161     }
1162     *ppTInfo = NULL;
1163     return E_NOTIMPL;
1164 };
1165
1166 STDMETHODIMP VLCMessageIterator::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
1167         UINT cNames, LCID lcid, DISPID* rgDispID)
1168 {
1169     if( SUCCEEDED(loadTypeInfo()) )
1170     {
1171         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
1172     }
1173     return E_NOTIMPL;
1174 };
1175
1176 STDMETHODIMP VLCMessageIterator::Invoke(DISPID dispIdMember, REFIID riid,
1177         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1178         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1179 {
1180     if( SUCCEEDED(loadTypeInfo()) )
1181     {
1182         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
1183                 pVarResult, pExcepInfo, puArgErr);
1184     }
1185     return E_NOTIMPL;
1186 };
1187
1188 STDMETHODIMP VLCMessageIterator::get_hasNext(VARIANT_BOOL* hasNext)
1189 {
1190     if( NULL == hasNext )
1191         return E_POINTER;
1192
1193     if( _p_iter &&  _p_vlclog->_p_log )
1194     {
1195         libvlc_exception_t ex;
1196         libvlc_exception_init(&ex);
1197
1198         *hasNext = libvlc_log_iterator_has_next(_p_iter, &ex) ? VARIANT_TRUE : VARIANT_FALSE;
1199         if( libvlc_exception_raised(&ex) )
1200         {
1201             _p_instance->setErrorInfo(IID_IVLCMessageIterator, libvlc_exception_get_message(&ex));
1202             libvlc_exception_clear(&ex);
1203             return E_FAIL;
1204         }
1205     }
1206     else
1207     {
1208         *hasNext = VARIANT_FALSE;
1209     }
1210     return S_OK;
1211 };
1212
1213 STDMETHODIMP VLCMessageIterator::next(IVLCMessage** message)
1214 {
1215     if( NULL == message )
1216         return E_POINTER;
1217
1218     if( _p_iter &&  _p_vlclog->_p_log )
1219     {
1220         struct libvlc_log_message_t buffer;
1221
1222         buffer.sizeof_msg = sizeof(buffer);
1223
1224         libvlc_exception_t ex;
1225         libvlc_exception_init(&ex);
1226
1227         libvlc_log_iterator_next(_p_iter, &buffer, &ex);
1228         if( libvlc_exception_raised(&ex) )
1229         {
1230             _p_instance->setErrorInfo(IID_IVLCMessageIterator, libvlc_exception_get_message(&ex));
1231             libvlc_exception_clear(&ex);
1232             return E_FAIL;
1233         }
1234         *message = new VLCMessage(_p_instance, buffer);
1235         return *message ? NOERROR : E_OUTOFMEMORY;
1236     }
1237     return E_FAIL;
1238 };
1239
1240 /*******************************************************************************/
1241
1242 VLCMessage::~VLCMessage()
1243 {
1244     if( _p_typeinfo )
1245         _p_typeinfo->Release();
1246 };
1247
1248 HRESULT VLCMessage::loadTypeInfo(void)
1249 {
1250     HRESULT hr = NOERROR;
1251     if( NULL == _p_typeinfo )
1252     {
1253         ITypeLib *p_typelib;
1254
1255         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
1256         if( SUCCEEDED(hr) )
1257         {
1258             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCMessage, &_p_typeinfo);
1259             if( FAILED(hr) )
1260             {
1261                 _p_typeinfo = NULL;
1262             }
1263             p_typelib->Release();
1264         }
1265     }
1266     return hr;
1267 };
1268
1269 STDMETHODIMP VLCMessage::GetTypeInfoCount(UINT* pctInfo)
1270 {
1271     if( NULL == pctInfo )
1272         return E_INVALIDARG;
1273
1274     if( SUCCEEDED(loadTypeInfo()) )
1275         *pctInfo = 1;
1276     else
1277         *pctInfo = 0;
1278
1279     return NOERROR;
1280 };
1281
1282 STDMETHODIMP VLCMessage::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
1283 {
1284     if( NULL == ppTInfo )
1285         return E_INVALIDARG;
1286
1287     if( SUCCEEDED(loadTypeInfo()) )
1288     {
1289         _p_typeinfo->AddRef();
1290         *ppTInfo = _p_typeinfo;
1291         return NOERROR;
1292     }
1293     *ppTInfo = NULL;
1294     return E_NOTIMPL;
1295 };
1296
1297 STDMETHODIMP VLCMessage::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
1298         UINT cNames, LCID lcid, DISPID* rgDispID)
1299 {
1300     if( SUCCEEDED(loadTypeInfo()) )
1301     {
1302         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
1303     }
1304     return E_NOTIMPL;
1305 };
1306
1307 STDMETHODIMP VLCMessage::Invoke(DISPID dispIdMember, REFIID riid,
1308         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1309         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1310 {
1311     if( SUCCEEDED(loadTypeInfo()) )
1312     {
1313         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
1314                 pVarResult, pExcepInfo, puArgErr);
1315     }
1316     return E_NOTIMPL;
1317 };
1318
1319 inline const char *msgSeverity(int sev)
1320 {
1321     switch( sev )
1322     {
1323         case 0:
1324             return "info";
1325         case 1:
1326             return "error";
1327         case 2:
1328             return "warning";
1329         default:
1330             return "debug";
1331     }
1332 };
1333
1334 STDMETHODIMP VLCMessage::get__Value(VARIANT* _Value)
1335 {
1336     if( NULL == _Value )
1337         return E_POINTER;
1338
1339     char buffer[256];
1340
1341     snprintf(buffer, sizeof(buffer), "%s %s %s: %s",
1342         _msg.psz_type, _msg.psz_name, msgSeverity(_msg.i_severity), _msg.psz_message);
1343
1344     V_VT(_Value) = VT_BSTR;
1345     V_BSTR(_Value) = BSTRFromCStr(CP_UTF8, buffer);
1346
1347     return S_OK;
1348 };
1349
1350 STDMETHODIMP VLCMessage::get_severity(long* level)
1351 {
1352     if( NULL == level )
1353         return E_POINTER;
1354
1355     *level = _msg.i_severity;
1356
1357     return S_OK;
1358 };
1359
1360 STDMETHODIMP VLCMessage::get_type(BSTR* type)
1361 {
1362     if( NULL == type )
1363         return E_POINTER;
1364
1365     *type = BSTRFromCStr(CP_UTF8, _msg.psz_type);
1366
1367     return NOERROR;
1368 };
1369
1370 STDMETHODIMP VLCMessage::get_name(BSTR* name)
1371 {
1372     if( NULL == name )
1373         return E_POINTER;
1374
1375     *name = BSTRFromCStr(CP_UTF8, _msg.psz_name);
1376
1377     return NOERROR;
1378 };
1379
1380 STDMETHODIMP VLCMessage::get_header(BSTR* header)
1381 {
1382     if( NULL == header )
1383         return E_POINTER;
1384
1385     *header = BSTRFromCStr(CP_UTF8, _msg.psz_header);
1386
1387     return NOERROR;
1388 };
1389
1390 STDMETHODIMP VLCMessage::get_message(BSTR* message)
1391 {
1392     if( NULL == message )
1393         return E_POINTER;
1394
1395     *message = BSTRFromCStr(CP_UTF8, _msg.psz_message);
1396
1397     return NOERROR;
1398 };
1399
1400 /*******************************************************************************/
1401
1402 VLCPlaylistItems::~VLCPlaylistItems()
1403 {
1404     if( _p_typeinfo )
1405         _p_typeinfo->Release();
1406 };
1407
1408 HRESULT VLCPlaylistItems::loadTypeInfo(void)
1409 {
1410     HRESULT hr = NOERROR;
1411     if( NULL == _p_typeinfo )
1412     {
1413         ITypeLib *p_typelib;
1414
1415         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
1416         if( SUCCEEDED(hr) )
1417         {
1418             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCPlaylistItems, &_p_typeinfo);
1419             if( FAILED(hr) )
1420             {
1421                 _p_typeinfo = NULL;
1422             }
1423             p_typelib->Release();
1424         }
1425     }
1426     return hr;
1427 };
1428
1429 STDMETHODIMP VLCPlaylistItems::GetTypeInfoCount(UINT* pctInfo)
1430 {
1431     if( NULL == pctInfo )
1432         return E_INVALIDARG;
1433
1434     if( SUCCEEDED(loadTypeInfo()) )
1435         *pctInfo = 1;
1436     else
1437         *pctInfo = 0;
1438
1439     return NOERROR;
1440 };
1441
1442 STDMETHODIMP VLCPlaylistItems::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
1443 {
1444     if( NULL == ppTInfo )
1445         return E_INVALIDARG;
1446
1447     if( SUCCEEDED(loadTypeInfo()) )
1448     {
1449         _p_typeinfo->AddRef();
1450         *ppTInfo = _p_typeinfo;
1451         return NOERROR;
1452     }
1453     *ppTInfo = NULL;
1454     return E_NOTIMPL;
1455 };
1456
1457 STDMETHODIMP VLCPlaylistItems::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
1458         UINT cNames, LCID lcid, DISPID* rgDispID)
1459 {
1460     if( SUCCEEDED(loadTypeInfo()) )
1461     {
1462         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
1463     }
1464     return E_NOTIMPL;
1465 };
1466
1467 STDMETHODIMP VLCPlaylistItems::Invoke(DISPID dispIdMember, REFIID riid,
1468         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1469         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1470 {
1471     if( SUCCEEDED(loadTypeInfo()) )
1472     {
1473         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
1474                 pVarResult, pExcepInfo, puArgErr);
1475     }
1476     return E_NOTIMPL;
1477 };
1478
1479 STDMETHODIMP VLCPlaylistItems::get_count(long* count)
1480 {
1481     if( NULL == count )
1482         return E_POINTER;
1483
1484     libvlc_instance_t* p_libvlc;
1485     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1486     if( SUCCEEDED(hr) )
1487     {
1488         libvlc_exception_t ex;
1489         libvlc_exception_init(&ex);
1490
1491         *count = libvlc_playlist_items_count(p_libvlc, &ex);
1492         if( libvlc_exception_raised(&ex) )
1493         {
1494             _p_instance->setErrorInfo(IID_IVLCPlaylistItems,
1495                 libvlc_exception_get_message(&ex));
1496             libvlc_exception_clear(&ex);
1497             return E_FAIL;
1498         }
1499         return NOERROR;
1500     }
1501     return hr;
1502 };
1503
1504 STDMETHODIMP VLCPlaylistItems::clear()
1505 {
1506     libvlc_instance_t* p_libvlc;
1507     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1508     if( SUCCEEDED(hr) )
1509     {
1510         libvlc_exception_t ex;
1511         libvlc_exception_init(&ex);
1512
1513         libvlc_playlist_clear(p_libvlc, &ex);
1514         if( libvlc_exception_raised(&ex) )
1515         {
1516             _p_instance->setErrorInfo(IID_IVLCPlaylistItems,
1517                 libvlc_exception_get_message(&ex));
1518             libvlc_exception_clear(&ex);
1519             return E_FAIL;
1520         }
1521         return NOERROR;
1522     }
1523     return hr;
1524 };
1525
1526 STDMETHODIMP VLCPlaylistItems::remove(long item)
1527 {
1528     libvlc_instance_t* p_libvlc;
1529     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1530     if( SUCCEEDED(hr) )
1531     {
1532         libvlc_exception_t ex;
1533         libvlc_exception_init(&ex);
1534
1535         libvlc_playlist_delete_item(p_libvlc, item, &ex);
1536         if( libvlc_exception_raised(&ex) )
1537         {
1538             _p_instance->setErrorInfo(IID_IVLCPlaylistItems,
1539                 libvlc_exception_get_message(&ex));
1540             libvlc_exception_clear(&ex);
1541             return E_FAIL;
1542         }
1543         return NOERROR;
1544     }
1545     return hr;
1546 };
1547
1548 /*******************************************************************************/
1549
1550 VLCPlaylist::~VLCPlaylist()
1551 {
1552     delete _p_vlcplaylistitems;
1553     if( _p_typeinfo )
1554         _p_typeinfo->Release();
1555 };
1556
1557 HRESULT VLCPlaylist::loadTypeInfo(void)
1558 {
1559     HRESULT hr = NOERROR;
1560     if( NULL == _p_typeinfo )
1561     {
1562         ITypeLib *p_typelib;
1563
1564         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
1565         if( SUCCEEDED(hr) )
1566         {
1567             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCPlaylist, &_p_typeinfo);
1568             if( FAILED(hr) )
1569             {
1570                 _p_typeinfo = NULL;
1571             }
1572             p_typelib->Release();
1573         }
1574     }
1575     return hr;
1576 };
1577
1578 STDMETHODIMP VLCPlaylist::GetTypeInfoCount(UINT* pctInfo)
1579 {
1580     if( NULL == pctInfo )
1581         return E_INVALIDARG;
1582
1583     if( SUCCEEDED(loadTypeInfo()) )
1584         *pctInfo = 1;
1585     else
1586         *pctInfo = 0;
1587
1588     return NOERROR;
1589 };
1590
1591 STDMETHODIMP VLCPlaylist::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
1592 {
1593     if( NULL == ppTInfo )
1594         return E_INVALIDARG;
1595
1596     if( SUCCEEDED(loadTypeInfo()) )
1597     {
1598         _p_typeinfo->AddRef();
1599         *ppTInfo = _p_typeinfo;
1600         return NOERROR;
1601     }
1602     *ppTInfo = NULL;
1603     return E_NOTIMPL;
1604 };
1605
1606 STDMETHODIMP VLCPlaylist::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
1607         UINT cNames, LCID lcid, DISPID* rgDispID)
1608 {
1609     if( SUCCEEDED(loadTypeInfo()) )
1610     {
1611         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
1612     }
1613     return E_NOTIMPL;
1614 };
1615
1616 STDMETHODIMP VLCPlaylist::Invoke(DISPID dispIdMember, REFIID riid,
1617         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1618         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1619 {
1620     if( SUCCEEDED(loadTypeInfo()) )
1621     {
1622         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
1623                 pVarResult, pExcepInfo, puArgErr);
1624     }
1625     return E_NOTIMPL;
1626 };
1627
1628 STDMETHODIMP VLCPlaylist::get_itemCount(long* count)
1629 {
1630     if( NULL == count )
1631         return E_POINTER;
1632
1633     libvlc_instance_t* p_libvlc;
1634     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1635     if( SUCCEEDED(hr) )
1636     {
1637         libvlc_exception_t ex;
1638         libvlc_exception_init(&ex);
1639
1640         *count = libvlc_playlist_items_count(p_libvlc, &ex);
1641         if( libvlc_exception_raised(&ex) )
1642         {
1643             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1644                 libvlc_exception_get_message(&ex));
1645             libvlc_exception_clear(&ex);
1646             return E_FAIL;
1647         }
1648         return NOERROR;
1649     }
1650     return hr;
1651 };
1652
1653 STDMETHODIMP VLCPlaylist::get_isPlaying(VARIANT_BOOL* isPlaying)
1654 {
1655     if( NULL == isPlaying )
1656         return E_POINTER;
1657
1658     libvlc_instance_t* p_libvlc;
1659     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1660     if( SUCCEEDED(hr) )
1661     {
1662         libvlc_exception_t ex;
1663         libvlc_exception_init(&ex);
1664
1665         *isPlaying = libvlc_playlist_isplaying(p_libvlc, &ex) ? VARIANT_TRUE: VARIANT_FALSE;
1666         if( libvlc_exception_raised(&ex) )
1667         {
1668             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1669                 libvlc_exception_get_message(&ex));
1670             libvlc_exception_clear(&ex);
1671             return E_FAIL;
1672         }
1673         return NOERROR;
1674     }
1675     return hr;
1676 };
1677
1678 STDMETHODIMP VLCPlaylist::add(BSTR uri, VARIANT name, VARIANT options, long* item)
1679 {
1680     if( NULL == item )
1681         return E_POINTER;
1682
1683     if( 0 == SysStringLen(uri) )
1684         return E_INVALIDARG;
1685
1686     libvlc_instance_t* p_libvlc;
1687     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1688     if( SUCCEEDED(hr) )
1689     {
1690         libvlc_exception_t ex;
1691         libvlc_exception_init(&ex);
1692
1693         char *psz_uri = NULL;
1694         if( SysStringLen(_p_instance->getBaseURL()) > 0 )
1695         {
1696             /*
1697             ** if the MRL a relative URL, we should end up with an absolute URL
1698             */
1699             LPWSTR abs_url = CombineURL(_p_instance->getBaseURL(), uri);
1700             if( NULL != abs_url )
1701             {
1702                 psz_uri = CStrFromWSTR(CP_UTF8, abs_url, wcslen(abs_url));
1703                 CoTaskMemFree(abs_url);
1704             }
1705             else
1706             {
1707                 psz_uri = CStrFromBSTR(CP_UTF8, uri);
1708             }
1709         }
1710         else
1711         {
1712             /*
1713             ** baseURL is empty, assume MRL is absolute
1714             */
1715             psz_uri = CStrFromBSTR(CP_UTF8, uri);
1716         }
1717
1718         if( NULL == psz_uri )
1719         {
1720             return E_OUTOFMEMORY;
1721         }
1722
1723         int i_options;
1724         char **ppsz_options;
1725
1726         hr = VLCControl::CreateTargetOptions(CP_UTF8, &options, &ppsz_options, &i_options);
1727         if( FAILED(hr) )
1728         {
1729             CoTaskMemFree(psz_uri);
1730             return hr;
1731         }
1732
1733         char *psz_name = NULL;
1734         VARIANT v_name;
1735         VariantInit(&v_name);
1736         if( SUCCEEDED(VariantChangeType(&v_name, &name, 0, VT_BSTR)) )
1737         {
1738             if( SysStringLen(V_BSTR(&v_name)) > 0 )
1739                 psz_name = CStrFromBSTR(CP_UTF8, V_BSTR(&v_name));
1740
1741             VariantClear(&v_name);
1742         }
1743
1744         *item = libvlc_playlist_add_extended(p_libvlc,
1745                     psz_uri,
1746                     psz_name,
1747                     i_options,
1748                     const_cast<const char **>(ppsz_options),
1749                     &ex);
1750
1751         VLCControl::FreeTargetOptions(ppsz_options, i_options);
1752         CoTaskMemFree(psz_uri);
1753         if( psz_name )
1754             CoTaskMemFree(psz_name);
1755         if( libvlc_exception_raised(&ex) )
1756         {
1757             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1758                 libvlc_exception_get_message(&ex));
1759             libvlc_exception_clear(&ex);
1760             return E_FAIL;
1761         }
1762         return NOERROR;
1763     }
1764     return hr;
1765 };
1766
1767 STDMETHODIMP VLCPlaylist::play()
1768 {
1769     libvlc_instance_t* p_libvlc;
1770     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1771     if( SUCCEEDED(hr) )
1772     {
1773         libvlc_exception_t ex;
1774         libvlc_exception_init(&ex);
1775
1776         libvlc_playlist_play(p_libvlc, -1, 0, NULL, &ex);
1777         if( libvlc_exception_raised(&ex) )
1778         {
1779             libvlc_exception_clear(&ex);
1780             return E_FAIL;
1781         }
1782         return NOERROR;
1783     }
1784     return hr;
1785 };
1786
1787 STDMETHODIMP VLCPlaylist::playItem(long item)
1788 {
1789     libvlc_instance_t* p_libvlc;
1790     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1791     if( SUCCEEDED(hr) )
1792     {
1793         libvlc_exception_t ex;
1794         libvlc_exception_init(&ex);
1795
1796         libvlc_playlist_play(p_libvlc, item, 0, NULL, &ex);
1797         if( libvlc_exception_raised(&ex) )
1798         {
1799             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1800                 libvlc_exception_get_message(&ex));
1801             libvlc_exception_clear(&ex);
1802             return E_FAIL;
1803         }
1804         return NOERROR;
1805     }
1806     return hr;
1807 };
1808
1809 STDMETHODIMP VLCPlaylist::togglePause()
1810 {
1811     libvlc_instance_t* p_libvlc;
1812     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1813     if( SUCCEEDED(hr) )
1814     {
1815         libvlc_exception_t ex;
1816         libvlc_exception_init(&ex);
1817
1818         libvlc_playlist_pause(p_libvlc, &ex);
1819         if( libvlc_exception_raised(&ex) )
1820         {
1821             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1822                 libvlc_exception_get_message(&ex));
1823             libvlc_exception_clear(&ex);
1824             return E_FAIL;
1825         }
1826         return NOERROR;
1827     }
1828     return hr;
1829 };
1830
1831 STDMETHODIMP VLCPlaylist::stop()
1832 {
1833     libvlc_instance_t* p_libvlc;
1834     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1835     if( SUCCEEDED(hr) )
1836     {
1837         libvlc_exception_t ex;
1838         libvlc_exception_init(&ex);
1839
1840         libvlc_playlist_stop(p_libvlc, &ex);
1841         if( libvlc_exception_raised(&ex) )
1842         {
1843             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1844                 libvlc_exception_get_message(&ex));
1845             libvlc_exception_clear(&ex);
1846             return E_FAIL;
1847         }
1848         return NOERROR;
1849     }
1850     return hr;
1851 };
1852
1853 STDMETHODIMP VLCPlaylist::next()
1854 {
1855     libvlc_instance_t* p_libvlc;
1856     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1857     if( SUCCEEDED(hr) )
1858     {
1859         libvlc_exception_t ex;
1860         libvlc_exception_init(&ex);
1861
1862         libvlc_playlist_next(p_libvlc, &ex);
1863         if( libvlc_exception_raised(&ex) )
1864         {
1865             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1866                 libvlc_exception_get_message(&ex));
1867             libvlc_exception_clear(&ex);
1868             return E_FAIL;
1869         }
1870         return NOERROR;
1871     }
1872     return hr;
1873 };
1874
1875 STDMETHODIMP VLCPlaylist::prev()
1876 {
1877     libvlc_instance_t* p_libvlc;
1878     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1879     if( SUCCEEDED(hr) )
1880     {
1881         libvlc_exception_t ex;
1882         libvlc_exception_init(&ex);
1883
1884         libvlc_playlist_prev(p_libvlc, &ex);
1885         if( libvlc_exception_raised(&ex) )
1886         {
1887             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1888                 libvlc_exception_get_message(&ex));
1889             libvlc_exception_clear(&ex);
1890             return E_FAIL;
1891         }
1892         return NOERROR;
1893     }
1894     return hr;
1895 };
1896
1897 STDMETHODIMP VLCPlaylist::clear()
1898 {
1899     libvlc_instance_t* p_libvlc;
1900     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1901     if( SUCCEEDED(hr) )
1902     {
1903         libvlc_exception_t ex;
1904         libvlc_exception_init(&ex);
1905
1906         libvlc_playlist_clear(p_libvlc, &ex);
1907         if( libvlc_exception_raised(&ex) )
1908         {
1909             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1910                 libvlc_exception_get_message(&ex));
1911             libvlc_exception_clear(&ex);
1912             return E_FAIL;
1913         }
1914         return NOERROR;
1915     }
1916     return hr;
1917 };
1918
1919 STDMETHODIMP VLCPlaylist::removeItem(long item)
1920 {
1921     libvlc_instance_t* p_libvlc;
1922     HRESULT hr = _p_instance->getVLC(&p_libvlc);
1923     if( SUCCEEDED(hr) )
1924     {
1925         libvlc_exception_t ex;
1926         libvlc_exception_init(&ex);
1927
1928         libvlc_playlist_delete_item(p_libvlc, item, &ex);
1929         if( libvlc_exception_raised(&ex) )
1930         {
1931             _p_instance->setErrorInfo(IID_IVLCPlaylist,
1932                 libvlc_exception_get_message(&ex));
1933             libvlc_exception_clear(&ex);
1934             return E_FAIL;
1935         }
1936         return NOERROR;
1937     }
1938     return hr;
1939 };
1940
1941 STDMETHODIMP VLCPlaylist::get_items(IVLCPlaylistItems** obj)
1942 {
1943     if( NULL == obj )
1944         return E_POINTER;
1945
1946     *obj = _p_vlcplaylistitems;
1947     if( NULL != _p_vlcplaylistitems )
1948     {
1949         _p_vlcplaylistitems->AddRef();
1950         return NOERROR;
1951     }
1952     return E_OUTOFMEMORY;
1953 };
1954
1955 /*******************************************************************************/
1956
1957 VLCVideo::~VLCVideo()
1958 {
1959     if( _p_typeinfo )
1960         _p_typeinfo->Release();
1961 };
1962
1963 HRESULT VLCVideo::loadTypeInfo(void)
1964 {
1965     HRESULT hr = NOERROR;
1966     if( NULL == _p_typeinfo )
1967     {
1968         ITypeLib *p_typelib;
1969
1970         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
1971         if( SUCCEEDED(hr) )
1972         {
1973             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCVideo, &_p_typeinfo);
1974             if( FAILED(hr) )
1975             {
1976                 _p_typeinfo = NULL;
1977             }
1978             p_typelib->Release();
1979         }
1980     }
1981     return hr;
1982 };
1983
1984 STDMETHODIMP VLCVideo::GetTypeInfoCount(UINT* pctInfo)
1985 {
1986     if( NULL == pctInfo )
1987         return E_INVALIDARG;
1988
1989     if( SUCCEEDED(loadTypeInfo()) )
1990         *pctInfo = 1;
1991     else
1992         *pctInfo = 0;
1993
1994     return NOERROR;
1995 };
1996
1997 STDMETHODIMP VLCVideo::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
1998 {
1999     if( NULL == ppTInfo )
2000         return E_INVALIDARG;
2001
2002     if( SUCCEEDED(loadTypeInfo()) )
2003     {
2004         _p_typeinfo->AddRef();
2005         *ppTInfo = _p_typeinfo;
2006         return NOERROR;
2007     }
2008     *ppTInfo = NULL;
2009     return E_NOTIMPL;
2010 };
2011
2012 STDMETHODIMP VLCVideo::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
2013         UINT cNames, LCID lcid, DISPID* rgDispID)
2014 {
2015     if( SUCCEEDED(loadTypeInfo()) )
2016     {
2017         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
2018     }
2019     return E_NOTIMPL;
2020 };
2021
2022 STDMETHODIMP VLCVideo::Invoke(DISPID dispIdMember, REFIID riid,
2023         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
2024         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
2025 {
2026     if( SUCCEEDED(loadTypeInfo()) )
2027     {
2028         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
2029                 pVarResult, pExcepInfo, puArgErr);
2030     }
2031     return E_NOTIMPL;
2032 };
2033
2034 STDMETHODIMP VLCVideo::get_fullscreen(VARIANT_BOOL* fullscreen)
2035 {
2036     if( NULL == fullscreen )
2037         return E_POINTER;
2038
2039     libvlc_instance_t* p_libvlc;
2040     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2041     if( SUCCEEDED(hr) )
2042     {
2043         libvlc_exception_t ex;
2044         libvlc_exception_init(&ex);
2045
2046         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2047         if( ! libvlc_exception_raised(&ex) )
2048         {
2049             *fullscreen = libvlc_get_fullscreen(p_md, &ex) ? VARIANT_TRUE : VARIANT_FALSE;
2050             libvlc_media_instance_release(p_md);
2051             if( ! libvlc_exception_raised(&ex) )
2052             {
2053                 return NOERROR;
2054             }
2055         }
2056         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2057         libvlc_exception_clear(&ex);
2058         return E_FAIL;
2059     }
2060     return hr;
2061 };
2062
2063 STDMETHODIMP VLCVideo::put_fullscreen(VARIANT_BOOL fullscreen)
2064 {
2065     libvlc_instance_t* p_libvlc;
2066     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2067     if( SUCCEEDED(hr) )
2068     {
2069         libvlc_exception_t ex;
2070         libvlc_exception_init(&ex);
2071
2072         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2073         if( ! libvlc_exception_raised(&ex) )
2074         {
2075             libvlc_set_fullscreen(p_md, VARIANT_FALSE != fullscreen, &ex);
2076             libvlc_media_instance_release(p_md);
2077             if( ! libvlc_exception_raised(&ex) )
2078             {
2079                 return NOERROR;
2080             }
2081         }
2082         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2083         libvlc_exception_clear(&ex);
2084         return E_FAIL;
2085     }
2086     return hr;
2087 };
2088
2089 STDMETHODIMP VLCVideo::get_width(long* width)
2090 {
2091     if( NULL == width )
2092         return E_POINTER;
2093
2094     libvlc_instance_t* p_libvlc;
2095     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2096     if( SUCCEEDED(hr) )
2097     {
2098         libvlc_exception_t ex;
2099         libvlc_exception_init(&ex);
2100
2101         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2102         if( ! libvlc_exception_raised(&ex) )
2103         {
2104             *width = libvlc_video_get_width(p_md, &ex);
2105             libvlc_media_instance_release(p_md);
2106             if( ! libvlc_exception_raised(&ex) )
2107             {
2108                 return NOERROR;
2109             }
2110         }
2111         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2112         libvlc_exception_clear(&ex);
2113         return E_FAIL;
2114     }
2115     return hr;
2116 };
2117
2118 STDMETHODIMP VLCVideo::get_height(long* height)
2119 {
2120     if( NULL == height )
2121         return E_POINTER;
2122
2123     libvlc_instance_t* p_libvlc;
2124     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2125     if( SUCCEEDED(hr) )
2126     {
2127         libvlc_exception_t ex;
2128         libvlc_exception_init(&ex);
2129
2130         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2131         if( ! libvlc_exception_raised(&ex) )
2132         {
2133             *height = libvlc_video_get_height(p_md, &ex);
2134             libvlc_media_instance_release(p_md);
2135             if( ! libvlc_exception_raised(&ex) )
2136             {
2137                 return NOERROR;
2138             }
2139         }
2140         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2141         libvlc_exception_clear(&ex);
2142         return E_FAIL;
2143     }
2144     return hr;
2145 };
2146
2147 STDMETHODIMP VLCVideo::get_aspectRatio(BSTR* aspect)
2148 {
2149     if( NULL == aspect )
2150         return E_POINTER;
2151
2152     libvlc_instance_t* p_libvlc;
2153     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2154     if( SUCCEEDED(hr) )
2155     {
2156         libvlc_exception_t ex;
2157         libvlc_exception_init(&ex);
2158
2159         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2160         if( ! libvlc_exception_raised(&ex) )
2161         {
2162             char *psz_aspect = libvlc_video_get_aspect_ratio(p_md, &ex);
2163
2164             libvlc_media_instance_release(p_md);
2165             if( ! libvlc_exception_raised(&ex) )
2166             {
2167                 if( NULL == psz_aspect )
2168                     return E_OUTOFMEMORY;
2169
2170                 *aspect = BSTRFromCStr(CP_UTF8, psz_aspect);
2171                 free( psz_aspect );
2172                 psz_aspect = NULL;
2173                 return (NULL == *aspect) ? E_OUTOFMEMORY : NOERROR;
2174             }
2175             if( psz_aspect ) free( psz_aspect );
2176             psz_aspect = NULL;
2177         }
2178         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2179         libvlc_exception_clear(&ex);
2180         return E_FAIL;
2181     }
2182     return hr;
2183 };
2184
2185 STDMETHODIMP VLCVideo::put_aspectRatio(BSTR aspect)
2186 {
2187     if( NULL == aspect )
2188         return E_POINTER;
2189
2190     if( 0 == SysStringLen(aspect) )
2191         return E_INVALIDARG;
2192
2193     libvlc_instance_t* p_libvlc;
2194     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2195     if( SUCCEEDED(hr) )
2196     {
2197         libvlc_exception_t ex;
2198         libvlc_exception_init(&ex);
2199
2200         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2201         if( ! libvlc_exception_raised(&ex) )
2202         {
2203             char *psz_aspect = CStrFromBSTR(CP_UTF8, aspect);
2204             if( NULL == psz_aspect )
2205             {
2206                 return E_OUTOFMEMORY;
2207             }
2208
2209             libvlc_video_set_aspect_ratio(p_md, psz_aspect, &ex);
2210
2211             CoTaskMemFree(psz_aspect);
2212             libvlc_media_instance_release(p_md);
2213             if( libvlc_exception_raised(&ex) )
2214             {
2215                 _p_instance->setErrorInfo(IID_IVLCVideo,
2216                     libvlc_exception_get_message(&ex));
2217                 libvlc_exception_clear(&ex);
2218                 return E_FAIL;
2219             }
2220         }
2221         return NOERROR;
2222     }
2223     return hr;
2224 };
2225
2226 STDMETHODIMP VLCVideo::get_subtitle(long* spu)
2227 {
2228     if( NULL == spu )
2229         return E_POINTER;
2230
2231     libvlc_instance_t* p_libvlc;
2232     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2233     if( SUCCEEDED(hr) )
2234     {
2235         libvlc_exception_t ex;
2236         libvlc_exception_init(&ex);
2237
2238         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2239         if( ! libvlc_exception_raised(&ex) )
2240         {
2241             *spu = libvlc_video_get_spu(p_md, &ex);
2242             libvlc_media_instance_release(p_md);
2243             if( ! libvlc_exception_raised(&ex) )
2244             {
2245                 return NOERROR;
2246             }
2247         }
2248         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2249         libvlc_exception_clear(&ex);
2250         return E_FAIL;
2251     }
2252     return hr;
2253 };
2254
2255 STDMETHODIMP VLCVideo::put_subtitle(long spu)
2256 {
2257     libvlc_instance_t* p_libvlc;
2258     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2259     if( SUCCEEDED(hr) )
2260     {
2261         libvlc_exception_t ex;
2262         libvlc_exception_init(&ex);
2263
2264         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2265         libvlc_video_set_spu(p_md, spu, &ex);
2266         libvlc_media_instance_release(p_md);
2267         if( libvlc_exception_raised(&ex) )
2268         {
2269             _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2270             libvlc_exception_clear(&ex);
2271             return E_FAIL;
2272         }
2273         return NOERROR;
2274     }
2275     return hr;
2276 };
2277
2278 STDMETHODIMP VLCVideo::get_crop(BSTR* geometry)
2279 {
2280     if( NULL == geometry )
2281         return E_POINTER;
2282
2283     libvlc_instance_t* p_libvlc;
2284     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2285     if( SUCCEEDED(hr) )
2286     {
2287         libvlc_exception_t ex;
2288         libvlc_exception_init(&ex);
2289
2290         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2291         if( ! libvlc_exception_raised(&ex) )
2292         {
2293             char *psz_geometry = libvlc_video_get_crop_geometry(p_md, &ex);
2294
2295             libvlc_media_instance_release(p_md);
2296             if( ! libvlc_exception_raised(&ex) )
2297             {
2298                 if( NULL == psz_geometry )
2299                     return E_OUTOFMEMORY;
2300
2301                 *geometry = BSTRFromCStr(CP_UTF8, psz_geometry);
2302                 free( psz_geometry );
2303                 psz_geometry = NULL;
2304                 return (NULL == geometry) ? E_OUTOFMEMORY : NOERROR;
2305             }
2306             if( psz_geometry ) free( psz_geometry );
2307             psz_geometry = NULL;
2308         }
2309         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2310         libvlc_exception_clear(&ex);
2311         return E_FAIL;
2312     }
2313     return hr;
2314 };
2315
2316 STDMETHODIMP VLCVideo::put_crop(BSTR geometry)
2317 {
2318     if( NULL == geometry )
2319         return E_POINTER;
2320
2321     if( 0 == SysStringLen(geometry) )
2322         return E_INVALIDARG;
2323
2324     libvlc_instance_t* p_libvlc;
2325     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2326     if( SUCCEEDED(hr) )
2327     {
2328         libvlc_exception_t ex;
2329         libvlc_exception_init(&ex);
2330
2331         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2332         if( ! libvlc_exception_raised(&ex) )
2333         {
2334             char *psz_geometry = CStrFromBSTR(CP_UTF8, geometry);
2335             if( NULL == psz_geometry )
2336             {
2337                 return E_OUTOFMEMORY;
2338             }
2339
2340             libvlc_video_set_crop_geometry(p_md, psz_geometry, &ex);
2341
2342             CoTaskMemFree(psz_geometry);
2343             libvlc_media_instance_release(p_md);
2344             if( libvlc_exception_raised(&ex) )
2345             {
2346                 _p_instance->setErrorInfo(IID_IVLCVideo,
2347                     libvlc_exception_get_message(&ex));
2348                 libvlc_exception_clear(&ex);
2349                 return E_FAIL;
2350             }
2351         }
2352         return NOERROR;
2353     }
2354     return hr;
2355 };
2356
2357 STDMETHODIMP VLCVideo::get_teletext(long* page)
2358 {
2359     if( NULL == page )
2360         return E_POINTER;
2361
2362     libvlc_instance_t* p_libvlc;
2363     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2364     if( SUCCEEDED(hr) )
2365     {
2366         libvlc_exception_t ex;
2367         libvlc_exception_init(&ex);
2368
2369         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2370         if( ! libvlc_exception_raised(&ex) )
2371         {
2372             *page = libvlc_video_get_teletext(p_md, &ex);
2373             libvlc_media_instance_release(p_md);
2374             if( ! libvlc_exception_raised(&ex) )
2375             {
2376                 return NOERROR;
2377             }
2378         }
2379         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2380         libvlc_exception_clear(&ex);
2381         return E_FAIL;
2382     }
2383     return hr;
2384 };
2385
2386 STDMETHODIMP VLCVideo::put_teletext(long page)
2387 {
2388     libvlc_instance_t* p_libvlc;
2389     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2390     if( SUCCEEDED(hr) )
2391     {
2392         libvlc_exception_t ex;
2393         libvlc_exception_init(&ex);
2394
2395         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2396         libvlc_video_set_teletext(p_md, page, &ex);
2397         libvlc_media_instance_release(p_md);
2398         if( libvlc_exception_raised(&ex) )
2399         {
2400             _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2401             libvlc_exception_clear(&ex);
2402             return E_FAIL;
2403         }
2404         return NOERROR;
2405     }
2406     return hr;
2407 };
2408
2409 STDMETHODIMP VLCVideo::takeSnapshot(LPPICTUREDISP* picture)
2410 {
2411     if( NULL == picture )
2412         return E_POINTER;
2413
2414     libvlc_instance_t* p_libvlc;
2415     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2416     if( SUCCEEDED(hr) )
2417     {
2418         libvlc_exception_t ex;
2419         libvlc_exception_init(&ex);
2420
2421         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2422         if( ! libvlc_exception_raised(&ex) )
2423         {
2424             static int uniqueId = 0;
2425             TCHAR path[MAX_PATH+1];
2426
2427             int pathlen = GetTempPath(MAX_PATH-24, path);
2428             if( (0 == pathlen) || (pathlen > (MAX_PATH-24)) )
2429                 return E_FAIL;
2430
2431             /* check temp directory path by openning it */
2432             {
2433                 HANDLE dirHandle = CreateFile(path,
2434                                               GENERIC_READ,
2435                                               FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
2436                                               NULL,
2437                                               OPEN_EXISTING,
2438                                               FILE_FLAG_BACKUP_SEMANTICS, NULL);
2439                 if( INVALID_HANDLE_VALUE == dirHandle )
2440                 {
2441                     _p_instance->setErrorInfo(IID_IVLCVideo,
2442                             "Invalid temporary directory for snapshot images, check values of TMP, TEMP envars.");
2443                     return E_FAIL;
2444                 }
2445                 else
2446                 {
2447                     BY_HANDLE_FILE_INFORMATION bhfi;
2448                     BOOL res = GetFileInformationByHandle(dirHandle, &bhfi);
2449                     CloseHandle(dirHandle);
2450                     if( !res || !(bhfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
2451                     {
2452                         _p_instance->setErrorInfo(IID_IVLCVideo,
2453                                 "Invalid temporary directory for snapshot images, check values of TMP, TEMP envars.");
2454                         return E_FAIL;
2455                     }
2456                 }
2457             }
2458
2459             TCHAR filepath[MAX_PATH+1];
2460
2461             _stprintf(filepath, TEXT("%sAXVLC%lXS%lX.bmp"),
2462                      path, GetCurrentProcessId(), ++uniqueId);
2463
2464 #ifdef _UNICODE
2465             /* reuse path storage for UTF8 string */
2466             char *psz_filepath = (char *)path;
2467             WCHAR* wpath = filepath;
2468 #else
2469             char *psz_filepath = path;
2470             /* first convert to unicode using current code page */
2471             WCHAR wpath[MAX_PATH+1];
2472             if( 0 == MultiByteToWideChar(CP_ACP, 0, filepath, -1, wpath, sizeof(wpath)/sizeof(WCHAR)) )
2473                 return E_FAIL;
2474 #endif
2475             /* convert to UTF8 */
2476             pathlen = WideCharToMultiByte(CP_UTF8, 0, wpath, -1, psz_filepath, sizeof(path), NULL, NULL);
2477             // fail if path is 0 or too short (i.e pathlen is the same as storage size)
2478             if( (0 == pathlen) || (sizeof(path) == pathlen) )
2479                 return E_FAIL;
2480
2481             /* take snapshot into file */
2482             libvlc_video_take_snapshot(p_md, psz_filepath, 0, 0, &ex);
2483             libvlc_media_instance_release(p_md);
2484             if( ! libvlc_exception_raised(&ex) )
2485             {
2486                 hr = E_FAIL;
2487                 /* open snapshot file */
2488                 HANDLE snapPic = LoadImage(NULL, filepath, IMAGE_BITMAP,0, 0, LR_CREATEDIBSECTION|LR_LOADFROMFILE);
2489                 if( snapPic )
2490                 {
2491                     PICTDESC snapDesc;
2492
2493                     snapDesc.cbSizeofstruct = sizeof(PICTDESC);
2494                     snapDesc.picType        = PICTYPE_BITMAP;
2495                     snapDesc.bmp.hbitmap    = (HBITMAP)snapPic;
2496                     snapDesc.bmp.hpal       = NULL;
2497
2498                     hr = OleCreatePictureIndirect(&snapDesc, IID_IPictureDisp, TRUE, (LPVOID*)picture);
2499                     if( FAILED(hr) )
2500                     {
2501                         *picture = NULL;
2502                         DeleteObject(snapPic);
2503                     }
2504                 }
2505                 DeleteFile(filepath);
2506                 return hr;
2507             }
2508         }
2509         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2510         libvlc_exception_clear(&ex);
2511         return E_FAIL;
2512     }
2513     return hr;
2514 };
2515
2516 STDMETHODIMP VLCVideo::toggleFullscreen()
2517 {
2518     libvlc_instance_t* p_libvlc;
2519     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2520     if( SUCCEEDED(hr) )
2521     {
2522         libvlc_exception_t ex;
2523         libvlc_exception_init(&ex);
2524
2525         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2526         if( ! libvlc_exception_raised(&ex) )
2527         {
2528             libvlc_toggle_fullscreen(p_md, &ex);
2529             libvlc_media_instance_release(p_md);
2530             if( ! libvlc_exception_raised(&ex) )
2531             {
2532                 return NOERROR;
2533             }
2534         }
2535         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2536         libvlc_exception_clear(&ex);
2537         return E_FAIL;
2538     }
2539     return hr;
2540 };
2541
2542 STDMETHODIMP VLCVideo::toggleTeletext()
2543 {
2544     libvlc_instance_t* p_libvlc;
2545     HRESULT hr = _p_instance->getVLC(&p_libvlc);
2546     if( SUCCEEDED(hr) )
2547     {
2548         libvlc_exception_t ex;
2549         libvlc_exception_init(&ex);
2550
2551         libvlc_media_instance_t *p_md = libvlc_playlist_get_media_instance(p_libvlc, &ex);
2552         if( ! libvlc_exception_raised(&ex) )
2553         {
2554             libvlc_toggle_teletext(p_md, &ex);
2555             libvlc_media_instance_release(p_md);
2556             if( ! libvlc_exception_raised(&ex) )
2557             {
2558                 return NOERROR;
2559             }
2560         }
2561         _p_instance->setErrorInfo(IID_IVLCVideo, libvlc_exception_get_message(&ex));
2562         libvlc_exception_clear(&ex);
2563         return E_FAIL;
2564     }
2565     return hr;
2566 };
2567
2568 /*******************************************************************************/
2569
2570 VLCControl2::VLCControl2(VLCPlugin *p_instance) :
2571     _p_instance(p_instance),
2572     _p_typeinfo(NULL),
2573     _p_vlcaudio(NULL),
2574     _p_vlcinput(NULL),
2575     _p_vlcplaylist(NULL),
2576     _p_vlcvideo(NULL)
2577 {
2578     _p_vlcaudio     = new VLCAudio(p_instance);
2579     _p_vlcinput     = new VLCInput(p_instance);
2580     _p_vlclog       = new VLCLog(p_instance);
2581     _p_vlcplaylist  = new VLCPlaylist(p_instance);
2582     _p_vlcvideo     = new VLCVideo(p_instance);
2583 };
2584
2585 VLCControl2::~VLCControl2()
2586 {
2587     delete _p_vlcvideo;
2588     delete _p_vlcplaylist;
2589     delete _p_vlclog;
2590     delete _p_vlcinput;
2591     delete _p_vlcaudio;
2592     if( _p_typeinfo )
2593         _p_typeinfo->Release();
2594 };
2595
2596 HRESULT VLCControl2::loadTypeInfo(void)
2597 {
2598     HRESULT hr = NOERROR;
2599     if( NULL == _p_typeinfo )
2600     {
2601         ITypeLib *p_typelib;
2602
2603         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
2604         if( SUCCEEDED(hr) )
2605         {
2606             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCControl2, &_p_typeinfo);
2607             if( FAILED(hr) )
2608             {
2609                 _p_typeinfo = NULL;
2610             }
2611             p_typelib->Release();
2612         }
2613     }
2614     return hr;
2615 };
2616
2617 STDMETHODIMP VLCControl2::GetTypeInfoCount(UINT* pctInfo)
2618 {
2619     if( NULL == pctInfo )
2620         return E_INVALIDARG;
2621
2622     if( SUCCEEDED(loadTypeInfo()) )
2623         *pctInfo = 1;
2624     else
2625         *pctInfo = 0;
2626
2627     return NOERROR;
2628 };
2629
2630 STDMETHODIMP VLCControl2::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
2631 {
2632     if( NULL == ppTInfo )
2633         return E_INVALIDARG;
2634
2635     if( SUCCEEDED(loadTypeInfo()) )
2636     {
2637         _p_typeinfo->AddRef();
2638         *ppTInfo = _p_typeinfo;
2639         return NOERROR;
2640     }
2641     *ppTInfo = NULL;
2642     return E_NOTIMPL;
2643 };
2644
2645 STDMETHODIMP VLCControl2::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
2646         UINT cNames, LCID lcid, DISPID* rgDispID)
2647 {
2648     if( SUCCEEDED(loadTypeInfo()) )
2649     {
2650         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
2651     }
2652     return E_NOTIMPL;
2653 };
2654
2655 STDMETHODIMP VLCControl2::Invoke(DISPID dispIdMember, REFIID riid,
2656         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
2657         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
2658 {
2659     if( SUCCEEDED(loadTypeInfo()) )
2660     {
2661         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
2662                 pVarResult, pExcepInfo, puArgErr);
2663     }
2664     return E_NOTIMPL;
2665 };
2666
2667 STDMETHODIMP VLCControl2::get_AutoLoop(VARIANT_BOOL *autoloop)
2668 {
2669     if( NULL == autoloop )
2670         return E_POINTER;
2671
2672     *autoloop = _p_instance->getAutoLoop() ? VARIANT_TRUE: VARIANT_FALSE;
2673     return S_OK;
2674 };
2675
2676 STDMETHODIMP VLCControl2::put_AutoLoop(VARIANT_BOOL autoloop)
2677 {
2678     _p_instance->setAutoLoop((VARIANT_FALSE != autoloop) ? TRUE: FALSE);
2679     return S_OK;
2680 };
2681
2682 STDMETHODIMP VLCControl2::get_AutoPlay(VARIANT_BOOL *autoplay)
2683 {
2684     if( NULL == autoplay )
2685         return E_POINTER;
2686
2687     *autoplay = _p_instance->getAutoPlay() ? VARIANT_TRUE: VARIANT_FALSE;
2688     return S_OK;
2689 };
2690
2691 STDMETHODIMP VLCControl2::put_AutoPlay(VARIANT_BOOL autoplay)
2692 {
2693     _p_instance->setAutoPlay((VARIANT_FALSE != autoplay) ? TRUE: FALSE);
2694     return S_OK;
2695 };
2696
2697 STDMETHODIMP VLCControl2::get_BaseURL(BSTR *url)
2698 {
2699     if( NULL == url )
2700         return E_POINTER;
2701
2702     *url = SysAllocStringLen(_p_instance->getBaseURL(),
2703                 SysStringLen(_p_instance->getBaseURL()));
2704     return NOERROR;
2705 };
2706
2707 STDMETHODIMP VLCControl2::put_BaseURL(BSTR mrl)
2708 {
2709     _p_instance->setBaseURL(mrl);
2710
2711     return S_OK;
2712 };
2713
2714 STDMETHODIMP VLCControl2::get_MRL(BSTR *mrl)
2715 {
2716     if( NULL == mrl )
2717         return E_POINTER;
2718
2719     *mrl = SysAllocStringLen(_p_instance->getMRL(),
2720                 SysStringLen(_p_instance->getMRL()));
2721     return NOERROR;
2722 };
2723
2724 STDMETHODIMP VLCControl2::put_MRL(BSTR mrl)
2725 {
2726     _p_instance->setMRL(mrl);
2727
2728     return S_OK;
2729 };
2730
2731 STDMETHODIMP VLCControl2::get_StartTime(long *seconds)
2732 {
2733     if( NULL == seconds )
2734         return E_POINTER;
2735
2736     *seconds = _p_instance->getStartTime();
2737
2738     return S_OK;
2739 };
2740
2741 STDMETHODIMP VLCControl2::put_StartTime(long seconds)
2742 {
2743     _p_instance->setStartTime(seconds);
2744
2745     return NOERROR;
2746 };
2747
2748 STDMETHODIMP VLCControl2::get_VersionInfo(BSTR *version)
2749 {
2750     if( NULL == version )
2751         return E_POINTER;
2752
2753     const char *versionStr = VLC_Version();
2754     if( NULL != versionStr )
2755     {
2756         *version = BSTRFromCStr(CP_UTF8, versionStr);
2757
2758         return NULL == *version ? E_OUTOFMEMORY : NOERROR;
2759     }
2760     *version = NULL;
2761     return E_FAIL;
2762 };
2763
2764 STDMETHODIMP VLCControl2::get_Visible(VARIANT_BOOL *isVisible)
2765 {
2766     if( NULL == isVisible )
2767         return E_POINTER;
2768
2769     *isVisible = _p_instance->getVisible() ? VARIANT_TRUE : VARIANT_FALSE;
2770
2771     return NOERROR;
2772 };
2773
2774 STDMETHODIMP VLCControl2::put_Visible(VARIANT_BOOL isVisible)
2775 {
2776     _p_instance->setVisible(isVisible != VARIANT_FALSE);
2777
2778     return NOERROR;
2779 };
2780
2781 STDMETHODIMP VLCControl2::get_Volume(long *volume)
2782 {
2783     if( NULL == volume )
2784         return E_POINTER;
2785
2786     *volume  = _p_instance->getVolume();
2787     return NOERROR;
2788 };
2789
2790 STDMETHODIMP VLCControl2::put_Volume(long volume)
2791 {
2792     _p_instance->setVolume(volume);
2793     return NOERROR;
2794 };
2795
2796 STDMETHODIMP VLCControl2::get_BackColor(OLE_COLOR *backcolor)
2797 {
2798     if( NULL == backcolor )
2799         return E_POINTER;
2800
2801     *backcolor  = _p_instance->getBackColor();
2802     return NOERROR;
2803 };
2804
2805 STDMETHODIMP VLCControl2::put_BackColor(OLE_COLOR backcolor)
2806 {
2807     _p_instance->setBackColor(backcolor);
2808     return NOERROR;
2809 };
2810
2811 STDMETHODIMP VLCControl2::get_audio(IVLCAudio** obj)
2812 {
2813     if( NULL == obj )
2814         return E_POINTER;
2815
2816     *obj = _p_vlcaudio;
2817     if( NULL != _p_vlcaudio )
2818     {
2819         _p_vlcaudio->AddRef();
2820         return NOERROR;
2821     }
2822     return E_OUTOFMEMORY;
2823 };
2824
2825 STDMETHODIMP VLCControl2::get_input(IVLCInput** obj)
2826 {
2827     if( NULL == obj )
2828         return E_POINTER;
2829
2830     *obj = _p_vlcinput;
2831     if( NULL != _p_vlcinput )
2832     {
2833         _p_vlcinput->AddRef();
2834         return NOERROR;
2835     }
2836     return E_OUTOFMEMORY;
2837 };
2838
2839 STDMETHODIMP VLCControl2::get_log(IVLCLog** obj)
2840 {
2841     if( NULL == obj )
2842         return E_POINTER;
2843
2844     *obj = _p_vlclog;
2845     if( NULL != _p_vlclog )
2846     {
2847         _p_vlclog->AddRef();
2848         return NOERROR;
2849     }
2850     return E_OUTOFMEMORY;
2851 };
2852
2853 STDMETHODIMP VLCControl2::get_playlist(IVLCPlaylist** obj)
2854 {
2855     if( NULL == obj )
2856         return E_POINTER;
2857
2858     *obj = _p_vlcplaylist;
2859     if( NULL != _p_vlcplaylist )
2860     {
2861         _p_vlcplaylist->AddRef();
2862         return NOERROR;
2863     }
2864     return E_OUTOFMEMORY;
2865 };
2866
2867 STDMETHODIMP VLCControl2::get_video(IVLCVideo** obj)
2868 {
2869     if( NULL == obj )
2870         return E_POINTER;
2871
2872     *obj = _p_vlcvideo;
2873     if( NULL != _p_vlcvideo )
2874     {
2875         _p_vlcvideo->AddRef();
2876         return NOERROR;
2877     }
2878     return E_OUTOFMEMORY;
2879 };