void ExtraPanel::OnEqRestore( wxCommandEvent &event )
{
aout_instance_t *p_aout= (aout_instance_t *)vlc_object_find(p_intf,
VLC_OBJECT_AOUT, FIND_ANYWHERE);
if( p_aout == NULL )
{
vlc_value_t val;
vlc_bool_t b_previous = eq_chkbox->IsChecked();
val.f_float = 12.0;
IntfPreampCallback( NULL, NULL, val,val, this );
config_PutFloat( p_intf, "equalizer-preamp", 12.0 );
val.psz_string = strdup( "0 0 0 0 0 0 0 0 0 0" );
IntfBandsCallback( NULL, NULL, val,val, this );
config_PutPsz( p_intf, "equalizer-bands",
"0 0 0 0 0 0 0 0 0 0");
config_PutPsz( p_intf, "equalizer-preset","flat" );
eq_chkbox->SetValue( b_previous );
}
else
{
var_SetFloat( p_aout, "equalizer-preamp", 12.0 );
config_PutFloat( p_intf, "equalizer-preamp", 12.0 );
var_SetString( p_aout, "equalizer-bands",
"0 0 0 0 0 0 0 0 0 0");
config_PutPsz( p_intf, "equalizer-bands",
"0 0 0 0 0 0 0 0 0 0");
var_SetString( p_aout , "equalizer-preset" , "flat" );
config_PutPsz( p_intf, "equalizer-preset","flat" );
vlc_object_release( p_aout );
}
}
void
libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, char *psz_filepath,
unsigned int i_width, unsigned int i_height, libvlc_exception_t *p_e )
{
vout_thread_t *p_vout = GetVout( p_mi, p_e );
input_thread_t *p_input_thread;
/* GetVout will raise the exception for us */
if( !p_vout ) return;
if( !psz_filepath )
{
libvlc_exception_raise( p_e, "filepath is null" );
return;
}
var_SetInteger( p_vout, "snapshot-width", i_width );
var_SetInteger( p_vout, "snapshot-height", i_height );
p_input_thread = p_mi->p_input_thread;
if( !p_mi->p_input_thread )
{
libvlc_exception_raise( p_e, "Input does not exist" );
return;
}
var_SetString( p_vout, "snapshot-path", psz_filepath );
var_SetString( p_vout, "snapshot-format", "png" );
vout_Control( p_vout, VOUT_SNAPSHOT );
vlc_object_release( p_vout );
}
/**
* Allocates a whole server's TLS credentials.
*
* @param cert_path required (Unicode) path to an x509 certificate,
* if NULL, anonymous key exchange will be used.
* @param key_path (UTF-8) path to the PKCS private key for the certificate,
* if NULL; cert_path will be used.
*
* @return NULL on error.
*/
vlc_tls_creds_t *
vlc_tls_ServerCreate (vlc_object_t *obj, const char *cert_path,
const char *key_path)
{
vlc_tls_creds_t *srv = vlc_custom_create (obj, sizeof (*srv), "tls creds");
if (unlikely(srv == NULL))
return NULL;
var_Create (srv, "tls-x509-cert", VLC_VAR_STRING);
var_Create (srv, "tls-x509-key", VLC_VAR_STRING);
if (cert_path != NULL)
{
var_SetString (srv, "tls-x509-cert", cert_path);
if (key_path == NULL)
key_path = cert_path;
var_SetString (srv, "tls-x509-key", key_path);
}
srv->module = module_need (srv, "tls server", NULL, false );
if (srv->module == NULL)
{
msg_Err (srv, "TLS server plugin not available");
vlc_object_release (srv);
return NULL;
}
msg_Dbg (srv, "TLS server plugin initialized");
return srv;
}
int
libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, unsigned num,
const char *psz_filepath,
unsigned int i_width, unsigned int i_height )
{
assert( psz_filepath );
vout_thread_t *p_vout = GetVout (p_mi, num);
if (p_vout == NULL)
return -1;
/* FIXME: This is not atomic. All parameters should be passed at once
* (obviously _not_ with var_*()). Also, the libvlc object should not be
* used for the callbacks: that breaks badly if there are concurrent
* media players in the instance. */
var_Create( p_vout, "snapshot-width", VLC_VAR_INTEGER );
var_SetInteger( p_vout, "snapshot-width", i_width);
var_Create( p_vout, "snapshot-height", VLC_VAR_INTEGER );
var_SetInteger( p_vout, "snapshot-height", i_height );
var_Create( p_vout, "snapshot-path", VLC_VAR_STRING );
var_SetString( p_vout, "snapshot-path", psz_filepath );
var_Create( p_vout, "snapshot-format", VLC_VAR_STRING );
var_SetString( p_vout, "snapshot-format", "png" );
var_TriggerCallback( p_vout, "video-snapshot" );
vlc_object_release( p_vout );
return 0;
}
int libvlc_media_player_set_equalizer( libvlc_media_player_t *p_mi, libvlc_equalizer_t *p_equalizer )
{
char bands[EQZ_BANDS_MAX * EQZ_BAND_VALUE_SIZE + 1];
if( p_equalizer != NULL )
{
for( unsigned i = 0, c = 0; i < EQZ_BANDS_MAX; i++ )
{
c += snprintf( bands + c, sizeof(bands) - c, " %.07f",
p_equalizer->f_amp[i] );
if( unlikely(c >= sizeof(bands)) )
return -1;
}
var_SetFloat( p_mi, "equalizer-preamp", p_equalizer->f_preamp );
var_SetString( p_mi, "equalizer-bands", bands );
}
var_SetString( p_mi, "audio-filter", p_equalizer ? "equalizer" : "" );
audio_output_t *p_aout = input_resource_HoldAout( p_mi->input.p_resource );
if( p_aout != NULL )
{
if( p_equalizer != NULL )
{
var_SetFloat( p_aout, "equalizer-preamp", p_equalizer->f_preamp );
var_SetString( p_aout, "equalizer-bands", bands );
}
var_SetString( p_aout, "audio-filter", p_equalizer ? "equalizer" : "" );
vlc_object_release( p_aout );
}
return 0;
}
static void test_strings( libvlc_int_t *p_libvlc )
{
int i;
char *psz_tmp;
for( i = 0; i < i_var_count; i++ )
var_Create( p_libvlc, psz_var_name[i], VLC_VAR_STRING );
for( i = 0; i < i_var_count; i++ )
var_SetString( p_libvlc, psz_var_name[i], psz_var_name[i] );
for( i = 0; i < i_var_count; i++ )
{
psz_tmp = var_GetString( p_libvlc, psz_var_name[i] );
assert( !strcmp( psz_tmp, psz_var_name[i] ) );
free( psz_tmp );
}
for( i = 0; i < i_var_count; i++ )
var_Destroy( p_libvlc, psz_var_name[i] );
/* Some more test for strings */
var_Create( p_libvlc, "bla", VLC_VAR_STRING );
assert( var_GetNonEmptyString( p_libvlc, "bla" ) == NULL );
var_SetString( p_libvlc, "bla", "" );
assert( var_GetNonEmptyString( p_libvlc, "bla" ) == NULL );
var_SetString( p_libvlc, "bla", "test" );
psz_tmp = var_GetNonEmptyString( p_libvlc, "bla" );
assert( !strcmp( psz_tmp, "test" ) );
free( psz_tmp );
var_Destroy( p_libvlc, "bla" );
}
void libvlc_set_user_agent (libvlc_instance_t *p_i,
const char *name, const char *http)
{
libvlc_int_t *p_libvlc = p_i->p_libvlc_int;
var_SetString (p_libvlc, "user-agent", name);
if (http != NULL)
var_SetString (p_libvlc, "http-user-agent", http);
}
/**************************************************************************
* set_xwindow
**************************************************************************/
void libvlc_media_player_set_xwindow( libvlc_media_player_t *p_mi,
uint32_t drawable )
{
assert (p_mi != NULL);
var_SetString (p_mi, "vout", drawable ? "xid" : "any");
var_SetString (p_mi, "window", drawable ? "embed-xid,any" : "any");
var_SetInteger (p_mi, "drawable-xid", drawable);
}
void libvlc_set_app_id(libvlc_instance_t *p_i, const char *id,
const char *version, const char *icon)
{
libvlc_int_t *p_libvlc = p_i->p_libvlc_int;
var_SetString(p_libvlc, "app-id", id ? id : "");
var_SetString(p_libvlc, "app-version", version ? version : "");
var_SetString(p_libvlc, "app-icon-name", icon ? icon : "");
}
void libvlc_video_set_callbacks( libvlc_media_player_t *mp,
void *(*lock_cb) (void *, void **),
void (*unlock_cb) (void *, void *, void *const *),
void (*display_cb) (void *, void *),
void *opaque )
{
var_SetAddress( mp, "vmem-lock", lock_cb );
var_SetAddress( mp, "vmem-unlock", unlock_cb );
var_SetAddress( mp, "vmem-display", display_cb );
var_SetAddress( mp, "vmem-data", opaque );
var_SetString( mp, "vout", "vmem" );
var_SetString( mp, "avcodec-hw", "none" );
}
void libvlc_set_user_agent (libvlc_instance_t *p_i,
const char *name, const char *http)
{
libvlc_int_t *p_libvlc = p_i->p_libvlc_int;
char *str;
var_SetString (p_libvlc, "user-agent", name);
if ((http != NULL)
&& (asprintf (&str, "%s LibVLC/"PACKAGE_VERSION, http) != -1))
{
var_SetString (p_libvlc, "http-user-agent", str);
free (str);
}
}
bool VLCVarChoiceModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (!m_object->get())
return false;
int row = index.row();
if (role == Qt::CheckStateRole && row >= 0 && row < m_values.count())
{
//only update the variable when we select an entry
if (!value.toBool())
return false;
int ret = VLC_EGENERIC;
switch (m_type & VLC_VAR_CLASS) {
case VLC_VAR_STRING:
ret = var_SetString(m_object->get(), qtu(m_varname), qtu(m_values[row].toString()) );
break;
case VLC_VAR_INTEGER:
ret = var_SetInteger(m_object->get(), qtu(m_varname), m_values[row].toInt() );
break;
case VLC_VAR_FLOAT:
ret = var_SetFloat(m_object->get(), qtu(m_varname), m_values[row].toFloat() );
break;
case VLC_VAR_BOOL:
ret = var_SetBool(m_object->get(), qtu(m_varname), m_values[row].toBool() );
break;
default:
break;
}
return ret == VLC_SUCCESS;
}
return false;
}
void libvlc_audio_set_format( libvlc_media_player_t *mp, const char *format,
unsigned rate, unsigned channels )
{
var_SetString( mp, "amem-format", format );
var_SetInteger( mp, "amem-rate", rate );
var_SetInteger( mp, "amem-channels", channels );
}
/***********************
* Set the audio output.
***********************/
int libvlc_audio_output_set( libvlc_media_player_t *mp, const char *psz_name )
{
if( !module_exists( psz_name ) )
return -1;
var_SetString( mp, "aout", psz_name );
return 0;
}
static int DeinterlaceCallback(vlc_object_t *object, char const *cmd,
vlc_value_t oldval, vlc_value_t newval, void *data)
{
VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(newval); VLC_UNUSED(data);
vout_thread_t *vout = (vout_thread_t *)object;
/* */
const int deinterlace_state = var_GetInteger(vout, "deinterlace");
char *mode = var_GetString(vout, "deinterlace-mode");
const bool is_needed = var_GetBool(vout, "deinterlace-needed");
if (!mode || !DeinterlaceIsModeValid(mode))
{
free(mode);
return VLC_EGENERIC;
}
/* */
char *old = var_CreateGetString(vout, "sout-deinterlace-mode");
var_SetString(vout, "sout-deinterlace-mode", mode);
msg_Dbg(vout, "deinterlace %d, mode %s, is_needed %d", deinterlace_state, mode, is_needed);
if (deinterlace_state == 0 || (deinterlace_state < 0 && !is_needed))
vout_control_PushBool(&vout->p->control,
VOUT_CONTROL_CHANGE_INTERLACE, false);
else
vout_control_PushBool(&vout->p->control,
VOUT_CONTROL_CHANGE_INTERLACE, true);
/* */
free(old);
free(mode);
return VLC_SUCCESS;
}
static void DeinterlaceAdd(vout_thread_t *vout)
{
char *filter = var_GetNonEmptyString(vout, "video-filter");
if (FilterFind(filter, "deinterlace")) {
free(filter);
return;
}
/* */
if (filter) {
char *tmp = filter;
if (asprintf(&filter, "%s:%s", tmp, "deinterlace") < 0)
filter = tmp;
else
free(tmp);
} else {
filter = strdup("deinterlace");
}
if (filter) {
var_SetString(vout, "video-filter", filter);
free(filter);
}
}
/*****************************
* 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 int DeinterlaceCallback(vlc_object_t *object, char const *cmd,
vlc_value_t oldval, vlc_value_t newval, void *data)
{
VLC_UNUSED(cmd); VLC_UNUSED(oldval); VLC_UNUSED(newval); VLC_UNUSED(data);
vout_thread_t *vout = (vout_thread_t *)object;
/* */
const int deinterlace_state = var_GetInteger(vout, "deinterlace");
char *mode = var_GetString(vout, "deinterlace-mode");
const bool is_needed = var_GetBool(vout, "deinterlace-needed");
if (!mode || !DeinterlaceIsModeValid(mode))
return VLC_EGENERIC;
/* */
char *old = var_CreateGetString(vout, "sout-deinterlace-mode");
var_SetString(vout, "sout-deinterlace-mode", mode);
msg_Dbg(vout, "deinterlace %d, mode %s, is_needed %d", deinterlace_state, mode, is_needed);
if (deinterlace_state == 0 || (deinterlace_state == -1 && !is_needed))
DeinterlaceRemove(vout);
else if (!DeinterlaceIsPresent(vout))
DeinterlaceAdd(vout);
else if (old && strcmp(old, mode))
var_TriggerCallback(vout, "video-filter");
/* */
free(old);
free(mode);
return VLC_SUCCESS;
}
static void ChangeVFiltersString( intf_thread_t *p_intf,
char *psz_name, vlc_bool_t b_add )
{
vout_thread_t *p_vout;
char *psz_parser, *psz_string;
psz_string = config_GetPsz( p_intf, "filter" );
if( !psz_string ) psz_string = strdup("");
psz_parser = strstr( psz_string, psz_name );
if( b_add )
{
if( !psz_parser )
{
psz_parser = psz_string;
asprintf( &psz_string, (*psz_string) ? "%s:%s" : "%s%s",
psz_string, psz_name );
free( psz_parser );
}
else
{
return;
}
}
else
{
if( psz_parser )
{
memmove( psz_parser, psz_parser + strlen(psz_name) +
(*(psz_parser + strlen(psz_name)) == ':' ? 1 : 0 ),
strlen(psz_parser + strlen(psz_name)) + 1 );
/* Remove trailing : : */
if( *(psz_string+strlen(psz_string ) -1 ) == ':' )
{
*(psz_string+strlen(psz_string ) -1 ) = '\0';
}
}
else
{
free( psz_string );
return;
}
}
/* Vout is not kept, so put that in the config */
config_PutPsz( p_intf, "filter", psz_string );
/* Try to set on the fly */
p_vout = (vout_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_VOUT,
FIND_ANYWHERE );
if( p_vout )
{
var_SetString( p_vout, "filter", psz_string );
vlc_object_release( p_vout );
}
free( psz_string );
}
void EqualizerBands::onUpdate( Subject<VarPercent> &rBand, void *arg )
{
// Make sure we are not called from set()
if (!m_isUpdating)
{
float val;
stringstream ss;
// Write one digit after the floating point
ss << setprecision( 1 ) << setiosflags( ios::fixed );
// Convert the band values to a string
val = 40 * ((VarPercent*)m_cBands[0].get())->get() - 20;
ss << val;
for( int i = 1; i < kNbBands; i++ )
{
val = 40 * ((VarPercent*)m_cBands[i].get())->get() - 20;
ss << " " << val;
}
string bands = ss.str();
aout_instance_t *pAout = (aout_instance_t *)vlc_object_find( getIntf(),
VLC_OBJECT_AOUT, FIND_ANYWHERE );
config_PutPsz( getIntf(), "equalizer-bands", bands.c_str() );
if( pAout )
{
// Update the audio output
var_SetString( pAout, "equalizer-bands", (char*)bands.c_str() );
vlc_object_release( pAout );
}
}
}
static int transcode_audio_initialize_filters( sout_stream_t *p_stream, sout_stream_id_t *id, sout_stream_sys_t *p_sys, audio_sample_format_t *fmt_last )
{
/* Load user specified audio filters */
/* XXX: These variable names come kinda out of nowhere... */
var_Create( p_stream, "audio-time-stretch", VLC_VAR_BOOL );
var_Create( p_stream, "audio-filter", VLC_VAR_STRING );
if( p_sys->psz_af )
var_SetString( p_stream, "audio-filter", p_sys->psz_af );
id->p_af_chain = aout_FiltersNew( p_stream, fmt_last,
&id->p_encoder->fmt_in.audio, NULL );
var_Destroy( p_stream, "audio-filter" );
var_Destroy( p_stream, "audio-time-stretch" );
if( id->p_af_chain == NULL )
{
msg_Err( p_stream, "Unable to initialize audio filters" );
module_unneed( id->p_encoder, id->p_encoder->p_module );
id->p_encoder->p_module = NULL;
module_unneed( id->p_decoder, id->p_decoder->p_module );
id->p_decoder->p_module = NULL;
return VLC_EGENERIC;
}
p_sys->fmt_audio.i_rate = fmt_last->i_rate;
p_sys->fmt_audio.i_physical_channels = fmt_last->i_physical_channels;
return VLC_SUCCESS;
}
static int EqualizerCallback( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
aout_instance_t *p_aout = (aout_instance_t *)p_this;
char *psz_mode = newval.psz_string;
int i_ret;
(void)psz_cmd; (void)oldval; (void)p_data;
if( !psz_mode || !*psz_mode )
{
i_ret = ChangeFiltersString( p_aout, "audio-filter", "equalizer",
false );
}
else
{
var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING );
var_SetString( p_aout, "equalizer-preset", psz_mode );
i_ret = ChangeFiltersString( p_aout, "audio-filter", "equalizer",
true );
}
/* That sucks */
if( i_ret == 1 )
AoutInputsMarkToRestart( p_aout );
return VLC_SUCCESS;
}
static void RegisterIntf( intf_thread_t *p_this )
{
playlist_t *pl = p_this->p_sys->p_playlist;
var_Create (pl, "qt4-iface", VLC_VAR_ADDRESS);
var_SetAddress (pl, "qt4-iface", p_this);
var_Create (pl, "window", VLC_VAR_STRING);
var_SetString (pl, "window", "qt4,any");
}
void libvlc_video_set_format( libvlc_media_player_t *mp, const char *chroma,
unsigned width, unsigned height, unsigned pitch )
{
var_SetString( mp, "vmem-chroma", chroma );
var_SetInteger( mp, "vmem-width", width );
var_SetInteger( mp, "vmem-height", height );
var_SetInteger( mp, "vmem-pitch", pitch );
}
static int OutputNew( sout_stream_t *p_stream,
const char *psz_muxer, const char *psz_prefix, const char *psz_extension )
{
sout_stream_sys_t *p_sys = p_stream->p_sys;
char *psz_file = NULL;
char *psz_output = NULL;
int i_count;
if( asprintf( &psz_file, "%s%s%s",
psz_prefix, psz_extension ? "." : "", psz_extension ? psz_extension : "" ) < 0 )
{
psz_file = NULL;
goto error;
}
if( asprintf( &psz_output, "std{access=file,mux='%s',dst='%s'}",
psz_muxer, psz_file ) < 0 )
{
psz_output = NULL;
goto error;
}
/* Create the output */
msg_Dbg( p_stream, "Using record output `%s'", psz_output );
p_sys->p_out = sout_StreamChainNew( p_stream->p_sout, psz_output, NULL, NULL );
if( !p_sys->p_out )
goto error;
/* Add es */
i_count = 0;
for( int i = 0; i < p_sys->i_id; i++ )
{
sout_stream_id_t *id = p_sys->id[i];
id->id = sout_StreamIdAdd( p_sys->p_out, &id->fmt );
if( id->id )
i_count++;
}
if( psz_file && psz_extension )
var_SetString( p_stream->p_libvlc, "record-file", psz_file );
free( psz_file );
free( psz_output );
return i_count;
error:
free( psz_file );
free( psz_output );
return -1;
}
/*****************************************************************************
* Set the equalizer level for the specified band
*****************************************************************************/
static int vlclua_equalizer_set( lua_State *L )
{
int bandid = luaL_checknumber( L, 1 );
if( bandid < 0 || bandid > 9)
return 0;
input_thread_t *p_input = vlclua_get_input_internal( L );
if( !p_input )
return 0;
audio_output_t *p_aout = input_GetAout( p_input );
vlc_object_release( p_input );
if( !p_aout )
return 0;
char *psz_af = var_GetNonEmptyString( p_aout, "audio-filter" );
if( !psz_af || strstr ( psz_af, "equalizer" ) == NULL )
{
free( psz_af );
vlc_object_release( p_aout );
return 0;
}
free( psz_af );
float level = luaL_checknumber( L, 2 );
char *bands = var_GetString( p_aout, "equalizer-bands" );
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t oldloc = uselocale (loc);
char *b = bands;
while( bandid > 0 )
{
float dummy = strtof( b, &b );
(void)dummy;
bandid--;
}
if( *b != '\0' )
*b++ = '\0';
float dummy = strtof( b, &b );
(void)dummy;
char *newstr;
if( asprintf( &newstr, "%s %.1f%s", bands, level, b ) != -1 )
{
var_SetString( p_aout, "equalizer-bands", newstr );
free( newstr );
}
if( loc != (locale_t)0 )
{
uselocale (oldloc);
freelocale (loc);
}
free( bands );
vlc_object_release( p_aout );
return 0;
}
void AspectRatioComboBox::updateAspectRatio( int x )
{
vout_thread_t* p_vout = THEMIM->getVout();
if( p_vout && x >= 0 )
{
var_SetString( p_vout, "aspect-ratio", qtu( itemData(x).toString() ) );
}
if( p_vout )
vlc_object_release( p_vout );
}
void libvlc_audio_set_callbacks( libvlc_media_player_t *mp,
libvlc_audio_play_cb play_cb,
libvlc_audio_set_volume_cb set_volume_cb,
void *opaque )
{
var_SetAddress( mp, "amem-play", play_cb );
var_SetAddress( mp, "amem-set-volume", set_volume_cb );
var_SetAddress( mp, "amem-data", opaque );
var_SetString( mp, "aout", "amem" );
}
/**********************************************************************
* 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;
}
int
libvlc_video_take_snapshot( libvlc_media_player_t *p_mi, unsigned num,
const char *psz_filepath,
unsigned int i_width, unsigned int i_height )
{
assert( psz_filepath );
vout_thread_t *p_vout = GetVout (p_mi, num);
if (p_vout == NULL)
return -1;
/* FIXME: This is not atomic. Someone else could change the values,
* at least in theory. */
var_SetInteger( p_vout, "snapshot-width", i_width);
var_SetInteger( p_vout, "snapshot-height", i_height );
var_SetString( p_vout, "snapshot-path", psz_filepath );
var_SetString( p_vout, "snapshot-format", "png" );
var_TriggerCallback (p_vout, "video-snapshot" );
return 0;
}
