// Close all streams/contexts/loops and return void quisk_close_sound_pulseaudio() { int i = 0; if (quisk_sound_state.verbose_pulse) printf("Closing Pulseaudio interfaces \n "); while (OpenPulseDevices[i]) { pa_stream_disconnect(OpenPulseDevices[i]); pa_stream_unref(OpenPulseDevices[i]); OpenPulseDevices[i] = '\0'; i++; } if (quisk_sound_state.verbose_pulse) printf("Waiting for %d streams to disconnect\n", streams_ready); while(streams_ready > 0); if (pa_IQ_ctx) { pa_context_disconnect(pa_IQ_ctx); pa_context_unref(pa_IQ_ctx); } if (pa_ctx) { pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); } if (pa_ml) { pa_threaded_mainloop_stop(pa_ml); pa_threaded_mainloop_free(pa_ml); } }
static int pa_get_devicelist(AudioDeviceInfoList& input) { pa_mainloop *pa_ml; pa_mainloop_api *pa_mlapi; pa_operation *pa_op; pa_context *pa_ctx; int state = 0; int pa_ready = 0; pa_ml = pa_mainloop_new(); pa_mlapi = pa_mainloop_get_api(pa_ml); pa_ctx = pa_context_new(pa_mlapi, "USBqemu-devicelist"); pa_context_connect(pa_ctx, NULL, PA_CONTEXT_NOFLAGS, NULL); pa_context_set_state_callback(pa_ctx, pa_context_state_cb, &pa_ready); for (;;) { if (pa_ready == 0) { pa_mainloop_iterate(pa_ml, 1, NULL); continue; } // Connection failed if (pa_ready == 2) { pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); return -1; } switch (state) { case 0: pa_op = pa_context_get_source_info_list(pa_ctx, pa_sourcelist_cb, &input); state++; break; case 1: if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) { pa_operation_unref(pa_op); pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); return 0; } break; default: return -1; } pa_mainloop_iterate(pa_ml, 1, NULL); } }
int pa_get_devicelist(pa_devicelist_t *output) { pa_mainloop *pa_ml = NULL; pa_mainloop_api *pa_mlapi = NULL; pa_operation *pa_op = NULL; pa_context *pa_ctx = NULL; uint8_t state = 0; int pa_ready = 0; memset(output, 0, sizeof(pa_devicelist_t) * 16); if ( (pa_ml = pa_mainloop_new()) == NULL) return -1; if ( (pa_mlapi = pa_mainloop_get_api(pa_ml)) == NULL ) return -2; if ( (pa_ctx = pa_context_new(pa_mlapi, "test")) == NULL) return -3; pa_context_connect(pa_ctx, NULL, 0, NULL); pa_context_set_state_callback(pa_ctx, pa_state_cb, &pa_ready); while (1) { if (pa_ready == 0) { pa_mainloop_iterate(pa_ml, 1, NULL); continue; } if (pa_ready == 2) { pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); return -1; } switch (state) { case 0: pa_op = pa_context_get_sink_info_list(pa_ctx, pa_sinklist_cb, output); state++; break; case 1: if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) { pa_operation_unref(pa_op); pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); return 0; } break; default: return -1; } pa_mainloop_iterate(pa_ml, 1, NULL); } }
int main(int argc, const char *argv[]) { pa_mainloop *pa_ml = NULL; pa_mainloop_api *pa_mlapi = NULL; pa_operation *pa_op = NULL; pa_context *pa_ctx = NULL; int pa_ready = 0; int state = 0; pa_ml = pa_mainloop_new(); pa_mlapi = pa_mainloop_get_api(pa_ml); pa_ctx = pa_context_new(pa_mlapi, "deepin"); pa_context_connect(pa_ctx, NULL, 0, NULL); pa_context_set_state_callback(pa_ctx, pa_state_cb, &pa_ready); for (;;) { if (pa_ready == 0) { pa_mainloop_iterate(pa_ml, 1, NULL); continue; } if (pa_ready == 2) { pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); return -1; } switch (state) { case 0: pa_op = pa_context_get_source_output_info_list(pa_ctx, pa_source_output_cb, NULL); state++; break; case 1: if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) { pa_operation_unref(pa_op); pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); return 0; } break; default: fprintf(stderr, "in state %d\n", state); return -1; } pa_mainloop_iterate(pa_ml, 1, NULL); } return 0; }
static void pulse_close(ALCdevice *device) //{{{ { pulse_data *data = device->ExtraData; pa_threaded_mainloop_lock(data->loop); if(data->stream) { pa_stream_disconnect(data->stream); pa_stream_unref(data->stream); } pa_context_disconnect(data->context); pa_context_unref(data->context); pa_threaded_mainloop_unlock(data->loop); pa_threaded_mainloop_stop(data->loop); pa_threaded_mainloop_free(data->loop); DestroyRingBuffer(data->ring); free(data->device_name); device->ExtraData = NULL; pa_xfree(data); } //}}}
static void rdpsnd_pulse_free(rdpsndDevicePlugin * devplugin) { struct pulse_device_data * pulse_data; pulse_data = (struct pulse_device_data *) devplugin->device_data; LLOGLN(10, ("rdpsnd_pulse_free:")); if (!pulse_data) return; rdpsnd_pulse_close(devplugin); if (pulse_data->mainloop) { pa_threaded_mainloop_stop(pulse_data->mainloop); } if (pulse_data->context) { pa_context_disconnect(pulse_data->context); pa_context_unref(pulse_data->context); pulse_data->context = NULL; } if (pulse_data->mainloop) { pa_threaded_mainloop_free(pulse_data->mainloop); pulse_data->mainloop = NULL; } free(pulse_data); devplugin->device_data = NULL; }
void AudioOutputPulseAudio::CloseDevice() { if (mainloop) pa_threaded_mainloop_lock(mainloop); if (pstream) { FlushStream("CloseDevice"); pa_stream_disconnect(pstream); pa_stream_unref(pstream); pstream = NULL; } if (pcontext) { pa_context_drain(pcontext, NULL, NULL); pa_context_disconnect(pcontext); pa_context_unref(pcontext); pcontext = NULL; } if (mainloop) { pa_threaded_mainloop_unlock(mainloop); pa_threaded_mainloop_stop(mainloop); mainloop = NULL; } }
void CAESinkPULSE::Deinitialize() { CSingleLock lock(m_sec); m_IsAllocated = false; m_passthrough = false; m_periodSize = 0; if (m_Stream) Drain(); if (m_MainLoop) pa_threaded_mainloop_stop(m_MainLoop); if (m_Stream) { pa_stream_disconnect(m_Stream); pa_stream_unref(m_Stream); m_Stream = NULL; m_IsStreamPaused = false; } if (m_Context) { pa_context_disconnect(m_Context); pa_context_unref(m_Context); m_Context = NULL; } if (m_MainLoop) { pa_threaded_mainloop_free(m_MainLoop); m_MainLoop = NULL; } }
//////////////////////////////////////////////////////////////////////// // REMOVE SOUND //////////////////////////////////////////////////////////////////////// void RemoveSound (void) { if (device.mainloop != NULL) pa_threaded_mainloop_stop (device.mainloop); // Release in reverse order of acquisition if (device.stream != NULL) { pa_stream_unref (device.stream); device.stream = NULL; } if (device.context != NULL) { pa_context_disconnect (device.context); pa_context_unref (device.context); device.context = NULL; } if (device.mainloop != NULL) { pa_threaded_mainloop_free (device.mainloop); device.mainloop = NULL; } }
int sa_stream_destroy(sa_stream_t *s) { if (s == NULL) { return SA_SUCCESS; } pthread_mutex_lock(&s->mutex); s->thread_id = 0; pthread_mutex_unlock(&s->mutex); pa_threaded_mainloop_lock(s->m); pa_stream_disconnect(s->stream); s->stream = NULL; pa_context_disconnect(s->context); pa_context_unref(s->context); s->context = NULL; pa_threaded_mainloop_unlock(s->m); pa_threaded_mainloop_stop(s->m); pa_threaded_mainloop_free(s->m); pthread_mutex_destroy(&s->mutex); while (s->bl_head != NULL) { sa_buf * next = s->bl_head->next; free(s->bl_head); s->bl_head = next; } free(s); return SA_SUCCESS; }
/* This callback is called when the context drain is complete, i.e. the * context is ready to be disconnected. */ static void context_drain_complete_cb(pa_context*c, void *userdata) { _mbx_out out = (_mbx_out ) userdata; assert ( out != NULL && out->pa_ctx == c); mbx_log_debug(MBX_LOG_AUDIO_OUTPUT, "Draining pulseaudio context has completed."); pa_context_disconnect(c); out->state = _MBX_OUT_SHUT_DOWN; }
/* * clean up and disconnect * args: * pa_ctx - pointer to pulse context * pa_ml - pointer to pulse mainloop * * asserts: * none * * returns: * none */ static void finish(pa_context *pa_ctx, pa_mainloop *pa_ml) { /* clean up and disconnect */ pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); }
void pulse_conn_close(struct pulse_conn_t *conn) { int err; unsigned int i; uint8_t cmd; cmd = 1; err = write(conn->pipe[1], &cmd, 1); if(err < 0) fprintf(stderr, "Failed to write to descriptor. %s.", strerror(errno)), exit(1); pthread_join(conn->thread, NULL); pa_context_disconnect(conn->context); pa_context_unref(conn->context); pa_mainloop_free(conn->loop); for(i = 0; i < conn->width; i++) free(conn->buf[i]); free(conn->buf); close(conn->pipe[0]); close(conn->pipe[1]); free(conn); }
void swfdec_playback_close (SwfdecPlayback *sound) { pa_operation *op; #define REMOVE_HANDLER_FULL(obj,func,data,count) G_STMT_START {\ if (g_signal_handlers_disconnect_by_func ((obj), \ G_CALLBACK (func), (data)) != (count)) { \ g_assert_not_reached (); \ } \ } G_STMT_END #define REMOVE_HANDLER(obj,func,data) REMOVE_HANDLER_FULL (obj, func, data, 1) while (sound->streams) swfdec_playback_stream_close (sound->streams->data); REMOVE_HANDLER (sound->player, advance_before, sound); REMOVE_HANDLER (sound->player, audio_added, sound); REMOVE_HANDLER (sound->player, audio_removed, sound); if (sound->pa != NULL) { op = pa_context_drain (sound->pa, context_drain_complete, NULL); if (op == NULL) { pa_context_disconnect (sound->pa); pa_context_unref (sound->pa); } else { pa_operation_unref (op); } pa_glib_mainloop_free (sound->pa_mainloop); } g_main_context_unref (sound->context); g_free (sound); }
JNIEXPORT void JNICALL Java_com_harrcharr_pulse_PulseContext_disconnect( JNIEnv *jenv, jobject jobj) { pa_context *c = (pa_context *)get_obj_ptr(jenv, jobj); pa_context_disconnect(c); pa_context_unref(c); }
static void pulse_close(void) { connected = 0; if (mainloop) pa_threaded_mainloop_stop(mainloop); if (stream) { pa_stream_disconnect(stream); pa_stream_unref(stream); stream = NULL; } if (context) { pa_context_disconnect(context); pa_context_unref(context); context = NULL; } if (mainloop) { pa_threaded_mainloop_free(mainloop); mainloop = NULL; } volume_time_event = NULL; volume_valid = 0; }
static void pulse_close(ALCdevice *device) { pulse_data *data = device->ExtraData; pa_threaded_mainloop_lock(data->loop); if(data->stream) { #if PA_CHECK_VERSION(0,9,15) if(pa_stream_set_buffer_attr_callback) pa_stream_set_buffer_attr_callback(data->stream, NULL, NULL); #endif pa_stream_disconnect(data->stream); pa_stream_unref(data->stream); } pa_context_disconnect(data->context); pa_context_unref(data->context); pa_threaded_mainloop_unlock(data->loop); pa_threaded_mainloop_stop(data->loop); pa_threaded_mainloop_free(data->loop); free(data->device_name); device->ExtraData = NULL; pa_xfree(data); }
static void gst_pulsemixer_ctrl_close (GstPulseMixerCtrl * c) { g_assert (c); if (c->mainloop) pa_threaded_mainloop_stop (c->mainloop); if (c->context) { pa_context_disconnect (c->context); pa_context_unref (c->context); c->context = NULL; } if (c->mainloop) { pa_threaded_mainloop_free (c->mainloop); c->mainloop = NULL; c->time_event = NULL; } if (c->tracklist) { g_list_free (c->tracklist); c->tracklist = NULL; } if (c->track) { GST_PULSEMIXER_TRACK (c->track)->control = NULL; g_object_unref (c->track); c->track = NULL; } }
bool PulseDeviceFinder::Reconnect() { if (context_) { pa_context_disconnect(context_); pa_context_unref(context_); } context_ = pa_context_new(pa_mainloop_get_api(mainloop_), "Clementine device finder"); if (!context_) { qLog(Warning) << "Failed to create pulseaudio context"; return false; } if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOFLAGS, nullptr) < 0) { qLog(Warning) << "Failed to connect pulseaudio context"; return false; } // Wait for the context to be connected. forever { const pa_context_state state = pa_context_get_state(context_); if (state == PA_CONTEXT_FAILED || state == PA_CONTEXT_TERMINATED) { qLog(Warning) << "Connection to pulseaudio failed"; return false; } if (state == PA_CONTEXT_READY) { return true; } pa_mainloop_iterate(mainloop_, true, nullptr); } }
static void uninit(struct ao *ao, bool cut_audio) { struct priv *priv = ao->priv; if (priv->stream && !cut_audio) { pa_threaded_mainloop_lock(priv->mainloop); waitop(priv, pa_stream_drain(priv->stream, success_cb, ao)); } if (priv->mainloop) pa_threaded_mainloop_stop(priv->mainloop); if (priv->stream) { pa_stream_disconnect(priv->stream); pa_stream_unref(priv->stream); priv->stream = NULL; } if (priv->context) { pa_context_disconnect(priv->context); pa_context_unref(priv->context); priv->context = NULL; } if (priv->mainloop) { pa_threaded_mainloop_free(priv->mainloop); priv->mainloop = NULL; } }
void PulseOutput::close() { #ifdef DEBUG context->getReactor().debug(); #endif if (stream) { GM_DEBUG_PRINT("[pulse] disconnecting stream\n"); pa_stream_disconnect(stream); pa_stream_unref(stream); stream=nullptr; } if (pulse_context) { GM_DEBUG_PRINT("[pulse] disconnecting context\n"); pa_context_disconnect(pulse_context); pa_context_unref(pulse_context); pulse_context=nullptr; } #ifdef DEBUG context->getReactor().debug(); #endif delete pa_io_event::recycle; delete pa_time_event::recycle; delete pa_defer_event::recycle; pa_io_event::recycle = nullptr; pa_time_event::recycle = nullptr; pa_defer_event::recycle = nullptr; pulsevolume = PA_VOLUME_MUTED; af.reset(); }
static void tsmf_pulse_free(ITSMFAudioDevice * audio) { TSMFPulseAudioDevice * pulse = (TSMFPulseAudioDevice *) audio; LLOGLN(0, ("tsmf_pulse_free:")); tsmf_pulse_close_stream(pulse); if (pulse->mainloop) { pa_threaded_mainloop_stop(pulse->mainloop); } if (pulse->context) { pa_context_disconnect(pulse->context); pa_context_unref(pulse->context); pulse->context = NULL; } if (pulse->mainloop) { pa_threaded_mainloop_free(pulse->mainloop); pulse->mainloop = NULL; } free(pulse); }
static void rdpsnd_pulse_free(rdpsndDevicePlugin* device) { rdpsndPulsePlugin* pulse = (rdpsndPulsePlugin*)device; if (!pulse) return; rdpsnd_pulse_close(device); if (pulse->mainloop) { pa_threaded_mainloop_stop(pulse->mainloop); } if (pulse->context) { pa_context_disconnect(pulse->context); pa_context_unref(pulse->context); pulse->context = NULL; } if (pulse->mainloop) { pa_threaded_mainloop_free(pulse->mainloop); pulse->mainloop = NULL; } xfree(pulse->device_name); freerdp_dsp_context_free(pulse->dsp_context); xfree(pulse); }
static void uninit(struct ao *ao) { struct priv *priv = ao->priv; if (priv->mainloop) pa_threaded_mainloop_stop(priv->mainloop); if (priv->stream) { pa_stream_disconnect(priv->stream); pa_stream_unref(priv->stream); priv->stream = NULL; } if (priv->context) { pa_context_disconnect(priv->context); pa_context_unref(priv->context); priv->context = NULL; } if (priv->mainloop) { pa_threaded_mainloop_free(priv->mainloop); priv->mainloop = NULL; } pthread_cond_destroy(&priv->wakeup); pthread_mutex_destroy(&priv->wakeup_lock); }
/* * enumerate input/output devices */ static void pulse_enumerate_devices(obs_properties_t props, bool input) { pa_context *c; pa_operation *op; pa_threaded_mainloop *m = pa_threaded_mainloop_new(); struct pulse_enumerate e; e.mainloop = m; e.devices = obs_properties_add_list(props, "device_id", "Device", OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING); e.input = input; pa_threaded_mainloop_start(m); c = pulse_context_create(m); if (pulse_context_connect(m, c) < 0) goto fail; pa_threaded_mainloop_lock(m); op = pa_context_get_source_info_list(c, pulse_source_info, (void *) &e); while (pa_operation_get_state(op) == PA_OPERATION_RUNNING) pa_threaded_mainloop_wait(m); pa_operation_unref(op); pa_threaded_mainloop_unlock(m); pa_context_disconnect(c); fail: pa_context_unref(c); pa_threaded_mainloop_stop(m); pa_threaded_mainloop_free(m); }
void backend_destroy(context_t *context) { pa_threaded_mainloop_stop(context->loop); pa_context_disconnect(context->context); pa_context_unref(context->context); pa_threaded_mainloop_free(context->loop); free(context); }
static void pulse_close(void) { ENTER(__FUNCTION__); drain(); connected = 0; if (mainloop) pa_threaded_mainloop_stop(mainloop); connected = 0; if (context) { SHOW_TIME("pa_context_disconnect (call)"); pa_context_disconnect(context); pa_context_unref(context); context = NULL; } if (mainloop) { SHOW_TIME("pa_threaded_mainloop_free (call)"); pa_threaded_mainloop_free(mainloop); mainloop = NULL; } SHOW_TIME("pulse_close (ret)"); }
static void audin_pulse_free(IAudinDevice* device) { AudinPulseDevice* pulse = (AudinPulseDevice*) device; DEBUG_DVC(""); if (!pulse) return; if (pulse->mainloop) { pa_threaded_mainloop_stop(pulse->mainloop); } if (pulse->context) { pa_context_disconnect(pulse->context); pa_context_unref(pulse->context); pulse->context = NULL; } if (pulse->mainloop) { pa_threaded_mainloop_free(pulse->mainloop); pulse->mainloop = NULL; } xfree(pulse); }
static void pulse_free(void *data) { pa_t *pa = (pa_t*)data; if (!pa) return; if (pa->mainloop) pa_threaded_mainloop_stop(pa->mainloop); if (pa->stream) { pa_stream_disconnect(pa->stream); pa_stream_unref(pa->stream); } if (pa->context) { pa_context_disconnect(pa->context); pa_context_unref(pa->context); } if (pa->mainloop) pa_threaded_mainloop_free(pa->mainloop); free(pa); }
static void uninit(aout_instance_t *p_aout){ struct aout_sys_t * p_sys = p_aout->output.p_sys; if (p_sys->mainloop) pa_threaded_mainloop_stop(p_sys->mainloop); if (p_sys->stream) { pa_stream_disconnect(p_sys->stream); pa_stream_unref(p_sys->stream); p_sys->stream = NULL; } if (p_sys->context) { pa_context_disconnect(p_sys->context); pa_context_unref(p_sys->context); p_sys->context = NULL; } if (p_sys->mainloop) { pa_threaded_mainloop_free(p_sys->mainloop); p_sys->mainloop = NULL; } free(p_sys); p_aout->output.p_sys = NULL; }