git.sesse.net Git - vlc/blob - src/control/video.c

   1 /*****************************************************************************
   2  * video.c: libvlc new API video functions
   3  *****************************************************************************
   4  * Copyright (C) 2005 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 <vlc_osd.h>
  42 #include <assert.h>
  43
  44 /*
  45  * Remember to release the returned vout_thread_t.
  46  */
  47 static vout_thread_t *GetVout( libvlc_media_player_t *p_mi,
  48                                libvlc_exception_t *p_exception )
  49 {
  50     input_thread_t *p_input = libvlc_get_input_thread( p_mi, p_exception );
  51     vout_thread_t *p_vout = NULL;
  52
  53     if( p_input )
  54     {
  55         p_vout = input_GetVout( p_input );
  56         if( !p_vout )
  57         {
  58             libvlc_exception_raise( p_exception );
  59             libvlc_printerr( "No active video output" );
  60         }
  61         vlc_object_release( p_input );
  62     }
  63     return p_vout;
  64 }
  65
  66 /**********************************************************************
  67  * Exported functions
  68  **********************************************************************/
  69
  70 void libvlc_set_fullscreen( libvlc_media_player_t *p_mi, int b_fullscreen,
  71                             libvlc_exception_t *p_e )
  72 {
  73     /* We only work on the first vout */
  74     vout_thread_t *p_vout = GetVout( p_mi, p_e );
  75
  76     /* GetVout will raise the exception for us */
  77     if( !p_vout ) return;
  78
  79     var_SetBool( p_vout, "fullscreen", b_fullscreen );
  80
  81     vlc_object_release( p_vout );
  82 }
  83
  84 int libvlc_get_fullscreen( libvlc_media_player_t *p_mi,
  85                             libvlc_exception_t *p_e )
  86 {
  87     /* We only work on the first vout */
  88     vout_thread_t *p_vout = GetVout( p_mi, p_e );
  89     int i_ret;
  90
  91     /* GetVout will raise the exception for us */
  92     if( !p_vout ) return 0;
  93
  94     i_ret = var_GetBool( p_vout, "fullscreen" );
  95
  96     vlc_object_release( p_vout );
  97
  98     return i_ret;
  99 }
 100
 101 void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi,
 102                                libvlc_exception_t *p_e )
 103 {
 104     /* We only work on the first vout */
 105     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 106
 107     /* GetVout will raise the exception for us */
 108     if( !p_vout ) return;
 109
 110     var_ToggleBool( p_vout, "fullscreen" );
 111
 112     vlc_object_release( p_vout );
 113 }
 114
 115 void libvlc_video_set_key_input( libvlc_media_player_t *p_mi, unsigned on )
 116 {
 117     p_mi->keyboard_events = !!on;
 118 }
 119
 120 void libvlc_video_set_mouse_input( libvlc_media_player_t *p_mi, unsigned on )
 121 {
 122     p_mi->mouse_events = !!on;
 123 }
 124
 125 void
 126 libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, const char *psz_filepath,
 127         unsigned int i_width, unsigned int i_height, libvlc_exception_t *p_e )
 128 {
 129     vout_thread_t *p_vout;
 130
 131     assert( psz_filepath );
 132
 133     /* We must have an input */
 134     if( !p_mi->p_input_thread )
 135     {
 136         libvlc_exception_raise( p_e );
 137         libvlc_printerr( "Input does not exist" );
 138         return;
 139     }
 140
 141     /* GetVout will raise the exception for us */
 142     p_vout = GetVout( p_mi, p_e );
 143     if( !p_vout ) return;
 144
 145     var_SetInteger( p_vout, "snapshot-width", i_width );
 146     var_SetInteger( p_vout, "snapshot-height", i_height );
 147
 148     var_SetString( p_vout, "snapshot-path", psz_filepath );
 149     var_SetString( p_vout, "snapshot-format", "png" );
 150
 151     var_TriggerCallback( p_vout, "video-snapshot" );
 152     vlc_object_release( p_vout );
 153 }
 154
 155 int libvlc_video_get_height( libvlc_media_player_t *p_mi,
 156                              libvlc_exception_t *p_e )
 157 {
 158     int height;
 159
 160     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 161     if( !p_vout ) return 0;
 162
 163     height = p_vout->i_window_height;
 164
 165     vlc_object_release( p_vout );
 166
 167     return height;
 168 }
 169
 170 int libvlc_video_get_width( libvlc_media_player_t *p_mi,
 171                             libvlc_exception_t *p_e )
 172 {
 173     int width;
 174
 175     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 176     if( !p_vout ) return 0;
 177
 178     width = p_vout->i_window_width;
 179
 180     vlc_object_release( p_vout );
 181
 182     return width;
 183 }
 184
 185 int libvlc_media_player_has_vout( libvlc_media_player_t *p_mi,
 186                                      libvlc_exception_t *p_e )
 187 {
 188     input_thread_t *p_input_thread = libvlc_get_input_thread(p_mi, p_e);
 189     bool has_vout = false;
 190
 191     if( p_input_thread )
 192     {
 193         vout_thread_t *p_vout;
 194
 195         p_vout = input_GetVout( p_input_thread );
 196         if( p_vout )
 197         {
 198             has_vout = true;
 199             vlc_object_release( p_vout );
 200         }
 201         vlc_object_release( p_input_thread );
 202     }
 203     return has_vout;
 204 }
 205
 206 float libvlc_video_get_scale( libvlc_media_player_t *p_mp,
 207                               libvlc_exception_t *p_e )
 208 {
 209     vout_thread_t *p_vout = GetVout( p_mp, p_e );
 210     if( !p_vout )
 211         return 0.;
 212
 213     float f_scale = var_GetFloat( p_vout, "scale" );
 214     if( var_GetBool( p_vout, "autoscale" ) )
 215         f_scale = 0.;
 216     vlc_object_release( p_vout );
 217     return f_scale;
 218 }
 219
 220 void libvlc_video_set_scale( libvlc_media_player_t *p_mp, float f_scale,
 221                              libvlc_exception_t *p_e )
 222 {
 223     vout_thread_t *p_vout = GetVout( p_mp, p_e );
 224     if( !p_vout )
 225         return;
 226
 227     if( f_scale != 0. )
 228         var_SetFloat( p_vout, "scale", f_scale );
 229     var_SetBool( p_vout, "autoscale", f_scale != 0. );
 230     vlc_object_release( p_vout );
 231 }
 232
 233 char *libvlc_video_get_aspect_ratio( libvlc_media_player_t *p_mi,
 234                                      libvlc_exception_t *p_e )
 235 {
 236     char *psz_aspect = NULL;
 237     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 238
 239     if( !p_vout ) return NULL;
 240
 241     psz_aspect = var_GetNonEmptyString( p_vout, "aspect-ratio" );
 242     vlc_object_release( p_vout );
 243     return psz_aspect ? psz_aspect : strdup("");
 244 }
 245
 246 void libvlc_video_set_aspect_ratio( libvlc_media_player_t *p_mi,
 247                                     const char *psz_aspect, libvlc_exception_t *p_e )
 248 {
 249     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 250     int i_ret = -1;
 251
 252     if( !p_vout ) return;
 253
 254     i_ret = var_SetString( p_vout, "aspect-ratio", psz_aspect );
 255     vlc_object_release( p_vout );
 256     if( i_ret )
 257     {
 258         libvlc_exception_raise( p_e );
 259         libvlc_printerr( "Bad or unsupported aspect ratio" );
 260     }
 261 }
 262
 263 int libvlc_video_get_spu( libvlc_media_player_t *p_mi,
 264                           libvlc_exception_t *p_e )
 265 {
 266     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 267     vlc_value_t val_list;
 268     vlc_value_t val;
 269     int i_spu = -1;
 270     int i_ret = -1;
 271     int i;
 272
 273     if( !p_input_thread ) return -1;
 274
 275     i_ret = var_Get( p_input_thread, "spu-es", &val );
 276     if( i_ret < 0 )
 277     {
 278         vlc_object_release( p_input_thread );
 279         libvlc_exception_raise( p_e );
 280         libvlc_printerr( "Subtitle informations not found" );
 281         return i_ret;
 282     }
 283
 284     var_Change( p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 285     for( i = 0; i < val_list.p_list->i_count; i++ )
 286     {
 287         if( val.i_int == val_list.p_list->p_values[i].i_int )
 288         {
 289             i_spu = i;
 290             break;
 291         }
 292     }
 293     var_FreeList( &val_list, NULL );
 294     vlc_object_release( p_input_thread );
 295     return i_spu;
 296 }
 297
 298 int libvlc_video_get_spu_count( libvlc_media_player_t *p_mi,
 299                                 libvlc_exception_t *p_e )
 300 {
 301     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 302     int i_spu_count;
 303
 304     if( !p_input_thread )
 305         return -1;
 306
 307     i_spu_count = var_CountChoices( p_input_thread, "spu-es" );
 308
 309     vlc_object_release( p_input_thread );
 310     return i_spu_count;
 311 }
 312
 313 libvlc_track_description_t *
 314         libvlc_video_get_spu_description( libvlc_media_player_t *p_mi,
 315                                           libvlc_exception_t *p_e )
 316 {
 317     return libvlc_get_track_description( p_mi, "spu-es", p_e);
 318 }
 319
 320 void libvlc_video_set_spu( libvlc_media_player_t *p_mi, int i_spu,
 321                            libvlc_exception_t *p_e )
 322 {
 323     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 324     vlc_value_t val_list;
 325     vlc_value_t newval;
 326     int i_ret = -1;
 327
 328     if( !p_input_thread ) return;
 329
 330     var_Change( p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 331
 332     if( ( val_list.p_list->i_count == 0 )
 333      || (i_spu < 0) || (i_spu > val_list.p_list->i_count) )
 334     {
 335         libvlc_exception_raise( p_e );
 336         libvlc_printerr( "Subtitle number out of range" );
 337         goto end;
 338     }
 339
 340     newval = val_list.p_list->p_values[i_spu];
 341     i_ret = var_Set( p_input_thread, "spu-es", newval );
 342     if( i_ret < 0 )
 343     {
 344         libvlc_exception_raise( p_e );
 345         libvlc_printerr( "Subtitle selection error" );
 346     }
 347
 348 end:
 349     var_FreeList( &val_list, NULL );
 350     vlc_object_release( p_input_thread );
 351 }
 352
 353 int libvlc_video_set_subtitle_file( libvlc_media_player_t *p_mi,
 354                                     const char *psz_subtitle,
 355                                     libvlc_exception_t *p_e )
 356 {
 357     input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e );
 358     bool b_ret = false;
 359
 360     if( p_input_thread )
 361     {
 362         if( !input_AddSubtitle( p_input_thread, psz_subtitle, true ) )
 363             b_ret = true;
 364         vlc_object_release( p_input_thread );
 365     }
 366     return b_ret;
 367 }
 368
 369 libvlc_track_description_t *
 370         libvlc_video_get_title_description( libvlc_media_player_t *p_mi,
 371                                             libvlc_exception_t * p_e )
 372 {
 373     return libvlc_get_track_description( p_mi, "title", p_e);
 374 }
 375
 376 libvlc_track_description_t *
 377         libvlc_video_get_chapter_description( libvlc_media_player_t *p_mi,
 378                                               int i_title,
 379                                               libvlc_exception_t *p_e )
 380 {
 381     char psz_title[12];
 382     sprintf( psz_title,  "title %2i", i_title );
 383     return libvlc_get_track_description( p_mi, psz_title, p_e);
 384 }
 385
 386 char *libvlc_video_get_crop_geometry( libvlc_media_player_t *p_mi,
 387                                    libvlc_exception_t *p_e )
 388 {
 389     char *psz_geometry = 0;
 390     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 391
 392     if( !p_vout ) return 0;
 393
 394     psz_geometry = var_GetNonEmptyString( p_vout, "crop" );
 395     vlc_object_release( p_vout );
 396     return psz_geometry ? psz_geometry : strdup("");
 397 }
 398
 399 void libvlc_video_set_crop_geometry( libvlc_media_player_t *p_mi,
 400                                      const char *psz_geometry, libvlc_exception_t *p_e )
 401 {
 402     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 403     int i_ret = -1;
 404
 405     if( !p_vout ) return;
 406
 407     i_ret = var_SetString( p_vout, "crop", psz_geometry );
 408     vlc_object_release( p_vout );
 409
 410     if( i_ret )
 411     {
 412         libvlc_exception_raise( p_e );
 413         libvlc_printerr( "Bad or unsupported cropping geometry" );
 414     }
 415 }
 416
 417 int libvlc_video_get_teletext( libvlc_media_player_t *p_mi,
 418                                libvlc_exception_t *p_e )
 419 {
 420 #if 0
 421     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 422     vlc_object_t *p_vbi;
 423     int i_ret = -1;
 424
 425     if( !p_vout ) return i_ret;
 426
 427     p_vbi = (vlc_object_t *) vlc_object_find_name( p_vout, "zvbi",
 428                                                    FIND_CHILD );
 429     if( p_vbi )
 430     {
 431         i_ret = var_GetInteger( p_vbi, "vbi-page" );
 432         vlc_object_release( p_vbi );
 433     }
 434
 435     vlc_object_release( p_vout );
 436     return i_ret;
 437 #else
 438     VLC_UNUSED( p_mi );
 439     VLC_UNUSED( p_e );
 440     return -1;
 441 #endif
 442 }
 443
 444 void libvlc_video_set_teletext( libvlc_media_player_t *p_mi, int i_page,
 445                                 libvlc_exception_t *p_e )
 446 {
 447 #if 0
 448     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 449     vlc_object_t *p_vbi;
 450     int i_ret = -1;
 451
 452     if( !p_vout ) return;
 453
 454     p_vbi = (vlc_object_t *) vlc_object_find_name( p_vout, "zvbi",
 455                                                    FIND_CHILD );
 456     if( p_vbi )
 457     {
 458         i_ret = var_SetInteger( p_vbi, "vbi-page", i_page );
 459         vlc_object_release( p_vbi );
 460         if( i_ret )
 461             libvlc_exception_raise( p_e,
 462                             "Unexpected error while setting teletext page" );
 463     }
 464     vlc_object_release( p_vout );
 465 #else
 466     VLC_UNUSED( p_mi );
 467     VLC_UNUSED( p_e );
 468     VLC_UNUSED( i_page );
 469 #endif
 470 }
 471
 472 void libvlc_toggle_teletext( libvlc_media_player_t *p_mi,
 473                              libvlc_exception_t *p_e )
 474 {
 475     input_thread_t *p_input_thread;
 476
 477     p_input_thread = libvlc_get_input_thread(p_mi, p_e);
 478     if( !p_input_thread ) return;
 479
 480     if( var_CountChoices( p_input_thread, "teletext-es" ) <= 0 )
 481     {
 482         vlc_object_release( p_input_thread );
 483         return;
 484     }
 485     const bool b_selected = var_GetInteger( p_input_thread, "teletext-es" ) >= 0;
 486 #if 0
 487     int i_ret;
 488     vlc_object_t *p_vbi;
 489     p_vbi = (vlc_object_t *)vlc_object_find_name( p_input_thread, "zvbi",
 490                                                   FIND_CHILD );
 491     if( p_vbi )
 492     {
 493         if( b_selected )
 494         {
 495             /* FIXME Gni, why that ? */
 496             i_ret = var_SetInteger( p_vbi, "vbi-page",
 497                                     var_GetInteger( p_vbi, "vbi-page" ) );
 498             if( i_ret )
 499                 libvlc_exception_raise( p_e,
 500                                 "Unexpected error while setting teletext page" );
 501         }
 502         else
 503         {
 504             /* FIXME Gni^2 */
 505             i_ret = var_SetBool( p_vbi, "vbi-opaque",
 506                                  !var_GetBool( p_vbi, "vbi-opaque" ) );
 507             if( i_ret )
 508                 libvlc_exception_raise( p_e,
 509                                 "Unexpected error while setting teletext transparency" );
 510         }
 511         vlc_object_release( p_vbi );
 512     }
 513     else
 514 #endif
 515     if( b_selected )
 516     {
 517         var_SetInteger( p_input_thread, "spu-es", -1 );
 518     }
 519     else
 520     {
 521         vlc_value_t list;
 522         if( !var_Change( p_input_thread, "teletext-es", VLC_VAR_GETLIST, &list, NULL ) )
 523         {
 524             if( list.p_list->i_count > 0 )
 525                 var_SetInteger( p_input_thread, "spu-es", list.p_list->p_values[0].i_int );
 526
 527             var_FreeList( &list, NULL );
 528         }
 529     }
 530     vlc_object_release( p_input_thread );
 531 }
 532
 533 int libvlc_video_get_track_count( libvlc_media_player_t *p_mi,
 534                                   libvlc_exception_t *p_e )
 535 {
 536     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 537     int i_track_count;
 538
 539     if( !p_input_thread )
 540         return -1;
 541
 542     i_track_count = var_CountChoices( p_input_thread, "video-es" );
 543
 544     vlc_object_release( p_input_thread );
 545     return i_track_count;
 546 }
 547
 548 libvlc_track_description_t *
 549         libvlc_video_get_track_description( libvlc_media_player_t *p_mi,
 550                                             libvlc_exception_t *p_e )
 551 {
 552     return libvlc_get_track_description( p_mi, "video-es", p_e);
 553 }
 554
 555 int libvlc_video_get_track( libvlc_media_player_t *p_mi,
 556                             libvlc_exception_t *p_e )
 557 {
 558     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 559     vlc_value_t val_list;
 560     vlc_value_t val;
 561     int i_track = -1;
 562     int i_ret = -1;
 563     int i;
 564
 565     if( !p_input_thread )
 566         return -1;
 567
 568     i_ret = var_Get( p_input_thread, "video-es", &val );
 569     if( i_ret < 0 )
 570     {
 571         libvlc_exception_raise( p_e );
 572         libvlc_printerr( "Video track information not found" );
 573         vlc_object_release( p_input_thread );
 574         return i_ret;
 575     }
 576
 577     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 578     for( i = 0; i < val_list.p_list->i_count; i++ )
 579     {
 580         if( val_list.p_list->p_values[i].i_int == val.i_int )
 581         {
 582             i_track = i;
 583             break;
 584         }
 585     }
 586     var_FreeList( &val_list, NULL );
 587     vlc_object_release( p_input_thread );
 588     return i_track;
 589 }
 590
 591 void libvlc_video_set_track( libvlc_media_player_t *p_mi, int i_track,
 592                              libvlc_exception_t *p_e )
 593 {
 594     input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );
 595     vlc_value_t val_list;
 596     int i_ret = -1;
 597     int i;
 598
 599     if( !p_input_thread )
 600         return;
 601
 602     var_Change( p_input_thread, "video-es", VLC_VAR_GETCHOICES, &val_list, NULL );
 603     for( i = 0; i < val_list.p_list->i_count; i++ )
 604     {
 605         if( i_track == val_list.p_list->p_values[i].i_int )
 606         {
 607             i_ret = var_SetInteger( p_input_thread, "video-es", i_track );
 608             if( i_ret < 0 )
 609                 break;
 610             goto end;
 611         }
 612     }
 613     libvlc_exception_raise( p_e );
 614     libvlc_printerr( "Video track number out of range" );
 615 end:
 616     var_FreeList( &val_list, NULL );
 617     vlc_object_release( p_input_thread );
 618 }
 619
 620 /******************************************************************************
 621  * libvlc_video_set_deinterlace : enable deinterlace
 622  *****************************************************************************/
 623 void libvlc_video_set_deinterlace( libvlc_media_player_t *p_mi, int b_enable,
 624                                    const char *psz_mode,
 625                                    libvlc_exception_t *p_e )
 626 {
 627     vout_thread_t *p_vout = GetVout( p_mi, p_e );
 628
 629     if( !p_vout )
 630         return;
 631
 632     if( b_enable )
 633     {
 634         /* be sure that the filter name given is supported */
 635         if( !strcmp(psz_mode, "blend")   || !strcmp(psz_mode, "bob")
 636          || !strcmp(psz_mode, "discard") || !strcmp(psz_mode, "linear")
 637          || !strcmp(psz_mode, "mean")    || !strcmp(psz_mode, "x")
 638          || !strcmp(psz_mode, "yadif")   || !strcmp(psz_mode, "yadif2x") )
 639         {
 640             /* set deinterlace filter chosen */
 641             var_SetString( p_vout, "deinterlace-mode", psz_mode );
 642             var_SetInteger( p_vout, "deinterlace", 1 );
 643         }
 644         else
 645         {
 646             libvlc_exception_raise( p_e );
 647             libvlc_printerr( "Bad or unsupported deinterlacing mode" );
 648         }
 649     }
 650     else
 651     {
 652         /* disable deinterlace filter */
 653         var_SetInteger( p_vout, "deinterlace", 0 );
 654     }
 655
 656     vlc_object_release( p_vout );
 657 }
 658
 659 /*****************************************************************************
 660  * Marquee: FIXME: That implementation has no persistent state and requires
 661  * a vout
 662  *****************************************************************************/
 663
 664 static const char *get_marquee_int_option_identifier(unsigned option)
 665 {
 666     static const char tab[][16] =
 667     {
 668         "marq",
 669         "marq-color",
 670         "marq-opacity",
 671         "marq-position",
 672         "marq-refresh",
 673         "marq-size",
 674         "marq-timeout",
 675         "marq-x",
 676         "marq-y",
 677     };
 678     if( option >= sizeof( tab ) / sizeof( tab[0] ) )
 679         return NULL;
 680     return tab[option];
 681 }
 682
 683 static const char *get_marquee_string_option_identifier(unsigned option)
 684 {
 685     static const char tab[][16] =
 686     {
 687         "marq-marquee",
 688     };
 689     if( option >= sizeof( tab ) / sizeof( tab[0] ) )
 690         return NULL;
 691     return tab[option];
 692 }
 693
 694
 695 static vlc_object_t *get_marquee_object( libvlc_media_player_t * p_mi )
 696 {
 697     libvlc_exception_t e;
 698     libvlc_exception_init(&e);
 699     vout_thread_t * vout = GetVout( p_mi, &e );
 700     libvlc_exception_clear(&e);
 701     if( !vout )
 702         return NULL;
 703     vlc_object_t * object = vlc_object_find_name( vout, "marq", FIND_CHILD );
 704     vlc_object_release(vout);
 705     return object;
 706 }
 707
 708 /*****************************************************************************
 709  * libvlc_video_get_marquee_option_as_int : get a marq option value
 710  *****************************************************************************/
 711 int libvlc_video_get_marquee_option_as_int( libvlc_media_player_t *p_mi,
 712                                             libvlc_video_marquee_int_option_t option,
 713                                             libvlc_exception_t *p_e )
 714 {
 715     const char * identifier = get_marquee_int_option_identifier(option);
 716     if(!identifier)
 717     {
 718         libvlc_exception_raise( p_e );
 719         libvlc_printerr( "Unknown marquee option" );
 720         return 0;
 721     }
 722     vlc_object_t * marquee = get_marquee_object(p_mi);
 723
 724     /* Handle the libvlc_marquee_Enabled separately */
 725     if(option == libvlc_marquee_Enabled)
 726     {
 727         bool isEnabled = marquee != NULL;
 728         vlc_object_release(marquee);
 729         return isEnabled;
 730     }
 731
 732     /* Generic case */
 733     if(!identifier)
 734     {
 735         libvlc_exception_raise( p_e );
 736         libvlc_printerr( "Marquee not enabled" );
 737         return 0;
 738     }
 739 #warning This and the next function may crash due to type checking!
 740     int ret = var_GetInteger(marquee, identifier);
 741     vlc_object_release(marquee);
 742     return ret;
 743 }
 744
 745 /*****************************************************************************
 746  * libvlc_video_get_marquee_option_as_string : get a marq option value
 747  *****************************************************************************/
 748 char * libvlc_video_get_marquee_option_as_string( libvlc_media_player_t *p_mi,
 749                                                   libvlc_video_marquee_string_option_t option,
 750                                                   libvlc_exception_t *p_e )
 751 {
 752     const char * identifier = get_marquee_string_option_identifier(option);
 753     if(!identifier)
 754     {
 755         libvlc_exception_raise( p_e );
 756         libvlc_printerr( "Unknown marquee option" );
 757         return NULL;
 758     }
 759
 760     vlc_object_t * marquee = get_marquee_object(p_mi);
 761     if(!marquee)
 762     {
 763         libvlc_exception_raise( p_e );
 764         libvlc_printerr( "Marquee not enabled" );
 765         return NULL;
 766     }
 767     char *ret = var_GetString(marquee, identifier);
 768     vlc_object_release(marquee);
 769     return ret;
 770 }
 771
 772 /*****************************************************************************
 773  * libvlc_video_set_marquee_option_as_int: enable, disable or set an int option
 774  *****************************************************************************/
 775 void libvlc_video_set_marquee_option_as_int( libvlc_media_player_t *p_mi,
 776                                           libvlc_video_marquee_int_option_t option,
 777                                           int value, libvlc_exception_t *p_e )
 778 {
 779     const char * identifier = get_marquee_int_option_identifier(option);
 780     if(!identifier)
 781     {
 782         libvlc_exception_raise( p_e );
 783         libvlc_printerr( "Unknown marquee option" );
 784         return;
 785     }
 786
 787     /* Handle the libvlc_marquee_Enabled separately */
 788     if(option == libvlc_marquee_Enabled)
 789     {
 790         libvlc_exception_t e;
 791         libvlc_exception_init(&e);
 792         vout_thread_t * vout = GetVout( p_mi, &e );
 793         libvlc_exception_clear(&e);
 794         if (vout)
 795         {
 796             vout_EnableFilter(vout, identifier, value, false);
 797             vlc_object_release(vout);
 798         }
 799         return;
 800     }
 801
 802     vlc_object_t * marquee = get_marquee_object(p_mi);
 803     if(!marquee)
 804     {
 805         libvlc_exception_raise( p_e );
 806         libvlc_printerr( "Marquee not enabled" );
 807         return;
 808     }
 809     var_SetInteger(marquee, identifier, value);
 810     vlc_object_release(marquee);
 811 }
 812
 813 /*****************************************************************************
 814  * libvlc_video_set_marquee_option_as_string: set a string option
 815  *****************************************************************************/
 816 void libvlc_video_set_marquee_option_as_string( libvlc_media_player_t *p_mi,
 817                                              libvlc_video_marquee_string_option_t option,
 818                                              const char * value,
 819                                              libvlc_exception_t *p_e )
 820 {
 821     const char * identifier = get_marquee_string_option_identifier(option);
 822     if(!identifier)
 823     {
 824         libvlc_exception_raise( p_e );
 825         libvlc_printerr( "Unknown marquee option" );
 826         return;
 827     }
 828     vlc_object_t * marquee = get_marquee_object(p_mi);
 829     if(!marquee)
 830     {
 831         libvlc_exception_raise( p_e );
 832         libvlc_printerr( "Marquee not enabled" );
 833         return;
 834     }
 835     var_SetString(marquee, identifier, value);
 836     vlc_object_release(marquee);
 837 }