From d5f46e824e3f8a042e6f67dd4c3fc385545edd74 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Tue, 27 Jan 2009 04:39:07 +0100 Subject: move flat volume logic into the core. while doing so add n_volume_steps field to sinks/sources --- src/pulsecore/cli-command.c | 2 +- src/pulsecore/cli-text.c | 17 ++- src/pulsecore/core.c | 1 + src/pulsecore/core.h | 2 +- src/pulsecore/play-memblockq.c | 2 +- src/pulsecore/protocol-native.c | 6 +- src/pulsecore/sink-input.c | 156 ++++++++++++++++------- src/pulsecore/sink-input.h | 44 +++---- src/pulsecore/sink.c | 257 +++++++++++++++++++++++++++++--------- src/pulsecore/sink.h | 41 +++--- src/pulsecore/sound-file-stream.c | 2 +- src/pulsecore/source-output.c | 11 +- src/pulsecore/source.c | 85 +++++++------ src/pulsecore/source.h | 27 ++-- 14 files changed, 434 insertions(+), 219 deletions(-) (limited to 'src/pulsecore') diff --git a/src/pulsecore/cli-command.c b/src/pulsecore/cli-command.c index da3ef1e2..b93f24f7 100644 --- a/src/pulsecore/cli-command.c +++ b/src/pulsecore/cli-command.c @@ -518,7 +518,7 @@ static int pa_cli_command_sink_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *bu } pa_cvolume_set(&cvolume, sink->sample_spec.channels, volume); - pa_sink_set_volume(sink, &cvolume); + pa_sink_set_volume(sink, &cvolume, TRUE, TRUE); return 0; } diff --git a/src/pulsecore/cli-text.c b/src/pulsecore/cli-text.c index c74ca5df..647fc1b5 100644 --- a/src/pulsecore/cli-text.c +++ b/src/pulsecore/cli-text.c @@ -232,11 +232,12 @@ char *pa_sink_list_to_string(pa_core *c) { " %c index: %u\n" "\tname: <%s>\n" "\tdriver: <%s>\n" - "\tflags: %s%s%s%s%s%s\n" + "\tflags: %s%s%s%s%s%s%s\n" "\tstate: %s\n" "\tvolume: %s%s%s\n" "\t balance %0.2f\n" "\tbase volume: %s%s%s\n" + "\tvolume steps: %u\n" "\tmuted: %s\n" "\tcurrent latency: %0.2f ms\n" "\tconfigured latency: %0.2f ms; range is %0.2f .. %0.2f ms\n" @@ -257,6 +258,7 @@ char *pa_sink_list_to_string(pa_core *c) { sink->flags & PA_SINK_HW_VOLUME_CTRL ? "HW_VOLUME_CTRL " : "", sink->flags & PA_SINK_DECIBEL_VOLUME ? "DECIBEL_VOLUME " : "", sink->flags & PA_SINK_LATENCY ? "LATENCY " : "", + sink->flags & PA_SINK_FLAT_VOLUME ? "FLAT_VOLUME" : "", sink_state_to_string(pa_sink_get_state(sink)), pa_cvolume_snprint(cv, sizeof(cv), pa_sink_get_volume(sink, FALSE)), sink->flags & PA_SINK_DECIBEL_VOLUME ? "\n\t " : "", @@ -265,6 +267,7 @@ char *pa_sink_list_to_string(pa_core *c) { pa_volume_snprint(v, sizeof(v), sink->base_volume), sink->flags & PA_SINK_DECIBEL_VOLUME ? "\n\t " : "", sink->flags & PA_SINK_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), sink->base_volume) : "", + sink->n_volume_steps, pa_yes_no(pa_sink_get_mute(sink, FALSE)), (double) pa_sink_get_latency(sink) / (double) PA_USEC_PER_MSEC, (double) pa_sink_get_requested_latency(sink) / (double) PA_USEC_PER_MSEC, @@ -275,7 +278,7 @@ char *pa_sink_list_to_string(pa_core *c) { sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX, pa_sample_spec_snprint(ss, sizeof(ss), &sink->sample_spec), pa_channel_map_snprint(cm, sizeof(cm), &sink->channel_map), - cmn ? "\n\t " : "", + cmn ? "\n\t " : "", cmn ? cmn : "", pa_sink_used_by(sink), pa_sink_linked_by(sink)); @@ -327,6 +330,7 @@ char *pa_source_list_to_string(pa_core *c) { "\tvolume: %s%s%s\n" "\t balance %0.2f\n" "\tbase volume: %s%s%s\n" + "\tvolume steps: %u\n" "\tmuted: %s\n" "\tcurrent latency: %0.2f ms\n" "\tconfigured latency: %0.2f ms; range is %0.2f .. %0.2f ms\n" @@ -353,6 +357,7 @@ char *pa_source_list_to_string(pa_core *c) { pa_volume_snprint(v, sizeof(v), source->base_volume), source->flags & PA_SOURCE_DECIBEL_VOLUME ? "\n\t " : "", source->flags & PA_SOURCE_DECIBEL_VOLUME ? pa_sw_volume_snprint_dB(vdb, sizeof(vdb), source->base_volume) : "", + source->n_volume_steps, pa_yes_no(pa_source_get_mute(source, FALSE)), (double) pa_source_get_latency(source) / PA_USEC_PER_MSEC, (double) pa_source_get_requested_latency(source) / PA_USEC_PER_MSEC, @@ -361,7 +366,7 @@ char *pa_source_list_to_string(pa_core *c) { (unsigned long) pa_source_get_max_rewind(source) / 1024, pa_sample_spec_snprint(ss, sizeof(ss), &source->sample_spec), pa_channel_map_snprint(cm, sizeof(cm), &source->channel_map), - cmn ? "\n\t " : "", + cmn ? "\n\t " : "", cmn ? cmn : "", pa_source_used_by(source), pa_source_linked_by(source)); @@ -440,7 +445,7 @@ char *pa_source_output_list_to_string(pa_core *c) { clt, pa_sample_spec_snprint(ss, sizeof(ss), &o->sample_spec), pa_channel_map_snprint(cm, sizeof(cm), &o->channel_map), - cmn ? "\n\t " : "", + cmn ? "\n\t " : "", cmn ? cmn : "", pa_resample_method_to_string(pa_source_output_get_resample_method(o))); if (o->module) @@ -525,7 +530,7 @@ char *pa_sink_input_list_to_string(pa_core *c) { clt, pa_sample_spec_snprint(ss, sizeof(ss), &i->sample_spec), pa_channel_map_snprint(cm, sizeof(cm), &i->channel_map), - cmn ? "\n\t " : "", + cmn ? "\n\t " : "", cmn ? cmn : "", pa_resample_method_to_string(pa_sink_input_get_resample_method(i))); @@ -584,7 +589,7 @@ char *pa_scache_list_to_string(pa_core *c) { e->index, ss, cm, - cmn ? "\n\t " : "", + cmn ? "\n\t " : "", cmn ? cmn : "", (long unsigned)(e->memchunk.memblock ? e->memchunk.length : 0), l, diff --git a/src/pulsecore/core.c b/src/pulsecore/core.c index c6e96c1e..381a6779 100644 --- a/src/pulsecore/core.c +++ b/src/pulsecore/core.c @@ -127,6 +127,7 @@ pa_core* pa_core_new(pa_mainloop_api *m, pa_bool_t shared, size_t shm_size) { c->exit_idle_time = -1; c->scache_idle_time = 20; + c->flat_volumes = TRUE; c->resample_method = PA_RESAMPLER_SPEEX_FLOAT_BASE + 3; diff --git a/src/pulsecore/core.h b/src/pulsecore/core.h index ffac6d37..e33a2453 100644 --- a/src/pulsecore/core.h +++ b/src/pulsecore/core.h @@ -55,7 +55,6 @@ typedef enum pa_core_hook { PA_CORE_HOOK_SINK_UNLINK_POST, PA_CORE_HOOK_SINK_STATE_CHANGED, PA_CORE_HOOK_SINK_PROPLIST_CHANGED, - PA_CORE_HOOK_SINK_SET_VOLUME, PA_CORE_HOOK_SOURCE_NEW, PA_CORE_HOOK_SOURCE_FIXATE, PA_CORE_HOOK_SOURCE_PUT, @@ -129,6 +128,7 @@ struct pa_core { pa_silence_cache silence_cache; int exit_idle_time, scache_idle_time; + pa_bool_t flat_volumes; pa_time_event *exit_event; diff --git a/src/pulsecore/play-memblockq.c b/src/pulsecore/play-memblockq.c index 758c0dee..eac21de5 100644 --- a/src/pulsecore/play-memblockq.c +++ b/src/pulsecore/play-memblockq.c @@ -197,7 +197,7 @@ pa_sink_input* pa_memblockq_sink_input_new( data.driver = __FILE__; pa_sink_input_new_data_set_sample_spec(&data, ss); pa_sink_input_new_data_set_channel_map(&data, map); - pa_sink_input_new_data_set_volume(&data, volume); + pa_sink_input_new_data_set_virtual_volume(&data, volume); pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p); u->sink_input = pa_sink_input_new(sink->core, &data, 0); diff --git a/src/pulsecore/protocol-native.c b/src/pulsecore/protocol-native.c index 3896dff6..80edb203 100644 --- a/src/pulsecore/protocol-native.c +++ b/src/pulsecore/protocol-native.c @@ -1012,7 +1012,7 @@ static playback_stream* playback_stream_new( pa_sink_input_new_data_set_sample_spec(&data, ss); pa_sink_input_new_data_set_channel_map(&data, map); if (volume) - pa_sink_input_new_data_set_volume(&data, volume); + pa_sink_input_new_data_set_virtual_volume(&data, volume); if (muted_set) pa_sink_input_new_data_set_muted(&data, muted); data.sync_base = ssync ? ssync->sink_input : NULL; @@ -2691,6 +2691,7 @@ static void sink_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sin if (PA_UNLIKELY(pa_sink_get_state(sink) == PA_SINK_INVALID_STATE)) pa_log_error("Internal sink state is invalid."); pa_tagstruct_putu32(t, pa_sink_get_state(sink)); + pa_tagstruct_putu32(t, sink->n_volume_steps); } } @@ -2729,6 +2730,7 @@ static void source_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_s if (PA_UNLIKELY(pa_source_get_state(source) == PA_SOURCE_INVALID_STATE)) pa_log_error("Internal source state is invalid."); pa_tagstruct_putu32(t, pa_source_get_state(source)); + pa_tagstruct_putu32(t, source->n_volume_steps); } } @@ -3164,7 +3166,7 @@ static void command_set_volume( CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY); if (sink) - pa_sink_set_volume(sink, &volume); + pa_sink_set_volume(sink, &volume, TRUE, TRUE); else if (source) pa_source_set_volume(source, &volume); else if (si) diff --git a/src/pulsecore/sink-input.c b/src/pulsecore/sink-input.c index d1ffb0f7..8b76df0d 100644 --- a/src/pulsecore/sink-input.c +++ b/src/pulsecore/sink-input.c @@ -72,11 +72,18 @@ void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const data->channel_map = *map; } -void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) { +void pa_sink_input_new_data_set_soft_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) { pa_assert(data); - if ((data->volume_is_set = !!volume)) - data->volume = data->virtual_volume = *volume; + if ((data->soft_volume_is_set = !!volume)) + data->soft_volume = *volume; +} + +void pa_sink_input_new_data_set_virtual_volume(pa_sink_input_new_data *data, const pa_cvolume *volume) { + pa_assert(data); + + if ((data->virtual_volume_is_set = !!volume)) + data->virtual_volume = *volume; } void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) { @@ -153,17 +160,34 @@ pa_sink_input* pa_sink_input_new( pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map)); pa_return_null_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec)); - if (!data->volume_is_set) { - pa_cvolume_reset(&data->volume, data->sample_spec.channels); - pa_cvolume_reset(&data->virtual_volume, data->sample_spec.channels); - } + if (!data->virtual_volume_is_set) { - pa_return_null_if_fail(pa_cvolume_valid(&data->volume)); - pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec)); + if (data->sink->flags & PA_SINK_FLAT_VOLUME) { + data->virtual_volume = data->sink->virtual_volume; + pa_cvolume_remap(&data->virtual_volume, &data->sink->channel_map, &data->channel_map); + } else + pa_cvolume_reset(&data->virtual_volume, data->sample_spec.channels); + + } else if (!data->virtual_volume_is_absolute) { + + /* When the 'absolute' bool is set then we'll treat the volume + * as relative to the sink volume even in flat volume mode */ + if (data->sink->flags & PA_SINK_FLAT_VOLUME) { + pa_cvolume t = data->sink->virtual_volume; + pa_cvolume_remap(&t, &data->sink->channel_map, &data->channel_map); + pa_sw_cvolume_multiply(&data->virtual_volume, &data->virtual_volume, &t); + } + } pa_return_null_if_fail(pa_cvolume_valid(&data->virtual_volume)); pa_return_null_if_fail(pa_cvolume_compatible(&data->virtual_volume, &data->sample_spec)); + if (!data->soft_volume_is_set) + data->soft_volume = data->virtual_volume; + + pa_return_null_if_fail(pa_cvolume_valid(&data->soft_volume)); + pa_return_null_if_fail(pa_cvolume_compatible(&data->soft_volume, &data->sample_spec)); + if (!data->muted_is_set) data->muted = FALSE; @@ -184,7 +208,8 @@ pa_sink_input* pa_sink_input_new( 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); + pa_cvolume_remap(&data->soft_volume, &original_cm, &data->channel_map); + pa_cvolume_remap(&data->virtual_volume, &original_cm, &data->channel_map); if (data->resample_method == PA_RESAMPLER_INVALID) data->resample_method = core->resample_method; @@ -239,7 +264,7 @@ pa_sink_input* pa_sink_input_new( i->channel_map = data->channel_map; i->virtual_volume = data->virtual_volume; - i->volume = data->volume; + i->soft_volume = data->soft_volume; i->muted = data->muted; @@ -263,7 +288,7 @@ pa_sink_input* pa_sink_input_new( pa_atomic_store(&i->thread_info.drained, 1); i->thread_info.sample_spec = i->sample_spec; i->thread_info.resampler = resampler; - i->thread_info.volume = i->volume; + i->thread_info.soft_volume = i->soft_volume; i->thread_info.muted = i->muted; i->thread_info.requested_sink_latency = (pa_usec_t) -1; i->thread_info.rewrite_nbytes = 0; @@ -395,9 +420,17 @@ void pa_sink_input_unlink(pa_sink_input *i) { update_n_corked(i, PA_SINK_INPUT_UNLINKED); i->state = PA_SINK_INPUT_UNLINKED; - if (linked && i->sink) + if (linked && i->sink) { + /* We might need to update the sink's volume if we are in flat volume mode. */ + if (i->sink->flags & PA_SINK_FLAT_VOLUME) { + pa_cvolume new_volume; + pa_sink_update_flat_volume(i->sink, &new_volume); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE); + } + if (i->sink->asyncmsgq) pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0); + } reset_callbacks(i); @@ -459,7 +492,7 @@ void pa_sink_input_put(pa_sink_input *i) { pa_assert(i->process_rewind); pa_assert(i->kill); - i->thread_info.volume = i->volume; + i->thread_info.soft_volume = i->soft_volume; i->thread_info.muted = i->muted; state = i->flags & PA_SINK_INPUT_START_CORKED ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING; @@ -467,6 +500,13 @@ void pa_sink_input_put(pa_sink_input *i) { update_n_corked(i, state); i->state = state; + /* We might need to update the sink's volume if we are in flat volume mode. */ + if (i->sink->flags & PA_SINK_FLAT_VOLUME) { + pa_cvolume new_volume; + pa_sink_update_flat_volume(i->sink, &new_volume); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE); + } + pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_ADD_INPUT, i, 0, NULL) == 0); pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW, i->index); @@ -552,7 +592,7 @@ int pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa * it after and leave it for the sink code */ do_volume_adj_here = !pa_channel_map_equal(&i->channel_map, &i->sink->channel_map); - volume_is_norm = pa_cvolume_is_norm(&i->thread_info.volume) && !i->thread_info.muted; + volume_is_norm = pa_cvolume_is_norm(&i->thread_info.soft_volume) && !i->thread_info.muted; while (!pa_memblockq_is_readable(i->thread_info.render_memblockq)) { pa_memchunk tchunk; @@ -598,7 +638,7 @@ int pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa if (i->thread_info.muted) pa_silence_memchunk(&wchunk, &i->thread_info.sample_spec); else - pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.volume); + pa_volume_memchunk(&wchunk, &i->thread_info.sample_spec, &i->thread_info.soft_volume); } if (!i->thread_info.resampler) @@ -644,7 +684,7 @@ int pa_sink_input_peek(pa_sink_input *i, size_t slength /* in sink frames */, pa /* We've both the same channel map, so let's have the sink do the adjustment for us*/ pa_cvolume_mute(volume, i->sink->sample_spec.channels); else - *volume = i->thread_info.volume; + *volume = i->thread_info.soft_volume; return 0; } @@ -816,34 +856,41 @@ pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) { /* Called from main context */ void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume) { - pa_sink_input_set_volume_data data; - pa_sink_input_assert_ref(i); pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); pa_assert(volume); pa_assert(pa_cvolume_valid(volume)); pa_assert(pa_cvolume_compatible(volume, &i->sample_spec)); - data.sink_input = i; - data.virtual_volume = *volume; - data.volume = *volume; + if (pa_cvolume_equal(volume, &i->virtual_volume)) + return; - /* If you change something here, consider looking into - * module-flat-volume.c as well since it uses very similar - * code. */ + i->virtual_volume = *volume; - if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], &data) < 0) - return; + if (i->sink->flags & PA_SINK_FLAT_VOLUME) { + pa_cvolume new_volume; - if (!pa_cvolume_equal(&i->volume, &data.volume)) { - i->volume = data.volume; - pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_VOLUME, &data.volume, 0, NULL) == 0); - } + /* We are in flat volume mode, so let's update all sink input + * volumes and update the flat volume of the sink */ - if (!pa_cvolume_equal(&i->virtual_volume, &data.virtual_volume)) { - i->virtual_volume = data.virtual_volume; - pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); + pa_sink_update_flat_volume(i->sink, &new_volume); + pa_sink_set_volume(i->sink, &new_volume, FALSE, TRUE); + + } else { + + /* OK, we are in normal volume mode. The volume only affects + * ourselves */ + + i->soft_volume = *volume; + + /* Hooks have the ability to play games with i->soft_volume */ + pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i); + + pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, NULL, 0, NULL) == 0); } + + /* The virtual volume changed, let's tell people so */ + pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); } /* Called from main context */ @@ -865,7 +912,7 @@ void pa_sink_input_set_mute(pa_sink_input *i, pa_bool_t mute) { i->muted = mute; - pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_MUTE, PA_UINT_TO_PTR(mute), 0, NULL, NULL); + pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, NULL, 0, NULL) == 0); pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); } @@ -1013,15 +1060,22 @@ int pa_sink_input_start_move(pa_sink_input *i) { } pa_assert(pa_idxset_isempty(i->direct_outputs)); - pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0); + pa_idxset_remove_by_data(i->sink->inputs, i, NULL); if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED) pa_assert_se(i->sink->n_corked-- >= 1); - pa_idxset_remove_by_data(i->sink->inputs, i, NULL); - i->sink = NULL; + /* We might need to update the sink's volume if we are in flat volume mode. */ + if (i->sink->flags & PA_SINK_FLAT_VOLUME) { + pa_cvolume new_volume; + pa_sink_update_flat_volume(i->sink, &new_volume); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE); + } + + pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0); - pa_sink_update_status(origin); + pa_sink_update_status(i->sink); + i->sink = NULL; return 0; } @@ -1092,6 +1146,14 @@ int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest) { } pa_sink_update_status(dest); + + /* We might need to update the sink's volume if we are in flat volume mode. */ + if (i->sink->flags & PA_SINK_FLAT_VOLUME) { + pa_cvolume new_volume; + pa_sink_update_flat_volume(i->sink, &new_volume); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE); + } + pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0); pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name); @@ -1176,14 +1238,18 @@ int pa_sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t switch (code) { - case PA_SINK_INPUT_MESSAGE_SET_VOLUME: - i->thread_info.volume = *((pa_cvolume*) userdata); - pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE); + case PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME: + if (!pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) { + i->thread_info.soft_volume = i->soft_volume; + pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE); + } return 0; - case PA_SINK_INPUT_MESSAGE_SET_MUTE: - i->thread_info.muted = PA_PTR_TO_UINT(userdata); - pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE); + case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE: + if (i->thread_info.muted != i->muted) { + i->thread_info.muted = i->muted; + pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE); + } return 0; case PA_SINK_INPUT_MESSAGE_GET_LATENCY: { diff --git a/src/pulsecore/sink-input.h b/src/pulsecore/sink-input.h index 66ec6136..5bf38de6 100644 --- a/src/pulsecore/sink-input.h +++ b/src/pulsecore/sink-input.h @@ -90,9 +90,7 @@ struct pa_sink_input { pa_sink_input *sync_prev, *sync_next; - pa_cvolume virtual_volume; - - pa_cvolume volume; + pa_cvolume virtual_volume, soft_volume; pa_bool_t muted; pa_resample_method_t requested_resample_method, actual_resample_method; @@ -170,7 +168,15 @@ struct pa_sink_input { pa_sink_input_state_t state; pa_atomic_t drained; - pa_bool_t attached; /* True only between ->attach() and ->detach() calls */ + pa_cvolume soft_volume; + pa_bool_t muted:1; + + pa_bool_t attached:1; /* True only between ->attach() and ->detach() calls */ + + /* 0: rewrite nothing, (size_t) -1: rewrite everything, otherwise how many bytes to rewrite */ + pa_bool_t rewrite_flush:1, dont_rewind_render:1; + size_t rewrite_nbytes; + uint64_t underrun_for, playing_for; pa_sample_spec sample_spec; @@ -179,16 +185,8 @@ struct pa_sink_input { /* We maintain a history of resampled audio data here. */ pa_memblockq *render_memblockq; - /* 0: rewrite nothing, (size_t) -1: rewrite everything, otherwise how many bytes to rewrite */ - size_t rewrite_nbytes; - pa_bool_t rewrite_flush, dont_rewind_render; - uint64_t underrun_for, playing_for; - pa_sink_input *sync_prev, *sync_next; - pa_cvolume volume; - pa_bool_t muted; - /* The requested latency for the sink */ pa_usec_t requested_sink_latency; @@ -202,8 +200,8 @@ PA_DECLARE_CLASS(pa_sink_input); #define PA_SINK_INPUT(o) pa_sink_input_cast(o) enum { - PA_SINK_INPUT_MESSAGE_SET_VOLUME, - PA_SINK_INPUT_MESSAGE_SET_MUTE, + PA_SINK_INPUT_MESSAGE_SET_SOFT_VOLUME, + PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE, PA_SINK_INPUT_MESSAGE_GET_LATENCY, PA_SINK_INPUT_MESSAGE_SET_RATE, PA_SINK_INPUT_MESSAGE_SET_STATE, @@ -228,30 +226,26 @@ typedef struct pa_sink_input_new_data { pa_sample_spec sample_spec; pa_channel_map channel_map; - pa_cvolume virtual_volume; - - pa_cvolume volume; + pa_cvolume virtual_volume, soft_volume; pa_bool_t muted:1; pa_bool_t sample_spec_is_set:1; pa_bool_t channel_map_is_set:1; - pa_bool_t volume_is_set:1; + + pa_bool_t virtual_volume_is_set:1, soft_volume_is_set:1; pa_bool_t muted_is_set:1; + + pa_bool_t virtual_volume_is_absolute:1; } pa_sink_input_new_data; pa_sink_input_new_data* pa_sink_input_new_data_init(pa_sink_input_new_data *data); void pa_sink_input_new_data_set_sample_spec(pa_sink_input_new_data *data, const pa_sample_spec *spec); void pa_sink_input_new_data_set_channel_map(pa_sink_input_new_data *data, const pa_channel_map *map); -void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cvolume *volume); +void pa_sink_input_new_data_set_soft_volume(pa_sink_input_new_data *data, const pa_cvolume *volume); +void pa_sink_input_new_data_set_virtual_volume(pa_sink_input_new_data *data, const pa_cvolume *volume); void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute); void pa_sink_input_new_data_done(pa_sink_input_new_data *data); -typedef struct pa_sink_set_input_volume_data { - pa_sink_input *sink_input; - pa_cvolume virtual_volume; - pa_cvolume volume; -} pa_sink_input_set_volume_data; - /* To be called by the implementing module only */ pa_sink_input* pa_sink_input_new( diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c index 083dbaae..7735d3af 100644 --- a/src/pulsecore/sink.c +++ b/src/pulsecore/sink.c @@ -195,10 +195,10 @@ pa_sink* pa_sink_new( s->inputs = pa_idxset_new(NULL, NULL); s->n_corked = 0; - s->volume = data->volume; + s->virtual_volume = data->volume; + pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); s->base_volume = PA_VOLUME_NORM; - s->virtual_volume = s->volume; - + s->n_volume_steps = PA_VOLUME_NORM+1; s->muted = data->muted; s->refresh_volume = s->refresh_muted = FALSE; @@ -216,8 +216,8 @@ pa_sink* pa_sink_new( 0); s->thread_info.inputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func); - pa_cvolume_reset(&s->thread_info.soft_volume, s->sample_spec.channels); - s->thread_info.soft_muted = FALSE; + s->thread_info.soft_volume = s->soft_volume; + s->thread_info.soft_muted = s->muted; s->thread_info.state = s->state; s->thread_info.rewind_nbytes = 0; s->thread_info.rewind_requested = FALSE; @@ -335,10 +335,17 @@ void pa_sink_put(pa_sink* s) { if (!(s->flags & PA_SINK_HW_VOLUME_CTRL)) { s->flags |= PA_SINK_DECIBEL_VOLUME; - s->thread_info.soft_volume = s->volume; + s->thread_info.soft_volume = s->soft_volume; s->thread_info.soft_muted = s->muted; } + if (s->flags & PA_SINK_DECIBEL_VOLUME) + s->n_volume_steps = PA_VOLUME_NORM+1; + + if (s->core->flat_volumes) + if (s->flags & PA_SINK_DECIBEL_VOLUME) + s->flags |= PA_SINK_FLAT_VOLUME; + pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0); pa_source_put(s->monitor_source); @@ -911,9 +918,100 @@ pa_usec_t pa_sink_get_latency(pa_sink *s) { } /* Called from main thread */ -void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume) { - pa_bool_t changed; - pa_sink_set_volume_data data; +void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume) { + pa_sink_input *i; + uint32_t idx; + + /* This is called whenever a sink input volume changes and we + * might need to fix up the sink volume accordingly. Please note + * that we don't actually update the sinks volume here, we only + * return how it needs to be updated. The caller should then call + * pa_sink_set_flat_volume().*/ + + pa_cvolume_mute(new_volume, s->channel_map.channels); + + /* First let's determine the new maximum volume of all inputs + * connected to this sink */ + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + unsigned c; + pa_cvolume remapped_volume; + + remapped_volume = i->virtual_volume; + pa_cvolume_remap(&remapped_volume, &i->channel_map, &s->channel_map); + + for (c = 0; c < new_volume->channels; c++) + if (remapped_volume.values[c] > new_volume->values[c]) + new_volume->values[c] = remapped_volume.values[c]; + } + + /* Then, let's update the soft volumes of all inputs connected + * to this sink */ + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + pa_cvolume remapped_new_volume; + + remapped_new_volume = *new_volume; + pa_cvolume_remap(&remapped_new_volume, &s->channel_map, &i->channel_map); + pa_sw_cvolume_divide(&i->soft_volume, &i->virtual_volume, &remapped_new_volume); + + /* Hooks have the ability to play games with i->soft_volume */ + pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], i); + + /* We don't issue PA_SINK_INPUT_MESSAGE_SET_VOLUME because + * we want the update to have atomically with the sink + * volume update, hence we do it within the + * pa_sink_set_flat_volume() call below*/ + } +} + +/* Called from main thread */ +void pa_sink_propagate_flat_volume(pa_sink *s, const pa_cvolume *old_volume) { + pa_sink_input *i; + uint32_t idx; + + pa_sink_assert_ref(s); + pa_assert(PA_SINK_IS_LINKED(s->state)); + pa_assert(old_volume); + pa_assert(s->flags & PA_SINK_FLAT_VOLUME); + + /* This is called whenever the sink volume changes that is not + * caused by a sink input volume change. We need to fix up the + * sink input volumes accordingly */ + + for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + pa_cvolume remapped_old_volume, remapped_new_volume, fixed_volume; + unsigned c; + + remapped_new_volume = s->virtual_volume; + pa_cvolume_remap(&remapped_new_volume, &s->channel_map, &i->channel_map); + + remapped_old_volume = *old_volume; + pa_cvolume_remap(&remapped_old_volume, &s->channel_map, &i->channel_map); + + for (c = 0; c < i->sample_spec.channels; c++) + + if (remapped_old_volume.values[c] == PA_VOLUME_MUTED) + fixed_volume.values[c] = PA_VOLUME_MUTED; + else + fixed_volume.values[c] = (pa_volume_t) + ((uint64_t) i->virtual_volume.values[c] * + (uint64_t) remapped_new_volume.values[c] / + (uint64_t) remapped_old_volume.values[c]); + + fixed_volume.channels = i->virtual_volume.channels; + + if (!pa_cvolume_equal(&fixed_volume, &i->virtual_volume)) { + i->virtual_volume = fixed_volume; + + /* The virtual volume changed, let's tell people so */ + pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); + } + } +} + +/* Called from main thread */ +void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg) { + pa_cvolume old_virtual_volume; + pa_bool_t virtual_volume_changed; pa_sink_assert_ref(s); pa_assert(PA_SINK_IS_LINKED(s->state)); @@ -921,39 +1019,45 @@ void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume) { pa_assert(pa_cvolume_valid(volume)); pa_assert(pa_cvolume_compatible(volume, &s->sample_spec)); - data.sink = s; - data.virtual_volume = data.volume = *volume; + old_virtual_volume = s->virtual_volume; + s->virtual_volume = *volume; + virtual_volume_changed = !pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume); - changed = !pa_cvolume_equal(&data.virtual_volume, &s->virtual_volume) || - !pa_cvolume_equal(&data.volume, &s->volume); + /* Propagate this volume change back to the inputs */ + if (virtual_volume_changed) + if (propagate && (s->flags & PA_SINK_FLAT_VOLUME)) + pa_sink_propagate_flat_volume(s, &old_virtual_volume); - if (changed) { - if (pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_SET_VOLUME], &data) < 0) - return; + if (s->set_volume) { + /* If we have a function set_volume(), then we do not apply a + * soft volume by default. However, set_volume() is apply one + * to s->soft_volume */ - changed = !pa_cvolume_equal(&data.virtual_volume, &s->virtual_volume); /* from client-side view */ - } + pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); + s->set_volume(s); - s->volume = data.volume; - s->virtual_volume = data.virtual_volume; + } else + /* If we have no function set_volume(), then the soft volume + * becomes the virtual volume */ + s->soft_volume = s->virtual_volume; - if (s->set_volume && s->set_volume(s) < 0) - s->set_volume = NULL; + /* This tells the sink that soft and/or virtual volume changed */ + if (sendmsg) + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0); - if (!s->set_volume) - pa_sink_set_soft_volume(s, &s->volume); - - if (changed) + if (virtual_volume_changed) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } -/* Called from main thread */ +/* Called from main thread. Only to be called by sink implementor */ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) { pa_sink_assert_ref(s); pa_assert(volume); + s->soft_volume = *volume; + if (PA_SINK_IS_LINKED(s->state)) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, volume, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0); else s->thread_info.soft_volume = *volume; } @@ -961,21 +1065,22 @@ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) { /* Called from main thread */ const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) { pa_sink_assert_ref(s); - pa_assert(PA_SINK_IS_LINKED(s->state)); if (s->refresh_volume || force_refresh) { - struct pa_cvolume old_volume = s->virtual_volume; + struct pa_cvolume old_virtual_volume = s->virtual_volume; - if (s->get_volume && s->get_volume(s) < 0) - s->get_volume = NULL; + if (s->get_volume) + s->get_volume(s); - if (!s->get_volume) { - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, &s->volume, 0, NULL); - s->virtual_volume = s->volume; - } + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0); + + if (!pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume)) { + + if (s->flags & PA_SINK_FLAT_VOLUME) + pa_sink_propagate_flat_volume(s, &old_virtual_volume); - if (!pa_cvolume_equal(&old_volume, &s->virtual_volume)) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); + } } return &s->virtual_volume; @@ -983,21 +1088,20 @@ const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) { /* Called from main thread */ void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) { - pa_bool_t changed; + pa_bool_t old_muted; pa_sink_assert_ref(s); pa_assert(PA_SINK_IS_LINKED(s->state)); - changed = s->muted != mute; + old_muted = s->muted; s->muted = mute; - if (s->set_mute && s->set_mute(s) < 0) - s->set_mute = NULL; + if (s->set_mute) + s->set_mute(s); - if (!s->set_mute) - pa_asyncmsgq_post(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, PA_UINT_TO_PTR(mute), 0, NULL, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0); - if (changed) + if (old_muted != s->muted) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } @@ -1005,16 +1109,14 @@ void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) { pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) { pa_sink_assert_ref(s); - pa_assert(PA_SINK_IS_LINKED(s->state)); if (s->refresh_muted || force_refresh) { pa_bool_t old_muted = s->muted; - if (s->get_mute && s->get_mute(s) < 0) - s->get_mute = NULL; + if (s->get_mute) + s->get_mute(s); - if (!s->get_mute) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, &s->muted, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0); if (old_muted != s->muted) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); @@ -1138,6 +1240,22 @@ unsigned pa_sink_check_suspend(pa_sink *s) { return ret; } +/* Called from the IO thread */ +static void sync_input_volumes_within_thread(pa_sink *s) { + pa_sink_input *i; + void *state = NULL; + + pa_sink_assert_ref(s); + + while ((i = PA_SINK_INPUT(pa_hashmap_iterate(s->thread_info.inputs, &state, NULL)))) { + if (pa_cvolume_equal(&i->thread_info.soft_volume, &i->soft_volume)) + continue; + + i->thread_info.soft_volume = i->soft_volume; + pa_sink_input_request_rewind(i, 0, TRUE, FALSE, FALSE); + } +} + /* Called from IO thread, except when it is not */ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) { pa_sink *s = PA_SINK(o); @@ -1192,7 +1310,9 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse * slow start, i.e. need some time to buffer client * samples before beginning streaming. */ - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_REMOVE_INPUT: { @@ -1233,7 +1353,9 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse pa_sink_invalidate_requested_latency(s); pa_sink_request_rewind(s, (size_t) -1); - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_START_MOVE: { @@ -1279,7 +1401,9 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse pa_log_debug("Requesting rewind due to started move"); pa_sink_request_rewind(s, (size_t) -1); - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_FINISH_MOVE: { @@ -1323,27 +1447,36 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse pa_sink_request_rewind(s, nbytes); } - return 0; + /* In flat volume mode we need to update the volume as + * well */ + return o->process_msg(o, PA_SINK_MESSAGE_SET_VOLUME, NULL, 0, NULL); } case PA_SINK_MESSAGE_SET_VOLUME: - s->thread_info.soft_volume = *((pa_cvolume*) userdata); - pa_sink_request_rewind(s, (size_t) -1); - return 0; + if (!pa_cvolume_equal(&s->thread_info.soft_volume, &s->soft_volume)) { + s->thread_info.soft_volume = s->soft_volume; + pa_sink_request_rewind(s, (size_t) -1); + } - case PA_SINK_MESSAGE_SET_MUTE: - s->thread_info.soft_muted = PA_PTR_TO_UINT(userdata); + if (s->flags & PA_SINK_FLAT_VOLUME) + sync_input_volumes_within_thread(s); - pa_sink_request_rewind(s, (size_t) -1); return 0; case PA_SINK_MESSAGE_GET_VOLUME: - *((pa_cvolume*) userdata) = s->thread_info.soft_volume; + return 0; + + case PA_SINK_MESSAGE_SET_MUTE: + + if (!s->thread_info.soft_muted != s->muted) { + s->thread_info.soft_muted = s->muted; + pa_sink_request_rewind(s, (size_t) -1); + } + return 0; case PA_SINK_MESSAGE_GET_MUTE: - *((pa_bool_t*) userdata) = s->thread_info.soft_muted; return 0; case PA_SINK_MESSAGE_SET_STATE: @@ -1676,6 +1809,7 @@ void pa_sink_update_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t m pa_source_update_latency_range(s->monitor_source, min_latency, max_latency); } +/* Called from main context */ size_t pa_sink_get_max_rewind(pa_sink *s) { size_t r; pa_sink_assert_ref(s); @@ -1688,6 +1822,7 @@ size_t pa_sink_get_max_rewind(pa_sink *s) { return r; } +/* Called from main context */ size_t pa_sink_get_max_request(pa_sink *s) { size_t r; pa_sink_assert_ref(s); diff --git a/src/pulsecore/sink.h b/src/pulsecore/sink.h index a30245d9..b26ca779 100644 --- a/src/pulsecore/sink.h +++ b/src/pulsecore/sink.h @@ -71,11 +71,11 @@ struct pa_sink { unsigned n_corked; pa_source *monitor_source; - pa_cvolume volume; - pa_cvolume virtual_volume; - pa_bool_t muted; + pa_volume_t base_volume; /* shall be constant */ + unsigned n_volume_steps; /* shall be constant */ - pa_volume_t base_volume; /* shall be constant */ + pa_cvolume virtual_volume, soft_volume; + pa_bool_t muted:1; pa_bool_t refresh_volume:1; pa_bool_t refresh_muted:1; @@ -94,23 +94,23 @@ struct pa_sink { * context. If this is NULL a PA_SINK_MESSAGE_GET_VOLUME message * will be sent to the IO thread instead. If refresh_volume is * FALSE neither this function is called nor a message is sent. */ - int (*get_volume)(pa_sink *s); /* may be NULL */ + void (*get_volume)(pa_sink *s); /* may be NULL */ /* Called when the volume shall be changed. Called from main loop * context. If this is NULL a PA_SINK_MESSAGE_SET_VOLUME message * will be sent to the IO thread instead. */ - int (*set_volume)(pa_sink *s); /* dito */ + void (*set_volume)(pa_sink *s); /* dito */ /* Called when the mute setting is queried. Called from main loop * context. If this is NULL a PA_SINK_MESSAGE_GET_MUTE message * will be sent to the IO thread instead. If refresh_mute is * FALSE neither this function is called nor a message is sent.*/ - int (*get_mute)(pa_sink *s); /* dito */ + void (*get_mute)(pa_sink *s); /* dito */ /* Called when the mute setting shall be changed. Called from main * loop context. If this is NULL a PA_SINK_MESSAGE_SET_MUTE * message will be sent to the IO thread instead. */ - int (*set_mute)(pa_sink *s); /* dito */ + void (*set_mute)(pa_sink *s); /* dito */ /* Called when a rewind request is issued. Called from IO thread * context. */ @@ -125,6 +125,7 @@ struct pa_sink { struct { pa_sink_state_t state; pa_hashmap *inputs; + pa_cvolume soft_volume; pa_bool_t soft_muted:1; @@ -203,13 +204,7 @@ void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volum void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute); void pa_sink_new_data_done(pa_sink_new_data *data); -typedef struct pa_sink_set_volume_data { - pa_sink *sink; - pa_cvolume volume; - pa_cvolume virtual_volume; -} pa_sink_set_volume_data; - -/* To be called exclusively by the sink driver, from main context */ +/*** To be called exclusively by the sink driver, from main context */ pa_sink* pa_sink_new( pa_core *core, @@ -228,7 +223,9 @@ void pa_sink_set_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_ void pa_sink_detach(pa_sink *s); void pa_sink_attach(pa_sink *s); -/* May be called by everyone, from main context */ +void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume); + +/**** May be called by everyone, from main context */ /* The returned value is supposed to be in the time domain of the sound card! */ pa_usec_t pa_sink_get_latency(pa_sink *s); @@ -242,11 +239,13 @@ int pa_sink_update_status(pa_sink*s); int pa_sink_suspend(pa_sink *s, pa_bool_t suspend); int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend); -void pa_sink_set_volume(pa_sink *sink, const pa_cvolume *volume); -void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume); +void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume); +void pa_sink_propagate_flat_volume(pa_sink *s, const pa_cvolume *old_volume); + +void pa_sink_set_volume(pa_sink *sink, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg); const pa_cvolume *pa_sink_get_volume(pa_sink *sink, pa_bool_t force_refresh); void pa_sink_set_mute(pa_sink *sink, pa_bool_t mute); -pa_bool_t pa_sink_get_mute(pa_sink *sink, pa_bool_t force_refres); +pa_bool_t pa_sink_get_mute(pa_sink *sink, pa_bool_t force_refresh); pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p); @@ -260,7 +259,7 @@ pa_queue *pa_sink_move_all_start(pa_sink *s); void pa_sink_move_all_finish(pa_sink *s, pa_queue *q); void pa_sink_move_all_fail(pa_queue *q); -/* To be called exclusively by the sink driver, from IO context */ +/*** To be called exclusively by the sink driver, from IO context */ void pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result); void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result); @@ -281,7 +280,7 @@ void pa_sink_set_max_request(pa_sink *s, size_t max_request); void pa_sink_update_latency_range(pa_sink *s, pa_usec_t min_latency, pa_usec_t max_latency); -/* To be called exclusively by sink input drivers, from IO context */ +/*** To be called exclusively by sink input drivers, from IO context */ void pa_sink_request_rewind(pa_sink*s, size_t nbytes); diff --git a/src/pulsecore/sound-file-stream.c b/src/pulsecore/sound-file-stream.c index b78afca8..1be421f1 100644 --- a/src/pulsecore/sound-file-stream.c +++ b/src/pulsecore/sound-file-stream.c @@ -322,7 +322,7 @@ int pa_play_file( data.sink = sink; data.driver = __FILE__; pa_sink_input_new_data_set_sample_spec(&data, &ss); - pa_sink_input_new_data_set_volume(&data, volume); + pa_sink_input_new_data_set_virtual_volume(&data, volume); pa_proplist_sets(data.proplist, PA_PROP_MEDIA_NAME, pa_path_get_filename(fname)); pa_proplist_sets(data.proplist, PA_PROP_MEDIA_FILENAME, fname); diff --git a/src/pulsecore/source-output.c b/src/pulsecore/source-output.c index 1d21ffb6..204e06cc 100644 --- a/src/pulsecore/source-output.c +++ b/src/pulsecore/source-output.c @@ -685,15 +685,15 @@ int pa_source_output_start_move(pa_source_output *o) { origin = o->source; - pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_REMOVE_OUTPUT, o, 0, NULL) == 0); + pa_idxset_remove_by_data(o->source->outputs, o, NULL); if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED) pa_assert_se(origin->n_corked-- >= 1); - pa_idxset_remove_by_data(o->source->outputs, o, NULL); - o->source = NULL; + 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(origin); + pa_source_update_status(o->source); + o->source = NULL; return 0; } @@ -707,6 +707,9 @@ int pa_source_output_finish_move(pa_source_output *o, pa_source *dest) { pa_assert(!o->source); pa_source_assert_ref(dest); + if (!pa_source_output_may_move_to(o, dest)) + return -1; + o->source = dest; pa_idxset_put(o->source->outputs, o, NULL); diff --git a/src/pulsecore/source.c b/src/pulsecore/source.c index 3cddd099..cd6ebc36 100644 --- a/src/pulsecore/source.c +++ b/src/pulsecore/source.c @@ -187,10 +187,12 @@ pa_source* pa_source_new( s->n_corked = 0; s->monitor_of = NULL; - s->volume = data->volume; + s->virtual_volume = data->volume; + pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); + s->base_volume = PA_VOLUME_NORM; + s->n_volume_steps = PA_VOLUME_NORM+1; s->muted = data->muted; s->refresh_volume = s->refresh_muted = FALSE; - s->base_volume = PA_VOLUME_NORM; reset_callbacks(s); s->userdata = NULL; @@ -206,8 +208,8 @@ pa_source* pa_source_new( 0); s->thread_info.outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func); - pa_cvolume_reset(&s->thread_info.soft_volume, s->sample_spec.channels); - s->thread_info.soft_muted = FALSE; + s->thread_info.soft_volume = s->soft_volume; + s->thread_info.soft_muted = s->muted; s->thread_info.state = s->state; s->thread_info.max_rewind = 0; s->thread_info.requested_latency_valid = FALSE; @@ -293,10 +295,13 @@ void pa_source_put(pa_source *s) { if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL)) { s->flags |= PA_SOURCE_DECIBEL_VOLUME; - s->thread_info.soft_volume = s->volume; + s->thread_info.soft_volume = s->soft_volume; s->thread_info.soft_muted = s->muted; } + if (s->flags & PA_SOURCE_DECIBEL_VOLUME) + s->n_volume_steps = PA_VOLUME_NORM+1; + pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0); pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index); @@ -568,32 +573,38 @@ pa_usec_t pa_source_get_latency(pa_source *s) { /* Called from main thread */ void pa_source_set_volume(pa_source *s, const pa_cvolume *volume) { - pa_bool_t changed; + pa_cvolume old_virtual_volume; + pa_bool_t virtual_volume_changed; pa_source_assert_ref(s); pa_assert(PA_SOURCE_IS_LINKED(s->state)); pa_assert(volume); + pa_assert(pa_cvolume_valid(volume)); + pa_assert(pa_cvolume_compatible(volume, &s->sample_spec)); - changed = !pa_cvolume_equal(volume, &s->volume); - s->volume = *volume; + old_virtual_volume = s->virtual_volume; + s->virtual_volume = *volume; + virtual_volume_changed = !pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume); - if (s->set_volume && s->set_volume(s) < 0) - s->set_volume = NULL; + if (s->set_volume) { + pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); + s->set_volume(s); + } else + s->soft_volume = s->virtual_volume; - if (!s->set_volume) - pa_source_set_soft_volume(s, volume); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0); - if (changed) + if (virtual_volume_changed) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } -/* Called from main thread */ +/* Called from main thread. Only to be called by source implementor */ void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) { pa_source_assert_ref(s); pa_assert(volume); if (PA_SOURCE_IS_LINKED(s->state)) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, volume, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_VOLUME, NULL, 0, NULL) == 0); else s->thread_info.soft_volume = *volume; } @@ -604,38 +615,36 @@ const pa_cvolume *pa_source_get_volume(pa_source *s, pa_bool_t force_refresh) { pa_assert(PA_SOURCE_IS_LINKED(s->state)); if (s->refresh_volume || force_refresh) { - pa_cvolume old_volume = s->volume; + pa_cvolume old_virtual_volume = s->virtual_volume; - if (s->get_volume && s->get_volume(s) < 0) - s->get_volume = NULL; + if (s->get_volume) + s->get_volume(s); - if (!s->get_volume) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, &s->volume, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0); - if (!pa_cvolume_equal(&old_volume, &s->volume)) + if (!pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume)) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } - return &s->volume; + return &s->virtual_volume; } /* Called from main thread */ void pa_source_set_mute(pa_source *s, pa_bool_t mute) { - pa_bool_t changed; + pa_bool_t old_muted; pa_source_assert_ref(s); pa_assert(PA_SOURCE_IS_LINKED(s->state)); - changed = s->muted != mute; + old_muted = s->muted; s->muted = mute; - if (s->set_mute && s->set_mute(s) < 0) - s->set_mute = NULL; + if (s->set_mute) + s->set_mute(s); - if (!s->set_mute) - pa_asyncmsgq_post(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, PA_UINT_TO_PTR(mute), 0, NULL, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0); - if (changed) + if (old_muted != s->muted) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } @@ -648,11 +657,10 @@ pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) { if (s->refresh_muted || force_refresh) { pa_bool_t old_muted = s->muted; - if (s->get_mute && s->get_mute(s) < 0) - s->get_mute = NULL; + if (s->get_mute) + s->get_mute(s); - if (!s->get_mute) - pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, &s->muted, 0, NULL); + pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0); if (old_muted != s->muted) pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); @@ -661,6 +669,7 @@ pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) { return s->muted; } +/* Called from main thread */ pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) { pa_source_assert_ref(s); @@ -814,19 +823,17 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_ } case PA_SOURCE_MESSAGE_SET_VOLUME: - s->thread_info.soft_volume = *((pa_cvolume*) userdata); + s->thread_info.soft_volume = s->soft_volume; return 0; - case PA_SOURCE_MESSAGE_SET_MUTE: - s->thread_info.soft_muted = PA_PTR_TO_UINT(userdata); + case PA_SOURCE_MESSAGE_GET_VOLUME: return 0; - case PA_SOURCE_MESSAGE_GET_VOLUME: - *((pa_cvolume*) userdata) = s->thread_info.soft_volume; + case PA_SOURCE_MESSAGE_SET_MUTE: + s->thread_info.soft_muted = s->muted; return 0; case PA_SOURCE_MESSAGE_GET_MUTE: - *((pa_bool_t*) userdata) = s->thread_info.soft_muted; return 0; case PA_SOURCE_MESSAGE_SET_STATE: diff --git a/src/pulsecore/source.h b/src/pulsecore/source.h index 479cade2..de239770 100644 --- a/src/pulsecore/source.h +++ b/src/pulsecore/source.h @@ -73,10 +73,11 @@ struct pa_source { unsigned n_corked; pa_sink *monitor_of; /* may be NULL */ - pa_cvolume volume; - pa_bool_t muted; - pa_volume_t base_volume; /* shall be constant */ + unsigned n_volume_steps; /* shall be constant */ + + pa_cvolume virtual_volume, soft_volume; + pa_bool_t muted:1; pa_bool_t refresh_volume:1; pa_bool_t refresh_muted:1; @@ -95,23 +96,23 @@ struct pa_source { * context. If this is NULL a PA_SOURCE_MESSAGE_GET_VOLUME message * will be sent to the IO thread instead. If refresh_volume is * FALSE neither this function is called nor a message is sent. */ - int (*get_volume)(pa_source *s); /* dito */ + void (*get_volume)(pa_source *s); /* dito */ /* Called when the volume shall be changed. Called from main loop * context. If this is NULL a PA_SOURCE_MESSAGE_SET_VOLUME message * will be sent to the IO thread instead. */ - int (*set_volume)(pa_source *s); /* dito */ + void (*set_volume)(pa_source *s); /* dito */ /* 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 * FALSE neither this function is called nor a message is sent.*/ - int (*get_mute)(pa_source *s); /* dito */ + void (*get_mute)(pa_source *s); /* dito */ /* Called when the mute setting shall be changed. Called from main * loop context. If this is NULL a PA_SOURCE_MESSAGE_SET_MUTE * message will be sent to the IO thread instead. */ - int (*set_mute)(pa_source *s); /* dito */ + void (*set_mute)(pa_source *s); /* dito */ /* Called when a the requested latency is changed. Called from IO * thread context. */ @@ -122,6 +123,7 @@ struct pa_source { struct { pa_source_state_t state; pa_hashmap *outputs; + pa_cvolume soft_volume; pa_bool_t soft_muted:1; @@ -189,7 +191,7 @@ void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *v void pa_source_new_data_set_muted(pa_source_new_data *data, pa_bool_t mute); void pa_source_new_data_done(pa_source_new_data *data); -/* To be called exclusively by the source driver, from main context */ +/*** To be called exclusively by the source driver, from main context */ pa_source* pa_source_new( pa_core *core, @@ -208,7 +210,9 @@ void pa_source_set_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t void pa_source_detach(pa_source *s); void pa_source_attach(pa_source *s); -/* May be called by everyone, from main context */ +void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume); + +/*** May be called by everyone, from main context */ /* The returned value is supposed to be in the time domain of the sound card! */ pa_usec_t pa_source_get_latency(pa_source *s); @@ -222,7 +226,6 @@ int pa_source_suspend(pa_source *s, pa_bool_t suspend); int pa_source_suspend_all(pa_core *c, pa_bool_t suspend); void pa_source_set_volume(pa_source *source, const pa_cvolume *volume); -void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume); 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 pa_source_get_mute(pa_source *source, pa_bool_t force_refresh); @@ -239,7 +242,7 @@ pa_queue *pa_source_move_all_start(pa_source *s); void pa_source_move_all_finish(pa_source *s, pa_queue *q); void pa_source_move_all_fail(pa_queue *q); -/* To be called exclusively by the source driver, from IO context */ +/*** To be called exclusively by the source driver, from IO context */ void pa_source_post(pa_source*s, const pa_memchunk *chunk); void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *chunk); @@ -255,7 +258,7 @@ pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s); void pa_source_set_max_rewind(pa_source *s, size_t max_rewind); void pa_source_update_latency_range(pa_source *s, pa_usec_t min_latency, pa_usec_t max_latency); -/* To be called exclusively by source output drivers, from IO context */ +/*** To be called exclusively by source output drivers, from IO context */ void pa_source_invalidate_requested_latency(pa_source *s); -- cgit