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

void InputManager::UpdateCaching(){    if(!hasInput()) return;    float f_newCache = var_GetFloat ( p_input, "cache" );    if( f_newCache != f_cache )    {        f_cache = f_newCache;        /* Update cache */        emit cachingChanged( f_cache );    }}

/* Define the Input used.   Add the callbacks on input   p_input is held once here */void InputManager::setInput( input_thread_t *_p_input ){    delInput();    p_input = _p_input;    if( p_input != NULL )    {        msg_Dbg( p_intf, "IM: Setting an input" );        vlc_object_hold( p_input );        addCallbacks();        UpdateStatus();        UpdateName();        UpdateArt();        UpdateTeletext();        UpdateNavigation();        UpdateVout();        p_item = input_GetItem( p_input );        emit rateChanged( var_GetFloat( p_input, "rate" ) );        /* Get Saved Time */        if( p_item->i_type == ITEM_TYPE_FILE )        {            int i_time = RecentsMRL::getInstance( p_intf )->time( p_item->psz_uri );            if( i_time > 0 &&                    !var_GetFloat( p_input, "run-time" ) &&                    !var_GetFloat( p_input, "start-time" ) &&                    !var_GetFloat( p_input, "stop-time" ) )            {                emit resumePlayback( (int64_t)i_time * 1000 );            }        }    }    else    {        p_item = NULL;        assert( !p_input_vbi );        emit rateChanged( var_InheritFloat( p_intf, "rate" ) );    }}

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

void VlcProc::init_variables(){    playlist_t* pPlaylist = getIntf()->p_sys->p_playlist;    SET_BOOL( m_cVarRandom, var_GetBool( pPlaylist, "random" ) );    SET_BOOL( m_cVarLoop, var_GetBool( pPlaylist, "loop" ) );    SET_BOOL( m_cVarRepeat, var_GetBool( pPlaylist, "repeat" ) );    SET_VOLUME( m_cVarVolume, var_GetFloat( pPlaylist, "volume" ), false );    bool b_is_muted = aout_MuteGet( pPlaylist ) > 0;    SET_BOOL( m_cVarMute, b_is_muted );    update_equalizer();}

float libvlc_media_player_get_position( libvlc_media_player_t *p_mi ){    input_thread_t *p_input_thread;    float f_position;    p_input_thread = libvlc_get_input_thread ( p_mi );    if( !p_input_thread )        return -1.0;    f_position = var_GetFloat( p_input_thread, "position" );    vlc_object_release( p_input_thread );    return f_position;}

static voidMarshalRate( intf_thread_t *p_intf, DBusMessageIter *container ){    double d_rate;    input_thread_t *p_input;    if( ( p_input = playlist_CurrentInput( p_intf->p_sys->p_playlist ) ) )    {        d_rate = var_GetFloat( p_input, "rate" );        vlc_object_release( (vlc_object_t*) p_input );    }    else        d_rate = 0.;    dbus_message_iter_append_basic( container, DBUS_TYPE_DOUBLE, &d_rate );}

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

static intMarshalRate( intf_thread_t *p_intf, DBusMessageIter *container ){    double d_rate;    input_thread_t *p_input = pl_CurrentInput( p_intf );    if( p_input != NULL )    {        d_rate = var_GetFloat( p_input, "rate" );        vlc_object_release( (vlc_object_t*) p_input );    }    else        d_rate = 1.0;    if( !dbus_message_iter_append_basic( container, DBUS_TYPE_DOUBLE,                                         &d_rate ) )        return VLC_ENOMEM;    return VLC_SUCCESS;}

