vlm.c 23.6 KB
Newer Older
Clément Stenac's avatar
Clément Stenac committed
1 2 3
/*****************************************************************************
 * vlm.c: libvlc new API VLM handling functions
 *****************************************************************************
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
4
 * Copyright (C) 2005 VLC authors and VideoLAN
5
 * $Id$
Clément Stenac's avatar
Clément Stenac committed
6 7 8
 *
 * Authors: Clément Stenac <zorglub@videolan.org>
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
9 10 11
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
Clément Stenac's avatar
Clément Stenac committed
12 13 14 15
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
16 17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
Clément Stenac's avatar
Clément Stenac committed
18
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
19 20 21
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
Clément Stenac's avatar
Clément Stenac committed
22 23
 *****************************************************************************/

24 25 26 27
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

Clément Stenac's avatar
Clément Stenac committed
28
#include <vlc/libvlc.h>
29
#include <vlc/libvlc_vlm.h>
30
#include <vlc_es.h>
Clément Stenac's avatar
Clément Stenac committed
31
#include <vlc_input.h>
32
#include <vlc_vlm.h>
33
#include <assert.h>
Clément Stenac's avatar
Clément Stenac committed
34

35 36
#include "libvlc_internal.h"

37 38 39 40
/* VLM events callback. Transmit to libvlc */
static int VlmEvent( vlc_object_t *p_this, const char * name,
                     vlc_value_t old_val, vlc_value_t newval, void *param )
{
41 42
    VLC_UNUSED(p_this);
    VLC_UNUSED(name);
43
    VLC_UNUSED(old_val);
44 45 46 47
    vlm_event_t *event = (vlm_event_t*)newval.p_address;
    libvlc_event_manager_t *p_event_manager = (libvlc_event_manager_t *) param;
    libvlc_event_t libvlc_event;

48
    libvlc_event.u.vlm_media_event.psz_instance_name = NULL;
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
    libvlc_event.u.vlm_media_event.psz_media_name = event->psz_name;

    switch( event->i_type )
    {
    case VLM_EVENT_MEDIA_ADDED:
        libvlc_event.type = libvlc_VlmMediaAdded;
        break;
    case VLM_EVENT_MEDIA_REMOVED:
        libvlc_event.type = libvlc_VlmMediaRemoved;
        break;
    case VLM_EVENT_MEDIA_CHANGED:
        libvlc_event.type = libvlc_VlmMediaChanged;
        break;
    case VLM_EVENT_MEDIA_INSTANCE_STARTED:
        libvlc_event.type = libvlc_VlmMediaInstanceStarted;
        break;
    case VLM_EVENT_MEDIA_INSTANCE_STOPPED:
        libvlc_event.type = libvlc_VlmMediaInstanceStopped;
        break;
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
    case VLM_EVENT_MEDIA_INSTANCE_STATE:
        libvlc_event.u.vlm_media_event.psz_instance_name =
            event->psz_instance_name;
        switch( event->input_state )
        {
        case INIT_S:
            libvlc_event.type = libvlc_VlmMediaInstanceStatusInit;
            break;
        case OPENING_S:
            libvlc_event.type =
                libvlc_VlmMediaInstanceStatusOpening;
            break;
        case PLAYING_S:
            libvlc_event.type =
                libvlc_VlmMediaInstanceStatusPlaying;
            break;
        case PAUSE_S:
            libvlc_event.type = libvlc_VlmMediaInstanceStatusPause;
            break;
        case END_S:
            libvlc_event.type = libvlc_VlmMediaInstanceStatusEnd;
            break;
        case ERROR_S:
            libvlc_event.type = libvlc_VlmMediaInstanceStatusError;
            break;
        default:
            return 0;
        }
        break;
    default:
        return 0;
99 100 101 102
    }
    libvlc_event_send( p_event_manager, &libvlc_event );
    return 0;
}
103

104
void libvlc_vlm_release( libvlc_instance_t *p_instance )
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
{
    vlm_t *p_vlm = p_instance->libvlc_vlm.p_vlm;
    if( !p_instance->libvlc_vlm.p_vlm )
        return;
    /* We need to remove medias in order to receive events */
    vlm_Control( p_vlm, VLM_CLEAR_MEDIAS );
    vlm_Control( p_vlm, VLM_CLEAR_SCHEDULES );

    var_DelCallback( (vlc_object_t *)p_vlm, "intf-event", VlmEvent,
                     p_instance->libvlc_vlm.p_event_manager );
    p_instance->libvlc_vlm.pf_release = NULL;
    libvlc_event_manager_release( p_instance->libvlc_vlm.p_event_manager );
    p_instance->libvlc_vlm.p_event_manager = NULL;
    vlm_Delete( p_vlm );
    p_instance->libvlc_vlm.p_vlm = NULL;
120
    libvlc_release( p_instance );
121 122
}

