void CmdPlaylistLoad::execute()
{
char* psz_path = vlc_uri2path( m_file.c_str() );
if ( !psz_path )
{
msg_Err(getIntf(),"unable to load playlist %s", m_file.c_str() );
return;
}
playlist_Import( getPL(), psz_path );
free( psz_path );
}
/* Decode URL (which has had its scheme stripped earlier) to a file path. */
char *get_path(const char *location)
{
char *url, *path;
/* Prepending "file://" is a bit hackish. But then again, we do not want
* to hard-code the list of schemes that use file paths in vlc_uri2path().
*/
if (asprintf(&url, "file://%s", location) == -1)
return NULL;
path = vlc_uri2path (url);
free (url);
return path;
}
const QString InputManager::decodeArtURL( input_item_t *p_item )
{
assert( p_item );
char *psz_art = input_item_GetArtURL( p_item );
if( psz_art )
{
char *psz = vlc_uri2path( psz_art );
free( psz_art );
psz_art = psz;
}
#if 0
/* Taglib seems to define a attachment://, It won't work yet */
url = url.replace( "attachment://", "" );
#endif
QString path = qfu( psz_art ? psz_art : "" );
free( psz_art );
return path;
}
void TopWindow::processEvent( EvtDragDrop &rEvtDragDrop )
{
// Get the control hit by the mouse
int xPos = rEvtDragDrop.getXPos() - getLeft();
int yPos = rEvtDragDrop.getYPos() - getTop();
CtrlGeneric *pHitControl = findHitControl( xPos, yPos );
if( pHitControl && pHitControl->getType() == "tree" )
{
// Send a dragDrop event
EvtDragDrop evt( getIntf(), xPos, yPos, rEvtDragDrop.getFiles() );
pHitControl->handleEvent( evt );
}
else
{
input_thread_t *pInput = getIntf()->p_sys->p_input;
bool is_subtitle = false;
std::list<std::string> files = rEvtDragDrop.getFiles();
if( files.size() == 1 && pInput != NULL )
{
std::list<std::string>::const_iterator it = files.begin();
char* psz_file = vlc_uri2path( it->c_str() );
if( psz_file )
{
is_subtitle = !input_AddSubtitleOSD( pInput, psz_file, true, true );
free( psz_file );
}
}
if( !is_subtitle )
{
std::list<std::string>::const_iterator it = files.begin();
for( bool first = true; it != files.end(); ++it, first = false )
{
bool playOnDrop = m_playOnDrop && first;
CmdAddItem( getIntf(), it->c_str(), playOnDrop ).execute();
}
}
}
m_pDragControl = NULL;
}
void VlcProc::update_current_input()
{
input_thread_t* pInput = getIntf()->p_sys->p_input;
if( !pInput )
return;
input_item_t *pItem = input_GetItem( pInput );
if( pItem )
{
// Update short name (as defined by --input-title-format)
char *psz_fmt = var_InheritString( getIntf(), "input-title-format" );
char *psz_name = NULL;
if( psz_fmt != NULL )
{
psz_name = vlc_strfinput( pInput, psz_fmt );
free( psz_fmt );
}
SET_TEXT( m_cVarStreamName, UString( getIntf(),
psz_name ? psz_name : "" ) );
free( psz_name );
// Update local path (if possible) or full uri
char *psz_uri = input_item_GetURI( pItem );
char *psz_path = vlc_uri2path( psz_uri );
char *psz_save = psz_path ? psz_path : psz_uri;
SET_TEXT( m_cVarStreamURI, UString( getIntf(), psz_save ) );
free( psz_path );
free( psz_uri );
// Update art uri
char *psz_art = input_item_GetArtURL( pItem );
SET_STRING( m_cVarStreamArt, std::string( psz_art ? psz_art : "" ) );
free( psz_art );
}
}
void RecentsMRL::addRecent( const QString &mrl )
{
if ( !isActive || ( filter && filter->indexIn( mrl ) >= 0 ) )
return;
#ifdef _WIN32
/* Add to the Windows 7 default list in taskbar */
char* path = vlc_uri2path( qtu( mrl ) );
if( path )
{
wchar_t *wmrl = ToWide( path );
SHAddToRecentDocs( SHARD_PATHW, wmrl );
free( wmrl );
free( path );
}
#endif
int i_index = recents.indexOf( mrl );
if( 0 <= i_index )
{
/* move to the front */
recents.move( i_index, 0 );
times.move( i_index, 0 );
}
else
{
recents.prepend( mrl );
times.prepend( "-1" );
if( recents.count() > RECENTS_LIST_SIZE ) {
recents.takeLast();
times.takeLast();
}
}
VLCMenuBar::updateRecents( p_intf );
save();
}
/*****************************************************************************
* Export_M3U: main export function
*****************************************************************************/
static void DoChildren( playlist_export_t *p_export, playlist_item_t *p_root,
int (*pf_fprintf) (FILE *, const char *, ...) )
{
/* Write header */
fputs( "#EXTM3U\n", p_export->p_file );
/* Go through the playlist and add items */
for( int i = 0; i< p_root->i_children ; i++)
{
playlist_item_t *p_current = p_root->pp_children[i];
assert( p_current );
if( p_current->i_flags & PLAYLIST_SAVE_FLAG )
continue;
if( p_current->i_children >= 0 )
{
DoChildren( p_export, p_current, pf_fprintf );
continue;
}
/* General info */
char *psz_uri = input_item_GetURI( p_current->p_input );
assert( psz_uri );
char *psz_name = input_item_GetName( p_current->p_input );
if( psz_name && strcmp( psz_uri, psz_name ) )
{
char *psz_artist = input_item_GetArtist( p_current->p_input );
if( psz_artist == NULL ) psz_artist = strdup( "" );
mtime_t i_duration = input_item_GetDuration( p_current->p_input );
if( psz_artist && *psz_artist )
{
/* write EXTINF with artist */
pf_fprintf( p_export->p_file, "#EXTINF:%"PRIu64",%s - %s\n",
i_duration / CLOCK_FREQ, psz_artist, psz_name);
}
else
{
/* write EXTINF without artist */
pf_fprintf( p_export->p_file, "#EXTINF:%"PRIu64",%s\n",
i_duration / CLOCK_FREQ, psz_name);
}
free( psz_artist );
}
free( psz_name );
/* VLC specific options */
vlc_mutex_lock( &p_current->p_input->lock );
for( int j = 0; j < p_current->p_input->i_options; j++ )
{
pf_fprintf( p_export->p_file, "#EXTVLCOPT:%s\n",
p_current->p_input->ppsz_options[j][0] == ':' ?
p_current->p_input->ppsz_options[j] + 1 :
p_current->p_input->ppsz_options[j] );
}
vlc_mutex_unlock( &p_current->p_input->lock );
/* Stupid third party players don't understand file: URIs. */
char *psz_path = vlc_uri2path( psz_uri );
if( psz_path != NULL )
{
free( psz_uri );
psz_uri = psz_path;
}
fprintf( p_export->p_file, "%s\n", psz_uri );
free( psz_uri );
}
}
/*****************************************************************************
* ItemChange: Playlist item change callback
*****************************************************************************/
static int ItemChange( vlc_object_t *p_this, const char *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *param )
{
VLC_UNUSED(psz_var); VLC_UNUSED(oldval); VLC_UNUSED(newval);
char psz_tmp[MAX_LENGTH];
char psz_notify[MAX_LENGTH];
char *psz_title;
char *psz_artist;
char *psz_album;
char *psz_arturl;
input_thread_t *p_input = newval.p_address;
intf_thread_t *p_intf = param;
intf_sys_t *p_sys = p_intf->p_sys;
if( !p_input )
return VLC_SUCCESS;
/* Playing something ... */
input_item_t *p_input_item = input_GetItem( p_input );
/* Checking for click on directories */
if(p_input_item->i_type == ITEM_TYPE_DIRECTORY || p_input_item->i_type == ITEM_TYPE_PLAYLIST
|| p_input_item->i_type == ITEM_TYPE_NODE || p_input_item->i_type== ITEM_TYPE_UNKNOWN
|| p_input_item->i_type == ITEM_TYPE_CARD){
return VLC_SUCCESS;
}
psz_title = input_item_GetTitleFbName( p_input_item );
/* We need at least a title */
if( EMPTY_STR( psz_title ) )
{
free( psz_title );
return VLC_SUCCESS;
}
psz_artist = input_item_GetArtist( p_input_item );
psz_album = input_item_GetAlbum( p_input_item );
if( !EMPTY_STR( psz_artist ) )
{
if( !EMPTY_STR( psz_album ) )
snprintf( psz_tmp, MAX_LENGTH, "<b>%s</b>\n%s\n[%s]",
psz_title, psz_artist, psz_album );
else
snprintf( psz_tmp, MAX_LENGTH, "<b>%s</b>\n%s",
psz_title, psz_artist );
}
else
snprintf( psz_tmp, MAX_LENGTH, "<b>%s</b>", psz_title );
free( psz_title );
free( psz_artist );
free( psz_album );
GdkPixbuf *pix = NULL;
psz_arturl = input_item_GetArtURL( p_input_item );
if( psz_arturl )
{
char *psz = vlc_uri2path( psz_arturl );
free( psz_arturl );
psz_arturl = psz;
}
if( psz_arturl )
{ /* scale the art to show it in notify popup */
GError *p_error = NULL;
pix = gdk_pixbuf_new_from_file_at_scale( psz_arturl,
72, 72, TRUE, &p_error );
}
else /* else we show state-of-the art logo */
{
/* First try to get an icon from the current theme. */
GtkIconTheme* p_theme = gtk_icon_theme_get_default();
pix = gtk_icon_theme_load_icon( p_theme, "vlc", 72, 0, NULL);
if( !pix )
{
/* Load icon from share/ */
GError *p_error = NULL;
char *psz_pixbuf = config_GetSysPath(VLC_SYSDATA_DIR,
"icons/hicolor/48x48/"PACKAGE_NAME".png");
if (psz_pixbuf != NULL)
{
pix = gdk_pixbuf_new_from_file( psz_pixbuf, &p_error );
free( psz_pixbuf );
}
}
}
free( psz_arturl );
/* we need to replace '&' with '&' because '&' is a keyword of
* notification-daemon parser */
const int i_len = strlen( psz_tmp );
int i_notify = 0;
for( int i = 0; i < i_len && i_notify < ( MAX_LENGTH - 5 ); i++ )
{ /* we use MAX_LENGTH - 5 because if the last char of psz_tmp is '&'
* we will need 5 more characters: 'amp;\0' .
* however that's unlikely to happen because the last char is '\0' */
if( psz_tmp[i] != '&' )
{
psz_notify[i_notify] = psz_tmp[i];
}
else
{
strcpy( &psz_notify[i_notify], "&" );
i_notify += 4;
}
i_notify++;
}
psz_notify[i_notify] = '\0';
vlc_mutex_lock( &p_sys->lock );
Notify( p_this, psz_notify, pix, p_intf );
vlc_mutex_unlock( &p_sys->lock );
return VLC_SUCCESS;
}
/**
* Update all the MetaData and art on an "item-changed" event
**/
void MetaPanel::update( input_item_t *p_item )
{
if( !p_item )
{
clear();
return;
}
/* Don't update if you are in edit mode */
if( b_inEditMode ) return;
p_input = p_item;
char *psz_meta;
#define UPDATE_META( meta, widget ) { \
psz_meta = input_item_Get##meta( p_item ); \
widget->setText( !EMPTY_STR( psz_meta ) ? qfu( psz_meta ) : "" ); \
free( psz_meta ); }
#define UPDATE_META_INT( meta, widget ) { \
psz_meta = input_item_Get##meta( p_item ); \
if( !EMPTY_STR( psz_meta ) ) \
widget->setValue( atoi( psz_meta ) ); } \
free( psz_meta );
/* Name / Title */
psz_meta = input_item_GetTitleFbName( p_item );
if( psz_meta )
{
title_text->setText( qfu( psz_meta ) );
free( psz_meta );
}
else
title_text->setText( "" );
/* URL / URI */
psz_meta = input_item_GetURI( p_item );
if( !EMPTY_STR( psz_meta ) )
emit uriSet( qfu( psz_meta ) );
fingerprintButton->setVisible( Chromaprint::isSupported( QString( psz_meta ) ) );
free( psz_meta );
/* Other classic though */
UPDATE_META( Artist, artist_text );
UPDATE_META( Genre, genre_text );
UPDATE_META( Copyright, copyright_text );
UPDATE_META( Album, collection_text );
disconnect( description_text, SIGNAL(textChanged()), this,
SLOT(enterEditMode()) );
UPDATE_META( Description, description_text );
CONNECT( description_text, textChanged(), this, enterEditMode() );
UPDATE_META( Language, language_text );
UPDATE_META( NowPlaying, nowplaying_text );
UPDATE_META( Publisher, publisher_text );
UPDATE_META( EncodedBy, encodedby_text );
UPDATE_META( Date, date_text );
UPDATE_META( TrackNum, seqnum_text );
UPDATE_META( TrackTotal, seqtot_text );
// UPDATE_META( Setting, setting_text );
// UPDATE_META_INT( Rating, rating_text );
/* URL */
psz_meta = input_item_GetURL( p_item );
if( !EMPTY_STR( psz_meta ) )
{
QString newURL = qfu(psz_meta);
if( currentURL != newURL )
{
currentURL = newURL;
lblURL->setText( "<a href='" + currentURL + "'>" +
currentURL.remove( QRegExp( ".*://") ) + "</a>" );
}
}
free( psz_meta );
#undef UPDATE_META_INT
#undef UPDATE_META
// If a artURL is available as a local file, directly display it !
QString file;
char *psz_art = input_item_GetArtURL( p_item );
if( psz_art )
{
char *psz = vlc_uri2path( psz_art );
free( psz_art );
file = qfu( psz );
free( psz );
}
art_cover->showArtUpdate( file );
art_cover->setItem( p_item );
}
/**
* Detect subtitle files.
*
* When called this function will split up the psz_name string into a
* directory, filename and extension. It then opens the directory
* in which the file resides and tries to find possible matches of
* subtitles files.
*
* \ingroup Demux
* \param p_this the calling \ref input_thread_t
* \param psz_path a list of subdirectories (separated by a ',') to look in.
* \param psz_name_org the complete filename to base the search on.
* \param pp_slaves an initialized input item slave list to append detected subtitles to
* \param p_slaves pointer to the size of the slave list
* \return VLC_SUCCESS if ok
*/
int subtitles_Detect( input_thread_t *p_this, char *psz_path, const char *psz_name_org,
input_item_slave_t ***ppp_slaves, int *p_slaves )
{
int i_fuzzy = var_GetInteger( p_this, "sub-autodetect-fuzzy" );
if ( i_fuzzy == 0 )
return VLC_EGENERIC;
int j, i_fname_len;
input_item_slave_t **pp_slaves = *ppp_slaves;
int i_slaves = *p_slaves;
char *f_fname_noext = NULL, *f_fname_trim = NULL;
char **subdirs; /* list of subdirectories to look in */
if( !psz_name_org )
return VLC_EGENERIC;
char *psz_fname = vlc_uri2path( psz_name_org );
if( !psz_fname )
return VLC_EGENERIC;
/* extract filename & dirname from psz_fname */
char *f_dir = strdup( psz_fname );
if( f_dir == 0 )
{
free( psz_fname );
return VLC_ENOMEM;
}
const char *f_fname = strrchr( psz_fname, DIR_SEP_CHAR );
if( !f_fname )
{
free( f_dir );
free( psz_fname );
return VLC_EGENERIC;
}
f_fname++; /* Skip the '/' */
f_dir[f_fname - psz_fname] = 0; /* keep dir separator in f_dir */
i_fname_len = strlen( f_fname );
f_fname_noext = malloc(i_fname_len + 1);
f_fname_trim = malloc(i_fname_len + 1 );
if( !f_fname_noext || !f_fname_trim )
{
free( f_dir );
free( f_fname_noext );
free( f_fname_trim );
free( psz_fname );
return VLC_ENOMEM;
}
strcpy_strip_ext( f_fname_noext, f_fname );
strcpy_trim( f_fname_trim, f_fname_noext );
subdirs = paths_to_list( f_dir, psz_path );
for( j = -1; (j == -1) || ( j >= 0 && subdirs != NULL && subdirs[j] != NULL ); j++ )
{
const char *psz_dir = (j < 0) ? f_dir : subdirs[j];
if( psz_dir == NULL || ( j >= 0 && !strcmp( psz_dir, f_dir ) ) )
continue;
/* parse psz_src dir */
DIR *dir = vlc_opendir( psz_dir );
if( dir == NULL )
continue;
msg_Dbg( p_this, "looking for a subtitle file in %s", psz_dir );
const char *psz_name;
while( (psz_name = vlc_readdir( dir )) )
{
if( psz_name[0] == '.' || !subtitles_Filter( psz_name ) )
continue;
char tmp_fname_noext[strlen( psz_name ) + 1];
char tmp_fname_trim[strlen( psz_name ) + 1];
char tmp_fname_ext[strlen( psz_name ) + 1];
const char *tmp;
int i_prio = 0;
/* retrieve various parts of the filename */
strcpy_strip_ext( tmp_fname_noext, psz_name );
strcpy_get_ext( tmp_fname_ext, psz_name );
strcpy_trim( tmp_fname_trim, tmp_fname_noext );
if( !strcmp( tmp_fname_trim, f_fname_trim ) )
{
/* matches the movie name exactly */
i_prio = SLAVE_PRIORITY_MATCH_ALL;
}
else if( (tmp = strstr( tmp_fname_trim, f_fname_trim )) )
{
/* contains the movie name */
tmp += strlen( f_fname_trim );
if( whiteonly( tmp ) )
{
/* chars in front of the movie name */
i_prio = SLAVE_PRIORITY_MATCH_RIGHT;
}
else
{
/* chars after (and possibly in front of)
* the movie name */
i_prio = SLAVE_PRIORITY_MATCH_LEFT;
}
}
else if( j == -1 )
{
/* doesn't contain the movie name, prefer files in f_dir over subdirs */
i_prio = SLAVE_PRIORITY_MATCH_NONE;
}
if( i_prio >= i_fuzzy )
{
struct stat st;
char *path;
size_t i_len = strlen( psz_dir );
const char *psz_format;
if ( i_len == 0 )
continue;
if( psz_dir[i_len - 1] == DIR_SEP_CHAR )
psz_format = "%s%s";
else
psz_format = "%s"DIR_SEP"%s";
if( asprintf( &path, psz_format, psz_dir, psz_name ) < 0 )
continue;
if( strcmp( path, psz_fname )
&& vlc_stat( path, &st ) == 0
&& S_ISREG( st.st_mode ) )
{
msg_Dbg( p_this,
"autodetected subtitle: %s with priority %d",
path, i_prio );
char *psz_uri = vlc_path2uri( path, NULL );
input_item_slave_t *p_sub = psz_uri != NULL ?
input_item_slave_New( psz_uri, SLAVE_TYPE_SPU, i_prio )
: NULL;
if( p_sub )
{
p_sub->b_forced = true;
INSERT_ELEM( pp_slaves, i_slaves, i_slaves, p_sub );
}
free( psz_uri );
}
free( path );
}
}
closedir( dir );
}
if( subdirs )
{
for( j = 0; subdirs[j]; j++ )
free( subdirs[j] );
free( subdirs );
}
free( f_dir );
free( f_fname_trim );
free( f_fname_noext );
free( psz_fname );
for( int i = 0; i < i_slaves; i++ )
{
input_item_slave_t *p_sub = pp_slaves[i];
bool b_reject = false;
char *psz_ext = strrchr( p_sub->psz_uri, '.' );
if( !psz_ext )
continue;
psz_ext++;
if( !strcasecmp( psz_ext, "sub" ) )
{
for( int j = 0; j < i_slaves; j++ )
{
input_item_slave_t *p_sub_inner = pp_slaves[j];
/* A slave can be null if it's already rejected */
if( p_sub_inner == NULL )
continue;
/* check that the filenames without extension match */
if( strncasecmp( p_sub->psz_uri, p_sub_inner->psz_uri,
strlen( p_sub->psz_uri ) - 3 ) )
continue;
char *psz_ext_inner = strrchr( p_sub_inner->psz_uri, '.' );
if( !psz_ext_inner )
continue;
psz_ext_inner++;
/* check that we have an idx file */
if( !strcasecmp( psz_ext_inner, "idx" ) )
{
b_reject = true;
break;
}
}
}
else if( !strcasecmp( psz_ext, "cdg" ) )
{
if( p_sub->i_priority < SLAVE_PRIORITY_MATCH_ALL )
b_reject = true;
}
if( b_reject )
{
pp_slaves[i] = NULL;
input_item_slave_Delete( p_sub );
}
}
/* Sort alphabetically */
if( i_slaves > 0 )
qsort( pp_slaves, i_slaves, sizeof (input_item_slave_t*), slave_strcmp );
*ppp_slaves = pp_slaves; /* in case of realloc */
*p_slaves = i_slaves;
return VLC_SUCCESS;
}
