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

static void Close(vlc_object_t *object){    filter_t     *filter = (filter_t *)object;    filter_sys_t *sys = filter->p_sys;    var_DelCallback(filter, CFG_PREFIX "radius",   Callback, NULL);    var_DelCallback(filter, CFG_PREFIX "strength", Callback, NULL);    vlc_free(sys->cfg.buf);    vlc_mutex_destroy(&sys->lock);    free(sys);}

static void AddressDestroy (sap_address_t *addr){    assert (addr->first == NULL);    vlc_cancel (addr->thread);    vlc_join (addr->thread, NULL);    vlc_cond_destroy (&addr->wait);    vlc_mutex_destroy (&addr->lock);    net_Close (addr->fd);    free (addr);}

CAtmoConnection::~CAtmoConnection(void){  if(isOpen())     CloseConnection();#if defined(_ATMO_VLC_PLUGIN_)     vlc_mutex_destroy( &m_AccessConnection );#else     DeleteCriticalSection( &m_AccessConnection );#endif}

/***************************************************************************** * CloseDecoder: fake decoder destruction *****************************************************************************/static void CloseDecoder( vlc_object_t *p_this ){    decoder_t *p_dec = (decoder_t *)p_this;    picture_t *p_image = p_dec->p_sys->p_image;    if( p_image != NULL )        picture_Release( p_image );    vlc_mutex_destroy( &p_dec->p_sys->lock );    free( p_dec->p_sys );}

/***************************************************************************** * Destroy: destroy adjust video thread output method ***************************************************************************** * Terminate an output method created by adjustCreateOutputMethod *****************************************************************************/static void Destroy( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    var_DelCallback( p_filter, CFG_PREFIX "color", FilterCallback, NULL );    var_DelCallback( p_filter, CFG_PREFIX "similaritythres", FilterCallback, NULL );    var_DelCallback( p_filter, CFG_PREFIX "saturationthres", FilterCallback, NULL );    vlc_mutex_destroy( &p_filter->p_sys->lock );    free( p_filter->p_sys );}

/***************************************************************************** * Open: initialize interface *****************************************************************************/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 (intf_sys_t) );    if( p_sys == NULL )        return VLC_ENOMEM;    p_intf->p_sys = p_sys;    p_sys->hotkeyWindow = NULL;    vlc_mutex_init( &p_sys->lock );    vlc_cond_init( &p_sys->wait );    if( vlc_clone( &p_sys->thread, Thread, p_intf, VLC_THREAD_PRIORITY_LOW ) )    {        vlc_mutex_destroy( &p_sys->lock );        vlc_cond_destroy( &p_sys->wait );        free( p_sys );        p_intf->p_sys = NULL;        return VLC_ENOMEM;    }    vlc_mutex_lock( &p_sys->lock );    while( p_sys->hotkeyWindow == NULL )        vlc_cond_wait( &p_sys->wait, &p_sys->lock );    if( p_sys->hotkeyWindow == INVALID_HANDLE_VALUE )    {        vlc_mutex_unlock( &p_sys->lock );        vlc_join( p_sys->thread, NULL );        vlc_mutex_destroy( &p_sys->lock );        vlc_cond_destroy( &p_sys->wait );        free( p_sys );        p_intf->p_sys = NULL;        return VLC_ENOMEM;    }    vlc_mutex_unlock( &p_sys->lock );    return VLC_SUCCESS;}

static void Close( vlc_object_t *p_this ){    stream_t *s = (stream_t*)p_this;    stream_sys_t *p_sys = s->p_sys;    p_sys->b_close = true;    vlc_cond_signal(&p_sys->download.wait);    vlc_mutex_lock( &p_sys->playback.lock );    p_sys->playback.toffset = 0;    vlc_mutex_unlock( &p_sys->playback.lock );    vlc_join( p_sys->download.thread, NULL );    vlc_mutex_destroy( &p_sys->lock );    vlc_cond_destroy( &p_sys->download.wait );    vlc_mutex_destroy( &p_sys->playback.lock );    vlc_cond_destroy( &p_sys->playback.wait );    SysCleanup( p_sys );    free( p_sys );}

