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

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

int libvlc_media_player_set_rate( libvlc_media_player_t *p_mi, float rate ){    var_SetFloat (p_mi, "rate", rate);    input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );    if( !p_input_thread )        return 0;    var_SetFloat( p_input_thread, "rate", rate );    vlc_object_release( p_input_thread );    return 0;}

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 CmdPlay::execute(){    playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;    if( pPlaylist == NULL )        return;    // if already playing an input, reset rate to normal speed    input_thread_t *pInput = playlist_CurrentInput( pPlaylist );    if( pInput )    {        var_SetFloat( pPlaylist, "rate", 1.0 );        vlc_object_release( pInput );    }    playlist_Lock( pPlaylist );    const bool b_empty = playlist_IsEmpty( pPlaylist );    playlist_Unlock( pPlaylist );    if( !b_empty )    {        playlist_Play( pPlaylist );    }    else    {        // If the playlist is empty, open a file requester instead        CmdDlgFile( getIntf() ).execute();    }}

/***************************************************************************** * Object variables callbacks *****************************************************************************/static int ZoomCallback( vlc_object_t *p_this, char const *psz_cmd,                         vlc_value_t oldval, vlc_value_t newval, void *p_data ){    (void)psz_cmd; (void)oldval; (void)p_data;    return var_SetFloat( p_this, "scale", newval.f_float );}

static int PositionCallback( vlc_object_t *p_this, char const *psz_cmd,                             vlc_value_t oldval, vlc_value_t newval,                             void *p_data ){    input_thread_t *p_input = (input_thread_t*)p_this;    VLC_UNUSED(oldval); VLC_UNUSED(p_data);    if( !strcmp( psz_cmd, "position-offset" ) )    {        float f_position = var_GetFloat( p_input, "position" ) + newval.f_float;        if( f_position < 0.f )            f_position = 0.f;        else if( f_position > 1.f )            f_position = 1.f;        var_SetFloat( p_this, "position", f_position );    }    else    {        /* Update "length" for better intf behaviour */        const int64_t i_length = var_GetInteger( p_input, "length" );        if( i_length > 0 && newval.f_float >= 0.f && newval.f_float <= 1.f )        {            vlc_value_t val;            val.i_int = i_length * newval.f_float;            var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL );        }        /* */        input_ControlPush( p_input, INPUT_CONTROL_SET_POSITION, &newval );    }    return VLC_SUCCESS;}

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 InputManager::reverse(){    if( hasInput() )    {        float f_rate_ = var_GetFloat( p_input, "rate" );        var_SetFloat( p_input, "rate", -f_rate_ );    }}

void StreamTime::set( float percentage, bool updateVLC ){    VarPercent::set( percentage );    // Avoid looping forever...    if( updateVLC && getIntf()->p_sys->p_input )        var_SetFloat( getIntf()->p_sys->p_input, "position", percentage );}

int libvlc_media_player_set_rate( libvlc_media_player_t *p_mi, float rate ){    if (rate < 0.)    {        libvlc_printerr ("Playing backward not supported");        return -1;    }    var_SetFloat (p_mi, "rate", rate);    input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );    if( !p_input_thread )        return 0;    var_SetFloat( p_input_thread, "rate", rate );    vlc_object_release( p_input_thread );    return 0;}

