开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
vlccontrol2.cpp
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：67k
源码类别：

midi

开发平台：

Unix_Linux

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