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);
}
