////////////////////////////////////////////////////////////////////////
// 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;
}
}
/** Destroy libao driver */
static void uninit(int immed) {
if (stream && !immed) {
pa_threaded_mainloop_lock(mainloop);
waitop(pa_stream_drain(stream, success_cb, NULL));
}
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;
}
}
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 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;
}
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);
}
/*
* 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);
}
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 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_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
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;
}
}
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);
}
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;
}
}
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;
}
// 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 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 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 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;
}
}
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);
}
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;
}
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 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);
} //}}}
void guac_pa_stop_stream(guac_client* client) {
vnc_guac_client_data* client_data = (vnc_guac_client_data*) client->data;
/* Stop loop */
pa_threaded_mainloop_stop(client_data->pa_mainloop);
guac_client_log_info(client, "Audio stream finished");
}
RageSoundDriver_PulseAudio::~RageSoundDriver_PulseAudio()
{
pa_context_disconnect(m_PulseCtx);
pa_context_unref(m_PulseCtx);
pa_threaded_mainloop_stop(m_PulseMainLoop);
pa_threaded_mainloop_free(m_PulseMainLoop);
if(m_Error != nullptr)
{
free(m_Error);
}
}
static void
pulse_output_disable(struct audio_output *ao)
{
struct pulse_output *po = (struct pulse_output *)ao;
assert(po->mainloop != NULL);
pa_threaded_mainloop_stop(po->mainloop);
if (po->context != NULL)
pulse_output_delete_context(po);
pa_threaded_mainloop_free(po->mainloop);
po->mainloop = NULL;
}
/**
* Closes a connection to PulseAudio.
*/
void vlc_pa_disconnect (vlc_object_t *obj, pa_context *ctx,
pa_threaded_mainloop *mainloop)
{
pa_threaded_mainloop_lock (mainloop);
pa_context_disconnect (ctx);
pa_context_set_state_callback (ctx, NULL, NULL);
pa_context_unref (ctx);
pa_threaded_mainloop_unlock (mainloop);
pa_threaded_mainloop_stop (mainloop);
pa_threaded_mainloop_free (mainloop);
(void) obj;
}
APULSE_EXPORT
void
pa_threaded_mainloop_free(pa_threaded_mainloop *m)
{
trace_info_f("F %s m=%p\n", __func__, m);
if (m->running)
pa_threaded_mainloop_stop(m);
pthread_mutex_destroy(&m->lock);
pthread_cond_destroy(&m->cond);
pa_mainloop_free(m->m);
free(m);
}
PulseAudioWrapper::~PulseAudioWrapper()
{
qDeleteAll(d->cards);
qDeleteAll(d->sinks);
pa_context_disconnect(PulseAudioWrapperPrivate::paContext);
pa_threaded_mainloop_wait(PulseAudioWrapperPrivate::paMainLoop);
pa_context_unref(PulseAudioWrapperPrivate::paContext);
pa_threaded_mainloop_stop(PulseAudioWrapperPrivate::paMainLoop);
pa_threaded_mainloop_free(PulseAudioWrapperPrivate::paMainLoop);
}
static void m_destroy(GtkWindow *window, gpointer user_data)
{
if (m_pa_ctx) {
pa_context_unref(m_pa_ctx);
m_pa_ctx = NULL;
}
if (m_pa_ml) {
pa_threaded_mainloop_stop(m_pa_ml);
pa_threaded_mainloop_free(m_pa_ml);
m_pa_ml = NULL;
}
gtk_main_quit();
}
void xmms_pulse_backend_free (xmms_pulse *p)
{
assert (p);
if (p->stream)
xmms_pulse_backend_close_stream (p);
if (p->mainloop)
pa_threaded_mainloop_stop (p->mainloop);
if (p->context)
pa_context_unref (p->context);
if (p->mainloop)
pa_threaded_mainloop_free (p->mainloop);
g_free (p);
}
void QPulseAudioThread::cleanup()
{
pa_threaded_mainloop_stop ( mainloop );
if ( stream )
pa_stream_unref ( stream );
if ( context )
pa_context_unref ( context );
if ( stdio_event ) {
assert ( mainloop_api );
mainloop_api->io_free ( stdio_event );
}
if ( time_event ) {
assert ( mainloop_api );
mainloop_api->time_free ( time_event );
}
if ( mainloop_api )
mainloop_api->quit ( mainloop_api, 0 );
if ( mainloop ) {
pa_signal_done();
pa_threaded_mainloop_free ( mainloop );
}
if ( buffer )
pa_xfree ( buffer );
if ( server )
pa_xfree ( server );
if ( device )
pa_xfree ( device );
if ( client_name )
pa_xfree ( client_name );
if ( stream_name )
pa_xfree ( stream_name );
return ;
}
