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

static aout_instance_t *RequestAout( input_resource_t *p_resource, aout_instance_t *p_aout ){    vlc_assert_locked( &p_resource->lock );    assert( p_resource->p_input );    if( p_aout )    {        msg_Dbg( p_resource->p_parent, "releasing aout" );        vlc_object_release( p_aout );        return NULL;    }    else    {        p_aout = p_resource->p_aout;        if( !p_aout )        {            msg_Dbg( p_resource->p_parent, "creating aout" );            p_aout = aout_New( p_resource->p_parent );            vlc_mutex_lock( &p_resource->lock_hold );            p_resource->p_aout = p_aout;            vlc_mutex_unlock( &p_resource->lock_hold );        }        else        {            msg_Dbg( p_resource->p_parent, "reusing aout" );        }        if( !p_aout )            return NULL;        vlc_object_hold( p_aout );        return p_aout;    }}

static void HoldVouts( input_resource_t *p_resource, vout_thread_t ***ppp_vout,                       size_t *pi_vout ){    vout_thread_t **pp_vout;    *pi_vout = 0;    *ppp_vout = NULL;    vlc_mutex_lock( &p_resource->lock_hold );    if( p_resource->i_vout <= 0 )        goto exit;    pp_vout = malloc( p_resource->i_vout * sizeof(*pp_vout) );    if( !pp_vout )        goto exit;    *ppp_vout = pp_vout;    *pi_vout = p_resource->i_vout;    for( int i = 0; i < p_resource->i_vout; i++ )    {        pp_vout[i] = p_resource->pp_vout[i];        vlc_object_hold( pp_vout[i] );    }exit:    vlc_mutex_unlock( &p_resource->lock_hold );}

static int vlclua_get_libvlc( lua_State *L ){    libvlc_int_t *p_libvlc = vlclua_get_this( L )->obj.libvlc;    vlc_object_hold( p_libvlc );    vlclua_push_vlc_object( L, p_libvlc );    return 1;}

// Callbacks for vout requestsstatic int WindowOpen( vlc_object_t *p_this ){    int i_ret;    vout_window_t *pWnd = (vout_window_t *)p_this;    vlc_mutex_lock( &skin_load.mutex );    intf_thread_t *pIntf = skin_load.intf;    if( pIntf )        vlc_object_hold( pIntf );    vlc_mutex_unlock( &skin_load.mutex );    if( pIntf == NULL )        return VLC_EGENERIC;    vlc_mutex_lock( &serializer );    pWnd->handle.hwnd = VoutManager::getWindow( pIntf, pWnd );    if( pWnd->handle.hwnd )    {        pWnd->control = &VoutManager::controlWindow;        pWnd->sys = (vout_window_sys_t*)pIntf;        vlc_mutex_unlock( &serializer );        return VLC_SUCCESS;    }    else    {        vlc_object_release( pIntf );        vlc_mutex_unlock( &serializer );        return VLC_EGENERIC;    }}

static int VarsCommand (vlc_object_t *obj, char const *cmd,                        vlc_value_t oldval, vlc_value_t newval, void *data){    void *p;    (void) cmd; (void) oldval; (void) data;    if (sscanf (newval.psz_string, "%p", &p) == 1)    {        p = ObjectExists (obj, p);        if (p == NULL)        {            msg_Err (obj, "no such object: %s", newval.psz_string);            return VLC_ENOOBJ;        }        obj = p;    }    else        vlc_object_hold (obj);    PrintObject (obj, "");    DumpVariables (obj);    vlc_object_release (obj);    return VLC_SUCCESS;}

