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

void filter_AddProxyCallbacks( vlc_object_t *obj, filter_t *filter,                               vlc_callback_t restart_cb ){    char **names = var_GetAllNames(VLC_OBJECT(filter));    if (names == NULL)        return;    for (char **pname = names; *pname != NULL; pname++)    {        char *name = *pname;        int var_type = var_Type(filter, name);        if (var_Type(obj, name) || config_GetType(name) == 0)        {            free(name);            continue;        }        var_Create(obj, name,                   var_type | VLC_VAR_DOINHERIT | VLC_VAR_ISCOMMAND);        if ((var_type & VLC_VAR_ISCOMMAND))            var_AddCallback(obj, name, TriggerFilterCallback, filter);        else            var_AddCallback(obj, name, restart_cb, obj);        free(name);    }    free(names);}

void filter_DelProxyCallbacks( vlc_object_t *obj, filter_t *filter,                               vlc_callback_t restart_cb ){    char **names = var_GetAllNames(VLC_OBJECT(filter));    if (names == NULL)        return;    for (char **pname = names; *pname != NULL; pname++)    {        char *name = *pname;        if (!(var_Type(obj, name) & VLC_VAR_ISCOMMAND))        {            free(name);            continue;        }        int filter_var_type = var_Type(filter, name);        if (filter_var_type & VLC_VAR_ISCOMMAND)            var_DelCallback(obj, name, TriggerFilterCallback, filter);        else if (filter_var_type)            var_DelCallback(obj, name, restart_cb, obj);        var_Destroy(obj, name);        free(name);    }    free(names);}

/***************************************************************************** * aout_FindAndRestart : find the audio output instance and restart ***************************************************************************** * This is used for callbacks of the configuration variables, and we believe * that when those are changed, it is a significant change which implies * rebuilding the audio-device and audio-channels variables. *****************************************************************************/int aout_FindAndRestart( vlc_object_t * p_this, const char *psz_name,                         vlc_value_t oldval, vlc_value_t newval, void *p_data ){    aout_instance_t * p_aout = vlc_object_find( p_this, VLC_OBJECT_AOUT,                               FIND_ANYWHERE );    (void)psz_name;    (void)oldval;    (void)newval;    (void)p_data;    if ( p_aout == NULL ) return VLC_SUCCESS;    if ( var_Type( p_aout, "audio-device" ) != 0 )    {        var_Destroy( p_aout, "audio-device" );    }    if ( var_Type( p_aout, "audio-channels" ) != 0 )    {        var_Destroy( p_aout, "audio-channels" );    }    aout_Restart( p_aout );    vlc_object_release( p_aout );    return VLC_SUCCESS;}

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

/***************************************************************************** * aout_DecDelete : delete a decoder *****************************************************************************/int aout_DecDelete( aout_instance_t * p_aout, aout_input_t * p_input ){    int i_input;    /* This function can only be called by the decoder itself, so no need     * to lock p_input->lock. */    vlc_mutex_lock( &p_aout->mixer_lock );    for ( i_input = 0; i_input < p_aout->i_nb_inputs; i_input++ )    {        if ( p_aout->pp_inputs[i_input] == p_input )        {            break;        }    }    if ( i_input == p_aout->i_nb_inputs )    {        msg_Err( p_aout, "cannot find an input to delete" );        return -1;    }    /* Remove the input from the list. */    memmove( &p_aout->pp_inputs[i_input], &p_aout->pp_inputs[i_input + 1],             (AOUT_MAX_INPUTS - i_input - 1) * sizeof(aout_input_t *) );    p_aout->i_nb_inputs--;    aout_InputDelete( p_aout, p_input );    vlc_mutex_destroy( &p_input->lock );    free( p_input );    if ( !p_aout->i_nb_inputs )    {        aout_OutputDelete( p_aout );        aout_MixerDelete( p_aout );        if ( var_Type( p_aout, "audio-device" ) != 0 )        {            var_Destroy( p_aout, "audio-device" );        }        if ( var_Type( p_aout, "audio-channels" ) != 0 )        {            var_Destroy( p_aout, "audio-channels" );        }    }    vlc_mutex_unlock( &p_aout->mixer_lock );    return 0;}

