/** * @brief Callback function called when the state of the context is changed * @param c Context which changed status * @param this_gen pulse_class_t pointer for the PulseAudio output class */ static void __xine_pa_context_state_callback(pa_context *c, void *this_gen) { pulse_driver_t * this = (pulse_driver_t*) this_gen; switch (pa_context_get_state(c)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: case PA_CONTEXT_FAILED: pa_threaded_mainloop_signal(this->mainloop, 0); break; case PA_CONTEXT_CONNECTING: case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; } }
static void gst_pulsesrc_context_state_cb (pa_context * c, void *userdata) { GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (userdata); switch (pa_context_get_state (c)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: case PA_CONTEXT_FAILED: pa_threaded_mainloop_signal (pulsesrc->mainloop, 0); break; case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; } }
static void context_state_cb(pa_context *c, void *userdata) { pa_simple *p = userdata; pa_assert(c); pa_assert(p); switch (pa_context_get_state(c)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: case PA_CONTEXT_FAILED: pa_threaded_mainloop_signal(p->mainloop, 0); break; case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; } }
static void context_state_callback(pa_context *c, void *userdata) { switch (pa_context_get_state(c)) { case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: case PA_CONTEXT_READY: break; case PA_CONTEXT_TERMINATED: gtk_main_quit(); break; case PA_CONTEXT_FAILED: default: fprintf(stderr, "Connection failure: %s", pa_strerror(pa_context_errno(c))); gtk_main_quit(); 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: { printf("func = %s , LINE = %d \n",__func__,__LINE__); pa_operation *o; // set up a callback to tell us about source devices if (!(o = pa_context_get_source_info_list(c, sourcelist_cb, NULL ))) { show_error(_("pa_context_subscribe() failed")); return; } pa_operation_unref(o); // set up a callback to tell us about sink devices if (!(o = pa_context_get_sink_info_list(c, sinklist_cb, NULL ))) { show_error(_("pa_context_subscribe() failed")); return; } pa_operation_unref(o); break; } case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: default: return; } }
static void pa_state_cb(pa_context* c, void* data) { int* pa_ready = (int*)data; switch (pa_context_get_state(c)) { // These are just here for reference case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: default: break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: *pa_ready = 2; break; case PA_CONTEXT_READY: *pa_ready = 1; break; } }
std::shared_ptr<AudioSink> AudioSinksManager::create_new_sink(std::string name, std::string pretty_name) { auto internal_sink = std::shared_ptr<InternalAudioSink>( new InternalAudioSink(this, std::move(name), std::move(pretty_name))); auto sink = std::shared_ptr<AudioSink>(new AudioSink(internal_sink)); pa_mainloop.get_strand().dispatch([this, internal_sink]() { if (stopping) { internal_sink->free(); } else { logger->trace("(AudioSinkManager) Registering audio_sink '{}'", internal_sink->get_name()); audio_sinks.insert(internal_sink); sink_identifier_audio_sink.emplace(internal_sink->get_identifier(), internal_sink); if (pa_context_get_state(context) == PA_CONTEXT_READY) { internal_sink->start_sink(); } } }); return sink; }
void AudioOutputPulseAudio::ContextStateCallback(pa_context *c, void *arg) { QString fn_log_tag = "_ContextStateCallback, "; AudioOutputPulseAudio *audoutP = static_cast<AudioOutputPulseAudio*>(arg); switch (pa_context_get_state(c)) { case PA_CONTEXT_READY: pa_threaded_mainloop_signal(audoutP->mainloop, 0); break; case PA_CONTEXT_TERMINATED: case PA_CONTEXT_FAILED: pa_threaded_mainloop_signal(audoutP->mainloop, 0); break; case PA_CONTEXT_CONNECTING: case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; } }
void context_state_callback(pa_context *context, void *data){ (void) data; pa_context_state_t state = pa_context_get_state(context); qDebug("Context state changed: %d", state); switch(state){ case PA_CONTEXT_READY: qDebug("Ready, set, go..."); connected = true; pa_threaded_mainloop_signal(threaded_main_loop, 0); break; case PA_CONTEXT_FAILED: qDebug("Connecting context failed."); failed = true; pa_threaded_mainloop_signal(threaded_main_loop, 0); break; default: break; } }
void PulseAudioSinksManager::pulseAudioStateCallback(pa_context *ctx, void *userdata) { PulseAudioSinksManager* sinksManager = (PulseAudioSinksManager*)userdata; pa_context_state_t state = pa_context_get_state(ctx); switch (state) { // There are just here for reference case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: case PA_CONTEXT_TERMINATED: default: break; case PA_CONTEXT_FAILED: sinksManager->emitSignalError("Cannot connect to pulse audio"); break; case PA_CONTEXT_READY: sinksManager->retrieveSinksInfo(); break; } }
/** * Context status changed. */ static void drvHostPulseAudioCbCtxState(pa_context *pContext, void *pvUser) { AssertPtrReturnVoid(pContext); NOREF(pvUser); switch (pa_context_get_state(pContext)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: drvHostPulseAudioAbortMainLoop(); break; case PA_CONTEXT_FAILED: LogRel(("PulseAudio: Audio input/output stopped!\n")); drvHostPulseAudioAbortMainLoop(); break; default: break; } }
static void gst_pulsemixer_ctrl_context_state_cb (pa_context * context, void *userdata) { GstPulseMixerCtrl *c = GST_PULSEMIXER_CTRL (userdata); /* Called from the background thread! */ switch (pa_context_get_state (context)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: case PA_CONTEXT_FAILED: pa_threaded_mainloop_signal (c->mainloop, 0); break; case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; } }
static void tsmf_pulse_context_state_callback(pa_context *context, void *userdata) { TSMFPulseAudioDevice *pulse = (TSMFPulseAudioDevice *) userdata; pa_context_state_t state; state = pa_context_get_state(context); switch(state) { case PA_CONTEXT_READY: DEBUG_TSMF("PA_CONTEXT_READY"); pa_threaded_mainloop_signal(pulse->mainloop, 0); break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: DEBUG_TSMF("state %d", (int)state); pa_threaded_mainloop_signal(pulse->mainloop, 0); break; default: DEBUG_TSMF("state %d", (int)state); break; } }
/* This is called whenever the context status changes */ static void context_state_callback(pa_context *c, void *userdata) { fail_unless(c != NULL); switch (pa_context_get_state(c)) { case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; case PA_CONTEXT_READY: { int i; fprintf(stderr, "Connection established.\n"); for (i = 0; i < NSTREAMS; i++) { char name[64]; fprintf(stderr, "Creating stream %i\n", i); snprintf(name, sizeof(name), "stream #%i", i); streams[i] = pa_stream_new(c, name, &sample_spec, NULL); fail_unless(streams[i] != NULL); pa_stream_set_state_callback(streams[i], stream_state_callback, (void*) (long) i); pa_stream_connect_playback(streams[i], NULL, &buffer_attr, PA_STREAM_START_CORKED, NULL, i == 0 ? NULL : streams[0]); } break; } case PA_CONTEXT_TERMINATED: mainloop_api->quit(mainloop_api, 0); break; case PA_CONTEXT_FAILED: default: fprintf(stderr, "Context error: %s\n", pa_strerror(pa_context_errno(c))); fail(); } }
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))); } }
void xvd_toggle_mute (XvdInstance *i) { pa_operation *op = NULL; if (!i || !i->pulse_context) { g_warning ("xvd_toggle_mute: pulseaudio context is null"); return; } if (pa_context_get_state (i->pulse_context) != PA_CONTEXT_READY) { g_warning ("xvd_toggle_mute: pulseaudio context isn't ready"); return; } if (i->sink_index == PA_INVALID_INDEX) { g_warning ("xvd_toggle_mute: undefined sink"); return; } /* backup existing mute and update */ i->mute = !(old_mute = i->mute); op = pa_context_set_sink_mute_by_index (i->pulse_context, i->sink_index, i->mute, xvd_notify_volume_callback, i); if (!op) { g_warning ("xvd_toggle_mute: failed"); return; } pa_operation_unref (op); }
/** * Callback for context state. * Sets *user_data to one of conn_state_t. */ void state_cb(pa_context *ctx, void *user_data) { pa_context_state_t state; enum conn_state_t *pa_ready = user_data; state = pa_context_get_state(ctx); switch (state) { case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: default: *pa_ready = CONN_WAIT; break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: *pa_ready = CONN_FAILED; break; case PA_CONTEXT_READY: *pa_ready = CONN_READY; break; } }
// This callback gets called when our context changes state. We really only // care about when it's ready or if it has failed. static void pa_names_state_cb(pa_context *c, void *userdata) { pa_context_state_t ctx_state; int *main_state = userdata; ctx_state = pa_context_get_state(c); switch (ctx_state) { // There are just here for reference case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: default: break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: *main_state = 9; break; case PA_CONTEXT_READY: *main_state = 1; break; } }
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(); }
/* * Create a new pulse audio main loop and connect to the server * * Returns a negative value on error */ static int pulse_connect(struct pulse_data *data) { data->mainloop = pa_mainloop_new(); if (!data->mainloop) { blog(LOG_ERROR, "pulse-input: Unable to create main loop"); return -1; } data->context = pa_context_new_with_proplist( pa_mainloop_get_api(data->mainloop), "OBS Studio", data->props); if (!data->context) { blog(LOG_ERROR, "pulse-input: Unable to create context"); return -1; } int status = pa_context_connect( data->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL); if (status < 0) { blog(LOG_ERROR, "pulse-input: Unable to connect! Status: %d", status); return -1; } // wait until connected for (;;) { pulse_iterate(data); pa_context_state_t state = pa_context_get_state(data->context); if (state == PA_CONTEXT_READY) { blog(LOG_DEBUG, "pulse-input: Context ready"); break; } if (!PA_CONTEXT_IS_GOOD(state)) { blog(LOG_ERROR, "pulse-input: Context connect failed"); return -1; } } return 0; }
static void __pulseaudio_context_state_cb(pa_context *pulse_context, void *user_data) { int state = 0; SOUND_INFO *info = NULL; mmf_return_if_fail(user_data); info = (SOUND_INFO *)user_data; state = pa_context_get_state(pulse_context); switch (state) { case PA_CONTEXT_READY: _mmcam_dbg_log("pulseaudio context READY"); if (info->pulse_context == pulse_context) { /* Signal */ _mmcam_dbg_log("pulseaudio send signal"); pa_threaded_mainloop_signal(info->pulse_mainloop, 0); } break; case PA_CONTEXT_TERMINATED: if (info->pulse_context == pulse_context) { /* Signal */ _mmcam_dbg_log("Context terminated : pulseaudio send signal"); pa_threaded_mainloop_signal(info->pulse_mainloop, 0); } break; case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: case PA_CONTEXT_FAILED: default: _mmcam_dbg_log("pulseaudio context %p, state %d", pulse_context, state); break; } return; }
void pa_state_cb(pa_context *c, void *userdata) { pa_context_state_t state; int *pa_ready = userdata; state = pa_context_get_state(c); switch (state) { case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: default: break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: *pa_ready = 2; break; case PA_CONTEXT_READY: *pa_ready = 1; break; } }
//////////////////////////////////////////////////////////////////////// // CALLBACKS FOR THREADED MAINLOOP //////////////////////////////////////////////////////////////////////// static void context_state_cb (pa_context *context, void *userdata) { Device *dev = userdata; if ((context == NULL) || (dev == NULL)) return; switch (pa_context_get_state (context)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: case PA_CONTEXT_FAILED: pa_threaded_mainloop_signal (dev->mainloop, 0); break; case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; } }
void WavegenClient::onContextStateChanged() { switch (pa_context_get_state(paContext_)) { case PA_CONTEXT_FAILED: reportContextError(paContext_, pa_context_get_server(paContext_)); notifyResult(OperationType::Connect, OperationResult::Failed, true); break; case PA_CONTEXT_TERMINATED: notifyResult(OperationType::Connect, OperationResult::Failed, true); break; case PA_CONTEXT_READY: // connection OK if (firstConnection_) { onConnectionEstablishedFirstTime(); firstConnection_ = false; } notifyResult(OperationType::Connect, OperationResult::Success, true); break; default: // connecting in progress... notifyResult(OperationType::Connect, OperationResult::InProgress, false); break; } }
/** * Context status changed. */ static void paContextCbStateChanged(pa_context *pCtx, void *pvUser) { AssertPtrReturnVoid(pCtx); PDRVHOSTPULSEAUDIO pThis = (PDRVHOSTPULSEAUDIO)pvUser; AssertPtrReturnVoid(pThis); switch (pa_context_get_state(pCtx)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: paSignalWaiter(pThis); break; case PA_CONTEXT_FAILED: LogRel(("PulseAudio: Audio context has failed, stopping\n")); paSignalWaiter(pThis); break; default: break; } }
void pa_state_cb(pa_context *c, void *userdata) { pa_context_state_t state; state = pa_context_get_state(c); switch (state) { // There are just here for reference case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: exit(-1); break; case PA_CONTEXT_READY: if (m_pa_stream_connect(c) < 0) { exit(-1); } break; } }
/****************************************************************************** * The context_state_cb() will be called by PulseAudio when the PulseAudio * context changes state. * So far, we are only interested in PA_CONTEXT_READY: When the context is * ready, we initialize a PulseAudio stream and connect it to the server. *****************************************************************************/ static void context_state_cb(pa_context *context, void *userdata) { _mbx_out out = (_mbx_out ) userdata; pa_context_state_t state = pa_context_get_state(context); assert ( out != NULL && out->pa_ctx == context ); log_context_state(state); switch (state) { case PA_CONTEXT_READY: context_ready(out); out->state = _MBX_OUT_READY; break; case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: /* Do nothing until the state becomes PA_CONTEXT_READY. */ break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: default: /* Initialization error. */ out->state = _MBX_OUT_PULSEAUDIO_ERROR; } }
/** * Context status changed. */ static void drvHostPulseAudioCbCtxState(pa_context *pContext, void *pvContext) { AssertPtrReturnVoid(pContext); PPULSEAUDIOSTREAM pStrm = (PPULSEAUDIOSTREAM)pvContext; NOREF(pStrm); switch (pa_context_get_state(pContext)) { case PA_CONTEXT_READY: case PA_CONTEXT_TERMINATED: pa_threaded_mainloop_signal(g_pMainLoop, 0); break; case PA_CONTEXT_FAILED: LogRel(("PulseAudio: Audio input/output stopped!\n")); pa_threaded_mainloop_signal(g_pMainLoop, 0); break; default: break; } }
static void context_state_callback (pa_context *pa, void *data) { SwfdecPlayback *sound = data; switch (pa_context_get_state(pa)) { case PA_CONTEXT_FAILED: g_printerr ("PA context failed\n"); pa_context_unref (pa); sound->pa = NULL; break; default: case PA_CONTEXT_TERMINATED: case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: case PA_CONTEXT_READY: break; } }
int AudioOutputPulseAudio::GetBufferedOnSoundcard(void) const { pa_usec_t latency = (pa_usec_t) -1; size_t buffered = 0; if (!pcontext || pa_context_get_state(pcontext) != PA_CONTEXT_READY) return 0; if (!pstream || pa_stream_get_state(pstream) != PA_STREAM_READY) return 0; const pa_buffer_attr *buf_attr = pa_stream_get_buffer_attr(pstream); size_t bfree = pa_stream_writable_size(pstream); buffered = buf_attr->tlength - bfree; pa_threaded_mainloop_lock(mainloop); while (pa_stream_get_latency(pstream, &latency, NULL) < 0) { if (pa_context_errno(pcontext) != PA_ERR_NODATA) { latency = 0; break; } pa_threaded_mainloop_wait(mainloop); } pa_threaded_mainloop_unlock(mainloop); if (latency < 0) { latency = 0; } return ((uint64_t)latency * samplerate * output_bytes_per_frame / 1000000) + buffered; }