123
static int libvlc_vlm_init( libvlc_instance_t *p_instance )
124
{
125
    if( !p_instance->libvlc_vlm.p_event_manager )
126
    {
127
        p_instance->libvlc_vlm.p_event_manager =
128
            libvlc_event_manager_new( p_instance->libvlc_vlm.p_vlm );
129 130
        if( unlikely(p_instance->libvlc_vlm.p_event_manager == NULL) )
            return VLC_ENOMEM;
131 132
    }

133
    if( !p_instance->libvlc_vlm.p_vlm )
134
    {
135 136
        p_instance->libvlc_vlm.p_vlm = vlm_New( p_instance->p_libvlc_int );
        if( !p_instance->libvlc_vlm.p_vlm )
137
        {
138
            libvlc_printerr( "VLM not supported or out of memory" );
139 140
            return VLC_EGENERIC;
        }
141 142
        var_AddCallback( (vlc_object_t *)p_instance->libvlc_vlm.p_vlm,
                         "intf-event", VlmEvent,
143
                         p_instance->libvlc_vlm.p_event_manager );
144
        p_instance->libvlc_vlm.pf_release = libvlc_vlm_release;
145
        libvlc_retain( p_instance );
146
    }
147

148 149
    return VLC_SUCCESS;
}
150

151 152 153 154 155 156
#define VLM_RET(p,ret) do { \
    if( libvlc_vlm_init( p_instance ) ) \
        return (ret); \
    (p) = p_instance->libvlc_vlm.p_vlm; \
  } while(0)

157 158
static vlm_media_instance_t *
libvlc_vlm_get_media_instance( libvlc_instance_t *p_instance,
159
                               const char *psz_name, int i_minstance_idx )
160 161 162 163 164 165 166 167 168 169
{
    vlm_t *p_vlm;
    vlm_media_instance_t **pp_minstance;
    vlm_media_instance_t *p_minstance;
    int i_minstance;
    int64_t id;

    VLM_RET(p_vlm, NULL);

    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) ||
170 171
        vlm_Control( p_vlm, VLM_GET_MEDIA_INSTANCES, id, &pp_minstance,
                     &i_minstance ) )
172
    {
173
        libvlc_printerr( "%s: media instances not found", psz_name );
174 175 176 177 178 179 180 181 182 183 184 185 186 187
        return NULL;
    }
    p_minstance = NULL;
    if( i_minstance_idx >= 0 && i_minstance_idx < i_minstance )
    {
        p_minstance = pp_minstance[i_minstance_idx];
        TAB_REMOVE( i_minstance, pp_minstance, p_minstance );
    }
    while( i_minstance > 0 )
        vlm_media_instance_Delete( pp_minstance[--i_minstance] );
    TAB_CLEAN( i_minstance, pp_minstance );
    return p_minstance;
}

