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

void libvlc_video_set_spu( libvlc_media_player_t *p_mi, int i_spu,                           libvlc_exception_t *p_e ){    input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );    vlc_value_t val_list;    vlc_value_t newval;    int i_ret = -1;    if( !p_input_thread ) return;    var_Change( p_input_thread, "spu-es", VLC_VAR_GETCHOICES, &val_list, NULL );    if( (i_spu < 0) && (i_spu > val_list.p_list->i_count) )    {        libvlc_exception_raise( p_e, "Subtitle value out of range" );        vlc_object_release( p_input_thread );        return;    }    newval = val_list.p_list->p_values[i_spu];    i_ret = var_Set( p_input_thread, "spu-es", newval );    if( i_ret < 0 )    {        libvlc_exception_raise( p_e, "Setting subtitle value failed" );    }    vlc_object_release( p_input_thread );}

/***************************************************************************** * aout_VolumeDown : lower the output volume ***************************************************************************** * If pi_volume != NULL, *pi_volume will contain the volume at the end of the * function. *****************************************************************************/int __aout_VolumeDown( vlc_object_t * p_object, int i_nb_steps,                       audio_volume_t * pi_volume ){    vlc_value_t val;    aout_instance_t * p_aout = vlc_object_find( p_object, VLC_OBJECT_AOUT,                               FIND_ANYWHERE );    int i_result = 0, i_volume = 0, i_volume_step = 0;    i_volume_step = config_GetInt( p_object->p_libvlc, "volume-step" );    i_volume = config_GetInt( p_object, "volume" );    i_volume -= i_volume_step * i_nb_steps;    if ( i_volume < AOUT_VOLUME_MIN )    {        i_volume = AOUT_VOLUME_MIN;    }    config_PutInt( p_object, "volume", i_volume );    var_Create( p_object->p_libvlc, "saved-volume", VLC_VAR_INTEGER );    var_SetInteger( p_object->p_libvlc, "saved-volume", (audio_volume_t) i_volume );    if ( pi_volume != NULL ) *pi_volume = (audio_volume_t) i_volume;    val.b_bool = true;    var_Set( p_object->p_libvlc, "volume-change", val );    if ( p_aout == NULL ) return 0;    aout_lock_mixer( p_aout );    if ( !p_aout->mixer.b_error )    {        i_result = p_aout->output.pf_volume_set( p_aout, (audio_volume_t) i_volume );    }    aout_unlock_mixer( p_aout );    vlc_object_release( p_aout );    return i_result;}

/** * Enables a playlist group * * /param p_playlist the playlist to enable from. * /param i_group the id of the group to enable * /return returns 0 */int playlist_EnableGroup( playlist_t * p_playlist, int i_group ){    vlc_value_t val;    int i;    vlc_mutex_lock( &p_playlist->object_lock );    for( i = 0; i< p_playlist->i_size; i++ )    {        if( p_playlist->pp_items[i]->i_group == i_group )        {            msg_Dbg( p_playlist, "enabling playlist item `%s'",                     p_playlist->pp_items[i]->input.psz_name );            if( p_playlist->pp_items[i]->b_enabled == VLC_FALSE )                p_playlist->i_enabled++;            p_playlist->pp_items[i]->b_enabled = VLC_TRUE;            val.b_bool = i;            var_Set( p_playlist, "item-change", val );        }    }    vlc_mutex_unlock( &p_playlist->object_lock );    return 0;}

/***************************************************************************** * libvlc_audio_set_track : Set the current audio track *****************************************************************************/void libvlc_audio_set_track( libvlc_media_player_t *p_mi, int i_track,                             libvlc_exception_t *p_e ){    input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi, p_e );    vlc_value_t val_list;    vlc_value_t newval;    int i_ret = -1;    if( !p_input_thread )        return;    var_Change( p_input_thread, "audio-es", VLC_VAR_GETCHOICES, &val_list, NULL );    if( (i_track < 0) || (i_track > val_list.p_list->i_count) )    {        libvlc_exception_raise( p_e );        libvlc_printerr( "Audio track out of range" );        goto end;    }    newval = val_list.p_list->p_values[i_track];    i_ret = var_Set( p_input_thread, "audio-es", newval );    if( i_ret < 0 )    {        libvlc_exception_raise( p_e );        libvlc_printerr( "Audio track out of range" ); /* Race... */    }end:    var_FreeList( &val_list, NULL );    vlc_object_release( p_input_thread );}

