lib/video.c

   1 /*****************************************************************************
   2  * video.c: libvlc new API video functions
   3  *****************************************************************************
   4  * Copyright (C) 2005-2010 VLC authors and VideoLAN
   5  *
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *          Filippo Carone <littlejohn@videolan.org>
   9  *          Jean-Paul Saman <jpsaman _at_ m2x _dot_ nl>
  10  *          Damien Fouilleul <damienf a_t videolan dot org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU Lesser General Public License as published by
  14  * the Free Software Foundation; either version 2.1 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc/libvlc.h>
  32 #include <vlc/libvlc_renderer_discoverer.h>
  33 #include <vlc/libvlc_picture.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_vout.h>
  40 #include <vlc_url.h>
  41
  42 #include "libvlc_internal.h"
  43 #include "media_player_internal.h"
  44 #include <math.h>
  45 #include <assert.h>
  46
  47 /*
  48  * Remember to release the returned vout_thread_t.
  49  */
  50 static vout_thread_t **GetVouts( libvlc_media_player_t *p_mi, size_t *n )
  51 {
  52     vlc_player_t *player = p_mi->player;
  53     return vlc_player_vout_HoldAll(player, n);
  54 }
  55
  56 static vout_thread_t *GetVout (libvlc_media_player_t *mp, size_t num)
  57 {
  58     vout_thread_t *p_vout = NULL;
  59     size_t n;
  60     vout_thread_t **pp_vouts = GetVouts (mp, &n);
  61     if (pp_vouts == NULL)
  62         goto err;
  63
  64     if (num < n)
  65         p_vout = pp_vouts[num];
  66
  67     for (size_t i = 0; i < n; i++)
  68         if (i != num)
  69             vout_Release(pp_vouts[i]);
  70     free (pp_vouts);
  71
  72     if (p_vout == NULL)
  73 err:
  74         libvlc_printerr ("Video output not active");
  75     return p_vout;
  76 }
  77
  78 /**********************************************************************
  79  * Exported functions
  80  **********************************************************************/
  81
  82 void libvlc_set_fullscreen(libvlc_media_player_t *p_mi, bool b_fullscreen)
  83 {
  84     /* This will work even if the video is not currently active */
  85     var_SetBool(p_mi, "fullscreen", b_fullscreen);
  86
  87     /* Apply to current video outputs (if any) */
  88     size_t n;
  89     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
  90     for (size_t i = 0; i < n; i++)
  91     {
  92         var_SetBool (pp_vouts[i], "fullscreen", b_fullscreen);
  93         vout_Release(pp_vouts[i]);
  94     }
  95     free (pp_vouts);
  96 }
  97
  98 bool libvlc_get_fullscreen( libvlc_media_player_t *p_mi )
  99 {
 100     return var_GetBool (p_mi, "fullscreen");
 101 }
 102
 103 void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi )
 104 {
 105     bool b_fullscreen = var_ToggleBool (p_mi, "fullscreen");
 106
 107     /* Apply to current video outputs (if any) */
 108     size_t n;
 109     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 110     for (size_t i = 0; i < n; i++)
 111     {
 112         vout_thread_t *p_vout = pp_vouts[i];
 113
 114         var_SetBool (p_vout, "fullscreen", b_fullscreen);
 115         vout_Release(p_vout);
 116     }
 117     free (pp_vouts);
 118 }
 119
 120 void libvlc_video_set_key_input( libvlc_media_player_t *p_mi, unsigned on )
 121 {
 122     var_SetBool (p_mi, "keyboard-events", !!on);
 123 }
 124
 125 void libvlc_video_set_mouse_input( libvlc_media_player_t *p_mi, unsigned on )
 126 {
 127     var_SetBool (p_mi, "mouse-events", !!on);
 128 }
 129
 130 int
 131 libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, unsigned num,
 132                             const char *psz_filepath,
 133                             unsigned int i_width, unsigned int i_height )
 134 {
 135     assert( psz_filepath );
 136
 137     vout_thread_t *p_vout = GetVout (p_mi, num);
 138     if (p_vout == NULL)
 139         return -1;
 140
 141     /* FIXME: This is not atomic. All parameters should be passed at once
 142      * (obviously _not_ with var_*()). Also, the libvlc object should not be
 143      * used for the callbacks: that breaks badly if there are concurrent
 144      * media players in the instance. */
 145     var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER );
 146     var_SetInteger( p_vout, "snapshot-width", i_width);
 147     var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER );
 148     var_SetInteger( p_vout, "snapshot-height", i_height );
 149     var_Create( p_vout, "snapshot-path", VLC_VAR_STRING );
 150     var_SetString( p_vout, "snapshot-path", psz_filepath );
 151     var_Create( p_vout, "snapshot-format", VLC_VAR_STRING );
 152     var_SetString( p_vout, "snapshot-format", "png" );
 153     var_TriggerCallback( p_vout, "video-snapshot" );
 154     vout_Release(p_vout);
 155     return 0;
 156 }
 157
 158 int libvlc_video_get_size( libvlc_media_player_t *p_mi, unsigned ignored,
 159                            unsigned *restrict px, unsigned *restrict py )
 160 {
 161     (void) ignored;
 162     if (p_mi->p_md == NULL)
 163         return -1;
 164
 165     int ret = -1;
 166     libvlc_media_track_t *track =
 167         libvlc_media_player_get_selected_track( p_mi, libvlc_track_video );
 168
 169     if (track)
 170     {
 171         *px = track->video->i_width;
 172         *py = track->video->i_height;
 173         ret = 0;
 174         libvlc_media_track_release(track);
 175     }
 176
 177     return ret;
 178 }
 179
 180 int libvlc_video_get_cursor( libvlc_media_player_t *mp, unsigned num,
 181                              int *restrict px, int *restrict py )
 182 {
 183     vout_thread_t *p_vout = GetVout (mp, num);
 184     if (p_vout == NULL)
 185         return -1;
 186
 187     var_GetCoords (p_vout, "mouse-moved", px, py);
 188     vout_Release(p_vout);
 189     return 0;
 190 }
 191
 192 unsigned libvlc_media_player_has_vout( libvlc_media_player_t *p_mi )
 193 {
 194     size_t n;
 195     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 196     for (size_t i = 0; i < n; i++)
 197         vout_Release(pp_vouts[i]);
 198     free (pp_vouts);
 199     return n;
 200 }
 201
 202 float libvlc_video_get_scale( libvlc_media_player_t *mp )
 203 {
 204     float f_scale = var_GetFloat (mp, "zoom");
 205     if (var_GetBool (mp, "autoscale"))
 206         f_scale = 0.f;
 207     return f_scale;
 208 }
 209
 210 void libvlc_video_set_scale( libvlc_media_player_t *p_mp, float f_scale )
 211 {
 212     if (isfinite(f_scale) && f_scale != 0.f)
 213         var_SetFloat (p_mp, "zoom", f_scale);
 214     var_SetBool (p_mp, "autoscale", f_scale == 0.f);
 215
 216     /* Apply to current video outputs (if any) */
 217     size_t n;
 218     vout_thread_t **pp_vouts = GetVouts (p_mp, &n);
 219     for (size_t i = 0; i < n; i++)
 220     {
 221         vout_thread_t *p_vout = pp_vouts[i];
 222
 223         if (isfinite(f_scale) && f_scale != 0.f)
 224             var_SetFloat (p_vout, "zoom", f_scale);
 225         var_SetBool (p_vout, "autoscale", f_scale == 0.f);
 226         vout_Release(p_vout);
 227     }
 228     free (pp_vouts);
 229 }
 230
 231 char *libvlc_video_get_aspect_ratio( libvlc_media_player_t *p_mi )
 232 {
 233     return var_GetNonEmptyString (p_mi, "aspect-ratio");
 234 }
 235
 236 void libvlc_video_set_aspect_ratio( libvlc_media_player_t *p_mi,
 237                                     const char *psz_aspect )
 238 {
 239     if (psz_aspect == NULL)
 240         psz_aspect = "";
 241     var_SetString (p_mi, "aspect-ratio", psz_aspect);
 242
 243     size_t n;
 244     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 245     for (size_t i = 0; i < n; i++)
 246     {
 247         vout_thread_t *p_vout = pp_vouts[i];
 248
 249         var_SetString (p_vout, "aspect-ratio", psz_aspect);
 250         vout_Release(p_vout);
 251     }
 252     free (pp_vouts);
 253 }
 254
 255 libvlc_video_viewpoint_t *libvlc_video_new_viewpoint(void)
 256 {
 257     libvlc_video_viewpoint_t *p_vp = malloc(sizeof *p_vp);
 258     if (unlikely(p_vp == NULL))
 259         return NULL;
 260     p_vp->f_yaw = p_vp->f_pitch = p_vp->f_roll = p_vp->f_field_of_view = 0.0f;
 261     return p_vp;
 262 }
 263
 264 int libvlc_video_update_viewpoint( libvlc_media_player_t *p_mi,
 265                                    const libvlc_video_viewpoint_t *p_viewpoint,
 266                                    bool b_absolute )
 267 {
 268     vlc_viewpoint_t update = {
 269         .yaw   = p_viewpoint->f_yaw,
 270         .pitch = p_viewpoint->f_pitch,
 271         .roll  = p_viewpoint->f_roll,
 272         .fov   = p_viewpoint->f_field_of_view,
 273     };
 274
 275     enum vlc_player_whence whence = b_absolute ? VLC_PLAYER_WHENCE_ABSOLUTE
 276                                                : VLC_PLAYER_WHENCE_RELATIVE;
 277
 278     vlc_player_t *player = p_mi->player;
 279     vlc_player_Lock(player);
 280
 281     vlc_player_UpdateViewpoint(player, &update, whence);
 282
 283     vlc_player_Unlock(player);
 284
 285     /* may not fail anymore, keep int not to break the API */
 286     return 0;
 287 }
 288
 289 int libvlc_video_get_spu( libvlc_media_player_t *p_mi )
 290 {
 291     vlc_player_t *player = p_mi->player;
 292     vlc_player_Lock(player);
 293
 294     const struct vlc_player_track *track =
 295         vlc_player_GetSelectedTrack(player, SPU_ES);
 296     int i_spu = track ? vlc_es_id_GetInputId(track->es_id) : -1;
 297
 298     vlc_player_Unlock(player);
 299     return i_spu;
 300 }
 301
 302 int libvlc_video_get_spu_count( libvlc_media_player_t *p_mi )
 303 {
 304     vlc_player_t *player = p_mi->player;
 305     vlc_player_Lock(player);
 306
 307     int ret = vlc_player_GetTrackCount(p_mi->player, SPU_ES);
 308
 309     vlc_player_Unlock(player);
 310     return ret;
 311 }
 312
 313 libvlc_track_description_t *
 314         libvlc_video_get_spu_description( libvlc_media_player_t *p_mi )
 315 {
 316     return libvlc_get_track_description( p_mi, SPU_ES );
 317 }
 318
 319 int libvlc_video_set_spu( libvlc_media_player_t *p_mi, int i_spu )
 320 {
 321     int i_ret = -1;
 322
 323     vlc_player_t *player = p_mi->player;
 324     vlc_player_Lock(player);
 325
 326     size_t count = vlc_player_GetSubtitleTrackCount(player);
 327     for (size_t i = 0; i < count; i++)
 328     {
 329         const struct vlc_player_track *track =
 330             vlc_player_GetSubtitleTrackAt(player, i);
 331         if (i_spu == vlc_es_id_GetInputId(track->es_id))
 332         {
 333             /* found */
 334             vlc_player_SelectTrack(player, track, VLC_PLAYER_SELECT_EXCLUSIVE);
 335             i_ret = 0;
 336             goto end;
 337         }
 338     }
 339     libvlc_printerr( "Track identifier not found" );
 340 end:
 341     vlc_player_Unlock(player);
 342     return i_ret;
 343 }
 344
 345 int64_t libvlc_video_get_spu_delay( libvlc_media_player_t *p_mi )
 346 {
 347     vlc_player_t *player = p_mi->player;
 348     vlc_player_Lock(player);
 349
 350     vlc_tick_t delay = vlc_player_GetSubtitleDelay(player);
 351
 352     vlc_player_Unlock(player);
 353
 354     return US_FROM_VLC_TICK(delay);
 355 }
 356
 357 int libvlc_video_set_spu_delay( libvlc_media_player_t *p_mi,
 358                                 int64_t i_delay )
 359 {
 360     vlc_player_t *player = p_mi->player;
 361     vlc_player_Lock(player);
 362
 363     vlc_player_SetSubtitleDelay(player, VLC_TICK_FROM_US(i_delay),
 364                                 VLC_PLAYER_WHENCE_ABSOLUTE);
 365
 366     vlc_player_Unlock(player);
 367     /* may not fail anymore, keep int not to break the API */
 368     return 0;
 369 }
 370
 371 void libvlc_video_set_spu_text_scale( libvlc_media_player_t *p_mi,
 372                                       float f_scale )
 373 {
 374     vlc_player_t *player = p_mi->player;
 375     vlc_player_Lock(player);
 376
 377     vlc_player_SetSubtitleTextScale(player, lroundf(f_scale * 100.f));
 378
 379     vlc_player_Unlock(player);
 380 }
 381
 382 static void libvlc_video_set_crop(libvlc_media_player_t *mp,
 383                                   const char *geometry)
 384 {
 385     var_SetString(mp, "crop", geometry);
 386
 387     size_t n;
 388     vout_thread_t **vouts = GetVouts(mp, &n);
 389
 390     for (size_t i = 0; i < n; i++)
 391     {
 392         var_SetString(vouts[i], "crop", geometry);
 393         vout_Release(vouts[i]);
 394     }
 395     free(vouts);
 396 }
 397
 398 void libvlc_video_set_crop_ratio(libvlc_media_player_t *mp,
 399                                  unsigned num, unsigned den)
 400 {
 401     char geometry[2 * (3 * sizeof (unsigned) + 1)];
 402
 403     if (den == 0)
 404         geometry[0] = '\0';
 405     else
 406         sprintf(geometry, "%u:%u", num, den);
 407
 408     libvlc_video_set_crop(mp, geometry);
 409 }
 410
 411 void libvlc_video_set_crop_window(libvlc_media_player_t *mp,
 412                                   unsigned x, unsigned y,
 413                                   unsigned width, unsigned height)
 414 {
 415     char geometry[4 * (3 * sizeof (unsigned) + 1)];
 416
 417     assert(width != 0 && height != 0);
 418     sprintf(geometry, "%ux%u+%u+%u", x, y, width, height);
 419     libvlc_video_set_crop(mp, geometry);
 420 }
 421
 422 void libvlc_video_set_crop_border(libvlc_media_player_t *mp,
 423                                   unsigned left, unsigned right,
 424                                   unsigned top, unsigned bottom)
 425 {
 426     char geometry[4 * (3 * sizeof (unsigned) + 1)];
 427
 428     sprintf(geometry, "%u+%u+%u+%u", left, top, right, bottom);
 429     libvlc_video_set_crop(mp, geometry);
 430 }
 431
 432 int libvlc_video_get_teletext( libvlc_media_player_t *p_mi )
 433 {
 434     return var_GetInteger (p_mi, "vbi-page");
 435 }
 436
 437 void libvlc_video_set_teletext( libvlc_media_player_t *p_mi, int i_page )
 438 {
 439     vlc_player_t *player = p_mi->player;
 440     vlc_player_Lock(player);
 441
 442     if (i_page == 0)
 443         vlc_player_SetTeletextEnabled(player, false);
 444     else if (i_page > 0)
 445     {
 446         if (i_page >= 1000)
 447         {
 448             bool is_key = i_page == libvlc_teletext_key_red
 449                        || i_page == libvlc_teletext_key_green
 450                        || i_page == libvlc_teletext_key_yellow
 451                        || i_page == libvlc_teletext_key_blue
 452                        || i_page == libvlc_teletext_key_index;
 453             if (!is_key)
 454             {
 455                 libvlc_printerr("Invalid key action");
 456                 return;
 457             }
 458         }
 459         vlc_player_SetTeletextEnabled(player, true);
 460         vlc_player_SelectTeletextPage(player, i_page);
 461     }
 462     else
 463     {
 464         libvlc_printerr("Invalid page number");
 465         return;
 466     }
 467
 468     vlc_player_Unlock(player);
 469 }
 470
 471 int libvlc_video_get_track_count( libvlc_media_player_t *p_mi )
 472 {
 473     vlc_player_t *player = p_mi->player;
 474     vlc_player_Lock(player);
 475
 476     int ret = vlc_player_GetTrackCount(p_mi->player, VIDEO_ES);
 477
 478     vlc_player_Unlock(player);
 479     return ret;
 480 }
 481
 482 libvlc_track_description_t *
 483         libvlc_video_get_track_description( libvlc_media_player_t *p_mi )
 484 {
 485     return libvlc_get_track_description( p_mi, VIDEO_ES );
 486 }
 487
 488 int libvlc_video_get_track( libvlc_media_player_t *p_mi )
 489 {
 490     vlc_player_t *player = p_mi->player;
 491     vlc_player_Lock(player);
 492
 493     const struct vlc_player_track * track =
 494         vlc_player_GetSelectedTrack(player, VIDEO_ES);
 495     int id = track ? vlc_es_id_GetInputId(track->es_id) : -1;
 496
 497     vlc_player_Unlock(player);
 498     return id;
 499 }
 500
 501 int libvlc_video_set_track( libvlc_media_player_t *p_mi, int i_track )
 502 {
 503     int i_ret = -1;
 504
 505     vlc_player_t *player = p_mi->player;
 506     vlc_player_Lock(player);
 507
 508     size_t count = vlc_player_GetVideoTrackCount(player);
 509     for( size_t i = 0; i < count; i++ )
 510     {
 511         const struct vlc_player_track *track =
 512             vlc_player_GetVideoTrackAt(player, i);
 513         if (i_track == vlc_es_id_GetInputId(track->es_id))
 514         {
 515             /* found */
 516             vlc_player_SelectTrack(player, track, VLC_PLAYER_SELECT_EXCLUSIVE);
 517             i_ret = 0;
 518             goto end;
 519         }
 520     }
 521     libvlc_printerr( "Track identifier not found" );
 522 end:
 523     vlc_player_Unlock(player);
 524     return i_ret;
 525 }
 526
 527 /******************************************************************************
 528  * libvlc_video_set_deinterlace : enable/disable/auto deinterlace and filter
 529  *****************************************************************************/
 530 void libvlc_video_set_deinterlace( libvlc_media_player_t *p_mi, int deinterlace,
 531                                    const char *psz_mode )
 532 {
 533     if (deinterlace != 0 && deinterlace != 1)
 534         deinterlace = -1;
 535
 536     if (psz_mode
 537      && strcmp (psz_mode, "blend")    && strcmp (psz_mode, "bob")
 538      && strcmp (psz_mode, "discard")  && strcmp (psz_mode, "linear")
 539      && strcmp (psz_mode, "mean")     && strcmp (psz_mode, "x")
 540      && strcmp (psz_mode, "yadif")    && strcmp (psz_mode, "yadif2x")
 541      && strcmp (psz_mode, "phosphor") && strcmp (psz_mode, "ivtc")
 542      && strcmp (psz_mode, "auto"))
 543         return;
 544
 545     if (psz_mode && deinterlace != 0)
 546         var_SetString (p_mi, "deinterlace-mode", psz_mode);
 547
 548     var_SetInteger (p_mi, "deinterlace", deinterlace);
 549
 550     size_t n;
 551     vout_thread_t **pp_vouts = GetVouts (p_mi, &n);
 552     for (size_t i = 0; i < n; i++)
 553     {
 554         vout_thread_t *p_vout = pp_vouts[i];
 555
 556         if (psz_mode && deinterlace != 0)
 557             var_SetString (p_vout, "deinterlace-mode", psz_mode);
 558
 559         var_SetInteger (p_vout, "deinterlace", deinterlace);
 560         vout_Release(p_vout);
 561     }
 562     free (pp_vouts);
 563 }
 564
 565 /* ************** */
 566 /* module helpers */
 567 /* ************** */
 568
 569 static int get_filter_str( vlc_object_t *p_parent, const char *psz_name,
 570                            bool b_add, const char **ppsz_filter_type,
 571                            char **ppsz_filter_value)
 572 {
 573     char *psz_parser;
 574     char *psz_string;
 575     const char *psz_filter_type;
 576
 577     module_t *p_obj = module_find( psz_name );
 578     if( !p_obj )
 579     {
 580         msg_Err( p_parent, "Unable to find filter module \"%s\".", psz_name );
 581         return VLC_EGENERIC;
 582     }
 583
 584     if( module_provides( p_obj, "video filter" ) )
 585     {
 586         psz_filter_type = "video-filter";
 587     }
 588     else if( module_provides( p_obj, "sub source" ) )
 589     {
 590         psz_filter_type = "sub-source";
 591     }
 592     else if( module_provides( p_obj, "sub filter" ) )
 593     {
 594         psz_filter_type = "sub-filter";
 595     }
 596     else
 597     {
 598         msg_Err( p_parent, "Unknown video filter type." );
 599         return VLC_EGENERIC;
 600     }
 601
 602     psz_string = var_GetString( p_parent, psz_filter_type );
 603
 604     /* Todo : Use some generic chain manipulation functions */
 605     if( !psz_string ) psz_string = strdup("");
 606
 607     psz_parser = strstr( psz_string, psz_name );
 608     if( b_add )
 609     {
 610         if( !psz_parser )
 611         {
 612             psz_parser = psz_string;
 613             if( asprintf( &psz_string, (*psz_string) ? "%s:%s" : "%s%s",
 614                           psz_string, psz_name ) == -1 )
 615             {
 616                 free( psz_parser );
 617                 return VLC_EGENERIC;
 618             }
 619             free( psz_parser );
 620         }
 621         else
 622         {
 623             free( psz_string );
 624             return VLC_EGENERIC;
 625         }
 626     }
 627     else
 628     {
 629         if( psz_parser )
 630         {
 631             memmove( psz_parser, psz_parser + strlen(psz_name) +
 632                             (*(psz_parser + strlen(psz_name)) == ':' ? 1 : 0 ),
 633                             strlen(psz_parser + strlen(psz_name)) + 1 );
 634
 635             /* Remove trailing : : */
 636             if( *(psz_string+strlen(psz_string ) -1 ) == ':' )
 637                 *(psz_string+strlen(psz_string ) -1 ) = '\0';
 638         }
 639         else
 640         {
 641             free( psz_string );
 642             return VLC_EGENERIC;
 643         }
 644     }
 645
 646     *ppsz_filter_type = psz_filter_type;
 647     *ppsz_filter_value = psz_string;
 648     return VLC_SUCCESS;
 649 }
 650
 651 static bool find_sub_source_by_name( libvlc_media_player_t *p_mi, const char *restrict name )
 652 {
 653     vout_thread_t *vout = GetVout( p_mi, 0 );
 654     if (!vout)
 655         return false;
 656
 657     char *psz_sources = var_GetString( vout, "sub-source" );
 658     if( !psz_sources )
 659     {
 660         libvlc_printerr( "%s not enabled", name );
 661         vout_Release(vout);
 662         return false;
 663     }
 664
 665     /* Find 'name'  */
 666     char *p = strstr( psz_sources, name );
 667     free( psz_sources );
 668     vout_Release(vout);
 669     return (p != NULL);
 670 }
 671
 672 typedef const struct {
 673     const char name[20];
 674     unsigned type;
 675 } opt_t;
 676
 677 static void
 678 set_value( libvlc_media_player_t *p_mi, const char *restrict name,
 679            const opt_t *restrict opt, unsigned i_expected_type,
 680            const vlc_value_t *val, bool b_sub_source )
 681 {
 682     if( !opt ) return;
 683
 684     int i_type = opt->type;
 685     vlc_value_t new_val = *val;
 686     const char *psz_opt_name = opt->name;
 687     switch( i_type )
 688     {
 689         case 0: /* the enabler */
 690         {
 691             int i_ret = get_filter_str( VLC_OBJECT( p_mi ), opt->name, val->i_int,
 692                                         &psz_opt_name, &new_val.psz_string );
 693             if( i_ret != VLC_SUCCESS )
 694                 return;
 695             i_type = VLC_VAR_STRING;
 696             break;
 697         }
 698         case VLC_VAR_INTEGER:
 699         case VLC_VAR_FLOAT:
 700         case VLC_VAR_STRING:
 701             if( i_expected_type != opt->type )
 702             {
 703                 libvlc_printerr( "Invalid argument to %s", name );
 704                 return;
 705             }
 706             break;
 707         default:
 708             libvlc_printerr( "Invalid argument to %s", name );
 709             return;
 710     }
 711
 712     /* Set the new value to the media player. Next vouts created from this
 713      * media player will inherit this new value */
 714     var_SetChecked( p_mi, psz_opt_name, i_type, new_val );
 715
 716     /* Set the new value to every loaded vouts */
 717     size_t i_vout_count;
 718     vout_thread_t **pp_vouts = GetVouts( p_mi, &i_vout_count );
 719     for( size_t i = 0; i < i_vout_count; ++i )
 720     {
 721         var_SetChecked( pp_vouts[i], psz_opt_name, i_type, new_val );
 722         if( b_sub_source )
 723             var_TriggerCallback( pp_vouts[i], "sub-source" );
 724         vout_Release(pp_vouts[i]);
 725     }
 726
 727     if( opt->type == 0 )
 728         free( new_val.psz_string );
 729 }
 730
 731 static int
 732 get_int( libvlc_media_player_t *p_mi, const char *restrict name,
 733          const opt_t *restrict opt )
 734 {
 735     if( !opt ) return 0;
 736
 737     switch( opt->type )
 738     {
 739         case 0: /* the enabler */
 740         {
 741             bool b_enabled = find_sub_source_by_name( p_mi, name );
 742             return b_enabled ? 1 : 0;
 743         }
 744     case VLC_VAR_INTEGER:
 745         return var_GetInteger(p_mi, opt->name);
 746     case VLC_VAR_FLOAT:
 747         return lroundf(var_GetFloat(p_mi, opt->name));
 748     default:
 749         libvlc_printerr( "Invalid argument to %s in %s", name, "get int" );
 750         return 0;
 751     }
 752 }
 753
 754 static float
 755 get_float( libvlc_media_player_t *p_mi, const char *restrict name,
 756             const opt_t *restrict opt )
 757 {
 758     if( !opt ) return 0.0;
 759
 760     if( opt->type != VLC_VAR_FLOAT )
 761     {
 762         libvlc_printerr( "Invalid argument to %s in %s", name, "get float" );
 763         return 0.0;
 764     }
 765
 766     return var_GetFloat( p_mi, opt->name );
 767 }
 768
 769 static const opt_t *
 770 marq_option_bynumber(unsigned option)
 771 {
 772     static const opt_t optlist[] =
 773     {
 774         { "marq",          0 },
 775         { "marq-marquee",  VLC_VAR_STRING },
 776         { "marq-color",    VLC_VAR_INTEGER },
 777         { "marq-opacity",  VLC_VAR_INTEGER },
 778         { "marq-position", VLC_VAR_INTEGER },
 779         { "marq-refresh",  VLC_VAR_INTEGER },
 780         { "marq-size",     VLC_VAR_INTEGER },
 781         { "marq-timeout",  VLC_VAR_INTEGER },
 782         { "marq-x",        VLC_VAR_INTEGER },
 783         { "marq-y",        VLC_VAR_INTEGER },
 784     };
 785     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
 786
 787     const opt_t *r = option < num_opts ? optlist+option : NULL;
 788     if( !r )
 789         libvlc_printerr( "Unknown marquee option" );
 790     return r;
 791 }
 792
 793 /*****************************************************************************
 794  * libvlc_video_get_marquee_int : get a marq option value
 795  *****************************************************************************/
 796 int libvlc_video_get_marquee_int( libvlc_media_player_t *p_mi,
 797                                   unsigned option )
 798 {
 799     return get_int( p_mi, "marq", marq_option_bynumber(option) );
 800 }
 801
 802 /*****************************************************************************
 803  * libvlc_video_set_marquee_int: enable, disable or set an int option
 804  *****************************************************************************/
 805 void libvlc_video_set_marquee_int( libvlc_media_player_t *p_mi,
 806                          unsigned option, int value )
 807 {
 808     set_value( p_mi, "marq", marq_option_bynumber(option), VLC_VAR_INTEGER,
 809                &(vlc_value_t) { .i_int = value }, true );
 810 }
 811
 812 /*****************************************************************************
 813  * libvlc_video_set_marquee_string: set a string option
 814  *****************************************************************************/
 815 void libvlc_video_set_marquee_string( libvlc_media_player_t *p_mi,
 816                 unsigned option, const char * value )
 817 {
 818     set_value( p_mi, "marq", marq_option_bynumber(option), VLC_VAR_STRING,
 819                &(vlc_value_t){ .psz_string = (char *)value }, true );
 820 }
 821
 822
 823 /* logo module support */
 824
 825 static const opt_t *
 826 logo_option_bynumber( unsigned option )
 827 {
 828     static const opt_t vlogo_optlist[] =
 829     /* depends on libvlc_video_logo_option_t */
 830     {
 831         { "logo",          0 },
 832         { "logo-file",     VLC_VAR_STRING },
 833         { "logo-x",        VLC_VAR_INTEGER },
 834         { "logo-y",        VLC_VAR_INTEGER },
 835         { "logo-delay",    VLC_VAR_INTEGER },
 836         { "logo-repeat",   VLC_VAR_INTEGER },
 837         { "logo-opacity",  VLC_VAR_INTEGER },
 838         { "logo-position", VLC_VAR_INTEGER },
 839     };
 840     enum { num_vlogo_opts = sizeof(vlogo_optlist) / sizeof(*vlogo_optlist) };
 841
 842     const opt_t *r = option < num_vlogo_opts ? vlogo_optlist+option : NULL;
 843     if( !r )
 844         libvlc_printerr( "Unknown logo option" );
 845     return r;
 846 }
 847
 848 void libvlc_video_set_logo_string( libvlc_media_player_t *p_mi,
 849                                    unsigned option, const char *psz_value )
 850 {
 851     set_value( p_mi,"logo",logo_option_bynumber(option), VLC_VAR_STRING,
 852                &(vlc_value_t){ .psz_string = (char *)psz_value }, true );
 853 }
 854
 855
 856 void libvlc_video_set_logo_int( libvlc_media_player_t *p_mi,
 857                                 unsigned option, int value )
 858 {
 859     set_value( p_mi, "logo", logo_option_bynumber(option), VLC_VAR_INTEGER,
 860                &(vlc_value_t) { .i_int = value }, true );
 861 }
 862
 863
 864 int libvlc_video_get_logo_int( libvlc_media_player_t *p_mi,
 865                                unsigned option )
 866 {
 867     return get_int( p_mi, "logo", logo_option_bynumber(option) );
 868 }
 869
 870
 871 /* adjust module support */
 872
 873
 874 static const opt_t *
 875 adjust_option_bynumber( unsigned option )
 876 {
 877     static const opt_t optlist[] =
 878     {
 879         { "adjust",     0 },
 880         { "contrast",   VLC_VAR_FLOAT },
 881         { "brightness", VLC_VAR_FLOAT },
 882         { "hue",        VLC_VAR_FLOAT },
 883         { "saturation", VLC_VAR_FLOAT },
 884         { "gamma",      VLC_VAR_FLOAT },
 885     };
 886     enum { num_opts = sizeof(optlist) / sizeof(*optlist) };
 887
 888     const opt_t *r = option < num_opts ? optlist+option : NULL;
 889     if( !r )
 890         libvlc_printerr( "Unknown adjust option" );
 891     return r;
 892 }
 893
 894
 895 void libvlc_video_set_adjust_int( libvlc_media_player_t *p_mi,
 896                                   unsigned option, int value )
 897 {
 898     set_value( p_mi, "adjust", adjust_option_bynumber(option), VLC_VAR_INTEGER,
 899                &(vlc_value_t) { .i_int = value }, false );
 900 }
 901
 902
 903 int libvlc_video_get_adjust_int( libvlc_media_player_t *p_mi,
 904                                  unsigned option )
 905 {
 906     return get_int( p_mi, "adjust", adjust_option_bynumber(option) );
 907 }
 908
 909
 910 void libvlc_video_set_adjust_float( libvlc_media_player_t *p_mi,
 911                                     unsigned option, float value )
 912 {
 913     set_value( p_mi, "adjust", adjust_option_bynumber(option), VLC_VAR_FLOAT,
 914                &(vlc_value_t) { .f_float = value }, false );
 915 }
 916
 917
 918 float libvlc_video_get_adjust_float( libvlc_media_player_t *p_mi,
 919                                      unsigned option )
 920 {
 921     return get_float( p_mi, "adjust", adjust_option_bynumber(option) );
 922 }