void vout_snapshot_Clean(vout_snapshot_t *snap){    picture_t *picture = snap->picture;    while (picture) {        picture_t *next = picture->p_next;        picture_Release(picture);        picture = next;    }    vlc_cond_destroy(&snap->wait);    vlc_mutex_destroy(&snap->lock);}

void directx_va_Close(vlc_va_t *va, directx_sys_t *dx_sys){    DestroyVideoDecoder(va, dx_sys);    DestroyVideoService(va, dx_sys);    DestroyDeviceManager(va, dx_sys);    DestroyDevice(va, dx_sys);    if (dx_sys->hdecoder_dll)        FreeLibrary(dx_sys->hdecoder_dll);    vlc_mutex_destroy( &dx_sys->surface_lock );}

/** * Deinitializes an interruption context. * The context shall no longer be used by any thread. */void vlc_interrupt_deinit(vlc_interrupt_t *ctx){    assert(ctx->callback == NULL);    assert(!ctx->attached);    vlc_mutex_destroy(&ctx->lock);    vlc_rwlock_wrlock(&vlc_interrupt_lock);    assert(vlc_interrupt_refs > 0);    if (--vlc_interrupt_refs == 0)        vlc_threadvar_delete(&vlc_interrupt_var);    vlc_rwlock_unlock(&vlc_interrupt_lock);}

static void Deactivate(vlc_object_t *p_this) {    intf_thread_t *p_intf = (intf_thread_t*)p_this;    intf_sys_t *p_sys = p_intf->p_sys;    net_ListenClose(p_sys->pi_socket);    if(p_sys->i_socket != -1)        net_Close(p_sys->i_socket);    vlc_mutex_destroy(&p_sys->o_write_lock);    close(p_sys->i_wakeup[0]);    close(p_sys->i_wakeup[1]);    free(p_sys);}

stream_t *stream_DemuxNew( demux_t *p_demux, const char *psz_demux, es_out_t *out ){    vlc_object_t *p_obj = VLC_OBJECT(p_demux);    /* We create a stream reader, and launch a thread */    stream_t     *s;    stream_sys_t *p_sys;    s = stream_CommonNew( p_obj );    if( s == NULL )        return NULL;    s->p_input = p_demux->p_input;    s->pf_read   = DStreamRead;    s->pf_control= DStreamControl;    s->pf_destroy= DStreamDelete;    s->p_sys = p_sys = malloc( sizeof( *p_sys) );    if( !s->p_sys )    {        stream_Delete( s );        return NULL;    }    p_sys->out = out;    p_sys->p_block = NULL;    p_sys->psz_name = strdup( psz_demux );    p_sys->stats.position = 0.;    p_sys->stats.length = 0;    p_sys->stats.time = 0;    /* decoder fifo */    if( ( p_sys->p_fifo = block_FifoNew() ) == NULL )    {        stream_Delete( s );        free( p_sys->psz_name );        free( p_sys );        return NULL;    }    atomic_init( &p_sys->active, true );    vlc_mutex_init( &p_sys->lock );    if( vlc_clone( &p_sys->thread, DStreamThread, s, VLC_THREAD_PRIORITY_INPUT ) )    {        vlc_mutex_destroy( &p_sys->lock );        block_FifoRelease( p_sys->p_fifo );        stream_Delete( s );        free( p_sys->psz_name );        free( p_sys );        return NULL;    }    return s;}

static voidvlc_media_tree_Delete(vlc_media_tree_t *tree){    media_tree_private_t *priv = mt_priv(tree);    vlc_media_tree_listener_id *listener;    vlc_list_foreach(listener, &priv->listeners, node)        free(listener);    vlc_list_init(&priv->listeners); /* reset */    vlc_media_tree_DestroyRootNode(tree);    vlc_mutex_destroy(&priv->lock);    free(tree);}

