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

/** * Open the module * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */static int Open( vlc_object_t * p_this ){    filter_t     *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys;    /* Test the audio format */    if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 ||        p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 )    {        msg_Warn( p_filter, "bad input or output format" );        return VLC_EGENERIC;    }    if( !AOUT_FMTS_SIMILAR( &p_filter->fmt_in.audio, &p_filter->fmt_out.audio ) )    {        msg_Warn( p_filter, "input and outut are not similar" );        return VLC_EGENERIC;    }    p_filter->pf_audio_filter = DoWork;    p_sys = p_filter->p_sys = (filter_sys_t*)malloc( sizeof( *p_sys ) );    if( !p_sys )        return VLC_ENOMEM;    /* Create the object for the thread */    vlc_sem_init( &p_sys->ready, 0 );    p_sys->b_error       = false;    p_sys->b_quit        = false;    p_sys->i_width       = var_InheritInteger( p_filter, "projectm-width" );    p_sys->i_height      = var_InheritInteger( p_filter, "projectm-height" );    p_sys->i_channels    = aout_FormatNbChannels( &p_filter->fmt_in.audio );    vlc_mutex_init( &p_sys->lock );    p_sys->p_buffer      = NULL;    p_sys->i_buffer_size = 0;    p_sys->i_nb_samples  = 0;    /* Create the thread */    if( vlc_clone( &p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_LOW ) )        goto error;    vlc_sem_wait( &p_sys->ready );    if( p_sys->b_error )    {        vlc_join( p_sys->thread, NULL );        goto error;    }    return VLC_SUCCESS;error:    vlc_sem_destroy( &p_sys->ready );    free (p_sys );    return VLC_EGENERIC;}

static void Close( vlc_object_t *p_this ){    intf_thread_t *p_intf = (intf_thread_t *)p_this;    var_Destroy (p_this->p_libvlc, "hildon-iface");    gtk_main_quit();    vlc_join (p_intf->p_sys->thread, NULL);    vlc_spin_destroy( &p_intf->p_sys->event_lock );    free( p_intf->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 );}

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);    free (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 );}

/** * Open the module. * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */static int Open(vlc_object_t * p_this){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys;    p_sys = p_filter->p_sys = (filter_sys_t*)malloc(sizeof(*p_sys));    if (p_sys == NULL)        return VLC_ENOMEM;    /* Create the object for the thread */    vlc_sem_init(&p_sys->ready, 0);    p_sys->b_error = false;    p_sys->i_width = var_InheritInteger(p_filter, "glspectrum-width");    p_sys->i_height = var_InheritInteger(p_filter, "glspectrum-height");    p_sys->i_channels = aout_FormatNbChannels(&p_filter->fmt_in.audio);    p_sys->i_prev_nb_samples = 0;    p_sys->p_prev_s16_buff = NULL;    p_sys->f_rotationAngle = 0;    p_sys->f_rotationIncrement = ROTATION_INCREMENT;    /* Fetch the FFT window parameters */    window_get_param( VLC_OBJECT( p_filter ), &p_sys->wind_param );    /* Create the FIFO for the audio data. */    p_sys->fifo = block_FifoNew();    if (p_sys->fifo == NULL)        goto error;    /* Create the thread */    if (vlc_clone(&p_sys->thread, Thread, p_filter,                  VLC_THREAD_PRIORITY_VIDEO))        goto error;    /* Wait for the displaying thread to be ready. */    vlc_sem_wait(&p_sys->ready);    if (p_sys->b_error)    {        vlc_join(p_sys->thread, NULL);        goto error;    }    p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32;    p_filter->fmt_out.audio = p_filter->fmt_in.audio;    p_filter->pf_audio_filter = DoWork;    return VLC_SUCCESS;error:    vlc_sem_destroy(&p_sys->ready);    free(p_sys);    return VLC_EGENERIC;}