/***************************** * 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 struct decklink_sys_t *GetDLSys(vlc_object_t *obj){    vlc_object_t *libvlc = VLC_OBJECT(obj->p_libvlc);    struct decklink_sys_t *sys;    vlc_mutex_lock(&sys_lock);    if (var_Type(libvlc, "decklink-sys") == VLC_VAR_ADDRESS)        sys = (struct decklink_sys_t*)var_GetAddress(libvlc, "decklink-sys");    else {        sys = (struct decklink_sys_t*)malloc(sizeof(*sys));        if (sys) {            sys->p_output = NULL;            sys->offset = 0;            sys->users = 0;            sys->i_rate = -1;            vlc_mutex_init(&sys->lock);            vlc_cond_init(&sys->cond);            var_Create(libvlc, "decklink-sys", VLC_VAR_ADDRESS);            var_SetAddress(libvlc, "decklink-sys", (void*)sys);        }    }    vlc_mutex_unlock(&sys_lock);    return sys;}

/***************************************************************************** * Activate: allocate a chroma function ***************************************************************************** * This function allocates and initializes a chroma function *****************************************************************************/static int Activate( filter_t *p_filter, int (*pf_build)(filter_t *) ){    filter_sys_t *p_sys;    int i_ret = VLC_EGENERIC;    p_sys = p_filter->p_sys = calloc( 1, sizeof( *p_sys ) );    if( !p_sys )        return VLC_ENOMEM;    filter_owner_t owner = {        .video = &filter_video_chain_cbs,        .sys = p_filter,    };    p_sys->p_chain = filter_chain_NewVideo( p_filter, p_filter->b_allow_fmt_out_change, &owner );    if( !p_sys->p_chain )    {        free( p_sys );        return VLC_EGENERIC;    }    int type = VLC_VAR_INTEGER;    if( var_Type( p_filter->obj.parent, "chain-level" ) != 0 )        type |= VLC_VAR_DOINHERIT;    var_Create( p_filter, "chain-level", type );    /* Note: atomicity is not actually needed here. */    var_IncInteger( p_filter, "chain-level" );    int level = var_GetInteger( p_filter, "chain-level" );    if( level < 0 || level > CHAIN_LEVEL_MAX )        msg_Err( p_filter, "Too high level of recursion (%d)", level );    else        i_ret = pf_build( p_filter );    var_Destroy( p_filter, "chain-level" );    if( i_ret )    {        /* Hum ... looks like this really isn't going to work. Too bad. */        if (p_sys->p_video_filter)            filter_DelProxyCallbacks( p_filter, p_sys->p_video_filter,                                      RestartFilterCallback );        filter_chain_Delete( p_sys->p_chain );        free( p_sys );        return VLC_EGENERIC;    }    if( p_filter->b_allow_fmt_out_change )    {        es_format_Clean( &p_filter->fmt_out );        es_format_Copy( &p_filter->fmt_out,                        filter_chain_GetFmtOut( p_sys->p_chain ) );    }    /* */    p_filter->pf_video_filter = Chain;    return VLC_SUCCESS;}

void InputManager::sectionNext(){    if( hasInput() )    {        int i_type = var_Type( p_input, "next-chapter" );        var_TriggerCallback( p_input, (i_type & VLC_VAR_TYPE) != 0 ?                             "next-chapter":"next-title" );    }}

