/*****************************************************************************
* config_PutInt: set the integer value of an int variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* represented by an integer (CONFIG_ITEM_INTEGER and
* CONFIG_ITEM_BOOL).
*****************************************************************************/
void config_PutInt( vlc_object_t *p_this, const char *psz_name,
int64_t i_value )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigIntegerType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to an int", psz_name );
return;
}
if (i_value < p_config->min.i)
i_value = p_config->min.i;
if (i_value > p_config->max.i)
i_value = p_config->max.i;
vlc_rwlock_wrlock (&config_lock);
p_config->value.i = i_value;
config_dirty = true;
vlc_rwlock_unlock (&config_lock);
}
/****************************
* Get count of devices.
*****************************/
int libvlc_audio_output_device_count( libvlc_instance_t *p_instance,
const char *psz_audio_output )
{
char *psz_config_name;
if( !psz_audio_output )
return 0;
if( asprintf( &psz_config_name, "%s-audio-device", psz_audio_output ) == -1 )
return 0;
module_config_t *p_module_config = config_FindConfig(
VLC_OBJECT( p_instance->p_libvlc_int ), psz_config_name );
if( p_module_config && p_module_config->pf_update_list )
{
vlc_value_t val;
val.psz_string = strdup( p_module_config->value.psz );
p_module_config->pf_update_list(
VLC_OBJECT( p_instance->p_libvlc_int ), psz_config_name, val, val, NULL );
free( val.psz_string );
free( psz_config_name );
return p_module_config->i_list;
}
free( psz_config_name );
return 0;
}
/*****************************************************************************
* config_GetFloat: get the value of a float variable
*****************************************************************************
* This function is used to get the value of variables which are internally
* represented by a float (CONFIG_ITEM_FLOAT).
*****************************************************************************/
float config_GetFloat( vlc_object_t *p_this, const char *psz_name )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Err( p_this, "option %s does not exist", psz_name );
return -1;
}
if (!IsConfigFloatType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a float", psz_name );
return -1;
}
float val;
vlc_rwlock_rdlock (&config_lock);
val = p_config->value.f;
vlc_rwlock_unlock (&config_lock);
return val;
}
/*****************************************************************************
* config_GetPsz: get the string value of a string variable
*****************************************************************************
* This function is used to get the value of variables which are internally
* represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_*FILE,
* CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
*
* Important note: remember to free() the returned char* because it's a
* duplicate of the actual value. It isn't safe to return a pointer to the
* actual value as it can be modified at any time.
*****************************************************************************/
char * config_GetPsz( vlc_object_t *p_this, const char *psz_name )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Err( p_this, "option %s does not exist", psz_name );
return NULL;
}
if (!IsConfigStringType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a string", psz_name );
return NULL;
}
/* return a copy of the string */
vlc_rwlock_rdlock (&config_lock);
char *psz_value = strdupnull (p_config->value.psz);
vlc_rwlock_unlock (&config_lock);
return psz_value;
}
/*****************************************************************************
* config variable callback
*****************************************************************************/
static int FindDevicesCallback( vlc_object_t *p_this, char const *psz_name,
vlc_value_t newval, vlc_value_t oldval, void *p_unused )
{
module_config_t *p_item;
int i;
(void)newval;
(void)oldval;
(void)p_unused;
p_item = config_FindConfig( p_this, psz_name );
if( !p_item ) return VLC_SUCCESS;
/* Clear-up the current list */
if( p_item->i_list )
{
/* Keep the first entrie */
for( i = 1; i < p_item->i_list; i++ )
{
free( (char *)p_item->ppsz_list[i] );
free( (char *)p_item->ppsz_list_text[i] );
}
/* TODO: Remove when no more needed */
p_item->ppsz_list[i] = NULL;
p_item->ppsz_list_text[i] = NULL;
}
p_item->i_list = 1;
GetDevices( p_item );
/* Signal change to the interface */
p_item->b_dirty = true;
return VLC_SUCCESS;
}
/********************************
* Get id name of device
*********************************/
char * libvlc_audio_output_device_id( libvlc_instance_t *p_instance,
const char *psz_audio_output,
int i_device )
{
char *psz_config_name;
if( !psz_audio_output )
return NULL;
if( asprintf( &psz_config_name, "%s-audio-device", psz_audio_output ) == -1)
return NULL;
module_config_t *p_module_config = config_FindConfig(
VLC_OBJECT( p_instance->p_libvlc_int ), psz_config_name );
if( p_module_config )
{
// refresh if there arent devices
if( p_module_config->i_list < 2 && p_module_config->pf_update_list )
{
vlc_value_t val;
val.psz_string = strdup( p_module_config->value.psz );
p_module_config->pf_update_list(
VLC_OBJECT( p_instance->p_libvlc_int ), psz_config_name, val, val, NULL );
free( val.psz_string );
}
free( psz_config_name );
if( i_device >= 0 && i_device < p_module_config->i_list )
return strdup( p_module_config->ppsz_list[i_device] );
}
free( psz_config_name );
return NULL;
}
/*****************************************************************************
* config_PutPsz: set the string value of a string variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_*FILE,
* CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
*****************************************************************************/
void config_PutPsz( vlc_object_t *p_this,
const char *psz_name, const char *psz_value )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigStringType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a string", psz_name );
return;
}
char *str, *oldstr;
if ((psz_value != NULL) && *psz_value)
str = strdup (psz_value);
else
str = NULL;
vlc_rwlock_wrlock (&config_lock);
oldstr = (char *)p_config->value.psz;
p_config->value.psz = str;
config_dirty = true;
vlc_rwlock_unlock (&config_lock);
free (oldstr);
}
/*****************************************************************************
* config_PutFloat: set the value of a float variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* represented by a float (CONFIG_ITEM_FLOAT).
*****************************************************************************/
void config_PutFloat( vlc_object_t *p_this,
const char *psz_name, float f_value )
{
module_config_t *p_config;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigFloatType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a float", psz_name );
return;
}
/* if f_min == f_max == 0, then do not use them */
if ((p_config->min.f == 0) && (p_config->max.f == 0))
;
else if (f_value < p_config->min.f)
f_value = p_config->min.f;
else if (f_value > p_config->max.f)
f_value = p_config->max.f;
vlc_rwlock_wrlock (&config_lock);
p_config->value.f = f_value;
config_dirty = true;
vlc_rwlock_unlock (&config_lock);
}
/*****************************************************************************
* config_GetType: get the type of a variable (bool, int, float, string)
*****************************************************************************
* This function is used to get the type of a variable from its name.
* Beware, this is quite slow.
*****************************************************************************/
int config_GetType( vlc_object_t *p_this, const char *psz_name )
{
module_config_t *p_config;
int i_type;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
return 0;
}
switch( p_config->i_type )
{
case CONFIG_ITEM_BOOL:
i_type = VLC_VAR_BOOL;
break;
case CONFIG_ITEM_INTEGER:
case CONFIG_ITEM_KEY:
i_type = VLC_VAR_INTEGER;
break;
case CONFIG_ITEM_FLOAT:
i_type = VLC_VAR_FLOAT;
break;
case CONFIG_ITEM_MODULE:
case CONFIG_ITEM_MODULE_CAT:
case CONFIG_ITEM_MODULE_LIST:
case CONFIG_ITEM_MODULE_LIST_CAT:
i_type = VLC_VAR_MODULE;
break;
case CONFIG_ITEM_STRING:
i_type = VLC_VAR_STRING;
break;
case CONFIG_ITEM_PASSWORD:
i_type = VLC_VAR_STRING;
break;
case CONFIG_ITEM_FILE:
i_type = VLC_VAR_FILE;
break;
case CONFIG_ITEM_DIRECTORY:
i_type = VLC_VAR_DIRECTORY;
break;
default:
i_type = 0;
break;
}
return i_type;
}
/********* String / choice list **********/
StringListConfigControl::StringListConfigControl( vlc_object_t *_p_this,
module_config_t *_p_item, QWidget *_parent, bool bycat,
QGridLayout *l, int &line) :
VStringConfigControl( _p_this, _p_item, _parent )
{
label = new QLabel( qtr(p_item->psz_text) );
combo = new QComboBox();
combo->setMinimumWidth( MINWIDTH_BOX );
combo->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::Preferred );
module_config_t *p_module_config = config_FindConfig( p_this, p_item->psz_name );
if(p_module_config && p_module_config->pf_update_list)
{
vlc_value_t val;
val.psz_string = strdup(p_module_config->value.psz);
p_module_config->pf_update_list(p_this, p_item->psz_name, val, val, NULL);
// assume in any case that dirty was set to true
// because lazy programmes will use the same callback for
// this, like the one behind the refresh push button?
p_module_config->b_dirty = false;
free( val.psz_string );
}
finish( p_module_config, bycat );
if( !l )
{
l = new QGridLayout();
l->addWidget( label, 0, 0 ); l->addWidget( combo, 0, LAST_COLUMN );
widget->setLayout( l );
}
else
{
l->addWidget( label, line, 0 );
l->addWidget( combo, line, LAST_COLUMN, Qt::AlignRight );
}
if( p_item->i_action )
{
QSignalMapper *signalMapper = new QSignalMapper(this);
/* Some stringLists like Capture listings have action associated */
for( int i = 0; i < p_item->i_action; i++ )
{
QPushButton *button =
new QPushButton( qfu( p_item->ppsz_action_text[i] ));
CONNECT( button, clicked(), signalMapper, map() );
signalMapper->setMapping( button, i );
l->addWidget( button, line, LAST_COLUMN - p_item->i_action + i,
Qt::AlignRight );
}
CONNECT( signalMapper, mapped( int ),
this, actionRequested( int ) );
}
StringListConfigControl::StringListConfigControl( vlc_object_t *_p_this,
module_config_t *_p_item, QLabel *_label, QComboBox *_combo,
bool ) : VStringConfigControl( _p_this, _p_item )
{
combo = _combo;
label = _label;
module_config_t *p_module_config = config_FindConfig( p_this, getName() );
finish( p_module_config );
}
/********* String / choice list **********/
StringListConfigControl::StringListConfigControl( vlc_object_t *_p_this,
module_config_t *_p_item, QWidget *p ) :
VStringConfigControl( _p_this, _p_item )
{
label = new QLabel( qtr(p_item->psz_text), p );
combo = new QComboBox( p );
combo->setMinimumWidth( MINWIDTH_BOX );
combo->setSizePolicy( QSizePolicy::MinimumExpanding, QSizePolicy::Preferred );
module_config_t *p_module_config = config_FindConfig( p_this, p_item->psz_name );
finish( p_module_config );
}
/*****************************************************************************
* config_PutPsz: set the string value of a string variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
* CONFIG_ITEM_DIRECTORY, CONFIG_ITEM_PASSWORD, and CONFIG_ITEM_MODULE).
*****************************************************************************/
void config_PutPsz( vlc_object_t *p_this,
const char *psz_name, const char *psz_value )
{
module_config_t *p_config;
vlc_value_t oldval;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigStringType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to a string", psz_name );
return;
}
vlc_rwlock_wrlock (&config_lock);
/* backup old value */
oldval.psz_string = (char *)p_config->value.psz;
if ((psz_value != NULL) && *psz_value)
p_config->value.psz = strdup (psz_value);
else
p_config->value.psz = NULL;
p_config->b_dirty = true;
vlc_rwlock_unlock (&config_lock);
if( p_config->pf_callback )
{
vlc_value_t val;
val.psz_string = (char *)psz_value;
p_config->pf_callback( p_this, psz_name, oldval, val,
p_config->p_callback_data );
}
/* free old string */
free( oldval.psz_string );
}
static int FindDevicesCallback(vlc_object_t *object, char const *name,
vlc_value_t newval, vlc_value_t oldval, void *data)
{
VLC_UNUSED(newval);
VLC_UNUSED(oldval);
VLC_UNUSED(data);
module_config_t *item = config_FindConfig(object, name);
if (!item)
return VLC_SUCCESS;
/* Clear-up the current list */
if (item->i_list > 0) {
int i;
/* Keep the first entry */
for (i = 1; i < item->i_list; i++) {
free(item->ppsz_list[i]);
free(item->ppsz_list_text[i]);
}
/* TODO: Remove when no more needed */
item->ppsz_list[i] = NULL;
item->ppsz_list_text[i] = NULL;
}
item->i_list = 1;
/* Load direct draw DLL */
HINSTANCE hddraw_dll = LoadLibrary(_T("DDRAW.DLL"));
if (!hddraw_dll)
return VLC_SUCCESS;
/* Enumerate displays */
HRESULT (WINAPI *OurDirectDrawEnumerateEx)(LPDDENUMCALLBACKEXA,
LPVOID, DWORD) =
(void *)GetProcAddress(hddraw_dll, _T("DirectDrawEnumerateExA"));
if (OurDirectDrawEnumerateEx)
OurDirectDrawEnumerateEx(DirectXEnumCallback2, item,
DDENUM_ATTACHEDSECONDARYDEVICES);
FreeLibrary(hddraw_dll);
/* Signal change to the interface */
item->b_dirty = true;
return VLC_SUCCESS;
}
/*****************************************************************************
* config_PutInt: set the integer value of an int variable
*****************************************************************************
* This function is used to set the value of variables which are internally
* represented by an integer (CONFIG_ITEM_INTEGER and
* CONFIG_ITEM_BOOL).
*****************************************************************************/
void config_PutInt( vlc_object_t *p_this, const char *psz_name, int i_value )
{
module_config_t *p_config;
vlc_value_t oldval;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
msg_Warn( p_this, "option %s does not exist", psz_name );
return;
}
if (!IsConfigIntegerType (p_config->i_type))
{
msg_Err( p_this, "option %s does not refer to an int", psz_name );
return;
}
/* if i_min == i_max == 0, then do not use them */
if ((p_config->min.i == 0) && (p_config->max.i == 0))
;
else if (i_value < p_config->min.i)
i_value = p_config->min.i;
else if (i_value > p_config->max.i)
i_value = p_config->max.i;
vlc_rwlock_wrlock (&config_lock);
/* backup old value */
oldval.i_int = p_config->value.i;
p_config->value.i = i_value;
p_config->b_dirty = true;
vlc_rwlock_unlock (&config_lock);
if( p_config->pf_callback )
{
vlc_value_t val;
val.i_int = i_value;
p_config->pf_callback( p_this, psz_name, oldval, val,
p_config->p_callback_data );
}
}
void setfillVLCConfigCombo( const char *configname, intf_thread_t *p_intf,
QComboBox *combo )
{
module_config_t *p_config =
config_FindConfig( VLC_OBJECT(p_intf), configname );
if( p_config == NULL )
return;
if( (p_config->i_type & 0xF0) == CONFIG_ITEM_STRING )
{
char **values, **texts;
ssize_t count = config_GetPszChoices(VLC_OBJECT(p_intf),
configname, &values, &texts);
for( ssize_t i = 0; i < count; i++ )
{
combo->addItem( qtr(texts[i]), QVariant(qfu(values[i])) );
if( p_config->value.psz && !strcmp(p_config->value.psz, values[i]) )
combo->setCurrentIndex( i );
free( texts[i] );
free( values[i] );
}
free( texts );
free( values );
}
else
{
int64_t *values;
char **texts;
ssize_t count = config_GetIntChoices(VLC_OBJECT(p_intf), configname,
&values, &texts);
for( ssize_t i = 0; i < count; i++ )
{
combo->addItem( qtr(texts[i]), QVariant(qlonglong(values[i])) );
if( p_config->value.i == values[i] )
combo->setCurrentIndex( i );
free( texts[i] );
}
free( texts );
}
if( p_config->psz_longtext != NULL )
combo->setToolTip( qfu( p_config->psz_longtext ) );
}
/*****************************************************************************
* config_GetInt: get the value of an int variable
*****************************************************************************
* This function is used to get the value of variables which are internally
* represented by an integer (CONFIG_ITEM_INTEGER and
* CONFIG_ITEM_BOOL).
*****************************************************************************/
int64_t config_GetInt( vlc_object_t *p_this, const char *psz_name )
{
module_config_t *p_config = config_FindConfig( psz_name );
/* sanity checks */
if( !p_config )
{
msg_Err( p_this, "option %s does not exist", psz_name );
return -1;
}
assert(IsConfigIntegerType(p_config->i_type));
int64_t val;
vlc_rwlock_rdlock (&config_lock);
val = p_config->value.i;
vlc_rwlock_unlock (&config_lock);
return val;
}
void IntegerListConfigControl::OnAction( wxCommandEvent& event )
{
int i_action = event.GetId() - wxID_HIGHEST;
module_config_t *p_item;
p_item = config_FindConfig( p_this, GetName().mb_str() );
if( !p_item ) return;
if( i_action < 0 || i_action >= p_item->i_action ) return;
vlc_value_t val;
val.i_int = GetIntValue();
p_item->ppf_action[i_action]( p_this, GetName().mb_str(), val, val, 0 );
if( p_item->b_dirty )
{
combo->Clear();
UpdateCombo( p_item );
p_item->b_dirty = false;
}
}
void StringListConfigControl::OnAction( wxCommandEvent& event )
{
int i_action = event.GetId() - wxID_HIGHEST;
module_config_t *p_item = config_FindConfig( p_this, GetName().mb_str() );
if( !p_item ) return;
if( i_action < 0 || i_action >= p_item->i_action ) return;
vlc_value_t val;
wxString value = GetPszValue();
(const char *)val.psz_string = value.mb_str();
p_item->ppf_action[i_action]( p_this, GetName().mb_str(), val, val, 0 );
if( p_item->b_dirty )
{
combo->Clear();
UpdateCombo( p_item );
p_item->b_dirty = false;
}
}
/*****************************************************************************
* config_GetType: get the type of a variable (bool, int, float, string)
*****************************************************************************
* This function is used to get the type of a variable from its name.
* Beware, this is quite slow.
*****************************************************************************/
int config_GetType( vlc_object_t *p_this, const char *psz_name )
{
module_config_t *p_config;
int i_type;
p_config = config_FindConfig( p_this, psz_name );
/* sanity checks */
if( !p_config )
{
return 0;
}
switch( CONFIG_CLASS(p_config->i_type) )
{
case CONFIG_ITEM_FLOAT:
i_type = VLC_VAR_FLOAT;
break;
case CONFIG_ITEM_INTEGER:
i_type = VLC_VAR_INTEGER;
break;
case CONFIG_ITEM_BOOL:
i_type = VLC_VAR_BOOL;
break;
case CONFIG_ITEM_STRING:
i_type = VLC_VAR_STRING;
break;
default:
i_type = 0;
break;
}
return i_type;
}
/*****************************************************************************
* config_GetType: get the type of a variable (bool, int, float, string)
*****************************************************************************
* This function is used to get the type of a variable from its name.
*****************************************************************************/
int config_GetType(const char *psz_name)
{
module_config_t *p_config = config_FindConfig(psz_name);
/* sanity checks */
if( !p_config )
{
return 0;
}
switch( CONFIG_CLASS(p_config->i_type) )
{
case CONFIG_ITEM_FLOAT:
return VLC_VAR_FLOAT;
case CONFIG_ITEM_INTEGER:
return VLC_VAR_INTEGER;
case CONFIG_ITEM_BOOL:
return VLC_VAR_BOOL;
case CONFIG_ITEM_STRING:
return VLC_VAR_STRING;
default:
return 0;
}
}
/*****************************************************************************
* aout_New: initialize aout structure
*****************************************************************************/
audio_output_t *aout_New( vlc_object_t * p_parent )
{
audio_output_t *aout = vlc_custom_create (p_parent,
sizeof (aout_instance_t),
"audio output");
if (unlikely(aout == NULL))
return NULL;
aout_owner_t *owner = aout_owner (aout);
vlc_mutex_init (&owner->lock);
owner->module = NULL;
owner->input = NULL;
vlc_mutex_init (&owner->volume.lock);
owner->volume.multiplier = 1.0;
owner->volume.mixer = NULL;
aout->pf_play = aout_DecDeleteBuffer;
aout_VolumeNoneInit (aout);
vlc_object_set_destructor (aout, aout_Destructor);
/*
* Persistent audio output variables
*/
vlc_value_t val, text;
char *str;
var_Create (aout, "intf-change", VLC_VAR_VOID);
/* Visualizations */
var_Create (aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE);
text.psz_string = _("Visualizations");
var_Change (aout, "visual", VLC_VAR_SETTEXT, &text, NULL);
val.psz_string = (char *)"";
text.psz_string = _("Disable");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"spectrometer";
text.psz_string = _("Spectrometer");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"scope";
text.psz_string = _("Scope");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"spectrum";
text.psz_string = _("Spectrum");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"vuMeter";
text.psz_string = _("Vu meter");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
/* Look for goom plugin */
if (module_exists ("goom"))
{
val.psz_string = (char *)"goom";
text.psz_string = (char *)"Goom";
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
}
/* Look for libprojectM plugin */
if (module_exists ("projectm"))
{
val.psz_string = (char *)"projectm";
text.psz_string = (char*)"projectM";
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
}
str = var_GetNonEmptyString (aout, "effect-list");
if (str != NULL)
{
var_SetString (aout, "visual", str);
free (str);
}
/* Equalizer */
var_Create (aout, "equalizer", VLC_VAR_STRING | VLC_VAR_HASCHOICE);
text.psz_string = _("Equalizer");
var_Change (aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL);
val.psz_string = (char*)"";
text.psz_string = _("Disable");
var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text);
{
module_config_t *cfg = config_FindConfig (VLC_OBJECT(aout),
"equalizer-preset");
if (cfg != NULL)
for (int i = 0; i < cfg->i_list; i++)
{
val.psz_string = (char *)cfg->ppsz_list[i];
text.psz_string = (char *)cfg->ppsz_list_text[i];
var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text);
}
}
var_Create (aout, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
text.psz_string = _("Audio filters");
var_Change (aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL);
var_Create (aout, "audio-visual", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
text.psz_string = _("Audio visualizations");
var_Change (aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL);
/* Replay gain */
var_Create (aout, "audio-replay-gain-mode",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
text.psz_string = _("Replay gain");
var_Change (aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL);
{
module_config_t *cfg = config_FindConfig (VLC_OBJECT(aout),
"audio-replay-gain-mode");
if( cfg != NULL )
for (int i = 0; i < cfg->i_list; i++)
{
val.psz_string = (char *)cfg->ppsz_list[i];
text.psz_string = (char *)cfg->ppsz_list_text[i];
var_Change (aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE,
&val, &text);
}
}
return aout;
}
/*****************************************************************************
* aout_InputNew : allocate a new input and rework the filter pipeline
*****************************************************************************/
int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input, const aout_request_vout_t *p_request_vout )
{
audio_sample_format_t chain_input_format;
audio_sample_format_t chain_output_format;
vlc_value_t val, text;
char *psz_filters, *psz_visual, *psz_scaletempo;
int i_visual;
aout_FormatPrint( p_aout, "input", &p_input->input );
p_input->i_nb_resamplers = p_input->i_nb_filters = 0;
/* Prepare FIFO. */
aout_FifoInit( p_aout, &p_input->mixer.fifo, p_aout->mixer_format.i_rate );
p_input->mixer.begin = NULL;
/* */
if( p_request_vout )
{
p_input->request_vout = *p_request_vout;
}
else
{
p_input->request_vout.pf_request_vout = RequestVout;
p_input->request_vout.p_private = p_aout;
}
/* Prepare format structure */
chain_input_format = p_input->input;
chain_output_format = p_aout->mixer_format;
chain_output_format.i_rate = p_input->input.i_rate;
aout_FormatPrepare( &chain_output_format );
/* Now add user filters */
if( var_Type( p_aout, "visual" ) == 0 )
{
var_Create( p_aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE );
text.psz_string = _("Visualizations");
var_Change( p_aout, "visual", VLC_VAR_SETTEXT, &text, NULL );
val.psz_string = (char*)""; text.psz_string = _("Disable");
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
val.psz_string = (char*)"spectrometer"; text.psz_string = _("Spectrometer");
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
val.psz_string = (char*)"scope"; text.psz_string = _("Scope");
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
val.psz_string = (char*)"spectrum"; text.psz_string = _("Spectrum");
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
val.psz_string = (char*)"vuMeter"; text.psz_string = _("Vu meter");
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
/* Look for goom plugin */
if( module_exists( "goom" ) )
{
val.psz_string = (char*)"goom"; text.psz_string = (char*)"Goom";
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
}
/* Look for libprojectM plugin */
if( module_exists( "projectm" ) )
{
val.psz_string = (char*)"projectm"; text.psz_string = (char*)"projectM";
var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
}
if( var_Get( p_aout, "effect-list", &val ) == VLC_SUCCESS )
{
var_SetString( p_aout, "visual", val.psz_string );
free( val.psz_string );
}
var_AddCallback( p_aout, "visual", VisualizationCallback, NULL );
}
if( var_Type( p_aout, "equalizer" ) == 0 )
{
module_config_t *p_config;
int i;
p_config = config_FindConfig( VLC_OBJECT(p_aout), "equalizer-preset" );
if( p_config && p_config->i_list )
{
var_Create( p_aout, "equalizer",
VLC_VAR_STRING | VLC_VAR_HASCHOICE );
text.psz_string = _("Equalizer");
var_Change( p_aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL );
val.psz_string = (char*)""; text.psz_string = _("Disable");
var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text );
for( i = 0; i < p_config->i_list; i++ )
{
val.psz_string = (char *)p_config->ppsz_list[i];
text.psz_string = (char *)p_config->ppsz_list_text[i];
var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE,
&val, &text );
}
var_AddCallback( p_aout, "equalizer", EqualizerCallback, NULL );
}
}
if( var_Type( p_aout, "audio-filter" ) == 0 )
{
var_Create( p_aout, "audio-filter",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
text.psz_string = _("Audio filters");
var_Change( p_aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL );
}
if( var_Type( p_aout, "audio-visual" ) == 0 )
{
var_Create( p_aout, "audio-visual",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
text.psz_string = _("Audio visualizations");
var_Change( p_aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL );
}
if( var_Type( p_aout, "audio-replay-gain-mode" ) == 0 )
{
module_config_t *p_config;
int i;
p_config = config_FindConfig( VLC_OBJECT(p_aout), "audio-replay-gain-mode" );
if( p_config && p_config->i_list )
{
var_Create( p_aout, "audio-replay-gain-mode",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
text.psz_string = _("Replay gain");
var_Change( p_aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL );
for( i = 0; i < p_config->i_list; i++ )
{
val.psz_string = (char *)p_config->ppsz_list[i];
text.psz_string = (char *)p_config->ppsz_list_text[i];
var_Change( p_aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE,
&val, &text );
}
var_AddCallback( p_aout, "audio-replay-gain-mode", ReplayGainCallback, NULL );
}
}
if( var_Type( p_aout, "audio-replay-gain-preamp" ) == 0 )
{
var_Create( p_aout, "audio-replay-gain-preamp",
VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
}
if( var_Type( p_aout, "audio-replay-gain-default" ) == 0 )
{
var_Create( p_aout, "audio-replay-gain-default",
VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );
}
if( var_Type( p_aout, "audio-replay-gain-peak-protection" ) == 0 )
{
var_Create( p_aout, "audio-replay-gain-peak-protection",
VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
}
if( var_Type( p_aout, "audio-time-stretch" ) == 0 )
{
var_Create( p_aout, "audio-time-stretch",
VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
}
psz_filters = var_GetString( p_aout, "audio-filter" );
psz_visual = var_GetString( p_aout, "audio-visual");
psz_scaletempo = var_GetBool( p_aout, "audio-time-stretch" ) ? strdup( "scaletempo" ) : NULL;
p_input->b_recycle_vout = psz_visual && *psz_visual;
/* parse user filter lists */
char *const ppsz_array[] = { psz_scaletempo, psz_filters, psz_visual };
p_input->p_playback_rate_filter = NULL;
for( i_visual = 0; i_visual < 3 && !AOUT_FMT_NON_LINEAR(&chain_output_format); i_visual++ )
{
char *psz_next = NULL;
char *psz_parser = ppsz_array[i_visual];
if( psz_parser == NULL || !*psz_parser )
continue;
while( psz_parser && *psz_parser )
{
filter_t * p_filter = NULL;
if( p_input->i_nb_filters >= AOUT_MAX_FILTERS )
{
msg_Dbg( p_aout, "max filters reached (%d)", AOUT_MAX_FILTERS );
break;
}
while( *psz_parser == ' ' && *psz_parser == ':' )
{
psz_parser++;
}
if( ( psz_next = strchr( psz_parser , ':' ) ) )
{
*psz_next++ = '\0';
}
if( *psz_parser =='\0' )
{
break;
}
/* Create a VLC object */
static const char typename[] = "audio filter";
p_filter = vlc_custom_create( p_aout, sizeof(*p_filter),
VLC_OBJECT_GENERIC, typename );
if( p_filter == NULL )
{
msg_Err( p_aout, "cannot add user filter %s (skipped)",
psz_parser );
psz_parser = psz_next;
continue;
}
vlc_object_attach( p_filter , p_aout );
p_filter->p_owner = malloc( sizeof(*p_filter->p_owner) );
p_filter->p_owner->p_aout = p_aout;
p_filter->p_owner->p_input = p_input;
/* request format */
memcpy( &p_filter->fmt_in.audio, &chain_output_format,
sizeof(audio_sample_format_t) );
p_filter->fmt_in.i_codec = chain_output_format.i_format;
memcpy( &p_filter->fmt_out.audio, &chain_output_format,
sizeof(audio_sample_format_t) );
p_filter->fmt_out.i_codec = chain_output_format.i_format;
p_filter->pf_audio_buffer_new = aout_FilterBufferNew;
/* try to find the requested filter */
if( i_visual == 2 ) /* this can only be a visualization module */
{
p_filter->p_module = module_need( p_filter, "visualization2",
psz_parser, true );
}
else /* this can be a audio filter module as well as a visualization module */
{
p_filter->p_module = module_need( p_filter, "audio filter",
psz_parser, true );
if ( p_filter->p_module == NULL )
{
/* if the filter requested a special format, retry */
if ( !( AOUT_FMTS_IDENTICAL( &p_filter->fmt_in.audio,
&chain_input_format )
&& AOUT_FMTS_IDENTICAL( &p_filter->fmt_out.audio,
&chain_output_format ) ) )
{
aout_FormatPrepare( &p_filter->fmt_in.audio );
aout_FormatPrepare( &p_filter->fmt_out.audio );
p_filter->p_module = module_need( p_filter,
"audio filter",
psz_parser, true );
}
/* try visual filters */
else
{
memcpy( &p_filter->fmt_in.audio, &chain_output_format,
sizeof(audio_sample_format_t) );
memcpy( &p_filter->fmt_out.audio, &chain_output_format,
sizeof(audio_sample_format_t) );
p_filter->p_module = module_need( p_filter,
"visualization2",
psz_parser, true );
}
}
}
/* failure */
if ( p_filter->p_module == NULL )
{
msg_Err( p_aout, "cannot add user filter %s (skipped)",
psz_parser );
free( p_filter->p_owner );
vlc_object_release( p_filter );
psz_parser = psz_next;
continue;
}
/* complete the filter chain if necessary */
if ( !AOUT_FMTS_IDENTICAL( &chain_input_format,
&p_filter->fmt_in.audio ) )
{
if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
&p_input->i_nb_filters,
&chain_input_format,
&p_filter->fmt_in.audio ) < 0 )
{
msg_Err( p_aout, "cannot add user filter %s (skipped)",
psz_parser );
module_unneed( p_filter, p_filter->p_module );
free( p_filter->p_owner );
vlc_object_release( p_filter );
psz_parser = psz_next;
continue;
}
}
/* success */
p_input->pp_filters[p_input->i_nb_filters++] = p_filter;
memcpy( &chain_input_format, &p_filter->fmt_out.audio,
sizeof( audio_sample_format_t ) );
if( i_visual == 0 ) /* scaletempo */
p_input->p_playback_rate_filter = p_filter;
/* next filter if any */
psz_parser = psz_next;
}
}
free( psz_visual );
free( psz_filters );
free( psz_scaletempo );
/* complete the filter chain if necessary */
if ( !AOUT_FMTS_IDENTICAL( &chain_input_format, &chain_output_format ) )
{
if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
&p_input->i_nb_filters,
&chain_input_format,
&chain_output_format ) < 0 )
{
inputFailure( p_aout, p_input, "couldn't set an input pipeline" );
return -1;
}
}
/* Prepare hints for the buffer allocator. */
p_input->input_alloc.b_alloc = true;
p_input->input_alloc.i_bytes_per_sec = -1;
/* Create resamplers. */
if ( !AOUT_FMT_NON_LINEAR( &p_aout->mixer_format ) )
{
chain_output_format.i_rate = (__MAX(p_input->input.i_rate,
p_aout->mixer_format.i_rate)
* (100 + AOUT_MAX_RESAMPLING)) / 100;
if ( chain_output_format.i_rate == p_aout->mixer_format.i_rate )
{
/* Just in case... */
chain_output_format.i_rate++;
}
if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_resamplers,
&p_input->i_nb_resamplers,
&chain_output_format,
&p_aout->mixer_format ) < 0 )
{
inputFailure( p_aout, p_input, "couldn't set a resampler pipeline");
return -1;
}
aout_FiltersHintBuffers( p_aout, p_input->pp_resamplers,
p_input->i_nb_resamplers,
&p_input->input_alloc );
p_input->input_alloc.b_alloc = true;
/* Setup the initial rate of the resampler */
p_input->pp_resamplers[0]->fmt_in.audio.i_rate = p_input->input.i_rate;
}
p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
if( ! p_input->p_playback_rate_filter && p_input->i_nb_resamplers > 0 )
{
p_input->p_playback_rate_filter = p_input->pp_resamplers[0];
}
aout_FiltersHintBuffers( p_aout, p_input->pp_filters,
p_input->i_nb_filters,
&p_input->input_alloc );
p_input->input_alloc.b_alloc = true;
/* i_bytes_per_sec is still == -1 if no filters */
p_input->input_alloc.i_bytes_per_sec = __MAX(
p_input->input_alloc.i_bytes_per_sec,
(int)(p_input->input.i_bytes_per_frame
* p_input->input.i_rate
/ p_input->input.i_frame_length) );
ReplayGainSelect( p_aout, p_input );
/* Success */
p_input->b_error = false;
p_input->i_last_input_rate = INPUT_RATE_DEFAULT;
return 0;
}
/**
* Creates an audio output object and initializes an output module.
*/
audio_output_t *aout_New (vlc_object_t *parent)
{
vlc_value_t val, text;
audio_output_t *aout = vlc_custom_create (parent, sizeof (aout_instance_t),
"audio output");
if (unlikely(aout == NULL))
return NULL;
aout_owner_t *owner = aout_owner (aout);
vlc_mutex_init (&owner->lock);
vlc_mutex_init (&owner->req.lock);
vlc_mutex_init (&owner->dev.lock);
owner->req.device = (char *)unset_str;
owner->req.volume = -1.f;
owner->req.mute = -1;
vlc_object_set_destructor (aout, aout_Destructor);
/* Audio output module callbacks */
var_Create (aout, "volume", VLC_VAR_FLOAT);
var_AddCallback (aout, "volume", var_Copy, parent);
var_Create (aout, "mute", VLC_VAR_BOOL | VLC_VAR_DOINHERIT);
var_AddCallback (aout, "mute", var_Copy, parent);
var_Create (aout, "device", VLC_VAR_STRING);
aout->event.volume_report = aout_VolumeNotify;
aout->event.mute_report = aout_MuteNotify;
aout->event.policy_report = aout_PolicyNotify;
aout->event.device_report = aout_DeviceNotify;
aout->event.hotplug_report = aout_HotplugNotify;
aout->event.gain_request = aout_GainNotify;
aout->event.restart_request = aout_RestartNotify;
/* Audio output module initialization */
aout->start = NULL;
aout->stop = NULL;
aout->volume_set = NULL;
aout->mute_set = NULL;
aout->device_select = NULL;
owner->module = module_need (aout, "audio output", "$aout", false);
if (owner->module == NULL)
{
msg_Err (aout, "no suitable audio output module");
vlc_object_release (aout);
return NULL;
}
/*
* Persistent audio output variables
*/
module_config_t *cfg;
char *str;
/* Visualizations */
var_Create (aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE);
text.psz_string = _("Visualizations");
var_Change (aout, "visual", VLC_VAR_SETTEXT, &text, NULL);
val.psz_string = (char *)"";
text.psz_string = _("Disable");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"spectrometer";
text.psz_string = _("Spectrometer");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"scope";
text.psz_string = _("Scope");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"spectrum";
text.psz_string = _("Spectrum");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
val.psz_string = (char *)"vuMeter";
text.psz_string = _("Vu meter");
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
/* Look for goom plugin */
if (module_exists ("goom"))
{
val.psz_string = (char *)"goom";
text.psz_string = (char *)"Goom";
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
}
/* Look for libprojectM plugin */
if (module_exists ("projectm"))
{
val.psz_string = (char *)"projectm";
text.psz_string = (char*)"projectM";
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
}
/* Look for VSXu plugin */
if (module_exists ("vsxu"))
{
val.psz_string = (char *)"vsxu";
text.psz_string = (char*)"Vovoid VSXu";
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
}
/* Look for glspectrum plugin */
if (module_exists ("glspectrum"))
{
val.psz_string = (char *)"glspectrum";
text.psz_string = (char*)"3D spectrum";
var_Change (aout, "visual", VLC_VAR_ADDCHOICE, &val, &text);
}
str = var_GetNonEmptyString (aout, "effect-list");
if (str != NULL)
{
var_SetString (aout, "visual", str);
free (str);
}
/* Equalizer */
var_Create (aout, "equalizer", VLC_VAR_STRING | VLC_VAR_HASCHOICE);
text.psz_string = _("Equalizer");
var_Change (aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL);
val.psz_string = (char*)"";
text.psz_string = _("Disable");
var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text);
cfg = config_FindConfig (VLC_OBJECT(aout), "equalizer-preset");
if (likely(cfg != NULL))
for (unsigned i = 0; i < cfg->list_count; i++)
{
val.psz_string = cfg->list.psz[i];
text.psz_string = vlc_gettext(cfg->list_text[i]);
var_Change (aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text);
}
var_Create (aout, "audio-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
text.psz_string = _("Audio filters");
var_Change (aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL);
var_Create (aout, "audio-visual", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
text.psz_string = _("Audio visualizations");
var_Change (aout, "audio-visual", VLC_VAR_SETTEXT, &text, NULL);
/* Replay gain */
var_Create (aout, "audio-replay-gain-mode",
VLC_VAR_STRING | VLC_VAR_DOINHERIT );
text.psz_string = _("Replay gain");
var_Change (aout, "audio-replay-gain-mode", VLC_VAR_SETTEXT, &text, NULL);
cfg = config_FindConfig (VLC_OBJECT(aout), "audio-replay-gain-mode");
if (likely(cfg != NULL))
for (unsigned i = 0; i < cfg->list_count; i++)
{
val.psz_string = cfg->list.psz[i];
text.psz_string = vlc_gettext(cfg->list_text[i]);
var_Change (aout, "audio-replay-gain-mode", VLC_VAR_ADDCHOICE,
&val, &text);
}
var_Create (aout, "equalizer-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
var_Create (aout, "equalizer-bands", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
return aout;
}
void config_ChainParse( vlc_object_t *p_this, const char *psz_prefix,
const char *const *ppsz_options, config_chain_t *cfg )
{
if( psz_prefix == NULL ) psz_prefix = "";
size_t plen = 1 + strlen( psz_prefix );
/* First, var_Create all variables */
for( size_t i = 0; ppsz_options[i] != NULL; i++ )
{
const char *optname = ppsz_options[i];
if (optname[0] == '*')
optname++;
char name[plen + strlen( optname )];
snprintf( name, sizeof (name), "%s%s", psz_prefix, optname );
if( var_Create( p_this, name,
config_GetType( p_this, name ) | VLC_VAR_DOINHERIT ) )
return /* VLC_xxx */;
}
/* Now parse options and set value */
for(; cfg; cfg = cfg->p_next )
{
vlc_value_t val;
bool b_yes = true;
bool b_once = false;
module_config_t *p_conf;
int i_type;
size_t i;
if( cfg->psz_name == NULL || *cfg->psz_name == '\0' )
continue;
for( i = 0; ppsz_options[i] != NULL; i++ )
{
if( !strcmp( ppsz_options[i], cfg->psz_name ) )
{
break;
}
if( ( !strncmp( cfg->psz_name, "no-", 3 ) &&
!strcmp( ppsz_options[i], cfg->psz_name + 3 ) ) ||
( !strncmp( cfg->psz_name, "no", 2 ) &&
!strcmp( ppsz_options[i], cfg->psz_name + 2 ) ) )
{
b_yes = false;
break;
}
if( *ppsz_options[i] == '*' &&
!strcmp( &ppsz_options[i][1], cfg->psz_name ) )
{
b_once = true;
break;
}
}
if( ppsz_options[i] == NULL )
{
msg_Warn( p_this, "option %s is unknown", cfg->psz_name );
continue;
}
/* create name */
char name[plen + strlen( ppsz_options[i] )];
const char *psz_name = name;
snprintf( name, sizeof (name), "%s%s", psz_prefix,
b_once ? (ppsz_options[i] + 1) : ppsz_options[i] );
/* Check if the option is deprecated */
p_conf = config_FindConfig( p_this, name );
/* This is basically cut and paste from src/misc/configuration.c
* with slight changes */
if( p_conf )
{
if( p_conf->b_removed )
{
msg_Err( p_this, "Option %s is not supported anymore.",
name );
/* TODO: this should return an error and end option parsing
* ... but doing this would change the VLC API and all the
* modules so i'll do it later */
continue;
}
}
/* </Check if the option is deprecated> */
/* get the type of the variable */
i_type = config_GetType( p_this, psz_name );
if( !i_type )
{
msg_Warn( p_this, "unknown option %s (value=%s)",
cfg->psz_name, cfg->psz_value );
continue;
}
if( i_type != VLC_VAR_BOOL && cfg->psz_value == NULL )
{
msg_Warn( p_this, "missing value for option %s", cfg->psz_name );
continue;
}
if( i_type != VLC_VAR_STRING && b_once )
{
msg_Warn( p_this, "*option_name need to be a string option" );
continue;
}
switch( i_type )
{
case VLC_VAR_BOOL:
val.b_bool = b_yes;
break;
case VLC_VAR_INTEGER:
val.i_int = strtol( cfg->psz_value ? cfg->psz_value : "0",
NULL, 0 );
break;
case VLC_VAR_FLOAT:
val.f_float = us_atof( cfg->psz_value ? cfg->psz_value : "0" );
break;
case VLC_VAR_STRING:
val.psz_string = cfg->psz_value;
break;
default:
msg_Warn( p_this, "unhandled config var type (%d)", i_type );
memset( &val, 0, sizeof( vlc_value_t ) );
break;
}
if( b_once )
{
vlc_value_t val2;
var_Get( p_this, psz_name, &val2 );
if( *val2.psz_string )
{
free( val2.psz_string );
msg_Dbg( p_this, "ignoring option %s (not first occurrence)", psz_name );
continue;
}
free( val2.psz_string );
}
var_Set( p_this, psz_name, val );
msg_Dbg( p_this, "set config option: %s to %s", psz_name,
cfg->psz_value ? cfg->psz_value : "(null)" );
}
}
void vout_InitInterlacingSupport(vout_thread_t *vout, bool is_interlaced)
{
vlc_value_t val, text;
msg_Dbg(vout, "Deinterlacing available");
/* Create the configuration variables */
/* */
var_Create(vout, "deinterlace", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT | VLC_VAR_HASCHOICE);
int deinterlace_state = var_GetInteger(vout, "deinterlace");
deinterlace_state = __MAX(__MIN(deinterlace_state, 1), -1);
text.psz_string = _("Deinterlace");
var_Change(vout, "deinterlace", VLC_VAR_SETTEXT, &text, NULL);
const module_config_t *optd = config_FindConfig(VLC_OBJECT(vout), "deinterlace");
var_Change(vout, "deinterlace", VLC_VAR_CLEARCHOICES, NULL, NULL);
for (int i = 0; optd && i < optd->i_list; i++) {
val.i_int = optd->pi_list[i];
text.psz_string = (char*)vlc_gettext(optd->ppsz_list_text[i]);
var_Change(vout, "deinterlace", VLC_VAR_ADDCHOICE, &val, &text);
}
var_AddCallback(vout, "deinterlace", DeinterlaceCallback, NULL);
/* */
var_Create(vout, "deinterlace-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT | VLC_VAR_HASCHOICE);
char *deinterlace_mode = var_GetNonEmptyString(vout, "deinterlace-mode");
text.psz_string = _("Deinterlace mode");
var_Change(vout, "deinterlace-mode", VLC_VAR_SETTEXT, &text, NULL);
const module_config_t *optm = config_FindConfig(VLC_OBJECT(vout), "deinterlace-mode");
var_Change(vout, "deinterlace-mode", VLC_VAR_CLEARCHOICES, NULL, NULL);
for (int i = 0; optm && i < optm->i_list; i++) {
if (!DeinterlaceIsModeValid(optm->ppsz_list[i]))
continue;
val.psz_string = optm->ppsz_list[i];
text.psz_string = (char*)vlc_gettext(optm->ppsz_list_text[i]);
var_Change(vout, "deinterlace-mode", VLC_VAR_ADDCHOICE, &val, &text);
}
var_AddCallback(vout, "deinterlace-mode", DeinterlaceCallback, NULL);
/* */
var_Create(vout, "deinterlace-needed", VLC_VAR_BOOL);
var_AddCallback(vout, "deinterlace-needed", DeinterlaceCallback, NULL);
/* Override the initial value from filters if present */
char *filter_mode = NULL;
if (DeinterlaceIsPresent(vout))
filter_mode = var_CreateGetNonEmptyString(vout, "sout-deinterlace-mode");
if (filter_mode) {
deinterlace_state = 1;
free(deinterlace_mode);
deinterlace_mode = filter_mode;
}
/* */
val.psz_string = deinterlace_mode ? deinterlace_mode : optm->orig.psz;
var_Change(vout, "deinterlace-mode", VLC_VAR_SETVALUE, &val, NULL);
val.b_bool = is_interlaced;
var_Change(vout, "deinterlace-needed", VLC_VAR_SETVALUE, &val, NULL);
var_SetInteger(vout, "deinterlace", deinterlace_state);
free(deinterlace_mode);
}
/**
* Parse command line for configuration options.
*
* Now that the module_bank has been initialized, we can dynamically
* generate the longopts structure used by getops. We have to do it this way
* because we don't know (and don't want to know) in advance the configuration
* options used (ie. exported) by each module.
*
* @param p_this object to write command line options as variables to
* @param i_argc number of command line arguments
* @param ppsz_args commandl ine arguments [IN/OUT]
* @param pindex NULL to ignore unknown options,
* otherwise index of the first non-option argument [OUT]
* @return 0 on success, -1 on error.
*/
int config_LoadCmdLine( vlc_object_t *p_this, int i_argc,
const char *ppsz_argv[], int *pindex )
{
int i_cmd, i_index, i_opts, i_shortopts, flag, i_verbose = 0;
module_t *p_parser;
struct vlc_option *p_longopts;
const char **argv_copy = NULL;
#define b_ignore_errors (pindex == NULL)
/* Short options */
module_config_t *pp_shortopts[256];
char *psz_shortopts;
/* List all modules */
module_t **list = module_list_get (NULL);
/*
* Generate the longopts and shortopts structures used by getopt_long
*/
i_opts = 0;
for (size_t i = 0; (p_parser = list[i]) != NULL; i++)
/* count the number of exported configuration options (to allocate
* longopts). We also need to allocate space for two options when
* dealing with boolean to allow for --foo and --no-foo */
i_opts += p_parser->i_config_items + 2 * p_parser->i_bool_items;
p_longopts = malloc( sizeof(*p_longopts) * (i_opts + 1) );
if( p_longopts == NULL )
{
module_list_free (list);
return -1;
}
psz_shortopts = malloc( 2 * i_opts + 1 );
if( psz_shortopts == NULL )
{
free( p_longopts );
module_list_free (list);
return -1;
}
/* If we are requested to ignore errors, then we must work on a copy
* of the ppsz_argv array, otherwise getopt_long will reorder it for
* us, ignoring the arity of the options */
if( b_ignore_errors )
{
argv_copy = (const char**)malloc( i_argc * sizeof(char *) );
if( argv_copy == NULL )
{
free( psz_shortopts );
free( p_longopts );
module_list_free (list);
return -1;
}
memcpy( argv_copy, ppsz_argv, i_argc * sizeof(char *) );
ppsz_argv = argv_copy;
}
i_shortopts = 0;
for( i_index = 0; i_index < 256; i_index++ )
{
pp_shortopts[i_index] = NULL;
}
/* Fill the p_longopts and psz_shortopts structures */
i_index = 0;
for (size_t i = 0; (p_parser = list[i]) != NULL; i++)
{
module_config_t *p_item, *p_end;
if( !p_parser->i_config_items )
continue;
for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
p_item < p_end;
p_item++ )
{
/* Ignore hints */
if( p_item->i_type & CONFIG_HINT )
continue;
/* Add item to long options */
p_longopts[i_index].name = strdup( p_item->psz_name );
if( p_longopts[i_index].name == NULL ) continue;
p_longopts[i_index].has_arg =
(p_item->i_type != CONFIG_ITEM_BOOL);
p_longopts[i_index].flag = &flag;
p_longopts[i_index].val = 0;
i_index++;
/* When dealing with bools we also need to add the --no-foo
* option */
if( p_item->i_type == CONFIG_ITEM_BOOL )
{
char *psz_name = malloc( strlen(p_item->psz_name) + 3 );
if( psz_name == NULL ) continue;
strcpy( psz_name, "no" );
strcat( psz_name, p_item->psz_name );
p_longopts[i_index].name = psz_name;
p_longopts[i_index].has_arg = false;
p_longopts[i_index].flag = &flag;
p_longopts[i_index].val = 1;
i_index++;
psz_name = malloc( strlen(p_item->psz_name) + 4 );
if( psz_name == NULL ) continue;
strcpy( psz_name, "no-" );
strcat( psz_name, p_item->psz_name );
p_longopts[i_index].name = psz_name;
p_longopts[i_index].has_arg = false;
p_longopts[i_index].flag = &flag;
p_longopts[i_index].val = 1;
i_index++;
}
/* If item also has a short option, add it */
if( p_item->i_short )
{
pp_shortopts[(int)p_item->i_short] = p_item;
psz_shortopts[i_shortopts] = p_item->i_short;
i_shortopts++;
if( p_item->i_type != CONFIG_ITEM_BOOL
&& p_item->i_short != 'v' )
{
psz_shortopts[i_shortopts] = ':';
i_shortopts++;
}
}
}
}
/* We don't need the module list anymore */
module_list_free( list );
/* Close the longopts and shortopts structures */
memset( &p_longopts[i_index], 0, sizeof(*p_longopts) );
psz_shortopts[i_shortopts] = '\0';
int ret = -1;
/*
* Parse the command line options
*/
vlc_getopt_t state;
state.optind = 0 ; /* set to 0 to tell GNU getopt to reinitialize */
while( ( i_cmd = vlc_getopt_long( i_argc, (char **)ppsz_argv,
psz_shortopts,
p_longopts, &i_index, &state ) ) != -1 )
{
/* A long option has been recognized */
if( i_cmd == 0 )
{
module_config_t *p_conf;
const char *psz_name = p_longopts[i_index].name;
/* Check if we deal with a --nofoo or --no-foo long option */
if( flag ) psz_name += psz_name[2] == '-' ? 3 : 2;
/* Store the configuration option */
p_conf = config_FindConfig( p_this, psz_name );
if( p_conf )
{
/* Check if the option is deprecated */
if( p_conf->b_removed )
{
fprintf(stderr,
"Warning: option --%s no longer exists.\n",
psz_name);
continue;
}
if( p_conf->psz_oldname
&& !strcmp( p_conf->psz_oldname, psz_name) )
{
if( !b_ignore_errors )
{
fprintf( stderr, "Error: option --%s is deprecated. "
"Use --%s instead.\n",
psz_name, p_conf->psz_name );
goto out;
}
psz_name = p_conf->psz_name;
}
switch( p_conf->i_type )
{
case CONFIG_ITEM_STRING:
case CONFIG_ITEM_PASSWORD:
case CONFIG_ITEM_FILE:
case CONFIG_ITEM_DIRECTORY:
case CONFIG_ITEM_MODULE:
case CONFIG_ITEM_MODULE_LIST:
case CONFIG_ITEM_MODULE_LIST_CAT:
case CONFIG_ITEM_MODULE_CAT:
var_Create( p_this, psz_name, VLC_VAR_STRING );
var_SetString( p_this, psz_name, state.optarg );
break;
case CONFIG_ITEM_INTEGER:
var_Create( p_this, psz_name, VLC_VAR_INTEGER );
var_SetInteger( p_this, psz_name,
strtol(state.optarg, NULL, 0));
break;
case CONFIG_ITEM_FLOAT:
var_Create( p_this, psz_name, VLC_VAR_FLOAT );
var_SetFloat( p_this, psz_name, us_atof(state.optarg) );
break;
case CONFIG_ITEM_KEY:
var_Create( p_this, psz_name, VLC_VAR_INTEGER );
var_SetInteger( p_this, psz_name,
ConfigStringToKey( state.optarg ) );
break;
case CONFIG_ITEM_BOOL:
var_Create( p_this, psz_name, VLC_VAR_BOOL );
var_SetBool( p_this, psz_name, !flag );
break;
}
continue;
}
}
/* A short option has been recognized */
if( pp_shortopts[i_cmd] != NULL )
{
const char *name = pp_shortopts[i_cmd]->psz_name;
switch( pp_shortopts[i_cmd]->i_type )
{
case CONFIG_ITEM_STRING:
case CONFIG_ITEM_PASSWORD:
case CONFIG_ITEM_FILE:
case CONFIG_ITEM_DIRECTORY:
case CONFIG_ITEM_MODULE:
case CONFIG_ITEM_MODULE_CAT:
case CONFIG_ITEM_MODULE_LIST:
case CONFIG_ITEM_MODULE_LIST_CAT:
var_Create( p_this, name, VLC_VAR_STRING );
var_SetString( p_this, name, state.optarg );
break;
case CONFIG_ITEM_INTEGER:
var_Create( p_this, name, VLC_VAR_INTEGER );
if( i_cmd == 'v' )
{
i_verbose++; /* -v */
var_SetInteger( p_this, name, i_verbose );
}
else
{
var_SetInteger( p_this, name,
strtol(state.optarg, NULL, 0) );
}
break;
case CONFIG_ITEM_BOOL:
var_Create( p_this, name, VLC_VAR_BOOL );
var_SetBool( p_this, name, true );
break;
}
continue;
}
/* Internal error: unknown option */
if( !b_ignore_errors )
{
fputs( "vlc: unknown option"
" or missing mandatory argument ", stderr );
if( state.optopt )
{
fprintf( stderr, "`-%c'\n", state.optopt );
}
else
{
fprintf( stderr, "`%s'\n", ppsz_argv[state.optind-1] );
}
fputs( "Try `vlc --help' for more information.\n", stderr );
goto out;
}
}
ret = 0;
if( pindex != NULL )
*pindex = state.optind;
out:
/* Free allocated resources */
for( i_index = 0; p_longopts[i_index].name; i_index++ )
free( (char *)p_longopts[i_index].name );
free( p_longopts );
free( psz_shortopts );
free( argv_copy );
return ret;
}
void vout_InitInterlacingSupport(vout_thread_t *vout)
{
vlc_value_t val;
msg_Dbg(vout, "Deinterlacing available");
vout->p->filter.has_deint = false;
/* Create the configuration variables */
/* */
var_Create(vout, "deinterlace", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
int deinterlace_state = var_GetInteger(vout, "deinterlace");
var_Change(vout, "deinterlace", VLC_VAR_SETTEXT, _("Deinterlace"));
const module_config_t *optd = config_FindConfig("deinterlace");
var_Change(vout, "deinterlace", VLC_VAR_CLEARCHOICES);
if (likely(optd != NULL))
for (unsigned i = 0; i < optd->list_count; i++) {
val.i_int = optd->list.i[i];
var_Change(vout, "deinterlace", VLC_VAR_ADDCHOICE, val,
vlc_gettext(optd->list_text[i]));
}
var_AddCallback(vout, "deinterlace", DeinterlaceCallback, NULL);
/* */
var_Create(vout, "deinterlace-mode", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
char *deinterlace_mode = var_GetNonEmptyString(vout, "deinterlace-mode");
var_Change(vout, "deinterlace-mode", VLC_VAR_SETTEXT,
_("Deinterlace mode"));
const module_config_t *optm = config_FindConfig("deinterlace-mode");
var_Change(vout, "deinterlace-mode", VLC_VAR_CLEARCHOICES);
if (likely(optm != NULL))
for (unsigned i = 0; i < optm->list_count; i++) {
if (!DeinterlaceIsModeValid(optm->list.psz[i]))
continue;
val.psz_string = (char *)optm->list.psz[i];
var_Change(vout, "deinterlace-mode", VLC_VAR_ADDCHOICE,
val, vlc_gettext(optm->list_text[i]));
}
var_AddCallback(vout, "deinterlace-mode", DeinterlaceCallback, NULL);
/* */
var_Create(vout, "deinterlace-needed", VLC_VAR_BOOL);
var_AddCallback(vout, "deinterlace-needed", DeinterlaceCallback, NULL);
/* Override the initial value from filters if present */
char *filter_mode = NULL;
if (vout->p->filter.has_deint)
filter_mode = var_CreateGetNonEmptyString(vout, "sout-deinterlace-mode");
if (filter_mode) {
deinterlace_state = 1;
free(deinterlace_mode);
deinterlace_mode = filter_mode;
}
/* */
val.psz_string = deinterlace_mode ? deinterlace_mode : optm->orig.psz;
var_Change(vout, "deinterlace-mode", VLC_VAR_SETVALUE, val);
var_SetInteger(vout, "deinterlace", deinterlace_state);
free(deinterlace_mode);
vout->p->interlacing.is_interlaced = false;
}
/*****************************************************************************
* config_LoadConfigFile: loads the configuration file.
*****************************************************************************
* This function is called to load the config options stored in the config
* file.
*****************************************************************************/
int config_LoadConfigFile( vlc_object_t *p_this )
{
FILE *file;
file = config_OpenConfigFile (p_this);
if (file == NULL)
return VLC_EGENERIC;
/* Look for UTF-8 Byte Order Mark */
char * (*convert) (const char *) = strdupnull;
char bom[3];
if ((fread (bom, 1, 3, file) != 3)
|| memcmp (bom, "\xEF\xBB\xBF", 3))
{
convert = FromLocaleDup;
rewind (file); /* no BOM, rewind */
}
char *line = NULL;
size_t bufsize;
ssize_t linelen;
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
vlc_rwlock_wrlock (&config_lock);
while ((linelen = getline (&line, &bufsize, file)) != -1)
{
line[linelen - 1] = '\0'; /* trim newline */
/* Ignore comments, section and empty lines */
if (memchr ("#[", line[0], 3) != NULL)
continue;
/* look for option name */
const char *psz_option_name = line;
char *ptr = strchr (line, '=');
if (ptr == NULL)
continue; /* syntax error */
*ptr = '\0';
module_config_t *item = config_FindConfig (p_this, psz_option_name);
if (item == NULL)
continue;
const char *psz_option_value = ptr + 1;
switch (item->i_type)
{
case CONFIG_ITEM_BOOL:
case CONFIG_ITEM_INTEGER:
{
int64_t l;
errno = 0;
l = strtoi (psz_option_value);
if ((l > item->max.i) || (l < item->min.i))
errno = ERANGE;
if (errno)
msg_Warn (p_this, "Integer value (%s) for %s: %m",
psz_option_value, psz_option_name);
else
item->saved.i = item->value.i = l;
break;
}
case CONFIG_ITEM_FLOAT:
if (!*psz_option_value)
break; /* ignore empty option */
item->value.f = (float)atof (psz_option_value);
item->saved.f = item->value.f;
break;
default:
free ((char *)item->value.psz);
free ((char *)item->saved.psz);
item->value.psz = convert (psz_option_value);
item->saved.psz = strdupnull (item->value.psz);
break;
}
}
vlc_rwlock_unlock (&config_lock);
free (line);
if (ferror (file))
{
msg_Err (p_this, "error reading configuration: %m");
clearerr (file);
}
fclose (file);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
return 0;
}
/*****************************************************************************
* Constructor.
*****************************************************************************/
SubsFileDialog::SubsFileDialog( intf_thread_t *_p_intf, wxWindow* _p_parent ):
wxDialog( _p_parent, -1, wxU(_("Subtitle options")),
wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE )
{
/* Initializations */
p_intf = _p_intf;
p_parent = _p_parent;
SetIcon( *p_intf->p_sys->p_icon );
/* Create a panel to put everything in */
wxPanel *panel = new wxPanel( this, -1 );
panel->SetAutoLayout( TRUE );
wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
/* Create the subtitles file textctrl */
wxBoxSizer *file_sizer_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticBox *file_box = new wxStaticBox( panel, -1,
wxU(_("Subtitles file")) );
wxStaticBoxSizer *file_sizer = new wxStaticBoxSizer( file_box,
wxHORIZONTAL );
char *psz_subsfile = config_GetPsz( p_intf, "sub-file" );
if( !psz_subsfile ) psz_subsfile = strdup("");
file_combo = new wxComboBox( panel, -1, wxL2U(psz_subsfile),
wxPoint(20,25), wxSize(300, -1), 0, NULL );
if( psz_subsfile ) free( psz_subsfile );
wxButton *browse_button = new wxButton( panel, FileBrowse_Event,
wxU(_("Browse...")) );
file_sizer->Add( file_combo, 1, wxALL, 5 );
file_sizer->Add( browse_button, 0, wxALL, 5 );
file_sizer_sizer->Add( file_sizer, 1, wxEXPAND | wxALL, 5 );
panel_sizer->Add( file_sizer, 0, wxEXPAND | wxALL, 5 );
/* Subtitles encoding */
encoding_combo = NULL;
module_config_t *p_item =
config_FindConfig( VLC_OBJECT(p_intf), "subsdec-encoding" );
if( p_item )
{
wxBoxSizer *enc_sizer_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticBox *enc_box = new wxStaticBox( panel, -1,
wxU(_("Subtitles encoding")) );
wxStaticBoxSizer *enc_sizer = new wxStaticBoxSizer( enc_box,
wxHORIZONTAL );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(p_item->psz_text));
encoding_combo = new wxComboBox( panel, -1, wxU(p_item->psz_value),
wxDefaultPosition, wxDefaultSize,
0, NULL, wxCB_READONLY );
/* build a list of available options */
for( int i_index = 0; p_item->ppsz_list && p_item->ppsz_list[i_index];
i_index++ )
{
encoding_combo->Append( wxU(p_item->ppsz_list[i_index]) );
if( p_item->psz_value && !strcmp( p_item->psz_value,
p_item->ppsz_list[i_index] ) )
encoding_combo->SetSelection( i_index );
}
if( p_item->psz_value )
encoding_combo->SetValue( wxU(p_item->psz_value) );
encoding_combo->SetToolTip( wxU(p_item->psz_longtext) );
enc_sizer->Add( label, 0, wxALL | wxALIGN_CENTER, 5 );
enc_sizer->Add( encoding_combo, 0, wxEXPAND | wxALL | wxALIGN_CENTER, 5 );
enc_sizer_sizer->Add( enc_sizer, 1, wxEXPAND | wxALL, 5 );
panel_sizer->Add( enc_sizer, 0, wxEXPAND | wxALL, 5 );
}
/* Misc Subtitles options */
wxBoxSizer *misc_sizer_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticBox *misc_box = new wxStaticBox( panel, -1,
wxU(_("Subtitles options")) );
wxStaticBoxSizer *misc_sizer = new wxStaticBoxSizer( misc_box,
wxVERTICAL );
wxFlexGridSizer *grid_sizer = new wxFlexGridSizer( 2, 1, 20 );
/* Font size */
p_item =
config_FindConfig( VLC_OBJECT(p_intf), "freetype-rel-fontsize" );
if( p_item )
{
wxBoxSizer *size_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(p_item->psz_text));
size_combo = new wxComboBox( panel, -1, wxT(""),
wxDefaultPosition, wxDefaultSize,
0, NULL, wxCB_READONLY );
/* build a list of available options */
for( int i_index = 0; i_index < p_item->i_list; i_index++ )
{
size_combo->Append( wxU(p_item->ppsz_list_text[i_index]),
(void *)p_item->pi_list[i_index] );
if( p_item->i_value == p_item->pi_list[i_index] )
{
size_combo->SetSelection( i_index );
size_combo->SetValue(wxU(p_item->ppsz_list_text[i_index]));
}
}
size_combo->SetToolTip( wxU(p_item->psz_longtext) );
size_sizer->Add( label, 0, wxRIGHT | wxALIGN_CENTER, 5 );
size_sizer->Add( size_combo, 0, wxLEFT | wxALIGN_CENTER, 5 );
grid_sizer->Add( size_sizer, 1, wxEXPAND | wxALL, 5 );
}
p_item =
config_FindConfig( VLC_OBJECT(p_intf), "subsdec-align" );
if( p_item )
{
wxBoxSizer *align_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(p_item->psz_text));
align_combo = new wxComboBox( panel, -1, wxT(""),
wxDefaultPosition, wxDefaultSize,
0, NULL, wxCB_READONLY );
/* build a list of available options */
for( int i_index = 0; i_index < p_item->i_list; i_index++ )
{
align_combo->Append( wxU(p_item->ppsz_list_text[i_index]),
(void *)p_item->pi_list[i_index] );
if( p_item->i_value == p_item->pi_list[i_index] )
{
align_combo->SetSelection( i_index );
align_combo->SetValue(wxU(p_item->ppsz_list_text[i_index]));
}
}
align_combo->SetToolTip( wxU(p_item->psz_longtext) );
align_sizer->Add( label, 0, wxRIGHT | wxALIGN_CENTER, 5 );
align_sizer->Add( align_combo, 0, wxLEFT | wxALIGN_CENTER, 5 );
grid_sizer->Add( align_sizer, 1, wxEXPAND | wxALL, 5 );
}
misc_sizer->Add( grid_sizer, 1, wxEXPAND | wxALL , 5 );
grid_sizer = new wxFlexGridSizer( 4, 1, 20 );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(_("Frames per second")));
float f_fps = config_GetFloat( p_intf, "sub-fps" );
/* Outside the new wxSpinCtrl to avoid an internal error in gcc2.95 ! */
wxString format_fps(wxString::Format(wxT("%d"),(int)f_fps));
fps_spinctrl = new wxSpinCtrl( panel, -1, format_fps,
wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS,
0, 16000, (int)f_fps );
fps_spinctrl->SetToolTip( wxU(_("Override frames per second. "
"It will only work with MicroDVD and SubRIP subtitles.")) );
grid_sizer->Add( label, 0, wxALIGN_CENTER, 5 );
grid_sizer->Add( fps_spinctrl, 0,wxALIGN_CENTER, 5 );
wxStaticText *label_delay =
new wxStaticText(panel, -1, wxU(_("Delay")));
int i_delay = config_GetInt( p_intf, "sub-delay" );
/* Outside the new wxSpinCtrl to avoid an internal error in gcc2.95 ! */
wxString format_delay(wxString::Format(wxT("%i"), i_delay ));
delay_spinctrl = new wxSpinCtrl( panel, -1, format_delay,
wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS,
0, 16000, i_delay );
delay_spinctrl->SetToolTip( wxU(_("Set subtitle delay (in 1/10s)" ) ) );
grid_sizer->Add( label_delay , 0, wxALIGN_CENTER, 5 );
grid_sizer->Add( delay_spinctrl, 0, wxALIGN_CENTER, 5 );
misc_sizer->Add( grid_sizer, 0, wxALL, 5 );
misc_sizer_sizer->Add( misc_sizer, 1, wxEXPAND | wxALL, 5 );
panel_sizer->Add( misc_sizer, 0, wxEXPAND | wxALL, 5 );
/* Separation */
wxStaticLine *static_line = new wxStaticLine( panel, wxID_OK );
/* Create the buttons */
wxButton *ok_button = new wxButton( panel, wxID_OK, wxU(_("OK")) );
ok_button->SetDefault();
wxButton *cancel_button = new wxButton( panel, wxID_CANCEL,
wxU(_("Cancel")) );
/* Place everything in sizers */
wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );
button_sizer->Add( ok_button, 0, wxALL, 5 );
button_sizer->Add( cancel_button, 0, wxALL, 5 );
button_sizer->Layout();
panel_sizer->Add( static_line, 0, wxEXPAND | wxALL, 5 );
panel_sizer->Add( button_sizer, 0, wxALIGN_LEFT | wxALIGN_BOTTOM |
wxALL, 5 );
panel_sizer->Layout();
panel->SetSizerAndFit( panel_sizer );
main_sizer->Add( panel, 1, wxGROW, 0 );
main_sizer->Layout();
SetSizerAndFit( main_sizer );
}