static void services_discovery_ended( const vlc_event_t * p_event,
void * user_data )
{
VLC_UNUSED(p_event);
libvlc_media_discoverer_t * p_mdis = user_data;
libvlc_media_list_t * p_mlist = p_mdis->p_mlist;
libvlc_event_t event;
p_mdis->running = false;
libvlc_media_list_lock( p_mlist );
libvlc_media_list_internal_end_reached( p_mlist );
libvlc_media_list_unlock( p_mlist );
event.type = libvlc_MediaDiscovererEnded;
libvlc_event_send( p_mdis->p_event_manager, &event );
}
int VlcPlugin::playlist_add( const char *mrl, libvlc_exception_t *ex )
{
int item = -1;
libvlc_media_t *p_m = libvlc_media_new(libvlc_instance,mrl,ex);
if( libvlc_exception_raised(ex) )
return -1;
libvlc_media_list_lock(libvlc_media_list);
libvlc_media_list_add_media(libvlc_media_list,p_m,ex);
if( !libvlc_exception_raised(ex) )
item = libvlc_media_list_count(libvlc_media_list,ex)-1;
libvlc_media_list_unlock(libvlc_media_list);
libvlc_media_release(p_m);
return item;
}
static void send_parsed_changed( libvlc_media_t *p_md,
libvlc_media_parsed_status_t new_status )
{
libvlc_event_t event;
vlc_mutex_lock( &p_md->parsed_lock );
if( p_md->parsed_status == new_status )
{
vlc_mutex_unlock( &p_md->parsed_lock );
return;
}
/* Legacy: notify libvlc_media_parse */
if( !p_md->is_parsed )
{
p_md->is_parsed = true;
vlc_cond_broadcast( &p_md->parsed_cond );
}
p_md->parsed_status = new_status;
if( p_md->parsed_status == libvlc_media_parsed_status_skipped )
p_md->has_asked_preparse = false;
vlc_mutex_unlock( &p_md->parsed_lock );
if( new_status == libvlc_media_parsed_status_done )
{
libvlc_media_list_t *p_subitems = media_get_subitems( p_md, false );
if( p_subitems != NULL )
{
/* notify the media list */
libvlc_media_list_lock( p_subitems );
libvlc_media_list_internal_end_reached( p_subitems );
libvlc_media_list_unlock( p_subitems );
}
}
/* Construct the event */
event.type = libvlc_MediaParsedChanged;
event.u.media_parsed_changed.new_status = new_status;
/* Send the event */
libvlc_event_send( p_md->p_event_manager, &event );
}
/**************************************************************************
* 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 );
}
/**************************************************************************
* input_item_preparse_ended (Private) (vlc event Callback)
**************************************************************************/
static void input_item_preparse_ended( const vlc_event_t * p_event,
void * user_data )
{
VLC_UNUSED( p_event );
libvlc_media_t * p_md = user_data;
libvlc_media_list_t *p_subitems = media_get_subitems( p_md, false );
libvlc_event_t event;
event.type = libvlc_MediaParsedStatus;
vlc_mutex_lock(&p_md->parsed_lock);
switch (p_event->u.input_item_preparse_ended.new_status)
{
case ITEM_PREPARSE_SKIPPED:
p_md->parsed_status = libvlc_media_parse_skipped;
p_md->has_asked_preparse = false;
break;
case ITEM_PREPARSE_FAILED:
p_md->parsed_status = libvlc_media_parse_failed;
break;
case ITEM_PREPARSE_DONE:
p_md->parsed_status = libvlc_media_parse_done;
break;
}
event.u.media_parsed_status.new_status = p_md->parsed_status;
vlc_mutex_unlock(&p_md->parsed_lock);
if( p_subitems != NULL )
{
/* notify the media list */
libvlc_media_list_lock( p_subitems );
libvlc_media_list_internal_end_reached( p_subitems );
libvlc_media_list_unlock( p_subitems );
}
/* XXX: libVLC 2.2.0 compat: even if case of preparse failure,
* libvlc_MediaParsedChanged was sent with a true status. Therefore, send
* this event if it was not previously sent */
send_preparsed_event(p_md);
libvlc_event_send(p_md->p_event_manager, &event);
}
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 );
}
int VlcPlugin::playlist_add_extended_untrusted( const char *mrl, const char *name,
int optc, const char **optv, libvlc_exception_t *ex )
{
libvlc_media_t *p_m = libvlc_media_new(libvlc_instance, mrl,ex);
int item = -1;
if( libvlc_exception_raised(ex) )
return -1;
for( int i = 0; i < optc; ++i )
libvlc_media_add_option_flag(p_m, optv[i], libvlc_media_option_unique);
libvlc_media_list_lock(libvlc_media_list);
libvlc_media_list_add_media(libvlc_media_list,p_m,ex);
if( !libvlc_exception_raised(ex) )
item = libvlc_media_list_count(libvlc_media_list,ex)-1;
libvlc_media_list_unlock(libvlc_media_list);
libvlc_media_release(p_m);
return item;
}
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 );
}
/**************************************************************************
* Set relative playlist position and play (Private)
*
* Sets the currently played item to the given relative play item position
* (based on the currently playing item) and then begins the new item playback.
* Lock must be held.
**************************************************************************/
static void set_relative_playlist_position_and_play(
libvlc_media_list_player_t * p_mlp,
int i_relative_position,
libvlc_exception_t * p_e)
{
assert_locked(p_mlp);
if (!p_mlp->p_mlist)
{
libvlc_exception_raise(p_e);
libvlc_printerr("No media list");
return;
}
libvlc_media_list_lock(p_mlp->p_mlist);
libvlc_media_list_path_t path = p_mlp->current_playing_item_path;
if(p_mlp->e_playback_mode != libvlc_playback_mode_repeat)
{
bool b_loop = (p_mlp->e_playback_mode == libvlc_playback_mode_loop);
if(i_relative_position > 0)
{
do
{
path = get_next_path(p_mlp, b_loop);
set_current_playing_item(p_mlp, path);
--i_relative_position;
}
while(i_relative_position > 0);
}
else if(i_relative_position < 0)
{
do
{
path = get_previous_path(p_mlp, b_loop);
set_current_playing_item(p_mlp, path);
++i_relative_position;
}
while (i_relative_position < 0);
}
}
else
{
set_current_playing_item(p_mlp, path);
}
#ifdef DEBUG_MEDIA_LIST_PLAYER
printf("Playing:");
libvlc_media_list_path_dump(path);
#endif
if (!path)
{
libvlc_media_list_unlock(p_mlp->p_mlist);
stop(p_mlp, p_e);
return;
}
libvlc_media_player_play(p_mlp->p_mi, p_e);
libvlc_media_list_unlock(p_mlp->p_mlist);
/* Send the next item event */
libvlc_event_t event;
event.type = libvlc_MediaListPlayerNextItemSet;
libvlc_media_t * p_md = libvlc_media_list_item_at_path(p_mlp->p_mlist, path);
event.u.media_list_player_next_item_set.item = p_md;
libvlc_event_send(p_mlp->p_event_manager, &event);
libvlc_media_release(p_md);
}
void VlcPlugin::playlist_delete_item( int idx, libvlc_exception_t *ex )
{
libvlc_media_list_lock(libvlc_media_list);
libvlc_media_list_remove_index(libvlc_media_list,idx,ex);
libvlc_media_list_unlock(libvlc_media_list);
}
void VideoSource::UpdateSettings()
{
EnterCriticalSection(&textureLock);
isRendering = false;
LeaveCriticalSection(&textureLock);
if (mediaPlayer) {
libvlc_video_set_callbacks(mediaPlayer, nullptr, nullptr, nullptr, nullptr);
libvlc_media_player_stop(mediaPlayer);
}
config->Reload();
hasSetVolume = false;
videoSize.x = float(config->width);
videoSize.y = float(config->height);
if (mediaPlayer == nullptr) {
mediaPlayer = libvlc_media_player_new(vlc);
libvlc_event_manager_t *em = libvlc_media_player_event_manager(mediaPlayer);
libvlc_event_attach(em, libvlc_MediaPlayerEndReached, vlcEvent, this);
libvlc_event_attach(em, libvlc_MediaPlayerPlaying, vlcEvent, this);
}
if (mediaListPlayer == nullptr) {
mediaListPlayer = libvlc_media_list_player_new(vlc);
libvlc_media_list_player_set_media_player(mediaListPlayer, mediaPlayer);
} else {
libvlc_media_list_player_stop(mediaListPlayer);
}
if (mediaList) {
libvlc_media_list_lock(mediaList);
while(libvlc_media_list_count(mediaList)) {
libvlc_media_list_remove_index(mediaList, 0);
}
libvlc_media_list_unlock(mediaList);
} else {
mediaList = libvlc_media_list_new(vlc);
libvlc_media_list_player_set_media_list(mediaListPlayer, mediaList);
}
char *utf8PathOrUrl;
for(unsigned int i = 0; i < config->playlist.Num(); i++) {
String &mediaEntry = config->playlist[i];
String token = mediaEntry.GetToken(1, L':');
// .. Yup.
bool isStream = token.Length() >= 2 && token[0] == L'/' && token[1] == L'/';
utf8PathOrUrl = config->playlist[i].CreateUTF8String();
if (utf8PathOrUrl) {
libvlc_media_t *media;
if (!isStream) {
media = libvlc_media_new_path(vlc, utf8PathOrUrl);
} else {
media = libvlc_media_new_location(vlc, utf8PathOrUrl);
}
libvlc_media_list_lock(mediaList);
libvlc_media_list_add_media(mediaList, media);
libvlc_media_list_unlock(mediaList);
libvlc_media_release(media);
Free(utf8PathOrUrl);
}
}
if (!config->isPlaylistLooping) {
remainingVideos = config->playlist.Num();
}
libvlc_video_set_callbacks(mediaPlayer, lock, unlock, display, this);
libvlc_video_set_format_callbacks(mediaPlayer, videoFormatProxy, videoCleanupProxy);
libvlc_media_list_player_set_playback_mode(mediaListPlayer, config->isPlaylistLooping ? libvlc_playback_mode_loop : libvlc_playback_mode_default);
if (!audioOutputStreamHandler) {
audioOutputStreamHandler = new AudioOutputStreamHandler(vlc, mediaPlayer);
}
audioOutputStreamHandler->SetOutputParameters(
config->audioOutputType,
config->audioOutputTypeDevice,
config->audioOutputDevice,
config->isAudioOutputToStream);
audioOutputStreamHandler->SetVolume(config->volume);
// set (possibly in vane) the volume. If it doesn't work it will try later until it works
// vlc... que pasa amigo
hasSetVolume = libvlc_audio_set_volume(mediaPlayer, config->volume) == 0;
EnterCriticalSection(&textureLock);
isRendering = true;
LeaveCriticalSection(&textureLock);
libvlc_media_list_player_play(mediaListPlayer);
}
/*
* Release lock on media list items
* The {#lock} should be held upon entering this function.
*
* @return self
* @todo fixme
*/
static VALUE
rg_unlock(VALUE self)
{
libvlc_media_list_unlock(_SELF(self));
return self;
}
