bool PulseSubscription::run()
{
pa_context *context = getContext();
pa_operation *operation;
mainLoopLock();
// Must assume only one subscription will be alive. Can fix this if needed one day.
pa_context_set_subscribe_callback(context, _subscribe_callback, this);
m_triggered = 0;
operation = pa_context_subscribe(context,
(pa_subscription_mask_t)( PA_SUBSCRIPTION_MASK_SOURCE |
PA_SUBSCRIPTION_MASK_SINK |
PA_SUBSCRIPTION_MASK_MODULE),
NULL,
NULL);
while(pa_operation_get_state(operation) != PA_OPERATION_CANCELLED){
mainLoopWait();
if(m_triggered){
fireEvent();
m_triggered = 0;
}
}
pa_operation_unref(operation);
mainLoopUnlock();
return true;
}
static void context_state_cb(pa_context *context, void *user_data)
{
struct audio_service *service = user_data;
if (!service->context_initialized) {
switch (pa_context_get_state(service->context)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY:
g_message("Successfully established connection to pulseaudio context");
service->context_initialized = true;
break;
case PA_CONTEXT_TERMINATED:
g_warning("Connection of our context was terminated from pulseaudio");
break;
case PA_CONTEXT_FAILED:
g_warning("Failed to establish a connection to pulseaudio");
break;
default:
break;
}
if (service->context_initialized) {
pa_context_set_subscribe_callback(service->context, context_subscribe_cb, service);
pa_context_subscribe(service->context, PA_SUBSCRIPTION_MASK_CARD, NULL, service);
update_properties(service);
}
}
}
void _cb_state_changed(pa_context *context, void *userdata) {
callback_t *callback = (callback_t*)userdata;
pa_context_state_t state = pa_context_get_state(context);
PACMIXER_LOG("B:server state changed to %d", state);
switch(state) {
case PA_CONTEXT_READY:
pa_context_set_subscribe_callback(context, _cb_event, callback);
pa_context_subscribe(context, PA_SUBSCRIPTION_MASK_ALL, NULL, NULL);
pa_context_get_sink_input_info_list(context, _cb_sink_input, callback);
pa_context_get_sink_info_list(context, _cb_sink, callback);
pa_context_get_source_info_list(context, _cb_source, callback);
pa_context_get_source_output_info_list(context, _cb_source_output, callback);
pa_context_get_card_info_list(context, _cb_card, callback);
pa_context_get_server_info(context, _cb_server, callback);
((tstate_callback_func)(callback->state))(callback->self, S_CAME);
break;
case PA_CONTEXT_FAILED:
case PA_CONTEXT_TERMINATED:
pa_context_unref(context);
((tstate_callback_func)(callback->state))(callback->self, S_GONE);
break;
default:
break;
}
}
void QPulseAudioThread::initialize_callbacks ( QPulseAudioThread * pulseThread )
{
pa_operation * op;
pa_operation_unref
( pa_context_get_source_info_list ( context, pa_source_info_callback, pulseThread ) );
//pa_operation_unref(pa_context_get_server_info(&c, server_info_callback, this));
//pa_operation_unref(pa_context_get_sink_info_list(&c, sink_info_callback, this));
//pa_operation_unref(pa_context_get_source_info_list(&c, source_info_callback, this));
//pa_operation_unref(pa_context_get_module_info_list(&c, module_info_callback, this));
//pa_operation_unref(pa_context_get_client_info_list(&c, client_info_callback, this));
//pa_operation_unref(pa_context_get_sink_input_info_list(&c, sink_input_info_callback, this));
//pa_operation_unref(pa_context_get_source_output_info_list(&c, source_output_info_callback, this));
//pa_operation_unref(pa_context_get_sample_info_list(&c, sample_info_callback, this));
//pa_context_set_drain
pa_context_set_subscribe_callback ( context, subscribe_callback, pulseThread );
if ( op = pa_context_subscribe ( context, ( enum pa_subscription_mask )
PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, NULL, NULL ) ) {
pa_operation_unref ( op );
} else {
qDebug() << "null op returned on subscribe";
}
}
static void m_context_state_cb(pa_context *c, void *user_data)
{
if (!c) {
printf("m_context_state_cb() invalid arguement\n");
return;
}
pa_operation *pa_op = NULL;
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_context_set_subscribe_callback(c, m_pa_context_subscribe_cb, NULL);
pa_op = pa_context_subscribe(c, (pa_subscription_mask_t)
(PA_SUBSCRIPTION_MASK_SINK|
PA_SUBSCRIPTION_MASK_SOURCE|
PA_SUBSCRIPTION_MASK_SINK_INPUT|
PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT|
PA_SUBSCRIPTION_MASK_CLIENT|
PA_SUBSCRIPTION_MASK_SERVER|
PA_SUBSCRIPTION_MASK_CARD), NULL, NULL);
if (!pa_op) {
printf("pa_context_subscribe() failed\n");
return;
}
pa_operation_unref(pa_op);
pa_op = pa_context_get_sink_info_list(c, m_pa_sink_info_cb, NULL);
if (!pa_op) {
printf("pa_context_get_sink_info_list() failed\n");
return;
}
pa_operation_unref(pa_op);
break;
case PA_CONTEXT_FAILED:
if (m_pa_ctx) {
pa_context_unref(m_pa_ctx);
m_pa_ctx = NULL;
}
printf("Connection failed, attempting reconnect\n");
g_timeout_add_seconds(13, m_connect_to_pulse, NULL);
return;
case PA_CONTEXT_TERMINATED:
default:
printf("pa_context terminated\n");
return;
}
}
static int subscribe_to_events(struct SoundIoPrivate *si) {
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
pa_subscription_mask_t events = (pa_subscription_mask_t)(
PA_SUBSCRIPTION_MASK_SINK|PA_SUBSCRIPTION_MASK_SOURCE|PA_SUBSCRIPTION_MASK_SERVER);
pa_operation *subscribe_op = pa_context_subscribe(sipa->pulse_context, events, NULL, si);
if (!subscribe_op)
return SoundIoErrorNoMem;
pa_operation_unref(subscribe_op);
return 0;
}
void PulseAudioSystem::contextCallback(pa_context *c) {
Q_ASSERT(c == pacContext);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_READY:
bPulseIsGood = true;
pa_operation_unref(pa_context_subscribe(pacContext, PA_SUBSCRIPTION_MASK_SOURCE, NULL, this));
pa_operation_unref(pa_context_subscribe(pacContext, PA_SUBSCRIPTION_MASK_SINK, NULL, this));
query();
break;
case PA_CONTEXT_TERMINATED:
qWarning("PulseAudio: Forcibly disconnected from PulseAudio");
break;
case PA_CONTEXT_FAILED:
qWarning("PulseAudio: Connection failure: %s", pa_strerror(pa_context_errno(c)));
break;
default:
return;
}
qmWait.lock();
qwcWait.wakeAll();
qmWait.unlock();
}
void AudioSinksManager::context_state_callback(pa_context* c, void* userdata) {
AudioSinksManager* manager = static_cast<AudioSinksManager*>(userdata);
pa_context_state_t state = pa_context_get_state(c);
const char* state_name = "Wrong impossible state";
switch (state) {
case PA_CONTEXT_UNCONNECTED: state_name = "UNCONNECTED"; break;
case PA_CONTEXT_CONNECTING: state_name = "CONNECTING"; break;
case PA_CONTEXT_AUTHORIZING: state_name = "AUTHORIZING"; break;
case PA_CONTEXT_SETTING_NAME: state_name = "SETTING_NAME"; break;
case PA_CONTEXT_READY: state_name = "READY"; break;
case PA_CONTEXT_TERMINATED: state_name = "TERMINATED"; break;
case PA_CONTEXT_FAILED: state_name = "FAILED"; break;
}
manager->logger->debug("(AudioSinkManager) PA state change: {}", state_name);
switch (state) {
case PA_CONTEXT_READY:
manager->logger->info("(AudioSinkManager) Connected to PulseAudio server");
if (!manager->stopping) {
pa_operation_unref(pa_context_subscribe(
c, PA_SUBSCRIPTION_MASK_ALL, context_success_callback,
new ContextOperation(manager, "Subscripe to context events")));
for (auto& sink : manager->audio_sinks) {
sink->start_sink();
}
manager->update_server_info();
} else {
while (!manager->audio_sinks.empty()) {
auto sink = *manager->audio_sinks.begin();
sink->free();
}
manager->logger->trace("(AudioSinkManager) Disconnecting context");
pa_context_disconnect(manager->context);
}
break;
case PA_CONTEXT_TERMINATED:
pa_context_unref(manager->context);
manager->context = nullptr;
(manager->pa_mainloop.get_api()->quit)(manager->pa_mainloop.get_api(), 0);
break;
case PA_CONTEXT_FAILED:
manager->report_error("Connection to PulseAudio server failed: " +
manager->get_pa_error());
break;
default: break;
}
}
/**
* This is called whenever the context status changes
*/
static void
context_state_callback(pa_context *c, void *userdata)
{
pa_audio_mode_t *pam = (pa_audio_mode_t *)userdata;
pa_operation *o;
switch(pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
case PA_CONTEXT_UNCONNECTED:
case PA_CONTEXT_AUTHORIZING:
case PA_CONTEXT_SETTING_NAME:
break;
case PA_CONTEXT_READY:
pa_context_set_subscribe_callback(pam->context,
subscription_event_callback, pam);
o = pa_context_subscribe(pam->context,
PA_SUBSCRIPTION_MASK_SINK_INPUT,
NULL, NULL);
if(o != NULL)
pa_operation_unref(o);
TRACE(TRACE_DEBUG, "PA", "Context ready");
pa_threaded_mainloop_signal(mainloop, 0);
break;
case PA_CONTEXT_TERMINATED:
if(pam->stream != NULL) {
pa_stream_unref(pam->stream);
pam->stream = NULL;
}
TRACE(TRACE_ERROR, "PA", "Context terminated");
pa_threaded_mainloop_signal(mainloop, 0);
break;
case PA_CONTEXT_FAILED:
if(pam->stream != NULL) {
pa_stream_unref(pam->stream);
pam->stream = NULL;
}
TRACE(TRACE_ERROR, "PA",
"Connection failure: %s", pa_strerror(pa_context_errno(c)));
pa_threaded_mainloop_signal(mainloop, 0);
break;
}
}
void context_state_cb(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 *o;
if (!(o = pa_context_get_source_info_list(c,
source_cb,
NULL
))) {
show_error(_("pa_context_subscribe() failed"));
return;
}
pa_operation_unref(o);
if (!(o = pa_context_get_sink_info_list(c,
sink_cb,
NULL
))) {
show_error(_("pa_context_subscribe() failed"));
return;
}
pa_operation_unref(o);
pa_context_set_subscribe_callback(c, subscribe_cb, NULL);
if (!(o = pa_context_subscribe(c, (pa_subscription_mask_t)
(PA_SUBSCRIPTION_MASK_SINK|
PA_SUBSCRIPTION_MASK_SOURCE), NULL, NULL))) {
show_error(_("pa_context_subscribe() failed"));
return;
}
pa_operation_unref(o);
break;
}
case PA_CONTEXT_FAILED:
case PA_CONTEXT_TERMINATED:
default:
return;
}
}
static int Open (vlc_object_t *obj)
{
services_discovery_t *sd = (services_discovery_t *)obj;
pa_operation *op;
pa_context *ctx;
services_discovery_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
ctx = vlc_pa_connect (obj, &sys->mainloop);
if (ctx == NULL)
{
free (sys);
return VLC_EGENERIC;
}
sd->p_sys = sys;
sd->description = _("Audio capture");
sys->context = ctx;
sys->root = NULL;
/* Subscribe for source events */
const pa_subscription_mask_t mask = PA_SUBSCRIPTION_MASK_SOURCE;
pa_threaded_mainloop_lock (sys->mainloop);
pa_context_set_subscribe_callback (ctx, ContextCallback, sd);
op = pa_context_subscribe (ctx, mask, NULL, NULL);
if (likely(op != NULL))
pa_operation_unref (op);
/* Enumerate existing sources */
op = pa_context_get_source_info_list (ctx, SourceCallback, sd);
if (likely(op != NULL))
{
//while (pa_operation_get_state (op) == PA_OPERATION_RUNNING)
// pa_threaded_mainloop_wait (sys->mainloop);
pa_operation_unref (op);
}
pa_threaded_mainloop_unlock (sys->mainloop);
return VLC_SUCCESS;
/*
error:
pa_threaded_mainloop_unlock (sys->mainloop);
vlc_pa_disconnect (obj, ctx, sys->mainloop);
free (sys);
return VLC_EGENERIC;*/
}
JNIEXPORT void JNICALL
Java_com_harrcharr_pulse_PulseContext_JNISubscribe(
JNIEnv *jenv, jobject jcontext) {
pa_context *c = get_context_ptr(jenv, jcontext);
pa_threaded_mainloop *m = get_mainloop_ptr(jenv, jcontext);
LOGE("Subscribing, pulse state %d", pa_context_get_state(c));
LOGE("Subscribing, pulse state %d", pa_context_get_state(c));
LOGE("Subscribing, pulse state %d", pa_context_get_state(c));
pa_threaded_mainloop_lock(m);
pa_operation *o;
o = pa_context_subscribe(c, PA_SUBSCRIPTION_MASK_ALL, NULL, NULL);
assert(o);
pa_operation_unref(o);
pa_threaded_mainloop_unlock(m);
}
FXbool PulseOutput::open() {
/// Start the mainloop
//if (eventloop==nullptr) {
// eventloop = new PulseReactor();
// }
/// Get a context
if (pulse_context==nullptr) {
pulse_context = pa_context_new(&api,"Goggles Music Manager");
#ifdef DEBUG
pa_context_set_state_callback(pulse_context,context_state_callback,this);
#endif
pa_context_set_subscribe_callback(pulse_context,context_subscribe_callback,this);
}
/// Try connecting
GM_DEBUG_PRINT("[pulse] pa_context_connect()\n");
if (pa_context_get_state(pulse_context)==PA_CONTEXT_UNCONNECTED) {
if (pa_context_connect(pulse_context,nullptr,PA_CONTEXT_NOFLAGS,nullptr)<0) {
GM_DEBUG_PRINT("[pulse] pa_context_connect failed\n");
return false;
}
}
/// Wait until we're connected to the pulse daemon
GM_DEBUG_PRINT("[pulse] wait for connection\n");
pa_context_state_t state;
while((state=pa_context_get_state(pulse_context))!=PA_CONTEXT_READY) {
if (state==PA_CONTEXT_FAILED || state==PA_CONTEXT_TERMINATED){
GM_DEBUG_PRINT("[pulse] Unable to connect to pulsedaemon\n");
return false;
}
context->wait_plugin_events();
}
pa_operation* operation = pa_context_subscribe(pulse_context,PA_SUBSCRIPTION_MASK_SINK_INPUT,nullptr,this);
if (operation) pa_operation_unref(operation);
GM_DEBUG_PRINT("[pulse] ready()\n");
return true;
}
void PulseSrc::pa_context_state_callback(pa_context* pulse_context, void* user_data) {
PulseSrc* context = static_cast<PulseSrc*>(user_data);
switch (pa_context_get_state(pulse_context)) {
case PA_CONTEXT_CONNECTING:
// g_print ("PA_CONTEXT_CONNECTING\n");
break;
case PA_CONTEXT_AUTHORIZING:
// g_print ("PA_CONTEXT_AUTHORIZING\n");
break;
case PA_CONTEXT_SETTING_NAME:
// g_print ("PA_CONTEXT_SETTING_NAME\n");
break;
case PA_CONTEXT_READY:
// g_print ("PA_CONTEXT_READY\n");
context->make_device_description(pulse_context);
// pa_operation_unref(pa_context_get_source_info_list(pulse_context,
// get_source_info_callback,
// nullptr));
pa_context_set_subscribe_callback(pulse_context, on_pa_event_callback, nullptr);
pa_operation_unref(pa_context_subscribe(
pulse_context,
static_cast<pa_subscription_mask_t>(
PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE |
PA_SUBSCRIPTION_MASK_SINK_INPUT | PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT |
PA_SUBSCRIPTION_MASK_MODULE | PA_SUBSCRIPTION_MASK_CLIENT |
PA_SUBSCRIPTION_MASK_SAMPLE_CACHE | PA_SUBSCRIPTION_MASK_SERVER |
PA_SUBSCRIPTION_MASK_CARD),
nullptr, // pa_context_success_cb_t cb,
nullptr)); // void *userdata);
break;
case PA_CONTEXT_TERMINATED: {
g_debug("PulseSrc: PA_CONTEXT_TERMINATED");
} break;
case PA_CONTEXT_FAILED:
g_debug("PA_CONTEXT_FAILED");
break;
default:
g_debug("PulseSrc Context error: %s", pa_strerror(pa_context_errno(pulse_context)));
}
}
int main(int argc, char **argv)
{
int retval = 0;
struct timeval timeout, timeout_def;
pa_mainloop * ml = pa_mainloop_new();
pa_mainloop_api * api = pa_mainloop_get_api(ml);
pa_context_state_t pa_state;
pa_context * context = pa_context_new(api, "pa-mixer");
pa_context_connect(context, NULL, 0, NULL);
pa_context_set_state_callback(context, pa_state_changed, &pa_state);
/*
struct sigaction sigint_handler;
sigint_handler.sa_handler = handle_sig_int;
sigemptyset(&sigint_handler.sa_mask);
sigint_handler.sa_flags = 0;
sigaction(SIGINT, &sigint_handler, NULL);
*/
int init_done = 0;
initscr();
keypad(stdscr, TRUE);
start_color();
curs_set(0);
cbreak();
noecho();
init_pair(1, COLOR_WHITE, COLOR_BLACK);
init_pair(2, COLOR_WHITE, COLOR_BLUE);
fd_set read_set, test_set;
FD_ZERO(&read_set);
FD_SET(0, &read_set);
timeout_def.tv_sec = 0;
timeout_def.tv_usec = 1000;
view_init();
while(running) {
if(pa_state == PA_CONTEXT_UNCONNECTED) {
pa_mainloop_iterate(ml, 1, NULL);
continue;
}
if(pa_state == PA_CONTEXT_FAILED || pa_state == PA_CONTEXT_TERMINATED) {
running = 0;
retval = -1;
}
if(pa_state == PA_CONTEXT_READY) {
if(!init_done) {
pa_context_set_subscribe_callback(context, on_event, NULL);
pa_context_subscribe(context, PA_SUBSCRIPTION_MASK_ALL, NULL, NULL);
pa_context_get_sink_input_info_list(context, on_sink_input_update, context);
pa_context_get_sink_info_list(context, on_sink_update, context);
}
init_done = 1;
}
test_set = read_set;
timeout = timeout_def;
int r = select(1, &test_set, NULL, NULL, &timeout);
if(r == 0) {
/* timeout */
pa_mainloop_iterate(ml, 0, NULL);
}
if(FD_ISSET(0, &test_set)) {
/* stdin ready */
int key = getch();
switch(key) {
case KEY_UP:
view_select_prev();
view_show();
break;
case KEY_DOWN:
view_select_next();
view_show();
break;
case KEY_LEFT:
change_sel_vol(context, VOL_DOWN);
break;
case KEY_RIGHT:
change_sel_vol(context, VOL_UP);
break;
case 'n':
change_sel_vol(context, VOL_NORM);
break;
case 'm':
change_sel_vol(context, VOL_MUTE);
break;
case 'q':
running = 0;
break;
case KEY_RESIZE:
view_show();
refresh();
break;
}
}
}
pa_context_disconnect(context);
pa_context_unref(context);
pa_mainloop_free(ml);
endwin();
return retval;
}
static gboolean
gst_pulsesrc_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
{
pa_buffer_attr wanted;
const pa_buffer_attr *actual;
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (asrc);
pa_stream_flags_t flags;
pa_operation *o;
GstAudioClock *clock;
pa_threaded_mainloop_lock (pulsesrc->mainloop);
{
GstAudioRingBufferSpec s = *spec;
const pa_channel_map *m;
m = pa_stream_get_channel_map (pulsesrc->stream);
gst_pulse_channel_map_to_gst (m, &s);
gst_audio_ring_buffer_set_channel_positions (GST_AUDIO_BASE_SRC
(pulsesrc)->ringbuffer, s.info.position);
}
/* enable event notifications */
GST_LOG_OBJECT (pulsesrc, "subscribing to context events");
if (!(o = pa_context_subscribe (pulsesrc->context,
PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, NULL, NULL))) {
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("pa_context_subscribe() failed: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
pa_operation_unref (o);
wanted.maxlength = -1;
wanted.tlength = -1;
wanted.prebuf = 0;
wanted.minreq = -1;
wanted.fragsize = spec->segsize;
GST_INFO_OBJECT (pulsesrc, "maxlength: %d", wanted.maxlength);
GST_INFO_OBJECT (pulsesrc, "tlength: %d", wanted.tlength);
GST_INFO_OBJECT (pulsesrc, "prebuf: %d", wanted.prebuf);
GST_INFO_OBJECT (pulsesrc, "minreq: %d", wanted.minreq);
GST_INFO_OBJECT (pulsesrc, "fragsize: %d", wanted.fragsize);
flags = PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE |
PA_STREAM_NOT_MONOTONIC | PA_STREAM_ADJUST_LATENCY |
PA_STREAM_START_CORKED;
if (pulsesrc->mute_set && pulsesrc->mute)
flags |= PA_STREAM_START_MUTED;
if (pa_stream_connect_record (pulsesrc->stream, pulsesrc->device, &wanted,
flags) < 0) {
goto connect_failed;
}
/* our clock will now start from 0 again */
clock = GST_AUDIO_CLOCK (GST_AUDIO_BASE_SRC (pulsesrc)->clock);
gst_audio_clock_reset (clock, 0);
pulsesrc->corked = TRUE;
for (;;) {
pa_stream_state_t state;
state = pa_stream_get_state (pulsesrc->stream);
if (!PA_STREAM_IS_GOOD (state))
goto stream_is_bad;
if (state == PA_STREAM_READY)
break;
/* Wait until the stream is ready */
pa_threaded_mainloop_wait (pulsesrc->mainloop);
}
pulsesrc->stream_connected = TRUE;
/* store the source output index so it can be accessed via a property */
pulsesrc->source_output_idx = pa_stream_get_index (pulsesrc->stream);
g_object_notify (G_OBJECT (pulsesrc), "source-output-index");
if (pulsesrc->volume_set) {
gst_pulsesrc_set_stream_volume (pulsesrc, pulsesrc->volume);
pulsesrc->volume_set = FALSE;
}
/* get the actual buffering properties now */
actual = pa_stream_get_buffer_attr (pulsesrc->stream);
GST_INFO_OBJECT (pulsesrc, "maxlength: %d", actual->maxlength);
GST_INFO_OBJECT (pulsesrc, "tlength: %d (wanted: %d)",
actual->tlength, wanted.tlength);
GST_INFO_OBJECT (pulsesrc, "prebuf: %d", actual->prebuf);
GST_INFO_OBJECT (pulsesrc, "minreq: %d (wanted %d)", actual->minreq,
wanted.minreq);
GST_INFO_OBJECT (pulsesrc, "fragsize: %d (wanted %d)",
actual->fragsize, wanted.fragsize);
if (actual->fragsize >= wanted.fragsize) {
spec->segsize = actual->fragsize;
} else {
spec->segsize = actual->fragsize * (wanted.fragsize / actual->fragsize);
}
spec->segtotal = actual->maxlength / spec->segsize;
if (!pulsesrc->paused) {
GST_DEBUG_OBJECT (pulsesrc, "uncorking because we are playing");
gst_pulsesrc_set_corked (pulsesrc, FALSE, FALSE);
}
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return TRUE;
/* ERRORS */
connect_failed:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to connect stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
stream_is_bad:
{
GST_ELEMENT_ERROR (pulsesrc, RESOURCE, FAILED,
("Failed to connect stream: %s",
pa_strerror (pa_context_errno (pulsesrc->context))), (NULL));
goto unlock_and_fail;
}
unlock_and_fail:
{
gst_pulsesrc_destroy_stream (pulsesrc);
pa_threaded_mainloop_unlock (pulsesrc->mainloop);
return FALSE;
}
}
int force_volume(char* source_name, pa_volume_t desired_volume) {
// Create a mainloop
pa_mainloop* pa_ml = pa_mainloop_new();
pa_mainloop_api* pa_mlapi = pa_mainloop_get_api(pa_ml);
// Establish PA context
pa_context* pa_ctx = pa_context_new(pa_mlapi, "uneven");
pa_context_connect(pa_ctx, NULL, 0, NULL);
// Set up PA state callback
int pa_state = 0;
pa_context_set_state_callback(pa_ctx, pa_state_cb, &pa_state);
// Set up event subscription
int state = 0;
pa_context_set_subscribe_callback(pa_ctx, source_state_cb, &state);
// Prepare loop variables
pa_operation* pending_op = NULL;
pa_cvolume current_volume = {0, {0}};
int do_update;
int i;
// Iterate PA mainloop until we're done or the context enters an error state
while (done == -1 && pa_state != 2) {
pa_mainloop_iterate(pa_ml, 1, NULL);
// Can't do anything unless PA is ready
if (pa_state == 1) {
// Wait for any pending operation to complete
if (!pending_op || (pending_op && pa_operation_get_state(pending_op) == PA_OPERATION_DONE)) {
if (pending_op) {
pa_operation_unref(pending_op);
pending_op = NULL;
}
switch (state) {
case 0:
// Subscribe to source events
pending_op = pa_context_subscribe(pa_ctx, PA_SUBSCRIPTION_MASK_SOURCE, NULL, NULL);
state = 2;
break;
case 1:
// Idle
break;
case 2:
// Source change detected, retrive volume information
pending_op = pa_context_get_source_info_by_name(pa_ctx, source_name, get_volume_cb, ¤t_volume);
state++;
break;
case 3:
// Check channel volumes and reset if required
do_update = 0;
for (i = 0; i < current_volume.channels; i++) {
if (current_volume.values[i] != desired_volume) {
do_update = 1;
current_volume.values[i] = desired_volume;
}
}
if (do_update) {
pending_op = pa_context_set_source_volume_by_name(pa_ctx, source_name, ¤t_volume, NULL, NULL);
}
state = 1;
break;
default:
fprintf(stderr, "in state %d\n", state);
done = 2;
}
}
}
}
// Clean up
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
pa_mainloop_free(pa_ml);
return done;
}
int main(int argc, char *const *argv) {
static const char *context_name = "i3blocks-pulse-volume";
static const char *usage_str = "Usage: %s [-h] [-d] [-s INDEX] [-m FUNC]\n"
"Options:\n"
" -s INDEX: pulseaudio sink index on which to wait for "
"changes (default: 0)\n"
" -m FUNC : function used to compute the displayed volume value\n"
" in there are multiple channels (eg. left/right):\n"
" * avg: use average volume of all channels (default)\n"
" * min: use minimum volume of all channels\n"
" * max: use maximum volume of all channels\n"
" -d : use decibel notation instead of 0-100 percentage; "
"the sink may\n"
" not support this feature\n";
options_t options;
options.calculator = pa_cvolume_avg;
options.use_decibel = 0;
options.observed_index = 0;
sink_info_data_t sink_info_data;
sink_info_data.sink_ready = 0;
sink_info_data.sink_changed = 0;
pa_mainloop *pa_ml = NULL;
pa_mainloop_api *pa_ml_api = NULL;
pa_operation *pa_op = NULL;
pa_context *pa_ctx = NULL;
enum state_t state = FIRST_SINK_INFO;
int pa_ready = CONN_WAIT;
int opt;
while ((opt = getopt(argc, argv, "m:s:dh")) != -1) {
if (opt == 'm') {
if (strcmp(optarg, "min") == 0) {
options.calculator = pa_cvolume_min;
} else if (strcmp(optarg, "max") == 0) {
options.calculator = pa_cvolume_max;
} else if (strcmp(optarg, "avg") == 0) {
options.calculator = pa_cvolume_avg;
} else {
fprintf(stderr, usage_str, argv[0]);
return 1;
}
} else if (opt == 's') {
// Parse observed sink index
errno = 0;
char *endptr;
uint32_t *oind = &options.observed_index;
*oind = strtoul(optarg, &endptr, 10);
if ((errno == ERANGE) || (errno != 0 && *oind == 0) ||
endptr == optarg) {
fprintf(stderr, "%s: invalid sink index: %s\n", argv[0],
optarg);
fprintf(stderr, usage_str, argv[0]);
return 1;
}
} else if (opt == 'd') {
options.use_decibel = 1;
} else if (opt == 'h') {
fprintf(stderr, usage_str, argv[0]);
return 0;
} else {
fprintf(stderr, usage_str, argv[0]);
return 1;
}
}
// Needed to filter out sink in callbacks
sink_info_data.observed_index = options.observed_index;
if ((pa_ml = pa_mainloop_new()) == NULL) {
fprintf(stderr, "error: failed to allocate pulseaudio mainloop.\n");
return 2;
}
if ((pa_ml_api = pa_mainloop_get_api(pa_ml)) == NULL) {
fprintf(stderr, "error: failed to allocate pulseaudio mainloop API.\n");
return 3;
}
if ((pa_ctx = pa_context_new(pa_ml_api, context_name)) == NULL) {
fprintf(stderr, "error: failed to allocate pulseaudio context.\n");
return 4;
}
if (pa_context_connect(pa_ctx, NULL, PA_CONTEXT_NOFAIL, NULL) < 0) {
fprintf(stderr, "error: failed to connect to pulseaudio context: %s\n",
pa_strerror(pa_context_errno(pa_ctx)));
return 5;
}
pa_context_set_state_callback(pa_ctx, state_cb, &pa_ready);
pa_context_set_subscribe_callback(pa_ctx, subscribe_cb, &sink_info_data);
while (1) {
if (pa_ready == CONN_WAIT) {
pa_mainloop_iterate(pa_ml, 1, NULL);
continue;
}
if (pa_ready == CONN_FAILED) {
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
pa_mainloop_free(pa_ml);
fprintf(stderr,
"error: failed to connect to pulseaudio context.\n");
return 6;
}
// Main loop automaton
switch (state) {
case FIRST_SINK_INFO:
// First run
pa_op = pa_context_get_sink_info_by_index(pa_ctx,
options.observed_index,
sink_info_cb, &sink_info_data);
state = SUBSCRIBE;
break;
case SUBSCRIBE:
if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) {
pa_operation_unref(pa_op);
if (!sink_info_data.sink_ready) {
fprintf(stderr, "error: sink %u does not exist.\n",
options.observed_index);
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
pa_mainloop_free(pa_ml);
return 7;
}
if (options.use_decibel &&
!sink_info_data.sink.can_decibel) {
fprintf(stderr,
"error: sink %u does not support decibel; "
"try without `-d`.\n",
options.observed_index);
pa_context_disconnect(pa_ctx);
pa_context_unref(pa_ctx);
pa_mainloop_free(pa_ml);
return 8;
}
// Show volume once at start
show_volume(&sink_info_data.sink, &options);
// Subsequent runs: wait for changes
pa_op = pa_context_subscribe(pa_ctx,
PA_SUBSCRIPTION_MASK_SINK,
NULL, &sink_info_data);
state = SUBSCRIBED;
}
break;
case SUBSCRIBED:
if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) {
pa_operation_unref(pa_op);
state = WAIT_FOR_CHANGE;
}
break;
case WAIT_FOR_CHANGE:
if (sink_info_data.sink_changed) {
sink_info_data.sink_changed = 0;
pa_op = pa_context_get_sink_info_by_index(pa_ctx,
options.observed_index, sink_info_cb,
&sink_info_data);
state = SHOW_CHANGE;
}
break;
case SHOW_CHANGE:
if (pa_operation_get_state(pa_op) == PA_OPERATION_DONE) {
pa_operation_unref(pa_op);
show_volume(&sink_info_data.sink, &options);
state = WAIT_FOR_CHANGE;
}
break;
default:
return 7;
}
pa_mainloop_iterate(pa_ml, 1, NULL);
}
}
PulseAudioWrapper::PulseAudioWrapper(QObject *parent)
: QObject(parent),
d(new PulseAudioWrapperPrivate(this))
{
PulseAudioWrapperPrivate::paMainLoop = pa_threaded_mainloop_new();
pa_threaded_mainloop_start(PulseAudioWrapperPrivate::paMainLoop);
PulseAudioWrapperPrivate::paMainLoopApi = pa_threaded_mainloop_get_api(PulseAudioWrapperPrivate::paMainLoop);
pa_threaded_mainloop_lock(PulseAudioWrapperPrivate::paMainLoop);
PulseAudioWrapperPrivate::paContext = pa_context_new(PulseAudioWrapperPrivate::paMainLoopApi,
qApp->applicationName().toUtf8().data());
pa_context_set_state_callback(PulseAudioWrapperPrivate::paContext, &PulseAudioWrapperPrivate::onContextNotify, NULL);
pa_context_connect(PulseAudioWrapperPrivate::paContext, NULL, PA_CONTEXT_NOFLAGS, NULL);
bool done = false;
pa_context_state_t contextState;
while (!done)
{
switch (contextState = pa_context_get_state(d->paContext))
{
case PA_CONTEXT_UNCONNECTED: qDebug() << "Context state: PA_CONTEXT_UNCONNECTED"; break;
case PA_CONTEXT_CONNECTING: qDebug() << "Context state: PA_CONTEXT_CONNECTING"; break;
case PA_CONTEXT_AUTHORIZING: qDebug() << "Context state: PA_CONTEXT_AUTHORIZING"; break;
case PA_CONTEXT_SETTING_NAME: qDebug() << "Context state: PA_CONTEXT_SETTING_NAME"; break;
case PA_CONTEXT_READY: qDebug() << "Context state: PA_CONTEXT_READY"; done = true; break;
case PA_CONTEXT_FAILED: qDebug() << "Context state: PA_CONTEXT_FAILED"; done = true; break;
case PA_CONTEXT_TERMINATED: qDebug() << "Context state: PA_CONTEXT_TERMINATED"; done = true; break;
}
if (!done)
pa_threaded_mainloop_wait(PulseAudioWrapperPrivate::paMainLoop);
}
if (contextState != PA_CONTEXT_READY)
throw CallRecorderException("Unable to connect PulseAudio context!");
pa_operation* listCardsOp = pa_context_get_card_info_list(PulseAudioWrapperPrivate::paContext,
&PulseAudioWrapperPrivate::onCardInfoList,
d.data());
pa_threaded_mainloop_wait(PulseAudioWrapperPrivate::paMainLoop);
pa_operation_unref(listCardsOp);
pa_operation* listSinksOp = pa_context_get_sink_info_list(PulseAudioWrapperPrivate::paContext,
&PulseAudioWrapperPrivate::onSinkInfoList,
d.data());
pa_threaded_mainloop_wait(PulseAudioWrapperPrivate::paMainLoop);
pa_operation_unref(listSinksOp);
pa_operation* listSourcesOp = pa_context_get_source_info_list(PulseAudioWrapperPrivate::paContext,
&PulseAudioWrapperPrivate::onSourceInfoList,
d.data());
pa_threaded_mainloop_wait(PulseAudioWrapperPrivate::paMainLoop);
pa_operation_unref(listSourcesOp);
pa_context_set_subscribe_callback(PulseAudioWrapperPrivate::paContext,
&PulseAudioWrapperPrivate::onContextSubscription,
d.data());
pa_operation* subscriptionOp = pa_context_subscribe(PulseAudioWrapperPrivate::paContext,
static_cast< pa_subscription_mask_t >(
PA_SUBSCRIPTION_MASK_CARD |
PA_SUBSCRIPTION_MASK_SINK |
PA_SUBSCRIPTION_MASK_SOURCE),
&PulseAudioWrapperPrivate::onContextSubscriptionSuccess,
d.data());
pa_threaded_mainloop_wait(PulseAudioWrapperPrivate::paMainLoop);
pa_operation_unref(subscriptionOp);
pa_threaded_mainloop_unlock(PulseAudioWrapperPrivate::paMainLoop);
}
static gboolean
gst_pulsemixer_ctrl_open (GstPulseMixerCtrl * c)
{
int e;
gchar *name = gst_pulse_client_name ();
pa_operation *o = NULL;
g_assert (c);
c->mainloop = pa_threaded_mainloop_new ();
g_assert (c->mainloop);
e = pa_threaded_mainloop_start (c->mainloop);
g_assert (e == 0);
pa_threaded_mainloop_lock (c->mainloop);
if (!(c->context =
pa_context_new (pa_threaded_mainloop_get_api (c->mainloop), name))) {
GST_WARNING_OBJECT (c->object, "Failed to create context");
goto unlock_and_fail;
}
pa_context_set_state_callback (c->context,
gst_pulsemixer_ctrl_context_state_cb, c);
pa_context_set_subscribe_callback (c->context,
gst_pulsemixer_ctrl_subscribe_cb, c);
if (pa_context_connect (c->context, c->server, 0, NULL) < 0) {
GST_WARNING_OBJECT (c->object, "Failed to connect context: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
/* Wait until the context is ready */
pa_threaded_mainloop_wait (c->mainloop);
if (pa_context_get_state (c->context) != PA_CONTEXT_READY) {
GST_WARNING_OBJECT (c->object, "Failed to connect context: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
/* Subscribe to events */
if (!(o =
pa_context_subscribe (c->context,
PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE,
gst_pulsemixer_ctrl_success_cb, c))) {
GST_WARNING_OBJECT (c->object, "Failed to subscribe to events: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
c->operation_success = 0;
while (pa_operation_get_state (o) != PA_OPERATION_DONE) {
pa_threaded_mainloop_wait (c->mainloop);
CHECK_DEAD_GOTO (c, unlock_and_fail);
}
if (!c->operation_success) {
GST_WARNING_OBJECT (c->object, "Failed to subscribe to events: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
pa_operation_unref (o);
o = NULL;
/* Get sink info */
if (c->type == GST_PULSEMIXER_UNKNOWN || c->type == GST_PULSEMIXER_SINK) {
if (!(o =
pa_context_get_sink_info_by_name (c->context, c->device,
gst_pulsemixer_ctrl_sink_info_cb, c))) {
GST_WARNING_OBJECT (c->object, "Failed to get sink info: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
c->operation_success = 0;
while (pa_operation_get_state (o) != PA_OPERATION_DONE) {
pa_threaded_mainloop_wait (c->mainloop);
CHECK_DEAD_GOTO (c, unlock_and_fail);
}
pa_operation_unref (o);
o = NULL;
if (!c->operation_success && (c->type == GST_PULSEMIXER_SINK
|| pa_context_errno (c->context) != PA_ERR_NOENTITY)) {
GST_WARNING_OBJECT (c->object, "Failed to get sink info: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
}
if (c->type == GST_PULSEMIXER_UNKNOWN || c->type == GST_PULSEMIXER_SOURCE) {
if (!(o =
pa_context_get_source_info_by_name (c->context, c->device,
gst_pulsemixer_ctrl_source_info_cb, c))) {
GST_WARNING_OBJECT (c->object, "Failed to get source info: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
c->operation_success = 0;
while (pa_operation_get_state (o) != PA_OPERATION_DONE) {
pa_threaded_mainloop_wait (c->mainloop);
CHECK_DEAD_GOTO (c, unlock_and_fail);
}
pa_operation_unref (o);
o = NULL;
if (!c->operation_success) {
GST_WARNING_OBJECT (c->object, "Failed to get source info: %s",
pa_strerror (pa_context_errno (c->context)));
goto unlock_and_fail;
}
}
g_assert (c->type != GST_PULSEMIXER_UNKNOWN);
c->track = gst_pulsemixer_track_new (c);
c->tracklist = g_list_append (c->tracklist, c->track);
pa_threaded_mainloop_unlock (c->mainloop);
g_free (name);
return TRUE;
unlock_and_fail:
if (o)
pa_operation_unref (o);
if (c->mainloop)
pa_threaded_mainloop_unlock (c->mainloop);
g_free (name);
return FALSE;
}
AudioDevPulseAudio::AudioDevPulseAudio(QObject *parent):
AudioDev(parent)
{
this->d = new AudioDevPulseAudioPrivate(this);
// Create a threaded main loop for PulseAudio
this->d->m_mainLoop = pa_threaded_mainloop_new();
if (!this->d->m_mainLoop)
return;
// Start main loop.
if (pa_threaded_mainloop_start(this->d->m_mainLoop) != 0) {
pa_threaded_mainloop_free(this->d->m_mainLoop);
this->d->m_mainLoop = nullptr;
return;
}
pa_threaded_mainloop_lock(this->d->m_mainLoop);
// Get main loop abstration layer.
auto mainLoopApi = pa_threaded_mainloop_get_api(this->d->m_mainLoop);
if (!mainLoopApi) {
pa_threaded_mainloop_unlock(this->d->m_mainLoop);
pa_threaded_mainloop_stop(this->d->m_mainLoop);
pa_threaded_mainloop_free(this->d->m_mainLoop);
this->d->m_mainLoop = nullptr;
return;
}
// Get a PulseAudio context.
this->d->m_context = pa_context_new(mainLoopApi,
QCoreApplication::applicationName()
.toStdString()
.c_str());
if (!this->d->m_context) {
pa_threaded_mainloop_unlock(this->d->m_mainLoop);
pa_threaded_mainloop_stop(this->d->m_mainLoop);
pa_threaded_mainloop_free(this->d->m_mainLoop);
this->d->m_mainLoop = nullptr;
return;
}
// We need to set a state callback in order to connect to the server.
pa_context_set_state_callback(this->d->m_context,
AudioDevPulseAudioPrivate::contextStateCallbackInit,
this);
// Connect to PulseAudio server.
if (pa_context_connect(this->d->m_context,
nullptr,
PA_CONTEXT_NOFLAGS,
nullptr) < 0) {
pa_context_unref(this->d->m_context);
this->d->m_context = nullptr;
pa_threaded_mainloop_unlock(this->d->m_mainLoop);
pa_threaded_mainloop_stop(this->d->m_mainLoop);
pa_threaded_mainloop_free(this->d->m_mainLoop);
this->d->m_mainLoop = nullptr;
return;
}
static const QList<pa_context_state_t> expectedStates = {
PA_CONTEXT_READY,
PA_CONTEXT_FAILED,
PA_CONTEXT_TERMINATED
};
pa_context_state_t state;
// Wait until the connection to the server is stablished.
forever {
state = pa_context_get_state(this->d->m_context);
if (expectedStates.contains(state))
break;
pa_threaded_mainloop_wait(this->d->m_mainLoop);
}
if (state != PA_CONTEXT_READY) {
pa_context_disconnect(this->d->m_context);
pa_context_unref(this->d->m_context);
this->d->m_context = nullptr;
pa_threaded_mainloop_unlock(this->d->m_mainLoop);
pa_threaded_mainloop_stop(this->d->m_mainLoop);
pa_threaded_mainloop_free(this->d->m_mainLoop);
this->d->m_mainLoop = nullptr;
return;
}
// Get server information.
auto operation =
pa_context_get_server_info(this->d->m_context,
AudioDevPulseAudioPrivate::serverInfoCallback,
this);
while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(this->d->m_mainLoop);
pa_operation_unref(operation);
// Get sources information.
operation = pa_context_get_source_info_list(this->d->m_context,
AudioDevPulseAudioPrivate::sourceInfoCallback,
this);
while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(this->d->m_mainLoop);
pa_operation_unref(operation);
// Get sinks information.
operation = pa_context_get_sink_info_list(this->d->m_context,
AudioDevPulseAudioPrivate::sinkInfoCallback,
this);
while (pa_operation_get_state(operation) == PA_OPERATION_RUNNING)
pa_threaded_mainloop_wait(this->d->m_mainLoop);
pa_operation_unref(operation);
pa_context_set_subscribe_callback(this->d->m_context,
AudioDevPulseAudioPrivate::deviceUpdateCallback,
this);
pa_operation_unref(pa_context_subscribe(this->d->m_context,
pa_subscription_mask_t(PA_SUBSCRIPTION_MASK_SINK
| PA_SUBSCRIPTION_MASK_SOURCE
| PA_SUBSCRIPTION_MASK_SERVER),
nullptr,
this));
pa_threaded_mainloop_unlock(this->d->m_mainLoop);
}
static int pulse_open(int fmt, int rate, int nch) {
pa_sample_spec ss;
pa_operation *o = NULL;
int success;
assert(!mainloop);
assert(!context);
assert(!stream);
assert(!connected);
switch(fmt)
{
case FMT_U8:
ss.format = PA_SAMPLE_U8;
break;
case FMT_S16_LE:
ss.format = PA_SAMPLE_S16LE;
break;
case FMT_S16_BE:
ss.format = PA_SAMPLE_S16BE;
break;
#ifdef PA_SAMPLE_S24_32LE
case FMT_S24_LE:
ss.format = PA_SAMPLE_S24_32LE;
break;
case FMT_S24_BE:
ss.format = PA_SAMPLE_S24_32BE;
break;
#endif
#ifdef PA_SAMPLE_S32LE
case FMT_S32_LE:
ss.format = PA_SAMPLE_S32LE;
break;
case FMT_S32_BE:
ss.format = PA_SAMPLE_S32BE;
break;
#endif
case FMT_FLOAT:
ss.format = PA_SAMPLE_FLOAT32NE;
break;
default:
return FALSE;
}
ss.rate = rate;
ss.channels = nch;
if (!pa_sample_spec_valid(&ss))
return FALSE;
if (!(mainloop = pa_threaded_mainloop_new())) {
ERROR ("Failed to allocate main loop");
goto fail;
}
pa_threaded_mainloop_lock(mainloop);
if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), "Audacious"))) {
ERROR ("Failed to allocate context");
goto unlock_and_fail;
}
pa_context_set_state_callback(context, context_state_cb, NULL);
pa_context_set_subscribe_callback(context, subscribe_cb, NULL);
if (pa_context_connect(context, NULL, 0, NULL) < 0) {
ERROR ("Failed to connect to server: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
if (pa_threaded_mainloop_start(mainloop) < 0) {
ERROR ("Failed to start main loop");
goto unlock_and_fail;
}
/* Wait until the context is ready */
pa_threaded_mainloop_wait(mainloop);
if (pa_context_get_state(context) != PA_CONTEXT_READY) {
ERROR ("Failed to connect to server: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
if (!(stream = pa_stream_new(context, "Audacious", &ss, NULL))) {
ERROR ("Failed to create stream: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
pa_stream_set_state_callback(stream, stream_state_cb, NULL);
pa_stream_set_write_callback(stream, stream_request_cb, NULL);
pa_stream_set_latency_update_callback(stream, stream_latency_update_cb, NULL);
/* Connect stream with sink and default volume */
/* Buffer struct */
int aud_buffer = aud_get_int(NULL, "output_buffer_size");
size_t buffer_size = pa_usec_to_bytes(aud_buffer, &ss) * 1000;
pa_buffer_attr buffer = {(uint32_t) -1, buffer_size, (uint32_t) -1, (uint32_t) -1, buffer_size};
if (pa_stream_connect_playback(stream, NULL, &buffer, PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL) < 0) {
ERROR ("Failed to connect stream: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
/* Wait until the stream is ready */
pa_threaded_mainloop_wait(mainloop);
if (pa_stream_get_state(stream) != PA_STREAM_READY) {
ERROR ("Failed to connect stream: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
/* Now subscribe to events */
if (!(o = pa_context_subscribe(context, PA_SUBSCRIPTION_MASK_SINK_INPUT, context_success_cb, &success))) {
ERROR ("pa_context_subscribe() failed: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
success = 0;
while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
CHECK_DEAD_GOTO(fail, 1);
pa_threaded_mainloop_wait(mainloop);
}
if (!success) {
ERROR ("pa_context_subscribe() failed: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
pa_operation_unref(o);
/* Now request the initial stream info */
if (!(o = pa_context_get_sink_input_info(context, pa_stream_get_index(stream), info_cb, NULL))) {
ERROR ("pa_context_get_sink_input_info() failed: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
CHECK_DEAD_GOTO(fail, 1);
pa_threaded_mainloop_wait(mainloop);
}
if (!volume_valid) {
ERROR ("pa_context_get_sink_input_info() failed: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
pa_operation_unref(o);
do_trigger = 0;
written = 0;
flush_time = 0;
bytes_per_second = FMT_SIZEOF (fmt) * nch * rate;
connected = 1;
volume_time_event = NULL;
pa_threaded_mainloop_unlock(mainloop);
return TRUE;
unlock_and_fail:
if (o)
pa_operation_unref(o);
pa_threaded_mainloop_unlock(mainloop);
fail:
pulse_close();
return FALSE;
}
static int pulse_open()
{
ENTER(__FUNCTION__);
pa_sample_spec ss;
pa_operation *o = NULL;
int success;
int ret = PULSE_ERROR;
assert(!mainloop);
assert(!context);
assert(!stream);
assert(!connected);
pthread_mutex_init( &pulse_mutex, (const pthread_mutexattr_t *)NULL);
ss.format = ESPEAK_FORMAT;
ss.rate = wave_samplerate;
ss.channels = ESPEAK_CHANNEL;
if (!pa_sample_spec_valid(&ss))
return false;
SHOW_TIME("pa_threaded_mainloop_new (call)");
if (!(mainloop = pa_threaded_mainloop_new())) {
SHOW("Failed to allocate main loop\n","");
goto fail;
}
pa_threaded_mainloop_lock(mainloop);
SHOW_TIME("pa_context_new (call)");
if (!(context = pa_context_new(pa_threaded_mainloop_get_api(mainloop), "eSpeak"))) {
SHOW("Failed to allocate context\n","");
goto unlock_and_fail;
}
pa_context_set_state_callback(context, context_state_cb, NULL);
pa_context_set_subscribe_callback(context, subscribe_cb, NULL);
SHOW_TIME("pa_context_connect (call)");
if (pa_context_connect(context, NULL, (pa_context_flags_t)0, NULL) < 0) {
SHOW("Failed to connect to server: %s", pa_strerror(pa_context_errno(context)));
ret = PULSE_NO_CONNECTION;
goto unlock_and_fail;
}
SHOW_TIME("pa_threaded_mainloop_start (call)");
if (pa_threaded_mainloop_start(mainloop) < 0) {
SHOW("Failed to start main loop","");
goto unlock_and_fail;
}
/* Wait until the context is ready */
SHOW_TIME("pa_threaded_mainloop_wait");
pa_threaded_mainloop_wait(mainloop);
if (pa_context_get_state(context) != PA_CONTEXT_READY) {
SHOW("Failed to connect to server: %s", pa_strerror(pa_context_errno(context)));
ret = PULSE_NO_CONNECTION;
if (mainloop)
pa_threaded_mainloop_stop(mainloop);
goto unlock_and_fail;
}
SHOW_TIME("pa_stream_new");
if (!(stream = pa_stream_new(context, "unknown", &ss, NULL))) {
SHOW("Failed to create stream: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
pa_stream_set_state_callback(stream, stream_state_cb, NULL);
pa_stream_set_write_callback(stream, stream_request_cb, NULL);
pa_stream_set_latency_update_callback(stream, stream_latency_update_cb, NULL);
pa_buffer_attr a_attr;
a_attr.maxlength = MAXLENGTH;
a_attr.tlength = TLENGTH;
a_attr.prebuf = PREBUF;
a_attr.minreq = MINREQ;
a_attr.fragsize = 0;
SHOW_TIME("pa_connect_playback");
if (pa_stream_connect_playback(stream, NULL, &a_attr, (pa_stream_flags_t)(PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_AUTO_TIMING_UPDATE), NULL, NULL) < 0) {
SHOW("Failed to connect stream: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
/* Wait until the stream is ready */
SHOW_TIME("pa_threaded_mainloop_wait");
pa_threaded_mainloop_wait(mainloop);
if (pa_stream_get_state(stream) != PA_STREAM_READY) {
SHOW("Failed to connect stream: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
/* Now subscribe to events */
SHOW_TIME("pa_context_subscribe");
if (!(o = pa_context_subscribe(context, PA_SUBSCRIPTION_MASK_SINK_INPUT, context_success_cb, &success))) {
SHOW("pa_context_subscribe() failed: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
success = 0;
SHOW_TIME("pa_threaded_mainloop_wait");
while (pa_operation_get_state(o) != PA_OPERATION_DONE) {
CHECK_DEAD_GOTO(fail, 1);
pa_threaded_mainloop_wait(mainloop);
}
pa_operation_unref(o);
if (!success) {
SHOW("pa_context_subscribe() failed: %s", pa_strerror(pa_context_errno(context)));
goto unlock_and_fail;
}
do_trigger = 0;
written = 0;
time_offset_msec = 0;
just_flushed = 0;
connected = 1;
pa_threaded_mainloop_unlock(mainloop);
SHOW_TIME("pulse_open (ret true)");
return PULSE_OK;
unlock_and_fail:
if (o)
pa_operation_unref(o);
pa_threaded_mainloop_unlock(mainloop);
fail:
// pulse_close();
if (ret == PULSE_NO_CONNECTION) {
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;
}
}
else {
pulse_close();
}
SHOW_TIME("pulse_open (ret false)");
return ret;
}
/**
* Callback to check the status of context initialization.
*/
static void
xvd_context_state_callback (pa_context *c,
void *userdata)
{
XvdInstance *i = (XvdInstance *) userdata;
pa_subscription_mask_t mask = PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SERVER;
pa_operation *op = NULL;
if (!c || !userdata)
{
g_critical ("xvd_context_state_callback: invalid argument");
return;
}
switch (pa_context_get_state (c))
{
case PA_CONTEXT_UNCONNECTED:
g_debug ("xvd_context_state_callback: The context hasn't been connected yet");
break;
case PA_CONTEXT_CONNECTING:
g_debug ("xvd_context_state_callback: A connection is being established");
break;
case PA_CONTEXT_AUTHORIZING:
g_debug ("xvd_context_state_callback: The client is authorizing itself to the daemon");
break;
case PA_CONTEXT_SETTING_NAME:
g_debug ("xvd_context_state_callback: The client is passing its application name to the daemon");
break;
case PA_CONTEXT_TERMINATED:
g_debug ("xvd_context_state_callback: The connection was terminated cleanly");
i->sink_index = PA_INVALID_INDEX;
xvd_connect_to_pulse (i);
break;
case PA_CONTEXT_FAILED:
g_warning ("xvd_context_state_callback: The connection failed or was disconnected, is PulseAudio Daemon running?");
i->sink_index = PA_INVALID_INDEX;
xvd_connect_to_pulse (i);
break;
case PA_CONTEXT_READY:
g_debug ("xvd_context_state_callback: The connection is established, the context is ready to execute operations");
pa_context_set_subscribe_callback (c,
xvd_subscribed_events_callback,
userdata);
/* subscribe to sink and server changes, we don't need more */
op = pa_context_subscribe (c,
mask,
NULL,
NULL);
if (!op)
{
g_critical ("xvd_context_state_callback: pa_context_subscribe() failed");
return;
}
pa_operation_unref(op);
op = pa_context_get_server_info (c,
xvd_server_info_callback,
userdata);
if (!op)
{
g_warning("xvd_context_state_callback: pa_context_get_server_info() failed");
return;
}
pa_operation_unref(op);
break;
}
}
void Context::contextStateCallback(pa_context *c)
{
qCDebug(PLASMAPA) << "state callback";
pa_context_state_t state = pa_context_get_state(c);
if (state == PA_CONTEXT_READY) {
qCDebug(PLASMAPA) << "ready";
// 1. Register for the stream changes (except during probe)
if (m_context == c) {
pa_context_set_subscribe_callback(c, subscribe_cb, this);
if (!PAOperation(pa_context_subscribe(c, (pa_subscription_mask_t)
(PA_SUBSCRIPTION_MASK_SINK|
PA_SUBSCRIPTION_MASK_SOURCE|
PA_SUBSCRIPTION_MASK_CLIENT|
PA_SUBSCRIPTION_MASK_SINK_INPUT|
PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT|
PA_SUBSCRIPTION_MASK_CARD|
PA_SUBSCRIPTION_MASK_SERVER), nullptr, nullptr))) {
qCWarning(PLASMAPA) << "pa_context_subscribe() failed";
return;
}
}
if (!PAOperation(pa_context_get_sink_info_list(c, sink_cb, this))) {
qCWarning(PLASMAPA) << "pa_context_get_sink_info_list() failed";
return;
}
if (!PAOperation(pa_context_get_source_info_list(c, source_cb, this))) {
qCWarning(PLASMAPA) << "pa_context_get_source_info_list() failed";
return;
}
if (!PAOperation(pa_context_get_client_info_list(c, client_cb, this))) {
qCWarning(PLASMAPA) << "pa_context_client_info_list() failed";
return;
}
if (!PAOperation(pa_context_get_card_info_list(c, card_cb, this))) {
qCWarning(PLASMAPA) << "pa_context_get_card_info_list() failed";
return;
}
if (!PAOperation(pa_context_get_sink_input_info_list(c, sink_input_callback, this))) {
qCWarning(PLASMAPA) << "pa_context_get_sink_input_info_list() failed";
return;
}
if (!PAOperation(pa_context_get_source_output_info_list(c, source_output_cb, this))) {
qCWarning(PLASMAPA) << "pa_context_get_source_output_info_list() failed";
return;
}
if (!PAOperation(pa_context_get_server_info(c, server_cb, this))) {
qCWarning(PLASMAPA) << "pa_context_get_server_info() failed";
return;
}
if (PAOperation(pa_ext_stream_restore_read(c, ext_stream_restore_read_cb, this))) {
pa_ext_stream_restore_set_subscribe_cb(c, ext_stream_restore_subscribe_cb, this);
PAOperation(pa_ext_stream_restore_subscribe(c, 1, nullptr, this));
} else {
qCWarning(PLASMAPA) << "Failed to initialize stream_restore extension";
}
} else if (!PA_CONTEXT_IS_GOOD(state)) {
qCWarning(PLASMAPA) << "context kaput";
if (m_context) {
pa_context_unref(m_context);
m_context = nullptr;
}
reset();
QTimer::singleShot(1000, this, &Context::connectToDaemon);
}
}
bool CAESinkPULSE::Initialize(AEAudioFormat &format, std::string &device)
{
{
CSingleLock lock(m_sec);
m_IsAllocated = false;
}
m_passthrough = false;
m_BytesPerSecond = 0;
m_BufferSize = 0;
m_filled_bytes = 0;
m_lastPackageStamp = 0;
m_Channels = 0;
m_Stream = NULL;
m_Context = NULL;
m_periodSize = 0;
if (!SetupContext(NULL, &m_Context, &m_MainLoop))
{
CLog::Log(LOGNOTICE, "PulseAudio might not be running. Context was not created.");
Deinitialize();
return false;
}
pa_threaded_mainloop_lock(m_MainLoop);
struct pa_channel_map map;
pa_channel_map_init(&map);
// PULSE cannot cope with e.g. planar formats so we fallback to FLOAT
// when we receive an invalid pulse format
if (AEFormatToPulseFormat(format.m_dataFormat) == PA_SAMPLE_INVALID)
{
CLog::Log(LOGDEBUG, "PULSE does not support format: %s - will fallback to AE_FMT_FLOAT", CAEUtil::DataFormatToStr(format.m_dataFormat));
format.m_dataFormat = AE_FMT_FLOAT;
}
m_passthrough = AE_IS_RAW(format.m_dataFormat);
if(m_passthrough)
{
map.channels = 2;
format.m_channelLayout = AE_CH_LAYOUT_2_0;
}
else
{
map = AEChannelMapToPAChannel(format.m_channelLayout);
// if count has changed we need to fit the AE Map
if(map.channels != format.m_channelLayout.Count())
format.m_channelLayout = PAChannelToAEChannelMap(map);
}
m_Channels = format.m_channelLayout.Count();
// store information about current sink
SinkInfoStruct sinkStruct;
sinkStruct.mainloop = m_MainLoop;
sinkStruct.device_found = false;
// get real sample rate of the device we want to open - to avoid resampling
bool isDefaultDevice = (device == "Default");
WaitForOperation(pa_context_get_sink_info_by_name(m_Context, isDefaultDevice ? NULL : device.c_str(), SinkInfoCallback, &sinkStruct), m_MainLoop, "Get Sink Info");
// only check if the device is existing - don't alter the sample rate
if (!sinkStruct.device_found)
{
CLog::Log(LOGERROR, "PulseAudio: Sink %s not found", device.c_str());
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
// Pulse can resample everything between 1 hz and 192000 hz
// Make sure we are in the range that we originally added
format.m_sampleRate = std::max(5512U, std::min(format.m_sampleRate, 192000U));
pa_format_info *info[1];
info[0] = pa_format_info_new();
info[0]->encoding = AEFormatToPulseEncoding(format.m_dataFormat);
if(!m_passthrough)
{
pa_format_info_set_sample_format(info[0], AEFormatToPulseFormat(format.m_dataFormat));
pa_format_info_set_channel_map(info[0], &map);
}
pa_format_info_set_channels(info[0], m_Channels);
// PA requires m_encodedRate in order to do EAC3
unsigned int samplerate = format.m_sampleRate;
if (m_passthrough && (AEFormatToPulseEncoding(format.m_dataFormat) == PA_ENCODING_EAC3_IEC61937))
{
// this is only used internally for PA to use EAC3
samplerate = format.m_encodedRate;
}
pa_format_info_set_rate(info[0], samplerate);
if (!pa_format_info_valid(info[0]))
{
CLog::Log(LOGERROR, "PulseAudio: Invalid format info");
pa_format_info_free(info[0]);
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
pa_sample_spec spec;
#if PA_CHECK_VERSION(2,0,0)
pa_format_info_to_sample_spec(info[0], &spec, NULL);
#else
spec.rate = (AEFormatToPulseEncoding(format.m_dataFormat) == PA_ENCODING_EAC3_IEC61937) ? 4 * samplerate : samplerate;
spec.format = AEFormatToPulseFormat(format.m_dataFormat);
spec.channels = m_Channels;
#endif
if (!pa_sample_spec_valid(&spec))
{
CLog::Log(LOGERROR, "PulseAudio: Invalid sample spec");
pa_format_info_free(info[0]);
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
m_BytesPerSecond = pa_bytes_per_second(&spec);
unsigned int frameSize = pa_frame_size(&spec);
m_Stream = pa_stream_new_extended(m_Context, "kodi audio stream", info, 1, NULL);
pa_format_info_free(info[0]);
if (m_Stream == NULL)
{
CLog::Log(LOGERROR, "PulseAudio: Could not create a stream");
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
pa_stream_set_state_callback(m_Stream, StreamStateCallback, m_MainLoop);
pa_stream_set_write_callback(m_Stream, StreamRequestCallback, m_MainLoop);
pa_stream_set_latency_update_callback(m_Stream, StreamLatencyUpdateCallback, m_MainLoop);
// default buffer construction
// align with AE's max buffer
unsigned int latency = m_BytesPerSecond / 2.5; // 400 ms
unsigned int process_time = latency / 4; // 100 ms
if(sinkStruct.isHWDevice)
{
// on hw devices buffers can be further reduced
// 200ms max latency
// 50ms min packet size
latency = m_BytesPerSecond / 5;
process_time = latency / 4;
}
pa_buffer_attr buffer_attr;
buffer_attr.fragsize = latency;
buffer_attr.maxlength = (uint32_t) -1;
buffer_attr.minreq = process_time;
buffer_attr.prebuf = (uint32_t) -1;
buffer_attr.tlength = latency;
if (pa_stream_connect_playback(m_Stream, isDefaultDevice ? NULL : device.c_str(), &buffer_attr, ((pa_stream_flags)(PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_ADJUST_LATENCY)), NULL, NULL) < 0)
{
CLog::Log(LOGERROR, "PulseAudio: Failed to connect stream to output");
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
/* Wait until the stream is ready */
do
{
pa_threaded_mainloop_wait(m_MainLoop);
CLog::Log(LOGDEBUG, "PulseAudio: Stream %s", StreamStateToString(pa_stream_get_state(m_Stream)));
}
while (pa_stream_get_state(m_Stream) != PA_STREAM_READY && pa_stream_get_state(m_Stream) != PA_STREAM_FAILED);
if (pa_stream_get_state(m_Stream) == PA_STREAM_FAILED)
{
CLog::Log(LOGERROR, "PulseAudio: Waited for the stream but it failed");
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
const pa_buffer_attr *a;
if (!(a = pa_stream_get_buffer_attr(m_Stream)))
{
CLog::Log(LOGERROR, "PulseAudio: %s", pa_strerror(pa_context_errno(m_Context)));
pa_threaded_mainloop_unlock(m_MainLoop);
Deinitialize();
return false;
}
else
{
unsigned int packetSize = a->minreq;
m_BufferSize = a->tlength;
m_periodSize = a->minreq;
format.m_frames = packetSize / frameSize;
}
{
CSingleLock lock(m_sec);
// Register Callback for Sink changes
pa_context_set_subscribe_callback(m_Context, SinkChangedCallback, this);
const pa_subscription_mask_t mask = PA_SUBSCRIPTION_MASK_SINK;
pa_operation *op = pa_context_subscribe(m_Context, mask, NULL, this);
if (op != NULL)
pa_operation_unref(op);
// Register Callback for Sink Info changes - this handles volume
pa_context_set_subscribe_callback(m_Context, SinkInputInfoChangedCallback, this);
const pa_subscription_mask_t mask_input = PA_SUBSCRIPTION_MASK_SINK_INPUT;
pa_operation* op_sinfo = pa_context_subscribe(m_Context, mask_input, NULL, this);
if (op_sinfo != NULL)
pa_operation_unref(op_sinfo);
}
pa_threaded_mainloop_unlock(m_MainLoop);
format.m_frameSize = frameSize;
format.m_frameSamples = format.m_frames * format.m_channelLayout.Count();
m_format = format;
format.m_dataFormat = m_passthrough ? AE_FMT_S16NE : format.m_dataFormat;
CLog::Log(LOGNOTICE, "PulseAudio: Opened device %s in %s mode with Buffersize %u ms",
device.c_str(), m_passthrough ? "passthrough" : "pcm",
(unsigned int) ((m_BufferSize / (float) m_BytesPerSecond) * 1000));
// Cork stream will resume when adding first package
Pause(true);
{
CSingleLock lock(m_sec);
m_IsAllocated = true;
}
return true;
}
