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

/** * Checks for help command line options such as --help or --version. * If one is found, print the corresponding text. * /return true if a command line options caused some help message to be * printed, false otherwise.  */bool config_PrintHelp (vlc_object_t *obj){    char *str;    /* Check for short help option */    if (var_InheritBool (obj, "help"))    {        Help (obj, "help");        return true;    }    /* Check for version option */    if (var_InheritBool (obj, "version"))    {        Version();        return true;    }    /* Check for help on modules */    str = var_InheritString (obj, "module");    if (str != NULL)    {        Help (obj, str);        free (str);        return true;    }    /* Check for full help option */    if (var_InheritBool (obj, "full-help"))    {        var_Create (obj, "advanced", VLC_VAR_BOOL);        var_SetBool (obj, "advanced", true);        var_Create (obj, "help-verbose", VLC_VAR_BOOL);        var_SetBool (obj, "help-verbose", true);        Help (obj, "full-help");        return true;    }    /* Check for long help option */    if (var_InheritBool (obj, "longhelp"))    {        Help (obj, "longhelp");        return true;    }    /* Check for module list option */    if (var_InheritBool (obj, "list"))    {        ListModules (obj, false );        return true;    }    if (var_InheritBool (obj, "list-verbose"))    {        ListModules (obj, true);        return true;    }    return false;}

static int Mouse( filter_t *p_filter, vlc_mouse_t *p_mouse,                  const vlc_mouse_t *p_old, const vlc_mouse_t *p_new ){    filter_sys_t *p_sys = p_filter->p_sys;    vlc_mutex_lock( &p_sys->lock );    logo_t *p_logo = LogoListCurrent( &p_sys->list );    const picture_t *p_pic = p_logo->p_pic;    if( p_pic )    {        const video_format_t *p_fmt = &p_pic->format;        const int i_logo_w = p_fmt->i_visible_width;        const int i_logo_h = p_fmt->i_visible_height;        /* Check if we are over the logo */        const bool b_over = p_new->i_x >= p_sys->i_pos_x &&                            p_new->i_x <  p_sys->i_pos_x + i_logo_w &&                            p_new->i_y >= p_sys->i_pos_y &&                            p_new->i_y <  p_sys->i_pos_y + i_logo_h;        if( b_over && vlc_mouse_HasPressed( p_old, p_new, MOUSE_BUTTON_LEFT ) )            p_sys->b_mouse_grab = true;        else if( vlc_mouse_HasReleased( p_old, p_new, MOUSE_BUTTON_LEFT ) )            p_sys->b_mouse_grab = false;        if( p_sys->b_mouse_grab )        {            int i_dx, i_dy;            vlc_mouse_GetMotion( &i_dx, &i_dy, p_old, p_new );            p_sys->i_pos_x = __MIN( __MAX( p_sys->i_pos_x + i_dx, 0 ),                                    p_filter->fmt_in.video.i_width  - i_logo_w );            p_sys->i_pos_y = __MIN( __MAX( p_sys->i_pos_y + i_dy, 0 ),                                    p_filter->fmt_in.video.i_height - i_logo_h );            /* object under mouse has moved */            var_SetBool( p_filter->p_parent, "mouse-object", true );        }        else if( b_over )        {            /* object under mouse stoped moving */            var_SetBool( p_filter->p_parent, "mouse-object", false );        }        if( p_sys->b_mouse_grab || b_over )        {            vlc_mutex_unlock( &p_sys->lock );            return VLC_EGENERIC;        }    }    vlc_mutex_unlock( &p_sys->lock );    *p_mouse = *p_new;    return VLC_SUCCESS;}

void libvlc_media_player_set_video_title_display( libvlc_media_player_t *p_mi, libvlc_position_t position, unsigned timeout ){    if ( position != libvlc_position_disable )    {        var_SetBool( p_mi, "video-title-show", true );        var_SetInteger( p_mi, "video-title-position", position );        var_SetInteger( p_mi, "video-title-timeout", timeout );    }    else    {        var_SetBool( p_mi, "video-title-show", false );    }}

