1 /*****************************************************************************
2 * media_player.c: Libvlc API Media Instance management functions
3 *****************************************************************************
4 * Copyright (C) 2005-2011 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_media.h>
31 #include <vlc/libvlc_events.h>
33 #include <vlc_demux.h>
34 #include <vlc_input.h>
39 #include "libvlc_internal.h"
40 #include "media_internal.h" // libvlc_media_set_state()
41 #include "media_player_internal.h"
44 input_seekable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
45 vlc_value_t oldval
, vlc_value_t newval
,
48 input_pausable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
49 vlc_value_t oldval
, vlc_value_t newval
,
52 input_scrambled_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
53 vlc_value_t oldval
, vlc_value_t newval
,
56 input_event_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
57 vlc_value_t oldval
, vlc_value_t newval
,
61 snapshot_was_taken( vlc_object_t
*p_this
, char const *psz_cmd
,
62 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
);
64 static void libvlc_media_player_destroy( libvlc_media_player_t
*p_mi
);
70 #define register_event(a, b) __register_event(a, libvlc_MediaPlayer ## b)
71 static inline void __register_event(libvlc_media_player_t
*mp
, libvlc_event_type_t type
)
73 libvlc_event_manager_register_event_type(mp
->p_event_manager
, type
);
77 * The input lock protects the input and input resource pointer.
78 * It MUST NOT be used from callbacks.
80 * The object lock protects the reset, namely the media and the player state.
81 * It can, and usually needs to be taken from callbacks.
82 * The object lock can be acquired under the input lock... and consequently
83 * the opposite order is STRICTLY PROHIBITED.
85 static inline void lock(libvlc_media_player_t
*mp
)
87 vlc_mutex_lock(&mp
->object_lock
);
90 static inline void unlock(libvlc_media_player_t
*mp
)
92 vlc_mutex_unlock(&mp
->object_lock
);
95 static inline void lock_input(libvlc_media_player_t
*mp
)
97 vlc_mutex_lock(&mp
->input
.lock
);
100 static inline void unlock_input(libvlc_media_player_t
*mp
)
102 vlc_mutex_unlock(&mp
->input
.lock
);
106 * Release the associated input thread.
108 * Object lock is NOT held.
109 * Input lock is held or instance is being destroyed.
111 static void release_input_thread( libvlc_media_player_t
*p_mi
, bool b_input_abort
)
115 input_thread_t
*p_input_thread
= p_mi
->input
.p_thread
;
116 if( !p_input_thread
)
118 p_mi
->input
.p_thread
= NULL
;
120 var_DelCallback( p_input_thread
, "can-seek",
121 input_seekable_changed
, p_mi
);
122 var_DelCallback( p_input_thread
, "can-pause",
123 input_pausable_changed
, p_mi
);
124 var_DelCallback( p_input_thread
, "program-scrambled",
125 input_scrambled_changed
, p_mi
);
126 var_DelCallback( p_input_thread
, "intf-event",
127 input_event_changed
, p_mi
);
129 /* We owned this one */
130 input_Stop( p_input_thread
, b_input_abort
);
131 input_Close( p_input_thread
);
135 * Retrieve the input thread. Be sure to release the object
136 * once you are done with it. (libvlc Internal)
138 input_thread_t
*libvlc_get_input_thread( libvlc_media_player_t
*p_mi
)
140 input_thread_t
*p_input_thread
;
145 p_input_thread
= p_mi
->input
.p_thread
;
147 vlc_object_hold( p_input_thread
);
149 libvlc_printerr( "No active input" );
152 return p_input_thread
;
156 * Set the internal state of the media_player. (media player Internal)
158 * Function will lock the media_player.
160 static void set_state( libvlc_media_player_t
*p_mi
, libvlc_state_t state
,
167 libvlc_media_t
*media
= p_mi
->p_md
;
169 libvlc_media_retain(media
);
176 // Also set the state of the corresponding media
177 // This is strictly for convenience.
178 libvlc_media_set_state(media
, state
);
180 libvlc_media_release(media
);
185 input_seekable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
186 vlc_value_t oldval
, vlc_value_t newval
,
192 libvlc_media_player_t
* p_mi
= p_userdata
;
193 libvlc_event_t event
;
195 event
.type
= libvlc_MediaPlayerSeekableChanged
;
196 event
.u
.media_player_seekable_changed
.new_seekable
= newval
.b_bool
;
198 libvlc_event_send( p_mi
->p_event_manager
, &event
);
203 input_pausable_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
204 vlc_value_t oldval
, vlc_value_t newval
,
210 libvlc_media_player_t
* p_mi
= p_userdata
;
211 libvlc_event_t event
;
213 event
.type
= libvlc_MediaPlayerPausableChanged
;
214 event
.u
.media_player_pausable_changed
.new_pausable
= newval
.b_bool
;
216 libvlc_event_send( p_mi
->p_event_manager
, &event
);
221 input_scrambled_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
222 vlc_value_t oldval
, vlc_value_t newval
,
228 libvlc_media_player_t
* p_mi
= p_userdata
;
229 libvlc_event_t event
;
231 event
.type
= libvlc_MediaPlayerScrambledChanged
;
232 event
.u
.media_player_scrambled_changed
.new_scrambled
= newval
.b_bool
;
234 libvlc_event_send( p_mi
->p_event_manager
, &event
);
239 input_event_changed( vlc_object_t
* p_this
, char const * psz_cmd
,
240 vlc_value_t oldval
, vlc_value_t newval
,
244 input_thread_t
* p_input
= (input_thread_t
*)p_this
;
245 libvlc_media_player_t
* p_mi
= p_userdata
;
246 libvlc_event_t event
;
248 assert( !strcmp( psz_cmd
, "intf-event" ) );
250 if( newval
.i_int
== INPUT_EVENT_STATE
)
252 libvlc_state_t libvlc_state
;
254 switch ( var_GetInteger( p_input
, "state" ) )
257 libvlc_state
= libvlc_NothingSpecial
;
258 event
.type
= libvlc_MediaPlayerNothingSpecial
;
261 libvlc_state
= libvlc_Opening
;
262 event
.type
= libvlc_MediaPlayerOpening
;
265 libvlc_state
= libvlc_Playing
;
266 event
.type
= libvlc_MediaPlayerPlaying
;
269 libvlc_state
= libvlc_Paused
;
270 event
.type
= libvlc_MediaPlayerPaused
;
273 libvlc_state
= libvlc_Ended
;
274 event
.type
= libvlc_MediaPlayerEndReached
;
277 libvlc_state
= libvlc_Error
;
278 event
.type
= libvlc_MediaPlayerEncounteredError
;
285 set_state( p_mi
, libvlc_state
, false );
286 libvlc_event_send( p_mi
->p_event_manager
, &event
);
288 else if( newval
.i_int
== INPUT_EVENT_ABORT
)
290 libvlc_state_t libvlc_state
= libvlc_Stopped
;
291 event
.type
= libvlc_MediaPlayerStopped
;
293 set_state( p_mi
, libvlc_state
, false );
294 libvlc_event_send( p_mi
->p_event_manager
, &event
);
296 else if( newval
.i_int
== INPUT_EVENT_POSITION
)
298 if( var_GetInteger( p_input
, "state" ) != PLAYING_S
)
299 return VLC_SUCCESS
; /* Don't send the position while stopped */
302 event
.type
= libvlc_MediaPlayerPositionChanged
;
303 event
.u
.media_player_position_changed
.new_position
=
304 var_GetFloat( p_input
, "position" );
305 libvlc_event_send( p_mi
->p_event_manager
, &event
);
308 event
.type
= libvlc_MediaPlayerTimeChanged
;
309 event
.u
.media_player_time_changed
.new_time
=
310 from_mtime(var_GetTime( p_input
, "time" ));
311 libvlc_event_send( p_mi
->p_event_manager
, &event
);
313 else if( newval
.i_int
== INPUT_EVENT_LENGTH
)
315 event
.type
= libvlc_MediaPlayerLengthChanged
;
316 event
.u
.media_player_length_changed
.new_length
=
317 from_mtime(var_GetTime( p_input
, "length" ));
318 libvlc_event_send( p_mi
->p_event_manager
, &event
);
320 else if( newval
.i_int
== INPUT_EVENT_CACHE
)
322 event
.type
= libvlc_MediaPlayerBuffering
;
323 event
.u
.media_player_buffering
.new_cache
= (int)(100 *
324 var_GetFloat( p_input
, "cache" ));
325 libvlc_event_send( p_mi
->p_event_manager
, &event
);
327 else if( newval
.i_int
== INPUT_EVENT_VOUT
)
329 vout_thread_t
**pp_vout
;
331 if( input_Control( p_input
, INPUT_GET_VOUTS
, &pp_vout
, &i_vout
) )
337 for( size_t i
= 0; i
< i_vout
; i
++ )
338 vlc_object_release( pp_vout
[i
] );
342 event
.type
= libvlc_MediaPlayerVout
;
343 event
.u
.media_player_vout
.new_count
= i_vout
;
344 libvlc_event_send( p_mi
->p_event_manager
, &event
);
350 /**************************************************************************
351 * Snapshot Taken Event.
353 * FIXME: This snapshot API interface makes no sense in media_player.
354 *************************************************************************/
355 static int snapshot_was_taken(vlc_object_t
*p_this
, char const *psz_cmd
,
356 vlc_value_t oldval
, vlc_value_t newval
, void *p_data
)
358 VLC_UNUSED(psz_cmd
); VLC_UNUSED(oldval
); VLC_UNUSED(p_this
);
360 libvlc_media_player_t
*mp
= p_data
;
361 libvlc_event_t event
;
362 event
.type
= libvlc_MediaPlayerSnapshotTaken
;
363 event
.u
.media_player_snapshot_taken
.psz_filename
= newval
.psz_string
;
364 libvlc_event_send(mp
->p_event_manager
, &event
);
370 static void libvlc_media_player_destroy( libvlc_media_player_t
* );
373 /**************************************************************************
374 * Create a Media Instance object.
377 * - All items created by _new start with a refcount set to 1.
378 * - Accessor _release decrease the refcount by 1, if after that
379 * operation the refcount is 0, the object is destroyed.
380 * - Accessor _retain increase the refcount by 1 (XXX: to implement)
382 * Object locking strategy:
383 * - No lock held while in constructor.
384 * - When accessing any member variable this lock is held. (XXX who locks?)
385 * - When attempting to destroy the object the lock is also held.
386 **************************************************************************/
387 libvlc_media_player_t
*
388 libvlc_media_player_new( libvlc_instance_t
*instance
)
390 libvlc_media_player_t
* mp
;
394 mp
= vlc_object_create (instance
->p_libvlc_int
, sizeof(*mp
));
395 if (unlikely(mp
== NULL
))
397 libvlc_printerr("Not enough memory");
402 var_Create (mp
, "rate", VLC_VAR_FLOAT
|VLC_VAR_DOINHERIT
);
405 var_Create (mp
, "vout", VLC_VAR_STRING
|VLC_VAR_DOINHERIT
);
406 var_Create (mp
, "window", VLC_VAR_STRING
);
407 var_Create (mp
, "vmem-lock", VLC_VAR_ADDRESS
);
408 var_Create (mp
, "vmem-unlock", VLC_VAR_ADDRESS
);
409 var_Create (mp
, "vmem-display", VLC_VAR_ADDRESS
);
410 var_Create (mp
, "vmem-data", VLC_VAR_ADDRESS
);
411 var_Create (mp
, "vmem-setup", VLC_VAR_ADDRESS
);
412 var_Create (mp
, "vmem-cleanup", VLC_VAR_ADDRESS
);
413 var_Create (mp
, "vmem-chroma", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
414 var_Create (mp
, "vmem-width", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
415 var_Create (mp
, "vmem-height", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
416 var_Create (mp
, "vmem-pitch", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
417 var_Create (mp
, "drawable-xid", VLC_VAR_INTEGER
);
418 #if defined (_WIN32) || defined (__OS2__)
419 var_Create (mp
, "drawable-hwnd", VLC_VAR_INTEGER
);
422 var_Create (mp
, "drawable-agl", VLC_VAR_INTEGER
);
423 var_Create (mp
, "drawable-nsobject", VLC_VAR_ADDRESS
);
426 var_Create (mp
, "keyboard-events", VLC_VAR_BOOL
);
427 var_SetBool (mp
, "keyboard-events", true);
428 var_Create (mp
, "mouse-events", VLC_VAR_BOOL
);
429 var_SetBool (mp
, "mouse-events", true);
431 var_Create (mp
, "fullscreen", VLC_VAR_BOOL
);
432 var_Create (mp
, "autoscale", VLC_VAR_BOOL
);
433 var_SetBool (mp
, "autoscale", true);
434 var_Create (mp
, "scale", VLC_VAR_FLOAT
);
435 var_SetFloat (mp
, "scale", 1.);
436 var_Create (mp
, "aspect-ratio", VLC_VAR_STRING
);
437 var_Create (mp
, "crop", VLC_VAR_STRING
);
438 var_Create (mp
, "deinterlace", VLC_VAR_INTEGER
);
439 var_Create (mp
, "deinterlace-mode", VLC_VAR_STRING
);
441 var_Create (mp
, "vbi-page", VLC_VAR_INTEGER
);
443 var_Create (mp
, "marq-marquee", VLC_VAR_STRING
);
444 var_Create (mp
, "marq-color", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
445 var_Create (mp
, "marq-opacity", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
446 var_Create (mp
, "marq-position", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
447 var_Create (mp
, "marq-refresh", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
448 var_Create (mp
, "marq-size", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
449 var_Create (mp
, "marq-timeout", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
450 var_Create (mp
, "marq-x", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
451 var_Create (mp
, "marq-y", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
453 var_Create (mp
, "logo-file", VLC_VAR_STRING
);
454 var_Create (mp
, "logo-x", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
455 var_Create (mp
, "logo-y", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
456 var_Create (mp
, "logo-delay", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
457 var_Create (mp
, "logo-repeat", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
458 var_Create (mp
, "logo-opacity", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
459 var_Create (mp
, "logo-position", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
461 var_Create (mp
, "contrast", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
462 var_Create (mp
, "brightness", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
463 var_Create (mp
, "hue", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
464 var_Create (mp
, "saturation", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
465 var_Create (mp
, "gamma", VLC_VAR_FLOAT
| VLC_VAR_DOINHERIT
);
468 var_Create (mp
, "aout", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
469 var_Create (mp
, "mute", VLC_VAR_BOOL
);
470 var_Create (mp
, "volume", VLC_VAR_FLOAT
);
471 var_Create (mp
, "corks", VLC_VAR_INTEGER
);
472 var_Create (mp
, "amem-data", VLC_VAR_ADDRESS
);
473 var_Create (mp
, "amem-setup", VLC_VAR_ADDRESS
);
474 var_Create (mp
, "amem-cleanup", VLC_VAR_ADDRESS
);
475 var_Create (mp
, "amem-play", VLC_VAR_ADDRESS
);
476 var_Create (mp
, "amem-pause", VLC_VAR_ADDRESS
);
477 var_Create (mp
, "amem-resume", VLC_VAR_ADDRESS
);
478 var_Create (mp
, "amem-flush", VLC_VAR_ADDRESS
);
479 var_Create (mp
, "amem-drain", VLC_VAR_ADDRESS
);
480 var_Create (mp
, "amem-set-volume", VLC_VAR_ADDRESS
);
481 var_Create (mp
, "amem-format", VLC_VAR_STRING
| VLC_VAR_DOINHERIT
);
482 var_Create (mp
, "amem-rate", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
483 var_Create (mp
, "amem-channels", VLC_VAR_INTEGER
| VLC_VAR_DOINHERIT
);
486 var_Create (mp
, "video-title-show", VLC_VAR_BOOL
);
487 var_Create (mp
, "video-title-position", VLC_VAR_INTEGER
);
488 var_Create (mp
, "video-title-timeout", VLC_VAR_INTEGER
);
491 var_Create (mp
, "equalizer-preamp", VLC_VAR_FLOAT
);
492 var_Create (mp
, "equalizer-vlcfreqs", VLC_VAR_BOOL
);
493 var_Create (mp
, "equalizer-bands", VLC_VAR_STRING
);
496 mp
->state
= libvlc_NothingSpecial
;
497 mp
->p_libvlc_instance
= instance
;
498 mp
->input
.p_thread
= NULL
;
499 mp
->input
.p_resource
= input_resource_New(VLC_OBJECT(mp
));
500 if (unlikely(mp
->input
.p_resource
== NULL
))
502 vlc_object_release(mp
);
505 audio_output_t
*aout
= input_resource_GetAout(mp
->input
.p_resource
);
507 input_resource_PutAout(mp
->input
.p_resource
, aout
);
509 vlc_mutex_init (&mp
->input
.lock
);
511 mp
->p_event_manager
= libvlc_event_manager_new(mp
, instance
);
512 if (unlikely(mp
->p_event_manager
== NULL
))
514 input_resource_Release(mp
->input
.p_resource
);
515 vlc_object_release(mp
);
518 vlc_mutex_init(&mp
->object_lock
);
520 register_event(mp
, NothingSpecial
);
521 register_event(mp
, Opening
);
522 register_event(mp
, Buffering
);
523 register_event(mp
, Playing
);
524 register_event(mp
, Paused
);
525 register_event(mp
, Stopped
);
526 register_event(mp
, Forward
);
527 register_event(mp
, Backward
);
528 register_event(mp
, EndReached
);
529 register_event(mp
, EncounteredError
);
530 register_event(mp
, SeekableChanged
);
532 register_event(mp
, PositionChanged
);
533 register_event(mp
, TimeChanged
);
534 register_event(mp
, LengthChanged
);
535 register_event(mp
, TitleChanged
);
536 register_event(mp
, PausableChanged
);
538 register_event(mp
, Vout
);
539 register_event(mp
, ScrambledChanged
);
541 /* Snapshot initialization */
542 register_event(mp
, SnapshotTaken
);
544 register_event(mp
, MediaChanged
);
546 /* Attach a var callback to the global object to provide the glue between
547 * vout_thread that generates the event and media_player that re-emits it
548 * with its own event manager
550 * FIXME: It's unclear why we want to put this in public API, and why we
551 * want to expose it in such a limiting and ugly way.
553 var_AddCallback(mp
->p_libvlc
, "snapshot-file", snapshot_was_taken
, mp
);
555 libvlc_retain(instance
);
559 /**************************************************************************
560 * Create a Media Instance object with a media descriptor.
561 **************************************************************************/
562 libvlc_media_player_t
*
563 libvlc_media_player_new_from_media( libvlc_media_t
* p_md
)
565 libvlc_media_player_t
* p_mi
;
567 p_mi
= libvlc_media_player_new( p_md
->p_libvlc_instance
);
571 libvlc_media_retain( p_md
);
577 /**************************************************************************
578 * Destroy a Media Instance object (libvlc internal)
580 * Warning: No lock held here, but hey, this is internal. Caller must lock.
581 **************************************************************************/
582 static void libvlc_media_player_destroy( libvlc_media_player_t
*p_mi
)
586 /* Detach Callback from the main libvlc object */
587 var_DelCallback( p_mi
->p_libvlc
,
588 "snapshot-file", snapshot_was_taken
, p_mi
);
590 /* No need for lock_input() because no other threads knows us anymore */
591 if( p_mi
->input
.p_thread
)
592 release_input_thread(p_mi
, true);
593 input_resource_Terminate( p_mi
->input
.p_resource
);
594 input_resource_Release( p_mi
->input
.p_resource
);
595 vlc_mutex_destroy( &p_mi
->input
.lock
);
597 libvlc_event_manager_release( p_mi
->p_event_manager
);
598 libvlc_media_release( p_mi
->p_md
);
599 vlc_mutex_destroy( &p_mi
->object_lock
);
601 libvlc_instance_t
*instance
= p_mi
->p_libvlc_instance
;
602 vlc_object_release( p_mi
);
603 libvlc_release(instance
);
606 /**************************************************************************
607 * Release a Media Instance object.
609 * Function does the locking.
610 **************************************************************************/
611 void libvlc_media_player_release( libvlc_media_player_t
*p_mi
)
617 destroy
= !--p_mi
->i_refcount
;
621 libvlc_media_player_destroy( p_mi
);
624 /**************************************************************************
625 * Retain a Media Instance object.
627 * Caller must hold the lock.
628 **************************************************************************/
629 void libvlc_media_player_retain( libvlc_media_player_t
*p_mi
)
638 /**************************************************************************
639 * Set the Media descriptor associated with the instance.
641 * Enter without lock -- function will lock the object.
642 **************************************************************************/
643 void libvlc_media_player_set_media(
644 libvlc_media_player_t
*p_mi
,
645 libvlc_media_t
*p_md
)
649 /* FIXME I am not sure if it is a user request or on die(eof/error)
651 release_input_thread( p_mi
,
652 p_mi
->input
.p_thread
&&
653 !p_mi
->input
.p_thread
->b_eof
&&
654 !p_mi
->input
.p_thread
->b_error
);
657 set_state( p_mi
, libvlc_NothingSpecial
, true );
658 unlock_input( p_mi
);
660 libvlc_media_release( p_mi
->p_md
);
666 return; /* It is ok to pass a NULL md */
669 libvlc_media_retain( p_md
);
672 /* The policy here is to ignore that we were created using a different
673 * libvlc_instance, because we don't really care */
674 p_mi
->p_libvlc_instance
= p_md
->p_libvlc_instance
;
678 /* Send an event for the newly available media */
679 libvlc_event_t event
;
680 event
.type
= libvlc_MediaPlayerMediaChanged
;
681 event
.u
.media_player_media_changed
.new_media
= p_md
;
682 libvlc_event_send( p_mi
->p_event_manager
, &event
);
686 /**************************************************************************
687 * Get the Media descriptor associated with the instance.
688 **************************************************************************/
690 libvlc_media_player_get_media( libvlc_media_player_t
*p_mi
)
697 libvlc_media_retain( p_m
);
703 /**************************************************************************
704 * Get the event Manager.
705 **************************************************************************/
706 libvlc_event_manager_t
*
707 libvlc_media_player_event_manager( libvlc_media_player_t
*p_mi
)
709 return p_mi
->p_event_manager
;
712 /**************************************************************************
713 * Tell media player to start playing.
714 **************************************************************************/
715 int libvlc_media_player_play( libvlc_media_player_t
*p_mi
)
719 input_thread_t
*p_input_thread
= p_mi
->input
.p_thread
;
722 /* A thread already exists, send it a play message */
723 input_Control( p_input_thread
, INPUT_SET_STATE
, PLAYING_S
);
724 unlock_input( p_mi
);
728 /* Ignore previous exception */
734 unlock_input( p_mi
);
735 libvlc_printerr( "No associated media descriptor" );
739 p_input_thread
= input_Create( p_mi
, p_mi
->p_md
->p_input_item
, NULL
,
740 p_mi
->input
.p_resource
);
742 if( !p_input_thread
)
745 libvlc_printerr( "Not enough memory" );
749 var_AddCallback( p_input_thread
, "can-seek", input_seekable_changed
, p_mi
);
750 var_AddCallback( p_input_thread
, "can-pause", input_pausable_changed
, p_mi
);
751 var_AddCallback( p_input_thread
, "program-scrambled", input_scrambled_changed
, p_mi
);
752 var_AddCallback( p_input_thread
, "intf-event", input_event_changed
, p_mi
);
754 if( input_Start( p_input_thread
) )
757 var_DelCallback( p_input_thread
, "intf-event", input_event_changed
, p_mi
);
758 var_DelCallback( p_input_thread
, "can-pause", input_pausable_changed
, p_mi
);
759 var_DelCallback( p_input_thread
, "program-scrambled", input_scrambled_changed
, p_mi
);
760 var_DelCallback( p_input_thread
, "can-seek", input_seekable_changed
, p_mi
);
761 vlc_object_release( p_input_thread
);
762 libvlc_printerr( "Input initialization failure" );
765 p_mi
->input
.p_thread
= p_input_thread
;
770 void libvlc_media_player_set_pause( libvlc_media_player_t
*p_mi
, int paused
)
772 input_thread_t
* p_input_thread
= libvlc_get_input_thread( p_mi
);
773 if( !p_input_thread
)
776 libvlc_state_t state
= libvlc_media_player_get_state( p_mi
);
777 if( state
== libvlc_Playing
|| state
== libvlc_Buffering
)
781 if( libvlc_media_player_can_pause( p_mi
) )
782 input_Control( p_input_thread
, INPUT_SET_STATE
, PAUSE_S
);
784 libvlc_media_player_stop( p_mi
);
790 input_Control( p_input_thread
, INPUT_SET_STATE
, PLAYING_S
);
793 vlc_object_release( p_input_thread
);
796 /**************************************************************************
798 **************************************************************************/
799 void libvlc_media_player_pause( libvlc_media_player_t
*p_mi
)
801 libvlc_state_t state
= libvlc_media_player_get_state( p_mi
);
802 bool playing
= (state
== libvlc_Playing
|| state
== libvlc_Buffering
);
804 libvlc_media_player_set_pause( p_mi
, playing
);
807 /**************************************************************************
808 * Tells whether the media player is currently playing.
810 * Enter with lock held.
811 **************************************************************************/
812 int libvlc_media_player_is_playing( libvlc_media_player_t
*p_mi
)
814 libvlc_state_t state
= libvlc_media_player_get_state( p_mi
);
815 return (libvlc_Playing
== state
) || (libvlc_Buffering
== state
);
818 /**************************************************************************
820 **************************************************************************/
821 void libvlc_media_player_stop( libvlc_media_player_t
*p_mi
)
823 libvlc_state_t state
= libvlc_media_player_get_state( p_mi
);
826 release_input_thread( p_mi
, true ); /* This will stop the input thread */
828 /* Force to go to stopped state, in case we were in Ended, or Error
830 if( state
!= libvlc_Stopped
)
832 set_state( p_mi
, libvlc_Stopped
, false );
834 /* Construct and send the event */
835 libvlc_event_t event
;
836 event
.type
= libvlc_MediaPlayerStopped
;
837 libvlc_event_send( p_mi
->p_event_manager
, &event
);
840 input_resource_Terminate( p_mi
->input
.p_resource
);
845 void libvlc_video_set_callbacks( libvlc_media_player_t
*mp
,
846 void *(*lock_cb
) (void *, void **),
847 void (*unlock_cb
) (void *, void *, void *const *),
848 void (*display_cb
) (void *, void *),
851 var_SetAddress( mp
, "vmem-lock", lock_cb
);
852 var_SetAddress( mp
, "vmem-unlock", unlock_cb
);
853 var_SetAddress( mp
, "vmem-display", display_cb
);
854 var_SetAddress( mp
, "vmem-data", opaque
);
855 var_SetString( mp
, "vout", "vmem" );
858 void libvlc_video_set_format_callbacks( libvlc_media_player_t
*mp
,
859 libvlc_video_format_cb setup
,
860 libvlc_video_cleanup_cb cleanup
)
862 var_SetAddress( mp
, "vmem-setup", setup
);
863 var_SetAddress( mp
, "vmem-cleanup", cleanup
);
866 void libvlc_video_set_format( libvlc_media_player_t
*mp
, const char *chroma
,
867 unsigned width
, unsigned height
, unsigned pitch
)
869 var_SetString( mp
, "vmem-chroma", chroma
);
870 var_SetInteger( mp
, "vmem-width", width
);
871 var_SetInteger( mp
, "vmem-height", height
);
872 var_SetInteger( mp
, "vmem-pitch", pitch
);
875 /**************************************************************************
877 **************************************************************************/
878 void libvlc_media_player_set_nsobject( libvlc_media_player_t
*p_mi
,
881 assert (p_mi
!= NULL
);
883 var_SetAddress (p_mi
, "drawable-nsobject", drawable
);
885 (void) p_mi
; (void)drawable
;
889 /**************************************************************************
891 **************************************************************************/
892 void * libvlc_media_player_get_nsobject( libvlc_media_player_t
*p_mi
)
894 assert (p_mi
!= NULL
);
896 return var_GetAddress (p_mi
, "drawable-nsobject");
902 /**************************************************************************
904 **************************************************************************/
905 void libvlc_media_player_set_agl( libvlc_media_player_t
*p_mi
,
909 var_SetInteger (p_mi
, "drawable-agl", drawable
);
911 (void) p_mi
; (void)drawable
;
915 /**************************************************************************
917 **************************************************************************/
918 uint32_t libvlc_media_player_get_agl( libvlc_media_player_t
*p_mi
)
920 assert (p_mi
!= NULL
);
922 return var_GetInteger (p_mi
, "drawable-agl");
928 /**************************************************************************
930 **************************************************************************/
931 void libvlc_media_player_set_xwindow( libvlc_media_player_t
*p_mi
,
934 assert (p_mi
!= NULL
);
936 var_SetString (p_mi
, "vout", drawable
? "xid" : "any");
937 var_SetString (p_mi
, "window", drawable
? "embed-xid,any" : "any");
938 var_SetInteger (p_mi
, "drawable-xid", drawable
);
941 /**************************************************************************
943 **************************************************************************/
944 uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t
*p_mi
)
946 return var_GetInteger (p_mi
, "drawable-xid");
949 /**************************************************************************
951 **************************************************************************/
952 void libvlc_media_player_set_hwnd( libvlc_media_player_t
*p_mi
,
955 assert (p_mi
!= NULL
);
956 #if defined (_WIN32) || defined (__OS2__)
957 var_SetString (p_mi
, "window",
958 (drawable
!= NULL
) ? "embed-hwnd,any" : "");
959 var_SetInteger (p_mi
, "drawable-hwnd", (uintptr_t)drawable
);
961 (void) p_mi
; (void) drawable
;
965 /**************************************************************************
967 **************************************************************************/
968 void *libvlc_media_player_get_hwnd( libvlc_media_player_t
*p_mi
)
970 assert (p_mi
!= NULL
);
971 #if defined (_WIN32) || defined (__OS2__)
972 return (void *)(uintptr_t)var_GetInteger (p_mi
, "drawable-hwnd");
978 void libvlc_audio_set_callbacks( libvlc_media_player_t
*mp
,
979 libvlc_audio_play_cb play_cb
,
980 libvlc_audio_pause_cb pause_cb
,
981 libvlc_audio_resume_cb resume_cb
,
982 libvlc_audio_flush_cb flush_cb
,
983 libvlc_audio_drain_cb drain_cb
,
986 var_SetAddress( mp
, "amem-play", play_cb
);
987 var_SetAddress( mp
, "amem-pause", pause_cb
);
988 var_SetAddress( mp
, "amem-resume", resume_cb
);
989 var_SetAddress( mp
, "amem-flush", flush_cb
);
990 var_SetAddress( mp
, "amem-drain", drain_cb
);
991 var_SetAddress( mp
, "amem-data", opaque
);
992 var_SetString( mp
, "aout", "amem,none" );
994 input_resource_ResetAout(mp
->input
.p_resource
);
997 void libvlc_audio_set_volume_callback( libvlc_media_player_t
*mp
,
998 libvlc_audio_set_volume_cb cb
)
1000 var_SetAddress( mp
, "amem-set-volume", cb
);
1002 input_resource_ResetAout(mp
->input
.p_resource
);
1005 void libvlc_audio_set_format_callbacks( libvlc_media_player_t
*mp
,
1006 libvlc_audio_setup_cb setup
,
1007 libvlc_audio_cleanup_cb cleanup
)
1009 var_SetAddress( mp
, "amem-setup", setup
);
1010 var_SetAddress( mp
, "amem-cleanup", cleanup
);
1012 input_resource_ResetAout(mp
->input
.p_resource
);
1015 void libvlc_audio_set_format( libvlc_media_player_t
*mp
, const char *format
,
1016 unsigned rate
, unsigned channels
)
1018 var_SetString( mp
, "amem-format", format
);
1019 var_SetInteger( mp
, "amem-rate", rate
);
1020 var_SetInteger( mp
, "amem-channels", channels
);
1022 input_resource_ResetAout(mp
->input
.p_resource
);
1026 /**************************************************************************
1027 * Getters for stream information
1028 **************************************************************************/
1029 libvlc_time_t
libvlc_media_player_get_length(
1030 libvlc_media_player_t
*p_mi
)
1032 input_thread_t
*p_input_thread
;
1033 libvlc_time_t i_time
;
1035 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1036 if( !p_input_thread
)
1039 i_time
= from_mtime(var_GetTime( p_input_thread
, "length" ));
1040 vlc_object_release( p_input_thread
);
1045 libvlc_time_t
libvlc_media_player_get_time( libvlc_media_player_t
*p_mi
)
1047 input_thread_t
*p_input_thread
;
1048 libvlc_time_t i_time
;
1050 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1051 if( !p_input_thread
)
1054 i_time
= from_mtime(var_GetTime( p_input_thread
, "time" ));
1055 vlc_object_release( p_input_thread
);
1059 void libvlc_media_player_set_time( libvlc_media_player_t
*p_mi
,
1060 libvlc_time_t i_time
)
1062 input_thread_t
*p_input_thread
;
1064 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1065 if( !p_input_thread
)
1068 var_SetTime( p_input_thread
, "time", to_mtime(i_time
) );
1069 vlc_object_release( p_input_thread
);
1072 void libvlc_media_player_set_position( libvlc_media_player_t
*p_mi
,
1075 input_thread_t
*p_input_thread
;
1077 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1078 if( !p_input_thread
)
1081 var_SetFloat( p_input_thread
, "position", position
);
1082 vlc_object_release( p_input_thread
);
1085 float libvlc_media_player_get_position( libvlc_media_player_t
*p_mi
)
1087 input_thread_t
*p_input_thread
;
1090 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1091 if( !p_input_thread
)
1094 f_position
= var_GetFloat( p_input_thread
, "position" );
1095 vlc_object_release( p_input_thread
);
1100 void libvlc_media_player_set_chapter( libvlc_media_player_t
*p_mi
,
1103 input_thread_t
*p_input_thread
;
1105 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1106 if( !p_input_thread
)
1109 var_SetInteger( p_input_thread
, "chapter", chapter
);
1110 vlc_object_release( p_input_thread
);
1113 int libvlc_media_player_get_chapter( libvlc_media_player_t
*p_mi
)
1115 input_thread_t
*p_input_thread
;
1118 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1119 if( !p_input_thread
)
1122 i_chapter
= var_GetInteger( p_input_thread
, "chapter" );
1123 vlc_object_release( p_input_thread
);
1128 int libvlc_media_player_get_chapter_count( libvlc_media_player_t
*p_mi
)
1130 input_thread_t
*p_input_thread
;
1133 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1134 if( !p_input_thread
)
1137 var_Change( p_input_thread
, "chapter", VLC_VAR_CHOICESCOUNT
, &val
, NULL
);
1138 vlc_object_release( p_input_thread
);
1143 int libvlc_media_player_get_chapter_count_for_title(
1144 libvlc_media_player_t
*p_mi
,
1147 input_thread_t
*p_input_thread
;
1150 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1151 if( !p_input_thread
)
1155 if( asprintf( &psz_name
, "title %2i", i_title
) == -1 )
1157 vlc_object_release( p_input_thread
);
1160 var_Change( p_input_thread
, psz_name
, VLC_VAR_CHOICESCOUNT
, &val
, NULL
);
1161 vlc_object_release( p_input_thread
);
1167 void libvlc_media_player_set_title( libvlc_media_player_t
*p_mi
,
1170 input_thread_t
*p_input_thread
;
1172 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1173 if( !p_input_thread
)
1176 var_SetInteger( p_input_thread
, "title", i_title
);
1177 vlc_object_release( p_input_thread
);
1180 libvlc_event_t event
;
1181 event
.type
= libvlc_MediaPlayerTitleChanged
;
1182 event
.u
.media_player_title_changed
.new_title
= i_title
;
1183 libvlc_event_send( p_mi
->p_event_manager
, &event
);
1186 int libvlc_media_player_get_title( libvlc_media_player_t
*p_mi
)
1188 input_thread_t
*p_input_thread
;
1191 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1192 if( !p_input_thread
)
1195 i_title
= var_GetInteger( p_input_thread
, "title" );
1196 vlc_object_release( p_input_thread
);
1201 int libvlc_media_player_get_title_count( libvlc_media_player_t
*p_mi
)
1203 input_thread_t
*p_input_thread
;
1206 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1207 if( !p_input_thread
)
1210 var_Change( p_input_thread
, "title", VLC_VAR_CHOICESCOUNT
, &val
, NULL
);
1211 vlc_object_release( p_input_thread
);
1216 void libvlc_media_player_next_chapter( libvlc_media_player_t
*p_mi
)
1218 input_thread_t
*p_input_thread
;
1220 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1221 if( !p_input_thread
)
1224 int i_type
= var_Type( p_input_thread
, "next-chapter" );
1225 var_TriggerCallback( p_input_thread
, (i_type
& VLC_VAR_TYPE
) != 0 ?
1226 "next-chapter":"next-title" );
1228 vlc_object_release( p_input_thread
);
1231 void libvlc_media_player_previous_chapter( libvlc_media_player_t
*p_mi
)
1233 input_thread_t
*p_input_thread
;
1235 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1236 if( !p_input_thread
)
1239 int i_type
= var_Type( p_input_thread
, "next-chapter" );
1240 var_TriggerCallback( p_input_thread
, (i_type
& VLC_VAR_TYPE
) != 0 ?
1241 "prev-chapter":"prev-title" );
1243 vlc_object_release( p_input_thread
);
1246 float libvlc_media_player_get_fps( libvlc_media_player_t
*p_mi
)
1248 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1251 if( p_input_thread
)
1253 if( input_Control( p_input_thread
, INPUT_GET_VIDEO_FPS
, &f_fps
) )
1255 vlc_object_release( p_input_thread
);
1260 int libvlc_media_player_will_play( libvlc_media_player_t
*p_mi
)
1263 input_thread_t
*p_input_thread
=
1264 libvlc_get_input_thread ( p_mi
);
1265 if ( !p_input_thread
)
1268 b_will_play
= !p_input_thread
->b_dead
;
1269 vlc_object_release( p_input_thread
);
1274 int libvlc_media_player_set_rate( libvlc_media_player_t
*p_mi
, float rate
)
1276 var_SetFloat (p_mi
, "rate", rate
);
1278 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1279 if( !p_input_thread
)
1281 var_SetFloat( p_input_thread
, "rate", rate
);
1282 vlc_object_release( p_input_thread
);
1286 float libvlc_media_player_get_rate( libvlc_media_player_t
*p_mi
)
1288 return var_GetFloat (p_mi
, "rate");
1291 libvlc_state_t
libvlc_media_player_get_state( libvlc_media_player_t
*p_mi
)
1294 libvlc_state_t state
= p_mi
->state
;
1299 int libvlc_media_player_is_seekable( libvlc_media_player_t
*p_mi
)
1301 input_thread_t
*p_input_thread
;
1304 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1305 if ( !p_input_thread
)
1307 b_seekable
= var_GetBool( p_input_thread
, "can-seek" );
1308 vlc_object_release( p_input_thread
);
1313 void libvlc_media_player_navigate( libvlc_media_player_t
* p_mi
,
1316 static const vlc_action_t map
[] =
1318 INPUT_NAV_ACTIVATE
, INPUT_NAV_UP
, INPUT_NAV_DOWN
,
1319 INPUT_NAV_LEFT
, INPUT_NAV_RIGHT
,
1322 if( navigate
>= sizeof(map
) / sizeof(map
[0]) )
1325 input_thread_t
*p_input
= libvlc_get_input_thread ( p_mi
);
1326 if ( p_input
== NULL
)
1329 input_Control( p_input
, map
[navigate
], NULL
);
1330 vlc_object_release( p_input
);
1333 /* internal function, used by audio, video */
1334 libvlc_track_description_t
*
1335 libvlc_get_track_description( libvlc_media_player_t
*p_mi
,
1336 const char *psz_variable
)
1338 input_thread_t
*p_input
= libvlc_get_input_thread( p_mi
);
1339 libvlc_track_description_t
*p_track_description
= NULL
,
1340 *p_actual
, *p_previous
;
1345 vlc_value_t val_list
, text_list
;
1346 var_Change( p_input
, psz_variable
, VLC_VAR_GETLIST
, &val_list
, &text_list
);
1349 if( val_list
.p_list
->i_count
<= 0 )
1352 p_track_description
= ( libvlc_track_description_t
* )
1353 malloc( sizeof( libvlc_track_description_t
) );
1354 if ( !p_track_description
)
1356 libvlc_printerr( "Not enough memory" );
1359 p_actual
= p_track_description
;
1361 for( int i
= 0; i
< val_list
.p_list
->i_count
; i
++ )
1365 p_actual
= ( libvlc_track_description_t
* )
1366 malloc( sizeof( libvlc_track_description_t
) );
1369 libvlc_track_description_list_release( p_track_description
);
1370 libvlc_printerr( "Not enough memory" );
1374 p_actual
->i_id
= val_list
.p_list
->p_values
[i
].i_int
;
1375 p_actual
->psz_name
= strdup( text_list
.p_list
->p_values
[i
].psz_string
);
1376 p_actual
->p_next
= NULL
;
1378 p_previous
->p_next
= p_actual
;
1379 p_previous
= p_actual
;
1384 var_FreeList( &val_list
, &text_list
);
1385 vlc_object_release( p_input
);
1387 return p_track_description
;
1390 // Deprecated alias for libvlc_track_description_list_release
1391 void libvlc_track_description_release( libvlc_track_description_t
*p_td
)
1393 libvlc_track_description_list_release( p_td
);
1396 void libvlc_track_description_list_release( libvlc_track_description_t
*p_td
)
1398 libvlc_track_description_t
*p_actual
, *p_before
;
1403 free( p_actual
->psz_name
);
1404 p_before
= p_actual
;
1405 p_actual
= p_before
->p_next
;
1410 int libvlc_media_player_can_pause( 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
)
1418 b_can_pause
= var_GetBool( p_input_thread
, "can-pause" );
1419 vlc_object_release( p_input_thread
);
1424 int libvlc_media_player_program_scrambled( libvlc_media_player_t
*p_mi
)
1426 input_thread_t
*p_input_thread
;
1427 bool b_program_scrambled
;
1429 p_input_thread
= libvlc_get_input_thread ( p_mi
);
1430 if ( !p_input_thread
)
1432 b_program_scrambled
= var_GetBool( p_input_thread
, "program-scrambled" );
1433 vlc_object_release( p_input_thread
);
1435 return b_program_scrambled
;
1438 void libvlc_media_player_next_frame( libvlc_media_player_t
*p_mi
)
1440 input_thread_t
*p_input_thread
= libvlc_get_input_thread ( p_mi
);
1441 if( p_input_thread
!= NULL
)
1443 var_TriggerCallback( p_input_thread
, "frame-next" );
1444 vlc_object_release( p_input_thread
);
1448 void libvlc_media_player_set_video_title_display( libvlc_media_player_t
*p_mi
, libvlc_position_t position
, unsigned timeout
)
1450 if ( position
!= libvlc_position_disable
)
1452 var_SetBool( p_mi
, "video-title-show", true );
1453 var_SetInteger( p_mi
, "video-title-position", position
);
1454 var_SetInteger( p_mi
, "video-title-timeout", timeout
);
1458 var_SetBool( p_mi
, "video-title-show", false );
1463 * Maximum size of a formatted equalizer amplification band frequency value.
1465 * The allowed value range is supposed to be constrained from -20.0 to 20.0.
1467 * The format string " %.07f" with a minimum value of "-20" gives a maximum
1468 * string length of e.g. " -19.1234567", i.e. 12 bytes (not including the null
1471 #define EQZ_BAND_VALUE_SIZE 12
1473 int libvlc_media_player_set_equalizer( libvlc_media_player_t
*p_mi
, libvlc_equalizer_t
*p_equalizer
)
1480 f_preamp
= p_equalizer
->f_preamp
;
1482 psz_bands
= malloc( EQZ_BANDS_MAX
* EQZ_BAND_VALUE_SIZE
+ 1 );
1483 if ( unlikely( psz_bands
== NULL
) )
1486 char *p
= psz_bands
;
1488 for ( int i
= 0; i
< EQZ_BANDS_MAX
; i
++ )
1490 c
= snprintf( p
, EQZ_BAND_VALUE_SIZE
+ 1, " %.07f", p_equalizer
->f_amp
[i
] );
1491 if ( unlikely( c
>= EQZ_BAND_VALUE_SIZE
+ 1 ) )
1506 var_SetFloat( p_mi
, "equalizer-preamp", f_preamp
);
1507 var_SetString( p_mi
, "equalizer-bands", psz_bands
);
1509 audio_output_t
*p_aout
= input_resource_HoldAout( p_mi
->input
.p_resource
);
1512 var_SetFloat( p_aout
, "equalizer-preamp", f_preamp
);
1513 var_SetString( p_aout
, "equalizer-bands", psz_bands
);
1515 vlc_object_release( p_aout
);