void SinkInput::setMuted(int muted)
{
pa_operation *o;
o = pa_context_set_sink_input_mute(d->context->cObject(),
d->index, muted, SinkInput::volume_cb, this);
pa_operation_unref(o);
}
void pulseaudio_toggle_mute(menu_info_item_t* mii)
{
g_debug("pulseaudio_toggle_mute(%s)", mii->name);
pa_operation* o = NULL;
int mute = (mii->mute) ? 0 : 1;
switch(mii->menu_info->type)
{
case MENU_SERVER:
case MENU_MODULE:
/* nothing to do here */
break;
case MENU_SINK:
o = pa_context_set_sink_mute_by_index(context, mii->index,
mute, pulseaudio_toggle_mute_success_cb, mii);
break;
case MENU_SOURCE:
o = pa_context_set_source_mute_by_index(context, mii->index,
mute, pulseaudio_toggle_mute_success_cb, mii);
break;
case MENU_INPUT:
o = pa_context_set_sink_input_mute(context, mii->index,
mute, pulseaudio_toggle_mute_success_cb, mii);
break;
case MENU_OUTPUT:
o = pa_context_set_source_output_mute(context, mii->index,
mute, pulseaudio_toggle_mute_success_cb, mii);
break;
}
if(o)
pa_operation_unref(o);
}
static int qpa_ctl_out (HWVoiceOut *hw, int cmd, ...)
{
PAVoiceOut *pa = (PAVoiceOut *) hw;
pa_operation *op;
pa_cvolume v;
paaudio *g = pa->g;
#ifdef PA_CHECK_VERSION /* macro is present in 0.9.16+ */
pa_cvolume_init (&v); /* function is present in 0.9.13+ */
#endif
switch (cmd) {
case VOICE_VOLUME:
{
SWVoiceOut *sw;
va_list ap;
va_start (ap, cmd);
sw = va_arg (ap, SWVoiceOut *);
va_end (ap);
v.channels = 2;
v.values[0] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.l) / UINT32_MAX;
v.values[1] = ((PA_VOLUME_NORM - PA_VOLUME_MUTED) * sw->vol.r) / UINT32_MAX;
pa_threaded_mainloop_lock (g->mainloop);
op = pa_context_set_sink_input_volume (g->context,
pa_stream_get_index (pa->stream),
&v, NULL, NULL);
if (!op)
qpa_logerr (pa_context_errno (g->context),
"set_sink_input_volume() failed\n");
else
pa_operation_unref (op);
op = pa_context_set_sink_input_mute (g->context,
pa_stream_get_index (pa->stream),
sw->vol.mute, NULL, NULL);
if (!op) {
qpa_logerr (pa_context_errno (g->context),
"set_sink_input_mute() failed\n");
} else {
pa_operation_unref (op);
}
pa_threaded_mainloop_unlock (g->mainloop);
}
}
return 0;
}
void backend_mute_set(context_t *c, backend_entry_type type, uint32_t idx, int v) {
switch(type) {
case SINK:
pa_context_set_sink_mute_by_index(c->context, idx, v, NULL, NULL);
break;
case SINK_INPUT:
pa_context_set_sink_input_mute(c->context, idx, v, NULL, NULL);
break;
case SOURCE:
pa_context_set_source_mute_by_index(c->context, idx, v, NULL, NULL);
break;
case SOURCE_OUTPUT:
pa_context_set_source_output_mute(c->context, idx, v, NULL, NULL);
break;
default:
break;
}
}
/**
* Mute (from within showtime), send update to PA
*
* Lock for PA mainloop is already held
*/
static void
set_mastermute(void *opaque, int value)
{
pa_audio_mode_t *pam = opaque;
pa_operation *o;
pam->muted = value;
if(pam->stream == NULL ||
pa_stream_get_state(pam->stream) != PA_STREAM_READY)
return;
o = pa_context_set_sink_input_mute(pam->context,
pa_stream_get_index(pam->stream),
pam->muted, NULL, NULL);
if(o != NULL)
pa_operation_unref(o);
}
static void
stream_state_callback(pa_stream *s, void *userdata)
{
pa_audio_mode_t *pam = (pa_audio_mode_t *)userdata;
pa_operation *o;
if(pa_stream_get_state(s) == PA_STREAM_FAILED) {
pam->stream_error = pa_context_errno(pam->context);
TRACE(TRACE_ERROR, "PA",
"Stream failure: %s", pa_strerror(pam->stream_error));
}
if(pa_stream_get_state(s) == PA_STREAM_READY && pam->muted) {
o = pa_context_set_sink_input_mute(pam->context,
pa_stream_get_index(pam->stream),
pam->muted, NULL, NULL);
if(o != NULL)
pa_operation_unref(o);
}
pa_threaded_mainloop_signal(mainloop, 0);
}
int pa_simple_mute(pa_simple *p, int mute, int *rerror) {
pa_operation *o = NULL;
uint32_t idx;
pa_assert(p);
CHECK_VALIDITY_RETURN_ANY(rerror, p->direction == PA_STREAM_PLAYBACK, PA_ERR_BADSTATE, -1);
pa_threaded_mainloop_lock(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
CHECK_SUCCESS_GOTO(p, rerror, ((idx = pa_stream_get_index (p->stream)) != PA_INVALID_INDEX), unlock_and_fail);
o = pa_context_set_sink_input_mute (p->context, idx, mute, success_context_cb, p);
CHECK_SUCCESS_GOTO(p, rerror, o, unlock_and_fail);
p->operation_success = 0;
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
pa_threaded_mainloop_wait(p->mainloop);
CHECK_DEAD_GOTO(p, rerror, unlock_and_fail);
}
CHECK_SUCCESS_GOTO(p, rerror, p->operation_success, unlock_and_fail);
pa_operation_unref(o);
pa_threaded_mainloop_unlock(p->mainloop);
return 0;
unlock_and_fail:
if (o) {
pa_operation_cancel(o);
pa_operation_unref(o);
}
pa_threaded_mainloop_unlock(p->mainloop);
return -1;
}
static int control(struct ao *ao, enum aocontrol cmd, void *arg)
{
struct priv *priv = ao->priv;
switch (cmd) {
case AOCONTROL_GET_MUTE:
case AOCONTROL_GET_VOLUME: {
uint32_t devidx = pa_stream_get_index(priv->stream);
pa_threaded_mainloop_lock(priv->mainloop);
if (!waitop(priv, pa_context_get_sink_input_info(priv->context, devidx,
info_func, ao))) {
GENERIC_ERR_MSG(priv->context,
"pa_stream_get_sink_input_info() failed");
return CONTROL_ERROR;
}
// Warning: some information in pi might be unaccessible, because
// we naively copied the struct, without updating pointers etc.
// Pointers might point to invalid data, accessors might fail.
if (cmd == AOCONTROL_GET_VOLUME) {
ao_control_vol_t *vol = arg;
if (priv->pi.volume.channels != 2)
vol->left = vol->right =
pa_cvolume_avg(&priv->pi.volume) * 100 / PA_VOLUME_NORM;
else {
vol->left = priv->pi.volume.values[0] * 100 / PA_VOLUME_NORM;
vol->right = priv->pi.volume.values[1] * 100 / PA_VOLUME_NORM;
}
} else if (cmd == AOCONTROL_GET_MUTE) {
bool *mute = arg;
*mute = priv->pi.mute;
}
return CONTROL_OK;
}
case AOCONTROL_SET_MUTE:
case AOCONTROL_SET_VOLUME: {
pa_operation *o;
pa_threaded_mainloop_lock(priv->mainloop);
uint32_t stream_index = pa_stream_get_index(priv->stream);
if (cmd == AOCONTROL_SET_VOLUME) {
const ao_control_vol_t *vol = arg;
struct pa_cvolume volume;
pa_cvolume_reset(&volume, ao->channels);
if (volume.channels != 2)
pa_cvolume_set(&volume, volume.channels,
vol->left * PA_VOLUME_NORM / 100);
else {
volume.values[0] = vol->left * PA_VOLUME_NORM / 100;
volume.values[1] = vol->right * PA_VOLUME_NORM / 100;
}
o = pa_context_set_sink_input_volume(priv->context, stream_index,
&volume, NULL, NULL);
if (!o) {
pa_threaded_mainloop_unlock(priv->mainloop);
GENERIC_ERR_MSG(priv->context,
"pa_context_set_sink_input_volume() failed");
return CONTROL_ERROR;
}
} else if (cmd == AOCONTROL_SET_MUTE) {
const bool *mute = arg;
o = pa_context_set_sink_input_mute(priv->context, stream_index,
*mute, NULL, NULL);
if (!o) {
pa_threaded_mainloop_unlock(priv->mainloop);
GENERIC_ERR_MSG(priv->context,
"pa_context_set_sink_input_mute() failed");
return CONTROL_ERROR;
}
} else
abort();
/* We don't wait for completion here */
pa_operation_unref(o);
pa_threaded_mainloop_unlock(priv->mainloop);
return CONTROL_OK;
}
default:
return CONTROL_UNKNOWN;
}
}
