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