X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fcontrol%2Fmedia_player.c;h=1be7112f040ed7b6e8a0bc21b786ecc806b65d7e;hb=7228b1b132936ab5d7744a804f89b0155f56bc3c;hp=4b63d1baf78643b2a5d50ec293a58bfa68b98a95;hpb=d6b67211aacbdf45627f5b267ebe0dcf5edb146d;p=vlc diff --git a/src/control/media_player.c b/src/control/media_player.c index 4b63d1baf7..1be7112f04 100644 --- a/src/control/media_player.c +++ b/src/control/media_player.c @@ -1,7 +1,7 @@ /***************************************************************************** * media_player.c: Libvlc API Media Instance management functions ***************************************************************************** - * Copyright (C) 2005 the VideoLAN team + * Copyright (C) 2005-2009 the VideoLAN team * $Id$ * * Authors: Clément Stenac @@ -21,14 +21,25 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ -#include "libvlc_internal.h" +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include #include +#include +#include + #include #include #include + #include "libvlc.h" -#include + +#include "libvlc_internal.h" +#include "media_internal.h" // libvlc_media_set_state() +#include "media_player_internal.h" static int input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd, @@ -43,25 +54,30 @@ input_event_changed( vlc_object_t * p_this, char const * psz_cmd, vlc_value_t oldval, vlc_value_t newval, void * p_userdata ); -static int SnapshotTakenCallback( vlc_object_t *p_this, char const *psz_cmd, - vlc_value_t oldval, vlc_value_t newval, void *p_data ); +static int +snapshot_was_taken( vlc_object_t *p_this, char const *psz_cmd, + vlc_value_t oldval, vlc_value_t newval, void *p_data ); + +static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ); + +/* + * Shortcuts + */ -static const libvlc_state_t vlc_to_libvlc_state_array[] = +#define register_event(a, b) __register_event(a, libvlc_MediaPlayer ## b) +static inline void __register_event(libvlc_media_player_t *mp, libvlc_event_type_t type) { - [INIT_S] = libvlc_NothingSpecial, - [OPENING_S] = libvlc_Opening, - [PLAYING_S] = libvlc_Playing, - [PAUSE_S] = libvlc_Paused, - [END_S] = libvlc_Ended, - [ERROR_S] = libvlc_Error, -}; - -static inline libvlc_state_t vlc_to_libvlc_state( int vlc_state ) + libvlc_event_manager_register_event_type(mp->p_event_manager, type); +} + +static inline void lock(libvlc_media_player_t *mp) { - if( vlc_state < 0 || vlc_state > 6 ) - return libvlc_Ended; + vlc_mutex_lock(&mp->object_lock); +} - return vlc_to_libvlc_state_array[vlc_state]; +static inline void unlock(libvlc_media_player_t *mp) +{ + vlc_mutex_unlock(&mp->object_lock); } /* @@ -78,24 +94,26 @@ static void release_input_thread( libvlc_media_player_t *p_mi, bool b_input_abor p_input_thread = p_mi->p_input_thread; - /* No one is tracking this input_thread apart from us. Destroy it. */ - if( p_mi->b_own_its_input_thread ) - { - var_DelCallback( p_input_thread, "can-seek", - input_seekable_changed, p_mi ); - var_DelCallback( p_input_thread, "can-pause", - input_pausable_changed, p_mi ); - var_DelCallback( p_input_thread, "intf-event", - input_event_changed, p_mi ); - - /* We owned this one */ - input_StopThread( p_input_thread, b_input_abort ); - vlc_thread_join( p_input_thread ); - - var_Destroy( p_input_thread, "drawable-hwnd" ); - var_Destroy( p_input_thread, "drawable-xid" ); - var_Destroy( p_input_thread, "drawable-agl" ); - } + var_DelCallback( p_input_thread, "can-seek", + input_seekable_changed, p_mi ); + var_DelCallback( p_input_thread, "can-pause", + input_pausable_changed, p_mi ); + var_DelCallback( p_input_thread, "intf-event", + input_event_changed, p_mi ); + + /* We owned this one */ + input_Stop( p_input_thread, b_input_abort ); + + vlc_thread_join( p_input_thread ); + + assert( p_mi->p_input_resource == NULL ); + assert( p_input_thread->b_dead ); + /* Store the input resource for future use. */ + p_mi->p_input_resource = input_DetachResource( p_input_thread ); + + var_Destroy( p_input_thread, "drawable-hwnd" ); + var_Destroy( p_input_thread, "drawable-xid" ); + var_Destroy( p_input_thread, "drawable-agl" ); vlc_object_release( p_input_thread ); @@ -115,22 +133,49 @@ input_thread_t *libvlc_get_input_thread( libvlc_media_player_t *p_mi, if( !p_mi ) RAISENULL( "Media Instance is NULL" ); - vlc_mutex_lock( &p_mi->object_lock ); + lock(p_mi); if( !p_mi->p_input_thread ) { - vlc_mutex_unlock( &p_mi->object_lock ); + unlock(p_mi); RAISENULL( "Input is NULL" ); } p_input_thread = p_mi->p_input_thread; vlc_object_hold( p_input_thread ); - vlc_mutex_unlock( &p_mi->object_lock ); + unlock(p_mi); return p_input_thread; } +/* + * Set the internal state of the media_player. (media player Internal) + * + * Function will lock the media_player. + */ +static void set_state( libvlc_media_player_t *p_mi, libvlc_state_t state, + bool b_locked ) +{ + if(!b_locked) + lock(p_mi); + p_mi->state = state; + libvlc_media_t *media = p_mi->p_md; + if (media) + libvlc_media_retain(media); + if(!b_locked) + unlock(p_mi); + + + if (media) { + // Also set the state of the corresponding media + // This is strictly for convenience. + libvlc_media_set_state(media, state); + + libvlc_media_release(media); + } +} + static int input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd, vlc_value_t oldval, vlc_value_t newval, @@ -142,7 +187,6 @@ input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd, libvlc_media_player_t * p_mi = p_userdata; libvlc_event_t event; - libvlc_media_set_state( p_mi->p_md, libvlc_NothingSpecial, NULL); event.type = libvlc_MediaPlayerSeekableChanged; event.u.media_player_seekable_changed.new_seekable = newval.b_bool; @@ -161,7 +205,6 @@ input_pausable_changed( vlc_object_t * p_this, char const * psz_cmd, libvlc_media_player_t * p_mi = p_userdata; libvlc_event_t event; - libvlc_media_set_state( p_mi->p_md, libvlc_NothingSpecial, NULL); event.type = libvlc_MediaPlayerPausableChanged; event.u.media_player_pausable_changed.new_pausable = newval.b_bool; @@ -216,10 +259,18 @@ input_event_changed( vlc_object_t * p_this, char const * psz_cmd, return VLC_SUCCESS; } - libvlc_media_set_state( p_mi->p_md, libvlc_state, NULL ); + set_state( p_mi, libvlc_state, false ); libvlc_event_send( p_mi->p_event_manager, &event ); } - else if( newval.i_int == INPUT_EVENT_TIMES ) + else if( newval.i_int == INPUT_EVENT_ABORT ) + { + libvlc_state_t libvlc_state = libvlc_Stopped; + event.type = libvlc_MediaPlayerStopped; + + set_state( p_mi, libvlc_state, false ); + libvlc_event_send( p_mi->p_event_manager, &event ); + } + else if( newval.i_int == INPUT_EVENT_POSITION ) { if( var_GetInteger( p_input, "state" ) != PLAYING_S ) return VLC_SUCCESS; /* Don't send the position while stopped */ @@ -233,7 +284,14 @@ input_event_changed( vlc_object_t * p_this, char const * psz_cmd, /* */ event.type = libvlc_MediaPlayerTimeChanged; event.u.media_player_time_changed.new_time = - var_GetTime( p_input, "time" ); + from_mtime(var_GetTime( p_input, "time" )); + libvlc_event_send( p_mi->p_event_manager, &event ); + } + else if( newval.i_int == INPUT_EVENT_LENGTH ) + { + event.type = libvlc_MediaPlayerLengthChanged; + event.u.media_player_length_changed.new_length = + from_mtime(var_GetTime( p_input, "length" )); libvlc_event_send( p_mi->p_event_manager, &event ); } @@ -241,6 +299,28 @@ input_event_changed( vlc_object_t * p_this, char const * psz_cmd, } +/************************************************************************** + * Snapshot Taken Event. + * + * FIXME: This snapshot API interface makes no sense in media_player. + *************************************************************************/ +static int snapshot_was_taken(vlc_object_t *p_this, char const *psz_cmd, + vlc_value_t oldval, vlc_value_t newval, void *p_data ) +{ + VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_this); + + libvlc_media_player_t *mp = p_data; + libvlc_event_t event; + event.type = libvlc_MediaPlayerSnapshotTaken; + event.u.media_player_snapshot_taken.psz_filename = newval.psz_string; + libvlc_event_send(mp->p_event_manager, &event); + + return VLC_SUCCESS; +} + + +static void libvlc_media_player_destroy( libvlc_media_player_t * ); + /************************************************************************** * Create a Media Instance object. @@ -257,85 +337,71 @@ input_event_changed( vlc_object_t * p_this, char const * psz_cmd, * - When attempting to destroy the object the lock is also held. **************************************************************************/ libvlc_media_player_t * -libvlc_media_player_new( libvlc_instance_t * p_libvlc_instance, - libvlc_exception_t * p_e ) +libvlc_media_player_new( libvlc_instance_t *instance, libvlc_exception_t *e ) { - libvlc_media_player_t * p_mi; + libvlc_media_player_t * mp; - if( !p_libvlc_instance ) - { - libvlc_exception_raise( p_e, "invalid libvlc instance" ); - return NULL; - } + assert(instance); - p_mi = malloc( sizeof(libvlc_media_player_t) ); - if( !p_mi ) + mp = malloc(sizeof(libvlc_media_player_t)); + if (!mp) { - libvlc_exception_raise( p_e, "Not enough memory" ); + libvlc_exception_raise(e); + libvlc_printerr("Not enough memory"); return NULL; } - p_mi->p_md = NULL; - p_mi->drawable.agl = 0; - p_mi->drawable.xid = 0; - p_mi->drawable.hwnd = NULL; - p_mi->p_libvlc_instance = p_libvlc_instance; - p_mi->p_input_thread = NULL; - p_mi->i_refcount = 1; - p_mi->b_own_its_input_thread = true; - vlc_mutex_init( &p_mi->object_lock ); - p_mi->p_event_manager = libvlc_event_manager_new( p_mi, - p_libvlc_instance, p_e ); - if( libvlc_exception_raised( p_e ) ) + mp->p_md = NULL; + mp->drawable.agl = 0; + mp->drawable.xid = 0; + mp->drawable.hwnd = NULL; + mp->drawable.nsobject = NULL; + mp->keyboard_events = mp->mouse_events = 1; + mp->state = libvlc_NothingSpecial; + mp->p_libvlc_instance = instance; + mp->p_input_thread = NULL; + mp->p_input_resource = NULL; + mp->i_refcount = 1; + mp->p_event_manager = libvlc_event_manager_new(mp, instance); + if (unlikely(mp->p_event_manager == NULL)) { - free( p_mi ); + free(mp); return NULL; } - - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerNothingSpecial, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerOpening, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerBuffering, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerPlaying, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerPaused, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerStopped, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerForward, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerBackward, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerEndReached, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerEncounteredError, p_e ); - - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerPositionChanged, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerTimeChanged, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerTitleChanged, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerSeekableChanged, p_e ); - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerPausableChanged, p_e ); + vlc_mutex_init(&mp->object_lock); + + register_event(mp, NothingSpecial); + register_event(mp, Opening); + register_event(mp, Buffering); + register_event(mp, Playing); + register_event(mp, Paused); + register_event(mp, Stopped); + register_event(mp, Forward); + register_event(mp, Backward); + register_event(mp, EndReached); + register_event(mp, EncounteredError); + register_event(mp, SeekableChanged); + + register_event(mp, PositionChanged); + register_event(mp, TimeChanged); + register_event(mp, LengthChanged); + register_event(mp, TitleChanged); + register_event(mp, PausableChanged); /* Snapshot initialization */ - libvlc_event_manager_register_event_type( p_mi->p_event_manager, - libvlc_MediaPlayerSnapshotTaken, p_e ); - /* Attach a var callback to the global object to provide the glue between - vout_thread that generates the event and media_player that re-emits it - with its own event manager - */ - var_Create( p_libvlc_instance->p_libvlc_int, "vout-snapshottaken", - VLC_VAR_STRING | VLC_VAR_ISCOMMAND ); - var_AddCallback( p_libvlc_instance->p_libvlc_int, "vout-snapshottaken", - SnapshotTakenCallback, p_mi ); + register_event(mp, SnapshotTaken); - return p_mi; + register_event(mp, MediaChanged); + + /* Attach a var callback to the global object to provide the glue between + * vout_thread that generates the event and media_player that re-emits it + * with its own event manager + * + * FIXME: It's unclear why we want to put this in public API, and why we + * want to expose it in such a limiting and ugly way. + */ + var_AddCallback(instance->p_libvlc_int, "snapshot-file", snapshot_was_taken, mp); + + return mp; } /************************************************************************** @@ -347,8 +413,8 @@ libvlc_media_player_new_from_media( libvlc_exception_t *p_e ) { libvlc_media_player_t * p_mi; - p_mi = libvlc_media_player_new( p_md->p_libvlc_instance, p_e ); + p_mi = libvlc_media_player_new( p_md->p_libvlc_instance, p_e ); if( !p_mi ) return NULL; @@ -358,80 +424,36 @@ libvlc_media_player_new_from_media( return p_mi; } -/************************************************************************** - * Create a new media instance object from an input_thread (Libvlc Internal). - **************************************************************************/ -libvlc_media_player_t * libvlc_media_player_new_from_input_thread( - struct libvlc_instance_t *p_libvlc_instance, - input_thread_t *p_input, - libvlc_exception_t *p_e ) -{ - libvlc_media_player_t * p_mi; - - if( !p_input ) - { - libvlc_exception_raise( p_e, "invalid input thread" ); - return NULL; - } - - p_mi = libvlc_media_player_new( p_libvlc_instance, p_e ); - - if( !p_mi ) - return NULL; - - p_mi->p_md = libvlc_media_new_from_input_item( - p_libvlc_instance, - input_GetItem( p_input ), p_e ); - - if( !p_mi->p_md ) - { - libvlc_media_player_destroy( p_mi ); - return NULL; - } - - /* will be released in media_player_release() */ - vlc_object_hold( p_input ); - - p_mi->p_input_thread = p_input; - p_mi->b_own_its_input_thread = false; - - return p_mi; -} - /************************************************************************** * Destroy a Media Instance object (libvlc internal) * * Warning: No lock held here, but hey, this is internal. Caller must lock. **************************************************************************/ -void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ) +static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ) { - input_thread_t *p_input_thread; - libvlc_exception_t p_e; - - libvlc_exception_init( &p_e ); + assert( p_mi ); - if( !p_mi ) - return; - - /* Detach Callback from the main libvlc object */ + /* Detach Callback from the main libvlc object */ var_DelCallback( p_mi->p_libvlc_instance->p_libvlc_int, - "vout-snapshottaken", SnapshotTakenCallback, p_mi ); + "snapshot-file", snapshot_was_taken, p_mi ); + + /* If the input thread hasn't been already deleted it means + * that the owners didn't stop the thread before releasing it. */ + assert(!p_mi->p_input_thread); - p_input_thread = libvlc_get_input_thread( p_mi, &p_e ); + /* Fallback for those who don't use NDEBUG */ + if (p_mi->p_input_thread) + release_input_thread(p_mi, true); - if( libvlc_exception_raised( &p_e ) ) + if( p_mi->p_input_resource ) { - libvlc_event_manager_release( p_mi->p_event_manager ); - libvlc_exception_clear( &p_e ); - free( p_mi ); - return; /* no need to worry about no input thread */ + input_resource_Delete( p_mi->p_input_resource ); + p_mi->p_input_resource = NULL; } - vlc_mutex_destroy( &p_mi->object_lock ); - - vlc_object_release( p_input_thread ); + libvlc_event_manager_release( p_mi->p_event_manager ); libvlc_media_release( p_mi->p_md ); - + vlc_mutex_destroy( &p_mi->object_lock ); free( p_mi ); } @@ -442,28 +464,15 @@ void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ) **************************************************************************/ void libvlc_media_player_release( libvlc_media_player_t *p_mi ) { - if( !p_mi ) - return; - - vlc_mutex_lock( &p_mi->object_lock ); - - p_mi->i_refcount--; - - if( p_mi->i_refcount > 0 ) - { - vlc_mutex_unlock( &p_mi->object_lock ); - return; - } - vlc_mutex_unlock( &p_mi->object_lock ); - vlc_mutex_destroy( &p_mi->object_lock ); + bool destroy; - release_input_thread( p_mi, true ); - - libvlc_event_manager_release( p_mi->p_event_manager ); - - libvlc_media_release( p_mi->p_md ); + assert( p_mi ); + lock(p_mi); + destroy = !--p_mi->i_refcount; + unlock(p_mi); - free( p_mi ); + if( destroy ) + libvlc_media_player_destroy( p_mi ); } /************************************************************************** @@ -473,10 +482,11 @@ void libvlc_media_player_release( libvlc_media_player_t *p_mi ) **************************************************************************/ void libvlc_media_player_retain( libvlc_media_player_t *p_mi ) { - if( !p_mi ) - return; + assert( p_mi ); + lock(p_mi); p_mi->i_refcount++; + unlock(p_mi); } /************************************************************************** @@ -486,15 +496,9 @@ void libvlc_media_player_retain( libvlc_media_player_t *p_mi ) **************************************************************************/ void libvlc_media_player_set_media( libvlc_media_player_t *p_mi, - libvlc_media_t *p_md, - libvlc_exception_t *p_e ) + libvlc_media_t *p_md ) { - VLC_UNUSED(p_e); - - if( !p_mi ) - return; - - vlc_mutex_lock( &p_mi->object_lock ); + lock(p_mi); /* FIXME I am not sure if it is a user request or on die(eof/error) * request here */ @@ -503,15 +507,14 @@ void libvlc_media_player_set_media( !p_mi->p_input_thread->b_eof && !p_mi->p_input_thread->b_error ); - if( p_mi->p_md ) - libvlc_media_set_state( p_mi->p_md, libvlc_NothingSpecial, p_e ); + set_state( p_mi, libvlc_NothingSpecial, true ); libvlc_media_release( p_mi->p_md ); if( !p_md ) { p_mi->p_md = NULL; - vlc_mutex_unlock( &p_mi->object_lock ); + unlock(p_mi); return; /* It is ok to pass a NULL md */ } @@ -522,23 +525,29 @@ void libvlc_media_player_set_media( * libvlc_instance, because we don't really care */ p_mi->p_libvlc_instance = p_md->p_libvlc_instance; - vlc_mutex_unlock( &p_mi->object_lock ); + unlock(p_mi); + + /* Send an event for the newly available media */ + libvlc_event_t event; + event.type = libvlc_MediaPlayerMediaChanged; + event.u.media_player_media_changed.new_media = p_md; + libvlc_event_send( p_mi->p_event_manager, &event ); + } /************************************************************************** * Get the Media descriptor associated with the instance. **************************************************************************/ libvlc_media_t * -libvlc_media_player_get_media( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +libvlc_media_player_get_media( libvlc_media_player_t *p_mi ) { - VLC_UNUSED(p_e); - - if( !p_mi->p_md ) - return NULL; + libvlc_media_t *p_m; - libvlc_media_retain( p_mi->p_md ); + lock(p_mi); + p_m = p_mi->p_md; + if( p_m ) + libvlc_media_retain( p_mi->p_md ); + unlock(p_mi); return p_mi->p_md; } @@ -546,38 +555,11 @@ libvlc_media_player_get_media( * Get the event Manager. **************************************************************************/ libvlc_event_manager_t * -libvlc_media_player_event_manager( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +libvlc_media_player_event_manager( libvlc_media_player_t *p_mi ) { - VLC_UNUSED(p_e); - return p_mi->p_event_manager; } -/************************************************************************** - * Trigger a snapshot Taken Event. - *************************************************************************/ -static int SnapshotTakenCallback( vlc_object_t *p_this, char const *psz_cmd, - vlc_value_t oldval, vlc_value_t newval, void *p_data ) -{ - VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); - VLC_UNUSED(p_this) ; - - libvlc_media_player_t* p_mi = (libvlc_media_player_t*) p_data ; - libvlc_event_t event ; - event.type = libvlc_MediaPlayerSnapshotTaken ; - event.u.media_player_snapshot_taken.psz_filename = newval.psz_string ; - /* Snapshot psz data is a vlc_variable owned by libvlc object . - Its memmory management is taken care by the obj*/ - msg_Dbg( p_this, "about to emit libvlc_snapshot_taken.make psz_str=0x%p" - " (%s)", event.u.media_player_snapshot_taken.psz_filename, - event.u.media_player_snapshot_taken.psz_filename ); - libvlc_event_send( p_mi->p_event_manager, &event ); - - return VLC_SUCCESS; -} - /************************************************************************** * Tell media player to start playing. **************************************************************************/ @@ -597,24 +579,26 @@ void libvlc_media_player_play( libvlc_media_player_t *p_mi, /* Ignore previous exception */ libvlc_exception_clear( p_e ); - vlc_mutex_lock( &p_mi->object_lock ); + lock(p_mi); if( !p_mi->p_md ) { - libvlc_exception_raise( p_e, "no associated media descriptor" ); - vlc_mutex_unlock( &p_mi->object_lock ); + unlock(p_mi); + libvlc_exception_raise( p_e ); + libvlc_printerr( "No associated media descriptor" ); return; } - p_mi->p_input_thread = input_CreateThread( - p_mi->p_libvlc_instance->p_libvlc_int, p_mi->p_md->p_input_item ); + p_mi->p_input_thread = input_Create( p_mi->p_libvlc_instance->p_libvlc_int, + p_mi->p_md->p_input_item, NULL, p_mi->p_input_resource ); if( !p_mi->p_input_thread ) { - vlc_mutex_unlock( &p_mi->object_lock ); + unlock(p_mi); return; } + p_mi->p_input_resource = NULL; p_input_thread = p_mi->p_input_thread; var_Create( p_input_thread, "drawable-agl", VLC_VAR_INTEGER ); @@ -627,16 +611,28 @@ void libvlc_media_player_play( libvlc_media_player_t *p_mi, var_Create( p_input_thread, "drawable-hwnd", VLC_VAR_ADDRESS ); if( p_mi->drawable.hwnd != NULL ) - { - vlc_value_t val = { .p_address = p_mi->drawable.hwnd }; - var_Set( p_input_thread, "drawable-hwnd", val ); - } + var_SetAddress( p_input_thread, "drawable-hwnd", p_mi->drawable.hwnd ); + + var_Create( p_input_thread, "drawable-nsobject", VLC_VAR_ADDRESS ); + if( p_mi->drawable.nsobject != NULL ) + var_SetAddress( p_input_thread, "drawable-nsobject", p_mi->drawable.nsobject ); + + var_Create( p_input_thread, "keyboard-events", VLC_VAR_BOOL ); + var_SetBool( p_input_thread, "keyboard-events", p_mi->keyboard_events ); + var_Create( p_input_thread, "mouse-events", VLC_VAR_BOOL ); + var_SetBool( p_input_thread, "mouse-events", p_mi->mouse_events ); var_AddCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi ); var_AddCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi ); var_AddCallback( p_input_thread, "intf-event", input_event_changed, p_mi ); - vlc_mutex_unlock( &p_mi->object_lock ); + if( input_Start( p_input_thread ) ) + { + vlc_object_release( p_input_thread ); + p_mi->p_input_thread = NULL; + } + + unlock(p_mi); } /************************************************************************** @@ -646,18 +642,16 @@ void libvlc_media_player_pause( libvlc_media_player_t *p_mi, libvlc_exception_t *p_e ) { input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e ); - if( !p_input_thread ) return; - libvlc_state_t state = libvlc_media_player_get_state( p_mi, p_e ); - - if( state == libvlc_Playing ) + libvlc_state_t state = libvlc_media_player_get_state( p_mi ); + if( state == libvlc_Playing || state == libvlc_Buffering ) { if( libvlc_media_player_can_pause( p_mi, p_e ) ) input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S ); else - libvlc_media_player_stop( p_mi, p_e ); + libvlc_media_player_stop( p_mi ); } else input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S ); @@ -670,61 +664,59 @@ void libvlc_media_player_pause( libvlc_media_player_t *p_mi, * * Enter with lock held. **************************************************************************/ -int libvlc_media_player_is_playing( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_is_playing( libvlc_media_player_t *p_mi ) { - libvlc_state_t state = libvlc_media_player_get_state( p_mi, p_e ); - return libvlc_Playing == state; + libvlc_state_t state = libvlc_media_player_get_state( p_mi ); + return (libvlc_Playing == state) || (libvlc_Buffering == state); } - /************************************************************************** * Stop playing. **************************************************************************/ -void libvlc_media_player_stop( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +void libvlc_media_player_stop( libvlc_media_player_t *p_mi ) { - libvlc_state_t state = libvlc_media_player_get_state( p_mi, p_e ); + libvlc_state_t state = libvlc_media_player_get_state( p_mi ); - if( state == libvlc_Playing || state == libvlc_Paused ) + lock(p_mi); + release_input_thread( p_mi, true ); /* This will stop the input thread */ + unlock(p_mi); + + /* Force to go to stopped state, in case we were in Ended, or Error + * state. */ + if( state != libvlc_Stopped ) { - /* Send a stop notification event only if we are in playing or - * paused states */ - libvlc_media_set_state( p_mi->p_md, libvlc_Ended, p_e ); + set_state( p_mi, libvlc_Stopped, false ); /* Construct and send the event */ libvlc_event_t event; event.type = libvlc_MediaPlayerStopped; libvlc_event_send( p_mi->p_event_manager, &event ); } +} - if( p_mi->b_own_its_input_thread ) - { - vlc_mutex_lock( &p_mi->object_lock ); - release_input_thread( p_mi, true ); /* This will stop the input thread */ - vlc_mutex_unlock( &p_mi->object_lock ); - } - else - { - input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e ); - - if( !p_input_thread ) - return; +/************************************************************************** + * set_nsobject + **************************************************************************/ +void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi, + void * drawable ) +{ + p_mi->drawable.nsobject = drawable; +} - input_StopThread( p_input_thread, true ); - vlc_object_release( p_input_thread ); - p_mi->p_input_thread = NULL; - } +/************************************************************************** + * get_nsobject + **************************************************************************/ +void * libvlc_media_player_get_nsobject( libvlc_media_player_t *p_mi ) +{ + return p_mi->drawable.nsobject; } /************************************************************************** * set_agl **************************************************************************/ void libvlc_media_player_set_agl( libvlc_media_player_t *p_mi, - uint32_t drawable, - libvlc_exception_t *p_e ) + uint32_t drawable ) { - (void) p_e; p_mi->drawable.agl = drawable; } @@ -740,10 +732,8 @@ uint32_t libvlc_media_player_get_agl( libvlc_media_player_t *p_mi ) * set_xwindow **************************************************************************/ void libvlc_media_player_set_xwindow( libvlc_media_player_t *p_mi, - uint32_t drawable, - libvlc_exception_t *p_e ) + uint32_t drawable ) { - (void) p_e; p_mi->drawable.xid = drawable; } @@ -759,10 +749,8 @@ uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t *p_mi ) * set_hwnd **************************************************************************/ void libvlc_media_player_set_hwnd( libvlc_media_player_t *p_mi, - void *drawable, - libvlc_exception_t *p_e ) + void *drawable ) { - (void) p_e; p_mi->drawable.hwnd = drawable; } @@ -774,46 +762,6 @@ void *libvlc_media_player_get_hwnd( libvlc_media_player_t *p_mi ) return p_mi->drawable.hwnd; } -/************************************************************************** - * Set Drawable - **************************************************************************/ -void libvlc_media_player_set_drawable( libvlc_media_player_t *p_mi, - libvlc_drawable_t drawable, - libvlc_exception_t *p_e ) -{ -#ifdef WIN32 - if (sizeof (HWND) <= sizeof (libvlc_drawable_t)) - p_mi->drawable.hwnd = (HWND)drawable; - else - libvlc_exception_raise(p_e, "Operation not supported"); -#elif defined(__APPLE__) - p_mi->drawable.agl = drawable; -#else - p_mi->drawable.xid = drawable; -#endif -} - -/************************************************************************** - * Get Drawable - **************************************************************************/ -libvlc_drawable_t -libvlc_media_player_get_drawable ( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) -{ - VLC_UNUSED(p_e); - -#ifdef WIN32 - if (sizeof (HWND) <= sizeof (libvlc_drawable_t)) - return (libvlc_drawable_t)p_mi->drawable.hwnd; - else - return 0; -#elif defined(__APPLE__) - return p_mi->drawable.agl; -#else - return p_mi->drawable.xid; -#endif -} - /************************************************************************** * Getters for stream information **************************************************************************/ @@ -822,16 +770,16 @@ libvlc_time_t libvlc_media_player_get_length( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + libvlc_time_t i_time; p_input_thread = libvlc_get_input_thread ( p_mi, p_e); if( !p_input_thread ) return -1; - var_Get( p_input_thread, "length", &val ); + i_time = from_mtime(var_GetTime( p_input_thread, "length" )); vlc_object_release( p_input_thread ); - return (val.i_time+500LL)/1000LL; + return i_time; } libvlc_time_t libvlc_media_player_get_time( @@ -839,31 +787,29 @@ libvlc_time_t libvlc_media_player_get_time( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + libvlc_time_t i_time; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if( !p_input_thread ) return -1; - var_Get( p_input_thread , "time", &val ); + i_time = from_mtime(var_GetTime( p_input_thread , "time" )); vlc_object_release( p_input_thread ); - return (val.i_time+500LL)/1000LL; + return i_time; } void libvlc_media_player_set_time( libvlc_media_player_t *p_mi, - libvlc_time_t time, + libvlc_time_t i_time, libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t value; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if( !p_input_thread ) return; - value.i_time = time*1000LL; - var_Set( p_input_thread, "time", value ); + var_SetTime( p_input_thread, "time", to_mtime(i_time) ); vlc_object_release( p_input_thread ); } @@ -873,14 +819,12 @@ void libvlc_media_player_set_position( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; - val.f_float = position; p_input_thread = libvlc_get_input_thread ( p_mi, p_e); if( !p_input_thread ) return; - var_Set( p_input_thread, "position", val ); + var_SetFloat( p_input_thread, "position", position ); vlc_object_release( p_input_thread ); } @@ -889,16 +833,16 @@ float libvlc_media_player_get_position( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + float f_position; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if( !p_input_thread ) return -1.0; - var_Get( p_input_thread, "position", &val ); + f_position = var_GetFloat( p_input_thread, "position" ); vlc_object_release( p_input_thread ); - return val.f_float; + return f_position; } void libvlc_media_player_set_chapter( @@ -907,14 +851,12 @@ void libvlc_media_player_set_chapter( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; - val.i_int = chapter; p_input_thread = libvlc_get_input_thread ( p_mi, p_e); if( !p_input_thread ) return; - var_Set( p_input_thread, "chapter", val ); + var_SetInteger( p_input_thread, "chapter", chapter ); vlc_object_release( p_input_thread ); } @@ -923,16 +865,16 @@ int libvlc_media_player_get_chapter( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + int i_chapter; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if( !p_input_thread ) return -1; - var_Get( p_input_thread, "chapter", &val ); + i_chapter = var_GetInteger( p_input_thread, "chapter" ); vlc_object_release( p_input_thread ); - return val.i_int; + return i_chapter; } int libvlc_media_player_get_chapter_count( @@ -983,14 +925,12 @@ void libvlc_media_player_set_title( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; - val.i_int = i_title; p_input_thread = libvlc_get_input_thread ( p_mi, p_e); if( !p_input_thread ) return; - var_Set( p_input_thread, "title", val ); + var_SetInteger( p_input_thread, "title", i_title ); vlc_object_release( p_input_thread ); //send event @@ -1005,16 +945,16 @@ int libvlc_media_player_get_title( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + int i_title; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if( !p_input_thread ) return -1; - var_Get( p_input_thread, "title", &val ); + i_title = var_GetInteger( p_input_thread, "title" ); vlc_object_release( p_input_thread ); - return val.i_int; + return i_title; } int libvlc_media_player_get_title_count( @@ -1045,10 +985,8 @@ void libvlc_media_player_next_chapter( return; int i_type = var_Type( p_input_thread, "next-chapter" ); - vlc_value_t val; - val.b_bool = true; - var_Set( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ? - "next-chapter":"next-title", val ); + var_SetBool( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ? + "next-chapter":"next-title", true ); vlc_object_release( p_input_thread ); } @@ -1064,10 +1002,8 @@ void libvlc_media_player_previous_chapter( return; int i_type = var_Type( p_input_thread, "next-chapter" ); - vlc_value_t val; - val.b_bool = true; - var_Set( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ? - "prev-chapter":"prev-title", val ); + var_SetBool( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ? + "prev-chapter":"prev-title", true ); vlc_object_release( p_input_thread ); } @@ -1091,18 +1027,16 @@ float libvlc_media_player_get_fps( int libvlc_media_player_will_play( libvlc_media_player_t *p_mi, libvlc_exception_t *p_e) { + bool b_will_play; input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e); if ( !p_input_thread ) return false; - if ( !p_input_thread->b_die && !p_input_thread->b_dead ) - { - vlc_object_release( p_input_thread ); - return true; - } + b_will_play = !p_input_thread->b_die && !p_input_thread->b_dead; vlc_object_release( p_input_thread ); - return false; + + return b_will_play; } void libvlc_media_player_set_rate( @@ -1111,7 +1045,6 @@ void libvlc_media_player_set_rate( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; bool b_can_rewind; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); @@ -1122,12 +1055,12 @@ void libvlc_media_player_set_rate( if( (rate < 0.0) && !b_can_rewind ) { vlc_object_release( p_input_thread ); - libvlc_exception_raise( p_e, "Rate value is invalid" ); + libvlc_exception_raise( p_e ); + libvlc_printerr( "Invalid playback rate" ); return; } - val.i_int = 1000.0f/rate; - var_Set( p_input_thread, "rate", val ); + var_SetFloat( p_input_thread, "rate", rate ); vlc_object_release( p_input_thread ); } @@ -1136,53 +1069,31 @@ float libvlc_media_player_get_rate( libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + float f_rate; bool b_can_rewind; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if( !p_input_thread ) return 0.0; /* rate < 0 indicates rewind */ - var_Get( p_input_thread, "rate", &val ); + f_rate = var_GetFloat( p_input_thread, "rate" ); b_can_rewind = var_GetBool( p_input_thread, "can-rewind" ); - if( (val.i_int < 0) && !b_can_rewind ) + /* FIXME: why are negative values forbidden ?? (rewinding) */ + if( f_rate < 0 && !b_can_rewind ) { - libvlc_exception_raise( p_e, "invalid rate" ); + vlc_object_release( p_input_thread ); return 0.0; } vlc_object_release( p_input_thread ); - return (float)1000.0f/val.i_int; + return f_rate; } -libvlc_state_t libvlc_media_player_get_state( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +libvlc_state_t libvlc_media_player_get_state( libvlc_media_player_t *p_mi ) { - input_thread_t *p_input_thread; - libvlc_state_t state = libvlc_Ended; - vlc_value_t val; - - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); - if( !p_input_thread ) - { - /* We do return the right value, no need to throw an exception */ - if( libvlc_exception_raised( p_e ) ) - libvlc_exception_clear( p_e ); - return state; - } - - var_Get( p_input_thread, "state", &val ); - state = vlc_to_libvlc_state(val.i_int); - - if( state == libvlc_Playing ) - { - float caching; - caching = var_GetFloat( p_input_thread, "cache" ); - if( caching > 0.0 && caching < 1.0 ) - state = libvlc_Buffering; - } - vlc_object_release( p_input_thread ); + lock(p_mi); + libvlc_state_t state = p_mi->state; + unlock(p_mi); return state; } @@ -1190,20 +1101,19 @@ int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi, libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + bool b_seekable; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if ( !p_input_thread ) { /* We do return the right value, no need to throw an exception */ - if( libvlc_exception_raised( p_e ) ) - libvlc_exception_clear( p_e ); + clear_if_needed(p_e); return false; } - var_Get( p_input_thread, "can-seek", &val ); + b_seekable = var_GetBool( p_input_thread, "can-seek" ); vlc_object_release( p_input_thread ); - return val.b_bool; + return b_seekable; } /* internal function, used by audio, video */ @@ -1213,6 +1123,8 @@ libvlc_track_description_t * libvlc_exception_t *p_e ) { input_thread_t *p_input = libvlc_get_input_thread( p_mi, p_e ); + libvlc_track_description_t *p_track_description = NULL, + *p_actual, *p_previous; if( !p_input ) return NULL; @@ -1220,19 +1132,17 @@ libvlc_track_description_t * vlc_value_t val_list, text_list; var_Change( p_input, psz_variable, VLC_VAR_GETLIST, &val_list, &text_list); - if( val_list.p_list->i_count <= 0 ) /* no tracks */ - return NULL; + /* no tracks */ + if( val_list.p_list->i_count <= 0 ) + goto end; - libvlc_track_description_t *p_track_description, *p_actual, *p_previous; p_track_description = ( libvlc_track_description_t * ) malloc( sizeof( libvlc_track_description_t ) ); if ( !p_track_description ) { - var_Change( p_input, psz_variable, VLC_VAR_FREELIST, - &val_list, &text_list); - vlc_object_release( p_input ); - libvlc_exception_raise( p_e, "no enough memory" ); - return NULL; + libvlc_exception_raise( p_e ); + libvlc_printerr( "Not enough memory" ); + goto end; } p_actual = p_track_description; p_previous = NULL; @@ -1245,11 +1155,9 @@ libvlc_track_description_t * if ( !p_actual ) { libvlc_track_description_release( p_track_description ); - var_Change( p_input, psz_variable, VLC_VAR_FREELIST, - &val_list, &text_list); - vlc_object_release( p_input ); - libvlc_exception_raise( p_e, "no enough memory" ); - return NULL; + libvlc_exception_raise( p_e ); + libvlc_printerr( "Not enough memory" ); + goto end; } } p_actual->i_id = val_list.p_list->p_values[i].i_int; @@ -1260,7 +1168,9 @@ libvlc_track_description_t * p_previous = p_actual; p_actual = NULL; } - var_Change( p_input, psz_variable, VLC_VAR_FREELIST, &val_list, &text_list); + +end: + var_FreeList( &val_list, &text_list ); vlc_object_release( p_input ); return p_track_description; @@ -1284,18 +1194,32 @@ int libvlc_media_player_can_pause( libvlc_media_player_t *p_mi, libvlc_exception_t *p_e ) { input_thread_t *p_input_thread; - vlc_value_t val; + bool b_can_pause; p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); if ( !p_input_thread ) { /* We do return the right value, no need to throw an exception */ - if( libvlc_exception_raised( p_e ) ) - libvlc_exception_clear( p_e ); + clear_if_needed(p_e); return false; } - var_Get( p_input_thread, "can-pause", &val ); + b_can_pause = var_GetBool( p_input_thread, "can-pause" ); vlc_object_release( p_input_thread ); - return val.b_bool; + return b_can_pause; +} + +void libvlc_media_player_next_frame( libvlc_media_player_t *p_mi, libvlc_exception_t *p_e ) +{ + input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + if( p_input_thread != NULL ) + { + var_TriggerCallback( p_input_thread, "frame-next" ); + vlc_object_release( p_input_thread ); + } + else + { + libvlc_exception_raise( p_e ); + libvlc_printerr( "No active input" ); + } }