void filter_AddProxyCallbacks( vlc_object_t *obj, filter_t *filter,
vlc_callback_t restart_cb )
{
char **names = var_GetAllNames(VLC_OBJECT(filter));
if (names == NULL)
return;
for (char **pname = names; *pname != NULL; pname++)
{
char *name = *pname;
int var_type = var_Type(filter, name);
if (var_Type(obj, name) || config_GetType(name) == 0)
{
free(name);
continue;
}
var_Create(obj, name,
var_type | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND);
if ((var_type & VLC_VAR_ISCOMMAND))
var_AddCallback(obj, name, TriggerFilterCallback, filter);
else
var_AddCallback(obj, name, restart_cb, obj);
free(name);
}
free(names);
}
void filter_DelProxyCallbacks( vlc_object_t *obj, filter_t *filter,
vlc_callback_t restart_cb )
{
char **names = var_GetAllNames(VLC_OBJECT(filter));
if (names == NULL)
return;
for (char **pname = names; *pname != NULL; pname++)
{
char *name = *pname;
if (!(var_Type(obj, name) & VLC_VAR_ISCOMMAND))
{
free(name);
continue;
}
int filter_var_type = var_Type(filter, name);
if (filter_var_type & VLC_VAR_ISCOMMAND)
var_DelCallback(obj, name, TriggerFilterCallback, filter);
else if (filter_var_type)
var_DelCallback(obj, name, restart_cb, obj);
var_Destroy(obj, name);
free(name);
}
free(names);
}
/*****************************************************************************
* aout_FindAndRestart : find the audio output instance and restart
*****************************************************************************
* This is used for callbacks of the configuration variables, and we believe
* that when those are changed, it is a significant change which implies
* rebuilding the audio-device and audio-channels variables.
*****************************************************************************/
int aout_FindAndRestart( vlc_object_t * p_this, const char *psz_name,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
aout_instance_t * p_aout = vlc_object_find( p_this, VLC_OBJECT_AOUT,
FIND_ANYWHERE );
(void)psz_name;
(void)oldval;
(void)newval;
(void)p_data;
if ( p_aout == NULL ) return VLC_SUCCESS;
if ( var_Type( p_aout, "audio-device" ) != 0 )
{
var_Destroy( p_aout, "audio-device" );
}
if ( var_Type( p_aout, "audio-channels" ) != 0 )
{
var_Destroy( p_aout, "audio-channels" );
}
aout_Restart( p_aout );
vlc_object_release( p_aout );
return VLC_SUCCESS;
}
void VlcProc::init_equalizer()
{
playlist_t* pPlaylist = getIntf()->p_sys->p_playlist;
audio_output_t* pAout = playlist_GetAout( pPlaylist );
if( pAout )
{
if( !var_Type( pAout, "equalizer-bands" ) )
var_Create( pAout, "equalizer-bands",
VLC_VAR_STRING | VLC_VAR_DOINHERIT);
if( !var_Type( pAout, "equalizer-preamp" ) )
var_Create( pAout, "equalizer-preamp",
VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
// New Aout (addCallbacks)
var_AddCallback( pAout, "audio-filter",
onGenericCallback, this );
var_AddCallback( pAout, "equalizer-bands",
onEqBandsChange, this );
var_AddCallback( pAout, "equalizer-preamp",
onEqPreampChange, this );
}
// is equalizer enabled ?
char *pFilters = pAout ?
var_GetNonEmptyString( pAout, "audio-filter" ) :
var_InheritString( getIntf(), "audio-filter" );
bool b_equalizer = pFilters && strstr( pFilters, "equalizer" );
free( pFilters );
SET_BOOL( m_cVarEqualizer, b_equalizer );
// retrieve initial bands
char* bands = pAout ?
var_GetString( pAout, "equalizer-bands" ) :
var_InheritString( getIntf(), "equalizer-bands" );
if( bands )
{
m_varEqBands.set( bands );
free( bands );
}
// retrieve initial preamp
float preamp = pAout ?
var_GetFloat( pAout, "equalizer-preamp" ) :
var_InheritFloat( getIntf(), "equalizer-preamp" );
EqualizerPreamp *pVarPreamp = (EqualizerPreamp*)m_cVarEqPreamp.get();
pVarPreamp->set( (preamp + 20.0) / 40.0 );
if( pAout )
vlc_object_release( pAout);
}
/*****************************************************************************
* aout_DecDelete : delete a decoder
*****************************************************************************/
int aout_DecDelete( aout_instance_t * p_aout, aout_input_t * p_input )
{
int i_input;
/* This function can only be called by the decoder itself, so no need
* to lock p_input->lock. */
vlc_mutex_lock( &p_aout->mixer_lock );
for ( i_input = 0; i_input < p_aout->i_nb_inputs; i_input++ )
{
if ( p_aout->pp_inputs[i_input] == p_input )
{
break;
}
}
if ( i_input == p_aout->i_nb_inputs )
{
msg_Err( p_aout, "cannot find an input to delete" );
return -1;
}
/* Remove the input from the list. */
memmove( &p_aout->pp_inputs[i_input], &p_aout->pp_inputs[i_input + 1],
(AOUT_MAX_INPUTS - i_input - 1) * sizeof(aout_input_t *) );
p_aout->i_nb_inputs--;
aout_InputDelete( p_aout, p_input );
vlc_mutex_destroy( &p_input->lock );
free( p_input );
if ( !p_aout->i_nb_inputs )
{
aout_OutputDelete( p_aout );
aout_MixerDelete( p_aout );
if ( var_Type( p_aout, "audio-device" ) != 0 )
{
var_Destroy( p_aout, "audio-device" );
}
if ( var_Type( p_aout, "audio-channels" ) != 0 )
{
var_Destroy( p_aout, "audio-channels" );
}
}
vlc_mutex_unlock( &p_aout->mixer_lock );
return 0;
}
/*****************************
* Set device for using
*****************************/
void libvlc_audio_output_device_set( libvlc_media_player_t *mp,
const char *module, const char *devid )
{
if( devid == NULL )
return;
if( module != NULL )
{
char *cfg_name;
if( asprintf( &cfg_name, "%s-audio-device", module ) == -1 )
return;
if( !var_Type( mp, cfg_name ) )
/* Don't recreate the same variable over and over and over... */
var_Create( mp, cfg_name, VLC_VAR_STRING );
var_SetString( mp, cfg_name, devid );
free( cfg_name );
return;
}
audio_output_t *aout = GetAOut( mp );
if( aout == NULL )
return;
aout_DeviceSet( aout, devid );
vlc_object_release( aout );
}
static struct decklink_sys_t *GetDLSys(vlc_object_t *obj)
{
vlc_object_t *libvlc = VLC_OBJECT(obj->p_libvlc);
struct decklink_sys_t *sys;
vlc_mutex_lock(&sys_lock);
if (var_Type(libvlc, "decklink-sys") == VLC_VAR_ADDRESS)
sys = (struct decklink_sys_t*)var_GetAddress(libvlc, "decklink-sys");
else {
sys = (struct decklink_sys_t*)malloc(sizeof(*sys));
if (sys) {
sys->p_output = NULL;
sys->offset = 0;
sys->users = 0;
sys->i_rate = -1;
vlc_mutex_init(&sys->lock);
vlc_cond_init(&sys->cond);
var_Create(libvlc, "decklink-sys", VLC_VAR_ADDRESS);
var_SetAddress(libvlc, "decklink-sys", (void*)sys);
}
}
vlc_mutex_unlock(&sys_lock);
return sys;
}
/*****************************************************************************
* Activate: allocate a chroma function
*****************************************************************************
* This function allocates and initializes a chroma function
*****************************************************************************/
static int Activate( filter_t *p_filter, int (*pf_build)(filter_t *) )
{
filter_sys_t *p_sys;
int i_ret = VLC_EGENERIC;
p_sys = p_filter->p_sys = calloc( 1, sizeof( *p_sys ) );
if( !p_sys )
return VLC_ENOMEM;
filter_owner_t owner = {
.video = &filter_video_chain_cbs,
.sys = p_filter,
};
p_sys->p_chain = filter_chain_NewVideo( p_filter, p_filter->b_allow_fmt_out_change, &owner );
if( !p_sys->p_chain )
{
free( p_sys );
return VLC_EGENERIC;
}
int type = VLC_VAR_INTEGER;
if( var_Type( p_filter->obj.parent, "chain-level" ) != 0 )
type |= VLC_VAR_DOINHERIT;
var_Create( p_filter, "chain-level", type );
/* Note: atomicity is not actually needed here. */
var_IncInteger( p_filter, "chain-level" );
int level = var_GetInteger( p_filter, "chain-level" );
if( level < 0 || level > CHAIN_LEVEL_MAX )
msg_Err( p_filter, "Too high level of recursion (%d)", level );
else
i_ret = pf_build( p_filter );
var_Destroy( p_filter, "chain-level" );
if( i_ret )
{
/* Hum ... looks like this really isn't going to work. Too bad. */
if (p_sys->p_video_filter)
filter_DelProxyCallbacks( p_filter, p_sys->p_video_filter,
RestartFilterCallback );
filter_chain_Delete( p_sys->p_chain );
free( p_sys );
return VLC_EGENERIC;
}
if( p_filter->b_allow_fmt_out_change )
{
es_format_Clean( &p_filter->fmt_out );
es_format_Copy( &p_filter->fmt_out,
filter_chain_GetFmtOut( p_sys->p_chain ) );
}
/* */
p_filter->pf_video_filter = Chain;
return VLC_SUCCESS;
}
void InputManager::sectionNext()
{
if( hasInput() )
{
int i_type = var_Type( p_input, "next-chapter" );
var_TriggerCallback( p_input, (i_type & VLC_VAR_TYPE) != 0 ?
"next-chapter":"next-title" );
}
}
/**********************************************************************
* Execute a var command on an object identified by its name
**********************************************************************/
int var_Command( vlc_object_t *p_this, const char *psz_name,
const char *psz_cmd, const char *psz_arg, char **psz_msg )
{
vlc_object_t *p_obj = vlc_object_find_name( p_this->p_libvlc,
psz_name );
int i_type, i_ret;
if( !p_obj )
{
if( psz_msg )
*psz_msg = strdup( "Unknown destination object." );
return VLC_ENOOBJ;
}
i_type = var_Type( p_obj, psz_cmd );
if( !( i_type&VLC_VAR_ISCOMMAND ) )
{
vlc_object_release( p_obj );
if( psz_msg )
*psz_msg = strdup( "Variable doesn't exist or isn't a command." );
return VLC_EGENERIC;
}
i_type &= VLC_VAR_CLASS;
switch( i_type )
{
case VLC_VAR_INTEGER:
i_ret = var_SetInteger( p_obj, psz_cmd, atoi( psz_arg ) );
break;
case VLC_VAR_FLOAT:
i_ret = var_SetFloat( p_obj, psz_cmd, us_atof( psz_arg ) );
break;
case VLC_VAR_STRING:
i_ret = var_SetString( p_obj, psz_cmd, psz_arg );
break;
case VLC_VAR_BOOL:
i_ret = var_SetBool( p_obj, psz_cmd, atoi( psz_arg ) );
break;
default:
i_ret = VLC_EGENERIC;
break;
}
vlc_object_release( p_obj );
if( psz_msg )
{
if( asprintf( psz_msg, "%s on object %s returned %i (%s)",
psz_cmd, psz_name, i_ret, vlc_error( i_ret ) ) == -1)
*psz_msg = NULL;
}
return i_ret;
}
static int vlclua_var_get( lua_State *L )
{
int i_type;
vlc_value_t val;
vlc_object_t **pp_obj = luaL_checkudata( L, 1, "vlc_object" );
const char *psz_var = luaL_checkstring( L, 2 );
i_type = var_Type( *pp_obj, psz_var );
if( var_Get( *pp_obj, psz_var, &val ) != VLC_SUCCESS )
return 0;
lua_pop( L, 2 );
return vlclua_pushvalue( L, i_type, val );
}
static int vlclua_var_set( lua_State *L )
{
int i_type;
vlc_value_t val;
vlc_object_t **pp_obj = luaL_checkudata( L, 1, "vlc_object" );
const char *psz_var = luaL_checkstring( L, 2 );
int i_ret;
i_type = var_Type( *pp_obj, psz_var );
vlclua_tovalue( L, i_type, &val );
i_ret = var_Set( *pp_obj, psz_var, val );
lua_pop( L, 3 );
return vlclua_push_ret( L, i_ret );
}
//---------------------------------------------------------------------------
// DemuxOpen: initialize demux
//---------------------------------------------------------------------------
static int DemuxOpen( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
intf_thread_t *p_intf;
char *ext;
// Needed callbacks
p_demux->pf_demux = Demux;
p_demux->pf_control = DemuxControl;
// Test that we have a valid .vlt file, based on the extension
// TODO: an actual check of the contents would be better...
if( ( ext = strchr( p_demux->psz_path, '.' ) ) == NULL ||
strcasecmp( ext, ".vlt" ) )
{
return VLC_EGENERIC;
}
p_intf = (intf_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INTF,
FIND_ANYWHERE );
if( p_intf != NULL )
{
// Do nothing is skins2 is not the main interface
if( var_Type( p_intf, "skin-to-load" ) == VLC_VAR_STRING )
{
playlist_t *p_playlist =
(playlist_t *) vlc_object_find( p_this, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist != NULL )
{
// Make sure the item is deleted afterwards
p_playlist->pp_items[p_playlist->i_index]->b_autodeletion =
VLC_TRUE;
vlc_object_release( p_playlist );
}
vlc_value_t val;
val.psz_string = p_demux->psz_path;
var_Set( p_intf, "skin-to-load", val );
}
else
{
msg_Warn( p_this,
"skin could not be loaded (not using skins2 intf)" );
}
vlc_object_release( p_intf );
}
return VLC_SUCCESS;
}
void libvlc_media_player_previous_chapter( libvlc_media_player_t *p_mi )
{
input_thread_t *p_input_thread;
p_input_thread = libvlc_get_input_thread ( p_mi );
if( !p_input_thread )
return;
int i_type = var_Type( p_input_thread, "next-chapter" );
var_TriggerCallback( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
"prev-chapter":"prev-title" );
vlc_object_release( p_input_thread );
}
/*****************************************************************************
* input_ControlVarTitle:
* Create all variables for a title
*****************************************************************************/
void input_ControlVarTitle( input_thread_t *p_input, int i_title )
{
input_title_t *t = p_input->p->title[i_title];
vlc_value_t text;
int i;
/* Create/Destroy command variables */
if( t->i_seekpoint <= 1 )
{
var_Destroy( p_input, "next-chapter" );
var_Destroy( p_input, "prev-chapter" );
}
else if( var_Type( p_input, "next-chapter" ) == 0 )
{
var_Create( p_input, "next-chapter", VLC_VAR_VOID );
text.psz_string = _("Next chapter");
var_Change( p_input, "next-chapter", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_input, "next-chapter", SeekpointCallback, NULL );
var_Create( p_input, "prev-chapter", VLC_VAR_VOID );
text.psz_string = _("Previous chapter");
var_Change( p_input, "prev-chapter", VLC_VAR_SETTEXT, &text, NULL );
var_AddCallback( p_input, "prev-chapter", SeekpointCallback, NULL );
}
/* Build chapter list */
var_Change( p_input, "chapter", VLC_VAR_CLEARCHOICES, NULL, NULL );
for( i = 0; i < t->i_seekpoint; i++ )
{
vlc_value_t val;
val.i_int = i;
if( t->seekpoint[i]->psz_name == NULL ||
*t->seekpoint[i]->psz_name == '\0' )
{
/* Default value */
if( asprintf( &text.psz_string, _("Chapter %i"),
i + p_input->p->i_seekpoint_offset ) == -1 )
continue;
}
else
{
text.psz_string = strdup( t->seekpoint[i]->psz_name );
}
var_Change( p_input, "chapter", VLC_VAR_ADDCHOICE, &val, &text );
free( text.psz_string );
}
}
void irc_PRIVMSG(void *handle, struct irc_msg_t *irc_msg)
{
intf_thread_t *intf = (intf_thread_t*)handle;
intf_sys_t *sys = intf->p_sys;
char *msg = irc_msg->trailing;
if(msg[0] == '>') {
char *cmd = msg+1;
if(var_Type(intf, cmd) & VLC_VAR_ISCOMMAND) {
vlc_value_t val;
var_Set(intf, cmd, val);
}
}
}
/*****************************
* Set device for using
*****************************/
void libvlc_audio_output_device_set( libvlc_media_player_t *mp,
const char *psz_audio_output,
const char *psz_device_id )
{
char *psz_config_name;
if( !psz_audio_output || !psz_device_id )
return;
if( asprintf( &psz_config_name, "%s-audio-device", psz_audio_output ) == -1 )
return;
if( !var_Type( mp, psz_audio_output ) )
/* Don't recreate the same variable over and over and over... */
var_Create( mp, psz_audio_output, VLC_VAR_STRING );
var_SetString( mp, psz_config_name, psz_device_id );
free( psz_config_name );
}
static int ActivateFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
if( !p_filter->b_allow_fmt_out_change || p_filter->psz_name == NULL )
return VLC_EGENERIC;
if( var_Type( p_filter->obj.parent, "chain-filter-level" ) != 0 )
return VLC_EGENERIC;
var_Create( p_filter, "chain-filter-level", VLC_VAR_INTEGER );
int i_ret = Activate( p_filter, BuildFilterChain );
var_Destroy( p_filter, "chain-filter-level" );
return i_ret;
}
/*****************************************************************************
* vout_RequestWindow: Create/Get a video window if possible.
*****************************************************************************
* This function looks for the main interface and tries to request
* a new video window. If it fails then the vout will still need to create the
* window by itself.
*****************************************************************************/
void *vout_RequestWindow( vout_thread_t *p_vout,
int *pi_x_hint, int *pi_y_hint,
unsigned int *pi_width_hint,
unsigned int *pi_height_hint )
{
/* Small kludge */
if( !var_Type( p_vout, "aspect-ratio" ) ) vout_IntfInit( p_vout );
/* Get requested coordinates */
*pi_x_hint = var_GetInteger( p_vout, "video-x" );
*pi_y_hint = var_GetInteger( p_vout, "video-y" );
*pi_width_hint = p_vout->i_window_width;
*pi_height_hint = p_vout->i_window_height;
/* Check whether someone provided us with a window ID */
int drawable = var_CreateGetInteger( p_vout, "drawable" );
if( drawable ) return (void *)(intptr_t)drawable;
vout_window_t *wnd = vlc_custom_create (VLC_OBJECT(p_vout), sizeof (*wnd),
VLC_OBJECT_GENERIC, "window");
if (wnd == NULL)
return NULL;
wnd->vout = p_vout;
wnd->width = *pi_width_hint;
wnd->height = *pi_height_hint;
wnd->pos_x = *pi_x_hint;
wnd->pos_y = *pi_y_hint;
vlc_object_attach (wnd, p_vout);
wnd->module = module_Need (wnd, "vout window", 0, 0);
if (wnd->module == NULL)
{
msg_Dbg (wnd, "no window provider available");
vlc_object_release (wnd);
return NULL;
}
p_vout->p_window = wnd;
*pi_width_hint = wnd->width;
*pi_height_hint = wnd->height;
*pi_x_hint = wnd->pos_x;
*pi_y_hint = wnd->pos_y;
return wnd->handle;
}
/**
* Initializes list of devices.
*/
static void Probe (vlc_object_t *obj)
{
/* Due to design bug in audio output core, this hack is required: */
if (var_Type (obj, "audio-device"))
return;
/* The variable does not exist - first call. */
vlc_value_t text;
var_Create (obj, "audio-device", VLC_VAR_STRING | VLC_VAR_HASCHOICE);
text.psz_string = _("Audio Device");
var_Change (obj, "audio-device", VLC_VAR_SETTEXT, &text, NULL);
GetDevices (obj, NULL);
var_AddCallback (obj, "audio-device", aout_ChannelsRestart, NULL);
var_TriggerCallback (obj, "intf-change");
}
static bool IsMenuEmpty( const char *psz_var,
vlc_object_t *p_object,
bool b_root )
{
vlc_value_t val, val_list;
int i_type, i_result, i;
/* Check the type of the object variable */
i_type = var_Type( p_object, psz_var );
/* Check if we want to display the variable */
if( !( i_type & VLC_VAR_HASCHOICE ) ) return false;
var_Change( p_object, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );
if( val.i_int == 0 ) return true;
if( ( i_type & VLC_VAR_TYPE ) != VLC_VAR_VARIABLE )
{
if( val.i_int == 1 && b_root ) return true;
else return false;
}
/* Check children variables in case of VLC_VAR_VARIABLE */
if( var_Change( p_object, psz_var, VLC_VAR_GETLIST, &val_list, NULL ) < 0 )
{
return true;
}
for( i = 0, i_result = true; i < val_list.p_list->i_count; i++ )
{
if( !IsMenuEmpty( val_list.p_list->p_values[i].psz_string,
p_object, false ) )
{
i_result = false;
break;
}
}
/* clean up everything */
var_FreeList( &val_list, NULL );
return i_result;
}
static int vlclua_libvlc_command( lua_State *L )
{
vlc_object_t * p_this = vlclua_get_this( L );
const char *psz_cmd;
vlc_value_t val_arg;
psz_cmd = luaL_checkstring( L, 1 );
val_arg.psz_string = strdup( luaL_optstring( L, 2, "" ) );
lua_pop( L, 2 );
int i_type = var_Type( p_this->p_libvlc, psz_cmd );
if( ! (i_type & VLC_VAR_ISCOMMAND) )
{
free( val_arg.psz_string );
return luaL_error( L, "libvlc's \"%s\" is not a command",
psz_cmd );
}
return vlclua_push_ret( L,
var_Set( p_this->p_libvlc, psz_cmd, val_arg ) );
}
/*****************************************************************************
* aout_ChannelsRestart : change the audio device or channels and restart
*****************************************************************************/
int aout_ChannelsRestart( vlc_object_t * p_this, const char * psz_variable,
vlc_value_t oldval, vlc_value_t newval,
void *p_data )
{
aout_instance_t * p_aout = (aout_instance_t *)p_this;
(void)oldval;
(void)newval;
(void)p_data;
if ( !strcmp( psz_variable, "audio-device" ) )
{
/* This is supposed to be a significant change and supposes
* rebuilding the channel choices. */
if ( var_Type( p_aout, "audio-channels" ) >= 0 )
{
var_Destroy( p_aout, "audio-channels" );
}
}
aout_Restart( p_aout );
return 0;
}
static int CreateChoicesMenu( intf_thread_t *p_intf, GtkMenu *submenu, const char *psz_var,
vlc_object_t *p_object, bool b_root )
{
vlc_value_t val, val_list, text_list;
int i_type, i;
/* Check the type of the object variable */
i_type = var_Type( p_object, psz_var );
/* Make sure we want to display the variable */
if( !g_list_length(GTK_MENU_SHELL(submenu)->children) &&
IsMenuEmpty( psz_var, p_object, b_root ) )
return VLC_EGENERIC;
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_VOID:
case VLC_VAR_BOOL:
case VLC_VAR_VARIABLE:
case VLC_VAR_STRING:
case VLC_VAR_INTEGER:
case VLC_VAR_FLOAT:
break;
default:
/* Variable doesn't exist or isn't handled */
return VLC_EGENERIC;
}
if( var_Change( p_object, psz_var, VLC_VAR_GETLIST,
&val_list, &text_list ) < 0 )
{
return VLC_EGENERIC;
}
#define CURVAL val_list.p_list->p_values[i]
#define CURTEXT text_list.p_list->p_values[i].psz_string
for( i = 0; i < val_list.p_list->i_count; i++ )
{
vlc_value_t another_val;
char string[16] = {0};
char *menutext = string;
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_VARIABLE:
{
GtkWidget *subsubmenu = gtk_menu_new();
GtkWidget *submenuitem =
gtk_menu_item_new_with_label( CURTEXT ? CURTEXT : CURVAL.psz_string );
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenuitem), subsubmenu);
gtk_menu_append( submenu, submenuitem );
CreateChoicesMenu( p_intf, GTK_MENU(subsubmenu), CURVAL.psz_string, p_object, false );
break;
}
case VLC_VAR_STRING:
var_Get( p_object, psz_var, &val );
another_val.psz_string = strdup( CURVAL.psz_string );
menutext = CURTEXT ? CURTEXT : another_val.psz_string;
CreateAndConnect( p_intf, submenu, psz_var, menutext, "",
ITEM_RADIO, p_object, another_val, i_type,
val.psz_string && !strcmp( val.psz_string, CURVAL.psz_string ) );
free( val.psz_string );
break;
case VLC_VAR_INTEGER:
var_Get( p_object, psz_var, &val );
if( CURTEXT ) menutext = CURTEXT;
else snprintf( menutext, sizeof(string)-1, "%"PRId64, CURVAL.i_int );
CreateAndConnect( p_intf, submenu, psz_var, menutext, "",
ITEM_RADIO, p_object, CURVAL, i_type,
( CURVAL.i_int == val.i_int )
&& CheckTitle( p_object, psz_var ) );
break;
case VLC_VAR_FLOAT:
var_Get( p_object, psz_var, &val );
if( CURTEXT ) menutext = CURTEXT;
else snprintf( menutext, sizeof(string)-1, "%.2f", CURVAL.f_float );
CreateAndConnect( p_intf, submenu, psz_var, menutext, "",
ITEM_RADIO, p_object, CURVAL, i_type,
CURVAL.f_float == val.f_float );
break;
default:
break;
}
}
/* clean up everything */
var_FreeList( &val_list, &text_list );
#undef CURVAL
#undef CURTEXT
return !g_list_length(GTK_MENU_SHELL(submenu)->children) ? VLC_EGENERIC : VLC_SUCCESS;
}
static void UpdateItem( intf_thread_t *p_intf, GtkMenu *menu,
const char *psz_var, vlc_object_t *p_object, bool b_submenu )
{
vlc_value_t val, text;
int i_type;
/* Check the type of the object variable */
/* This HACK is needed so we have a radio button for audio and video tracks
instread of a checkbox */
if( !strcmp( psz_var, "audio-es" )
|| !strcmp( psz_var, "video-es" ) )
i_type = VLC_VAR_INTEGER | VLC_VAR_HASCHOICE;
else
i_type = var_Type( p_object, psz_var );
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_VOID:
case VLC_VAR_BOOL:
case VLC_VAR_VARIABLE:
case VLC_VAR_STRING:
case VLC_VAR_INTEGER:
case VLC_VAR_FLOAT:
break;
default:
/* Variable doesn't exist or isn't handled */
return;
}
/* Make sure we want to display the variable */
if( !g_list_length(GTK_MENU_SHELL(menu)->children) && IsMenuEmpty( psz_var, p_object, true ) )
{
return;
}
/* Get the descriptive name of the variable */
int i_ret = var_Change( p_object, psz_var, VLC_VAR_GETTEXT, &text, NULL );
if( i_ret != VLC_SUCCESS )
{
text.psz_string = NULL;
}
/* Some specific stuff */
bool forceDisabled = false;
if( !strcmp( psz_var, "spu-es" ) )
{
vlc_object_t *p_vout = get_vout(p_intf);
forceDisabled = ( p_vout == NULL );
if( p_vout ) vlc_object_release( p_vout );
}
if( i_type & VLC_VAR_HASCHOICE )
{
/* Append choices menu */
if( b_submenu )
{
GtkWidget *item =
gtk_menu_item_new_with_label( text.psz_string ? text.psz_string : psz_var );
GtkWidget *submenu = gtk_menu_new( );
gtk_menu_append( menu, item );
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
if( CreateChoicesMenu( p_intf, GTK_MENU(submenu), psz_var, p_object, true ) )
gtk_widget_set_sensitive(item, false);
if( forceDisabled )
gtk_widget_set_sensitive(item, false);
}
else
{
if( CreateChoicesMenu( p_intf, menu, psz_var, p_object, true ) )
gtk_widget_set_sensitive(menu, false);
}
FREENULL( text.psz_string );
return;
}
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_VOID:
var_Get( p_object, psz_var, &val );
CreateAndConnect( p_intf, menu, psz_var, text.psz_string, "",
ITEM_NORMAL, p_object, val, i_type, false );
break;
case VLC_VAR_BOOL:
var_Get( p_object, psz_var, &val );
val.b_bool = !val.b_bool;
CreateAndConnect( p_intf, menu, psz_var, text.psz_string, "",
ITEM_CHECK, p_object, val, i_type, !val.b_bool );
break;
}
FREENULL( text.psz_string );
}
/*****************************************************************************
* Open: open the audio device
*****************************************************************************/
static int Open ( vlc_object_t *p_this )
{
aout_instance_t *p_aout = (aout_instance_t *)p_this;
SDL_AudioSpec desired, obtained;
int i_nb_channels;
vlc_value_t val, text;
/* Check that no one uses the DSP. */
uint32_t i_flags = SDL_INIT_AUDIO;
if( SDL_WasInit( i_flags ) )
{
return VLC_EGENERIC;
}
i_flags |= SDL_INIT_EVENTTHREAD;
#ifndef NDEBUG
/* In debug mode you may want vlc to dump a core instead of staying
* stuck */
i_flags |= SDL_INIT_NOPARACHUTE;
#endif
/* Initialize library */
if( SDL_Init( i_flags ) < 0 )
{
msg_Err( p_aout, "cannot initialize SDL (%s)", SDL_GetError() );
return VLC_EGENERIC;
}
if( var_Get( p_aout, "audio-device", &val ) != VLC_ENOVAR )
{
/* The user has selected an audio device. */
if ( val.i_int == AOUT_VAR_STEREO )
{
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
}
else if ( val.i_int == AOUT_VAR_MONO )
{
p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;
}
}
i_nb_channels = aout_FormatNbChannels( &p_aout->output.output );
if ( i_nb_channels > 2 )
{
/* SDL doesn't support more than two channels. */
i_nb_channels = 2;
p_aout->output.output.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
}
desired.freq = p_aout->output.output.i_rate;
desired.format = AUDIO_S16SYS;
desired.channels = i_nb_channels;
desired.callback = SDLCallback;
desired.userdata = p_aout;
desired.samples = FRAME_SIZE;
/* Open the sound device. */
if( SDL_OpenAudio( &desired, &obtained ) < 0 )
{
return VLC_EGENERIC;
}
SDL_PauseAudio( 0 );
/* Now have a look at what we got. */
switch ( obtained.format )
{
case AUDIO_S16LSB:
p_aout->output.output.i_format = VLC_CODEC_S16L; break;
case AUDIO_S16MSB:
p_aout->output.output.i_format = VLC_CODEC_S16B; break;
case AUDIO_U16LSB:
p_aout->output.output.i_format = VLC_CODEC_U16L; break;
case AUDIO_U16MSB:
p_aout->output.output.i_format = VLC_CODEC_U16B; break;
case AUDIO_S8:
p_aout->output.output.i_format = VLC_CODEC_S8; break;
case AUDIO_U8:
p_aout->output.output.i_format = VLC_CODEC_U8; break;
}
/* Volume is entirely done in software. */
aout_VolumeSoftInit( p_aout );
if ( obtained.channels != i_nb_channels )
{
p_aout->output.output.i_physical_channels = (obtained.channels == 2 ?
AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT :
AOUT_CHAN_CENTER);
if ( var_Type( p_aout, "audio-device" ) == 0 )
{
var_Create( p_aout, "audio-device",
VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
text.psz_string = _("Audio Device");
var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
val.i_int = (obtained.channels == 2) ? AOUT_VAR_STEREO :
AOUT_VAR_MONO;
text.psz_string = (obtained.channels == 2) ? _("Stereo") :
_("Mono");
var_Change( p_aout, "audio-device",
VLC_VAR_ADDCHOICE, &val, &text );
var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart,
NULL );
}
}
else if ( var_Type( p_aout, "audio-device" ) == 0 )
{
/* First launch. */
var_Create( p_aout, "audio-device",
VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );
text.psz_string = _("Audio Device");
var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );
val.i_int = AOUT_VAR_STEREO;
text.psz_string = _("Stereo");
var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );
val.i_int = AOUT_VAR_MONO;
text.psz_string = _("Mono");
var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );
if ( i_nb_channels == 2 )
{
val.i_int = AOUT_VAR_STEREO;
}
else
{
val.i_int = AOUT_VAR_MONO;
}
var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL );
var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
}
var_TriggerCallback( p_aout, "intf-change" );
p_aout->output.output.i_rate = obtained.freq;
p_aout->output.i_nb_samples = obtained.samples;
p_aout->output.pf_play = Play;
return VLC_SUCCESS;
}
/*****************************************************************************
* 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;
}
/*****************************************************************************
* Run: rtci thread
*****************************************************************************
* This part of the interface is in a separate thread so that we can call
* exec() from within it without annoying the rest of the program.
*****************************************************************************/
static void Run( intf_thread_t *p_intf )
{
input_thread_t * p_input;
playlist_t * p_playlist;
char p_buffer[ MAX_LINE_LENGTH + 1 ];
vlc_bool_t b_showpos = config_GetInt( p_intf, "rtci-show-pos" );
int i_size = 0;
int i_oldpos = 0;
int i_newpos;
p_buffer[0] = 0;
p_input = NULL;
p_playlist = NULL;
p_intf->p_sys->b_extend = config_GetInt( p_intf, "rtci-extend" );
/* Register commands that will be cleaned up upon object destruction */
var_Create( p_intf, "quit", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "quit", Quit, NULL );
var_Create( p_intf, "intf", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "intf", Intf, NULL );
var_Create( p_intf, "add", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "add", Playlist, NULL );
var_Create( p_intf, "playlist", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "playlist", Playlist, NULL );
var_Create( p_intf, "play", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "play", Playlist, NULL );
var_Create( p_intf, "stop", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "stop", Playlist, NULL );
var_Create( p_intf, "prev", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "prev", Playlist, NULL );
var_Create( p_intf, "next", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "next", Playlist, NULL );
var_Create( p_intf, "marq-marquee", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "marq-marquee", Other, NULL );
var_Create( p_intf, "marq-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "marq-x", Other, NULL );
var_Create( p_intf, "marq-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "marq-y", Other, NULL );
var_Create( p_intf, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "marq-timeout", Other, NULL );
var_Create( p_intf, "pause", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "pause", Input, NULL );
var_Create( p_intf, "seek", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "seek", Input, NULL );
var_Create( p_intf, "title", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "title", Input, NULL );
var_Create( p_intf, "title_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "title_n", Input, NULL );
var_Create( p_intf, "title_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "title_p", Input, NULL );
var_Create( p_intf, "chapter", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "chapter", Input, NULL );
var_Create( p_intf, "chapter_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "chapter_n", Input, NULL );
var_Create( p_intf, "chapter_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "chapter_p", Input, NULL );
var_Create( p_intf, "volume", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "volume", Volume, NULL );
var_Create( p_intf, "volup", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "volup", VolumeMove, NULL );
var_Create( p_intf, "voldown", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "voldown", VolumeMove, NULL );
var_Create( p_intf, "adev", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "adev", AudioConfig, NULL );
var_Create( p_intf, "achan", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
var_AddCallback( p_intf, "achan", AudioConfig, NULL );
#ifdef WIN32
/* Get the file descriptor of the console input */
p_intf->p_sys->hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
if( p_intf->p_sys->hConsoleIn == INVALID_HANDLE_VALUE )
{
msg_Err( p_intf, "Couldn't open STD_INPUT_HANDLE" );
p_intf->b_die = VLC_TRUE;
}
#endif
while( !p_intf->b_die )
{
char *psz_cmd, *psz_arg;
vlc_bool_t b_complete;
if( p_intf->p_sys->i_socket_listen != - 1 &&
p_intf->p_sys->i_socket == -1 )
{
p_intf->p_sys->i_socket =
net_Accept( p_intf, p_intf->p_sys->i_socket_listen, 0 );
}
b_complete = ReadCommand( p_intf, p_buffer, &i_size );
/* Manage the input part */
if( p_input == NULL )
{
if( p_playlist )
{
p_input = vlc_object_find( p_playlist, VLC_OBJECT_INPUT,
FIND_CHILD );
}
else
{
p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
FIND_ANYWHERE );
if( p_input )
{
p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
FIND_PARENT );
}
}
}
else if( p_input->b_dead )
{
vlc_object_release( p_input );
p_input = NULL;
}
if( p_input && b_showpos )
{
i_newpos = 100 * var_GetFloat( p_input, "position" );
if( i_oldpos != i_newpos )
{
i_oldpos = i_newpos;
msg_rtci( "pos: %d%%\n", i_newpos );
}
}
/* Is there something to do? */
if( !b_complete ) continue;
/* Skip heading spaces */
psz_cmd = p_buffer;
while( *psz_cmd == ' ' )
{
psz_cmd++;
}
/* Split psz_cmd at the first space and make sure that
* psz_arg is valid */
psz_arg = strchr( psz_cmd, ' ' );
if( psz_arg )
{
*psz_arg++ = 0;
while( *psz_arg == ' ' )
{
psz_arg++;
}
}
else
{
psz_arg = "";
}
/* If the user typed a registered local command, try it */
if( var_Type( p_intf, psz_cmd ) & VLC_VAR_ISCOMMAND )
{
vlc_value_t val;
int i_ret;
val.psz_string = psz_arg;
i_ret = var_Set( p_intf, psz_cmd, val );
msg_rtci( "%s: returned %i (%s)\n",
psz_cmd, i_ret, vlc_error( i_ret ) );
}
/* Or maybe it's a global command */
else if( var_Type( p_intf->p_libvlc, psz_cmd ) & VLC_VAR_ISCOMMAND )
{
vlc_value_t val;
int i_ret;
val.psz_string = psz_arg;
/* FIXME: it's a global command, but we should pass the
* local object as an argument, not p_intf->p_libvlc. */
i_ret = var_Set( p_intf->p_libvlc, psz_cmd, val );
if( i_ret != 0 )
{
msg_rtci( "%s: returned %i (%s)\n",
psz_cmd, i_ret, vlc_error( i_ret ) );
}
}
else if( !strcmp( psz_cmd, "logout" ) )
{
/* Close connection */
if( p_intf->p_sys->i_socket != -1 )
{
net_Close( p_intf->p_sys->i_socket );
}
p_intf->p_sys->i_socket = -1;
}
else if( !strcmp( psz_cmd, "info" ) )
{
if( p_input )
{
int i, j;
vlc_mutex_lock( &p_input->input.p_item->lock );
for ( i = 0; i < p_input->input.p_item->i_categories; i++ )
{
info_category_t *p_category =
p_input->input.p_item->pp_categories[i];
msg_rtci( "+----[ %s ]\n", p_category->psz_name );
msg_rtci( "| \n" );
for ( j = 0; j < p_category->i_infos; j++ )
{
info_t *p_info = p_category->pp_infos[j];
msg_rtci( "| %s: %s\n", p_info->psz_name,
p_info->psz_value );
}
msg_rtci( "| \n" );
}
msg_rtci( "+----[ end of stream info ]\n" );
vlc_mutex_unlock( &p_input->input.p_item->lock );
}
else
{
msg_rtci( "no input\n" );
}
}
else if( !strcmp( psz_cmd, "is_playing" ) )
{
if( ! p_input )
{
msg_rtci( "0\n" );
}
else
{
msg_rtci( "1\n" );
}
}
else if( !strcmp( psz_cmd, "get_time" ) )
{
if( ! p_input )
{
msg_rtci("0\n");
}
else
{
vlc_value_t time;
var_Get( p_input, "time", &time );
msg_rtci( "%i\n", time.i_time / 1000000);
}
}
else if( !strcmp( psz_cmd, "get_length" ) )
{
if( ! p_input )
{
msg_rtci("0\n");
}
else
{
vlc_value_t time;
var_Get( p_input, "length", &time );
msg_rtci( "%i\n", time.i_time / 1000000);
}
}
else if( !strcmp( psz_cmd, "get_title" ) )
{
if( ! p_input )
{
msg_rtci("\n");
}
else
{
msg_rtci( "%s\n", p_input->input.p_item->psz_name );
}
}
else switch( psz_cmd[0] )
{
case 'f':
case 'F':
if( p_input )
{
vout_thread_t *p_vout;
p_vout = vlc_object_find( p_input,
VLC_OBJECT_VOUT, FIND_CHILD );
if( p_vout )
{
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
vlc_object_release( p_vout );
}
}
break;
case 's':
case 'S':
;
break;
case '?':
case 'h':
case 'H':
msg_rtci(_("+----[ Remote control commands ]\n"));
msg_rtci("| \n");
msg_rtci(_("| add XYZ . . . . . . . . . . add XYZ to playlist\n"));
msg_rtci(_("| playlist . . . show items currently in playlist\n"));
msg_rtci(_("| play . . . . . . . . . . . . . . . . play stream\n"));
msg_rtci(_("| stop . . . . . . . . . . . . . . . . stop stream\n"));
msg_rtci(_("| next . . . . . . . . . . . . next playlist item\n"));
msg_rtci(_("| prev . . . . . . . . . . previous playlist item\n"));
msg_rtci(_("| title [X] . . . . set/get title in current item\n"));
msg_rtci(_("| title_n . . . . . . next title in current item\n"));
msg_rtci(_("| title_p . . . . previous title in current item\n"));
msg_rtci(_("| chapter [X] . . set/get chapter in current item\n"));
msg_rtci(_("| chapter_n . . . . next chapter in current item\n"));
msg_rtci(_("| chapter_p . . previous chapter in current item\n"));
msg_rtci("| \n");
msg_rtci(_("| seek X . seek in seconds, for instance `seek 12'\n"));
msg_rtci(_("| pause . . . . . . . . . . . . . . toggle pause\n"));
msg_rtci(_("| f . . . . . . . . . . . . . . toggle fullscreen\n"));
msg_rtci(_("| info . . . information about the current stream\n"));
msg_rtci("| \n");
msg_rtci(_("| volume [X] . . . . . . . . set/get audio volume\n"));
msg_rtci(_("| volup [X] . . . . . raise audio volume X steps\n"));
msg_rtci(_("| voldown [X] . . . . lower audio volume X steps\n"));
msg_rtci(_("| adev [X] . . . . . . . . . set/get audio device\n"));
msg_rtci(_("| achan [X]. . . . . . . . set/get audio channels\n"));
msg_rtci("| \n");
if (p_intf->p_sys->b_extend)
{
msg_rtci(_("| marq-marquee STRING . . overlay STRING in video\n"));
msg_rtci(_("| marq-x X . . . . . .offset of marquee, from left\n"));
msg_rtci(_("| marq-y Y . . . . . . offset of marquee, from top\n"));
msg_rtci(_("| marq-timeout T. . . . .timeout of marquee, in ms\n"));
msg_rtci("| \n");
}
msg_rtci(_("| help . . . . . . . . . . . . . this help message\n"));
msg_rtci(_("| logout . . . . . .exit (if in socket connection)\n"));
msg_rtci(_("| quit . . . . . . . . . . . . . . . . . quit vlc\n"));
msg_rtci("| \n");
msg_rtci(_("+----[ end of help ]\n"));
break;
case '\0':
/* Ignore empty lines */
break;
default:
msg_rtci(_("unknown command `%s', type `help' for help\n"), psz_cmd);
break;
}
/* Command processed */
i_size = 0; p_buffer[0] = 0;
}
if( p_input )
{
vlc_object_release( p_input );
p_input = NULL;
}
if( p_playlist )
{
vlc_object_release( p_playlist );
p_playlist = NULL;
}
}
static void test_creation_and_type( libvlc_int_t *p_libvlc )
{
vlc_value_t val;
val.i_int = 4212;
var_Create( p_libvlc, "bla", VLC_VAR_INTEGER );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER) );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER) );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND) );
var_Change( p_libvlc, "bla", VLC_VAR_SETMIN, &val, NULL );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN) );
var_Change( p_libvlc, "bla", VLC_VAR_SETMAX, &val, NULL );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN | VLC_VAR_HASMAX) );
var_Change( p_libvlc, "bla", VLC_VAR_SETSTEP, &val, NULL );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN | VLC_VAR_HASMAX | VLC_VAR_HASSTEP) );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );
var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER) );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND) );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE) );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );
var_Create( p_libvlc, "bla", VLC_VAR_INTEGER );
var_Change( p_libvlc, "bla", VLC_VAR_SETMIN, &val, NULL );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN) );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN | VLC_VAR_HASCHOICE) );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );
var_Create( p_libvlc, "bla", VLC_VAR_INTEGER );
var_Change( p_libvlc, "bla", VLC_VAR_SETMAX, &val, NULL );
var_Change( p_libvlc, "bla", VLC_VAR_SETSTEP, &val, NULL );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMAX | VLC_VAR_HASSTEP) );
assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ) == VLC_SUCCESS );
assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMAX | VLC_VAR_HASSTEP | VLC_VAR_HASCHOICE) );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
var_Destroy( p_libvlc, "bla" );
assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );
}
static int vlclua_add_callback( lua_State *L )
{
vlclua_callback_t *p_callback;
static int i_index = 0;
vlc_object_t **pp_obj = luaL_checkudata( L, 1, "vlc_object" );
const char *psz_var = luaL_checkstring( L, 2 );
lua_settop( L, 4 ); /* makes sure that optional data arg is set */
if( !lua_isfunction( L, 3 ) )
return vlclua_error( L );
if( !pp_obj || !*pp_obj )
return vlclua_error( L );
/* Check variable type, in order to avoid PANIC */
switch( var_Type( *pp_obj, psz_var ) )
{
case VLC_VAR_BOOL:
case VLC_VAR_INTEGER:
case VLC_VAR_STRING:
case VLC_VAR_FLOAT:
case VLC_VAR_TIME:
break;
case VLC_VAR_ADDRESS:
case VLC_VAR_VOID:
case VLC_VAR_MUTEX:
case VLC_VAR_LIST:
default:
return vlclua_error( L );
}
i_index++;
p_callback = (vlclua_callback_t*)malloc( sizeof( vlclua_callback_t ) );
if( !p_callback )
return vlclua_error( L );
/* obj var func data */
lua_getglobal( L, "vlc" );
/* obj var func data vlc */
lua_getfield( L, -1, "callbacks" );
if( lua_isnil( L, -1 ) )
{
lua_pop( L, 1 );
lua_newtable( L );
lua_setfield( L, -2, "callbacks" );
lua_getfield( L, -1, "callbacks" );
}
/* obj var func data vlc callbacks */
lua_remove( L, -2 );
/* obj var func data callbacks */
lua_pushinteger( L, i_index );
/* obj var func data callbacks index */
lua_insert( L, -4 );
/* obj var index func data callbacks */
lua_insert( L, -4 );
/* obj var callbacks index func data */
lua_createtable( L, 0, 0 );
/* obj var callbacks index func data cbtable */
lua_insert( L, -2 );
/* obj var callbacks index func cbtable data */
lua_setfield( L, -2, "data" );
/* obj var callbacks index func cbtable */
lua_insert( L, -2 );
/* obj var callbacks index cbtable func */
lua_setfield( L, -2, "callback" );
/* obj var callbacks index cbtable */
lua_pushlightuserdata( L, *pp_obj ); /* will be needed in vlclua_del_callback */
/* obj var callbacks index cbtable p_obj */
lua_setfield( L, -2, "private1" );
/* obj var callbacks index cbtable */
lua_pushvalue( L, 2 ); /* will be needed in vlclua_del_callback */
/* obj var callbacks index cbtable var */
lua_setfield( L, -2, "private2" );
/* obj var callbacks index cbtable */
lua_pushlightuserdata( L, p_callback ); /* will be needed in vlclua_del_callback */
/* obj var callbacks index cbtable p_callback */
lua_setfield( L, -2, "private3" );
/* obj var callbacks index cbtable */
lua_settable( L, -3 );
/* obj var callbacks */
lua_pop( L, 3 );
/* <empty stack> */
/* Do not move this before the lua specific code (it somehow changes
* the function in the stack to nil) */
p_callback->i_index = i_index;
p_callback->i_type = var_Type( *pp_obj, psz_var );
p_callback->L = lua_newthread( L ); /* Do we have to keep a reference to this thread somewhere to prevent garbage collection? */
var_AddCallback( *pp_obj, psz_var, vlclua_callback, p_callback );
return 0;
}