188 189 190 191 192 193 194
/* local function to be used in libvlc_vlm_show_media only */
static char* recurse_answer( vlm_message_t *p_answer, const char* psz_delim,
                             const int i_list ) {
    char* psz_childdelim = NULL;
    char* psz_nametag = NULL;
    char* psz_response = strdup( "" );
    int i_success = 0;
195

196 197 198
    vlm_message_t *aw_child, **paw_child;

    i_success = asprintf( &psz_childdelim, "%s\t", psz_delim);
199 200
    if( i_success == -1 )
        return psz_response;
201

202 203 204
    paw_child = p_answer->child;
    aw_child = *( paw_child );
    /* Iterate over children */
205
    for( int i = 0; i < p_answer->i_child; i++ )
206
    {
207
        char *psz_tmp;
208 209 210 211 212 213 214
        /* Spare comma if it is the last element */
        char c_comma = ',';
        if( i == (p_answer->i_child - 1) )
            c_comma = ' ';

        /* Append name of child node, if not in a list */
        if( !i_list )
215
        {
Rémi Duraffort's avatar
Rémi Duraffort committed
216
            i_success = asprintf( &psz_tmp, "%s\"%s\": ",
217 218
                          psz_response, aw_child->psz_name );
            if( i_success == -1 ) break;
Rémi Duraffort's avatar
Rémi Duraffort committed
219 220
            free( psz_response );
            psz_response = psz_tmp;
221
        }
222

223 224 225 226 227 228 229
        /* If child node has children, */
        if( aw_child->i_child )
        {
            /* If the parent node is a list (hence the child node is
             * inside a list), create a property of its name as if it
             * had a name value node
             */
230
            free( psz_nametag );
231
            if( i_list )
232
            {
233 234
                i_success = asprintf( &psz_nametag, "\"name\": \"%s\",%s",
                              aw_child->psz_name, psz_childdelim );
235 236 237 238 239
                if( i_success == -1 )
                {
                    psz_nametag = NULL;
                    break;
                }
240
            }
241 242 243 244 245 246 247 248 249 250 251
            else
            {
                psz_nametag = strdup( "" );
            }
            /* If the child is a list itself, format it accordingly and
             * recurse through the child's children, telling them that
             * they are inside a list.
             */
            if( strcmp( aw_child->psz_name, "media" ) == 0 ||
                strcmp( aw_child->psz_name, "inputs" ) == 0 ||
                strcmp( aw_child->psz_name, "options" ) == 0 )
252
            {
253
                char *psz_recurse = recurse_answer( aw_child, psz_childdelim, 1 );
Rémi Duraffort's avatar
Rémi Duraffort committed
254 255
                i_success = asprintf( &psz_tmp, "%s[%s%s%s]%c%s",
                                      psz_response, psz_childdelim, psz_recurse,
256
                                      psz_delim, c_comma, psz_delim );
Rémi Duraffort's avatar
Rémi Duraffort committed
257
                free( psz_recurse );
258
                if( i_success == -1 ) break;
Rémi Duraffort's avatar
Rémi Duraffort committed
259 260
                free( psz_response );
                psz_response = psz_tmp;
261
            }
262 263
            /* Not a list, so format the child as a JSON object and
             * recurse through the child's children
264 265 266
             */
            else
            {
267
                char *psz_recurse = recurse_answer( aw_child, psz_childdelim, 0 );
Rémi Duraffort's avatar
Rémi Duraffort committed
268
                i_success = asprintf( &psz_tmp, "%s{%s%s%s%s}%c%s",
269
                                      psz_response, psz_childdelim, psz_nametag,
Rémi Duraffort's avatar
Rémi Duraffort committed
270 271
                                      psz_recurse, psz_delim, c_comma, psz_delim );
                free( psz_recurse );
272
                if( i_success == -1 ) break;
Rémi Duraffort's avatar
Rémi Duraffort committed
273 274
                free( psz_response );
                psz_response = psz_tmp;
275 276
            }
        }
277 278 279 280 281 282 283 284 285
        /* Otherwise - when no children are present - the node is a
         * value node. So print the value string
         */
        else
        {
            /* If value is equivalent to NULL, print it as null */
            if( aw_child->psz_value == NULL
                || strcmp( aw_child->psz_value, "(null)" ) == 0 )
            {
Rémi Duraffort's avatar
Rémi Duraffort committed
286
                i_success = asprintf( &psz_tmp, "%snull%c%s",
287
                                      psz_response, c_comma, psz_delim );
Rémi Duraffort's avatar
Rémi Duraffort committed
288 289 290
                if( i_success == -1 ) break;
                free( psz_response );
                psz_response = psz_tmp;
291 292 293 294
            }
            /* Otherwise print the value in quotation marks */
            else
            {
Rémi Duraffort's avatar
Rémi Duraffort committed
295
                i_success = asprintf( &psz_tmp, "%s\"%s\"%c%s",
296 297 298
                                      psz_response, aw_child->psz_value,
                                      c_comma, psz_delim );
                if( i_success == -1 ) break;
Rémi Duraffort's avatar
Rémi Duraffort committed
299 300
                free( psz_response );
                psz_response = psz_tmp;
301 302 303 304 305
            }
        }
        /* getting next child */
        paw_child++;
        aw_child = *( paw_child );
306 307 308 309 310 311 312 313 314 315 316 317
    }
    free( psz_nametag );
    free( psz_childdelim );
    if( i_success == -1 )
    {
        free( psz_response );
        psz_response = strdup( "" );
    }
    return psz_response;
}