/***************************************************************************** * SendEventsToChild: forward events to the child/children vout *****************************************************************************/static int SendEventsToChild( vlc_object_t *p_this, char const *psz_var,                       vlc_value_t oldval, vlc_value_t newval, void *p_data ){    vout_thread_t *p_vout = (vout_thread_t *)p_this;    var_Set( p_vout->p_sys->p_vout, psz_var, newval );    return VLC_SUCCESS;}

void VoutWindow::processEvent( EvtKey &rEvtKey ){    // Only do the action when the key is down    if( rEvtKey.getAsString().find( "key:down") != string::npos )    {        vlc_value_t val;        // Set the key        val.i_int = rEvtKey.getKey();        // Set the modifiers        if( rEvtKey.getMod() & EvtInput::kModAlt )        {            val.i_int |= KEY_MODIFIER_ALT;        }        if( rEvtKey.getMod() & EvtInput::kModCtrl )        {            val.i_int |= KEY_MODIFIER_CTRL;        }        if( rEvtKey.getMod() & EvtInput::kModShift )        {            val.i_int |= KEY_MODIFIER_SHIFT;        }        var_Set( getIntf()->p_libvlc, "key-pressed", val );    }}

static voidClose( vlc_object_t *p_this ){    /*tls_t *p_tls = (tls_t *)p_this;    tls_sys_t *p_sys = (tls_sys_t *)(p_this->p_sys);*/    vlc_value_t lock, count;    var_Create( p_this->p_libvlc, "gnutls_mutex", VLC_VAR_MUTEX );    var_Get( p_this->p_libvlc, "gnutls_mutex", &lock );    vlc_mutex_lock( lock.p_address );    var_Create( p_this->p_libvlc, "gnutls_count", VLC_VAR_INTEGER );    var_Get( p_this->p_libvlc, "gnutls_count", &count);    count.i_int--;    var_Set( p_this->p_libvlc, "gnutls_count", count);    if( count.i_int == 0 )    {        gnutls_global_deinit( );        msg_Dbg( p_this, "GNUTLS deinitialized" );    }    vlc_mutex_unlock( lock.p_address);}

/***************************************************************************** * SendEvents: forward mouse and keyboard events to the parent p_vout *****************************************************************************/static int SendEvents( vlc_object_t *p_this, char const *psz_var,                       vlc_value_t oldval, vlc_value_t newval, void *p_data ){    var_Set( (vlc_object_t *)p_data, psz_var, newval );    return VLC_SUCCESS;}

/***************************************************************************** * PlayItem: play current playlist item ***************************************************************************** * This function calculates the position of the next playlist item, depending * on the playlist course mode (forward, backward, random...). *****************************************************************************/static void PlayItem( playlist_t *p_playlist ){    playlist_item_t *p_item;    vlc_value_t val;    if( p_playlist->i_index == -1 )    {        if( p_playlist->i_size == 0 || p_playlist->i_enabled == 0)        {            return;        }        SkipItem( p_playlist, 1 );    }    if( p_playlist->i_enabled == 0)    {        return;    }    msg_Dbg( p_playlist, "creating new input thread" );    p_item = p_playlist->pp_items[p_playlist->i_index];    p_item->i_nb_played++;    p_playlist->p_input = input_CreateThread( p_playlist, &p_item->input );    val.i_int = p_playlist->i_index;    /* unlock the playlist to set the var...mmm */    vlc_mutex_unlock( &p_playlist->object_lock);    var_Set( p_playlist, "playlist-current", val);    vlc_mutex_lock( &p_playlist->object_lock);}

/***************************************************************************** * CloseEncoder: x264 encoder destruction *****************************************************************************/static void Close( vlc_object_t *p_this ){    encoder_t     *p_enc = (encoder_t *)p_this;    encoder_sys_t *p_sys = p_enc->p_sys;    free( p_sys->psz_stat_name );    if( p_sys->h )        x264_encoder_close( p_sys->h );#ifdef PTW32_STATIC_LIB    vlc_value_t lock, count;    var_Get( p_enc->p_libvlc, "pthread_win32_mutex", &lock );    vlc_mutex_lock( lock.p_address );    var_Get( p_enc->p_libvlc, "pthread_win32_count", &count );    count.i_int--;    var_Set( p_enc->p_libvlc, "pthread_win32_count", count );    if( count.i_int == 0 )    {        pthread_win32_thread_detach_np();        pthread_win32_process_detach_np();        msg_Dbg( p_enc, "pthread-win32 deinitialized" );    }    vlc_mutex_unlock( lock.p_address );#endif    free( p_sys->p_buffer );    free( p_sys );}

static int vlclua_var_create( lua_State *L ){    int i_type, i_ret;    vlc_object_t **pp_obj = luaL_checkudata( L, 1, "vlc_object" );    const char *psz_var = luaL_checkstring( L, 2 );    switch( lua_type( L, 3 ) )    {        case LUA_TNUMBER:            i_type = VLC_VAR_FLOAT;            break;        case LUA_TBOOLEAN:            i_type = VLC_VAR_BOOL;            break;        case LUA_TSTRING:            i_type = VLC_VAR_STRING;            break;        case LUA_TNIL:            i_type = VLC_VAR_VOID;            break;        default:            return 0;    }    if( ( i_ret = var_Create( *pp_obj, psz_var, i_type ) ) != VLC_SUCCESS )        return vlclua_push_ret( L, i_ret );    // Special case for void variables    if( i_type == VLC_VAR_VOID )        return 0;    vlc_value_t val;    vlclua_tovalue( L, i_type, &val );    return vlclua_push_ret( L, var_Set( *pp_obj, psz_var, val ) );}

static int TriggerFilterCallback(vlc_object_t *p_this, char const *psz_var,                                 vlc_value_t oldval, vlc_value_t newval,                                 void *p_data){    (void) p_this; (void) oldval;    var_Set((filter_t *)p_data, psz_var, newval);    return 0;}

void QVLCMenu::DoAction( QObject *data ){    MenuItemData *itemData = qobject_cast<MenuItemData *>( data );    vlc_object_t *p_object = itemData->p_obj;    if( p_object == NULL ) return;    var_Set( p_object, itemData->psz_var, itemData->val );}

static int FullscreenCallback( vlc_object_t *p_this, char const *psz_cmd,                       vlc_value_t oldval, vlc_value_t newval, void *p_data ){    vout_thread_t *p_vout = (vout_thread_t *)p_this;    vlc_value_t val;    (void)psz_cmd; (void)oldval; (void)p_data;    p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;    /* Modify libvlc as well because the vout might have to be restarted */    var_Create( p_vout->p_libvlc, "fullscreen", VLC_VAR_BOOL );    var_Set( p_vout->p_libvlc, "fullscreen", newval );    val.b_bool = true;    var_Set( p_vout, "intf-change", val );    return VLC_SUCCESS;}

static int var_Copy (vlc_object_t *src, const char *name, vlc_value_t prev,                     vlc_value_t value, void *data){    vlc_object_t *dst = data;    (void) src; (void) prev;    return var_Set (dst, name, value);}

static void menu_callback(GtkMenuItem *menuitem, gpointer user_data){    VlcMenuItem *item = (VlcMenuItem *)menuitem;    vlc_object_t *p_object = item->p_obj;    (void)user_data;    if( p_object == NULL ) return;    var_Set( p_object, item->psz_var, item->val );}

static int Forward(vlc_object_t *object, char const *var,                   vlc_value_t oldval, vlc_value_t newval, void *data){    vout_thread_t *vout = (vout_thread_t*)object;    VLC_UNUSED(oldval);    VLC_UNUSED(data);    return var_Set(vout->p->display.vd, var, newval);}

void TopWindow::processEvent( EvtKey &rEvtKey ){    // Forward the event to the focused control, if any    if( m_pFocusControl )    {        m_pFocusControl->handleEvent( rEvtKey );        return;    }    // Only do the action when the key is down    if( rEvtKey.getAsString().find( "key:down") != string::npos )    {        //XXX not to be hardcoded!        // Ctrl-S = Change skin        if( (rEvtKey.getMod() & EvtInput::kModCtrl) &&            rEvtKey.getKey() == 's' )        {            CmdDlgChangeSkin cmd( getIntf() );            cmd.execute();            return;        }        //XXX not to be hardcoded!        // Ctrl-T = Toggle on top        if( (rEvtKey.getMod() & EvtInput::kModCtrl) &&            rEvtKey.getKey() == 't' )        {            CmdOnTop cmd( getIntf() );            cmd.execute();            return;        }        vlc_value_t val;        // Set the key        val.i_int = rEvtKey.getKey();        // Set the modifiers        if( rEvtKey.getMod() & EvtInput::kModAlt )        {            val.i_int |= KEY_MODIFIER_ALT;        }        if( rEvtKey.getMod() & EvtInput::kModCtrl )        {            val.i_int |= KEY_MODIFIER_CTRL;        }        if( rEvtKey.getMod() & EvtInput::kModShift )        {            val.i_int |= KEY_MODIFIER_SHIFT;        }        var_Set( getIntf()->p_vlc, "key-pressed", val );    }    // Always store the modifier, which can be needed for scroll events    m_currModifier = rEvtKey.getMod();}

static int OnTopCallback( vlc_object_t *p_this, char const *psz_cmd,                         vlc_value_t oldval, vlc_value_t newval, void *p_data ){    vout_thread_t *p_vout = (vout_thread_t *)p_this;    vout_Control( p_vout, VOUT_SET_STAY_ON_TOP, newval.b_bool );    (void)psz_cmd; (void)oldval; (void)p_data;    /* Modify libvlc as well because the vout might have to be restarted */    var_Create( p_vout->p_libvlc, "video-on-top", VLC_VAR_BOOL );    var_Set( p_vout->p_libvlc, "video-on-top", newval );    return VLC_SUCCESS;}

static int vlclua_var_set( lua_State *L ){    int i_type;    vlc_value_t val;    vlc_object_t **pp_obj = luaL_checkudata( L, 1, "vlc_object" );    const char *psz_var = luaL_checkstring( L, 2 );    int i_ret;    i_type = var_Type( *pp_obj, psz_var );    vlclua_tovalue( L, i_type, &val );    i_ret = var_Set( *pp_obj, psz_var, val );    lua_pop( L, 3 );    return vlclua_push_ret( L, i_ret );}

//---------------------------------------------------------------------------// DemuxOpen: initialize demux//---------------------------------------------------------------------------static int DemuxOpen( vlc_object_t *p_this ){    demux_t *p_demux = (demux_t*)p_this;    intf_thread_t *p_intf;    char *ext;    // Needed callbacks    p_demux->pf_demux   = Demux;    p_demux->pf_control = DemuxControl;    // Test that we have a valid .vlt file, based on the extension    // TODO: an actual check of the contents would be better...    if( ( ext = strchr( p_demux->psz_path, '.' ) ) == NULL ||        strcasecmp( ext, ".vlt" ) )    {        return VLC_EGENERIC;    }    p_intf = (intf_thread_t *)vlc_object_find( p_this, VLC_OBJECT_INTF,                                               FIND_ANYWHERE );    if( p_intf != NULL )    {        // Do nothing is skins2 is not the main interface        if( var_Type( p_intf, "skin-to-load" ) == VLC_VAR_STRING )        {            playlist_t *p_playlist =                (playlist_t *) vlc_object_find( p_this, VLC_OBJECT_PLAYLIST,                                                FIND_ANYWHERE );            if( p_playlist != NULL )            {                // Make sure the item is deleted afterwards                p_playlist->pp_items[p_playlist->i_index]->b_autodeletion =                    VLC_TRUE;                vlc_object_release( p_playlist );            }            vlc_value_t val;            val.psz_string = p_demux->psz_path;            var_Set( p_intf, "skin-to-load", val );        }        else        {            msg_Warn( p_this,                      "skin could not be loaded (not using skins2 intf)" );        }        vlc_object_release( p_intf );    }    return VLC_SUCCESS;}

void CmdFaster::execute(){    input_thread_t *pInput =        (input_thread_t *)vlc_object_find( getIntf(), VLC_OBJECT_INPUT,                                           FIND_ANYWHERE );    if( pInput )    {        vlc_value_t val;        val.b_bool = VLC_TRUE;        var_Set( pInput, "rate-faster", val );        vlc_object_release( pInput );    }}