X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fcontrol%2Fmedia_list.c;h=8dc7e0c6ae6a585cb7d24d265e1d1888f4556d26;hb=a776627390f18b77c44581d60ad73058d80ac971;hp=be1b0d2ab945eb736877e74d684ab666c926e0ea;hpb=6e3263c3d6fe0e9bfed279f8e10fca0d20df10a6;p=vlc diff --git a/src/control/media_list.c b/src/control/media_list.c index be1b0d2ab9..8dc7e0c6ae 100644 --- a/src/control/media_list.c +++ b/src/control/media_list.c @@ -21,10 +21,36 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ -#include "libvlc_internal.h" -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + #include -#include "vlc_arrays.h" + +#include +#include +#include +#include + +#include +#include + +#include "libvlc_internal.h" +#include "media_internal.h" // libvlc_media_new_from_input_item() +#include "media_list_internal.h" + +typedef enum EventPlaceInTime { + EventWillHappen, + EventDidHappen +} EventPlaceInTime; + +//#define DEBUG_MEDIA_LIST + +#ifdef DEBUG_MEDIA_LIST +# define trace( fmt, ... ) printf( "%s(): " fmt, __FUNCTION__, ##__VA_ARGS__ ) +#else +# define trace( ... ) +#endif /* * Private functions @@ -39,15 +65,26 @@ **************************************************************************/ static void notify_item_addition( libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_md, - int index ) + libvlc_media_t * p_md, + int index, + EventPlaceInTime event_status ) { libvlc_event_t event; /* Construct the event */ - event.type = libvlc_MediaListItemAdded; - event.u.media_list_item_added.item = p_md; - event.u.media_list_item_added.index = index; + if( event_status == EventDidHappen ) + { + trace("item was added at index %d\n", index); + event.type = libvlc_MediaListItemAdded; + event.u.media_list_item_added.item = p_md; + event.u.media_list_item_added.index = index; + } + else /* if( event_status == EventWillHappen ) */ + { + event.type = libvlc_MediaListWillAddItem; + event.u.media_list_will_add_item.item = p_md; + event.u.media_list_will_add_item.index = index; + } /* Send the event */ libvlc_event_send( p_mlist->p_event_manager, &event ); @@ -60,178 +97,44 @@ notify_item_addition( libvlc_media_list_t * p_mlist, **************************************************************************/ static void notify_item_deletion( libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_md, - int index ) + libvlc_media_t * p_md, + int index, + EventPlaceInTime event_status ) { libvlc_event_t event; /* Construct the event */ - event.type = libvlc_MediaListItemDeleted; - event.u.media_list_item_deleted.item = p_md; - event.u.media_list_item_deleted.index = index; - - /* Send the event */ - libvlc_event_send( p_mlist->p_event_manager, &event ); -} - -/************************************************************************** - * media_descriptor_changed (private) (libvlc Event Callback ) - * - * An item has changed. - **************************************************************************/ -static void -media_descriptor_changed( const libvlc_event_t * p_event, void * user_data ) -{ - libvlc_media_list_t * p_mlist = user_data; - libvlc_media_descriptor_t * p_md = p_event->p_obj; - libvlc_event_t event; - - /* Construct the new media list event */ - event.type = libvlc_MediaListItemChanged; - event.u.media_list_item_changed.item = p_md; - - /* XXX: this is not good, but there is a solution in the pipeline */ - event.u.media_list_item_changed.index = - libvlc_media_list_index_of_item( p_mlist, p_md, NULL ); - - /* Send the event */ - libvlc_event_send( p_mlist->p_event_manager, &event ); -} - -/************************************************************************** - * media_descriptor_subitem_added (private) (libvlc Event Callback ) - * - * An item (which is a playlist) has gained sub child. - **************************************************************************/ -static void -media_descriptor_subitem_added( const libvlc_event_t * p_event, void * user_data ) -{ - libvlc_media_list_t * p_mlist = user_data; - libvlc_media_descriptor_t * p_new_md; - - p_new_md = p_event->u.media_descriptor_subitem_added.new_child; - - /* For now, just add the new item to this media list */ - libvlc_media_list_add_media_descriptor( p_mlist, p_new_md, NULL ); -} - -/************************************************************************** - * install_media_descriptor_observer (private) - * - * Do the appropriate action when an item is deleted. - **************************************************************************/ -static void -install_media_descriptor_observer( libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_md ) -{ - libvlc_event_attach( p_md->p_event_manager, - libvlc_MediaDescriptorMetaChanged, - media_descriptor_changed, - p_mlist, NULL ); - libvlc_event_attach( p_md->p_event_manager, - libvlc_MediaDescriptorSubItemAdded, - media_descriptor_subitem_added, - p_mlist, NULL ); -} - -/************************************************************************** - * uninstall_media_descriptor_observer (private) - * - * Do the appropriate action when an item is deleted. - **************************************************************************/ -static void -uninstall_media_descriptor_observer( libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_md ) -{ - libvlc_event_detach( p_md->p_event_manager, - libvlc_MediaDescriptorMetaChanged, - media_descriptor_changed, - p_mlist, NULL ); - libvlc_event_detach( p_md->p_event_manager, - libvlc_MediaDescriptorSubItemAdded, - media_descriptor_subitem_added, - p_mlist, NULL ); -} - -/************************************************************************** - * dynamic_list_propose_item (private) (Event Callback) - * - * This is called if the dynamic sublist's data provider adds a new item. - **************************************************************************/ -static void -dynamic_list_propose_item( const libvlc_event_t * p_event, void * p_user_data ) -{ - libvlc_media_list_t * p_submlist = p_user_data; - libvlc_media_descriptor_t * p_md = p_event->u.media_list_item_added.item; - - //libvlc_media_descriptor_lock( p_md ); - if( libvlc_tag_query_match( p_submlist->p_query, p_md, NULL ) ) + if( event_status == EventDidHappen ) { - libvlc_media_list_lock( p_submlist ); - libvlc_media_list_add_media_descriptor( p_submlist, p_md, NULL ); - libvlc_media_list_unlock( p_submlist ); + trace("item at index %d was deleted\n", index); + event.type = libvlc_MediaListItemDeleted; + event.u.media_list_item_deleted.item = p_md; + event.u.media_list_item_deleted.index = index; } - //libvlc_media_descriptor_unlock( p_md ); -} - -/************************************************************************** - * dynamic_list_remove_item (private) (Event Callback) - * - * This is called if the dynamic sublist's data provider adds a new item. - **************************************************************************/ -static void -dynamic_list_remove_item( const libvlc_event_t * p_event, void * p_user_data ) -{ - libvlc_media_list_t * p_submlist = p_user_data; - libvlc_media_descriptor_t * p_md = p_event->u.media_list_item_deleted.item; - - //libvlc_media_descriptor_lock( p_md ); - if( libvlc_tag_query_match( p_submlist->p_query, p_md, NULL ) ) + else /* if( event_status == EventWillHappen ) */ { - int i; - libvlc_media_list_lock( p_submlist ); - i = libvlc_media_list_index_of_item( p_submlist, p_md, NULL ); - if ( i < 0 ) - { - /* We've missed one item addition, that could happen especially - * if we add item in a threaded maner, so we just ignore */ - libvlc_media_list_unlock( p_submlist ); - //libvlc_media_descriptor_unlock( p_md ); - return; - } - libvlc_media_list_remove_index( p_submlist, i, NULL ); - libvlc_media_list_unlock( p_submlist ); + event.type = libvlc_MediaListWillDeleteItem; + event.u.media_list_will_delete_item.item = p_md; + event.u.media_list_will_delete_item.index = index; } - //libvlc_media_descriptor_unlock( p_md ); + + /* Send the event */ + libvlc_event_send( p_mlist->p_event_manager, &event ); } /************************************************************************** - * dynamic_list_change_item (private) (Event Callback) - * - * This is called if the dynamic sublist's data provider adds a new item. + * static mlist_is_writable (private) **************************************************************************/ -static void -dynamic_list_change_item( const libvlc_event_t * p_event , void * p_user_data) +static inline +bool mlist_is_writable( libvlc_media_list_t *p_mlist ) { - libvlc_media_list_t * p_submlist = p_user_data; - libvlc_media_descriptor_t * p_md = p_event->u.media_list_item_changed.item; - int index; - - libvlc_media_list_lock( p_submlist ); - - index = libvlc_media_list_index_of_item( p_submlist, p_md, NULL ); - if( index < 0 ) + if( !p_mlist||p_mlist->b_read_only ) { - libvlc_media_list_unlock( p_submlist ); - return; /* Not found, no prob, just ignore */ + /* We are read-only from user side */ + libvlc_printerr( "Attempt to write a read-only media list" ); + return false; } - - //libvlc_media_descriptor_lock( p_md ); - if( !libvlc_tag_query_match( p_submlist->p_query, p_md, NULL ) ) - libvlc_media_list_remove_index( p_submlist, index, NULL ); - //libvlc_media_descriptor_unlock( p_md ); - - libvlc_media_list_unlock( p_submlist ); + return true; } /* @@ -244,38 +147,44 @@ dynamic_list_change_item( const libvlc_event_t * p_event , void * p_user_data) * Init an object. **************************************************************************/ libvlc_media_list_t * -libvlc_media_list_new( libvlc_instance_t * p_inst, - libvlc_exception_t * p_e ) +libvlc_media_list_new( libvlc_instance_t * p_inst ) { libvlc_media_list_t * p_mlist; p_mlist = malloc(sizeof(libvlc_media_list_t)); - - if( !p_mlist ) + if( unlikely(p_mlist == NULL) ) + { + libvlc_printerr( "Not enough memory" ); return NULL; - + } + p_mlist->p_libvlc_instance = p_inst; - p_mlist->p_event_manager = libvlc_event_manager_new( p_mlist, p_inst, p_e ); + p_mlist->p_event_manager = libvlc_event_manager_new( p_mlist, p_inst ); + if( unlikely(p_mlist->p_event_manager == NULL) ) + { + free(p_mlist); + return NULL; + } + + /* Code for that one should be handled in flat_media_list.c */ + p_mlist->p_flat_mlist = NULL; + p_mlist->b_read_only = false; libvlc_event_manager_register_event_type( p_mlist->p_event_manager, - libvlc_MediaListItemAdded, p_e ); + libvlc_MediaListItemAdded ); + libvlc_event_manager_register_event_type( p_mlist->p_event_manager, + libvlc_MediaListWillAddItem ); libvlc_event_manager_register_event_type( p_mlist->p_event_manager, - libvlc_MediaListItemChanged, p_e ); + libvlc_MediaListItemDeleted ); libvlc_event_manager_register_event_type( p_mlist->p_event_manager, - libvlc_MediaListItemDeleted, p_e ); + libvlc_MediaListWillDeleteItem ); - if( libvlc_exception_raised( p_e ) ) - { - libvlc_event_manager_release( p_mlist->p_event_manager ); - free( p_mlist ); - return NULL; - } + vlc_mutex_init( &p_mlist->object_lock ); + vlc_mutex_init( &p_mlist->refcount_lock ); // FIXME: spinlock? - vlc_mutex_init( p_inst->p_libvlc_int, &p_mlist->object_lock ); - - ARRAY_INIT(p_mlist->items); + vlc_array_init( &p_mlist->items ); p_mlist->i_refcount = 1; - p_mlist->p_media_provider = NULL; + p_mlist->p_md = NULL; return p_mlist; } @@ -287,33 +196,36 @@ libvlc_media_list_new( libvlc_instance_t * p_inst, **************************************************************************/ void libvlc_media_list_release( libvlc_media_list_t * p_mlist ) { - libvlc_media_descriptor_t * p_md; + libvlc_media_t * p_md; + int i; - vlc_mutex_lock( &p_mlist->object_lock ); + vlc_mutex_lock( &p_mlist->refcount_lock ); p_mlist->i_refcount--; if( p_mlist->i_refcount > 0 ) { - vlc_mutex_unlock( &p_mlist->object_lock ); + vlc_mutex_unlock( &p_mlist->refcount_lock ); return; } - vlc_mutex_unlock( &p_mlist->object_lock ); + vlc_mutex_unlock( &p_mlist->refcount_lock ); /* Refcount null, time to free */ - if( p_mlist->p_media_provider ) - libvlc_media_list_release( p_mlist->p_media_provider ); - - if( p_mlist->p_query ) - libvlc_tag_query_release( p_mlist->p_query ); libvlc_event_manager_release( p_mlist->p_event_manager ); - FOREACH_ARRAY( p_md, p_mlist->items ) - uninstall_media_descriptor_observer( p_mlist, p_md ); - libvlc_media_descriptor_release( p_md ); - FOREACH_END() - + libvlc_media_release( p_mlist->p_md ); + + for ( i = 0; i < vlc_array_count( &p_mlist->items ); i++ ) + { + p_md = vlc_array_item_at_index( &p_mlist->items, i ); + libvlc_media_release( p_md ); + } + + vlc_mutex_destroy( &p_mlist->object_lock ); + vlc_array_clear( &p_mlist->items ); + free( p_mlist ); } + /************************************************************************** * libvlc_media_list_retain (Public) * @@ -321,113 +233,240 @@ void libvlc_media_list_release( libvlc_media_list_t * p_mlist ) **************************************************************************/ void libvlc_media_list_retain( libvlc_media_list_t * p_mlist ) { - vlc_mutex_lock( &p_mlist->object_lock ); + vlc_mutex_lock( &p_mlist->refcount_lock ); p_mlist->i_refcount++; + vlc_mutex_unlock( &p_mlist->refcount_lock ); +} + + +/************************************************************************** + * add_file_content (Public) + **************************************************************************/ +int +libvlc_media_list_add_file_content( libvlc_media_list_t * p_mlist, + const char * psz_uri ) +{ + input_item_t * p_input_item; + libvlc_media_t * p_md; + + p_input_item = input_item_NewExt( + p_mlist->p_libvlc_instance->p_libvlc_int, psz_uri, + _("Media Library"), 0, NULL, 0, -1 ); + + if( !p_input_item ) + { + libvlc_printerr( "Not enough memory" ); + return -1; + } + + p_md = libvlc_media_new_from_input_item( p_mlist->p_libvlc_instance, + p_input_item ); + if( !p_md ) + { + vlc_gc_decref( p_input_item ); + return -1; + } + + if( libvlc_media_list_add_media( p_mlist, p_md ) ) + { +#warning Missing error handling! + /* printerr and leaks */ + return -1; + } + + input_Read( p_mlist->p_libvlc_instance->p_libvlc_int, p_input_item ); + return 0; +} + +/************************************************************************** + * set_media (Public) + **************************************************************************/ +void libvlc_media_list_set_media( libvlc_media_list_t * p_mlist, + libvlc_media_t * p_md ) + +{ + vlc_mutex_lock( &p_mlist->object_lock ); + libvlc_media_release( p_mlist->p_md ); + libvlc_media_retain( p_md ); + p_mlist->p_md = p_md; vlc_mutex_unlock( &p_mlist->object_lock ); } +/************************************************************************** + * media (Public) + * + * If this media_list comes is a media's subitems, + * This holds the corresponding media. + * This md is also seen as the information holder for the media_list. + * Indeed a media_list can have meta information through this + * media. + **************************************************************************/ +libvlc_media_t * +libvlc_media_list_media( libvlc_media_list_t * p_mlist ) +{ + libvlc_media_t *p_md; + + vlc_mutex_lock( &p_mlist->object_lock ); + p_md = p_mlist->p_md; + if( p_md ) + libvlc_media_retain( p_md ); + vlc_mutex_unlock( &p_mlist->object_lock ); + + return p_md; +} + /************************************************************************** * libvlc_media_list_count (Public) * - * Lock should be hold when entering. + * Lock should be held when entering. **************************************************************************/ -int libvlc_media_list_count( libvlc_media_list_t * p_mlist, - libvlc_exception_t * p_e ) +int libvlc_media_list_count( libvlc_media_list_t * p_mlist ) { - (void)p_e; - return p_mlist->items.i_size; + return vlc_array_count( &p_mlist->items ); } /************************************************************************** - * libvlc_media_list_add_media_descriptor (Public) + * libvlc_media_list_add_media (Public) * - * Lock should be hold when entering. + * Lock should be held when entering. **************************************************************************/ -void libvlc_media_list_add_media_descriptor( - libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_md, - libvlc_exception_t * p_e ) +int libvlc_media_list_add_media( libvlc_media_list_t * p_mlist, + libvlc_media_t * p_md ) { - (void)p_e; - libvlc_media_descriptor_retain( p_md ); - ARRAY_APPEND( p_mlist->items, p_md ); - notify_item_addition( p_mlist, p_md, p_mlist->items.i_size-1 ); - install_media_descriptor_observer( p_mlist, p_md ); + if( !mlist_is_writable(p_mlist) ) + return -1; + _libvlc_media_list_add_media( p_mlist, p_md ); + return 0; +} + +/* LibVLC internal version */ +void _libvlc_media_list_add_media( libvlc_media_list_t * p_mlist, + libvlc_media_t * p_md ) +{ + libvlc_media_retain( p_md ); + + notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items ), + EventWillHappen ); + vlc_array_append( &p_mlist->items, p_md ); + notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items )-1, + EventDidHappen ); } /************************************************************************** - * libvlc_media_list_insert_media_descriptor (Public) + * libvlc_media_list_insert_media (Public) * * Lock should be hold when entering. **************************************************************************/ -void libvlc_media_list_insert_media_descriptor( +int libvlc_media_list_insert_media( libvlc_media_list_t * p_mlist, + libvlc_media_t * p_md, + int index ) +{ + if( !mlist_is_writable(p_mlist) ) + return -1; + _libvlc_media_list_insert_media( p_mlist, p_md, index ); + return 0; +} + +/* LibVLC internal version */ +void _libvlc_media_list_insert_media( libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_md, - int index, - libvlc_exception_t * p_e ) + libvlc_media_t * p_md, + int index ) { - (void)p_e; - libvlc_media_descriptor_retain( p_md ); + libvlc_media_retain( p_md ); - ARRAY_INSERT( p_mlist->items, p_md, index); - notify_item_addition( p_mlist, p_md, index ); - install_media_descriptor_observer( p_mlist, p_md ); + notify_item_addition( p_mlist, p_md, index, EventWillHappen ); + vlc_array_insert( &p_mlist->items, p_md, index ); + notify_item_addition( p_mlist, p_md, index, EventDidHappen ); } /************************************************************************** * libvlc_media_list_remove_index (Public) * - * Lock should be hold when entering. + * Lock should be held when entering. **************************************************************************/ -void libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist, - int index, - libvlc_exception_t * p_e ) +int libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist, + int index ) +{ + if( !mlist_is_writable(p_mlist) ) + return -1; + return _libvlc_media_list_remove_index( p_mlist, index ); +} + +/* LibVLC internal version */ +int _libvlc_media_list_remove_index( libvlc_media_list_t * p_mlist, + int index ) { - libvlc_media_descriptor_t * p_md; + libvlc_media_t * p_md; - p_md = ARRAY_VAL( p_mlist->items, index ); + if( index < 0 || index >= vlc_array_count( &p_mlist->items )) + { + libvlc_printerr( "Index out of bounds" ); + return -1; + } - uninstall_media_descriptor_observer( p_mlist, p_md ); + p_md = vlc_array_item_at_index( &p_mlist->items, index ); - ARRAY_REMOVE( p_mlist->items, index ) - notify_item_deletion( p_mlist, p_md, index ); + notify_item_deletion( p_mlist, p_md, index, EventWillHappen ); + vlc_array_remove( &p_mlist->items, index ); + notify_item_deletion( p_mlist, p_md, index, EventDidHappen ); - libvlc_media_descriptor_release( p_md ); + libvlc_media_release( p_md ); + return 0; } /************************************************************************** * libvlc_media_list_item_at_index (Public) * - * Lock should be hold when entering. + * Lock should be held when entering. **************************************************************************/ -libvlc_media_descriptor_t * +libvlc_media_t * libvlc_media_list_item_at_index( libvlc_media_list_t * p_mlist, - int index, - libvlc_exception_t * p_e ) + int index ) { - libvlc_media_descriptor_t * p_md = ARRAY_VAL( p_mlist->items, index ); - libvlc_media_descriptor_retain( p_md ); + libvlc_media_t * p_md; + + if( index < 0 || index >= vlc_array_count( &p_mlist->items )) + { + libvlc_printerr( "Index out of bounds" ); + return NULL; + } + + p_md = vlc_array_item_at_index( &p_mlist->items, index ); + libvlc_media_retain( p_md ); return p_md; } /************************************************************************** * libvlc_media_list_index_of_item (Public) * - * Lock should be hold when entering. - * Warning: this function would return the first matching item + * Lock should be held when entering. + * Warning: this function returns the first matching item. **************************************************************************/ int libvlc_media_list_index_of_item( libvlc_media_list_t * p_mlist, - libvlc_media_descriptor_t * p_searched_md, - libvlc_exception_t * p_e ) + libvlc_media_t * p_searched_md ) { - libvlc_media_descriptor_t * p_md; - FOREACH_ARRAY( p_md, p_mlist->items ) + libvlc_media_t * p_md; + int i; + for ( i = 0; i < vlc_array_count( &p_mlist->items ); i++ ) + { + p_md = vlc_array_item_at_index( &p_mlist->items, i ); if( p_searched_md == p_md ) - return fe_idx; /* Once more, we hate macro for that */ - FOREACH_END() + return i; + } return -1; } +/************************************************************************** + * libvlc_media_list_is_readonly (Public) + * + * This indicates if this media list is read-only from a user point of view + **************************************************************************/ +int libvlc_media_list_is_readonly( libvlc_media_list_t * p_mlist ) +{ + return p_mlist->b_read_only; +} + /************************************************************************** * libvlc_media_list_lock (Public) * @@ -451,78 +490,13 @@ void libvlc_media_list_unlock( libvlc_media_list_t * p_mlist ) } - /************************************************************************** * libvlc_media_list_p_event_manager (Public) * * The p_event_manager is immutable, so you don't have to hold the lock **************************************************************************/ libvlc_event_manager_t * -libvlc_media_list_event_manager( libvlc_media_list_t * p_mlist, - libvlc_exception_t * p_e ) +libvlc_media_list_event_manager( libvlc_media_list_t * p_mlist ) { - (void)p_e; return p_mlist->p_event_manager; } - -/************************************************************************** - * libvlc_media_list_dynamic_sublist (Public) - * - * Lock should be hold when entering. - **************************************************************************/ -libvlc_media_list_t * -libvlc_media_list_dynamic_sublist( libvlc_media_list_t * p_mlist, - libvlc_tag_query_t * p_query, - libvlc_exception_t * p_e ) -{ - libvlc_media_list_t * p_submlist; - libvlc_event_manager_t * p_em; - int count, i; - - (void)p_e; - - p_submlist = libvlc_media_list_new( p_mlist->p_libvlc_instance, p_e ); - if( !p_submlist ) - { - if( !libvlc_exception_raised( p_e ) ) - libvlc_exception_raise( p_e, "Can't get the new media_list" ); - return NULL; - } - - /* We have a query */ - libvlc_tag_query_retain( p_query ); - p_submlist->p_query = p_query; - - /* We have a media provider */ - libvlc_media_list_retain( p_mlist ); - p_submlist->p_media_provider = p_mlist; - - - libvlc_media_list_lock( p_submlist ); - - count = libvlc_media_list_count( p_mlist, p_e ); - - /* This should be running in a thread, a good plan to achieve that - * move all the dynamic code to libvlc_tag_query. */ - for( i = 0; i < count; i++ ) - { - libvlc_media_descriptor_t * p_md; - p_md = libvlc_media_list_item_at_index( p_mlist, i, p_e ); - if( libvlc_tag_query_match( p_query, p_md, NULL ) ) - libvlc_media_list_add_media_descriptor( p_submlist, p_md, p_e ); - } - - /* And we will listen to its event, so we can update p_submlist - * accordingly */ - p_em = libvlc_media_list_event_manager( p_mlist, p_e ); - libvlc_event_attach( p_em, libvlc_MediaListItemAdded, - dynamic_list_propose_item, p_submlist, p_e ); - libvlc_event_attach( p_em, libvlc_MediaListItemDeleted, - dynamic_list_remove_item, p_submlist, p_e ); - libvlc_event_attach( p_em, libvlc_MediaListItemChanged, - dynamic_list_change_item, p_submlist, p_e ); - - libvlc_media_list_unlock( p_submlist ); - - return p_submlist; -}