git.sesse.net Git - vlc/blob - lib/video.c

   1 /*****************************************************************************
   2  * video.c: libvlc new API video functions
   3  *****************************************************************************
   4  * Copyright (C) 2005-2010 VLC authors and VideoLAN
   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 it
  14  * under the terms of the GNU Lesser General Public License as published by
  15  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this program; if not, write to the Free Software Foundation,
  25  * 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 <assert.h>
  42
  43 /*
  44  * Remember to release the returned vout_thread_t.
  45  */
  46 static vout_thread_t **GetVouts( libvlc_media_player_t *p_mi, size_t *n )
  47 {
  48     input_thread_t *p_input = libvlc_get_input_thread( p_mi );
  49     if( !p_input )
  50     {
  51         *n = 0;
  52         return NULL;
  53     }
  54
  55     vout_thread_t **pp_vouts;
  56     if (input_Control( p_input, INPUT_GET_VOUTS, &pp_vouts, n))
  57     {
  58         *n = 0;
  59         pp_vouts = NULL;
  60     }
  61     vlc_object_release (p_input);
  62     return pp_vouts;
  63 }
  64
  65 static vout_thread_t *GetVout (libvlc_media_player_t *mp, size_t num)
  66 {
  67     vout_thread_t *p_vout = NULL;
  68     size_t n;
  69     vout_thread_t **pp_vouts = GetVouts (mp, &n);
  70     if (pp_vouts == NULL)
  71         goto err;
  72
  73     if (num < n)
  74         p_vout = pp_vouts[num];
  75
  76     for (size_t i = 0; i < n; i++)
  77         if (i != num)
  78             vlc_object_release (pp_vouts[i]);
  79     free (pp_vouts);
  80
  81     if (p_vout == NULL)
  82 err:
  83         libvlc_printerr ("Video output not active");
  84     return p_vout;
  85 }
  86
  87 /**********************************************************************
  88  * Exported functions
  89  **********************************************************************/
  90
  91 void libvlc_set_fullscreen( libvlc_media_player_t *p_mi, int b_fullscreen )
  92 {
  93     /* This will work even if the video is not currently active */
  94     var_SetBool (p_mi, "fullscreen", !!b_fullscreen);
  95
  96     /* Apply to current video outputs (if any) */
  97     size_t n;
  98     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
  99     for (size_t i = 0; i < n; i++)
 100     {
 101         var_SetBool (pp_vouts[i], "fullscreen", b_fullscreen);
 102         vlc_object_release (pp_vouts[i]);
 103     }
 104     free (pp_vouts);
 105 }
 106
 107 int libvlc_get_fullscreen( libvlc_media_player_t *p_mi )
 108 {
 109     return var_GetBool (p_mi, "fullscreen");
 110 }
 111
 112 void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi )
 113 {
 114     bool b_fullscreen = var_ToggleBool (p_mi, "fullscreen");
 115
 116     /* Apply to current video outputs (if any) */
 117     size_t n;
 118     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 119     for (size_t i = 0; i < n; i++)
 120     {
 121         vout_thread_t *p_vout = pp_vouts[i];
 122
 123         var_SetBool (p_vout, "fullscreen", b_fullscreen);
 124         vlc_object_release (p_vout);
 125     }
 126     free (pp_vouts);
 127 }
 128
 129 void libvlc_video_set_key_input( libvlc_media_player_t *p_mi, unsigned on )
 130 {
 131     var_SetBool (p_mi, "keyboard-events", !!on);
 132 }
 133
 134 void libvlc_video_set_mouse_input( libvlc_media_player_t *p_mi, unsigned on )
 135 {
 136     var_SetBool (p_mi, "mouse-events", !!on);
 137 }
 138
 139 int
 140 libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, unsigned num,
 141                             const char *psz_filepath,
 142                             unsigned int i_width, unsigned int i_height )
 143 {
 144     assert( psz_filepath );
 145
 146     vout_thread_t *p_vout = GetVout (p_mi, num);
 147     if (p_vout == NULL)
 148         return -1;
 149
 150     /* FIXME: This is not atomic. Someone else could change the values,
 151      * at least in theory. */
 152     var_SetInteger( p_vout, "snapshot-width", i_width);
 153     var_SetInteger( p_vout, "snapshot-height", i_height );
 154     var_SetString( p_vout, "snapshot-path", psz_filepath );
 155     var_SetString( p_vout, "snapshot-format", "png" );
 156     var_TriggerCallback( p_vout, "video-snapshot" );
 157     vlc_object_release( p_vout );
 158     return 0;
 159 }
 160
 161 int libvlc_video_get_size( libvlc_media_player_t *p_mi, unsigned num,
 162                            unsigned *restrict px, unsigned *restrict py )
 163 {
 164     libvlc_media_track_info_t *info;
 165     int ret = -1;
 166     int infos = libvlc_media_get_tracks_info(p_mi->p_md, &info);
 167     if (infos <= 0)
 168         return ret;
 169
 170     for (int i = 0; i < infos; i++)
 171         if (info[i].i_type == libvlc_track_video && num-- == 0) {
 172             *px = info[i].u.video.i_width;
 173             *py = info[i].u.video.i_height;
 174             ret = 0;
 175             break;
 176         }
 177
 178     free(info);
 179     return ret;
 180 }
 181
 182 int libvlc_video_get_height( libvlc_media_player_t *p_mi )
 183 {
 184     unsigned width, height;
 185
 186     if (libvlc_video_get_size (p_mi, 0, &width, &height))
 187         return 0;
 188     return height;
 189 }
 190
 191 int libvlc_video_get_width( libvlc_media_player_t *p_mi )
 192 {
 193     unsigned width, height;
 194
 195     if (libvlc_video_get_size (p_mi, 0, &width, &height))
 196         return 0;
 197     return width;
 198 }
 199
 200 int libvlc_video_get_cursor( libvlc_media_player_t *mp, unsigned num,
 201                              int *restrict px, int *restrict py )
 202 {
 203     vout_thread_t *p_vout = GetVout (mp, num);
 204     if (p_vout == NULL)
 205         return -1;
 206
 207     var_GetCoords (p_vout, "mouse-moved", px, py);
 208     vlc_object_release (p_vout);
 209     return 0;
 210 }
 211
 212 unsigned libvlc_media_player_has_vout( libvlc_media_player_t *p_mi )
 213 {
 214     size_t n;
 215     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 216     for (size_t i = 0; i < n; i++)
 217         vlc_object_release (pp_vouts[i]);
 218     free (pp_vouts);
 219     return n;
 220 }
 221
 222 float libvlc_video_get_scale( libvlc_media_player_t *mp )
 223 {
 224     float f_scale = var_GetFloat (mp, "scale");
 225     if (var_GetBool (mp, "autoscale"))
 226         f_scale = 0.;
 227     return f_scale;
 228 }
 229
 230 void libvlc_video_set_scale( libvlc_media_player_t *p_mp, float f_scale )
 231 {
 232     if (f_scale != 0.)
 233         var_SetFloat (p_mp, "scale", f_scale);
 234     var_SetBool (p_mp, "autoscale", f_scale == 0.);
 235
 236     /* Apply to current video outputs (if any) */
 237     size_t n;
 238     vout_thread_t **pp_vouts = GetVouts (p_mp, &n);
 239     for (size_t i = 0; i < n; i++)
 240     {
 241         vout_thread_t *p_vout = pp_vouts[i];
 242
 243         if (f_scale != 0.)
 244             var_SetFloat (p_vout, "scale", f_scale);
 245         var_SetBool (p_vout, "autoscale", f_scale == 0.);
 246         vlc_object_release (p_vout);
 247     }
 248     free (pp_vouts);
 249 }
 250
 251 char *libvlc_video_get_aspect_ratio( libvlc_media_player_t *p_mi )
 252 {
 253     return var_GetNonEmptyString (p_mi, "aspect-ratio");
 254 }
 255
 256 void libvlc_video_set_aspect_ratio( libvlc_media_player_t *p_mi,
 257                                     const char *psz_aspect )
 258 {
 259     if (psz_aspect == NULL)
 260         psz_aspect = "";
 261     var_SetString (p_mi, "aspect-ratio", psz_aspect);
 262
 263     size_t n;
 264     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 265     for (size_t i = 0; i < n; i++)
 266     {
 267         vout_thread_t *p_vout = pp_vouts[i];
 268
 269         var_SetString (p_vout, "aspect-ratio", psz_aspect);
 270         vlc_object_release (p_vout);
 271     }
 272     free (pp_vouts);
 273 }
 274
 275 int libvlc_video_get_spu( libvlc_media_player_t *p_mi )
 276 {
 277     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 278     vlc_value_t val_list;
 279     vlc_value_t val;
 280     int i_spu = -1;
 281     int i_ret = -1;
 282     int i;
 283
 284     if( !p_input_thread )
 285     {
 286         libvlc_printerr( "No active input" );
 287         return -1;
 288     }
 289
 290     i_ret = var_Get( p_input_thread, "spu-es", &val );
 291     if( i_ret < 0 )
 292     {
 293         vlc_object_release( p_input_thread );
 294         libvlc_printerr( "Subtitle information not found" );
 295         return -1;
 296     }
 297
 298     var_Change( p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 299     for( i = 0; i < val_list.p_list->i_count; i++ )
 300     {
 301         if( val.i_int == val_list.p_list->p_values[i].i_int )
 302         {
 303             i_spu = i;
 304             break;
 305         }
 306     }
 307     var_FreeList( &val_list, NULL );
 308     vlc_object_release( p_input_thread );
 309     return i_spu;
 310 }
 311
 312 int libvlc_video_get_spu_count( libvlc_media_player_t *p_mi )
 313 {
 314     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 315     int i_spu_count;
 316
 317     if( !p_input_thread )
 318         return 0;
 319
 320     i_spu_count = var_CountChoices( p_input_thread, "spu-es" );
 321     vlc_object_release( p_input_thread );
 322     return i_spu_count;
 323 }
 324
 325 libvlc_track_description_t *
 326         libvlc_video_get_spu_description( libvlc_media_player_t *p_mi )
 327 {
 328     return libvlc_get_track_description( p_mi, "spu-es" );
 329 }
 330
 331 int libvlc_video_set_spu( libvlc_media_player_t *p_mi, unsigned i_spu )
 332 {
 333     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 334     vlc_value_t list;
 335     int i_ret = 0;
 336
 337     if( !p_input_thread )
 338         return -1;
 339
 340     var_Change (p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &list, NULL);
 341
 342     if (i_spu > (unsigned)list.p_list->i_count)
 343     {
 344         libvlc_printerr( "Subtitle number out of range (%u/%u)",
 345                          i_spu, list.p_list->i_count );
 346         i_ret = -1;
 347         goto end;
 348     }
 349     var_SetInteger (p_input_thread, "spu-es",
 350                     list.p_list->p_values[i_spu].i_int);
 351 end:
 352     vlc_object_release (p_input_thread);
 353     var_FreeList (&list, NULL);
 354     return i_ret;
 355 }
 356
 357 int libvlc_video_set_subtitle_file( libvlc_media_player_t *p_mi,
 358                                     const char *psz_subtitle )
 359 {
 360     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
 361     bool b_ret = false;
 362
 363     if( p_input_thread )
 364     {
 365         if( !input_AddSubtitle( p_input_thread, psz_subtitle, true ) )
 366             b_ret = true;
 367         vlc_object_release( p_input_thread );
 368     }
 369     return b_ret;
 370 }
 371
 372 int64_t libvlc_video_get_spu_delay( libvlc_media_player_t *p_mi )
 373 {
 374     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 375     int64_t val = 0;
 376
 377     if( p_input_thread )
 378     {
 379         val = var_GetTime( p_input_thread, "spu-delay" );
 380         vlc_object_release( p_input_thread );
 381     }
 382     else
 383     {
 384         libvlc_printerr( "No active input" );
 385     }
 386
 387     return val;
 388 }
 389
 390 int libvlc_video_set_spu_delay( libvlc_media_player_t *p_mi,
 391                                 int64_t i_delay )
 392 {
 393     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 394     int ret = -1;
 395
 396     if( p_input_thread )
 397     {
 398         var_SetTime( p_input_thread, "spu-delay", i_delay );
 399         vlc_object_release( p_input_thread );
 400         ret = 0;
 401     }
 402     else
 403     {
 404         libvlc_printerr( "No active input" );
 405     }
 406
 407     return ret;
 408 }
 409
 410 libvlc_track_description_t *
 411         libvlc_video_get_title_description( libvlc_media_player_t *p_mi )
 412 {
 413     return libvlc_get_track_description( p_mi, "title" );
 414 }
 415
 416 libvlc_track_description_t *
 417         libvlc_video_get_chapter_description( libvlc_media_player_t *p_mi,
 418                                               int i_title )
 419 {
 420     char psz_title[12];
 421     sprintf( psz_title,  "title %2i", i_title );
 422     return libvlc_get_track_description( p_mi, psz_title );
 423 }
 424
 425 char *libvlc_video_get_crop_geometry (libvlc_media_player_t *p_mi)
 426 {
 427     return var_GetNonEmptyString (p_mi, "crop");
 428 }
 429
 430 void libvlc_video_set_crop_geometry( libvlc_media_player_t *p_mi,
 431                                      const char *psz_geometry )
 432 {
 433     if (psz_geometry == NULL)
 434         psz_geometry = "";
 435
 436     var_SetString (p_mi, "crop", psz_geometry);
 437
 438     size_t n;
 439     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 440
 441     for (size_t i = 0; i < n; i++)
 442     {
 443         vout_thread_t *p_vout = pp_vouts[i];
 444         vlc_value_t val;
 445
 446         /* Make sure the geometry is in the choice list */
 447         /* Earlier choices are removed to not grow a long list over time. */
 448         /* FIXME: not atomic - lock? */
 449         val.psz_string = (char *)psz_geometry;
 450         var_Change (p_vout, "crop", VLC_VAR_CLEARCHOICES, NULL, NULL);
 451         var_Change (p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &val);
 452         var_SetString (p_vout, "crop", psz_geometry);
 453         vlc_object_release (p_vout);
 454     }
 455     free (pp_vouts);
 456 }
 457
 458 int libvlc_video_get_teletext( libvlc_media_player_t *p_mi )
 459 {
 460     return var_GetInteger (p_mi, "vbi-page");
 461 }
 462
 463 void libvlc_video_set_teletext( libvlc_media_player_t *p_mi, int i_page )
 464 {
 465     input_thread_t *p_input_thread;
 466     vlc_object_t *p_zvbi = NULL;
 467     int telx;
 468
 469     var_SetInteger (p_mi, "vbi-page", i_page);
 470
 471     p_input_thread = libvlc_get_input_thread( p_mi );
 472     if( !p_input_thread ) return;
 473
 474     if( var_CountChoices( p_input_thread, "teletext-es" ) <= 0 )
 475     {
 476         vlc_object_release( p_input_thread );
 477         return;
 478     }
 479
 480     telx = var_GetInteger( p_input_thread, "teletext-es" );
 481     if( input_GetEsObjects( p_input_thread, telx, &p_zvbi, NULL, NULL )
 482         == VLC_SUCCESS )
 483     {
 484         var_SetInteger( p_zvbi, "vbi-page", i_page );
 485         vlc_object_release( p_zvbi );
 486     }
 487     vlc_object_release( p_input_thread );
 488 }
 489
 490 void libvlc_toggle_teletext( libvlc_media_player_t *p_mi )
 491 {
 492     input_thread_t *p_input_thread;
 493
 494     p_input_thread = libvlc_get_input_thread(p_mi);
 495     if( !p_input_thread ) return;
 496
 497     if( var_CountChoices( p_input_thread, "teletext-es" ) <= 0 )
 498     {
 499         vlc_object_release( p_input_thread );
 500         return;
 501     }
 502     const bool b_selected = var_GetInteger( p_input_thread, "teletext-es" ) >= 0;
 503     if( b_selected )
 504     {
 505         var_SetInteger( p_input_thread, "spu-es", -1 );
 506     }
 507     else
 508     {
 509         vlc_value_t list;
 510         if( !var_Change( p_input_thread, "teletext-es", VLC_VAR_GETLIST, &list, NULL ) )
 511         {
 512             if( list.p_list->i_count > 0 )
 513                 var_SetInteger( p_input_thread, "spu-es", list.p_list->p_values[0].i_int );
 514
 515             var_FreeList( &list, NULL );
 516         }
 517     }
 518     vlc_object_release( p_input_thread );
 519 }
 520
 521 int libvlc_video_get_track_count( libvlc_media_player_t *p_mi )
 522 {
 523     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 524     int i_track_count;
 525
 526     if( !p_input_thread )
 527         return -1;
 528
 529     i_track_count = var_CountChoices( p_input_thread, "video-es" );
 530
 531     vlc_object_release( p_input_thread );
 532     return i_track_count;
 533 }
 534
 535 libvlc_track_description_t *
 536         libvlc_video_get_track_description( libvlc_media_player_t *p_mi )
 537 {
 538     return libvlc_get_track_description( p_mi, "video-es" );
 539 }
 540
 541 int libvlc_video_get_track( libvlc_media_player_t *p_mi )
 542 {
 543     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 544     vlc_value_t val_list;
 545     vlc_value_t val;
 546     int i_track = -1;
 547
 548     if( !p_input_thread )
 549         return -1;
 550
 551     if( var_Get( p_input_thread, "video-es", &val ) < 0 )
 552     {
 553         libvlc_printerr( "Video track information not found" );
 554         vlc_object_release( p_input_thread );
 555         return -1;
 556     }
 557
 558     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 559     for( int i = 0; i < val_list.p_list->i_count; i++ )
 560     {
 561         if( val_list.p_list->p_values[i].i_int == val.i_int )
 562         {
 563             i_track = i;
 564             break;
 565         }
 566     }
 567     var_FreeList( &val_list, NULL );
 568     vlc_object_release( p_input_thread );
 569     return i_track;
 570 }
 571
 572 int libvlc_video_set_track( libvlc_media_player_t *p_mi, int i_track )
 573 {
 574     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 575     vlc_value_t val_list;
 576     int i_ret = -1;
 577
 578     if( !p_input_thread )
 579         return -1;
 580
 581     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 582     for( int i = 0; i < val_list.p_list->i_count; i++ )
 583     {
 584         if( i_track == val_list.p_list->p_values[i].i_int )
 585         {
 586             if( var_SetInteger( p_input_thread, "video-es", i_track ) < 0 )
 587                 break;
 588             i_ret = 0;
 589             goto end;
 590         }
 591     }
 592     libvlc_printerr( "Video track number out of range" );
 593 end:
 594     var_FreeList( &val_list, NULL );
 595     vlc_object_release( p_input_thread );
 596     return i_ret;
 597 }
 598
 599 /******************************************************************************
 600  * libvlc_video_set_deinterlace : enable deinterlace
 601  *****************************************************************************/
 602 void libvlc_video_set_deinterlace( libvlc_media_player_t *p_mi,
 603                                    const char *psz_mode )
 604 {
 605     if (psz_mode == NULL)
 606         psz_mode = "";
 607     if (*psz_mode
 608      && strcmp (psz_mode, "blend")    && strcmp (psz_mode, "bob")
 609      && strcmp (psz_mode, "discard")  && strcmp (psz_mode, "linear")
 610      && strcmp (psz_mode, "mean")     && strcmp (psz_mode, "x")
 611      && strcmp (psz_mode, "yadif")    && strcmp (psz_mode, "yadif2x")
 612      && strcmp (psz_mode, "phosphor") && strcmp (psz_mode, "ivtc"))
 613         return;
 614
 615     if (*psz_mode)
 616     {
 617         var_SetString (p_mi, "deinterlace-mode", psz_mode);
 618         var_SetInteger (p_mi, "deinterlace", 1);
 619     }
 620     else
 621         var_SetInteger (p_mi, "deinterlace", 0);
 622
 623     size_t n;
 624     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 625     for (size_t i = 0; i < n; i++)
 626     {
 627         vout_thread_t *p_vout = pp_vouts[i];
 628
 629         if (*psz_mode)
 630         {
 631             var_SetString (p_vout, "deinterlace-mode", psz_mode);
 632             var_SetInteger (p_vout, "deinterlace", 1);
 633         }
 634         else
 635             var_SetInteger (p_vout, "deinterlace", 0);
 636         vlc_object_release (p_vout);
 637     }
 638     free (pp_vouts);
 639 }
 640
 641 /* ************** */
 642 /* module helpers */
 643 /* ************** */
 644
 645
 646 static vlc_object_t *get_object( libvlc_media_player_t * p_mi,
 647                                  const char *name )
 648 {
 649     vlc_object_t *object;
 650     vout_thread_t *vout = GetVout( p_mi, 0 );
 651
 652     if( vout )
 653     {
 654         object = vlc_object_find_name( vout, name );
 655         vlc_object_release(vout);
 656     }
 657     else
 658         object = NULL;
 659
 660     if( !object )
 661         libvlc_printerr( "%s not enabled", name );
 662     return object;
 663 }
 664
 665
 666 typedef const struct {
 667     const char name[20];
 668     unsigned type;
 669 } opt_t;
 670
 671
 672 static void
 673 set_int( libvlc_media_player_t *p_mi, const char *restrict name,
 674          const opt_t *restrict opt, int value )
 675 {
 676     if( !opt ) return;
 677
 678     if( !opt->type ) /* the enabler */
 679     {
 680         vout_thread_t *vout = GetVout( p_mi, 0 );
 681         if (vout)
 682         {
 683             vout_EnableFilter( vout, opt->name, value, false );
 684             vlc_object_release( vout );
 685         }
 686         return;
 687     }
 688
 689     if( opt->type != VLC_VAR_INTEGER )
 690     {
 691         libvlc_printerr( "Invalid argument to %s in %s", name, "set int" );
 692         return;
 693     }
 694
 695     var_SetInteger(p_mi, opt->name, value);
 696     vlc_object_t *object = get_object( p_mi, name );
 697     if( object )
 698     {
 699         var_SetInteger(object, opt->name, value);
 700         vlc_object_release( object );
 701     }
 702 }
 703
 704
 705 static int
 706 get_int( libvlc_media_player_t *p_mi, const char *restrict name,
 707          const opt_t *restrict opt )
 708 {
 709     if( !opt ) return 0;
 710
 711     switch( opt->type )
 712     {
 713         case 0: /* the enabler */
 714         {
 715             vlc_object_t *object = get_object( p_mi, name );
 716             vlc_object_release( object );
 717             return object != NULL;
 718         }
 719     case VLC_VAR_INTEGER:
 720         return var_GetInteger(p_mi, opt->name);
 721     default:
 722         libvlc_printerr( "Invalid argument to %s in %s", name, "get int" );
 723         return 0;
 724     }
 725 }
 726
 727
 728 static void
 729 set_float( libvlc_media_player_t *p_mi, const char *restrict name,
 730             const opt_t *restrict opt, float value )
 731 {
 732     if( !opt ) return;
 733
 734     if( opt->type != VLC_VAR_FLOAT )
 735     {
 736         libvlc_printerr( "Invalid argument to %s in %s", name, "set float" );
 737         return;
 738     }
 739
 740     var_SetFloat( p_mi, opt->name, value );
 741
 742     vlc_object_t *object = get_object( p_mi, name );
 743     if( object )
 744     {
 745         var_SetFloat(object, opt->name, value );
 746         vlc_object_release( object );
 747     }
 748 }
 749
 750
 751 static float
 752 get_float( libvlc_media_player_t *p_mi, const char *restrict name,
 753             const opt_t *restrict opt )
 754 {
 755     if( !opt ) return 0.0;
 756
 757
 758     if( opt->type != VLC_VAR_FLOAT )
 759     {
 760         libvlc_printerr( "Invalid argument to %s in %s", name, "get float" );
 761         return 0.0;
 762     }
 763
 764     return var_GetFloat( p_mi, opt->name );
 765 }
 766
 767
 768 static void
 769 set_string( libvlc_media_player_t *p_mi, const char *restrict name,
 770             const opt_t *restrict opt, const char *restrict psz_value )
 771 {
 772     if( !opt ) return;
 773
 774     if( opt->type != VLC_VAR_STRING )
 775     {
 776         libvlc_printerr( "Invalid argument to %s in %s", name, "set string" );
 777         return;
 778     }
 779
 780     var_SetString( p_mi, opt->name, psz_value );
 781
 782     vlc_object_t *object = get_object( p_mi, name );
 783     if( object )
 784     {
 785         var_SetString(object, opt->name, psz_value );
 786         vlc_object_release( object );
 787     }
 788 }
 789
 790
 791 static char *
 792 get_string( libvlc_media_player_t *p_mi, const char *restrict name,
 793             const opt_t *restrict opt )
 794 {
 795     if( !opt ) return NULL;
 796
 797     if( opt->type != VLC_VAR_STRING )
 798     {
 799         libvlc_printerr( "Invalid argument to %s in %s", name, "get string" );
 800         return NULL;
 801     }
 802
 803     return var_GetString( p_mi, opt->name );
 804 }
 805
 806
 807 static const opt_t *
 808 marq_option_bynumber(unsigned option)
 809 {
 810     static const opt_t optlist[] =
 811     {
 812         { "marq",          0 },
 813         { "marq-marquee",  VLC_VAR_STRING },
 814         { "marq-color",    VLC_VAR_INTEGER },
 815         { "marq-opacity",  VLC_VAR_INTEGER },
 816         { "marq-position", VLC_VAR_INTEGER },
 817         { "marq-refresh",  VLC_VAR_INTEGER },
 818         { "marq-size",     VLC_VAR_INTEGER },
 819         { "marq-timeout",  VLC_VAR_INTEGER },
 820         { "marq-x",        VLC_VAR_INTEGER },
 821         { "marq-y",        VLC_VAR_INTEGER },
 822     };
 823     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
 824
 825     const opt_t *r = option < num_opts ? optlist+option : NULL;
 826     if( !r )
 827         libvlc_printerr( "Unknown marquee option" );
 828     return r;
 829 }
 830
 831 static vlc_object_t *get_object( libvlc_media_player_t *, const char *);
 832
 833 /*****************************************************************************
 834  * libvlc_video_get_marquee_int : get a marq option value
 835  *****************************************************************************/
 836 int libvlc_video_get_marquee_int( libvlc_media_player_t *p_mi,
 837                                   unsigned option )
 838 {
 839     return get_int( p_mi, "marq", marq_option_bynumber(option) );
 840 }
 841
 842 /*****************************************************************************
 843  * libvlc_video_get_marquee_string : get a marq option value
 844  *****************************************************************************/
 845 char * libvlc_video_get_marquee_string( libvlc_media_player_t *p_mi,
 846                                         unsigned option )
 847 {
 848     return get_string( p_mi, "marq", marq_option_bynumber(option) );
 849 }
 850
 851 /*****************************************************************************
 852  * libvlc_video_set_marquee_int: enable, disable or set an int option
 853  *****************************************************************************/
 854 void libvlc_video_set_marquee_int( libvlc_media_player_t *p_mi,
 855                          unsigned option, int value )
 856 {
 857     set_int( p_mi, "marq", marq_option_bynumber(option), value );
 858 }
 859
 860 /*****************************************************************************
 861  * libvlc_video_set_marquee_string: set a string option
 862  *****************************************************************************/
 863 void libvlc_video_set_marquee_string( libvlc_media_player_t *p_mi,
 864                 unsigned option, const char * value )
 865 {
 866     set_string( p_mi, "marq", marq_option_bynumber(option), value );
 867 }
 868
 869
 870 /* logo module support */
 871
 872
 873 static const opt_t *
 874 logo_option_bynumber( unsigned option )
 875 {
 876     static const opt_t vlogo_optlist[] =
 877     /* depends on libvlc_video_logo_option_t */
 878     {
 879         { "logo",          0 },
 880         { "logo-file",     VLC_VAR_STRING },
 881         { "logo-x",        VLC_VAR_INTEGER },
 882         { "logo-y",        VLC_VAR_INTEGER },
 883         { "logo-delay",    VLC_VAR_INTEGER },
 884         { "logo-repeat",   VLC_VAR_INTEGER },
 885         { "logo-opacity",  VLC_VAR_INTEGER },
 886         { "logo-position", VLC_VAR_INTEGER },
 887     };
 888     enum { num_vlogo_opts = sizeof(vlogo_optlist) / sizeof(*vlogo_optlist) };
 889
 890     const opt_t *r = option < num_vlogo_opts ? vlogo_optlist+option : NULL;
 891     if( !r )
 892         libvlc_printerr( "Unknown logo option" );
 893     return r;
 894 }
 895
 896
 897 void libvlc_video_set_logo_string( libvlc_media_player_t *p_mi,
 898                                    unsigned option, const char *psz_value )
 899 {
 900     set_string( p_mi,"logo",logo_option_bynumber(option),psz_value );
 901 }
 902
 903
 904 void libvlc_video_set_logo_int( libvlc_media_player_t *p_mi,
 905                                 unsigned option, int value )
 906 {
 907     set_int( p_mi, "logo", logo_option_bynumber(option), value );
 908 }
 909
 910
 911 int libvlc_video_get_logo_int( libvlc_media_player_t *p_mi,
 912                                unsigned option )
 913 {
 914     return get_int( p_mi, "logo", logo_option_bynumber(option) );
 915 }
 916
 917
 918 /* adjust module support */
 919
 920
 921 static const opt_t *
 922 adjust_option_bynumber( unsigned option )
 923 {
 924     static const opt_t optlist[] =
 925     {
 926         { "adjust",               0 },
 927         { "contrast",             VLC_VAR_FLOAT },
 928         { "brightness",           VLC_VAR_FLOAT },
 929         { "hue",                  VLC_VAR_INTEGER },
 930         { "saturation",           VLC_VAR_FLOAT },
 931         { "gamma",                VLC_VAR_FLOAT },
 932     };
 933     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
 934
 935     const opt_t *r = option < num_opts ? optlist+option : NULL;
 936     if( !r )
 937         libvlc_printerr( "Unknown adjust option" );
 938     return r;
 939 }
 940
 941
 942 void libvlc_video_set_adjust_int( libvlc_media_player_t *p_mi,
 943                                   unsigned option, int value )
 944 {
 945     set_int( p_mi, "adjust", adjust_option_bynumber(option), value );
 946 }
 947
 948
 949 int libvlc_video_get_adjust_int( libvlc_media_player_t *p_mi,
 950                                  unsigned option )
 951 {
 952     return get_int( p_mi, "adjust", adjust_option_bynumber(option) );
 953 }
 954
 955
 956 void libvlc_video_set_adjust_float( libvlc_media_player_t *p_mi,
 957                                     unsigned option, float value )
 958 {
 959     set_float( p_mi, "adjust", adjust_option_bynumber(option), value );
 960 }
 961
 962
 963 float libvlc_video_get_adjust_float( libvlc_media_player_t *p_mi,
 964                                      unsigned option )
 965 {
 966     return get_float( p_mi, "adjust", adjust_option_bynumber(option) );
 967 }