void InputManager::requestArtUpdate( input_item_t *p_item, bool b_forced )
{
bool b_current_item = false;
if ( !p_item && hasInput() )
{ /* default to current item */
p_item = input_GetItem( p_input );
b_current_item = true;
}
if ( p_item )
{
/* check if it has already been enqueued */
if ( p_item->p_meta && !b_forced )
{
int status = vlc_meta_GetStatus( p_item->p_meta );
if ( status & ( ITEM_ART_NOTFOUND|ITEM_ART_FETCHED ) )
return;
}
libvlc_ArtRequest( p_intf->obj.libvlc, p_item,
(b_forced) ? META_REQUEST_OPTION_SCOPE_ANY
: META_REQUEST_OPTION_NONE );
/* No input will signal the cover art to update,
* let's do it ourself */
if ( b_current_item )
UpdateArt();
else
emit artChanged( p_item );
}
}
static int media_parse(libvlc_media_t *media)
{
libvlc_int_t *libvlc = media->p_libvlc_instance->p_libvlc_int;
input_item_t *item = media->p_input_item;
/* TODO: Fetch art on need basis. But how not to break compatibility? */
libvlc_ArtRequest(libvlc, item, META_REQUEST_OPTION_NONE);
return libvlc_MetaRequest(libvlc, item, META_REQUEST_OPTION_NONE);
}
/**
* Start the input for an item
*
* \param p_playlist the playlist object
* \param p_item the item to play
* \return nothing
*/
static void PlayItem( playlist_t *p_playlist, playlist_item_t *p_item )
{
playlist_private_t *p_sys = pl_priv(p_playlist);
input_item_t *p_input = p_item->p_input;
PL_ASSERT_LOCKED;
msg_Dbg( p_playlist, "creating new input thread" );
p_item->i_nb_played++;
set_current_status_item( p_playlist, p_item );
p_sys->status.i_status = PLAYLIST_RUNNING;
assert( p_sys->p_input == NULL );
PL_UNLOCK;
input_thread_t *p_input_thread = input_Create( p_playlist, p_input, NULL,
p_sys->p_input_resource );
if( likely(p_input_thread != NULL) )
{
var_AddCallback( p_input_thread, "intf-event",
InputEvent, p_playlist );
if( input_Start( p_input_thread ) )
{
var_DelCallback( p_input_thread, "intf-event",
InputEvent, p_playlist );
vlc_object_release( p_input_thread );
p_input_thread = NULL;
}
}
var_SetAddress( p_playlist, "input-current", p_input_thread );
/* TODO store art policy in playlist private data */
char *psz_arturl = input_item_GetArtURL( p_input );
/* p_input->p_meta should not be null after a successful CreateThread */
bool b_has_art = !EMPTY_STR( psz_arturl );
if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) )
{
PL_DEBUG( "requesting art for new input thread" );
libvlc_ArtRequest( p_playlist->p_libvlc, p_input, META_REQUEST_OPTION_NONE );
}
free( psz_arturl );
var_TriggerCallback( p_playlist, "activity" );
PL_LOCK;
p_sys->p_input = p_input_thread;
}
static int media_parse(libvlc_media_t *media, bool b_async,
libvlc_media_parse_flag_t parse_flag)
{
bool needed;
vlc_mutex_lock(&media->parsed_lock);
needed = !media->has_asked_preparse;
media->has_asked_preparse = true;
if (needed)
media->is_parsed = false;
vlc_mutex_unlock(&media->parsed_lock);
if (needed)
{
libvlc_int_t *libvlc = media->p_libvlc_instance->p_libvlc_int;
input_item_t *item = media->p_input_item;
input_item_meta_request_option_t art_scope = META_REQUEST_OPTION_NONE;
input_item_meta_request_option_t parse_scope = META_REQUEST_OPTION_SCOPE_LOCAL;
int ret;
if (parse_flag & libvlc_media_fetch_local)
art_scope |= META_REQUEST_OPTION_SCOPE_LOCAL;
if (parse_flag & libvlc_media_fetch_network)
art_scope |= META_REQUEST_OPTION_SCOPE_NETWORK;
if (art_scope != META_REQUEST_OPTION_NONE) {
ret = libvlc_ArtRequest(libvlc, item, art_scope);
if (ret != VLC_SUCCESS)
return ret;
}
if (parse_flag & libvlc_media_parse_network)
parse_scope |= META_REQUEST_OPTION_SCOPE_NETWORK;
if (parse_flag & libvlc_media_do_interact)
parse_scope |= META_REQUEST_OPTION_DO_INTERACT;
ret = libvlc_MetaRequest(libvlc, item, parse_scope);
if (ret != VLC_SUCCESS)
return ret;
}
else
return VLC_EGENERIC;
if (!b_async)
{
vlc_mutex_lock(&media->parsed_lock);
while (!media->is_parsed)
vlc_cond_wait(&media->parsed_cond, &media->parsed_lock);
vlc_mutex_unlock(&media->parsed_lock);
}
return VLC_SUCCESS;
}
/**
* Start the input for an item
*
* \param p_playlist the playlist object
* \param p_item the item to play
* \return nothing
*/
static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item )
{
playlist_private_t *p_sys = pl_priv(p_playlist);
input_item_t *p_input = p_item->p_input;
PL_ASSERT_LOCKED;
msg_Dbg( p_playlist, "creating new input thread" );
p_input->i_nb_played++;
set_current_status_item( p_playlist, p_item );
p_sys->status.i_status = PLAYLIST_RUNNING;
assert( p_sys->p_input == NULL );
input_thread_t *p_input_thread = input_Create( p_playlist, p_input, NULL, p_sys->p_input_resource );
if( p_input_thread )
{
p_sys->p_input = p_input_thread;
var_AddCallback( p_input_thread, "intf-event", InputEvent, p_playlist );
var_SetAddress( p_playlist, "input-current", p_input_thread );
if( input_Start( p_sys->p_input ) )
{
vlc_object_release( p_input_thread );
p_sys->p_input = p_input_thread = NULL;
}
}
bool b_find_art = var_GetInteger( p_playlist, "album-art" )
== ALBUM_ART_WHEN_PLAYED;
if( b_find_art )
{
char *psz_uri = input_item_GetURI( p_item->p_input );
if( psz_uri != NULL && (!strncmp( psz_uri, "directory:", 10 ) ||
!strncmp( psz_uri, "vlc:", 4 )) )
b_find_art = false;
free( psz_uri );
}
/* TODO store art policy in playlist private data */
if( b_find_art )
{
char *psz_arturl = input_item_GetArtURL( p_input );
char *psz_name = input_item_GetName( p_input );
/* p_input->p_meta should not be null after a successful CreateThread */
bool b_has_art = !EMPTY_STR( psz_arturl );
if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) )
{
PL_DEBUG( "requesting art for %s", psz_name );
libvlc_ArtRequest( p_playlist->p_libvlc, p_input );
}
free( psz_arturl );
free( psz_name );
}
PL_UNLOCK;
var_TriggerCallback( p_playlist, "activity" );
PL_LOCK;
return VLC_SUCCESS;
}
