/**************************************************************************
* libvlc_media_list_new (Public)
*
* Init an object.
**************************************************************************/
libvlc_media_list_t *
libvlc_media_list_new( libvlc_instance_t * p_inst )
{
libvlc_media_list_t * p_mlist;
p_mlist = malloc(sizeof(libvlc_media_list_t));
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 );
if( unlikely(p_mlist->p_event_manager == NULL) )
{
free(p_mlist);
return NULL;
}
p_mlist->b_read_only = false;
vlc_mutex_init( &p_mlist->object_lock );
vlc_mutex_init( &p_mlist->refcount_lock ); // FIXME: spinlock?
vlc_array_init( &p_mlist->items );
assert( p_mlist->items.i_count == 0 );
p_mlist->i_refcount = 1;
p_mlist->p_md = NULL;
p_mlist->p_internal_md = NULL;
libvlc_retain( p_inst );
return p_mlist;
}
/**************************************************************************
* 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;
}
vlc_http_cookie_jar_t * vlc_http_cookies_new()
{
vlc_http_cookie_jar_t * jar = malloc( sizeof( vlc_http_cookie_jar_t ) );
if ( !jar )
return NULL;
vlc_array_init( &jar->cookies );
vlc_mutex_init( &jar->lock );
return jar;
}
/**************************************************************************
* libvlc_event_manager_register_event_type (internal) :
*
* Init an object's event manager.
**************************************************************************/
void libvlc_event_manager_register_event_type(
libvlc_event_manager_t * p_em,
libvlc_event_type_t event_type )
{
libvlc_event_listeners_group_t * listeners_group;
listeners_group = xmalloc(sizeof(libvlc_event_listeners_group_t));
listeners_group->event_type = event_type;
vlc_array_init( &listeners_group->listeners );
vlc_mutex_lock( &p_em->object_lock );
vlc_array_append( &p_em->listeners_groups, listeners_group );
vlc_mutex_unlock( &p_em->object_lock );
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open(vlc_object_t *p_this)
{
fingerprinter_thread_t *p_fingerprinter = (fingerprinter_thread_t*) p_this;
fingerprinter_sys_t *p_sys = calloc(1, sizeof(fingerprinter_sys_t));
if ( !p_sys )
return VLC_ENOMEM;
p_fingerprinter->p_sys = p_sys;
vlc_array_init( &p_sys->incoming.queue );
vlc_mutex_init( &p_sys->incoming.lock );
vlc_array_init( &p_sys->processing.queue );
vlc_mutex_init( &p_sys->processing.lock );
vlc_cond_init( &p_sys->processing.cond );
vlc_array_init( &p_sys->results.queue );
vlc_mutex_init( &p_sys->results.lock );
p_fingerprinter->pf_enqueue = EnqueueRequest;
p_fingerprinter->pf_getresults = GetResult;
p_fingerprinter->pf_apply = ApplyResult;
var_Create( p_fingerprinter, "results-available", VLC_VAR_BOOL );
if( vlc_clone( &p_sys->thread, Run, p_fingerprinter,
VLC_THREAD_PRIORITY_LOW ) )
{
msg_Err( p_fingerprinter, "cannot spawn fingerprinter thread" );
goto error;
}
return VLC_SUCCESS;
error:
CleanSys( p_sys );
free( p_sys );
return VLC_EGENERIC;
}
/**************************************************************************
* libvlc_event_manager_new (internal) :
*
* Init an object's event manager.
**************************************************************************/
libvlc_event_manager_t *
libvlc_event_manager_new( void * p_obj )
{
libvlc_event_manager_t * p_em;
p_em = malloc(sizeof( libvlc_event_manager_t ));
if( !p_em )
{
libvlc_printerr( "Not enough memory" );
return NULL;
}
p_em->p_obj = p_obj;
vlc_array_init(&p_em->listeners);
vlc_mutex_init_recursive(&p_em->lock);
return p_em;
}
/**************************************************************************
* libvlc_media_list_new (Public)
*
* Init an object.
**************************************************************************/
libvlc_media_list_t *
libvlc_media_list_new( libvlc_instance_t * p_inst )
{
libvlc_media_list_t * p_mlist;
p_mlist = malloc(sizeof(libvlc_media_list_t));
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 );
if( unlikely(p_mlist->p_event_manager == NULL) )
{
free(p_mlist);
return NULL;
}
p_mlist->b_read_only = false;
libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
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_MediaListItemDeleted );
libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
libvlc_MediaListWillDeleteItem );
libvlc_event_manager_register_event_type( p_mlist->p_event_manager,
libvlc_MediaListEndReached );
vlc_mutex_init( &p_mlist->object_lock );
vlc_mutex_init( &p_mlist->refcount_lock ); // FIXME: spinlock?
vlc_array_init( &p_mlist->items );
assert( p_mlist->items.i_count == 0 );
p_mlist->i_refcount = 1;
p_mlist->p_md = NULL;
p_mlist->p_internal_md = NULL;
return p_mlist;
}
/**************************************************************************
* 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;
}
int
libvlc_InternalDialogInit(libvlc_int_t *p_libvlc)
{
assert(p_libvlc != NULL);
vlc_dialog_provider *p_provider = malloc(sizeof(*p_provider));
if (p_provider == NULL)
return VLC_EGENERIC;
vlc_mutex_init(&p_provider->lock);
vlc_array_init(&p_provider->dialog_array);
memset(&p_provider->cbs, 0, sizeof(p_provider->cbs));
p_provider->p_cbs_data = NULL;
p_provider->pf_ext_update = NULL;
p_provider->p_ext_data = NULL;
libvlc_priv(p_libvlc)->p_dialog_provider = p_provider;
return VLC_SUCCESS;
}
struct background_worker* background_worker_New( void* owner,
struct background_worker_config* conf )
{
struct background_worker* worker = malloc( sizeof *worker );
if( unlikely( !worker ) )
return NULL;
worker->conf = *conf;
worker->owner = owner;
worker->head.id = NULL;
worker->head.active = false;
worker->head.deadline = VLC_TS_INVALID;
vlc_mutex_init( &worker->lock );
vlc_cond_init( &worker->head.wait );
vlc_cond_init( &worker->head.worker_wait );
vlc_array_init( &worker->tail.data );
vlc_cond_init( &worker->tail.wait );
return worker;
}
/**************************************************************************
* libvlc_event_manager_new (internal) :
*
* Init an object's event manager.
**************************************************************************/
libvlc_event_manager_t *
libvlc_event_manager_new( void * p_obj, libvlc_instance_t * p_libvlc_inst )
{
libvlc_event_manager_t * p_em;
p_em = malloc(sizeof( libvlc_event_manager_t ));
if( !p_em )
{
libvlc_printerr( "Not enough memory" );
return NULL;
}
p_em->p_obj = p_obj;
p_em->p_obj = p_obj;
p_em->async_event_queue = NULL;
p_em->p_libvlc_instance = p_libvlc_inst;
libvlc_retain( p_libvlc_inst );
vlc_array_init( &p_em->listeners_groups );
vlc_mutex_init( &p_em->object_lock );
vlc_mutex_init_recursive( &p_em->event_sending_lock );
return p_em;
}
/* Creates a complete "stream_out" modules chain
*
* chain format: module1{option=*:option=*}[:module2{option=*:...}]
*
* The modules are created starting from the last one and linked together
* A pointer to the last module created is stored if pp_last isn't NULL, to
* make sure sout_StreamChainDelete doesn't delete modules created in another
* place.
*
* Returns a pointer to the first module.
*/
sout_stream_t *sout_StreamChainNew(sout_instance_t *p_sout, const char *psz_chain,
sout_stream_t *p_next, sout_stream_t **pp_last)
{
if(!psz_chain || !*psz_chain)
{
if(pp_last) *pp_last = NULL;
return p_next;
}
char *psz_parser = strdup(psz_chain);
if(!psz_parser)
return NULL;
vlc_array_t cfg, name;
vlc_array_init(&cfg);
vlc_array_init(&name);
/* parse chain */
while(psz_parser)
{
config_chain_t *p_cfg;
char *psz_name;
char *psz_rest_chain = config_ChainCreate( &psz_name, &p_cfg, psz_parser );
free( psz_parser );
psz_parser = psz_rest_chain;
vlc_array_append(&cfg, p_cfg);
vlc_array_append(&name, psz_name);
}
int i = vlc_array_count(&name);
vlc_array_t module;
vlc_array_init(&module);
while(i--)
{
p_next = sout_StreamNew( p_sout, vlc_array_item_at_index(&name, i),
vlc_array_item_at_index(&cfg, i), p_next);
if(!p_next)
goto error;
if(i == vlc_array_count(&name) - 1 && pp_last)
*pp_last = p_next; /* last module created in the chain */
vlc_array_append(&module, p_next);
}
vlc_array_clear(&name);
vlc_array_clear(&cfg);
vlc_array_clear(&module);
return p_next;
error:
i++; /* last module couldn't be created */
/* destroy all modules created, starting with the last one */
int modules = vlc_array_count(&module);
while(modules--)
sout_StreamDelete(vlc_array_item_at_index(&module, modules));
vlc_array_clear(&module);
/* then destroy all names and config which weren't destroyed by
* sout_StreamDelete */
while(i--)
{
free(vlc_array_item_at_index(&name, i));
config_ChainDestroy(vlc_array_item_at_index(&cfg, i));
}
vlc_array_clear(&name);
vlc_array_clear(&cfg);
return NULL;
}
void libvlc_event_manager_init(libvlc_event_manager_t *em, void *obj)
{
em->p_obj = obj;
vlc_array_init(&em->listeners);
vlc_mutex_init_recursive(&em->lock);
}
