static void services_discovery_item_added( services_discovery_t *sd, input_item_t *parent, input_item_t *p_item, const char *psz_cat ) { libvlc_media_t * p_md; libvlc_media_discoverer_t *p_mdis = sd->owner.sys; libvlc_media_list_t * p_mlist = p_mdis->p_mlist; p_md = libvlc_media_new_from_input_item( p_mdis->p_libvlc_instance, p_item ); if( parent != NULL ) { /* Flatten items list for now. TODO: tree support. */ } else /* If we have a category, that mean we have to group the items having * that category in a media_list. */ if( psz_cat ) { p_mlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, psz_cat ); if( p_mlist == kVLCDictionaryNotFound ) { libvlc_media_t * p_catmd; p_catmd = libvlc_media_new_as_node( p_mdis->p_libvlc_instance, psz_cat ); p_mlist = libvlc_media_subitems( p_catmd ); p_mlist->b_read_only = true; /* Insert the newly created mlist in our dictionary */ vlc_dictionary_insert( &p_mdis->catname_to_submedialist, psz_cat, p_mlist ); /* Insert the md into the root list */ libvlc_media_list_lock( p_mdis->p_mlist ); libvlc_media_list_internal_add_media( p_mdis->p_mlist, p_catmd ); libvlc_media_list_unlock( p_mdis->p_mlist ); /* We don't release the mlist cause the dictionary * doesn't retain the object. But we release the md. */ libvlc_media_release( p_catmd ); } } libvlc_media_list_lock( p_mlist ); libvlc_media_list_internal_add_media( p_mlist, p_md ); libvlc_media_list_unlock( p_mlist ); libvlc_media_release( p_md ); }
/************************************************************************** * libvlc_media_list_flat_view (Public) **************************************************************************/ libvlc_media_list_view_t * libvlc_media_list_flat_view( libvlc_media_list_t * p_mlist, libvlc_exception_t * p_e ) { trace("\n"); libvlc_media_list_view_t * p_mlv; struct libvlc_media_list_view_private_t * p_this_view_data; p_this_view_data = malloc(sizeof(struct libvlc_media_list_view_private_t)); vlc_array_init( &p_this_view_data->array ); p_mlv = libvlc_media_list_view_new( p_mlist, flat_media_list_view_count, flat_media_list_view_item_at_index, flat_media_list_view_children_at_index, libvlc_media_list_flat_view, flat_media_list_view_release, p_this_view_data, p_e ); libvlc_media_list_lock( p_mlist ); import_mlist_rec( p_mlv, p_mlist, p_e ); libvlc_media_list_view_set_ml_notification_callback( p_mlv, ml_item_added, ml_item_removed ); libvlc_media_list_unlock( p_mlist ); return p_mlv; }
/* Little helper */ static void import_mlist_rec( libvlc_media_list_view_t * p_mlv, libvlc_media_list_t * p_mlist, libvlc_exception_t * p_e ) { int i, count; count = libvlc_media_list_count( p_mlist, p_e ); for( i = 0; i < count; i++ ) { libvlc_media_t * p_md; libvlc_media_list_t * p_submlist; p_md = libvlc_media_list_item_at_index( p_mlist, i, p_e ); vlc_array_append( &p_mlv->p_this_view_data->array, p_md ); p_submlist = libvlc_media_subitems( p_md ); if( p_submlist ) { libvlc_media_list_lock( p_submlist ); import_mlist_rec( p_mlv, p_submlist, p_e ); libvlc_media_list_unlock( p_submlist ); libvlc_media_list_release( p_submlist ); } /* No need to release the md, as we want to retain it, as it is * stored in our array */ } }
/************************************************************************** * input_item_subitem_added (Private) (vlc event Callback) **************************************************************************/ static void input_item_subitem_added( const vlc_event_t *p_event, void * user_data ) { libvlc_media_t * p_md = user_data; libvlc_media_t * p_md_child; libvlc_media_list_t *p_subitems; libvlc_event_t event; p_md_child = libvlc_media_new_from_input_item( p_md->p_libvlc_instance, p_event->u.input_item_subitem_added.p_new_child ); /* Add this to our media list */ p_subitems = media_get_subitems( p_md, true ); if( p_subitems != NULL ) { libvlc_media_list_lock( p_subitems ); libvlc_media_list_internal_add_media( p_subitems, p_md_child ); libvlc_media_list_unlock( p_subitems ); } /* Construct the event */ event.type = libvlc_MediaSubItemAdded; event.u.media_subitem_added.new_child = p_md_child; /* Send the event */ libvlc_event_send( p_md->p_event_manager, &event ); libvlc_media_release( p_md_child ); }
/************************************************************************** * libvlc_media_list_flat_view (Public) **************************************************************************/ libvlc_media_list_view_t * libvlc_media_list_hierarchical_view( libvlc_media_list_t * p_mlist, libvlc_exception_t * p_e ) { trace("\n"); libvlc_media_list_view_t * p_mlv; p_mlv = libvlc_media_list_view_new( p_mlist, hierarch_media_list_view_count, hierarch_media_list_view_item_at_index, hierarch_media_list_view_children_at_index, libvlc_media_list_hierarchical_view, hierarch_media_list_view_release, NULL, p_e ); libvlc_media_list_lock( p_mlist ); libvlc_event_attach( p_mlv->p_mlist->p_event_manager, libvlc_MediaListItemAdded, media_list_item_added, p_mlv, NULL ); libvlc_event_attach( p_mlv->p_mlist->p_event_manager, libvlc_MediaListWillAddItem, media_list_will_add_item, p_mlv, NULL ); libvlc_event_attach( p_mlv->p_mlist->p_event_manager, libvlc_MediaListItemDeleted, media_list_item_deleted, p_mlv, NULL ); libvlc_event_attach( p_mlv->p_mlist->p_event_manager, libvlc_MediaListWillDeleteItem, media_list_will_delete_item, p_mlv, NULL ); libvlc_media_list_unlock( p_mlist ); return p_mlv; }
static void uninstall_md_listener( libvlc_media_list_view_t * p_mlv, libvlc_media_t * p_md) { libvlc_media_list_t * p_mlist; libvlc_exception_t ignored_exception; libvlc_exception_init( &ignored_exception ); libvlc_event_detach( p_md->p_event_manager, libvlc_MediaSubItemAdded, media_list_subitem_added, p_mlv, &ignored_exception ); if( libvlc_exception_raised( &ignored_exception ) ) libvlc_exception_clear( &ignored_exception ); /* We don't care if we encounter an exception */ if((p_mlist = libvlc_media_subitems( p_md ))) { libvlc_media_list_lock( p_mlist ); libvlc_event_detach( p_mlist->p_event_manager, libvlc_MediaListItemAdded, media_list_item_added, p_mlv, NULL ); libvlc_event_detach( p_mlist->p_event_manager, libvlc_MediaListItemDeleted, media_list_item_removed, p_mlv, NULL ); int i, count = libvlc_media_list_count( p_mlist, NULL ); for( i = 0; i < count; i++) { libvlc_media_t * p_submd; p_submd = libvlc_media_list_item_at_index( p_mlist,i, NULL ); uninstall_md_listener( p_mlv, p_submd ); libvlc_media_release( p_submd ); } libvlc_media_list_unlock( p_mlist ); libvlc_media_list_release( p_mlist ); } }
static void media_list_subitem_added( const libvlc_event_t * p_event, void * p_user_data ) { libvlc_media_list_t * p_mlist; libvlc_event_t added_event; libvlc_media_list_view_t * p_mlv = p_user_data; libvlc_media_t * p_submd = p_event->u.media_subitem_added.new_child; libvlc_media_t * p_md = p_event->p_obj; if((p_mlist = libvlc_media_subitems( p_md ))) { /* We have a mlist to which we're going to listen to events * thus, no need to wait for SubItemAdded events */ libvlc_event_detach( p_md->p_event_manager, libvlc_MediaSubItemAdded, media_list_subitem_added, p_mlv, NULL ); libvlc_media_list_lock( p_mlist ); libvlc_event_attach( p_mlist->p_event_manager, libvlc_MediaListItemAdded, media_list_item_added, p_mlv, NULL ); libvlc_event_attach( p_mlist->p_event_manager, libvlc_MediaListItemDeleted, media_list_item_removed, p_mlv, NULL ); libvlc_media_list_unlock( p_mlist ); libvlc_media_list_release( p_mlist ); } install_md_listener( p_mlv, p_submd ); added_event.u.media_list_item_added.item = p_submd; added_event.u.media_list_item_added.index = 0; if( p_mlv->pf_ml_item_added ) p_mlv->pf_ml_item_added( &added_event, p_mlv ); }
/* * Get lock on media list items * * @yield * @return self * @todo fixme */ static VALUE rg_lock(VALUE self) { libvlc_media_list_lock(_SELF(self)); if (rb_block_given_p()) rb_ensure(rb_yield, self, rg_unlock, self); return self; }
static void services_discovery_item_added( const vlc_event_t * p_event, void * user_data ) { input_item_t * p_item = p_event->u.services_discovery_item_added.p_new_item; const char * psz_cat = p_event->u.services_discovery_item_added.psz_category; libvlc_media_t * p_md; libvlc_media_discoverer_t * p_mdis = user_data; libvlc_media_list_t * p_mlist = p_mdis->p_mlist; p_md = libvlc_media_new_from_input_item( p_mdis->p_libvlc_instance, p_item, NULL ); /* If we have a category, that mean we have to group the items having * that category in a media_list. */ if( psz_cat ) { p_mlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, psz_cat ); if( p_mlist == kVLCDictionaryNotFound ) { libvlc_media_t * p_catmd; p_catmd = libvlc_media_new_as_node( p_mdis->p_libvlc_instance, psz_cat, NULL ); p_mlist = libvlc_media_subitems( p_catmd, NULL ); p_mlist->b_read_only = true; /* Insert the newly created mlist in our dictionary */ vlc_dictionary_insert( &p_mdis->catname_to_submedialist, psz_cat, p_mlist ); /* Insert the md into the root list */ libvlc_media_list_lock( p_mdis->p_mlist ); _libvlc_media_list_add_media( p_mdis->p_mlist, p_catmd, NULL ); libvlc_media_list_unlock( p_mdis->p_mlist ); /* We don't release the mlist cause the dictionary * doesn't retain the object. But we release the md. */ libvlc_media_release( p_catmd ); } } else { libvlc_media_list_lock( p_mlist ); _libvlc_media_list_add_media( p_mlist, p_md, NULL ); libvlc_media_list_unlock( p_mlist ); } }
int VlcPlugin::playlist_count( libvlc_exception_t *ex ) { int items_count = 0; libvlc_media_list_lock(libvlc_media_list); items_count = libvlc_media_list_count(libvlc_media_list,ex); libvlc_media_list_unlock(libvlc_media_list); return items_count; }
/************************************************************************** * services_discovery_removeall (Private) (VLC event callback) **************************************************************************/ static void services_discovery_removeall( const vlc_event_t * p_event, void * user_data ) { VLC_UNUSED(p_event); libvlc_media_discoverer_t * p_mdis = user_data; libvlc_media_list_lock( p_mdis->p_mlist ); for( int i = 0; i < libvlc_media_list_count( p_mdis->p_mlist ); i++ ) { _libvlc_media_list_remove_index( p_mdis->p_mlist, i ); } libvlc_media_list_unlock( p_mdis->p_mlist ); }
/************************************************************************** * input_item_preparse_ended (Private) (vlc event Callback) **************************************************************************/ static void input_item_preparse_ended( const vlc_event_t * p_event, void * user_data ) { VLC_UNUSED( p_event ); libvlc_media_t * p_md = user_data; libvlc_media_list_t *p_subitems = media_get_subitems( p_md, false ); if( p_subitems != NULL ) { /* notify the media list */ libvlc_media_list_lock( p_subitems ); libvlc_media_list_internal_end_reached( p_subitems ); libvlc_media_list_unlock( p_subitems ); } }
/************************************************************************** * stop (Public) **************************************************************************/ LIBVLC_API void libvlc_media_discoverer_stop( libvlc_media_discoverer_t * p_mdis ) { libvlc_media_list_t * p_mlist = p_mdis->p_mlist; libvlc_media_list_lock( p_mlist ); libvlc_media_list_internal_end_reached( p_mlist ); libvlc_media_list_unlock( p_mlist ); libvlc_event_t event; event.type = libvlc_MediaDiscovererEnded; libvlc_event_send( &p_mdis->event_manager, &event ); vlc_sd_Destroy( p_mdis->p_sd ); p_mdis->p_sd = NULL; }
static void test_media_has_slaves_from_parent(libvlc_instance_t *p_vlc, libvlc_media_slave_t *p_expected_slaves, unsigned i_expected_slaves) { libvlc_media_t *p_m = libvlc_media_new_path(p_vlc, SLAVES_DIR); assert(p_m != NULL); printf("Parse media dir to get subitems\n"); media_parse_sync(p_m); char *psz_main_media_mrl = path_to_mrl(p_vlc, MAIN_MEDIA_PATH); assert(psz_main_media_mrl != NULL); printf("Main media mrl: '%s'\n", psz_main_media_mrl); printf("Fetch main media from subitems\n"); libvlc_media_list_t *p_ml = libvlc_media_subitems(p_m); assert(p_ml != NULL); libvlc_media_list_lock(p_ml); int i_count = libvlc_media_list_count(p_ml); assert(i_count > 0); libvlc_media_t *p_subm = NULL; for (int i = 0; i < i_count; ++i) { p_subm = libvlc_media_list_item_at_index(p_ml, i); assert(p_subm != NULL); char *psz_mrl = libvlc_media_get_mrl(p_subm); assert(psz_mrl != NULL); if (strcmp(psz_main_media_mrl, psz_mrl) == 0) { printf("Found main media\n"); free(psz_mrl); break; } free(psz_mrl); libvlc_media_release(p_subm); p_subm = NULL; } free(psz_main_media_mrl); libvlc_media_list_unlock(p_ml); libvlc_media_list_release(p_ml); assert(p_subm != NULL); test_expected_slaves(p_subm, p_expected_slaves, i_expected_slaves); libvlc_media_release(p_subm); libvlc_media_release(p_m); }
int VlcPlugin::playlist_add( const char *mrl, libvlc_exception_t *ex ) { int item = -1; libvlc_media_t *p_m = libvlc_media_new(libvlc_instance,mrl,ex); if( libvlc_exception_raised(ex) ) return -1; libvlc_media_list_lock(libvlc_media_list); libvlc_media_list_add_media(libvlc_media_list,p_m,ex); if( !libvlc_exception_raised(ex) ) item = libvlc_media_list_count(libvlc_media_list,ex)-1; libvlc_media_list_unlock(libvlc_media_list); libvlc_media_release(p_m); return item; }
static void services_discovery_ended( const vlc_event_t * p_event, void * user_data ) { VLC_UNUSED(p_event); libvlc_media_discoverer_t * p_mdis = user_data; libvlc_media_list_t * p_mlist = p_mdis->p_mlist; libvlc_event_t event; p_mdis->running = false; libvlc_media_list_lock( p_mlist ); libvlc_media_list_internal_end_reached( p_mlist ); libvlc_media_list_unlock( p_mlist ); event.type = libvlc_MediaDiscovererEnded; libvlc_event_send( p_mdis->p_event_manager, &event ); }
static void send_parsed_changed( libvlc_media_t *p_md, libvlc_media_parsed_status_t new_status ) { libvlc_event_t event; vlc_mutex_lock( &p_md->parsed_lock ); if( p_md->parsed_status == new_status ) { vlc_mutex_unlock( &p_md->parsed_lock ); return; } /* Legacy: notify libvlc_media_parse */ if( !p_md->is_parsed ) { p_md->is_parsed = true; vlc_cond_broadcast( &p_md->parsed_cond ); } p_md->parsed_status = new_status; if( p_md->parsed_status == libvlc_media_parsed_status_skipped ) p_md->has_asked_preparse = false; vlc_mutex_unlock( &p_md->parsed_lock ); if( new_status == libvlc_media_parsed_status_done ) { libvlc_media_list_t *p_subitems = media_get_subitems( p_md, false ); if( p_subitems != NULL ) { /* notify the media list */ libvlc_media_list_lock( p_subitems ); libvlc_media_list_internal_end_reached( p_subitems ); libvlc_media_list_unlock( p_subitems ); } } /* Construct the event */ event.type = libvlc_MediaParsedChanged; event.u.media_parsed_changed.new_status = new_status; /* Send the event */ libvlc_event_send( p_md->p_event_manager, &event ); }
/************************************************************************** * libvlc_media_list_view_release (Public) **************************************************************************/ void libvlc_media_list_view_release( libvlc_media_list_view_t * p_mlv ) { vlc_mutex_lock( &p_mlv->object_lock ); p_mlv->i_refcount--; if( p_mlv->i_refcount > 0 ) { vlc_mutex_unlock( &p_mlv->object_lock ); return; } vlc_mutex_unlock( &p_mlv->object_lock ); /* Refcount null, time to free */ libvlc_media_list_lock( p_mlv->p_mlist ); if( p_mlv->pf_ml_item_added ) { libvlc_event_detach( p_mlv->p_mlist->p_event_manager, libvlc_MediaListItemAdded, media_list_item_added, p_mlv, NULL ); } if( p_mlv->pf_ml_item_removed ) { libvlc_event_detach( p_mlv->p_mlist->p_event_manager, libvlc_MediaListItemDeleted, media_list_item_removed, p_mlv, NULL ); } int i, count = libvlc_media_list_count( p_mlv->p_mlist, NULL ); for( i = 0; i < count; i++) { libvlc_media_t * p_md; p_md = libvlc_media_list_item_at_index( p_mlv->p_mlist, i, NULL ); uninstall_md_listener( p_mlv, p_md ); libvlc_media_release( p_md ); } libvlc_media_list_unlock( p_mlv->p_mlist ); libvlc_event_manager_release( p_mlv->p_event_manager ); if( p_mlv->pf_release ) p_mlv->pf_release( p_mlv ); libvlc_media_list_release( p_mlv->p_mlist ); vlc_mutex_destroy( &p_mlv->object_lock ); }
/************************************************************************** * input_item_preparse_ended (Private) (vlc event Callback) **************************************************************************/ static void input_item_preparse_ended( const vlc_event_t * p_event, void * user_data ) { VLC_UNUSED( p_event ); libvlc_media_t * p_md = user_data; libvlc_media_list_t *p_subitems = media_get_subitems( p_md, false ); libvlc_event_t event; event.type = libvlc_MediaParsedStatus; vlc_mutex_lock(&p_md->parsed_lock); switch (p_event->u.input_item_preparse_ended.new_status) { case ITEM_PREPARSE_SKIPPED: p_md->parsed_status = libvlc_media_parse_skipped; p_md->has_asked_preparse = false; break; case ITEM_PREPARSE_FAILED: p_md->parsed_status = libvlc_media_parse_failed; break; case ITEM_PREPARSE_DONE: p_md->parsed_status = libvlc_media_parse_done; break; } event.u.media_parsed_status.new_status = p_md->parsed_status; vlc_mutex_unlock(&p_md->parsed_lock); if( p_subitems != NULL ) { /* notify the media list */ libvlc_media_list_lock( p_subitems ); libvlc_media_list_internal_end_reached( p_subitems ); libvlc_media_list_unlock( p_subitems ); } /* XXX: libVLC 2.2.0 compat: even if case of preparse failure, * libvlc_MediaParsedChanged was sent with a true status. Therefore, send * this event if it was not previously sent */ send_preparsed_event(p_md); libvlc_event_send(p_md->p_event_manager, &event); }
static void services_discovery_item_removed( const vlc_event_t * p_event, void * user_data ) { input_item_t * p_item = p_event->u.services_discovery_item_added.p_new_item; libvlc_media_t * p_md; libvlc_media_discoverer_t * p_mdis = user_data; int i, count = libvlc_media_list_count( p_mdis->p_mlist, NULL ); libvlc_media_list_lock( p_mdis->p_mlist ); for( i = 0; i < count; i++ ) { p_md = libvlc_media_list_item_at_index( p_mdis->p_mlist, i, NULL ); if( p_md->p_input_item == p_item ) { _libvlc_media_list_remove_index( p_mdis->p_mlist, i, NULL ); break; } } libvlc_media_list_unlock( p_mdis->p_mlist ); }
int VlcPlugin::playlist_add_extended_untrusted( const char *mrl, const char *name, int optc, const char **optv, libvlc_exception_t *ex ) { libvlc_media_t *p_m = libvlc_media_new(libvlc_instance, mrl,ex); int item = -1; if( libvlc_exception_raised(ex) ) return -1; for( int i = 0; i < optc; ++i ) libvlc_media_add_option_flag(p_m, optv[i], libvlc_media_option_unique); libvlc_media_list_lock(libvlc_media_list); libvlc_media_list_add_media(libvlc_media_list,p_m,ex); if( !libvlc_exception_raised(ex) ) item = libvlc_media_list_count(libvlc_media_list,ex)-1; libvlc_media_list_unlock(libvlc_media_list); libvlc_media_release(p_m); return item; }
static void install_md_listener( libvlc_media_list_view_t * p_mlv, libvlc_media_t * p_md) { libvlc_media_list_t * p_mlist; if((p_mlist = libvlc_media_subitems( p_md ))) { libvlc_media_list_lock( p_mlist ); int i, count = libvlc_media_list_count( p_mlist, NULL ); for( i = 0; i < count; i++) { libvlc_event_t added_event; libvlc_media_t * p_submd; p_submd = libvlc_media_list_item_at_index( p_mlist, i, NULL ); /* Install our listeners */ install_md_listener( p_mlv, p_submd ); /* For each item, send a notification to the mlv subclasses */ added_event.u.media_list_item_added.item = p_submd; added_event.u.media_list_item_added.index = 0; if( p_mlv->pf_ml_item_added ) p_mlv->pf_ml_item_added( &added_event, p_mlv ); libvlc_media_release( p_submd ); } libvlc_event_attach( p_mlist->p_event_manager, libvlc_MediaListItemAdded, media_list_item_added, p_mlv, NULL ); libvlc_event_attach( p_mlist->p_event_manager, libvlc_MediaListItemDeleted, media_list_item_removed, p_mlv, NULL ); libvlc_media_list_unlock( p_mlist ); libvlc_media_list_release( p_mlist ); } else { /* No mlist, wait for a subitem added event */ libvlc_event_attach( p_md->p_event_manager, libvlc_MediaSubItemAdded, media_list_subitem_added, p_mlv, NULL ); } }
static void services_discovery_item_removed( services_discovery_t *sd, input_item_t *p_item ) { libvlc_media_t * p_md; libvlc_media_discoverer_t *p_mdis = sd->owner.sys; int i, count = libvlc_media_list_count( p_mdis->p_mlist ); libvlc_media_list_lock( p_mdis->p_mlist ); for( i = 0; i < count; i++ ) { p_md = libvlc_media_list_item_at_index( p_mdis->p_mlist, i ); assert(p_md != NULL); if( p_md->p_input_item == p_item ) { libvlc_media_list_internal_remove_index( p_mdis->p_mlist, i ); libvlc_media_release( p_md ); break; } libvlc_media_release( p_md ); } libvlc_media_list_unlock( p_mdis->p_mlist ); }
bool VlcPlugin::playlist_select( int idx, libvlc_exception_t *ex ) { libvlc_media_t *p_m = NULL; libvlc_media_list_lock(libvlc_media_list); int count = libvlc_media_list_count(libvlc_media_list,ex); if( libvlc_exception_raised(ex) ) goto bad_unlock; if( idx<0||idx>=count ) goto bad_unlock; playlist_index = idx; p_m = libvlc_media_list_item_at_index(libvlc_media_list,playlist_index,ex); libvlc_media_list_unlock(libvlc_media_list); if( libvlc_exception_raised(ex) ) return false; if( libvlc_media_player ) { libvlc_media_player_release( libvlc_media_player ); libvlc_media_player = NULL; } libvlc_media_player = libvlc_media_player_new_from_media(p_m,ex); if( libvlc_media_player ) set_player_window(ex); libvlc_media_release( p_m ); return !libvlc_exception_raised(ex); bad_unlock: libvlc_media_list_unlock(libvlc_media_list); return false; }
void VideoSource::UpdateSettings() { EnterCriticalSection(&textureLock); isRendering = false; LeaveCriticalSection(&textureLock); if (mediaPlayer) { libvlc_video_set_callbacks(mediaPlayer, nullptr, nullptr, nullptr, nullptr); libvlc_media_player_stop(mediaPlayer); } config->Reload(); hasSetVolume = false; videoSize.x = float(config->width); videoSize.y = float(config->height); if (mediaPlayer == nullptr) { mediaPlayer = libvlc_media_player_new(vlc); libvlc_event_manager_t *em = libvlc_media_player_event_manager(mediaPlayer); libvlc_event_attach(em, libvlc_MediaPlayerEndReached, vlcEvent, this); libvlc_event_attach(em, libvlc_MediaPlayerPlaying, vlcEvent, this); } if (mediaListPlayer == nullptr) { mediaListPlayer = libvlc_media_list_player_new(vlc); libvlc_media_list_player_set_media_player(mediaListPlayer, mediaPlayer); } else { libvlc_media_list_player_stop(mediaListPlayer); } if (mediaList) { libvlc_media_list_lock(mediaList); while(libvlc_media_list_count(mediaList)) { libvlc_media_list_remove_index(mediaList, 0); } libvlc_media_list_unlock(mediaList); } else { mediaList = libvlc_media_list_new(vlc); libvlc_media_list_player_set_media_list(mediaListPlayer, mediaList); } char *utf8PathOrUrl; for(unsigned int i = 0; i < config->playlist.Num(); i++) { String &mediaEntry = config->playlist[i]; String token = mediaEntry.GetToken(1, L':'); // .. Yup. bool isStream = token.Length() >= 2 && token[0] == L'/' && token[1] == L'/'; utf8PathOrUrl = config->playlist[i].CreateUTF8String(); if (utf8PathOrUrl) { libvlc_media_t *media; if (!isStream) { media = libvlc_media_new_path(vlc, utf8PathOrUrl); } else { media = libvlc_media_new_location(vlc, utf8PathOrUrl); } libvlc_media_list_lock(mediaList); libvlc_media_list_add_media(mediaList, media); libvlc_media_list_unlock(mediaList); libvlc_media_release(media); Free(utf8PathOrUrl); } } if (!config->isPlaylistLooping) { remainingVideos = config->playlist.Num(); } libvlc_video_set_callbacks(mediaPlayer, lock, unlock, display, this); libvlc_video_set_format_callbacks(mediaPlayer, videoFormatProxy, videoCleanupProxy); libvlc_media_list_player_set_playback_mode(mediaListPlayer, config->isPlaylistLooping ? libvlc_playback_mode_loop : libvlc_playback_mode_default); if (!audioOutputStreamHandler) { audioOutputStreamHandler = new AudioOutputStreamHandler(vlc, mediaPlayer); } audioOutputStreamHandler->SetOutputParameters( config->audioOutputType, config->audioOutputTypeDevice, config->audioOutputDevice, config->isAudioOutputToStream); audioOutputStreamHandler->SetVolume(config->volume); // set (possibly in vane) the volume. If it doesn't work it will try later until it works // vlc... que pasa amigo hasSetVolume = libvlc_audio_set_volume(mediaPlayer, config->volume) == 0; EnterCriticalSection(&textureLock); isRendering = true; LeaveCriticalSection(&textureLock); libvlc_media_list_player_play(mediaListPlayer); }
/************************************************************************** * Set relative playlist position and play (Private) * * Sets the currently played item to the given relative play item position * (based on the currently playing item) and then begins the new item playback. * Lock must be held. **************************************************************************/ static void set_relative_playlist_position_and_play( libvlc_media_list_player_t * p_mlp, int i_relative_position, libvlc_exception_t * p_e) { assert_locked(p_mlp); if (!p_mlp->p_mlist) { libvlc_exception_raise(p_e); libvlc_printerr("No media list"); return; } libvlc_media_list_lock(p_mlp->p_mlist); libvlc_media_list_path_t path = p_mlp->current_playing_item_path; if(p_mlp->e_playback_mode != libvlc_playback_mode_repeat) { bool b_loop = (p_mlp->e_playback_mode == libvlc_playback_mode_loop); if(i_relative_position > 0) { do { path = get_next_path(p_mlp, b_loop); set_current_playing_item(p_mlp, path); --i_relative_position; } while(i_relative_position > 0); } else if(i_relative_position < 0) { do { path = get_previous_path(p_mlp, b_loop); set_current_playing_item(p_mlp, path); ++i_relative_position; } while (i_relative_position < 0); } } else { set_current_playing_item(p_mlp, path); } #ifdef DEBUG_MEDIA_LIST_PLAYER printf("Playing:"); libvlc_media_list_path_dump(path); #endif if (!path) { libvlc_media_list_unlock(p_mlp->p_mlist); stop(p_mlp, p_e); return; } libvlc_media_player_play(p_mlp->p_mi, p_e); libvlc_media_list_unlock(p_mlp->p_mlist); /* Send the next item event */ libvlc_event_t event; event.type = libvlc_MediaListPlayerNextItemSet; libvlc_media_t * p_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, path); event.u.media_list_player_next_item_set.item = p_md; libvlc_event_send(p_mlp->p_event_manager, &event); libvlc_media_release(p_md); }
void VlcPlugin::playlist_delete_item( int idx, libvlc_exception_t *ex ) { libvlc_media_list_lock(libvlc_media_list); libvlc_media_list_remove_index(libvlc_media_list,idx,ex); libvlc_media_list_unlock(libvlc_media_list); }