const char* libvlc_vlm_show_media( libvlc_instance_t *p_instance,
318
                                   const char *psz_name )
319 320 321 322 323 324 325 326 327 328 329
{
    char *psz_message = NULL;
    vlm_message_t *answer = NULL;
    char *psz_response = NULL;
    const char *psz_fmt = NULL;
    const char *psz_delimiter = NULL;
    int i_list;
    vlm_t *p_vlm = NULL;

    VLM_RET(p_vlm, NULL);

330 331 332 333 334 335 336
    assert( psz_name );

    if( asprintf( &psz_message, "show %s", psz_name ) == -1 )
        return NULL;

    vlm_ExecuteCommand( p_vlm, psz_message, &answer );
    if( answer->psz_value )
337
    {
338 339
        libvlc_printerr( "Unable to call show %s: %s",
                         psz_name, answer->psz_value );
340
    }
341 342 343
    else if ( answer->child )
    {   /* in case everything was requested  */
        if ( strcmp( psz_name, "" ) == 0 )
344
        {
345 346 347
            psz_fmt = "{\n\t%s\n}\n";
            psz_delimiter = "\n\t";
            i_list = 0;
348
        }
349 350 351 352 353 354
        else
        {
            psz_fmt = "%s\n";
            psz_delimiter = "\n";
            i_list = 1;
        }
Rémi Duraffort's avatar
Rémi Duraffort committed
355 356
        char *psz_tmp = recurse_answer( answer, psz_delimiter, i_list );
        if( asprintf( &psz_response, psz_fmt, psz_tmp ) == -1 )
357 358
        {
            libvlc_printerr( "Out of memory" );
359
            psz_response = NULL;
360
        }
Rémi Duraffort's avatar
Rémi Duraffort committed
361
        free( psz_tmp );
362
    }
363
    vlm_MessageDelete( answer );
364 365 366 367 368
    free( psz_message );
    return( psz_response );
}


369 370 371 372 373 374
int libvlc_vlm_add_broadcast( libvlc_instance_t *p_instance,
                              const char *psz_name,
                              const char *psz_input,
                              const char *psz_output, int i_options,
                              const char * const *ppsz_options,
                              int b_enabled, int b_loop )
Laurent Aimar's avatar
Laurent Aimar committed
375
{
376 377 378 379
    vlm_t *p_vlm;
    vlm_media_t m;
    int n;

380
    VLM_RET(p_vlm, -1);
381 382 383 384

    vlm_media_Init( &m );
    m.psz_name = strdup( psz_name );
    m.b_enabled = b_enabled;
385
    m.b_vod = false;
386 387 388 389 390 391 392 393
    m.broadcast.b_loop = b_loop;
    if( psz_input )
        TAB_APPEND( m.i_input, m.ppsz_input, strdup(psz_input) );
    if( psz_output )
        m.psz_output = strdup( psz_output );
    for( n = 0; n < i_options; n++ )
        TAB_APPEND( m.i_option, m.ppsz_option, strdup(ppsz_options[n]) );

394
    n = vlm_Control( p_vlm, VLM_ADD_MEDIA, &m, NULL );
395
    vlm_media_Clean( &m );
396
    if( n )
397 398
    {
        libvlc_printerr( "Media %s creation failed", psz_name );
399
        return -1;
400
    }
401
    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
402 403
}

404 405 406 407
int libvlc_vlm_add_vod( libvlc_instance_t *p_instance, const char *psz_name,
                        const char *psz_input, int i_options,
                        const char * const *ppsz_options, int b_enabled,
                        const char *psz_mux )
408 409 410 411 412
{
    vlm_t *p_vlm;
    vlm_media_t m;
    int n;

413
    VLM_RET(p_vlm, -1);
414 415 416 417 418 419 420 421 422 423 424

    vlm_media_Init( &m );
    m.psz_name = strdup( psz_name );
    m.b_enabled = b_enabled;
    m.b_vod = true;
    m.vod.psz_mux = psz_mux ? strdup( psz_mux ) : NULL;
    if( psz_input )
        TAB_APPEND( m.i_input, m.ppsz_input, strdup(psz_input) );
    for( n = 0; n < i_options; n++ )
        TAB_APPEND( m.i_option, m.ppsz_option, strdup(ppsz_options[n]) );

425
    n = vlm_Control( p_vlm, VLM_ADD_MEDIA, &m, NULL );
426
    vlm_media_Clean( &m );
427
    if( n )
428 429
    {
        libvlc_printerr( "Media %s creation failed", psz_name );
430
        return -1;
431
    }
432
    return 0;
433 434
}

