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

void libvlc_video_set_format_callbacks( libvlc_media_player_t *mp,                                        libvlc_video_format_cb setup,                                        libvlc_video_cleanup_cb cleanup ){    var_SetAddress( mp, "vmem-setup", setup );    var_SetAddress( mp, "vmem-cleanup", cleanup );}

void libvlc_audio_set_format_callbacks( libvlc_media_player_t *mp,                                        libvlc_audio_setup_cb setup,                                        libvlc_audio_cleanup_cb cleanup ){    var_SetAddress( mp, "amem-setup", setup );    var_SetAddress( mp, "amem-cleanup", cleanup );    input_resource_ResetAout(mp->input.p_resource);}

void libvlc_audio_set_callbacks( libvlc_media_player_t *mp,                                 libvlc_audio_play_cb play_cb,                                 libvlc_audio_set_volume_cb set_volume_cb,                                 void *opaque ){    var_SetAddress( mp, "amem-play", play_cb );    var_SetAddress( mp, "amem-set-volume", set_volume_cb );    var_SetAddress( mp, "amem-data", opaque );    var_SetString( mp, "aout", "amem" );}

void libvlc_video_set_callbacks( libvlc_media_player_t *mp,    void *(*lock_cb) (void *, void **),    void (*unlock_cb) (void *, void *, void *const *),    void (*display_cb) (void *, void *),    void *opaque ){    var_SetAddress( mp, "vmem-lock", lock_cb );    var_SetAddress( mp, "vmem-unlock", unlock_cb );    var_SetAddress( mp, "vmem-display", display_cb );    var_SetAddress( mp, "vmem-data", opaque );    var_SetString( mp, "vout", "vmem" );}

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

/** * Sends an error message through the user interface (if any). * @param obj the VLC object emitting the error * @param modal whether to wait for user to acknowledge the error *              before returning control to the caller * @param title title of the error dialog * @param fmt format string for the error message * @param ap parameters list for the formatted error message */void dialog_VFatal (vlc_object_t *obj, bool modal, const char *title,                    const char *fmt, va_list ap){    char *text;    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)        return;    vlc_object_t *provider = dialog_GetProvider (obj);    if (provider == NULL)    {        msg_Err (obj, "%s", title);        msg_GenericVa (obj, VLC_MSG_ERR, MODULE_STRING, fmt, ap);        return;    }    if (vasprintf (&text, fmt, ap) != -1)    {        dialog_fatal_t dialog = { title, text, };        var_SetAddress (provider,                        modal ? "dialog-critical" : "dialog-error", &dialog);        free (text);    }    vlc_object_release (provider);}

/** * Requests a username and password through the user interface. * @param obj the VLC object requesting credential information * @param username a pointer to the specified username [OUT] * @param password a pointer to the specified password [OUT] * @param title title for the dialog * @param text format string for the message in the dialog * @return Nothing. If a user name resp. a password was specified, * it will be returned as a heap-allocated character array * into the username resp password pointer. Those must be freed with free(). * Otherwise *username resp *password will be NULL. */void dialog_Login (vlc_object_t *obj, char **username, char **password,                   const char *title, const char *fmt, ...){    assert ((username != NULL) && (password != NULL));    *username = *password = NULL;    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)        return;    vlc_object_t *provider = dialog_GetProvider (obj);    if (provider == NULL)        return;    char *text;    va_list ap;    va_start (ap, fmt);    if (vasprintf (&text, fmt, ap) != -1)    {        dialog_login_t dialog = { title, text, username, password, };        var_SetAddress (provider, "dialog-login", &dialog);        free (text);    }    va_end (ap);    vlc_object_release (provider);}

