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

/***************************************************************************** * Activate: initialize and create stuff *****************************************************************************/static int Open(vlc_object_t *object){    intf_thread_t *intf = (intf_thread_t*)object;    intf_sys_t    *sys;    int fd;    if (!var_InheritBool(intf, "netsync-master")) {        char *psz_master = var_InheritString(intf, "netsync-master-ip");        if (psz_master == NULL) {            msg_Err(intf, "master address not specified");            return VLC_EGENERIC;        }        fd = net_ConnectUDP(VLC_OBJECT(intf), psz_master, NETSYNC_PORT, -1);        free(psz_master);    } else {        fd = net_ListenUDP1(VLC_OBJECT(intf), NULL, NETSYNC_PORT);    }    if (fd == -1) {        msg_Err(intf, "Netsync socket failure");        return VLC_EGENERIC;    }    intf->p_sys = sys = malloc(sizeof(*sys));    if (!sys) {        net_Close(fd);        return VLC_ENOMEM;    }    sys->fd = fd;    sys->is_master = var_InheritBool(intf, "netsync-master");    sys->timeout = var_InheritInteger(intf, "netsync-timeout");    if (sys->timeout < 500)        sys->timeout = 500;    sys->playlist = pl_Get(intf);    sys->input = NULL;    var_AddCallback(sys->playlist, "input-current", PlaylistEvent, intf);    return VLC_SUCCESS;}

/***************************************************************************** * Open: initialize and create stuff *****************************************************************************/static int Open( vlc_object_t *p_this ){    intf_thread_t   *p_intf = (intf_thread_t *)p_this;    intf_sys_t      *p_sys  = malloc( sizeof( *p_sys ) );    if( !p_sys )        return VLC_ENOMEM;    if( !notify_init( APPLICATION_NAME ) )    {        free( p_sys );        msg_Err( p_intf, "can't find notification daemon" );        return VLC_EGENERIC;    }    p_intf->p_sys = p_sys;    vlc_mutex_init( &p_sys->lock );    p_sys->notification = NULL;    p_sys->b_has_actions = false;    GList *p_caps = notify_get_server_caps ();    if( p_caps )    {        for( GList *c = p_caps; c != NULL; c = c->next )        {            if( !strcmp( (char*)c->data, "actions" ) )            {                p_sys->b_has_actions = true;                break;            }        }        g_list_foreach( p_caps, (GFunc)g_free, NULL );        g_list_free( p_caps );    }    /* */    var_AddCallback( pl_Get( p_intf ), "item-current", ItemChange, p_intf );    return VLC_SUCCESS;}