/// Callback for the systray configuration optionstatic int onTaskBarChange( vlc_object_t *pObj, const char *pVariable,                            vlc_value_t oldVal, vlc_value_t newVal,                            void *pParam ){    intf_thread_t *pIntf;    vlc_mutex_lock( &skin_load.mutex );    pIntf = skin_load.intf;    if( pIntf )        vlc_object_hold( pIntf );    vlc_mutex_unlock( &skin_load.mutex );    if( pIntf == NULL )    {        return VLC_EGENERIC;    }    AsyncQueue *pQueue = AsyncQueue::instance( pIntf );    if( newVal.b_bool )    {        CmdAddInTaskBar *pCmd = new CmdAddInTaskBar( pIntf );        pQueue->push( CmdGenericPtr( pCmd ) );    }    else    {        CmdRemoveFromTaskBar *pCmd = new CmdRemoveFromTaskBar( pIntf );        pQueue->push( CmdGenericPtr( pCmd ) );    }    vlc_object_release( pIntf );    return VLC_SUCCESS;}

/* Define the Input used.   Add the callbacks on input   p_input is held once here */void InputManager::setInput( input_thread_t *_p_input ){    delInput();    p_input = _p_input;    if( p_input && !( p_input->b_dead || !vlc_object_alive (p_input) ) )    {        msg_Dbg( p_intf, "IM: Setting an input" );        vlc_object_hold( p_input );        addCallbacks();        UpdateStatus();        UpdateName();        UpdateArt();        UpdateTeletext();        UpdateNavigation();        UpdateVout();        p_item = input_GetItem( p_input );        emit rateChanged( var_GetFloat( p_input, "rate" ) );    }    else    {        p_input = NULL;        p_item = NULL;        assert( !p_input_vbi );        emit rateChanged( var_InheritFloat( p_intf, "rate" ) );    }}

static aout_instance_t *AllocateAout( input_resource_t *p_resource ){    aout_instance_t *p_aout;    if( unlikely(p_resource->b_aout_busy) )    {        msg_Dbg( p_resource->p_parent, "creating audio output" );        return aout_New( p_resource->p_parent );    }    p_aout = p_resource->p_aout;    if( p_aout == NULL )    {        msg_Dbg( p_resource->p_parent, "creating audio output" );        p_aout = aout_New( p_resource->p_parent );        if( unlikely(p_aout == NULL) )            return NULL;        vlc_mutex_lock( &p_resource->lock_hold );        p_resource->p_aout = p_aout;        vlc_mutex_unlock( &p_resource->lock_hold );    }    else        msg_Dbg( p_resource->p_parent, "recycling audio output" );    p_resource->b_aout_busy = true;    vlc_object_hold( p_aout );    return p_aout;}

/** * Perform a deep copy of an existing ACL. * * @param p_this object to attach the copy to. * @param p_acl ACL object to be copied. * * @return a new ACL object, or NULL on error. */vlc_acl_t *ACL_Duplicate( vlc_object_t *p_this, const vlc_acl_t *p_acl ){    vlc_acl_t *p_dupacl;    if( p_acl == NULL )        return NULL;    p_dupacl = (vlc_acl_t *)malloc( sizeof( *p_dupacl ) );    if( p_dupacl == NULL )        return NULL;    if( p_acl->i_size )    {        p_dupacl->p_entries = (vlc_acl_entry_t *)            malloc( p_acl->i_size * sizeof( vlc_acl_entry_t ) );        if( p_dupacl->p_entries == NULL )        {            free( p_dupacl );            return NULL;        }        memcpy( p_dupacl->p_entries, p_acl->p_entries,                p_acl->i_size * sizeof( vlc_acl_entry_t ) );    }    else        p_dupacl->p_entries = NULL;    vlc_object_hold( p_this );    p_dupacl->p_owner = p_this;    p_dupacl->i_size = p_acl->i_size;    p_dupacl->b_allow_default = p_acl->b_allow_default;    return p_dupacl;}