/** * Open the module * @param p_this: the filter object * @return VLC_SUCCESS or vlc error codes */static int Open( vlc_object_t * p_this ){    filter_t     *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys;    /* Test the audio format */    if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 )    {        msg_Warn( p_filter, "bad input format" );        return VLC_EGENERIC;    }    p_sys = p_filter->p_sys = (filter_sys_t*)malloc( sizeof( *p_sys ) );    if( unlikely( !p_sys ) )    {        return VLC_ENOMEM;    }    /* Create the object for the thread */    vlc_sem_init( &p_sys->ready, 0 );    p_sys->b_error       = false;    p_sys->b_quit        = false;    p_sys->i_width       = var_InheritInteger( p_filter, "vsxu-width" );    p_sys->i_height      = var_InheritInteger( p_filter, "vsxu-height" );    p_sys->i_channels    = aout_FormatNbChannels( &p_filter->fmt_in.audio );    vlc_mutex_init( &p_sys->lock );    vlc_mutex_init( &p_sys->cyclic_block_mutex );    p_sys->vsxu_cyclic_buffer = new cyclic_block_queue();    /* Create the thread */    if( vlc_clone( &p_sys->thread, Thread, p_filter, VLC_THREAD_PRIORITY_LOW ) )        goto error;    vlc_sem_wait( &p_sys->ready );    if( p_sys->b_error )    {        vlc_join( p_sys->thread, NULL );        goto error;    }    p_filter->fmt_out.audio = p_filter->fmt_in.audio;    p_filter->pf_audio_filter = DoWork;    return VLC_SUCCESS;error:    vlc_sem_destroy( &p_sys->ready );    free (p_sys );    return VLC_EGENERIC;}

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;    vlclua_fd_interrupt( &p_sys->dtable );    vlc_join( p_sys->thread, NULL );    lua_close( p_sys->L );    vlclua_fd_cleanup( &p_sys->dtable );    free( p_sys->psz_filename );    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_join( p_sys->thread, NULL );    var_DelCallback( p_sd->obj.libvlc, p_sys->psz_var, onNewFileAdded, p_sd );    free( p_sys->psz_dir[1] );    free( p_sys->psz_dir[0] );    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);}

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

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;    close( p_sys->fd[1] );    vlc_join( p_sys->thread, NULL );    lua_close( p_sys->L );    close( p_sys->fd[0] );    vlclua_fd_destroy( p_sys );    free( p_sys->psz_filename );    free( p_sys );}

static void Close( vlc_object_t *p_this ){    stream_t *s = (stream_t*)p_this;    stream_sys_t *p_sys = s->p_sys;    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 );}

/** * 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: *****************************************************************************/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 );    Unregister( p_intf );    free( p_sys->p_map );    xcb_key_symbols_free( p_sys->p_symbols );    xcb_disconnect( p_sys->p_connection );    free( p_sys );}

/** * @brief VLC module destruct callback * @param obj */static void y4m_close(vlc_object_t* obj){    filter_t* intf = (filter_t*)obj;    filter_sys_t* sys = intf->p_sys;    msg_Info(intf, "close");    // process stop causes thread exit if blocked on write    stopProcess(intf);    // cancel causes thread exit if blocked in mutex or cond wait    if (sys->inputThread.handle)    {        vlc_cancel(sys->inputThread);        vlc_join(sys->inputThread, NULL);    }    // output should be dead if input is    if (sys->outputThread.handle)        vlc_join(sys->outputThread, NULL);    picture_fifo_Flush(sys->inputFifo, LAST_MDATE, true);    picture_fifo_Flush(sys->outputFifo, LAST_MDATE, true);    picture_fifo_Delete(sys->inputFifo);    picture_fifo_Delete(sys->outputFifo);    vlc_cond_destroy(&sys->inputCond);    vlc_cond_destroy(&sys->outputCond);    vlc_mutex_destroy(&sys->inputMutex);    vlc_mutex_destroy(&sys->outputMutex);    free(sys->cmd);    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);}

/***************************************************************************** * 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 stop_osdvnc ( filter_t *p_filter ){    filter_sys_t *p_sys = p_filter->p_sys;    /* It will unlock socket reading */    vlc_object_kill( p_filter );    /* */    msg_Dbg( p_filter, "joining worker_thread" );    vlc_cancel( p_sys->worker_thread );    vlc_join( p_sys->worker_thread, NULL );    msg_Dbg( p_filter, "released worker_thread" );    msg_Dbg( p_filter, "osdvnc stopped" );}

/***************************************************************************** * 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 );}

/***************************************************************************** * Close: *****************************************************************************/static void Close( vlc_object_t *p_this ){    demux_t     *p_demux = (demux_t*)p_this;    demux_sys_t *p_sys = p_demux->p_sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    if ( p_sys->es )        es_out_Del( p_demux->out, p_sys->es );    rfbClientCleanup( p_sys->p_client );    if ( p_sys->p_block )        block_Release( p_sys->p_block );}