435
int libvlc_vlm_del_media( libvlc_instance_t *p_instance, const char *psz_name )
Laurent Aimar's avatar
Laurent Aimar committed
436
{
437 438 439
    vlm_t *p_vlm;
    int64_t id;

440
    VLM_RET(p_vlm, -1);
441 442 443 444

    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) ||
        vlm_Control( p_vlm, VLM_DEL_MEDIA, id ) )
    {
445
        libvlc_printerr( "Unable to delete %s", psz_name );
446
        return -1;
447
    }
448
    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
449 450
}

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
static vlm_media_t *get_media( libvlc_instance_t *p_instance,
                               vlm_t **restrict pp_vlm, const char *name )
{
    vlm_media_t *p_media;
    vlm_t *p_vlm;
    int64_t id;

    VLM_RET(p_vlm, NULL);
    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, name, &id ) ||
        vlm_Control( p_vlm, VLM_GET_MEDIA, id, &p_media ) )
        return NULL;
    *pp_vlm = p_vlm;
    return p_media;
}

466 467
#define VLM_CHANGE(psz_error, code ) do {   \
    vlm_t *p_vlm;           \
468 469 470 471 472
    vlm_media_t *p_media = get_media( p_instance, &p_vlm, psz_name ); \
    if( p_media != NULL ) { \
        code;               \
        if( vlm_Control( p_vlm, VLM_CHANGE_MEDIA, p_media ) )       \
            p_vlm = NULL;                                           \
473
        vlm_media_Delete( p_media );                                \
474 475
        if( p_vlm != NULL ) \
            return 0;       \
476
    }                       \
477
    libvlc_printerr( psz_error, psz_name );                         \
478
    return -1;              \
479 480
  } while(0)

481 482
int libvlc_vlm_set_enabled( libvlc_instance_t *p_instance,
                            const char *psz_name, int b_enabled )
Laurent Aimar's avatar
Laurent Aimar committed
483
{
484 485 486
#define VLM_CHANGE_CODE { p_media->b_enabled = b_enabled; }
    VLM_CHANGE( "Unable to delete %s", VLM_CHANGE_CODE );
#undef VLM_CHANGE_CODE
Laurent Aimar's avatar
Laurent Aimar committed
487 488
}

489 490
int libvlc_vlm_set_loop( libvlc_instance_t *p_instance, const char *psz_name,
                         int b_loop )
Laurent Aimar's avatar
Laurent Aimar committed
491
{
492 493
#define VLM_CHANGE_CODE { p_media->broadcast.b_loop = b_loop; }
    VLM_CHANGE( "Unable to change %s loop property", VLM_CHANGE_CODE );
494 495 496
#undef VLM_CHANGE_CODE
}

497 498
int libvlc_vlm_set_mux( libvlc_instance_t *p_instance, const char *psz_name,
                        const char *psz_mux )
499 500 501
{
#define VLM_CHANGE_CODE { if( p_media->b_vod ) { \
                            free( p_media->vod.psz_mux ); \
502 503
                            p_media->vod.psz_mux = psz_mux \
                                 ? strdup( psz_mux ) : NULL; \
504 505
                          } }
    VLM_CHANGE( "Unable to change %s mux property", VLM_CHANGE_CODE );
506
#undef VLM_CHANGE_CODE
Laurent Aimar's avatar
Laurent Aimar committed
507 508
}

509 510
int libvlc_vlm_set_output( libvlc_instance_t *p_instance,
                           const char *psz_name, const char *psz_output )
Laurent Aimar's avatar
Laurent Aimar committed
511
{
512
#define VLM_CHANGE_CODE { free( p_media->psz_output ); \
513 514 515
                          p_media->psz_output = strdup( psz_output ); }
    VLM_CHANGE( "Unable to change %s output property", VLM_CHANGE_CODE );
#undef VLM_CHANGE_CODE
Laurent Aimar's avatar
Laurent Aimar committed
516 517
}

518 519
int libvlc_vlm_set_input( libvlc_instance_t *p_instance,
                          const char *psz_name, const char *psz_input )
