/**************************************************************************
* Delete a media descriptor object
**************************************************************************/
void libvlc_media_release( libvlc_media_t *p_md )
{
if (!p_md)
return;
p_md->i_refcount--;
if( p_md->i_refcount > 0 )
return;
if( p_md->p_subitems )
libvlc_media_list_release( p_md->p_subitems );
uninstall_input_item_observer( p_md );
vlc_gc_decref( p_md->p_input_item );
vlc_cond_destroy( &p_md->parsed_cond );
vlc_mutex_destroy( &p_md->parsed_lock );
/* Construct the event */
libvlc_event_t event;
event.type = libvlc_MediaFreed;
event.u.media_freed.md = p_md;
/* Send the event */
libvlc_event_send( p_md->p_event_manager, &event );
libvlc_event_manager_release( p_md->p_event_manager );
free( p_md );
}
/**************************************************************************
* Destroy a Media Instance object (libvlc internal)
*
* Warning: No lock held here, but hey, this is internal. Caller must lock.
**************************************************************************/
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,
"snapshot-file", snapshot_was_taken, p_mi );
/* No need for lock_input() because no other threads knows us anymore */
if( p_mi->input.p_thread )
release_input_thread(p_mi, true);
if( p_mi->input.p_resource )
{
input_resource_Terminate( p_mi->input.p_resource );
input_resource_Release( p_mi->input.p_resource );
p_mi->input.p_resource = NULL;
}
vlc_mutex_destroy( &p_mi->input.lock );
libvlc_event_manager_release( p_mi->p_event_manager );
libvlc_media_release( p_mi->p_md );
vlc_mutex_destroy( &p_mi->object_lock );
libvlc_instance_t *instance = p_mi->p_libvlc_instance;
vlc_object_release( p_mi );
libvlc_release(instance);
}
/**************************************************************************
* libvlc_media_list_release (Public)
*
* Release an object.
**************************************************************************/
void libvlc_media_list_release( libvlc_media_list_t * p_mlist )
{
libvlc_media_t * p_md;
int i;
vlc_mutex_lock( &p_mlist->refcount_lock );
p_mlist->i_refcount--;
if( p_mlist->i_refcount > 0 )
{
vlc_mutex_unlock( &p_mlist->refcount_lock );
return;
}
vlc_mutex_unlock( &p_mlist->refcount_lock );
/* Refcount null, time to free */
libvlc_event_manager_release( p_mlist->p_event_manager );
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 );
}
/**************************************************************************
* new (Public)
**************************************************************************/
libvlc_media_list_player_t *
libvlc_media_list_player_new(libvlc_instance_t * p_instance)
{
libvlc_media_list_player_t * p_mlp;
p_mlp = calloc( 1, sizeof(libvlc_media_list_player_t) );
if (unlikely(p_mlp == NULL))
{
libvlc_printerr("Not enough memory");
return NULL;
}
p_mlp->i_refcount = 1;
p_mlp->seek_offset = 0;
vlc_mutex_init(&p_mlp->object_lock);
vlc_mutex_init(&p_mlp->mp_callback_lock);
vlc_cond_init(&p_mlp->seek_pending);
p_mlp->p_event_manager = libvlc_event_manager_new(p_mlp);
if (unlikely(p_mlp->p_event_manager == NULL))
goto error;
/* Create the underlying media_player */
p_mlp->p_mi = libvlc_media_player_new(p_instance);
if( p_mlp->p_mi == NULL )
{
libvlc_event_manager_release(p_mlp->p_event_manager);
goto error;
}
install_media_player_observer(p_mlp);
if (vlc_clone(&p_mlp->thread, playlist_thread, p_mlp,
VLC_THREAD_PRIORITY_LOW))
{
libvlc_media_player_release(p_mlp->p_mi);
libvlc_event_manager_release(p_mlp->p_event_manager);
goto error;
}
return p_mlp;
error:
vlc_cond_destroy(&p_mlp->seek_pending);
vlc_mutex_destroy(&p_mlp->mp_callback_lock);
vlc_mutex_destroy(&p_mlp->object_lock);
free(p_mlp);
return NULL;
}
/**************************************************************************
* release (Public)
**************************************************************************/
void libvlc_media_library_release( libvlc_media_library_t * p_mlib )
{
p_mlib->i_refcount--;
if( p_mlib->i_refcount > 0 )
return;
libvlc_event_manager_release( p_mlib->p_event_manager );
free( p_mlib );
}
/**************************************************************************
* release (Public)
**************************************************************************/
void
libvlc_media_discoverer_release( libvlc_media_discoverer_t * p_mdis )
{
int i;
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemAdded,
services_discovery_item_added,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoved,
services_discovery_item_removed,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryStarted,
services_discovery_started,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryEnded,
services_discovery_ended,
p_mdis );
vlc_event_detach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoveAll,
services_discovery_removeall,
p_mdis );
libvlc_media_list_release( p_mdis->p_mlist );
if( p_mdis->running )
vlc_sd_Stop( p_mdis->p_sd );
vlc_sd_Destroy( p_mdis->p_sd );
/* Free catname_to_submedialist and all the mlist */
char ** all_keys = vlc_dictionary_all_keys( &p_mdis->catname_to_submedialist );
for( i = 0; all_keys[i]; i++ )
{
libvlc_media_list_t * p_catmlist = vlc_dictionary_value_for_key( &p_mdis->catname_to_submedialist, all_keys[i] );
libvlc_media_list_release( p_catmlist );
free( all_keys[i] );
}
free( all_keys );
vlc_dictionary_clear( &p_mdis->catname_to_submedialist, NULL, NULL );
libvlc_event_manager_release( p_mdis->p_event_manager );
libvlc_release( p_mdis->p_libvlc_instance );
free( p_mdis );
}
static void libvlc_vlm_release_internal( libvlc_instance_t *p_instance )
{
vlm_t *p_vlm = p_instance->libvlc_vlm.p_vlm;
if( !p_instance->libvlc_vlm.p_vlm )
return;
/* We need to remove medias in order to receive events */
vlm_Control( p_vlm, VLM_CLEAR_MEDIAS );
vlm_Control( p_vlm, VLM_CLEAR_SCHEDULES );
var_DelCallback( (vlc_object_t *)p_vlm, "intf-event", VlmEvent,
p_instance->libvlc_vlm.p_event_manager );
p_instance->libvlc_vlm.pf_release = NULL;
libvlc_event_manager_release( p_instance->libvlc_vlm.p_event_manager );
p_instance->libvlc_vlm.p_event_manager = NULL;
vlm_Delete( p_vlm );
p_instance->libvlc_vlm.p_vlm = NULL;
}
/**************************************************************************
* 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 );
}
/**************************************************************************
* libvlc_media_list_new (Public)
*
* Init an object.
**************************************************************************/
libvlc_media_list_t *
libvlc_media_list_new( libvlc_instance_t * p_inst,
libvlc_exception_t * p_e )
{
libvlc_media_list_t * p_mlist;
p_mlist = malloc(sizeof(libvlc_media_list_t));
if( !p_mlist )
return NULL;
p_mlist->p_libvlc_instance = p_inst;
p_mlist->p_event_manager = libvlc_event_manager_new( p_mlist, p_inst, p_e );
/* 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_event_manager_register_event_type( p_mlist->p_event_manager,
libvlc_MediaListWillAddItem, p_e );
libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
libvlc_MediaListItemDeleted, p_e );
libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
libvlc_MediaListWillDeleteItem, p_e );
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_array_init( &p_mlist->items );
p_mlist->i_refcount = 1;
p_mlist->p_md = NULL;
return p_mlist;
}
/**************************************************************************
* release (Public)
**************************************************************************/
void libvlc_media_list_player_release(libvlc_media_list_player_t * p_mlp)
{
if (!p_mlp)
return;
lock(p_mlp);
p_mlp->i_refcount--;
if (p_mlp->i_refcount > 0)
{
unlock(p_mlp);
return;
}
assert(p_mlp->i_refcount == 0);
unlock(p_mlp);
vlc_cancel(p_mlp->thread);
vlc_join(p_mlp->thread, NULL);
lock(p_mlp);
/* Keep the lock(), because the uninstall functions
* check for it. That's convenient. */
uninstall_media_player_observer(p_mlp);
libvlc_media_player_release(p_mlp->p_mi);
if (p_mlp->p_mlist)
{
uninstall_playlist_observer(p_mlp);
libvlc_media_list_release(p_mlp->p_mlist);
}
unlock(p_mlp);
libvlc_event_manager_release(p_mlp->p_event_manager);
vlc_cond_destroy(&p_mlp->seek_pending);
vlc_mutex_destroy(&p_mlp->mp_callback_lock);
vlc_mutex_destroy(&p_mlp->object_lock);
free(p_mlp->current_playing_item_path);
free(p_mlp);
}
/**************************************************************************
* new (Public)
*
* Init an object.
**************************************************************************/
libvlc_media_discoverer_t *
libvlc_media_discoverer_new_from_name( libvlc_instance_t * p_inst,
const char * psz_name )
{
libvlc_media_discoverer_t * p_mdis;
p_mdis = malloc(sizeof(libvlc_media_discoverer_t));
if( unlikely(!p_mdis) )
{
libvlc_printerr( "Not enough memory" );
return NULL;
}
p_mdis->p_libvlc_instance = p_inst;
p_mdis->p_mlist = libvlc_media_list_new( p_inst );
p_mdis->p_mlist->b_read_only = true;
p_mdis->running = false;
vlc_dictionary_init( &p_mdis->catname_to_submedialist, 0 );
p_mdis->p_event_manager = libvlc_event_manager_new( p_mdis, p_inst );
if( unlikely(p_mdis->p_event_manager == NULL) )
{
free( p_mdis );
return NULL;
}
libvlc_event_manager_register_event_type( p_mdis->p_event_manager,
libvlc_MediaDiscovererStarted );
libvlc_event_manager_register_event_type( p_mdis->p_event_manager,
libvlc_MediaDiscovererEnded );
p_mdis->p_sd = vlc_sd_Create( (vlc_object_t*)p_inst->p_libvlc_int,
psz_name );
if( unlikely(p_mdis->p_sd == NULL) )
{
libvlc_printerr( "%s: no such discovery module found", psz_name );
libvlc_media_list_release( p_mdis->p_mlist );
libvlc_event_manager_release( p_mdis->p_event_manager );
free( p_mdis );
return NULL;
}
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemAdded,
services_discovery_item_added,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoved,
services_discovery_item_removed,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryStarted,
services_discovery_started,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryEnded,
services_discovery_ended,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoveAll,
services_discovery_removeall,
p_mdis );
/* Here we go */
if( !vlc_sd_Start( p_mdis->p_sd ) )
{
libvlc_printerr( "%s: internal module error",
p_mdis->p_sd->psz_name );
libvlc_media_list_release( p_mdis->p_mlist );
libvlc_event_manager_release( p_mdis->p_event_manager );
free( p_mdis );
return NULL;
}
return p_mdis;
}
/**************************************************************************
* new (Public)
**************************************************************************/
libvlc_media_discoverer_t *
libvlc_media_discoverer_new( libvlc_instance_t * p_inst, const char * psz_name )
{
/* podcast SD is a hack and only works with custom playlist callbacks. */
if( !strncasecmp( psz_name, "podcast", 7 ) )
return NULL;
libvlc_media_discoverer_t *p_mdis = malloc(sizeof(*p_mdis));
if( unlikely(!p_mdis) )
{
libvlc_printerr( "Not enough memory" );
return NULL;
}
p_mdis->p_libvlc_instance = p_inst;
p_mdis->p_mlist = libvlc_media_list_new( p_inst );
p_mdis->p_mlist->b_read_only = true;
p_mdis->running = false;
vlc_dictionary_init( &p_mdis->catname_to_submedialist, 0 );
p_mdis->p_event_manager = libvlc_event_manager_new( p_mdis );
if( unlikely(p_mdis->p_event_manager == NULL) )
{
free( p_mdis );
return NULL;
}
p_mdis->p_sd = vlc_sd_Create( (vlc_object_t*)p_inst->p_libvlc_int,
psz_name );
if( unlikely(p_mdis->p_sd == NULL) )
{
libvlc_printerr( "%s: no such discovery module found", psz_name );
libvlc_media_list_release( p_mdis->p_mlist );
libvlc_event_manager_release( p_mdis->p_event_manager );
free( p_mdis );
return NULL;
}
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemAdded,
services_discovery_item_added,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoved,
services_discovery_item_removed,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryStarted,
services_discovery_started,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryEnded,
services_discovery_ended,
p_mdis );
vlc_event_attach( services_discovery_EventManager( p_mdis->p_sd ),
vlc_ServicesDiscoveryItemRemoveAll,
services_discovery_removeall,
p_mdis );
libvlc_retain( p_inst );
return p_mdis;
}
