media & media::operator=(const media &from) noexcept
{
if (from.libvlc_media) libvlc_media_retain(from.libvlc_media);
if (libvlc_media) libvlc_media_release(libvlc_media);
libvlc_media = from.libvlc_media;
return *this;
}
/* LibVLC internal version */
void libvlc_media_list_internal_insert_media( libvlc_media_list_t * p_mlist,
libvlc_media_t * p_md,
int index )
{
libvlc_media_retain( p_md );
notify_item_addition( p_mlist, p_md, index, EventWillHappen );
vlc_array_insert( &p_mlist->items, p_md, index );
notify_item_addition( p_mlist, p_md, index, EventDidHappen );
}
/**************************************************************************
* flat_media_list_view_item_at_index (private)
* (called by flat_media_list_view_item_at_index)
**************************************************************************/
static libvlc_media_t *
flat_media_list_view_item_at_index( libvlc_media_list_view_t * p_mlv,
int index,
libvlc_exception_t * p_e )
{
libvlc_media_t * p_md;
(void)p_e;
p_md = vlc_array_item_at_index( &p_mlv->p_this_view_data->array, index );
libvlc_media_retain( p_md );
return p_md;
}
/* LibVLC internal version */
void libvlc_media_list_internal_add_media( libvlc_media_list_t * p_mlist,
libvlc_media_t * p_md )
{
libvlc_media_retain( p_md );
notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items ),
EventWillHappen );
vlc_array_append( &p_mlist->items, p_md );
notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items )-1,
EventDidHappen );
}
/**************************************************************************
* Get the Media descriptor associated with the instance.
**************************************************************************/
libvlc_media_t *
libvlc_media_player_get_media( libvlc_media_player_t *p_mi )
{
libvlc_media_t *p_m;
lock(p_mi);
p_m = p_mi->p_md;
if( p_m )
libvlc_media_retain( p_mi->p_md );
unlock(p_mi);
return p_mi->p_md;
}
/**************************************************************************
* ml_item_added (private) (Callback from media_list_view item_added)
**************************************************************************/
static void
ml_item_added( const libvlc_event_t * p_event, libvlc_media_list_view_t * p_mlv )
{
int index = vlc_array_count( &p_mlv->p_this_view_data->array );
libvlc_media_t * p_md = p_event->u.media_list_item_added.item;
libvlc_media_retain( p_md );
trace("appending item at index %d\n", index);
libvlc_media_list_view_will_add_item( p_mlv, p_md, index );
vlc_array_append( &p_mlv->p_this_view_data->array, p_md );
libvlc_media_list_view_item_added( p_mlv, p_md, index );
}
/**************************************************************************
* set_media (Public)
**************************************************************************/
void libvlc_media_list_set_media( libvlc_media_list_t * p_mlist,
libvlc_media_t * p_md,
libvlc_exception_t * p_e)
{
VLC_UNUSED(p_e);
vlc_mutex_lock( &p_mlist->object_lock );
libvlc_media_release( p_mlist->p_md );
libvlc_media_retain( p_md );
p_mlist->p_md = p_md;
vlc_mutex_unlock( &p_mlist->object_lock );
}
/* LibVLC internal version */
void _libvlc_media_list_insert_media(
libvlc_media_list_t * p_mlist,
libvlc_media_t * p_md,
int index,
libvlc_exception_t * p_e )
{
VLC_UNUSED(p_e);
libvlc_media_retain( p_md );
notify_item_addition( p_mlist, p_md, index, EventWillHappen );
vlc_array_insert( &p_mlist->items, p_md, index );
notify_item_addition( p_mlist, p_md, index, EventDidHappen );
}
/**************************************************************************
* media (Public)
*
* If this media_list comes is a media's subitems,
* This holds the corresponding media.
* This md is also seen as the information holder for the media_list.
* Indeed a media_list can have meta information through this
* media.
**************************************************************************/
libvlc_media_t *
libvlc_media_list_media( libvlc_media_list_t * p_mlist )
{
libvlc_media_t *p_md;
vlc_mutex_lock( &p_mlist->object_lock );
p_md = p_mlist->p_internal_md ? p_mlist->p_internal_md : p_mlist->p_md;
if( p_md )
libvlc_media_retain( p_md );
vlc_mutex_unlock( &p_mlist->object_lock );
return p_md;
}
/* LibVLC internal version */
void _libvlc_media_list_add_media(
libvlc_media_list_t * p_mlist,
libvlc_media_t * p_md,
libvlc_exception_t * p_e )
{
VLC_UNUSED(p_e);
libvlc_media_retain( p_md );
notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items ),
EventWillHappen );
vlc_array_append( &p_mlist->items, p_md );
notify_item_addition( p_mlist, p_md, vlc_array_count( &p_mlist->items )-1,
EventDidHappen );
}
/**************************************************************************
* Create a Media Instance object with a media descriptor.
**************************************************************************/
libvlc_media_player_t *
libvlc_media_player_new_from_media( libvlc_media_t * p_md )
{
libvlc_media_player_t * p_mi;
p_mi = libvlc_media_player_new( p_md->p_libvlc_instance );
if( !p_mi )
return NULL;
libvlc_media_retain( p_md );
p_mi->p_md = p_md;
return p_mi;
}
/**************************************************************************
* media (Public)
*
* If this media_list comes is a media's subitems,
* This holds the corresponding media.
* This md is also seen as the information holder for the media_list.
* Indeed a media_list can have meta information through this
* media.
**************************************************************************/
libvlc_media_t *
libvlc_media_list_media( libvlc_media_list_t * p_mlist,
libvlc_exception_t * p_e)
{
libvlc_media_t *p_md;
VLC_UNUSED(p_e);
vlc_mutex_lock( &p_mlist->object_lock );
p_md = p_mlist->p_md;
if( p_md )
libvlc_media_retain( p_md );
vlc_mutex_unlock( &p_mlist->object_lock );
return p_md;
}
/**************************************************************************
* set_media (Public)
**************************************************************************/
void libvlc_media_list_set_media( libvlc_media_list_t * p_mlist,
libvlc_media_t * p_md )
{
vlc_mutex_lock( &p_mlist->object_lock );
if( p_mlist->p_internal_md || !mlist_is_writable(p_mlist) )
{
vlc_mutex_unlock( &p_mlist->object_lock );
return;
}
libvlc_media_release( p_mlist->p_md );
libvlc_media_retain( p_md );
p_mlist->p_md = p_md;
vlc_mutex_unlock( &p_mlist->object_lock );
}
/**************************************************************************
* libvlc_media_list_item_at_index (Public)
*
* Lock should be held when entering.
**************************************************************************/
libvlc_media_t *
libvlc_media_list_item_at_index( libvlc_media_list_t * p_mlist,
int index )
{
libvlc_media_t * p_md;
if( index < 0 || index >= vlc_array_count( &p_mlist->items ))
{
libvlc_printerr( "Index out of bounds" );
return NULL;
}
p_md = vlc_array_item_at_index( &p_mlist->items, index );
libvlc_media_retain( p_md );
return p_md;
}
/**************************************************************************
* libvlc_media_list_item_at_index (Public)
*
* Lock should be held when entering.
**************************************************************************/
libvlc_media_t *
libvlc_media_list_item_at_index( libvlc_media_list_t * p_mlist,
int index,
libvlc_exception_t * p_e )
{
libvlc_media_t * p_md;
if( index < 0 || index >= vlc_array_count( &p_mlist->items ))
{
libvlc_exception_raise( p_e, "Index out of bounds");
return NULL;
}
p_md = vlc_array_item_at_index( &p_mlist->items, index );
libvlc_media_retain( p_md );
return p_md;
}
/**************************************************************************
* Set the Media descriptor associated with the instance.
*
* Enter without lock -- function will lock the object.
**************************************************************************/
void libvlc_media_player_set_media(
libvlc_media_player_t *p_mi,
libvlc_media_t *p_md )
{
lock_input(p_mi);
/* FIXME I am not sure if it is a user request or on die(eof/error)
* request here */
release_input_thread( p_mi,
p_mi->input.p_thread &&
!p_mi->input.p_thread->b_eof &&
!p_mi->input.p_thread->b_error );
lock( p_mi );
set_state( p_mi, libvlc_NothingSpecial, true );
unlock_input( p_mi );
libvlc_media_release( p_mi->p_md );
if( !p_md )
{
p_mi->p_md = NULL;
unlock(p_mi);
return; /* It is ok to pass a NULL md */
}
libvlc_media_retain( p_md );
p_mi->p_md = p_md;
/* The policy here is to ignore that we were created using a different
* libvlc_instance, because we don't really care */
p_mi->p_libvlc_instance = p_md->p_libvlc_instance;
unlock(p_mi);
/* Send an event for the newly available media */
libvlc_event_t event;
event.type = libvlc_MediaPlayerMediaChanged;
event.u.media_player_media_changed.new_media = p_md;
libvlc_event_send( p_mi->p_event_manager, &event );
}
/*
* Set the internal state of the media_player. (media player Internal)
*
* Function will lock the media_player.
*/
static void set_state( libvlc_media_player_t *p_mi, libvlc_state_t state,
bool b_locked )
{
if(!b_locked)
lock(p_mi);
p_mi->state = state;
libvlc_media_t *media = p_mi->p_md;
if (media)
libvlc_media_retain(media);
if(!b_locked)
unlock(p_mi);
if (media)
{
// Also set the state of the corresponding media
// This is strictly for convenience.
libvlc_media_set_state(media, state);
libvlc_media_release(media);
}
}
media::media(const media &from) noexcept
: libvlc_media(from.libvlc_media)
{
if (libvlc_media) libvlc_media_retain(libvlc_media);
}
void VLC::retain(libvlc_media_t *media) {
// Retain doesn't check for NULL
if (media != NULL) {
libvlc_media_retain(media);
}
}