/********************************************************************** * 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 int vlclua_var_get( 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 );    i_type = var_Type( *pp_obj, psz_var );    if( var_Get( *pp_obj, psz_var, &val ) != VLC_SUCCESS )        return 0;    lua_pop( L, 2 );    return vlclua_pushvalue( L, i_type, val );}

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 libvlc_media_player_previous_chapter( libvlc_media_player_t *p_mi ){    input_thread_t *p_input_thread;    p_input_thread = libvlc_get_input_thread ( p_mi );    if( !p_input_thread )        return;    int i_type = var_Type( p_input_thread, "next-chapter" );    var_TriggerCallback( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?                            "prev-chapter":"prev-title" );    vlc_object_release( p_input_thread );}

/***************************************************************************** * input_ControlVarTitle: *  Create all variables for a title *****************************************************************************/void input_ControlVarTitle( input_thread_t *p_input, int i_title ){    input_title_t *t = p_input->p->title[i_title];    vlc_value_t text;    int  i;    /* Create/Destroy command variables */    if( t->i_seekpoint <= 1 )    {        var_Destroy( p_input, "next-chapter" );        var_Destroy( p_input, "prev-chapter" );    }    else if( var_Type( p_input, "next-chapter" ) == 0 )    {        var_Create( p_input, "next-chapter", VLC_VAR_VOID );        text.psz_string = _("Next chapter");        var_Change( p_input, "next-chapter", VLC_VAR_SETTEXT, &text, NULL );        var_AddCallback( p_input, "next-chapter", SeekpointCallback, NULL );        var_Create( p_input, "prev-chapter", VLC_VAR_VOID );        text.psz_string = _("Previous chapter");        var_Change( p_input, "prev-chapter", VLC_VAR_SETTEXT, &text, NULL );        var_AddCallback( p_input, "prev-chapter", SeekpointCallback, NULL );    }    /* Build chapter list */    var_Change( p_input, "chapter", VLC_VAR_CLEARCHOICES, NULL, NULL );    for( i = 0; i <  t->i_seekpoint; i++ )    {        vlc_value_t val;        val.i_int = i;        if( t->seekpoint[i]->psz_name == NULL ||            *t->seekpoint[i]->psz_name == '/0' )        {            /* Default value */            if( asprintf( &text.psz_string, _("Chapter %i"),                      i + p_input->p->i_seekpoint_offset ) == -1 )                continue;        }        else        {            text.psz_string = strdup( t->seekpoint[i]->psz_name );        }        var_Change( p_input, "chapter", VLC_VAR_ADDCHOICE, &val, &text );        free( text.psz_string );    }}

void irc_PRIVMSG(void *handle, struct irc_msg_t *irc_msg){  intf_thread_t *intf = (intf_thread_t*)handle;  intf_sys_t *sys = intf->p_sys;  char *msg = irc_msg->trailing;  if(msg[0] == '>') {    char *cmd = msg+1;    if(var_Type(intf, cmd) & VLC_VAR_ISCOMMAND) {      vlc_value_t val;      var_Set(intf, cmd, val);    }  }}

static int ActivateFilter( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    if( !p_filter->b_allow_fmt_out_change || p_filter->psz_name == NULL )        return VLC_EGENERIC;    if( var_Type( p_filter->obj.parent, "chain-filter-level" ) != 0 )        return VLC_EGENERIC;    var_Create( p_filter, "chain-filter-level", VLC_VAR_INTEGER );    int i_ret = Activate( p_filter, BuildFilterChain );    var_Destroy( p_filter, "chain-filter-level" );    return i_ret;}

/***************************************************************************** * vout_RequestWindow: Create/Get a video window if possible. ***************************************************************************** * This function looks for the main interface and tries to request * a new video window. If it fails then the vout will still need to create the * window by itself. *****************************************************************************/void *vout_RequestWindow( vout_thread_t *p_vout,                          int *pi_x_hint, int *pi_y_hint,                          unsigned int *pi_width_hint,                          unsigned int *pi_height_hint ){    /* Small kludge */    if( !var_Type( p_vout, "aspect-ratio" ) ) vout_IntfInit( p_vout );    /* Get requested coordinates */    *pi_x_hint = var_GetInteger( p_vout, "video-x" );    *pi_y_hint = var_GetInteger( p_vout, "video-y" );    *pi_width_hint = p_vout->i_window_width;    *pi_height_hint = p_vout->i_window_height;    /* Check whether someone provided us with a window ID */    int drawable = var_CreateGetInteger( p_vout, "drawable" );    if( drawable ) return (void *)(intptr_t)drawable;    vout_window_t *wnd = vlc_custom_create (VLC_OBJECT(p_vout), sizeof (*wnd),                                            VLC_OBJECT_GENERIC, "window");    if (wnd == NULL)        return NULL;    wnd->vout = p_vout;    wnd->width = *pi_width_hint;    wnd->height = *pi_height_hint;    wnd->pos_x = *pi_x_hint;    wnd->pos_y = *pi_y_hint;    vlc_object_attach (wnd, p_vout);    wnd->module = module_Need (wnd, "vout window", 0, 0);    if (wnd->module == NULL)    {        msg_Dbg (wnd, "no window provider available");        vlc_object_release (wnd);        return NULL;    }    p_vout->p_window = wnd;    *pi_width_hint = wnd->width;    *pi_height_hint = wnd->height;    *pi_x_hint = wnd->pos_x;    *pi_y_hint = wnd->pos_y;    return wnd->handle;}

