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

/***************************************************************************** * Close: destroy interface *****************************************************************************/static void Close(vlc_object_t *p_this){    sout_stream_t *p_stream = (sout_stream_t *)p_this;    sout_stream_sys_t *p_sys = p_stream->p_sys;    vlc_cancel(p_sys->chromecastThread);    vlc_join(p_sys->chromecastThread, NULL);    switch (p_sys->i_status)    {    case CHROMECAST_MEDIA_LOAD_SENT:    case CHROMECAST_APP_STARTED:        // Generate the close messages.        msgClose(p_stream, p_sys->appTransportId);        // ft    case CHROMECAST_AUTHENTICATED:        msgClose(p_stream, "receiver-0");        // Send the just added close messages.        sendMessages(p_stream);        // ft    default:        break;    }    Clean(p_stream);}

/***************************************************************************** * Close: close the target *****************************************************************************/static void Close( vlc_object_t * p_this ){    sout_access_out_t *p_access = (sout_access_out_t *) p_this;    sout_access_out_sys_t *p_sys = p_access->p_sys;    int i;    vlc_cancel( p_sys->p_thread->thread );    vlc_join( p_sys->p_thread->thread, NULL );    vlc_cond_destroy( &p_sys->p_thread->wait );    vlc_mutex_destroy( &p_sys->p_thread->lock );    block_FifoRelease( p_sys->p_thread->p_fifo_input );    block_FifoRelease( p_sys->p_thread->p_empty_blocks );    for( i = 0; i < 64; i++ ) /* RTMP_HEADER_STREAM_INDEX_MASK */    {        if( p_sys->p_thread->rtmp_headers_recv[i].body != NULL )        {            free( p_sys->p_thread->rtmp_headers_recv[i].body->body );            free( p_sys->p_thread->rtmp_headers_recv[i].body );        }    }    net_Close( p_sys->p_thread->fd );    vlc_object_release( p_sys->p_thread );    vlc_UrlClean( &p_sys->p_thread->url );    free( p_sys->p_thread->psz_application );    free( p_sys->p_thread->psz_media );    free( p_sys );}

/************************************************************************** *       libvlc_event_async_fini (internal) : * * Destroy what might have been created by. **************************************************************************/voidlibvlc_event_async_fini(libvlc_event_manager_t * p_em){    if(!is_queue_initialized(p_em)) return;    if(current_thread_is_asynch_thread(p_em))    {        fprintf(stderr, "*** Error: releasing the last reference of the observed object from its callback thread is not (yet!) supported/n");        abort();    }    vlc_thread_t thread = queue(p_em)->thread;    if(thread)    {        vlc_cancel(thread);        vlc_join(thread, NULL);    }    vlc_mutex_destroy(&queue(p_em)->lock);    vlc_cond_destroy(&queue(p_em)->signal);    vlc_cond_destroy(&queue(p_em)->signal_idle);    vlc_threadvar_delete(&queue(p_em)->is_asynch_dispatch_thread_var);    struct queue_elmt * iter = queue(p_em)->elements;    while (iter) {        struct queue_elmt * elemt_to_delete = iter;        iter = iter->next;        free(elemt_to_delete);    }    free(queue(p_em));}

/***************************************************************************** * Close: destroy interface *****************************************************************************/static void Close(vlc_object_t *p_this){    sout_stream_t *p_stream = reinterpret_cast<sout_stream_t*>(p_this);    sout_stream_sys_t *p_sys = p_stream->p_sys;    vlc_cancel(p_sys->chromecastThread);    vlc_join(p_sys->chromecastThread, NULL);    switch (p_sys->p_intf->getConnectionStatus())    {    case CHROMECAST_MEDIA_LOAD_SENT:    case CHROMECAST_APP_STARTED:        // Generate the close messages.        p_sys->p_intf->msgReceiverClose(p_sys->p_intf->appTransportId);        // ft    case CHROMECAST_AUTHENTICATED:        p_sys->p_intf->msgReceiverClose(DEFAULT_CHOMECAST_RECEIVER);        // Send the just added close messages.        p_sys->p_intf->sendMessages();        // ft    default:        break;    }    Clean(p_stream);}

/***************************************************************************** * Close: close the ALSA device *****************************************************************************/static void Close( vlc_object_t *p_this ){    aout_instance_t *p_aout = (aout_instance_t *)p_this;    struct aout_sys_t * p_sys = p_aout->output.p_sys;    int i_snd_rc;    /* Make sure that the thread will stop once it is waken up */    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    vlc_sem_destroy( &p_sys->wait );    /* */    i_snd_rc = snd_pcm_close( p_sys->p_snd_pcm );    if( i_snd_rc > 0 )    {        msg_Err( p_aout, "failed closing ALSA device (%s)",                         snd_strerror( i_snd_rc ) );    }#ifdef ALSA_DEBUG    snd_output_close( p_sys->p_snd_stderr );#endif    free( p_sys );}

/***************************************************************************** * Close: *****************************************************************************/static void Close(vlc_object_t *p_this){    fingerprinter_thread_t   *p_fingerprinter = (fingerprinter_thread_t*) p_this;    fingerprinter_sys_t *p_sys = p_fingerprinter->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    vlc_mutex_destroy( &p_sys->condwait.lock );    vlc_cond_destroy( &p_sys->condwait.wait );    for ( int i = 0; i < vlc_array_count( p_sys->incoming.queue ); i++ )        fingerprint_request_Delete( vlc_array_item_at_index( p_sys->incoming.queue, i ) );    vlc_array_destroy( p_sys->incoming.queue );    vlc_mutex_destroy( &p_sys->incoming.lock );    vlc_cond_destroy( &p_sys->incoming_queue_filled );    for ( int i = 0; i < vlc_array_count( p_sys->processing.queue ); i++ )        fingerprint_request_Delete( vlc_array_item_at_index( p_sys->processing.queue, i ) );    vlc_array_destroy( p_sys->processing.queue );    vlc_mutex_destroy( &p_sys->processing.lock );    for ( int i = 0; i < vlc_array_count( p_sys->results.queue ); i++ )        fingerprint_request_Delete( vlc_array_item_at_index( p_sys->results.queue, i ) );    vlc_array_destroy( p_sys->results.queue );    vlc_mutex_destroy( &p_sys->results.lock );    free( p_sys );}

/** * Stops and destroys all interfaces * @param p_libvlc the LibVLC instance */void intf_DestroyAll( libvlc_int_t *p_libvlc ){    intf_thread_t *p_first;    vlc_mutex_lock( &lock );    p_first = libvlc_priv( p_libvlc )->p_intf;#ifndef NDEBUG    libvlc_priv( p_libvlc )->p_intf = NULL;#endif    vlc_mutex_unlock( &lock );    /* Tell the interfaces to die */    for( intf_thread_t *p_intf = p_first; p_intf; p_intf = p_intf->p_next )        vlc_object_kill( p_intf );    /* Cleanup the interfaces */    for( intf_thread_t *p_intf = p_first; p_intf != NULL; )    {        intf_thread_t *p_next = p_intf->p_next;        if( p_intf->pf_run )        {            vlc_cancel( p_intf->thread );            vlc_join( p_intf->thread, NULL );        }        module_unneed( p_intf, p_intf->p_module );        config_ChainDestroy( p_intf->p_cfg );        vlc_object_release( p_intf );        p_intf = p_next;    }}

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/static void Close(vlc_object_t *p_this){    intf_thread_t               *p_intf = (intf_thread_t*) p_this;    intf_sys_t                  *p_sys  = p_intf->p_sys;    vlc_cancel(p_sys->thread);    vlc_join(p_sys->thread, NULL);    var_DelCallback(pl_Get(p_intf), "input-current", ItemChange, p_intf);    if (p_sys->p_input != NULL)    {        var_DelCallback(p_sys->p_input, "intf-event", PlayingChange, p_intf);        vlc_object_release(p_sys->p_input);    }    int i;    for (i = 0; i < p_sys->i_songs; i++)        DeleteSong(&p_sys->p_queue[i]);    vlc_UrlClean(&p_sys->p_submit_url);    vlc_UrlClean(&p_sys->p_nowp_url);    vlc_cond_destroy(&p_sys->wait);    vlc_mutex_destroy(&p_sys->lock);    free(p_sys);}

/***************************************************************************** * Close: *****************************************************************************/static void Close( vlc_object_t *p_this ){    services_discovery_t *p_sd = ( services_discovery_t* )p_this;    services_discovery_sys_t *p_sys  = p_sd->p_sys;    int i;    vlc_cancel (p_sys->thread);    vlc_join (p_sys->thread, NULL);    var_DelCallback( p_sd, "podcast-urls", UrlsChange, p_sys );    var_DelCallback( p_sd, "podcast-request", Request, p_sys );    vlc_cond_destroy( &p_sys->wait );    vlc_mutex_destroy( &p_sys->lock );    for( i = 0; i < p_sys->i_input; i++ )    {        input_thread_t *p_input = p_sd->p_sys->pp_input[i];        if( !p_input )            continue;        input_Stop( p_input, true );        vlc_thread_join( p_input );        vlc_object_release( p_input );        p_sd->p_sys->pp_input[i] = NULL;    }    free( p_sd->p_sys->pp_input );    for( i = 0; i < p_sys->i_urls; i++ ) free( p_sys->ppsz_urls[i] );    free( p_sys->ppsz_urls );    for( i = 0; i < p_sys->i_items; i++ ) vlc_gc_decref( p_sys->pp_items[i] );    free( p_sys->pp_items );    free( p_sys->psz_request );    free( p_sys );}

static void update_thread_cleanup( void *p ){    vlc_thread_t *th = p;    vlc_cancel( *th );    vlc_join( *th, NULL );}

/** * Closes the audio device. */static HRESULT Stop( aout_stream_sys_t *p_sys ){    vlc_mutex_lock( &p_sys->lock );    p_sys->b_playing =  true;    vlc_cond_signal( &p_sys->cond );    vlc_mutex_unlock( &p_sys->lock );    vlc_cancel( p_sys->eraser_thread );    vlc_join( p_sys->eraser_thread, NULL );    vlc_cond_destroy( &p_sys->cond );    vlc_mutex_destroy( &p_sys->lock );    if( p_sys->p_notify != NULL )    {        IDirectSoundNotify_Release(p_sys->p_notify );        p_sys->p_notify = NULL;    }    if( p_sys->p_dsbuffer != NULL )    {        IDirectSoundBuffer_Stop( p_sys->p_dsbuffer );        IDirectSoundBuffer_Release( p_sys->p_dsbuffer );        p_sys->p_dsbuffer = NULL;    }    if( p_sys->p_dsobject != NULL )    {        IDirectSound_Release( p_sys->p_dsobject );        p_sys->p_dsobject = NULL;    }    return DS_OK;}

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/static void Close(vlc_object_t *p_this){    intf_thread_t *p_intf = (intf_thread_t*) p_this;    intf_sys_t *p_sys = p_intf->p_sys;    vlc_playlist_t *playlist = p_sys->playlist;    vlc_cancel(p_sys->thread);    vlc_join(p_sys->thread, NULL);    int i;    for (i = 0; i < p_sys->i_songs; i++)        DeleteSong(&p_sys->p_queue[i]);    vlc_UrlClean(&p_sys->p_submit_url);    vlc_UrlClean(&p_sys->p_nowp_url);    vlc_cond_destroy(&p_sys->wait);    vlc_mutex_destroy(&p_sys->lock);    vlc_playlist_Lock(playlist);    vlc_player_RemoveListener(            vlc_playlist_GetPlayer(playlist), p_sys->player_listener);    vlc_playlist_RemoveListener(playlist, p_sys->playlist_listener);    vlc_playlist_Unlock(playlist);    free(p_sys);}

/***************************************************************************** * Close: destroy interface stuff *****************************************************************************/static void Close(vlc_object_t *p_this){    intf_thread_t               *p_intf = (intf_thread_t*) p_this;    intf_sys_t                  *p_sys  = p_intf->p_sys;    var_DelCallback(pl_Get(p_intf), "activity", ItemChange, p_intf);    vlc_cancel(p_sys->thread);    vlc_join(p_sys->thread, NULL);    input_thread_t *p_input = pl_CurrentInput(p_intf);    if (p_input)    {        if (p_sys->b_state_cb)            var_DelCallback(p_input, "intf-event", PlayingChange, p_intf);        vlc_object_release(p_input);    }    int i;    for (i = 0; i < p_sys->i_songs; i++)        DeleteSong(&p_sys->p_queue[i]);    vlc_UrlClean(&p_sys->p_submit_url);#if 0 //NOT USED    free(p_sys->psz_nowp_host);    free(p_sys->psz_nowp_file);#endif    vlc_cond_destroy(&p_sys->wait);    vlc_mutex_destroy(&p_sys->lock);    free(p_sys);}

void vlc_timer_destroy (vlc_timer_t timer){    vlc_cancel (timer->thread);    vlc_join (timer->thread, NULL);    vlc_cond_destroy (&timer->reschedule);    vlc_mutex_destroy (&timer->lock);    free (timer);}

/***************************************************************************** * Close: cleanup *****************************************************************************/static void Close( vlc_object_t *p_this ){    services_discovery_t *p_sd = ( services_discovery_t * )p_this;    free( p_sd->p_sys->psz_name );    vlc_cancel( p_sd->p_sys->thread );    vlc_join( p_sd->p_sys->thread, NULL );    free( p_sd->p_sys );}

static void Close (vlc_object_t *obj){    demux_t *demux = (demux_t *)obj;    demux_sys_t *sys = demux->p_sys;    vlc_cancel (sys->thread);    vlc_join (sys->thread, NULL);    snd_pcm_close (sys->pcm);}

/***************************************************************************** * CloseIntf: destroy interface *****************************************************************************/static void Close ( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;    intf_sys_t *p_sys = p_intf->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    motion_destroy( p_sys->p_motion );    free( p_sys );}

/***************************************************************************** * Close: *****************************************************************************/static void Close(vlc_object_t *p_this){    fingerprinter_thread_t   *p_fingerprinter = (fingerprinter_thread_t*) p_this;    fingerprinter_sys_t *p_sys = p_fingerprinter->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    CleanSys( p_sys );    free( p_sys );}

void Close_LuaIntf( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t*)p_this;    intf_sys_t *p_sys = p_intf->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    lua_close( p_sys->L );    free( p_sys->psz_filename );    free( p_sys );}

/***************************************************************************** * Close: destroy interface *****************************************************************************/static void Close( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;    intf_sys_t *p_sys = p_intf->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    /* Destroy structure */    lirc_freeconfig( p_sys->config );    lirc_deinit();    free( p_sys );}

/** * Releases resources */static void Close (vlc_object_t *obj){    services_discovery_t *sd = (services_discovery_t *)obj;    services_discovery_sys_t *p_sys = sd->p_sys;    vlc_cancel (p_sys->thread);    vlc_join (p_sys->thread, NULL);    xcb_disconnect (p_sys->conn);    tdestroy (p_sys->apps, DelApp);    if (p_sys->apps_root != NULL)        input_item_Release(p_sys->apps_root);    free (p_sys);}

/***************************************************************************** * Close: *****************************************************************************/static void Close( vlc_object_t *p_this ){    services_discovery_t *p_sd = (services_discovery_t *)p_this;    services_discovery_sys_t *p_sys = p_sd->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    var_DelCallback( p_sd->p_libvlc, p_sys->psz_var, onNewFileAdded, p_sd );    free( p_sys->psz_dir[1] );    free( p_sys->psz_dir[0] );    free( p_sys );}

static void Close(vlc_object_t *obj){    demux_t *demux = (demux_t *)obj;    demux_sys_t *sys = demux->p_sys;    vlc_cancel(sys->thread);    vlc_join(sys->thread, NULL);    screenshooter_destroy(sys->screenshooter);    wl_shm_destroy(sys->shm);    wl_output_destroy(sys->output);    wl_display_disconnect(sys->display);    free(sys);}

/***************************************************************************** * Close: destroy interface *****************************************************************************/void Close(vlc_object_t *object){    intf_thread_t *intf = (intf_thread_t*)object;    intf_sys_t *sys = intf->p_sys;    var_DelCallback(sys->playlist, "input-current", PlaylistEvent, intf);    if (sys->input != NULL) {        vlc_cancel(sys->thread);        vlc_join(sys->thread, NULL);    }    net_Close(sys->fd);    free(sys);}

static void Close (vlc_object_t *obj){    intf_thread_t *intf = (intf_thread_t *)obj;    intf_sys_t *p_sys = intf->p_sys;    vlc_cancel (p_sys->thread);#ifdef __APPLE__   /* In Mac OS X up to 10.5 sigwait (among others) is not a pthread    * cancellation point, so we throw a dummy quit signal to end    * sigwait() in the sigth thread */    pthread_kill (p_sys->thread, SIGQUIT);# endif    vlc_join (p_sys->thread, NULL);    free (p_sys);}

/** * Destroys the X11 window. */static void Close (vout_window_t *wnd){    vout_window_sys_t *p_sys = wnd->sys;    xcb_connection_t *conn = p_sys->conn;    if (p_sys->keys)    {        vlc_cancel (p_sys->thread);        vlc_join (p_sys->thread, NULL);        DestroyKeyHandler (p_sys->keys);    }    xcb_disconnect (conn);    free (wnd->display.x11);    free (p_sys);}

/***************************************************************************** * Close: close the target *****************************************************************************/static void Close( vlc_object_t * p_this ){    sout_access_out_t     *p_access = (sout_access_out_t*)p_this;    sout_access_out_sys_t *p_sys = p_access->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    block_FifoRelease( p_sys->p_fifo );    block_FifoRelease( p_sys->p_empty_blocks );    if( p_sys->p_buffer ) block_Release( p_sys->p_buffer );    net_Close( p_sys->i_handle );    free( p_sys );}