/* * Releases resources. */static void Close( vlc_object_t *p_this ){    services_discovery_t *p_sd = ( services_discovery_t* )p_this;    UpnpUnRegisterClient( p_sd->p_sys->client_handle );    UpnpFinish();    delete p_sd->p_sys->p_server_list;    vlc_mutex_destroy( &p_sd->p_sys->callback_lock );    free( p_sd->p_sys );}

/************************************************************************** *         new (Public) **************************************************************************/libvlc_media_list_player_t *libvlc_media_list_player_new(libvlc_instance_t * p_instance){    libvlc_media_list_player_t * p_mlp;    p_mlp = calloc( 1, sizeof(libvlc_media_list_player_t) );    if (unlikely(p_mlp == NULL))    {        libvlc_printerr("Not enough memory");        return NULL;    }    p_mlp->i_refcount = 1;    p_mlp->seek_offset = 0;    vlc_mutex_init(&p_mlp->object_lock);    vlc_mutex_init(&p_mlp->mp_callback_lock);    vlc_cond_init(&p_mlp->seek_pending);    libvlc_event_manager_init(&p_mlp->event_manager, p_mlp);    /* Create the underlying media_player */    p_mlp->p_mi = libvlc_media_player_new(p_instance);    if( p_mlp->p_mi == NULL )        goto error;    install_media_player_observer(p_mlp);    if (vlc_clone(&p_mlp->thread, playlist_thread, p_mlp,                  VLC_THREAD_PRIORITY_LOW))    {        libvlc_media_player_release(p_mlp->p_mi);        goto error;    }    return p_mlp;error:    libvlc_event_manager_destroy(&p_mlp->event_manager);    vlc_cond_destroy(&p_mlp->seek_pending);    vlc_mutex_destroy(&p_mlp->mp_callback_lock);    vlc_mutex_destroy(&p_mlp->object_lock);    free(p_mlp);    return NULL;}

/************************************************************************** *         release (Public) **************************************************************************/void libvlc_media_list_player_release(libvlc_media_list_player_t * p_mlp){    if (!p_mlp)        return;    lock(p_mlp);    p_mlp->i_refcount--;    if (p_mlp->i_refcount > 0)    {        unlock(p_mlp);        return;    }    assert(p_mlp->i_refcount == 0);    unlock(p_mlp);    vlc_cancel(p_mlp->thread);    vlc_join(p_mlp->thread, NULL);    lock(p_mlp);    /* Keep the lock(), because the uninstall functions     * check for it. That's convenient. */    uninstall_media_player_observer(p_mlp);    libvlc_media_player_release(p_mlp->p_mi);    if (p_mlp->p_mlist)    {        uninstall_playlist_observer(p_mlp);        libvlc_media_list_release(p_mlp->p_mlist);    }    unlock(p_mlp);    libvlc_event_manager_destroy(&p_mlp->event_manager);    vlc_cond_destroy(&p_mlp->seek_pending);    vlc_mutex_destroy(&p_mlp->mp_callback_lock);    vlc_mutex_destroy(&p_mlp->object_lock);    free(p_mlp->current_playing_item_path);    free(p_mlp);}