static void VariablesInit( playlist_t *p_playlist ){    /* These variables control updates */    var_Create( p_playlist, "intf-change", VLC_VAR_BOOL );    var_SetBool( p_playlist, "intf-change", true );    var_Create( p_playlist, "item-change", VLC_VAR_ADDRESS );    var_Create( p_playlist, "leaf-to-parent", VLC_VAR_INTEGER );    var_Create( p_playlist, "playlist-item-deleted", VLC_VAR_INTEGER );    var_SetInteger( p_playlist, "playlist-item-deleted", -1 );    var_Create( p_playlist, "playlist-item-append", VLC_VAR_ADDRESS );    var_Create( p_playlist, "input-current", VLC_VAR_ADDRESS );    /* Variables to control playback */    var_Create( p_playlist, "playlist-autostart", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "random", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_AddCallback( p_playlist, "random", RandomCallback, NULL );    var_Create( p_playlist, "repeat", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "loop", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "corks", VLC_VAR_INTEGER );    var_AddCallback( p_playlist, "corks", CorksCallback, NULL );    var_Create( p_playlist, "rate", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );    var_AddCallback( p_playlist, "rate", RateCallback, NULL );    var_Create( p_playlist, "rate-slower", VLC_VAR_VOID );    var_AddCallback( p_playlist, "rate-slower", RateOffsetCallback, NULL );    var_Create( p_playlist, "rate-faster", VLC_VAR_VOID );    var_AddCallback( p_playlist, "rate-faster", RateOffsetCallback, NULL );    var_Create( p_playlist, "video-splitter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_AddCallback( p_playlist, "video-splitter", VideoSplitterCallback, NULL );    /* sout variables */    var_Create( p_playlist, "sout", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "demux-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    /* */    var_Create( p_playlist, "album-art", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "metadata-network-access", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    /* Variables to preserve video output parameters */    var_Create( p_playlist, "fullscreen", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "video-on-top", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    var_Create( p_playlist, "video-wallpaper", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );    /* Audio output parameters */    var_Create( p_playlist, "audio-device", VLC_VAR_STRING );    var_Create( p_playlist, "mute", VLC_VAR_BOOL );    var_Create( p_playlist, "volume", VLC_VAR_FLOAT );    var_SetFloat( p_playlist, "volume", -1.f );}

/********************************************************************** * 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 void Run(intf_thread_t *intf){  intf_sys_t *sys = intf->p_sys;  int fd;  int canc = vlc_savecancel();  RegisterCallbacks(intf);  while(1) {    msg_Info(intf, "Creating IRC connection...");    fd = net_ConnectTCP(VLC_OBJECT(intf), sys->server, 6667);    if(fd == -1) {      msg_Err(intf, "Error connecting to server");      return;    }    msg_Info(intf, "Connected to server");    /* initialize context */    sys->fd = fd;    sys->line_loc = 0;    SendBufferInit(intf);    SendBufferAppend(intf, "NICK ");    SendBufferAppend(intf, sys->nick);    SendBufferAppend(intf, "/r/n");    SendBufferAppend(intf, "USER ");    SendBufferAppend(intf, sys->nick);    SendBufferAppend(intf, " 8 * vlc/r/n");    sys->playlist = pl_Get(intf);    #ifdef STOP_HACK    playlist_Pause(sys->playlist);    input_thread_t * input = playlist_CurrentInput(sys->playlist);    var_SetFloat(input, "position", 0.0);    #endif    EventLoop(fd, intf);    free(sys->send_buffer->buffer);    sleep(30);  }  free(sys);  vlc_restorecancel(canc);}

void libvlc_media_player_set_position( libvlc_media_player_t *p_mi,                                       float position ){    input_thread_t *p_input_thread;    p_input_thread = libvlc_get_input_thread ( p_mi );    if( !p_input_thread )        return;    var_SetFloat( p_input_thread, "position", position );    vlc_object_release( p_input_thread );}

static int PresetCallback( vlc_object_t *p_this, char const *psz_cmd,                         vlc_value_t oldval, vlc_value_t newval, void *p_data ){    aout_filter_sys_t *p_sys = (aout_filter_sys_t *)p_data;    aout_instance_t *p_aout = (aout_instance_t *)p_this;    char *psz_preset = newval.psz_string;    char psz_newbands[120];    memset( psz_newbands, 0, 120 );    if( *psz_preset && p_sys->i_band == 10 )    {        int i;        /* */        for( i = 0; eqz_preset_10b[i] != NULL; i++ )        {            if( !strcasecmp( eqz_preset_10b[i]->psz_name, psz_preset ) )            {                int j;                p_sys->f_gamp *= pow( 10, eqz_preset_10b[i]->f_preamp / 20.0 );                for( j = 0; j < p_sys->i_band; j++ )                {                    p_sys->f_amp[j] = EqzConvertdB(                                        eqz_preset_10b[i]->f_amp[j] );                    sprintf( psz_newbands, "%s %f", psz_newbands,                                         eqz_preset_10b[i]->f_amp[j] );                }                if( p_sys->b_first == VLC_FALSE )                {                    var_SetString( p_aout, "equalizer-bands", psz_newbands );                    var_SetFloat( p_aout, "equalizer-preamp",                                    eqz_preset_10b[i]->f_preamp );                }                else                {                    p_sys->psz_newbands = strdup( psz_newbands );                    p_sys->f_newpreamp = eqz_preset_10b[i]->f_preamp;                }                break;            }        }        if( eqz_preset_10b[i] == NULL )        {            msg_Err( p_aout, "equalizer preset '%s' not found", psz_preset );            msg_Dbg( p_aout, "full list:" );            for( i = 0; eqz_preset_10b[i] != NULL; i++ )                msg_Dbg( p_aout, "  - '%s'", eqz_preset_10b[i]->psz_name );        }    }    return VLC_SUCCESS;}

void ExtraPanel::OnNormvolSlider( wxScrollEvent &event ){    aout_instance_t *p_aout= (aout_instance_t *)vlc_object_find(p_intf,                                 VLC_OBJECT_AOUT, FIND_ANYWHERE);    if( p_aout != NULL )    {        var_SetFloat( p_aout, "norm-max-level", (float)event.GetPosition()/10 );        vlc_object_release( p_aout );    }    else    {        config_PutFloat( p_intf, "norm-max-level",                        (float)event.GetPosition()/10 );    }}

/** * Deinitializes an audio output module and destroys an audio output object. */void aout_Destroy (audio_output_t *aout){    aout_owner_t *owner = aout_owner (aout);    aout_OutputLock (aout);    module_unneed (aout, owner->module);    /* Protect against late call from intf.c */    aout->volume_set = NULL;    aout->mute_set = NULL;    aout_OutputUnlock (aout);    var_DelCallback (aout, "mute", var_Copy, aout->p_parent);    var_SetFloat (aout, "volume", -1.f);    var_DelCallback (aout, "volume", var_Copy, aout->p_parent);    vlc_object_release (aout);}

static void test_floats( libvlc_int_t *p_libvlc ){    int i;    for( i = 0; i < i_var_count; i++ )         var_Create( p_libvlc, psz_var_name[i], VLC_VAR_FLOAT );    for( i = 0; i < i_var_count; i++ )    {        var_value[i].f_float = rand();        var_SetFloat( p_libvlc, psz_var_name[i], var_value[i].f_float );    }    for( i = 0; i < i_var_count; i++ )        assert( var_GetFloat( p_libvlc, psz_var_name[i] ) == var_value[i].f_float );    for( i = 0; i < i_var_count; i++ )        var_Destroy( p_libvlc, psz_var_name[i] );}

static int RateOffsetCallback( vlc_object_t *p_this, char const *psz_cmd,                               vlc_value_t oldval, vlc_value_t newval, void *p_data ){    input_thread_t *p_input = (input_thread_t*)p_this;    VLC_UNUSED(oldval); VLC_UNUSED(p_data); VLC_UNUSED(newval);    static const float pf_rate[] = {        1.0/64, 1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0/3, 1.0/2, 2.0/3,        1.0/1,        3.0/2, 2.0/1, 3.0/1, 4.0/1, 8.0/1, 16.0/1, 32.0/1, 64.0/1,    };    const unsigned i_rate_count = sizeof(pf_rate)/sizeof(*pf_rate);    const float f_rate = var_GetFloat( p_input, "rate" );    /* Determine the factor closest to the current rate */    float f_error;    int i_idx;    for( unsigned i = 0; i < i_rate_count; i++ )    {        const float f_test_e = fabs( fabs( f_rate ) - pf_rate[i] );        if( i == 0 || f_test_e < f_error )        {            i_idx = i;            f_error = f_test_e;        }    }    assert( i_idx < (int)i_rate_count );    /* */    i_idx += strcmp( psz_cmd, "rate-faster" ) == 0 ? 1 : -1;    if( i_idx >= 0 && i_idx < (int)i_rate_count )    {        const float f_rate_min = (float)INPUT_RATE_DEFAULT / INPUT_RATE_MAX;        const float f_rate_max = (float)INPUT_RATE_DEFAULT / INPUT_RATE_MIN;        const float f_sign = f_rate >= 0 ? +1. : -1.;        var_SetFloat( p_input, "rate",                      f_sign * __MAX( __MIN( pf_rate[i_idx],                                             f_rate_max ),                                      f_rate_min ) );    }    return VLC_SUCCESS;}

void EqualizerPreamp::set( float percentage, bool updateVLC ){    VarPercent::set( percentage );    // Avoid infinite loop    if( updateVLC )    {        float val = 40 * percentage - 20;        aout_instance_t *pAout = (aout_instance_t *)vlc_object_find( getIntf(),                                VLC_OBJECT_AOUT, FIND_ANYWHERE );        config_PutFloat( getIntf(), "equalizer-preamp", val );        if( pAout )        {            // Update the audio output            var_SetFloat( pAout, "equalizer-preamp", val );            vlc_object_release( pAout );        }    }}

/****************************************************************************** Set the preset specified by preset id*****************************************************************************/static int vlclua_equalizer_setpreset( lua_State *L ){    int presetid = luaL_checknumber( L, 1 );    if( presetid >= NB_PRESETS || presetid < 0 )        return 0;    input_thread_t *p_input = vlclua_get_input_internal( L );    if( p_input )    {        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 );        char *newstr;        if( asprintf( &newstr , "%6.1f" , eqz_preset_10b[presetid].f_amp[0] ) == -1 )            return 0;        for ( int i = 1 ; i < 10 ; i++ )        {            if( asprintf( &newstr, "%s%6.1f",newstr ,eqz_preset_10b[presetid].f_amp[i]) == -1 )                return 0;        }        var_SetString( p_aout, "equalizer-bands",newstr );        var_SetFloat( p_aout, "equalizer-preamp", eqz_preset_10b[presetid].f_preamp );        var_SetString( p_aout , "equalizer-preset" , preset_list[presetid] );        vlc_object_release( p_aout );        free( newstr );        return 1;    }    return 0;}

void EqualizerPreamp::set( float percentage, bool updateVLC ){    playlist_t *pPlaylist = getIntf()->p_sys->p_playlist;    audio_output_t *pAout = playlist_GetAout( pPlaylist );    VarPercent::set( percentage );    // Avoid infinite loop    if( updateVLC )    {        float val = 40 * percentage - 20;        config_PutFloat( getIntf(), "equalizer-preamp", val );        if( pAout )        {            // Update the audio output            var_SetFloat( pAout, "equalizer-preamp", val );        }    }    if( pAout )        vlc_object_release( pAout );}

/****************************************************************************** Set the preamp level*****************************************************************************/static int vlclua_preamp_set( lua_State *L ){    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 );    var_SetFloat( p_aout, "equalizer-preamp", luaL_checknumber( L, 1 ) );    vlc_object_release( p_aout );    return 1;}

void ExtraPanel::OnPreamp( wxScrollEvent &event ){    float f= (float)( 400 - event.GetPosition() ) / 10 - 20 ;    char psz_val[5];    aout_instance_t *p_aout= (aout_instance_t *)vlc_object_find(p_intf,                                 VLC_OBJECT_AOUT, FIND_ANYWHERE);    sprintf( psz_val, "%.1f", f );    const wxString preamp = wxT("Preamp/n");    preamp_text->SetLabel( preamp + wxU( psz_val ) + wxT( "dB" ) );    if( p_aout == NULL )    {        config_PutFloat( p_intf, "equalizer-preamp", f );    }    else    {        var_SetFloat( p_aout, "equalizer-preamp", f );        config_PutFloat( p_intf, "equalizer-preamp", f );        b_my_update = VLC_TRUE;        vlc_object_release( p_aout );    }}

void InputManager::setRate( int new_rate ){    var_SetFloat( THEPL, "rate",                 (float)INPUT_RATE_DEFAULT / (float)new_rate );}