void XMLParser::LoadCatalog()
{
// Get the resource path and look for the DTD
OSFactory *pOSFactory = OSFactory::instance( getIntf() );
const list<string> &resPath = pOSFactory->getResourcePath();
const string &sep = pOSFactory->getDirSeparator();
list<string>::const_iterator it;
struct stat statBuf;
// Try to load the catalog first (needed at least on win32 where
// we don't have a default catalog)
for( it = resPath.begin(); it != resPath.end(); ++it )
{
string catalog_path = (*it) + sep + "skin.catalog";
if( !vlc_stat( catalog_path.c_str(), &statBuf ) )
{
msg_Dbg( getIntf(), "Using catalog %s", catalog_path.c_str() );
xml_CatalogLoad( m_pXML, catalog_path.c_str() );
break;
}
}
if( it == resPath.end() )
{
// Ok, try the default one
xml_CatalogLoad( m_pXML, NULL );
}
for( it = resPath.begin(); it != resPath.end(); ++it )
{
string path = (*it) + sep + "skin.dtd";
if( !vlc_stat( path.c_str(), &statBuf ) )
{
// DTD found
msg_Dbg( getIntf(), "using DTD %s", path.c_str() );
// Add an entry in the default catalog
xml_CatalogAdd( m_pXML, "public",
"-//VideoLAN//DTD VLC Skins V"
SKINS_DTD_VERSION "//EN", path.c_str() );
break;
}
}
if( it == resPath.end() )
{
msg_Err( getIntf(), "cannot find the skins DTD");
}
}
bool ThemeLoader::load( const string &fileName )
{
string path = getFilePath( fileName );
//Before all, let's see if the file is present
struct stat p_stat;
if( vlc_stat( fileName.c_str(), &p_stat ) )
return false;
// First, we try to un-targz the file, and if it fails we hope it's a XML
// file...
#if defined( HAVE_ZLIB_H )
if( ! extract( sToLocale( fileName ) ) && ! parse( path, fileName ) )
return false;
#else
if( ! parse( path, fileName ) )
return false;
#endif
Theme *pNewTheme = getIntf()->p_sys->p_theme;
if( !pNewTheme )
return false;
// Restore the theme configuration
getIntf()->p_sys->p_theme->loadConfig();
// Retain new loaded skins in config
config_PutPsz( getIntf(), "skins2-last", fileName.c_str() );
return true;
}
/*****************************************************************************
* Check if another part exists and import it
*****************************************************************************/
static bool ImportNextFile( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
char *psz_path = GetFilePath( p_access, FILE_COUNT );
if( !psz_path )
return false;
struct stat st;
if( vlc_stat( psz_path, &st ) )
{
msg_Dbg( p_access, "could not stat %s: %s", psz_path,
vlc_strerror_c(errno) );
free( psz_path );
return false;
}
if( !S_ISREG( st.st_mode ) )
{
msg_Dbg( p_access, "%s is not a regular file", psz_path );
free( psz_path );
return false;
}
msg_Dbg( p_access, "%s exists", psz_path );
free( psz_path );
ARRAY_APPEND( p_sys->file_sizes, st.st_size );
p_sys->size += st.st_size;
return true;
}
char *vlclua_find_file( vlc_object_t *p_this, const char *psz_luadirname, const char *psz_name )
{
char **ppsz_dir_list = NULL;
vlclua_dir_list( p_this, psz_luadirname, &ppsz_dir_list );
for( char **ppsz_dir = ppsz_dir_list; *ppsz_dir; ppsz_dir++ )
{
for( const char **ppsz_ext = ppsz_lua_exts; *ppsz_ext; ppsz_ext++ )
{
char *psz_filename;
struct stat st;
if( asprintf( &psz_filename, "%s"DIR_SEP"%s%s", *ppsz_dir,
psz_name, *ppsz_ext ) < 0 )
{
vlclua_dir_list_free( ppsz_dir_list );
return NULL;
}
if( vlc_stat( psz_filename, &st ) == 0
&& S_ISREG( st.st_mode ) )
{
vlclua_dir_list_free( ppsz_dir_list );
return psz_filename;
}
free( psz_filename );
}
}
vlclua_dir_list_free( ppsz_dir_list );
return NULL;
}
int playlist_MLLoad( playlist_t *p_playlist )
{
input_item_t *p_input;
char *psz_datadir = config_GetUserDir( VLC_DATA_DIR );
if( !psz_datadir ) /* XXX: This should never happen */
{
msg_Err( p_playlist, "no data directory, cannot load media library") ;
return VLC_EGENERIC;
}
char *psz_file;
if( asprintf( &psz_file, "%s" DIR_SEP "ml.xspf", psz_datadir ) == -1 )
psz_file = NULL;
free( psz_datadir );
if( psz_file == NULL )
return VLC_ENOMEM;
/* lousy check for media library file */
struct stat st;
if( vlc_stat( psz_file, &st ) )
{
free( psz_file );
return VLC_EGENERIC;
}
char *psz_uri = vlc_path2uri( psz_file, "file/xspf-open" );
free( psz_file );
if( psz_uri == NULL )
return VLC_ENOMEM;
p_input = input_item_New( psz_uri, _("Media Library") );
free( psz_uri );
if( p_input == NULL )
return VLC_EGENERIC;
PL_LOCK;
if( p_playlist->p_media_library->p_input )
vlc_gc_decref( p_playlist->p_media_library->p_input );
p_playlist->p_media_library->p_input = p_input;
vlc_event_attach( &p_input->event_manager, vlc_InputItemSubItemTreeAdded,
input_item_subitem_tree_added, p_playlist );
PL_UNLOCK;
vlc_object_t *dummy = vlc_object_create( p_playlist, sizeof (*dummy) );
var_Create( dummy, "meta-file", VLC_VAR_VOID );
input_Read( dummy, p_input );
vlc_object_release( dummy );
vlc_event_detach( &p_input->event_manager, vlc_InputItemSubItemTreeAdded,
input_item_subitem_tree_added, p_playlist );
return VLC_SUCCESS;
}
/*****************************************************************************
* Open a directory
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
if( !p_access->psz_filepath )
return VLC_EGENERIC;
/* Some tests can be skipped if this module was explicitly requested.
* That way, the user can play "corrupt" recordings if necessary
* and we can avoid false positives in the general case. */
bool b_strict = strcmp( p_access->psz_name, "vdr" );
/* Do a quick test based on the directory name to see if this
* directory might contain a VDR recording. We can be reasonably
* sure if ScanDirectory() actually finds files. */
if( b_strict )
{
char psz_extension[4];
int i_length = 0;
const char *psz_name = BaseName( p_access->psz_filepath );
if( sscanf( psz_name, "%*u-%*u-%*u.%*u.%*u.%*u%*[-.]%*u.%3s%n",
psz_extension, &i_length ) != 1 || strcasecmp( psz_extension, "rec" ) ||
( psz_name[i_length] != DIR_SEP_CHAR && psz_name[i_length] != '\0' ) )
return VLC_EGENERIC;
}
/* Only directories can be recordings */
struct stat st;
if( vlc_stat( p_access->psz_filepath, &st ) ||
!S_ISDIR( st.st_mode ) )
return VLC_EGENERIC;
access_sys_t *p_sys = vlc_calloc( p_this, 1, sizeof( *p_sys ) );
if( unlikely(p_sys == NULL) )
return VLC_ENOMEM;
p_access->p_sys = p_sys;
p_sys->fd = -1;
p_sys->cur_seekpoint = 0;
p_sys->fps = var_InheritFloat( p_access, "vdr-fps" );
ARRAY_INIT( p_sys->file_sizes );
/* Import all files and prepare playback. */
if( !ScanDirectory( p_access ) ||
!SwitchFile( p_access, 0 ) )
{
Close( p_this );
return VLC_EGENERIC;
}
ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
return VLC_SUCCESS;
}
/**
* @brief Update library if new files found or updated
*/
static void UpdateLibrary( monitoring_thread_t *p_mon )
{
int i_rows, i_cols, i;
char **pp_results;
media_library_t *p_ml = p_mon->p_ml;
struct stat s_stat;
bool b_recursive = var_GetBool( p_mon, "ml-recursive-scan" );
msg_Dbg( p_mon, "Scanning directories" );
Query( p_ml, &pp_results, &i_rows, &i_cols,
"SELECT id AS directory_id, uri AS directory_uri, "
"timestamp AS directory_ts FROM directories" );
msg_Dbg( p_mon, "%d directories to scan", i_rows );
for( i = 1; i <= i_rows; i++ )
{
int id = atoi( pp_results[i*i_cols] );
char *psz_dir = pp_results[i*i_cols+1];
int timestamp = atoi( pp_results[i*i_cols+2] );
if( vlc_stat( psz_dir, &s_stat ) == -1 )
{
int err = errno;
if( err == ENOTDIR || err == ENOENT )
{
msg_Dbg( p_mon, "Removing `%s'", psz_dir );
RemoveDirToMonitor( p_ml, psz_dir );
}
else
{
msg_Err( p_mon, "%s: %m", psz_dir );
FreeSQLResult( p_ml, pp_results );
return;
}
errno = err;
}
if( !S_ISDIR( s_stat.st_mode ) )
{
msg_Dbg( p_mon, "Removing `%s'", psz_dir );
RemoveDirToMonitor( p_ml, psz_dir );
}
if( timestamp < s_stat.st_mtime )
{
msg_Dbg( p_mon, "Adding `%s'", psz_dir );
ScanFiles( p_mon, id, b_recursive, NULL );
}
}
FreeSQLResult( p_ml, pp_results );
}
static int vlclua_stat( lua_State *L )
{
const char *psz_path = luaL_checkstring( L, 1 );
struct stat s;
if( vlc_stat( psz_path, &s ) )
return 0;
//return luaL_error( L, "Couldn't stat %s.", psz_path );
lua_newtable( L );
if( S_ISREG( s.st_mode ) )
lua_pushliteral( L, "file" );
else if( S_ISDIR( s.st_mode ) )
lua_pushliteral( L, "dir" );
#ifdef S_ISCHR
else if( S_ISCHR( s.st_mode ) )
lua_pushliteral( L, "character device" );
#endif
#ifdef S_ISBLK
else if( S_ISBLK( s.st_mode ) )
lua_pushliteral( L, "block device" );
#endif
#ifdef S_ISFIFO
else if( S_ISFIFO( s.st_mode ) )
lua_pushliteral( L, "fifo" );
#endif
#ifdef S_ISLNK
else if( S_ISLNK( s.st_mode ) )
lua_pushliteral( L, "symbolic link" );
#endif
#ifdef S_ISSOCK
else if( S_ISSOCK( s.st_mode ) )
lua_pushliteral( L, "socket" );
#endif
else
lua_pushliteral( L, "unknown" );
lua_setfield( L, -2, "type" );
lua_pushinteger( L, s.st_mode );
lua_setfield( L, -2, "mode" );
lua_pushinteger( L, s.st_uid );
lua_setfield( L, -2, "uid" );
lua_pushinteger( L, s.st_gid );
lua_setfield( L, -2, "gid" );
lua_pushinteger( L, s.st_size );
lua_setfield( L, -2, "size" );
lua_pushinteger( L, s.st_atime );
lua_setfield( L, -2, "access_time" );
lua_pushinteger( L, s.st_mtime );
lua_setfield( L, -2, "modification_time" );
lua_pushinteger( L, s.st_ctime );
lua_setfield( L, -2, "creation_time" );
return 1;
}
/*****************************************************************************
* Run:
*****************************************************************************/
static void *Run( void *data )
{
services_discovery_t *p_sd = data;
services_discovery_sys_t *p_sys = p_sd->p_sys;
int canc = vlc_savecancel();
int num_dir = sizeof( p_sys->psz_dir ) / sizeof( p_sys->psz_dir[0] );
for( int i = 0; i < num_dir; i++ )
{
char* psz_dir = p_sys->psz_dir[i];
/* make sure the directory exists */
struct stat st;
if( psz_dir == NULL ||
vlc_stat( psz_dir, &st ) ||
!S_ISDIR( st.st_mode ) )
continue;
char* psz_uri = make_URI( psz_dir, "file" );
input_item_t* p_root = input_item_New( psz_uri, NULL );
if( p_sys->i_type == Picture )
input_item_AddOption( p_root, "ignore-filetypes=ini,db,lnk,txt",
VLC_INPUT_OPTION_TRUSTED );
input_item_AddOption( p_root, "recursive=collapse",
VLC_INPUT_OPTION_TRUSTED );
vlc_event_manager_t *p_em = &p_root->event_manager;
vlc_event_attach( p_em, vlc_InputItemSubItemAdded,
input_item_subitem_added, p_sd );
input_Read( p_sd, p_root );
vlc_event_detach( p_em, vlc_InputItemSubItemAdded,
input_item_subitem_added, p_sd );
vlc_gc_decref( p_root );
free( psz_uri );
}
vlc_restorecancel(canc);
return NULL;
}
bool ThemeLoader::load( const string &fileName )
{
string path = getFilePath( fileName );
//Before all, let's see if the file is present
struct stat p_stat;
if( vlc_stat( path.c_str(), &p_stat ) )
return false;
// First, we try to un-targz the file, and if it fails we hope it's a XML
// file...
#if defined( HAVE_ZLIB_H )
if( ! extract( sToLocale( fileName ) ) && ! parse( path, fileName ) )
return false;
#else
if( ! parse( path, fileName ) )
return false;
#endif
Theme *pNewTheme = getIntf()->p_sys->p_theme;
if( !pNewTheme )
{
return false;
}
// Check if the skin to load is in the config file, to load its config
char *skin_last = config_GetPsz( getIntf(), "skins2-last" );
if( skin_last != NULL && fileName == (string)skin_last )
{
// Restore the theme configuration
getIntf()->p_sys->p_theme->loadConfig();
// Used to anchor the windows at the beginning
pNewTheme->getWindowManager().stopMove();
}
else
{
config_PutPsz( getIntf(), "skins2-last", fileName.c_str() );
// Show the windows
pNewTheme->getWindowManager().showAll( true );
}
free( skin_last );
return true;
}
/**
* 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;
}
/*****************************************************************************
* ioctl_Open: Opens a VCD device or file and returns an opaque handle
*****************************************************************************/
vcddev_t *ioctl_Open( vlc_object_t *p_this, const char *psz_dev )
{
int i_ret;
int b_is_file;
vcddev_t *p_vcddev;
#if !defined( _WIN32 ) && !defined( __OS2__ )
struct stat fileinfo;
#endif
if( !psz_dev ) return NULL;
/*
* Initialize structure with default values
*/
p_vcddev = malloc( sizeof(*p_vcddev) );
if( p_vcddev == NULL )
return NULL;
p_vcddev->i_vcdimage_handle = -1;
p_vcddev->psz_dev = NULL;
b_is_file = 1;
/*
* Check if we are dealing with a device or a file (vcd image)
*/
#if defined( _WIN32 ) || defined( __OS2__ )
if( (strlen( psz_dev ) == 2 && psz_dev[1] == ':') )
{
b_is_file = 0;
}
#else
if( vlc_stat( psz_dev, &fileinfo ) < 0 )
{
free( p_vcddev );
return NULL;
}
/* Check if this is a block/char device */
if( S_ISBLK( fileinfo.st_mode ) || S_ISCHR( fileinfo.st_mode ) )
b_is_file = 0;
#endif
if( b_is_file )
{
i_ret = OpenVCDImage( p_this, psz_dev, p_vcddev );
}
else
{
/*
* open the vcd device
*/
#ifdef _WIN32
i_ret = win32_vcd_open( p_this, psz_dev, p_vcddev );
#elif defined( __OS2__ )
i_ret = os2_vcd_open( p_this, psz_dev, p_vcddev );
#else
p_vcddev->i_device_handle = -1;
p_vcddev->i_device_handle = vlc_open( psz_dev, O_RDONLY | O_NONBLOCK );
i_ret = (p_vcddev->i_device_handle == -1) ? -1 : 0;
#endif
}
if( i_ret == 0 )
{
p_vcddev->psz_dev = (char *)strdup( psz_dev );
}
else
{
free( p_vcddev );
p_vcddev = NULL;
}
return p_vcddev;
}
int DirRead (stream_t *access, input_item_node_t *node)
{
access_sys_t *sys = access->p_sys;
const char *entry;
int ret = VLC_SUCCESS;
bool special_files = var_InheritBool(access, "list-special-files");
struct vlc_readdir_helper rdh;
vlc_readdir_helper_init(&rdh, access, node);
while (ret == VLC_SUCCESS && (entry = vlc_readdir(sys->dir)) != NULL)
{
struct stat st;
int type;
#ifdef HAVE_OPENAT
if (fstatat(dirfd(sys->dir), entry, &st, 0))
continue;
#else
char path[PATH_MAX];
if (snprintf(path, PATH_MAX, "%s"DIR_SEP"%s", access->psz_filepath,
entry) >= PATH_MAX || vlc_stat(path, &st))
continue;
#endif
switch (st.st_mode & S_IFMT)
{
case S_IFBLK:
if (!special_files)
continue;
type = ITEM_TYPE_DISC;
break;
case S_IFCHR:
if (!special_files)
continue;
type = ITEM_TYPE_CARD;
break;
case S_IFIFO:
if (!special_files)
continue;
type = ITEM_TYPE_STREAM;
break;
case S_IFREG:
type = ITEM_TYPE_FILE;
break;
case S_IFDIR:
type = ITEM_TYPE_DIRECTORY;
break;
/* S_IFLNK cannot occur while following symbolic links */
/* S_IFSOCK cannot be opened with open()/openat() */
default:
continue; /* ignore */
}
/* Create an input item for the current entry */
char *encoded = vlc_uri_encode(entry);
if (unlikely(encoded == NULL))
{
ret = VLC_ENOMEM;
break;
}
char *uri;
if (unlikely(asprintf(&uri, "%s/%s", sys->base_uri, encoded) == -1))
uri = NULL;
free(encoded);
if (unlikely(uri == NULL))
{
ret = VLC_ENOMEM;
break;
}
ret = vlc_readdir_helper_additem(&rdh, uri, NULL, entry, type,
ITEM_NET_UNKNOWN);
free(uri);
}
vlc_readdir_helper_finish(&rdh, ret == VLC_SUCCESS);
return ret;
}
/**
* Recursively browses a directory to look for plug-ins.
*/
static void AllocatePluginDir (module_bank_t *bank, unsigned maxdepth,
const char *absdir, const char *reldir)
{
if (maxdepth == 0)
return;
maxdepth--;
DIR *dh = vlc_opendir (absdir);
if (dh == NULL)
return;
/* Parse the directory and try to load all files it contains. */
for (;;)
{
char *relpath = NULL, *abspath = NULL;
const char *file = vlc_readdir (dh);
if (file == NULL)
break;
/* Skip ".", ".." */
if (!strcmp (file, ".") || !strcmp (file, ".."))
continue;
/* Compute path relative to plug-in base directory */
if (reldir != NULL)
{
if (asprintf (&relpath, "%s"DIR_SEP"%s", reldir, file) == -1)
relpath = NULL;
}
else
relpath = strdup (file);
if (unlikely(relpath == NULL))
continue;
/* Compute absolute path */
if (asprintf (&abspath, "%s"DIR_SEP"%s", bank->base, relpath) == -1)
{
abspath = NULL;
goto skip;
}
struct stat st;
if (vlc_stat (abspath, &st) == -1)
goto skip;
if (S_ISREG (st.st_mode))
{
static const char prefix[] = "lib";
static const char suffix[] = "_plugin"LIBEXT;
size_t len = strlen (file);
#ifndef __OS2__
/* Check that file matches the "lib*_plugin"LIBEXT pattern */
if (len > strlen (suffix)
&& !strncmp (file, prefix, strlen (prefix))
&& !strcmp (file + len - strlen (suffix), suffix))
#else
/* We load all the files ending with LIBEXT on OS/2,
* because OS/2 has a 8.3 length limitation for DLL name */
if (len > strlen (LIBEXT)
&& !strcasecmp (file + len - strlen (LIBEXT), LIBEXT))
#endif
AllocatePluginFile (bank, abspath, relpath, &st);
}
else if (S_ISDIR (st.st_mode))
/* Recurse into another directory */
AllocatePluginDir (bank, maxdepth, abspath, relpath);
skip:
free (relpath);
free (abspath);
}
closedir (dh);
}
static int LoadCatalog( addons_finder_t *p_finder )
{
char *psz_path;
char * psz_userdir = config_GetUserDir( VLC_DATA_DIR );
if ( !psz_userdir ) return VLC_ENOMEM;
if ( asprintf( &psz_path, "%s%s", psz_userdir, ADDONS_CATALOG ) < 1 )
{
free( psz_userdir );
return VLC_ENOMEM;
}
free( psz_userdir );
addon_entry_t *p_entry = NULL;
const char *p_node;
int i_current_node_type;
int i_ret = VLC_SUCCESS;
/* attr */
const char *attr, *value;
/* temp reading */
char *psz_filename = NULL;
int i_filetype = -1;
struct stat stat_;
if ( vlc_stat( psz_path, &stat_ ) )
{
free( psz_path );
return VLC_EGENERIC;
}
char *psz_catalog_uri = vlc_path2uri( psz_path, "file" );
free( psz_path );
if ( !psz_catalog_uri )
return VLC_EGENERIC;
stream_t *p_stream = stream_UrlNew( p_finder, psz_catalog_uri );
free( psz_catalog_uri );
if (! p_stream ) return VLC_EGENERIC;
xml_reader_t *p_xml_reader = xml_ReaderCreate( p_finder, p_stream );
if( !p_xml_reader )
{
stream_Delete( p_stream );
return VLC_EGENERIC;
}
if( xml_ReaderNextNode( p_xml_reader, &p_node ) != XML_READER_STARTELEM )
{
msg_Err( p_finder, "invalid catalog" );
i_ret = VLC_EGENERIC;
goto end;
}
if ( strcmp( p_node, "videolan") )
{
msg_Err( p_finder, "unsupported catalog data format" );
i_ret = VLC_EGENERIC;
goto end;
}
while( (i_current_node_type = xml_ReaderNextNode( p_xml_reader, &p_node )) > 0 )
{
switch( i_current_node_type )
{
case XML_READER_STARTELEM:
{
if ( ! strcmp( p_node, "addon" ) )
{
if ( p_entry ) /* ?!? Unclosed tag */
addon_entry_Release( p_entry );
p_entry = addon_entry_New();
//p_entry->psz_source_module = strdup( ADDONS_MODULE_SHORTCUT );
p_entry->e_flags = ADDON_MANAGEABLE;
p_entry->e_state = ADDON_INSTALLED;
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) )
{
if ( !strcmp( attr, "type" ) )
{
p_entry->e_type = ReadType( value );
}
else if ( !strcmp( attr, "id" ) )
{
addons_uuid_read( value, & p_entry->uuid );
}
else if ( !strcmp( attr, "downloads" ) )
{
p_entry->i_downloads = atoi( value );
if ( p_entry->i_downloads < 0 )
p_entry->i_downloads = 0;
}
else if ( !strcmp( attr, "score" ) )
{
p_entry->i_score = atoi( value );
if ( p_entry->i_score < 0 )
p_entry->i_score = 0;
else if ( p_entry->i_score > ADDON_MAX_SCORE )
p_entry->i_score = ADDON_MAX_SCORE;
}
else if ( !strcmp( attr, "source" ) )
{
p_entry->psz_source_module = strdup( value );
}
else if ( !strcmp( attr, "version" ) )
{
p_entry->psz_version = strdup( value );
}
}
break;
}
if ( !p_entry ) break;
BINDNODE("name", p_entry->psz_name, TYPE_STRING)
BINDNODE("archive", p_entry->psz_archive_uri, TYPE_STRING)
BINDNODE("summary", p_entry->psz_summary, TYPE_STRING)
BINDNODE("description", p_entry->psz_description, TYPE_STRING)
BINDNODE("image", p_entry->psz_image_data, TYPE_STRING)
BINDNODE("resource", psz_filename, TYPE_STRING)
BINDNODE("creator", p_entry->psz_author, TYPE_STRING)
BINDNODE("sourceurl", p_entry->psz_source_uri, TYPE_STRING)
data_pointer.e_type = TYPE_NONE;
if ( ! strcmp( p_node, "resource" ) )
{
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) )
{
if ( !strcmp( attr, "type" ) )
{
i_filetype = ReadType( value );
}
}
}
break;
}
case XML_READER_TEXT:
if ( data_pointer.e_type == TYPE_NONE || !p_entry ) break;
if ( data_pointer.e_type == TYPE_STRING )
*data_pointer.u_data.ppsz = strdup( p_node );
else
if ( data_pointer.e_type == TYPE_LONG )
*data_pointer.u_data.pl = atol( p_node );
else
if ( data_pointer.e_type == TYPE_INTEGER )
*data_pointer.u_data.pi = atoi( p_node );
break;
case XML_READER_ENDELEM:
if ( !p_entry ) break;
if ( ! strcmp( p_node, "addon" ) )
{
/* then append entry */
ARRAY_APPEND( p_finder->entries, p_entry );
p_entry = NULL;
}
if ( ! strcmp( p_node, "resource" ) )
{
if ( p_entry && psz_filename && i_filetype >= 0 )
{
addon_file_t *p_file = malloc( sizeof(addon_file_t) );
p_file->e_filetype = i_filetype;
p_file->psz_filename = psz_filename;
p_file->psz_download_uri = NULL;
ARRAY_APPEND( p_entry->files, p_file );
}
/* reset temp */
psz_filename = NULL;
i_filetype = -1;
}
data_pointer.e_type = TYPE_NONE;
break;
default:
break;
}
}
end:
if ( p_entry ) /* ?!? Unclosed tag */
addon_entry_Release( p_entry );
xml_ReaderDelete( p_xml_reader );
stream_Delete( p_stream );
return i_ret;
}
int playlist_SaveArt( vlc_object_t *obj, input_item_t *p_item,
const void *data, size_t length, const char *psz_type )
{
char *psz_filename = ArtCacheName( p_item, psz_type );
if( !psz_filename )
return VLC_EGENERIC;
char *psz_uri = vlc_path2uri( psz_filename, "file" );
if( !psz_uri )
{
free( psz_filename );
return VLC_EGENERIC;
}
/* Check if we already dumped it */
struct stat s;
if( !vlc_stat( psz_filename, &s ) )
{
input_item_SetArtURL( p_item, psz_uri );
free( psz_filename );
free( psz_uri );
return VLC_SUCCESS;
}
/* Dump it otherwise */
FILE *f = vlc_fopen( psz_filename, "wb" );
if( f )
{
if( fwrite( data, 1, length, f ) != length )
{
msg_Err( obj, "%s: %s", psz_filename, vlc_strerror_c(errno) );
}
else
{
msg_Dbg( obj, "album art saved to %s", psz_filename );
input_item_SetArtURL( p_item, psz_uri );
}
fclose( f );
}
free( psz_uri );
/* save uid info */
char *uid = input_item_GetInfo( p_item, "uid", "md5" );
if ( ! *uid )
{
free( uid );
goto end;
}
char *psz_byuiddir = GetDirByItemUIDs( uid );
char *psz_byuidfile = GetFileByItemUID( psz_byuiddir, "arturl" );
ArtCacheCreateDir( psz_byuiddir );
free( psz_byuiddir );
if ( psz_byuidfile )
{
f = vlc_fopen( psz_byuidfile, "wb" );
if ( f )
{
if( fputs( "file://", f ) < 0 || fputs( psz_filename, f ) < 0 )
msg_Err( obj, "Error writing %s: %s", psz_byuidfile,
vlc_strerror_c(errno) );
fclose( f );
}
free( psz_byuidfile );
}
free( uid );
/* !save uid info */
end:
free( psz_filename );
return VLC_SUCCESS;
}
int vout_snapshot_SaveImage(char **name, int *sequential,
const block_t *image,
vout_thread_t *p_vout,
const vout_snapshot_save_cfg_t *cfg)
{
/* */
char *filename;
DIR *pathdir = vlc_opendir(cfg->path);
input_thread_t *input = (input_thread_t*)p_vout->p->input;
if (pathdir != NULL) {
/* The use specified a directory path */
closedir(pathdir);
/* */
char *prefix = NULL;
if (cfg->prefix_fmt)
prefix = str_format(input, cfg->prefix_fmt);
if (prefix)
filename_sanitize(prefix);
else {
prefix = strdup("vlcsnap-");
if (!prefix)
goto error;
}
if (cfg->is_sequential) {
for (int num = cfg->sequence; ; num++) {
struct stat st;
if (asprintf(&filename, "%s" DIR_SEP "%s%05d.%s",
cfg->path, prefix, num, cfg->format) < 0) {
free(prefix);
goto error;
}
if (vlc_stat(filename, &st)) {
*sequential = num;
break;
}
free(filename);
}
} else {
struct timespec ts;
struct tm curtime;
char buffer[128];
timespec_get(&ts, TIME_UTC);
if (localtime_r(&ts.tv_sec, &curtime) == NULL)
gmtime_r(&ts.tv_sec, &curtime);
if (strftime(buffer, sizeof(buffer), "%Y-%m-%d-%Hh%Mm%Ss",
&curtime) == 0)
strcpy(buffer, "error");
if (asprintf(&filename, "%s" DIR_SEP "%s%s%03lu.%s",
cfg->path, prefix, buffer, ts.tv_nsec / 1000000,
cfg->format) < 0)
filename = NULL;
}
free(prefix);
} else {
/* The user specified a full path name (including file name) */
filename = str_format(input, cfg->path);
path_sanitize(filename);
}
if (!filename)
goto error;
/* Save the snapshot */
FILE *file = vlc_fopen(filename, "wb");
if (!file) {
msg_Err(p_vout, "Failed to open '%s'", filename);
free(filename);
goto error;
}
if (fwrite(image->p_buffer, image->i_buffer, 1, file) != 1) {
msg_Err(p_vout, "Failed to write to '%s'", filename);
fclose(file);
free(filename);
goto error;
}
fclose(file);
/* */
if (name)
*name = filename;
else
free(filename);
return VLC_SUCCESS;
error:
msg_Err(p_vout, "could not save snapshot");
return VLC_EGENERIC;
}
ThemeRepository::ThemeRepository( intf_thread_t *pIntf ): SkinObject( pIntf )
{
vlc_value_t val;
// Create a variable to add items in wxwindows popup menu
var_Create( pIntf, "intf-skins", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_Change( pIntf, "intf-skins", VLC_VAR_SETTEXT, _("Select skin") );
// Scan vlt files in the resource path
OSFactory *pOsFactory = OSFactory::instance( pIntf );
std::list<std::string> resPath = pOsFactory->getResourcePath();
std::list<std::string>::const_iterator it;
for( it = resPath.begin(); it != resPath.end(); ++it )
{
parseDirectory( *it );
}
// retrieve skins from skins directories and locate default skins
std::map<std::string,std::string>::const_iterator itmap, itdefault;
bool b_default_found = false;
for( itmap = m_skinsMap.begin(); itmap != m_skinsMap.end(); ++itmap )
{
std::string name = itmap->first;
std::string path = itmap->second;
val.psz_string = (char*) path.c_str();
var_Change( getIntf(), "intf-skins", VLC_VAR_ADDCHOICE, val,
name.c_str() );
if( name == "Default" )
{
itdefault = itmap;
b_default_found = true;
}
}
// retrieve last skins stored or skins requested by user
char* psz_current = var_InheritString( getIntf(), "skins2-last" );
std::string current( psz_current ? psz_current : "" );
free( psz_current );
// check if skin exists
struct stat stat;
bool b_exists = !vlc_stat( current.c_str(), &stat );
msg_Dbg( getIntf(), "requested skins %s is %s accessible",
current.c_str(), b_exists ? "" : "NOT" );
// set the default skins if given skins not accessible
if( !b_exists && b_default_found )
current = itdefault->second;
// save this valid skins for reuse
config_PutPsz( "skins2-last", current.c_str() );
// Update repository
updateRepository();
// Set the callback
var_AddCallback( pIntf, "intf-skins", changeSkin, this );
// variable for opening a dialog box to change skins
var_Create( pIntf, "intf-skins-interactive", VLC_VAR_VOID |
VLC_VAR_ISCOMMAND );
var_Change( pIntf, "intf-skins-interactive", VLC_VAR_SETTEXT,
_("Open skin...") );
// Set the callback
var_AddCallback( pIntf, "intf-skins-interactive", changeSkin, this );
}
static int FindMeta( vlc_object_t *p_this )
{
art_finder_t *p_finder = (art_finder_t *)p_this;
input_item_t *p_item = p_finder->p_item;
bool b_have_art = false;
if( !p_item )
return VLC_EGENERIC;
char *psz_dir = input_item_GetURI( p_item );
if( !psz_dir )
return VLC_EGENERIC;
char *psz_path = make_path( psz_dir );
free( psz_dir );
if( psz_path == NULL )
return VLC_EGENERIC;
char *psz_buf = strrchr( psz_path, DIR_SEP_CHAR );
if( psz_buf )
*++psz_buf = '\0';
else
*psz_path = '\0'; /* relative path */
for( int i = -1; !b_have_art && i < i_covers; i++ )
{
const char *filename;
char *filebuf, *filepath;
if( i == -1 ) /* higher priority : configured filename */
{
filebuf = var_InheritString( p_this, "album-art-filename" );
if( filebuf == NULL )
continue;
filename = filebuf;
}
else
{
filename = cover_files[i];
filebuf = NULL;
}
if( asprintf( &filepath, "%s%s", psz_path, filename ) == -1 )
filepath = NULL;
free( filebuf );
if( unlikely(filepath != NULL) )
continue;
struct stat dummy;
if( vlc_stat( filepath, &dummy ) == 0 )
{
char *psz_uri = make_URI( filepath, "file" );
if( psz_uri )
{
input_item_SetArtURL( p_item, psz_uri );
free( psz_uri );
b_have_art = true;
}
}
free( filepath );
}
free( psz_path );
return b_have_art ? VLC_SUCCESS : VLC_EGENERIC;
}
static int FindMeta( vlc_object_t *p_this )
{
art_finder_t *p_finder = (art_finder_t *)p_this;
input_item_t *p_item = p_finder->p_item;
bool b_have_art = false;
struct stat statinfo;
char *psz_path = NULL;
if( !p_item )
return VLC_EGENERIC;
char *psz_uri = input_item_GetURI( p_item );
if( !psz_uri )
return VLC_EGENERIC;
if ( *psz_uri && psz_uri[strlen( psz_uri ) - 1] != DIR_SEP_CHAR )
{
if ( asprintf( &psz_path, "%s"DIR_SEP, psz_uri ) == -1 )
{
free( psz_uri );
return VLC_EGENERIC;
}
char *psz_basedir = make_path( psz_path );
FREENULL( psz_path );
if( psz_basedir == NULL )
{
free( psz_uri );
return VLC_EGENERIC;
}
if( vlc_stat( psz_basedir, &statinfo ) == 0 && S_ISDIR(statinfo.st_mode) )
psz_path = psz_basedir;
else
free( psz_basedir );
}
if ( psz_path == NULL )
{
char *psz_basedir = make_path( psz_uri );
if( psz_basedir == NULL )
{
free( psz_uri );
return VLC_EGENERIC;
}
char *psz_buf = strrchr( psz_basedir, DIR_SEP_CHAR );
if( psz_buf )
*++psz_buf = '\0';
else
*psz_basedir = '\0'; /* relative path */
psz_path = psz_basedir;
}
free( psz_uri );
for( int i = -1; !b_have_art && i < i_covers; i++ )
{
const char *filename;
char *filebuf, *filepath;
if( i == -1 ) /* higher priority : configured filename */
{
filebuf = var_InheritString( p_this, "album-art-filename" );
if( filebuf == NULL )
continue;
filename = filebuf;
}
else
{
filename = cover_files[i];
filebuf = NULL;
}
if( asprintf( &filepath, "%s%s", psz_path, filename ) == -1 )
filepath = NULL;
free( filebuf );
if( unlikely(filepath == NULL) )
continue;
if( vlc_stat( filepath, &statinfo ) == 0 && S_ISREG(statinfo.st_mode) )
{
char *psz_uri = vlc_path2uri( filepath, "file" );
if( psz_uri )
{
input_item_SetArtURL( p_item, psz_uri );
free( psz_uri );
b_have_art = true;
}
}
free( filepath );
}
free( psz_path );
return b_have_art ? VLC_SUCCESS : VLC_EGENERIC;
}
/**
* @brief Scan files in a particular directory
*/
static void ScanFiles( monitoring_thread_t *p_mon, int i_dir_id,
bool b_recursive, stat_list_t *stparent )
{
int i_rows, i_cols, i_dir_content, i, i_mon_rows, i_mon_cols;
char **ppsz_monitored_files;
char **pp_results, *psz_dir;
char **pp_dir_content;
bool *pb_processed;
input_item_t *p_input;
struct stat s_stat;
media_library_t *p_ml = (media_library_t *)p_mon->p_ml;
Query( p_ml, &pp_results, &i_rows, &i_cols,
"SELECT uri AS directory_uri FROM directories WHERE id = '%d'",
i_dir_id );
if( i_rows < 1 )
{
msg_Dbg( p_mon, "query returned no directory for dir_id: %d (%s:%d)",
i_dir_id, __FILE__, __LINE__ );
return;
}
psz_dir = strdup( pp_results[1] );
FreeSQLResult( p_ml, pp_results );
struct stat_list_t stself;
if( vlc_stat( psz_dir, &stself.st ) == -1 )
{
msg_Err( p_ml, "Cannot stat `%s': %m", psz_dir );
free( psz_dir );
return;
}
#ifndef WIN32
for( stat_list_t *stats = stparent; stats != NULL; stats = stats->parent )
{
if( ( stself.st.st_ino == stats->st.st_ino ) &&
( stself.st.st_dev == stats->st.st_dev ) )
{
msg_Warn( p_ml, "Ignoring infinitely recursive directory `%s'",
psz_dir );
free( psz_dir );
return;
}
}
#else
/* Windows has st_dev (driver letter - 'A'), but it zeroes st_ino,
* so that the test above will always incorrectly succeed.
* Besides, Windows does not have dirfd(). */
#endif
stself.parent = stparent;
QuerySimple( p_ml, "UPDATE directories SET timestamp=%d WHERE id = %d",
stself.st.st_mtime, i_dir_id );
Query( p_ml, &ppsz_monitored_files, &i_mon_rows, &i_mon_cols,
"SELECT id AS media_id, timestamp AS media_ts, uri AS media_uri "
"FROM media WHERE directory_id = %d",
i_dir_id );
pb_processed = malloc(sizeof(bool) * i_mon_rows);
for( i = 0; i < i_mon_rows ; i++)
pb_processed[i] = false;
i_dir_content = vlc_scandir( psz_dir, &pp_dir_content, NULL, Sort );
if( i_dir_content == -1 )
{
msg_Err( p_mon, "Cannot read `%s': %m", psz_dir );
free( pb_processed );
free( psz_dir );
return;
}
else if( i_dir_content == 0 )
{
msg_Dbg( p_mon, "Nothing in directory `%s'", psz_dir );
free( pb_processed );
free( psz_dir );
return;
}
for( i = 0; i < i_dir_content; i++ )
{
const char *psz_entry = pp_dir_content[i];
if( psz_entry[0] != '.' )
{
/* 7 is the size of "file://" */
char psz_uri[strlen(psz_dir) + strlen(psz_entry) + 2 + 7];
sprintf( psz_uri, "%s/%s", psz_dir, psz_entry );
if( vlc_stat( psz_uri, &s_stat ) == -1 )
{
msg_Err( p_mon, "%s: %m", psz_uri );
free( pb_processed );
free( psz_dir );
return;
}
if( S_ISREG( s_stat.st_mode ) )
{
const char *psz_dot = strrchr( psz_uri, '.' );
if( psz_dot++ && *psz_dot )
{
int i_is_media = 0;
for( int a = 0; ppsz_MediaExtensions[a]; a++ )
{
if( !strcasecmp( psz_dot, ppsz_MediaExtensions[a] ) )
{
i_is_media = 1;
break;
}
}
if( !i_is_media )
{
msg_Dbg( p_mon, "ignoring file %s", psz_uri );
continue;
}
}
char * psz_tmp = encode_URI_component( psz_uri );
char * psz_encoded_uri = ( char * )calloc( strlen( psz_tmp ) + 9, 1 );
strcpy( psz_encoded_uri, "file:///" );
strcat( psz_encoded_uri, psz_tmp );
free( psz_tmp );
/* Check if given media is already in DB and it has been updated */
bool b_skip = false;
bool b_update = false;
int j = 1;
for( j = 1; j <= i_mon_rows; j++ )
{
if( strcasecmp( ppsz_monitored_files[ j * i_mon_cols + 2 ],
psz_encoded_uri ) != 0 )
continue;
b_update = true;
pb_processed[ j - 1 ] = true;
if( atoi( ppsz_monitored_files[ j * i_mon_cols + 1 ] )
< s_stat.st_mtime )
{
b_skip = false;
break;
}
else
{
b_skip = true;
break;
}
}
msg_Dbg( p_ml , "Checking if %s is in DB. Found: %d", psz_encoded_uri,
b_skip? 1 : 0 );
if( b_skip )
continue;
p_input = input_item_New( psz_encoded_uri, psz_entry );
playlist_t* p_pl = pl_Get( p_mon );
preparsed_item_t* p_itemobject;
p_itemobject = malloc( sizeof( preparsed_item_t ) );
p_itemobject->i_dir_id = i_dir_id;
p_itemobject->psz_uri = psz_encoded_uri;
p_itemobject->i_mtime = s_stat.st_mtime;
p_itemobject->p_mon = p_mon;
p_itemobject->b_update = b_update;
p_itemobject->i_update_id = b_update ?
atoi( ppsz_monitored_files[ j * i_mon_cols + 0 ] ) : 0 ;
vlc_event_manager_t *p_em = &p_input->event_manager;
vlc_event_attach( p_em, vlc_InputItemPreparsedChanged,
PreparseComplete, p_itemobject );
playlist_PreparseEnqueue( p_pl, p_input );
}
else if( S_ISDIR( s_stat.st_mode ) && b_recursive )
{
Query( p_ml, &pp_results, &i_rows, &i_cols,
"SELECT id AS directory_id FROM directories "
"WHERE uri=%Q", psz_uri );
FreeSQLResult( p_ml, pp_results );
if( i_rows <= 0 )
{
msg_Dbg( p_mon, "New directory `%s' in dir of id %d",
psz_uri, i_dir_id );
QuerySimple( p_ml,
"INSERT INTO directories (uri, timestamp, "
"recursive) VALUES(%Q, 0, 1)", psz_uri );
// We get the id of the directory we've just added
Query( p_ml, &pp_results, &i_rows, &i_cols,
"SELECT id AS directory_id FROM directories WHERE uri=%Q",
psz_uri );
if( i_rows <= 0 )
{
msg_Err( p_mon, "Directory `%s' was not sucessfully"
" added to the database", psz_uri );
FreeSQLResult( p_ml, pp_results );
continue;
}
ScanFiles( p_mon, atoi( pp_results[1] ), b_recursive,
&stself );
FreeSQLResult( p_ml, pp_results );
}
}
}
}
vlc_array_t* delete_ids = vlc_array_new();
for( i = 0; i < i_mon_rows; i++ )
{
if( !pb_processed[i] )
{
/* This file doesn't exist anymore. Let's...urm...delete it. */
ml_element_t* find = ( ml_element_t* ) calloc( 1, sizeof( ml_element_t ) );
find->criteria = ML_ID;
find->value.i = atoi( ppsz_monitored_files[ (i + 1) * i_mon_cols ] );
vlc_array_append( delete_ids, find );
}
}
/* Delete the unfound media */
if( Delete( p_ml, delete_ids ) != VLC_SUCCESS )
msg_Dbg( p_ml, "Something went wrong in multi delete" );
for( i = 0; i < vlc_array_count( delete_ids ); i++ )
{
free( vlc_array_item_at_index( delete_ids, i ) );
}
vlc_array_destroy( delete_ids );
FreeSQLResult( p_ml, ppsz_monitored_files );
for( i = 0; i < i_dir_content; i++ )
free( pp_dir_content[i] );
free( pp_dir_content );
free( psz_dir );
free( pb_processed );
}
bool ThemeLoader::findFile( const string &rootDir, const string &rFileName,
string &themeFilePath )
{
// Path separator
const string &sep = OSFactory::instance( getIntf() )->getDirSeparator();
DIR *pCurrDir;
char *pszDirContent;
// Open the dir
pCurrDir = vlc_opendir( rootDir.c_str() );
if( pCurrDir == NULL )
{
// An error occurred
msg_Dbg( getIntf(), "cannot open directory %s", rootDir.c_str() );
return false;
}
// While we still have entries in the directory
while( ( pszDirContent = vlc_readdir( pCurrDir ) ) != NULL )
{
string newURI = rootDir + sep + pszDirContent;
// Skip . and ..
if( string( pszDirContent ) != "." &&
string( pszDirContent ) != ".." )
{
#if defined( S_ISDIR )
struct stat stat_data;
if( ( vlc_stat( newURI.c_str(), &stat_data ) == 0 )
&& S_ISDIR(stat_data.st_mode) )
#elif defined( DT_DIR )
if( pDirContent->d_type & DT_DIR )
#else
if( 0 )
#endif
{
// Can we find the file in this subdirectory?
if( findFile( newURI, rFileName, themeFilePath ) )
{
free( pszDirContent );
closedir( pCurrDir );
return true;
}
}
else
{
// Found the theme file?
if( rFileName == string( pszDirContent ) )
{
themeFilePath = newURI;
free( pszDirContent );
closedir( pCurrDir );
return true;
}
}
}
free( pszDirContent );
}
closedir( pCurrDir );
return false;
}
mvar_t *mvar_FileSetNew( intf_thread_t *p_intf, char *name,
char *psz_dir )
{
mvar_t *s = mvar_New( name, "set" );
char **ppsz_dir_content;
int i_dir_content, i;
psz_dir = RealPath( psz_dir );
/* parse psz_src dir */
if( ( i_dir_content = vlc_scandir( psz_dir, &ppsz_dir_content, Filter,
InsensitiveAlphasort ) ) == -1 )
{
if( errno != ENOENT && errno != ENOTDIR )
msg_Warn( p_intf, "error while scanning dir %s (%m)", psz_dir );
free( psz_dir );
return s;
}
for( i = 0; i < i_dir_content; i++ )
{
#ifdef HAVE_SYS_STAT_H
struct stat stat_info;
#endif
char *psz_name = ppsz_dir_content[i], *psz_ext, *psz_dummy;
char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_name ) + 1];
mvar_t *f;
#if defined( WIN32 )
if( psz_dir[0] == '\0' || (psz_dir[0] == '\\' && psz_dir[1] == '\0') )
{
strcpy( psz_tmp, psz_name );
}
else
#endif
{
sprintf( psz_tmp, "%s"DIR_SEP"%s", psz_dir, psz_name );
#ifdef HAVE_SYS_STAT_H
if( vlc_stat( psz_tmp, &stat_info ) == -1 )
{
free( psz_name );
continue;
}
#endif
}
f = mvar_New( name, "set" );
/* put lower-case file extension in 'ext' */
psz_ext = strrchr( psz_name, '.' );
psz_ext = strdup( psz_ext != NULL ? psz_ext + 1 : "" );
for( psz_dummy = psz_ext; *psz_dummy != '\0'; psz_dummy++ )
*psz_dummy = tolower( *psz_dummy );
mvar_AppendNewVar( f, "ext", psz_ext );
free( psz_ext );
#if defined( WIN32 )
if( psz_dir[0] == '\0' || (psz_dir[0] == '\\' && psz_dir[1] == '\0') )
{
char psz_tmp[3];
sprintf( psz_tmp, "%c:", psz_name[0] );
mvar_AppendNewVar( f, "name", psz_name );
mvar_AppendNewVar( f, "basename", psz_tmp );
mvar_AppendNewVar( f, "type", "directory" );
mvar_AppendNewVar( f, "size", "unknown" );
mvar_AppendNewVar( f, "date", "unknown" );
}
else
#endif
{
char psz_buf[26];
char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_name ) + 1];
sprintf( psz_tmp, "%s"DIR_SEP"%s", psz_dir, psz_name );
mvar_AppendNewVar( f, "name", psz_tmp );
mvar_AppendNewVar( f, "basename", psz_name );
#ifdef HAVE_SYS_STAT_H
if( S_ISDIR( stat_info.st_mode ) )
{
mvar_AppendNewVar( f, "type", "directory" );
}
else if( S_ISREG( stat_info.st_mode ) )
{
mvar_AppendNewVar( f, "type", "file" );
}
else
{
mvar_AppendNewVar( f, "type", "unknown" );
}
snprintf( psz_buf, sizeof( psz_buf ), "%"PRId64,
(int64_t)stat_info.st_size );
mvar_AppendNewVar( f, "size", psz_buf );
/* FIXME memory leak FIXME */
# ifdef HAVE_CTIME_R
ctime_r( &stat_info.st_mtime, psz_buf );
mvar_AppendNewVar( f, "date", psz_buf );
# else
mvar_AppendNewVar( f, "date", ctime( &stat_info.st_mtime ) );
# endif
#else
mvar_AppendNewVar( f, "type", "unknown" );
mvar_AppendNewVar( f, "size", "unknown" );
mvar_AppendNewVar( f, "date", "unknown" );
#endif
}
mvar_AppendVar( s, f );
free( psz_name );
}
free( psz_dir );
free( ppsz_dir_content );
return s;
}
int playlist_MLLoad( playlist_t *p_playlist )
{
input_item_t *p_input;
char *psz_datadir = config_GetUserDir( VLC_DATA_DIR );
if( !psz_datadir ) /* XXX: This should never happen */
{
msg_Err( p_playlist, "no data directory, cannot load media library") ;
return VLC_EGENERIC;
}
char *psz_file;
if( asprintf( &psz_file, "%s" DIR_SEP "ml.xspf", psz_datadir ) == -1 )
psz_file = NULL;
free( psz_datadir );
if( psz_file == NULL )
return VLC_ENOMEM;
/* loosy check for media library file */
struct stat st;
if( vlc_stat( psz_file, &st ) )
{
free( psz_file );
return VLC_EGENERIC;
}
char *psz_uri = make_URI( psz_file, "file/xspf-open" );
free( psz_file );
if( psz_uri == NULL )
return VLC_ENOMEM;
const char *const options[1] = { "meta-file", };
/* that option has to be cleaned in input_item_subitem_tree_added() */
/* vlc_gc_decref() in the same function */
p_input = input_item_NewExt( psz_uri, _("Media Library"),
1, options, VLC_INPUT_OPTION_TRUSTED, -1 );
free( psz_uri );
if( p_input == NULL )
return VLC_EGENERIC;
PL_LOCK;
if( p_playlist->p_media_library->p_input )
vlc_gc_decref( p_playlist->p_media_library->p_input );
p_playlist->p_media_library->p_input = p_input;
vlc_event_attach( &p_input->event_manager, vlc_InputItemSubItemTreeAdded,
input_item_subitem_tree_added, p_playlist );
pl_priv(p_playlist)->b_doing_ml = true;
PL_UNLOCK;
stats_TimerStart( p_playlist, "ML Load", STATS_TIMER_ML_LOAD );
input_Read( p_playlist, p_input );
stats_TimerStop( p_playlist,STATS_TIMER_ML_LOAD );
PL_LOCK;
pl_priv(p_playlist)->b_doing_ml = false;
PL_UNLOCK;
vlc_event_detach( &p_input->event_manager, vlc_InputItemSubItemTreeAdded,
input_item_subitem_tree_added, p_playlist );
return VLC_SUCCESS;
}
int vout_snapshot_SaveImage(char **name, int *sequential,
const block_t *image,
vlc_object_t *object,
const vout_snapshot_save_cfg_t *cfg)
{
/* */
char *filename;
DIR *pathdir = vlc_opendir(cfg->path);
if (pathdir != NULL) {
/* The use specified a directory path */
closedir(pathdir);
/* */
char *prefix = NULL;
if (cfg->prefix_fmt)
prefix = str_format(object, cfg->prefix_fmt);
if (prefix)
filename_sanitize(prefix);
else {
prefix = strdup("vlcsnap-");
if (!prefix)
goto error;
}
if (cfg->is_sequential) {
for (int num = cfg->sequence; ; num++) {
struct stat st;
if (asprintf(&filename, "%s" DIR_SEP "%s%05d.%s",
cfg->path, prefix, num, cfg->format) < 0) {
free(prefix);
goto error;
}
if (vlc_stat(filename, &st)) {
*sequential = num;
break;
}
free(filename);
}
} else {
struct tm curtime;
time_t lcurtime = time(NULL) ;
if (!localtime_r(&lcurtime, &curtime)) {
const unsigned int id = (image->i_pts / 100000) & 0xFFFFFF;
msg_Warn(object, "failed to get current time. Falling back to legacy snapshot naming");
if (asprintf(&filename, "%s" DIR_SEP "%s%u.%s",
cfg->path, prefix, id, cfg->format) < 0)
filename = NULL;
} else {
/* suffix with the last decimal digit in 10s of seconds resolution
* FIXME gni ? */
const int id = (image->i_pts / (100*1000)) & 0xFF;
char buffer[128];
if (!strftime(buffer, sizeof(buffer), "%Y-%m-%d-%Hh%Mm%Ss", &curtime))
strcpy(buffer, "error");
if (asprintf(&filename, "%s" DIR_SEP "%s%s%1u.%s",
cfg->path, prefix, buffer, id, cfg->format) < 0)
filename = NULL;
}
}
free(prefix);
} else {
/* The user specified a full path name (including file name) */
filename = str_format(object, cfg->path);
path_sanitize(filename);
}
if (!filename)
goto error;
/* Save the snapshot */
FILE *file = vlc_fopen(filename, "wb");
if (!file) {
msg_Err(object, "Failed to open '%s'", filename);
free(filename);
goto error;
}
if (fwrite(image->p_buffer, image->i_buffer, 1, file) != 1) {
msg_Err(object, "Failed to write to '%s'", filename);
fclose(file);
free(filename);
goto error;
}
fclose(file);
/* */
if (name)
*name = filename;
else
free(filename);
return VLC_SUCCESS;
error:
msg_Err(object, "could not save snapshot");
return VLC_EGENERIC;
}
int playlist_SaveArt( playlist_t *p_playlist, input_item_t *p_item,
const uint8_t *p_buffer, int i_buffer, const char *psz_type )
{
char *psz_filename = ArtCacheName( p_item, psz_type );
if( !psz_filename )
return VLC_EGENERIC;
char *psz_uri = make_URI( psz_filename, "file" );
if( !psz_uri )
{
free( psz_filename );
return VLC_EGENERIC;
}
/* Check if we already dumped it */
struct stat s;
if( !vlc_stat( psz_filename, &s ) )
{
input_item_SetArtURL( p_item, psz_uri );
free( psz_filename );
free( psz_uri );
return VLC_SUCCESS;
}
/* Dump it otherwise */
FILE *f = vlc_fopen( psz_filename, "wb" );
if( f )
{
if( fwrite( p_buffer, i_buffer, 1, f ) != 1 )
{
msg_Err( p_playlist, "%s: %m", psz_filename );
}
else
{
msg_Dbg( p_playlist, "album art saved to %s", psz_filename );
input_item_SetArtURL( p_item, psz_uri );
}
fclose( f );
}
free( psz_uri );
/* save uid info */
char *uid = input_item_GetInfo( p_item, "uid", "md5" );
if ( ! *uid )
{
free( uid );
goto end;
}
char *psz_byuiddir = GetDirByItemUIDs( uid );
char *psz_byuidfile = GetFileByItemUID( psz_byuiddir, "arturl" );
ArtCacheCreateDir( psz_byuiddir );
free( psz_byuiddir );
if ( psz_byuidfile )
{
f = vlc_fopen( psz_byuidfile, "wb" );
if ( f )
{
if( fputs( "file://", f ) < 0 || fputs( psz_filename, f ) < 0 )
msg_Err( p_playlist, "Error writing %s: %m", psz_byuidfile );
fclose( f );
}
free( psz_byuidfile );
}
free( uid );
/* !save uid info */
end:
free( psz_filename );
return VLC_SUCCESS;
}