/***************************************************************************** * sout_NewInstance: creates a new stream output instance *****************************************************************************/sout_instance_t *sout_NewInstance( vlc_object_t *p_parent, const char *psz_dest ){    sout_instance_t *p_sout;    char *psz_chain;    if( psz_dest && psz_dest[0] == '#' )    {        psz_chain = strdup( &psz_dest[1] );    }    else    {        psz_chain = sout_stream_url_to_chain(            var_InheritBool(p_parent, "sout-display"), psz_dest );    }    if(!psz_chain)        return NULL;    /* *** Allocate descriptor *** */    p_sout = vlc_custom_create( p_parent, sizeof( *p_sout ), "stream output" );    if( p_sout == NULL )    {        free( psz_chain );        return NULL;    }    msg_Dbg( p_sout, "using sout chain=`%s'", psz_chain );    /* *** init descriptor *** */    p_sout->psz_sout    = strdup( psz_dest );    p_sout->i_out_pace_nocontrol = 0;    vlc_mutex_init( &p_sout->lock );    p_sout->p_stream = NULL;    var_Create( p_sout, "sout-mux-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );    p_sout->p_stream = sout_StreamChainNew( p_sout, psz_chain, NULL, NULL );    if( p_sout->p_stream )    {        free( psz_chain );        return p_sout;    }    msg_Err( p_sout, "stream chain failed for `%s'", psz_chain );    free( psz_chain );    FREENULL( p_sout->psz_sout );    vlc_mutex_destroy( &p_sout->lock );    vlc_object_release( p_sout );    return NULL;}

static inline void input_item_Clean( input_item_t *p_i ){    int i;    vlc_event_manager_fini( &p_i->event_manager );    free( p_i->psz_name );    free( p_i->psz_uri );    if( p_i->p_stats )    {        vlc_mutex_destroy( &p_i->p_stats->lock );        free( p_i->p_stats );    }    if( p_i->p_meta )        vlc_meta_Delete( p_i->p_meta );    for( i = 0; i < p_i->i_options; i++ )        free( p_i->ppsz_options[i] );    TAB_CLEAN( p_i->i_options, p_i->ppsz_options );    free( p_i->optflagv);    for( i = 0; i < p_i->i_es; i++ )    {        es_format_Clean( p_i->es[i] );        free( p_i->es[i] );    }    TAB_CLEAN( p_i->i_es, p_i->es );    for( i = 0; i < p_i->i_epg; i++ )        vlc_epg_Delete( p_i->pp_epg[i] );    TAB_CLEAN( p_i->i_epg, p_i->pp_epg );    for( i = 0; i < p_i->i_categories; i++ )        info_category_Delete( p_i->pp_categories[i] );    TAB_CLEAN( p_i->i_categories, p_i->pp_categories );    vlc_mutex_destroy( &p_i->lock );}

static voiddialog_id_release(vlc_dialog_id *p_id){    if (p_id->answer.i_type == VLC_DIALOG_LOGIN)    {        free(p_id->answer.u.login.psz_username);        free(p_id->answer.u.login.psz_password);    }    free(p_id->psz_progress_text);    vlc_mutex_destroy(&p_id->lock);    vlc_cond_destroy(&p_id->wait);    free(p_id);}

/***************************************************************************** * sout_DeleteInstance: delete a previously allocated instance *****************************************************************************/void sout_DeleteInstance( sout_instance_t * p_sout ){    /* remove the stream out chain */    sout_StreamChainDelete( p_sout->p_stream, NULL );    /* *** free all string *** */    FREENULL( p_sout->psz_sout );    vlc_mutex_destroy( &p_sout->lock );    /* *** free structure *** */    vlc_object_release( p_sout );}

/***************************************************************************** * DestroyFilter: destroy RSS video filter *****************************************************************************/static void DestroyFilter( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys = p_filter->p_sys;    vlc_timer_destroy( p_sys->timer );    vlc_mutex_destroy( &p_sys->lock );    text_style_Delete( p_sys->p_style );    free( p_sys->psz_marquee );    FreeRSS( p_sys->p_feeds, p_sys->i_feeds );    free( p_sys );}

static void Close(filter_t *filter){    filter_sys_t *sys = filter->p_sys;    MMAL_BUFFER_HEADER_T *buffer;    if (!sys)        return;    if (sys->component && sys->component->control->is_enabled)        mmal_port_disable(sys->component->control);    if (sys->input && sys->input->is_enabled)        mmal_port_disable(sys->input);    if (sys->output && sys->output->is_enabled)        mmal_port_disable(sys->output);    if (sys->component && sys->component->is_enabled)        mmal_component_disable(sys->component);    while ((buffer = mmal_queue_get(sys->filtered_pictures))) {        picture_t *pic = (picture_t *)buffer->user_data;        picture_Release(pic);    }    if (sys->filtered_pictures)        mmal_queue_destroy(sys->filtered_pictures);    if (sys->component)        mmal_component_release(sys->component);    vlc_mutex_destroy(&sys->mutex);    vlc_mutex_destroy(&sys->buffer_cond_mutex);    vlc_cond_destroy(&sys->buffer_cond);    free(sys);    bcm_host_deinit();}

/** * Close the filter */static void Close( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys = p_filter->p_sys;    var_DelCallback( p_filter, CFG_PREFIX "rows", PuzzleCallback, p_sys );    var_DelCallback( p_filter, CFG_PREFIX "cols", PuzzleCallback, p_sys );    var_DelCallback( p_filter, CFG_PREFIX "black-slot", PuzzleCallback, p_sys );    vlc_mutex_destroy( &p_sys->lock );    free( p_sys->pi_order );    free( p_sys );}

static void Destroy( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys = p_filter->p_sys;    var_DelCallback( p_filter, CFG_PREFIX "u", BluescreenCallback, p_sys );    var_DelCallback( p_filter, CFG_PREFIX "v", BluescreenCallback, p_sys );    var_DelCallback( p_filter, CFG_PREFIX "ut", BluescreenCallback, p_sys );    var_DelCallback( p_filter, CFG_PREFIX "vt", BluescreenCallback, p_sys );    free( p_sys->p_at );    vlc_mutex_destroy( &p_sys->lock );    free( p_sys );}

static void Destroy( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys = p_filter->p_sys;    var_DelCallback( p_filter, CFG_PREFIX "mask", MaskCallback,                     p_filter );    vlc_mutex_destroy( &p_sys->mask_lock );    if( p_sys->p_mask )        picture_Release( p_sys->p_mask );    free( p_sys );}

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

void vlc_http_cookies_destroy( vlc_http_cookie_jar_t * p_jar ){    if ( !p_jar )        return;    int i;    for( i = 0; i < vlc_array_count( &p_jar->cookies ); i++ )        cookie_destroy( vlc_array_item_at_index( &p_jar->cookies, i ) );    vlc_array_clear( &p_jar->cookies );    vlc_mutex_destroy( &p_jar->lock );    free( p_jar );}

/************************************************************************** * Destroy a Media Instance object (libvlc internal) * * Warning: No lock held here, but hey, this is internal. Caller must lock. **************************************************************************/static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi ){    assert( p_mi );    /* Detach Callback from the main libvlc object */    var_DelCallback( p_mi->p_libvlc,                     "snapshot-file", snapshot_was_taken, p_mi );    /* No need for lock_input() because no other threads knows us anymore */    if( p_mi->input.p_thread )        release_input_thread(p_mi, true);    input_resource_Terminate( p_mi->input.p_resource );    input_resource_Release( p_mi->input.p_resource );    vlc_mutex_destroy( &p_mi->input.lock );    libvlc_event_manager_release( p_mi->p_event_manager );    libvlc_media_release( p_mi->p_md );    vlc_mutex_destroy( &p_mi->object_lock );    libvlc_instance_t *instance = p_mi->p_libvlc_instance;    vlc_object_release( p_mi );    libvlc_release(instance);}

/***************************************************************************** * End: terminate Crop video thread output method *****************************************************************************/static void End( vout_thread_t *p_vout ){    vout_sys_t *p_sys = p_vout->p_sys;    if( p_sys->p_vout )    {        vout_filter_DelChild( p_vout, p_sys->p_vout, MouseEvent );        vout_CloseAndRelease( p_sys->p_vout );    }    vout_filter_ReleaseDirectBuffers( p_vout );    var_DelCallback( p_vout, "ratio-crop", FilterCallback, NULL );    vlc_mutex_destroy( &p_sys->lock );}