//.........这里部分代码省略.........    p_sys->ctx.src_params.pix_asr.numerator = u_asr_num;    p_sys->ctx.src_params.pix_asr.denominator = u_asr_den;    config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );    psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_CHROMAFMT );    if( !psz_tmp )        goto error;    else if( !strcmp( psz_tmp, "420" ) ) {        p_enc->fmt_in.i_codec = VLC_CODEC_I420;        p_enc->fmt_in.video.i_bits_per_pixel = 12;        p_sys->ctx.src_params.chroma = format420;        p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 3 / 2;    }    else if( !strcmp( psz_tmp, "422" ) ) {        p_enc->fmt_in.i_codec = VLC_CODEC_I422;        p_enc->fmt_in.video.i_bits_per_pixel = 16;        p_sys->ctx.src_params.chroma = format422;        p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 2;    }    else if( !strcmp( psz_tmp, "444" ) ) {        p_enc->fmt_in.i_codec = VLC_CODEC_I444;        p_enc->fmt_in.video.i_bits_per_pixel = 24;        p_sys->ctx.src_params.chroma = format444;        p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 3;    }    else {        msg_Err( p_enc, "Invalid chroma format: %s", psz_tmp );        free( psz_tmp );        goto error;    }    free( psz_tmp );    p_sys->ctx.enc_params.qf = var_GetFloat( p_enc, ENC_CFG_PREFIX ENC_QUALITY_FACTOR );    /* use bitrate from sout-transcode-vb in kbps */    p_sys->ctx.enc_params.trate = p_enc->fmt_out.i_bitrate / 1000;    i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_TARGETRATE );    if( i_tmp > -1 )        p_sys->ctx.enc_params.trate = i_tmp;    p_enc->fmt_out.i_bitrate = p_sys->ctx.enc_params.trate * 1000;    p_sys->ctx.enc_params.lossless = var_GetBool( p_enc, ENC_CFG_PREFIX ENC_LOSSLESS );    psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_PREFILTER );    if( !psz_tmp )        goto error;    else if( !strcmp( psz_tmp, "none" ) ) {        p_sys->ctx.enc_params.prefilter = NO_PF;    }    else if( !strcmp( psz_tmp, "cwm" ) ) {        p_sys->ctx.enc_params.prefilter = CWM;    }    else if( !strcmp( psz_tmp, "rectlp" ) ) {        p_sys->ctx.enc_params.prefilter = RECTLP;    }    else if( !strcmp( psz_tmp, "diaglp" ) ) {        p_sys->ctx.enc_params.prefilter = DIAGLP;    }    else {        msg_Err( p_enc, "Invalid prefilter: %s", psz_tmp );        free( psz_tmp );        goto error;    }    free( psz_tmp );

//.........这里部分代码省略.........            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 = "";