void libvlc_media_player_set_video_title_display( libvlc_media_player_t *p_mi, libvlc_position_t position, unsigned timeout ){    assert( position >= libvlc_position_disable && position <= libvlc_position_bottom_right );    if ( position != libvlc_position_disable )    {        var_SetBool( p_mi, "video-title-show", true );        var_SetInteger( p_mi, "video-title-position", position_subpicture_alignment[position] );        var_SetInteger( p_mi, "video-title-timeout", timeout );    }    else    {        var_SetBool( p_mi, "video-title-show", false );    }}

void libvlc_set_fullscreen( libvlc_media_player_t *p_mi, int b_fullscreen ){    /* This will work even if the video is not currently active */    var_SetBool (p_mi, "fullscreen", !!b_fullscreen);    /* Apply to current video outputs (if any) */    size_t n;    vout_thread_t **pp_vouts = GetVouts (p_mi, &n);    for (size_t i = 0; i < n; i++)    {        var_SetBool (pp_vouts[i], "fullscreen", b_fullscreen);        vlc_object_release (pp_vouts[i]);    }    free (pp_vouts);}

void libvlc_toggle_teletext( libvlc_media_player_t *p_mi,                             libvlc_exception_t *p_e ){    input_thread_t *p_input_thread;    vlc_object_t *p_vbi;    int i_ret;    p_input_thread = libvlc_get_input_thread(p_mi, p_e);    if( !p_input_thread ) return;    p_vbi = (vlc_object_t *) vlc_object_find_name( p_input_thread, "zvbi",                                                   FIND_ANYWHERE );    if( p_vbi )    {        const int i_teletext_es = var_GetInteger( p_input_thread, "teletext-es" );        const int i_spu_es = var_GetInteger( p_input_thread, "spu-es" );        if( (i_teletext_es >= 0) && (i_teletext_es == i_spu_es) )        {            int i_page = 100;            i_page = var_GetInteger( p_vbi, "vbi-page" );            i_page = (i_teletext_es >= 0) ? i_page : 0;            i_ret = var_SetInteger( p_vbi, "vbi-page", i_page );            if( i_ret )                libvlc_exception_raise( p_e,                                "Unexpected error while setting teletext page" );        }        else if( i_teletext_es >= 0 )        {            bool opaque = true;            opaque = var_GetBool( p_vbi, "vbi-opaque" );            i_ret = var_SetBool( p_vbi, "vbi-opaque", !opaque );            if( i_ret )                libvlc_exception_raise( p_e,                                "Unexpected error while setting teletext transparency" );        }        vlc_object_release( p_vbi );    }    else    {        /* Teletext is not enabled yet, so enable it.         * Only after it is enable it is possible to view teletext pages         */        const int i_teletext_es = var_GetInteger( p_input_thread, "teletext-es" );        if( i_teletext_es >= 0 )        {            const int i_spu_es = var_GetInteger( p_input_thread, "spu-es" );            if( i_teletext_es == i_spu_es )                var_SetInteger( p_input_thread, "spu-es", -1 );            else                var_SetInteger( p_input_thread, "spu-es", i_teletext_es );        }    }    vlc_object_release( p_input_thread );}

/***************************************************************************** * DesktopCallback: desktop mode variable callback *****************************************************************************/static int DesktopCallback(vlc_object_t *object, char const *psz_cmd,                            vlc_value_t oldval, vlc_value_t newval,                            void *p_data){    vout_display_t *vd = (vout_display_t *)object;    vout_display_sys_t *sys = vd->sys;    VLC_UNUSED(psz_cmd);    VLC_UNUSED(oldval);    VLC_UNUSED(p_data);    vlc_mutex_lock(&sys->lock);    const bool ch_desktop = !sys->desktop_requested != !newval.b_bool;    sys->ch_desktop |= ch_desktop;    sys->desktop_requested = newval.b_bool;    vlc_mutex_unlock(&sys->lock);    /* FIXME we should have a way to export variable to be saved */    if (ch_desktop) {        /* Modify playlist as well because the vout might have to be         * restarted */        var_Create(object->p_parent, "video-wallpaper", VLC_VAR_BOOL);        var_SetBool(object->p_parent, "video-wallpaper", newval.b_bool);    }    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;}

