git.sesse.net Git - vlc/blob - src/control/video.c

   1 /*****************************************************************************
   2  * video.c: libvlc new API video functions
   3  *****************************************************************************
   4  * Copyright (C) 2005-2010 the VideoLAN team
   5  *
   6  * $Id$
   7  *
   8  * Authors: Clément Stenac <zorglub@videolan.org>
   9  *          Filippo Carone <littlejohn@videolan.org>
  10  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>
  11  *          Damien Fouilleul <damienf a_t videolan dot org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc/libvlc.h>
  33 #include <vlc/libvlc_media.h>
  34 #include <vlc/libvlc_media_player.h>
  35
  36 #include <vlc_common.h>
  37 #include <vlc_input.h>
  38 #include <vlc_vout.h>
  39
  40 #include "media_player_internal.h"
  41 #include <vlc_osd.h>
  42 #include <assert.h>
  43
  44 /*
  45  * Remember to release the returned vout_thread_t.
  46  */
  47 static vout_thread_t *GetVout( libvlc_media_player_t *p_mi,
  48                                libvlc_exception_t *p_exception )
  49 {
  50     input_thread_t *p_input = libvlc_get_input_thread( p_mi, p_exception );
  51     vout_thread_t *p_vout = NULL;
  52
  53     if( p_input )
  54     {
  55         p_vout = input_GetVout( p_input );
  56         if( !p_vout )
  57         {
  58             libvlc_exception_raise( p_exception );
  59             libvlc_printerr( "No active video output" );
  60         }
  61         vlc_object_release( p_input );
  62     }
  63     return p_vout;
  64 }
  65
  66 /**********************************************************************
  67  * Exported functions
  68  **********************************************************************/
  69
  70 void libvlc_set_fullscreen( libvlc_media_player_t *p_mi, int b_fullscreen,
  71                             libvlc_exception_t *p_e )
  72 {
  73     /* We only work on the first vout */
  74     vout_thread_t *p_vout = GetVout( p_mi, p_e );
  75
  76     /* GetVout will raise the exception for us */
  77     if( !p_vout ) return;
  78
  79     var_SetBool( p_vout, "fullscreen", b_fullscreen );
  80
  81     vlc_object_release( p_vout );
  82 }
  83
  84 int libvlc_get_fullscreen( libvlc_media_player_t *p_mi,
  85                             libvlc_exception_t *p_e )
  86 {
  87     /* We only work on the first vout */
  88     vout_thread_t *p_vout = GetVout( p_mi, p_e );
  89     int i_ret;
  90
  91     /* GetVout will raise the exception for us */
  92     if( !p_vout ) return 0;
  93
  94     i_ret = var_GetBool( p_vout, "fullscreen" );
  95
  96     vlc_object_release( p_vout );
  97
  98     return i_ret;
  99 }
 100
 101 void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi,
 102                                libvlc_exception_t *p_e )
 103 {
 104     /* We only work on the first vout */
 105     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 106
 107     /* GetVout will raise the exception for us */
 108     if( !p_vout ) return;
 109
 110     var_ToggleBool( p_vout, "fullscreen" );
 111
 112     vlc_object_release( p_vout );
 113 }
 114
 115 void libvlc_video_set_key_input( libvlc_media_player_t *p_mi, unsigned on )
 116 {
 117     p_mi->keyboard_events = !!on;
 118 }
 119
 120 void libvlc_video_set_mouse_input( libvlc_media_player_t *p_mi, unsigned on )
 121 {
 122     p_mi->mouse_events = !!on;
 123 }
 124
 125 void
 126 libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, const char *psz_filepath,
 127         unsigned int i_width, unsigned int i_height, libvlc_exception_t *p_e )
 128 {
 129     vout_thread_t *p_vout;
 130
 131     assert( psz_filepath );
 132
 133     /* We must have an input */
 134     if( !p_mi->p_input_thread )
 135     {
 136         libvlc_exception_raise( p_e );
 137         libvlc_printerr( "Input does not exist" );
 138         return;
 139     }
 140
 141     /* GetVout will raise the exception for us */
 142     p_vout = GetVout( p_mi, p_e );
 143     if( !p_vout ) return;
 144
 145     var_SetInteger( p_vout, "snapshot-width", i_width );
 146     var_SetInteger( p_vout, "snapshot-height", i_height );
 147
 148     var_SetString( p_vout, "snapshot-path", psz_filepath );
 149     var_SetString( p_vout, "snapshot-format", "png" );
 150
 151     var_TriggerCallback( p_vout, "video-snapshot" );
 152     vlc_object_release( p_vout );
 153 }
 154
 155 int libvlc_video_get_height( libvlc_media_player_t *p_mi,
 156                              libvlc_exception_t *p_e )
 157 {
 158     int height;
 159
 160     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 161     if( !p_vout ) return 0;
 162
 163     height = p_vout->i_window_height;
 164
 165     vlc_object_release( p_vout );
 166
 167     return height;
 168 }
 169
 170 int libvlc_video_get_width( libvlc_media_player_t *p_mi,
 171                             libvlc_exception_t *p_e )
 172 {
 173     int width;
 174
 175     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 176     if( !p_vout ) return 0;
 177
 178     width = p_vout->i_window_width;
 179
 180     vlc_object_release( p_vout );
 181
 182     return width;
 183 }
 184
 185 int libvlc_media_player_has_vout( libvlc_media_player_t *p_mi,
 186                                      libvlc_exception_t *p_e )
 187 {
 188     input_thread_t *p_input_thread = libvlc_get_input_thread(p_mi, p_e);
 189     bool has_vout = false;
 190
 191     if( p_input_thread )
 192     {
 193         vout_thread_t *p_vout;
 194
 195         p_vout = input_GetVout( p_input_thread );
 196         if( p_vout )
 197         {
 198             has_vout = true;
 199             vlc_object_release( p_vout );
 200         }
 201         vlc_object_release( p_input_thread );
 202     }
 203     return has_vout;
 204 }
 205
 206 float libvlc_video_get_scale( libvlc_media_player_t *p_mp,
 207                               libvlc_exception_t *p_e )
 208 {
 209     vout_thread_t *p_vout = GetVout( p_mp, p_e );
 210     if( !p_vout )
 211         return 0.;
 212
 213     float f_scale = var_GetFloat( p_vout, "scale" );
 214     if( var_GetBool( p_vout, "autoscale" ) )
 215         f_scale = 0.;
 216     vlc_object_release( p_vout );
 217     return f_scale;
 218 }
 219
 220 void libvlc_video_set_scale( libvlc_media_player_t *p_mp, float f_scale,
 221                              libvlc_exception_t *p_e )
 222 {
 223     vout_thread_t *p_vout = GetVout( p_mp, p_e );
 224     if( !p_vout )
 225         return;
 226
 227     if( f_scale != 0. )
 228         var_SetFloat( p_vout, "scale", f_scale );
 229     var_SetBool( p_vout, "autoscale", f_scale != 0. );
 230     vlc_object_release( p_vout );
 231 }
 232
 233 char *libvlc_video_get_aspect_ratio( libvlc_media_player_t *p_mi,
 234                                      libvlc_exception_t *p_e )
 235 {
 236     char *psz_aspect = NULL;
 237     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 238
 239     if( !p_vout ) return NULL;
 240
 241     psz_aspect = var_GetNonEmptyString( p_vout, "aspect-ratio" );
 242     vlc_object_release( p_vout );
 243     return psz_aspect ? psz_aspect : strdup("");
 244 }
 245
 246 void libvlc_video_set_aspect_ratio( libvlc_media_player_t *p_mi,
 247                                     const char *psz_aspect, libvlc_exception_t *p_e )
 248 {
 249     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 250     int i_ret = -1;
 251
 252     if( !p_vout ) return;
 253
 254     i_ret = var_SetString( p_vout, "aspect-ratio", psz_aspect );
 255     vlc_object_release( p_vout );
 256     if( i_ret )
 257     {
 258         libvlc_exception_raise( p_e );
 259         libvlc_printerr( "Bad or unsupported aspect ratio" );
 260     }
 261 }
 262
 263 int libvlc_video_get_spu( libvlc_media_player_t *p_mi,
 264                           libvlc_exception_t *p_e )
 265 {
 266     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 267     vlc_value_t val_list;
 268     vlc_value_t val;
 269     int i_spu = -1;
 270     int i_ret = -1;
 271     int i;
 272
 273     if( !p_input_thread ) return -1;
 274
 275     i_ret = var_Get( p_input_thread, "spu-es", &val );
 276     if( i_ret < 0 )
 277     {
 278         vlc_object_release( p_input_thread );
 279         libvlc_exception_raise( p_e );
 280         libvlc_printerr( "Subtitle informations not found" );
 281         return i_ret;
 282     }
 283
 284     var_Change( p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 285     for( i = 0; i < val_list.p_list->i_count; i++ )
 286     {
 287         if( val.i_int == val_list.p_list->p_values[i].i_int )
 288         {
 289             i_spu = i;
 290             break;
 291         }
 292     }
 293     var_FreeList( &val_list, NULL );
 294     vlc_object_release( p_input_thread );
 295     return i_spu;
 296 }
 297
 298 int libvlc_video_get_spu_count( libvlc_media_player_t *p_mi,
 299                                 libvlc_exception_t *p_e )
 300 {
 301     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 302     int i_spu_count;
 303
 304     if( !p_input_thread )
 305         return -1;
 306
 307     i_spu_count = var_CountChoices( p_input_thread, "spu-es" );
 308
 309     vlc_object_release( p_input_thread );
 310     return i_spu_count;
 311 }
 312
 313 libvlc_track_description_t *
 314         libvlc_video_get_spu_description( libvlc_media_player_t *p_mi,
 315                                           libvlc_exception_t *p_e )
 316 {
 317     return libvlc_get_track_description( p_mi, "spu-es", p_e);
 318 }
 319
 320 void libvlc_video_set_spu( libvlc_media_player_t *p_mi, int i_spu,
 321                            libvlc_exception_t *p_e )
 322 {
 323     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 324     vlc_value_t val_list;
 325     vlc_value_t newval;
 326     int i_ret = -1;
 327
 328     if( !p_input_thread ) return;
 329
 330     var_Change( p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 331
 332     if( ( val_list.p_list->i_count == 0 )
 333      || (i_spu < 0) || (i_spu > val_list.p_list->i_count) )
 334     {
 335         libvlc_exception_raise( p_e );
 336         libvlc_printerr( "Subtitle number out of range" );
 337         goto end;
 338     }
 339
 340     newval = val_list.p_list->p_values[i_spu];
 341     i_ret = var_Set( p_input_thread, "spu-es", newval );
 342     if( i_ret < 0 )
 343     {
 344         libvlc_exception_raise( p_e );
 345         libvlc_printerr( "Subtitle selection error" );
 346     }
 347
 348 end:
 349     var_FreeList( &val_list, NULL );
 350     vlc_object_release( p_input_thread );
 351 }
 352
 353 int libvlc_video_set_subtitle_file( libvlc_media_player_t *p_mi,
 354                                     const char *psz_subtitle,
 355                                     libvlc_exception_t *p_e )
 356 {
 357     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 358     bool b_ret = false;
 359
 360     if( p_input_thread )
 361     {
 362         if( !input_AddSubtitle( p_input_thread, psz_subtitle, true ) )
 363             b_ret = true;
 364         vlc_object_release( p_input_thread );
 365     }
 366     return b_ret;
 367 }
 368
 369 libvlc_track_description_t *
 370         libvlc_video_get_title_description( libvlc_media_player_t *p_mi,
 371                                             libvlc_exception_t * p_e )
 372 {
 373     return libvlc_get_track_description( p_mi, "title", p_e);
 374 }
 375
 376 libvlc_track_description_t *
 377         libvlc_video_get_chapter_description( libvlc_media_player_t *p_mi,
 378                                               int i_title,
 379                                               libvlc_exception_t *p_e )
 380 {
 381     char psz_title[12];
 382     sprintf( psz_title,  "title %2i", i_title );
 383     return libvlc_get_track_description( p_mi, psz_title, p_e);
 384 }
 385
 386 char *libvlc_video_get_crop_geometry( libvlc_media_player_t *p_mi,
 387                                    libvlc_exception_t *p_e )
 388 {
 389     char *psz_geometry = 0;
 390     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 391
 392     if( !p_vout ) return 0;
 393
 394     psz_geometry = var_GetNonEmptyString( p_vout, "crop" );
 395     vlc_object_release( p_vout );
 396     return psz_geometry ? psz_geometry : strdup("");
 397 }
 398
 399 void libvlc_video_set_crop_geometry( libvlc_media_player_t *p_mi,
 400                                      const char *psz_geometry, libvlc_exception_t *p_e )
 401 {
 402     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 403     int i_ret = -1;
 404
 405     if( !p_vout ) return;
 406
 407     i_ret = var_SetString( p_vout, "crop", psz_geometry );
 408     vlc_object_release( p_vout );
 409
 410     if( i_ret )
 411     {
 412         libvlc_exception_raise( p_e );
 413         libvlc_printerr( "Bad or unsupported cropping geometry" );
 414     }
 415 }
 416
 417 void libvlc_toggle_teletext( libvlc_media_player_t *p_mi,
 418                              libvlc_exception_t *p_e )
 419 {
 420     input_thread_t *p_input_thread;
 421
 422     p_input_thread = libvlc_get_input_thread(p_mi, p_e);
 423     if( !p_input_thread ) return;
 424
 425     if( var_CountChoices( p_input_thread, "teletext-es" ) <= 0 )
 426     {
 427         vlc_object_release( p_input_thread );
 428         return;
 429     }
 430     const bool b_selected = var_GetInteger( p_input_thread, "teletext-es" ) >= 0;
 431     if( b_selected )
 432     {
 433         var_SetInteger( p_input_thread, "spu-es", -1 );
 434     }
 435     else
 436     {
 437         vlc_value_t list;
 438         if( !var_Change( p_input_thread, "teletext-es", VLC_VAR_GETLIST, &list, NULL ) )
 439         {
 440             if( list.p_list->i_count > 0 )
 441                 var_SetInteger( p_input_thread, "spu-es", list.p_list->p_values[0].i_int );
 442
 443             var_FreeList( &list, NULL );
 444         }
 445     }
 446     vlc_object_release( p_input_thread );
 447 }
 448
 449 int libvlc_video_get_track_count( libvlc_media_player_t *p_mi,
 450                                   libvlc_exception_t *p_e )
 451 {
 452     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 453     int i_track_count;
 454
 455     if( !p_input_thread )
 456         return -1;
 457
 458     i_track_count = var_CountChoices( p_input_thread, "video-es" );
 459
 460     vlc_object_release( p_input_thread );
 461     return i_track_count;
 462 }
 463
 464 libvlc_track_description_t *
 465         libvlc_video_get_track_description( libvlc_media_player_t *p_mi,
 466                                             libvlc_exception_t *p_e )
 467 {
 468     return libvlc_get_track_description( p_mi, "video-es", p_e);
 469 }
 470
 471 int libvlc_video_get_track( libvlc_media_player_t *p_mi,
 472                             libvlc_exception_t *p_e )
 473 {
 474     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 475     vlc_value_t val_list;
 476     vlc_value_t val;
 477     int i_track = -1;
 478     int i_ret = -1;
 479     int i;
 480
 481     if( !p_input_thread )
 482         return -1;
 483
 484     i_ret = var_Get( p_input_thread, "video-es", &val );
 485     if( i_ret < 0 )
 486     {
 487         libvlc_exception_raise( p_e );
 488         libvlc_printerr( "Video track information not found" );
 489         vlc_object_release( p_input_thread );
 490         return i_ret;
 491     }
 492
 493     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 494     for( i = 0; i < val_list.p_list->i_count; i++ )
 495     {
 496         if( val_list.p_list->p_values[i].i_int == val.i_int )
 497         {
 498             i_track = i;
 499             break;
 500         }
 501     }
 502     var_FreeList( &val_list, NULL );
 503     vlc_object_release( p_input_thread );
 504     return i_track;
 505 }
 506
 507 void libvlc_video_set_track( libvlc_media_player_t *p_mi, int i_track,
 508                              libvlc_exception_t *p_e )
 509 {
 510     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 511     vlc_value_t val_list;
 512     int i_ret = -1;
 513     int i;
 514
 515     if( !p_input_thread )
 516         return;
 517
 518     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 519     for( i = 0; i < val_list.p_list->i_count; i++ )
 520     {
 521         if( i_track == val_list.p_list->p_values[i].i_int )
 522         {
 523             i_ret = var_SetInteger( p_input_thread, "video-es", i_track );
 524             if( i_ret < 0 )
 525                 break;
 526             goto end;
 527         }
 528     }
 529     libvlc_exception_raise( p_e );
 530     libvlc_printerr( "Video track number out of range" );
 531 end:
 532     var_FreeList( &val_list, NULL );
 533     vlc_object_release( p_input_thread );
 534 }
 535
 536 /******************************************************************************
 537  * libvlc_video_set_deinterlace : enable deinterlace
 538  *****************************************************************************/
 539 void libvlc_video_set_deinterlace( libvlc_media_player_t *p_mi, int b_enable,
 540                                    const char *psz_mode,
 541                                    libvlc_exception_t *p_e )
 542 {
 543     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 544
 545     if( !p_vout )
 546         return;
 547
 548     if( b_enable )
 549     {
 550         /* be sure that the filter name given is supported */
 551         if( !strcmp(psz_mode, "blend")   || !strcmp(psz_mode, "bob")
 552          || !strcmp(psz_mode, "discard") || !strcmp(psz_mode, "linear")
 553          || !strcmp(psz_mode, "mean")    || !strcmp(psz_mode, "x")
 554          || !strcmp(psz_mode, "yadif")   || !strcmp(psz_mode, "yadif2x") )
 555         {
 556             /* set deinterlace filter chosen */
 557             var_SetString( p_vout, "deinterlace-mode", psz_mode );
 558             var_SetInteger( p_vout, "deinterlace", 1 );
 559         }
 560         else
 561         {
 562             libvlc_exception_raise( p_e );
 563             libvlc_printerr( "Bad or unsupported deinterlacing mode" );
 564         }
 565     }
 566     else
 567     {
 568         /* disable deinterlace filter */
 569         var_SetInteger( p_vout, "deinterlace", 0 );
 570     }
 571
 572     vlc_object_release( p_vout );
 573 }
 574
 575
 576 /* ************** */
 577 /* module helpers */
 578 /* ************** */
 579
 580
 581 static vlc_object_t *get_object( libvlc_media_player_t * p_mi,
 582                                  const char *name, libvlc_exception_t *p_e )
 583 {
 584     vlc_object_t *object = NULL;
 585     vout_thread_t  *vout = GetVout( p_mi, p_e );
 586     libvlc_exception_clear( p_e );
 587     if( vout )
 588     {
 589         object = vlc_object_find_name( vout, name, FIND_CHILD );
 590         vlc_object_release(vout);
 591     }
 592     if( !object )
 593     {
 594         libvlc_exception_raise( p_e );
 595         libvlc_printerr( "%s not enabled", name );
 596     }
 597     return object;
 598 }
 599
 600
 601 typedef const struct {
 602     const char name[20]; /* probably will become a const char * sometime */
 603     unsigned type;
 604 } opt_t;
 605
 606
 607 static void
 608 set_int( libvlc_media_player_t *p_mi, const char *name,
 609          const opt_t *opt, int value, libvlc_exception_t *p_e )
 610 {
 611     if( !opt ) return;
 612
 613     if( !opt->type ) /* the enabler */
 614     {
 615         vout_thread_t *vout = GetVout( p_mi, p_e );
 616         libvlc_exception_clear( p_e );
 617         if (vout)
 618         {
 619             vout_EnableFilter( vout, opt->name, value, false );
 620             vlc_object_release( vout );
 621         }
 622         return;
 623     }
 624
 625     vlc_object_t *object = get_object( p_mi, name, p_e );
 626     if( !object ) return;
 627
 628     switch( opt->type )
 629     {
 630     case VLC_VAR_INTEGER:
 631         var_SetInteger(object, opt->name, value);
 632         break;
 633     default:
 634         libvlc_exception_raise( p_e );
 635         libvlc_printerr( "Invalid argument for %s in %s", name, "set int" );
 636         break;
 637     }
 638     vlc_object_release( object );
 639 }
 640
 641
 642 static int
 643 get_int( libvlc_media_player_t *p_mi, const char *name,
 644         const opt_t *opt, libvlc_exception_t *p_e )
 645 {
 646     if( !opt ) return 0;
 647
 648     vlc_object_t *object = get_object( p_mi, name, p_e );
 649     if( !object ) return 0;
 650
 651     int ret;
 652     switch( opt->type )
 653     {
 654     case 0: /* the enabler */
 655         ret = NULL != object;
 656         break;
 657     case VLC_VAR_INTEGER:
 658         ret = var_GetInteger(object, opt->name);
 659         break;
 660     default:
 661         libvlc_exception_raise( p_e );
 662         libvlc_printerr( "Invalid argument for %s in %s", name, "get int" );
 663         ret = 0;
 664         break;
 665     }
 666     vlc_object_release( object );
 667     return ret;
 668 }
 669
 670
 671 static void
 672 set_string( libvlc_media_player_t *p_mi, const char *name, const opt_t *opt,
 673             const char *psz_value, libvlc_exception_t *p_e )
 674 {
 675     if( !opt ) return;
 676     vlc_object_t *object = get_object( p_mi, name, p_e );
 677     if( !object ) return;
 678
 679     switch( opt->type )
 680     {
 681     case VLC_VAR_STRING:
 682         var_SetString( object, opt->name, psz_value );
 683         break;
 684     default:
 685         libvlc_exception_raise( p_e );
 686         libvlc_printerr( "Invalid argument for %s in %s", name, "set string" );
 687         break;
 688     }
 689     vlc_object_release( object );
 690 }
 691
 692
 693 static char *
 694 get_string( libvlc_media_player_t *p_mi, const char *name,
 695             const opt_t *opt, libvlc_exception_t *p_e )
 696 {
 697     if( !opt ) return NULL;
 698     vlc_object_t *object = get_object( p_mi, name, p_e );
 699     if( !object ) return NULL;
 700
 701     char *ret;
 702     switch( opt->type )
 703     {
 704     case VLC_VAR_STRING:
 705         ret = var_GetString( object, opt->name );
 706         break;
 707     default:
 708         libvlc_exception_raise( p_e );
 709         libvlc_printerr( "Invalid argument for %s in %s", name, "get string" );
 710         ret = NULL;
 711         break;
 712     }
 713     vlc_object_release( object );
 714     return ret;
 715 }
 716
 717
 718 /*****************************************************************************
 719  * Marquee: FIXME: That implementation has no persistent state and requires
 720  * a vout
 721  *****************************************************************************/
 722
 723 static const opt_t *
 724 marq_option_bynumber(unsigned option, libvlc_exception_t *p_e)
 725 {
 726     opt_t optlist[] =
 727     {
 728         { "marq",          0 },
 729         { "marq-marquee",  VLC_VAR_STRING },
 730         { "marq-color",    VLC_VAR_INTEGER },
 731         { "marq-opacity",  VLC_VAR_INTEGER },
 732         { "marq-position", VLC_VAR_INTEGER },
 733         { "marq-refresh",  VLC_VAR_INTEGER },
 734         { "marq-size",     VLC_VAR_INTEGER },
 735         { "marq-timeout",  VLC_VAR_INTEGER },
 736         { "marq-x",        VLC_VAR_INTEGER },
 737         { "marq-y",        VLC_VAR_INTEGER },
 738     };
 739     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
 740
 741     opt_t *r = option < num_opts ? optlist+option : NULL;
 742     if( !r )
 743     {
 744         libvlc_exception_raise( p_e );
 745         libvlc_printerr( "Unknown marquee option" );
 746     }
 747     return r;
 748 }
 749
 750 static vlc_object_t *get_object( libvlc_media_player_t *,
 751                                  const char *, libvlc_exception_t *);
 752
 753 /*****************************************************************************
 754  * libvlc_video_get_marquee_int : get a marq option value
 755  *****************************************************************************/
 756 int libvlc_video_get_marquee_int( libvlc_media_player_t *p_mi,
 757                                   unsigned option, libvlc_exception_t *p_e )
 758 {
 759     return get_int( p_mi, "marq", marq_option_bynumber(option,p_e), p_e );
 760 }
 761
 762 /*****************************************************************************
 763  * libvlc_video_get_marquee_string : get a marq option value
 764  *****************************************************************************/
 765 char * libvlc_video_get_marquee_string( libvlc_media_player_t *p_mi,
 766                                     unsigned option, libvlc_exception_t *p_e )
 767 {
 768     return get_string( p_mi, "marq", marq_option_bynumber(option,p_e), p_e );
 769 }
 770
 771 /*****************************************************************************
 772  * libvlc_video_set_marquee_int: enable, disable or set an int option
 773  *****************************************************************************/
 774 void libvlc_video_set_marquee_int( libvlc_media_player_t *p_mi,
 775                          unsigned option, int value, libvlc_exception_t *p_e )
 776 {
 777     set_int( p_mi, "marq", marq_option_bynumber(option,p_e), value, p_e );
 778 }
 779
 780 /*****************************************************************************
 781  * libvlc_video_set_marquee_string: set a string option
 782  *****************************************************************************/
 783 void libvlc_video_set_marquee_string( libvlc_media_player_t *p_mi,
 784                 unsigned option, const char * value, libvlc_exception_t *p_e )
 785 {
 786     set_string( p_mi, "marq", marq_option_bynumber(option,p_e), value, p_e );
 787 }
 788
 789
 790 /* logo module support */
 791
 792
 793 static opt_t *
 794 logo_option_bynumber( unsigned option, libvlc_exception_t *p_e )
 795 {
 796     opt_t vlogo_optlist[] = /* depends on libvlc_video_logo_option_t */
 797     {
 798         { "logo",          0 },
 799         { "logo-file",     VLC_VAR_STRING },
 800         { "logo-x",        VLC_VAR_INTEGER },
 801         { "logo-y",        VLC_VAR_INTEGER },
 802         { "logo-delay",    VLC_VAR_INTEGER },
 803         { "logo-repeat",   VLC_VAR_INTEGER },
 804         { "logo-opacity",  VLC_VAR_INTEGER },
 805         { "logo-position", VLC_VAR_INTEGER },
 806     };
 807     enum { num_vlogo_opts = sizeof(vlogo_optlist) / sizeof(*vlogo_optlist) };
 808
 809     opt_t *r = option < num_vlogo_opts ? vlogo_optlist+option : NULL;
 810     if( !r )
 811     {
 812         libvlc_exception_raise( p_e );
 813         libvlc_printerr( "Unknown logo option" );
 814     }
 815     return r;
 816 }
 817
 818
 819 void libvlc_video_set_logo_string( libvlc_media_player_t *p_mi,
 820                                    unsigned option, const char *psz_value,
 821                                    libvlc_exception_t *p_e )
 822 {
 823     set_string( p_mi,"logo",logo_option_bynumber(option,p_e),psz_value,p_e );
 824 }
 825
 826
 827 void libvlc_video_set_logo_int( libvlc_media_player_t *p_mi,
 828                                 unsigned option, int value,
 829                                 libvlc_exception_t *p_e )
 830 {
 831     set_int( p_mi, "logo", logo_option_bynumber(option, p_e), value, p_e );
 832 }
 833
 834
 835 int libvlc_video_get_logo_int( libvlc_media_player_t *p_mi,
 836                                unsigned option, libvlc_exception_t *p_e )
 837 {
 838     return get_int( p_mi, "logo", logo_option_bynumber(option,p_e), p_e );
 839 }
 840
 841