1 /*****************************************************************************
2 * video.c: libvlc new API video functions
3 *****************************************************************************
4 * Copyright (C) 2005-2010 VLC authors and VideoLAN
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>
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.
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.
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 *****************************************************************************/
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>
37 #include <vlc_common.h>
38 #include <vlc_modules.h>
42 #include "libvlc_internal.h"
43 #include "media_player_internal.h"
48 * Remember to release the returned vout_thread_t.
50 static vout_thread_t
**GetVouts( libvlc_media_player_t
*p_mi
, size_t *n
)
52 vlc_player_t
*player
= p_mi
->player
;
53 return vlc_player_vout_HoldAll(player
, n
);
56 static vout_thread_t
*GetVout (libvlc_media_player_t
*mp
, size_t num
)
58 vout_thread_t
*p_vout
= NULL
;
60 vout_thread_t
**pp_vouts
= GetVouts (mp
, &n
);
65 p_vout
= pp_vouts
[num
];
67 for (size_t i
= 0; i
< n
; i
++)
69 vout_Release(pp_vouts
[i
]);
74 libvlc_printerr ("Video output not active");
78 /**********************************************************************
80 **********************************************************************/
82 void libvlc_set_fullscreen(libvlc_media_player_t
*p_mi
, bool b_fullscreen
)
84 /* This will work even if the video is not currently active */
85 var_SetBool(p_mi
, "fullscreen", b_fullscreen
);
87 /* Apply to current video outputs (if any) */
89 vout_thread_t
**pp_vouts
= GetVouts (p_mi
, &n
);
90 for (size_t i
= 0; i
< n
; i
++)
92 var_SetBool (pp_vouts
[i
], "fullscreen", b_fullscreen
);
93 vout_Release(pp_vouts
[i
]);
98 bool libvlc_get_fullscreen( libvlc_media_player_t
*p_mi
)
100 return var_GetBool (p_mi
, "fullscreen");
103 void libvlc_toggle_fullscreen( libvlc_media_player_t
*p_mi
)
105 bool b_fullscreen
= var_ToggleBool (p_mi
, "fullscreen");
107 /* Apply to current video outputs (if any) */
109 vout_thread_t
**pp_vouts
= GetVouts (p_mi
, &n
);
110 for (size_t i
= 0; i
< n
; i
++)
112 vout_thread_t
*p_vout
= pp_vouts
[i
];
114 var_SetBool (p_vout
, "fullscreen", b_fullscreen
);
115 vout_Release(p_vout
);
120 void libvlc_video_set_key_input( libvlc_media_player_t
*p_mi
, unsigned on
)
122 var_SetBool (p_mi
, "keyboard-events", !!on
);
125 void libvlc_video_set_mouse_input( libvlc_media_player_t
*p_mi
, unsigned on
)
127 var_SetBool (p_mi
, "mouse-events", !!on
);
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
)
135 assert( psz_filepath
);
137 vout_thread_t
*p_vout
= GetVout (p_mi
, num
);
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
);
158 int libvlc_video_get_size( libvlc_media_player_t
*p_mi
, unsigned ignored
,
159 unsigned *restrict px
, unsigned *restrict py
)
162 if (p_mi
->p_md
== NULL
)
166 libvlc_media_track_t
*track
=
167 libvlc_media_player_get_selected_track( p_mi
, libvlc_track_video
);
171 *px
= track
->video
->i_width
;
172 *py
= track
->video
->i_height
;
174 libvlc_media_track_release(track
);
180 int libvlc_video_get_cursor( libvlc_media_player_t
*mp
, unsigned num
,
181 int *restrict px
, int *restrict py
)
183 vout_thread_t
*p_vout
= GetVout (mp
, num
);
187 var_GetCoords (p_vout
, "mouse-moved", px
, py
);
188 vout_Release(p_vout
);
192 unsigned libvlc_media_player_has_vout( libvlc_media_player_t
*p_mi
)
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
]);
202 float libvlc_video_get_scale( libvlc_media_player_t
*mp
)
204 float f_scale
= var_GetFloat (mp
, "zoom");
205 if (var_GetBool (mp
, "autoscale"))
210 void libvlc_video_set_scale( libvlc_media_player_t
*p_mp
, float f_scale
)
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
);
216 /* Apply to current video outputs (if any) */
218 vout_thread_t
**pp_vouts
= GetVouts (p_mp
, &n
);
219 for (size_t i
= 0; i
< n
; i
++)
221 vout_thread_t
*p_vout
= pp_vouts
[i
];
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
);
231 char *libvlc_video_get_aspect_ratio( libvlc_media_player_t
*p_mi
)
233 return var_GetNonEmptyString (p_mi
, "aspect-ratio");
236 void libvlc_video_set_aspect_ratio( libvlc_media_player_t
*p_mi
,
237 const char *psz_aspect
)
239 if (psz_aspect
== NULL
)
241 var_SetString (p_mi
, "aspect-ratio", psz_aspect
);
244 vout_thread_t
**pp_vouts
= GetVouts (p_mi
, &n
);
245 for (size_t i
= 0; i
< n
; i
++)
247 vout_thread_t
*p_vout
= pp_vouts
[i
];
249 var_SetString (p_vout
, "aspect-ratio", psz_aspect
);
250 vout_Release(p_vout
);
255 libvlc_video_viewpoint_t
*libvlc_video_new_viewpoint(void)
257 libvlc_video_viewpoint_t
*p_vp
= malloc(sizeof *p_vp
);
258 if (unlikely(p_vp
== NULL
))
260 p_vp
->f_yaw
= p_vp
->f_pitch
= p_vp
->f_roll
= p_vp
->f_field_of_view
= 0.0f
;
264 int libvlc_video_update_viewpoint( libvlc_media_player_t
*p_mi
,
265 const libvlc_video_viewpoint_t
*p_viewpoint
,
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
,
275 enum vlc_player_whence whence
= b_absolute
? VLC_PLAYER_WHENCE_ABSOLUTE
276 : VLC_PLAYER_WHENCE_RELATIVE
;
278 vlc_player_t
*player
= p_mi
->player
;
279 vlc_player_Lock(player
);
281 vlc_player_UpdateViewpoint(player
, &update
, whence
);
283 vlc_player_Unlock(player
);
285 /* may not fail anymore, keep int not to break the API */
289 int libvlc_video_get_spu( libvlc_media_player_t
*p_mi
)
291 vlc_player_t
*player
= p_mi
->player
;
292 vlc_player_Lock(player
);
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;
298 vlc_player_Unlock(player
);
302 int libvlc_video_get_spu_count( libvlc_media_player_t
*p_mi
)
304 vlc_player_t
*player
= p_mi
->player
;
305 vlc_player_Lock(player
);
307 int ret
= vlc_player_GetTrackCount(p_mi
->player
, SPU_ES
);
309 vlc_player_Unlock(player
);
313 libvlc_track_description_t
*
314 libvlc_video_get_spu_description( libvlc_media_player_t
*p_mi
)
316 return libvlc_get_track_description( p_mi
, SPU_ES
);
319 int libvlc_video_set_spu( libvlc_media_player_t
*p_mi
, int i_spu
)
323 vlc_player_t
*player
= p_mi
->player
;
324 vlc_player_Lock(player
);
326 size_t count
= vlc_player_GetSubtitleTrackCount(player
);
327 for (size_t i
= 0; i
< count
; i
++)
329 const struct vlc_player_track
*track
=
330 vlc_player_GetSubtitleTrackAt(player
, i
);
331 if (i_spu
== vlc_es_id_GetInputId(track
->es_id
))
334 vlc_player_SelectTrack(player
, track
, VLC_PLAYER_SELECT_EXCLUSIVE
);
339 libvlc_printerr( "Track identifier not found" );
341 vlc_player_Unlock(player
);
345 int64_t libvlc_video_get_spu_delay( libvlc_media_player_t
*p_mi
)
347 vlc_player_t
*player
= p_mi
->player
;
348 vlc_player_Lock(player
);
350 vlc_tick_t delay
= vlc_player_GetSubtitleDelay(player
);
352 vlc_player_Unlock(player
);
354 return US_FROM_VLC_TICK(delay
);
357 int libvlc_video_set_spu_delay( libvlc_media_player_t
*p_mi
,
360 vlc_player_t
*player
= p_mi
->player
;
361 vlc_player_Lock(player
);
363 vlc_player_SetSubtitleDelay(player
, VLC_TICK_FROM_US(i_delay
),
364 VLC_PLAYER_WHENCE_ABSOLUTE
);
366 vlc_player_Unlock(player
);
367 /* may not fail anymore, keep int not to break the API */
371 void libvlc_video_set_spu_text_scale( libvlc_media_player_t
*p_mi
,
374 vlc_player_t
*player
= p_mi
->player
;
375 vlc_player_Lock(player
);
377 vlc_player_SetSubtitleTextScale(player
, lroundf(f_scale
* 100.f
));
379 vlc_player_Unlock(player
);
382 static void libvlc_video_set_crop(libvlc_media_player_t
*mp
,
383 const char *geometry
)
385 var_SetString(mp
, "crop", geometry
);
388 vout_thread_t
**vouts
= GetVouts(mp
, &n
);
390 for (size_t i
= 0; i
< n
; i
++)
392 var_SetString(vouts
[i
], "crop", geometry
);
393 vout_Release(vouts
[i
]);
398 void libvlc_video_set_crop_ratio(libvlc_media_player_t
*mp
,
399 unsigned num
, unsigned den
)
401 char geometry
[2 * (3 * sizeof (unsigned) + 1)];
406 sprintf(geometry
, "%u:%u", num
, den
);
408 libvlc_video_set_crop(mp
, geometry
);
411 void libvlc_video_set_crop_window(libvlc_media_player_t
*mp
,
412 unsigned x
, unsigned y
,
413 unsigned width
, unsigned height
)
415 char geometry
[4 * (3 * sizeof (unsigned) + 1)];
417 assert(width
!= 0 && height
!= 0);
418 sprintf(geometry
, "%ux%u+%u+%u", x
, y
, width
, height
);
419 libvlc_video_set_crop(mp
, geometry
);
422 void libvlc_video_set_crop_border(libvlc_media_player_t
*mp
,
423 unsigned left
, unsigned right
,
424 unsigned top
, unsigned bottom
)
426 char geometry
[4 * (3 * sizeof (unsigned) + 1)];
428 sprintf(geometry
, "%u+%u+%u+%u", left
, top
, right
, bottom
);
429 libvlc_video_set_crop(mp
, geometry
);
432 int libvlc_video_get_teletext( libvlc_media_player_t
*p_mi
)
434 return var_GetInteger (p_mi
, "vbi-page");
437 void libvlc_video_set_teletext( libvlc_media_player_t
*p_mi
, int i_page
)
439 vlc_player_t
*player
= p_mi
->player
;
440 vlc_player_Lock(player
);
443 vlc_player_SetTeletextEnabled(player
, false);
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
;
455 libvlc_printerr("Invalid key action");
459 vlc_player_SetTeletextEnabled(player
, true);
460 vlc_player_SelectTeletextPage(player
, i_page
);
464 libvlc_printerr("Invalid page number");
468 vlc_player_Unlock(player
);
471 int libvlc_video_get_track_count( libvlc_media_player_t
*p_mi
)
473 vlc_player_t
*player
= p_mi
->player
;
474 vlc_player_Lock(player
);
476 int ret
= vlc_player_GetTrackCount(p_mi
->player
, VIDEO_ES
);
478 vlc_player_Unlock(player
);
482 libvlc_track_description_t
*
483 libvlc_video_get_track_description( libvlc_media_player_t
*p_mi
)
485 return libvlc_get_track_description( p_mi
, VIDEO_ES
);
488 int libvlc_video_get_track( libvlc_media_player_t
*p_mi
)
490 vlc_player_t
*player
= p_mi
->player
;
491 vlc_player_Lock(player
);
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;
497 vlc_player_Unlock(player
);
501 int libvlc_video_set_track( libvlc_media_player_t
*p_mi
, int i_track
)
505 vlc_player_t
*player
= p_mi
->player
;
506 vlc_player_Lock(player
);
508 size_t count
= vlc_player_GetVideoTrackCount(player
);
509 for( size_t i
= 0; i
< count
; i
++ )
511 const struct vlc_player_track
*track
=
512 vlc_player_GetVideoTrackAt(player
, i
);
513 if (i_track
== vlc_es_id_GetInputId(track
->es_id
))
516 vlc_player_SelectTrack(player
, track
, VLC_PLAYER_SELECT_EXCLUSIVE
);
521 libvlc_printerr( "Track identifier not found" );
523 vlc_player_Unlock(player
);
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
)
533 if (deinterlace
!= 0 && deinterlace
!= 1)
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"))
545 if (psz_mode
&& deinterlace
!= 0)
546 var_SetString (p_mi
, "deinterlace-mode", psz_mode
);
548 var_SetInteger (p_mi
, "deinterlace", deinterlace
);
551 vout_thread_t
**pp_vouts
= GetVouts (p_mi
, &n
);
552 for (size_t i
= 0; i
< n
; i
++)
554 vout_thread_t
*p_vout
= pp_vouts
[i
];
556 if (psz_mode
&& deinterlace
!= 0)
557 var_SetString (p_vout
, "deinterlace-mode", psz_mode
);
559 var_SetInteger (p_vout
, "deinterlace", deinterlace
);
560 vout_Release(p_vout
);
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
)
575 const char *psz_filter_type
;
577 module_t
*p_obj
= module_find( psz_name
);
580 msg_Err( p_parent
, "Unable to find filter module \"%s\".", psz_name
);
584 if( module_provides( p_obj
, "video filter" ) )
586 psz_filter_type
= "video-filter";
588 else if( module_provides( p_obj
, "sub source" ) )
590 psz_filter_type
= "sub-source";
592 else if( module_provides( p_obj
, "sub filter" ) )
594 psz_filter_type
= "sub-filter";
598 msg_Err( p_parent
, "Unknown video filter type." );
602 psz_string
= var_GetString( p_parent
, psz_filter_type
);
604 /* Todo : Use some generic chain manipulation functions */
605 if( !psz_string
) psz_string
= strdup("");
607 psz_parser
= strstr( psz_string
, psz_name
);
612 psz_parser
= psz_string
;
613 if( asprintf( &psz_string
, (*psz_string
) ? "%s:%s" : "%s%s",
614 psz_string
, psz_name
) == -1 )
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 );
635 /* Remove trailing : : */
636 if( *(psz_string
+strlen(psz_string
) -1 ) == ':' )
637 *(psz_string
+strlen(psz_string
) -1 ) = '\0';
646 *ppsz_filter_type
= psz_filter_type
;
647 *ppsz_filter_value
= psz_string
;
651 static bool find_sub_source_by_name( libvlc_media_player_t
*p_mi
, const char *restrict name
)
653 vout_thread_t
*vout
= GetVout( p_mi
, 0 );
657 char *psz_sources
= var_GetString( vout
, "sub-source" );
660 libvlc_printerr( "%s not enabled", name
);
666 char *p
= strstr( psz_sources
, name
);
672 typedef const struct {
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
)
684 int i_type
= opt
->type
;
685 vlc_value_t new_val
= *val
;
686 const char *psz_opt_name
= opt
->name
;
689 case 0: /* the enabler */
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
)
695 i_type
= VLC_VAR_STRING
;
698 case VLC_VAR_INTEGER
:
701 if( i_expected_type
!= opt
->type
)
703 libvlc_printerr( "Invalid argument to %s", name
);
708 libvlc_printerr( "Invalid argument to %s", name
);
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
);
716 /* Set the new value to every loaded vouts */
718 vout_thread_t
**pp_vouts
= GetVouts( p_mi
, &i_vout_count
);
719 for( size_t i
= 0; i
< i_vout_count
; ++i
)
721 var_SetChecked( pp_vouts
[i
], psz_opt_name
, i_type
, new_val
);
723 var_TriggerCallback( pp_vouts
[i
], "sub-source" );
724 vout_Release(pp_vouts
[i
]);
728 free( new_val
.psz_string
);
732 get_int( libvlc_media_player_t
*p_mi
, const char *restrict name
,
733 const opt_t
*restrict opt
)
739 case 0: /* the enabler */
741 bool b_enabled
= find_sub_source_by_name( p_mi
, name
);
742 return b_enabled
? 1 : 0;
744 case VLC_VAR_INTEGER
:
745 return var_GetInteger(p_mi
, opt
->name
);
747 return lroundf(var_GetFloat(p_mi
, opt
->name
));
749 libvlc_printerr( "Invalid argument to %s in %s", name
, "get int" );
755 get_float( libvlc_media_player_t
*p_mi
, const char *restrict name
,
756 const opt_t
*restrict opt
)
758 if( !opt
) return 0.0;
760 if( opt
->type
!= VLC_VAR_FLOAT
)
762 libvlc_printerr( "Invalid argument to %s in %s", name
, "get float" );
766 return var_GetFloat( p_mi
, opt
->name
);
770 marq_option_bynumber(unsigned option
)
772 static const opt_t optlist
[] =
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
},
785 enum { num_opts
= sizeof(optlist
) / sizeof(*optlist
) };
787 const opt_t
*r
= option
< num_opts
? optlist
+option
: NULL
;
789 libvlc_printerr( "Unknown marquee option" );
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
,
799 return get_int( p_mi
, "marq", marq_option_bynumber(option
) );
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
)
808 set_value( p_mi
, "marq", marq_option_bynumber(option
), VLC_VAR_INTEGER
,
809 &(vlc_value_t
) { .i_int
= value
}, true );
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
)
818 set_value( p_mi
, "marq", marq_option_bynumber(option
), VLC_VAR_STRING
,
819 &(vlc_value_t
){ .psz_string
= (char *)value
}, true );
823 /* logo module support */
826 logo_option_bynumber( unsigned option
)
828 static const opt_t vlogo_optlist
[] =
829 /* depends on libvlc_video_logo_option_t */
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
},
840 enum { num_vlogo_opts
= sizeof(vlogo_optlist
) / sizeof(*vlogo_optlist
) };
842 const opt_t
*r
= option
< num_vlogo_opts
? vlogo_optlist
+option
: NULL
;
844 libvlc_printerr( "Unknown logo option" );
848 void libvlc_video_set_logo_string( libvlc_media_player_t
*p_mi
,
849 unsigned option
, const char *psz_value
)
851 set_value( p_mi
,"logo",logo_option_bynumber(option
), VLC_VAR_STRING
,
852 &(vlc_value_t
){ .psz_string
= (char *)psz_value
}, true );
856 void libvlc_video_set_logo_int( libvlc_media_player_t
*p_mi
,
857 unsigned option
, int value
)
859 set_value( p_mi
, "logo", logo_option_bynumber(option
), VLC_VAR_INTEGER
,
860 &(vlc_value_t
) { .i_int
= value
}, true );
864 int libvlc_video_get_logo_int( libvlc_media_player_t
*p_mi
,
867 return get_int( p_mi
, "logo", logo_option_bynumber(option
) );
871 /* adjust module support */
875 adjust_option_bynumber( unsigned option
)
877 static const opt_t optlist
[] =
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
},
886 enum { num_opts
= sizeof(optlist
) / sizeof(*optlist
) };
888 const opt_t
*r
= option
< num_opts
? optlist
+option
: NULL
;
890 libvlc_printerr( "Unknown adjust option" );
895 void libvlc_video_set_adjust_int( libvlc_media_player_t
*p_mi
,
896 unsigned option
, int value
)
898 set_value( p_mi
, "adjust", adjust_option_bynumber(option
), VLC_VAR_INTEGER
,
899 &(vlc_value_t
) { .i_int
= value
}, false );
903 int libvlc_video_get_adjust_int( libvlc_media_player_t
*p_mi
,
906 return get_int( p_mi
, "adjust", adjust_option_bynumber(option
) );
910 void libvlc_video_set_adjust_float( libvlc_media_player_t
*p_mi
,
911 unsigned option
, float value
)
913 set_value( p_mi
, "adjust", adjust_option_bynumber(option
), VLC_VAR_FLOAT
,
914 &(vlc_value_t
) { .f_float
= value
}, false );
918 float libvlc_video_get_adjust_float( libvlc_media_player_t
*p_mi
,
921 return get_float( p_mi
, "adjust", adjust_option_bynumber(option
) );