pa_zero(*data);
data->proplist = pa_proplist_new();
+ data->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
return data;
}
data->channel_map = *map;
}
+void pa_source_new_data_set_alternate_sample_rate(pa_source_new_data *data, const uint32_t alternate_sample_rate) {
+ pa_assert(data);
+
+ data->alternate_sample_rate_is_set = TRUE;
+ data->alternate_sample_rate = alternate_sample_rate;
+}
+
void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *volume) {
pa_assert(data);
pa_proplist_free(data->proplist);
- if (data->ports) {
- pa_device_port *p;
-
- while ((p = pa_hashmap_steal_first(data->ports)))
- pa_device_port_free(p);
-
- pa_hashmap_free(data->ports, NULL, NULL);
- }
+ if (data->ports)
+ pa_device_port_hashmap_free(data->ports);
pa_xfree(data->name);
pa_xfree(data->active_port);
s->update_requested_latency = NULL;
s->set_port = NULL;
s->get_formats = NULL;
+ s->update_rate = NULL;
}
/* Called from main context */
s->state = PA_SOURCE_INIT;
s->flags = flags;
s->priority = 0;
- s->suspend_cause = 0;
+ s->suspend_cause = data->suspend_cause;
+ pa_source_set_mixer_dirty(s, FALSE);
s->name = pa_xstrdup(name);
s->proplist = pa_proplist_copy(data->proplist);
s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
s->sample_spec = data->sample_spec;
s->channel_map = data->channel_map;
+ s->default_sample_rate = s->sample_spec.rate;
+
+ if (data->alternate_sample_rate_is_set)
+ s->alternate_sample_rate = data->alternate_sample_rate;
+ else
+ s->alternate_sample_rate = s->core->alternate_sample_rate;
+
+ if (s->sample_spec.rate == s->alternate_sample_rate) {
+ pa_log_warn("Default and alternate sample rates are the same.");
+ s->alternate_sample_rate = 0;
+ }
s->outputs = pa_idxset_new(NULL, NULL);
s->n_corked = 0;
s->active_port = NULL;
s->save_port = FALSE;
- if (data->active_port && s->ports)
+ if (data->active_port)
if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
s->save_port = data->save_port;
- if (!s->active_port && s->ports) {
+ if (!s->active_port) {
void *state;
pa_device_port *p;
s->active_port = p;
}
+ if (s->active_port)
+ s->latency_offset = s->active_port->latency_offset;
+ else
+ s->latency_offset = 0;
+
s->save_volume = data->save_volume;
s->save_muted = data->save_muted;
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;
+ s->thread_info.latency_offset = s->latency_offset;
/* 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);
}
flags = s->flags;
if (cb)
- s->flags |= PA_SOURCE_SYNC_VOLUME;
+ s->flags |= PA_SOURCE_DEFERRED_VOLUME;
else
- s->flags &= ~PA_SOURCE_SYNC_VOLUME;
+ 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)
* 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_SYNC_VOLUME) || s->write_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
enable_flat_volume(s, TRUE);
if (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) {
- pa_source *root_source = s->output_from_master->source;
+ pa_source *root_source = pa_source_get_master(s);
- while (root_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
- root_source = root_source->output_from_master->source;
+ pa_assert(PA_LIKELY(root_source));
s->reference_volume = root_source->reference_volume;
pa_cvolume_remap(&s->reference_volume, &root_source->channel_map, &s->channel_map);
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_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
+ if (s->suspend_cause)
+ pa_assert_se(source_set_state(s, PA_SOURCE_SUSPENDED) == 0);
+ else
+ 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);
pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
if (s->proplist)
pa_proplist_free(s->proplist);
- if (s->ports) {
- pa_device_port *p;
-
- while ((p = pa_hashmap_steal_first(s->ports)))
- pa_device_port_free(p);
-
- pa_hashmap_free(s->ports, NULL, NULL);
- }
+ if (s->ports)
+ pa_device_port_hashmap_free(s->ports);
pa_xfree(s);
}
return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
}
+/* Called from any context - must be threadsafe */
+void pa_source_set_mixer_dirty(pa_source *s, pa_bool_t is_dirty)
+{
+ pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
+}
+
/* Called from main context */
int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
pa_source_assert_ref(s);
else
s->suspend_cause &= ~cause;
+ if (!(s->suspend_cause & PA_SUSPEND_SESSION) && (pa_atomic_load(&s->mixer_dirty) != 0)) {
+ /* This might look racy but isn't: If somebody sets mixer_dirty exactly here,
+ it'll be handled just fine. */
+ pa_source_set_mixer_dirty(s, FALSE);
+ pa_log_debug("Mixer is now accessible. Updating alsa mixer settings.");
+ if (s->active_port && s->set_port) {
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
+ struct source_message_set_port msg = { .port = s->active_port, .ret = 0 };
+ pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
+ }
+ else
+ s->set_port(s, s->active_port);
+ }
+ else {
+ if (s->set_mute)
+ s->set_mute(s);
+ if (s->set_volume)
+ s->set_volume(s);
+ }
+ }
+
if ((pa_source_get_state(s) == PA_SOURCE_SUSPENDED) == !!s->suspend_cause)
return 0;
pa_source_output_unref(o);
}
- pa_queue_free(q, NULL, NULL);
+ pa_queue_free(q, NULL);
}
/* Called from main context */
pa_source_output_unref(o);
}
- pa_queue_free(q, NULL, NULL);
+ pa_queue_free(q, NULL);
}
/* Called from IO thread context */
pa_source_output_push(o, chunk);
}
+/* Called from main thread */
+pa_bool_t pa_source_update_rate(pa_source *s, uint32_t rate, pa_bool_t passthrough)
+{
+ if (s->update_rate) {
+ uint32_t desired_rate = rate;
+ uint32_t default_rate = s->default_sample_rate;
+ uint32_t alternate_rate = s->alternate_sample_rate;
+ uint32_t idx;
+ pa_source_output *o;
+ pa_bool_t use_alternate = FALSE;
+
+ if (PA_UNLIKELY(default_rate == alternate_rate)) {
+ pa_log_warn("Default and alternate sample rates are the same.");
+ return FALSE;
+ }
+
+ if (PA_SOURCE_IS_RUNNING(s->state)) {
+ pa_log_info("Cannot update rate, SOURCE_IS_RUNNING, will keep using %u Hz",
+ s->sample_spec.rate);
+ return FALSE;
+ }
+
+ if (PA_UNLIKELY (desired_rate < 8000 ||
+ desired_rate > PA_RATE_MAX))
+ return FALSE;
+
+ if (!passthrough) {
+ pa_assert(default_rate % 4000 || default_rate % 11025);
+ pa_assert(alternate_rate % 4000 || alternate_rate % 11025);
+
+ if (default_rate % 4000) {
+ /* default is a 11025 multiple */
+ if ((alternate_rate % 4000 == 0) && (desired_rate % 4000 == 0))
+ use_alternate=TRUE;
+ } else {
+ /* default is 4000 multiple */
+ if ((alternate_rate % 11025 == 0) && (desired_rate % 11025 == 0))
+ use_alternate=TRUE;
+ }
+
+ if (use_alternate)
+ desired_rate = alternate_rate;
+ else
+ desired_rate = default_rate;
+ } else {
+ desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
+ }
+
+ if (!passthrough && pa_source_used_by(s) > 0)
+ return FALSE;
+
+ pa_source_suspend(s, TRUE, PA_SUSPEND_IDLE); /* needed before rate update, will be resumed automatically */
+
+ if (s->update_rate(s, desired_rate) == TRUE) {
+ pa_log_info("Changed sampling rate successfully ");
+
+ PA_IDXSET_FOREACH(o, s->outputs, idx) {
+ if (o->state == PA_SOURCE_OUTPUT_CORKED)
+ pa_source_output_update_rate(o);
+ }
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
/* Called from main thread */
pa_usec_t pa_source_get_latency(pa_source *s) {
pa_usec_t usec;
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
+ /* usec is unsigned, so check that the offset can be added to usec without
+ * underflowing. */
+ if (-s->latency_offset <= (int64_t) usec)
+ usec += s->latency_offset;
+ else
+ usec = 0;
+
return usec;
}
if (o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
return -1;
+ /* usec is unsigned, so check that the offset can be added to usec without
+ * underflowing. */
+ if (-s->thread_info.latency_offset <= (int64_t) usec)
+ usec += s->thread_info.latency_offset;
+ else
+ usec = 0;
+
return usec;
}
pa_bool_t pa_source_flat_volume_enabled(pa_source *s) {
pa_source_assert_ref(s);
- while (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
+ s = pa_source_get_master(s);
+
+ if (PA_LIKELY(s))
+ return (s->flags & PA_SOURCE_FLAT_VOLUME);
+ else
+ return FALSE;
+}
+
+/* Called from the main thread (and also from the IO thread while the main
+ * thread is waiting). */
+pa_source *pa_source_get_master(pa_source *s) {
+ pa_source_assert_ref(s);
+
+ while (s && (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
+ if (PA_UNLIKELY(!s->output_from_master))
+ return NULL;
+
s = s->output_from_master->source;
+ }
- return (s->flags & PA_SOURCE_FLAT_VOLUME);
+ return s;
}
/* Called from main context */
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_VOLUME_NORM);
+ pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
pa_source_set_volume(s, &volume, TRUE, FALSE);
}
/* 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_bool_t save) {
pa_cvolume new_reference_volume;
- pa_source *root_source = s;
+ pa_source *root_source;
pa_source_assert_ref(s);
pa_assert_ctl_context();
/* 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");
+ pa_log_warn("Cannot change volume, source is monitor of a PASSTHROUGH sink");
return;
}
/* In case of volume sharing, the volume is set for the root source first,
* from which it's then propagated to the sharing sources. */
- while (root_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
- root_source = root_source->output_from_master->source;
+ root_source = pa_source_get_master(s);
+
+ if (PA_UNLIKELY(!root_source))
+ return;
/* As a special exception we accept mono volumes on all sources --
* even on those with more complex channel maps */
}
pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
- }
- /* If volume is NULL we synchronize the source's real and reference
- * volumes with the stream volumes. If it is not NULL we update
- * the reference_volume with it. */
-
- if (volume) {
if (update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save)) {
if (pa_source_flat_volume_enabled(root_source)) {
/* OK, propagate this volume change back to the outputs */
}
} else {
+ /* If volume is NULL we synchronize the source's real and
+ * reference volumes with the stream volumes. */
+
pa_assert(pa_source_flat_volume_enabled(root_source));
/* Ok, let's determine the new real volume */
/* Let's 'push' the reference volume if necessary */
pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_source->real_volume);
+ /* If the source and it's root don't have the same number of channels, we need to remap */
+ if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
+ pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save);
/* Now that the reference volume is updated, we can update the streams'
* 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_SHARED_VOLUME: {
- pa_source *root_source = s;
+ pa_source *root_source = pa_source_get_master(s);
- while (root_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
- root_source = root_source->output_from_master->source;
+ if (PA_LIKELY(root_source))
+ set_shared_volume_within_thread(root_source);
- set_shared_volume_within_thread(root_source);
return 0;
}
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;
/* This message is sent from IO-thread and handled in main thread. */
pa_assert_ctl_context();
+ /* Make sure we're not messing with main thread when no longer linked */
+ if (!PA_SOURCE_IS_LINKED(s->state))
+ return 0;
+
pa_source_get_volume(s, TRUE);
pa_source_get_mute(s, TRUE);
return 0;
+ case PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET:
+ s->thread_info.latency_offset = offset;
+ return 0;
+
case PA_SOURCE_MESSAGE_MAX:
;
}
pa_source_invalidate_requested_latency(s, FALSE);
}
+/* Called from main thread */
+void pa_source_set_latency_offset(pa_source *s, int64_t offset) {
+ pa_source_assert_ref(s);
+
+ s->latency_offset = offset;
+
+ if (PA_SOURCE_IS_LINKED(s->state))
+ pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
+ else
+ s->thread_info.latency_offset = offset;
+}
+
/* Called from main thread */
size_t pa_source_get_max_rewind(pa_source *s) {
size_t r;
return -PA_ERR_NOTIMPLEMENTED;
}
- if (!s->ports)
+ if (!name)
return -PA_ERR_NOENTITY;
if (!(port = pa_hashmap_get(s->ports, name)))
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;
/* Called from the IO thread. */
pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
- pa_usec_t now = pa_rtclock_now();
+ pa_usec_t now;
pa_bool_t ret = FALSE;
pa_assert(s);
- if (!PA_SOURCE_IS_LINKED(s->state)) {
+ if (!s->thread_info.volume_changes || !PA_SOURCE_IS_LINKED(s->state)) {
if (usec_to_next)
*usec_to_next = 0;
return ret;
pa_assert(s->write_volume);
+ now = pa_rtclock_now();
+
while (s->thread_info.volume_changes && now >= s->thread_info.volume_changes->at) {
pa_source_volume_change *c = s->thread_info.volume_changes;
PA_LLIST_REMOVE(pa_source_volume_change, s->thread_info.volume_changes, c);
pa_source_volume_change_free(c);
}
- if (s->write_volume && ret)
+ if (ret)
s->write_volume(s);
if (s->thread_info.volume_changes) {