mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2026-02-21 01:40:30 -05:00
capture: Implement per-stream volume control for capture streams.
This piggy backs onto the previous changes for protocol 22 and thus does not bump the version. This and the previous commits should be seen as mostly atomic. Apologies for any bisecting issues this causes (although I would expect these to be minimal)
This commit is contained in:
Colin Guthrie
parent
fdf3a08814
commit
dffc4d18d3
21 changed files with 1980 additions and 219 deletions
|
|
@ -632,7 +632,7 @@ static int pa_cli_command_source_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *
|
|||
}
|
||||
|
||||
pa_cvolume_set(&cvolume, 1, volume);
|
||||
pa_source_set_volume(source, &cvolume, TRUE);
|
||||
pa_source_set_volume(source, &cvolume, TRUE, TRUE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -169,6 +169,10 @@ enum {
|
|||
PA_COMMAND_SET_SINK_PORT,
|
||||
PA_COMMAND_SET_SOURCE_PORT,
|
||||
|
||||
/* Supported since protocol v22 (1.0) */
|
||||
PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME,
|
||||
PA_COMMAND_SET_SOURCE_OUTPUT_MUTE,
|
||||
|
||||
PA_COMMAND_MAX
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -184,7 +184,12 @@ static const char *command_names[PA_COMMAND_MAX] = {
|
|||
|
||||
/* Supported since protocol v16 (0.9.16) */
|
||||
[PA_COMMAND_SET_SINK_PORT] = "SET_SINK_PORT",
|
||||
[PA_COMMAND_SET_SOURCE_PORT] = "SET_SOURCE_PORT"
|
||||
[PA_COMMAND_SET_SOURCE_PORT] = "SET_SOURCE_PORT",
|
||||
|
||||
/* Supported since protocol v22 (1.0) */
|
||||
[PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME] = "SET_SOURCE_OUTPUT_VOLUME",
|
||||
[PA_COMMAND_SET_SOURCE_OUTPUT_MUTE] = "SET_SOURCE_OUTPUT_MUTE",
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -338,10 +338,12 @@ static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
|
|||
[PA_COMMAND_SET_SINK_VOLUME] = command_set_volume,
|
||||
[PA_COMMAND_SET_SINK_INPUT_VOLUME] = command_set_volume,
|
||||
[PA_COMMAND_SET_SOURCE_VOLUME] = command_set_volume,
|
||||
[PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME] = command_set_volume,
|
||||
|
||||
[PA_COMMAND_SET_SINK_MUTE] = command_set_mute,
|
||||
[PA_COMMAND_SET_SINK_INPUT_MUTE] = command_set_mute,
|
||||
[PA_COMMAND_SET_SOURCE_MUTE] = command_set_mute,
|
||||
[PA_COMMAND_SET_SOURCE_OUTPUT_MUTE] = command_set_mute,
|
||||
|
||||
[PA_COMMAND_SUSPEND_SINK] = command_suspend,
|
||||
[PA_COMMAND_SUSPEND_SOURCE] = command_suspend,
|
||||
|
|
@ -631,10 +633,14 @@ static record_stream* record_stream_new(
|
|||
pa_channel_map *map,
|
||||
pa_idxset *formats,
|
||||
pa_buffer_attr *attr,
|
||||
pa_cvolume *volume,
|
||||
pa_bool_t muted,
|
||||
pa_bool_t muted_set,
|
||||
pa_source_output_flags_t flags,
|
||||
pa_proplist *p,
|
||||
pa_bool_t adjust_latency,
|
||||
pa_bool_t early_requests,
|
||||
pa_bool_t relative_volume,
|
||||
pa_bool_t peak_detect,
|
||||
pa_sink_input *direct_on_input,
|
||||
int *ret) {
|
||||
|
|
@ -663,6 +669,15 @@ static record_stream* record_stream_new(
|
|||
if (formats)
|
||||
pa_source_output_new_data_set_formats(&data, formats);
|
||||
data.direct_on_input = direct_on_input;
|
||||
if (volume) {
|
||||
pa_source_output_new_data_set_volume(&data, volume);
|
||||
data.volume_is_absolute = !relative_volume;
|
||||
data.save_volume = TRUE;
|
||||
}
|
||||
if (muted_set) {
|
||||
pa_source_output_new_data_set_muted(&data, muted);
|
||||
data.save_muted = TRUE;
|
||||
}
|
||||
if (peak_detect)
|
||||
data.resample_method = PA_RESAMPLER_PEAKS;
|
||||
data.flags = flags;
|
||||
|
|
@ -2215,6 +2230,7 @@ static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uin
|
|||
pa_channel_map map;
|
||||
pa_tagstruct *reply;
|
||||
pa_source *source = NULL;
|
||||
pa_cvolume volume;
|
||||
pa_bool_t
|
||||
corked = FALSE,
|
||||
no_remap = FALSE,
|
||||
|
|
@ -2224,11 +2240,15 @@ static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uin
|
|||
fix_channels = FALSE,
|
||||
no_move = FALSE,
|
||||
variable_rate = FALSE,
|
||||
muted = FALSE,
|
||||
adjust_latency = FALSE,
|
||||
peak_detect = FALSE,
|
||||
early_requests = FALSE,
|
||||
dont_inhibit_auto_suspend = FALSE,
|
||||
volume_set = TRUE,
|
||||
muted_set = FALSE,
|
||||
fail_on_suspend = FALSE,
|
||||
relative_volume = FALSE,
|
||||
passthrough = FALSE;
|
||||
|
||||
pa_source_output_flags_t flags = 0;
|
||||
|
|
@ -2333,10 +2353,24 @@ static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uin
|
|||
}
|
||||
pa_idxset_put(formats, format, NULL);
|
||||
}
|
||||
|
||||
if (pa_tagstruct_get_cvolume(t, &volume) < 0 ||
|
||||
pa_tagstruct_get_boolean(t, &muted) < 0 ||
|
||||
pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
|
||||
pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
|
||||
pa_tagstruct_get_boolean(t, &relative_volume) < 0 ||
|
||||
pa_tagstruct_get_boolean(t, &passthrough) < 0) {
|
||||
|
||||
protocol_error(c);
|
||||
goto finish;
|
||||
}
|
||||
|
||||
CHECK_VALIDITY_GOTO(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID, finish);
|
||||
}
|
||||
|
||||
if (n_formats == 0) {
|
||||
CHECK_VALIDITY_GOTO(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID, finish);
|
||||
CHECK_VALIDITY_GOTO(c->pstream, map.channels == ss.channels && volume.channels == ss.channels, tag, PA_ERR_INVALID, finish);
|
||||
CHECK_VALIDITY_GOTO(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID, finish);
|
||||
} else {
|
||||
PA_IDXSET_FOREACH(format, formats, i) {
|
||||
|
|
@ -2386,7 +2420,7 @@ static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uin
|
|||
(fail_on_suspend ? PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND|PA_SOURCE_OUTPUT_KILL_ON_SUSPEND : 0) |
|
||||
(passthrough ? PA_SOURCE_OUTPUT_PASSTHROUGH : 0);
|
||||
|
||||
s = record_stream_new(c, source, &ss, &map, formats, &attr, flags, p, adjust_latency, early_requests, peak_detect, direct_on_input, &ret);
|
||||
s = record_stream_new(c, source, &ss, &map, formats, &attr, volume_set ? &volume : NULL, muted, muted_set, flags, p, adjust_latency, early_requests, relative_volume, peak_detect, direct_on_input, &ret);
|
||||
|
||||
CHECK_VALIDITY_GOTO(c->pstream, s, tag, ret, finish);
|
||||
|
||||
|
|
@ -3249,12 +3283,20 @@ static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t,
|
|||
static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
|
||||
pa_sample_spec fixed_ss;
|
||||
pa_usec_t source_latency;
|
||||
pa_cvolume v;
|
||||
pa_bool_t has_volume = FALSE;
|
||||
|
||||
pa_assert(t);
|
||||
pa_source_output_assert_ref(s);
|
||||
|
||||
fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
|
||||
|
||||
has_volume = pa_source_output_is_volume_readable(s);
|
||||
if (has_volume)
|
||||
pa_source_output_get_volume(s, &v, TRUE);
|
||||
else
|
||||
pa_cvolume_reset(&v, fixed_ss.channels);
|
||||
|
||||
pa_tagstruct_putu32(t, s->index);
|
||||
pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
|
||||
pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
|
||||
|
|
@ -3270,6 +3312,12 @@ static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *
|
|||
pa_tagstruct_put_proplist(t, s->proplist);
|
||||
if (c->version >= 19)
|
||||
pa_tagstruct_put_boolean(t, (pa_source_output_get_state(s) == PA_SOURCE_OUTPUT_CORKED));
|
||||
if (c->version >= 22) {
|
||||
pa_tagstruct_put_cvolume(t, &v);
|
||||
pa_tagstruct_put_boolean(t, pa_source_output_get_mute(s));
|
||||
pa_tagstruct_put_boolean(t, has_volume);
|
||||
pa_tagstruct_put_boolean(t, s->volume_writable);
|
||||
}
|
||||
}
|
||||
|
||||
static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
|
||||
|
|
@ -3564,6 +3612,7 @@ static void command_set_volume(
|
|||
pa_sink *sink = NULL;
|
||||
pa_source *source = NULL;
|
||||
pa_sink_input *si = NULL;
|
||||
pa_source_output *so = NULL;
|
||||
const char *name = NULL;
|
||||
const char *client_name;
|
||||
|
||||
|
|
@ -3606,11 +3655,15 @@ static void command_set_volume(
|
|||
si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
|
||||
break;
|
||||
|
||||
case PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME:
|
||||
so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
|
||||
break;
|
||||
|
||||
default:
|
||||
pa_assert_not_reached();
|
||||
}
|
||||
|
||||
CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
|
||||
CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
|
||||
|
||||
client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
|
||||
|
||||
|
|
@ -3623,7 +3676,7 @@ static void command_set_volume(
|
|||
CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &source->sample_spec), tag, PA_ERR_INVALID);
|
||||
|
||||
pa_log_debug("Client %s changes volume of source %s.", client_name, source->name);
|
||||
pa_source_set_volume(source, &volume, TRUE);
|
||||
pa_source_set_volume(source, &volume, TRUE, TRUE);
|
||||
} else if (si) {
|
||||
CHECK_VALIDITY(c->pstream, si->volume_writable, tag, PA_ERR_BADSTATE);
|
||||
CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &si->sample_spec), tag, PA_ERR_INVALID);
|
||||
|
|
@ -3632,6 +3685,13 @@ static void command_set_volume(
|
|||
client_name,
|
||||
pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
|
||||
pa_sink_input_set_volume(si, &volume, TRUE, TRUE);
|
||||
} else if (so) {
|
||||
CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &so->sample_spec), tag, PA_ERR_INVALID);
|
||||
|
||||
pa_log_debug("Client %s changes volume of source output %s.",
|
||||
client_name,
|
||||
pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
|
||||
pa_source_output_set_volume(so, &volume, TRUE, TRUE);
|
||||
}
|
||||
|
||||
pa_pstream_send_simple_ack(c->pstream, tag);
|
||||
|
|
@ -3650,6 +3710,7 @@ static void command_set_mute(
|
|||
pa_sink *sink = NULL;
|
||||
pa_source *source = NULL;
|
||||
pa_sink_input *si = NULL;
|
||||
pa_source_output *so = NULL;
|
||||
const char *name = NULL, *client_name;
|
||||
|
||||
pa_native_connection_assert_ref(c);
|
||||
|
|
@ -3692,11 +3753,15 @@ static void command_set_mute(
|
|||
si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
|
||||
break;
|
||||
|
||||
case PA_COMMAND_SET_SOURCE_OUTPUT_MUTE:
|
||||
so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
|
||||
break;
|
||||
|
||||
default:
|
||||
pa_assert_not_reached();
|
||||
}
|
||||
|
||||
CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY);
|
||||
CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
|
||||
|
||||
client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
|
||||
|
||||
|
|
@ -3711,6 +3776,11 @@ static void command_set_mute(
|
|||
client_name,
|
||||
pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
|
||||
pa_sink_input_set_mute(si, mute, TRUE);
|
||||
} else if (so) {
|
||||
pa_log_debug("Client %s changes mute of source output %s.",
|
||||
client_name,
|
||||
pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
|
||||
pa_source_output_set_mute(so, mute, TRUE);
|
||||
}
|
||||
|
||||
pa_pstream_send_simple_ack(c->pstream, tag);
|
||||
|
|
|
|||
|
|
@ -24,9 +24,9 @@
|
|||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include <pulse/introspect.h>
|
||||
#include <pulse/utf8.h>
|
||||
|
|
@ -2616,6 +2616,7 @@ pa_usec_t pa_sink_get_requested_latency(pa_sink *s) {
|
|||
return 0;
|
||||
|
||||
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_REQUESTED_LATENCY, &usec, 0, NULL) == 0);
|
||||
|
||||
return usec;
|
||||
}
|
||||
|
||||
|
|
@ -2873,8 +2874,8 @@ void pa_sink_set_fixed_latency_within_thread(pa_sink *s, pa_usec_t latency) {
|
|||
/* Called from main context */
|
||||
size_t pa_sink_get_max_rewind(pa_sink *s) {
|
||||
size_t r;
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_ctl_context();
|
||||
pa_sink_assert_ref(s);
|
||||
|
||||
if (!PA_SINK_IS_LINKED(s->state))
|
||||
return s->thread_info.max_rewind;
|
||||
|
|
@ -2902,6 +2903,7 @@ size_t pa_sink_get_max_request(pa_sink *s) {
|
|||
int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
|
||||
pa_device_port *port;
|
||||
int ret;
|
||||
|
||||
pa_sink_assert_ref(s);
|
||||
pa_assert_ctl_context();
|
||||
|
||||
|
|
|
|||
|
|
@ -45,6 +45,7 @@
|
|||
PA_DEFINE_PUBLIC_CLASS(pa_source_output, pa_msgobject);
|
||||
|
||||
static void source_output_free(pa_object* mo);
|
||||
static void set_real_ratio(pa_source_output *o, const pa_cvolume *v);
|
||||
|
||||
pa_source_output_new_data* pa_source_output_new_data_init(pa_source_output_new_data *data) {
|
||||
pa_assert(data);
|
||||
|
|
@ -52,6 +53,7 @@ pa_source_output_new_data* pa_source_output_new_data_init(pa_source_output_new_d
|
|||
pa_zero(*data);
|
||||
data->resample_method = PA_RESAMPLER_INVALID;
|
||||
data->proplist = pa_proplist_new();
|
||||
data->volume_writable = TRUE;
|
||||
|
||||
return data;
|
||||
}
|
||||
|
|
@ -82,6 +84,45 @@ pa_bool_t pa_source_output_new_data_is_passthrough(pa_source_output_new_data *da
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
void pa_source_output_new_data_set_volume(pa_source_output_new_data *data, const pa_cvolume *volume) {
|
||||
pa_assert(data);
|
||||
pa_assert(data->volume_writable);
|
||||
|
||||
if ((data->volume_is_set = !!volume))
|
||||
data->volume = *volume;
|
||||
}
|
||||
|
||||
void pa_source_output_new_data_apply_volume_factor(pa_source_output_new_data *data, const pa_cvolume *volume_factor) {
|
||||
pa_assert(data);
|
||||
pa_assert(volume_factor);
|
||||
|
||||
if (data->volume_factor_is_set)
|
||||
pa_sw_cvolume_multiply(&data->volume_factor, &data->volume_factor, volume_factor);
|
||||
else {
|
||||
data->volume_factor_is_set = TRUE;
|
||||
data->volume_factor = *volume_factor;
|
||||
}
|
||||
}
|
||||
|
||||
void pa_source_output_new_data_apply_volume_factor_source(pa_source_output_new_data *data, const pa_cvolume *volume_factor) {
|
||||
pa_assert(data);
|
||||
pa_assert(volume_factor);
|
||||
|
||||
if (data->volume_factor_source_is_set)
|
||||
pa_sw_cvolume_multiply(&data->volume_factor_source, &data->volume_factor_source, volume_factor);
|
||||
else {
|
||||
data->volume_factor_source_is_set = TRUE;
|
||||
data->volume_factor_source = *volume_factor;
|
||||
}
|
||||
}
|
||||
|
||||
void pa_source_output_new_data_set_muted(pa_source_output_new_data *data, pa_bool_t mute) {
|
||||
pa_assert(data);
|
||||
|
||||
data->muted_is_set = TRUE;
|
||||
data->muted = !!mute;
|
||||
}
|
||||
|
||||
pa_bool_t pa_source_output_new_data_set_source(pa_source_output_new_data *data, pa_source *s, pa_bool_t save) {
|
||||
pa_bool_t ret = TRUE;
|
||||
pa_idxset *formats = NULL;
|
||||
|
|
@ -167,6 +208,8 @@ static void reset_callbacks(pa_source_output *o) {
|
|||
o->state_change = NULL;
|
||||
o->may_move_to = NULL;
|
||||
o->send_event = NULL;
|
||||
o->volume_changed = NULL;
|
||||
o->mute_changed = NULL;
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
|
|
@ -192,6 +235,9 @@ int pa_source_output_new(
|
|||
if (data->client)
|
||||
pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->client->proplist);
|
||||
|
||||
if (data->destination_source && (data->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
|
||||
data->volume_writable = FALSE;
|
||||
|
||||
if (!data->req_formats) {
|
||||
/* From this point on, we want to work only with formats, and get back
|
||||
* to using the sample spec and channel map after all decisions w.r.t.
|
||||
|
|
@ -250,6 +296,33 @@ int pa_source_output_new(
|
|||
|
||||
pa_return_val_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec), -PA_ERR_INVALID);
|
||||
|
||||
/* Don't restore (or save) stream volume for passthrough streams */
|
||||
if (!pa_format_info_is_pcm(data->format)) {
|
||||
data->volume_is_set = FALSE;
|
||||
data->volume_factor_is_set = FALSE;
|
||||
}
|
||||
|
||||
if (!data->volume_is_set) {
|
||||
pa_cvolume_reset(&data->volume, data->sample_spec.channels);
|
||||
data->volume_is_absolute = FALSE;
|
||||
data->save_volume = FALSE;
|
||||
}
|
||||
|
||||
pa_return_val_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec), -PA_ERR_INVALID);
|
||||
|
||||
if (!data->volume_factor_is_set)
|
||||
pa_cvolume_reset(&data->volume_factor, data->sample_spec.channels);
|
||||
|
||||
pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor, &data->sample_spec), -PA_ERR_INVALID);
|
||||
|
||||
if (!data->volume_factor_source_is_set)
|
||||
pa_cvolume_reset(&data->volume_factor_source, data->source->sample_spec.channels);
|
||||
|
||||
pa_return_val_if_fail(pa_cvolume_compatible(&data->volume_factor_source, &data->source->sample_spec), -PA_ERR_INVALID);
|
||||
|
||||
if (!data->muted_is_set)
|
||||
data->muted = FALSE;
|
||||
|
||||
if (data->flags & PA_SOURCE_OUTPUT_FIX_FORMAT)
|
||||
data->sample_spec.format = data->source->sample_spec.format;
|
||||
|
||||
|
|
@ -266,6 +339,9 @@ int pa_source_output_new(
|
|||
pa_assert(pa_sample_spec_valid(&data->sample_spec));
|
||||
pa_assert(pa_channel_map_valid(&data->channel_map));
|
||||
|
||||
/* Due to the fixing of the sample spec the volume might not match anymore */
|
||||
pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
|
||||
|
||||
if (data->resample_method == PA_RESAMPLER_INVALID)
|
||||
data->resample_method = core->resample_method;
|
||||
|
||||
|
|
@ -324,6 +400,39 @@ int pa_source_output_new(
|
|||
o->channel_map = data->channel_map;
|
||||
o->format = pa_format_info_copy(data->format);
|
||||
|
||||
if (!data->volume_is_absolute && pa_source_flat_volume_enabled(o->source)) {
|
||||
pa_cvolume remapped;
|
||||
|
||||
/* When the 'absolute' bool is not set then we'll treat the volume
|
||||
* as relative to the source volume even in flat volume mode */
|
||||
remapped = data->source->reference_volume;
|
||||
pa_cvolume_remap(&remapped, &data->source->channel_map, &data->channel_map);
|
||||
pa_sw_cvolume_multiply(&o->volume, &data->volume, &remapped);
|
||||
} else
|
||||
o->volume = data->volume;
|
||||
|
||||
o->volume_factor = data->volume_factor;
|
||||
o->volume_factor_source = data->volume_factor_source;
|
||||
o->real_ratio = o->reference_ratio = data->volume;
|
||||
pa_cvolume_reset(&o->soft_volume, o->sample_spec.channels);
|
||||
pa_cvolume_reset(&o->real_ratio, o->sample_spec.channels);
|
||||
o->volume_writable = data->volume_writable;
|
||||
o->save_volume = data->save_volume;
|
||||
o->save_source = data->save_source;
|
||||
o->save_muted = data->save_muted;
|
||||
|
||||
o->muted = data->muted;
|
||||
|
||||
if (data->sync_base) {
|
||||
o->sync_next = data->sync_base->sync_next;
|
||||
o->sync_prev = data->sync_base;
|
||||
|
||||
if (data->sync_base->sync_next)
|
||||
data->sync_base->sync_next->sync_prev = o;
|
||||
data->sync_base->sync_next = o;
|
||||
} else
|
||||
o->sync_next = o->sync_prev = NULL;
|
||||
|
||||
o->direct_on_input = data->direct_on_input;
|
||||
|
||||
reset_callbacks(o);
|
||||
|
|
@ -333,6 +442,8 @@ int pa_source_output_new(
|
|||
o->thread_info.attached = FALSE;
|
||||
o->thread_info.sample_spec = o->sample_spec;
|
||||
o->thread_info.resampler = resampler;
|
||||
o->thread_info.soft_volume = o->soft_volume;
|
||||
o->thread_info.muted = o->muted;
|
||||
o->thread_info.requested_source_latency = (pa_usec_t) -1;
|
||||
o->thread_info.direct_on_input = o->direct_on_input;
|
||||
|
||||
|
|
@ -387,6 +498,7 @@ static void update_n_corked(pa_source_output *o, pa_source_output_state_t state)
|
|||
|
||||
/* Called from main context */
|
||||
static void source_output_set_state(pa_source_output *o, pa_source_output_state_t state) {
|
||||
pa_source_output *ssync;
|
||||
pa_assert(o);
|
||||
pa_assert_ctl_context();
|
||||
|
||||
|
|
@ -398,9 +510,24 @@ static void source_output_set_state(pa_source_output *o, pa_source_output_state_
|
|||
update_n_corked(o, state);
|
||||
o->state = state;
|
||||
|
||||
for (ssync = o->sync_prev; ssync; ssync = ssync->sync_prev) {
|
||||
update_n_corked(ssync, state);
|
||||
ssync->state = state;
|
||||
}
|
||||
for (ssync = o->sync_next; ssync; ssync = ssync->sync_next) {
|
||||
update_n_corked(ssync, state);
|
||||
ssync->state = state;
|
||||
}
|
||||
|
||||
if (state != PA_SOURCE_OUTPUT_UNLINKED) {
|
||||
pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_STATE_CHANGED], o);
|
||||
|
||||
for (ssync = o->sync_prev; ssync; ssync = ssync->sync_prev)
|
||||
pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_STATE_CHANGED], ssync);
|
||||
|
||||
for (ssync = o->sync_next; ssync; ssync = ssync->sync_next)
|
||||
pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_STATE_CHANGED], ssync);
|
||||
|
||||
if (PA_SOURCE_OUTPUT_IS_LINKED(state))
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
|
||||
}
|
||||
|
|
@ -424,6 +551,13 @@ void pa_source_output_unlink(pa_source_output*o) {
|
|||
if (linked)
|
||||
pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK], o);
|
||||
|
||||
if (o->sync_prev)
|
||||
o->sync_prev->sync_next = o->sync_next;
|
||||
if (o->sync_next)
|
||||
o->sync_next->sync_prev = o->sync_prev;
|
||||
|
||||
o->sync_prev = o->sync_next = NULL;
|
||||
|
||||
if (o->direct_on_input)
|
||||
pa_idxset_remove_by_data(o->direct_on_input->direct_outputs, o, NULL);
|
||||
|
||||
|
|
@ -439,9 +573,14 @@ void pa_source_output_unlink(pa_source_output*o) {
|
|||
update_n_corked(o, PA_SOURCE_OUTPUT_UNLINKED);
|
||||
o->state = PA_SOURCE_OUTPUT_UNLINKED;
|
||||
|
||||
if (linked && o->source)
|
||||
if (linked && o->source) {
|
||||
/* We might need to update the source's volume if we are in flat volume mode. */
|
||||
if (pa_source_flat_volume_enabled(o->source))
|
||||
pa_source_set_volume(o->source, NULL, FALSE, FALSE);
|
||||
|
||||
if (o->source->asyncmsgq)
|
||||
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_REMOVE_OUTPUT, o, 0, NULL) == 0);
|
||||
}
|
||||
|
||||
reset_callbacks(o);
|
||||
|
||||
|
|
@ -507,6 +646,21 @@ void pa_source_output_put(pa_source_output *o) {
|
|||
update_n_corked(o, state);
|
||||
o->state = state;
|
||||
|
||||
/* We might need to update the source's volume if we are in flat volume mode. */
|
||||
if (pa_source_flat_volume_enabled(o->source))
|
||||
pa_source_set_volume(o->source, NULL, FALSE, o->save_volume);
|
||||
else {
|
||||
if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
|
||||
pa_assert(pa_cvolume_is_norm(&o->volume));
|
||||
pa_assert(pa_cvolume_is_norm(&o->reference_ratio));
|
||||
}
|
||||
|
||||
set_real_ratio(o, &o->volume);
|
||||
}
|
||||
|
||||
o->thread_info.soft_volume = o->soft_volume;
|
||||
o->thread_info.muted = o->muted;
|
||||
|
||||
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_ADD_OUTPUT, o, 0, NULL) == 0);
|
||||
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_NEW, o->index);
|
||||
|
|
@ -545,6 +699,8 @@ pa_usec_t pa_source_output_get_latency(pa_source_output *o, pa_usec_t *source_la
|
|||
|
||||
/* Called from thread context */
|
||||
void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
|
||||
pa_bool_t need_volume_factor_source;
|
||||
pa_bool_t volume_is_norm;
|
||||
size_t length;
|
||||
size_t limit, mbs = 0;
|
||||
|
||||
|
|
@ -566,6 +722,9 @@ void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
|
|||
|
||||
limit = o->process_rewind ? 0 : o->source->thread_info.max_rewind;
|
||||
|
||||
volume_is_norm = pa_cvolume_is_norm(&o->thread_info.soft_volume) && !o->thread_info.muted;
|
||||
need_volume_factor_source = !pa_cvolume_is_norm(&o->volume_factor_source);
|
||||
|
||||
if (limit > 0 && o->source->monitor_of) {
|
||||
pa_usec_t latency;
|
||||
size_t n;
|
||||
|
|
@ -588,6 +747,7 @@ void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
|
|||
/* Implement the delay queue */
|
||||
while ((length = pa_memblockq_get_length(o->thread_info.delay_memblockq)) > limit) {
|
||||
pa_memchunk qchunk;
|
||||
pa_bool_t nvfs = need_volume_factor_source;
|
||||
|
||||
length -= limit;
|
||||
|
||||
|
|
@ -598,9 +758,36 @@ void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
|
|||
|
||||
pa_assert(qchunk.length > 0);
|
||||
|
||||
if (!o->thread_info.resampler)
|
||||
/* It might be necessary to adjust the volume here */
|
||||
if (!volume_is_norm) {
|
||||
pa_memchunk_make_writable(&qchunk, 0);
|
||||
|
||||
if (o->thread_info.muted) {
|
||||
pa_silence_memchunk(&qchunk, &o->thread_info.sample_spec);
|
||||
nvfs = FALSE;
|
||||
|
||||
} else if (!o->thread_info.resampler && nvfs) {
|
||||
pa_cvolume v;
|
||||
|
||||
/* If we don't need a resampler we can merge the
|
||||
* post and the pre volume adjustment into one */
|
||||
|
||||
pa_sw_cvolume_multiply(&v, &o->thread_info.soft_volume, &o->volume_factor_source);
|
||||
pa_volume_memchunk(&qchunk, &o->thread_info.sample_spec, &v);
|
||||
nvfs = FALSE;
|
||||
|
||||
} else
|
||||
pa_volume_memchunk(&qchunk, &o->thread_info.sample_spec, &o->thread_info.soft_volume);
|
||||
}
|
||||
|
||||
if (!o->thread_info.resampler) {
|
||||
if (nvfs) {
|
||||
pa_memchunk_make_writable(&qchunk, 0);
|
||||
pa_volume_memchunk(&qchunk, &o->source->sample_spec, &o->volume_factor_source);
|
||||
}
|
||||
|
||||
o->push(o, &qchunk);
|
||||
else {
|
||||
} else {
|
||||
pa_memchunk rchunk;
|
||||
|
||||
if (mbs == 0)
|
||||
|
|
@ -611,8 +798,14 @@ void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
|
|||
|
||||
pa_resampler_run(o->thread_info.resampler, &qchunk, &rchunk);
|
||||
|
||||
if (rchunk.length > 0)
|
||||
if (rchunk.length > 0) {
|
||||
if (nvfs) {
|
||||
pa_memchunk_make_writable(&rchunk, 0);
|
||||
pa_volume_memchunk(&rchunk, &o->source->sample_spec, &o->volume_factor_source);
|
||||
}
|
||||
|
||||
o->push(o, &rchunk);
|
||||
}
|
||||
|
||||
if (rchunk.memblock)
|
||||
pa_memblock_unref(rchunk.memblock);
|
||||
|
|
@ -786,6 +979,85 @@ void pa_source_output_set_name(pa_source_output *o, const char *name) {
|
|||
}
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
void pa_source_output_set_volume(pa_source_output *o, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute) {
|
||||
pa_cvolume v;
|
||||
|
||||
pa_source_output_assert_ref(o);
|
||||
pa_assert_ctl_context();
|
||||
pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state));
|
||||
pa_assert(volume);
|
||||
pa_assert(pa_cvolume_valid(volume));
|
||||
pa_assert(volume->channels == 1 || pa_cvolume_compatible(volume, &o->sample_spec));
|
||||
pa_assert(o->volume_writable);
|
||||
|
||||
if (!absolute && pa_source_flat_volume_enabled(o->source)) {
|
||||
v = o->source->reference_volume;
|
||||
pa_cvolume_remap(&v, &o->source->channel_map, &o->channel_map);
|
||||
|
||||
if (pa_cvolume_compatible(volume, &o->sample_spec))
|
||||
volume = pa_sw_cvolume_multiply(&v, &v, volume);
|
||||
else
|
||||
volume = pa_sw_cvolume_multiply_scalar(&v, &v, pa_cvolume_max(volume));
|
||||
} else {
|
||||
if (!pa_cvolume_compatible(volume, &o->sample_spec)) {
|
||||
v = o->volume;
|
||||
volume = pa_cvolume_scale(&v, pa_cvolume_max(volume));
|
||||
}
|
||||
}
|
||||
|
||||
if (pa_cvolume_equal(volume, &o->volume)) {
|
||||
o->save_volume = o->save_volume || save;
|
||||
return;
|
||||
}
|
||||
|
||||
o->volume = *volume;
|
||||
o->save_volume = save;
|
||||
|
||||
if (pa_source_flat_volume_enabled(o->source)) {
|
||||
/* We are in flat volume mode, so let's update all source input
|
||||
* volumes and update the flat volume of the source */
|
||||
|
||||
pa_source_set_volume(o->source, NULL, TRUE, save);
|
||||
|
||||
} else {
|
||||
/* OK, we are in normal volume mode. The volume only affects
|
||||
* ourselves */
|
||||
set_real_ratio(o, volume);
|
||||
|
||||
/* Copy the new soft_volume to the thread_info struct */
|
||||
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o), PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0);
|
||||
}
|
||||
|
||||
/* The volume changed, let's tell people so */
|
||||
if (o->volume_changed)
|
||||
o->volume_changed(o);
|
||||
|
||||
/* The virtual volume changed, let's tell people so */
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
static void set_real_ratio(pa_source_output *o, const pa_cvolume *v) {
|
||||
pa_source_output_assert_ref(o);
|
||||
pa_assert_ctl_context();
|
||||
pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state));
|
||||
pa_assert(!v || pa_cvolume_compatible(v, &o->sample_spec));
|
||||
|
||||
/* This basically calculates:
|
||||
*
|
||||
* o->real_ratio := v
|
||||
* o->soft_volume := o->real_ratio * o->volume_factor */
|
||||
|
||||
if (v)
|
||||
o->real_ratio = *v;
|
||||
else
|
||||
pa_cvolume_reset(&o->real_ratio, o->sample_spec.channels);
|
||||
|
||||
pa_sw_cvolume_multiply(&o->soft_volume, &o->real_ratio, &o->volume_factor);
|
||||
/* We don't copy the data to the thread_info data. That's left for someone else to do */
|
||||
}
|
||||
|
||||
/* Called from main or I/O context */
|
||||
pa_bool_t pa_source_output_is_passthrough(pa_source_output *o) {
|
||||
pa_source_output_assert_ref(o);
|
||||
|
|
@ -799,6 +1071,61 @@ pa_bool_t pa_source_output_is_passthrough(pa_source_output *o) {
|
|||
return FALSE;
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
pa_bool_t pa_source_output_is_volume_readable(pa_source_output *o) {
|
||||
pa_source_output_assert_ref(o);
|
||||
pa_assert_ctl_context();
|
||||
|
||||
return !pa_source_output_is_passthrough(o);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
pa_cvolume *pa_source_output_get_volume(pa_source_output *o, pa_cvolume *volume, pa_bool_t absolute) {
|
||||
pa_source_output_assert_ref(o);
|
||||
pa_assert_ctl_context();
|
||||
pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state));
|
||||
pa_assert(pa_source_output_is_volume_readable(o));
|
||||
|
||||
if (absolute || !pa_source_flat_volume_enabled(o->source))
|
||||
*volume = o->volume;
|
||||
else
|
||||
*volume = o->reference_ratio;
|
||||
|
||||
return volume;
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
void pa_source_output_set_mute(pa_source_output *o, pa_bool_t mute, pa_bool_t save) {
|
||||
pa_source_output_assert_ref(o);
|
||||
pa_assert_ctl_context();
|
||||
pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state));
|
||||
|
||||
if (!o->muted == !mute) {
|
||||
o->save_muted = o->save_muted || mute;
|
||||
return;
|
||||
}
|
||||
|
||||
o->muted = mute;
|
||||
o->save_muted = save;
|
||||
|
||||
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o), PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0);
|
||||
|
||||
/* The mute status changed, let's tell people so */
|
||||
if (o->mute_changed)
|
||||
o->mute_changed(o);
|
||||
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
pa_bool_t pa_source_output_get_mute(pa_source_output *o) {
|
||||
pa_source_output_assert_ref(o);
|
||||
pa_assert_ctl_context();
|
||||
pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state));
|
||||
|
||||
return o->muted;
|
||||
}
|
||||
|
||||
/* Called from main thread */
|
||||
void pa_source_output_update_proplist(pa_source_output *o, pa_update_mode_t mode, pa_proplist *p) {
|
||||
pa_source_output_assert_ref(o);
|
||||
|
|
@ -833,6 +1160,11 @@ pa_bool_t pa_source_output_may_move(pa_source_output *o) {
|
|||
if (o->direct_on_input)
|
||||
return FALSE;
|
||||
|
||||
if (o->sync_next || o->sync_prev) {
|
||||
pa_log_warn("Moving synchronized streams not supported.");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -883,6 +1215,11 @@ int pa_source_output_start_move(pa_source_output *o) {
|
|||
if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED)
|
||||
pa_assert_se(origin->n_corked-- >= 1);
|
||||
|
||||
if (pa_source_flat_volume_enabled(o->source))
|
||||
/* We might need to update the source's volume if we are in flat
|
||||
* volume mode. */
|
||||
pa_source_set_volume(o->source, NULL, FALSE, FALSE);
|
||||
|
||||
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_REMOVE_OUTPUT, o, 0, NULL) == 0);
|
||||
|
||||
pa_source_update_status(o->source);
|
||||
|
|
@ -893,6 +1230,156 @@ int pa_source_output_start_move(pa_source_output *o) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* Called from main context. If it has an origin source that uses volume sharing,
|
||||
* then also the origin source and all streams connected to it need to update
|
||||
* their volume - this function does all that by using recursion. */
|
||||
static void update_volume_due_to_moving(pa_source_output *o, pa_source *dest) {
|
||||
pa_cvolume old_volume;
|
||||
|
||||
pa_assert(o);
|
||||
pa_assert(dest);
|
||||
pa_assert(o->source); /* The destination source should already be set. */
|
||||
|
||||
if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
|
||||
pa_source *root_source = o->source;
|
||||
pa_source_output *destination_source_output;
|
||||
uint32_t idx;
|
||||
|
||||
while (root_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
|
||||
root_source = root_source->output_from_master->source;
|
||||
|
||||
if (pa_source_flat_volume_enabled(o->source)) {
|
||||
/* Ok, so the origin source uses volume sharing, and flat volume is
|
||||
* enabled. The volume will have to be updated as follows:
|
||||
*
|
||||
* o->volume := o->source->real_volume
|
||||
* (handled later by pa_source_set_volume)
|
||||
* o->reference_ratio := o->volume / o->source->reference_volume
|
||||
* (handled later by pa_source_set_volume)
|
||||
* o->real_ratio stays unchanged
|
||||
* (streams whose origin source uses volume sharing should
|
||||
* always have real_ratio of 0 dB)
|
||||
* o->soft_volume stays unchanged
|
||||
* (streams whose origin source uses volume sharing should
|
||||
* always have volume_factor as soft_volume, so no change
|
||||
* should be needed) */
|
||||
|
||||
pa_assert(pa_cvolume_is_norm(&o->real_ratio));
|
||||
pa_assert(pa_cvolume_equal(&o->soft_volume, &o->volume_factor));
|
||||
|
||||
/* Notifications will be sent by pa_source_set_volume(). */
|
||||
|
||||
} else {
|
||||
/* Ok, so the origin source uses volume sharing, and flat volume is
|
||||
* disabled. The volume will have to be updated as follows:
|
||||
*
|
||||
* o->volume := 0 dB
|
||||
* o->reference_ratio := 0 dB
|
||||
* o->real_ratio stays unchanged
|
||||
* (streams whose origin source uses volume sharing should
|
||||
* always have real_ratio of 0 dB)
|
||||
* o->soft_volume stays unchanged
|
||||
* (streams whose origin source uses volume sharing should
|
||||
* always have volume_factor as soft_volume, so no change
|
||||
* should be needed) */
|
||||
|
||||
old_volume = o->volume;
|
||||
pa_cvolume_reset(&o->volume, o->volume.channels);
|
||||
pa_cvolume_reset(&o->reference_ratio, o->reference_ratio.channels);
|
||||
pa_assert(pa_cvolume_is_norm(&o->real_ratio));
|
||||
pa_assert(pa_cvolume_equal(&o->soft_volume, &o->volume_factor));
|
||||
|
||||
/* Notify others about the changed source output volume. */
|
||||
if (!pa_cvolume_equal(&o->volume, &old_volume)) {
|
||||
if (o->volume_changed)
|
||||
o->volume_changed(o);
|
||||
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
|
||||
}
|
||||
}
|
||||
|
||||
/* Additionally, the origin source volume needs updating:
|
||||
*
|
||||
* o->destination_source->reference_volume := root_source->reference_volume
|
||||
* o->destination_source->real_volume := root_source->real_volume
|
||||
* o->destination_source->soft_volume stays unchanged
|
||||
* (sources that use volume sharing should always have
|
||||
* soft_volume of 0 dB) */
|
||||
|
||||
old_volume = o->destination_source->reference_volume;
|
||||
|
||||
o->destination_source->reference_volume = root_source->reference_volume;
|
||||
pa_cvolume_remap(&o->destination_source->reference_volume, &root_source->channel_map, &o->destination_source->channel_map);
|
||||
|
||||
o->destination_source->real_volume = root_source->real_volume;
|
||||
pa_cvolume_remap(&o->destination_source->real_volume, &root_source->channel_map, &o->destination_source->channel_map);
|
||||
|
||||
pa_assert(pa_cvolume_is_norm(&o->destination_source->soft_volume));
|
||||
|
||||
/* Notify others about the changed source volume. If you wonder whether
|
||||
* o->destination_source->set_volume() should be called somewhere, that's not
|
||||
* the case, because sources that use volume sharing shouldn't have any
|
||||
* internal volume that set_volume() would update. If you wonder
|
||||
* whether the thread_info variables should be synced, yes, they
|
||||
* should, and it's done by the PA_SOURCE_MESSAGE_FINISH_MOVE message
|
||||
* handler. */
|
||||
if (!pa_cvolume_equal(&o->destination_source->reference_volume, &old_volume))
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, o->destination_source->index);
|
||||
|
||||
/* Recursively update origin source outputs. */
|
||||
PA_IDXSET_FOREACH(destination_source_output, o->destination_source->outputs, idx)
|
||||
update_volume_due_to_moving(destination_source_output, dest);
|
||||
|
||||
} else {
|
||||
old_volume = o->volume;
|
||||
|
||||
if (pa_source_flat_volume_enabled(o->source)) {
|
||||
/* Ok, so this is a regular stream, and flat volume is enabled. The
|
||||
* volume will have to be updated as follows:
|
||||
*
|
||||
* o->volume := o->reference_ratio * o->source->reference_volume
|
||||
* o->reference_ratio stays unchanged
|
||||
* o->real_ratio := o->volume / o->source->real_volume
|
||||
* (handled later by pa_source_set_volume)
|
||||
* o->soft_volume := o->real_ratio * o->volume_factor
|
||||
* (handled later by pa_source_set_volume) */
|
||||
|
||||
o->volume = o->source->reference_volume;
|
||||
pa_cvolume_remap(&o->volume, &o->source->channel_map, &o->channel_map);
|
||||
pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
|
||||
|
||||
} else {
|
||||
/* Ok, so this is a regular stream, and flat volume is disabled.
|
||||
* The volume will have to be updated as follows:
|
||||
*
|
||||
* o->volume := o->reference_ratio
|
||||
* o->reference_ratio stays unchanged
|
||||
* o->real_ratio := o->reference_ratio
|
||||
* o->soft_volume := o->real_ratio * o->volume_factor */
|
||||
|
||||
o->volume = o->reference_ratio;
|
||||
o->real_ratio = o->reference_ratio;
|
||||
pa_sw_cvolume_multiply(&o->soft_volume, &o->real_ratio, &o->volume_factor);
|
||||
}
|
||||
|
||||
/* Notify others about the changed source output volume. */
|
||||
if (!pa_cvolume_equal(&o->volume, &old_volume)) {
|
||||
/* XXX: In case o->source has flat volume enabled, then real_ratio
|
||||
* and soft_volume are not updated yet. Let's hope that the
|
||||
* callback implementation doesn't care about those variables... */
|
||||
if (o->volume_changed)
|
||||
o->volume_changed(o);
|
||||
|
||||
pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
|
||||
}
|
||||
}
|
||||
|
||||
/* If o->source == dest, then recursion has finished, and we can finally call
|
||||
* pa_source_set_volume(), which will do the rest of the updates. */
|
||||
if ((o->source == dest) && pa_source_flat_volume_enabled(o->source))
|
||||
pa_source_set_volume(o->source, NULL, FALSE, o->save_volume);
|
||||
}
|
||||
|
||||
/* Called from main context */
|
||||
int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, pa_bool_t save) {
|
||||
pa_resampler *new_resampler;
|
||||
|
|
@ -951,11 +1438,14 @@ int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, pa_bool_t
|
|||
o->save_source = save;
|
||||
pa_idxset_put(o->source->outputs, pa_source_output_ref(o), NULL);
|
||||
|
||||
pa_cvolume_remap(&o->volume_factor_source, &o->channel_map, &o->source->channel_map);
|
||||
|
||||
if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED)
|
||||
o->source->n_corked++;
|
||||
|
||||
/* Replace resampler */
|
||||
if (new_resampler != o->thread_info.resampler) {
|
||||
|
||||
if (o->thread_info.resampler)
|
||||
pa_resampler_free(o->thread_info.resampler);
|
||||
o->thread_info.resampler = new_resampler;
|
||||
|
|
@ -976,6 +1466,8 @@ int pa_source_output_finish_move(pa_source_output *o, pa_source *dest, pa_bool_t
|
|||
|
||||
pa_source_update_status(dest);
|
||||
|
||||
update_volume_due_to_moving(o, dest);
|
||||
|
||||
pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_ADD_OUTPUT, o, 0, NULL) == 0);
|
||||
|
||||
pa_log_debug("Successfully moved source output %i to %s.", o->index, dest->name);
|
||||
|
|
@ -1075,10 +1567,19 @@ int pa_source_output_process_msg(pa_msgobject *mo, int code, void *userdata, int
|
|||
pa_resampler_set_output_rate(o->thread_info.resampler, PA_PTR_TO_UINT(userdata));
|
||||
return 0;
|
||||
|
||||
case PA_SOURCE_OUTPUT_MESSAGE_SET_STATE:
|
||||
case PA_SOURCE_OUTPUT_MESSAGE_SET_STATE: {
|
||||
pa_source_output *ssync;
|
||||
|
||||
pa_source_output_set_state_within_thread(o, PA_PTR_TO_UINT(userdata));
|
||||
|
||||
for (ssync = o->thread_info.sync_prev; ssync; ssync = ssync->thread_info.sync_prev)
|
||||
pa_source_output_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
|
||||
|
||||
for (ssync = o->thread_info.sync_next; ssync; ssync = ssync->thread_info.sync_next)
|
||||
pa_source_output_set_state_within_thread(ssync, PA_PTR_TO_UINT(userdata));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
case PA_SOURCE_OUTPUT_MESSAGE_SET_REQUESTED_LATENCY: {
|
||||
pa_usec_t *usec = userdata;
|
||||
|
|
@ -1094,6 +1595,18 @@ int pa_source_output_process_msg(pa_msgobject *mo, int code, void *userdata, int
|
|||
*r = o->thread_info.requested_source_latency;
|
||||
return 0;
|
||||
}
|
||||
|
||||
case PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_VOLUME:
|
||||
if (!pa_cvolume_equal(&o->thread_info.soft_volume, &o->soft_volume)) {
|
||||
o->thread_info.soft_volume = o->soft_volume;
|
||||
}
|
||||
return 0;
|
||||
|
||||
case PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_MUTE:
|
||||
if (o->thread_info.muted != o->muted) {
|
||||
o->thread_info.muted = o->muted;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -PA_ERR_NOTIMPLEMENTED;
|
||||
|
|
|
|||
|
|
@ -86,10 +86,26 @@ struct pa_source_output {
|
|||
pa_channel_map channel_map;
|
||||
pa_format_info *format;
|
||||
|
||||
/* if TRUE then the source we are connected to is worth
|
||||
* remembering, i.e. was explicitly chosen by the user and not
|
||||
* automatically. module-stream-restore looks for this.*/
|
||||
pa_bool_t save_source:1;
|
||||
pa_source_output *sync_prev, *sync_next;
|
||||
|
||||
/* Also see http://pulseaudio.org/wiki/InternalVolumes */
|
||||
pa_cvolume volume; /* The volume clients are informed about */
|
||||
pa_cvolume reference_ratio; /* The ratio of the stream's volume to the source's reference volume */
|
||||
pa_cvolume real_ratio; /* The ratio of the stream's volume to the source's real volume */
|
||||
pa_cvolume volume_factor; /* An internally used volume factor that can be used by modules to apply effects and suchlike without having that visible to the outside */
|
||||
pa_cvolume soft_volume; /* The internal software volume we apply to all PCM data while it passes through. Usually calculated as real_ratio * volume_factor */
|
||||
|
||||
pa_cvolume volume_factor_source; /* A second volume factor in format of the source this stream is connected to */
|
||||
|
||||
pa_bool_t volume_writable:1;
|
||||
|
||||
pa_bool_t muted:1;
|
||||
|
||||
/* if TRUE then the source we are connected to and/or the volume
|
||||
* set is worth remembering, i.e. was explicitly chosen by the
|
||||
* user and not automatically. module-stream-restore looks for
|
||||
* this.*/
|
||||
pa_bool_t save_source:1, save_volume:1, save_muted:1;
|
||||
|
||||
pa_resample_method_t requested_resample_method, actual_resample_method;
|
||||
|
||||
|
|
@ -118,7 +134,10 @@ struct pa_source_output {
|
|||
void (*update_source_fixed_latency) (pa_source_output *i); /* may be NULL */
|
||||
|
||||
/* If non-NULL this function is called when the output is first
|
||||
* connected to a source. Called from IO thread context */
|
||||
* connected to a source or when the rtpoll/asyncmsgq fields
|
||||
* change. You usually don't need to implement this function
|
||||
* unless you rewrite a source that is piggy-backed onto
|
||||
* another. Called from IO thread context */
|
||||
void (*attach) (pa_source_output *o); /* may be NULL */
|
||||
|
||||
/* If non-NULL this function is called when the output is
|
||||
|
|
@ -134,9 +153,9 @@ struct pa_source_output {
|
|||
void (*suspend_within_thread) (pa_source_output *o, pa_bool_t b); /* may be NULL */
|
||||
|
||||
/* If non-NULL called whenever the source output is moved to a new
|
||||
* source. Called from main context after the stream was detached
|
||||
* from the old source and before it is attached to the new
|
||||
* source. If dest is NULL the move was executed in two
|
||||
* source. Called from main context after the source output has been
|
||||
* detached from the old source and before it has been attached to
|
||||
* the new source. If dest is NULL the move was executed in two
|
||||
* phases and the second one failed; the stream will be destroyed
|
||||
* after this call. */
|
||||
void (*moving) (pa_source_output *o, pa_source *dest); /* may be NULL */
|
||||
|
|
@ -164,9 +183,20 @@ struct pa_source_output {
|
|||
* control events. */
|
||||
void (*send_event)(pa_source_output *o, const char *event, pa_proplist* data);
|
||||
|
||||
/* If non-NULL this function is called whenever the source output
|
||||
* volume changes. Called from main context */
|
||||
void (*volume_changed)(pa_source_output *o); /* may be NULL */
|
||||
|
||||
/* If non-NULL this function is called whenever the source output
|
||||
* mute status changes. Called from main context */
|
||||
void (*mute_changed)(pa_source_output *o); /* may be NULL */
|
||||
|
||||
struct {
|
||||
pa_source_output_state_t state;
|
||||
|
||||
pa_cvolume soft_volume;
|
||||
pa_bool_t muted:1;
|
||||
|
||||
pa_bool_t attached:1; /* True only between ->attach() and ->detach() calls */
|
||||
|
||||
pa_sample_spec sample_spec;
|
||||
|
|
@ -177,6 +207,8 @@ struct pa_source_output {
|
|||
* don't implement rewind() */
|
||||
pa_memblockq *delay_memblockq;
|
||||
|
||||
pa_source_output *sync_prev, *sync_next;
|
||||
|
||||
/* The requested latency for the source */
|
||||
pa_usec_t requested_source_latency;
|
||||
|
||||
|
|
@ -195,6 +227,8 @@ enum {
|
|||
PA_SOURCE_OUTPUT_MESSAGE_SET_STATE,
|
||||
PA_SOURCE_OUTPUT_MESSAGE_SET_REQUESTED_LATENCY,
|
||||
PA_SOURCE_OUTPUT_MESSAGE_GET_REQUESTED_LATENCY,
|
||||
PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_VOLUME,
|
||||
PA_SOURCE_OUTPUT_MESSAGE_SET_SOFT_MUTE,
|
||||
PA_SOURCE_OUTPUT_MESSAGE_MAX
|
||||
};
|
||||
|
||||
|
|
@ -219,22 +253,38 @@ typedef struct pa_source_output_new_data {
|
|||
|
||||
pa_resample_method_t resample_method;
|
||||
|
||||
pa_source_output *sync_base;
|
||||
|
||||
pa_sample_spec sample_spec;
|
||||
pa_channel_map channel_map;
|
||||
pa_format_info *format;
|
||||
pa_idxset *req_formats;
|
||||
pa_idxset *nego_formats;
|
||||
|
||||
pa_cvolume volume, volume_factor, volume_factor_source;
|
||||
pa_bool_t muted:1;
|
||||
|
||||
pa_bool_t sample_spec_is_set:1;
|
||||
pa_bool_t channel_map_is_set:1;
|
||||
|
||||
pa_bool_t save_source:1;
|
||||
pa_bool_t volume_is_set:1, volume_factor_is_set:1, volume_factor_source_is_set:1;
|
||||
pa_bool_t muted_is_set:1;
|
||||
|
||||
pa_bool_t volume_is_absolute:1;
|
||||
|
||||
pa_bool_t volume_writable:1;
|
||||
|
||||
pa_bool_t save_source:1, save_volume:1, save_muted:1;
|
||||
} pa_source_output_new_data;
|
||||
|
||||
pa_source_output_new_data* pa_source_output_new_data_init(pa_source_output_new_data *data);
|
||||
void pa_source_output_new_data_set_sample_spec(pa_source_output_new_data *data, const pa_sample_spec *spec);
|
||||
void pa_source_output_new_data_set_channel_map(pa_source_output_new_data *data, const pa_channel_map *map);
|
||||
pa_bool_t pa_source_output_new_data_is_passthrough(pa_source_output_new_data *data);
|
||||
void pa_source_output_new_data_set_volume(pa_source_output_new_data *data, const pa_cvolume *volume);
|
||||
void pa_source_output_new_data_apply_volume_factor(pa_source_output_new_data *data, const pa_cvolume *volume_factor);
|
||||
void pa_source_output_new_data_apply_volume_factor_source(pa_source_output_new_data *data, const pa_cvolume *volume_factor);
|
||||
void pa_source_output_new_data_set_muted(pa_source_output_new_data *data, pa_bool_t mute);
|
||||
pa_bool_t pa_source_output_new_data_set_source(pa_source_output_new_data *data, pa_source *s, pa_bool_t save);
|
||||
pa_bool_t pa_source_output_new_data_set_formats(pa_source_output_new_data *data, pa_idxset *formats);
|
||||
void pa_source_output_new_data_done(pa_source_output_new_data *data);
|
||||
|
|
@ -266,7 +316,13 @@ void pa_source_output_kill(pa_source_output*o);
|
|||
|
||||
pa_usec_t pa_source_output_get_latency(pa_source_output *o, pa_usec_t *source_latency);
|
||||
|
||||
pa_bool_t pa_source_output_is_volume_readable(pa_source_output *o);
|
||||
pa_bool_t pa_source_output_is_passthrough(pa_source_output *o);
|
||||
void pa_source_output_set_volume(pa_source_output *o, const pa_cvolume *volume, pa_bool_t save, pa_bool_t absolute);
|
||||
pa_cvolume *pa_source_output_get_volume(pa_source_output *o, pa_cvolume *volume, pa_bool_t absolute);
|
||||
|
||||
void pa_source_output_set_mute(pa_source_output *o, pa_bool_t mute, pa_bool_t save);
|
||||
pa_bool_t pa_source_output_get_mute(pa_source_output *o);
|
||||
|
||||
void pa_source_output_update_proplist(pa_source_output *o, pa_update_mode_t mode, pa_proplist *p);
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -24,6 +24,7 @@
|
|||
***/
|
||||
|
||||
typedef struct pa_source pa_source;
|
||||
typedef struct pa_source_volume_change pa_source_volume_change;
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
|
|
@ -80,12 +81,15 @@ struct pa_source {
|
|||
pa_volume_t base_volume; /* shall be constant */
|
||||
unsigned n_volume_steps; /* shall be constant */
|
||||
|
||||
pa_cvolume volume, soft_volume;
|
||||
/* Also see http://pulseaudio.org/wiki/InternalVolumes */
|
||||
pa_cvolume reference_volume; /* The volume exported and taken as reference base for relative source output volumes */
|
||||
pa_cvolume real_volume; /* The volume that the hardware is configured to */
|
||||
pa_cvolume soft_volume; /* The internal software volume we apply to all PCM data while it passes through */
|
||||
|
||||
pa_bool_t muted:1;
|
||||
|
||||
pa_bool_t refresh_volume:1;
|
||||
pa_bool_t refresh_muted:1;
|
||||
|
||||
pa_bool_t save_port:1;
|
||||
pa_bool_t save_volume:1;
|
||||
pa_bool_t save_muted:1;
|
||||
|
|
@ -115,6 +119,19 @@ struct pa_source {
|
|||
* will be sent to the IO thread instead. */
|
||||
void (*set_volume)(pa_source *s); /* ditto */
|
||||
|
||||
/* Source drivers that set PA_SOURCE_SYNC_VOLUME must provide this
|
||||
* callback. This callback is not used with source that do not set
|
||||
* PA_SOURCE_SYNC_VOLUME. This is called from the IO thread when a
|
||||
* pending hardware volume change has to be written to the
|
||||
* hardware. The requested volume is passed to the callback
|
||||
* implementation in s->thread_info.current_hw_volume.
|
||||
*
|
||||
* The call is done inside pa_source_volume_change_apply(), which is
|
||||
* not called automatically - it is the driver's responsibility to
|
||||
* schedule that function to be called at the right times in the
|
||||
* IO thread. */
|
||||
void (*write_volume)(pa_source *s); /* ditto */
|
||||
|
||||
/* Called when the mute setting is queried. Called from main loop
|
||||
* context. If this is NULL a PA_SOURCE_MESSAGE_GET_MUTE message
|
||||
* will be sent to the IO thread instead. If refresh_mute is
|
||||
|
|
@ -160,6 +177,21 @@ struct pa_source {
|
|||
pa_usec_t max_latency; /* An upper limit for the latencies */
|
||||
|
||||
pa_usec_t fixed_latency; /* for sources with PA_SOURCE_DYNAMIC_LATENCY this is 0 */
|
||||
|
||||
/* Delayed volume change events are queued here. The events
|
||||
* are stored in expiration order. The one expiring next is in
|
||||
* the head of the list. */
|
||||
PA_LLIST_HEAD(pa_source_volume_change, volume_changes);
|
||||
pa_source_volume_change *volume_changes_tail;
|
||||
/* This value is updated in pa_source_volume_change_apply() and
|
||||
* used only by sources with PA_SOURCE_SYNC_VOLUME. */
|
||||
pa_cvolume current_hw_volume;
|
||||
|
||||
/* The amount of usec volume up events are delayed and volume
|
||||
* down events are made earlier. */
|
||||
uint32_t volume_change_safety_margin;
|
||||
/* Usec delay added to all volume change events, may be negative. */
|
||||
int32_t volume_change_extra_delay;
|
||||
} thread_info;
|
||||
|
||||
void *userdata;
|
||||
|
|
@ -172,7 +204,10 @@ typedef enum pa_source_message {
|
|||
PA_SOURCE_MESSAGE_ADD_OUTPUT,
|
||||
PA_SOURCE_MESSAGE_REMOVE_OUTPUT,
|
||||
PA_SOURCE_MESSAGE_GET_VOLUME,
|
||||
PA_SOURCE_MESSAGE_SET_SHARED_VOLUME,
|
||||
PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED,
|
||||
PA_SOURCE_MESSAGE_SET_VOLUME,
|
||||
PA_SOURCE_MESSAGE_SYNC_VOLUMES,
|
||||
PA_SOURCE_MESSAGE_GET_MUTE,
|
||||
PA_SOURCE_MESSAGE_SET_MUTE,
|
||||
PA_SOURCE_MESSAGE_GET_LATENCY,
|
||||
|
|
@ -186,6 +221,8 @@ typedef enum pa_source_message {
|
|||
PA_SOURCE_MESSAGE_GET_FIXED_LATENCY,
|
||||
PA_SOURCE_MESSAGE_GET_MAX_REWIND,
|
||||
PA_SOURCE_MESSAGE_SET_MAX_REWIND,
|
||||
PA_SOURCE_MESSAGE_SET_PORT,
|
||||
PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE,
|
||||
PA_SOURCE_MESSAGE_MAX
|
||||
} pa_source_message_t;
|
||||
|
||||
|
|
@ -269,11 +306,14 @@ int pa_source_update_status(pa_source*s);
|
|||
int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause);
|
||||
int pa_source_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause);
|
||||
|
||||
/* Use this instead of checking s->flags & PA_SOURCE_FLAT_VOLUME directly. */
|
||||
pa_bool_t pa_source_flat_volume_enabled(pa_source *s);
|
||||
|
||||
/* Is the source in passthrough mode? (that is, is this a monitor source for a sink
|
||||
* that has a passthrough sink input connected to it. */
|
||||
pa_bool_t pa_source_is_passthrough(pa_source *s);
|
||||
|
||||
void pa_source_set_volume(pa_source *source, const pa_cvolume *volume, pa_bool_t save);
|
||||
void pa_source_set_volume(pa_source *source, const pa_cvolume *volume, pa_bool_t sendmsg, pa_bool_t save);
|
||||
const pa_cvolume *pa_source_get_volume(pa_source *source, pa_bool_t force_refresh);
|
||||
|
||||
void pa_source_set_mute(pa_source *source, pa_bool_t mute, pa_bool_t save);
|
||||
|
|
@ -315,6 +355,10 @@ void pa_source_set_max_rewind_within_thread(pa_source *s, size_t max_rewind);
|
|||
void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency);
|
||||
void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency);
|
||||
|
||||
void pa_source_update_volume_and_mute(pa_source *s);
|
||||
|
||||
pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next);
|
||||
|
||||
/*** To be called exclusively by source output drivers, from IO context */
|
||||
|
||||
void pa_source_invalidate_requested_latency(pa_source *s, pa_bool_t dynamic);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue