Add playlist_CurrentId() to get the playlist item id from the currently playing item.
[vlc.git] / projects / activex / 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  *****************************************************************************/
23
24 #include "plugin.h"
25 #include "vlccontrol.h"
26
27 #include "utils.h"
28
29 using namespace std;
30
31 VLCControl::~VLCControl()
32 {
33     if( _p_typeinfo )
34         _p_typeinfo->Release();
35 };
36
37 HRESULT VLCControl::getTypeInfo(void)
38 {
39     HRESULT hr = NOERROR;
40     if( NULL == _p_typeinfo )
41     {
42         ITypeLib *p_typelib;
43
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 };
57
58 STDMETHODIMP VLCControl::GetTypeInfoCount(UINT* pctInfo)
59 {
60     if( NULL == pctInfo )
61         return E_INVALIDARG;
62
63     if( SUCCEEDED(getTypeInfo()) )
64         *pctInfo = 1;
65     else
66         *pctInfo = 0;
67
68     return NOERROR;
69 };
70
71 STDMETHODIMP VLCControl::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
72 {
73     if( NULL == ppTInfo )
74         return E_INVALIDARG;
75
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 };
85
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 };
95
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 };
107
108 STDMETHODIMP VLCControl::get_Visible(VARIANT_BOOL *isVisible)
109 {
110     if( NULL == isVisible )
111         return E_POINTER;
112
113     *isVisible = _p_instance->getVisible() ? VARIANT_TRUE : VARIANT_FALSE;
114
115     return NOERROR;
116 };
117
118 STDMETHODIMP VLCControl::put_Visible(VARIANT_BOOL isVisible)
119 {
120     _p_instance->setVisible(isVisible != VARIANT_FALSE);
121
122     return NOERROR;
123 };
124
125 STDMETHODIMP VLCControl::play(void)
126 {
127     libvlc_instance_t* p_libvlc;
128     HRESULT result = _p_instance->getVLC(&p_libvlc);
129     if( SUCCEEDED(result) )
130     {
131         libvlc_exception_t ex;
132         libvlc_exception_init(&ex);
133
134         libvlc_playlist_play(p_libvlc, -1, 0, NULL, &ex);
135         if( libvlc_exception_raised(&ex) )
136         {
137             _p_instance->setErrorInfo(IID_IVLCControl,
138                 libvlc_exception_get_message(&ex));
139             libvlc_exception_clear(&ex);
140             return E_FAIL;
141         }
142         _p_instance->fireOnPlayEvent();
143         return NOERROR;
144     }
145     return result;
146 };
147
148 STDMETHODIMP VLCControl::pause(void)
149 {
150     libvlc_instance_t* p_libvlc;
151     HRESULT result = _p_instance->getVLC(&p_libvlc);
152     if( SUCCEEDED(result) )
153     {
154         libvlc_exception_t ex;
155         libvlc_exception_init(&ex);
156
157         libvlc_playlist_pause(p_libvlc, &ex);
158         if( libvlc_exception_raised(&ex) )
159         {
160             _p_instance->setErrorInfo(IID_IVLCControl,
161                 libvlc_exception_get_message(&ex));
162             libvlc_exception_clear(&ex);
163             return E_FAIL;
164         }
165         _p_instance->fireOnPauseEvent();
166         return NOERROR;
167     }
168     return result;
169 };
170
171 STDMETHODIMP VLCControl::stop(void)
172 {
173     libvlc_instance_t* p_libvlc;
174     HRESULT result = _p_instance->getVLC(&p_libvlc);
175     if( SUCCEEDED(result) )
176     {
177         libvlc_exception_t ex;
178         libvlc_exception_init(&ex);
179
180         libvlc_playlist_stop(p_libvlc, &ex);
181         if( libvlc_exception_raised(&ex) )
182         {
183             _p_instance->setErrorInfo(IID_IVLCControl,
184                 libvlc_exception_get_message(&ex));
185             libvlc_exception_clear(&ex);
186             return E_FAIL;
187         }
188         return NOERROR;
189     }
190     _p_instance->fireOnStopEvent();
191     return result;
192 };
193
194 STDMETHODIMP VLCControl::get_Playing(VARIANT_BOOL *isPlaying)
195 {
196     if( NULL == isPlaying )
197         return E_POINTER;
198
199     HRESULT result = NOERROR;
200     if( _p_instance->isRunning() )
201     {
202         libvlc_instance_t *p_libvlc;
203         result = _p_instance->getVLC(&p_libvlc);
204         if( SUCCEEDED(result) )
205         {
206             if( libvlc_playlist_isplaying(p_libvlc, NULL) )
207                 *isPlaying = VARIANT_TRUE;
208             else
209                 *isPlaying = VARIANT_FALSE;
210             return NOERROR;
211         }
212     }
213     *isPlaying = VARIANT_FALSE;
214     return result;
215 };
216
217 STDMETHODIMP VLCControl::get_Position(float *position)
218 {
219     if( NULL == position )
220         return E_POINTER;
221     *position = 0.0f;
222
223     libvlc_instance_t* p_libvlc;
224     HRESULT result = E_UNEXPECTED;
225     result = _p_instance->getVLC(&p_libvlc);
226     if( SUCCEEDED(result) )
227     {
228         libvlc_exception_t ex;
229         libvlc_exception_init(&ex);
230
231         libvlc_media_player_t *p_md;
232         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
233         if( !libvlc_exception_raised(&ex) )
234         {
235             *position = libvlc_media_player_get_position(p_md, &ex);
236             libvlc_media_player_release(p_md);
237             if( ! libvlc_exception_raised(&ex) )
238             {
239                 return NOERROR;
240             }
241         }
242         _p_instance->setErrorInfo(IID_IVLCControl,
243                      libvlc_exception_get_message(&ex));
244         libvlc_exception_clear(&ex);
245         return E_FAIL;
246     }
247     return result;
248 };
249
250 STDMETHODIMP VLCControl::put_Position(float position)
251 {
252     HRESULT result = E_UNEXPECTED;
253     libvlc_instance_t* p_libvlc;
254     result = _p_instance->getVLC(&p_libvlc);
255     if( SUCCEEDED(result) )
256     {
257         libvlc_exception_t ex;
258         libvlc_exception_init(&ex);
259
260         libvlc_media_player_t *p_md;
261         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
262         if( ! libvlc_exception_raised(&ex) )
263         {
264             libvlc_media_player_set_position(p_md, position, &ex);
265             libvlc_media_player_release(p_md);
266             if( ! libvlc_exception_raised(&ex) )
267             {
268                 return NOERROR;
269             }
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 };
278
279 STDMETHODIMP VLCControl::get_Time(int *seconds)
280 {
281     if( NULL == seconds )
282         return E_POINTER;
283
284     *seconds = 0;
285     libvlc_instance_t* p_libvlc;
286     HRESULT result = _p_instance->getVLC(&p_libvlc);
287     if( SUCCEEDED(result) )
288     {
289         libvlc_exception_t ex;
290         libvlc_exception_init(&ex);
291
292         libvlc_media_player_t *p_md;
293         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
294         if( ! libvlc_exception_raised(&ex) )
295         {
296             *seconds = libvlc_media_player_get_time(p_md, &ex);
297             libvlc_media_player_release(p_md);
298             if( ! libvlc_exception_raised(&ex) )
299             {
300                 return NOERROR;
301             }
302         }
303         _p_instance->setErrorInfo(IID_IVLCControl,
304                      libvlc_exception_get_message(&ex));
305         libvlc_exception_clear(&ex);
306         return E_FAIL;
307     }
308     return result;
309 };
310
311 STDMETHODIMP VLCControl::put_Time(int seconds)
312 {
313     /* setTime function of the plugin sets the time. */
314     _p_instance->setTime(seconds);
315     return NOERROR;
316 };
317
318 STDMETHODIMP VLCControl::shuttle(int seconds)
319 {
320     libvlc_instance_t* p_libvlc;
321     HRESULT result = _p_instance->getVLC(&p_libvlc);
322     if( SUCCEEDED(result) )
323     {
324         libvlc_exception_t ex;
325         libvlc_exception_init(&ex);
326
327         libvlc_media_player_t *p_md;
328         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
329         if( ! libvlc_exception_raised(&ex) )
330         {
331             if( seconds < 0 ) seconds = 0;
332             libvlc_media_player_set_time(p_md, (int64_t)seconds, &ex);
333             libvlc_media_player_release(p_md);
334             if( ! libvlc_exception_raised(&ex) )
335             {
336                 return NOERROR;
337             }
338         }
339         _p_instance->setErrorInfo(IID_IVLCControl,
340                      libvlc_exception_get_message(&ex));
341         libvlc_exception_clear(&ex);
342         return E_FAIL;
343     }
344     return result;
345
346 };
347
348 STDMETHODIMP VLCControl::fullscreen(void)
349 {
350     HRESULT result = E_UNEXPECTED;
351     if( _p_instance->isRunning() )
352     {
353         libvlc_instance_t *p_libvlc;
354         result = _p_instance->getVLC(&p_libvlc);
355         if( SUCCEEDED(result) )
356         {
357             if( libvlc_playlist_isplaying(p_libvlc, NULL) )
358             {
359                 libvlc_media_player_t *p_md =
360                     libvlc_playlist_get_media_player(p_libvlc, NULL);
361                 if( p_md )
362                 {
363                     libvlc_toggle_fullscreen(p_md, NULL);
364                     libvlc_media_player_release(p_md);
365                 }
366             }
367         }
368     }
369     return result;
370 };
371
372 STDMETHODIMP VLCControl::get_Length(int *seconds)
373 {
374     if( NULL == seconds )
375         return E_POINTER;
376     *seconds = 0;
377
378     libvlc_instance_t* p_libvlc;
379     HRESULT result = _p_instance->getVLC(&p_libvlc);
380     if( SUCCEEDED(result) )
381     {
382         libvlc_exception_t ex;
383         libvlc_exception_init(&ex);
384
385         libvlc_media_player_t *p_md;
386         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
387         if( ! libvlc_exception_raised(&ex) )
388         {
389             *seconds = (double)libvlc_media_player_get_length(p_md, &ex);
390             libvlc_media_player_release(p_md);
391             if( ! libvlc_exception_raised(&ex) )
392             {
393                 return NOERROR;
394             }
395         }
396         _p_instance->setErrorInfo(IID_IVLCControl,
397                      libvlc_exception_get_message(&ex));
398         libvlc_exception_clear(&ex);
399         return E_FAIL;
400     }
401     return result;
402
403 };
404
405 STDMETHODIMP VLCControl::playFaster(void)
406 {
407     int32_t rate = 2;
408
409     HRESULT result = E_UNEXPECTED;
410     if( !_p_instance->isRunning() )
411         return result;
412
413     libvlc_instance_t* p_libvlc;
414     result = _p_instance->getVLC(&p_libvlc);
415     if( SUCCEEDED(result) )
416     {
417         libvlc_exception_t ex;
418         libvlc_exception_init(&ex);
419
420         libvlc_media_player_t *p_md;
421         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
422         if( ! libvlc_exception_raised(&ex) )
423         {
424             libvlc_media_player_set_rate(p_md, rate, &ex);
425             libvlc_media_player_release(p_md);
426             if( ! libvlc_exception_raised(&ex) )
427             {
428                 return NOERROR;
429             }
430         }
431         _p_instance->setErrorInfo(IID_IVLCControl,
432                      libvlc_exception_get_message(&ex));
433         libvlc_exception_clear(&ex);
434         return E_FAIL;
435     }
436     return result;
437 };
438
439 STDMETHODIMP VLCControl::playSlower(void)
440 {
441     float rate = 0.5;
442
443     HRESULT result = E_UNEXPECTED;
444     if( !_p_instance->isRunning() )
445         return result;
446
447     libvlc_instance_t* p_libvlc;
448     result = _p_instance->getVLC(&p_libvlc);
449     if( SUCCEEDED(result) )
450     {
451         libvlc_exception_t ex;
452         libvlc_exception_init(&ex);
453
454         libvlc_media_player_t *p_md;
455         p_md = libvlc_playlist_get_media_player(p_libvlc, &ex);
456         if( ! libvlc_exception_raised(&ex) )
457         {
458             libvlc_media_player_set_rate(p_md, rate, &ex);
459             libvlc_media_player_release(p_md);
460             if( ! libvlc_exception_raised(&ex) )
461             {
462                 return NOERROR;
463             }
464         }
465         _p_instance->setErrorInfo(IID_IVLCControl,
466                      libvlc_exception_get_message(&ex));
467         libvlc_exception_clear(&ex);
468         return E_FAIL;
469     }
470     return result;
471 };
472
473 STDMETHODIMP VLCControl::get_Volume(int *volume)
474 {
475     if( NULL == volume )
476         return E_POINTER;
477
478     *volume  = _p_instance->getVolume();
479     return NOERROR;
480 };
481
482 STDMETHODIMP VLCControl::put_Volume(int volume)
483 {
484     _p_instance->setVolume(volume);
485     return NOERROR;
486 };
487
488 STDMETHODIMP VLCControl::toggleMute(void)
489 {
490     libvlc_instance_t* p_libvlc;
491     HRESULT result = _p_instance->getVLC(&p_libvlc);
492     if( SUCCEEDED(result) )
493     {
494         libvlc_exception_t ex;
495         libvlc_exception_init(&ex);
496
497         libvlc_audio_toggle_mute(p_libvlc, &ex);
498         if( libvlc_exception_raised(&ex) )
499         {
500             _p_instance->setErrorInfo(IID_IVLCControl,
501                          libvlc_exception_get_message(&ex));
502             libvlc_exception_clear(&ex);
503             return E_FAIL;
504         }
505         return NOERROR;
506     }
507     return result;
508 };
509
510 STDMETHODIMP VLCControl::setVariable(BSTR name, VARIANT value)
511 {
512     /** setVariable() is an unsafe interface because of security
513       implications it has and is thus removed. */
514     return E_INVALIDARG;
515 };
516
517 STDMETHODIMP VLCControl::getVariable(BSTR name, VARIANT *value)
518 {
519     /** getVariable() is an unsafe interface because of security
520       implications it has and is thus removed. */
521     return E_INVALIDARG;
522 };
523
524 void VLCControl::FreeTargetOptions(char **cOptions, int cOptionCount)
525 {
526     // clean up
527     if( NULL != cOptions )
528     {
529         for( int pos=0; pos<cOptionCount; ++pos )
530         {
531             char *cOption = cOptions[pos];
532             if( NULL != cOption )
533                 CoTaskMemFree(cOption);
534             else
535                 break;
536         }
537         CoTaskMemFree(cOptions);
538     }
539 };
540
541 static HRESULT parseStringOptions(int codePage, BSTR bstr, char*** cOptions, int *cOptionCount)
542 {
543     HRESULT hr = E_INVALIDARG;
544     if( SysStringLen(bstr) > 0 )
545     {
546         hr = E_OUTOFMEMORY;
547         char *s = CStrFromBSTR(codePage, bstr);
548         char *val = s;
549         if( val )
550         {
551             long capacity = 16;
552             char **options = (char **)CoTaskMemAlloc(capacity*sizeof(char *));
553             if( options )
554             {
555                 int nOptions = 0;
556
557                 char *end = val + strlen(val);
558                 while( val < end )
559                 {
560                     // skip leading blanks
561                     while( (val < end)
562                         && ((*val == ' ' ) || (*val == '\t')) )
563                         ++val;
564
565                     char *start = val;
566                     // skip till we get a blank character
567                     while( (val < end)
568                         && (*val != ' ' )
569                         && (*val != '\t') )
570                     {
571                         char c = *(val++);
572                         if( ('\'' == c) || ('"' == c) )
573                         {
574                             // skip till end of string
575                             while( (val < end) && (*(val++) != c ) );
576                         }
577                     }
578
579                     if( val > start )
580                     {
581                         if( nOptions == capacity )
582                         {
583                             capacity += 16;
584                             char **moreOptions = (char **)CoTaskMemRealloc(options, capacity*sizeof(char*));
585                             if( ! moreOptions )
586                             {
587                                 /* failed to allocate more memory */
588                                 CoTaskMemFree(s);
589                                 /* return what we got so far */
590                                 *cOptionCount = nOptions;
591                                 *cOptions = options;
592                                 return NOERROR;
593                             }
594                             options = moreOptions;
595                         }
596                         *(val++) = '\0';
597                         options[nOptions] = (char *)CoTaskMemAlloc(val-start);
598                         if( options[nOptions] )
599                         {
600                             memcpy(options[nOptions], start, val-start);
601                             ++nOptions;
602                         }
603                         else
604                         {
605                             /* failed to allocate memory */
606                             CoTaskMemFree(s);
607                             /* return what we got so far */
608                             *cOptionCount = nOptions;
609                             *cOptions = options;
610                             return NOERROR;
611                         }
612                     }
613                     else
614                         // must be end of string
615                         break;
616                 }
617                 *cOptionCount = nOptions;
618                 *cOptions = options;
619                 hr = NOERROR;
620             }
621             CoTaskMemFree(s);
622         }
623     }
624     return hr;
625 }
626
627 HRESULT VLCControl::CreateTargetOptions(int codePage, VARIANT *options, char ***cOptions, int *cOptionCount)
628 {
629     HRESULT hr = E_INVALIDARG;
630     if( VT_ERROR == V_VT(options) )
631     {
632         if( DISP_E_PARAMNOTFOUND == V_ERROR(options) )
633         {
634             // optional parameter not set
635             *cOptions = NULL;
636             *cOptionCount = 0;
637             return NOERROR;
638         }
639     }
640     else if( (VT_EMPTY == V_VT(options)) || (VT_NULL == V_VT(options)) )
641     {
642         // null parameter
643         *cOptions = NULL;
644         *cOptionCount = 0;
645         return NOERROR;
646     }
647     else if( VT_DISPATCH == V_VT(options) )
648     {
649         // if object is a collection, retrieve enumerator
650         VARIANT colEnum;
651         V_VT(&colEnum) = VT_UNKNOWN;
652         hr = GetObjectProperty(V_DISPATCH(options), DISPID_NEWENUM, colEnum);
653         if( SUCCEEDED(hr) )
654         {
655             IEnumVARIANT *enumVar;
656             hr = V_UNKNOWN(&colEnum)->QueryInterface(IID_IEnumVARIANT, (LPVOID *)&enumVar);
657             if( SUCCEEDED(hr) )
658             {
659                 long pos = 0;
660                 long capacity = 16;
661                 VARIANT option;
662
663                 *cOptions = (char **)CoTaskMemAlloc(capacity*sizeof(char *));
664                 if( NULL != *cOptions )
665                 {
666                     ZeroMemory(*cOptions, sizeof(char *)*capacity);
667                     while( SUCCEEDED(hr) && (S_OK == enumVar->Next(1, &option, NULL)) )
668                     {
669                         if( VT_BSTR == V_VT(&option) )
670                         {
671                             char *cOption = CStrFromBSTR(codePage, V_BSTR(&option));
672                             (*cOptions)[pos] = cOption;
673                             if( NULL != cOption )
674                             {
675                                 ++pos;
676                                 if( pos == capacity )
677                                 {
678                                     char **moreOptions = (char **)CoTaskMemRealloc(*cOptions, (capacity+16)*sizeof(char *));
679                                     if( NULL != moreOptions )
680                                     {
681                                         ZeroMemory(moreOptions+capacity, sizeof(char *)*16);
682                                         capacity += 16;
683                                         *cOptions = moreOptions;
684                                     }
685                                     else
686                                         hr = E_OUTOFMEMORY;
687                                 }
688                             }
689                             else
690                                 hr = ( SysStringLen(V_BSTR(&option)) > 0 ) ?
691                                     E_OUTOFMEMORY : E_INVALIDARG;
692                         }
693                         else
694                             hr = E_INVALIDARG;
695
696                         VariantClear(&option);
697                     }
698                     *cOptionCount = pos;
699                     if( FAILED(hr) )
700                     {
701                         // free already processed elements
702                         FreeTargetOptions(*cOptions, *cOptionCount);
703                     }
704                 }
705                 else
706                     hr = E_OUTOFMEMORY;
707
708                 enumVar->Release();
709             }
710         }
711         else
712         {
713             // coerce object into a string and parse it
714             VARIANT v_name;
715             VariantInit(&v_name);
716             hr = VariantChangeType(&v_name, options, 0, VT_BSTR);
717             if( SUCCEEDED(hr) )
718             {
719                 hr = parseStringOptions(codePage, V_BSTR(&v_name), cOptions, cOptionCount);
720                 VariantClear(&v_name);
721             }
722         }
723     }
724     else if( V_ISARRAY(options) )
725     {
726         // array parameter
727         SAFEARRAY *array = V_ISBYREF(options) ? *V_ARRAYREF(options) : V_ARRAY(options);
728
729         if( SafeArrayGetDim(array) != 1 )
730             return E_INVALIDARG;
731
732         long lBound = 0;
733         long uBound = 0;
734         SafeArrayGetLBound(array, 1, &lBound);
735         SafeArrayGetUBound(array, 1, &uBound);
736
737         // have we got any options
738         if( uBound >= lBound )
739         {
740             VARTYPE vType;
741             hr = SafeArrayGetVartype(array, &vType);
742             if( FAILED(hr) )
743                 return hr;
744
745             long pos;
746
747             // marshall options into an array of C strings
748             if( VT_VARIANT == vType )
749             {
750                 *cOptions = (char **)CoTaskMemAlloc(sizeof(char *)*(uBound-lBound+1));
751                 if( NULL == *cOptions )
752                     return E_OUTOFMEMORY;
753
754                 ZeroMemory(*cOptions, sizeof(char *)*(uBound-lBound+1));
755                 for(pos=lBound; (pos<=uBound) && SUCCEEDED(hr); ++pos )
756                 {
757                     VARIANT option;
758                     hr = SafeArrayGetElement(array, &pos, &option);
759                     if( SUCCEEDED(hr) )
760                     {
761                         if( VT_BSTR == V_VT(&option) )
762                         {
763                             char *cOption = CStrFromBSTR(codePage, V_BSTR(&option));
764                             (*cOptions)[pos-lBound] = cOption;
765                             if( NULL == cOption )
766                                 hr = ( SysStringLen(V_BSTR(&option)) > 0 ) ?
767                                     E_OUTOFMEMORY : E_INVALIDARG;
768                         }
769                         else
770                             hr = E_INVALIDARG;
771                         VariantClear(&option);
772                     }
773                 }
774             }
775             else if( VT_BSTR == vType )
776             {
777                 *cOptions = (char **)CoTaskMemAlloc(sizeof(char *)*(uBound-lBound+1));
778                 if( NULL == *cOptions )
779                     return E_OUTOFMEMORY;
780
781                 ZeroMemory(*cOptions, sizeof(char *)*(uBound-lBound+1));
782                 for(pos=lBound; (pos<=uBound) && SUCCEEDED(hr); ++pos )
783                 {
784                     BSTR option;
785                     hr = SafeArrayGetElement(array, &pos, &option);
786                     if( SUCCEEDED(hr) )
787                     {
788                         char *cOption = CStrFromBSTR(codePage, option);
789
790                         (*cOptions)[pos-lBound] = cOption;
791                         if( NULL == cOption )
792                             hr = ( SysStringLen(option) > 0 ) ?
793                                 E_OUTOFMEMORY : E_INVALIDARG;
794                         SysFreeString(option);
795                     }
796                 }
797             }
798             else
799             {
800                 // unsupported type
801                 return E_INVALIDARG;
802             }
803
804             *cOptionCount = pos-lBound;
805             if( FAILED(hr) )
806             {
807                 // free already processed elements
808                 FreeTargetOptions(*cOptions, *cOptionCount);
809             }
810         }
811         else
812         {
813             // empty array
814             *cOptions = NULL;
815             *cOptionCount = 0;
816             return NOERROR;
817         }
818     }
819     else if( VT_UNKNOWN == V_VT(options) )
820     {
821         // coerce object into a string and parse it
822         VARIANT v_name;
823         VariantInit(&v_name);
824         hr = VariantChangeType(&v_name, options, 0, VT_BSTR);
825         if( SUCCEEDED(hr) )
826         {
827             hr = parseStringOptions(codePage, V_BSTR(&v_name), cOptions, cOptionCount);
828             VariantClear(&v_name);
829         }
830     }
831     else if( VT_BSTR == V_VT(options) )
832     {
833         hr = parseStringOptions(codePage, V_BSTR(options), cOptions, cOptionCount);
834     }
835     return hr;
836 };
837
838 /*
839 ** use VARIANT rather than a SAFEARRAY as argument type
840 ** for compatibility with some scripting language (JScript)
841 */
842
843 STDMETHODIMP VLCControl::addTarget(BSTR uri, VARIANT options, enum VLCPlaylistMode mode, int position)
844 {
845     if( 0 == SysStringLen(uri) )
846         return E_INVALIDARG;
847
848     libvlc_instance_t *p_libvlc;
849     HRESULT hr = _p_instance->getVLC(&p_libvlc);
850     if( SUCCEEDED(hr) )
851     {
852         char *cUri = CStrFromBSTR(CP_UTF8, uri);
853         if( NULL == cUri )
854             return E_OUTOFMEMORY;
855
856         int cOptionsCount;
857         char **cOptions;
858
859         if( FAILED(CreateTargetOptions(CP_UTF8, &options, &cOptions, &cOptionsCount)) )
860             return E_INVALIDARG;
861
862         libvlc_exception_t ex;
863         libvlc_exception_init(&ex);
864
865         position = libvlc_playlist_add_extended(p_libvlc, cUri, cUri,
866                                                 cOptionsCount,
867                                                 const_cast<const char**>(cOptions),
868                                                 &ex);
869
870         FreeTargetOptions(cOptions, cOptionsCount);
871         CoTaskMemFree(cUri);
872
873         if( libvlc_exception_raised(&ex) )
874         {
875             _p_instance->setErrorInfo(IID_IVLCPlaylist,
876                 libvlc_exception_get_message(&ex));
877             libvlc_exception_clear(&ex);
878
879             if( mode & VLCPlayListAppendAndGo )
880                 _p_instance->fireOnStopEvent();
881             return E_FAIL;
882         }
883
884         if( mode & VLCPlayListAppendAndGo )
885             _p_instance->fireOnPlayEvent();
886         return NOERROR;
887     }
888     return hr;
889 };
890
891 STDMETHODIMP VLCControl::get_PlaylistIndex(int *index)
892 {
893     if( NULL == index )
894         return E_POINTER;
895
896     *index = 0;
897     libvlc_instance_t *p_libvlc;
898     HRESULT result = _p_instance->getVLC(&p_libvlc);
899     if( SUCCEEDED(result) )
900     {
901         libvlc_exception_t ex;
902         libvlc_exception_init(&ex);
903
904         *index = libvlc_playlist_get_current_index(p_libvlc, &ex);
905         if( libvlc_exception_raised(&ex) )
906         {
907             _p_instance->setErrorInfo(IID_IVLCControl,
908                 libvlc_exception_get_message(&ex));
909             libvlc_exception_clear(&ex);
910             return E_FAIL;
911         }
912         return NOERROR;
913     }
914     return result;
915 };
916
917 STDMETHODIMP VLCControl::get_PlaylistCount(int *count)
918 {
919     if( NULL == count )
920         return E_POINTER;
921
922     *count = 0;
923     libvlc_instance_t* p_libvlc;
924     HRESULT result = _p_instance->getVLC(&p_libvlc);
925     if( SUCCEEDED(result) )
926     {
927         libvlc_exception_t ex;
928         libvlc_exception_init(&ex);
929
930         *count = libvlc_playlist_items_count(p_libvlc, &ex);
931         if( libvlc_exception_raised(&ex) )
932         {
933             _p_instance->setErrorInfo(IID_IVLCControl,
934                 libvlc_exception_get_message(&ex));
935             libvlc_exception_clear(&ex);
936             return E_FAIL;
937         }
938         return NOERROR;
939     }
940     return result;
941 };
942
943 STDMETHODIMP VLCControl::playlistNext(void)
944 {
945     libvlc_instance_t* p_libvlc;
946     HRESULT result = _p_instance->getVLC(&p_libvlc);
947     if( SUCCEEDED(result) )
948     {
949         libvlc_exception_t ex;
950         libvlc_exception_init(&ex);
951
952         libvlc_playlist_next(p_libvlc, &ex);
953         if( libvlc_exception_raised(&ex) )
954         {
955             _p_instance->setErrorInfo(IID_IVLCControl,
956                 libvlc_exception_get_message(&ex));
957             libvlc_exception_clear(&ex);
958             return E_FAIL;
959         }
960         return NOERROR;
961     }
962     return result;
963 };
964
965 STDMETHODIMP VLCControl::playlistPrev(void)
966 {
967     libvlc_instance_t* p_libvlc;
968     HRESULT result = _p_instance->getVLC(&p_libvlc);
969     if( SUCCEEDED(result) )
970     {
971         libvlc_exception_t ex;
972         libvlc_exception_init(&ex);
973
974         libvlc_playlist_prev(p_libvlc, &ex);
975         if( libvlc_exception_raised(&ex) )
976         {
977             _p_instance->setErrorInfo(IID_IVLCControl,
978                 libvlc_exception_get_message(&ex));
979             libvlc_exception_clear(&ex);
980             return E_FAIL;
981         }
982         return NOERROR;
983     }
984     return result;
985 };
986
987 STDMETHODIMP VLCControl::playlistClear(void)
988 {
989     libvlc_instance_t* p_libvlc;
990     HRESULT result = _p_instance->getVLC(&p_libvlc);
991     if( SUCCEEDED(result) )
992     {
993         libvlc_exception_t ex;
994         libvlc_exception_init(&ex);
995
996         libvlc_playlist_clear(p_libvlc, &ex);
997         if( libvlc_exception_raised(&ex) )
998         {
999             _p_instance->setErrorInfo(IID_IVLCControl,
1000                 libvlc_exception_get_message(&ex));
1001             libvlc_exception_clear(&ex);
1002             return E_FAIL;
1003         }
1004         return NOERROR;
1005     }
1006     return result;
1007 };
1008
1009 STDMETHODIMP VLCControl::get_VersionInfo(BSTR *version)
1010 {
1011     if( NULL == version )
1012         return E_POINTER;
1013
1014     const char *versionStr = libvlc_get_version();
1015     if( NULL != versionStr )
1016     {
1017         *version = BSTRFromCStr(CP_UTF8, versionStr);
1018         return (NULL == *version) ? E_OUTOFMEMORY : NOERROR;
1019     }
1020     *version = NULL;
1021     return E_FAIL;
1022 };
1023
1024 STDMETHODIMP VLCControl::get_MRL(BSTR *mrl)
1025 {
1026     if( NULL == mrl )
1027         return E_POINTER;
1028
1029     *mrl = SysAllocStringLen(_p_instance->getMRL(),
1030                 SysStringLen(_p_instance->getMRL()));
1031     return NOERROR;
1032 };
1033
1034 STDMETHODIMP VLCControl::put_MRL(BSTR mrl)
1035 {
1036     _p_instance->setMRL(mrl);
1037
1038     return S_OK;
1039 };
1040
1041 STDMETHODIMP VLCControl::get_AutoPlay(VARIANT_BOOL *autoplay)
1042 {
1043     if( NULL == autoplay )
1044         return E_POINTER;
1045
1046     *autoplay = _p_instance->getAutoPlay() ? VARIANT_TRUE: VARIANT_FALSE;
1047     return S_OK;
1048 };
1049
1050 STDMETHODIMP VLCControl::put_AutoPlay(VARIANT_BOOL autoplay)
1051 {
1052     _p_instance->setAutoPlay((VARIANT_FALSE != autoplay) ? TRUE: FALSE);
1053     return S_OK;
1054 };
1055
1056 STDMETHODIMP VLCControl::get_AutoLoop(VARIANT_BOOL *autoloop)
1057 {
1058     if( NULL == autoloop )
1059         return E_POINTER;
1060
1061     *autoloop = _p_instance->getAutoLoop() ? VARIANT_TRUE: VARIANT_FALSE;
1062     return S_OK;
1063 };
1064
1065 STDMETHODIMP VLCControl::put_AutoLoop(VARIANT_BOOL autoloop)
1066 {
1067     _p_instance->setAutoLoop((VARIANT_FALSE != autoloop) ? TRUE: FALSE);
1068     return S_OK;
1069 };