int vlclua_var_toggle_or_set( lua_State *L, vlc_object_t *p_obj,                              const char *psz_name ){    bool b_bool;    if( lua_gettop( L ) > 1 ) return vlclua_error( L );    if( lua_gettop( L ) == 0 )    {        b_bool = var_ToggleBool( p_obj, psz_name );        goto end;    }    /* lua_gettop( L ) == 1 */    const char *s = luaL_checkstring( L, -1 );    lua_pop( L, 1 );    if( s && !strcmp(s, "on") )        b_bool = true;    else if( s && !strcmp(s, "off") )        b_bool = false;    else    {        b_bool = var_GetBool( p_obj, psz_name );        goto end;    }    if( b_bool != var_GetBool( p_obj, psz_name ) )        var_SetBool( p_obj, psz_name, b_bool );end:    lua_pushboolean( L, b_bool );    return 1;}

/***************************************************************************** * InitWindow: get embedded window and init X11 *****************************************************************************/static int InitWindow( vout_thread_t *p_vout ){    vout_sys_t *p_sys = (vout_sys_t *)p_vout->p_sys;    if( p_sys->b_embed )    {        p_sys->p_display = XOpenDisplay( NULL );        // Request window from interface        p_sys->owner_window =            vout_RequestXWindow( p_vout,                                &p_sys->embedded_window.i_x,                                &p_sys->embedded_window.i_y,                                &p_sys->embedded_window.i_width,                                &p_sys->embedded_window.i_height );        p_sys->main_window = p_sys->embedded_window;        // We have to create a new window to get some events        // (ButtonPress for example)        CreateWindow( p_sys );    }    else    {        // No embedding, fullscreen framebuffer overlay with no events handling        p_sys->main_window.i_x = p_sys->main_window.i_y = 0;        p_sys->main_window.i_width = p_sys->fb_vinfo.xres;        p_sys->main_window.i_height = p_sys->fb_vinfo.yres;        p_vout->b_fullscreen = true;        var_SetBool( p_vout, "fullscreen", p_vout->b_fullscreen );    }    return VLC_SUCCESS;}

void ExtraPanel::OnEq2Pass( wxCommandEvent &event ){    aout_instance_t *p_aout= (aout_instance_t *)vlc_object_find(p_intf,                                 VLC_OBJECT_AOUT, FIND_ANYWHERE);    vlc_bool_t b_2p = event.IsChecked() ? VLC_TRUE : VLC_FALSE;    if( p_aout == NULL )    {        config_PutInt( p_intf, "equalizer-2pass", b_2p );    }    else    {        var_SetBool( p_aout, "equalizer-2pass", b_2p );        config_PutInt( p_intf, "equalizer-2pass", b_2p );        if( eq_chkbox->IsChecked() )        {            for( int i = 0; i < p_aout->i_nb_inputs; i++ )            {                p_aout->pp_inputs[i]->b_restart = VLC_TRUE;            }        }        vlc_object_release( p_aout );    }}

void input_SendEventProgramScrambled( input_thread_t *p_input, int i_group, bool b_scrambled ){    if( var_GetInteger( p_input, "program" ) != i_group )        return;    var_SetBool( p_input, "program-scrambled", b_scrambled );    Trigger( p_input, INPUT_EVENT_PROGRAM );}

void libvlc_playlist_loop( libvlc_instance_t *p_instance, int loop,                           libvlc_exception_t *p_e){    VLC_UNUSED(p_e);    assert( PL );    var_SetBool( PL, "loop", loop );}

/* Set the transparency on teletext */void InputManager::telexSetTransparency( bool b_transparentTelextext ){    if( hasInput() && p_input_vbi )    {        var_SetBool( p_input_vbi, "vbi-opaque", !b_transparentTelextext );        emit teletextTransparencyActivated( b_transparentTelextext );    }}

/***************************************************************************** * RunIntf: main loop *****************************************************************************/static void RunIntf( intf_thread_t *p_intf ){    int canc = vlc_savecancel( );    /* Main loop */    while( vlc_object_alive( p_intf ) )    {        vlc_mutex_lock( &p_intf->p_sys->lock );        /* Notify the interfaces */        if( p_intf->p_sys->b_triggered )        {            var_SetBool( p_intf->p_libvlc, "intf-show", true );            p_intf->p_sys->b_triggered = false;        }        vlc_mutex_unlock( &p_intf->p_sys->lock );        /* Take care of the video output */        if( p_intf->p_sys->p_vout && !vlc_object_alive (p_intf->p_sys->p_vout) )        {            var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",                             MouseEvent, p_intf );            var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",                             MouseEvent, p_intf );            vlc_object_release( p_intf->p_sys->p_vout );            p_intf->p_sys->p_vout = NULL;        }        if( p_intf->p_sys->p_vout == NULL )        {            p_intf->p_sys->p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,                                                     FIND_ANYWHERE );            if( p_intf->p_sys->p_vout )            {                var_AddCallback( p_intf->p_sys->p_vout, "mouse-moved",                                 MouseEvent, p_intf );                var_AddCallback( p_intf->p_sys->p_vout, "mouse-button-down",                                 MouseEvent, p_intf );            }        }        /* Wait a bit */        msleep( INTF_IDLE_SLEEP );    }    if( p_intf->p_sys->p_vout )    {        var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",                         MouseEvent, p_intf );        var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",                         MouseEvent, p_intf );        vlc_object_release( p_intf->p_sys->p_vout );    }    vlc_restorecancel( canc );}

