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

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

midi

开发平台：

Unix_Linux

vlccontrol.cpp：源码内容
  1. /*****************************************************************************
  2.  * vlccontrol.cpp: ActiveX control for VLC
  3.  *****************************************************************************
  4.  * Copyright (C) 2005 the VideoLAN team
  5.  *
  6.  * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
  7.  *          Jean-Paul Saman <jpsaman@videolan.org>
  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 "vlccontrol.h"
  27. #include "utils.h"
  29. using namespace std;
  31. VLCControl::~VLCControl()
  32. {
  33.     if( _p_typeinfo )
  34.         _p_typeinfo->Release();
  35. };
  37. HRESULT VLCControl::getTypeInfo(void)
  38. {
  39.     HRESULT hr = NOERROR;
  40.     if( NULL == _p_typeinfo )
  41.     {
  42.         ITypeLib *p_typelib;
  44.         hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
  45.         if( SUCCEEDED(hr) )
  46.         {
  47.             hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCControl, &_p_typeinfo);
  48.             if( FAILED(hr) )
  49.             {
  50.                 _p_typeinfo = NULL;
  51.             }
  52.             p_typelib->Release();
  53.         }
  54.     }
  55.     return hr;
  56. };
  58. STDMETHODIMP VLCControl::GetTypeInfoCount(UINT* pctInfo)
  59. {
  60.     if( NULL == pctInfo )
  61.         return E_INVALIDARG;
  63.     if( SUCCEEDED(getTypeInfo()) )
  64.         *pctInfo = 1;
  65.     else
  66.         *pctInfo = 0;
  68.     return NOERROR;
  69. };
  71. STDMETHODIMP VLCControl::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
  72. {
  73.     if( NULL == ppTInfo )
  74.         return E_INVALIDARG;
  76.     if( SUCCEEDED(getTypeInfo()) )
  77.     {
  78.         _p_typeinfo->AddRef();
  79.         *ppTInfo = _p_typeinfo;
  80.         return NOERROR;
  81.     }
  82.     *ppTInfo = NULL;
  83.     return E_NOTIMPL;
  84. };
  86. STDMETHODIMP VLCControl::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
  87.         UINT cNames, LCID lcid, DISPID* rgDispID)
  88. {
  89.     if( SUCCEEDED(getTypeInfo()) )
  90.     {
  91.         return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
  92.     }
  93.     return E_NOTIMPL;
  94. };
  96. STDMETHODIMP VLCControl::Invoke(DISPID dispIdMember, REFIID riid,
  97.         LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
  98.         VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
  99. {
  100.     if( SUCCEEDED(getTypeInfo()) )
  101.     {
  102.         return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
  103.                 pVarResult, pExcepInfo, puArgErr);
  104.     }
  105.     return E_NOTIMPL;
  106. };
  108. STDMETHODIMP VLCControl::get_Visible(VARIANT_BOOL *isVisible)
  109. {
  110.     if( NULL == isVisible )
  111.         return E_POINTER;
  113.     *isVisible = _p_instance->getVisible() ? VARIANT_TRUE : VARIANT_FALSE;
  115.     return NOERROR;
  116. };
  118. STDMETHODIMP VLCControl::put_Visible(VARIANT_BOOL isVisible)
  119. {
  120.     _p_instance->setVisible(isVisible != VARIANT_FALSE);
  122.     return NOERROR;
  123. };
  125. STDMETHODIMP VLCControl::play(void)
  126. {
  127.     libvlc_exception_t ex;
  128.     libvlc_exception_init(&ex);
  130.     _p_instance->playlist_play(&ex);
  131.     if( libvlc_exception_raised(&ex) )
  132.     {
  133.         _p_instance->setErrorInfo(IID_IVLCControl,
  134.             libvlc_exception_get_message(&ex));
  135.         libvlc_exception_clear(&ex);
  136.         return E_FAIL;
  137.     }
  138.     _p_instance->fireOnPlayEvent();
  139.     return NOERROR;
  140. };
  142. STDMETHODIMP VLCControl::pause(void)
  143. {
  144.     libvlc_media_player_t* p_md;
  145.     HRESULT result = _p_instance->getMD(&p_md);
  146.     if( SUCCEEDED(result) )
  147.     {
  148.         libvlc_exception_t ex;
  149.         libvlc_exception_init(&ex);
  151.         libvlc_media_player_pause(p_md, &ex);
  152.         if( libvlc_exception_raised(&ex) )
  153.         {
  154.             _p_instance->setErrorInfo(IID_IVLCControl,
  155.                 libvlc_exception_get_message(&ex));
  156.             libvlc_exception_clear(&ex);
  157.             return E_FAIL;
  158.         }
  159.         _p_instance->fireOnPauseEvent();
  160.         return NOERROR;
  161.     }
  162.     return result;
  163. };
  165. STDMETHODIMP VLCControl::stop(void)
  166. {
  167.     libvlc_media_player_t *p_md;
  168.     HRESULT result = _p_instance->getMD(&p_md);
  169.     if( SUCCEEDED(result) )
  170.     {
  171.         libvlc_exception_t ex;
  172.         libvlc_exception_init(&ex);
  174.         libvlc_media_player_stop(p_md, &ex);
  175.         if( libvlc_exception_raised(&ex) )
  176.         {
  177.             _p_instance->setErrorInfo(IID_IVLCControl,
  178.                 libvlc_exception_get_message(&ex));
  179.             libvlc_exception_clear(&ex);
  180.             return E_FAIL;
  181.         }
  182.         return NOERROR;
  183.     }
  184.     _p_instance->fireOnStopEvent();
  185.     return result;
  186. };
  188. STDMETHODIMP VLCControl::get_Playing(VARIANT_BOOL *isPlaying)
  189. {
  190.     if( NULL == isPlaying )
  191.         return E_POINTER;
  193.     libvlc_media_player_t *p_md;
  194.     HRESULT result = _p_instance->getMD(&p_md);
  195.     if( SUCCEEDED(result) )
  196.     {
  197.         *isPlaying = libvlc_media_player_is_playing(p_md, NULL) ?
  198.                      VARIANT_TRUE : VARIANT_FALSE;
  199.         return NOERROR;
  200.     }
  201.     *isPlaying = VARIANT_FALSE;
  202.     return result;
  203. };
  205. STDMETHODIMP VLCControl::get_Position(float *position)
  206. {
  207.     if( NULL == position )
  208.         return E_POINTER;
  209.     *position = 0.0f;
  211.     libvlc_media_player_t *p_md;
  212.     HRESULT result = _p_instance->getMD(&p_md);
  213.     if( SUCCEEDED(result) )
  214.     {
  215.         libvlc_exception_t ex;
  216.         libvlc_exception_init(&ex);
  218.         *position = libvlc_media_player_get_position(p_md, &ex);
  219.         if( ! libvlc_exception_raised(&ex) )
  220.         {
  221.             return NOERROR;
  222.         }
  223.         _p_instance->setErrorInfo(IID_IVLCControl,
  224.                      libvlc_exception_get_message(&ex));
  225.         libvlc_exception_clear(&ex);
  226.         return E_FAIL;
  227.     }
  228.     return result;
  229. };
  231. STDMETHODIMP VLCControl::put_Position(float position)
  232. {
  233.     libvlc_media_player_t *p_md;
  234.     HRESULT result = _p_instance->getMD(&p_md);
  235.     if( SUCCEEDED(result) )
  236.     {
  237.         libvlc_exception_t ex;
  238.         libvlc_exception_init(&ex);
  240.         libvlc_media_player_set_position(p_md, position, &ex);
  241.         if( ! libvlc_exception_raised(&ex) )
  242.         {
  243.             return NOERROR;
  244.         }
  245.         _p_instance->setErrorInfo(IID_IVLCControl,
  246.                      libvlc_exception_get_message(&ex));
  247.         libvlc_exception_clear(&ex);
  248.         return E_FAIL;
  249.     }
  250.     return result;
  251. };
  253. STDMETHODIMP VLCControl::get_Time(int *seconds)
  254. {
  255.     if( NULL == seconds )
  256.         return E_POINTER;
  258.     *seconds = 0;
  259.     libvlc_media_player_t *p_md;
  260.     HRESULT result = _p_instance->getMD(&p_md);
  261.     if( SUCCEEDED(result) )
  262.     {
  263.         libvlc_exception_t ex;
  264.         libvlc_exception_init(&ex);
  266.         *seconds = libvlc_media_player_get_time(p_md, &ex);
  267.         if( ! libvlc_exception_raised(&ex) )
  268.         {
  269.             return NOERROR;
  270.         }
  271.         _p_instance->setErrorInfo(IID_IVLCControl,
  272.                      libvlc_exception_get_message(&ex));
  273.         libvlc_exception_clear(&ex);
  274.         return E_FAIL;
  275.     }
  276.     return result;
  277. };
  279. STDMETHODIMP VLCControl::put_Time(int seconds)
  280. {
  281.     /* setTime function of the plugin sets the time. */
  282.     _p_instance->setTime(seconds);
  283.     return NOERROR;
  284. };
  286. STDMETHODIMP VLCControl::shuttle(int seconds)
  287. {
  288.     libvlc_media_player_t *p_md;
  289.     HRESULT result = _p_instance->getMD(&p_md);
  290.     if( SUCCEEDED(result) )
  291.     {
  292.         libvlc_exception_t ex;
  293.         libvlc_exception_init(&ex);
  295.         if( seconds < 0 ) seconds = 0;
  296.         libvlc_media_player_set_time(p_md, (int64_t)seconds, &ex);
  297.         if( ! libvlc_exception_raised(&ex) )
  298.         {
  299.             return NOERROR;
  300.         }
  301.         _p_instance->setErrorInfo(IID_IVLCControl,
  302.                      libvlc_exception_get_message(&ex));
  303.         libvlc_exception_clear(&ex);
  304.         return E_FAIL;
  305.     }
  306.     return result;
  308. };
  310. STDMETHODIMP VLCControl::fullscreen(void)
  311. {
  312.     libvlc_media_player_t *p_md;
  313.     HRESULT result = _p_instance->getMD(&p_md);
  314.     if( SUCCEEDED(result) )
  315.     {
  316.         if( libvlc_media_player_is_playing(p_md, NULL) )
  317.         {
  318.             libvlc_toggle_fullscreen(p_md, NULL);
  319.         }
  320.     }
  321.     return result;
  322. };
  324. STDMETHODIMP VLCControl::get_Length(int *seconds)
  325. {
  326.     if( NULL == seconds )
  327.         return E_POINTER;
  328.     *seconds = 0;
  330.     libvlc_media_player_t *p_md;
  331.     HRESULT result = _p_instance->getMD(&p_md);
  332.     if( SUCCEEDED(result) )
  333.     {
  334.         libvlc_exception_t ex;
  335.         libvlc_exception_init(&ex);
  337.         *seconds = (double)libvlc_media_player_get_length(p_md, &ex);
  338.         if( ! libvlc_exception_raised(&ex) )
  339.         {
  340.             return NOERROR;
  341.         }
  342.         _p_instance->setErrorInfo(IID_IVLCControl,
  343.                      libvlc_exception_get_message(&ex));
  344.         libvlc_exception_clear(&ex);
  345.         return E_FAIL;
  346.     }
  347.     return result;
  349. };
  351. STDMETHODIMP VLCControl::playFaster(void)
  352. {
  353.     int32_t rate = 2;
  355.     libvlc_media_player_t *p_md;
  356.     HRESULT result = _p_instance->getMD(&p_md);
  358.     if( SUCCEEDED(result) )
  359.     {
  360.         libvlc_exception_t ex;
  361.         libvlc_exception_init(&ex);
  363.         if( ! libvlc_exception_raised(&ex) )
  364.         {
  365.             libvlc_media_player_set_rate(p_md, rate, &ex);
  366.             if( ! libvlc_exception_raised(&ex) )
  367.             {
  368.                 return NOERROR;
  369.             }
  370.         }
  371.         _p_instance->setErrorInfo(IID_IVLCControl,
  372.                      libvlc_exception_get_message(&ex));
  373.         libvlc_exception_clear(&ex);
  374.         return E_FAIL;
  375.     }
  376.     return result;
  377. };
  379. STDMETHODIMP VLCControl::playSlower(void)
  380. {
  381.     float rate = 0.5;
  383.     libvlc_media_player_t *p_md;
  384.     HRESULT result = _p_instance->getMD(&p_md);
  385.     if( SUCCEEDED(result) )
  386.     {
  387.         libvlc_exception_t ex;
  388.         libvlc_exception_init(&ex);
  390.         libvlc_media_player_set_rate(p_md, rate, &ex);
  391.         if( ! libvlc_exception_raised(&ex) )
  392.         {
  393.             return NOERROR;
  394.         }
  395.         _p_instance->setErrorInfo(IID_IVLCControl,
  396.                      libvlc_exception_get_message(&ex));
  397.         libvlc_exception_clear(&ex);
  398.         return E_FAIL;
  399.     }
  400.     return result;
  401. };
  403. STDMETHODIMP VLCControl::get_Volume(int *volume)
  404. {
  405.     if( NULL == volume )
  406.         return E_POINTER;
  408.     *volume  = _p_instance->getVolume();
  409.     return NOERROR;
  410. };
  412. STDMETHODIMP VLCControl::put_Volume(int volume)
  413. {
  414.     _p_instance->setVolume(volume);
  415.     return NOERROR;
  416. };
  418. STDMETHODIMP VLCControl::toggleMute(void)
  419. {
  420.     libvlc_instance_t* p_libvlc;
  421.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  422.     if( SUCCEEDED(result) )
  423.     {
  424.         libvlc_exception_t ex;
  425.         libvlc_exception_init(&ex);
  427.         libvlc_audio_toggle_mute(p_libvlc, &ex);
  428.         if( libvlc_exception_raised(&ex) )
  429.         {
  430.             _p_instance->setErrorInfo(IID_IVLCControl,
  431.                          libvlc_exception_get_message(&ex));
  432.             libvlc_exception_clear(&ex);
  433.             return E_FAIL;
  434.         }
  435.         return NOERROR;
  436.     }
  437.     return result;
  438. };
  440. STDMETHODIMP VLCControl::setVariable(BSTR name, VARIANT value)
  441. {
  442.     libvlc_instance_t* p_libvlc;
  443.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  444.     if( SUCCEEDED(result) )
  445.     {
  446.         _p_instance->setErrorInfo(IID_IVLCControl,
  447.             "setVariable() is an unsafe interface to use. "
  448.             "It has been removed because of security implications." );
  449.     }
  450.     return E_FAIL;
  451. };
  453. STDMETHODIMP VLCControl::getVariable(BSTR name, VARIANT *value)
  454. {
  455.     libvlc_instance_t* p_libvlc;
  456.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  457.     if( SUCCEEDED(result) )
  458.     {
  459.         _p_instance->setErrorInfo(IID_IVLCControl,
  460.             "getVariable() is an unsafe interface to use. "
  461.             "It has been removed because of security implications." );
  462.     }
  463.     return E_FAIL;
  464. };
  466. void VLCControl::FreeTargetOptions(char **cOptions, int cOptionCount)
  467. {
  468.     // clean up
  469.     if( NULL != cOptions )
  470.     {
  471.         for( int pos=0; pos<cOptionCount; ++pos )
  472.         {
  473.             char *cOption = cOptions[pos];
  474.             if( NULL != cOption )
  475.                 CoTaskMemFree(cOption);
  476.             else
  477.                 break;
  478.         }
  479.         CoTaskMemFree(cOptions);
  480.     }
  481. };
  483. static HRESULT parseStringOptions(int codePage, BSTR bstr, char*** cOptions, int *cOptionCount)
  484. {
  485.     HRESULT hr = E_INVALIDARG;
  486.     if( SysStringLen(bstr) > 0 )
  487.     {
  488.         hr = E_OUTOFMEMORY;
  489.         char *s = CStrFromBSTR(codePage, bstr);
  490.         char *val = s;
  491.         if( val )
  492.         {
  493.             long capacity = 16;
  494.             char **options = (char **)CoTaskMemAlloc(capacity*sizeof(char *));
  495.             if( options )
  496.             {
  497.                 int nOptions = 0;
  499.                 char *end = val + strlen(val);
  500.                 while( val < end )
  501.                 {
  502.                     // skip leading blanks
  503.                     while( (val < end)
  504.                         && ((*val == ' ' ) || (*val == 't')) )
  505.                         ++val;
  507.                     char *start = val;
  508.                     // skip till we get a blank character
  509.                     while( (val < end)
  510.                         && (*val != ' ' )
  511.                         && (*val != 't') )
  512.                     {
  513.                         char c = *(val++);
  514.                         if( (''' == c) || ('"' == c) )
  515.                         {
  516.                             // skip till end of string
  517.                             while( (val < end) && (*(val++) != c ) );
  518.                         }
  519.                     }
  521.                     if( val > start )
  522.                     {
  523.                         if( nOptions == capacity )
  524.                         {
  525.                             capacity += 16;
  526.                             char **moreOptions = (char **)CoTaskMemRealloc(options, capacity*sizeof(char*));
  527.                             if( ! moreOptions )
  528.                             {
  529.                                 /* failed to allocate more memory */
  530.                                 CoTaskMemFree(s);
  531.                                 /* return what we got so far */
  532.                                 *cOptionCount = nOptions;
  533.                                 *cOptions = options;
  534.                                 return NOERROR;
  535.                             }
  536.                             options = moreOptions;
  537.                         }
  538.                         *(val++) = '';
  539.                         options[nOptions] = (char *)CoTaskMemAlloc(val-start);
  540.                         if( options[nOptions] )
  541.                         {
  542.                             memcpy(options[nOptions], start, val-start);
  543.                             ++nOptions;
  544.                         }
  545.                         else
  546.                         {
  547.                             /* failed to allocate memory */
  548.                             CoTaskMemFree(s);
  549.                             /* return what we got so far */
  550.                             *cOptionCount = nOptions;
  551.                             *cOptions = options;
  552.                             return NOERROR;
  553.                         }
  554.                     }
  555.                     else
  556.                         // must be end of string
  557.                         break;
  558.                 }
  559.                 *cOptionCount = nOptions;
  560.                 *cOptions = options;
  561.                 hr = NOERROR;
  562.             }
  563.             CoTaskMemFree(s);
  564.         }
  565.     }
  566.     return hr;
  567. }
  569. HRESULT VLCControl::CreateTargetOptions(int codePage, VARIANT *options, char ***cOptions, int *cOptionCount)
  570. {
  571.     HRESULT hr = E_INVALIDARG;
  572.     if( VT_ERROR == V_VT(options) )
  573.     {
  574.         if( DISP_E_PARAMNOTFOUND == V_ERROR(options) )
  575.         {
  576.             // optional parameter not set
  577.             *cOptions = NULL;
  578.             *cOptionCount = 0;
  579.             return NOERROR;
  580.         }
  581.     }
  582.     else if( (VT_EMPTY == V_VT(options)) || (VT_NULL == V_VT(options)) )
  583.     {
  584.         // null parameter
  585.         *cOptions = NULL;
  586.         *cOptionCount = 0;
  587.         return NOERROR;
  588.     }
  589.     else if( VT_DISPATCH == V_VT(options) )
  590.     {
  591.         // if object is a collection, retrieve enumerator
  592.         VARIANT colEnum;
  593.         V_VT(&colEnum) = VT_UNKNOWN;
  594.         hr = GetObjectProperty(V_DISPATCH(options), DISPID_NEWENUM, colEnum);
  595.         if( SUCCEEDED(hr) )
  596.         {
  597.             IEnumVARIANT *enumVar;
  598.             hr = V_UNKNOWN(&colEnum)->QueryInterface(IID_IEnumVARIANT, (LPVOID *)&enumVar);
  599.             if( SUCCEEDED(hr) )
  600.             {
  601.                 long pos = 0;
  602.                 long capacity = 16;
  603.                 VARIANT option;
  605.                 *cOptions = (char **)CoTaskMemAlloc(capacity*sizeof(char *));
  606.                 if( NULL != *cOptions )
  607.                 {
  608.                     ZeroMemory(*cOptions, sizeof(char *)*capacity);
  609.                     while( SUCCEEDED(hr) && (S_OK == enumVar->Next(1, &option, NULL)) )
  610.                     {
  611.                         if( VT_BSTR == V_VT(&option) )
  612.                         {
  613.                             char *cOption = CStrFromBSTR(codePage, V_BSTR(&option));
  614.                             (*cOptions)[pos] = cOption;
  615.                             if( NULL != cOption )
  616.                             {
  617.                                 ++pos;
  618.                                 if( pos == capacity )
  619.                                 {
  620.                                     char **moreOptions = (char **)CoTaskMemRealloc(*cOptions, (capacity+16)*sizeof(char *));
  621.                                     if( NULL != moreOptions )
  622.                                     {
  623.                                         ZeroMemory(moreOptions+capacity, sizeof(char *)*16);
  624.                                         capacity += 16;
  625.                                         *cOptions = moreOptions;
  626.                                     }
  627.                                     else
  628.                                         hr = E_OUTOFMEMORY;
  629.                                 }
  630.                             }
  631.                             else
  632.                                 hr = ( SysStringLen(V_BSTR(&option)) > 0 ) ?
  633.                                     E_OUTOFMEMORY : E_INVALIDARG;
  634.                         }
  635.                         else
  636.                             hr = E_INVALIDARG;
  638.                         VariantClear(&option);
  639.                     }
  640.                     *cOptionCount = pos;
  641.                     if( FAILED(hr) )
  642.                     {
  643.                         // free already processed elements
  644.                         FreeTargetOptions(*cOptions, *cOptionCount);
  645.                     }
  646.                 }
  647.                 else
  648.                     hr = E_OUTOFMEMORY;
  650.                 enumVar->Release();
  651.             }
  652.         }
  653.         else
  654.         {
  655.             // coerce object into a string and parse it
  656.             VARIANT v_name;
  657.             VariantInit(&v_name);
  658.             hr = VariantChangeType(&v_name, options, 0, VT_BSTR);
  659.             if( SUCCEEDED(hr) )
  660.             {
  661.                 hr = parseStringOptions(codePage, V_BSTR(&v_name), cOptions, cOptionCount);
  662.                 VariantClear(&v_name);
  663.             }
  664.         }
  665.     }
  666.     else if( V_ISARRAY(options) )
  667.     {
  668.         // array parameter
  669.         SAFEARRAY *array = V_ISBYREF(options) ? *V_ARRAYREF(options) : V_ARRAY(options);
  671.         if( SafeArrayGetDim(array) != 1 )
  672.             return E_INVALIDARG;
  674.         long lBound = 0;
  675.         long uBound = 0;
  676.         SafeArrayGetLBound(array, 1, &lBound);
  677.         SafeArrayGetUBound(array, 1, &uBound);
  679.         // have we got any options
  680.         if( uBound >= lBound )
  681.         {
  682.             VARTYPE vType;
  683.             hr = SafeArrayGetVartype(array, &vType);
  684.             if( FAILED(hr) )
  685.                 return hr;
  687.             long pos;
  689.             // marshall options into an array of C strings
  690.             if( VT_VARIANT == vType )
  691.             {
  692.                 *cOptions = (char **)CoTaskMemAlloc(sizeof(char *)*(uBound-lBound+1));
  693.                 if( NULL == *cOptions )
  694.                     return E_OUTOFMEMORY;
  696.                 ZeroMemory(*cOptions, sizeof(char *)*(uBound-lBound+1));
  697.                 for(pos=lBound; (pos<=uBound) && SUCCEEDED(hr); ++pos )
  698.                 {
  699.                     VARIANT option;
  700.                     hr = SafeArrayGetElement(array, &pos, &option);
  701.                     if( SUCCEEDED(hr) )
  702.                     {
  703.                         if( VT_BSTR == V_VT(&option) )
  704.                         {
  705.                             char *cOption = CStrFromBSTR(codePage, V_BSTR(&option));
  706.                             (*cOptions)[pos-lBound] = cOption;
  707.                             if( NULL == cOption )
  708.                                 hr = ( SysStringLen(V_BSTR(&option)) > 0 ) ?
  709.                                     E_OUTOFMEMORY : E_INVALIDARG;
  710.                         }
  711.                         else
  712.                             hr = E_INVALIDARG;
  713.                         VariantClear(&option);
  714.                     }
  715.                 }
  716.             }
  717.             else if( VT_BSTR == vType )
  718.             {
  719.                 *cOptions = (char **)CoTaskMemAlloc(sizeof(char *)*(uBound-lBound+1));
  720.                 if( NULL == *cOptions )
  721.                     return E_OUTOFMEMORY;
  723.                 ZeroMemory(*cOptions, sizeof(char *)*(uBound-lBound+1));
  724.                 for(pos=lBound; (pos<=uBound) && SUCCEEDED(hr); ++pos )
  725.                 {
  726.                     BSTR option;
  727.                     hr = SafeArrayGetElement(array, &pos, &option);
  728.                     if( SUCCEEDED(hr) )
  729.                     {
  730.                         char *cOption = CStrFromBSTR(codePage, option);
  732.                         (*cOptions)[pos-lBound] = cOption;
  733.                         if( NULL == cOption )
  734.                             hr = ( SysStringLen(option) > 0 ) ?
  735.                                 E_OUTOFMEMORY : E_INVALIDARG;
  736.                         SysFreeString(option);
  737.                     }
  738.                 }
  739.             }
  740.             else
  741.             {
  742.                 // unsupported type
  743.                 return E_INVALIDARG;
  744.             }
  746.             *cOptionCount = pos-lBound;
  747.             if( FAILED(hr) )
  748.             {
  749.                 // free already processed elements
  750.                 FreeTargetOptions(*cOptions, *cOptionCount);
  751.             }
  752.         }
  753.         else
  754.         {
  755.             // empty array
  756.             *cOptions = NULL;
  757.             *cOptionCount = 0;
  758.             return NOERROR;
  759.         }
  760.     }
  761.     else if( VT_UNKNOWN == V_VT(options) )
  762.     {
  763.         // coerce object into a string and parse it
  764.         VARIANT v_name;
  765.         VariantInit(&v_name);
  766.         hr = VariantChangeType(&v_name, options, 0, VT_BSTR);
  767.         if( SUCCEEDED(hr) )
  768.         {
  769.             hr = parseStringOptions(codePage, V_BSTR(&v_name), cOptions, cOptionCount);
  770.             VariantClear(&v_name);
  771.         }
  772.     }
  773.     else if( VT_BSTR == V_VT(options) )
  774.     {
  775.         hr = parseStringOptions(codePage, V_BSTR(options), cOptions, cOptionCount);
  776.     }
  777.     return hr;
  778. };
  780. /*
  781. ** use VARIANT rather than a SAFEARRAY as argument type
  782. ** for compatibility with some scripting language (JScript)
  783. */
  785. STDMETHODIMP VLCControl::addTarget(BSTR uri, VARIANT options, enum VLCPlaylistMode mode, int position)
  786. {
  787.     if( 0 == SysStringLen(uri) )
  788.         return E_INVALIDARG;
  790.     libvlc_instance_t *p_libvlc;
  791.     HRESULT hr = _p_instance->getVLC(&p_libvlc);
  792.     if( SUCCEEDED(hr) )
  793.     {
  794.         char *cUri = CStrFromBSTR(CP_UTF8, uri);
  795.         if( NULL == cUri )
  796.             return E_OUTOFMEMORY;
  798.         int cOptionsCount;
  799.         char **cOptions;
  801.         if( FAILED(CreateTargetOptions(CP_UTF8, &options, &cOptions, &cOptionsCount)) )
  802.             return E_INVALIDARG;
  804.         libvlc_exception_t ex;
  805.         libvlc_exception_init(&ex);
  807.         position = _p_instance->playlist_add_extended_untrusted(cUri,
  808.                        cOptionsCount, const_cast<const char**>(cOptions), &ex);
  810.         FreeTargetOptions(cOptions, cOptionsCount);
  811.         CoTaskMemFree(cUri);
  813.         if( libvlc_exception_raised(&ex) )
  814.         {
  815.             _p_instance->setErrorInfo(IID_IVLCPlaylist,
  816.                 libvlc_exception_get_message(&ex));
  817.             libvlc_exception_clear(&ex);
  819.             if( mode & VLCPlayListAppendAndGo )
  820.                 _p_instance->fireOnStopEvent();
  821.             return E_FAIL;
  822.         }
  824.         if( mode & VLCPlayListAppendAndGo )
  825.             _p_instance->fireOnPlayEvent();
  826.         return NOERROR;
  827.     }
  828.     return hr;
  829. };
  831. STDMETHODIMP VLCControl::get_PlaylistIndex(int *index)
  832. {
  833.     if( NULL == index )
  834.         return E_POINTER;
  836.     *index = 0;
  837.     libvlc_instance_t *p_libvlc;
  838.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  839.     if( SUCCEEDED(result) )
  840.     {
  841.         libvlc_exception_t ex;
  842.         libvlc_exception_init(&ex);
  844.         *index = _p_instance->playlist_get_current_index(&ex);
  845.         if( libvlc_exception_raised(&ex) )
  846.         {
  847.             _p_instance->setErrorInfo(IID_IVLCControl,
  848.                 libvlc_exception_get_message(&ex));
  849.             libvlc_exception_clear(&ex);
  850.             return E_FAIL;
  851.         }
  852.         return NOERROR;
  853.     }
  854.     return result;
  855. };
  857. STDMETHODIMP VLCControl::get_PlaylistCount(int *count)
  858. {
  859.     if( NULL == count )
  860.         return E_POINTER;
  862.     libvlc_exception_t ex;
  863.     libvlc_exception_init(&ex);
  865.     *count = _p_instance->playlist_count(&ex);
  866.     if( libvlc_exception_raised(&ex) )
  867.     {
  868.         _p_instance->setErrorInfo(IID_IVLCControl,
  869.             libvlc_exception_get_message(&ex));
  870.         libvlc_exception_clear(&ex);
  871.         return E_FAIL;
  872.     }
  873.     return NOERROR;
  874. };
  876. STDMETHODIMP VLCControl::playlistNext(void)
  877. {
  878.     libvlc_instance_t* p_libvlc;
  879.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  880.     if( SUCCEEDED(result) )
  881.     {
  882.         libvlc_exception_t ex;
  883.         libvlc_exception_init(&ex);
  885.         _p_instance->playlist_next(&ex);
  886.         if( libvlc_exception_raised(&ex) )
  887.         {
  888.             _p_instance->setErrorInfo(IID_IVLCControl,
  889.                 libvlc_exception_get_message(&ex));
  890.             libvlc_exception_clear(&ex);
  891.             return E_FAIL;
  892.         }
  893.         return NOERROR;
  894.     }
  895.     return result;
  896. };
  898. STDMETHODIMP VLCControl::playlistPrev(void)
  899. {
  900.     libvlc_instance_t* p_libvlc;
  901.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  902.     if( SUCCEEDED(result) )
  903.     {
  904.         libvlc_exception_t ex;
  905.         libvlc_exception_init(&ex);
  907.         _p_instance->playlist_prev(&ex);
  908.         if( libvlc_exception_raised(&ex) )
  909.         {
  910.             _p_instance->setErrorInfo(IID_IVLCControl,
  911.                 libvlc_exception_get_message(&ex));
  912.             libvlc_exception_clear(&ex);
  913.             return E_FAIL;
  914.         }
  915.         return NOERROR;
  916.     }
  917.     return result;
  918. };
  920. STDMETHODIMP VLCControl::playlistClear(void)
  921. {
  922.     libvlc_instance_t* p_libvlc;
  923.     HRESULT result = _p_instance->getVLC(&p_libvlc);
  924.     if( SUCCEEDED(result) )
  925.     {
  926.         libvlc_exception_t ex;
  927.         libvlc_exception_init(&ex);
  929.         _p_instance->playlist_clear(&ex);
  930.         if( libvlc_exception_raised(&ex) )
  931.         {
  932.             _p_instance->setErrorInfo(IID_IVLCControl,
  933.                 libvlc_exception_get_message(&ex));
  934.             libvlc_exception_clear(&ex);
  935.             return E_FAIL;
  936.         }
  937.         return NOERROR;
  938.     }
  939.     return result;
  940. };
  942. STDMETHODIMP VLCControl::get_VersionInfo(BSTR *version)
  943. {
  944.     if( NULL == version )
  945.         return E_POINTER;
  947.     const char *versionStr = libvlc_get_version();
  948.     if( NULL != versionStr )
  949.     {
  950.         *version = BSTRFromCStr(CP_UTF8, versionStr);
  951.         return (NULL == *version) ? E_OUTOFMEMORY : NOERROR;
  952.     }
  953.     *version = NULL;
  954.     return E_FAIL;
  955. };
  957. STDMETHODIMP VLCControl::get_MRL(BSTR *mrl)
  958. {
  959.     if( NULL == mrl )
  960.         return E_POINTER;
  962.     *mrl = SysAllocStringLen(_p_instance->getMRL(),
  963.                 SysStringLen(_p_instance->getMRL()));
  964.     return NOERROR;
  965. };
  967. STDMETHODIMP VLCControl::put_MRL(BSTR mrl)
  968. {
  969.     _p_instance->setMRL(mrl);
  971.     return S_OK;
  972. };
  974. STDMETHODIMP VLCControl::get_AutoPlay(VARIANT_BOOL *autoplay)
  975. {
  976.     if( NULL == autoplay )
  977.         return E_POINTER;
  979.     *autoplay = _p_instance->getAutoPlay() ? VARIANT_TRUE: VARIANT_FALSE;
  980.     return S_OK;
  981. };
  983. STDMETHODIMP VLCControl::put_AutoPlay(VARIANT_BOOL autoplay)
  984. {
  985.     _p_instance->setAutoPlay((VARIANT_FALSE != autoplay) ? TRUE: FALSE);
  986.     return S_OK;
  987. };
  989. STDMETHODIMP VLCControl::get_AutoLoop(VARIANT_BOOL *autoloop)
  990. {
  991.     if( NULL == autoloop )
  992.         return E_POINTER;
  994.     *autoloop = _p_instance->getAutoLoop() ? VARIANT_TRUE: VARIANT_FALSE;
  995.     return S_OK;
  996. };
  998. STDMETHODIMP VLCControl::put_AutoLoop(VARIANT_BOOL autoloop)
  999. {
  1000.     _p_instance->setAutoLoop((VARIANT_FALSE != autoloop) ? TRUE: FALSE);
  1001.     return S_OK;
  1002. };