/** * 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); }
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); }
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 ); }
/***************************************************************************** * CloseDecoder: decoder destruction *****************************************************************************/ static void CloseDecoder(vlc_object_t *p_this) { decoder_t *p_dec = (decoder_t *)p_this; decoder_sys_t *p_sys = p_dec->p_sys; msg_Dbg(p_dec, "done cleaning up Cedar"); if (p_sys) { #ifdef DECODE_USE_ASYNC_THREAD vlc_cancel(p_sys->thread); vlc_join(p_sys->thread, NULL); #endif libcedarx_decoder_close(); free(p_sys); p_dec->p_sys = NULL; } }
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); }