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