/***************************************************************************** * Open: probe the encoder *****************************************************************************/static int  Open ( vlc_object_t *p_this ){    encoder_t     *p_enc = (encoder_t *)p_this;    encoder_sys_t *p_sys;    int i_val;    char *psz_val;    int i_qmin = 0, i_qmax = 0;    x264_nal_t    *nal;    int i, i_nal;    if( p_enc->fmt_out.i_codec != VLC_CODEC_H264 &&        !p_enc->b_force )    {        return VLC_EGENERIC;    }    /* X264_POINTVER or X264_VERSION are not available */    msg_Dbg ( p_enc, "version x264 0.%d.X", X264_BUILD );    config_ChainParse( p_enc, SOUT_CFG_PREFIX, ppsz_sout_options, p_enc->p_cfg );    p_enc->fmt_out.i_cat = VIDEO_ES;    p_enc->fmt_out.i_codec = VLC_CODEC_H264;    p_enc->fmt_in.i_codec = VLC_CODEC_I420;    p_enc->pf_encode_video = Encode;    p_enc->pf_encode_audio = NULL;    p_enc->p_sys = p_sys = malloc( sizeof( encoder_sys_t ) );    if( !p_sys )        return VLC_ENOMEM;    p_sys->i_interpolated_dts = 0;    p_sys->psz_stat_name = NULL;    p_sys->p_buffer = NULL;    x264_param_default( &p_sys->param );    p_sys->param.i_width  = p_enc->fmt_in.video.i_width;    p_sys->param.i_height = p_enc->fmt_in.video.i_height;    p_sys->param.rc.f_qcompress = var_GetFloat( p_enc, SOUT_CFG_PREFIX "qcomp" );    /* transcode-default bitrate is 0,     * set more to ABR if user specifies bitrate */    if( p_enc->fmt_out.i_bitrate > 0 )    {        p_sys->param.rc.i_bitrate = p_enc->fmt_out.i_bitrate / 1000;        p_sys->param.rc.i_rc_method = X264_RC_ABR;    }    else /* Set default to CRF */    {        i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "crf" );        if( i_val > 0 && i_val <= 51 )        {            p_sys->param.rc.f_rf_constant = i_val;            p_sys->param.rc.i_rc_method = X264_RC_CRF;        }    }    i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpstep" );    if( i_val >= 0 && i_val <= 51 ) p_sys->param.rc.i_qp_step = i_val;    i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpmin" );    if( i_val >= 0 && i_val <= 51 )    {        i_qmin = i_val;        p_sys->param.rc.i_qp_min = i_qmin;    }    i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qpmax" );    if( i_val >= 0 && i_val <= 51 )    {        i_qmax = i_val;        p_sys->param.rc.i_qp_max = i_qmax;    }    i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "qp" );    if( i_val >= 0 && i_val <= 51 )    {        if( i_qmin > i_val ) i_qmin = i_val;        if( i_qmax < i_val ) i_qmax = i_val;        /* User defined QP-value, so change ratecontrol method */        p_sys->param.rc.i_rc_method = X264_RC_CQP;        p_sys->param.rc.i_qp_constant = i_val;        p_sys->param.rc.i_qp_min = i_qmin;        p_sys->param.rc.i_qp_max = i_qmax;    }    p_sys->param.rc.f_rate_tolerance = var_GetFloat( p_enc,                            SOUT_CFG_PREFIX "ratetol" );    p_sys->param.rc.f_vbv_buffer_init = var_GetFloat( p_enc,                            SOUT_CFG_PREFIX "vbv-init" );    p_sys->param.rc.i_vbv_buffer_size = var_GetInteger( p_enc,                            SOUT_CFG_PREFIX "vbv-bufsize" );    /* max bitrate = average bitrate -> CBR */    i_val = var_GetInteger( p_enc, SOUT_CFG_PREFIX "vbv-maxrate" );    if( !i_val && p_sys->param.rc.i_rc_method == X264_RC_ABR )//.........这里部分代码省略.........

inline bool StreamTime::havePosition() const {    input_thread_t *p_input = getIntf()->p_sys->p_input;    return p_input && ( var_GetFloat( p_input, "position" ) != 0.0 );}