Laurent Aimar's avatar
Laurent Aimar committed
520
{
521 522
#define VLM_CHANGE_CODE { while( p_media->i_input > 0 ) \
                            free( p_media->ppsz_input[--p_media->i_input] );\
523 524
                          TAB_APPEND( p_media->i_input, p_media->ppsz_input, \
                                      strdup(psz_input) ); }
525 526
    VLM_CHANGE( "Unable to change %s input property", VLM_CHANGE_CODE );
#undef VLM_CHANGE_CODE
Laurent Aimar's avatar
Laurent Aimar committed
527 528
}

529 530
int libvlc_vlm_add_input( libvlc_instance_t *p_instance,
                          const char *psz_name, const char *psz_input )
Laurent Aimar's avatar
Laurent Aimar committed
531
{
532 533
#define VLM_CHANGE_CODE { TAB_APPEND( p_media->i_input, p_media->ppsz_input, \
                          strdup(psz_input) ); }
534 535
    VLM_CHANGE( "Unable to change %s input property", VLM_CHANGE_CODE );
#undef VLM_CHANGE_CODE
Laurent Aimar's avatar
Laurent Aimar committed
536 537
}

538 539 540 541 542
int libvlc_vlm_change_media( libvlc_instance_t *p_instance,
                             const char *psz_name, const char *psz_input,
                             const char *psz_output, int i_options,
                             const char * const *ppsz_options, int b_enabled,
                             int b_loop )
Laurent Aimar's avatar
Laurent Aimar committed
543
{
544 545 546 547 548 549 550
#define VLM_CHANGE_CODE { int n;        \
    p_media->b_enabled = b_enabled;     \
    p_media->broadcast.b_loop = b_loop; \
    while( p_media->i_input > 0 )       \
        free( p_media->ppsz_input[--p_media->i_input] );    \
    if( psz_input )                     \
        TAB_APPEND( p_media->i_input, p_media->ppsz_input, strdup(psz_input) ); \
551
    free( p_media->psz_output );        \
552 553 554 555
    p_media->psz_output = psz_output ? strdup( psz_output ) : NULL; \
    while( p_media->i_option > 0 )     \
        free( p_media->ppsz_option[--p_media->i_option] );        \
    for( n = 0; n < i_options; n++ )    \
556 557
        TAB_APPEND( p_media->i_option, p_media->ppsz_option, \
                    strdup(ppsz_options[n]) );   \
558 559 560
  }
    VLM_CHANGE( "Unable to change %s properties", VLM_CHANGE_CODE );
#undef VLM_CHANGE_CODE
Laurent Aimar's avatar
Laurent Aimar committed
561 562
}

563 564
int libvlc_vlm_play_media( libvlc_instance_t *p_instance,
                           const char *psz_name )
Laurent Aimar's avatar
Laurent Aimar committed
565
{
566 567 568
    vlm_t *p_vlm;
    int64_t id;

569
    VLM_RET(p_vlm, -1);
570 571 572 573

    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) ||
        vlm_Control( p_vlm, VLM_START_MEDIA_BROADCAST_INSTANCE, id, NULL, 0 ) )
    {
574
        libvlc_printerr( "Unable to play %s", psz_name );
575
        return -1;
576
    }
577
    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
578 579
}

580 581
int libvlc_vlm_stop_media( libvlc_instance_t *p_instance,
                           const char *psz_name )
Laurent Aimar's avatar
Laurent Aimar committed
582
{
583 584 585
    vlm_t *p_vlm;
    int64_t id;

586
    VLM_RET(p_vlm, -1);
587 588 589 590

    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) ||
        vlm_Control( p_vlm, VLM_STOP_MEDIA_INSTANCE, id, NULL ) )
    {
591
        libvlc_printerr( "Unable to stop %s", psz_name );
592
        return -1;
593
    }
594
    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
595 596
}

597 598
int libvlc_vlm_pause_media( libvlc_instance_t *p_instance,
                            const char *psz_name )
Laurent Aimar's avatar
Laurent Aimar committed
599
{
600 601 602
    vlm_t *p_vlm;
    int64_t id;

603
    VLM_RET(p_vlm, -1);
604 605 606 607

    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) ||
        vlm_Control( p_vlm, VLM_PAUSE_MEDIA_INSTANCE, id, NULL ) )
    {
608
        libvlc_printerr( "Unable to pause %s", psz_name );
609
        return -1;
610
    }
611
    return 0;
Laurent Aimar's avatar
Laurent Aimar committed
612 613
}

