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_renderer_discoverer.h>
  34 #include <vlc/libvlc_media.h>
  35 #include <vlc/libvlc_media_player.h>
  36
  37 #include <vlc_common.h>
  38 #include <vlc_modules.h>
  39 #include <vlc_input.h>
  40 #include <vlc_vout.h>
  41 #include <vlc_url.h>
  42
  43 #include "libvlc_internal.h"
  44 #include "media_player_internal.h"
  45 #include <math.h>
  46 #include <assert.h>
  47
  48 /*
  49  * Remember to release the returned vout_thread_t.
  50  */
  51 static vout_thread_t **GetVouts( libvlc_media_player_t *p_mi, size_t *n )
  52 {
  53     input_thread_t *p_input = libvlc_get_input_thread( p_mi );
  54     if( !p_input )
  55     {
  56         *n = 0;
  57         return NULL;
  58     }
  59
  60     vout_thread_t **pp_vouts;
  61     if (input_Control( p_input, INPUT_GET_VOUTS, &pp_vouts, n))
  62     {
  63         *n = 0;
  64         pp_vouts = NULL;
  65     }
  66     vlc_object_release (p_input);
  67     return pp_vouts;
  68 }
  69
  70 static vout_thread_t *GetVout (libvlc_media_player_t *mp, size_t num)
  71 {
  72     vout_thread_t *p_vout = NULL;
  73     size_t n;
  74     vout_thread_t **pp_vouts = GetVouts (mp, &n);
  75     if (pp_vouts == NULL)
  76         goto err;
  77
  78     if (num < n)
  79         p_vout = pp_vouts[num];
  80
  81     for (size_t i = 0; i < n; i++)
  82         if (i != num)
  83             vlc_object_release (pp_vouts[i]);
  84     free (pp_vouts);
  85
  86     if (p_vout == NULL)
  87 err:
  88         libvlc_printerr ("Video output not active");
  89     return p_vout;
  90 }
  91
  92 /**********************************************************************
  93  * Exported functions
  94  **********************************************************************/
  95
  96 void libvlc_set_fullscreen( libvlc_media_player_t *p_mi, int b_fullscreen )
  97 {
  98     /* This will work even if the video is not currently active */
  99     var_SetBool (p_mi, "fullscreen", !!b_fullscreen);
 100
 101     /* Apply to current video outputs (if any) */
 102     size_t n;
 103     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 104     for (size_t i = 0; i < n; i++)
 105     {
 106         var_SetBool (pp_vouts[i], "fullscreen", b_fullscreen);
 107         vlc_object_release (pp_vouts[i]);
 108     }
 109     free (pp_vouts);
 110 }
 111
 112 int libvlc_get_fullscreen( libvlc_media_player_t *p_mi )
 113 {
 114     return var_GetBool (p_mi, "fullscreen");
 115 }
 116
 117 void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi )
 118 {
 119     bool b_fullscreen = var_ToggleBool (p_mi, "fullscreen");
 120
 121     /* Apply to current video outputs (if any) */
 122     size_t n;
 123     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 124     for (size_t i = 0; i < n; i++)
 125     {
 126         vout_thread_t *p_vout = pp_vouts[i];
 127
 128         var_SetBool (p_vout, "fullscreen", b_fullscreen);
 129         vlc_object_release (p_vout);
 130     }
 131     free (pp_vouts);
 132 }
 133
 134 void libvlc_video_set_key_input( libvlc_media_player_t *p_mi, unsigned on )
 135 {
 136     var_SetBool (p_mi, "keyboard-events", !!on);
 137 }
 138
 139 void libvlc_video_set_mouse_input( libvlc_media_player_t *p_mi, unsigned on )
 140 {
 141     var_SetBool (p_mi, "mouse-events", !!on);
 142 }
 143
 144 int
 145 libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, unsigned num,
 146                             const char *psz_filepath,
 147                             unsigned int i_width, unsigned int i_height )
 148 {
 149     assert( psz_filepath );
 150
 151     vout_thread_t *p_vout = GetVout (p_mi, num);
 152     if (p_vout == NULL)
 153         return -1;
 154
 155     /* FIXME: This is not atomic. All parameters should be passed at once
 156      * (obviously _not_ with var_*()). Also, the libvlc object should not be
 157      * used for the callbacks: that breaks badly if there are concurrent
 158      * media players in the instance. */
 159     var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER );
 160     var_SetInteger( p_vout, "snapshot-width", i_width);
 161     var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER );
 162     var_SetInteger( p_vout, "snapshot-height", i_height );
 163     var_Create( p_vout, "snapshot-path", VLC_VAR_STRING );
 164     var_SetString( p_vout, "snapshot-path", psz_filepath );
 165     var_Create( p_vout, "snapshot-format", VLC_VAR_STRING );
 166     var_SetString( p_vout, "snapshot-format", "png" );
 167     var_TriggerCallback( p_vout, "video-snapshot" );
 168     vlc_object_release( p_vout );
 169     return 0;
 170 }
 171
 172 int libvlc_video_get_size( libvlc_media_player_t *p_mi, unsigned num,
 173                            unsigned *restrict px, unsigned *restrict py )
 174 {
 175     libvlc_media_track_info_t *info;
 176     int ret = -1;
 177     if (!p_mi->p_md)
 178         return ret;
 179     int infos = libvlc_media_get_tracks_info(p_mi->p_md, &info);
 180     if (infos <= 0)
 181         return ret;
 182
 183     for (int i = 0; i < infos; i++)
 184         if (info[i].i_type == libvlc_track_video && num-- == 0) {
 185             *px = info[i].u.video.i_width;
 186             *py = info[i].u.video.i_height;
 187             ret = 0;
 188             break;
 189         }
 190
 191     free(info);
 192     return ret;
 193 }
 194
 195 int libvlc_video_get_height( libvlc_media_player_t *p_mi )
 196 {
 197     unsigned width, height;
 198
 199     if (libvlc_video_get_size (p_mi, 0, &width, &height))
 200         return 0;
 201     return height;
 202 }
 203
 204 int libvlc_video_get_width( libvlc_media_player_t *p_mi )
 205 {
 206     unsigned width, height;
 207
 208     if (libvlc_video_get_size (p_mi, 0, &width, &height))
 209         return 0;
 210     return width;
 211 }
 212
 213 int libvlc_video_get_cursor( libvlc_media_player_t *mp, unsigned num,
 214                              int *restrict px, int *restrict py )
 215 {
 216     vout_thread_t *p_vout = GetVout (mp, num);
 217     if (p_vout == NULL)
 218         return -1;
 219
 220     var_GetCoords (p_vout, "mouse-moved", px, py);
 221     vlc_object_release (p_vout);
 222     return 0;
 223 }
 224
 225 unsigned libvlc_media_player_has_vout( libvlc_media_player_t *p_mi )
 226 {
 227     size_t n;
 228     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 229     for (size_t i = 0; i < n; i++)
 230         vlc_object_release (pp_vouts[i]);
 231     free (pp_vouts);
 232     return n;
 233 }
 234
 235 float libvlc_video_get_scale( libvlc_media_player_t *mp )
 236 {
 237     float f_scale = var_GetFloat (mp, "zoom");
 238     if (var_GetBool (mp, "autoscale"))
 239         f_scale = 0.f;
 240     return f_scale;
 241 }
 242
 243 void libvlc_video_set_scale( libvlc_media_player_t *p_mp, float f_scale )
 244 {
 245     if (isfinite(f_scale) && f_scale != 0.f)
 246         var_SetFloat (p_mp, "zoom", f_scale);
 247     var_SetBool (p_mp, "autoscale", f_scale == 0.f);
 248
 249     /* Apply to current video outputs (if any) */
 250     size_t n;
 251     vout_thread_t **pp_vouts = GetVouts (p_mp, &n);
 252     for (size_t i = 0; i < n; i++)
 253     {
 254         vout_thread_t *p_vout = pp_vouts[i];
 255
 256         if (isfinite(f_scale) && f_scale != 0.f)
 257             var_SetFloat (p_vout, "zoom", f_scale);
 258         var_SetBool (p_vout, "autoscale", f_scale == 0.f);
 259         vlc_object_release (p_vout);
 260     }
 261     free (pp_vouts);
 262 }
 263
 264 char *libvlc_video_get_aspect_ratio( libvlc_media_player_t *p_mi )
 265 {
 266     return var_GetNonEmptyString (p_mi, "aspect-ratio");
 267 }
 268
 269 void libvlc_video_set_aspect_ratio( libvlc_media_player_t *p_mi,
 270                                     const char *psz_aspect )
 271 {
 272     if (psz_aspect == NULL)
 273         psz_aspect = "";
 274     var_SetString (p_mi, "aspect-ratio", psz_aspect);
 275
 276     size_t n;
 277     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 278     for (size_t i = 0; i < n; i++)
 279     {
 280         vout_thread_t *p_vout = pp_vouts[i];
 281
 282         var_SetString (p_vout, "aspect-ratio", psz_aspect);
 283         vlc_object_release (p_vout);
 284     }
 285     free (pp_vouts);
 286 }
 287
 288 libvlc_video_viewpoint_t *libvlc_video_new_viewpoint(void)
 289 {
 290     libvlc_video_viewpoint_t *p_vp = malloc(sizeof *p_vp);
 291     if (unlikely(p_vp == NULL))
 292         return NULL;
 293     p_vp->f_yaw = p_vp->f_pitch = p_vp->f_roll = p_vp->f_field_of_view = 0.0f;
 294     return p_vp;
 295 }
 296
 297 int libvlc_video_update_viewpoint( libvlc_media_player_t *p_mi,
 298                                    const libvlc_video_viewpoint_t *p_viewpoint,
 299                                    bool b_absolute )
 300 {
 301     vlc_viewpoint_t update = {
 302         .yaw   = p_viewpoint->f_yaw,
 303         .pitch = p_viewpoint->f_pitch,
 304         .roll  = p_viewpoint->f_roll,
 305         .fov   = p_viewpoint->f_field_of_view,
 306     };
 307
 308     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 309     if( p_input_thread != NULL )
 310     {
 311         if( input_UpdateViewpoint( p_input_thread, &update,
 312                                    b_absolute ) != VLC_SUCCESS )
 313         {
 314             vlc_object_release( p_input_thread );
 315             return -1;
 316         }
 317         vlc_object_release( p_input_thread );
 318         return 0;
 319     }
 320
 321     /* Save the viewpoint in case the input is not created yet */
 322     if( !b_absolute )
 323     {
 324         p_mi->viewpoint.yaw += update.yaw;
 325         p_mi->viewpoint.pitch += update.pitch;
 326         p_mi->viewpoint.roll += update.roll;
 327         p_mi->viewpoint.fov += update.fov;
 328     }
 329     else
 330         p_mi->viewpoint = update;
 331
 332     vlc_viewpoint_clip( &p_mi->viewpoint );
 333
 334     return 0;
 335 }
 336
 337 int libvlc_video_get_spu( libvlc_media_player_t *p_mi )
 338 {
 339     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 340
 341     if( !p_input_thread )
 342     {
 343         libvlc_printerr( "No active input" );
 344         return -1;
 345     }
 346
 347     int i_spu = var_GetInteger( p_input_thread, "spu-es" );
 348     vlc_object_release( p_input_thread );
 349     return i_spu;
 350 }
 351
 352 int libvlc_video_get_spu_count( libvlc_media_player_t *p_mi )
 353 {
 354     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 355     int i_spu_count;
 356
 357     if( !p_input_thread )
 358         return 0;
 359
 360     i_spu_count = var_CountChoices( p_input_thread, "spu-es" );
 361     vlc_object_release( p_input_thread );
 362     return i_spu_count;
 363 }
 364
 365 libvlc_track_description_t *
 366         libvlc_video_get_spu_description( libvlc_media_player_t *p_mi )
 367 {
 368     return libvlc_get_track_description( p_mi, "spu-es" );
 369 }
 370
 371 int libvlc_video_set_spu( libvlc_media_player_t *p_mi, int i_spu )
 372 {
 373     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 374     vlc_value_t list;
 375     int i_ret = -1;
 376
 377     if( !p_input_thread )
 378         return -1;
 379
 380     var_Change (p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &list, NULL);
 381     for (int i = 0; i < list.p_list->i_count; i++)
 382     {
 383         if( i_spu == list.p_list->p_values[i].i_int )
 384         {
 385             if( var_SetInteger( p_input_thread, "spu-es", i_spu ) < 0 )
 386                 break;
 387             i_ret = 0;
 388             goto end;
 389         }
 390     }
 391     libvlc_printerr( "Track identifier not found" );
 392 end:
 393     vlc_object_release (p_input_thread);
 394     var_FreeList (&list, NULL);
 395     return i_ret;
 396 }
 397
 398 int libvlc_video_set_subtitle_file( libvlc_media_player_t *p_mi,
 399                                     const char *psz_subtitle )
 400 {
 401     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
 402     bool b_ret = false;
 403
 404     if( p_input_thread )
 405     {
 406         char* psz_mrl = vlc_path2uri( psz_subtitle, NULL );
 407         if( psz_mrl )
 408         {
 409             if( !input_AddSlave( p_input_thread, SLAVE_TYPE_SPU, psz_mrl,
 410                                  true, false, false ) )
 411                 b_ret = true;
 412             free( psz_mrl );
 413         }
 414         vlc_object_release( p_input_thread );
 415     }
 416     return b_ret;
 417 }
 418
 419 int64_t libvlc_video_get_spu_delay( libvlc_media_player_t *p_mi )
 420 {
 421     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 422     int64_t val = 0;
 423
 424     if( p_input_thread )
 425     {
 426         val = var_GetInteger( p_input_thread, "spu-delay" );
 427         vlc_object_release( p_input_thread );
 428     }
 429     else
 430     {
 431         libvlc_printerr( "No active input" );
 432     }
 433
 434     return val;
 435 }
 436
 437 int libvlc_video_set_spu_delay( libvlc_media_player_t *p_mi,
 438                                 int64_t i_delay )
 439 {
 440     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 441     int ret = -1;
 442
 443     if( p_input_thread )
 444     {
 445         var_SetInteger( p_input_thread, "spu-delay", i_delay );
 446         vlc_object_release( p_input_thread );
 447         ret = 0;
 448     }
 449     else
 450     {
 451         libvlc_printerr( "No active input" );
 452     }
 453
 454     return ret;
 455 }
 456
 457 libvlc_track_description_t *
 458         libvlc_video_get_title_description( libvlc_media_player_t *p_mi )
 459 {
 460     return libvlc_get_track_description( p_mi, "title" );
 461 }
 462
 463 libvlc_track_description_t *
 464         libvlc_video_get_chapter_description( libvlc_media_player_t *p_mi,
 465                                               int i_title )
 466 {
 467     char psz_title[sizeof ("title ") + 3 * sizeof (int)];
 468     sprintf( psz_title,  "title %2u", i_title );
 469     return libvlc_get_track_description( p_mi, psz_title );
 470 }
 471
 472 char *libvlc_video_get_crop_geometry (libvlc_media_player_t *p_mi)
 473 {
 474     return var_GetNonEmptyString (p_mi, "crop");
 475 }
 476
 477 void libvlc_video_set_crop_geometry( libvlc_media_player_t *p_mi,
 478                                      const char *psz_geometry )
 479 {
 480     if (psz_geometry == NULL)
 481         psz_geometry = "";
 482
 483     var_SetString (p_mi, "crop", psz_geometry);
 484
 485     size_t n;
 486     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 487
 488     for (size_t i = 0; i < n; i++)
 489     {
 490         vout_thread_t *p_vout = pp_vouts[i];
 491
 492         var_SetString (p_vout, "crop", psz_geometry);
 493         vlc_object_release (p_vout);
 494     }
 495     free (pp_vouts);
 496 }
 497
 498 int libvlc_video_get_teletext( libvlc_media_player_t *p_mi )
 499 {
 500     return var_GetInteger (p_mi, "vbi-page");
 501 }
 502
 503 static void teletext_enable( input_thread_t *p_input_thread, bool b_enable )
 504 {
 505     if( b_enable )
 506     {
 507         vlc_value_t list;
 508         if( !var_Change( p_input_thread, "teletext-es", VLC_VAR_GETCHOICES,
 509                          &list, NULL ) )
 510         {
 511             if( list.p_list->i_count > 0 )
 512                 var_SetInteger( p_input_thread, "spu-es",
 513                                 list.p_list->p_values[0].i_int );
 514
 515             var_FreeList( &list, NULL );
 516         }
 517     }
 518     else
 519         var_SetInteger( p_input_thread, "spu-es", -1 );
 520 }
 521
 522 void libvlc_video_set_teletext( libvlc_media_player_t *p_mi, int i_page )
 523 {
 524     input_thread_t *p_input_thread;
 525     vlc_object_t *p_zvbi = NULL;
 526     int telx;
 527     bool b_key = false;
 528
 529     if( i_page >= 0 && i_page < 1000 )
 530         var_SetInteger( p_mi, "vbi-page", i_page );
 531     else if( i_page >= 1000 )
 532     {
 533         switch (i_page)
 534         {
 535             case libvlc_teletext_key_red:
 536             case libvlc_teletext_key_green:
 537             case libvlc_teletext_key_yellow:
 538             case libvlc_teletext_key_blue:
 539             case libvlc_teletext_key_index:
 540                 b_key = true;
 541                 break;
 542             default:
 543                 libvlc_printerr("Invalid key action");
 544                 return;
 545         }
 546     }
 547     else
 548     {
 549         libvlc_printerr("Invalid page number");
 550         return;
 551     }
 552
 553     p_input_thread = libvlc_get_input_thread( p_mi );
 554     if( !p_input_thread ) return;
 555
 556     if( var_CountChoices( p_input_thread, "teletext-es" ) <= 0 )
 557     {
 558         vlc_object_release( p_input_thread );
 559         return;
 560     }
 561
 562     if( i_page == 0 )
 563     {
 564         teletext_enable( p_input_thread, false );
 565     }
 566     else
 567     {
 568         telx = var_GetInteger( p_input_thread, "teletext-es" );
 569         if( telx >= 0 )
 570         {
 571             if( input_GetEsObjects( p_input_thread, telx, &p_zvbi, NULL, NULL )
 572                 == VLC_SUCCESS )
 573             {
 574                 var_SetInteger( p_zvbi, "vbi-page", i_page );
 575                 vlc_object_release( p_zvbi );
 576             }
 577         }
 578         else if (!b_key)
 579         {
 580             /* the "vbi-page" will be selected on es creation */
 581             teletext_enable( p_input_thread, true );
 582         }
 583         else
 584             libvlc_printerr("Key action sent while the teletext is disabled");
 585     }
 586     vlc_object_release( p_input_thread );
 587 }
 588
 589 void libvlc_toggle_teletext( libvlc_media_player_t *p_mi )
 590 {
 591     input_thread_t *p_input_thread;
 592
 593     p_input_thread = libvlc_get_input_thread(p_mi);
 594     if( !p_input_thread ) return;
 595
 596     if( var_CountChoices( p_input_thread, "teletext-es" ) <= 0 )
 597     {
 598         vlc_object_release( p_input_thread );
 599         return;
 600     }
 601     const bool b_selected = var_GetInteger( p_input_thread, "teletext-es" ) >= 0;
 602     teletext_enable( p_input_thread, !b_selected );
 603     vlc_object_release( p_input_thread );
 604 }
 605
 606 int libvlc_video_get_track_count( libvlc_media_player_t *p_mi )
 607 {
 608     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 609     int i_track_count;
 610
 611     if( !p_input_thread )
 612         return -1;
 613
 614     i_track_count = var_CountChoices( p_input_thread, "video-es" );
 615
 616     vlc_object_release( p_input_thread );
 617     return i_track_count;
 618 }
 619
 620 libvlc_track_description_t *
 621         libvlc_video_get_track_description( libvlc_media_player_t *p_mi )
 622 {
 623     return libvlc_get_track_description( p_mi, "video-es" );
 624 }
 625
 626 int libvlc_video_get_track( libvlc_media_player_t *p_mi )
 627 {
 628     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 629
 630     if( !p_input_thread )
 631         return -1;
 632
 633     int id = var_GetInteger( p_input_thread, "video-es" );
 634     vlc_object_release( p_input_thread );
 635     return id;
 636 }
 637
 638 int libvlc_video_set_track( libvlc_media_player_t *p_mi, int i_track )
 639 {
 640     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
 641     vlc_value_t val_list;
 642     int i_ret = -1;
 643
 644     if( !p_input_thread )
 645         return -1;
 646
 647     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 648     for( int i = 0; i < val_list.p_list->i_count; i++ )
 649     {
 650         if( i_track == val_list.p_list->p_values[i].i_int )
 651         {
 652             if( var_SetInteger( p_input_thread, "video-es", i_track ) < 0 )
 653                 break;
 654             i_ret = 0;
 655             goto end;
 656         }
 657     }
 658     libvlc_printerr( "Track identifier not found" );
 659 end:
 660     var_FreeList( &val_list, NULL );
 661     vlc_object_release( p_input_thread );
 662     return i_ret;
 663 }
 664
 665 /******************************************************************************
 666  * libvlc_video_set_deinterlace : enable deinterlace
 667  *****************************************************************************/
 668 void libvlc_video_set_deinterlace( libvlc_media_player_t *p_mi,
 669                                    const char *psz_mode )
 670 {
 671     if (psz_mode == NULL)
 672         psz_mode = "";
 673     if (*psz_mode
 674      && strcmp (psz_mode, "blend")    && strcmp (psz_mode, "bob")
 675      && strcmp (psz_mode, "discard")  && strcmp (psz_mode, "linear")
 676      && strcmp (psz_mode, "mean")     && strcmp (psz_mode, "x")
 677      && strcmp (psz_mode, "yadif")    && strcmp (psz_mode, "yadif2x")
 678      && strcmp (psz_mode, "phosphor") && strcmp (psz_mode, "ivtc"))
 679         return;
 680
 681     if (*psz_mode)
 682     {
 683         var_SetString (p_mi, "deinterlace-mode", psz_mode);
 684         var_SetInteger (p_mi, "deinterlace", 1);
 685     }
 686     else
 687         var_SetInteger (p_mi, "deinterlace", 0);
 688
 689     size_t n;
 690     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 691     for (size_t i = 0; i < n; i++)
 692     {
 693         vout_thread_t *p_vout = pp_vouts[i];
 694
 695         if (*psz_mode)
 696         {
 697             var_SetString (p_vout, "deinterlace-mode", psz_mode);
 698             var_SetInteger (p_vout, "deinterlace", 1);
 699         }
 700         else
 701             var_SetInteger (p_vout, "deinterlace", 0);
 702         vlc_object_release (p_vout);
 703     }
 704     free (pp_vouts);
 705 }
 706
 707 /* ************** */
 708 /* module helpers */
 709 /* ************** */
 710
 711 static int get_filter_str( vlc_object_t *p_parent, const char *psz_name,
 712                            bool b_add, const char **ppsz_filter_type,
 713                            char **ppsz_filter_value)
 714 {
 715     char *psz_parser;
 716     char *psz_string;
 717     const char *psz_filter_type;
 718
 719     module_t *p_obj = module_find( psz_name );
 720     if( !p_obj )
 721     {
 722         msg_Err( p_parent, "Unable to find filter module \"%s\".", psz_name );
 723         return VLC_EGENERIC;
 724     }
 725
 726     if( module_provides( p_obj, "video filter" ) )
 727     {
 728         psz_filter_type = "video-filter";
 729     }
 730     else if( module_provides( p_obj, "sub source" ) )
 731     {
 732         psz_filter_type = "sub-source";
 733     }
 734     else if( module_provides( p_obj, "sub filter" ) )
 735     {
 736         psz_filter_type = "sub-filter";
 737     }
 738     else
 739     {
 740         msg_Err( p_parent, "Unknown video filter type." );
 741         return VLC_EGENERIC;
 742     }
 743
 744     psz_string = var_GetString( p_parent, psz_filter_type );
 745
 746     /* Todo : Use some generic chain manipulation functions */
 747     if( !psz_string ) psz_string = strdup("");
 748
 749     psz_parser = strstr( psz_string, psz_name );
 750     if( b_add )
 751     {
 752         if( !psz_parser )
 753         {
 754             psz_parser = psz_string;
 755             if( asprintf( &psz_string, (*psz_string) ? "%s:%s" : "%s%s",
 756                           psz_string, psz_name ) == -1 )
 757             {
 758                 free( psz_parser );
 759                 return VLC_EGENERIC;
 760             }
 761             free( psz_parser );
 762         }
 763         else
 764         {
 765             free( psz_string );
 766             return VLC_EGENERIC;
 767         }
 768     }
 769     else
 770     {
 771         if( psz_parser )
 772         {
 773             memmove( psz_parser, psz_parser + strlen(psz_name) +
 774                             (*(psz_parser + strlen(psz_name)) == ':' ? 1 : 0 ),
 775                             strlen(psz_parser + strlen(psz_name)) + 1 );
 776
 777             /* Remove trailing : : */
 778             if( *(psz_string+strlen(psz_string ) -1 ) == ':' )
 779                 *(psz_string+strlen(psz_string ) -1 ) = '\0';
 780         }
 781         else
 782         {
 783             free( psz_string );
 784             return VLC_EGENERIC;
 785         }
 786     }
 787
 788     *ppsz_filter_type = psz_filter_type;
 789     *ppsz_filter_value = psz_string;
 790     return VLC_SUCCESS;
 791 }
 792
 793 static bool find_sub_source_by_name( libvlc_media_player_t *p_mi, const char *restrict name )
 794 {
 795     vout_thread_t *vout = GetVout( p_mi, 0 );
 796     if (!vout)
 797         return false;
 798
 799     char *psz_sources = var_GetString( vout, "sub-source" );
 800     if( !psz_sources )
 801     {
 802         libvlc_printerr( "%s not enabled", name );
 803         vlc_object_release( vout );
 804         return false;
 805     }
 806
 807     /* Find 'name'  */
 808     char *p = strstr( psz_sources, name );
 809     free( psz_sources );
 810     vlc_object_release( vout );
 811     return (p != NULL);
 812 }
 813
 814 typedef const struct {
 815     const char name[20];
 816     unsigned type;
 817 } opt_t;
 818
 819 static void
 820 set_value( libvlc_media_player_t *p_mi, const char *restrict name,
 821            const opt_t *restrict opt, unsigned i_expected_type,
 822            const vlc_value_t *val, bool b_sub_source )
 823 {
 824     if( !opt ) return;
 825
 826     int i_type = opt->type;
 827     vlc_value_t new_val = *val;
 828     const char *psz_opt_name = opt->name;
 829     switch( i_type )
 830     {
 831         case 0: /* the enabler */
 832         {
 833             int i_ret = get_filter_str( VLC_OBJECT( p_mi ), opt->name, val->i_int,
 834                                         &psz_opt_name, &new_val.psz_string );
 835             if( i_ret != VLC_SUCCESS )
 836                 return;
 837             i_type = VLC_VAR_STRING;
 838             break;
 839         }
 840         case VLC_VAR_INTEGER:
 841         case VLC_VAR_FLOAT:
 842         case VLC_VAR_STRING:
 843             if( i_expected_type != opt->type )
 844             {
 845                 libvlc_printerr( "Invalid argument to %s", name );
 846                 return;
 847             }
 848             break;
 849         default:
 850             libvlc_printerr( "Invalid argument to %s", name );
 851             return;
 852     }
 853
 854     /* Set the new value to the media player. Next vouts created from this
 855      * media player will inherit this new value */
 856     var_SetChecked( p_mi, psz_opt_name, i_type, new_val );
 857
 858     /* Set the new value to every loaded vouts */
 859     size_t i_vout_count;
 860     vout_thread_t **pp_vouts = GetVouts( p_mi, &i_vout_count );
 861     for( size_t i = 0; i < i_vout_count; ++i )
 862     {
 863         var_SetChecked( pp_vouts[i], psz_opt_name, i_type, new_val );
 864         if( b_sub_source )
 865             var_TriggerCallback( pp_vouts[i], "sub-source" );
 866         vlc_object_release( pp_vouts[i] );
 867     }
 868
 869     if( opt->type == 0 )
 870         free( new_val.psz_string );
 871 }
 872
 873 static int
 874 get_int( libvlc_media_player_t *p_mi, const char *restrict name,
 875          const opt_t *restrict opt )
 876 {
 877     if( !opt ) return 0;
 878
 879     switch( opt->type )
 880     {
 881         case 0: /* the enabler */
 882         {
 883             bool b_enabled = find_sub_source_by_name( p_mi, name );
 884             return b_enabled ? 1 : 0;
 885         }
 886     case VLC_VAR_INTEGER:
 887         return var_GetInteger(p_mi, opt->name);
 888     case VLC_VAR_FLOAT:
 889         return lroundf(var_GetFloat(p_mi, opt->name));
 890     default:
 891         libvlc_printerr( "Invalid argument to %s in %s", name, "get int" );
 892         return 0;
 893     }
 894 }
 895
 896 static float
 897 get_float( libvlc_media_player_t *p_mi, const char *restrict name,
 898             const opt_t *restrict opt )
 899 {
 900     if( !opt ) return 0.0;
 901
 902     if( opt->type != VLC_VAR_FLOAT )
 903     {
 904         libvlc_printerr( "Invalid argument to %s in %s", name, "get float" );
 905         return 0.0;
 906     }
 907
 908     return var_GetFloat( p_mi, opt->name );
 909 }
 910
 911 static char *
 912 get_string( libvlc_media_player_t *p_mi, const char *restrict name,
 913             const opt_t *restrict opt )
 914 {
 915     if( !opt ) return NULL;
 916
 917     if( opt->type != VLC_VAR_STRING )
 918     {
 919         libvlc_printerr( "Invalid argument to %s in %s", name, "get string" );
 920         return NULL;
 921     }
 922
 923     return var_GetString( p_mi, opt->name );
 924 }
 925
 926 static const opt_t *
 927 marq_option_bynumber(unsigned option)
 928 {
 929     static const opt_t optlist[] =
 930     {
 931         { "marq",          0 },
 932         { "marq-marquee",  VLC_VAR_STRING },
 933         { "marq-color",    VLC_VAR_INTEGER },
 934         { "marq-opacity",  VLC_VAR_INTEGER },
 935         { "marq-position", VLC_VAR_INTEGER },
 936         { "marq-refresh",  VLC_VAR_INTEGER },
 937         { "marq-size",     VLC_VAR_INTEGER },
 938         { "marq-timeout",  VLC_VAR_INTEGER },
 939         { "marq-x",        VLC_VAR_INTEGER },
 940         { "marq-y",        VLC_VAR_INTEGER },
 941     };
 942     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
 943
 944     const opt_t *r = option < num_opts ? optlist+option : NULL;
 945     if( !r )
 946         libvlc_printerr( "Unknown marquee option" );
 947     return r;
 948 }
 949
 950 /*****************************************************************************
 951  * libvlc_video_get_marquee_int : get a marq option value
 952  *****************************************************************************/
 953 int libvlc_video_get_marquee_int( libvlc_media_player_t *p_mi,
 954                                   unsigned option )
 955 {
 956     return get_int( p_mi, "marq", marq_option_bynumber(option) );
 957 }
 958
 959 /*****************************************************************************
 960  * libvlc_video_get_marquee_string : get a marq option value
 961  *****************************************************************************/
 962 char * libvlc_video_get_marquee_string( libvlc_media_player_t *p_mi,
 963                                         unsigned option )
 964 {
 965     return get_string( p_mi, "marq", marq_option_bynumber(option) );
 966 }
 967
 968 /*****************************************************************************
 969  * libvlc_video_set_marquee_int: enable, disable or set an int option
 970  *****************************************************************************/
 971 void libvlc_video_set_marquee_int( libvlc_media_player_t *p_mi,
 972                          unsigned option, int value )
 973 {
 974     set_value( p_mi, "marq", marq_option_bynumber(option), VLC_VAR_INTEGER,
 975                &(vlc_value_t) { .i_int = value }, true );
 976 }
 977
 978 /*****************************************************************************
 979  * libvlc_video_set_marquee_string: set a string option
 980  *****************************************************************************/
 981 void libvlc_video_set_marquee_string( libvlc_media_player_t *p_mi,
 982                 unsigned option, const char * value )
 983 {
 984     set_value( p_mi, "marq", marq_option_bynumber(option), VLC_VAR_STRING,
 985                &(vlc_value_t){ .psz_string = (char *)value }, true );
 986 }
 987
 988
 989 /* logo module support */
 990
 991 static const opt_t *
 992 logo_option_bynumber( unsigned option )
 993 {
 994     static const opt_t vlogo_optlist[] =
 995     /* depends on libvlc_video_logo_option_t */
 996     {
 997         { "logo",          0 },
 998         { "logo-file",     VLC_VAR_STRING },
 999         { "logo-x",        VLC_VAR_INTEGER },
1000         { "logo-y",        VLC_VAR_INTEGER },
1001         { "logo-delay",    VLC_VAR_INTEGER },
1002         { "logo-repeat",   VLC_VAR_INTEGER },
1003         { "logo-opacity",  VLC_VAR_INTEGER },
1004         { "logo-position", VLC_VAR_INTEGER },
1005     };
1006     enum { num_vlogo_opts = sizeof(vlogo_optlist) / sizeof(*vlogo_optlist) };
1007
1008     const opt_t *r = option < num_vlogo_opts ? vlogo_optlist+option : NULL;
1009     if( !r )
1010         libvlc_printerr( "Unknown logo option" );
1011     return r;
1012 }
1013
1014 void libvlc_video_set_logo_string( libvlc_media_player_t *p_mi,
1015                                    unsigned option, const char *psz_value )
1016 {
1017     set_value( p_mi,"logo",logo_option_bynumber(option), VLC_VAR_STRING,
1018                &(vlc_value_t){ .psz_string = (char *)psz_value }, true );
1019 }
1020
1021
1022 void libvlc_video_set_logo_int( libvlc_media_player_t *p_mi,
1023                                 unsigned option, int value )
1024 {
1025     set_value( p_mi, "logo", logo_option_bynumber(option), VLC_VAR_INTEGER,
1026                &(vlc_value_t) { .i_int = value }, true );
1027 }
1028
1029
1030 int libvlc_video_get_logo_int( libvlc_media_player_t *p_mi,
1031                                unsigned option )
1032 {
1033     return get_int( p_mi, "logo", logo_option_bynumber(option) );
1034 }
1035
1036
1037 /* adjust module support */
1038
1039
1040 static const opt_t *
1041 adjust_option_bynumber( unsigned option )
1042 {
1043     static const opt_t optlist[] =
1044     {
1045         { "adjust",     0 },
1046         { "contrast",   VLC_VAR_FLOAT },
1047         { "brightness", VLC_VAR_FLOAT },
1048         { "hue",        VLC_VAR_FLOAT },
1049         { "saturation", VLC_VAR_FLOAT },
1050         { "gamma",      VLC_VAR_FLOAT },
1051     };
1052     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
1053
1054     const opt_t *r = option < num_opts ? optlist+option : NULL;
1055     if( !r )
1056         libvlc_printerr( "Unknown adjust option" );
1057     return r;
1058 }
1059
1060
1061 void libvlc_video_set_adjust_int( libvlc_media_player_t *p_mi,
1062                                   unsigned option, int value )
1063 {
1064     set_value( p_mi, "adjust", adjust_option_bynumber(option), VLC_VAR_INTEGER,
1065                &(vlc_value_t) { .i_int = value }, false );
1066 }
1067
1068
1069 int libvlc_video_get_adjust_int( libvlc_media_player_t *p_mi,
1070                                  unsigned option )
1071 {
1072     return get_int( p_mi, "adjust", adjust_option_bynumber(option) );
1073 }
1074
1075
1076 void libvlc_video_set_adjust_float( libvlc_media_player_t *p_mi,
1077                                     unsigned option, float value )
1078 {
1079     set_value( p_mi, "adjust", adjust_option_bynumber(option), VLC_VAR_FLOAT,
1080                &(vlc_value_t) { .f_float = value }, false );
1081 }
1082
1083
1084 float libvlc_video_get_adjust_float( libvlc_media_player_t *p_mi,
1085                                      unsigned option )
1086 {
1087     return get_float( p_mi, "adjust", adjust_option_bynumber(option) );
1088 }