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