C++ (Cpp) pa_context_set_sink_mute_by_name Examples

Example #1

File: supavolumed.c Project: osandov/supavolumed

static void sink_toggle_mute_callback(pa_context *c, const pa_sink_info *i,
				      int is_last, void *userdata)
{
	pa_operation *o;

	if (is_last < 0) {
		fprintf(stderr, "Failed to get sink information: %s\n",
			pa_strerror(pa_context_errno(c)));
		return;
	}

	if (is_last)
		return;

	o = pa_context_set_sink_mute_by_name(c, i->name, !i->mute,
					     simple_callback, NULL);
	if (!o) {
		fprintf(stderr, "Operation failed: %s\n",
			pa_strerror(pa_context_errno(c)));
		return;
	}
	pa_operation_unref(o);

	show_volume_notification(volume_pct_from_cv(&i->volume), !i->mute);
}

Example #2

File: pavol.c Project: lotrfan/pavolume

void pulse_set_default_sink_mute(struct pulseaudio_t *pulse, int muted) {
    pa_operation *op;

    pulse->muted = muted;

    op = pa_context_set_sink_mute_by_name(pulse->cxt, pulse->default_sink, pulse->muted, NULL, pulse);
    pulse_async_wait(pulse, op);
    pa_operation_unref(op);
}

Example #3

File: audio_service.c Project: nizovn/audio-service

static bool set_mute_cb(LSHandle *handle, LSMessage *message, void *user_data)
{
	struct audio_service *service = user_data;
	const char *payload;
	jvalue_ref parsed_obj = NULL;
	struct luna_service_req_data *req;
	pa_operation *op;

	if (!service->context_initialized) {
		luna_service_message_reply_custom_error(handle, message, "Not yet initialized");
		return true;
	}

	payload = LSMessageGetPayload(message);
	parsed_obj = luna_service_message_parse_and_validate(payload);
	if (jis_null(parsed_obj)) {
		luna_service_message_reply_error_bad_json(handle, message);
		goto cleanup;
	}

	service->new_mute = (int) luna_service_message_get_boolean(parsed_obj, "mute", (bool) service->mute);

	if (service->new_mute == service->mute) {
		luna_service_message_reply_success(handle, message);
		goto cleanup;
	}

	req = luna_service_req_data_new(handle, message);
	req->user_data = service;

	op = pa_context_set_sink_mute_by_name(service->context, service->default_sink_name, service->new_mute, set_mute_success_cb, req);
	pa_operation_unref(op);

cleanup:
	if (!jis_null(parsed_obj))
		j_release(&parsed_obj);

	return true;
}

Example #4

File: ctl_pulse.c Project: Boshin/workspace

static int pulse_write_integer(snd_ctl_ext_t * ext, snd_ctl_ext_key_t key,
			       long *value)
{
	snd_ctl_pulse_t *ctl = ext->private_data;
	int err = 0, i;
	pa_operation *o;
	pa_cvolume *vol = NULL;

	assert(ctl);

	if (!ctl->p || !ctl->p->mainloop)
		return -EBADFD;

	pa_threaded_mainloop_lock(ctl->p->mainloop);

	err = pulse_check_connection(ctl->p);
	if (err < 0)
		goto finish;

	err = pulse_update_volume(ctl);
	if (err < 0)
		goto finish;

	switch (key) {
	case 0:
		vol = &ctl->source_volume;
		break;
	case 1:
		if (!!ctl->source_muted == !*value)
			goto finish;
		ctl->source_muted = !*value;
		break;
	case 2:
		vol = &ctl->sink_volume;
		break;
	case 3:
		if (!!ctl->sink_muted == !*value)
			goto finish;
		ctl->sink_muted = !*value;
		break;
	default:
		err = -EINVAL;
		goto finish;
	}

	if (vol) {
		for (i = 0; i < vol->channels; i++)
			if (value[i] != vol->values[i])
				break;

		if (i == vol->channels)
			goto finish;

		for (i = 0; i < vol->channels; i++)
			vol->values[i] = value[i];

		if (key == 0)
			o = pa_context_set_source_volume_by_name(ctl->p->
								 context,
								 ctl->
								 source,
								 vol,
								 pulse_context_success_cb,
								 ctl->p);
		else
			o = pa_context_set_sink_volume_by_name(ctl->p->
							       context,
							       ctl->sink,
							       vol,
							       pulse_context_success_cb,
							       ctl->p);
	} else {
		if (key == 1)
			o = pa_context_set_source_mute_by_name(ctl->p->
							       context,
							       ctl->source,
							       ctl->
							       source_muted,
							       pulse_context_success_cb,
							       ctl->p);
		else
			o = pa_context_set_sink_mute_by_name(ctl->p->
							     context,
							     ctl->sink,
							     ctl->
							     sink_muted,
							     pulse_context_success_cb,
							     ctl->p);
	}

	if (!o) {
		err = -EIO;
		goto finish;
	}

	err = pulse_wait_operation(ctl->p, o);
	pa_operation_unref(o);

	if (err < 0)
		goto finish;

	err = 1;

      finish:
	pa_threaded_mainloop_unlock(ctl->p->mainloop);

	return err;
}