/**  * TODO * This functions toggle the fullscreen mode * If there is no video, it should first activate Visualisations... *  This has also to be fixed in enableVideo() */void ActionsManager::fullscreen(){    vout_thread_t *p_vout = THEMIM->getVout();    if( p_vout)    {        var_SetBool( p_vout, "fullscreen", !var_GetBool( p_vout, "fullscreen" ) );        vlc_object_release( p_vout );    }}

/** * Supply or update the current custom ("hardware") volume. * @note This only makes sense after calling aout_VolumeHardInit(). * @param setter volume setter callback * @param volume current custom volume * @param mute current mute flag * * @warning The caller (i.e. the audio output plug-in) is responsible for * interlocking and synchronizing call to this function and to the * audio_output_t.pf_volume_set callback. This ensures that VLC gets correct * volume information (possibly with a latency). */void aout_VolumeHardSet (audio_output_t *aout, float volume, bool mute){    audio_volume_t vol = lroundf (volume * (float)AOUT_VOLUME_DEFAULT);    /* We cannot acquire the volume lock as this gets called from the audio     * output plug-in (it would cause a lock inversion). */    var_SetInteger (aout, "volume", vol);    var_SetBool (aout, "mute", mute);    var_TriggerCallback (aout, "intf-change");}

void ExitFullscreen( vout_thread_t *p_vout ){    if( p_vout->b_fullscreen )    {        msg_Dbg( p_vout, "Quitting fullscreen" );        Win32ToggleFullscreen( p_vout );        /* Force fullscreen in the core for the next video */        var_SetBool( p_vout, "fullscreen", true );    }}

/** * TODO * This functions toggle the fullscreen mode * If there is no video, it should first activate Visualisations... * This has also to be fixed in enableVideo() */void ActionsManager::fullscreen(){    bool fs = var_ToggleBool( THEPL, "fullscreen" );    vout_thread_t *p_vout = THEMIM->getVout();    if( p_vout)    {        var_SetBool( p_vout, "fullscreen", fs );        vlc_object_release( p_vout );    }}

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

void libvlc_set_fullscreen( libvlc_media_player_t *p_mi, int b_fullscreen,                            libvlc_exception_t *p_e ){    /* We only work on the first vout */    vout_thread_t *p_vout = GetVout( p_mi, p_e );    /* GetVout will raise the exception for us */    if( !p_vout ) return;    var_SetBool( p_vout, "fullscreen", b_fullscreen );    vlc_object_release( p_vout );}