static int OpenEncoder( vlc_object_t *p_this ){    encoder_t *p_enc = (encoder_t *)p_this;    encoder_sys_t *p_sys;    int i_frequency;    if( p_enc->fmt_out.i_codec != VLC_CODEC_MP2 &&        p_enc->fmt_out.i_codec != VLC_CODEC_MPGA &&        p_enc->fmt_out.i_codec != VLC_FOURCC( 'm', 'p', '2', 'a' ) &&        !p_enc->obj.force )    {        return VLC_EGENERIC;    }    if( p_enc->fmt_in.audio.i_channels > 2 )    {        msg_Err( p_enc, "doesn't support > 2 channels" );        return VLC_EGENERIC;    }    for ( i_frequency = 0; i_frequency < 6; i_frequency++ )    {        if ( p_enc->fmt_out.audio.i_rate == mpa_freq_tab[i_frequency] )            break;    }    if ( i_frequency == 6 )    {        msg_Err( p_enc, "MPEG audio doesn't support frequency=%d",                 p_enc->fmt_out.audio.i_rate );        return VLC_EGENERIC;    }    /* Allocate the memory needed to store the decoder's structure */    if( ( p_sys = (encoder_sys_t *)malloc(sizeof(encoder_sys_t)) ) == NULL )        return VLC_ENOMEM;    p_enc->p_sys = p_sys;    p_enc->fmt_in.i_codec = VLC_CODEC_S16N;    p_enc->fmt_out.i_cat = AUDIO_ES;    p_enc->fmt_out.i_codec = VLC_CODEC_MPGA;    config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );    p_sys->p_twolame = twolame_init();    /* Set options */    twolame_set_in_samplerate( p_sys->p_twolame, p_enc->fmt_out.audio.i_rate );    twolame_set_out_samplerate( p_sys->p_twolame, p_enc->fmt_out.audio.i_rate );    if( var_GetBool( p_enc, ENC_CFG_PREFIX "vbr" ) )    {        float f_quality = var_GetFloat( p_enc, ENC_CFG_PREFIX "quality" );        if ( f_quality > 50.f ) f_quality = 50.f;        if ( f_quality < 0.f ) f_quality = 0.f;        twolame_set_VBR( p_sys->p_twolame, 1 );        twolame_set_VBR_q( p_sys->p_twolame, f_quality );    }    else    {        int i;        for ( i = 1; i < 14; i++ )        {            if ( p_enc->fmt_out.i_bitrate / 1000                  <= mpa_bitrate_tab[i_frequency / 3][i] )                break;        }        if ( p_enc->fmt_out.i_bitrate / 1000              != mpa_bitrate_tab[i_frequency / 3][i] )        {            msg_Warn( p_enc, "MPEG audio doesn't support bitrate=%d, using %d",                      p_enc->fmt_out.i_bitrate,                      mpa_bitrate_tab[i_frequency / 3][i] * 1000 );            p_enc->fmt_out.i_bitrate = mpa_bitrate_tab[i_frequency / 3][i]                                        * 1000;        }        twolame_set_bitrate( p_sys->p_twolame,                             p_enc->fmt_out.i_bitrate / 1000 );    }    if ( p_enc->fmt_in.audio.i_channels == 1 )    {        twolame_set_num_channels( p_sys->p_twolame, 1 );        twolame_set_mode( p_sys->p_twolame, TWOLAME_MONO );    }    else    {        twolame_set_num_channels( p_sys->p_twolame, 2 );        switch( var_GetInteger( p_enc, ENC_CFG_PREFIX "mode" ) )        {        case 1:            twolame_set_mode( p_sys->p_twolame, TWOLAME_DUAL_CHANNEL );            break;        case 2:            twolame_set_mode( p_sys->p_twolame, TWOLAME_JOINT_STEREO );            break;        case 0:        default:            twolame_set_mode( p_sys->p_twolame, TWOLAME_STEREO );//.........这里部分代码省略.........

static intinput_event_changed( vlc_object_t * p_this, char const * psz_cmd,                     vlc_value_t oldval, vlc_value_t newval,                     void * p_userdata ){    VLC_UNUSED(oldval);    input_thread_t * p_input = (input_thread_t *)p_this;    libvlc_media_player_t * p_mi = p_userdata;    libvlc_event_t event;    assert( !strcmp( psz_cmd, "intf-event" ) );    if( newval.i_int == INPUT_EVENT_STATE )    {        libvlc_state_t libvlc_state;        switch ( var_GetInteger( p_input, "state" ) )        {            case INIT_S:                libvlc_state = libvlc_NothingSpecial;                event.type = libvlc_MediaPlayerNothingSpecial;                break;            case OPENING_S:                libvlc_state = libvlc_Opening;                event.type = libvlc_MediaPlayerOpening;                break;            case PLAYING_S:                libvlc_state = libvlc_Playing;                event.type = libvlc_MediaPlayerPlaying;                break;            case PAUSE_S:                libvlc_state = libvlc_Paused;                event.type = libvlc_MediaPlayerPaused;                break;            case END_S:                libvlc_state = libvlc_Ended;                event.type = libvlc_MediaPlayerEndReached;                break;            case ERROR_S:                libvlc_state = libvlc_Error;                event.type = libvlc_MediaPlayerEncounteredError;                break;            default:                return VLC_SUCCESS;        }        set_state( p_mi, libvlc_state, false );        libvlc_event_send( p_mi->p_event_manager, &event );    }    else if( newval.i_int == INPUT_EVENT_ABORT )    {        libvlc_state_t libvlc_state = libvlc_Stopped;        event.type = libvlc_MediaPlayerStopped;        set_state( p_mi, libvlc_state, false );        libvlc_event_send( p_mi->p_event_manager, &event );    }    else if( newval.i_int == INPUT_EVENT_POSITION )    {        if( var_GetInteger( p_input, "state" ) != PLAYING_S )            return VLC_SUCCESS; /* Don't send the position while stopped */        /* */        event.type = libvlc_MediaPlayerPositionChanged;        event.u.media_player_position_changed.new_position =                                          var_GetFloat( p_input, "position" );        libvlc_event_send( p_mi->p_event_manager, &event );        /* */        event.type = libvlc_MediaPlayerTimeChanged;        event.u.media_player_time_changed.new_time =           from_mtime(var_GetTime( p_input, "time" ));        libvlc_event_send( p_mi->p_event_manager, &event );    }    else if( newval.i_int == INPUT_EVENT_LENGTH )    {        event.type = libvlc_MediaPlayerLengthChanged;        event.u.media_player_length_changed.new_length =           from_mtime(var_GetTime( p_input, "length" ));        libvlc_event_send( p_mi->p_event_manager, &event );    }    else if( newval.i_int == INPUT_EVENT_CACHE )    {        event.type = libvlc_MediaPlayerBuffering;        event.u.media_player_buffering.new_cache = (int)(100 *            var_GetFloat( p_input, "cache" ));        libvlc_event_send( p_mi->p_event_manager, &event );    }    else if( newval.i_int == INPUT_EVENT_VOUT )    {        vout_thread_t **pp_vout;        size_t i_vout;        if( input_Control( p_input, INPUT_GET_VOUTS, &pp_vout, &i_vout ) )        {            i_vout  = 0;        }        else        {            for( size_t i = 0; i < i_vout; i++ )//.........这里部分代码省略.........

void vout_IntfInit( vout_thread_t *p_vout ){    vlc_value_t val, text, old_val;    char *psz_buf;    /* Create a few object variables we'll need later on */    var_Create( p_vout, "snapshot-num", VLC_VAR_INTEGER );    var_SetInteger( p_vout, "snapshot-num", 1 );    var_Create( p_vout, "width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "align", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "video-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "video-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    var_Create( p_vout, "mouse-hide-timeout",                VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    /* Add variables to manage scaling video */    var_Create( p_vout, "autoscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT                | VLC_VAR_ISCOMMAND );    text.psz_string = _("Autoscale video");    var_Change( p_vout, "autoscale", VLC_VAR_SETTEXT, &text, NULL );    var_AddCallback( p_vout, "autoscale", ScalingCallback, NULL );    var_Create( p_vout, "scale", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT                | VLC_VAR_ISCOMMAND );    text.psz_string = _("Scale factor");    var_Change( p_vout, "scale", VLC_VAR_SETTEXT, &text, NULL );    var_AddCallback( p_vout, "scale", ScalingCallback, NULL );    /* Zoom object var */    var_Create( p_vout, "zoom", VLC_VAR_FLOAT | VLC_VAR_ISCOMMAND |                VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );    text.psz_string = _("Zoom");    var_Change( p_vout, "zoom", VLC_VAR_SETTEXT, &text, NULL );    old_val.f_float = var_GetFloat( p_vout, "zoom" );    for( size_t i = 0; i < ARRAY_SIZE(p_zoom_values); i++ )    {        val.f_float = p_zoom_values[i].f_value;        text.psz_string = vlc_gettext( p_zoom_values[i].psz_label );        /* FIXME: This DELCHOICE hack corrupts the the "zoom" variable value         * for a short time window. Same for "crop" and "aspect-ratio". */        if( old_val.f_float == val.f_float )            var_Change( p_vout, "zoom", VLC_VAR_DELCHOICE, &old_val, NULL );        var_Change( p_vout, "zoom", VLC_VAR_ADDCHOICE, &val, &text );        if( old_val.f_float == val.f_float )            var_Change( p_vout, "zoom", VLC_VAR_SETVALUE, &old_val, NULL );    }    var_AddCallback( p_vout, "zoom", ZoomCallback, NULL );    /* Crop offset vars */    var_Create( p_vout, "crop-left", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-top", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-right", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_Create( p_vout, "crop-bottom", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_vout, "crop-left", CropBorderCallback, NULL );    var_AddCallback( p_vout, "crop-top", CropBorderCallback, NULL );    var_AddCallback( p_vout, "crop-right", CropBorderCallback, NULL );    var_AddCallback( p_vout, "crop-bottom", CropBorderCallback, NULL );    /* Crop object var */    var_Create( p_vout, "crop", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |                VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );    text.psz_string = _("Crop");    var_Change( p_vout, "crop", VLC_VAR_SETTEXT, &text, NULL );    val.psz_string = (char*)"";    var_Change( p_vout, "crop", VLC_VAR_DELCHOICE, &val, 0 );    for( size_t i = 0; i < ARRAY_SIZE(p_crop_values); i++ )    {        val.psz_string = (char*)p_crop_values[i].psz_value;        text.psz_string = _( p_crop_values[i].psz_label );        var_Change( p_vout, "crop", VLC_VAR_ADDCHOICE, &val, &text );    }    /* Add custom crop ratios */    psz_buf = var_CreateGetNonEmptyString( p_vout, "custom-crop-ratios" );    if( psz_buf )    {        AddCustomRatios( p_vout, "crop", psz_buf );        free( psz_buf );    }    var_AddCallback( p_vout, "crop", CropCallback, NULL );    /* Monitor pixel aspect-ratio */    var_Create( p_vout, "monitor-par", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    /* Aspect-ratio object var */    var_Create( p_vout, "aspect-ratio", VLC_VAR_STRING | VLC_VAR_ISCOMMAND |                VLC_VAR_HASCHOICE | VLC_VAR_DOINHERIT );//.........这里部分代码省略.........

/** * Gets the volume of the audio output stream (independent of mute). * /return Current audio volume (0. = silent, 1. = nominal), * or a strictly negative value if undefined. */float aout_VolumeGet (audio_output_t *aout){    return var_GetFloat (aout, "volume");}

/* delete Input if it ever existed.   Delete the callbacls on input   p_input is released once here */void InputManager::delInput(){    if( !p_input ) return;    msg_Dbg( p_intf, "IM: Deleting the input" );    /* Save time / position */    char *uri = input_item_GetURI( p_item );    if( uri != NULL ) {        float f_pos = var_GetFloat( p_input , "position" );        int64_t i_time = -1;        if( f_pos >= 0.05f && f_pos <= 0.95f         && var_GetInteger( p_input, "length" ) >= 60 * CLOCK_FREQ )            i_time = var_GetInteger( p_input, "time");        RecentsMRL::getInstance( p_intf )->setTime( qfu(uri), i_time );        free(uri);    }    delCallbacks();    i_old_playing_status = END_S;    p_item               = NULL;    oldName              = "";    artUrl               = "";    b_video              = false;    timeA                = 0;    timeB                = 0;    f_rate               = 0. ;    if( p_input_vbi )    {        vlc_object_release( p_input_vbi );        p_input_vbi = NULL;    }    vlc_object_release( p_input );    p_input = NULL;    emit positionUpdated( -1.0, 0 ,0 );    emit rateChanged( var_InheritFloat( p_intf, "rate" ) );    emit nameChanged( "" );    emit chapterChanged( 0 );    emit titleChanged( 0 );    emit playingStatusChanged( END_S );    emit teletextPossible( false );    emit AtoBchanged( false, false );    emit voutChanged( false );    emit voutListChanged( NULL, 0 );    /* Reset all InfoPanels but stats */    emit artChanged( NULL );    emit artChanged( "" );    emit infoChanged( NULL );    emit currentMetaChanged( (input_item_t *)NULL );    emit encryptionChanged( false );    emit recordingStateChanged( false );    emit cachingChanged( 0.0 );}

void VlcProc::on_intf_event_changed( vlc_object_t* p_obj, vlc_value_t newVal ){    input_thread_t* pInput = (input_thread_t*) p_obj;    assert( getIntf()->p_sys->p_input == NULL || getIntf()->p_sys->p_input == pInput );    if( !getIntf()->p_sys->p_input )    {        msg_Dbg( getIntf(), "new input %p detected", pInput );        getIntf()->p_sys->p_input = pInput;        vlc_object_hold( pInput );    }    switch( newVal.i_int )    {        case INPUT_EVENT_STATE:        {            int state = var_GetInteger( pInput, "state" );            SET_BOOL( m_cVarStopped, false );            SET_BOOL( m_cVarPlaying, state != PAUSE_S );            SET_BOOL( m_cVarPaused, state == PAUSE_S );            break;        }        case INPUT_EVENT_POSITION:        {            float pos = var_GetFloat( pInput, "position" );            SET_STREAMTIME( m_cVarTime, pos, false );            SET_BOOL( m_cVarSeekable, pos != 0.0 );            break;        }        case INPUT_EVENT_RATE:        {            float rate = var_GetFloat( pInput, "rate" );            char* buffer;            if( asprintf( &buffer, "%.3g", rate ) != -1 )            {                SET_TEXT( m_cVarSpeed, UString( getIntf(), buffer ) );                free( buffer );            }            break;        }        case INPUT_EVENT_ES:        {            // Do we have audio            vlc_value_t audio_es;            var_Change( pInput, "audio-es", VLC_VAR_CHOICESCOUNT,                            &audio_es, NULL );            SET_BOOL( m_cVarHasAudio, audio_es.i_int > 0 );            break;        }        case INPUT_EVENT_VOUT:        {            vout_thread_t* pVout = input_GetVout( pInput );            SET_BOOL( m_cVarHasVout, pVout != NULL );            if( !pVout || pVout == m_pVout )            {                // end of input or vout reuse (nothing to do)                if( pVout )                    vlc_object_release( pVout );                break;            }            if( m_pVout )            {                // remove previous Vout callbacks                var_DelCallback( m_pVout, "mouse-moved",                                 onGenericCallback, this );                vlc_object_release( m_pVout );                m_pVout = NULL;            }            // add new Vout callbackx            var_AddCallback( pVout, "mouse-moved",                             onGenericCallback, this );            m_pVout = pVout;            break;        }        case INPUT_EVENT_AOUT:        {            audio_output_t* pAout = input_GetAout( pInput );            // end of input or aout reuse (nothing to do)            if( !pAout || pAout == m_pAout )            {                if( pAout )                    vlc_object_release( pAout );                break;            }            // remove previous Aout if any            if( m_pAout )            {                var_DelCallback( m_pAout, "audio-filter",                                 onGenericCallback, this );                if( m_bEqualizer_started )//.........这里部分代码省略.........

void VlcProc::on_volume_changed( vlc_object_t* p_obj, vlc_value_t newVal ){    (void)p_obj; (void)newVal;    SET_VOLUME( m_cVarVolume, var_GetFloat( getPL(), "volume" ), false );}

/***************************************************************************** * DoWork : normalizes and sends a buffer *****************************************************************************/static block_t *DoWork( filter_t *p_filter, block_t *p_in_buf ){    float *pf_sum;    float *pf_gain;    float f_average = 0;    int i, i_chan;    int i_samples = p_in_buf->i_nb_samples;    int i_channels = aout_FormatNbChannels( &p_filter->fmt_in.audio );    float *p_out = (float*)p_in_buf->p_buffer;    float *p_in =  (float*)p_in_buf->p_buffer;    struct filter_sys_t *p_sys = p_filter->p_sys;    pf_sum = (float *)calloc( i_channels, sizeof(float) );			// sunqueen modify    if( !pf_sum )        goto out;    pf_gain = (float *)malloc( sizeof(float) * i_channels );			// sunqueen modify    if( !pf_gain )    {        free( pf_sum );        goto out;    }    /* Calculate the average power level on this buffer */    for( i = 0 ; i < i_samples; i++ )    {        for( i_chan = 0; i_chan < i_channels; i_chan++ )        {            float f_sample = p_in[i_chan];            float f_square = pow( f_sample, 2 );            pf_sum[i_chan] += f_square;        }        p_in += i_channels;    }    /* sum now contains for each channel the sigma(value
C++ var_GetInteger函数代码示例
C++ var_GetBool函数代码示例