/* Removes an extra interface from the configuration */
void config_RemoveIntf( vlc_object_t *p_this, const char *psz_intf )
{
vlc_object_t *libvlc = VLC_OBJECT(p_this->obj.libvlc);
assert( psz_intf );
char *psz_config, *psz_parser;
size_t i_len = strlen( psz_intf );
psz_config = psz_parser = config_GetPsz( libvlc, "extraintf" );
while( psz_parser )
{
if( !strncmp( psz_intf, psz_parser, i_len ) )
{
char *psz_newconfig;
char *psz_end = psz_parser + i_len;
if( *psz_end == ':' ) psz_end++;
*psz_parser = '\0';
if( asprintf( &psz_newconfig, "%s%s", psz_config, psz_end ) != -1 )
{
config_PutPsz( libvlc, "extraintf", psz_newconfig );
free( psz_newconfig );
}
break;
}
psz_parser = strchr( psz_parser, ':' );
if( psz_parser ) psz_parser++; /* skip the ':' */
}
free( psz_config );
psz_config = psz_parser = config_GetPsz( libvlc, "control" );
while( psz_parser )
{
if( !strncmp( psz_intf, psz_parser, i_len ) )
{
char *psz_newconfig;
char *psz_end = psz_parser + i_len;
if( *psz_end == ':' ) psz_end++;
*psz_parser = '\0';
if( asprintf( &psz_newconfig, "%s%s", psz_config, psz_end ) != -1 )
{
config_PutPsz( libvlc, "control", psz_newconfig );
free( psz_newconfig );
}
break;
}
psz_parser = strchr( psz_parser, ':' );
if( psz_parser ) psz_parser++; /* skip the ':' */
}
free( psz_config );
}
/* Adds an extra interface to the configuration */
void config_AddIntf( vlc_object_t *p_this, const char *psz_intf )
{
vlc_object_t *libvlc = VLC_OBJECT(p_this->obj.libvlc);
assert( psz_intf );
char *psz_config, *psz_parser;
size_t i_len = strlen( psz_intf );
psz_config = psz_parser = config_GetPsz( libvlc, "control" );
while( psz_parser )
{
if( !strncmp( psz_intf, psz_parser, i_len ) )
{
free( psz_config );
return;
}
psz_parser = strchr( psz_parser, ':' );
if( psz_parser ) psz_parser++; /* skip the ':' */
}
free( psz_config );
psz_config = psz_parser = config_GetPsz( libvlc, "extraintf" );
while( psz_parser )
{
if( !strncmp( psz_intf, psz_parser, i_len ) )
{
free( psz_config );
return;
}
psz_parser = strchr( psz_parser, ':' );
if( psz_parser ) psz_parser++; /* skip the ':' */
}
/* interface not found in the config, let's add it */
if( psz_config && strlen( psz_config ) > 0 )
{
char *psz_newconfig;
if( asprintf( &psz_newconfig, "%s:%s", psz_config, psz_intf ) != -1 )
{
config_PutPsz( libvlc, "extraintf", psz_newconfig );
free( psz_newconfig );
}
}
else
config_PutPsz( libvlc, "extraintf", psz_intf );
free( psz_config );
}
/**
Check to see if user has overridden subtitle aspect ratio.
0 is returned for no override which means just counteract any
scaling effects.
*/
unsigned int
VCDSubGetAROverride(vlc_object_t * p_input, vout_thread_t *p_vout)
{
char *psz_string = config_GetPsz( p_input, MODULE_STRING "-aspect-ratio" );
/* Check whether the user tried to override aspect ratio */
if( !psz_string ) return 0;
{
unsigned int i_new_aspect = 0;
char *psz_parser = strchr( psz_string, ':' );
if( psz_parser )
{
*psz_parser++ = '\0';
i_new_aspect = atoi( psz_string ) * VOUT_ASPECT_FACTOR
/ atoi( psz_parser );
}
else
{
i_new_aspect = p_vout->output.i_width * VOUT_ASPECT_FACTOR
* atof( psz_string )
/ p_vout->output.i_height;
}
return i_new_aspect;
}
}
/**
* Finds the value of a variable. If the specified object does not hold a
* variable with the specified name, try the parent object, and iterate until
* the top of the tree. If no match is found, the value is read from the
* configuration.
*/
int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type,
vlc_value_t *p_val )
{
i_type &= VLC_VAR_CLASS;
for( vlc_object_t *obj = p_this; obj != NULL; obj = obj->obj.parent )
{
if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS )
return VLC_SUCCESS;
}
/* else take value from config */
switch( i_type & VLC_VAR_CLASS )
{
case VLC_VAR_STRING:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
default:
vlc_assert_unreachable();
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Config handling
*****************************************************************************/
static int vlclua_config_get( lua_State *L )
{
vlc_object_t * p_this = vlclua_get_this( L );
const char *psz_name = luaL_checkstring( L, 1 );
switch( config_GetType( p_this, psz_name ) )
{
case VLC_VAR_STRING:
{
char *psz = config_GetPsz( p_this, psz_name );
lua_pushstring( L, psz );
free( psz );
break;
}
case VLC_VAR_INTEGER:
lua_pushinteger( L, config_GetInt( p_this, psz_name ) );
break;
case VLC_VAR_BOOL:
lua_pushboolean( L, config_GetInt( p_this, psz_name ) );
break;
case VLC_VAR_FLOAT:
lua_pushnumber( L, config_GetFloat( p_this, psz_name ) );
break;
default:
return vlclua_error( L );
}
return 1;
}
void ThemeRepository::updateRepository()
{
vlc_value_t val, text;
// retrieve the current skin
char* psz_current = config_GetPsz( getIntf(), "skins2-last" );
if( !psz_current )
return;
val.psz_string = psz_current;
text.psz_string = psz_current;
// add this new skins if not yet present in repository
string current( psz_current );
map<string,string>::const_iterator it;
for( it = m_skinsMap.begin(); it != m_skinsMap.end(); ++it )
{
if( it->second == current )
break;
}
if( it == m_skinsMap.end() )
{
var_Change( getIntf(), "intf-skins", VLC_VAR_ADDCHOICE, &val,
&text );
string name = psz_current;
m_skinsMap[name] = name;
}
// mark this current skins as 'checked' in list
var_Change( getIntf(), "intf-skins", VLC_VAR_SETVALUE, &val, NULL );
free( psz_current );
}
/*****************************************************************************
* Activate: initialize and create stuff
*****************************************************************************/
static int Activate( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*)p_this;
int fd;
if( config_GetInt( p_intf, "netsync-master" ) <= 0 )
{
char *psz_master = config_GetPsz( p_intf, "netsync-master-ip" );
if( psz_master == NULL )
{
msg_Err( p_intf, "master address not specified" );
return VLC_EGENERIC;
}
fd = net_ConnectUDP( VLC_OBJECT(p_intf), psz_master, NETSYNC_PORT, -1 );
free( psz_master );
}
else
fd = net_ListenUDP1( VLC_OBJECT(p_intf), NULL, NETSYNC_PORT );
if( fd == -1 )
{
msg_Err( p_intf, "Netsync socket failure" );
return VLC_EGENERIC;
}
p_intf->p_sys = (void *)(intptr_t)fd;
p_intf->pf_run = Run;
return VLC_SUCCESS;
}
static void ChangeVFiltersString( intf_thread_t *p_intf,
char *psz_name, vlc_bool_t b_add )
{
vout_thread_t *p_vout;
char *psz_parser, *psz_string;
psz_string = config_GetPsz( p_intf, "filter" );
if( !psz_string ) psz_string = strdup("");
psz_parser = strstr( psz_string, psz_name );
if( b_add )
{
if( !psz_parser )
{
psz_parser = psz_string;
asprintf( &psz_string, (*psz_string) ? "%s:%s" : "%s%s",
psz_string, psz_name );
free( psz_parser );
}
else
{
return;
}
}
else
{
if( psz_parser )
{
memmove( psz_parser, psz_parser + strlen(psz_name) +
(*(psz_parser + strlen(psz_name)) == ':' ? 1 : 0 ),
strlen(psz_parser + strlen(psz_name)) + 1 );
/* Remove trailing : : */
if( *(psz_string+strlen(psz_string ) -1 ) == ':' )
{
*(psz_string+strlen(psz_string ) -1 ) = '\0';
}
}
else
{
free( psz_string );
return;
}
}
/* Vout is not kept, so put that in the config */
config_PutPsz( p_intf, "filter", psz_string );
/* Try to set on the fly */
p_vout = (vout_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_VOUT,
FIND_ANYWHERE );
if( p_vout )
{
var_SetString( p_vout, "filter", psz_string );
vlc_object_release( p_vout );
}
free( psz_string );
}
/* Audio panel constructor */
wxPanel *ExtraPanel::AudioPanel( wxWindow *parent )
{
char *psz_filters;
wxPanel *panel = new wxPanel( parent, -1 );
wxBoxSizer *panel_sizer = new wxBoxSizer( wxHORIZONTAL );
/* Create static box to surround the adjust controls */
wxStaticBox *filter_box =
new wxStaticBox( panel, -1, wxU(_("Audio filters")) );
wxStaticBoxSizer *filter_sizer =
new wxStaticBoxSizer( filter_box, wxVERTICAL );
filter_sizer->SetMinSize( -1, 50 );
wxCheckBox * headphone_check = new wxCheckBox( panel, HeadPhone_Event,
wxU(_("Headphone virtualization")));
headphone_check->SetToolTip( wxU(_("This filter gives the feeling of a "
"5.1 speaker set when using a headphone." ) ) );
wxCheckBox * normvol_check = new wxCheckBox( panel, NormVol_Event,
wxU(_("Volume normalization")));
normvol_check->SetToolTip( wxU(_("This filter prevents the audio output "
"power from going over a defined value." ) ) );
wxStaticText *normvol_label = new wxStaticText( panel, -1,
wxU( _("Maximum level") ) );
wxSlider *normvol_slider = new wxSlider ( panel, NVSlider_Event, 20, 5,
100, wxDefaultPosition, wxSize( 100, -1 ) );
filter_sizer->Add( headphone_check, 0, wxALL, 4 );
filter_sizer->Add( normvol_check, 0, wxALL, 4 );
filter_sizer->Add( normvol_label, 0, wxALL, 4 );
filter_sizer->Add( normvol_slider, 0, wxALL, 4 );
panel_sizer->Add( filter_sizer, 1, wxTOP, 2 );
panel->SetSizerAndFit( panel_sizer );
panel_sizer->Layout();
panel_sizer->SetSizeHints( panel );
/* Write down initial values */
psz_filters = config_GetPsz( p_intf, "audio-filter" );
if( psz_filters )
{
headphone_check->SetValue( strstr( psz_filters, "headphone" ) );
normvol_check->SetValue( strstr( psz_filters, "normvol" ) );
free( psz_filters );
}
else
{
headphone_check->SetValue( 0 );
normvol_check->SetValue( 0 );
}
return panel;
}
/**
* Finds the value of a variable. If the specified object does not hold a
* variable with the specified name, try the parent object, and iterate until
* the top of the tree. If no match is found, the value is read from the
* configuration.
*/
int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type,
vlc_value_t *p_val )
{
#ifndef NDEBUG
if (p_this != VLC_OBJECT(p_this->p_libvlc)
&& unlikely(p_this->p_parent == NULL))
{
msg_Info (p_this, "%s(%s) on detached object", __func__, psz_name);
//vlc_backtrace ();
}
#endif
i_type &= VLC_VAR_CLASS;
for( vlc_object_t *obj = p_this; obj != NULL; obj = obj->p_parent )
{
if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS )
return VLC_SUCCESS;
#ifndef NDEBUG
if (obj != p_this && obj != VLC_OBJECT(p_this->p_libvlc)
&& unlikely(obj->p_parent == NULL))
{
msg_Info (p_this, "%s(%s) on detached tree [%p] %s", __func__,
psz_name, obj, obj->psz_object_type);
//vlc_backtrace ();
}
#endif
}
/* else take value from config */
switch( i_type & VLC_VAR_CLASS )
{
case VLC_VAR_STRING:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
default:
msg_Warn( p_this, "Could not inherit value for var %s "
"from config. Invalid Type", psz_name );
return VLC_ENOOBJ;
}
/*msg_Dbg( p_this, "Inherited value for var %s from config", psz_name );*/
return VLC_SUCCESS;
}
void vout_EnableFilter( vout_thread_t *p_vout, char *psz_name,
bool b_add, bool b_setconfig )
{
char *psz_parser;
char *psz_string = config_GetPsz( p_vout, "vout-filter" );
/* Todo : Use some generic chain manipulation functions */
if( !psz_string ) psz_string = strdup("");
psz_parser = strstr( psz_string, psz_name );
if( b_add )
{
if( !psz_parser )
{
psz_parser = psz_string;
if( asprintf( &psz_string, (*psz_string) ? "%s:%s" : "%s%s",
psz_string, psz_name ) == -1 )
{
free( psz_parser );
return;
}
free( psz_parser );
}
else
return;
}
else
{
if( psz_parser )
{
memmove( psz_parser, psz_parser + strlen(psz_name) +
(*(psz_parser + strlen(psz_name)) == ':' ? 1 : 0 ),
strlen(psz_parser + strlen(psz_name)) + 1 );
/* Remove trailing : : */
if( *(psz_string+strlen(psz_string ) -1 ) == ':' )
{
*(psz_string+strlen(psz_string ) -1 ) = '\0';
}
}
else
{
free( psz_string );
return;
}
}
if( b_setconfig )
config_PutPsz( p_vout, "vout-filter", psz_string );
var_SetString( p_vout, "vout-filter", psz_string );
free( psz_string );
}
/**
* Get the user's configuration file
*/
static char *config_GetConfigFile( vlc_object_t *obj )
{
char *psz_file = config_GetPsz( obj, "config" );
if( psz_file == NULL )
{
char *psz_dir = config_GetUserDir( VLC_CONFIG_DIR );
if( asprintf( &psz_file, "%s" DIR_SEP CONFIG_FILE, psz_dir ) == -1 )
psz_file = NULL;
free( psz_dir );
}
return psz_file;
}
/*
* Returns true if the specified extra interface is present in the
* configuration, false if not
*/
bool config_ExistIntf( vlc_object_t *p_this, const char *psz_intf )
{
vlc_object_t *libvlc = VLC_OBJECT(p_this->obj.libvlc);
assert( psz_intf );
char *psz_config, *psz_parser;
size_t i_len = strlen( psz_intf );
psz_config = psz_parser = config_GetPsz( libvlc, "extraintf" );
while( psz_parser )
{
if( !strncmp( psz_parser, psz_intf, i_len ) )
{
free( psz_config );
return true;
}
psz_parser = strchr( psz_parser, ':' );
if( psz_parser ) psz_parser++; /* skip the ':' */
}
free( psz_config );
psz_config = psz_parser = config_GetPsz( libvlc, "control" );
while( psz_parser )
{
if( !strncmp( psz_parser, psz_intf, i_len ) )
{
free( psz_config );
return true;
}
psz_parser = strchr( psz_parser, ':' );
if( psz_parser ) psz_parser++; /* skip the ':' */
}
free( psz_config );
return false;
}
/*****************************************************************************
* Open: initialize dummy interface
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
vlm_t *mediatheque;
char *psz_address;
vlc_url_t url;
int i_telnetport;
if( !(mediatheque = vlm_New( p_intf )) )
{
msg_Err( p_intf, "cannot start VLM" );
return VLC_EGENERIC;
}
msg_Info( p_intf, "using the VLM interface plugin..." );
i_telnetport = config_GetInt( p_intf, "telnet-port" );
psz_address = config_GetPsz( p_intf, "telnet-host" );
vlc_UrlParse(&url, psz_address, 0);
// There might be two ports given, resolve any potentially
// conflict
url.i_port = getPort(p_intf, url, i_telnetport);
p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
if( ( p_intf->p_sys->pi_fd = net_ListenTCP( p_intf, url.psz_host, url.i_port ) )
== NULL )
{
msg_Err( p_intf, "cannot listen for telnet" );
vlc_UrlClean(&url);
free( psz_address );
free( p_intf->p_sys );
return VLC_EGENERIC;
}
msg_Info( p_intf,
"telnet interface started on interface %s %d",
url.psz_host, url.i_port );
p_intf->p_sys->i_clients = 0;
p_intf->p_sys->clients = NULL;
p_intf->p_sys->mediatheque = mediatheque;
p_intf->pf_run = Run;
vlc_UrlClean(&url);
free( psz_address );
return VLC_SUCCESS;
}
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;
}
bool ThemeLoader::load( const string &fileName )
{
// First, we try to un-targz the file, and if it fails we hope it's a XML
// file...
string path = getFilePath( fileName );
#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 );
}
if( skin_last ) free( skin_last );
// The new theme cannot embed a video output yet
VlcProc::instance( getIntf() )->dropVout();
return true;
}
/*****************************************************************************
* OpenFilter: probe the filter and return score
*****************************************************************************/
static int OpenFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t*)p_this;
filter_sys_t *p_sys;
/* Allocate the memory needed to store the decoder's structure */
if( ( p_filter->p_sys = p_sys =
(filter_sys_t *)malloc(sizeof(filter_sys_t)) ) == NULL )
{
return VLC_ENOMEM;
}
//init the video_filter_event_info_t struct
p_sys->event_info.i_region_size = 0;
p_sys->event_info.p_region = NULL;
p_sys->i_id = 0;
p_filter->pf_video_filter = Filter;
//create the VIDEO_FILTER_EVENT_VARIABLE
vlc_value_t val;
if (var_Create( p_filter->p_libvlc, VIDEO_FILTER_EVENT_VARIABLE, VLC_VAR_ADDRESS | VLC_VAR_DOINHERIT ) != VLC_SUCCESS)
msg_Err( p_filter, "Could not create %s", VIDEO_FILTER_EVENT_VARIABLE);
val.p_address = &(p_sys->event_info);
if (var_Set( p_filter->p_libvlc, VIDEO_FILTER_EVENT_VARIABLE, val )!=VLC_SUCCESS)
msg_Err( p_filter, "Could not set %s", VIDEO_FILTER_EVENT_VARIABLE);
//OpenCV init specific to this example
char* filename = config_GetPsz( p_filter, "opencv-haarcascade-file" );
p_filter->p_sys->p_cascade = (CvHaarClassifierCascade*)cvLoad( filename, 0, 0, 0 );
p_filter->p_sys->p_storage = cvCreateMemStorage(0);
free( filename );
return VLC_SUCCESS;
}
void Theme::loadConfig()
{
msg_Dbg( getIntf(), "loading theme configuration");
// Get config from vlcrc file
char *save = config_GetPsz( getIntf(), "skins2-config" );
if( !save ) return;
// Is there an existing config?
if( !strcmp( save, "" ) )
{
// Show the windows as indicated by the XML file
m_windowManager.showAll( true );
return;
}
istringstream inStream(save);
free( save );
char sep;
string winId, layId;
int x, y, width, height, visible;
bool somethingVisible = false;
while( !inStream.eof() )
{
inStream >> sep;
if( sep != '[' ) goto invalid;
inStream >> winId >> layId >> x >> y >> width >> height >> visible >> sep >> ws;
if( sep != ']' ) goto invalid;
// Try to find the window and the layout
map<string, TopWindowPtr>::const_iterator itWin;
map<string, GenericLayoutPtr>::const_iterator itLay;
itWin = m_windows.find( winId );
itLay = m_layouts.find( layId );
if( itWin == m_windows.end() || itLay == m_layouts.end() )
{
goto invalid;
}
TopWindow *pWin = itWin->second.get();
GenericLayout *pLayout = itLay->second.get();
// Restore the layout
m_windowManager.setActiveLayout( *pWin, *pLayout );
if( pLayout->getWidth() != width ||
pLayout->getHeight() != height )
{
// XXX FIXME XXX: big kludge
// As resizing a hidden window causes some trouble (at least on
// Windows), first show the window off screen, resize it, and
// hide it again.
// This has to be investigated more deeply!
m_windowManager.startMove( *pWin );
m_windowManager.move( *pWin, -width - pLayout->getWidth(), 0);
m_windowManager.stopMove();
m_windowManager.show( *pWin );
m_windowManager.startResize( *pLayout, WindowManager::kResizeSE );
m_windowManager.resize( *pLayout, width, height );
m_windowManager.stopResize();
m_windowManager.hide( *pWin );
}
// Move the window (which incidentally takes care of the anchoring)
m_windowManager.startMove( *pWin );
m_windowManager.move( *pWin, x, y );
m_windowManager.stopMove();
if( visible )
{
somethingVisible = true;
m_windowManager.show( *pWin );
}
}
if( !somethingVisible )
{
goto invalid;
}
return;
invalid:
msg_Warn( getIntf(), "invalid config: %s", inStream.str().c_str() );
// Restore the visibility defined in the theme
m_windowManager.showAll( true );
}
/*****************************************************************************
* HTTPOpen: Start the internal HTTP server
*****************************************************************************/
int E_(HTTPOpen)( access_t *p_access )
{
#define FREE( x ) \
if ( (x) != NULL ) \
free( x );
access_sys_t *p_sys = p_access->p_sys;
char *psz_address, *psz_cert = NULL, *psz_key = NULL,
*psz_ca = NULL, *psz_crl = NULL, *psz_user = NULL,
*psz_password = NULL, *psz_acl = NULL;
int i_port = 0;
char psz_tmp[10];
vlc_acl_t *p_acl = NULL;
httpd_file_sys_t *f;
vlc_mutex_init( p_access, &p_sys->httpd_mutex );
vlc_cond_init( p_access, &p_sys->httpd_cond );
p_sys->b_request_frontend_info = p_sys->b_request_mmi_info = VLC_FALSE;
p_sys->i_httpd_timeout = 0;
psz_address = var_GetString( p_access, "dvb-http-host" );
if( psz_address != NULL && *psz_address )
{
char *psz_parser = strchr( psz_address, ':' );
if( psz_parser )
{
*psz_parser++ = '\0';
i_port = atoi( psz_parser );
}
}
else
{
if ( psz_address != NULL ) free( psz_address );
return VLC_SUCCESS;
}
/* determine SSL configuration */
psz_cert = var_GetString( p_access, "dvb-http-intf-cert" );
if ( psz_cert != NULL && *psz_cert )
{
msg_Dbg( p_access, "enabling TLS for HTTP interface (cert file: %s)",
psz_cert );
psz_key = config_GetPsz( p_access, "dvb-http-intf-key" );
psz_ca = config_GetPsz( p_access, "dvb-http-intf-ca" );
psz_crl = config_GetPsz( p_access, "dvb-http-intf-crl" );
if ( i_port <= 0 )
i_port = 8443;
}
else
{
if ( !*psz_cert )
{
free( psz_cert );
psz_cert = NULL;
}
if ( i_port <= 0 )
i_port= 8082;
}
/* Ugly hack to allow to run several HTTP servers on different ports. */
sprintf( psz_tmp, ":%d", i_port + 1 );
config_PutPsz( p_access, "dvb-http-host", psz_tmp );
msg_Dbg( p_access, "base %s:%d", psz_address, i_port );
p_sys->p_httpd_host = httpd_TLSHostNew( VLC_OBJECT(p_access), psz_address,
i_port, psz_cert, psz_key, psz_ca,
psz_crl );
FREE( psz_cert );
FREE( psz_key );
FREE( psz_ca );
FREE( psz_crl );
if ( p_sys->p_httpd_host == NULL )
{
msg_Err( p_access, "cannot listen on %s:%d", psz_address, i_port );
free( psz_address );
return VLC_EGENERIC;
}
free( psz_address );
psz_user = var_GetString( p_access, "dvb-http-user" );
psz_password = var_GetString( p_access, "dvb-http-password" );
psz_acl = var_GetString( p_access, "dvb-http-acl" );
if ( psz_acl != NULL )
{
p_acl = ACL_Create( p_access, VLC_FALSE );
if( ACL_LoadFile( p_acl, psz_acl ) )
{
ACL_Destroy( p_acl );
p_acl = NULL;
}
}
/* Declare an index.html file. */
f = malloc( sizeof(httpd_file_sys_t) );
f->p_access = p_access;
f->p_file = httpd_FileNew( p_sys->p_httpd_host, "/index.html",
"text/html; charset=UTF-8",
psz_user, psz_password, p_acl,
HttpCallback, f );
FREE( psz_user );
FREE( psz_password );
FREE( psz_acl );
if ( p_acl != NULL )
ACL_Destroy( p_acl );
if ( f->p_file == NULL )
{
free( f );
p_sys->p_httpd_file = NULL;
return VLC_EGENERIC;
}
p_sys->p_httpd_file = f;
p_sys->p_httpd_redir = httpd_RedirectNew( p_sys->p_httpd_host,
"/index.html", "/" );
#undef FREE
return VLC_SUCCESS;
}
/*****************************************************************************
* Run: main loop
*****************************************************************************/
static void Run( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
struct timeval timeout;
char *psz_password;
psz_password = config_GetPsz( p_intf, "telnet-password" );
while( !p_intf->b_die )
{
fd_set fds_read, fds_write;
int i_handle_max = 0;
int i_ret, i_len, fd, i;
/* if a new client wants to communicate */
fd = net_Accept( p_intf, p_sys->pi_fd, p_sys->i_clients > 0 ? 0 : -1 );
if( fd > 0 )
{
telnet_client_t *cl;
/* to be non blocking */
#if defined( WIN32 ) || defined( UNDER_CE )
{
unsigned long i_dummy = 1;
ioctlsocket( fd, FIONBIO, &i_dummy );
}
#else
fcntl( fd, F_SETFL, O_NONBLOCK );
#endif
cl = malloc( sizeof( telnet_client_t ));
cl->i_tel_cmd = 0;
cl->fd = fd;
cl->buffer_write = NULL;
cl->p_buffer_write = cl->buffer_write;
Write_message( cl, NULL, "Password: \xff\xfb\x01", WRITE_MODE_PWD );
TAB_APPEND( p_sys->i_clients, p_sys->clients, cl );
}
/* to do a proper select */
FD_ZERO( &fds_read );
FD_ZERO( &fds_write );
for( i = 0 ; i < p_sys->i_clients ; i++ )
{
telnet_client_t *cl = p_sys->clients[i];
if( cl->i_mode == WRITE_MODE_PWD || cl->i_mode == WRITE_MODE_CMD )
{
FD_SET( cl->fd , &fds_write );
}
else
{
FD_SET( cl->fd , &fds_read );
}
i_handle_max = __MAX( i_handle_max, cl->fd );
}
timeout.tv_sec = 0;
timeout.tv_usec = 500*1000;
i_ret = select( i_handle_max + 1, &fds_read, &fds_write, 0, &timeout );
if( i_ret == -1 && errno != EINTR )
{
msg_Warn( p_intf, "cannot select sockets" );
msleep( 1000 );
continue;
}
else if( i_ret <= 0 )
{
continue;
}
/* check if there is something to do with the socket */
for( i = 0 ; i < p_sys->i_clients ; i++ )
{
telnet_client_t *cl = p_sys->clients[i];
if( FD_ISSET(cl->fd , &fds_write) && cl->i_buffer_write > 0 )
{
i_len = send( cl->fd , cl->p_buffer_write ,
cl->i_buffer_write , 0 );
if( i_len > 0 )
{
cl->p_buffer_write += i_len;
cl->i_buffer_write -= i_len;
}
}
else if( FD_ISSET( cl->fd, &fds_read) )
{
int i_end = 0;
int i_recv;
while( (i_recv=recv( cl->fd, cl->p_buffer_read, 1, 0 )) > 0 &&
cl->p_buffer_read - cl->buffer_read < 999 )
{
switch( cl->i_tel_cmd )
{
case 0:
switch( *(uint8_t *)cl->p_buffer_read )
{
case '\r':
break;
case '\n':
*cl->p_buffer_read = '\n';
i_end = 1;
break;
case TEL_IAC: // telnet specific command
cl->i_tel_cmd = 1;
cl->p_buffer_read++;
break;
default:
cl->p_buffer_read++;
break;
}
break;
case 1:
switch( *(uint8_t *)cl->p_buffer_read )
{
case TEL_WILL: case TEL_WONT:
case TEL_DO: case TEL_DONT:
cl->i_tel_cmd++;
cl->p_buffer_read++;
break;
default:
cl->i_tel_cmd = 0;
cl->p_buffer_read--;
break;
}
break;
case 2:
cl->i_tel_cmd = 0;
cl->p_buffer_read -= 2;
break;
}
if( i_end != 0 ) break;
}
if( cl->p_buffer_read - cl->buffer_read == 999 )
{
Write_message( cl, NULL, "Line too long\r\n",
cl->i_mode + 2 );
}
if( i_recv == 0 || ( i_recv == -1 && errno != EAGAIN && errno != 0 ) )
{
net_Close( cl->fd );
TAB_REMOVE( p_intf->p_sys->i_clients ,
p_intf->p_sys->clients , cl );
free( cl );
}
}
}
/* and now we should bidouille the data we received / send */
for( i = 0 ; i < p_sys->i_clients ; i++ )
{
telnet_client_t *cl = p_sys->clients[i];
if( cl->i_mode >= WRITE_MODE_PWD && cl->i_buffer_write == 0 )
{
// we have finished to send
cl->i_mode -= 2; // corresponding READ MODE
}
else if( cl->i_mode == READ_MODE_PWD &&
*cl->p_buffer_read == '\n' )
{
*cl->p_buffer_read = '\0';
if( strcmp( psz_password, cl->buffer_read ) == 0 )
{
Write_message( cl, NULL, "\xff\xfc\x01\r\nWelcome, "
"Master\r\n> ", WRITE_MODE_CMD );
}
else
{
/* wrong password */
Write_message( cl, NULL,
"\r\nWrong password.\r\nPassword: "******"logout", 6 ) ||
!strncmp( cl->buffer_read, "quit", 4 ) ||
!strncmp( cl->buffer_read, "exit", 4 ) )
{
net_Close( cl->fd );
TAB_REMOVE( p_intf->p_sys->i_clients ,
p_intf->p_sys->clients , cl );
free( cl );
}
else if( !strncmp( cl->buffer_read, "shutdown", 8 ) )
{
msg_Err( p_intf, "shutdown requested" );
p_intf->p_vlc->b_die = VLC_TRUE;
}
else
{
vlm_message_t *message;
/* create a standard string */
*cl->p_buffer_read = '\0';
vlm_ExecuteCommand( p_sys->mediatheque, cl->buffer_read,
&message );
Write_message( cl, message, NULL, WRITE_MODE_CMD );
vlm_MessageDelete( message );
}
}
}
}
}
/*****************************************************************************
* Activate: initialize and create stuff
*****************************************************************************/
static int Activate( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*)p_this;
char *psz_host, *psz_unix_path;
int i_socket = -1;
#if defined(HAVE_ISATTY) && !defined(WIN32)
/* Check that stdin is a TTY */
if( !config_GetInt( p_intf, "rtci-fake-tty" ) && !isatty( 0 ) )
{
msg_Warn( p_intf, "fd 0 is not a TTY" );
return VLC_EGENERIC;
}
#endif
psz_unix_path = config_GetPsz( p_intf, "rtci-unix" );
if( psz_unix_path )
{
#ifndef PF_LOCAL
msg_Warn( p_intf, "your OS doesn't support filesystem sockets" );
free( psz_unix_path );
return VLC_EGENERIC;
#else
struct sockaddr_un addr;
int i_ret;
memset( &addr, 0, sizeof(struct sockaddr_un) );
msg_Dbg( p_intf, "trying UNIX socket" );
if( (i_socket = socket( PF_LOCAL, SOCK_STREAM, 0 ) ) < 0 )
{
msg_Warn( p_intf, "can't open socket: %s", strerror(errno) );
free( psz_unix_path );
return VLC_EGENERIC;
}
addr.sun_family = AF_LOCAL;
strncpy( addr.sun_path, psz_unix_path, sizeof( addr.sun_path ) );
addr.sun_path[sizeof( addr.sun_path ) - 1] = '\0';
if( (i_ret = bind( i_socket, (struct sockaddr*)&addr,
sizeof(struct sockaddr_un) ) ) < 0 )
{
msg_Warn( p_intf, "couldn't bind socket to address: %s",
strerror(errno) );
free( psz_unix_path );
net_Close( i_socket );
return VLC_EGENERIC;
}
if( ( i_ret = listen( i_socket, 1 ) ) < 0 )
{
msg_Warn( p_intf, "can't listen on socket: %s", strerror(errno));
free( psz_unix_path );
net_Close( i_socket );
return VLC_EGENERIC;
}
#endif
}
if( ( i_socket == -1) &&
( psz_host = config_GetPsz( p_intf, "rtci-host" ) ) != NULL )
{
vlc_url_t url;
vlc_UrlParse( &url, psz_host, 0 );
msg_Dbg( p_intf, "base %s port %d", url.psz_host, url.i_port );
if( (i_socket = net_ListenTCP(p_this, url.psz_host, url.i_port)) == -1)
{
msg_Warn( p_intf, "can't listen to %s port %i",
url.psz_host, url.i_port );
vlc_UrlClean( &url );
free( psz_host );
return VLC_EGENERIC;
}
vlc_UrlClean( &url );
free( psz_host );
}
p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
if( !p_intf->p_sys )
{
msg_Err( p_intf, "no memory" );
return VLC_ENOMEM;
}
p_intf->p_sys->i_socket_listen = i_socket;
p_intf->p_sys->i_socket = -1;
p_intf->p_sys->psz_unix_path = psz_unix_path;
/* Non-buffered stdout */
setvbuf( stdout, (char *)NULL, _IOLBF, 0 );
p_intf->pf_run = Run;
#ifdef WIN32
if( !config_GetInt( p_intf, "rtci-quiet" ) ) { CONSOLE_INTRO_MSG; }
#else
CONSOLE_INTRO_MSG;
#endif
msg_rtci( _("Real time control interface initialized, `h' for help\n") );
return VLC_SUCCESS;
}
/*****************************************************************************
* OpenVideo: allocate SDL video thread output method
*****************************************************************************
* This function allocate and initialize a SDL vout method. It uses some of the
* vout properties to choose the correct mode, and change them according to the
* mode actually used.
*****************************************************************************/
static int Open ( vlc_object_t *p_this )
{
vout_thread_t * p_vout = (vout_thread_t *)p_this;
vlc_value_t lockval;
#ifdef HAVE_SETENV
char *psz_method;
#endif
var_Get( p_this->p_libvlc, "sdl", &lockval );
vlc_mutex_lock( lockval.p_address );
if( SDL_WasInit( SDL_INIT_VIDEO ) != 0 )
{
vlc_mutex_unlock( lockval.p_address );
return VLC_EGENERIC;
}
/* Allocate structure */
p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
if( p_vout->p_sys == NULL )
{
msg_Err( p_vout, "out of memory" );
vlc_mutex_unlock( lockval.p_address );
return VLC_ENOMEM;
}
p_vout->pf_init = Init;
p_vout->pf_end = End;
p_vout->pf_manage = Manage;
p_vout->pf_render = NULL;
p_vout->pf_display = Display;
#ifdef HAVE_SETENV
psz_method = config_GetPsz( p_vout, "vout" );
if( psz_method )
{
while( *psz_method && *psz_method != ':' )
{
psz_method++;
}
if( *psz_method )
{
setenv( "SDL_VIDEODRIVER", psz_method + 1, 1 );
}
}
#endif
/* Initialize library */
if( SDL_Init( SDL_INIT_VIDEO
#ifndef WIN32
/* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
| SDL_INIT_EVENTTHREAD
#endif
#ifdef DEBUG
/* In debug mode you may want vlc to dump a core instead of staying
* stuck */
| SDL_INIT_NOPARACHUTE
#endif
) < 0 )
{
msg_Err( p_vout, "cannot initialize SDL (%s)", SDL_GetError() );
free( p_vout->p_sys );
vlc_mutex_unlock( lockval.p_address );
return VLC_EGENERIC;
}
vlc_mutex_unlock( lockval.p_address );
p_vout->p_sys->b_cursor = 1;
p_vout->p_sys->b_cursor_autohidden = 0;
p_vout->p_sys->i_lastmoved = mdate();
if( OpenDisplay( p_vout ) )
{
msg_Err( p_vout, "cannot set up SDL (%s)", SDL_GetError() );
SDL_QuitSubSystem( SDL_INIT_VIDEO );
free( p_vout->p_sys );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: initialize and create stuff
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys;
xosd *p_osd;
char *psz_font, *psz_colour;
if( getenv( "DISPLAY" ) == NULL )
{
msg_Err( p_intf, "no display, please set the DISPLAY variable" );
return VLC_EGENERIC;
}
/* Allocate instance and initialize some members */
p_sys = p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
/* Initialize library */
psz_font = config_GetPsz( p_intf, "xosd-font" );
psz_colour = config_GetPsz( p_intf, "xosd-colour" );
p_osd = xosd_create( 1 );
if( p_osd == NULL )
{
msg_Err( p_intf, "couldn't initialize libxosd" );
free( psz_colour );
free( psz_font );
free( p_sys );
return VLC_EGENERIC;
}
p_sys->p_osd = p_osd;
/* Set user preferences */
xosd_set_outline_colour( p_osd, "black" );
xosd_set_font( p_osd, psz_font );
xosd_set_colour( p_osd, psz_colour );
xosd_set_timeout( p_osd, 3 );
xosd_set_pos( p_osd, config_GetInt( p_intf, "xosd-position" ) ?
XOSD_bottom: XOSD_top );
xosd_set_horizontal_offset( p_osd,
config_GetInt( p_intf, "xosd-text-offset" ) );
xosd_set_vertical_offset( p_osd,
config_GetInt( p_intf, "xosd-text-offset" ) );
xosd_set_shadow_offset( p_osd,
config_GetInt( p_intf, "xosd-shadow-offset" ));
/* Initialize to NULL */
xosd_display( p_osd, 0, XOSD_string, "XOSD interface initialized" );
free( psz_colour );
free( psz_font );
// Initialize mutex and condition variable before adding the callbacks
vlc_mutex_init( &p_sys->lock );
vlc_cond_init( &p_sys->cond );
// Add the callbacks
playlist_t *p_playlist = pl_Hold( p_intf );
var_AddCallback( p_playlist, "item-current", PlaylistNext, p_this );
var_AddCallback( p_playlist, "item-change", PlaylistNext, p_this );
pl_Release( p_intf );
p_sys->b_need_update = true;
p_intf->pf_run = Run;
return VLC_SUCCESS;
}
static void ChangeFiltersString( intf_thread_t *p_intf,
aout_instance_t * p_aout,
char *psz_name, vlc_bool_t b_add )
{
char *psz_parser, *psz_string;
if( p_aout )
{
psz_string = var_GetString( p_aout, "audio-filter" );
}
else
{
psz_string = config_GetPsz( p_intf, "audio-filter" );
}
if( !psz_string ) psz_string = strdup("");
psz_parser = strstr( psz_string, psz_name );
if( b_add )
{
if( !psz_parser )
{
psz_parser = psz_string;
asprintf( &psz_string, (*psz_string) ? "%s,%s" : "%s%s",
psz_string, psz_name );
free( psz_parser );
}
else
{
return;
}
}
else
{
if( psz_parser )
{
memmove( psz_parser, psz_parser + strlen(psz_name) +
(*(psz_parser + strlen(psz_name)) == ',' ? 1 : 0 ),
strlen(psz_parser + strlen(psz_name)) + 1 );
if( *(psz_string+strlen(psz_string ) -1 ) == ',' )
{
*(psz_string+strlen(psz_string ) -1 ) = '\0';
}
}
else
{
free( psz_string );
return;
}
}
if( p_aout == NULL )
{
config_PutPsz( p_intf, "audio-filter", psz_string );
}
else
{
var_SetString( p_aout, "audio-filter", psz_string );
for( int i = 0; i < p_aout->i_nb_inputs; i++ )
{
p_aout->pp_inputs[i]->b_restart = VLC_TRUE;
}
}
free( psz_string );
}
//---------------------------------------------------------------------------
// Run: main loop
//---------------------------------------------------------------------------
static void *Run( void * p_obj )
{
int canc = vlc_savecancel();
intf_thread_t *p_intf = (intf_thread_t *)p_obj;
bool b_error = false;
char *skin_last = NULL;
ThemeLoader *pLoader = NULL;
OSLoop *loop = NULL;
vlc_mutex_lock( &p_intf->p_sys->init_lock );
// Initialize singletons
if( OSFactory::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot initialize OSFactory" );
b_error = true;
goto end;
}
if( AsyncQueue::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot initialize AsyncQueue" );
b_error = true;
goto end;
}
if( Interpreter::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instantiate Interpreter" );
b_error = true;
goto end;
}
if( VarManager::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instantiate VarManager" );
b_error = true;
goto end;
}
if( VlcProc::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot initialize VLCProc" );
b_error = true;
goto end;
}
if( VoutManager::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instantiate VoutManager" );
b_error = true;
goto end;
}
if( ArtManager::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instantiate ArtManager" );
b_error = true;
goto end;
}
if( ThemeRepository::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instantiate ThemeRepository" );
b_error = true;
goto end;
}
if( Dialogs::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instantiate qt4 dialogs provider" );
b_error = true;
goto end;
}
// Load a theme
skin_last = config_GetPsz( p_intf, "skins2-last" );
pLoader = new ThemeLoader( p_intf );
if( !skin_last || !pLoader->load( skin_last ) )
{
// No skins (not even the default one). let's quit
CmdQuit *pCmd = new CmdQuit( p_intf );
AsyncQueue *pQueue = AsyncQueue::instance( p_intf );
pQueue->push( CmdGenericPtr( pCmd ) );
msg_Err( p_intf, "no skins found : exiting");
}
delete pLoader;
free( skin_last );
// Get the instance of OSLoop
loop = OSFactory::instance( p_intf )->getOSLoop();
// Signal the main thread this thread is now ready
p_intf->p_sys->b_error = false;
p_intf->p_sys->b_ready = true;
vlc_cond_signal( &p_intf->p_sys->init_wait );
vlc_mutex_unlock( &p_intf->p_sys->init_lock );
// Enter the main event loop
loop->run();
// Destroy OSLoop
OSFactory::instance( p_intf )->destroyOSLoop();
// save and delete the theme
if( p_intf->p_sys->p_theme )
{
p_intf->p_sys->p_theme->saveConfig();
delete p_intf->p_sys->p_theme;
p_intf->p_sys->p_theme = NULL;
msg_Dbg( p_intf, "current theme deleted" );
}
// save config file
config_SaveConfigFile( p_intf );
end:
// Destroy "singleton" objects
Dialogs::destroy( p_intf );
ThemeRepository::destroy( p_intf );
ArtManager::destroy( p_intf );
VoutManager::destroy( p_intf );
VlcProc::destroy( p_intf );
VarManager::destroy( p_intf );
Interpreter::destroy( p_intf );
AsyncQueue::destroy( p_intf );
OSFactory::destroy( p_intf );
if( b_error )
{
p_intf->p_sys->b_error = true;
p_intf->p_sys->b_ready = true;
vlc_cond_signal( &p_intf->p_sys->init_wait );
vlc_mutex_unlock( &p_intf->p_sys->init_lock );
}
vlc_restorecancel(canc);
return NULL;
}
/*****************************************************************************
* Init: initialize video thread
*****************************************************************************/
static int Init( vout_thread_t *p_vout )
{
int i_index;
picture_t *p_pic;
vlc_value_t val;
char* psz_chroma;
int i_chroma;
int i_width;
int i_height;
int i_datasize;
i_width = config_GetInt( p_vout, "snapshot-width" );
i_height = config_GetInt( p_vout, "snapshot-height" );
psz_chroma = config_GetPsz( p_vout, "snapshot-chroma" );
if( psz_chroma )
{
if( strlen( psz_chroma ) < 4 )
{
msg_Err( p_vout, "snapshot-chroma should be 4 characters long" );
return VLC_EGENERIC;
}
i_chroma = VLC_FOURCC( psz_chroma[0], psz_chroma[1],
psz_chroma[2], psz_chroma[3] );
free( psz_chroma );
}
else
{
msg_Err( p_vout, "Cannot find chroma information." );
return VLC_EGENERIC;
}
I_OUTPUTPICTURES = 0;
/* Initialize the output structure */
p_vout->output.i_chroma = i_chroma;
p_vout->output.pf_setpalette = NULL;
p_vout->output.i_width = i_width;
p_vout->output.i_height = i_height;
p_vout->output.i_aspect = p_vout->output.i_width
* VOUT_ASPECT_FACTOR / p_vout->output.i_height;
/* Define the bitmasks */
switch( i_chroma )
{
case VLC_FOURCC( 'R','V','1','5' ):
p_vout->output.i_rmask = 0x001f;
p_vout->output.i_gmask = 0x03e0;
p_vout->output.i_bmask = 0x7c00;
break;
case VLC_FOURCC( 'R','V','1','6' ):
p_vout->output.i_rmask = 0x001f;
p_vout->output.i_gmask = 0x07e0;
p_vout->output.i_bmask = 0xf800;
break;
case VLC_FOURCC( 'R','V','2','4' ):
p_vout->output.i_rmask = 0xff0000;
p_vout->output.i_gmask = 0x00ff00;
p_vout->output.i_bmask = 0x0000ff;
break;
case VLC_FOURCC( 'R','V','3','2' ):
p_vout->output.i_rmask = 0xff0000;
p_vout->output.i_gmask = 0x00ff00;
p_vout->output.i_bmask = 0x0000ff;
break;
}
/* Try to initialize 1 direct buffer */
p_pic = NULL;
/* Find an empty picture slot */
for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
{
if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
{
p_pic = p_vout->p_picture + i_index;
break;
}
}
/* Allocate the picture */
if( p_pic == NULL )
{
return VLC_SUCCESS;
}
vout_AllocatePicture( VLC_OBJECT(p_vout), p_pic, p_vout->output.i_chroma,
p_vout->output.i_width, p_vout->output.i_height,
p_vout->output.i_aspect );
if( p_pic->i_planes == 0 )
{
return VLC_EGENERIC;
}
p_pic->i_status = DESTROYED_PICTURE;
p_pic->i_type = DIRECT_PICTURE;
PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
I_OUTPUTPICTURES++;
/* Get datasize and set variables */
i_datasize = i_width * i_height * p_pic->p->i_pixel_pitch;
p_vout->p_sys->i_datasize = i_datasize;
p_vout->p_sys->i_index = 0;
p_vout->p_sys->i_size = config_GetInt( p_vout, "snapshot-cache-size" );
if( p_vout->p_sys->i_size < 2 )
{
msg_Err( p_vout, "snapshot-cache-size must be at least 1." );
return VLC_EGENERIC;
}
p_vout->p_sys->p_list = malloc( p_vout->p_sys->i_size * sizeof( snapshot_t * ) );
if( p_vout->p_sys->p_list == NULL )
return VLC_ENOMEM;
/* Initialize the structures for the circular buffer */
for( i_index = 0; i_index < p_vout->p_sys->i_size; i_index++ )
{
snapshot_t *p_snapshot = malloc( sizeof( snapshot_t ) );
if( p_snapshot == NULL )
return VLC_ENOMEM;
p_snapshot->i_width = i_width;
p_snapshot->i_height = i_height;
p_snapshot->i_datasize = i_datasize;
p_snapshot->date = 0;
p_snapshot->p_data = ( char* ) malloc( i_datasize );
if( p_snapshot->p_data == NULL )
return VLC_ENOMEM;
p_vout->p_sys->p_list[i_index] = p_snapshot;
}
val.i_int = i_width;
var_Set( p_vout, "snapshot-width", val );
val.i_int = i_height;
var_Set( p_vout, "snapshot-height", val );
val.i_int = i_datasize;
var_Set( p_vout, "snapshot-datasize", val );
val.i_int = p_vout->p_sys->i_size;
var_Set( p_vout, "snapshot-cache-size", val );
val.p_address = p_vout->p_sys->p_list;
var_Set( p_vout, "snapshot-list-pointer", val );
/* Get the p_input pointer (to access video times) */
p_vout->p_sys->p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT,
FIND_PARENT );
if( !p_vout->p_sys->p_input )
return VLC_ENOOBJ;
if( var_Create( p_vout->p_sys->p_input, "snapshot-id", VLC_VAR_INTEGER ) )
{
msg_Err( p_vout, "Cannot create snapshot-id variable in p_input (%d).",
p_vout->p_sys->p_input->i_object_id );
return VLC_EGENERIC;
}
/* Register the snapshot vout module at the input level */
val.i_int = p_vout->i_object_id;
if( var_Set( p_vout->p_sys->p_input, "snapshot-id", val ) )
{
msg_Err( p_vout, "Cannot register snapshot-id in p_input (%d).",
p_vout->p_sys->p_input->i_object_id );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
//---------------------------------------------------------------------------
// Run: main loop
//---------------------------------------------------------------------------
static void *Run( void * p_obj )
{
int canc = vlc_savecancel();
intf_thread_t *p_intf = (intf_thread_t *)p_obj;
bool b_error = false;
char *skin_last = NULL;
ThemeLoader *pLoader = NULL;
OSLoop *loop = NULL;
vlc_mutex_lock( &p_intf->p_sys->init_lock );
// Initialize singletons
if( OSFactory::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot initialize OSFactory" );
b_error = true;
goto end;
}
if( AsyncQueue::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot initialize AsyncQueue" );
b_error = true;
goto end;
}
if( Interpreter::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instanciate Interpreter" );
b_error = true;
goto end;
}
if( VarManager::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instanciate VarManager" );
b_error = true;
goto end;
}
if( VlcProc::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot initialize VLCProc" );
b_error = true;
goto end;
}
if( VoutManager::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instanciate VoutManager" );
b_error = true;
goto end;
}
if( ThemeRepository::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instanciate ThemeRepository" );
b_error = true;
goto end;
}
if( Dialogs::instance( p_intf ) == NULL )
{
msg_Err( p_intf, "cannot instanciate qt4 dialogs provider" );
b_error = true;
goto end;
}
// Load a theme
skin_last = config_GetPsz( p_intf, "skins2-last" );
pLoader = new ThemeLoader( p_intf );
if( !skin_last || !*skin_last || !pLoader->load( skin_last ) )
{
// Get the resource path and try to load the default skin
OSFactory *pOSFactory = OSFactory::instance( p_intf );
const list<string> &resPath = pOSFactory->getResourcePath();
const string &sep = pOSFactory->getDirSeparator();
list<string>::const_iterator it;
for( it = resPath.begin(); it != resPath.end(); it++ )
{
string path = (*it) + sep + "default.vlt";
if( pLoader->load( path ) )
{
// Theme loaded successfully
break;
}
}
if( it == resPath.end() )
{
// Last chance: the user can select a new theme file
if( Dialogs::instance( p_intf ) )
{
CmdDlgChangeSkin *pCmd = new CmdDlgChangeSkin( p_intf );
AsyncQueue *pQueue = AsyncQueue::instance( p_intf );
pQueue->push( CmdGenericPtr( pCmd ) );
}
else
{
// No dialogs provider, just quit...
CmdQuit *pCmd = new CmdQuit( p_intf );
AsyncQueue *pQueue = AsyncQueue::instance( p_intf );
pQueue->push( CmdGenericPtr( pCmd ) );
msg_Err( p_intf,
"cannot show the \"open skin\" dialog: exiting...");
}
}
}
delete pLoader;
free( skin_last );
// Get the instance of OSLoop
loop = OSFactory::instance( p_intf )->getOSLoop();
// Signal the main thread this thread is now ready
p_intf->p_sys->b_ready = true;
vlc_cond_signal( &p_intf->p_sys->init_wait );
vlc_mutex_unlock( &p_intf->p_sys->init_lock );
// Enter the main event loop
loop->run();
// Destroy OSLoop
OSFactory::instance( p_intf )->destroyOSLoop();
// save and delete the theme
if( p_intf->p_sys->p_theme )
{
p_intf->p_sys->p_theme->saveConfig();
delete p_intf->p_sys->p_theme;
p_intf->p_sys->p_theme = NULL;
msg_Dbg( p_intf, "current theme deleted" );
}
// save config file
config_SaveConfigFile( p_intf, NULL );
end:
// Destroy "singleton" objects
Dialogs::destroy( p_intf );
ThemeRepository::destroy( p_intf );
VoutManager::destroy( p_intf );
VlcProc::destroy( p_intf );
VarManager::destroy( p_intf );
Interpreter::destroy( p_intf );
AsyncQueue::destroy( p_intf );
OSFactory::destroy( p_intf );
if( b_error )
{
p_intf->p_sys->b_ready = true;
vlc_cond_signal( &p_intf->p_sys->init_wait );
vlc_mutex_unlock( &p_intf->p_sys->init_lock );
libvlc_Quit( p_intf->p_libvlc );
}
vlc_restorecancel(canc);
return NULL;
}
/* Video Panel constructor */
wxPanel *ExtraPanel::VideoPanel( wxWindow *parent )
{
char *psz_filters;
wxPanel *panel = new wxPanel( parent, -1 );
wxBoxSizer *panel_sizer = new wxBoxSizer( wxHORIZONTAL );
/* Create static box to surround the adjust controls */
wxStaticBox *adjust_box =
new wxStaticBox( panel, -1, wxU(_("Adjust Image")) );
wxStaticBoxSizer *adjust_sizer =
new wxStaticBoxSizer( adjust_box, wxVERTICAL );
adjust_sizer->SetMinSize( -1, 50 );
/* Create flex grid */
wxFlexGridSizer *adjust_gridsizer =
new wxFlexGridSizer( 6, 2, 0, 0);
adjust_gridsizer->AddGrowableCol(1);
/* Create the adjust button */
wxCheckBox * adjust_check = new wxCheckBox( panel, Adjust_Event,
wxU(_("Enable")));
/* Create the restore to defaults button */
restoredefaults_button =
new wxButton( panel, RestoreDefaults_Event,
wxU(_("Restore Defaults")), wxDefaultPosition);
wxStaticText *hue_text = new wxStaticText( panel, -1,
wxU(_("Hue")) );
hue_slider = new wxSlider ( panel, Hue_Event, 0, 0,
360, wxDefaultPosition, wxDefaultSize );
wxStaticText *contrast_text = new wxStaticText( panel, -1,
wxU(_("Contrast")) );
contrast_slider = new wxSlider ( panel, Contrast_Event, 0, 0,
200, wxDefaultPosition, wxDefaultSize);
wxStaticText *brightness_text = new wxStaticText( panel, -1,
wxU(_("Brightness")) );
brightness_slider = new wxSlider ( panel, Brightness_Event, 0, 0,
200, wxDefaultPosition, wxDefaultSize) ;
wxStaticText *saturation_text = new wxStaticText( panel, -1,
wxU(_("Saturation")) );
saturation_slider = new wxSlider ( panel, Saturation_Event, 0, 0,
300, wxDefaultPosition, wxDefaultSize );
wxStaticText *gamma_text = new wxStaticText( panel, -1,
wxU(_("Gamma")) );
gamma_slider = new wxSlider ( panel, Gamma_Event, 0, 0,
100, wxDefaultPosition, wxDefaultSize );
adjust_gridsizer->Add( adjust_check, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( restoredefaults_button, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( hue_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( hue_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( contrast_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( contrast_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( brightness_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( brightness_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( saturation_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( saturation_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( gamma_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( gamma_slider, 1, wxEXPAND|wxALL, 2 );
adjust_sizer->Add( adjust_gridsizer, 1, wxEXPAND|wxALL, 2);
panel_sizer->Add( adjust_sizer , 1, wxTOP, 2 );
#if 0
/* Create sizer to surround the other controls */
wxBoxSizer *other_sizer = new wxBoxSizer( wxVERTICAL );
wxStaticBox *video_box =
new wxStaticBox( panel, -1, wxU(_("Video Options")) );
/* Create the sizer for the frame */
wxStaticBoxSizer *video_sizer =
new wxStaticBoxSizer( video_box, wxVERTICAL );
video_sizer->SetMinSize( -1, 50 );
static const wxString ratio_array[] =
{
wxT("4:3"),
wxT("16:9"),
};
wxBoxSizer *ratio_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticText *ratio_text = new wxStaticText( panel, -1,
wxU(_("Aspect Ratio")) );
ratio_combo = new wxComboBox( panel, Ratio_Event, wxT(""),
wxDefaultPosition, wxSize( 80 , -1),
WXSIZEOF(ratio_array), ratio_array,
0 );
ratio_sizer->Add( ratio_text, 0, wxALL, 2 );
ratio_sizer->Add( ratio_combo, 0, wxALL, 2 );
ratio_sizer->Layout();
video_sizer->Add( ratio_sizer , 0 , wxALL , 2 );
video_sizer->Layout();
#endif
wxStaticBox *filter_box =
new wxStaticBox( panel, -1, wxU(_("Video Filters")) );
wxStaticBoxSizer *filter_sizer =
new wxStaticBoxSizer( filter_box, wxHORIZONTAL );
wxBoxSizer *t_col_sizer = new wxBoxSizer( wxVERTICAL );
for( int i = 0 ; vfilters[i].psz_filter != NULL ; i++ )
{
wxCheckBox *box = new wxCheckBox( panel, Filter0_Event + i,
wxU( _( vfilters[i].psz_name ) ) );
t_col_sizer->Add( box, 0, wxALL, 4 );
box->SetToolTip( wxU( _( vfilters[i].psz_help ) ) );
}
filter_sizer->Add( t_col_sizer );
filter_sizer->Add( new wxButton( panel, FiltersInfo_Event,
wxU(_("More info" ) ) ), 0, wxALL, 4 );
#if 0
other_sizer->Add( video_sizer, 0, wxALL | wxEXPAND , 0);
other_sizer->Add( filter_sizer, 0, wxALL | wxEXPAND , 0);
other_sizer->Layout();
panel_sizer->Add(other_sizer , 1 );
#endif
panel_sizer->Add( filter_sizer, 1, wxTOP|wxLEFT, 2 );
panel->SetSizerAndFit( panel_sizer );
/* Layout the whole panel */
panel_sizer->Layout();
panel_sizer->SetSizeHints( panel );
/* Write down initial values */
psz_filters = config_GetPsz( p_intf, "filter" );
if( psz_filters && strstr( psz_filters, "adjust" ) )
{
adjust_check->SetValue( 1 );
restoredefaults_button->Enable();
saturation_slider->Enable();
contrast_slider->Enable();
brightness_slider->Enable();
hue_slider->Enable();
gamma_slider->Enable();
}
else
{
adjust_check->SetValue( 0 );
restoredefaults_button->Disable();
saturation_slider->Disable();
contrast_slider->Disable();
brightness_slider->Disable();
hue_slider->Disable();
gamma_slider->Disable();
}
if( psz_filters ) free( psz_filters );
int i_value = config_GetInt( p_intf, "hue" );
if( i_value > 0 && i_value < 360 )
hue_slider->SetValue( i_value );
float f_value;
f_value = config_GetFloat( p_intf, "saturation" );
if( f_value > 0 && f_value < 5 )
saturation_slider->SetValue( (int)(100 * f_value) );
f_value = config_GetFloat( p_intf, "contrast" );
if( f_value > 0 && f_value < 4 )
contrast_slider->SetValue( (int)(100 * f_value) );
f_value = config_GetFloat( p_intf, "brightness" );
if( f_value > 0 && f_value < 2 )
brightness_slider->SetValue( (int)(100 * f_value) );
f_value = config_GetFloat( p_intf, "gamma" );
if( f_value > 0 && f_value < 10 )
gamma_slider->SetValue( (int)(10 * f_value) );
return panel;
}
/*****************************************************************************
* Open: initialize and create stuff
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
xosd *p_osd;
/* Allocate instance and initialize some members */
p_intf->p_sys = (intf_sys_t *)malloc( sizeof( intf_sys_t ) );
if( p_intf->p_sys == NULL )
{
msg_Err( p_intf, "out of memory" );
return VLC_ENOMEM;
}
if( getenv( "DISPLAY" ) == NULL )
{
msg_Err( p_intf, "no display, please set the DISPLAY variable" );
return VLC_EGENERIC;
}
/* Initialize library */
#if defined(HAVE_XOSD_VERSION_0) || defined(HAVE_XOSD_VERSION_1)
p_osd = p_intf->p_sys->p_osd =
xosd_init( config_GetPsz( p_intf, "xosd-font" ),
config_GetPsz( p_intf,"xosd-colour" ), 3,
XOSD_top, 0, 1 );
if( p_intf->p_sys->p_osd == NULL )
{
msg_Err( p_intf, "couldn't initialize libxosd" );
return VLC_EGENERIC;
}
#else
p_osd = p_intf->p_sys->p_osd = xosd_create( 1 );
if( p_osd == NULL )
{
msg_Err( p_intf, "couldn't initialize libxosd" );
return VLC_EGENERIC;
}
xosd_set_colour( p_osd, config_GetPsz( p_intf,"xosd-colour" ) );
xosd_set_timeout( p_osd, 3 );
#endif
playlist_t *p_playlist =
(playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist == NULL )
{
return VLC_EGENERIC;
}
var_AddCallback( p_playlist, "playlist-current", PlaylistNext, p_this );
var_AddCallback( p_playlist, "item-change", PlaylistNext, p_this );
vlc_object_release( p_playlist );
/* Set user preferences */
xosd_set_font( p_intf->p_sys->p_osd,
config_GetPsz( p_intf, "xosd-font" ) );
xosd_set_outline_colour( p_intf->p_sys->p_osd,"black" );
#ifdef HAVE_XOSD_VERSION_2
xosd_set_horizontal_offset( p_intf->p_sys->p_osd,
config_GetInt( p_intf, "xosd-text-offset" ) );
xosd_set_vertical_offset( p_intf->p_sys->p_osd,
config_GetInt( p_intf, "xosd-text-offset" ) );
#else
xosd_set_offset( p_intf->p_sys->p_osd,
config_GetInt( p_intf, "xosd-text-offset" ) );
#endif
xosd_set_shadow_offset( p_intf->p_sys->p_osd,
config_GetInt( p_intf, "xosd-shadow-offset" ));
xosd_set_pos( p_intf->p_sys->p_osd,
config_GetInt( p_intf, "xosd-position" ) ?
XOSD_bottom: XOSD_top );
/* Initialize to NULL */
xosd_display( p_osd, 0, XOSD_string, "XOSD interface initialized" );
p_intf->pf_run = Run;
p_intf->p_sys->b_need_update = VLC_TRUE;
return VLC_SUCCESS;
}
void vout_IntfInit( vout_thread_t *p_vout )
{
vlc_value_t val, text, old_val;
bool b_force_par = false;
char *psz_buf;
int i;
/* Create a few object variables we'll need later on */
var_Create( p_vout, "snapshot-path", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-prefix", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-preview", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-sequential",
VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER );
var_SetInteger( p_vout, "snapshot-num", 1 );
var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_vout->i_alignment = var_CreateGetInteger( p_vout, "align" );
var_Create( p_vout, "video-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "video-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
var_Create( p_vout, "mouse-hide-timeout",
VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
p_vout->b_title_show = var_CreateGetBool( p_vout, "video-title-show" );
p_vout->i_title_timeout =
(mtime_t)var_CreateGetInteger( p_vout, "video-title-timeout" );
p_vout->i_title_position =
var_CreateGetInteger( p_vout, "video-title-position" );
var_AddCallback( p_vout, "video-title-show", TitleShowCallback, NULL );
var_AddCallback( p_vout, "video-title-timeout", TitleTimeoutCallback, NULL );
var_AddCallback( p_vout, "video-title-position", TitlePositionCallback, NULL );
/* Zoom object var */
var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND |
VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );
text.psz_string = _("Zoom");
var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL );
var_Get( p_vout, "zoom", &old_val );
for( i = 0; p_zoom_values[i].f_value; i++ )
{
if( old_val.f_float == p_zoom_values[i].f_value )
var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL );
val.f_float = p_zoom_values[i].f_value;
text.psz_string = _( p_zoom_values[i].psz_label );
var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text );
}
var_Set( p_vout, "zoom", old_val ); /* Is this really needed? */
var_AddCallback( p_vout, "zoom", ZoomCallback, NULL );
/* Crop offset vars */
var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_AddCallback( p_vout, "crop-left", CropCallback, NULL );
var_AddCallback( p_vout, "crop-top", CropCallback, NULL );
var_AddCallback( p_vout, "crop-right", CropCallback, NULL );
var_AddCallback( p_vout, "crop-bottom", CropCallback, NULL );
/* Crop object var */
var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |
VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );
text.psz_string = _("Crop");
var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL );
val.psz_string = (char*)"";
var_Change( p_vout, "crop", VLC_VAR_DELCHOICE, &val, 0 );
for( i = 0; p_crop_values[i].psz_value; i++ )
{
val.psz_string = (char*)p_crop_values[i].psz_value;
text.psz_string = _( p_crop_values[i].psz_label );
var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text );
}
/* update triggered every time the vout's crop parameters are changed */
var_Create( p_vout, "crop-update", VLC_VAR_VOID );
/* Add custom crop ratios */
psz_buf = config_GetPsz( p_vout, "custom-crop-ratios" );
AddCustomRatios( p_vout, "crop", psz_buf );
free( psz_buf );
var_AddCallback( p_vout, "crop", CropCallback, NULL );
var_Get( p_vout, "crop", &old_val );
if( old_val.psz_string && *old_val.psz_string )
var_Change( p_vout, "crop", VLC_VAR_TRIGGER_CALLBACKS, 0, 0 );
free( old_val.psz_string );
/* Monitor pixel aspect-ratio */
var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_vout, "monitor-par", &val );
if( val.psz_string && *val.psz_string )
{
char *psz_parser = strchr( val.psz_string, ':' );
unsigned int i_aspect_num = 0, i_aspect_den = 0;
float i_aspect = 0;
if( psz_parser )
{
i_aspect_num = strtol( val.psz_string, 0, 10 );
i_aspect_den = strtol( ++psz_parser, 0, 10 );
}
else
{
i_aspect = atof( val.psz_string );
vlc_ureduce( &i_aspect_num, &i_aspect_den,
i_aspect *VOUT_ASPECT_FACTOR, VOUT_ASPECT_FACTOR, 0 );
}
if( !i_aspect_num || !i_aspect_den ) i_aspect_num = i_aspect_den = 1;
p_vout->i_par_num = i_aspect_num;
p_vout->i_par_den = i_aspect_den;
vlc_ureduce( &p_vout->i_par_num, &p_vout->i_par_den,
p_vout->i_par_num, p_vout->i_par_den, 0 );
msg_Dbg( p_vout, "overriding monitor pixel aspect-ratio: %i:%i",
p_vout->i_par_num, p_vout->i_par_den );
b_force_par = true;
}
free( val.psz_string );
/* Aspect-ratio object var */
var_Create( p_vout, "aspect-ratio", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |
VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );
text.psz_string = _("Aspect-ratio");
var_Change( p_vout, "aspect-ratio", VLC_VAR_SETTEXT, &text, NULL );
val.psz_string = (char*)"";
var_Change( p_vout, "aspect-ratio", VLC_VAR_DELCHOICE, &val, 0 );
for( i = 0; p_aspect_ratio_values[i].psz_value; i++ )
{
val.psz_string = (char*)p_aspect_ratio_values[i].psz_value;
text.psz_string = _( p_aspect_ratio_values[i].psz_label );
var_Change( p_vout, "aspect-ratio", VLC_VAR_ADDCHOICE, &val, &text );
}
/* Add custom aspect ratios */
psz_buf = config_GetPsz( p_vout, "custom-aspect-ratios" );
AddCustomRatios( p_vout, "aspect-ratio", psz_buf );
free( psz_buf );
var_AddCallback( p_vout, "aspect-ratio", AspectCallback, NULL );
var_Get( p_vout, "aspect-ratio", &old_val );
if( (old_val.psz_string && *old_val.psz_string) || b_force_par )
var_Change( p_vout, "aspect-ratio", VLC_VAR_TRIGGER_CALLBACKS, 0, 0 );
free( old_val.psz_string );
/* Initialize the dimensions of the video window */
InitWindowSize( p_vout, &p_vout->i_window_width,
&p_vout->i_window_height );
/* Add a variable to indicate if the window should be on top of others */
var_Create( p_vout, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT
| VLC_VAR_ISCOMMAND );
text.psz_string = _("Always on top");
var_Change( p_vout, "video-on-top", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "video-on-top", OnTopCallback, NULL );
/* Add a variable to indicate whether we want window decoration or not */
var_Create( p_vout, "video-deco", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
/* Add a fullscreen variable */
if( var_CreateGetBoolCommand( p_vout, "fullscreen" ) )
{
/* user requested fullscreen */
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
}
text.psz_string = _("Fullscreen");
var_Change( p_vout, "fullscreen", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "fullscreen", FullscreenCallback, NULL );
/* Add a snapshot variable */
var_Create( p_vout, "video-snapshot", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
text.psz_string = _("Snapshot");
var_Change( p_vout, "video-snapshot", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_vout, "video-snapshot", SnapshotCallback, NULL );
/* Mouse coordinates */
var_Create( p_vout, "mouse-x", VLC_VAR_INTEGER );
var_Create( p_vout, "mouse-y", VLC_VAR_INTEGER );
var_Create( p_vout, "mouse-button-down", VLC_VAR_INTEGER );
var_Create( p_vout, "mouse-moved", VLC_VAR_BOOL );
var_Create( p_vout, "mouse-clicked", VLC_VAR_INTEGER );
var_Create( p_vout, "intf-change", VLC_VAR_BOOL );
var_SetBool( p_vout, "intf-change", true );
}