#include <stdio.h>
#include <stdlib.h>
+#include <pulse/format.h>
#include <pulse/utf8.h>
#include <pulse/xmalloc.h>
#include <pulse/timeval.h>
s->set_state = NULL;
s->get_volume = NULL;
s->set_volume = NULL;
+ s->write_volume = NULL;
s->get_mute = NULL;
s->set_mute = NULL;
s->update_requested_latency = NULL;
PA_LLIST_HEAD_INIT(pa_source_volume_change, s->thread_info.volume_changes);
s->thread_info.volume_changes_tail = NULL;
pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
- s->thread_info.volume_change_safety_margin = core->sync_volume_safety_margin_usec;
- s->thread_info.volume_change_extra_delay = core->sync_volume_extra_delay_usec;
+ s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
+ s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
/* FIXME: This should probably be moved to pa_source_put() */
pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
s->state = state;
- if (state != PA_SOURCE_UNLINKED) { /* if we enter UNLINKED state pa_source_unlink() will fire the apropriate events */
+ if (state != PA_SOURCE_UNLINKED) { /* if we enter UNLINKED state pa_source_unlink() will fire the appropriate events */
pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_STATE_CHANGED], s);
pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
}
return 0;
}
+void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb) {
+ pa_assert(s);
+
+ s->get_volume = cb;
+}
+
+void pa_source_set_set_volume_callback(pa_source *s, pa_source_cb_t cb) {
+ pa_source_flags_t flags;
+
+ pa_assert(s);
+ pa_assert(!s->write_volume || cb);
+
+ s->set_volume = cb;
+
+ /* Save the current flags so we can tell if they've changed */
+ flags = s->flags;
+
+ if (cb) {
+ /* The source implementor is responsible for setting decibel volume support */
+ s->flags |= PA_SOURCE_HW_VOLUME_CTRL;
+ } else {
+ s->flags &= ~PA_SOURCE_HW_VOLUME_CTRL;
+ /* See note below in pa_source_put() about volume sharing and decibel volumes */
+ pa_source_enable_decibel_volume(s, !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
+ }
+
+ /* If the flags have changed after init, let any clients know via a change event */
+ if (s->state != PA_SOURCE_INIT && flags != s->flags)
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
+void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb) {
+ pa_source_flags_t flags;
+
+ pa_assert(s);
+ pa_assert(!cb || s->set_volume);
+
+ s->write_volume = cb;
+
+ /* Save the current flags so we can tell if they've changed */
+ flags = s->flags;
+
+ if (cb)
+ s->flags |= PA_SOURCE_DEFERRED_VOLUME;
+ else
+ s->flags &= ~PA_SOURCE_DEFERRED_VOLUME;
+
+ /* If the flags have changed after init, let any clients know via a change event */
+ if (s->state != PA_SOURCE_INIT && flags != s->flags)
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
+void pa_source_set_get_mute_callback(pa_source *s, pa_source_cb_t cb) {
+ pa_assert(s);
+
+ s->get_mute = cb;
+}
+
+void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb) {
+ pa_source_flags_t flags;
+
+ pa_assert(s);
+
+ s->set_mute = cb;
+
+ /* Save the current flags so we can tell if they've changed */
+ flags = s->flags;
+
+ if (cb)
+ s->flags |= PA_SOURCE_HW_MUTE_CTRL;
+ else
+ s->flags &= ~PA_SOURCE_HW_MUTE_CTRL;
+
+ /* If the flags have changed after init, let any clients know via a change event */
+ if (s->state != PA_SOURCE_INIT && flags != s->flags)
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
+static void enable_flat_volume(pa_source *s, pa_bool_t enable) {
+ pa_source_flags_t flags;
+
+ pa_assert(s);
+
+ /* Always follow the overall user preference here */
+ enable = enable && s->core->flat_volumes;
+
+ /* Save the current flags so we can tell if they've changed */
+ flags = s->flags;
+
+ if (enable)
+ s->flags |= PA_SOURCE_FLAT_VOLUME;
+ else
+ s->flags &= ~PA_SOURCE_FLAT_VOLUME;
+
+ /* If the flags have changed after init, let any clients know via a change event */
+ if (s->state != PA_SOURCE_INIT && flags != s->flags)
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
+void pa_source_enable_decibel_volume(pa_source *s, pa_bool_t enable) {
+ pa_source_flags_t flags;
+
+ pa_assert(s);
+
+ /* Save the current flags so we can tell if they've changed */
+ flags = s->flags;
+
+ if (enable) {
+ s->flags |= PA_SOURCE_DECIBEL_VOLUME;
+ enable_flat_volume(s, TRUE);
+ } else {
+ s->flags &= ~PA_SOURCE_DECIBEL_VOLUME;
+ enable_flat_volume(s, FALSE);
+ }
+
+ /* If the flags have changed after init, let any clients know via a change event */
+ if (s->state != PA_SOURCE_INIT && flags != s->flags)
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
/* Called from main context */
void pa_source_put(pa_source *s) {
pa_source_assert_ref(s);
pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency);
/* Generally, flags should be initialized via pa_source_new(). As a
- * special exception we allow volume related flags to be set
- * between _new() and _put(). */
+ * special exception we allow some volume related flags to be set
+ * between _new() and _put() by the callback setter functions above.
+ *
+ * Thus we implement a couple safeguards here which ensure the above
+ * setters were used (or at least the implementor made manual changes
+ * in a compatible way).
+ *
+ * Note: All of these flags set here can change over the life time
+ * of the source. */
+ pa_assert(!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) || s->set_volume);
+ pa_assert(!(s->flags & PA_SOURCE_DEFERRED_VOLUME) || s->write_volume);
+ pa_assert(!(s->flags & PA_SOURCE_HW_MUTE_CTRL) || s->set_mute);
/* XXX: Currently decibel volume is disabled for all sources that use volume
* sharing. When the master source supports decibel volume, it would be good
* a master source to another. One solution for this problem would be to
* remove user-visible volume altogether from filter sources when volume
* sharing is used, but the current approach was easier to implement... */
+ /* We always support decibel volumes in software, otherwise we leave it to
+ * the source implementor to set this flag as needed.
+ *
+ * Note: This flag can also change over the life time of the source. */
if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
- s->flags |= PA_SOURCE_DECIBEL_VOLUME;
+ pa_source_enable_decibel_volume(s, TRUE);
- if ((s->flags & PA_SOURCE_DECIBEL_VOLUME) && s->core->flat_volumes)
- s->flags |= PA_SOURCE_FLAT_VOLUME;
+ /* If the source implementor support DB volumes by itself, we should always
+ * try and enable flat volumes too */
+ if ((s->flags & PA_SOURCE_DECIBEL_VOLUME))
+ enable_flat_volume(s, TRUE);
if (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) {
pa_source *root_source = s->output_from_master->source;
&& ((s->flags & PA_SOURCE_DECIBEL_VOLUME || (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)))));
pa_assert(!(s->flags & PA_SOURCE_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
pa_assert(!(s->flags & PA_SOURCE_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0));
- pa_assert(!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) || s->set_volume);
- pa_assert(!(s->flags & PA_SOURCE_SYNC_VOLUME) || (s->flags & PA_SOURCE_HW_VOLUME_CTRL));
- pa_assert(!(s->flags & PA_SOURCE_SYNC_VOLUME) || s->write_volume);
- pa_assert(!(s->flags & PA_SOURCE_HW_MUTE_CTRL) || s->set_mute);
pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
return (s->monitor_of && pa_sink_is_passthrough(s->monitor_of));
}
+/* Called from main context */
+void pa_source_enter_passthrough(pa_source *s) {
+ pa_cvolume volume;
+
+ /* set the volume to NORM */
+ s->saved_volume = *pa_source_get_volume(s, TRUE);
+ s->saved_save_volume = s->save_volume;
+
+ pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
+ pa_source_set_volume(s, &volume, TRUE, FALSE);
+}
+
+/* Called from main context */
+void pa_source_leave_passthrough(pa_source *s) {
+ /* Restore source volume to what it was before we entered passthrough mode */
+ pa_source_set_volume(s, &s->saved_volume, TRUE, s->saved_save_volume);
+
+ pa_cvolume_init(&s->saved_volume);
+ s->saved_save_volume = FALSE;
+}
+
/* Called from main context. */
static void compute_reference_ratio(pa_source_output *o) {
unsigned c = 0;
/* Ignore this output. The origin source uses volume sharing, so this
* output's volume will be set to be equal to the root source's real
- * volume. Obviously this outputs's current volume must not then
+ * volume. Obviously this output's current volume must not then
* affect what the root source's real volume will be. */
continue;
}
* due to rounding errors. If that happens, we still want to propagate
* the changed root source volume to the sources connected to the
* intermediate source that didn't change its volume. This theoretical
- * possiblity is the reason why we have that !(s->flags &
+ * possibility is the reason why we have that !(s->flags &
* PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
* notice even if we returned here FALSE always if
* reference_volume_changed is FALSE. */
pa_assert(volume || pa_source_flat_volume_enabled(s));
pa_assert(!volume || volume->channels == 1 || pa_cvolume_compatible(volume, &s->sample_spec));
- /* make sure we don't change the volume when a PASSTHROUGH output is connected */
- if (pa_source_is_passthrough(s)) {
- /* FIXME: Need to notify client that volume control is disabled */
+ /* make sure we don't change the volume in PASSTHROUGH mode ...
+ * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
+ if (pa_source_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
pa_log_warn("Cannot change volume, Source is monitor of a PASSTHROUGH sink");
return;
}
* apply one to root_source->soft_volume */
pa_cvolume_reset(&root_source->soft_volume, root_source->sample_spec.channels);
- if (!(root_source->flags & PA_SOURCE_SYNC_VOLUME))
+ if (!(root_source->flags & PA_SOURCE_DEFERRED_VOLUME))
root_source->set_volume(root_source);
} else
pa_source_assert_ref(s);
pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER));
- if (s->flags & PA_SOURCE_SYNC_VOLUME)
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME)
pa_source_assert_io_context(s);
else
pa_assert_ctl_context();
else
s->soft_volume = *volume;
- if (PA_SOURCE_IS_LINKED(s->state) && !(s->flags & PA_SOURCE_SYNC_VOLUME))
+ if (PA_SOURCE_IS_LINKED(s->state) && !(s->flags & PA_SOURCE_DEFERRED_VOLUME))
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 = s->soft_volume;
old_real_volume = s->real_volume;
- if (!(s->flags & PA_SOURCE_SYNC_VOLUME) && s->get_volume)
+ if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume)
s->get_volume(s);
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_VOLUME, NULL, 0, NULL) == 0);
s->muted = mute;
s->save_muted = (old_muted == s->muted && s->save_muted) || save;
- if (!(s->flags & PA_SOURCE_SYNC_VOLUME) && s->set_mute)
+ if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->set_mute)
s->set_mute(s);
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
if (s->refresh_muted || force_refresh) {
pa_bool_t old_muted = s->muted;
- if (!(s->flags & PA_SOURCE_SYNC_VOLUME) && s->get_mute)
+ if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_mute)
s->get_mute(s);
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
/* We do not assert here. It is perfectly valid for a source output to
* be in the INIT state (i.e. created, marked done but not yet put)
* and we should not care if it's unlinked as it won't contribute
- * towarards our busy status.
+ * towards our busy status.
*/
if (!PA_SOURCE_OUTPUT_IS_LINKED(st))
continue;
case PA_SOURCE_MESSAGE_SET_VOLUME_SYNCED:
- if (s->flags & PA_SOURCE_SYNC_VOLUME) {
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
s->set_volume(s);
pa_source_volume_change_push(s);
}
case PA_SOURCE_MESSAGE_GET_VOLUME:
- if ((s->flags & PA_SOURCE_SYNC_VOLUME) && s->get_volume) {
+ if ((s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_volume) {
s->get_volume(s);
pa_source_volume_change_flush(s);
pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
s->thread_info.soft_muted = s->muted;
}
- if (s->flags & PA_SOURCE_SYNC_VOLUME && s->set_mute)
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->set_mute)
s->set_mute(s);
return 0;
case PA_SOURCE_MESSAGE_GET_MUTE:
- if (s->flags & PA_SOURCE_SYNC_VOLUME && s->get_mute)
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->get_mute)
s->get_mute(s);
return 0;
return 0;
}
- if (s->flags & PA_SOURCE_SYNC_VOLUME) {
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
struct source_message_set_port msg = { .port = port, .ret = 0 };
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
ret = msg.ret;
pa_bool_t ret = FALSE;
pa_assert(s);
+
+ if (!PA_SOURCE_IS_LINKED(s->state)) {
+ if (usec_to_next)
+ *usec_to_next = 0;
+ return ret;
+ }
+
pa_assert(s->write_volume);
while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {