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; }