/* Define the Input used.   Add the callbacks on input   p_input is held once here */void InputManager::setInput( input_thread_t *_p_input ){    delInput();    p_input = _p_input;    if( p_input != NULL )    {        msg_Dbg( p_intf, "IM: Setting an input" );        vlc_object_hold( p_input );        addCallbacks();        UpdateStatus();        UpdateName();        UpdateArt();        UpdateTeletext();        UpdateNavigation();        UpdateVout();        p_item = input_GetItem( p_input );        emit rateChanged( var_GetFloat( p_input, "rate" ) );        /* Get Saved Time */        if( p_item->i_type == ITEM_TYPE_FILE )        {            char *uri = input_item_GetURI( p_item );            int i_time = RecentsMRL::getInstance( p_intf )->time( qfu(uri) );            if( i_time > 0 && qfu( uri ) != lastURI &&                    !var_GetFloat( p_input, "run-time" ) &&                    !var_GetFloat( p_input, "start-time" ) &&                    !var_GetFloat( p_input, "stop-time" ) )            {                emit resumePlayback( (int64_t)i_time * 1000 );            }            playlist_Lock( THEPL );            // Add root items only            playlist_item_t* p_node = playlist_CurrentPlayingItem( THEPL );            if ( p_node != NULL && p_node->p_parent != NULL && p_node->p_parent->i_id == THEPL->p_playing->i_id )            {                // Save the latest URI to avoid asking to restore the                // position on the same input file.                lastURI = qfu( uri );                RecentsMRL::getInstance( p_intf )->addRecent( lastURI );            }            playlist_Unlock( THEPL );            free( uri );        }    }    else    {        p_item = NULL;        lastURI.clear();        assert( !p_input_vbi );        emit rateChanged( var_InheritFloat( p_intf, "rate" ) );    }}

static vlc_object_t *FindParent (vlc_object_t *p_this, int i_type){    for (vlc_object_t *parent = p_this->p_parent;         parent != NULL;         parent = parent->p_parent)    {        if (vlc_internals (parent)->i_object_type == i_type)            return vlc_object_hold (parent);    }    return NULL;}

/** *  Registers a new session with the announce handler, using a pregenerated SDP * * /param obj a VLC object * /param psz_sdp the SDP to register * /param psz_dst session address (needed for SAP address auto detection) * /param p_method an announce method descriptor * /return the new session descriptor structure */session_descriptor_t *sout_AnnounceRegisterSDP( vlc_object_t *obj, const char *psz_sdp,                          const char *psz_dst, announce_method_t *p_method ){    assert (p_method == &sap_method);    (void) p_method;    session_descriptor_t *p_session = calloc( 1, sizeof (*p_session) );    if( !p_session )        return NULL;    p_session->psz_sdp = strdup( psz_sdp );    /* GRUIK. We should not convert back-and-forth from string to numbers */    struct addrinfo *res;    if (vlc_getaddrinfo (obj, psz_dst, 0, NULL, &res) == 0)    {        if (res->ai_addrlen <= sizeof (p_session->addr))            memcpy (&p_session->addr, res->ai_addr,                    p_session->addrlen = res->ai_addrlen);        vlc_freeaddrinfo (res);    }    vlc_mutex_lock (&sap_mutex);    sap_handler_t *p_sap = libvlc_priv (obj->p_libvlc)->p_sap;    if (p_sap == NULL)    {        p_sap = SAP_Create (VLC_OBJECT (obj->p_libvlc));        libvlc_priv (obj->p_libvlc)->p_sap = p_sap;        vlc_object_set_destructor ((vlc_object_t *)p_sap, sap_destroy);    }    else        vlc_object_hold ((vlc_object_t *)p_sap);    vlc_mutex_unlock (&sap_mutex);    if (p_sap == NULL)        goto error;    msg_Dbg (obj, "adding SAP session");    if (SAP_Add (p_sap, p_session))    {        vlc_mutex_lock (&sap_mutex);        vlc_object_release ((vlc_object_t *)p_sap);        vlc_mutex_unlock (&sap_mutex);        goto error;    }    return p_session;error:    free (p_session->psz_sdp);    free (p_session);    return NULL;}

QVLCVariable::QVLCVariable (vlc_object_t *obj, const char *varname, int type,                            bool inherit)    : object (obj), name (qfu(varname)){    vlc_object_hold (object);    if (inherit)        type |= VLC_VAR_DOINHERIT;    var_Create (object, qtu(name), type);    var_AddCallback (object, qtu(name), callback, this);}

static int vlclua_get_playlist( lua_State *L ){    playlist_t *p_playlist = vlclua_get_playlist_internal( L );    if( p_playlist )    {        vlclua_push_vlc_object( L, p_playlist, vlclua_gc_release );        vlc_object_hold( p_playlist );    }    else lua_pushnil( L );    return 1;}

static vlc_object_t *dialog_GetProvider (vlc_object_t *obj){    libvlc_priv_t *priv = libvlc_priv (obj->p_libvlc);    vlc_object_t *provider;    vlc_mutex_lock (&provider_lock);    if ((provider = priv->p_dialog_provider) != NULL)        vlc_object_hold (provider);    vlc_mutex_unlock (&provider_lock);    return provider;}

audio_output_t *input_resource_HoldAout( input_resource_t *p_resource ){    audio_output_t *p_aout;    vlc_mutex_lock( &p_resource->lock_hold );    p_aout = p_resource->p_aout;    if( p_aout != NULL )        vlc_object_hold( p_aout );    vlc_mutex_unlock( &p_resource->lock_hold );    return p_aout;}

static vlc_object_t *FindParentName (vlc_object_t *p_this, const char *name){    for (vlc_object_t *parent = p_this->p_parent;         parent != NULL;         parent = parent->p_parent)    {        const char *objname = vlc_internals (parent)->psz_name;        if (objname && !strcmp (objname, name))            return vlc_object_hold (parent);    }    return NULL;}

static aout_instance_t *HoldAout( input_resource_t *p_resource ){    vlc_mutex_lock( &p_resource->lock_hold );    aout_instance_t *p_aout = p_resource->p_aout;    if( p_aout )        vlc_object_hold( p_aout );    vlc_mutex_unlock( &p_resource->lock_hold );    return p_aout;}

VoutWindow::VoutWindow( intf_thread_t *pIntf, vout_window_t* pWnd,                        int width, int height, GenericWindow* pParent ) :      GenericWindow( pIntf, 0, 0, false, false, pParent ),      m_pWnd( pWnd ), original_width( width ), original_height( height ),      m_pParentWindow( pParent ), m_pCtrlVideo( NULL ), m_bFullscreen( false ){    // counter for debug    count++;    if( m_pWnd )        vlc_object_hold( m_pWnd );}

    foreach( vout_thread_t *p_vout, add )    {        vlc_object_hold( VLC_OBJECT(p_vout) );        vlc_mutex_lock( &lock );        vout.append( p_vout );        var_AddCallback( p_vout, "fullscreen",                         FullscreenControllerWidget::FullscreenChanged, this );        /* I miss a add and fire */        fullscreenChanged( p_vout, var_GetBool( THEPL, "fullscreen" ),                           var_GetInteger( p_vout, "mouse-hide-timeout" ) );        vlc_mutex_unlock( &lock );    }

static int WindowOpen( vout_window_t *pWnd, const vout_window_cfg_t *cfg ){    vout_window_sys_t* sys;    vlc_mutex_lock( &skin_load.mutex );    intf_thread_t *pIntf = skin_load.intf;    if( pIntf )        vlc_object_hold( pIntf );    vlc_mutex_unlock( &skin_load.mutex );    if( pIntf == NULL )        return VLC_EGENERIC;    if( !vlc_object_alive( pIntf ) ||        !var_InheritBool( pIntf, "skinned-video") ||        cfg->is_standalone )    {        vlc_object_release( pIntf );        return VLC_EGENERIC;    }    sys = (vout_window_sys_t*)calloc( 1, sizeof( *sys ) );    if( !sys )    {        vlc_object_release( pIntf );        return VLC_ENOMEM;    }    pWnd->sys = sys;    pWnd->sys->cfg = *cfg;    pWnd->sys->pIntf = pIntf;    pWnd->control = WindowControl;    // force execution in the skins2 thread context    CmdExecuteBlock* cmd = new CmdExecuteBlock( pIntf, VLC_OBJECT( pWnd ),                                                WindowOpenLocal );    CmdExecuteBlock::executeWait( CmdGenericPtr( cmd ) );#ifdef X11_SKINS    if( !pWnd->handle.xid )#else    if( !pWnd->handle.hwnd )#endif    {        free( sys );        vlc_object_release( pIntf );        return VLC_EGENERIC;    }    return VLC_SUCCESS;}

static int PlaylistEvent( vlc_object_t *p_this, char const *psz_var,                          vlc_value_t oldval, vlc_value_t val, void *p_data ){    intf_thread_t *p_intf = (intf_thread_t *)p_data;			// sunqueen modify    intf_sys_t *p_sys = p_intf->p_sys;    input_thread_t *p_input = (input_thread_t *)val.p_address;			// sunqueen modify    (void) p_this; (void) psz_var; (void) oldval;    var_AddCallback( p_input, "intf-event", InputEvent, p_intf );    assert( p_sys->p_input == NULL );    p_sys->p_input = (input_thread_t *)vlc_object_hold( p_input );			// sunqueen modify    return VLC_SUCCESS;}

input_thread_t * vlclua_get_input_internal( lua_State *L ){    extension_t *p_extension = vlclua_extension_get( L );    if( p_extension )    {        input_thread_t *p_input = p_extension->p_sys->p_input;        if( p_input )        {            vlc_object_hold(p_input);            return p_input;        }    }    playlist_t *p_playlist = vlclua_get_playlist_internal( L );    input_thread_t *p_input = playlist_CurrentInput( p_playlist );    return p_input;}

/* * Retrieve the input thread. Be sure to release the object * once you are done with it. (libvlc Internal) */input_thread_t *libvlc_get_input_thread( libvlc_media_player_t *p_mi ){    input_thread_t *p_input_thread;    assert( p_mi );    lock_input(p_mi);    p_input_thread = p_mi->input.p_thread;    if( p_input_thread )        vlc_object_hold( p_input_thread );    else        libvlc_printerr( "No active input" );    unlock_input(p_mi);    return p_input_thread;}

/***************************************************************************** * ItemChange: Playlist item change callback *****************************************************************************/static int ItemChange(vlc_object_t *p_this, const char *psz_var,                       vlc_value_t oldval, vlc_value_t newval, void *p_data){    intf_thread_t  *p_intf  = p_data;    intf_sys_t     *p_sys   = p_intf->p_sys;    input_thread_t *p_input = newval.p_address;    VLC_UNUSED(p_this); VLC_UNUSED(psz_var);    VLC_UNUSED(oldval);    p_sys->b_meta_read      = false;    p_sys->b_submit         = false;    if (p_sys->p_input != NULL)    {        var_DelCallback(p_sys->p_input, "intf-event", PlayingChange, p_intf);        vlc_object_release(p_sys->p_input);        p_sys->p_input = NULL;    }    if (p_input == NULL)        return VLC_SUCCESS;    input_item_t *p_item = input_GetItem(p_input);    if (p_item == NULL)        return VLC_SUCCESS;    if (var_CountChoices(p_input, "video-es"))    {        msg_Dbg(p_this, "Not an audio-only input, not submitting");        return VLC_SUCCESS;    }    p_sys->time_total_pauses = 0;    time(&p_sys->p_current_song.date);        /* to be sent to last.fm */    p_sys->p_current_song.i_start = mdate();    /* only used locally */    p_sys->p_input = vlc_object_hold(p_input);    var_AddCallback(p_input, "intf-event", PlayingChange, p_intf);    if (input_item_IsPreparsed(p_item))        ReadMetaData(p_intf, p_input);    /* if the input item was not preparsed, we'll do it in PlayingChange()     * callback, when "state" == PLAYING_S */    return VLC_SUCCESS;}

static vlc_object_t *ObjectExists (vlc_object_t *root, void *obj){    if (root == obj)        return vlc_object_hold (root);    vlc_object_internals_t *priv = vlc_internals(root);    vlc_object_t *ret = NULL;    /* NOTE: nested locking here (due to recursive call) */    vlc_mutex_lock (&vlc_internals(root)->tree_lock);    for (priv = priv->first; priv != NULL && ret == NULL; priv = priv->next)        ret = ObjectExists (vlc_externals (priv), obj);    vlc_mutex_unlock (&vlc_internals(root)->tree_lock);    return ret;}