static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, int64_t offset, pa_seek_mode_t seek, const pa_memchunk *chunk, void *userdata) { pa_context *c = userdata; pa_stream *s; pa_assert(p); pa_assert(chunk); pa_assert(chunk->length > 0); pa_assert(c); pa_assert(PA_REFCNT_VALUE(c) >= 1); pa_context_ref(c); if (c->srb_template.readfd != -1 && c->srb_template.memblock == NULL) { handle_srbchannel_memblock(c, chunk->memblock); pa_context_unref(c); return; } if ((s = pa_hashmap_get(c->record_streams, PA_UINT32_TO_PTR(channel)))) { if (chunk->memblock) { pa_memblockq_seek(s->record_memblockq, offset, seek, true); pa_memblockq_push_align(s->record_memblockq, chunk); } else pa_memblockq_seek(s->record_memblockq, offset+chunk->length, seek, true); if (s->read_callback) { size_t l; if ((l = pa_memblockq_get_length(s->record_memblockq)) > 0) s->read_callback(s, l, s->read_userdata); } } pa_context_unref(c); }
void ausrv_destroy(struct ausrv *ausrv) { if (ausrv != NULL) { stream_kill_all(ausrv); if (ausrv->context != NULL) pa_context_unref(ausrv->context); if (ausrv->mainloop != NULL) pa_glib_mainloop_free(ausrv->mainloop); free(ausrv->server); free(ausrv); } }
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); }
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(); }
bool PulseAudio::init(bool) { pa_ml = pa_mainloop_new(); pa_mainloop_api* pa_mlapi = pa_mainloop_get_api(pa_ml); pa_context* pa_ctx = pa_context_new(pa_mlapi, "MuseScore"); if (pa_context_connect(pa_ctx, NULL, pa_context_flags_t(0), NULL) != 0) { qDebug("PulseAudio Context Connect Failed with Error: %s", pa_strerror(pa_context_errno(pa_ctx))); return false; } int pa_ready = 0; pa_context_set_state_callback(pa_ctx, pa_state_cb, &pa_ready); while (pa_ready == 0) pa_mainloop_iterate(pa_ml, 1, NULL); if (pa_ready == 2) return false; ss.rate = _sampleRate; ss.channels = 2; ss.format = PA_SAMPLE_FLOAT32LE; pa_stream* playstream = pa_stream_new(pa_ctx, "Playback", &ss, NULL); if (!playstream) { qDebug("pa_stream_new failed: %s", pa_strerror(pa_context_errno(pa_ctx))); return false; } pa_stream_set_write_callback(playstream, paCallback, this); bufattr.fragsize = (uint32_t)-1; bufattr.maxlength = FRAMES * 2 * sizeof(float); bufattr.minreq = FRAMES * 1 * sizeof(float); // pa_usec_to_bytes(0, &ss); bufattr.prebuf = (uint32_t)-1; bufattr.tlength = bufattr.maxlength; int r = pa_stream_connect_playback(playstream, nullptr, &bufattr, PA_STREAM_NOFLAGS, nullptr, nullptr); if (r < 0) { qDebug("pa_stream_connect_playback failed"); pa_context_disconnect(pa_ctx); pa_context_unref(pa_ctx); pa_mainloop_free(pa_ml); pa_ml = 0; return false; } return true; }
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 ; }
CPulseAE::~CPulseAE() { if (m_Context) { pa_context_disconnect(m_Context); pa_context_unref(m_Context); m_Context = NULL; } if (m_MainLoop) { pa_threaded_mainloop_stop(m_MainLoop); pa_threaded_mainloop_free(m_MainLoop); } }
AudioDevPulseAudio::~AudioDevPulseAudio() { this->uninit(); if (this->d->m_context) { pa_context_disconnect(this->d->m_context); pa_context_unref(this->d->m_context); } if (this->d->m_mainLoop) { pa_threaded_mainloop_stop(this->d->m_mainLoop); pa_threaded_mainloop_free(this->d->m_mainLoop); } delete this->d; }
void Sounds::destroy() { if (m_loop) { pa_threaded_mainloop_stop(m_loop); } if (m_ctx) { pa_context_disconnect(m_ctx); pa_context_unref(m_ctx); m_ctx = 0; } if (m_loop) { pa_threaded_mainloop_free(m_loop); m_loop = 0; } }
static pa_context *connect_context(pa_threaded_mainloop *loop, ALboolean silent) { const char *name = "OpenAL Soft"; char path_name[PATH_MAX]; pa_context_state_t state; pa_context *context; int err; if(pa_get_binary_name(path_name, sizeof(path_name))) name = pa_path_get_filename(path_name); context = pa_context_new(pa_threaded_mainloop_get_api(loop), name); if(!context) { ERR("pa_context_new() failed\n"); return NULL; } pa_context_set_state_callback(context, context_state_callback, loop); if((err=pa_context_connect(context, NULL, pulse_ctx_flags, NULL)) >= 0) { while((state=pa_context_get_state(context)) != PA_CONTEXT_READY) { if(!PA_CONTEXT_IS_GOOD(state)) { err = pa_context_errno(context); if(err > 0) err = -err; break; } pa_threaded_mainloop_wait(loop); } } pa_context_set_state_callback(context, NULL, NULL); if(err < 0) { if(!silent) ERR("Context did not connect: %s\n", pa_strerror(err)); pa_context_unref(context); return NULL; } return context; }
PulseAudioSystem::~PulseAudioSystem() { bRunning = false; if (bAttenuating) { qmWait.lock(); bAttenuating = false; setVolumes(); bool success = qwcWait.wait(&qmWait, 1000); if (! success) { qWarning("PulseAudio: Shutdown timeout when attempting to restore volumes."); } qmWait.unlock(); } pa_threaded_mainloop_stop(pam); pa_context_disconnect(pacContext); pa_context_unref(pacContext); pa_threaded_mainloop_free(pam); }
static void pa_command_enable_srbchannel(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) { pa_context *c = userdata; #ifdef HAVE_CREDS pa_cmsg_ancil_data *ancil = NULL; pa_assert(pd); pa_assert(command == PA_COMMAND_ENABLE_SRBCHANNEL); pa_assert(t); pa_assert(c); pa_assert(PA_REFCNT_VALUE(c) >= 1); ancil = pa_pdispatch_take_ancil_data(pd); if (!ancil) goto fail; /* Currently only one srb channel is supported, might change in future versions */ if (c->srb_template.readfd != -1) goto fail; if (ancil->nfd != 2 || ancil->fds[0] == -1 || ancil->fds[1] == -1) goto fail; pa_context_ref(c); c->srb_template.readfd = ancil->fds[0]; c->srb_template.writefd = ancil->fds[1]; c->srb_setup_tag = tag; pa_context_unref(c); ancil->close_fds_on_cleanup = false; return; fail: if (ancil) pa_cmsg_ancil_data_close_fds(ancil); pa_context_fail(c, PA_ERR_PROTOCOL); return; #else pa_assert(c); pa_context_fail(c, PA_ERR_PROTOCOL); #endif }
void PulseAudioPlayer::CloseStream() { if (!open) return; //printf("Closing PuseAudio\n"); if (is_playing) Stop(); // Hope for the best and just do things as quickly as possible pa_stream_disconnect(stream); pa_stream_unref(stream); pa_context_disconnect(context); pa_context_unref(context); pa_threaded_mainloop_stop(mainloop); pa_threaded_mainloop_free(mainloop); //printf("Closed PulseAudio\n"); open = false; }
static void gst_pulsesrc_destroy_context (GstPulseSrc * pulsesrc) { gst_pulsesrc_destroy_stream (pulsesrc); if (pulsesrc->context) { pa_context_disconnect (pulsesrc->context); /* Make sure we don't get any further callbacks */ pa_context_set_state_callback (pulsesrc->context, NULL, NULL); pa_context_set_subscribe_callback (pulsesrc->context, NULL, NULL); pa_context_unref (pulsesrc->context); pulsesrc->context = NULL; } }
static void pai_context_set_state(pa_context *c, pa_context_state_t new_state) { if (c->state == new_state) return; pa_context_ref(c); c->state = new_state; if (c->state_cb) c->state_cb(c, c->state_cb_userdata); if (new_state == PA_CONTEXT_FAILED || new_state == PA_CONTEXT_TERMINATED) { c->state_cb = NULL; } pa_context_unref(c); }
ALCboolean alc_pulse_init(BackendFuncs *func_list) { ALCboolean ret = ALC_FALSE; if(pulse_load()) { pa_threaded_mainloop *loop; pulse_ctx_flags = 0; if(!GetConfigValueBool("pulse", "spawn-server", 0)) pulse_ctx_flags |= PA_CONTEXT_NOAUTOSPAWN; if((loop=pa_threaded_mainloop_new()) && pa_threaded_mainloop_start(loop) >= 0) { pa_context *context; pa_threaded_mainloop_lock(loop); context = connect_context(loop, AL_TRUE); if(context) { *func_list = pulse_funcs; ret = ALC_TRUE; /* Some libraries (Phonon, Qt) set some pulseaudio properties * through environment variables, which causes all streams in * the process to inherit them. This attempts to filter those * properties out by setting them to 0-length data. */ prop_filter = pa_proplist_new(); pa_proplist_set(prop_filter, PA_PROP_MEDIA_ROLE, NULL, 0); pa_proplist_set(prop_filter, "phonon.streamid", NULL, 0); pa_context_disconnect(context); pa_context_unref(context); } pa_threaded_mainloop_unlock(loop); pa_threaded_mainloop_stop(loop); } if(loop) pa_threaded_mainloop_free(loop); } return ret; }
/** Destroy libao driver */ static void uninit(int immed) { if (stream) { if (!immed && pa_stream_get_state(stream) == PA_STREAM_READY) wait_for_operation(pa_stream_drain(stream, NULL, NULL)); pa_stream_unref(stream); stream = NULL; } if (context) { pa_context_unref(context); context = NULL; } if (mainloop) { pa_mainloop_free(mainloop); mainloop = NULL; } }
PulseHandler::~PulseHandler(void) { // TODO - do we need to drain the context?? LOG(VB_AUDIO, LOG_INFO, LOC + "Destroying PulseAudio handler"); // is this correct? if (m_ctx) { pa_context_disconnect(m_ctx); pa_context_unref(m_ctx); } if (m_loop) { pa_signal_done(); pa_mainloop_free(m_loop); } }
void pa_context_set_state(pa_context *c, pa_context_state_t st) { pa_assert(c); pa_assert(PA_REFCNT_VALUE(c) >= 1); if (c->state == st) return; pa_context_ref(c); c->state = st; if (c->state_callback) c->state_callback(c, c->state_userdata); if (st == PA_CONTEXT_FAILED || st == PA_CONTEXT_TERMINATED) context_unlink(c); pa_context_unref(c); }
void QPulseAudioEngine::release() { if (!m_prepared) return; if (m_context) { pa_context_disconnect(m_context); pa_context_unref(m_context); m_context = 0; } if (m_mainLoop) { pa_threaded_mainloop_stop(m_mainLoop); pa_threaded_mainloop_free(m_mainLoop); m_mainLoop = 0; } m_prepared = false; }
void Uninit() { int ret; if (mStream) { ret = pa_stream_disconnect(mStream); pa_stream_unref(mStream); //needed? mStream = nullptr; } if (mPContext) { pa_context_disconnect(mPContext); pa_context_unref(mPContext); mPContext = nullptr; } if (mPMainLoop) { pa_threaded_mainloop_stop(mPMainLoop); pa_threaded_mainloop_free(mPMainLoop); mPMainLoop = nullptr; } }
static void qpa_audio_fini (void *opaque) { paaudio *g = opaque; if (g->mainloop) { pa_threaded_mainloop_stop (g->mainloop); } if (g->context) { pa_context_disconnect (g->context); pa_context_unref (g->context); } if (g->mainloop) { pa_threaded_mainloop_free (g->mainloop); } g_free(g); }
void pa_simple_free(pa_simple *s) { pa_assert(s); if (s->mainloop) pa_threaded_mainloop_stop(s->mainloop); if (s->stream) pa_stream_unref(s->stream); if (s->context) { pa_context_disconnect(s->context); pa_context_unref(s->context); } if (s->mainloop) pa_threaded_mainloop_free(s->mainloop); pa_xfree(s); }
int main(int argc, char *argv[]) { pa_mainloop* m = NULL; int i, ret = 0; for (i = 0; i < SAMPLE_HZ; i++) data[i] = (float) sin(((double) i/SAMPLE_HZ)*2*M_PI*SINE_HZ)/2; for (i = 0; i < NSTREAMS; i++) streams[i] = NULL; /* Set up a new main loop */ m = pa_mainloop_new(); assert(m); mainloop_api = pa_mainloop_get_api(m); context = pa_context_new(mainloop_api, argv[0]); assert(context); pa_context_set_state_callback(context, context_state_callback, NULL); /* Connect the context */ if (pa_context_connect(context, NULL, 0, NULL) < 0) { fprintf(stderr, "pa_context_connect() failed.\n"); goto quit; } if (pa_mainloop_run(m, &ret) < 0) fprintf(stderr, "pa_mainloop_run() failed.\n"); quit: pa_context_unref(context); for (i = 0; i < NSTREAMS; i++) if (streams[i]) pa_stream_unref(streams[i]); pa_mainloop_free(m); return ret; }
static void destroy_pa(struct SoundIoPrivate *si) { struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio; if (sipa->main_loop) pa_threaded_mainloop_stop(sipa->main_loop); pa_context_disconnect(sipa->pulse_context); pa_context_unref(sipa->pulse_context); soundio_destroy_devices_info(sipa->current_devices_info); soundio_destroy_devices_info(sipa->ready_devices_info); if (sipa->main_loop) pa_threaded_mainloop_free(sipa->main_loop); if (sipa->props) pa_proplist_free(sipa->props); free(sipa->default_sink_name); free(sipa->default_source_name); }
void executeRequest( StateData* stateData ) { // Create mainloop pa_mainloop* mainLoop = pa_mainloop_new(); // Create mainloop API pa_mainloop_api* mainLoopApi = pa_mainloop_get_api( mainLoop ); // Create context pa_context* context = pa_context_new( mainLoopApi, "cinder-requests" ); // Set context state callback stateData->mainLoopApi = mainLoopApi; pa_context_set_state_callback( context, processContextState, static_cast<void*>( stateData ) ); // Connect context if( pa_context_connect( context, nullptr, PA_CONTEXT_NOFLAGS, nullptr ) >= 0 ) { // Run mainloop int result = 0; if( pa_mainloop_run( mainLoop, &result ) < 0 ) { // Handle error } } pa_context_unref( context ); pa_mainloop_free( mainLoop ); }
static void tsmf_pulse_free(ITSMFAudioDevice *audio) { TSMFPulseAudioDevice *pulse = (TSMFPulseAudioDevice *) audio; DEBUG_TSMF(""); 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); }
void pulse_unref() { pthread_mutex_lock(&pulse_mutex); if (--pulse_refs == 0) { pulse_lock(); if (pulse_context != NULL) { pa_context_disconnect(pulse_context); pa_context_unref(pulse_context); pulse_context = NULL; } pulse_unlock(); if (pulse_mainloop != NULL) { pa_threaded_mainloop_stop(pulse_mainloop); pa_threaded_mainloop_free(pulse_mainloop); pulse_mainloop = NULL; } } pthread_mutex_unlock(&pulse_mutex); }
static void pa_command_enable_srbchannel(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) { pa_context *c = userdata; #ifdef HAVE_CREDS const int *fds; int nfd; pa_assert(pd); pa_assert(command == PA_COMMAND_ENABLE_SRBCHANNEL); pa_assert(t); pa_assert(c); pa_assert(PA_REFCNT_VALUE(c) >= 1); /* Currently only one srb channel is supported, might change in future versions */ if (c->srb_template.readfd != -1) { pa_context_fail(c, PA_ERR_PROTOCOL); return; } fds = pa_pdispatch_fds(pd, &nfd); if (nfd != 2 || !fds || fds[0] == -1 || fds[1] == -1) { pa_context_fail(c, PA_ERR_PROTOCOL); return; } pa_context_ref(c); c->srb_template.readfd = fds[0]; c->srb_template.writefd = fds[1]; c->srb_setup_tag = tag; pa_context_unref(c); #else pa_assert(c); pa_context_fail(c, PA_ERR_PROTOCOL); #endif }
int context_create(){ if(context != NULL){ return 0; } connected = false; failed = false; threaded_main_loop = pa_threaded_mainloop_new(); pa_mainloop_api *main_loop_api = pa_threaded_mainloop_get_api(threaded_main_loop); context = pa_context_new(main_loop_api, "vumeter"); pa_context_set_state_callback(context, context_state_callback, NULL); if(pa_context_connect(context, NULL, (pa_context_flags_t) PA_CONTEXT_NOAUTOSPAWN, NULL)){ qDebug("Error connecting to server..."); pa_threaded_mainloop_stop(threaded_main_loop); pa_threaded_mainloop_free(threaded_main_loop); return -1; } pa_threaded_mainloop_start(threaded_main_loop); pa_threaded_mainloop_lock(threaded_main_loop); while ((! connected) && (! failed)) { qDebug("Waiting until connection is established..."); pa_threaded_mainloop_wait(threaded_main_loop); qDebug("Received signal..."); } pa_threaded_mainloop_unlock(threaded_main_loop); if(failed){ pa_context_unref(context); context = NULL; return -2; } return 0; }