← Back to branch summary

~nik90/ubuntu/precise/vlc/keywords

« back to all changes in this revision

Viewing changes to projects/activex/vlccontrol2.cpp

  • Committer: Package Import Robot
  • Author(s): Benjamin Drung
  • Date: 2012-02-13 01:34:02 UTC
  • mfrom: (1.1.44)
  • Revision ID: package-import@ubuntu.com-20120213013402-7utx6r7s9dg3r0pf
Tags: 2.0.0~unix-0ubuntu1
http://bugs.debian.org/499381
http://bugs.debian.org/573064
http://bugs.debian.org/624027
https://launchpad.net/bugs/455825
http://bugs.debian.org/656831
* New upstream release (Closes: #499381, #573064, #624027, LP: #455825,
  #573775, #695882, #705151, #708448, #738381, #743581, #747757, #817924,
  #931083).
* Remove dropped mozilla-plugin-vlc, vlc-plugin-ggi, and vlc-plugin-svgalib.
  The Mozilla browser plug-in is now provided by a separate source tarball.
* Add new plugins to and remove dropped plugins from vlc-nox.
* Add new and remove dropped build dependencies:
  + libbluray-dev (for Blu-ray support)
  + libresid-builder-dev
  + libsamplerate0-dev
  + libsidplay2-dev
  + lbspeexdsp-dev
  + libxcb-composite0-dev
  - libgtk2.0-dev
  - xulrunner-dev
* vlc-plugin-fluidsynth depends on fluid-soundfont-gm or
  musescore-soundfont-gm for having a sound font for playing MIDI files.
* Drop all patches (they were either backported or accepted by upstream).
* Update symbols for libvlc5.
* Install plugins.dat instead of running vlc-cache-gen in postinst.
* Update minimum version of build dependencies.
* Change Build-Dependency from libupnp3-dev to unversioned libupnp-dev.
  (Closes: #656831)

Show diffs side-by-side

added added

removed removed

Lines of Context:
projects/activex/vlccontrol2.cpp
1
 
/*****************************************************************************
2
 
 * vlccontrol2.cpp: ActiveX control for VLC
3
 
 *****************************************************************************
4
 
 * Copyright (C) 2006 the VideoLAN team
5
 
 * Copyright (C) 2010 M2X BV
6
 
 *
7
 
 * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
8
 
 *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>
9
 
 *
10
 
 * This program is free software; you can redistribute it and/or modify
11
 
 * it under the terms of the GNU General Public License as published by
12
 
 * the Free Software Foundation; either version 2 of the License, or
13
 
 * (at your option) any later version.
14
 
 *
15
 
 * This program is distributed in the hope that it will be useful,
16
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
 
 * GNU General Public License for more details.
19
 
 *
20
 
 * You should have received a copy of the GNU General Public License along
21
 
 * with this program; if not, write to the Free Software Foundation, Inc.,
22
 
 * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23
 
 *****************************************************************************/
24
 
 
25
 
#include <stdio.h>
26
 
#include <shlwapi.h>
27
 
#include <wininet.h>
28
 
#include <tchar.h>
29
 
 
30
 
#include "utils.h"
31
 
#include "plugin.h"
32
 
#include "vlccontrol2.h"
33
 
#include "vlccontrol.h"
34
 
 
35
 
#include "position.h"
36
 
 
37
 
// ---------
38
 
 
39
 
HRESULT VLCInterfaceBase::loadTypeInfo(REFIID riid)
40
 
{
41
 
    // if( _ti ) return NOERROR; // unnecessairy
42
 
 
43
 
    ITypeLib *p_typelib;
44
 
    HRESULT hr = _plug->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
45
 
    if( SUCCEEDED(hr) )
46
 
    {
47
 
        hr = p_typelib->GetTypeInfoOfGuid(riid, &_ti);
48
 
        if( FAILED(hr) ) _ti = NULL;
49
 
        p_typelib->Release();
50
 
    }
51
 
    return hr;
52
 
}
53
 
 
54
 
#define BIND_INTERFACE( class ) \
55
 
    template<> REFIID VLCInterface<class, I##class>::_riid = IID_I##class;
56
 
 
57
 
BIND_INTERFACE( VLCAudio )
58
 
BIND_INTERFACE( VLCInput )
59
 
BIND_INTERFACE( VLCMarquee )
60
 
BIND_INTERFACE( VLCLogo )
61
 
BIND_INTERFACE( VLCDeinterlace )
62
 
BIND_INTERFACE( VLCPlaylistItems )
63
 
BIND_INTERFACE( VLCPlaylist )
64
 
BIND_INTERFACE( VLCVideo )
65
 
BIND_INTERFACE( VLCSubtitle )
66
 
 
67
 
#undef  BIND_INTERFACE
68
 
 
69
 
template<class I> static inline
70
 
HRESULT object_get(I **dst, I *src)
71
 
{
72
 
    if( NULL == dst )
73
 
        return E_POINTER;
74
 
 
75
 
    *dst = src;
76
 
    if( NULL != src )
77
 
    {
78
 
        src->AddRef();
79
 
        return NOERROR;
80
 
    }
81
 
    return E_OUTOFMEMORY;
82
 
}
83
 
 
84
 
static inline
85
 
VARIANT_BOOL varbool(bool b) { return b ? VARIANT_TRUE : VARIANT_FALSE; }
86
 
 
87
 
// ---------
88
 
 
89
 
STDMETHODIMP VLCAudio::get_mute(VARIANT_BOOL* mute)
90
 
{
91
 
    if( NULL == mute )
92
 
        return E_POINTER;
93
 
 
94
 
    libvlc_media_player_t *p_md;
95
 
    HRESULT hr = getMD(&p_md);
96
 
    if( SUCCEEDED(hr) )
97
 
        *mute = varbool( libvlc_audio_get_mute(p_md) );
98
 
    return hr;
99
 
};
100
 
 
101
 
STDMETHODIMP VLCAudio::put_mute(VARIANT_BOOL mute)
102
 
{
103
 
    libvlc_media_player_t *p_md;
104
 
    HRESULT hr = getMD(&p_md);
105
 
    if( SUCCEEDED(hr) )
106
 
        libvlc_audio_set_mute(p_md, VARIANT_FALSE != mute);
107
 
    return hr;
108
 
};
109
 
 
110
 
STDMETHODIMP VLCAudio::get_volume(long* volume)
111
 
{
112
 
    if( NULL == volume )
113
 
        return E_POINTER;
114
 
 
115
 
    libvlc_media_player_t *p_md;
116
 
    HRESULT hr = getMD(&p_md);
117
 
    if( SUCCEEDED(hr) )
118
 
        *volume = libvlc_audio_get_volume(p_md);
119
 
    return hr;
120
 
};
121
 
 
122
 
STDMETHODIMP VLCAudio::put_volume(long volume)
123
 
{
124
 
    libvlc_media_player_t *p_md;
125
 
    HRESULT hr = getMD(&p_md);
126
 
    if( SUCCEEDED(hr) )
127
 
    {
128
 
        libvlc_audio_set_volume(p_md, volume);
129
 
    }
130
 
    return hr;
131
 
};
132
 
 
133
 
STDMETHODIMP VLCAudio::get_track(long* track)
134
 
{
135
 
    if( NULL == track )
136
 
        return E_POINTER;
137
 
 
138
 
    libvlc_media_player_t* p_md;
139
 
    HRESULT hr = getMD(&p_md);
140
 
    if( SUCCEEDED(hr) )
141
 
    {
142
 
        *track = libvlc_audio_get_track(p_md);
143
 
    }
144
 
    return hr;
145
 
};
146
 
 
147
 
STDMETHODIMP VLCAudio::put_track(long track)
148
 
{
149
 
    libvlc_media_player_t *p_md;
150
 
    HRESULT hr = getMD(&p_md);
151
 
    if( SUCCEEDED(hr) )
152
 
    {
153
 
        libvlc_audio_set_track(p_md, track);
154
 
    }
155
 
    return hr;
156
 
};
157
 
 
158
 
STDMETHODIMP VLCAudio::get_count(long* trackNumber)
159
 
{
160
 
    if( NULL == trackNumber )
161
 
        return E_POINTER;
162
 
 
163
 
    libvlc_media_player_t* p_md;
164
 
    HRESULT hr = getMD(&p_md);
165
 
    if( SUCCEEDED(hr) )
166
 
    {
167
 
        // get the number of audio track available and return it
168
 
        *trackNumber = libvlc_audio_get_track_count(p_md);
169
 
    }
170
 
    return hr;
171
 
};
172
 
 
173
 
 
174
 
STDMETHODIMP VLCAudio::description(long trackID, BSTR* name)
175
 
{
176
 
    if( NULL == name )
177
 
        return E_POINTER;
178
 
 
179
 
    libvlc_media_player_t* p_md;
180
 
 
181
 
    HRESULT hr = getMD(&p_md);
182
 
    if( SUCCEEDED(hr) )
183
 
    {
184
 
        int i, i_limit;
185
 
        const char *psz_name;
186
 
        libvlc_track_description_t *p_trackDesc;
187
 
 
188
 
        // get tracks description
189
 
        p_trackDesc = libvlc_audio_get_track_description(p_md);
190
 
        if( !p_trackDesc )
191
 
            return E_FAIL;
192
 
 
193
 
        //get the number of available track
194
 
        i_limit = libvlc_audio_get_track_count(p_md);
195
 
        if( i_limit < 0 )
196
 
            return E_FAIL;
197
 
 
198
 
        // check if the number given is a good one
199
 
        if ( ( trackID > ( i_limit -1 ) ) || ( trackID < 0 ) )
200
 
                return E_FAIL;
201
 
 
202
 
        // get the good trackDesc
203
 
        for( i = 0 ; i < trackID ; i++ )
204
 
        {
205
 
            p_trackDesc = p_trackDesc->p_next;
206
 
        }
207
 
        // get the track name
208
 
        psz_name = p_trackDesc->psz_name;
209
 
 
210
 
        // return it
211
 
        if( psz_name != NULL )
212
 
        {
213
 
            *name = BSTRFromCStr(CP_UTF8, psz_name);
214
 
            return (NULL == *name) ? E_OUTOFMEMORY : NOERROR;
215
 
        }
216
 
        *name = NULL;
217
 
        return E_FAIL;
218
 
    }
219
 
    return hr;
220
 
};
221
 
 
222
 
STDMETHODIMP VLCAudio::get_channel(long *channel)
223
 
{
224
 
    if( NULL == channel )
225
 
        return E_POINTER;
226
 
 
227
 
    libvlc_media_player_t *p_md;
228
 
    HRESULT hr = getMD(&p_md);
229
 
    if( SUCCEEDED(hr) )
230
 
    {
231
 
        *channel = libvlc_audio_get_channel(p_md);
232
 
    }
233
 
    return hr;
234
 
};
235
 
 
236
 
STDMETHODIMP VLCAudio::put_channel(long channel)
237
 
{
238
 
    libvlc_media_player_t *p_md;
239
 
    HRESULT hr = getMD(&p_md);
240
 
    if( SUCCEEDED(hr) )
241
 
    {
242
 
        libvlc_audio_set_channel(p_md, channel);
243
 
    }
244
 
    return hr;
245
 
};
246
 
 
247
 
STDMETHODIMP VLCAudio::toggleMute()
248
 
{
249
 
    libvlc_media_player_t *p_md;
250
 
    HRESULT hr = getMD(&p_md);
251
 
    if( SUCCEEDED(hr) )
252
 
        libvlc_audio_toggle_mute(p_md);
253
 
    return hr;
254
 
};
255
 
 
256
 
/****************************************************************************/
257
 
 
258
 
STDMETHODIMP VLCDeinterlace::disable()
259
 
{
260
 
    libvlc_media_player_t *p_md;
261
 
    HRESULT hr = getMD(&p_md);
262
 
    if( SUCCEEDED(hr) )
263
 
    {
264
 
        libvlc_video_set_deinterlace(p_md, "");
265
 
    }
266
 
    return hr;
267
 
}
268
 
 
269
 
STDMETHODIMP VLCDeinterlace::enable(BSTR mode)
270
 
{
271
 
    libvlc_media_player_t *p_md;
272
 
    HRESULT hr = getMD(&p_md);
273
 
    if( SUCCEEDED(hr) )
274
 
    {
275
 
        char *psz_mode = CStrFromBSTR(CP_UTF8, mode);
276
 
        libvlc_video_set_deinterlace(p_md, psz_mode);
277
 
        CoTaskMemFree(psz_mode);
278
 
    }
279
 
    return hr;
280
 
}
281
 
 
282
 
/****************************************************************************/
283
 
 
284
 
STDMETHODIMP VLCInput::get_length(double* length)
285
 
{
286
 
    if( NULL == length )
287
 
        return E_POINTER;
288
 
    *length = 0;
289
 
 
290
 
    libvlc_media_player_t *p_md;
291
 
    HRESULT hr = getMD(&p_md);
292
 
    if( SUCCEEDED(hr) )
293
 
    {
294
 
        *length = (double)libvlc_media_player_get_length(p_md);
295
 
    }
296
 
    return hr;
297
 
};
298
 
 
299
 
STDMETHODIMP VLCInput::get_position(double* position)
300
 
{
301
 
    if( NULL == position )
302
 
        return E_POINTER;
303
 
 
304
 
    *position = 0.0f;
305
 
    libvlc_media_player_t *p_md;
306
 
    HRESULT hr = getMD(&p_md);
307
 
    if( SUCCEEDED(hr) )
308
 
    {
309
 
        *position = libvlc_media_player_get_position(p_md);
310
 
    }
311
 
    return hr;
312
 
};
313
 
 
314
 
STDMETHODIMP VLCInput::put_position(double position)
315
 
{
316
 
    libvlc_media_player_t *p_md;
317
 
    HRESULT hr = getMD(&p_md);
318
 
    if( SUCCEEDED(hr) )
319
 
    {
320
 
        libvlc_media_player_set_position(p_md, position);
321
 
    }
322
 
    return hr;
323
 
};
324
 
 
325
 
STDMETHODIMP VLCInput::get_time(double* time)
326
 
{
327
 
    if( NULL == time )
328
 
        return E_POINTER;
329
 
 
330
 
    libvlc_media_player_t *p_md;
331
 
    HRESULT hr = getMD(&p_md);
332
 
    if( SUCCEEDED(hr) )
333
 
    {
334
 
        *time = (double)libvlc_media_player_get_time(p_md);
335
 
    }
336
 
    return hr;
337
 
};
338
 
 
339
 
STDMETHODIMP VLCInput::put_time(double time)
340
 
{
341
 
    libvlc_media_player_t *p_md;
342
 
    HRESULT hr = getMD(&p_md);
343
 
    if( SUCCEEDED(hr) )
344
 
    {
345
 
        libvlc_media_player_set_time(p_md, (int64_t)time);
346
 
    }
347
 
    return hr;
348
 
};
349
 
 
350
 
STDMETHODIMP VLCInput::get_state(long* state)
351
 
{
352
 
    if( NULL == state )
353
 
        return E_POINTER;
354
 
 
355
 
    libvlc_media_player_t *p_md;
356
 
    HRESULT hr = getMD(&p_md);
357
 
    if( SUCCEEDED(hr) )
358
 
    {
359
 
        *state = libvlc_media_player_get_state(p_md);
360
 
    }
361
 
    return hr;
362
 
};
363
 
 
364
 
STDMETHODIMP VLCInput::get_rate(double* rate)
365
 
{
366
 
    if( NULL == rate )
367
 
        return E_POINTER;
368
 
 
369
 
    libvlc_media_player_t *p_md;
370
 
    HRESULT hr = getMD(&p_md);
371
 
    if( SUCCEEDED(hr) )
372
 
    {
373
 
        *rate = libvlc_media_player_get_rate(p_md);
374
 
    }
375
 
    return hr;
376
 
};
377
 
 
378
 
STDMETHODIMP VLCInput::put_rate(double rate)
379
 
{
380
 
    libvlc_media_player_t *p_md;
381
 
    HRESULT hr = getMD(&p_md);
382
 
    if( SUCCEEDED(hr) )
383
 
    {
384
 
        libvlc_media_player_set_rate(p_md, rate);
385
 
    }
386
 
    return hr;
387
 
};
388
 
 
389
 
STDMETHODIMP VLCInput::get_fps(double* fps)
390
 
{
391
 
    if( NULL == fps )
392
 
        return E_POINTER;
393
 
 
394
 
    *fps = 0.0;
395
 
    libvlc_media_player_t *p_md;
396
 
    HRESULT hr = getMD(&p_md);
397
 
    if( SUCCEEDED(hr) )
398
 
    {
399
 
        *fps = libvlc_media_player_get_fps(p_md);
400
 
    }
401
 
    return hr;
402
 
};
403
 
 
404
 
STDMETHODIMP VLCInput::get_hasVout(VARIANT_BOOL* hasVout)
405
 
{
406
 
    if( NULL == hasVout )
407
 
        return E_POINTER;
408
 
 
409
 
    libvlc_media_player_t *p_md;
410
 
    HRESULT hr = getMD(&p_md);
411
 
    if( SUCCEEDED(hr) )
412
 
    {
413
 
        *hasVout = varbool( libvlc_media_player_has_vout(p_md) );
414
 
    }
415
 
    return hr;
416
 
};
417
 
 
418
 
/****************************************************************************/
419
 
 
420
 
HRESULT VLCMarquee::do_put_int(unsigned idx, LONG val)
421
 
{
422
 
    libvlc_media_player_t *p_md;
423
 
    HRESULT hr = getMD(&p_md);
424
 
    if( SUCCEEDED(hr) )
425
 
    {
426
 
        libvlc_video_set_marquee_int(p_md, idx, val);
427
 
    }
428
 
    return hr;
429
 
}
430
 
 
431
 
HRESULT VLCMarquee::do_get_int(unsigned idx, LONG *val)
432
 
{
433
 
    if( NULL == val )
434
 
        return E_POINTER;
435
 
 
436
 
    libvlc_media_player_t *p_md;
437
 
    HRESULT hr = getMD(&p_md);
438
 
    if( SUCCEEDED(hr) )
439
 
    {
440
 
        *val = libvlc_video_get_marquee_int(p_md, idx);
441
 
    }
442
 
    return hr;
443
 
}
444
 
 
445
 
STDMETHODIMP VLCMarquee::get_position(BSTR* val)
446
 
{
447
 
    if( NULL == val )
448
 
        return E_POINTER;
449
 
 
450
 
    LONG i;
451
 
    HRESULT hr = do_get_int(libvlc_marquee_Position, &i);
452
 
    if(SUCCEEDED(hr))
453
 
        *val = BSTRFromCStr(CP_UTF8, position_bynumber(i));
454
 
 
455
 
    return hr;
456
 
}
457
 
 
458
 
STDMETHODIMP VLCMarquee::put_position(BSTR val)
459
 
{
460
 
    char *n = CStrFromBSTR(CP_UTF8, val);
461
 
    if( !n ) return E_OUTOFMEMORY;
462
 
 
463
 
    size_t i;
464
 
    HRESULT hr;
465
 
    if( position_byname( n, i ) )
466
 
        hr = do_put_int(libvlc_marquee_Position,i);
467
 
    else
468
 
        hr = E_INVALIDARG;
469
 
 
470
 
    CoTaskMemFree(n);
471
 
    return hr;
472
 
}
473
 
 
474
 
STDMETHODIMP VLCMarquee::get_text(BSTR *val)
475
 
{
476
 
    char *psz;
477
 
    if( NULL == val )
478
 
        return E_POINTER;
479
 
 
480
 
    libvlc_media_player_t *p_md;
481
 
    HRESULT hr = getMD(&p_md);
482
 
    if( SUCCEEDED(hr) )
483
 
    {
484
 
        psz = libvlc_video_get_marquee_string(p_md, libvlc_marquee_Text);
485
 
        if( psz )
486
 
            *val = BSTRFromCStr(CP_UTF8, psz);
487
 
    }
488
 
    return hr;
489
 
}
490
 
 
491
 
STDMETHODIMP VLCMarquee::put_text(BSTR val)
492
 
{
493
 
    libvlc_media_player_t *p_md;
494
 
    HRESULT hr = getMD(&p_md);
495
 
    if( SUCCEEDED(hr) )
496
 
    {
497
 
        char *psz_text = CStrFromBSTR(CP_UTF8, val);
498
 
        libvlc_video_set_marquee_string(p_md, libvlc_marquee_Text, psz_text);
499
 
        CoTaskMemFree(psz_text);
500
 
    }
501
 
    return hr;
502
 
}
503
 
 
504
 
/****************************************************************************/
505
 
 
506
 
STDMETHODIMP VLCPlaylistItems::get_count(long* count)
507
 
{
508
 
    if( NULL == count )
509
 
        return E_POINTER;
510
 
 
511
 
    *count = Instance()->playlist_count();
512
 
    return S_OK;
513
 
};
514
 
 
515
 
STDMETHODIMP VLCPlaylistItems::clear()
516
 
{
517
 
    Instance()->playlist_clear();
518
 
    return S_OK;
519
 
};
520
 
 
521
 
STDMETHODIMP VLCPlaylistItems::remove(long item)
522
 
{
523
 
    libvlc_instance_t* p_libvlc;
524
 
    HRESULT hr = getVLC(&p_libvlc);
525
 
    if( SUCCEEDED(hr) )
526
 
    {
527
 
        Instance()->playlist_delete_item(item);
528
 
    }
529
 
    return hr;
530
 
};
531
 
 
532
 
/****************************************************************************/
533
 
 
534
 
STDMETHODIMP VLCPlaylist::get_itemCount(long* count)
535
 
{
536
 
    if( NULL == count )
537
 
        return E_POINTER;
538
 
 
539
 
    *count = 0;
540
 
    *count = Instance()->playlist_count();
541
 
    return S_OK;
542
 
};
543
 
 
544
 
STDMETHODIMP VLCPlaylist::get_isPlaying(VARIANT_BOOL* isPlaying)
545
 
{
546
 
    if( NULL == isPlaying )
547
 
        return E_POINTER;
548
 
 
549
 
    libvlc_media_player_t *p_md;
550
 
    HRESULT hr = getMD(&p_md);
551
 
    if( SUCCEEDED(hr) )
552
 
    {
553
 
        *isPlaying = varbool( libvlc_media_player_is_playing(p_md) );
554
 
    }
555
 
    return hr;
556
 
};
557
 
 
558
 
STDMETHODIMP VLCPlaylist::add(BSTR uri, VARIANT name, VARIANT options, long* item)
559
 
{
560
 
    if( NULL == item )
561
 
        return E_POINTER;
562
 
 
563
 
    if( 0 == SysStringLen(uri) )
564
 
        return E_INVALIDARG;
565
 
 
566
 
    libvlc_instance_t* p_libvlc;
567
 
    HRESULT hr = getVLC(&p_libvlc);
568
 
    if( SUCCEEDED(hr) )
569
 
    {
570
 
        char *psz_uri = NULL;
571
 
        if( SysStringLen(Instance()->getBaseURL()) > 0 )
572
 
        {
573
 
            /*
574
 
            ** if the MRL a relative URL, we should end up with an absolute URL
575
 
            */
576
 
            LPWSTR abs_url = CombineURL(Instance()->getBaseURL(), uri);
577
 
            if( NULL != abs_url )
578
 
            {
579
 
                psz_uri = CStrFromWSTR(CP_UTF8, abs_url, wcslen(abs_url));
580
 
                CoTaskMemFree(abs_url);
581
 
            }
582
 
            else
583
 
            {
584
 
                psz_uri = CStrFromBSTR(CP_UTF8, uri);
585
 
            }
586
 
        }
587
 
        else
588
 
        {
589
 
            /*
590
 
            ** baseURL is empty, assume MRL is absolute
591
 
            */
592
 
            psz_uri = CStrFromBSTR(CP_UTF8, uri);
593
 
        }
594
 
 
595
 
        if( NULL == psz_uri )
596
 
        {
597
 
            return E_OUTOFMEMORY;
598
 
        }
599
 
 
600
 
        int i_options;
601
 
        char **ppsz_options;
602
 
 
603
 
        hr = VLCControl::CreateTargetOptions(CP_UTF8, &options, &ppsz_options, &i_options);
604
 
        if( FAILED(hr) )
605
 
        {
606
 
            CoTaskMemFree(psz_uri);
607
 
            return hr;
608
 
        }
609
 
 
610
 
        char *psz_name = NULL;
611
 
        VARIANT v_name;
612
 
        VariantInit(&v_name);
613
 
        if( SUCCEEDED(VariantChangeType(&v_name, &name, 0, VT_BSTR)) )
614
 
        {
615
 
            if( SysStringLen(V_BSTR(&v_name)) > 0 )
616
 
                psz_name = CStrFromBSTR(CP_UTF8, V_BSTR(&v_name));
617
 
 
618
 
            VariantClear(&v_name);
619
 
        }
620
 
 
621
 
        *item = Instance()->playlist_add_extended_untrusted(psz_uri,
622
 
                    i_options, const_cast<const char **>(ppsz_options));
623
 
 
624
 
        VLCControl::FreeTargetOptions(ppsz_options, i_options);
625
 
        CoTaskMemFree(psz_uri);
626
 
        if( psz_name ) /* XXX Do we even need to check? */
627
 
            CoTaskMemFree(psz_name);
628
 
    }
629
 
    return hr;
630
 
};
631
 
 
632
 
STDMETHODIMP VLCPlaylist::play()
633
 
{
634
 
    Instance()->playlist_play();
635
 
    return S_OK;
636
 
};
637
 
 
638
 
STDMETHODIMP VLCPlaylist::playItem(long item)
639
 
{
640
 
    Instance()->playlist_play_item(item);
641
 
    return S_OK;
642
 
};
643
 
 
644
 
STDMETHODIMP VLCPlaylist::togglePause()
645
 
{
646
 
    libvlc_media_player_t* p_md;
647
 
    HRESULT hr = getMD(&p_md);
648
 
    if( SUCCEEDED(hr) )
649
 
    {
650
 
        libvlc_media_player_pause(p_md);
651
 
    }
652
 
    return hr;
653
 
};
654
 
 
655
 
STDMETHODIMP VLCPlaylist::stop()
656
 
{
657
 
    libvlc_media_player_t *p_md;
658
 
    HRESULT hr = getMD(&p_md);
659
 
    if( SUCCEEDED(hr) )
660
 
    {
661
 
        libvlc_media_player_stop(p_md);
662
 
    }
663
 
    return hr;
664
 
};
665
 
 
666
 
STDMETHODIMP VLCPlaylist::next()
667
 
{
668
 
    Instance()->playlist_next();
669
 
    return S_OK;
670
 
};
671
 
 
672
 
STDMETHODIMP VLCPlaylist::prev()
673
 
{
674
 
    Instance()->playlist_prev();
675
 
    return S_OK;
676
 
};
677
 
 
678
 
STDMETHODIMP VLCPlaylist::clear()
679
 
{
680
 
    Instance()->playlist_clear();
681
 
    return S_OK;
682
 
};
683
 
 
684
 
STDMETHODIMP VLCPlaylist::removeItem(long item)
685
 
{
686
 
    libvlc_instance_t* p_libvlc;
687
 
    HRESULT hr = getVLC(&p_libvlc);
688
 
    if( SUCCEEDED(hr) )
689
 
    {
690
 
        Instance()->playlist_delete_item(item);
691
 
    }
692
 
    return hr;
693
 
};
694
 
 
695
 
STDMETHODIMP VLCPlaylist::get_items(IVLCPlaylistItems** obj)
696
 
{
697
 
    if( NULL == obj )
698
 
        return E_POINTER;
699
 
 
700
 
    *obj = _p_vlcplaylistitems;
701
 
    if( NULL != _p_vlcplaylistitems )
702
 
    {
703
 
        _p_vlcplaylistitems->AddRef();
704
 
        return NOERROR;
705
 
    }
706
 
    return E_OUTOFMEMORY;
707
 
};
708
 
 
709
 
/****************************************************************************/
710
 
 
711
 
STDMETHODIMP VLCSubtitle::get_track(long* spu)
712
 
{
713
 
    if( NULL == spu )
714
 
        return E_POINTER;
715
 
 
716
 
    libvlc_media_player_t *p_md;
717
 
    HRESULT hr = getMD(&p_md);
718
 
    if( SUCCEEDED(hr) )
719
 
    {
720
 
        *spu = libvlc_video_get_spu(p_md);
721
 
    }
722
 
    return hr;
723
 
};
724
 
 
725
 
STDMETHODIMP VLCSubtitle::put_track(long spu)
726
 
{
727
 
    libvlc_media_player_t *p_md;
728
 
    HRESULT hr = getMD(&p_md);
729
 
    if( SUCCEEDED(hr) )
730
 
    {
731
 
        libvlc_video_set_spu(p_md, spu);
732
 
    }
733
 
    return hr;
734
 
};
735
 
 
736
 
STDMETHODIMP VLCSubtitle::get_count(long* spuNumber)
737
 
{
738
 
    if( NULL == spuNumber )
739
 
        return E_POINTER;
740
 
 
741
 
    libvlc_media_player_t *p_md;
742
 
    HRESULT hr = getMD(&p_md);
743
 
    if( SUCCEEDED(hr) )
744
 
    {
745
 
        // get the number of video subtitle available and return it
746
 
        *spuNumber = libvlc_video_get_spu_count(p_md);
747
 
    }
748
 
    return hr;
749
 
};
750
 
 
751
 
 
752
 
STDMETHODIMP VLCSubtitle::description(long nameID, BSTR* name)
753
 
{
754
 
    if( NULL == name )
755
 
       return E_POINTER;
756
 
 
757
 
    libvlc_media_player_t* p_md;
758
 
 
759
 
    HRESULT hr = getMD(&p_md);
760
 
    if( SUCCEEDED(hr) )
761
 
    {
762
 
        int i, i_limit;
763
 
        const char *psz_name;
764
 
        libvlc_track_description_t *p_spuDesc;
765
 
 
766
 
        // get subtitles description
767
 
        p_spuDesc = libvlc_video_get_spu_description(p_md);
768
 
        if( !p_spuDesc )
769
 
            return E_FAIL;
770
 
 
771
 
        // get the number of available subtitle
772
 
        i_limit = libvlc_video_get_spu_count(p_md);
773
 
        if( i_limit < 0 )
774
 
            return E_FAIL;
775
 
 
776
 
        // check if the number given is a good one
777
 
        if ( ( nameID > ( i_limit -1 ) ) || ( nameID < 0 ) )
778
 
            return E_FAIL;
779
 
 
780
 
        // get the good spuDesc
781
 
        for( i = 0 ; i < nameID ; i++ )
782
 
        {
783
 
            p_spuDesc = p_spuDesc->p_next;
784
 
        }
785
 
        // get the subtitle name
786
 
        psz_name = p_spuDesc->psz_name;
787
 
 
788
 
        // return it
789
 
        if( psz_name != NULL )
790
 
        {
791
 
            *name = BSTRFromCStr(CP_UTF8, psz_name);
792
 
            return (NULL == *name) ? E_OUTOFMEMORY : NOERROR;
793
 
        }
794
 
        *name = NULL;
795
 
        return E_FAIL;
796
 
    }
797
 
    return hr;
798
 
};
799
 
 
800
 
/****************************************************************************/
801
 
 
802
 
STDMETHODIMP VLCVideo::get_fullscreen(VARIANT_BOOL* fullscreen)
803
 
{
804
 
    if( NULL == fullscreen )
805
 
        return E_POINTER;
806
 
 
807
 
    libvlc_media_player_t *p_md;
808
 
    HRESULT hr = getMD(&p_md);
809
 
    if( SUCCEEDED(hr) )
810
 
    {
811
 
        *fullscreen = varbool( libvlc_get_fullscreen(p_md) );
812
 
    }
813
 
    return hr;
814
 
};
815
 
 
816
 
STDMETHODIMP VLCVideo::put_fullscreen(VARIANT_BOOL fullscreen)
817
 
{
818
 
    libvlc_media_player_t *p_md;
819
 
    HRESULT hr = getMD(&p_md);
820
 
    if( SUCCEEDED(hr) )
821
 
    {
822
 
        libvlc_set_fullscreen(p_md, VARIANT_FALSE != fullscreen);
823
 
    }
824
 
    return hr;
825
 
};
826
 
 
827
 
STDMETHODIMP VLCVideo::get_width(long* width)
828
 
{
829
 
    if( NULL == width )
830
 
        return E_POINTER;
831
 
 
832
 
    libvlc_media_player_t *p_md;
833
 
    HRESULT hr = getMD(&p_md);
834
 
    if( SUCCEEDED(hr) )
835
 
    {
836
 
        *width = libvlc_video_get_width(p_md);
837
 
    }
838
 
    return hr;
839
 
};
840
 
 
841
 
STDMETHODIMP VLCVideo::get_height(long* height)
842
 
{
843
 
    if( NULL == height )
844
 
        return E_POINTER;
845
 
 
846
 
    libvlc_media_player_t *p_md;
847
 
    HRESULT hr = getMD(&p_md);
848
 
    if( SUCCEEDED(hr) )
849
 
    {
850
 
        *height = libvlc_video_get_height(p_md);
851
 
    }
852
 
    return hr;
853
 
};
854
 
 
855
 
STDMETHODIMP VLCVideo::get_aspectRatio(BSTR* aspect)
856
 
{
857
 
    if( NULL == aspect )
858
 
        return E_POINTER;
859
 
 
860
 
    libvlc_media_player_t *p_md;
861
 
    HRESULT hr = getMD(&p_md);
862
 
    if( SUCCEEDED(hr) )
863
 
    {
864
 
        char *psz_aspect = libvlc_video_get_aspect_ratio(p_md);
865
 
 
866
 
        if( !psz_aspect )
867
 
        {
868
 
            *aspect = BSTRFromCStr(CP_UTF8, psz_aspect);
869
 
            if( NULL == *aspect )
870
 
                hr = E_OUTOFMEMORY;
871
 
        } else if( NULL == psz_aspect)
872
 
                hr = E_OUTOFMEMORY;
873
 
        free( psz_aspect );
874
 
    }
875
 
    return hr;
876
 
};
877
 
 
878
 
STDMETHODIMP VLCVideo::put_aspectRatio(BSTR aspect)
879
 
{
880
 
    if( NULL == aspect )
881
 
        return E_POINTER;
882
 
 
883
 
    libvlc_media_player_t *p_md;
884
 
    HRESULT hr = getMD(&p_md);
885
 
    if( SUCCEEDED(hr) )
886
 
    {
887
 
        char *psz_aspect = CStrFromBSTR(CP_UTF8, aspect);
888
 
        if( !psz_aspect )
889
 
        {
890
 
            return E_OUTOFMEMORY;
891
 
        }
892
 
 
893
 
        libvlc_video_set_aspect_ratio(p_md, psz_aspect);
894
 
 
895
 
        CoTaskMemFree(psz_aspect);
896
 
    }
897
 
    return hr;
898
 
};
899
 
 
900
 
STDMETHODIMP VLCVideo::get_subtitle(long* spu)
901
 
{
902
 
    if( NULL == spu )
903
 
        return E_POINTER;
904
 
 
905
 
    libvlc_media_player_t *p_md;
906
 
    HRESULT hr = getMD(&p_md);
907
 
    if( SUCCEEDED(hr) )
908
 
    {
909
 
        *spu = libvlc_video_get_spu(p_md);
910
 
    }
911
 
    return hr;
912
 
};
913
 
 
914
 
STDMETHODIMP VLCVideo::put_subtitle(long spu)
915
 
{
916
 
    libvlc_media_player_t *p_md;
917
 
    HRESULT hr = getMD(&p_md);
918
 
    if( SUCCEEDED(hr) )
919
 
    {
920
 
        libvlc_video_set_spu(p_md, spu);
921
 
    }
922
 
    return hr;
923
 
};
924
 
 
925
 
STDMETHODIMP VLCVideo::get_crop(BSTR* geometry)
926
 
{
927
 
    if( NULL == geometry )
928
 
        return E_POINTER;
929
 
 
930
 
    libvlc_media_player_t *p_md;
931
 
    HRESULT hr = getMD(&p_md);
932
 
    if( SUCCEEDED(hr) )
933
 
    {
934
 
        char *psz_geometry = libvlc_video_get_crop_geometry(p_md);
935
 
        if( !psz_geometry )
936
 
        {
937
 
            *geometry = BSTRFromCStr(CP_UTF8, psz_geometry);
938
 
            if( !geometry )
939
 
                hr = E_OUTOFMEMORY;
940
 
        } else if( !psz_geometry )
941
 
                hr = E_OUTOFMEMORY;
942
 
        free( psz_geometry );
943
 
    }
944
 
    return hr;
945
 
};
946
 
 
947
 
STDMETHODIMP VLCVideo::put_crop(BSTR geometry)
948
 
{
949
 
    if( NULL == geometry )
950
 
        return E_POINTER;
951
 
 
952
 
    if( 0 == SysStringLen(geometry) )
953
 
        return E_INVALIDARG;
954
 
 
955
 
    libvlc_media_player_t *p_md;
956
 
    HRESULT hr = getMD(&p_md);
957
 
    if( SUCCEEDED(hr) )
958
 
    {
959
 
        char *psz_geometry = CStrFromBSTR(CP_UTF8, geometry);
960
 
        if( !psz_geometry )
961
 
        {
962
 
            return E_OUTOFMEMORY;
963
 
        }
964
 
 
965
 
        libvlc_video_set_crop_geometry(p_md, psz_geometry);
966
 
 
967
 
        CoTaskMemFree(psz_geometry);
968
 
    }
969
 
    return hr;
970
 
};
971
 
 
972
 
STDMETHODIMP VLCVideo::get_teletext(long* page)
973
 
{
974
 
    if( NULL == page )
975
 
        return E_POINTER;
976
 
 
977
 
    libvlc_media_player_t *p_md;
978
 
    HRESULT hr = getMD(&p_md);
979
 
    if( SUCCEEDED(hr) )
980
 
    {
981
 
        *page = libvlc_video_get_teletext(p_md);
982
 
    }
983
 
 
984
 
    return hr;
985
 
};
986
 
 
987
 
STDMETHODIMP VLCVideo::put_teletext(long page)
988
 
{
989
 
    libvlc_media_player_t *p_md;
990
 
    HRESULT hr = getMD(&p_md);
991
 
 
992
 
    if( SUCCEEDED(hr) )
993
 
    {
994
 
        libvlc_video_set_teletext(p_md, page);
995
 
    }
996
 
    return hr;
997
 
};
998
 
 
999
 
STDMETHODIMP VLCVideo::takeSnapshot(LPPICTUREDISP* picture)
1000
 
{
1001
 
    if( NULL == picture )
1002
 
        return E_POINTER;
1003
 
 
1004
 
    libvlc_media_player_t *p_md;
1005
 
    HRESULT hr = getMD(&p_md);
1006
 
    if( SUCCEEDED(hr) )
1007
 
    {
1008
 
        static int uniqueId = 0;
1009
 
        TCHAR path[MAX_PATH+1];
1010
 
 
1011
 
        int pathlen = GetTempPath(MAX_PATH-24, path);
1012
 
        if( (0 == pathlen) || (pathlen > (MAX_PATH-24)) )
1013
 
            return E_FAIL;
1014
 
 
1015
 
        /* check temp directory path by openning it */
1016
 
        {
1017
 
            HANDLE dirHandle = CreateFile(path, GENERIC_READ,
1018
 
                       FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
1019
 
                       NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
1020
 
            if( INVALID_HANDLE_VALUE == dirHandle )
1021
 
            {
1022
 
                Instance()->setErrorInfo(IID_IVLCVideo,
1023
 
                        "Invalid temporary directory for snapshot images, check values of TMP, TEMP envars.");
1024
 
                return E_FAIL;
1025
 
            }
1026
 
            else
1027
 
            {
1028
 
                BY_HANDLE_FILE_INFORMATION bhfi;
1029
 
                BOOL res = GetFileInformationByHandle(dirHandle, &bhfi);
1030
 
                CloseHandle(dirHandle);
1031
 
                if( !res || !(bhfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) )
1032
 
                {
1033
 
                    Instance()->setErrorInfo(IID_IVLCVideo,
1034
 
                            "Invalid temporary directory for snapshot images, check values of TMP, TEMP envars.");
1035
 
                    return E_FAIL;
1036
 
                }
1037
 
            }
1038
 
        }
1039
 
 
1040
 
        TCHAR filepath[MAX_PATH+1];
1041
 
 
1042
 
        _stprintf(filepath, TEXT("%sAXVLC%lXS%lX.bmp"),
1043
 
                 path, GetCurrentProcessId(), ++uniqueId);
1044
 
 
1045
 
#ifdef _UNICODE
1046
 
        /* reuse path storage for UTF8 string */
1047
 
        char *psz_filepath = (char *)path;
1048
 
        WCHAR* wpath = filepath;
1049
 
#else
1050
 
        char *psz_filepath = path;
1051
 
        /* first convert to unicode using current code page */
1052
 
        WCHAR wpath[MAX_PATH+1];
1053
 
        if( 0 == MultiByteToWideChar(CP_ACP, 0, filepath, -1,
1054
 
                                     wpath, sizeof(wpath)/sizeof(WCHAR)) )
1055
 
            return E_FAIL;
1056
 
#endif
1057
 
        /* convert to UTF8 */
1058
 
        pathlen = WideCharToMultiByte(CP_UTF8, 0, wpath, -1,
1059
 
                                      psz_filepath, sizeof(path), NULL, NULL);
1060
 
        // fail if path is 0 or too short (i.e pathlen is the same as
1061
 
        // storage size)
1062
 
 
1063
 
        if( (0 == pathlen) || (sizeof(path) == pathlen) )
1064
 
            return E_FAIL;
1065
 
 
1066
 
        /* take snapshot into file */
1067
 
        if( libvlc_video_take_snapshot(p_md, 0, psz_filepath, 0, 0) == 0 )
1068
 
        {
1069
 
            /* open snapshot file */
1070
 
            HANDLE snapPic = LoadImage(NULL, filepath, IMAGE_BITMAP, 0, 0,
1071
 
                                       LR_CREATEDIBSECTION|LR_LOADFROMFILE);
1072
 
            if( snapPic )
1073
 
            {
1074
 
                PICTDESC snapDesc;
1075
 
 
1076
 
                snapDesc.cbSizeofstruct = sizeof(PICTDESC);
1077
 
                snapDesc.picType        = PICTYPE_BITMAP;
1078
 
                snapDesc.bmp.hbitmap    = (HBITMAP)snapPic;
1079
 
                snapDesc.bmp.hpal       = NULL;
1080
 
 
1081
 
                hr = OleCreatePictureIndirect(&snapDesc, IID_IPictureDisp,
1082
 
                                              TRUE, (LPVOID*)picture);
1083
 
                if( FAILED(hr) )
1084
 
                {
1085
 
                    *picture = NULL;
1086
 
                    DeleteObject(snapPic);
1087
 
                }
1088
 
            }
1089
 
            DeleteFile(filepath);
1090
 
        }
1091
 
    }
1092
 
    return hr;
1093
 
};
1094
 
 
1095
 
STDMETHODIMP VLCVideo::toggleFullscreen()
1096
 
{
1097
 
    libvlc_media_player_t *p_md;
1098
 
    HRESULT hr = getMD(&p_md);
1099
 
    if( SUCCEEDED(hr) )
1100
 
    {
1101
 
        Instance()->toggleFullscreen();
1102
 
    }
1103
 
    return hr;
1104
 
};
1105
 
 
1106
 
STDMETHODIMP VLCVideo::toggleTeletext()
1107
 
{
1108
 
    libvlc_media_player_t *p_md;
1109
 
    HRESULT hr = getMD(&p_md);
1110
 
    if( SUCCEEDED(hr) )
1111
 
    {
1112
 
        libvlc_toggle_teletext(p_md);
1113
 
    }
1114
 
    return hr;
1115
 
};
1116
 
 
1117
 
STDMETHODIMP VLCVideo::get_marquee(IVLCMarquee** obj)
1118
 
{
1119
 
    return object_get(obj,_p_vlcmarquee);
1120
 
}
1121
 
 
1122
 
STDMETHODIMP VLCVideo::get_logo(IVLCLogo** obj)
1123
 
{
1124
 
    return object_get(obj,_p_vlclogo);
1125
 
}
1126
 
 
1127
 
STDMETHODIMP VLCVideo::get_deinterlace(IVLCDeinterlace** obj)
1128
 
{
1129
 
    return object_get(obj,_p_vlcdeint);
1130
 
}
1131
 
 
1132
 
/****************************************************************************/
1133
 
 
1134
 
HRESULT VLCLogo::do_put_int(unsigned idx, LONG val)
1135
 
{
1136
 
    libvlc_media_player_t *p_md;
1137
 
    HRESULT hr = getMD(&p_md);
1138
 
    if( SUCCEEDED(hr) )
1139
 
    {
1140
 
        libvlc_video_set_logo_int(p_md, idx, val);
1141
 
    }
1142
 
    return hr;
1143
 
}
1144
 
 
1145
 
HRESULT VLCLogo::do_get_int(unsigned idx, LONG *val)
1146
 
{
1147
 
    if( NULL == val )
1148
 
        return E_POINTER;
1149
 
 
1150
 
    libvlc_media_player_t *p_md;
1151
 
    HRESULT hr = getMD(&p_md);
1152
 
    if( SUCCEEDED(hr) )
1153
 
    {
1154
 
        *val = libvlc_video_get_logo_int(p_md, idx);
1155
 
    }
1156
 
    return hr;
1157
 
}
1158
 
 
1159
 
STDMETHODIMP VLCLogo::file(BSTR fname)
1160
 
{
1161
 
    libvlc_media_player_t *p_md;
1162
 
    HRESULT hr = getMD(&p_md);
1163
 
 
1164
 
    char *n = CStrFromBSTR(CP_UTF8, fname);
1165
 
    if( !n ) hr = E_OUTOFMEMORY;
1166
 
 
1167
 
    if( SUCCEEDED(hr) )
1168
 
    {
1169
 
        libvlc_video_set_logo_string(p_md, libvlc_logo_file, n);
1170
 
    }
1171
 
 
1172
 
    CoTaskMemFree(n);
1173
 
    return hr;
1174
 
}
1175
 
 
1176
 
STDMETHODIMP VLCLogo::get_position(BSTR* val)
1177
 
{
1178
 
    if( NULL == val )
1179
 
        return E_POINTER;
1180
 
 
1181
 
    LONG i;
1182
 
    HRESULT hr = do_get_int(libvlc_logo_position, &i);
1183
 
 
1184
 
    if(SUCCEEDED(hr))
1185
 
        *val = BSTRFromCStr(CP_UTF8, position_bynumber(i));
1186
 
 
1187
 
    return hr;
1188
 
}
1189
 
 
1190
 
STDMETHODIMP VLCLogo::put_position(BSTR val)
1191
 
{
1192
 
    char *n = CStrFromBSTR(CP_UTF8, val);
1193
 
    if( !n ) return E_OUTOFMEMORY;
1194
 
 
1195
 
    size_t i;
1196
 
    HRESULT hr;
1197
 
    if( position_byname( n, i ) )
1198
 
        hr = do_put_int(libvlc_logo_position,i);
1199
 
    else
1200
 
        hr = E_INVALIDARG;
1201
 
 
1202
 
    CoTaskMemFree(n);
1203
 
    return hr;
1204
 
}
1205
 
 
1206
 
/****************************************************************************/
1207
 
 
1208
 
VLCControl2::VLCControl2(VLCPlugin *p_instance) :
1209
 
    _p_instance(p_instance),
1210
 
    _p_typeinfo(NULL),
1211
 
    _p_vlcaudio(new VLCAudio(p_instance)),
1212
 
    _p_vlcinput(new VLCInput(p_instance)),
1213
 
    _p_vlcplaylist(new VLCPlaylist(p_instance)),
1214
 
    _p_vlcsubtitle(new VLCSubtitle(p_instance)),
1215
 
    _p_vlcvideo(new VLCVideo(p_instance))
1216
 
{
1217
 
}
1218
 
 
1219
 
VLCControl2::~VLCControl2()
1220
 
{
1221
 
    delete _p_vlcvideo;
1222
 
    delete _p_vlcsubtitle;
1223
 
    delete _p_vlcplaylist;
1224
 
    delete _p_vlcinput;
1225
 
    delete _p_vlcaudio;
1226
 
    if( _p_typeinfo )
1227
 
        _p_typeinfo->Release();
1228
 
};
1229
 
 
1230
 
HRESULT VLCControl2::loadTypeInfo(void)
1231
 
{
1232
 
    HRESULT hr = NOERROR;
1233
 
    if( NULL == _p_typeinfo )
1234
 
    {
1235
 
        ITypeLib *p_typelib;
1236
 
 
1237
 
        hr = _p_instance->getTypeLib(LOCALE_USER_DEFAULT, &p_typelib);
1238
 
        if( SUCCEEDED(hr) )
1239
 
        {
1240
 
            hr = p_typelib->GetTypeInfoOfGuid(IID_IVLCControl2, &_p_typeinfo);
1241
 
            if( FAILED(hr) )
1242
 
            {
1243
 
                _p_typeinfo = NULL;
1244
 
            }
1245
 
            p_typelib->Release();
1246
 
        }
1247
 
    }
1248
 
    return hr;
1249
 
};
1250
 
 
1251
 
STDMETHODIMP VLCControl2::GetTypeInfoCount(UINT* pctInfo)
1252
 
{
1253
 
    if( NULL == pctInfo )
1254
 
        return E_INVALIDARG;
1255
 
 
1256
 
    if( SUCCEEDED(loadTypeInfo()) )
1257
 
        *pctInfo = 1;
1258
 
    else
1259
 
        *pctInfo = 0;
1260
 
 
1261
 
    return NOERROR;
1262
 
};
1263
 
 
1264
 
STDMETHODIMP VLCControl2::GetTypeInfo(UINT iTInfo, LCID lcid, LPTYPEINFO* ppTInfo)
1265
 
{
1266
 
    if( NULL == ppTInfo )
1267
 
        return E_INVALIDARG;
1268
 
 
1269
 
    if( SUCCEEDED(loadTypeInfo()) )
1270
 
    {
1271
 
        _p_typeinfo->AddRef();
1272
 
        *ppTInfo = _p_typeinfo;
1273
 
        return NOERROR;
1274
 
    }
1275
 
    *ppTInfo = NULL;
1276
 
    return E_NOTIMPL;
1277
 
};
1278
 
 
1279
 
STDMETHODIMP VLCControl2::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames,
1280
 
        UINT cNames, LCID lcid, DISPID* rgDispID)
1281
 
{
1282
 
    if( SUCCEEDED(loadTypeInfo()) )
1283
 
    {
1284
 
        return DispGetIDsOfNames(_p_typeinfo, rgszNames, cNames, rgDispID);
1285
 
    }
1286
 
    return E_NOTIMPL;
1287
 
};
1288
 
 
1289
 
STDMETHODIMP VLCControl2::Invoke(DISPID dispIdMember, REFIID riid,
1290
 
        LCID lcid, WORD wFlags, DISPPARAMS* pDispParams,
1291
 
        VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
1292
 
{
1293
 
    if( SUCCEEDED(loadTypeInfo()) )
1294
 
    {
1295
 
        return DispInvoke(this, _p_typeinfo, dispIdMember, wFlags, pDispParams,
1296
 
                pVarResult, pExcepInfo, puArgErr);
1297
 
    }
1298
 
    return E_NOTIMPL;
1299
 
};
1300
 
 
1301
 
STDMETHODIMP VLCControl2::get_AutoLoop(VARIANT_BOOL *autoloop)
1302
 
{
1303
 
    if( NULL == autoloop )
1304
 
        return E_POINTER;
1305
 
 
1306
 
    *autoloop = varbool( _p_instance->getAutoLoop() );
1307
 
    return S_OK;
1308
 
};
1309
 
 
1310
 
STDMETHODIMP VLCControl2::put_AutoLoop(VARIANT_BOOL autoloop)
1311
 
{
1312
 
    _p_instance->setAutoLoop((VARIANT_FALSE != autoloop) ? TRUE: FALSE);
1313
 
    return S_OK;
1314
 
};
1315
 
 
1316
 
STDMETHODIMP VLCControl2::get_AutoPlay(VARIANT_BOOL *autoplay)
1317
 
{
1318
 
    if( NULL == autoplay )
1319
 
        return E_POINTER;
1320
 
 
1321
 
    *autoplay = varbool( _p_instance->getAutoPlay() );
1322
 
    return S_OK;
1323
 
};
1324
 
 
1325
 
STDMETHODIMP VLCControl2::put_AutoPlay(VARIANT_BOOL autoplay)
1326
 
{
1327
 
    _p_instance->setAutoPlay((VARIANT_FALSE != autoplay) ? TRUE: FALSE);
1328
 
    return S_OK;
1329
 
};
1330
 
 
1331
 
STDMETHODIMP VLCControl2::get_BaseURL(BSTR *url)
1332
 
{
1333
 
    if( NULL == url )
1334
 
        return E_POINTER;
1335
 
 
1336
 
    *url = SysAllocStringLen(_p_instance->getBaseURL(),
1337
 
                SysStringLen(_p_instance->getBaseURL()));
1338
 
    return NOERROR;
1339
 
};
1340
 
 
1341
 
STDMETHODIMP VLCControl2::put_BaseURL(BSTR mrl)
1342
 
{
1343
 
    _p_instance->setBaseURL(mrl);
1344
 
 
1345
 
    return S_OK;
1346
 
};
1347
 
 
1348
 
STDMETHODIMP VLCControl2::get_MRL(BSTR *mrl)
1349
 
{
1350
 
    if( NULL == mrl )
1351
 
        return E_POINTER;
1352
 
 
1353
 
    *mrl = SysAllocStringLen(_p_instance->getMRL(),
1354
 
                SysStringLen(_p_instance->getMRL()));
1355
 
    return NOERROR;
1356
 
};
1357
 
 
1358
 
STDMETHODIMP VLCControl2::put_MRL(BSTR mrl)
1359
 
{
1360
 
    _p_instance->setMRL(mrl);
1361
 
 
1362
 
    return S_OK;
1363
 
};
1364
 
 
1365
 
 
1366
 
STDMETHODIMP VLCControl2::get_Toolbar(VARIANT_BOOL *visible)
1367
 
{
1368
 
    if( NULL == visible )
1369
 
        return E_POINTER;
1370
 
 
1371
 
    /*
1372
 
     * Note to developers
1373
 
     *
1374
 
     * Returning the _b_toolbar is closer to the method specification.
1375
 
     * But returning True when toolbar is not implemented so not displayed
1376
 
     * could be bad for ActiveX users which rely on this value to show their
1377
 
     * own toolbar if not provided by the ActiveX.
1378
 
     *
1379
 
     * This is the reason why FALSE is returned, until toolbar get implemented.
1380
 
     */
1381
 
 
1382
 
    /* DISABLED for now */
1383
 
    //  *visible = varbool( _p_instance->getShowToolbar() );
1384
 
 
1385
 
    *visible = VARIANT_FALSE;
1386
 
 
1387
 
    return S_OK;
1388
 
};
1389
 
 
1390
 
STDMETHODIMP VLCControl2::put_Toolbar(VARIANT_BOOL visible)
1391
 
{
1392
 
    _p_instance->setShowToolbar((VARIANT_FALSE != visible) ? TRUE: FALSE);
1393
 
    return S_OK;
1394
 
};
1395
 
 
1396
 
 
1397
 
STDMETHODIMP VLCControl2::get_StartTime(long *seconds)
1398
 
{
1399
 
    if( NULL == seconds )
1400
 
        return E_POINTER;
1401
 
 
1402
 
    *seconds = _p_instance->getStartTime();
1403
 
    return S_OK;
1404
 
};
1405
 
 
1406
 
STDMETHODIMP VLCControl2::put_StartTime(long seconds)
1407
 
{
1408
 
    _p_instance->setStartTime(seconds);
1409
 
    return S_OK;
1410
 
};
1411
 
 
1412
 
STDMETHODIMP VLCControl2::get_VersionInfo(BSTR *version)
1413
 
{
1414
 
    if( NULL == version )
1415
 
        return E_POINTER;
1416
 
 
1417
 
    const char *versionStr = libvlc_get_version();
1418
 
    if( NULL != versionStr )
1419
 
    {
1420
 
        *version = BSTRFromCStr(CP_UTF8, versionStr);
1421
 
 
1422
 
        return (NULL == *version) ? E_OUTOFMEMORY : NOERROR;
1423
 
    }
1424
 
    *version = NULL;
1425
 
    return E_FAIL;
1426
 
};
1427
 
 
1428
 
STDMETHODIMP VLCControl2::get_Visible(VARIANT_BOOL *isVisible)
1429
 
{
1430
 
    if( NULL == isVisible )
1431
 
        return E_POINTER;
1432
 
 
1433
 
    *isVisible = varbool( _p_instance->getVisible() );
1434
 
 
1435
 
    return S_OK;
1436
 
};
1437
 
 
1438
 
STDMETHODIMP VLCControl2::put_Visible(VARIANT_BOOL isVisible)
1439
 
{
1440
 
    _p_instance->setVisible(isVisible != VARIANT_FALSE);
1441
 
    return S_OK;
1442
 
};
1443
 
 
1444
 
STDMETHODIMP VLCControl2::get_Volume(long *volume)
1445
 
{
1446
 
    if( NULL == volume )
1447
 
        return E_POINTER;
1448
 
 
1449
 
    *volume  = _p_instance->getVolume();
1450
 
    return S_OK;
1451
 
};
1452
 
 
1453
 
STDMETHODIMP VLCControl2::put_Volume(long volume)
1454
 
{
1455
 
    _p_instance->setVolume(volume);
1456
 
    return S_OK;
1457
 
};
1458
 
 
1459
 
STDMETHODIMP VLCControl2::get_BackColor(OLE_COLOR *backcolor)
1460
 
{
1461
 
    if( NULL == backcolor )
1462
 
        return E_POINTER;
1463
 
 
1464
 
    *backcolor  = _p_instance->getBackColor();
1465
 
    return S_OK;
1466
 
};
1467
 
 
1468
 
STDMETHODIMP VLCControl2::put_BackColor(OLE_COLOR backcolor)
1469
 
{
1470
 
    _p_instance->setBackColor(backcolor);
1471
 
    return S_OK;
1472
 
};
1473
 
 
1474
 
STDMETHODIMP VLCControl2::get_audio(IVLCAudio** obj)
1475
 
{
1476
 
    return object_get(obj,_p_vlcaudio);
1477
 
}
1478
 
 
1479
 
STDMETHODIMP VLCControl2::get_input(IVLCInput** obj)
1480
 
{
1481
 
    return object_get(obj,_p_vlcinput);
1482
 
}
1483
 
 
1484
 
STDMETHODIMP VLCControl2::get_playlist(IVLCPlaylist** obj)
1485
 
{
1486
 
    return object_get(obj,_p_vlcplaylist);
1487
 
}
1488
 
 
1489
 
STDMETHODIMP VLCControl2::get_subtitle(IVLCSubtitle** obj)
1490
 
{
1491
 
    return object_get(obj,_p_vlcsubtitle);
1492
 
}
1493
 
 
1494
 
STDMETHODIMP VLCControl2::get_video(IVLCVideo** obj)
1495
 
{
1496
 
    return object_get(obj,_p_vlcvideo);
1497
 
}