1 /*****************************************************************************
2 * media_player.c: Libvlc API Media Instance management functions
3 *****************************************************************************
4 * Copyright (C) 2005-2015 VLC authors and VideoLAN
6 * Authors: Clément Stenac <zorglub@videolan.org>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21 *****************************************************************************/
29 #include <vlc/libvlc.h>
30 #include <vlc/libvlc_renderer_discoverer.h>
31 #include <vlc/libvlc_media.h>
32 #include <vlc/libvlc_events.h>
34 #include <vlc_demux.h>
35 #include <vlc_input.h>
40 #include "libvlc_internal.h"
41 #include "media_internal.h" // libvlc_media_set_state()
42 #include "media_player_internal.h"
43 #include "renderer_discoverer_internal.h"
46 input_seekable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
47 vlc_value_t oldval
, vlc_value_t newval
,
50 input_pausable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
51 vlc_value_t oldval
, vlc_value_t newval
,
54 input_scrambled_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
55 vlc_value_t oldval
, vlc_value_t newval
,
58 input_event_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
59 vlc_value_t oldval
, vlc_value_t newval
,
63 input_es_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
64 int action
, vlc_value_t
*p_val
,
68 input_es_selected( vlc_object_t
* p_this
, char const * psz_cmd
,
69 vlc_value_t oldval
, vlc_value_t newval
,
73 corks_changed(vlc_object_t
*obj
, const char *name
, vlc_value_t old
,
74 vlc_value_t cur
, void *opaque
);
77 mute_changed(vlc_object_t
*obj
, const char *name
, vlc_value_t old
,
78 vlc_value_t cur
, void *opaque
);
81 volume_changed(vlc_object_t
*obj
, const char *name
, vlc_value_t old
,
82 vlc_value_t cur
, void *opaque
);
85 add_es_callbacks( input_thread_t
*p_input_thread
, libvlc_media_player_t
*p_mi
);
88 del_es_callbacks( input_thread_t
*p_input_thread
, libvlc_media_player_t
*p_mi
);
91 snapshot_was_taken( vlc_object_t
*p_this
, char const *psz_cmd
,
92 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
);
94 static void libvlc_media_player_destroy( libvlc_media_player_t
*p_mi
);
101 * The input lock protects the input and input resource pointer.
102 * It MUST NOT be used from callbacks.
104 * The object lock protects the reset, namely the media and the player state.
105 * It can, and usually needs to be taken from callbacks.
106 * The object lock can be acquired under the input lock... and consequently
107 * the opposite order is STRICTLY PROHIBITED.
109 static inline void lock(libvlc_media_player_t
*mp
)
111 vlc_mutex_lock(&mp
->object_lock
);
114 static inline void unlock(libvlc_media_player_t
*mp
)
116 vlc_mutex_unlock(&mp
->object_lock
);
119 static inline void lock_input(libvlc_media_player_t
*mp
)
121 vlc_mutex_lock(&mp
->input
.lock
);
124 static inline void unlock_input(libvlc_media_player_t
*mp
)
126 vlc_mutex_unlock(&mp
->input
.lock
);
129 static void input_item_preparsed_changed( const vlc_event_t
*p_event
,
132 libvlc_media_t
*p_md
= user_data
;
133 if( p_event
->u
.input_item_preparsed_changed
.new_status
& ITEM_PREPARSED
)
136 libvlc_event_t event
;
137 event
.type
= libvlc_MediaParsedChanged
;
138 event
.u
.media_parsed_changed
.new_status
= libvlc_media_parsed_status_done
;
139 libvlc_event_send( p_md
->p_event_manager
, &event
);
143 static void media_attach_preparsed_event( libvlc_media_t
*p_md
)
145 vlc_event_attach( &p_md
->p_input_item
->event_manager
,
146 vlc_InputItemPreparsedChanged
,
147 input_item_preparsed_changed
, p_md
);
150 static void media_detach_preparsed_event( libvlc_media_t
*p_md
)
152 vlc_event_detach( &p_md
->p_input_item
->event_manager
,
153 vlc_InputItemPreparsedChanged
,
154 input_item_preparsed_changed
,
159 * Release the associated input thread.
161 * Object lock is NOT held.
162 * Input lock is held or instance is being destroyed.
164 static void release_input_thread( libvlc_media_player_t
*p_mi
)
168 input_thread_t
*p_input_thread
= p_mi
->input
.p_thread
;
169 if( !p_input_thread
)
171 p_mi
->input
.p_thread
= NULL
;
173 media_detach_preparsed_event( p_mi
->p_md
);
175 var_DelCallback( p_input_thread
, "can-seek",
176 input_seekable_changed
, p_mi
);
177 var_DelCallback( p_input_thread
, "can-pause",
178 input_pausable_changed
, p_mi
);
179 var_DelCallback( p_input_thread
, "program-scrambled",
180 input_scrambled_changed
, p_mi
);
181 var_DelCallback( p_input_thread
, "intf-event",
182 input_event_changed
, p_mi
);
183 del_es_callbacks( p_input_thread
, p_mi
);
185 /* We owned this one */
186 input_Stop( p_input_thread
);
187 input_Close( p_input_thread
);
191 * Retrieve the input thread. Be sure to release the object
192 * once you are done with it. (libvlc Internal)
194 input_thread_t
*libvlc_get_input_thread( libvlc_media_player_t
*p_mi
)
196 input_thread_t
*p_input_thread
;
201 p_input_thread
= p_mi
->input
.p_thread
;
203 vlc_object_hold( p_input_thread
);
205 libvlc_printerr( "No active input" );
208 return p_input_thread
;
212 * Set the internal state of the media_player. (media player Internal)
214 * Function will lock the media_player.
216 static void set_state( libvlc_media_player_t
*p_mi
, libvlc_state_t state
,
223 libvlc_media_t
*media
= p_mi
->p_md
;
225 libvlc_media_retain(media
);
232 // Also set the state of the corresponding media
233 // This is strictly for convenience.
234 libvlc_media_set_state(media
, state
);
236 libvlc_media_release(media
);
241 input_seekable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
242 vlc_value_t oldval
, vlc_value_t newval
,
248 libvlc_media_player_t
* p_mi
= p_userdata
;
249 libvlc_event_t event
;
251 event
.type
= libvlc_MediaPlayerSeekableChanged
;
252 event
.u
.media_player_seekable_changed
.new_seekable
= newval
.b_bool
;
254 libvlc_event_send( p_mi
->p_event_manager
, &event
);
259 input_pausable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
260 vlc_value_t oldval
, vlc_value_t newval
,
266 libvlc_media_player_t
* p_mi
= p_userdata
;
267 libvlc_event_t event
;
269 event
.type
= libvlc_MediaPlayerPausableChanged
;
270 event
.u
.media_player_pausable_changed
.new_pausable
= newval
.b_bool
;
272 libvlc_event_send( p_mi
->p_event_manager
, &event
);
277 input_scrambled_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
278 vlc_value_t oldval
, vlc_value_t newval
,
284 libvlc_media_player_t
* p_mi
= p_userdata
;
285 libvlc_event_t event
;
287 event
.type
= libvlc_MediaPlayerScrambledChanged
;
288 event
.u
.media_player_scrambled_changed
.new_scrambled
= newval
.b_bool
;
290 libvlc_event_send( p_mi
->p_event_manager
, &event
);
295 input_event_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
296 vlc_value_t oldval
, vlc_value_t newval
,
299 VLC_UNUSED(oldval
); VLC_UNUSED(psz_cmd
);
300 input_thread_t
* p_input
= (input_thread_t
*)p_this
;
301 libvlc_media_player_t
* p_mi
= p_userdata
;
302 libvlc_event_t event
;
304 assert( !strcmp( psz_cmd
, "intf-event" ) );
306 if( newval
.i_int
== INPUT_EVENT_STATE
)
308 libvlc_state_t libvlc_state
;
310 switch ( var_GetInteger( p_input
, "state" ) )
313 libvlc_state
= libvlc_NothingSpecial
;
314 event
.type
= libvlc_MediaPlayerNothingSpecial
;
317 libvlc_state
= libvlc_Opening
;
318 event
.type
= libvlc_MediaPlayerOpening
;
321 libvlc_state
= libvlc_Playing
;
322 event
.type
= libvlc_MediaPlayerPlaying
;
325 libvlc_state
= libvlc_Paused
;
326 event
.type
= libvlc_MediaPlayerPaused
;
329 libvlc_state
= libvlc_Ended
;
330 event
.type
= libvlc_MediaPlayerEndReached
;
333 libvlc_state
= libvlc_Error
;
334 event
.type
= libvlc_MediaPlayerEncounteredError
;
341 set_state( p_mi
, libvlc_state
, false );
342 libvlc_event_send( p_mi
->p_event_manager
, &event
);
344 else if( newval
.i_int
== INPUT_EVENT_DEAD
)
346 libvlc_state_t libvlc_state
= libvlc_Ended
;
347 event
.type
= libvlc_MediaPlayerStopped
;
349 set_state( p_mi
, libvlc_state
, false );
350 libvlc_event_send( p_mi
->p_event_manager
, &event
);
352 else if( newval
.i_int
== INPUT_EVENT_POSITION
)
354 if( var_GetInteger( p_input
, "state" ) != PLAYING_S
)
355 return VLC_SUCCESS
; /* Don't send the position while stopped */
358 event
.type
= libvlc_MediaPlayerPositionChanged
;
359 event
.u
.media_player_position_changed
.new_position
=
360 var_GetFloat( p_input
, "position" );
361 libvlc_event_send( p_mi
->p_event_manager
, &event
);
364 event
.type
= libvlc_MediaPlayerTimeChanged
;
365 event
.u
.media_player_time_changed
.new_time
=
366 from_mtime(var_GetInteger( p_input
, "time" ));
367 libvlc_event_send( p_mi
->p_event_manager
, &event
);
369 else if( newval
.i_int
== INPUT_EVENT_LENGTH
)
371 event
.type
= libvlc_MediaPlayerLengthChanged
;
372 event
.u
.media_player_length_changed
.new_length
=
373 from_mtime(var_GetInteger( p_input
, "length" ));
374 libvlc_event_send( p_mi
->p_event_manager
, &event
);
376 else if( newval
.i_int
== INPUT_EVENT_CACHE
)
378 event
.type
= libvlc_MediaPlayerBuffering
;
379 event
.u
.media_player_buffering
.new_cache
= (100 *
380 var_GetFloat( p_input
, "cache" ));
381 libvlc_event_send( p_mi
->p_event_manager
, &event
);
383 else if( newval
.i_int
== INPUT_EVENT_VOUT
)
385 vout_thread_t
**pp_vout
;
387 if( input_Control( p_input
, INPUT_GET_VOUTS
, &pp_vout
, &i_vout
) )
393 for( size_t i
= 0; i
< i_vout
; i
++ )
394 vlc_object_release( pp_vout
[i
] );
398 event
.type
= libvlc_MediaPlayerVout
;
399 event
.u
.media_player_vout
.new_count
= i_vout
;
400 libvlc_event_send( p_mi
->p_event_manager
, &event
);
402 else if ( newval
.i_int
== INPUT_EVENT_TITLE
)
404 event
.type
= libvlc_MediaPlayerTitleChanged
;
405 event
.u
.media_player_title_changed
.new_title
= var_GetInteger( p_input
, "title" );
406 libvlc_event_send( p_mi
->p_event_manager
, &event
);
408 else if ( newval
.i_int
== INPUT_EVENT_CHAPTER
)
410 event
.type
= libvlc_MediaPlayerChapterChanged
;
411 event
.u
.media_player_chapter_changed
.new_chapter
= var_GetInteger( p_input
, "chapter" );
412 libvlc_event_send( p_mi
->p_event_manager
, &event
);
418 static int track_type_from_name(const char *psz_name
)
420 if( !strcmp( psz_name
, "video-es" ) )
421 return libvlc_track_video
;
422 else if( !strcmp( psz_name
, "audio-es" ) )
423 return libvlc_track_audio
;
424 else if( !strcmp( psz_name
, "spu-es" ) )
425 return libvlc_track_text
;
427 return libvlc_track_unknown
;
430 static int input_es_changed( vlc_object_t
*p_this
,
437 libvlc_media_player_t
*mp
= p_userdata
;
438 libvlc_event_t event
;
440 /* Ignore the "Disable" element */
441 if (p_val
&& p_val
->i_int
< 0)
446 case VLC_VAR_ADDCHOICE
:
447 event
.type
= libvlc_MediaPlayerESAdded
;
449 case VLC_VAR_DELCHOICE
:
450 case VLC_VAR_CLEARCHOICES
:
451 event
.type
= libvlc_MediaPlayerESDeleted
;
457 event
.u
.media_player_es_changed
.i_type
= track_type_from_name(psz_cmd
);
460 if (action
!= VLC_VAR_CLEARCHOICES
)
468 /* -1 means all ES tracks of this type were deleted. */
471 event
.u
.media_player_es_changed
.i_id
= i_id
;
473 libvlc_event_send(mp
->p_event_manager
, &event
);
479 input_es_selected( vlc_object_t
* p_this
, char const * psz_cmd
,
480 vlc_value_t oldval
, vlc_value_t newval
,
485 libvlc_media_player_t
*mp
= p_userdata
;
486 libvlc_event_t event
;
488 event
.type
= libvlc_MediaPlayerESSelected
;
489 event
.u
.media_player_es_changed
.i_type
= track_type_from_name(psz_cmd
);
490 event
.u
.media_player_es_changed
.i_id
= newval
.i_int
;
492 libvlc_event_send(mp
->p_event_manager
, &event
);
497 /**************************************************************************
498 * Snapshot Taken Event.
500 * FIXME: This snapshot API interface makes no sense in media_player.
501 *************************************************************************/
502 static int snapshot_was_taken(vlc_object_t
*p_this
, char const *psz_cmd
,
503 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
505 VLC_UNUSED(psz_cmd
); VLC_UNUSED(oldval
); VLC_UNUSED(p_this
);
507 libvlc_media_player_t
*mp
= p_data
;
508 libvlc_event_t event
;
509 event
.type
= libvlc_MediaPlayerSnapshotTaken
;
510 event
.u
.media_player_snapshot_taken
.psz_filename
= newval
.psz_string
;
511 libvlc_event_send(mp
->p_event_manager
, &event
);
516 static int corks_changed(vlc_object_t
*obj
, const char *name
, vlc_value_t old
,
517 vlc_value_t cur
, void *opaque
)
519 libvlc_media_player_t
*mp
= (libvlc_media_player_t
*)obj
;
521 if (!old
.i_int
!= !cur
.i_int
)
523 libvlc_event_t event
;
525 event
.type
= cur
.i_int
? libvlc_MediaPlayerCorked
526 : libvlc_MediaPlayerUncorked
;
527 libvlc_event_send(mp
->p_event_manager
, &event
);
529 VLC_UNUSED(name
); VLC_UNUSED(opaque
);
533 static int audio_device_changed(vlc_object_t
*obj
, const char *name
,
534 vlc_value_t old
, vlc_value_t cur
, void *opaque
)
536 libvlc_media_player_t
*mp
= (libvlc_media_player_t
*)obj
;
537 libvlc_event_t event
;
539 event
.type
= libvlc_MediaPlayerAudioDevice
;
540 event
.u
.media_player_audio_device
.device
= cur
.psz_string
;
541 libvlc_event_send(mp
->p_event_manager
, &event
);
542 VLC_UNUSED(name
); VLC_UNUSED(old
); VLC_UNUSED(opaque
);
546 static int mute_changed(vlc_object_t
*obj
, const char *name
, vlc_value_t old
,
547 vlc_value_t cur
, void *opaque
)
549 libvlc_media_player_t
*mp
= (libvlc_media_player_t
*)obj
;
551 if (old
.b_bool
!= cur
.b_bool
)
553 libvlc_event_t event
;
555 event
.type
= cur
.b_bool
? libvlc_MediaPlayerMuted
556 : libvlc_MediaPlayerUnmuted
;
557 libvlc_event_send(mp
->p_event_manager
, &event
);
559 VLC_UNUSED(name
); VLC_UNUSED(opaque
);
563 static int volume_changed(vlc_object_t
*obj
, const char *name
, vlc_value_t old
,
564 vlc_value_t cur
, void *opaque
)
566 libvlc_media_player_t
*mp
= (libvlc_media_player_t
*)obj
;
567 libvlc_event_t event
;
569 event
.type
= libvlc_MediaPlayerAudioVolume
;
570 event
.u
.media_player_audio_volume
.volume
= cur
.f_float
;
571 libvlc_event_send(mp
->p_event_manager
, &event
);
572 VLC_UNUSED(name
); VLC_UNUSED(old
); VLC_UNUSED(opaque
);
576 /**************************************************************************
577 * Create a Media Instance object.
580 * - All items created by _new start with a refcount set to 1.
581 * - Accessor _release decrease the refcount by 1, if after that
582 * operation the refcount is 0, the object is destroyed.
583 * - Accessor _retain increase the refcount by 1 (XXX: to implement)
585 * Object locking strategy:
586 * - No lock held while in constructor.
587 * - When accessing any member variable this lock is held. (XXX who locks?)
588 * - When attempting to destroy the object the lock is also held.
589 **************************************************************************/
590 libvlc_media_player_t
*
591 libvlc_media_player_new( libvlc_instance_t
*instance
)
593 libvlc_media_player_t
* mp
;
597 mp
= vlc_object_create (instance
->p_libvlc_int
, sizeof(*mp
));
598 if (unlikely(mp
== NULL
))
600 libvlc_printerr("Not enough memory");
605 var_Create (mp
, "rate", VLC_VAR_FLOAT
|VLC_VAR_DOINHERIT
);
606 var_Create (mp
, "sout", VLC_VAR_STRING
);
607 var_Create (mp
, "demux-filter", VLC_VAR_STRING
);
610 var_Create (mp
, "vout", VLC_VAR_STRING
|VLC_VAR_DOINHERIT
);
611 var_Create (mp
, "window", VLC_VAR_STRING
);
612 var_Create (mp
, "vmem-lock", VLC_VAR_ADDRESS
);
613 var_Create (mp
, "vmem-unlock", VLC_VAR_ADDRESS
);
614 var_Create (mp
, "vmem-display", VLC_VAR_ADDRESS
);
615 var_Create (mp
, "vmem-data", VLC_VAR_ADDRESS
);
616 var_Create (mp
, "vmem-setup", VLC_VAR_ADDRESS
);
617 var_Create (mp
, "vmem-cleanup", VLC_VAR_ADDRESS
);
618 var_Create (mp
, "vmem-chroma", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
619 var_Create (mp
, "vmem-width", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
620 var_Create (mp
, "vmem-height", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
621 var_Create (mp
, "vmem-pitch", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
622 var_Create (mp
, "avcodec-hw", VLC_VAR_STRING
);
623 var_Create (mp
, "drawable-xid", VLC_VAR_INTEGER
);
624 #if defined (_WIN32) || defined (__OS2__)
625 var_Create (mp
, "drawable-hwnd", VLC_VAR_INTEGER
);
628 var_Create (mp
, "drawable-nsobject", VLC_VAR_ADDRESS
);
631 var_Create (mp
, "drawable-androidwindow", VLC_VAR_ADDRESS
);
634 var_Create (mp
, "drawable-evasobject", VLC_VAR_ADDRESS
);
637 var_Create (mp
, "keyboard-events", VLC_VAR_BOOL
);
638 var_SetBool (mp
, "keyboard-events", true);
639 var_Create (mp
, "mouse-events", VLC_VAR_BOOL
);
640 var_SetBool (mp
, "mouse-events", true);
642 var_Create (mp
, "fullscreen", VLC_VAR_BOOL
);
643 var_Create (mp
, "autoscale", VLC_VAR_BOOL
| VLC_VAR_DOINHERIT
);
644 var_Create (mp
, "zoom", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
645 var_Create (mp
, "aspect-ratio", VLC_VAR_STRING
);
646 var_Create (mp
, "crop", VLC_VAR_STRING
);
647 var_Create (mp
, "deinterlace", VLC_VAR_INTEGER
);
648 var_Create (mp
, "deinterlace-mode", VLC_VAR_STRING
);
650 var_Create (mp
, "vbi-page", VLC_VAR_INTEGER
);
651 var_SetInteger (mp
, "vbi-page", 100);
653 var_Create (mp
, "marq-marquee", VLC_VAR_STRING
);
654 var_Create (mp
, "marq-color", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
655 var_Create (mp
, "marq-opacity", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
656 var_Create (mp
, "marq-position", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
657 var_Create (mp
, "marq-refresh", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
658 var_Create (mp
, "marq-size", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
659 var_Create (mp
, "marq-timeout", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
660 var_Create (mp
, "marq-x", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
661 var_Create (mp
, "marq-y", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
663 var_Create (mp
, "logo-file", VLC_VAR_STRING
);
664 var_Create (mp
, "logo-x", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
665 var_Create (mp
, "logo-y", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
666 var_Create (mp
, "logo-delay", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
667 var_Create (mp
, "logo-repeat", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
668 var_Create (mp
, "logo-opacity", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
669 var_Create (mp
, "logo-position", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
671 var_Create (mp
, "contrast", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
672 var_Create (mp
, "brightness", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
673 var_Create (mp
, "hue", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
674 var_Create (mp
, "saturation", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
675 var_Create (mp
, "gamma", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
678 var_Create (mp
, "aout", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
679 var_Create (mp
, "audio-device", VLC_VAR_STRING
);
680 var_Create (mp
, "mute", VLC_VAR_BOOL
);
681 var_Create (mp
, "volume", VLC_VAR_FLOAT
);
682 var_Create (mp
, "corks", VLC_VAR_INTEGER
);
683 var_Create (mp
, "audio-filter", VLC_VAR_STRING
);
684 var_Create (mp
, "role", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
685 var_Create (mp
, "amem-data", VLC_VAR_ADDRESS
);
686 var_Create (mp
, "amem-setup", VLC_VAR_ADDRESS
);
687 var_Create (mp
, "amem-cleanup", VLC_VAR_ADDRESS
);
688 var_Create (mp
, "amem-play", VLC_VAR_ADDRESS
);
689 var_Create (mp
, "amem-pause", VLC_VAR_ADDRESS
);
690 var_Create (mp
, "amem-resume", VLC_VAR_ADDRESS
);
691 var_Create (mp
, "amem-flush", VLC_VAR_ADDRESS
);
692 var_Create (mp
, "amem-drain", VLC_VAR_ADDRESS
);
693 var_Create (mp
, "amem-set-volume", VLC_VAR_ADDRESS
);
694 var_Create (mp
, "amem-format", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
695 var_Create (mp
, "amem-rate", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
696 var_Create (mp
, "amem-channels", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
699 var_Create (mp
, "video-title-show", VLC_VAR_BOOL
);
700 var_Create (mp
, "video-title-position", VLC_VAR_INTEGER
);
701 var_Create (mp
, "video-title-timeout", VLC_VAR_INTEGER
);
704 var_Create (mp
, "equalizer-preamp", VLC_VAR_FLOAT
);
705 var_Create (mp
, "equalizer-vlcfreqs", VLC_VAR_BOOL
);
706 var_Create (mp
, "equalizer-bands", VLC_VAR_STRING
);
709 mp
->state
= libvlc_NothingSpecial
;
710 mp
->p_libvlc_instance
= instance
;
711 mp
->input
.p_thread
= NULL
;
712 mp
->input
.p_resource
= input_resource_New(VLC_OBJECT(mp
));
713 if (unlikely(mp
->input
.p_resource
== NULL
))
715 vlc_object_release(mp
);
718 audio_output_t
*aout
= input_resource_GetAout(mp
->input
.p_resource
);
720 input_resource_PutAout(mp
->input
.p_resource
, aout
);
722 vlc_viewpoint_init(&mp
->viewpoint
);
724 var_Create (mp
, "viewpoint", VLC_VAR_ADDRESS
);
725 var_SetAddress( mp
, "viewpoint", &mp
->viewpoint
);
726 vlc_mutex_init (&mp
->input
.lock
);
728 mp
->p_event_manager
= libvlc_event_manager_new(mp
);
729 if (unlikely(mp
->p_event_manager
== NULL
))
731 input_resource_Release(mp
->input
.p_resource
);
732 vlc_object_release(mp
);
735 vlc_mutex_init(&mp
->object_lock
);
737 var_AddCallback(mp
, "corks", corks_changed
, NULL
);
738 var_AddCallback(mp
, "audio-device", audio_device_changed
, NULL
);
739 var_AddCallback(mp
, "mute", mute_changed
, NULL
);
740 var_AddCallback(mp
, "volume", volume_changed
, NULL
);
742 /* Snapshot initialization */
743 /* Attach a var callback to the global object to provide the glue between
744 * vout_thread that generates the event and media_player that re-emits it
745 * with its own event manager
747 * FIXME: It's unclear why we want to put this in public API, and why we
748 * want to expose it in such a limiting and ugly way.
750 var_AddCallback(mp
->obj
.libvlc
, "snapshot-file", snapshot_was_taken
, mp
);
752 libvlc_retain(instance
);
756 /**************************************************************************
757 * Create a Media Instance object with a media descriptor.
758 **************************************************************************/
759 libvlc_media_player_t
*
760 libvlc_media_player_new_from_media( libvlc_media_t
* p_md
)
762 libvlc_media_player_t
* p_mi
;
764 p_mi
= libvlc_media_player_new( p_md
->p_libvlc_instance
);
768 libvlc_media_retain( p_md
);
774 /**************************************************************************
775 * Destroy a Media Instance object (libvlc internal)
777 * Warning: No lock held here, but hey, this is internal. Caller must lock.
778 **************************************************************************/
779 static void libvlc_media_player_destroy( libvlc_media_player_t
*p_mi
)
783 /* Detach Callback from the main libvlc object */
784 var_DelCallback( p_mi
->obj
.libvlc
,
785 "snapshot-file", snapshot_was_taken
, p_mi
);
787 /* Detach callback from the media player / input manager object */
788 var_DelCallback( p_mi
, "volume", volume_changed
, NULL
);
789 var_DelCallback( p_mi
, "mute", mute_changed
, NULL
);
790 var_DelCallback( p_mi
, "audio-device", audio_device_changed
, NULL
);
791 var_DelCallback( p_mi
, "corks", corks_changed
, NULL
);
793 /* No need for lock_input() because no other threads knows us anymore */
794 if( p_mi
->input
.p_thread
)
795 release_input_thread(p_mi
);
796 input_resource_Terminate( p_mi
->input
.p_resource
);
797 input_resource_Release( p_mi
->input
.p_resource
);
798 vlc_mutex_destroy( &p_mi
->input
.lock
);
800 libvlc_event_manager_release( p_mi
->p_event_manager
);
801 libvlc_media_release( p_mi
->p_md
);
802 vlc_mutex_destroy( &p_mi
->object_lock
);
804 libvlc_instance_t
*instance
= p_mi
->p_libvlc_instance
;
805 vlc_object_release( p_mi
);
806 libvlc_release(instance
);
809 /**************************************************************************
810 * Release a Media Instance object.
812 * Function does the locking.
813 **************************************************************************/
814 void libvlc_media_player_release( libvlc_media_player_t
*p_mi
)
820 destroy
= !--p_mi
->i_refcount
;
824 libvlc_media_player_destroy( p_mi
);
827 /**************************************************************************
828 * Retain a Media Instance object.
830 * Caller must hold the lock.
831 **************************************************************************/
832 void libvlc_media_player_retain( libvlc_media_player_t
*p_mi
)
841 /**************************************************************************
842 * Set the Media descriptor associated with the instance.
844 * Enter without lock -- function will lock the object.
845 **************************************************************************/
846 void libvlc_media_player_set_media(
847 libvlc_media_player_t
*p_mi
,
848 libvlc_media_t
*p_md
)
852 release_input_thread( p_mi
);
855 set_state( p_mi
, libvlc_NothingSpecial
, true );
856 unlock_input( p_mi
);
858 libvlc_media_release( p_mi
->p_md
);
864 return; /* It is ok to pass a NULL md */
867 libvlc_media_retain( p_md
);
870 /* The policy here is to ignore that we were created using a different
871 * libvlc_instance, because we don't really care */
872 p_mi
->p_libvlc_instance
= p_md
->p_libvlc_instance
;
876 /* Send an event for the newly available media */
877 libvlc_event_t event
;
878 event
.type
= libvlc_MediaPlayerMediaChanged
;
879 event
.u
.media_player_media_changed
.new_media
= p_md
;
880 libvlc_event_send( p_mi
->p_event_manager
, &event
);
884 /**************************************************************************
885 * Get the Media descriptor associated with the instance.
886 **************************************************************************/
888 libvlc_media_player_get_media( libvlc_media_player_t
*p_mi
)
895 libvlc_media_retain( p_m
);
901 /**************************************************************************
902 * Get the event Manager.
903 **************************************************************************/
904 libvlc_event_manager_t
*
905 libvlc_media_player_event_manager( libvlc_media_player_t
*p_mi
)
907 return p_mi
->p_event_manager
;
910 static void add_es_callbacks( input_thread_t
*p_input_thread
, libvlc_media_player_t
*p_mi
)
912 var_AddListCallback( p_input_thread
, "video-es", input_es_changed
, p_mi
);
913 var_AddListCallback( p_input_thread
, "audio-es", input_es_changed
, p_mi
);
914 var_AddListCallback( p_input_thread
, "spu-es", input_es_changed
, p_mi
);
915 var_AddCallback( p_input_thread
, "video-es", input_es_selected
, p_mi
);
916 var_AddCallback( p_input_thread
, "audio-es", input_es_selected
, p_mi
);
917 var_AddCallback( p_input_thread
, "spu-es", input_es_selected
, p_mi
);
920 static void del_es_callbacks( input_thread_t
*p_input_thread
, libvlc_media_player_t
*p_mi
)
922 var_DelListCallback( p_input_thread
, "video-es", input_es_changed
, p_mi
);
923 var_DelListCallback( p_input_thread
, "audio-es", input_es_changed
, p_mi
);
924 var_DelListCallback( p_input_thread
, "spu-es", input_es_changed
, p_mi
);
925 var_DelCallback( p_input_thread
, "video-es", input_es_selected
, p_mi
);
926 var_DelCallback( p_input_thread
, "audio-es", input_es_selected
, p_mi
);
927 var_DelCallback( p_input_thread
, "spu-es", input_es_selected
, p_mi
);
930 /**************************************************************************
931 * Tell media player to start playing.
932 **************************************************************************/
933 int libvlc_media_player_play( libvlc_media_player_t
*p_mi
)
937 input_thread_t
*p_input_thread
= p_mi
->input
.p_thread
;
940 /* A thread already exists, send it a play message */
941 input_Control( p_input_thread
, INPUT_SET_STATE
, PLAYING_S
);
942 unlock_input( p_mi
);
946 /* Ignore previous exception */
952 unlock_input( p_mi
);
953 libvlc_printerr( "No associated media descriptor" );
957 media_attach_preparsed_event( p_mi
->p_md
);
959 p_input_thread
= input_Create( p_mi
, p_mi
->p_md
->p_input_item
, NULL
,
960 p_mi
->input
.p_resource
);
962 if( !p_input_thread
)
965 media_detach_preparsed_event( p_mi
->p_md
);
966 libvlc_printerr( "Not enough memory" );
970 var_AddCallback( p_input_thread
, "can-seek", input_seekable_changed
, p_mi
);
971 var_AddCallback( p_input_thread
, "can-pause", input_pausable_changed
, p_mi
);
972 var_AddCallback( p_input_thread
, "program-scrambled", input_scrambled_changed
, p_mi
);
973 var_AddCallback( p_input_thread
, "intf-event", input_event_changed
, p_mi
);
974 add_es_callbacks( p_input_thread
, p_mi
);
976 if( input_Start( p_input_thread
) )
979 del_es_callbacks( p_input_thread
, p_mi
);
980 var_DelCallback( p_input_thread
, "intf-event", input_event_changed
, p_mi
);
981 var_DelCallback( p_input_thread
, "can-pause", input_pausable_changed
, p_mi
);
982 var_DelCallback( p_input_thread
, "program-scrambled", input_scrambled_changed
, p_mi
);
983 var_DelCallback( p_input_thread
, "can-seek", input_seekable_changed
, p_mi
);
984 input_Close( p_input_thread
);
985 media_detach_preparsed_event( p_mi
->p_md
);
986 libvlc_printerr( "Input initialization failure" );
989 p_mi
->input
.p_thread
= p_input_thread
;
994 void libvlc_media_player_set_pause( libvlc_media_player_t
*p_mi
, int paused
)
996 input_thread_t
* p_input_thread
= libvlc_get_input_thread( p_mi
);
997 if( !p_input_thread
)
1000 libvlc_state_t state
= libvlc_media_player_get_state( p_mi
);
1001 if( state
== libvlc_Playing
)
1005 if( libvlc_media_player_can_pause( p_mi
) )
1006 input_Control( p_input_thread
, INPUT_SET_STATE
, PAUSE_S
);
1008 input_Stop( p_input_thread
);
1014 input_Control( p_input_thread
, INPUT_SET_STATE
, PLAYING_S
);
1017 vlc_object_release( p_input_thread
);
1020 /**************************************************************************
1022 **************************************************************************/
1023 void libvlc_media_player_pause( libvlc_media_player_t
*p_mi
)
1025 libvlc_media_player_set_pause( p_mi
, libvlc_media_player_is_playing( p_mi
) );
1028 /**************************************************************************
1029 * Tells whether the media player is currently playing.
1031 * Enter with lock held.
1032 **************************************************************************/
1033 int libvlc_media_player_is_playing( libvlc_media_player_t
*p_mi
)
1035 libvlc_state_t state
= libvlc_media_player_get_state( p_mi
);
1036 return libvlc_Playing
== state
;
1039 /**************************************************************************
1041 **************************************************************************/
1042 void libvlc_media_player_stop( libvlc_media_player_t
*p_mi
)
1045 release_input_thread( p_mi
); /* This will stop the input thread */
1047 /* Force to go to stopped state, in case we were in Ended, or Error
1049 if( p_mi
->state
!= libvlc_Stopped
)
1051 set_state( p_mi
, libvlc_Stopped
, false );
1053 /* Construct and send the event */
1054 libvlc_event_t event
;
1055 event
.type
= libvlc_MediaPlayerStopped
;
1056 libvlc_event_send( p_mi
->p_event_manager
, &event
);
1059 input_resource_Terminate( p_mi
->input
.p_resource
);
1063 int libvlc_media_player_set_renderer( libvlc_media_player_t
*p_mi
,
1064 const libvlc_renderer_item_t
*p_litem
)
1066 const vlc_renderer_item_t
*p_item
= libvlc_renderer_item_to_vlc( p_litem
);
1068 if( asprintf( &psz_sout
, "#%s", vlc_renderer_item_sout( p_item
) ) == -1 )
1071 var_SetString( p_mi
, "sout", psz_sout
);
1072 var_SetString( p_mi
, "demux-filter", vlc_renderer_item_demux_filter( p_item
) );
1077 void libvlc_video_set_callbacks( libvlc_media_player_t
*mp
,
1078 void *(*lock_cb
) (void *, void **),
1079 void (*unlock_cb
) (void *, void *, void *const *),
1080 void (*display_cb
) (void *, void *),
1083 var_SetAddress( mp
, "vmem-lock", lock_cb
);
1084 var_SetAddress( mp
, "vmem-unlock", unlock_cb
);
1085 var_SetAddress( mp
, "vmem-display", display_cb
);
1086 var_SetAddress( mp
, "vmem-data", opaque
);
1087 var_SetString( mp
, "avcodec-hw", "none" );
1088 var_SetString( mp
, "vout", "vmem" );
1089 var_SetString( mp
, "window", "none" );
1092 void libvlc_video_set_format_callbacks( libvlc_media_player_t
*mp
,
1093 libvlc_video_format_cb setup
,
1094 libvlc_video_cleanup_cb cleanup
)
1096 var_SetAddress( mp
, "vmem-setup", setup
);
1097 var_SetAddress( mp
, "vmem-cleanup", cleanup
);
1100 void libvlc_video_set_format( libvlc_media_player_t
*mp
, const char *chroma
,
1101 unsigned width
, unsigned height
, unsigned pitch
)
1103 var_SetString( mp
, "vmem-chroma", chroma
);
1104 var_SetInteger( mp
, "vmem-width", width
);
1105 var_SetInteger( mp
, "vmem-height", height
);
1106 var_SetInteger( mp
, "vmem-pitch", pitch
);
1109 /**************************************************************************
1111 **************************************************************************/
1112 void libvlc_media_player_set_nsobject( libvlc_media_player_t
*p_mi
,
1115 assert (p_mi
!= NULL
);
1117 var_SetString (p_mi
, "avcodec-hw", "");
1118 var_SetString (p_mi
, "vout", "");
1119 var_SetString (p_mi
, "window", "");
1120 var_SetAddress (p_mi
, "drawable-nsobject", drawable
);
1123 libvlc_printerr ("can't set nsobject: APPLE build required");
1125 var_SetString (p_mi
, "vout", "none");
1126 var_SetString (p_mi
, "window", "none");
1130 /**************************************************************************
1132 **************************************************************************/
1133 void * libvlc_media_player_get_nsobject( libvlc_media_player_t
*p_mi
)
1135 assert (p_mi
!= NULL
);
1137 return var_GetAddress (p_mi
, "drawable-nsobject");
1144 /**************************************************************************
1146 **************************************************************************/
1147 void libvlc_media_player_set_agl( libvlc_media_player_t
*p_mi
,
1151 libvlc_printerr ("can't set agl: use libvlc_media_player_set_nsobject instead");
1153 var_SetString (p_mi
, "vout", "none");
1154 var_SetString (p_mi
, "window", "none");
1157 /**************************************************************************
1159 **************************************************************************/
1160 uint32_t libvlc_media_player_get_agl( libvlc_media_player_t
*p_mi
)
1166 /**************************************************************************
1168 **************************************************************************/
1169 void libvlc_media_player_set_xwindow( libvlc_media_player_t
*p_mi
,
1172 assert (p_mi
!= NULL
);
1174 var_SetString (p_mi
, "avcodec-hw", "");
1175 var_SetString (p_mi
, "vout", drawable
? "xid" : "");
1176 var_SetString (p_mi
, "window", drawable
? "embed-xid,any" : "");
1177 var_SetInteger (p_mi
, "drawable-xid", drawable
);
1180 /**************************************************************************
1182 **************************************************************************/
1183 uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t
*p_mi
)
1185 return var_GetInteger (p_mi
, "drawable-xid");
1188 /**************************************************************************
1190 **************************************************************************/
1191 void libvlc_media_player_set_hwnd( libvlc_media_player_t
*p_mi
,
1194 assert (p_mi
!= NULL
);
1195 #if defined (_WIN32) || defined (__OS2__)
1196 var_SetString (p_mi
, "avcodec-hw", "");
1197 var_SetString (p_mi
, "vout", "");
1198 var_SetString (p_mi
, "window",
1199 (drawable
!= NULL
) ? "embed-hwnd,any" : "");
1200 var_SetInteger (p_mi
, "drawable-hwnd", (uintptr_t)drawable
);
1203 libvlc_printerr ("can't set nsobject: WIN32 build required");
1205 var_SetString (p_mi
, "vout", "none");
1206 var_SetString (p_mi
, "window", "none");
1210 /**************************************************************************
1212 **************************************************************************/
1213 void *libvlc_media_player_get_hwnd( libvlc_media_player_t
*p_mi
)
1215 assert (p_mi
!= NULL
);
1216 #if defined (_WIN32) || defined (__OS2__)
1217 return (void *)(uintptr_t)var_GetInteger (p_mi
, "drawable-hwnd");
1224 /**************************************************************************
1225 * set_android_context
1226 **************************************************************************/
1227 void libvlc_media_player_set_android_context( libvlc_media_player_t
*p_mi
,
1228 void *p_awindow_handler
)
1230 assert (p_mi
!= NULL
);
1232 var_SetAddress (p_mi
, "drawable-androidwindow", p_awindow_handler
);
1234 (void) p_awindow_handler
;
1235 libvlc_printerr ("can't set android context: ANDROID build required");
1237 var_SetString (p_mi
, "vout", "none");
1238 var_SetString (p_mi
, "window", "none");
1242 /**************************************************************************
1244 **************************************************************************/
1245 int libvlc_media_player_set_evas_object( libvlc_media_player_t
*p_mi
,
1246 void *p_evas_object
)
1248 assert (p_mi
!= NULL
);
1250 var_SetString (p_mi
, "vout", "evas");
1251 var_SetString (p_mi
, "window", "none");
1252 var_SetAddress (p_mi
, "drawable-evasobject", p_evas_object
);
1255 (void) p_mi
; (void) p_evas_object
;
1260 void libvlc_audio_set_callbacks( libvlc_media_player_t
*mp
,
1261 libvlc_audio_play_cb play_cb
,
1262 libvlc_audio_pause_cb pause_cb
,
1263 libvlc_audio_resume_cb resume_cb
,
1264 libvlc_audio_flush_cb flush_cb
,
1265 libvlc_audio_drain_cb drain_cb
,
1268 var_SetAddress( mp
, "amem-play", play_cb
);
1269 var_SetAddress( mp
, "amem-pause", pause_cb
);
1270 var_SetAddress( mp
, "amem-resume", resume_cb
);
1271 var_SetAddress( mp
, "amem-flush", flush_cb
);
1272 var_SetAddress( mp
, "amem-drain", drain_cb
);
1273 var_SetAddress( mp
, "amem-data", opaque
);
1274 var_SetString( mp
, "aout", "amem,none" );
1276 input_resource_ResetAout(mp
->input
.p_resource
);
1279 void libvlc_audio_set_volume_callback( libvlc_media_player_t
*mp
,
1280 libvlc_audio_set_volume_cb cb
)
1282 var_SetAddress( mp
, "amem-set-volume", cb
);
1284 input_resource_ResetAout(mp
->input
.p_resource
);
1287 void libvlc_audio_set_format_callbacks( libvlc_media_player_t
*mp
,
1288 libvlc_audio_setup_cb setup
,
1289 libvlc_audio_cleanup_cb cleanup
)
1291 var_SetAddress( mp
, "amem-setup", setup
);
1292 var_SetAddress( mp
, "amem-cleanup", cleanup
);
1294 input_resource_ResetAout(mp
->input
.p_resource
);
1297 void libvlc_audio_set_format( libvlc_media_player_t
*mp
, const char *format
,
1298 unsigned rate
, unsigned channels
)
1300 var_SetString( mp
, "amem-format", format
);
1301 var_SetInteger( mp
, "amem-rate", rate
);
1302 var_SetInteger( mp
, "amem-channels", channels
);
1304 input_resource_ResetAout(mp
->input
.p_resource
);
1308 /**************************************************************************
1309 * Getters for stream information
1310 **************************************************************************/
1311 libvlc_time_t
libvlc_media_player_get_length(
1312 libvlc_media_player_t
*p_mi
)
1314 input_thread_t
*p_input_thread
;
1315 libvlc_time_t i_time
;
1317 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1318 if( !p_input_thread
)
1321 i_time
= from_mtime(var_GetInteger( p_input_thread
, "length" ));
1322 vlc_object_release( p_input_thread
);
1327 libvlc_time_t
libvlc_media_player_get_time( libvlc_media_player_t
*p_mi
)
1329 input_thread_t
*p_input_thread
;
1330 libvlc_time_t i_time
;
1332 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1333 if( !p_input_thread
)
1336 i_time
= from_mtime(var_GetInteger( p_input_thread
, "time" ));
1337 vlc_object_release( p_input_thread
);
1341 void libvlc_media_player_set_time( libvlc_media_player_t
*p_mi
,
1342 libvlc_time_t i_time
)
1344 input_thread_t
*p_input_thread
;
1346 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1347 if( !p_input_thread
)
1350 var_SetInteger( p_input_thread
, "time", to_mtime(i_time
) );
1351 vlc_object_release( p_input_thread
);
1354 void libvlc_media_player_set_position( libvlc_media_player_t
*p_mi
,
1357 input_thread_t
*p_input_thread
;
1359 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1360 if( !p_input_thread
)
1363 var_SetFloat( p_input_thread
, "position", position
);
1364 vlc_object_release( p_input_thread
);
1367 float libvlc_media_player_get_position( libvlc_media_player_t
*p_mi
)
1369 input_thread_t
*p_input_thread
;
1372 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1373 if( !p_input_thread
)
1376 f_position
= var_GetFloat( p_input_thread
, "position" );
1377 vlc_object_release( p_input_thread
);
1382 void libvlc_media_player_set_chapter( libvlc_media_player_t
*p_mi
,
1385 input_thread_t
*p_input_thread
;
1387 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1388 if( !p_input_thread
)
1391 var_SetInteger( p_input_thread
, "chapter", chapter
);
1392 vlc_object_release( p_input_thread
);
1395 int libvlc_media_player_get_chapter( libvlc_media_player_t
*p_mi
)
1397 input_thread_t
*p_input_thread
;
1400 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1401 if( !p_input_thread
)
1404 i_chapter
= var_GetInteger( p_input_thread
, "chapter" );
1405 vlc_object_release( p_input_thread
);
1410 int libvlc_media_player_get_chapter_count( libvlc_media_player_t
*p_mi
)
1412 input_thread_t
*p_input_thread
;
1415 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1416 if( !p_input_thread
)
1419 int i_ret
= var_Change( p_input_thread
, "chapter", VLC_VAR_CHOICESCOUNT
, &val
, NULL
);
1420 vlc_object_release( p_input_thread
);
1422 return i_ret
== VLC_SUCCESS
? val
.i_int
: -1;
1425 int libvlc_media_player_get_chapter_count_for_title(
1426 libvlc_media_player_t
*p_mi
,
1431 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1432 if( !p_input_thread
)
1435 char psz_name
[sizeof ("title ") + 3 * sizeof (int)];
1436 sprintf( psz_name
, "title %2u", i_title
);
1438 int i_ret
= var_Change( p_input_thread
, psz_name
, VLC_VAR_CHOICESCOUNT
, &val
, NULL
);
1439 vlc_object_release( p_input_thread
);
1441 return i_ret
== VLC_SUCCESS
? val
.i_int
: -1;
1444 void libvlc_media_player_set_title( libvlc_media_player_t
*p_mi
,
1447 input_thread_t
*p_input_thread
;
1449 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1450 if( !p_input_thread
)
1453 var_SetInteger( p_input_thread
, "title", i_title
);
1454 vlc_object_release( p_input_thread
);
1457 libvlc_event_t event
;
1458 event
.type
= libvlc_MediaPlayerTitleChanged
;
1459 event
.u
.media_player_title_changed
.new_title
= i_title
;
1460 libvlc_event_send( p_mi
->p_event_manager
, &event
);
1463 int libvlc_media_player_get_title( libvlc_media_player_t
*p_mi
)
1465 input_thread_t
*p_input_thread
;
1468 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1469 if( !p_input_thread
)
1472 i_title
= var_GetInteger( p_input_thread
, "title" );
1473 vlc_object_release( p_input_thread
);
1478 int libvlc_media_player_get_title_count( libvlc_media_player_t
*p_mi
)
1480 input_thread_t
*p_input_thread
;
1483 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1484 if( !p_input_thread
)
1487 int i_ret
= var_Change( p_input_thread
, "title", VLC_VAR_CHOICESCOUNT
, &val
, NULL
);
1488 vlc_object_release( p_input_thread
);
1490 return i_ret
== VLC_SUCCESS
? val
.i_int
: -1;
1493 int libvlc_media_player_get_full_title_descriptions( libvlc_media_player_t
*p_mi
,
1494 libvlc_title_description_t
*** pp_titles
)
1498 input_thread_t
*p_input_thread
= libvlc_get_input_thread( p_mi
);
1500 if( !p_input_thread
)
1503 input_title_t
**p_input_title
;
1507 int ret
= input_Control( p_input_thread
, INPUT_GET_FULL_TITLE_INFO
,
1508 &p_input_title
, &count
);
1509 vlc_object_release( p_input_thread
);
1510 if( ret
!= VLC_SUCCESS
)
1513 libvlc_title_description_t
**titles
= malloc( count
* sizeof (*titles
) );
1514 if( count
> 0 && unlikely(titles
== NULL
) )
1518 for( int i
= 0; i
< count
; i
++)
1520 libvlc_title_description_t
*title
= malloc( sizeof (*title
) );
1521 if( unlikely(title
== NULL
) )
1523 libvlc_title_descriptions_release( titles
, i
);
1528 /* we want to return milliseconds to match the rest of the API */
1529 title
->i_duration
= p_input_title
[i
]->i_length
/ 1000;
1530 title
->i_flags
= p_input_title
[i
]->i_flags
;
1531 if( p_input_title
[i
]->psz_name
)
1532 title
->psz_name
= strdup( p_input_title
[i
]->psz_name
);
1534 title
->psz_name
= NULL
;
1535 vlc_input_title_Delete( p_input_title
[i
] );
1537 free( p_input_title
);
1539 *pp_titles
= titles
;
1543 void libvlc_title_descriptions_release( libvlc_title_description_t
**p_titles
,
1546 for (unsigned i
= 0; i
< i_count
; i
++ )
1551 free( p_titles
[i
]->psz_name
);
1552 free( p_titles
[i
] );
1557 int libvlc_media_player_get_full_chapter_descriptions( libvlc_media_player_t
*p_mi
,
1558 int i_chapters_of_title
,
1559 libvlc_chapter_description_t
*** pp_chapters
)
1563 input_thread_t
*p_input_thread
= libvlc_get_input_thread( p_mi
);
1565 if( !p_input_thread
)
1568 seekpoint_t
**p_seekpoint
= NULL
;
1571 int ret
= input_Control(p_input_thread
, INPUT_GET_SEEKPOINTS
, &p_seekpoint
, &i_chapters_of_title
);
1572 vlc_object_release( p_input_thread
);
1574 if( ret
!= VLC_SUCCESS
)
1579 if (i_chapters_of_title
== 0 || p_seekpoint
== NULL
)
1584 const int ci_chapter_count
= (const int)i_chapters_of_title
;
1586 *pp_chapters
= calloc( ci_chapter_count
, sizeof(**pp_chapters
) );
1593 for( int i
= 0; i
< ci_chapter_count
; i
++)
1595 libvlc_chapter_description_t
*p_chapter
= malloc( sizeof(*p_chapter
) );
1596 if( unlikely(p_chapter
== NULL
) )
1598 libvlc_chapter_descriptions_release( *pp_chapters
, ci_chapter_count
);
1601 (*pp_chapters
)[i
] = p_chapter
;
1603 p_chapter
->i_time_offset
= p_seekpoint
[i
]->i_time_offset
/ 1000;
1607 p_chapter
->i_duration
= p_chapter
->i_time_offset
- (*pp_chapters
)[i
-1]->i_time_offset
;
1611 p_chapter
->i_duration
= p_chapter
->i_time_offset
;
1614 if( p_seekpoint
[i
]->psz_name
)
1616 p_chapter
->psz_name
= strdup( p_seekpoint
[i
]->psz_name
);
1620 p_chapter
->psz_name
= NULL
;
1622 vlc_seekpoint_Delete( p_seekpoint
[i
] );
1625 return ci_chapter_count
;
1628 void libvlc_chapter_descriptions_release( libvlc_chapter_description_t
**p_chapters
,
1631 for (unsigned i
= 0; i
< i_count
; i
++ )
1633 if ( !p_chapters
[i
] )
1636 free( p_chapters
[i
]->psz_name
);
1637 free( p_chapters
[i
] );
1642 void libvlc_media_player_next_chapter( libvlc_media_player_t
*p_mi
)
1644 input_thread_t
*p_input_thread
;
1646 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1647 if( !p_input_thread
)
1650 int i_type
= var_Type( p_input_thread
, "next-chapter" );
1651 var_TriggerCallback( p_input_thread
, (i_type
& VLC_VAR_TYPE
) != 0 ?
1652 "next-chapter":"next-title" );
1654 vlc_object_release( p_input_thread
);
1657 void libvlc_media_player_previous_chapter( libvlc_media_player_t
*p_mi
)
1659 input_thread_t
*p_input_thread
;
1661 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1662 if( !p_input_thread
)
1665 int i_type
= var_Type( p_input_thread
, "next-chapter" );
1666 var_TriggerCallback( p_input_thread
, (i_type
& VLC_VAR_TYPE
) != 0 ?
1667 "prev-chapter":"prev-title" );
1669 vlc_object_release( p_input_thread
);
1672 float libvlc_media_player_get_fps( libvlc_media_player_t
*p_mi
)
1674 libvlc_media_t
*media
= libvlc_media_player_get_media( p_mi
);
1678 input_item_t
*item
= media
->p_input_item
;
1681 vlc_mutex_lock( &item
->lock
);
1682 for( int i
= 0; i
< item
->i_es
; i
++ )
1684 const es_format_t
*fmt
= item
->es
[i
];
1686 if( fmt
->i_cat
== VIDEO_ES
&& fmt
->video
.i_frame_rate_base
> 0 )
1687 fps
= (float)fmt
->video
.i_frame_rate
1688 / (float)fmt
->video
.i_frame_rate_base
;
1690 vlc_mutex_unlock( &item
->lock
);
1691 libvlc_media_release( media
);
1696 int libvlc_media_player_will_play( libvlc_media_player_t
*p_mi
)
1698 input_thread_t
*p_input_thread
=
1699 libvlc_get_input_thread ( p_mi
);
1700 if ( !p_input_thread
)
1703 int state
= var_GetInteger( p_input_thread
, "state" );
1704 vlc_object_release( p_input_thread
);
1706 return state
!= END_S
&& state
!= ERROR_S
;
1709 int libvlc_media_player_set_rate( libvlc_media_player_t
*p_mi
, float rate
)
1711 var_SetFloat (p_mi
, "rate", rate
);
1713 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1714 if( !p_input_thread
)
1716 var_SetFloat( p_input_thread
, "rate", rate
);
1717 vlc_object_release( p_input_thread
);
1721 float libvlc_media_player_get_rate( libvlc_media_player_t
*p_mi
)
1723 return var_GetFloat (p_mi
, "rate");
1726 libvlc_state_t
libvlc_media_player_get_state( libvlc_media_player_t
*p_mi
)
1729 libvlc_state_t state
= p_mi
->state
;
1734 int libvlc_media_player_is_seekable( libvlc_media_player_t
*p_mi
)
1736 input_thread_t
*p_input_thread
;
1739 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1740 if ( !p_input_thread
)
1742 b_seekable
= var_GetBool( p_input_thread
, "can-seek" );
1743 vlc_object_release( p_input_thread
);
1748 void libvlc_media_player_navigate( libvlc_media_player_t
* p_mi
,
1751 static const enum input_query_e map
[] =
1753 INPUT_NAV_ACTIVATE
, INPUT_NAV_UP
, INPUT_NAV_DOWN
,
1754 INPUT_NAV_LEFT
, INPUT_NAV_RIGHT
, INPUT_NAV_POPUP
,
1757 if( navigate
>= sizeof(map
) / sizeof(map
[0]) )
1760 input_thread_t
*p_input
= libvlc_get_input_thread ( p_mi
);
1761 if ( p_input
== NULL
)
1764 input_Control( p_input
, map
[navigate
], NULL
);
1765 vlc_object_release( p_input
);
1768 /* internal function, used by audio, video */
1769 libvlc_track_description_t
*
1770 libvlc_get_track_description( libvlc_media_player_t
*p_mi
,
1771 const char *psz_variable
)
1773 input_thread_t
*p_input
= libvlc_get_input_thread( p_mi
);
1774 libvlc_track_description_t
*p_track_description
= NULL
,
1775 *p_actual
, *p_previous
;
1780 vlc_value_t val_list
, text_list
;
1781 int i_ret
= var_Change( p_input
, psz_variable
, VLC_VAR_GETCHOICES
, &val_list
, &text_list
);
1782 if( i_ret
!= VLC_SUCCESS
)
1786 if( val_list
.p_list
->i_count
<= 0 )
1789 p_track_description
= ( libvlc_track_description_t
* )
1790 malloc( sizeof( libvlc_track_description_t
) );
1791 if ( !p_track_description
)
1793 libvlc_printerr( "Not enough memory" );
1796 p_actual
= p_track_description
;
1798 for( int i
= 0; i
< val_list
.p_list
->i_count
; i
++ )
1802 p_actual
= ( libvlc_track_description_t
* )
1803 malloc( sizeof( libvlc_track_description_t
) );
1806 libvlc_track_description_list_release( p_track_description
);
1807 libvlc_printerr( "Not enough memory" );
1811 p_actual
->i_id
= val_list
.p_list
->p_values
[i
].i_int
;
1812 p_actual
->psz_name
= strdup( text_list
.p_list
->p_values
[i
].psz_string
);
1813 p_actual
->p_next
= NULL
;
1815 p_previous
->p_next
= p_actual
;
1816 p_previous
= p_actual
;
1821 var_FreeList( &val_list
, &text_list
);
1822 vlc_object_release( p_input
);
1824 return p_track_description
;
1827 // Deprecated alias for libvlc_track_description_list_release
1828 void libvlc_track_description_release( libvlc_track_description_t
*p_td
)
1830 libvlc_track_description_list_release( p_td
);
1833 void libvlc_track_description_list_release( libvlc_track_description_t
*p_td
)
1835 libvlc_track_description_t
*p_actual
, *p_before
;
1840 free( p_actual
->psz_name
);
1841 p_before
= p_actual
;
1842 p_actual
= p_before
->p_next
;
1847 int libvlc_media_player_can_pause( libvlc_media_player_t
*p_mi
)
1849 input_thread_t
*p_input_thread
;
1852 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1853 if ( !p_input_thread
)
1855 b_can_pause
= var_GetBool( p_input_thread
, "can-pause" );
1856 vlc_object_release( p_input_thread
);
1861 int libvlc_media_player_program_scrambled( libvlc_media_player_t
*p_mi
)
1863 input_thread_t
*p_input_thread
;
1864 bool b_program_scrambled
;
1866 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1867 if ( !p_input_thread
)
1869 b_program_scrambled
= var_GetBool( p_input_thread
, "program-scrambled" );
1870 vlc_object_release( p_input_thread
);
1872 return b_program_scrambled
;
1875 void libvlc_media_player_next_frame( libvlc_media_player_t
*p_mi
)
1877 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1878 if( p_input_thread
!= NULL
)
1880 var_TriggerCallback( p_input_thread
, "frame-next" );
1881 vlc_object_release( p_input_thread
);
1886 * Private lookup table to get subpicture alignment flag values corresponding
1887 * to a libvlc_position_t enumerated value.
1889 static const unsigned char position_subpicture_alignment
[] = {
1890 [libvlc_position_center
] = 0,
1891 [libvlc_position_left
] = SUBPICTURE_ALIGN_LEFT
,
1892 [libvlc_position_right
] = SUBPICTURE_ALIGN_RIGHT
,
1893 [libvlc_position_top
] = SUBPICTURE_ALIGN_TOP
,
1894 [libvlc_position_top_left
] = SUBPICTURE_ALIGN_TOP
| SUBPICTURE_ALIGN_LEFT
,
1895 [libvlc_position_top_right
] = SUBPICTURE_ALIGN_TOP
| SUBPICTURE_ALIGN_RIGHT
,
1896 [libvlc_position_bottom
] = SUBPICTURE_ALIGN_BOTTOM
,
1897 [libvlc_position_bottom_left
] = SUBPICTURE_ALIGN_BOTTOM
| SUBPICTURE_ALIGN_LEFT
,
1898 [libvlc_position_bottom_right
] = SUBPICTURE_ALIGN_BOTTOM
| SUBPICTURE_ALIGN_RIGHT
1901 void libvlc_media_player_set_video_title_display( libvlc_media_player_t
*p_mi
, libvlc_position_t position
, unsigned timeout
)
1903 assert( position
>= libvlc_position_disable
&& position
<= libvlc_position_bottom_right
);
1905 if ( position
!= libvlc_position_disable
)
1907 var_SetBool( p_mi
, "video-title-show", true );
1908 var_SetInteger( p_mi
, "video-title-position", position_subpicture_alignment
[position
] );
1909 var_SetInteger( p_mi
, "video-title-timeout", timeout
);
1913 var_SetBool( p_mi
, "video-title-show", false );
1917 int libvlc_media_player_add_slave( libvlc_media_player_t
*p_mi
,
1918 libvlc_media_slave_type_t i_type
,
1919 const char *psz_uri
, bool b_select
)
1921 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1923 if( p_input_thread
== NULL
)
1925 libvlc_media_t
*p_media
= libvlc_media_player_get_media( p_mi
);
1926 if( p_media
== NULL
)
1929 int i_ret
= libvlc_media_slaves_add( p_media
, i_type
, 4, psz_uri
);
1930 libvlc_media_release( p_media
);
1935 int i_ret
= input_AddSlave( p_input_thread
, (enum slave_type
) i_type
,
1936 psz_uri
, b_select
);
1937 vlc_object_release( p_input_thread
);
1939 return i_ret
== VLC_SUCCESS
? 0 : -1;
1944 * Maximum size of a formatted equalizer amplification band frequency value.
1946 * The allowed value range is supposed to be constrained from -20.0 to 20.0.
1948 * The format string " %.07f" with a minimum value of "-20" gives a maximum
1949 * string length of e.g. " -19.1234567", i.e. 12 bytes (not including the null
1952 #define EQZ_BAND_VALUE_SIZE 12
1954 int libvlc_media_player_set_equalizer( libvlc_media_player_t
*p_mi
, libvlc_equalizer_t
*p_equalizer
)
1956 char bands
[EQZ_BANDS_MAX
* EQZ_BAND_VALUE_SIZE
+ 1];
1958 if( p_equalizer
!= NULL
)
1960 for( unsigned i
= 0, c
= 0; i
< EQZ_BANDS_MAX
; i
++ )
1962 c
+= snprintf( bands
+ c
, sizeof(bands
) - c
, " %.07f",
1963 p_equalizer
->f_amp
[i
] );
1964 if( unlikely(c
>= sizeof(bands
)) )
1968 var_SetFloat( p_mi
, "equalizer-preamp", p_equalizer
->f_preamp
);
1969 var_SetString( p_mi
, "equalizer-bands", bands
);
1971 var_SetString( p_mi
, "audio-filter", p_equalizer
? "equalizer" : "" );
1973 audio_output_t
*p_aout
= input_resource_HoldAout( p_mi
->input
.p_resource
);
1974 if( p_aout
!= NULL
)
1976 if( p_equalizer
!= NULL
)
1978 var_SetFloat( p_aout
, "equalizer-preamp", p_equalizer
->f_preamp
);
1979 var_SetString( p_aout
, "equalizer-bands", bands
);
1982 var_SetString( p_aout
, "audio-filter", p_equalizer
? "equalizer" : "" );
1983 vlc_object_release( p_aout
);
1989 static const char roles
[][16] =
1991 [libvlc_role_Music
] = "music",
1992 [libvlc_role_Video
] = "video",
1993 [libvlc_role_Communication
] = "communication",
1994 [libvlc_role_Game
] = "game",
1995 [liblvc_role_Notification
] = "notification",
1996 [libvlc_role_Animation
] = "animation",
1997 [libvlc_role_Production
] = "production",
1998 [libvlc_role_Accessibility
] = "accessibility",
1999 [libvlc_role_Test
] = "test",
2002 int libvlc_media_player_set_role(libvlc_media_player_t
*mp
, unsigned role
)
2004 if (role
>= ARRAY_SIZE(roles
)
2005 || var_SetString(mp
, "role", roles
[role
]) != VLC_SUCCESS
)
2010 int libvlc_media_player_get_role(libvlc_media_player_t
*mp
)
2013 char *str
= var_GetString(mp
, "role");
2017 for (size_t i
= 0; i
< ARRAY_SIZE(roles
); i
++)
2018 if (!strcmp(roles
[i
], str
))