/** * Initializes list of devices. */static void Probe (vlc_object_t *obj){    /* Due to design bug in audio output core, this hack is required: */    if (var_Type (obj, "audio-device"))        return;    /* The variable does not exist - first call. */    vlc_value_t text;    var_Create (obj, "audio-device", VLC_VAR_STRING | VLC_VAR_HASCHOICE);    text.psz_string = _("Audio Device");    var_Change (obj, "audio-device", VLC_VAR_SETTEXT, &text, NULL);    GetDevices (obj, NULL);    var_AddCallback (obj, "audio-device", aout_ChannelsRestart, NULL);    var_TriggerCallback (obj, "intf-change");}

static bool IsMenuEmpty( const char *psz_var,                         vlc_object_t *p_object,                         bool b_root ){    vlc_value_t val, val_list;    int i_type, i_result, i;    /* Check the type of the object variable */    i_type = var_Type( p_object, psz_var );    /* Check if we want to display the variable */    if( !( i_type & VLC_VAR_HASCHOICE ) ) return false;    var_Change( p_object, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL );    if( val.i_int == 0 ) return true;    if( ( i_type & VLC_VAR_TYPE ) != VLC_VAR_VARIABLE )    {        if( val.i_int == 1 && b_root ) return true;        else return false;    }    /* Check children variables in case of VLC_VAR_VARIABLE */    if( var_Change( p_object, psz_var, VLC_VAR_GETLIST, &val_list, NULL ) < 0 )    {        return true;    }    for( i = 0, i_result = true; i < val_list.p_list->i_count; i++ )    {        if( !IsMenuEmpty( val_list.p_list->p_values[i].psz_string,                    p_object, false ) )        {            i_result = false;            break;        }    }    /* clean up everything */    var_FreeList( &val_list, NULL );    return i_result;}

static int vlclua_libvlc_command( lua_State *L ){    vlc_object_t * p_this = vlclua_get_this( L );    const char *psz_cmd;    vlc_value_t val_arg;    psz_cmd = luaL_checkstring( L, 1 );    val_arg.psz_string = strdup( luaL_optstring( L, 2, "" ) );    lua_pop( L, 2 );    int i_type = var_Type( p_this->p_libvlc, psz_cmd );    if( ! (i_type & VLC_VAR_ISCOMMAND) )    {        free( val_arg.psz_string );        return luaL_error( L, "libvlc's /"%s/" is not a command",                           psz_cmd );    }    return vlclua_push_ret( L,                            var_Set( p_this->p_libvlc, psz_cmd, val_arg ) );}

/***************************************************************************** * aout_ChannelsRestart : change the audio device or channels and restart *****************************************************************************/int aout_ChannelsRestart( vlc_object_t * p_this, const char * psz_variable,                          vlc_value_t oldval, vlc_value_t newval,                          void *p_data ){    aout_instance_t * p_aout = (aout_instance_t *)p_this;    (void)oldval;    (void)newval;    (void)p_data;    if ( !strcmp( psz_variable, "audio-device" ) )    {        /* This is supposed to be a significant change and supposes         * rebuilding the channel choices. */        if ( var_Type( p_aout, "audio-channels" ) >= 0 )        {            var_Destroy( p_aout, "audio-channels" );        }    }    aout_Restart( p_aout );    return 0;}

