自学教程：C++ var_SetString函数代码示例

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

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

intlibvlc_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" );}

/************************************************************************** * 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 );}

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