void ThemeRepository::parseDirectory( const string &rDir_locale )
{
DIR *pDir;
char *pszDirContent;
vlc_value_t val, text;
// Path separator
const string &sep = OSFactory::instance( getIntf() )->getDirSeparator();
// Open the dir
// FIXME: parseDirectory should be invoked with UTF-8 input instead!!
string rDir = sFromLocale( rDir_locale );
pDir = utf8_opendir( rDir.c_str() );
if( pDir == NULL )
{
// An error occurred
msg_Dbg( getIntf(), "cannot open directory %s", rDir.c_str() );
return;
}
// While we still have entries in the directory
while( ( pszDirContent = utf8_readdir( pDir ) ) != NULL )
{
string name = pszDirContent;
string extension;
if( name.size() > 4 )
{
extension = name.substr( name.size() - 4, 4 );
}
if( extension == ".vlt" || extension == ".wsz" )
{
string path = rDir + sep + name;
msg_Dbg( getIntf(), "found skin %s", path.c_str() );
// Add the theme in the popup menu
string shortname = name.substr( 0, name.size() - 4 );
val.psz_string = strdup( path.c_str() );
text.psz_string = strdup( shortname.c_str() );
var_Change( getIntf(), "intf-skins", VLC_VAR_ADDCHOICE, &val,
&text );
free( val.psz_string );
free( text.psz_string );
}
free( pszDirContent );
}
closedir( pDir );
}
int playlist_FindArtInCache( input_item_t *p_item )
{
char *psz_path = ArtCachePath( p_item );
if( !psz_path )
return VLC_EGENERIC;
/* Check if file exists */
DIR *p_dir = utf8_opendir( psz_path );
if( !p_dir )
{
free( psz_path );
return VLC_EGENERIC;
}
bool b_found = false;
char *psz_filename;
while( !b_found && (psz_filename = utf8_readdir( p_dir )) )
{
if( !strncmp( psz_filename, "art", 3 ) )
{
char *psz_file;
if( asprintf( &psz_file, "%s" DIR_SEP "%s",
psz_path, psz_filename ) != -1 )
{
char *psz_uri = make_URI( psz_file );
if( psz_uri )
{
input_item_SetArtURL( p_item, psz_uri );
free( psz_uri );
}
free( psz_file );
}
b_found = true;
}
free( psz_filename );
}
/* */
closedir( p_dir );
free( psz_path );
return b_found ? VLC_SUCCESS : VLC_EGENERIC;
}
int vout_Snapshot( vout_thread_t *p_vout, picture_t *p_pic )
{
image_handler_t *p_image = image_HandlerCreate( p_vout );
video_format_t fmt_in, fmt_out;
char *psz_filename = NULL;
vlc_value_t val, format;
DIR *path;
int i_ret;
bool b_embedded_snapshot;
int i_id = 0;
/* */
val.psz_string = var_GetNonEmptyString( p_vout, "snapshot-path" );
/* Embedded snapshot : if snapshot-path == object:id */
if( val.psz_string && sscanf( val.psz_string, "object:%d", &i_id ) > 0 )
b_embedded_snapshot = true;
else
b_embedded_snapshot = false;
/* */
memset( &fmt_in, 0, sizeof(video_format_t) );
fmt_in = p_vout->fmt_in;
if( fmt_in.i_sar_num <= 0 || fmt_in.i_sar_den <= 0 )
{
fmt_in.i_sar_num =
fmt_in.i_sar_den = 1;
}
/* */
memset( &fmt_out, 0, sizeof(video_format_t) );
fmt_out.i_sar_num =
fmt_out.i_sar_den = 1;
fmt_out.i_chroma = b_embedded_snapshot ? VLC_FOURCC('p','n','g',' ') : 0;
fmt_out.i_width = var_GetInteger( p_vout, "snapshot-width" );
fmt_out.i_height = var_GetInteger( p_vout, "snapshot-height" );
if( b_embedded_snapshot &&
fmt_out.i_width == 0 && fmt_out.i_height == 0 )
{
/* If snapshot-width and/or snapshot height were not specified,
use a default snapshot width of 320 */
fmt_out.i_width = 320;
}
if( fmt_out.i_height == 0 && fmt_out.i_width > 0 )
{
fmt_out.i_height = fmt_in.i_height * fmt_out.i_width / fmt_in.i_width;
const int i_height = fmt_out.i_height * fmt_in.i_sar_den / fmt_in.i_sar_num;
if( i_height > 0 )
fmt_out.i_height = i_height;
}
else
{
if( fmt_out.i_width == 0 && fmt_out.i_height > 0 )
{
fmt_out.i_width = fmt_in.i_width * fmt_out.i_height / fmt_in.i_height;
}
else
{
fmt_out.i_width = fmt_in.i_width;
fmt_out.i_height = fmt_in.i_height;
}
const int i_width = fmt_out.i_width * fmt_in.i_sar_num / fmt_in.i_sar_den;
if( i_width > 0 )
fmt_out.i_width = i_width;
}
/* Embedded snapshot
create a snapshot_t* and store it in
object(object-id)->p_private, then unlock and signal the
waiting object.
*/
if( b_embedded_snapshot )
{
vlc_object_t* p_dest;
block_t *p_block;
snapshot_t *p_snapshot;
size_t i_size;
/* Destination object-id is following object: */
p_dest = ( vlc_object_t* )vlc_object_get( i_id );
if( !p_dest )
{
msg_Err( p_vout, "Cannot find calling object" );
image_HandlerDelete( p_image );
return VLC_EGENERIC;
}
/* Object must be locked. We will unlock it once we get the
snapshot and written it to p_private */
p_dest->p_private = NULL;
/* Save the snapshot to a memory zone */
p_block = image_Write( p_image, p_pic, &fmt_in, &fmt_out );
if( !p_block )
{
msg_Err( p_vout, "Could not get snapshot" );
image_HandlerDelete( p_image );
vlc_object_signal( p_dest );
vlc_object_release( p_dest );
return VLC_EGENERIC;
}
/* Copy the p_block data to a snapshot structure */
/* FIXME: get the timestamp */
p_snapshot = malloc( sizeof( snapshot_t ) );
if( !p_snapshot )
{
block_Release( p_block );
image_HandlerDelete( p_image );
vlc_object_signal( p_dest );
vlc_object_release( p_dest );
return VLC_ENOMEM;
}
i_size = p_block->i_buffer;
p_snapshot->i_width = fmt_out.i_width;
p_snapshot->i_height = fmt_out.i_height;
p_snapshot->i_datasize = i_size;
p_snapshot->date = p_block->i_pts; /* FIXME ?? */
p_snapshot->p_data = malloc( i_size );
if( !p_snapshot->p_data )
{
block_Release( p_block );
free( p_snapshot );
image_HandlerDelete( p_image );
vlc_object_signal( p_dest );
vlc_object_release( p_dest );
return VLC_ENOMEM;
}
memcpy( p_snapshot->p_data, p_block->p_buffer, p_block->i_buffer );
p_dest->p_private = p_snapshot;
block_Release( p_block );
/* Unlock the object */
vlc_object_signal( p_dest );
vlc_object_release( p_dest );
image_HandlerDelete( p_image );
return VLC_SUCCESS;
}
/* Get default directory if none provided */
if( !val.psz_string )
val.psz_string = VoutSnapshotGetDefaultDirectory( p_vout );
if( !val.psz_string )
{
msg_Err( p_vout, "no path specified for snapshots" );
image_HandlerDelete( p_image );
return VLC_EGENERIC;
}
/* Get snapshot format, default being "png" */
format.psz_string = var_GetNonEmptyString( p_vout, "snapshot-format" );
if( !format.psz_string )
format.psz_string = strdup( "png" );
if( !format.psz_string )
{
free( val.psz_string );
image_HandlerDelete( p_image );
return VLC_ENOMEM;
}
/*
* Did the user specify a directory? If not, path = NULL.
*/
path = utf8_opendir ( (const char *)val.psz_string );
if( path != NULL )
{
char *psz_prefix = var_GetNonEmptyString( p_vout, "snapshot-prefix" );
if( psz_prefix == NULL )
psz_prefix = strdup( "vlcsnap-" );
else
{
char *psz_tmp = str_format( p_vout, psz_prefix );
filename_sanitize( psz_tmp );
free( psz_prefix );
psz_prefix = psz_tmp;
}
closedir( path );
if( var_GetBool( p_vout, "snapshot-sequential" ) == true )
{
int i_num = var_GetInteger( p_vout, "snapshot-num" );
struct stat st;
do
{
free( psz_filename );
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%05d.%s",
val.psz_string, psz_prefix, i_num++,
format.psz_string ) == -1 )
{
msg_Err( p_vout, "could not create snapshot" );
image_HandlerDelete( p_image );
return VLC_EGENERIC;
}
}
while( utf8_stat( psz_filename, &st ) == 0 );
var_SetInteger( p_vout, "snapshot-num", i_num );
}
else
{
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%u.%s",
val.psz_string, psz_prefix,
(unsigned int)(p_pic->date / 100000) & 0xFFFFFF,
format.psz_string ) == -1 )
{
msg_Err( p_vout, "could not create snapshot" );
image_HandlerDelete( p_image );
return VLC_EGENERIC;
}
}
free( psz_prefix );
}
else // The user specified a full path name (including file name)
{
psz_filename = str_format( p_vout, val.psz_string );
path_sanitize( psz_filename );
}
free( val.psz_string );
free( format.psz_string );
/* Save the snapshot */
i_ret = image_WriteUrl( p_image, p_pic, &fmt_in, &fmt_out, psz_filename );
if( i_ret != VLC_SUCCESS )
{
msg_Err( p_vout, "could not create snapshot %s", psz_filename );
free( psz_filename );
image_HandlerDelete( p_image );
return VLC_EGENERIC;
}
/* */
msg_Dbg( p_vout, "snapshot taken (%s)", psz_filename );
vout_OSDMessage( VLC_OBJECT( p_vout ), DEFAULT_CHAN,
"%s", psz_filename );
free( psz_filename );
/* */
if( var_GetBool( p_vout, "snapshot-preview" ) )
{
if( VoutSnapshotPip( p_vout, p_image, p_pic, &fmt_in ) )
msg_Warn( p_vout, "Failed to display snapshot" );
}
image_HandlerDelete( p_image );
return VLC_SUCCESS;
}
/* Parse a directory and recursively add files */
int ParseDirectory( intf_thread_t *p_intf, char *psz_root,
char *psz_dir )
{
intf_sys_t *p_sys = p_intf->p_sys;
char dir[MAX_DIR_SIZE];
DIR *p_dir;
vlc_acl_t *p_acl;
FILE *file;
char *user = NULL;
char *password = NULL;
int i_dirlen;
if( ( p_dir = utf8_opendir( psz_dir ) ) == NULL )
{
if( errno != ENOENT && errno != ENOTDIR )
msg_Err( p_intf, "cannot open directory (%s)", psz_dir );
return VLC_EGENERIC;
}
i_dirlen = strlen( psz_dir );
if( i_dirlen + 10 > MAX_DIR_SIZE )
{
msg_Warn( p_intf, "skipping too deep directory (%s)", psz_dir );
closedir( p_dir );
return 0;
}
msg_Dbg( p_intf, "dir=%s", psz_dir );
snprintf( dir, sizeof( dir ), "%s"DIR_SEP".access", psz_dir );
if( ( file = utf8_fopen( dir, "r" ) ) != NULL )
{
char line[1024];
int i_size;
msg_Dbg( p_intf, "find .access in dir=%s", psz_dir );
i_size = fread( line, 1, 1023, file );
if( i_size > 0 )
{
char *p;
while( i_size > 0 && ( line[i_size-1] == '\n' ||
line[i_size-1] == '\r' ) )
{
i_size--;
}
line[i_size] = '\0';
p = strchr( line, ':' );
if( p )
{
*p++ = '\0';
user = strdup( line );
password = strdup( p );
}
}
msg_Dbg( p_intf, "using user=%s (read=%d)", user, i_size );
fclose( file );
}
snprintf( dir, sizeof( dir ), "%s"DIR_SEP".hosts", psz_dir );
p_acl = ACL_Create( p_intf, false );
if( ACL_LoadFile( p_acl, dir ) )
{
ACL_Destroy( p_acl );
struct stat st;
if( utf8_stat( dir, &st ) == 0 )
{
free( user );
free( password );
closedir( p_dir );
return VLC_EGENERIC;
}
p_acl = NULL;
}
for( ;; )
{
char *psz_filename;
/* parse psz_src dir */
if( ( psz_filename = utf8_readdir( p_dir ) ) == NULL )
{
break;
}
if( ( psz_filename[0] == '.' )
|| ( i_dirlen + strlen( psz_filename ) > MAX_DIR_SIZE ) )
{
free( psz_filename );
continue;
}
snprintf( dir, sizeof( dir ), "%s"DIR_SEP"%s", psz_dir, psz_filename );
free( psz_filename );
if( ParseDirectory( p_intf, psz_root, dir ) )
{
httpd_file_sys_t *f = NULL;
httpd_handler_sys_t *h = NULL;
bool b_index;
char *psz_name, *psz_ext;
psz_name = FileToUrl( &dir[strlen( psz_root )], &b_index );
psz_ext = strrchr( dir, '.' );
if( psz_ext != NULL )
{
int i;
psz_ext++;
for( i = 0; i < p_sys->i_handlers; i++ )
if( !strcmp( p_sys->pp_handlers[i]->psz_ext, psz_ext ) )
break;
if( i < p_sys->i_handlers )
{
f = malloc( sizeof( httpd_handler_sys_t ) );
h = (httpd_handler_sys_t *)f;
f->b_handler = true;
h->p_association = p_sys->pp_handlers[i];
}
}
if( f == NULL )
{
f = malloc( sizeof( httpd_file_sys_t ) );
f->b_handler = false;
}
f->p_intf = p_intf;
f->p_file = NULL;
f->p_redir = NULL;
f->p_redir2 = NULL;
f->file = strdup (dir);
f->name = psz_name;
f->b_html = strstr( &dir[strlen( psz_root )], ".htm" ) || strstr( &dir[strlen( psz_root )], ".xml" ) ? true : false;
if( !f->name )
{
msg_Err( p_intf , "unable to parse directory" );
closedir( p_dir );
free( f );
return( VLC_ENOMEM );
}
msg_Dbg( p_intf, "file=%s (url=%s)",
f->file, f->name );
if( !f->b_handler )
{
char *psz_type = strdup( "text/html; charset=UTF-8" );
if( strstr( &dir[strlen( psz_root )], ".xml" ) )
{
char *psz = strstr( psz_type, "html;" );
if( psz )
{
psz[0] = 'x';
psz[1] = 'm';
psz[2] = 'l';
psz[3] = ';';
psz[4] = ' ';
}
}
f->p_file = httpd_FileNew( p_sys->p_httpd_host,
f->name,
f->b_html ? psz_type : NULL,
user, password, p_acl,
HttpCallback, f );
free( psz_type );
if( f->p_file != NULL )
{
TAB_APPEND( p_sys->i_files, p_sys->pp_files, f );
}
}
else
{
h->p_handler = httpd_HandlerNew( p_sys->p_httpd_host,
f->name,
user, password, p_acl,
HandlerCallback, h );
if( h->p_handler != NULL )
{
TAB_APPEND( p_sys->i_files, p_sys->pp_files,
(httpd_file_sys_t *)h );
}
}
/* for url that ends by / add
* - a redirect from rep to rep/
* - in case of index.* rep/index.html to rep/ */
if( f && f->name[strlen(f->name) - 1] == '/' )
{
char *psz_redir = strdup( f->name );
char *p;
psz_redir[strlen( psz_redir ) - 1] = '\0';
msg_Dbg( p_intf, "redir=%s -> %s", psz_redir, f->name );
f->p_redir = httpd_RedirectNew( p_sys->p_httpd_host, f->name, psz_redir );
free( psz_redir );
if( b_index && ( p = strstr( f->file, "index." ) ) )
{
if( asprintf( &psz_redir, "%s%s", f->name, p ) != -1 )
{
msg_Dbg( p_intf, "redir=%s -> %s", psz_redir, f->name );
f->p_redir2 = httpd_RedirectNew( p_sys->p_httpd_host,
f->name, psz_redir );
free( psz_redir );
}
}
}
}
}
free( user );
free( password );
ACL_Destroy( p_acl );
closedir( p_dir );
return VLC_SUCCESS;
}
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 = utf8_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 = utf8_readdir( pCurrDir ) ) != NULL )
{
string newURI = rootDir + sep + pszDirContent;
// Skip . and ..
if( string( pszDirContent ) != "." &&
string( pszDirContent ) != ".." )
{
#if defined( S_ISDIR )
struct stat stat_data;
if( ( utf8_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;
}
/**
* This function will save a video snapshot to a file
*/
static int VoutWriteSnapshot( vout_thread_t *p_vout, char **ppsz_filename,
const block_t *p_image,
const char *psz_path,
const char *psz_format,
const char *psz_prefix_fmt )
{
/* */
char *psz_filename;
DIR *p_path = utf8_opendir( psz_path );
if( p_path != NULL )
{
/* The use specified a directory path */
closedir( p_path );
/* */
char *psz_prefix = NULL;
if( psz_prefix_fmt )
psz_prefix = str_format( p_vout, psz_prefix_fmt );
if( !psz_prefix )
{
psz_prefix = strdup( "vlcsnap-" );
if( !psz_prefix )
goto error;
}
if( var_GetBool( p_vout, "snapshot-sequential" ) )
{
int i_num = var_GetInteger( p_vout, "snapshot-num" );
for( ; ; i_num++ )
{
struct stat st;
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%05d.%s",
psz_path, psz_prefix, i_num++, psz_format ) < 0 )
{
free( psz_prefix );
goto error;
}
if( utf8_stat( psz_filename, &st ) )
break;
free( psz_filename );
}
var_SetInteger( p_vout, "snapshot-num", i_num );
}
else
{
struct tm curtime;
time_t lcurtime = time( NULL ) ;
if( !localtime_r( &lcurtime, &curtime ) )
{
const unsigned int i_id = (p_image->i_pts / 100000) & 0xFFFFFF;
msg_Warn( p_vout, "failed to get current time. Falling back to legacy snapshot naming" );
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%u.%s",
psz_path, psz_prefix, i_id, psz_format ) < 0 )
psz_filename = NULL;
}
else
{
/* suffix with the last decimal digit in 10s of seconds resolution
* FIXME gni ? */
const int i_id = (p_image->i_pts / (100*1000)) & 0xFF;
char psz_curtime[128];
if( !strftime( psz_curtime, sizeof(psz_curtime), "%Y-%m-%d-%Hh%Mm%Ss", &curtime ) )
strcpy( psz_curtime, "error" );
if( asprintf( &psz_filename, "%s" DIR_SEP "%s%s%1u.%s",
psz_path, psz_prefix, psz_curtime, i_id, psz_format ) < 0 )
psz_filename = NULL;
}
}
free( psz_prefix );
}
else
{
/* The user specified a full path name (including file name) */
psz_filename = str_format( p_vout, psz_path );
path_sanitize( psz_filename );
}
if( !psz_filename )
goto error;
/* Save the snapshot */
FILE *p_file = utf8_fopen( psz_filename, "wb" );
if( !p_file )
{
msg_Err( p_vout, "Failed to open '%s'", psz_filename );
free( psz_filename );
goto error;
}
if( fwrite( p_image->p_buffer, p_image->i_buffer, 1, p_file ) != 1 )
{
msg_Err( p_vout, "Failed to write to '%s'", psz_filename );
fclose( p_file );
free( psz_filename );
goto error;
}
fclose( p_file );
/* */
if( ppsz_filename )
*ppsz_filename = psz_filename;
else
free( psz_filename );
return VLC_SUCCESS;
error:
msg_Err( p_vout, "could not save snapshot" );
return VLC_EGENERIC;
}