/* Open Interface */static int Open( vlc_object_t *p_this, bool isDialogProvider ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;#ifdef Q_WS_X11    if( !vlc_xlib_init( p_this ) )        return VLC_EGENERIC;    char *display = var_CreateGetNonEmptyString( p_intf, "x11-display" );    Display *p_display = XOpenDisplay( x11_display );    if( !p_display )    {        msg_Err( p_intf, "Could not connect to X server" );        free (display);        return VLC_EGENERIC;    }    XCloseDisplay( p_display );#else    char *display = NULL;#endif    QMutexLocker locker (&lock);    if (busy)    {        msg_Err (p_this, "cannot start Qt4 multiple times");        free (display);        return VLC_EGENERIC;    }    /* Allocations of p_sys */    intf_sys_t *p_sys = p_intf->p_sys = new intf_sys_t;    p_intf->p_sys->b_isDialogProvider = isDialogProvider;    p_sys->p_mi = NULL;    p_sys->p_playlist = pl_Get( p_intf );    /* */#ifdef Q_WS_X11    x11_display = display;#endif    vlc_sem_init (&ready, 0);    if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) )    {        delete p_sys;        free (display);        return VLC_ENOMEM;    }    /* */    vlc_sem_wait (&ready);    vlc_sem_destroy (&ready);    busy = active = true;    if( !p_sys->b_isDialogProvider )    {        playlist_t *pl = pl_Get(p_this);        var_Create (pl, "qt4-iface", VLC_VAR_ADDRESS);        var_SetAddress (pl, "qt4-iface", p_this);    }    return VLC_SUCCESS;}

/** * Creates a progress bar dialog. */dialog_progress_bar_t *dialog_ProgressCreate (vlc_object_t *obj, const char *title,                       const char *message, const char *cancel){    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)        return NULL;    vlc_object_t *provider = dialog_GetProvider (obj);    if (provider == NULL)        return NULL;    dialog_progress_bar_t *dialog = malloc (sizeof (*dialog));    if (dialog != NULL)    {        dialog->title = title;        dialog->message = message;        dialog->cancel = cancel;        var_SetAddress (provider, "dialog-progress-bar", dialog);#ifndef NDEBUG        dialog->title = dialog->message = dialog->cancel = NULL;#endif        assert (dialog->pf_update);        assert (dialog->pf_check);        assert (dialog->pf_destroy);    }    /* FIXME: This could conceivably crash if the dialog provider is destroyed     * before the dialog user. Holding the provider does not help, as it only     * protects object variable operations. For instance, it does not prevent     * unloading of the interface plugin. In the short term, the only solution     * is to not use progress dialog after deinitialization of the interfaces.     */    vlc_object_release (provider);    return dialog;}

/** * Asks a total (Yes/No/Cancel) question through the user interface. * @param obj VLC object emitting the question * @param title dialog box title * @param fmt format string for the dialog box text * @param yes first choice/button text * @param no second choice/button text * @param cancel third answer/button text, or NULL if no third option * @return 0 if the user could not answer the question (e.g. there is no UI), * 1, 2 resp. 3 if the user pressed the first, second resp. third button. */int dialog_Question (vlc_object_t *obj, const char *title, const char *fmt,                     const char *yes, const char *no, const char *cancel, ...){    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)        return 0;    vlc_object_t *provider = dialog_GetProvider (obj);    if (provider == NULL)        return 0;    char *text;    va_list ap;    int answer = 0;    va_start (ap, cancel);    if (vasprintf (&text, fmt, ap) != -1)    {        dialog_question_t dialog = { title, text, yes, no, cancel, 0, };        var_SetAddress (provider, "dialog-question", &dialog);        answer = dialog.answer;    }    va_end (ap);    vlc_object_release (provider);    return answer;}

/** * This function preparses an item when needed. */static void Preparse( playlist_t *p_playlist, input_item_t *p_item ){    vlc_mutex_lock( &p_item->lock );    int i_type = p_item->i_type;    vlc_mutex_unlock( &p_item->lock );    if( i_type != ITEM_TYPE_FILE )    {        input_item_SetPreparsed( p_item, true );        return;    }    stats_TimerStart( p_playlist, "Preparse run", STATS_TIMER_PREPARSE );    /* Do not preparse if it is already done (like by playing it) */    if( !input_item_IsPreparsed( p_item ) )    {        input_Preparse( VLC_OBJECT(p_playlist), p_item );        input_item_SetPreparsed( p_item, true );        var_SetAddress( p_playlist, "item-change", p_item );    }    stats_TimerStop( p_playlist, STATS_TIMER_PREPARSE );}

/***************************************************************************** * An input item's meta or duration has changed (Event Callback) *****************************************************************************/static void input_item_changed( const vlc_event_t * p_event,                                void * user_data ){    playlist_item_t *p_item = user_data;    VLC_UNUSED( p_event );    var_SetAddress( p_item->p_playlist, "item-change", p_item->p_input );}

/** Remove this drawable from the list of busy ones */static void ReleaseDrawable (vlc_object_t *obj, xcb_window_t window){    xcb_window_t *used;    size_t n = 0;    vlc_mutex_lock (&serializer);    used = var_GetAddress (obj->p_libvlc, "xid-in-use");    assert (used);    while (used[n] != window)    {        assert (used[n]);        n++;    }    do        used[n] = used[n + 1];    while (used[++n]);    if (n == 0)         var_SetAddress (obj->p_libvlc, "xid-in-use", NULL);    vlc_mutex_unlock (&serializer);    if (n == 0)        free (used);    /* Variables are reference-counted... */    var_Destroy (obj->p_libvlc, "xid-in-use");}

void libvlc_audio_set_volume_callback( libvlc_media_player_t *mp,                                       libvlc_audio_set_volume_cb cb ){    var_SetAddress( mp, "amem-set-volume", cb );    input_resource_ResetAout(mp->input.p_resource);}

/** * Release the drawable. */static void Close (vlc_object_t *obj){    vout_window_t *wnd = (vout_window_t *)obj;    void **used, *val = wnd->p_sys;    size_t n = 0;    /* Remove this drawable from the list of busy ones */    vlc_mutex_lock (&serializer);    used = var_GetAddress (VLC_OBJECT (obj->p_libvlc), "drawables-in-use");    assert (used);    while (used[n] != val)    {        assert (used[n]);        n++;    }    do        used[n] = used[n + 1];    while (used[++n] != NULL);    if (n == 0)      /* should not be needed (var_Destroy...) but better safe than sorry: */         var_SetAddress (obj->p_libvlc, "drawables-in-use", NULL);    vlc_mutex_unlock (&serializer);    if (n == 0)        free (used);    /* Variables are reference-counted... */    var_Destroy (obj->p_libvlc, "drawables-in-use");}

static void RegisterIntf( intf_thread_t *p_this ){    playlist_t *pl = p_this->p_sys->p_playlist;    var_Create (pl, "qt4-iface", VLC_VAR_ADDRESS);    var_SetAddress (pl, "qt4-iface", p_this);    var_Create (pl, "window", VLC_VAR_STRING);    var_SetString (pl, "window", "qt4,any");}

/************************************************************************** * set_nsobject **************************************************************************/void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi,                                        void * drawable ){    assert (p_mi != NULL);#ifdef __APPLE__    var_SetAddress (p_mi, "drawable-nsobject", drawable);#else    (void) p_mi; (void)drawable;#endif}

static void TriggerInstanceState( vlm_t *p_vlm, int i_type, int64_t id, const char *psz_name, const char *psz_instance_name, input_state_e input_state ){    vlm_event_t event;    event.i_type = i_type;    event.id = id;    event.psz_name = psz_name;    event.input_state = input_state;    event.psz_instance_name = psz_instance_name;    var_SetAddress( p_vlm, "intf-event", &event );}

/************************************************************************** * set_hwnd **************************************************************************/void libvlc_media_player_set_hwnd( libvlc_media_player_t *p_mi,                                   void *drawable ){    assert (p_mi != NULL);#ifdef WIN32    var_SetString (p_mi, "window",                   (drawable != NULL) ? "embed-hwnd,any" : "");    var_SetAddress (p_mi, "drawable-hwnd", drawable);#else    (void) p_mi; (void) drawable;#endif}

/** * Start the input for an item * * /param p_playlist the playlist object * /param p_item the item to play * /return nothing */static void 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_item->i_nb_played++;    set_current_status_item( p_playlist, p_item );    p_sys->status.i_status = PLAYLIST_RUNNING;    assert( p_sys->p_input == NULL );    PL_UNLOCK;    input_thread_t *p_input_thread = input_Create( p_playlist, p_input, NULL,                                                   p_sys->p_input_resource );    if( likely(p_input_thread != NULL) )    {        var_AddCallback( p_input_thread, "intf-event",                         InputEvent, p_playlist );        if( input_Start( p_input_thread ) )        {            var_DelCallback( p_input_thread, "intf-event",                             InputEvent, p_playlist );            vlc_object_release( p_input_thread );            p_input_thread = NULL;        }    }    var_SetAddress( p_playlist, "input-current", p_input_thread );    /* TODO store art policy in playlist private data */    char *psz_arturl = input_item_GetArtURL( p_input );    /* p_input->p_meta should not be null after a successful CreateThread */    bool b_has_art = !EMPTY_STR( psz_arturl );    if( !b_has_art || strncmp( psz_arturl, "attachment://", 13 ) )    {        PL_DEBUG( "requesting art for new input thread" );        libvlc_ArtRequest( p_playlist->p_libvlc, p_input, META_REQUEST_OPTION_NONE );    }    free( psz_arturl );    var_TriggerCallback( p_playlist, "activity" );    PL_LOCK;    p_sys->p_input = p_input_thread;}

/** * Asks a total (Yes/No/Cancel) question through the user interface. * @param obj VLC object emitting the question * @param title dialog box title * @param text dialog box text * @param yes first choice/button text * @param no second choice/button text * @param cancel third answer/button text, or NULL if no third option * @return 0 if the user could not answer the question (e.g. there is no UI), * 1, 2 resp. 3 if the user pressed the first, second resp. third button. */int dialog_Question (vlc_object_t *obj, const char *title, const char *text,                     const char *yes, const char *no, const char *cancel){    if (obj->i_flags & OBJECT_FLAGS_NOINTERACT)        return 0;    vlc_object_t *provider = dialog_GetProvider (obj);    if (provider == NULL)        return 0;    dialog_question_t dialog = { title, text, yes, no, cancel, 0, };    var_SetAddress (provider, "dialog-question", &dialog);    vlc_object_release (provider);    return dialog.answer;}

/** * Send a notification that an item has been added to a node * * /param p_playlist the playlist object * /param i_item_id id of the item added * /param i_node_id id of the node in which the item was added * /param b_signal TRUE if the function must send a signal * /return nothing */void playlist_SendAddNotify( playlist_t *p_playlist, int i_item_id,                             int i_node_id, bool b_signal ){    playlist_private_t *p_sys = pl_priv(p_playlist);    PL_ASSERT_LOCKED;    p_sys->b_reset_currently_playing = true;    if( b_signal )        vlc_cond_signal( &p_sys->signal );    playlist_add_t add;    add.i_item = i_item_id;    add.i_node = i_node_id;    var_SetAddress( p_playlist, "playlist-item-append", &add );}

void input_item_ApplyOptions(vlc_object_t *obj, input_item_t *item){    vlc_mutex_lock(&item->lock);    assert(item->optflagc == (unsigned)item->i_options);    for (unsigned i = 0; i < (unsigned)item->i_options; i++)        var_OptionParse(obj, item->ppsz_options[i],                        !!(item->optflagv[i] & VLC_INPUT_OPTION_TRUSTED));    for (const input_item_opaque_t *o = item->opaques; o != NULL; o = o->next)    {        var_Create(obj, o->name, VLC_VAR_ADDRESS);        var_SetAddress(obj, o->name, o->value);    }    vlc_mutex_unlock(&item->lock);}

void osd_MenuDelete( vlc_object_t *p_this, osd_menu_t *p_osd ){    if( !p_osd || !p_this ) return;    vlc_mutex_lock( &osd_mutex );    if( vlc_internals( VLC_OBJECT(p_osd) )->i_refcount == 1 )    {        var_Destroy( p_osd, "osd-menu-visible" );        var_Destroy( p_osd, "osd-menu-update" );        osd_ParserUnload( p_osd );        var_SetAddress( p_this->p_libvlc, "osd-object", NULL );    }    vlc_object_release( p_osd );    vlc_mutex_unlock( &osd_mutex );}

/** * This function preparses an item when needed. */static void Preparse( playlist_preparser_t *preparser, input_item_t *p_item,                      input_item_meta_request_option_t i_options ){    vlc_mutex_lock( &p_item->lock );    int i_type = p_item->i_type;    bool b_net = p_item->b_net;    vlc_mutex_unlock( &p_item->lock );    bool b_preparse = false;    switch (i_type) {    case ITEM_TYPE_FILE:    case ITEM_TYPE_DIRECTORY:    case ITEM_TYPE_PLAYLIST:    case ITEM_TYPE_NODE:        if (!b_net || i_options & META_REQUEST_OPTION_SCOPE_NETWORK)            b_preparse = true;        break;    }    /* Do not preparse if it is already done (like by playing it) */    if( b_preparse && !input_item_IsPreparsed( p_item ) )    {        input_thread_t *input = input_CreatePreparser( preparser->object,                                p_item );        if( input == NULL )            return;        var_AddCallback( input, "intf-event", InputEvent,                         &preparser->item_done );        if( input_Start( input ) == VLC_SUCCESS )            vlc_sem_wait( &preparser->item_done );        var_DelCallback( input, "intf-event", InputEvent,                         &preparser->item_done );        /* Normally, the input is already stopped since we waited for it. But         * if the playlist preparser is being deleted, then the input might         * still be running. Force it to stop. */        input_Stop( input );        input_Close( input );        var_SetAddress( preparser->object, "item-change", p_item );    }    input_item_SetPreparsed( p_item, true );    input_item_SignalPreparseEnded( p_item );}

static void LoopInput( playlist_t *p_playlist ){    playlist_private_t *p_sys = pl_priv(p_playlist);    input_thread_t *p_input = p_sys->p_input;    assert( p_input != NULL );    if( p_sys->request.b_request || p_sys->killed )    {        PL_DEBUG( "incoming request - stopping current input" );        input_Stop( p_input, true );    }#warning Unsynchronized access to *p_input flags...    /* This input is dead. Remove it ! */    if( p_input->b_dead )    {        p_sys->p_input = NULL;        PL_DEBUG( "dead input" );        PL_UNLOCK;        var_SetAddress( p_playlist, "input-current", NULL );        /* WARNING: Input resource manipulation and callback deletion are         * incompatible with the playlist lock. */        if( !var_InheritBool( p_input, "sout-keep" ) )            input_resource_TerminateSout( p_sys->p_input_resource );        var_DelCallback( p_input, "intf-event", InputEvent, p_playlist );        input_Close( p_input );        var_TriggerCallback( p_playlist, "activity" );        PL_LOCK;        return;    }    /* This input has finished, ask it to die ! */    else if( p_input->b_error || p_input->b_eof )    {        PL_DEBUG( "finished input" );        input_Stop( p_input, false );    }    vlc_cond_wait( &p_sys->signal, &p_sys->lock );}

/* Actually convert an item to a node */static void ChangeToNode( playlist_t *p_playlist, playlist_item_t *p_item ){    int i;    if( p_item->i_children != -1 ) return;    p_item->i_children = 0;    input_item_t *p_input = p_item->p_input;    vlc_mutex_lock( &p_input->lock );    p_input->i_type = ITEM_TYPE_NODE;    vlc_mutex_unlock( &p_input->lock );    var_SetAddress( p_playlist, "item-change", p_item->p_input );    /* Remove it from the array of available items */    ARRAY_BSEARCH( p_playlist->items,->i_id, int, p_item->i_id, i );    if( i != -1 )        ARRAY_REMOVE( p_playlist->items, i );}

int dialog_ExtensionUpdate (vlc_object_t *obj, extension_dialog_t *dialog){    assert (obj);    assert (dialog);    vlc_object_t *dp = dialog_GetProvider(obj);    if (!dp)    {        msg_Warn (obj, "Dialog provider is not set, can't update dialog '%s'",                  dialog->psz_title);        return VLC_EGENERIC;    }    // Signaling the dialog provider    int ret = var_SetAddress (dp, "dialog-extension", dialog);    vlc_object_release (dp);    return ret;}

/** * This function preparses an item when needed. */static void Preparse( vlc_object_t *obj, input_item_t *p_item ){    vlc_mutex_lock( &p_item->lock );    int i_type = p_item->i_type;    vlc_mutex_unlock( &p_item->lock );    if( i_type != ITEM_TYPE_FILE )    {        input_item_SetPreparsed( p_item, true );        return;    }    /* Do not preparse if it is already done (like by playing it) */    if( !input_item_IsPreparsed( p_item ) )    {        input_Preparse( obj, p_item );        input_item_SetPreparsed( p_item, true );        var_SetAddress( obj, "item-change", p_item );    }}