static int CreateChoicesMenu( intf_thread_t *p_intf, GtkMenu *submenu, const char *psz_var,                       vlc_object_t *p_object, bool b_root ){    vlc_value_t val, val_list, text_list;    int i_type, i;    /* Check the type of the object variable */    i_type = var_Type( p_object, psz_var );    /* Make sure we want to display the variable */    if( !g_list_length(GTK_MENU_SHELL(submenu)->children) &&        IsMenuEmpty( psz_var, p_object, b_root ) )        return VLC_EGENERIC;    switch( i_type & VLC_VAR_TYPE )    {        case VLC_VAR_VOID:        case VLC_VAR_BOOL:        case VLC_VAR_VARIABLE:        case VLC_VAR_STRING:        case VLC_VAR_INTEGER:        case VLC_VAR_FLOAT:            break;        default:            /* Variable doesn't exist or isn't handled */            return VLC_EGENERIC;    }    if( var_Change( p_object, psz_var, VLC_VAR_GETLIST,                    &val_list, &text_list ) < 0 )    {        return VLC_EGENERIC;    }#define CURVAL val_list.p_list->p_values[i]#define CURTEXT text_list.p_list->p_values[i].psz_string    for( i = 0; i < val_list.p_list->i_count; i++ )    {        vlc_value_t another_val;        char string[16] = {0};        char *menutext = string;        switch( i_type & VLC_VAR_TYPE )        {            case VLC_VAR_VARIABLE:              {                GtkWidget *subsubmenu = gtk_menu_new();                GtkWidget *submenuitem =                    gtk_menu_item_new_with_label( CURTEXT ? CURTEXT : CURVAL.psz_string );                gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenuitem), subsubmenu);                gtk_menu_append( submenu, submenuitem );                CreateChoicesMenu( p_intf, GTK_MENU(subsubmenu), CURVAL.psz_string, p_object, false );                break;              }            case VLC_VAR_STRING:                var_Get( p_object, psz_var, &val );                another_val.psz_string = strdup( CURVAL.psz_string );                menutext = CURTEXT ? CURTEXT : another_val.psz_string;                CreateAndConnect( p_intf, submenu, psz_var, menutext, "",                                  ITEM_RADIO, p_object, another_val, i_type,                        val.psz_string && !strcmp( val.psz_string, CURVAL.psz_string ) );                free( val.psz_string );                break;            case VLC_VAR_INTEGER:                var_Get( p_object, psz_var, &val );                if( CURTEXT ) menutext = CURTEXT;                else snprintf( menutext, sizeof(string)-1, "%"PRId64, CURVAL.i_int );                CreateAndConnect( p_intf, submenu, psz_var, menutext, "",                                  ITEM_RADIO, p_object, CURVAL, i_type,                        ( CURVAL.i_int == val.i_int )                        && CheckTitle( p_object, psz_var ) );                break;            case VLC_VAR_FLOAT:                var_Get( p_object, psz_var, &val );                if( CURTEXT ) menutext = CURTEXT;                else snprintf( menutext, sizeof(string)-1, "%.2f", CURVAL.f_float );                CreateAndConnect( p_intf, submenu, psz_var, menutext, "",                                  ITEM_RADIO, p_object, CURVAL, i_type,                                  CURVAL.f_float == val.f_float );                break;            default:                break;        }    }    /* clean up everything */    var_FreeList( &val_list, &text_list );#undef CURVAL#undef CURTEXT    return !g_list_length(GTK_MENU_SHELL(submenu)->children) ? VLC_EGENERIC : VLC_SUCCESS;}

static void UpdateItem( intf_thread_t *p_intf, GtkMenu *menu,                 const char *psz_var, vlc_object_t *p_object, bool b_submenu ){    vlc_value_t val, text;    int i_type;    /* Check the type of the object variable */    /* This HACK is needed so we have a radio button for audio and video tracks       instread of a checkbox */    if( !strcmp( psz_var, "audio-es" )     || !strcmp( psz_var, "video-es" ) )        i_type = VLC_VAR_INTEGER | VLC_VAR_HASCHOICE;    else        i_type = var_Type( p_object, psz_var );    switch( i_type & VLC_VAR_TYPE )    {        case VLC_VAR_VOID:        case VLC_VAR_BOOL:        case VLC_VAR_VARIABLE:        case VLC_VAR_STRING:        case VLC_VAR_INTEGER:        case VLC_VAR_FLOAT:            break;        default:            /* Variable doesn't exist or isn't handled */            return;    }    /* Make sure we want to display the variable */    if( !g_list_length(GTK_MENU_SHELL(menu)->children) && IsMenuEmpty( psz_var, p_object, true ) )    {        return;    }    /* Get the descriptive name of the variable */    int i_ret = var_Change( p_object, psz_var, VLC_VAR_GETTEXT, &text, NULL );    if( i_ret != VLC_SUCCESS )    {        text.psz_string = NULL;    }    /* Some specific stuff */    bool forceDisabled = false;    if( !strcmp( psz_var, "spu-es" ) )    {        vlc_object_t *p_vout = get_vout(p_intf);        forceDisabled = ( p_vout == NULL );        if( p_vout ) vlc_object_release( p_vout );    }    if( i_type & VLC_VAR_HASCHOICE )    {        /* Append choices menu */        if( b_submenu )        {            GtkWidget *item =                gtk_menu_item_new_with_label( text.psz_string ? text.psz_string : psz_var );            GtkWidget *submenu = gtk_menu_new( );            gtk_menu_append( menu, item );            gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);            if( CreateChoicesMenu( p_intf, GTK_MENU(submenu), psz_var, p_object, true ) )                gtk_widget_set_sensitive(item, false);            if( forceDisabled )                gtk_widget_set_sensitive(item, false);        }        else        {            if( CreateChoicesMenu( p_intf, menu, psz_var, p_object, true ) )                gtk_widget_set_sensitive(menu, false);        }        FREENULL( text.psz_string );        return;    }    switch( i_type & VLC_VAR_TYPE )    {        case VLC_VAR_VOID:            var_Get( p_object, psz_var, &val );            CreateAndConnect( p_intf, menu, psz_var, text.psz_string, "",                              ITEM_NORMAL, p_object, val, i_type, false );            break;        case VLC_VAR_BOOL:            var_Get( p_object, psz_var, &val );            val.b_bool = !val.b_bool;            CreateAndConnect( p_intf, menu, psz_var, text.psz_string, "",                              ITEM_CHECK, p_object, val, i_type, !val.b_bool );            break;    }    FREENULL( text.psz_string );}

