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