X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fcontrol%2Fmedia_player.c;h=86be29dc93c7a89dcb74c43ba7ac431856d980a2;hb=d34728306e774ee27a195155d55979aaace3b6eb;hp=ad17ea048437fdcc9ad7d761676afba6076ec3f8;hpb=1ef06cd3b06cdfd3fc55a19da3beb6f8a7cd0a83;p=vlc diff --git a/src/control/media_player.c b/src/control/media_player.c index ad17ea0484..86be29dc93 100644 --- a/src/control/media_player.c +++ b/src/control/media_player.c @@ -67,7 +67,7 @@ static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ); #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) { - libvlc_event_manager_register_event_type(mp->p_event_manager, type, NULL); + libvlc_event_manager_register_event_type(mp->p_event_manager, type); } static inline void lock(libvlc_media_player_t *mp) @@ -80,12 +80,6 @@ static inline void unlock(libvlc_media_player_t *mp) vlc_mutex_unlock(&mp->object_lock); } -static inline void clear_if_needed(libvlc_exception_t *e) -{ - if (libvlc_exception_raised(e)) - libvlc_exception_clear(e); -} - /* * Release the associated input thread. * @@ -117,10 +111,6 @@ static void release_input_thread( libvlc_media_player_t *p_mi, bool b_input_abor /* 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 ); p_mi->p_input_thread = NULL; @@ -132,27 +122,46 @@ static void release_input_thread( libvlc_media_player_t *p_mi, bool b_input_abor * * Function will lock the object. */ -input_thread_t *libvlc_get_input_thread( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +input_thread_t *libvlc_get_input_thread( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; - if( !p_mi ) RAISENULL( "Media Instance is NULL" ); + assert( p_mi ); lock(p_mi); + p_input_thread = p_mi->p_input_thread; + if( p_input_thread ) + vlc_object_hold( p_input_thread ); + unlock(p_mi); - if( !p_mi->p_input_thread ) - { + 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); - RAISENULL( "Input is NULL" ); - } - p_input_thread = p_mi->p_input_thread; - vlc_object_hold( p_input_thread ); - unlock(p_mi); + if (media) { + // Also set the state of the corresponding media + // This is strictly for convenience. + libvlc_media_set_state(media, state); - return p_input_thread; + libvlc_media_release(media); + } } static int @@ -166,7 +175,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; @@ -185,7 +193,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; @@ -240,7 +247,7 @@ 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_ABORT ) @@ -248,7 +255,7 @@ input_event_changed( vlc_object_t * p_this, char const * psz_cmd, libvlc_state_t libvlc_state = libvlc_Stopped; event.type = libvlc_MediaPlayerStopped; - 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_POSITION ) @@ -265,14 +272,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 = - var_GetTime( p_input, "length" ); + from_mtime(var_GetTime( p_input, "length" )); libvlc_event_send( p_mi->p_event_manager, &event ); } @@ -318,36 +325,48 @@ static void libvlc_media_player_destroy( libvlc_media_player_t * ); * - When attempting to destroy the object the lock is also held. **************************************************************************/ libvlc_media_player_t * -libvlc_media_player_new( libvlc_instance_t *instance, libvlc_exception_t *e ) +libvlc_media_player_new( libvlc_instance_t *instance ) { libvlc_media_player_t * mp; assert(instance); - mp = malloc(sizeof(libvlc_media_player_t)); - if (!mp) + mp = vlc_object_create (instance->p_libvlc_int, sizeof(*mp)); + if (unlikely(mp == NULL)) { - libvlc_exception_raise(e); libvlc_printerr("Not enough memory"); return NULL; } + vlc_object_attach (mp, mp->p_libvlc); + + /* Drawable */ + var_Create (mp, "drawable-xid", VLC_VAR_INTEGER); +#ifdef WIN32 + var_Create (mp, "drawable-hwnd", VLC_VAR_ADDRESS); +#endif +#ifdef __APPLE__ + var_Create (mp, "drawable-agl", VLC_VAR_INTEGER); + var_Create (mp, "drawable-nsobject", VLC_VAR_ADDRESS); +#endif + + /* Drawable input methods */ + var_Create (mp, "keyboard-events", VLC_VAR_BOOL); + var_SetBool (mp, "keyboard-events", true); + var_Create (mp, "mouse-events", VLC_VAR_BOOL); + mp->p_md = NULL; - mp->drawable.agl = 0; - mp->drawable.xid = 0; - mp->drawable.hwnd = NULL; - mp->drawable.nsobject = NULL; + mp->state = libvlc_NothingSpecial; mp->p_libvlc_instance = instance; mp->p_input_thread = NULL; mp->p_input_resource = NULL; mp->i_refcount = 1; - vlc_mutex_init(&mp->object_lock); - mp->p_event_manager = libvlc_event_manager_new(mp, instance, e); - if (libvlc_exception_raised(e)) + mp->p_event_manager = libvlc_event_manager_new(mp, instance); + if (unlikely(mp->p_event_manager == NULL)) { - vlc_mutex_destroy(&mp->object_lock); - free(mp); + vlc_object_release(mp); return NULL; } + vlc_mutex_init(&mp->object_lock); register_event(mp, NothingSpecial); register_event(mp, Opening); @@ -359,6 +378,7 @@ libvlc_media_player_new( libvlc_instance_t *instance, libvlc_exception_t *e ) register_event(mp, Backward); register_event(mp, EndReached); register_event(mp, EncounteredError); + register_event(mp, SeekableChanged); register_event(mp, PositionChanged); register_event(mp, TimeChanged); @@ -369,6 +389,8 @@ libvlc_media_player_new( libvlc_instance_t *instance, libvlc_exception_t *e ) /* Snapshot initialization */ register_event(mp, SnapshotTaken); + 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 @@ -376,7 +398,7 @@ libvlc_media_player_new( libvlc_instance_t *instance, libvlc_exception_t *e ) * 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); + var_AddCallback(mp->p_libvlc, "snapshot-file", snapshot_was_taken, mp); return mp; } @@ -385,13 +407,11 @@ libvlc_media_player_new( libvlc_instance_t *instance, libvlc_exception_t *e ) * Create a Media Instance object with a media descriptor. **************************************************************************/ libvlc_media_player_t * -libvlc_media_player_new_from_media( - libvlc_media_t * p_md, - libvlc_exception_t *p_e ) +libvlc_media_player_new_from_media( libvlc_media_t * p_md ) { 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 ); if( !p_mi ) return NULL; @@ -411,22 +431,27 @@ static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ) assert( p_mi ); /* Detach Callback from the main libvlc object */ - var_DelCallback( p_mi->p_libvlc_instance->p_libvlc_int, + var_DelCallback( p_mi->p_libvlc, "snapshot-file", snapshot_was_taken, p_mi ); - /* Release the input thread */ - release_input_thread( p_mi, true ); + /* 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); + + /* Fallback for those who don't use NDEBUG */ + if (p_mi->p_input_thread) + release_input_thread(p_mi, true); if( p_mi->p_input_resource ) { input_resource_Delete( p_mi->p_input_resource ); - p_mi->p_input_resource = NULL; + p_mi->p_input_resource = NULL; } 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 ); + vlc_object_release( p_mi ); } /************************************************************************** @@ -468,14 +493,8 @@ 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; - lock(p_mi); /* FIXME I am not sure if it is a user request or on die(eof/error) @@ -485,8 +504,7 @@ 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 ); @@ -505,18 +523,22 @@ void libvlc_media_player_set_media( p_mi->p_libvlc_instance = p_md->p_libvlc_instance; 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 ) { libvlc_media_t *p_m; - VLC_UNUSED(p_e); lock(p_mi); p_m = p_mi->p_md; @@ -530,72 +552,49 @@ 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; } /************************************************************************** * Tell media player to start playing. **************************************************************************/ -void libvlc_media_player_play( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_play( libvlc_media_player_t *p_mi ) { input_thread_t * p_input_thread; - if( (p_input_thread = libvlc_get_input_thread( p_mi, p_e )) ) + if( (p_input_thread = libvlc_get_input_thread( p_mi )) ) { /* A thread already exists, send it a play message */ input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S ); vlc_object_release( p_input_thread ); - return; + return 0; } /* Ignore previous exception */ - libvlc_exception_clear( p_e ); - lock(p_mi); if( !p_mi->p_md ) { unlock(p_mi); - libvlc_exception_raise( p_e ); libvlc_printerr( "No associated media descriptor" ); - return; + return -1; } - 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 ); - + p_mi->p_input_thread = input_Create( p_mi, + p_mi->p_md->p_input_item, NULL, + p_mi->p_input_resource ); if( !p_mi->p_input_thread ) { unlock(p_mi); - return; + libvlc_printerr( "Not enough memory" ); + return -1; } p_mi->p_input_resource = NULL; p_input_thread = p_mi->p_input_thread; - var_Create( p_input_thread, "drawable-agl", VLC_VAR_INTEGER ); - if( p_mi->drawable.agl ) - var_SetInteger( p_input_thread, "drawable-agl", p_mi->drawable.agl ); - - var_Create( p_input_thread, "drawable-xid", VLC_VAR_INTEGER ); - if( p_mi->drawable.xid ) - var_SetInteger( p_input_thread, "drawable-xid", p_mi->drawable.xid ); - - var_Create( p_input_thread, "drawable-hwnd", VLC_VAR_ADDRESS ); - if( p_mi->drawable.hwnd != NULL ) - 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_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 ); @@ -607,25 +606,25 @@ void libvlc_media_player_play( libvlc_media_player_t *p_mi, } unlock(p_mi); + return 0; } /************************************************************************** * Pause. **************************************************************************/ -void libvlc_media_player_pause( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +void libvlc_media_player_pause( libvlc_media_player_t *p_mi ) { - input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi, p_e ); + input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi ); if( !p_input_thread ) return; - 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_Buffering ) { - if( libvlc_media_player_can_pause( p_mi, p_e ) ) + if( libvlc_media_player_can_pause( p_mi ) ) 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 ); @@ -638,49 +637,48 @@ 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 ); + 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 || - state == libvlc_Buffering ) + 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, - * buffering or paused states */ - libvlc_media_set_state( p_mi->p_md, libvlc_Stopped, 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 ); } - - lock(p_mi); - release_input_thread( p_mi, true ); /* This will stop the input thread */ - unlock(p_mi); } /************************************************************************** * set_nsobject **************************************************************************/ void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi, - void * drawable, - libvlc_exception_t *p_e ) + void * drawable ) { - (void) p_e; - p_mi->drawable.nsobject = drawable; + assert (p_mi != NULL); +#ifdef __APPLE__ + var_SetAddress (p_mi, "drawable-nsobject", drawable); +#else + (void) p_mi; (void)drawable; +#endif } /************************************************************************** @@ -688,18 +686,25 @@ void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi, **************************************************************************/ void * libvlc_media_player_get_nsobject( libvlc_media_player_t *p_mi ) { - return p_mi->drawable.nsobject; + assert (p_mi != NULL); +#ifdef __APPLE__ + return var_GetAddress (p_mi, "drawable-nsobject"); +#else + return NULL; +#endif } /************************************************************************** * 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; +#ifdef __APPLE__ + var_SetInteger (p_mi, "drawable-agl", drawable); +#else + (void) p_mi; (void)drawable; +#endif } /************************************************************************** @@ -707,18 +712,22 @@ void libvlc_media_player_set_agl( libvlc_media_player_t *p_mi, **************************************************************************/ uint32_t libvlc_media_player_get_agl( libvlc_media_player_t *p_mi ) { - return p_mi->drawable.agl; + assert (p_mi != NULL); +#ifdef __APPLE__ + return var_GetInteger (p_mi, "drawable-agl"); +#else + return 0; +#endif } /************************************************************************** * 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; + assert (p_mi != NULL); + var_SetInteger (p_mi, "drawable-xid", drawable); } /************************************************************************** @@ -726,18 +735,21 @@ void libvlc_media_player_set_xwindow( libvlc_media_player_t *p_mi, **************************************************************************/ uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t *p_mi ) { - return p_mi->drawable.xid; + return var_GetInteger (p_mi, "drawable-xid"); } /************************************************************************** * 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; + assert (p_mi != NULL); +#ifdef WIN32 + var_SetAddress (p_mi, "drawable-hwnd", drawable); +#else + (void) p_mi; (void) drawable; +#endif } /************************************************************************** @@ -745,68 +757,66 @@ void libvlc_media_player_set_hwnd( libvlc_media_player_t *p_mi, **************************************************************************/ void *libvlc_media_player_get_hwnd( libvlc_media_player_t *p_mi ) { - return p_mi->drawable.hwnd; + assert (p_mi != NULL); +#ifdef WIN32 + return var_GetAddress (p_mi, "drawable-hwnd"); +#else + return NULL; +#endif } /************************************************************************** * Getters for stream information **************************************************************************/ libvlc_time_t libvlc_media_player_get_length( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) + libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; libvlc_time_t i_time; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; - i_time = var_GetTime( p_input_thread, "length" ); + i_time = from_mtime(var_GetTime( p_input_thread, "length" )); vlc_object_release( p_input_thread ); - return (i_time+500LL)/1000LL; + return i_time; } -libvlc_time_t libvlc_media_player_get_time( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +libvlc_time_t libvlc_media_player_get_time( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; libvlc_time_t i_time; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; - i_time = var_GetTime( p_input_thread , "time" ); + i_time = from_mtime(var_GetTime( p_input_thread , "time" )); vlc_object_release( p_input_thread ); - return (i_time+500LL)/1000LL; + return i_time; } -void libvlc_media_player_set_time( - libvlc_media_player_t *p_mi, - libvlc_time_t i_time, - libvlc_exception_t *p_e ) +void libvlc_media_player_set_time( libvlc_media_player_t *p_mi, + libvlc_time_t i_time ) { input_thread_t *p_input_thread; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return; - var_SetTime( p_input_thread, "time", i_time*1000LL ); + var_SetTime( p_input_thread, "time", to_mtime(i_time) ); vlc_object_release( p_input_thread ); } -void libvlc_media_player_set_position( - libvlc_media_player_t *p_mi, - float position, - libvlc_exception_t *p_e ) +void libvlc_media_player_set_position( libvlc_media_player_t *p_mi, + float position ) { input_thread_t *p_input_thread; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return; @@ -814,14 +824,12 @@ void libvlc_media_player_set_position( vlc_object_release( p_input_thread ); } -float libvlc_media_player_get_position( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +float libvlc_media_player_get_position( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; float f_position; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1.0; @@ -831,14 +839,12 @@ float libvlc_media_player_get_position( return f_position; } -void libvlc_media_player_set_chapter( - libvlc_media_player_t *p_mi, - int chapter, - libvlc_exception_t *p_e ) +void libvlc_media_player_set_chapter( libvlc_media_player_t *p_mi, + int chapter ) { input_thread_t *p_input_thread; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return; @@ -846,14 +852,12 @@ void libvlc_media_player_set_chapter( vlc_object_release( p_input_thread ); } -int libvlc_media_player_get_chapter( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_get_chapter( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; int i_chapter; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; @@ -863,14 +867,12 @@ int libvlc_media_player_get_chapter( return i_chapter; } -int libvlc_media_player_get_chapter_count( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_get_chapter_count( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; vlc_value_t val; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; @@ -882,13 +884,12 @@ int libvlc_media_player_get_chapter_count( int libvlc_media_player_get_chapter_count_for_title( libvlc_media_player_t *p_mi, - int i_title, - libvlc_exception_t *p_e ) + int i_title ) { input_thread_t *p_input_thread; vlc_value_t val; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; @@ -905,14 +906,12 @@ int libvlc_media_player_get_chapter_count_for_title( return val.i_int; } -void libvlc_media_player_set_title( - libvlc_media_player_t *p_mi, - int i_title, - libvlc_exception_t *p_e ) +void libvlc_media_player_set_title( libvlc_media_player_t *p_mi, + int i_title ) { input_thread_t *p_input_thread; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return; @@ -926,14 +925,12 @@ void libvlc_media_player_set_title( libvlc_event_send( p_mi->p_event_manager, &event ); } -int libvlc_media_player_get_title( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_get_title( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; int i_title; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; @@ -943,14 +940,12 @@ int libvlc_media_player_get_title( return i_title; } -int libvlc_media_player_get_title_count( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_get_title_count( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; vlc_value_t val; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return -1; @@ -960,13 +955,11 @@ int libvlc_media_player_get_title_count( return val.i_int; } -void libvlc_media_player_next_chapter( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +void libvlc_media_player_next_chapter( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return; @@ -977,13 +970,11 @@ void libvlc_media_player_next_chapter( vlc_object_release( p_input_thread ); } -void libvlc_media_player_previous_chapter( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +void libvlc_media_player_previous_chapter( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return; @@ -994,11 +985,9 @@ void libvlc_media_player_previous_chapter( vlc_object_release( p_input_thread ); } -float libvlc_media_player_get_fps( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e) +float libvlc_media_player_get_fps( libvlc_media_player_t *p_mi ) { - input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi ); double f_fps = 0.0; if( p_input_thread ) @@ -1010,112 +999,81 @@ float libvlc_media_player_get_fps( return f_fps; } -int libvlc_media_player_will_play( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e) +int libvlc_media_player_will_play( libvlc_media_player_t *p_mi ) { + bool b_will_play; input_thread_t *p_input_thread = - libvlc_get_input_thread ( p_mi, p_e); + libvlc_get_input_thread ( p_mi ); 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( - libvlc_media_player_t *p_mi, - float rate, - libvlc_exception_t *p_e ) +int libvlc_media_player_set_rate( libvlc_media_player_t *p_mi, float rate ) { input_thread_t *p_input_thread; bool b_can_rewind; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) - return; + return -1; b_can_rewind = var_GetBool( p_input_thread, "can-rewind" ); if( (rate < 0.0) && !b_can_rewind ) { vlc_object_release( p_input_thread ); - libvlc_exception_raise( p_e ); libvlc_printerr( "Invalid playback rate" ); - return; + return -1; } - var_SetInteger( p_input_thread, "rate", 1000.0f/rate ); + var_SetFloat( p_input_thread, "rate", rate ); vlc_object_release( p_input_thread ); + return 0; } -float libvlc_media_player_get_rate( - libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +float libvlc_media_player_get_rate( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; - int i_rate; + float f_rate; bool b_can_rewind; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if( !p_input_thread ) return 0.0; /* rate < 0 indicates rewind */ - i_rate = var_GetInteger( p_input_thread, "rate" ); + f_rate = var_GetFloat( p_input_thread, "rate" ); b_can_rewind = var_GetBool( p_input_thread, "can-rewind" ); - if( i_rate < 0 && !b_can_rewind ) + /* FIXME: why are negative values forbidden ?? (rewinding) */ + if( f_rate < 0 && !b_can_rewind ) { vlc_object_release( p_input_thread ); return 0.0; } vlc_object_release( p_input_thread ); - return (float)1000.0f/i_rate; + 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; - - 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 */ - clear_if_needed(p_e); - return state; - } - - state = libvlc_media_get_state( p_mi->p_md, NULL ); - 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; } -int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; bool b_seekable; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if ( !p_input_thread ) - { - /* We do return the right value, no need to throw an exception */ - clear_if_needed(p_e); return false; - } b_seekable = var_GetBool( p_input_thread, "can-seek" ); vlc_object_release( p_input_thread ); @@ -1125,10 +1083,9 @@ int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi, /* internal function, used by audio, video */ libvlc_track_description_t * libvlc_get_track_description( libvlc_media_player_t *p_mi, - const char *psz_variable, - libvlc_exception_t *p_e ) + const char *psz_variable ) { - input_thread_t *p_input = libvlc_get_input_thread( p_mi, p_e ); + input_thread_t *p_input = libvlc_get_input_thread( p_mi ); libvlc_track_description_t *p_track_description = NULL, *p_actual, *p_previous; @@ -1146,7 +1103,6 @@ libvlc_track_description_t * malloc( sizeof( libvlc_track_description_t ) ); if ( !p_track_description ) { - libvlc_exception_raise( p_e ); libvlc_printerr( "Not enough memory" ); goto end; } @@ -1161,7 +1117,6 @@ libvlc_track_description_t * if ( !p_actual ) { libvlc_track_description_release( p_track_description ); - libvlc_exception_raise( p_e ); libvlc_printerr( "Not enough memory" ); goto end; } @@ -1196,36 +1151,26 @@ void libvlc_track_description_release( libvlc_track_description_t *p_td ) } } -int libvlc_media_player_can_pause( libvlc_media_player_t *p_mi, - libvlc_exception_t *p_e ) +int libvlc_media_player_can_pause( libvlc_media_player_t *p_mi ) { input_thread_t *p_input_thread; bool b_can_pause; - p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + p_input_thread = libvlc_get_input_thread ( p_mi ); if ( !p_input_thread ) - { - /* We do return the right value, no need to throw an exception */ - clear_if_needed(p_e); return false; - } b_can_pause = var_GetBool( p_input_thread, "can-pause" ); vlc_object_release( p_input_thread ); return b_can_pause; } -void libvlc_media_player_next_frame( libvlc_media_player_t *p_mi, libvlc_exception_t *p_e ) +void libvlc_media_player_next_frame( libvlc_media_player_t *p_mi ) { - input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi, p_e ); + input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi ); 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" ); - } }