void CmdFullscreen::execute(){    bool fs = var_ToggleBool( pl_Get( getIntf() ), "fullscreen" );    if( getIntf()->p_sys->p_input == NULL )        return;    vout_thread_t *pVout = input_GetVout( getIntf()->p_sys->p_input );    if( pVout )    {        // Switch fullscreen        var_SetBool( pVout, "fullscreen", fs );        vlc_object_release( pVout );    }}

void vout_SetInterlacingState(vout_thread_t *vout, vout_interlacing_support_t *state, bool is_interlaced){     /* Wait 30s before quiting interlacing mode */    const int interlacing_change = (!!is_interlaced) - (!!state->is_interlaced);    if ((interlacing_change == 1) ||        (interlacing_change == -1 && state->date + 30000000 < mdate())) {        msg_Dbg(vout, "Detected %s video",                 is_interlaced ? "interlaced" : "progressive");        var_SetBool(vout, "deinterlace-needed", is_interlaced);        state->is_interlaced = is_interlaced;    }    if (is_interlaced)        state->date = mdate();}

void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi,                               libvlc_exception_t *p_e ){    /* We only work on the first vout */    vout_thread_t *p_vout = GetVout( p_mi, p_e );    bool ret;    /* GetVout will raise the exception for us */    if( !p_vout ) return;    ret = var_GetBool( p_vout, "fullscreen" );    var_SetBool( p_vout, "fullscreen", !ret );    vlc_object_release( p_vout );}

static int EsSpuCallback( 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( psz_cmd); VLC_UNUSED( oldval ); VLC_UNUSED( p_data );    if( newval.i_int < 0 )        newval.i_int = -SPU_ES; /* disable spu es */    else        var_SetBool( p_input, "spu", true );    input_ControlPush( p_input, INPUT_CONTROL_SET_ES, &newval );    return VLC_SUCCESS;}

void libvlc_toggle_fullscreen( libvlc_media_player_t *p_mi ){    bool b_fullscreen = var_ToggleBool (p_mi, "fullscreen");    /* Apply to current video outputs (if any) */    size_t n;    vout_thread_t **pp_vouts = GetVouts (p_mi, &n);    for (size_t i = 0; i < n; i++)    {        vout_thread_t *p_vout = pp_vouts[i];        var_SetBool (p_vout, "fullscreen", b_fullscreen);        vlc_object_release (p_vout);    }    free (pp_vouts);}

void vout_SetInterlacingState(vout_thread_t *vout, bool is_interlaced){     /* Wait 30s before quiting interlacing mode */    const int interlacing_change = (!!is_interlaced)                                 - (!!vout->p->interlacing.is_interlaced);    if (interlacing_change == 1 ||        (interlacing_change == -1 &&        vout->p->interlacing.date + VLC_TICK_FROM_SEC(30) < vlc_tick_now()))    {        msg_Dbg(vout, "Detected %s video",                 is_interlaced ? "interlaced" : "progressive");        var_SetBool(vout, "deinterlace-needed", is_interlaced);        vout->p->interlacing.is_interlaced = is_interlaced;    }    if (is_interlaced)        vout->p->interlacing.date = vlc_tick_now();}

int __vlclua_var_toggle_or_set( lua_State *L, vlc_object_t *p_obj,                                const char *psz_name ){    bool b_bool;    if( lua_gettop( L ) > 1 ) return vlclua_error( L );    if( lua_gettop( L ) == 0 )        b_bool = var_ToggleBool( p_obj, psz_name );    else /* lua_gettop( L ) == 1 */    {        b_bool = luaL_checkboolean( L, -1 );        lua_pop( L, 1 );        if( b_bool != var_GetBool( p_obj, psz_name ) )            var_SetBool( p_obj, psz_name, b_bool );    }    lua_pushboolean( L, b_bool );    return 1;}