614 615
int libvlc_vlm_seek_media( libvlc_instance_t *p_instance,
                           const char *psz_name, float f_percentage )
Laurent Aimar's avatar
Laurent Aimar committed
616
{
617 618 619
    vlm_t *p_vlm;
    int64_t id;

620
    VLM_RET(p_vlm, -1);
621 622

    if( vlm_Control( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) ||
623 624
        vlm_Control( p_vlm, VLM_SET_MEDIA_INSTANCE_POSITION, id, NULL,
                     f_percentage ) )
625 626
    {
        libvlc_printerr( "Unable to seek %s to %f%%", psz_name, f_percentage );
627
        return -1;
628
    }
629
    return 0;
630 631
}

632
float libvlc_vlm_get_media_instance_position( libvlc_instance_t *p_instance,
633
                                              const char *psz_name,
634
                                              int i_instance )
635
{
636 637 638
    vlm_media_instance_t *p_mi;
    float result = -1.;

639
    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name, i_instance );
640 641 642 643 644 645 646 647 648
    if( p_mi )
    {
        result = p_mi->d_position;
        vlm_media_instance_Delete( p_mi );
    }
    return result;
}

int libvlc_vlm_get_media_instance_time( libvlc_instance_t *p_instance,
649
                                        const char *psz_name, int i_instance )
650
{
651
    vlm_media_instance_t *p_mi;
652
    int result = -1;
653

654
    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name, i_instance );
655 656 657 658 659 660 661 662 663
    if( p_mi )
    {
        result = p_mi->i_time;
        vlm_media_instance_Delete( p_mi );
    }
    return result;
}

int libvlc_vlm_get_media_instance_length( libvlc_instance_t *p_instance,
664
                                          const char *psz_name,
665
                                          int i_instance )
666
{
667
    vlm_media_instance_t *p_mi;
668
    int result = -1;
669

670
    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name, i_instance );
671 672 673 674 675 676 677 678 679
    if( p_mi )
    {
        result = p_mi->i_length;
        vlm_media_instance_Delete( p_mi );
    }
    return result;
}

int libvlc_vlm_get_media_instance_rate( libvlc_instance_t *p_instance,
680
                                        const char *psz_name, int i_instance )
681
{
682
    vlm_media_instance_t *p_mi;
683
    int result = -1;
684

685
    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name, i_instance );
686 687 688 689 690 691
    if( p_mi )
    {
        result = p_mi->i_rate;
        vlm_media_instance_Delete( p_mi );
    }
    return result;
Laurent Aimar's avatar
Laurent Aimar committed
692 693
}

694
#if 0
695
int libvlc_vlm_get_media_instance_title( libvlc_instance_t *p_instance,
696
                                         const char *psz_name, int i_instance )
697
{
698 699
    vlm_media_instance_t *p_mi;

700
    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name, i_instance );
701 702
    if( p_mi )
        vlm_media_instance_Delete( p_mi );
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
703
    return p_mi ? 0 : -1;
704
}
Laurent Aimar's avatar
Laurent Aimar committed
705

706
int libvlc_vlm_get_media_instance_chapter( libvlc_instance_t *p_instance,
707
                                           const char *psz_name,
708
                                           int i_instance )
709
{
710 711 712
    vlm_media_instance_t *p_mi;

    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name,
713
                                          i_instance );
714 715
    if( p_mi )
        vlm_media_instance_Delete( p_mi );
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
716
    return p_mi ? 0 : -1;
717
}
Laurent Aimar's avatar
Laurent Aimar committed
718

719
int libvlc_vlm_get_media_instance_seekable( libvlc_instance_t *p_instance,
720
                                            const char *psz_name,
721
                                            int i_instance )
Laurent Aimar's avatar
Laurent Aimar committed
722
{
723 724
    vlm_media_instance_t *p_mi;

725
    p_mi = libvlc_vlm_get_media_instance( p_instance, psz_name, i_instance );
726 727
    if( p_mi )
        vlm_media_instance_Delete( p_mi );
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
728
    return p_mi ? 0 : -1;
Laurent Aimar's avatar
Laurent Aimar committed
729
}
730
#endif
731

732 733
libvlc_event_manager_t *
libvlc_vlm_get_event_manager( libvlc_instance_t *p_instance )
734
{
735 736
    if( libvlc_vlm_init( p_instance ) )
        return NULL;
737
    return p_instance->libvlc_vlm.p_event_manager;
738
}