void PulseAudioDriver::ctx_state_callback(pa_context* ctx, void* udata)
{
PulseAudioDriver* self = (PulseAudioDriver*)udata;
pa_context_state s = pa_context_get_state(ctx);
if (s == PA_CONTEXT_READY)
{
pa_sample_spec spec;
spec.format = PA_SAMPLE_S16LE;
spec.rate = self->m_sample_rate;
spec.channels = 2;
self->m_stream = pa_stream_new(ctx, "Hydrogen", &spec, 0);
pa_stream_set_state_callback(self->m_stream, stream_state_callback, self);
pa_stream_set_write_callback(self->m_stream, stream_write_callback, self);
pa_buffer_attr bufattr;
bufattr.fragsize = (uint32_t)-1;
bufattr.maxlength = self->m_buffer_size * 4;
bufattr.minreq = 0;
bufattr.prebuf = (uint32_t)-1;
bufattr.tlength = self->m_buffer_size * 4;
pa_stream_connect_playback(self->m_stream, 0, &bufattr, pa_stream_flags_t(0), 0, 0);
}
else if (s == PA_CONTEXT_FAILED)
pa_mainloop_quit(self->m_main_loop, 1);
}
void vis::PulseAudioSource::pulseaudio_context_state_callback(pa_context *c,
void *userdata)
{
switch (pa_context_get_state(c))
{
case PA_CONTEXT_UNCONNECTED:
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY:
{
pa_operation_unref(pa_context_get_server_info(
c, pulseaudio_server_info_callback, userdata));
break;
}
case PA_CONTEXT_FAILED:
case PA_CONTEXT_TERMINATED:
PulseAudioSource *vis_pa_src =
reinterpret_cast<PulseAudioSource *>(userdata);
pa_mainloop_quit(vis_pa_src->m_pulseaudio_mainloop, 0);
break;
}
}
APULSE_EXPORT
void
pa_threaded_mainloop_stop(pa_threaded_mainloop *m)
{
trace_info_f("F %s m=%p\n", __func__, m);
pa_mainloop_quit(m->m, 0);
pthread_join(m->t, NULL);
m->running = 0;
}
static void quit_mainloop(client_t *c, int exit_status)
{
if (c != NULL) {
if (c->pa != NULL)
pa_mainloop_quit(c->pa, exit_status);
else
g_main_loop_quit(c->gml);
}
else
exit(exit_status);
}
void PulseAudioDriver::pipe_callback(pa_mainloop_api*, pa_io_event*, int fd,
pa_io_event_flags_t events, void *udata)
{
if (!(events & PA_IO_EVENT_INPUT))
return;
char buf[16];
int bytes = read(fd, buf, 16);
if (bytes > 0)
{
PulseAudioDriver* self = (PulseAudioDriver*)udata;
pa_mainloop_quit(self->m_main_loop, 0);
}
}
void pa_threaded_mainloop_stop(pa_threaded_mainloop *m) {
pa_assert(m);
if (!m->thread || !pa_thread_is_running(m->thread))
return;
/* Make sure that this function is not called from the helper thread */
pa_assert(!in_worker(m));
pa_mutex_lock(m->mutex);
pa_mainloop_quit(m->real_mainloop, 0);
pa_mutex_unlock(m->mutex);
pa_thread_join(m->thread);
}
void PulseAudioDriver::stream_state_callback(pa_stream* stream, void* udata)
{
PulseAudioDriver* self = (PulseAudioDriver*)udata;
pa_stream_state s = pa_stream_get_state(stream);
if (s == PA_STREAM_FAILED)
pa_mainloop_quit(self->m_main_loop, 1);
else if (s == PA_STREAM_READY)
{
pthread_mutex_lock(&self->m_mutex);
self->m_ready = 1;
pthread_cond_signal(&self->m_cond);
pthread_mutex_unlock(&self->m_mutex);
}
}
void vis::PulseAudioSource::pulseaudio_server_info_callback(
pa_context *, const pa_server_info *i, void *userdata)
{
if (i != nullptr)
{
PulseAudioSource *vis_pa_src =
reinterpret_cast<PulseAudioSource *>(userdata);
std::string name = i->default_sink_name;
name.append(k_default_monitor_postfix);
vis_pa_src->m_pulseaudio_default_source_name = name;
// stop mainloop after finding default name
pa_mainloop_quit(vis_pa_src->m_pulseaudio_mainloop, 0);
}
}
int stop_recording(recorder_context_t *rctx, bool restart)
{
int retval = 0;
Log(LOG_INFO, "Stopping recorder.\n");
#ifdef DEBUG
fclose(threshold_file);
#endif
fclose(rctx->recording_file);
fclose(rctx->length_file);
pa_mainloop_quit(rctx->pa_ml, retval);
pa_stream_disconnect(rctx->recording_stream);
pa_stream_unref(rctx->recording_stream);
pa_context_disconnect(rctx->pa_ctx);
pa_context_unref(rctx->pa_ctx);
pa_mainloop_free(rctx->pa_ml);
if (!restart){
free(rctx);
}
Log(LOG_INFO, "DONE.\n");
return retval;
}