/***************************************************************************** * Open: open the audio device *****************************************************************************/static int Open ( vlc_object_t *p_this ){    aout_instance_t *p_aout = (aout_instance_t *)p_this;    SDL_AudioSpec desired, obtained;    int i_nb_channels;    vlc_value_t val, text;    /* Check that no one uses the DSP. */    uint32_t i_flags = SDL_INIT_AUDIO;    if( SDL_WasInit( i_flags ) )    {        return VLC_EGENERIC;    }    i_flags |= SDL_INIT_EVENTTHREAD;#ifndef NDEBUG    /* In debug mode you may want vlc to dump a core instead of staying     * stuck */    i_flags |= SDL_INIT_NOPARACHUTE;#endif    /* Initialize library */    if( SDL_Init( i_flags ) < 0 )    {        msg_Err( p_aout, "cannot initialize SDL (%s)", SDL_GetError() );        return VLC_EGENERIC;    }    if( var_Get( p_aout, "audio-device", &val ) != VLC_ENOVAR )    {        /* The user has selected an audio device. */        if ( val.i_int == AOUT_VAR_STEREO )        {            p_aout->output.output.i_physical_channels                = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;        }        else if ( val.i_int == AOUT_VAR_MONO )        {            p_aout->output.output.i_physical_channels = AOUT_CHAN_CENTER;        }    }    i_nb_channels = aout_FormatNbChannels( &p_aout->output.output );    if ( i_nb_channels > 2 )    {        /* SDL doesn't support more than two channels. */        i_nb_channels = 2;        p_aout->output.output.i_physical_channels            = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;    }    desired.freq       = p_aout->output.output.i_rate;    desired.format     = AUDIO_S16SYS;    desired.channels   = i_nb_channels;    desired.callback   = SDLCallback;    desired.userdata   = p_aout;    desired.samples    = FRAME_SIZE;    /* Open the sound device. */    if( SDL_OpenAudio( &desired, &obtained ) < 0 )    {        return VLC_EGENERIC;    }    SDL_PauseAudio( 0 );    /* Now have a look at what we got. */    switch ( obtained.format )    {    case AUDIO_S16LSB:        p_aout->output.output.i_format = VLC_CODEC_S16L; break;    case AUDIO_S16MSB:        p_aout->output.output.i_format = VLC_CODEC_S16B; break;    case AUDIO_U16LSB:        p_aout->output.output.i_format = VLC_CODEC_U16L; break;    case AUDIO_U16MSB:        p_aout->output.output.i_format = VLC_CODEC_U16B; break;    case AUDIO_S8:        p_aout->output.output.i_format = VLC_CODEC_S8; break;    case AUDIO_U8:        p_aout->output.output.i_format = VLC_CODEC_U8; break;    }    /* Volume is entirely done in software. */    aout_VolumeSoftInit( p_aout );    if ( obtained.channels != i_nb_channels )    {        p_aout->output.output.i_physical_channels = (obtained.channels == 2 ?                                            AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT :                                            AOUT_CHAN_CENTER);        if ( var_Type( p_aout, "audio-device" ) == 0 )        {            var_Create( p_aout, "audio-device",                        VLC_VAR_INTEGER | VLC_VAR_HASCHOICE );            text.psz_string = _("Audio Device");            var_Change( p_aout, "audio-device", VLC_VAR_SETTEXT, &text, NULL );//.........这里部分代码省略.........

//.........这里部分代码省略.........                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 = "";        }        /* If the user typed a registered local command, try it */        if( var_Type( p_intf, psz_cmd ) & VLC_VAR_ISCOMMAND )        {            vlc_value_t val;            int i_ret;            val.psz_string = psz_arg;            i_ret = var_Set( p_intf, psz_cmd, val );            msg_rtci( "%s: returned %i (%s)/n",                    psz_cmd, i_ret, vlc_error( i_ret ) );        }        /* Or maybe it's a global command */        else if( var_Type( p_intf->p_libvlc, psz_cmd ) & VLC_VAR_ISCOMMAND )        {            vlc_value_t val;            int i_ret;            val.psz_string = psz_arg;            /* FIXME: it's a global command, but we should pass the             * local object as an argument, not p_intf->p_libvlc. */            i_ret = var_Set( p_intf->p_libvlc, psz_cmd, val );            if( i_ret != 0 )            {                msg_rtci( "%s: returned %i (%s)/n",                         psz_cmd, i_ret, vlc_error( i_ret ) );            }        }        else if( !strcmp( psz_cmd, "logout" ) )        {            /* Close connection */            if( p_intf->p_sys->i_socket != -1 )            {                net_Close( p_intf->p_sys->i_socket );            }

static void test_creation_and_type( libvlc_int_t *p_libvlc ){    vlc_value_t val;    val.i_int = 4212;    var_Create( p_libvlc, "bla", VLC_VAR_INTEGER );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER) );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER) );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND) );    var_Change( p_libvlc, "bla", VLC_VAR_SETMIN, &val, NULL );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN) );    var_Change( p_libvlc, "bla", VLC_VAR_SETMAX, &val, NULL );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN | VLC_VAR_HASMAX) );    var_Change( p_libvlc, "bla", VLC_VAR_SETSTEP, &val, NULL );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN | VLC_VAR_HASMAX | VLC_VAR_HASSTEP) );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );    var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER) );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND) );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASCHOICE) );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );    var_Create( p_libvlc, "bla", VLC_VAR_INTEGER );    var_Change( p_libvlc, "bla", VLC_VAR_SETMIN, &val, NULL );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN) );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMIN | VLC_VAR_HASCHOICE) );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );    var_Create( p_libvlc, "bla", VLC_VAR_INTEGER );    var_Change( p_libvlc, "bla", VLC_VAR_SETMAX, &val, NULL );    var_Change( p_libvlc, "bla", VLC_VAR_SETSTEP, &val, NULL );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMAX | VLC_VAR_HASSTEP) );    assert( var_Create( p_libvlc, "bla", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ) == VLC_SUCCESS );    assert( var_Type( p_libvlc, "bla" ) == (VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND | VLC_VAR_HASMAX | VLC_VAR_HASSTEP | VLC_VAR_HASCHOICE) );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    var_Destroy( p_libvlc, "bla" );    assert( var_Get( p_libvlc, "bla", &val ) == VLC_ENOVAR );}