int vlc_InitActions (libvlc_int_t *libvlc){    struct hotkey *keys;    var_Create (libvlc, "key-pressed", VLC_VAR_INTEGER);    var_Create (libvlc, "key-action", VLC_VAR_INTEGER);    keys = malloc ((libvlc_actions_count + 1) * sizeof (*keys));    if (keys == NULL)    {        libvlc->p_hotkeys = NULL;        return VLC_ENOMEM;    }    /* Initialize from configuration */    for (size_t i = 0; i < libvlc_actions_count; i++)    {        keys[i].psz_action = libvlc_actions[i].name;        keys[i].i_key = var_InheritInteger (libvlc, libvlc_actions[i].name );        keys[i].i_action = libvlc_actions[i].value;#ifndef NDEBUG        if (i > 0         && strcmp (libvlc_actions[i-1].name, libvlc_actions[i].name) >= 0)        {            msg_Err (libvlc, "%s and %s are not ordered properly",                     libvlc_actions[i-1].name, libvlc_actions[i].name);            abort ();        }#endif    }    qsort (keys, libvlc_actions_count, sizeof (*keys), keycmp);    keys[libvlc_actions_count].psz_action = NULL;    keys[libvlc_actions_count].i_key = 0;    keys[libvlc_actions_count].i_action = 0;    libvlc->p_hotkeys = keys;    var_AddCallback (libvlc, "key-pressed", vlc_key_to_action, NULL);    return VLC_SUCCESS;}

/***************************************************************************** * TrackChange: callback on playlist "item-current" *****************************************************************************/static int TrackChange( intf_thread_t *p_intf ){    intf_sys_t          *p_sys      = p_intf->p_sys;    playlist_t          *p_playlist;    input_thread_t      *p_input    = NULL;    input_item_t        *p_item     = NULL;    if( p_intf->p_sys->b_dead )        return VLC_SUCCESS;    p_sys->b_meta_read = false;    p_playlist = pl_Hold( p_intf );    p_input = playlist_CurrentInput( p_playlist );    if( !p_input )    {        pl_Release( p_intf );        return VLC_SUCCESS;    }    pl_Release( p_intf );    p_item = input_GetItem( p_input );    if( !p_item )    {        vlc_object_release( p_input );        return VLC_EGENERIC;    }    if( input_item_IsPreparsed( p_item ) )    {        p_sys->b_meta_read = true;        TrackChangeSignal( p_sys->p_conn, p_item );    }    var_AddCallback( p_input, "state", AllCallback, p_intf );    vlc_object_release( p_input );    return VLC_SUCCESS;}

void InputManager::UpdateTeletext(){    const bool b_enabled = var_CountChoices( p_input, "teletext-es" ) > 0;    const int i_teletext_es = var_GetInteger( p_input, "teletext-es" );    /* Teletext is possible. Show the buttons */    emit teletextPossible( b_enabled );    /* If Teletext is selected */    if( b_enabled && i_teletext_es >= 0 )    {        /* Then, find the current page */        int i_page = 100;        bool b_transparent = false;        if( p_input_vbi )        {            var_DelCallback( p_input_vbi, "vbi-page", VbiEvent, this );            vlc_object_release( p_input_vbi );        }        if( input_GetEsObjects( p_input, i_teletext_es, &p_input_vbi, NULL, NULL ) )            p_input_vbi = NULL;        if( p_input_vbi )        {            /* This callback is not remove explicitly, but interfaces             * are guaranted to outlive input */            var_AddCallback( p_input_vbi, "vbi-page", VbiEvent, this );            i_page = var_GetInteger( p_input_vbi, "vbi-page" );            b_transparent = !var_GetBool( p_input_vbi, "vbi-opaque" );        }        emit newTelexPageSet( i_page );        emit teletextTransparencyActivated( b_transparent );    }    emit teletextActivated( b_enabled && i_teletext_es >= 0 );}

static int OpenPitch( vlc_object_t *p_this ){    int err = Open( p_this );    if( err )        return err;    filter_t     *p_filter = (filter_t *)p_this;    vlc_object_t *p_aout = p_filter->obj.parent;    filter_sys_t *p_sys = p_filter->p_sys;    float pitch_shift  = var_CreateGetFloat( p_aout, "pitch-shift" );    var_AddCallback( p_aout, "pitch-shift", PitchCallback, p_sys );    PitchSetRateShift( p_sys, pitch_shift );    p_sys->resampler = ResamplerCreate(p_filter);    if( !p_sys->resampler )        return VLC_EGENERIC;    p_filter->pf_audio_filter = DoPitchWork;    return VLC_SUCCESS;}

/***************************************************************************** * OpenIntf: initialize dummy interface *****************************************************************************/int E_(OpenIntf) ( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;    msg_Dbg( p_intf, "VCDOpenIntf" );    /* Allocate instance and initialize some members */    p_intf->p_sys = malloc( sizeof( intf_sys_t ) );    if( p_intf->p_sys == NULL )    {        return( 1 );    };    p_intf->pf_run = RunIntf;    var_AddCallback( p_intf->p_vlc, "key-pressed", KeyEvent, p_intf );    p_intf->p_sys->m_still_time = 0;    p_intf->p_sys->b_inf_still = 0;    p_intf->p_sys->b_still = 0;    return( 0 );}

static int InputChange( vlc_object_t *p_playlist, const char *var,                        vlc_value_t prev, vlc_value_t value, void *data ){    intf_thread_t *p_intf = data;    intf_sys_t *p_sys = p_intf->p_sys;    if( p_sys->p_input )    {        var_DelCallback( p_sys->p_input, "state", StateChange, p_intf );        vlc_object_release( p_sys->p_input );    }    p_sys->p_input = VLC_OBJECT(playlist_CurrentInput( p_sys->p_playlist ));    if( p_sys->p_input )    {        Inhibit( p_intf, FREEDESKTOP );        Inhibit( p_intf, GNOME );        var_AddCallback( p_sys->p_input, "state", StateChange, p_intf );    }    (void)var; (void)prev; (void)value; (void)p_playlist;    return VLC_SUCCESS;}

/***************************************************************************** * Open: initialize and create stuff *****************************************************************************/static int Open(vlc_object_t *p_this){    intf_thread_t   *p_intf     = (intf_thread_t*) p_this;    intf_sys_t      *p_sys      = calloc(1, sizeof(intf_sys_t));    msg_Dbg(p_intf, "Entering Open()");    if (!p_sys)        return VLC_ENOMEM;    p_intf->p_sys = p_sys;    vlc_mutex_init(&p_sys->lock);    vlc_cond_init(&p_sys->wait);    var_AddCallback(pl_Get(p_intf), "item-current", ItemChange, p_intf);    msg_Dbg(p_intf, "Added Item Change Callback");    p_intf->pf_run = Run;    return VLC_SUCCESS;}

bool Dialogs::init(){    // Allocate descriptor    m_pProvider = (intf_thread_t *)vlc_object_create( getIntf(),                                                    sizeof( intf_thread_t ) );    if( m_pProvider == NULL )        return false;    m_pModule = module_need( m_pProvider, "dialogs provider", NULL, false );    if( m_pModule == NULL )    {        msg_Err( getIntf(), "no suitable dialogs provider found (hint: compile the qt4 plugin, and make sure it is loaded properly)" );        vlc_object_release( m_pProvider );        m_pProvider = NULL;        return false;    }    /* Register callback for the intf-popupmenu variable */    var_AddCallback( getIntf()->p_libvlc, "intf-popupmenu",                     PopupMenuCB, this );    return true;}

/** * Creates a software amplifier. */aout_volume_t *aout_volume_New(vlc_object_t *parent,                               const audio_replay_gain_t *gain){    aout_volume_t *vol = vlc_custom_create(parent, sizeof (aout_volume_t),                                           "volume");    if (unlikely(vol == NULL))        return NULL;    vol->module = NULL;    vol->output_factor = 1.f;    //audio_volume_t *obj = &vol->object;    /* Gain */    if (gain != NULL)        memcpy(&vol->replay_gain, gain, sizeof (vol->replay_gain));    else        memset(&vol->replay_gain, 0, sizeof (vol->replay_gain));    var_AddCallback(parent, "audio-replay-gain-mode",                    ReplayGainCallback, vol);    var_TriggerCallback(parent, "audio-replay-gain-mode");    return vol;}

/***************************************************************************** * Create *****************************************************************************/static int Create( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    const vlc_chroma_description_t *p_chroma =        vlc_fourcc_GetChromaDescription( p_filter->fmt_in.video.i_chroma );    if( p_chroma == NULL || p_chroma->plane_count == 0 )        return VLC_EGENERIC;    /* Allocate structure */    filter_sys_t *p_sys = malloc( sizeof( filter_sys_t ) );    if( p_sys == NULL )        return VLC_ENOMEM;    p_filter->p_sys = p_sys;    p_sys->p_tmp = picture_NewFromFormat( &p_filter->fmt_in.video );    if( !p_sys->p_tmp )    {        free( p_sys );        return VLC_ENOMEM;    }    p_sys->b_first = true;    p_filter->pf_video_filter = Filter;    config_ChainParse( p_filter, FILTER_PREFIX, ppsz_filter_options,                       p_filter->p_cfg );    atomic_init( &p_sys->i_factor,             var_CreateGetIntegerCommand( p_filter, FILTER_PREFIX "factor" ) );    var_AddCallback( p_filter, FILTER_PREFIX "factor",                     MotionBlurCallback, p_sys );    return VLC_SUCCESS;}

int vout_OpenWrapper(vout_thread_t *vout,                     const char *splitter_name, const vout_display_state_t *state){    vout_thread_sys_t *sys = vout->p;    msg_Dbg(vout, "Opening vout display wrapper");    /* */    sys->display.title = var_CreateGetNonEmptyString(vout, "video-title");    /* */    const mtime_t double_click_timeout = 300000;    const mtime_t hide_timeout = var_CreateGetInteger(vout, "mouse-hide-timeout") * 1000;    if (splitter_name) {        sys->display.vd = vout_NewSplitter(vout, &vout->p->original, state, "$vout", splitter_name,                                           double_click_timeout, hide_timeout);    } else {        sys->display.vd = vout_NewDisplay(vout, &vout->p->original, state, "$vout",                                          double_click_timeout, hide_timeout);    }    if (!sys->display.vd) {        free(sys->display.title);        return VLC_EGENERIC;    }    /* */#ifdef WIN32    var_Create(vout, "video-wallpaper", VLC_VAR_BOOL|VLC_VAR_DOINHERIT);    var_AddCallback(vout, "video-wallpaper", Forward, NULL);#endif    /* */    sys->decoder_pool = NULL;    return VLC_SUCCESS;}

/* Add the callbacks on Input. Self explanatory */inline void InputManager::addCallbacks(){    var_AddCallback( p_input, "intf-event", InputEvent, this );}

//.........这里部分代码省略.........    {        p_sys->f_alpha[i] = cfg.band[i].f_alpha;        p_sys->f_beta[i]  = cfg.band[i].f_beta;        p_sys->f_gamma[i] = cfg.band[i].f_gamma;    }    /* Filter dyn config */    p_sys->b_2eqz = false;    p_sys->f_gamp = 1.0f;    p_sys->f_amp  = malloc( p_sys->i_band * sizeof(float) );    if( !p_sys->f_amp )        goto error;    for( i = 0; i < p_sys->i_band; i++ )    {        p_sys->f_amp[i] = 0.0f;    }    /* Filter state */    for( ch = 0; ch < 32; ch++ )    {        p_sys->x[ch][0]  =        p_sys->x[ch][1]  =        p_sys->x2[ch][0] =        p_sys->x2[ch][1] = 0.0f;        for( i = 0; i < p_sys->i_band; i++ )        {            p_sys->y[ch][i][0]  =            p_sys->y[ch][i][1]  =            p_sys->y2[ch][i][0] =            p_sys->y2[ch][i][1] = 0.0f;        }    }    p_sys->psz_newbands = NULL;    var_Create( p_aout, "equalizer-bands", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING | VLC_VAR_DOINHERIT );    p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" );    var_Create( p_aout, "equalizer-preamp", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT );    /* Get initial values */    var_Get( p_aout, "equalizer-preset", &val1 );    var_Get( p_aout, "equalizer-bands", &val2 );    var_Get( p_aout, "equalizer-preamp", &val3 );    p_sys->b_first = true;    PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys );    BandsCallback(  VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys );    PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys );    p_sys->b_first = false;    free( val1.psz_string );    /* Exit if we have no preset and no bands value */    if (p_sys->psz_newbands == NULL && (!val2.psz_string || !*val2.psz_string))    {        msg_Err(p_filter, "No preset selected");        free( val2.psz_string );        free( p_sys->f_amp );        i_ret = VLC_EGENERIC;        goto error;    }    /* Register preset bands (for intf) if : */    /* We have no bands info --> the preset info must be given to the intf */    /* or The bands info matches the preset */    if( ( p_sys->psz_newbands && *(val2.psz_string) &&         strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string )    {        var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands );        if( p_sys->f_newpreamp == p_sys->f_gamp )            var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp );    }    free( val2.psz_string );    /* Add our own callbacks */    var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys );    var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys );    var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys );    var_AddCallback( p_aout, "equalizer-2pass", TwoPassCallback, p_sys );    msg_Dbg( p_filter, "equalizer loaded for %d Hz with %d bands %d pass",                        i_rate, p_sys->i_band, p_sys->b_2eqz ? 2 : 1 );    for( i = 0; i < p_sys->i_band; i++ )    {        msg_Dbg( p_filter, "   %.2f Hz -> factor:%f alpha:%f beta:%f gamma:%f",                 cfg.band[i].f_frequency, p_sys->f_amp[i],                 p_sys->f_alpha[i], p_sys->f_beta[i], p_sys->f_gamma[i]);    }    return VLC_SUCCESS;error:    free( p_sys->f_alpha );    free( p_sys->f_beta );    free( p_sys->f_gamma );    return i_ret;}

/***************************************************************************** * Run: rtci thread ***************************************************************************** * This part of the interface is in a separate thread so that we can call * exec() from within it without annoying the rest of the program. *****************************************************************************/static void Run( intf_thread_t *p_intf ){    input_thread_t * p_input;    playlist_t *     p_playlist;    char       p_buffer[ MAX_LINE_LENGTH + 1 ];    vlc_bool_t b_showpos = config_GetInt( p_intf, "rtci-show-pos" );    int        i_size = 0;    int        i_oldpos = 0;    int        i_newpos;    p_buffer[0] = 0;    p_input = NULL;    p_playlist = NULL;     p_intf->p_sys->b_extend = config_GetInt( p_intf, "rtci-extend" );    /* Register commands that will be cleaned up upon object destruction */    var_Create( p_intf, "quit", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "quit", Quit, NULL );    var_Create( p_intf, "intf", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "intf", Intf, NULL );    var_Create( p_intf, "add", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "add", Playlist, NULL );    var_Create( p_intf, "playlist", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "playlist", Playlist, NULL );    var_Create( p_intf, "play", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "play", Playlist, NULL );    var_Create( p_intf, "stop", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "stop", Playlist, NULL );    var_Create( p_intf, "prev", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "prev", Playlist, NULL );    var_Create( p_intf, "next", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "next", Playlist, NULL );      var_Create( p_intf, "marq-marquee", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "marq-marquee", Other, NULL );    var_Create( p_intf, "marq-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "marq-x", Other, NULL );    var_Create( p_intf, "marq-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "marq-y", Other, NULL );    var_Create( p_intf, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "marq-timeout", Other, NULL );    var_Create( p_intf, "pause", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "pause", Input, NULL );    var_Create( p_intf, "seek", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "seek", Input, NULL );    var_Create( p_intf, "title", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "title", Input, NULL );    var_Create( p_intf, "title_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "title_n", Input, NULL );    var_Create( p_intf, "title_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "title_p", Input, NULL );    var_Create( p_intf, "chapter", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "chapter", Input, NULL );    var_Create( p_intf, "chapter_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "chapter_n", Input, NULL );    var_Create( p_intf, "chapter_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "chapter_p", Input, NULL );    var_Create( p_intf, "volume", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "volume", Volume, NULL );    var_Create( p_intf, "volup", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "volup", VolumeMove, NULL );    var_Create( p_intf, "voldown", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "voldown", VolumeMove, NULL );    var_Create( p_intf, "adev", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "adev", AudioConfig, NULL );    var_Create( p_intf, "achan", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );    var_AddCallback( p_intf, "achan", AudioConfig, NULL );#ifdef WIN32    /* Get the file descriptor of the console input */    p_intf->p_sys->hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);    if( p_intf->p_sys->hConsoleIn == INVALID_HANDLE_VALUE )    {        msg_Err( p_intf, "Couldn't open STD_INPUT_HANDLE" );        p_intf->b_die = VLC_TRUE;    }#endif    while( !p_intf->b_die )    {        char *psz_cmd, *psz_arg;        vlc_bool_t b_complete;        if( p_intf->p_sys->i_socket_listen != - 1 &&            p_intf->p_sys->i_socket == -1 )        {            p_intf->p_sys->i_socket =                net_Accept( p_intf, p_intf->p_sys->i_socket_listen, 0 );        }//.........这里部分代码省略.........

/** * Common open function */static int OpenCommon( vlc_object_t *p_this, bool b_sub ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys;    char *psz_filename;    /* */    if( !b_sub && !es_format_IsSimilar( &p_filter->fmt_in, &p_filter->fmt_out ) )    {        msg_Err( p_filter, "Input and output format does not match" );        return VLC_EGENERIC;    }    /* */    p_filter->p_sys = p_sys = malloc( sizeof( *p_sys ) );    if( !p_sys )        return VLC_ENOMEM;    /* */    p_sys->p_blend = NULL;    if( !b_sub )    {        p_sys->p_blend = filter_NewBlend( VLC_OBJECT(p_filter),                                          &p_filter->fmt_in.video );        if( !p_sys->p_blend )        {            free( p_sys );            return VLC_EGENERIC;        }    }    /* */    config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,                       p_filter->p_cfg );    /* */    logo_list_t *p_list = &p_sys->list;    psz_filename = var_CreateGetStringCommand( p_filter, "logo-file" );    if( !psz_filename )    {        if( p_sys->p_blend )            filter_DeleteBlend( p_sys->p_blend );        free( p_sys );        return VLC_ENOMEM;    }    if( *psz_filename == '/0' )        msg_Warn( p_this, "no logo file specified" );    p_list->i_alpha = var_CreateGetIntegerCommand( p_filter, "logo-opacity");    p_list->i_alpha = __MAX( __MIN( p_list->i_alpha, 255 ), 0 );    p_list->i_delay = var_CreateGetIntegerCommand( p_filter, "logo-delay" );    p_list->i_repeat = var_CreateGetIntegerCommand( p_filter, "logo-repeat" );    p_sys->i_pos = var_CreateGetIntegerCommand( p_filter, "logo-position" );    p_sys->i_pos_x = var_CreateGetIntegerCommand( p_filter, "logo-x" );    p_sys->i_pos_y = var_CreateGetIntegerCommand( p_filter, "logo-y" );    /* Ignore aligment if a position is given for video filter */    if( !b_sub && p_sys->i_pos_x >= 0 && p_sys->i_pos_y >= 0 )        p_sys->i_pos = 0;    vlc_mutex_init( &p_sys->lock );    LogoListLoad( p_this, p_list, psz_filename );    p_sys->b_spu_update = true;    p_sys->b_mouse_grab = false;    for( int i = 0; ppsz_filter_callbacks[i]; i++ )        var_AddCallback( p_filter, ppsz_filter_callbacks[i],                         LogoCallback, p_sys );    /* Misc init */    if( b_sub )    {        p_filter->pf_sub_source = FilterSub;    }    else    {        p_filter->pf_video_filter = FilterVideo;        p_filter->pf_video_mouse = Mouse;    }    free( psz_filename );    return VLC_SUCCESS;}

//.........这里部分代码省略.........    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 );            val.i_int = (obtained.channels == 2) ? AOUT_VAR_STEREO :                        AOUT_VAR_MONO;            text.psz_string = (obtained.channels == 2) ? _("Stereo") :                              _("Mono");            var_Change( p_aout, "audio-device",                        VLC_VAR_ADDCHOICE, &val, &text );            var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart,                             NULL );        }    }    else if ( var_Type( p_aout, "audio-device" ) == 0 )    {        /* First launch. */        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 );        val.i_int = AOUT_VAR_STEREO;        text.psz_string = _("Stereo");        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );        val.i_int = AOUT_VAR_MONO;        text.psz_string = _("Mono");        var_Change( p_aout, "audio-device", VLC_VAR_ADDCHOICE, &val, &text );        if ( i_nb_channels == 2 )        {            val.i_int = AOUT_VAR_STEREO;        }        else        {            val.i_int = AOUT_VAR_MONO;        }        var_Change( p_aout, "audio-device", VLC_VAR_SETDEFAULT, &val, NULL );        var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );    }    var_TriggerCallback( p_aout, "intf-change" );    p_aout->output.output.i_rate = obtained.freq;    p_aout->output.i_nb_samples = obtained.samples;    p_aout->output.pf_play = Play;    return VLC_SUCCESS;}

/** * It creates a Direct3D vout display. */static int Open(vlc_object_t *object){    vout_display_t *vd = (vout_display_t *)object;    vout_display_sys_t *sys;    /* Allocate structure */    vd->sys = sys = calloc(1, sizeof(vout_display_sys_t));    if (!sys)        return VLC_ENOMEM;    if (Direct3DCreate(vd)) {        msg_Err(vd, "Direct3D could not be initialized");        Direct3DDestroy(vd);        free(sys);        return VLC_EGENERIC;    }    sys->use_desktop = var_CreateGetBool(vd, "direct3d-desktop");    sys->reset_device = false;    sys->reset_device = false;    sys->allow_hw_yuv = var_CreateGetBool(vd, "directx-hw-yuv");    sys->desktop_save.is_fullscreen = vd->cfg->is_fullscreen;    sys->desktop_save.is_on_top     = false;    sys->desktop_save.win.left      = var_InheritInteger(vd, "video-x");    sys->desktop_save.win.right     = vd->cfg->display.width;    sys->desktop_save.win.top       = var_InheritInteger(vd, "video-y");    sys->desktop_save.win.bottom    = vd->cfg->display.height;    if (CommonInit(vd))        goto error;    /* */    video_format_t fmt;    if (Direct3DOpen(vd, &fmt)) {        msg_Err(vd, "Direct3D could not be opened");        goto error;    }    /* */    vout_display_info_t info = vd->info;    info.is_slow = true;    info.has_double_click = true;    info.has_hide_mouse = false;    info.has_pictures_invalid = true;    info.has_event_thread = true;    /* Interaction */    vlc_mutex_init(&sys->lock);    sys->ch_desktop = false;    sys->desktop_requested = sys->use_desktop;    vlc_value_t val;    val.psz_string = _("Desktop");    var_Change(vd, "direct3d-desktop", VLC_VAR_SETTEXT, &val, NULL);    var_AddCallback(vd, "direct3d-desktop", DesktopCallback, NULL);    /* Setup vout_display now that everything is fine */    vd->fmt  = fmt;    vd->info = info;    vd->pool    = Pool;    vd->prepare = Prepare;    vd->display = Display;    vd->control = Control;    vd->manage  = Manage;    /* Fix state in case of desktop mode */    if (sys->use_desktop && vd->cfg->is_fullscreen)        vout_display_SendEventFullscreen(vd, false);    return VLC_SUCCESS;error:    Direct3DClose(vd);    CommonClean(vd);    Direct3DDestroy(vd);    free(vd->sys);    return VLC_EGENERIC;}

/** * Start the input for an item * * /param p_playlist the playlist object * /param p_item the item to play * /return nothing */static int PlayItem( playlist_t *p_playlist, playlist_item_t *p_item ){    playlist_private_t *p_sys = pl_priv(p_playlist);    input_item_t *p_input = p_item->p_input;    PL_ASSERT_LOCKED;    msg_Dbg( p_playlist, "creating new input thread" );    p_input->i_nb_played++;    set_current_status_item( p_playlist, p_item );    p_sys->status.i_status = PLAYLIST_RUNNING;    UpdateActivity( p_playlist, DEFAULT_INPUT_ACTIVITY );    assert( p_sys->p_input == NULL );    if( !p_sys->p_input_resource )        p_sys->p_input_resource = input_resource_New( VLC_OBJECT( p_playlist ) );    input_thread_t *p_input_thread = input_Create( p_playlist, p_input, NULL, p_sys->p_input_resource );    if( p_input_thread )    {        p_sys->p_input = p_input_thread;        var_AddCallback( p_input_thread, "intf-event", InputEvent, p_playlist );        var_SetAddress( p_playlist, "input-current", p_input_thread );        if( input_Start( p_sys->p_input ) )        {            vlc_object_release( p_input_thread );            p_sys->p_input = p_input_thread = NULL;        }    }    char *psz_uri = input_item_GetURI( p_item->p_input );    if( psz_uri && ( !strncmp( psz_uri, "directory:", 10 ) ||                     !strncmp( psz_uri, "vlc:", 4 ) ) )    {        free( psz_uri );        return VLC_SUCCESS;    }    free( psz_uri );    /* TODO store art policy in playlist private data */    if( var_GetInteger( p_playlist, "album-art" ) == ALBUM_ART_WHEN_PLAYED )    {        bool b_has_art;        char *psz_arturl, *psz_name;        psz_arturl = input_item_GetArtURL( p_input );        psz_name = input_item_GetName( p_input );        /* p_input->p_meta should not be null after a successfull CreateThread */        b_has_art = !EMPTY_STR( psz_arturl );        if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) )        {            PL_DEBUG( "requesting art for %s", psz_name );            playlist_AskForArtEnqueue( p_playlist, p_input );        }        free( psz_arturl );        free( psz_name );    }    /* FIXME: this is not safe !!*/    PL_UNLOCK;    var_SetAddress( p_playlist, "item-current", p_input );    PL_LOCK;    return VLC_SUCCESS;}

ThemeRepository::ThemeRepository( intf_thread_t *pIntf ): SkinObject( pIntf ){    vlc_value_t val, text;    // Create a variable to add items in wxwindows popup menu    var_Create( pIntf, "intf-skins", VLC_VAR_STRING |                VLC_VAR_HASCHOICE | VLC_VAR_ISCOMMAND );    text.psz_string = _("Select skin");    var_Change( pIntf, "intf-skins", VLC_VAR_SETTEXT, &text, NULL );    // Scan vlt files in the resource path    OSFactory *pOsFactory = OSFactory::instance( pIntf );    list<string> resPath = pOsFactory->getResourcePath();    list<string>::const_iterator it;    for( it = resPath.begin(); it != resPath.end(); ++it )    {        parseDirectory( *it );    }    // retrieve skins from skins directories and locate default skins    map<string,string>::const_iterator itmap, itdefault;    for( itmap = m_skinsMap.begin(); itmap != m_skinsMap.end(); ++itmap )    {        string name = itmap->first;        string path = itmap->second;        val.psz_string = (char*) path.c_str();        text.psz_string = (char*) name.c_str();        var_Change( getIntf(), "intf-skins", VLC_VAR_ADDCHOICE, &val,                    &text );        if( name == "Default" )            itdefault = itmap;    }    // retrieve last skins stored or skins requested by user    char* psz_current = var_InheritString( getIntf(), "skins2-last" );    string current = string( psz_current ? psz_current : "" );    free( psz_current );    // check if skins exists and is readable    bool b_readable = !ifstream( current.c_str() ).fail();    msg_Dbg( getIntf(), "requested skins %s is %s accessible",                         current.c_str(), b_readable ? "" : "NOT" );    // set the default skins if given skins not accessible    if( !b_readable )        current = itdefault->second;    // save this valid skins for reuse    config_PutPsz( getIntf(), "skins2-last", current.c_str() );    // Update repository    updateRepository();    // Set the callback    var_AddCallback( pIntf, "intf-skins", changeSkin, this );    // variable for opening a dialog box to change skins    var_Create( pIntf, "intf-skins-interactive", VLC_VAR_VOID |                VLC_VAR_ISCOMMAND );    text.psz_string = _("Open skin ...");    var_Change( pIntf, "intf-skins-interactive", VLC_VAR_SETTEXT, &text, NULL );    // Set the callback    var_AddCallback( pIntf, "intf-skins-interactive", changeSkin, this );}

static int EqzInit( aout_filter_t *p_filter, int i_rate ){    aout_filter_sys_t *p_sys = p_filter->p_sys;    const eqz_config_t *p_cfg;    int i, ch;    vlc_value_t val1, val2, val3;    aout_instance_t *p_aout = (aout_instance_t *)p_filter->p_parent;    /* Select the config */    if( i_rate == 48000 )    {        p_cfg = &eqz_config_48000_10b;    }    else if( i_rate == 44100 )    {        p_cfg = &eqz_config_44100_10b;    }    else    {        /* TODO compute the coeffs on the fly */        msg_Err( p_filter, "unsupported rate" );        return VLC_EGENERIC;    }    /* Create the static filter config */    p_sys->i_band = p_cfg->i_band;    p_sys->f_alpha = malloc( p_sys->i_band * sizeof(float) );    p_sys->f_beta  = malloc( p_sys->i_band * sizeof(float) );    p_sys->f_gamma = malloc( p_sys->i_band * sizeof(float) );    for( i = 0; i < p_sys->i_band; i++ )    {        p_sys->f_alpha[i] = p_cfg->band[i].f_alpha;        p_sys->f_beta[i]  = p_cfg->band[i].f_beta;        p_sys->f_gamma[i] = p_cfg->band[i].f_gamma;    }    /* Filter dyn config */    p_sys->b_2eqz = VLC_FALSE;    p_sys->f_gamp = 1.0;    p_sys->f_amp   = malloc( p_sys->i_band * sizeof(float) );    for( i = 0; i < p_sys->i_band; i++ )    {        p_sys->f_amp[i] = 0.0;    }    /* Filter state */    for( ch = 0; ch < 32; ch++ )    {        p_sys->x[ch][0]  =        p_sys->x[ch][1]  =        p_sys->x2[ch][0] =        p_sys->x2[ch][1] = 0.0;        for( i = 0; i < p_sys->i_band; i++ )        {            p_sys->y[ch][i][0]  =            p_sys->y[ch][i][1]  =            p_sys->y2[ch][i][0] =            p_sys->y2[ch][i][1] = 0.0;        }    }    var_CreateGetString( p_aout,"equalizer-bands" );    var_CreateGetString( p_aout, "equalizer-preset" );    p_sys->b_2eqz = var_CreateGetBool( p_aout, "equalizer-2pass" );    var_CreateGetFloat( p_aout, "equalizer-preamp" );    /* Get initial values */    var_Get( p_aout, "equalizer-preset", &val1 );    var_Get( p_aout, "equalizer-bands", &val2 );    var_Get( p_aout, "equalizer-preamp", &val3 );    p_sys->b_first = VLC_TRUE;    PresetCallback( VLC_OBJECT( p_aout ), NULL, val1, val1, p_sys );    BandsCallback(  VLC_OBJECT( p_aout ), NULL, val2, val2, p_sys );    PreampCallback( VLC_OBJECT( p_aout ), NULL, val3, val3, p_sys );    p_sys->b_first = VLC_FALSE;    /* Register preset bands (for intf) if : */    /* We have no bands info --> the preset info must be given to the intf */    /* or The bands info matches the preset */    if (p_sys->psz_newbands == NULL)    {        msg_Err(p_filter, "No preset selected");        return (VLC_EGENERIC);    }    if( ( *(val2.psz_string) &&        strstr( p_sys->psz_newbands, val2.psz_string ) ) || !*val2.psz_string )    {        var_SetString( p_aout, "equalizer-bands", p_sys->psz_newbands );        var_SetFloat( p_aout, "equalizer-preamp", p_sys->f_newpreamp );    }    /* Add our own callbacks */    var_AddCallback( p_aout, "equalizer-preset", PresetCallback, p_sys );    var_AddCallback( p_aout, "equalizer-bands", BandsCallback, p_sys );    var_AddCallback( p_aout, "equalizer-preamp", PreampCallback, p_sys );//.........这里部分代码省略.........

/***************************************************************************** * Init: initialize logo video thread output method *****************************************************************************/static int Init( vout_thread_t *p_vout ){    vout_sys_t *p_sys = p_vout->p_sys;    picture_t *p_pic;    int i_index;    I_OUTPUTPICTURES = 0;    /* Initialize the output structure */    p_vout->output.i_chroma = p_vout->render.i_chroma;    p_vout->output.i_width  = p_vout->render.i_width;    p_vout->output.i_height = p_vout->render.i_height;    p_vout->output.i_aspect = p_vout->render.i_aspect;    /* Load the video blending filter */    p_sys->p_blend = vlc_object_create( p_vout, sizeof(filter_t) );    vlc_object_attach( p_sys->p_blend, p_vout );    p_sys->p_blend->fmt_out.video.i_x_offset =        p_sys->p_blend->fmt_out.video.i_y_offset = 0;    p_sys->p_blend->fmt_in.video.i_x_offset =        p_sys->p_blend->fmt_in.video.i_y_offset = 0;    p_sys->p_blend->fmt_out.video.i_aspect = p_vout->render.i_aspect;    p_sys->p_blend->fmt_out.video.i_chroma = p_vout->output.i_chroma;    p_sys->p_blend->fmt_in.video.i_chroma = VLC_FOURCC('Y','U','V','A');    p_sys->p_blend->fmt_in.video.i_aspect = VOUT_ASPECT_FACTOR;    p_sys->p_blend->fmt_in.video.i_width =        p_sys->p_blend->fmt_in.video.i_visible_width =            p_sys->p_pic->p[Y_PLANE].i_visible_pitch;    p_sys->p_blend->fmt_in.video.i_height =        p_sys->p_blend->fmt_in.video.i_visible_height =            p_sys->p_pic->p[Y_PLANE].i_visible_lines;    p_sys->p_blend->fmt_out.video.i_width =        p_sys->p_blend->fmt_out.video.i_visible_width =           p_vout->output.i_width;    p_sys->p_blend->fmt_out.video.i_height =        p_sys->p_blend->fmt_out.video.i_visible_height =            p_vout->output.i_height;    p_sys->p_blend->p_module =        module_Need( p_sys->p_blend, "video blending", 0, 0 );    if( !p_sys->p_blend->p_module )    {        msg_Err( p_vout, "can't open blending filter, aborting" );        vlc_object_detach( p_sys->p_blend );        vlc_object_destroy( p_sys->p_blend );        return VLC_EGENERIC;    }    if( p_sys->posx < 0 || p_sys->posy < 0 )    {        p_sys->posx = 0; p_sys->posy = 0;        if( p_sys->pos & SUBPICTURE_ALIGN_BOTTOM )        {            p_sys->posy = p_vout->render.i_height - p_sys->i_height;        }        else if ( !(p_sys->pos & SUBPICTURE_ALIGN_TOP) )        {            p_sys->posy = p_vout->render.i_height / 2 - p_sys->i_height / 2;        }        if( p_sys->pos & SUBPICTURE_ALIGN_RIGHT )        {            p_sys->posx = p_vout->render.i_width - p_sys->i_width;        }        else if ( !(p_sys->pos & SUBPICTURE_ALIGN_LEFT) )        {            p_sys->posx = p_vout->render.i_width / 2 - p_sys->i_width / 2;        }    }    /* Try to open the real video output */    msg_Dbg( p_vout, "spawning the real video output" );    p_sys->p_vout =        vout_Create( p_vout, p_vout->render.i_width, p_vout->render.i_height,                     p_vout->render.i_chroma, p_vout->render.i_aspect );    /* Everything failed */    if( p_sys->p_vout == NULL )    {        msg_Err( p_vout, "can't open vout, aborting" );        return VLC_EGENERIC;    }    var_AddCallback( p_sys->p_vout, "mouse-x", MouseEvent, p_vout);    var_AddCallback( p_sys->p_vout, "mouse-y", MouseEvent, p_vout);    ALLOCATE_DIRECTBUFFERS( VOUT_MAX_PICTURES );    ADD_CALLBACKS( p_sys->p_vout, SendEvents );    ADD_PARENT_CALLBACKS( SendEventsToChild );    return VLC_SUCCESS;}

/** * ProjectM update thread which do the rendering * @param p_this: the p_thread object */static void *Thread( void *p_data ){    filter_t  *p_filter = (filter_t*)p_data;    filter_sys_t *p_sys = p_filter->p_sys;    video_format_t fmt;    vlc_gl_t *gl;    unsigned int i_last_width  = 0;    unsigned int i_last_height = 0;    locale_t loc;    locale_t oldloc;    projectM *p_projectm;#ifndef HAVE_PROJECTM2    char *psz_config;#else    char *psz_preset_path;    char *psz_title_font;    char *psz_menu_font;    projectM::Settings settings;#endif    vlc_savecancel();    /* Create the openGL provider */    p_sys->p_vout =        (vout_thread_t *)vlc_object_create( p_filter, sizeof(vout_thread_t) );    if( !p_sys->p_vout )        goto error;    /* */    video_format_Init( &fmt, 0 );    video_format_Setup( &fmt, VLC_CODEC_RGB32,                        p_sys->i_width, p_sys->i_height, 0, 1 );    fmt.i_sar_num = 1;    fmt.i_sar_den = 1;    vout_display_state_t state;    memset( &state, 0, sizeof(state) );    state.cfg.display.sar.num = 1;    state.cfg.display.sar.den = 1;    state.cfg.is_display_filled = true;    state.cfg.zoom.num = 1;    state.cfg.zoom.den = 1;    state.sar.num = 1;    state.sar.den = 1;    p_sys->p_vd = vout_NewDisplay( p_sys->p_vout, &fmt, &state, "opengl",                                   300000, 1000000 );    if( !p_sys->p_vd )    {        vlc_object_release( p_sys->p_vout );        goto error;    }    var_Create( p_sys->p_vout, "fullscreen", VLC_VAR_BOOL );    var_AddCallback( p_sys->p_vout, "fullscreen", VoutCallback, p_sys->p_vd );    gl = vout_GetDisplayOpengl( p_sys->p_vd );    if( !gl )    {        vout_DeleteDisplay( p_sys->p_vd, NULL );        vlc_object_release( p_sys->p_vout );        goto error;    }    /* Work-around the projectM locale bug */    loc = newlocale (LC_NUMERIC_MASK, "C", NULL);    oldloc = uselocale (loc);    /* Create the projectM object */#ifndef HAVE_PROJECTM2    psz_config = var_InheritString( p_filter, "projectm-config" );    p_projectm = new projectM( psz_config );    free( psz_config );#else    psz_preset_path = var_InheritString( p_filter, "projectm-preset-path" );#ifdef WIN32    if ( psz_preset_path == NULL )    {        char *psz_data_path = config_GetDataDir( p_filter );        asprintf( &psz_preset_path, "%s" DIR_SEP "visualization", psz_data_path );        free( psz_data_path );    }#endif    psz_title_font                = var_InheritString( p_filter, "projectm-title-font" );    psz_menu_font                 = var_InheritString( p_filter, "projectm-menu-font" );    settings.meshX                = var_InheritInteger( p_filter, "projectm-meshx" );    settings.meshY                = var_InheritInteger( p_filter, "projectm-meshy" );    settings.fps                  = 35;    settings.textureSize          = var_InheritInteger( p_filter, "projectm-texture-size" );    settings.windowWidth          = p_sys->i_width;    settings.windowHeight         = p_sys->i_height;    settings.presetURL            = psz_preset_path;    settings.titleFontURL         = psz_title_font;//.........这里部分代码省略.........