static void
uninstall_md_listener( libvlc_media_list_view_t * p_mlv,
libvlc_media_t * p_md)
{
libvlc_media_list_t * p_mlist;
libvlc_exception_t ignored_exception;
libvlc_exception_init( &ignored_exception );
libvlc_event_detach( p_md->p_event_manager,
libvlc_MediaSubItemAdded,
media_list_subitem_added, p_mlv, &ignored_exception );
if( libvlc_exception_raised( &ignored_exception ) )
libvlc_exception_clear( &ignored_exception ); /* We don't care if we encounter an exception */
if((p_mlist = libvlc_media_subitems( p_md )))
{
libvlc_media_list_lock( p_mlist );
libvlc_event_detach( p_mlist->p_event_manager,
libvlc_MediaListItemAdded,
media_list_item_added, p_mlv, NULL );
libvlc_event_detach( p_mlist->p_event_manager,
libvlc_MediaListItemDeleted,
media_list_item_removed, p_mlv, NULL );
int i, count = libvlc_media_list_count( p_mlist, NULL );
for( i = 0; i < count; i++)
{
libvlc_media_t * p_submd;
p_submd = libvlc_media_list_item_at_index( p_mlist,i, NULL );
uninstall_md_listener( p_mlv, p_submd );
libvlc_media_release( p_submd );
}
libvlc_media_list_unlock( p_mlist );
libvlc_media_list_release( p_mlist );
}
}
/* Little helper */
static void
import_mlist_rec( libvlc_media_list_view_t * p_mlv,
libvlc_media_list_t * p_mlist,
libvlc_exception_t * p_e )
{
int i, count;
count = libvlc_media_list_count( p_mlist, p_e );
for( i = 0; i < count; i++ )
{
libvlc_media_t * p_md;
libvlc_media_list_t * p_submlist;
p_md = libvlc_media_list_item_at_index( p_mlist, i, p_e );
vlc_array_append( &p_mlv->p_this_view_data->array, p_md );
p_submlist = libvlc_media_subitems( p_md );
if( p_submlist )
{
libvlc_media_list_lock( p_submlist );
import_mlist_rec( p_mlv, p_submlist, p_e );
libvlc_media_list_unlock( p_submlist );
libvlc_media_list_release( p_submlist );
}
/* No need to release the md, as we want to retain it, as it is
* stored in our array */
}
}
static int expand_media_internal(JNIEnv *env, libvlc_instance_t* p_instance, jobject arrayList, libvlc_media_t* p_md) {
if(!p_md) {
return -1;
}
libvlc_media_list_t* p_subitems = libvlc_media_subitems(p_md);
libvlc_media_release(p_md);
if(p_subitems) {
// Expand any subitems if needed
int subitem_count = libvlc_media_list_count(p_subitems);
if(subitem_count > 0) {
LOGD("Found %d subitems, expanding", subitem_count);
jclass arrayListClass; jmethodID methodAdd;
arrayListGetIDs(env, &arrayListClass, &methodAdd, NULL);
for(int i = subitem_count - 1; i >= 0; i--) {
libvlc_media_t* p_subitem = libvlc_media_list_item_at_index(p_subitems, i);
char* p_subitem_uri = libvlc_media_get_mrl(p_subitem);
arrayListStringAdd(env, arrayListClass, methodAdd, arrayList, p_subitem_uri);
free(p_subitem_uri);
}
}
libvlc_media_list_release(p_subitems);
if(subitem_count > 0) {
return 0;
} else {
return -1;
}
} else {
return -1;
}
}
/**************************************************************************
* flat_media_list_view_item_at_index (private)
* (called by flat_media_list_view_item_at_index)
**************************************************************************/
static libvlc_media_t *
hierarch_node_media_list_view_item_at_index( libvlc_media_list_view_t * p_mlv,
int index,
libvlc_exception_t * p_e )
{
/* FIXME: we may want to cache that */
libvlc_media_t * p_md;
libvlc_media_list_t * p_submlist;
trace("%d\n", index);
int i, current_index, count = libvlc_media_list_count( p_mlv->p_mlist, p_e );
current_index = -1;
for( i = 0; i < count; i++ )
{
p_md = libvlc_media_list_item_at_index( p_mlv->p_mlist, i, p_e );
if( !p_md ) continue;
p_submlist = libvlc_media_subitems( p_md );
if( !p_submlist ) continue;
libvlc_media_list_release( p_submlist );
current_index++;
if( current_index == index )
return p_md;
libvlc_media_release( p_md );
}
libvlc_exception_raise( p_e );
libvlc_printerr( "Index out of bound in Media List View" );
return NULL;
}
/**************************************************************************
* flat_media_list_view_item_at_index (private)
* (called by flat_media_list_view_item_at_index)
**************************************************************************/
static libvlc_media_t *
hierarch_media_list_view_item_at_index( libvlc_media_list_view_t * p_mlv,
int index,
libvlc_exception_t * p_e )
{
return libvlc_media_list_item_at_index( p_mlv->p_mlist, index, p_e );
}
static void
test_media_has_slaves_from_parent(libvlc_instance_t *p_vlc,
libvlc_media_slave_t *p_expected_slaves,
unsigned i_expected_slaves)
{
libvlc_media_t *p_m = libvlc_media_new_path(p_vlc, SLAVES_DIR);
assert(p_m != NULL);
printf("Parse media dir to get subitems\n");
media_parse_sync(p_m);
char *psz_main_media_mrl = path_to_mrl(p_vlc, MAIN_MEDIA_PATH);
assert(psz_main_media_mrl != NULL);
printf("Main media mrl: '%s'\n", psz_main_media_mrl);
printf("Fetch main media from subitems\n");
libvlc_media_list_t *p_ml = libvlc_media_subitems(p_m);
assert(p_ml != NULL);
libvlc_media_list_lock(p_ml);
int i_count = libvlc_media_list_count(p_ml);
assert(i_count > 0);
libvlc_media_t *p_subm = NULL;
for (int i = 0; i < i_count; ++i)
{
p_subm = libvlc_media_list_item_at_index(p_ml, i);
assert(p_subm != NULL);
char *psz_mrl = libvlc_media_get_mrl(p_subm);
assert(psz_mrl != NULL);
if (strcmp(psz_main_media_mrl, psz_mrl) == 0)
{
printf("Found main media\n");
free(psz_mrl);
break;
}
free(psz_mrl);
libvlc_media_release(p_subm);
p_subm = NULL;
}
free(psz_main_media_mrl);
libvlc_media_list_unlock(p_ml);
libvlc_media_list_release(p_ml);
assert(p_subm != NULL);
test_expected_slaves(p_subm, p_expected_slaves, i_expected_slaves);
libvlc_media_release(p_subm);
libvlc_media_release(p_m);
}
/**************************************************************************
* flat_media_list_view_item_at_index (private)
* (called by flat_media_list_view_item_at_index)
**************************************************************************/
static libvlc_media_list_view_t *
hierarch_media_list_view_children_at_index( libvlc_media_list_view_t * p_mlv,
int index,
libvlc_exception_t * p_e )
{
libvlc_media_t * p_md;
libvlc_media_list_t * p_submlist;
libvlc_media_list_view_t * p_ret;
p_md = libvlc_media_list_item_at_index( p_mlv->p_mlist, index, p_e );
if( !p_md ) return NULL;
p_submlist = libvlc_media_subitems( p_md, p_e );
libvlc_media_release( p_md );
if( !p_submlist ) return NULL;
p_ret = libvlc_media_list_hierarchical_view( p_submlist, p_e );
libvlc_media_list_release( p_submlist );
return p_ret;
}
/**************************************************************************
* 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 );
}
static void services_discovery_item_removed( const vlc_event_t * p_event,
void * user_data )
{
input_item_t * p_item = p_event->u.services_discovery_item_added.p_new_item;
libvlc_media_t * p_md;
libvlc_media_discoverer_t * p_mdis = user_data;
int i, count = libvlc_media_list_count( p_mdis->p_mlist, NULL );
libvlc_media_list_lock( p_mdis->p_mlist );
for( i = 0; i < count; i++ )
{
p_md = libvlc_media_list_item_at_index( p_mdis->p_mlist, i, NULL );
if( p_md->p_input_item == p_item )
{
_libvlc_media_list_remove_index( p_mdis->p_mlist, i, NULL );
break;
}
}
libvlc_media_list_unlock( p_mdis->p_mlist );
}
static void
install_md_listener( libvlc_media_list_view_t * p_mlv,
libvlc_media_t * p_md)
{
libvlc_media_list_t * p_mlist;
if((p_mlist = libvlc_media_subitems( p_md )))
{
libvlc_media_list_lock( p_mlist );
int i, count = libvlc_media_list_count( p_mlist, NULL );
for( i = 0; i < count; i++)
{
libvlc_event_t added_event;
libvlc_media_t * p_submd;
p_submd = libvlc_media_list_item_at_index( p_mlist, i, NULL );
/* Install our listeners */
install_md_listener( p_mlv, p_submd );
/* For each item, send a notification to the mlv subclasses */
added_event.u.media_list_item_added.item = p_submd;
added_event.u.media_list_item_added.index = 0;
if( p_mlv->pf_ml_item_added ) p_mlv->pf_ml_item_added( &added_event, p_mlv );
libvlc_media_release( p_submd );
}
libvlc_event_attach( p_mlist->p_event_manager,
libvlc_MediaListItemAdded,
media_list_item_added, p_mlv, NULL );
libvlc_event_attach( p_mlist->p_event_manager,
libvlc_MediaListItemDeleted,
media_list_item_removed, p_mlv, NULL );
libvlc_media_list_unlock( p_mlist );
libvlc_media_list_release( p_mlist );
}
else
{
/* No mlist, wait for a subitem added event */
libvlc_event_attach( p_md->p_event_manager,
libvlc_MediaSubItemAdded,
media_list_subitem_added, p_mlv, NULL );
}
}
static void services_discovery_item_removed( services_discovery_t *sd,
input_item_t *p_item )
{
libvlc_media_t * p_md;
libvlc_media_discoverer_t *p_mdis = sd->owner.sys;
int i, count = libvlc_media_list_count( p_mdis->p_mlist );
libvlc_media_list_lock( p_mdis->p_mlist );
for( i = 0; i < count; i++ )
{
p_md = libvlc_media_list_item_at_index( p_mdis->p_mlist, i );
assert(p_md != NULL);
if( p_md->p_input_item == p_item )
{
libvlc_media_list_internal_remove_index( p_mdis->p_mlist, i );
libvlc_media_release( p_md );
break;
}
libvlc_media_release( p_md );
}
libvlc_media_list_unlock( p_mdis->p_mlist );
}
/**************************************************************************
* flat_media_list_view_count (private)
* (called by media_list_view_count)
**************************************************************************/
static int
hierarch_node_media_list_view_count( libvlc_media_list_view_t * p_mlv,
libvlc_exception_t * p_e )
{
/* FIXME: we may want to cache that */
int i, ret, count = libvlc_media_list_count( p_mlv->p_mlist, p_e );
libvlc_media_t * p_md;
libvlc_media_list_t * p_submlist;
ret = 0;
trace("\n");
for( i = 0; i < count; i++ )
{
p_md = libvlc_media_list_item_at_index( p_mlv->p_mlist, i, p_e );
if( !p_md ) continue;
p_submlist = libvlc_media_subitems( p_md );
if( !p_submlist ) continue;
libvlc_media_release( p_md );
libvlc_media_list_release( p_submlist );
ret++;
}
return ret;
}
/* Helper */
static int
index_of_item( libvlc_media_list_view_t * p_mlv, libvlc_media_t * p_md )
{
libvlc_media_t * p_iter_md;
libvlc_media_list_t * p_submlist;
int i, current_index, count = libvlc_media_list_count( p_mlv->p_mlist, NULL );
current_index = -1;
for( i = 0; i < count; i++ )
{
p_iter_md = libvlc_media_list_item_at_index( p_mlv->p_mlist, i, NULL );
if( !p_iter_md ) continue;
p_submlist = libvlc_media_subitems( p_iter_md );
if( !p_submlist ) continue;
libvlc_media_list_release( p_submlist );
libvlc_media_release( p_iter_md );
current_index++;
if( p_md == p_iter_md )
return current_index;
}
return -1;
}
bool VlcPlugin::playlist_select( int idx, libvlc_exception_t *ex )
{
libvlc_media_t *p_m = NULL;
libvlc_media_list_lock(libvlc_media_list);
int count = libvlc_media_list_count(libvlc_media_list,ex);
if( libvlc_exception_raised(ex) )
goto bad_unlock;
if( idx<0||idx>=count )
goto bad_unlock;
playlist_index = idx;
p_m = libvlc_media_list_item_at_index(libvlc_media_list,playlist_index,ex);
libvlc_media_list_unlock(libvlc_media_list);
if( libvlc_exception_raised(ex) )
return false;
if( libvlc_media_player )
{
libvlc_media_player_release( libvlc_media_player );
libvlc_media_player = NULL;
}
libvlc_media_player = libvlc_media_player_new_from_media(p_m,ex);
if( libvlc_media_player )
set_player_window(ex);
libvlc_media_release( p_m );
return !libvlc_exception_raised(ex);
bad_unlock:
libvlc_media_list_unlock(libvlc_media_list);
return false;
}
MediaMeta VLCWrapper::GetItemMeta (int row, const QString& location) const
{
MediaMeta meta;
auto m = libvlc_media_list_item_at_index (List_.get (), row);
if (!m)
return meta;
if (!QUrl (location).scheme ().isEmpty ())
{
meta.Artist_ = tr ("Internet stream");
meta.Title_ = location;
return meta;
}
libvlc_media_parse (m);
meta.Artist_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Artist));
meta.Album_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Album));
meta.Title_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Title));
meta.Genre_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Genre));
meta.Date_ = libvlc_media_get_meta (m, libvlc_meta_Date);
meta.Length_ = libvlc_media_get_duration (m) / 1000;
if (location.isNull ())
meta.Location_ = QUrl (libvlc_media_get_mrl (m));
else
meta.Location_ = QUrl (location);
libvlc_media_track_info_t *pTrackInfo;
int numOfStream = libvlc_media_get_tracks_info (m, &pTrackInfo);
if (numOfStream >= 1)
meta.Type_ = pTrackInfo->i_type;
meta.TrackNumber_ = QString (libvlc_media_get_meta (m,
libvlc_meta_TrackNumber))
.toInt ();
return meta;
}
/**************************************************************************
* libvlc_media_list_view_set_ml_notification_callback (Internal)
* The mlist lock should be held when entered
**************************************************************************/
void
libvlc_media_list_view_set_ml_notification_callback(
libvlc_media_list_view_t * p_mlv,
void (*item_added)(const libvlc_event_t *, libvlc_media_list_view_t *),
void (*item_removed)(const libvlc_event_t *, libvlc_media_list_view_t *) )
{
p_mlv->pf_ml_item_added = item_added;
p_mlv->pf_ml_item_removed = item_removed;
libvlc_event_attach( p_mlv->p_mlist->p_event_manager,
libvlc_MediaListItemAdded,
media_list_item_added, p_mlv, NULL );
libvlc_event_attach( 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 );
install_md_listener( p_mlv, p_md );
libvlc_media_release( p_md );
}
}
void VLCWrapper::setMeta (libvlc_meta_t type, const QString& value, int index)
{
auto m = libvlc_media_list_item_at_index (List_.get (), index);
libvlc_media_set_meta (m, type, value.toUtf8 ());
libvlc_media_save_meta (m);
}
static void test_media_list (const char ** argv, int argc)
{
libvlc_instance_t *vlc;
libvlc_media_t *md, *md1, *md2, *md3, *md4;
libvlc_media_list_t *ml;
int ret;
log ("Testing media_list\n");
vlc = libvlc_new (argc, argv);
assert (vlc != NULL);
ml = libvlc_media_list_new (vlc);
assert (ml != NULL);
md1 = libvlc_media_new_path (vlc, "/dev/null");
assert (md1 != NULL);
md2 = libvlc_media_new_path (vlc, "/dev/null");
assert (md2 != NULL);
md3 = libvlc_media_new_path (vlc, "/dev/null");
assert (md3 != NULL);
ret = libvlc_media_list_add_media (ml, md1);
assert (!ret);
ret = libvlc_media_list_add_media (ml, md2);
assert (!ret);
assert( libvlc_media_list_count (ml) == 2 );
assert( libvlc_media_list_index_of_item (ml, md1) == 0 );
assert( libvlc_media_list_index_of_item (ml, md2) == 1 );
ret = libvlc_media_list_remove_index (ml, 0); /* removing first item */
assert (!ret);
/* test if second item was moved on first place */
assert( libvlc_media_list_index_of_item (ml, md2) == 0 );
ret = libvlc_media_list_add_media (ml, md1); /* add 2 items */
assert (!ret);
ret = libvlc_media_list_add_media (ml, md1);
assert (!ret);
/* there should be 3 pieces */
assert( libvlc_media_list_count (ml) == 3 );
ret = libvlc_media_list_insert_media (ml, md3, 2);
assert (!ret);
/* there should be 4 pieces */
assert( libvlc_media_list_count (ml) == 4 );
/* test inserting on right place */
assert( libvlc_media_list_index_of_item (ml, md3) == 2 );
/* test right returning descriptor*/
md = libvlc_media_list_item_at_index (ml, 0);
assert(md == md2);
libvlc_media_release(md);
md = libvlc_media_list_item_at_index (ml, 2);
assert(md == md3);
libvlc_media_release(md);
/* test if give errors, when it should */
/* have 4 items, so index 4 should give error */
ret = libvlc_media_list_remove_index (ml, 4);
assert (ret == -1);
ret = libvlc_media_list_remove_index (ml, 100);
assert (ret == -1);
ret = libvlc_media_list_remove_index (ml, -1);
assert (ret == -1);
/* getting non valid items */
libvlc_media_t * p_non_exist =
libvlc_media_list_item_at_index (ml, 4);
assert (p_non_exist == NULL);
p_non_exist = libvlc_media_list_item_at_index (ml, 100);
assert (p_non_exist == NULL);
p_non_exist = libvlc_media_list_item_at_index (ml, -1);
assert (p_non_exist == NULL);
md4 = libvlc_media_new_path (vlc, "/dev/null");
assert (md4 != NULL);
/* try to find non inserted item */
int i_non_exist = 0;
i_non_exist = libvlc_media_list_index_of_item (ml, md4);
assert ( i_non_exist == -1 );
libvlc_media_release (md1);
libvlc_media_release (md2);
libvlc_media_release (md3);
libvlc_media_release (md4);
libvlc_media_list_release (ml);
libvlc_release (vlc);
}
/*
* List media instance in media list at a position
* The {#lock} should be held upon entering this function.
*
* @param [Integer] pos position in array
* @return [VLC::Media] media instance at position or nil
* @todo fixme
*/
static VALUE
rg_get_media(VALUE self, VALUE pos)
{
/* TODO: need libvlc_media_release? */
return VLCMEDIA2RVAL(libvlc_media_list_item_at_index(_SELF(self), NUM2INT(pos)));
}