static int vlclua_add_callback( lua_State *L ){    vlclua_callback_t *p_callback;    static int i_index = 0;    vlc_object_t **pp_obj = luaL_checkudata( L, 1, "vlc_object" );    const char *psz_var = luaL_checkstring( L, 2 );    lua_settop( L, 4 ); /* makes sure that optional data arg is set */    if( !lua_isfunction( L, 3 ) )        return vlclua_error( L );    if( !pp_obj || !*pp_obj )        return vlclua_error( L );    /* Check variable type, in order to avoid PANIC */    switch( var_Type( *pp_obj, psz_var ) )    {        case VLC_VAR_BOOL:        case VLC_VAR_INTEGER:        case VLC_VAR_STRING:        case VLC_VAR_FLOAT:        case VLC_VAR_TIME:            break;        case VLC_VAR_ADDRESS:        case VLC_VAR_VOID:        case VLC_VAR_MUTEX:        case VLC_VAR_LIST:        default:            return vlclua_error( L );    }    i_index++;    p_callback = (vlclua_callback_t*)malloc( sizeof( vlclua_callback_t ) );    if( !p_callback )        return vlclua_error( L );    /* obj var func data */    lua_getglobal( L, "vlc" );    /* obj var func data vlc */    lua_getfield( L, -1, "callbacks" );    if( lua_isnil( L, -1 ) )    {        lua_pop( L, 1 );        lua_newtable( L );        lua_setfield( L, -2, "callbacks" );        lua_getfield( L, -1, "callbacks" );    }    /* obj var func data vlc callbacks */    lua_remove( L, -2 );    /* obj var func data callbacks */    lua_pushinteger( L, i_index );    /* obj var func data callbacks index */    lua_insert( L, -4 );    /* obj var index func data callbacks */    lua_insert( L, -4 );    /* obj var callbacks index func data */    lua_createtable( L, 0, 0 );    /* obj var callbacks index func data cbtable */    lua_insert( L, -2 );    /* obj var callbacks index func cbtable data */    lua_setfield( L, -2, "data" );    /* obj var callbacks index func cbtable */    lua_insert( L, -2 );    /* obj var callbacks index cbtable func */    lua_setfield( L, -2, "callback" );    /* obj var callbacks index cbtable */    lua_pushlightuserdata( L, *pp_obj ); /* will be needed in vlclua_del_callback */    /* obj var callbacks index cbtable p_obj */    lua_setfield( L, -2, "private1" );    /* obj var callbacks index cbtable */    lua_pushvalue( L, 2 ); /* will be needed in vlclua_del_callback */    /* obj var callbacks index cbtable var */    lua_setfield( L, -2, "private2" );    /* obj var callbacks index cbtable */    lua_pushlightuserdata( L, p_callback ); /* will be needed in vlclua_del_callback */    /* obj var callbacks index cbtable p_callback */    lua_setfield( L, -2, "private3" );    /* obj var callbacks index cbtable */    lua_settable( L, -3 );    /* obj var callbacks */    lua_pop( L, 3 );    /* <empty stack> */    /* Do not move this before the lua specific code (it somehow changes     * the function in the stack to nil) */    p_callback->i_index = i_index;    p_callback->i_type = var_Type( *pp_obj, psz_var );    p_callback->L = lua_newthread( L ); /* Do we have to keep a reference to this thread somewhere to prevent garbage collection? */    var_AddCallback( *pp_obj, psz_var, vlclua_callback, p_callback );    return 0;}