/**************************************************************************
* new (Public)
**************************************************************************/
libvlc_media_library_t *
libvlc_media_library_new( libvlc_instance_t * p_inst )
{
libvlc_media_library_t * p_mlib;
p_mlib = malloc(sizeof(libvlc_media_library_t));
if( !p_mlib )
{
libvlc_printerr( "Not enough memory" );
return NULL;
}
p_mlib->p_libvlc_instance = p_inst;
p_mlib->i_refcount = 1;
p_mlib->p_mlist = NULL;
p_mlib->p_event_manager = libvlc_event_manager_new( p_mlib, p_inst );
if( unlikely(p_mlib->p_event_manager == NULL) )
{
free(p_mlib);
return NULL;
}
return p_mlib;
}
static int libvlc_vlm_init( libvlc_instance_t *p_instance )
{
if( !p_instance->libvlc_vlm.p_event_manager )
{
p_instance->libvlc_vlm.p_event_manager =
libvlc_event_manager_new( p_instance->libvlc_vlm.p_vlm );
if( unlikely(p_instance->libvlc_vlm.p_event_manager == NULL) )
return VLC_ENOMEM;
}
if( !p_instance->libvlc_vlm.p_vlm )
{
p_instance->libvlc_vlm.p_vlm = vlm_New( p_instance->p_libvlc_int );
if( !p_instance->libvlc_vlm.p_vlm )
{
libvlc_printerr( "VLM not supported or out of memory" );
return VLC_EGENERIC;
}
var_AddCallback( (vlc_object_t *)p_instance->libvlc_vlm.p_vlm,
"intf-event", VlmEvent,
p_instance->libvlc_vlm.p_event_manager );
p_instance->libvlc_vlm.pf_release = libvlc_vlm_release_internal;
libvlc_retain( p_instance );
}
return VLC_SUCCESS;
}
static int libvlc_vlm_init( libvlc_instance_t *p_instance,
libvlc_exception_t *p_exception )
{
if( !p_instance->libvlc_vlm.p_event_manager )
{
p_instance->libvlc_vlm.p_event_manager =
libvlc_event_manager_new( p_instance->libvlc_vlm.p_vlm,
p_instance, p_exception );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaAdded, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaRemoved, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaChanged, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStarted, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStopped, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStatusInit, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStatusOpening, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStatusPlaying, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStatusPause, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStatusEnd, NULL );
libvlc_event_manager_register_event_type(
p_instance->libvlc_vlm.p_event_manager,
libvlc_VlmMediaInstanceStatusError, NULL );
}
if( !p_instance->libvlc_vlm.p_vlm )
{
p_instance->libvlc_vlm.p_vlm = vlm_New( p_instance->p_libvlc_int );
if( !p_instance->libvlc_vlm.p_vlm )
{
libvlc_exception_raise( p_exception );
libvlc_printerr( "VLM not supported or out of memory" );
return VLC_EGENERIC;
}
var_AddCallback( (vlc_object_t *)p_instance->libvlc_vlm.p_vlm,
"intf-event", VlmEvent,
p_instance->libvlc_vlm.p_event_manager );
p_instance->libvlc_vlm.pf_release = libvlc_vlm_release_internal;
}
return VLC_SUCCESS;
}
/**************************************************************************
* 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->p_event_manager = libvlc_event_manager_new(p_mlp, p_instance);
if (unlikely(p_mlp->p_event_manager == NULL))
{
free (p_mlp);
return NULL;
}
libvlc_retain(p_instance);
p_mlp->p_libvlc_instance = p_instance;
p_mlp->i_refcount = 1;
vlc_mutex_init(&p_mlp->object_lock);
vlc_mutex_init(&p_mlp->mp_callback_lock);
libvlc_event_manager_register_event_type(p_mlp->p_event_manager, libvlc_MediaListPlayerNextItemSet);
p_mlp->e_playback_mode = libvlc_playback_mode_default;
return p_mlp;
}
/**************************************************************************
* 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;
}
/**************************************************************************
* Create a new media descriptor object from an input_item
* (libvlc internal)
* That's the generic constructor
**************************************************************************/
libvlc_media_t * libvlc_media_new_from_input_item(
libvlc_instance_t *p_instance,
input_item_t *p_input_item )
{
libvlc_media_t * p_md;
if (!p_input_item)
{
libvlc_printerr( "No input item given" );
return NULL;
}
p_md = calloc( 1, sizeof(libvlc_media_t) );
if( !p_md )
{
libvlc_printerr( "Not enough memory" );
return NULL;
}
p_md->p_libvlc_instance = p_instance;
p_md->p_input_item = p_input_item;
p_md->i_refcount = 1;
vlc_cond_init(&p_md->parsed_cond);
vlc_mutex_init(&p_md->parsed_lock);
vlc_mutex_init(&p_md->subitems_lock);
p_md->state = libvlc_NothingSpecial;
/* A media descriptor can be a playlist. When you open a playlist
* It can give a bunch of item to read. */
p_md->p_subitems = NULL;
p_md->p_event_manager = libvlc_event_manager_new( p_md, p_instance );
if( unlikely(p_md->p_event_manager == NULL) )
{
free(p_md);
return NULL;
}
libvlc_event_manager_t *em = p_md->p_event_manager;
libvlc_event_manager_register_event_type(em, libvlc_MediaMetaChanged);
libvlc_event_manager_register_event_type(em, libvlc_MediaSubItemAdded);
libvlc_event_manager_register_event_type(em, libvlc_MediaFreed);
libvlc_event_manager_register_event_type(em, libvlc_MediaDurationChanged);
libvlc_event_manager_register_event_type(em, libvlc_MediaStateChanged);
libvlc_event_manager_register_event_type(em, libvlc_MediaParsedChanged);
libvlc_event_manager_register_event_type(em, libvlc_MediaSubItemTreeAdded);
vlc_gc_incref( p_md->p_input_item );
install_input_item_observer( p_md );
return p_md;
}
/**************************************************************************
* 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;
}
/**************************************************************************
* libvlc_media_list_view_new (Internal)
**************************************************************************/
libvlc_media_list_view_t *
libvlc_media_list_view_new( libvlc_media_list_t * p_mlist,
libvlc_media_list_view_count_func_t pf_count,
libvlc_media_list_view_item_at_index_func_t pf_item_at_index,
libvlc_media_list_view_children_at_index_func_t pf_children_at_index,
libvlc_media_list_view_constructor_func_t pf_constructor,
libvlc_media_list_view_release_func_t pf_release,
void * this_view_data,
libvlc_exception_t * p_e )
{
libvlc_media_list_view_t * p_mlv;
p_mlv = calloc( 1, sizeof(libvlc_media_list_view_t) );
if( !p_mlv )
return NULL;
p_mlv->p_libvlc_instance = p_mlist->p_libvlc_instance;
p_mlv->p_event_manager = libvlc_event_manager_new( p_mlist,
p_mlv->p_libvlc_instance, p_e );
libvlc_event_manager_register_event_type( p_mlv->p_event_manager,
libvlc_MediaListViewItemAdded, p_e );
libvlc_event_manager_register_event_type( p_mlv->p_event_manager,
libvlc_MediaListViewWillAddItem, p_e );
libvlc_event_manager_register_event_type( p_mlv->p_event_manager,
libvlc_MediaListViewItemDeleted, p_e );
libvlc_event_manager_register_event_type( p_mlv->p_event_manager,
libvlc_MediaListViewWillDeleteItem, p_e );
libvlc_media_list_retain( p_mlist );
p_mlv->p_mlist = p_mlist;
p_mlv->pf_count = pf_count;
p_mlv->pf_item_at_index = pf_item_at_index;
p_mlv->pf_children_at_index = pf_children_at_index;
p_mlv->pf_constructor = pf_constructor;
p_mlv->pf_release = pf_release;
p_mlv->p_this_view_data = this_view_data;
vlc_mutex_init( &p_mlv->object_lock );
p_mlv->i_refcount = 1;
return p_mlv;
}
/**************************************************************************
* 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;
}
/**************************************************************************
* new (Public)
**************************************************************************/
libvlc_media_list_player_t *
libvlc_media_list_player_new(libvlc_instance_t * p_instance, libvlc_exception_t * p_e)
{
(void)p_e;
libvlc_media_list_player_t * p_mlp;
p_mlp = calloc( 1, sizeof(libvlc_media_list_player_t) );
if (!p_mlp)
return NULL;
libvlc_retain(p_instance);
p_mlp->p_libvlc_instance = p_instance;
p_mlp->i_refcount = 1;
vlc_mutex_init(&p_mlp->object_lock);
vlc_mutex_init(&p_mlp->mp_callback_lock);
p_mlp->p_event_manager = libvlc_event_manager_new(p_mlp, p_instance, p_e);
libvlc_event_manager_register_event_type(p_mlp->p_event_manager, libvlc_MediaListPlayerNextItemSet, p_e);
p_mlp->e_playback_mode = libvlc_playback_mode_default;
return p_mlp;
}
/**************************************************************************
* Create a Media Instance object.
*
* Refcount strategy:
* - All items created by _new start with a refcount set to 1.
* - Accessor _release decrease the refcount by 1, if after that
* operation the refcount is 0, the object is destroyed.
* - Accessor _retain increase the refcount by 1 (XXX: to implement)
*
* Object locking strategy:
* - No lock held while in constructor.
* - When accessing any member variable this lock is held. (XXX who locks?)
* - When attempting to destroy the object the lock is also held.
**************************************************************************/
libvlc_media_player_t *
libvlc_media_player_new( libvlc_instance_t *instance )
{
libvlc_media_player_t * mp;
assert(instance);
mp = vlc_object_create (instance->p_libvlc_int, sizeof(*mp));
if (unlikely(mp == NULL))
{
libvlc_printerr("Not enough memory");
return NULL;
}
/* Input */
var_Create (mp, "rate", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT);
/* Video */
var_Create (mp, "vout", VLC_VAR_STRING|VLC_VAR_DOINHERIT);
var_Create (mp, "window", VLC_VAR_STRING);
var_Create (mp, "vmem-lock", VLC_VAR_ADDRESS);
var_Create (mp, "vmem-unlock", VLC_VAR_ADDRESS);
var_Create (mp, "vmem-display", VLC_VAR_ADDRESS);
var_Create (mp, "vmem-data", VLC_VAR_ADDRESS);
var_Create (mp, "vmem-setup", VLC_VAR_ADDRESS);
var_Create (mp, "vmem-cleanup", VLC_VAR_ADDRESS);
var_Create (mp, "vmem-chroma", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
var_Create (mp, "vmem-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "vmem-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "vmem-pitch", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "avcodec-hw", VLC_VAR_STRING);
var_Create (mp, "drawable-xid", VLC_VAR_INTEGER);
#if defined (_WIN32) || defined (__OS2__)
var_Create (mp, "drawable-hwnd", VLC_VAR_INTEGER);
#endif
#ifdef __APPLE__
var_Create (mp, "drawable-agl", VLC_VAR_INTEGER);
var_Create (mp, "drawable-nsobject", VLC_VAR_ADDRESS);
#endif
var_Create (mp, "keyboard-events", VLC_VAR_BOOL);
var_SetBool (mp, "keyboard-events", true);
var_Create (mp, "mouse-events", VLC_VAR_BOOL);
var_SetBool (mp, "mouse-events", true);
var_Create (mp, "fullscreen", VLC_VAR_BOOL);
var_Create (mp, "autoscale", VLC_VAR_BOOL);
var_SetBool (mp, "autoscale", true);
var_Create (mp, "scale", VLC_VAR_FLOAT);
var_SetFloat (mp, "scale", 1.);
var_Create (mp, "aspect-ratio", VLC_VAR_STRING);
var_Create (mp, "crop", VLC_VAR_STRING);
var_Create (mp, "deinterlace", VLC_VAR_INTEGER);
var_Create (mp, "deinterlace-mode", VLC_VAR_STRING);
var_Create (mp, "vbi-page", VLC_VAR_INTEGER);
var_Create (mp, "marq-marquee", VLC_VAR_STRING);
var_Create (mp, "marq-color", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-opacity", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-refresh", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-size", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "marq-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "logo-file", VLC_VAR_STRING);
var_Create (mp, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "logo-delay", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "logo-repeat", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "logo-opacity", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "contrast", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
var_Create (mp, "brightness", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
var_Create (mp, "hue", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "saturation", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
var_Create (mp, "gamma", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
/* Audio */
var_Create (mp, "aout", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
var_Create (mp, "mute", VLC_VAR_BOOL);
var_Create (mp, "volume", VLC_VAR_FLOAT);
var_Create (mp, "corks", VLC_VAR_INTEGER);
var_Create (mp, "audio-filter", VLC_VAR_STRING);
var_Create (mp, "amem-data", VLC_VAR_ADDRESS);
var_Create (mp, "amem-setup", VLC_VAR_ADDRESS);
var_Create (mp, "amem-cleanup", VLC_VAR_ADDRESS);
var_Create (mp, "amem-play", VLC_VAR_ADDRESS);
var_Create (mp, "amem-pause", VLC_VAR_ADDRESS);
var_Create (mp, "amem-resume", VLC_VAR_ADDRESS);
var_Create (mp, "amem-flush", VLC_VAR_ADDRESS);
var_Create (mp, "amem-drain", VLC_VAR_ADDRESS);
var_Create (mp, "amem-set-volume", VLC_VAR_ADDRESS);
var_Create (mp, "amem-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
var_Create (mp, "amem-rate", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
var_Create (mp, "amem-channels", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
/* Video Title */
var_Create (mp, "video-title-show", VLC_VAR_BOOL);
var_Create (mp, "video-title-position", VLC_VAR_INTEGER);
var_Create (mp, "video-title-timeout", VLC_VAR_INTEGER);
/* Equalizer */
var_Create (mp, "equalizer-preamp", VLC_VAR_FLOAT);
var_Create (mp, "equalizer-vlcfreqs", VLC_VAR_BOOL);
var_Create (mp, "equalizer-bands", VLC_VAR_STRING);
mp->p_md = NULL;
mp->state = libvlc_NothingSpecial;
mp->p_libvlc_instance = instance;
mp->input.p_thread = NULL;
mp->input.p_resource = input_resource_New(VLC_OBJECT(mp));
if (unlikely(mp->input.p_resource == NULL))
{
vlc_object_release(mp);
return NULL;
}
audio_output_t *aout = input_resource_GetAout(mp->input.p_resource);
if( aout != NULL )
input_resource_PutAout(mp->input.p_resource, aout);
vlc_mutex_init (&mp->input.lock);
mp->i_refcount = 1;
mp->p_event_manager = libvlc_event_manager_new(mp, instance);
if (unlikely(mp->p_event_manager == NULL))
{
input_resource_Release(mp->input.p_resource);
vlc_object_release(mp);
return NULL;
}
vlc_mutex_init(&mp->object_lock);
register_event(mp, NothingSpecial);
register_event(mp, Opening);
register_event(mp, Buffering);
register_event(mp, Playing);
register_event(mp, Paused);
register_event(mp, Stopped);
register_event(mp, Forward);
register_event(mp, Backward);
register_event(mp, EndReached);
register_event(mp, EncounteredError);
register_event(mp, SeekableChanged);
register_event(mp, PositionChanged);
register_event(mp, TimeChanged);
register_event(mp, LengthChanged);
register_event(mp, TitleChanged);
register_event(mp, PausableChanged);
register_event(mp, Vout);
register_event(mp, ScrambledChanged);
/* Snapshot initialization */
register_event(mp, SnapshotTaken);
register_event(mp, MediaChanged);
/* Attach a var callback to the global object to provide the glue between
* vout_thread that generates the event and media_player that re-emits it
* with its own event manager
*
* FIXME: It's unclear why we want to put this in public API, and why we
* want to expose it in such a limiting and ugly way.
*/
var_AddCallback(mp->p_libvlc, "snapshot-file", snapshot_was_taken, mp);
libvlc_retain(instance);
return mp;
}
/**************************************************************************
* 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_exception_t * p_e )
{
libvlc_media_discoverer_t * p_mdis;
p_mdis = malloc(sizeof(libvlc_media_discoverer_t));
if( !p_mdis )
{
libvlc_exception_raise( p_e, "Not enough memory" );
return NULL;
}
p_mdis->p_libvlc_instance = p_inst;
p_mdis->p_mlist = libvlc_media_list_new( p_inst, NULL );
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, NULL );
libvlc_event_manager_register_event_type( p_mdis->p_event_manager,
libvlc_MediaDiscovererStarted, NULL );
libvlc_event_manager_register_event_type( p_mdis->p_event_manager,
libvlc_MediaDiscovererEnded, NULL );
p_mdis->p_sd = services_discovery_Create( (vlc_object_t*)p_inst->p_libvlc_int, psz_name );
if( !p_mdis->p_sd )
{
libvlc_exception_raise( p_e, "Can't find the services_discovery module named '%s'", psz_name );
libvlc_media_list_release( p_mdis->p_mlist );
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 );
services_discovery_Start( p_mdis->p_sd );
/* Here we go */
return p_mdis;
}
/**************************************************************************
* 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;
}