/***************************************************************************** * 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;    /* stop hotkey window */    vlc_mutex_lock( &p_sys->lock );    if( p_sys->hotkeyWindow != NULL )        PostMessage( p_sys->hotkeyWindow, WM_CLOSE, 0, 0 );    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 );}

/***************************************************************************** * Close: close the DSP audio device *****************************************************************************/static void Close( vlc_object_t * p_this ){    audio_output_t *p_aout = (audio_output_t *)p_this;    struct aout_sys_t * p_sys = p_aout->sys;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    p_aout->b_die = false;    var_DelCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );    ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL );    close( p_sys->i_fd );    aout_PacketDestroy( p_aout );    free( p_sys );}

void EventThreadStop( event_thread_t *p_event ){    if( !p_event->b_ready )        return;    vlc_mutex_lock( &p_event->lock );    p_event->b_done = true;    vlc_mutex_unlock( &p_event->lock );    /* we need to be sure Vout EventThread won't stay stuck in     * GetMessage, so we send a fake message */    if( p_event->hwnd )        PostMessage( p_event->hwnd, WM_NULL, 0, 0);    vlc_join( p_event->thread, NULL );    p_event->b_ready = false;}

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;    playlist_t      *p_playlist = p_sys->p_playlist;    vlc_cancel( p_sys->thread );    vlc_join( p_sys->thread, NULL );    var_DelCallback( p_playlist, "input-current", AllCallback, p_intf );    var_DelCallback( p_playlist, "volume", AllCallback, p_intf );    var_DelCallback( p_playlist, "mute", AllCallback, p_intf );    var_DelCallback( p_playlist, "playlist-item-append", AllCallback, p_intf );    var_DelCallback( p_playlist, "playlist-item-deleted", AllCallback, p_intf );    var_DelCallback( p_playlist, "random", AllCallback, p_intf );    var_DelCallback( p_playlist, "repeat", AllCallback, p_intf );    var_DelCallback( p_playlist, "loop", AllCallback, p_intf );    var_DelCallback( p_playlist, "fullscreen", AllCallback, p_intf );    if( p_sys->p_input )    {        var_DelCallback( p_sys->p_input, "intf-event", InputCallback, p_intf );        var_DelCallback( p_sys->p_input, "can-pause", AllCallback, p_intf );        var_DelCallback( p_sys->p_input, "can-seek", AllCallback, p_intf );        vlc_object_release( p_sys->p_input );    }    /* The dbus connection is private, so we are responsible     * for closing it */    dbus_connection_close( p_sys->p_conn );    dbus_connection_unref( p_sys->p_conn );    // Free the events array    for( int i = 0; i < vlc_array_count( p_sys->p_events ); i++ )    {        callback_info_t* info = vlc_array_item_at_index( p_sys->p_events, i );        free( info );    }    vlc_mutex_destroy( &p_sys->lock );    vlc_array_destroy( p_sys->p_events );    vlc_array_destroy( p_sys->p_timeouts );    vlc_array_destroy( p_sys->p_watches );    vlc_close( p_sys->p_pipe_fds[1] );    vlc_close( p_sys->p_pipe_fds[0] );    free( p_sys );}

/** * Destroys a Wayland shell surface. */static void Close(vout_window_t *wnd){    vout_window_sys_t *sys = wnd->sys;    vlc_cancel(sys->thread);    vlc_join(sys->thread, NULL);    wl_shell_surface_destroy(sys->shell_surface);    wl_surface_destroy(wnd->handle.wl);    wl_shell_destroy(sys->shell);    if (sys->output != NULL)        wl_output_destroy(sys->output);    wl_compositor_destroy(sys->compositor);    wl_display_disconnect(wnd->display.wl);    vlc_mutex_destroy(&sys->lock);    free(sys);}

void vlc_h2_output_destroy(struct vlc_h2_output *out){    vlc_mutex_lock(&out->lock);    out->closing = true;    vlc_cond_signal(&out->wait);    vlc_mutex_unlock(&out->lock);    vlc_cancel(out->thread);    vlc_join(out->thread, NULL);    vlc_cond_destroy(&out->wait);    vlc_mutex_destroy(&out->lock);    /* Flush queues in case the thread was terminated within poll() and some     * packets were still queued. */    vlc_h2_output_flush_unlocked(out);    free(out);}