General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
- along with PulseAudio; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
- USA.
+ along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
***/
#ifdef HAVE_CONFIG_H
PA_LLIST_FIELDS(pa_source_volume_change);
};
-struct source_message_set_port {
- pa_device_port *port;
- int ret;
+struct set_state_data {
+ pa_source_state_t state;
+ pa_suspend_cause_t suspend_cause;
};
static void source_free(pa_object *o);
pa_assert(data);
data->muted_is_set = true;
- data->muted = !!mute;
+ data->muted = mute;
}
void pa_source_new_data_set_port(pa_source_new_data *data, const char *port) {
static void reset_callbacks(pa_source *s) {
pa_assert(s);
- s->set_state = NULL;
+ s->set_state_in_main_thread = NULL;
+ s->set_state_in_io_thread = NULL;
s->get_volume = NULL;
s->set_volume = NULL;
s->write_volume = NULL;
s->update_requested_latency = NULL;
s->set_port = NULL;
s->get_formats = NULL;
- s->update_rate = NULL;
+ s->reconfigure = NULL;
}
/* Called from main context */
if (data->card)
pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
- pa_device_init_description(data->proplist);
+ pa_device_init_description(data->proplist, data->card);
pa_device_init_icon(data->proplist, false);
pa_device_init_intended_roles(data->proplist);
+ if (!data->active_port) {
+ pa_device_port *p = pa_device_port_find_best(data->ports);
+ if (p)
+ pa_source_new_data_set_port(data, p->name);
+ }
+
if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], data) < 0) {
pa_xfree(s);
pa_namereg_unregister(core, name);
s->flags = flags;
s->priority = 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));
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->avoid_resampling = data->avoid_resampling;
s->outputs = pa_idxset_new(NULL, NULL);
s->n_corked = 0;
if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
s->save_port = data->save_port;
- if (!s->active_port) {
- void *state;
- pa_device_port *p;
-
- PA_HASHMAP_FOREACH(p, s->ports, state) {
- if (p->available == PA_AVAILABLE_NO)
- continue;
-
- if (!s->active_port || p->priority > s->active_port->priority)
- s->active_port = p;
- }
-
- if (!s->active_port) {
- PA_HASHMAP_FOREACH(p, s->ports, state)
- if (!s->active_port || p->priority > s->active_port->priority)
- s->active_port = p;
- }
- }
+ /* Hopefully the active port has already been assigned in the previous call
+ to pa_device_port_find_best, but better safe than sorry */
+ if (!s->active_port)
+ s->active_port = pa_device_port_find_best(s->ports);
if (s->active_port)
- s->latency_offset = s->active_port->latency_offset;
+ s->port_latency_offset = s->active_port->latency_offset;
else
- s->latency_offset = 0;
+ s->port_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);
+ pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
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;
+ s->thread_info.port_latency_offset = s->port_latency_offset;
/* FIXME: This should probably be moved to pa_source_put() */
pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
}
/* Called from main context */
-static int source_set_state(pa_source *s, pa_source_state_t state) {
- int ret;
- bool suspend_change;
- pa_source_state_t original_state;
+static int source_set_state(pa_source *s, pa_source_state_t state, pa_suspend_cause_t suspend_cause) {
+ int ret = 0;
+ bool state_changed;
+ bool suspend_cause_changed;
+ bool suspending;
+ bool resuming;
+ pa_source_state_t old_state;
+ pa_suspend_cause_t old_suspend_cause;
pa_assert(s);
pa_assert_ctl_context();
- if (s->state == state)
+ state_changed = state != s->state;
+ suspend_cause_changed = suspend_cause != s->suspend_cause;
+
+ if (!state_changed && !suspend_cause_changed)
return 0;
- original_state = s->state;
+ suspending = PA_SOURCE_IS_OPENED(s->state) && state == PA_SOURCE_SUSPENDED;
+ resuming = s->state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(state);
+
+ /* If we are resuming, suspend_cause must be 0. */
+ pa_assert(!resuming || !suspend_cause);
+
+ /* Here's something to think about: what to do with the suspend cause if
+ * resuming the source fails? The old suspend cause will be incorrect, so we
+ * can't use that. On the other hand, if we set no suspend cause (as is the
+ * case currently), then it looks strange to have a source suspended without
+ * any cause. It might be a good idea to add a new "resume failed" suspend
+ * cause, or it might just add unnecessary complexity, given that the
+ * current approach of not setting any suspend cause works well enough. */
+
+ if (s->set_state_in_main_thread) {
+ if ((ret = s->set_state_in_main_thread(s, state, suspend_cause)) < 0) {
+ /* set_state_in_main_thread() is allowed to fail only when resuming. */
+ pa_assert(resuming);
+
+ /* If resuming fails, we set the state to SUSPENDED and
+ * suspend_cause to 0. */
+ state = PA_SOURCE_SUSPENDED;
+ suspend_cause = 0;
+ state_changed = false;
+ suspend_cause_changed = suspend_cause != s->suspend_cause;
+ resuming = false;
+
+ /* We know the state isn't changing. If the suspend cause isn't
+ * changing either, then there's nothing more to do. */
+ if (!suspend_cause_changed)
+ return ret;
+ }
+ }
- suspend_change =
- (original_state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(state)) ||
- (PA_SOURCE_IS_OPENED(original_state) && state == PA_SOURCE_SUSPENDED);
+ if (s->asyncmsgq) {
+ struct set_state_data data = { .state = state, .suspend_cause = suspend_cause };
- if (s->set_state)
- if ((ret = s->set_state(s, state)) < 0)
- return ret;
+ if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_STATE, &data, 0, NULL)) < 0) {
+ /* SET_STATE is allowed to fail only when resuming. */
+ pa_assert(resuming);
- if (s->asyncmsgq)
- if ((ret = pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_STATE, PA_UINT_TO_PTR(state), 0, NULL)) < 0) {
+ if (s->set_state_in_main_thread)
+ s->set_state_in_main_thread(s, PA_SOURCE_SUSPENDED, 0);
- if (s->set_state)
- s->set_state(s, original_state);
+ /* If resuming fails, we set the state to SUSPENDED and
+ * suspend_cause to 0. */
+ state = PA_SOURCE_SUSPENDED;
+ suspend_cause = 0;
+ state_changed = false;
+ suspend_cause_changed = suspend_cause != s->suspend_cause;
+ resuming = false;
- return ret;
+ /* We know the state isn't changing. If the suspend cause isn't
+ * changing either, then there's nothing more to do. */
+ if (!suspend_cause_changed)
+ return ret;
}
+ }
- s->state = state;
+ old_suspend_cause = s->suspend_cause;
+ if (suspend_cause_changed) {
+ char old_cause_buf[PA_SUSPEND_CAUSE_TO_STRING_BUF_SIZE];
+ char new_cause_buf[PA_SUSPEND_CAUSE_TO_STRING_BUF_SIZE];
- 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);
+ pa_log_debug("%s: suspend_cause: %s -> %s", s->name, pa_suspend_cause_to_string(s->suspend_cause, old_cause_buf),
+ pa_suspend_cause_to_string(suspend_cause, new_cause_buf));
+ s->suspend_cause = suspend_cause;
}
- if (suspend_change) {
+ old_state = s->state;
+ if (state_changed) {
+ pa_log_debug("%s: state: %s -> %s", s->name, pa_source_state_to_string(s->state), pa_source_state_to_string(state));
+ s->state = state;
+
+ /* If we enter UNLINKED state, then we don't send change notifications.
+ * pa_source_unlink() will send unlink notifications instead. */
+ if (state != PA_SOURCE_UNLINKED) {
+ 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);
+ }
+ }
+
+ if (suspending || resuming || suspend_cause_changed) {
pa_source_output *o;
uint32_t idx;
(o->flags & PA_SOURCE_OUTPUT_KILL_ON_SUSPEND))
pa_source_output_kill(o);
else if (o->suspend)
- o->suspend(o, state == PA_SOURCE_SUSPENDED);
+ o->suspend(o, old_state, old_suspend_cause);
}
- return 0;
+ return ret;
}
void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb) {
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) {
+void pa_source_set_get_mute_callback(pa_source *s, pa_source_get_mute_cb_t cb) {
pa_assert(s);
s->get_mute = cb;
pa_assert_ctl_context();
pa_assert(s->state == PA_SOURCE_INIT);
- pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || s->output_from_master);
+ pa_assert(!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || pa_source_is_filter(s));
/* The following fields must be initialized properly when calling _put() */
pa_assert(s->asyncmsgq);
* 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))
+ if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
pa_source_enable_decibel_volume(s, true);
+ s->soft_volume = s->reference_volume;
+ }
/* If the source implementor support DB volumes by itself, we should always
* try and enable flat volumes too */
s->thread_info.soft_volume = s->soft_volume;
s->thread_info.soft_muted = s->muted;
- pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
+ pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
pa_assert((s->flags & PA_SOURCE_HW_VOLUME_CTRL)
|| (s->base_volume == PA_VOLUME_NORM
&& ((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_DYNAMIC_LATENCY) == !(s->thread_info.fixed_latency == 0));
if (s->suspend_cause)
- pa_assert_se(source_set_state(s, PA_SOURCE_SUSPENDED) == 0);
+ pa_assert_se(source_set_state(s, PA_SOURCE_SUSPENDED, s->suspend_cause) == 0);
else
- pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
+ pa_assert_se(source_set_state(s, PA_SOURCE_IDLE, 0) == 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);
+
+ /* This function must be called after the PA_CORE_HOOK_SOURCE_PUT hook,
+ * because module-switch-on-connect needs to know the old default source */
+ pa_core_update_default_source(s->core);
}
/* Called from main context */
void pa_source_unlink(pa_source *s) {
bool linked;
- pa_source_output *o, *j = NULL;
+ pa_source_output *o, PA_UNUSED *j = NULL;
- pa_assert(s);
+ pa_source_assert_ref(s);
pa_assert_ctl_context();
/* See pa_sink_unlink() for a couple of comments how this function
* works. */
+ if (s->unlink_requested)
+ return;
+
+ s->unlink_requested = true;
+
linked = PA_SOURCE_IS_LINKED(s->state);
if (linked)
pa_namereg_unregister(s->core, s->name);
pa_idxset_remove_by_data(s->core->sources, s, NULL);
+ pa_core_update_default_source(s->core);
+
if (s->card)
pa_idxset_remove_by_data(s->card->sources, s, NULL);
}
if (linked)
- source_set_state(s, PA_SOURCE_UNLINKED);
+ /* It's important to keep the suspend cause unchanged when unlinking,
+ * because if we remove the SESSION suspend cause here, the alsa
+ * source will sync its volume with the hardware while another user is
+ * active, messing up the volume for that other user. */
+ source_set_state(s, PA_SOURCE_UNLINKED, s->suspend_cause);
else
s->state = PA_SOURCE_UNLINKED;
pa_assert(s);
pa_assert_ctl_context();
pa_assert(pa_source_refcnt(s) == 0);
-
- if (PA_SOURCE_IS_LINKED(s->state))
- pa_source_unlink(s);
+ pa_assert(!PA_SOURCE_IS_LINKED(s->state));
pa_log_info("Freeing source %u \"%s\"", s->index, s->name);
+ pa_source_volume_change_flush(s);
+
pa_idxset_free(s->outputs, NULL);
pa_hashmap_free(s->thread_info.outputs);
if (s->state == PA_SOURCE_SUSPENDED)
return 0;
- 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, bool is_dirty) {
- pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
+ return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE, 0);
}
/* Called from main context */
int pa_source_suspend(pa_source *s, bool suspend, pa_suspend_cause_t cause) {
+ pa_suspend_cause_t merged_cause;
+
pa_source_assert_ref(s);
pa_assert_ctl_context();
pa_assert(PA_SOURCE_IS_LINKED(s->state));
return -PA_ERR_NOTSUPPORTED;
if (suspend)
- s->suspend_cause |= cause;
+ merged_cause = s->suspend_cause | cause;
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;
+ merged_cause = s->suspend_cause & ~cause;
- pa_log_debug("Suspend cause of source %s is 0x%04x, %s", s->name, s->suspend_cause, s->suspend_cause ? "suspending" : "resuming");
-
- if (s->suspend_cause)
- return source_set_state(s, PA_SOURCE_SUSPENDED);
+ if (merged_cause)
+ return source_set_state(s, PA_SOURCE_SUSPENDED, merged_cause);
else
- return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
+ return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE, 0);
}
/* Called from main context */
int pa_source_sync_suspend(pa_source *s) {
pa_sink_state_t state;
+ pa_suspend_cause_t suspend_cause;
pa_source_assert_ref(s);
pa_assert_ctl_context();
pa_assert(PA_SOURCE_IS_LINKED(s->state));
pa_assert(s->monitor_of);
- state = pa_sink_get_state(s->monitor_of);
+ state = s->monitor_of->state;
+ suspend_cause = s->monitor_of->suspend_cause;
+
+ /* The monitor source usually has the same state and suspend cause as the
+ * sink, the only exception is when the monitor source is suspended due to
+ * the sink being in the passthrough mode. If the monitor currently has the
+ * PASSTHROUGH suspend cause, then we have to keep the monitor suspended
+ * even if the sink is running. */
+ if (s->suspend_cause & PA_SUSPEND_PASSTHROUGH)
+ suspend_cause |= PA_SUSPEND_PASSTHROUGH;
- if (state == PA_SINK_SUSPENDED)
- return source_set_state(s, PA_SOURCE_SUSPENDED);
+ if (state == PA_SINK_SUSPENDED || suspend_cause)
+ return source_set_state(s, PA_SOURCE_SUSPENDED, suspend_cause);
pa_assert(PA_SINK_IS_OPENED(state));
- return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
+ return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE, 0);
}
/* Called from main context */
pa_assert(q);
while ((o = PA_SOURCE_OUTPUT(pa_queue_pop(q)))) {
- if (pa_source_output_finish_move(o, s, save) < 0)
- pa_source_output_fail_move(o);
+ if (PA_SOURCE_OUTPUT_IS_LINKED(o->state)) {
+ if (pa_source_output_finish_move(o, s, save) < 0)
+ pa_source_output_fail_move(o);
+ }
pa_source_output_unref(o);
}
}
/* Called from main thread */
-int pa_source_update_rate(pa_source *s, uint32_t rate, bool passthrough) {
- int ret;
- uint32_t desired_rate = rate;
+void pa_source_reconfigure(pa_source *s, pa_sample_spec *spec, bool passthrough) {
+ uint32_t idx;
+ pa_source_output *o;
+ pa_sample_spec desired_spec;
uint32_t default_rate = s->default_sample_rate;
uint32_t alternate_rate = s->alternate_sample_rate;
- bool use_alternate = false;
+ bool default_rate_is_usable = false;
+ bool alternate_rate_is_usable = false;
+ bool avoid_resampling = s->avoid_resampling;
- if (rate == s->sample_spec.rate)
- return 0;
+ if (pa_sample_spec_equal(spec, &s->sample_spec))
+ return;
- if (!s->update_rate && !s->monitor_of)
- return -1;
+ if (!s->reconfigure && !s->monitor_of)
+ return;
- if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough)) {
- pa_log_debug("Default and alternate sample rates are the same.");
- return -1;
+ if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough && !avoid_resampling)) {
+ pa_log_debug("Default and alternate sample rates are the same, so there is no point in switching.");
+ return;
}
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 -1;
+ pa_log_info("Cannot update sample spec, SOURCE_IS_RUNNING, will keep using %s and %u Hz",
+ pa_sample_format_to_string(s->sample_spec.format), s->sample_spec.rate);
+ return;
}
if (s->monitor_of) {
if (PA_SINK_IS_RUNNING(s->monitor_of->state)) {
- pa_log_info("Cannot update rate, this is a monitor source and the sink is running.");
- return -1;
+ pa_log_info("Cannot update sample spec, this is a monitor source and the sink is running.");
+ return;
}
}
- if (PA_UNLIKELY(!pa_sample_rate_valid(desired_rate)))
- return -1;
+ if (PA_UNLIKELY(!pa_sample_spec_valid(spec)))
+ return;
- if (!passthrough) {
- pa_assert((default_rate % 4000 == 0) || (default_rate % 11025 == 0));
- pa_assert((alternate_rate % 4000 == 0) || (alternate_rate % 11025 == 0));
+ desired_spec = s->sample_spec;
- if (default_rate % 11025 == 0) {
- 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 (passthrough) {
+ /* We have to try to use the source output format and rate */
+ desired_spec.format = spec->format;
+ desired_spec.rate = spec->rate;
+
+ } else if (avoid_resampling) {
+ /* We just try to set the source output's sample rate if it's not too low */
+ if (spec->rate >= default_rate || spec->rate >= alternate_rate)
+ desired_spec.rate = spec->rate;
+ desired_spec.format = spec->format;
+
+ } else if (default_rate == spec->rate || alternate_rate == spec->rate) {
+ /* We can directly try to use this rate */
+ desired_spec.rate = spec->rate;
- if (use_alternate)
- desired_rate = alternate_rate;
+ }
+
+ if (desired_spec.rate != spec->rate) {
+ /* See if we can pick a rate that results in less resampling effort */
+ if (default_rate % 11025 == 0 && spec->rate % 11025 == 0)
+ default_rate_is_usable = true;
+ if (default_rate % 4000 == 0 && spec->rate % 4000 == 0)
+ default_rate_is_usable = true;
+ if (alternate_rate % 11025 == 0 && spec->rate % 11025 == 0)
+ alternate_rate_is_usable = true;
+ if (alternate_rate % 4000 == 0 && spec->rate % 4000 == 0)
+ alternate_rate_is_usable = true;
+
+ if (alternate_rate_is_usable && !default_rate_is_usable)
+ desired_spec.rate = alternate_rate;
else
- desired_rate = default_rate;
- } else {
- desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
+ desired_spec.rate = default_rate;
}
- if (desired_rate == s->sample_spec.rate)
- return -1;
+ if (pa_sample_spec_equal(&desired_spec, &s->sample_spec) && passthrough == pa_source_is_passthrough(s))
+ return;
if (!passthrough && pa_source_used_by(s) > 0)
- return -1;
+ return;
- pa_log_debug("Suspending source %s due to changing the sample rate.", s->name);
+ pa_log_debug("Suspending source %s due to changing format, desired format = %s rate = %u",
+ s->name, pa_sample_format_to_string(desired_spec.format), desired_spec.rate);
pa_source_suspend(s, true, PA_SUSPEND_INTERNAL);
- if (s->update_rate)
- ret = s->update_rate(s, desired_rate);
+ if (s->reconfigure)
+ s->reconfigure(s, &desired_spec, passthrough);
else {
/* This is a monitor source. */
* have no idea whether the behaviour with passthrough streams is
* sensible. */
if (!passthrough) {
- uint32_t old_rate = s->sample_spec.rate;
-
- s->sample_spec.rate = desired_rate;
- ret = pa_sink_update_rate(s->monitor_of, desired_rate, false);
-
- if (ret < 0) {
- /* Changing the sink rate failed, roll back the old rate for
- * the monitor source. Why did we set the source rate before
- * calling pa_sink_update_rate(), you may ask. The reason is
- * that pa_sink_update_rate() tries to update the monitor
- * source rate, but we are already in the process of updating
- * the monitor source rate, so there's a risk of entering an
- * infinite loop. Setting the source rate before calling
- * pa_sink_update_rate() makes the rate == s->sample_spec.rate
- * check in the beginning of this function return early, so we
- * avoid looping. */
- s->sample_spec.rate = old_rate;
- }
+ s->sample_spec = desired_spec;
+ pa_sink_reconfigure(s->monitor_of, &desired_spec, false);
+ s->sample_spec = s->monitor_of->sample_spec;
} else
- ret = -1;
+ goto unsuspend;
}
- if (ret >= 0) {
- uint32_t idx;
- pa_source_output *o;
-
- PA_IDXSET_FOREACH(o, s->outputs, idx) {
- if (o->state == PA_SOURCE_OUTPUT_CORKED)
- pa_source_output_update_rate(o);
- }
-
- 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_resampler(o);
}
- pa_source_suspend(s, false, PA_SUSPEND_INTERNAL);
+ pa_log_info("Reconfigured successfully");
- return ret;
+unsuspend:
+ pa_source_suspend(s, false, PA_SUSPEND_INTERNAL);
}
/* Called from main thread */
pa_usec_t pa_source_get_latency(pa_source *s) {
- pa_usec_t usec;
+ int64_t usec;
pa_source_assert_ref(s);
pa_assert_ctl_context();
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
+ /* The return value 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;
+ if (-s->port_latency_offset <= usec)
+ usec += s->port_latency_offset;
else
usec = 0;
- return usec;
+ return (pa_usec_t)usec;
}
/* Called from IO thread */
-pa_usec_t pa_source_get_latency_within_thread(pa_source *s) {
- pa_usec_t usec = 0;
+int64_t pa_source_get_latency_within_thread(pa_source *s, bool allow_negative) {
+ int64_t usec = 0;
pa_msgobject *o;
pa_source_assert_ref(s);
/* FIXME: We probably should make this a proper vtable callback instead of going through process_msg() */
- if (o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
- return -1;
+ o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL);
- /* 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
+ /* If allow_negative is false, the call should only return positive values, */
+ usec += s->thread_info.port_latency_offset;
+ if (!allow_negative && usec < 0)
usec = 0;
return usec;
}
/* Called from main context */
+bool pa_source_is_filter(pa_source *s) {
+ pa_source_assert_ref(s);
+
+ return (s->output_from_master != NULL);
+}
+
+/* Called from main context */
bool pa_source_is_passthrough(pa_source *s) {
pa_source_assert_ref(s);
static void compute_reference_ratio(pa_source_output *o) {
unsigned c = 0;
pa_cvolume remapped;
+ pa_cvolume ratio;
pa_assert(o);
pa_assert(pa_source_flat_volume_enabled(o->source));
remapped = o->source->reference_volume;
pa_cvolume_remap(&remapped, &o->source->channel_map, &o->channel_map);
- o->reference_ratio.channels = o->sample_spec.channels;
+ ratio = o->reference_ratio;
for (c = 0; c < o->sample_spec.channels; c++) {
/* Don't update the reference ratio unless necessary */
if (pa_sw_volume_multiply(
- o->reference_ratio.values[c],
+ ratio.values[c],
remapped.values[c]) == o->volume.values[c])
continue;
- o->reference_ratio.values[c] = pa_sw_volume_divide(
+ ratio.values[c] = pa_sw_volume_divide(
o->volume.values[c],
remapped.values[c]);
}
+
+ pa_source_output_set_reference_ratio(o, &ratio);
}
/* Called from main context. Only called for the root source in volume sharing
PA_IDXSET_FOREACH(o, s->outputs, idx) {
compute_reference_ratio(o);
- if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
+ if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
+ && PA_SOURCE_IS_LINKED(o->destination_source->state))
compute_reference_ratios(o->destination_source);
}
}
pa_cvolume_reset(&o->real_ratio, o->real_ratio.channels);
o->soft_volume = o->volume_factor;
- compute_real_ratios(o->destination_source);
+ if (PA_SOURCE_IS_LINKED(o->destination_source->state))
+ compute_real_ratios(o->destination_source);
continue;
}
pa_cvolume remapped;
if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
- get_maximum_output_volume(o->destination_source, max_volume, channel_map);
+ if (PA_SOURCE_IS_LINKED(o->destination_source->state))
+ get_maximum_output_volume(o->destination_source, max_volume, channel_map);
/* 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
PA_IDXSET_FOREACH(o, s->outputs, idx) {
if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
if (pa_source_flat_volume_enabled(s)) {
- pa_cvolume old_volume = o->volume;
+ pa_cvolume new_output_volume;
/* Follow the root source's real volume. */
- o->volume = *new_volume;
- pa_cvolume_remap(&o->volume, channel_map, &o->channel_map);
+ new_output_volume = *new_volume;
+ pa_cvolume_remap(&new_output_volume, channel_map, &o->channel_map);
+ pa_source_output_set_volume_direct(o, &new_output_volume);
compute_reference_ratio(o);
-
- /* The volume changed, let's tell people so */
- if (!pa_cvolume_equal(&old_volume, &o->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);
- }
}
- update_real_volume(o->destination_source, new_volume, channel_map);
+ if (PA_SOURCE_IS_LINKED(o->destination_source->state))
+ update_real_volume(o->destination_source, new_volume, channel_map);
}
}
}
* source output volumes accordingly */
PA_IDXSET_FOREACH(o, s->outputs, idx) {
- pa_cvolume old_volume;
+ pa_cvolume new_volume;
if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
- propagate_reference_volume(o->destination_source);
+ if (PA_SOURCE_IS_LINKED(o->destination_source->state))
+ propagate_reference_volume(o->destination_source);
/* Since the origin source uses volume sharing, this output's volume
* needs to be updated to match the root source's real volume, but
- * that will be done later in update_shared_real_volume(). */
+ * that will be done later in update_real_volume(). */
continue;
}
- old_volume = o->volume;
-
/* This basically calculates:
*
* o->volume := o->reference_volume * o->reference_ratio */
- o->volume = s->reference_volume;
- pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
- pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
-
- /* The volume changed, let's tell people so */
- if (!pa_cvolume_equal(&old_volume, &o->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);
- }
+ new_volume = s->reference_volume;
+ pa_cvolume_remap(&new_volume, &s->channel_map, &o->channel_map);
+ pa_sw_cvolume_multiply(&new_volume, &new_volume, &o->reference_ratio);
+ pa_source_output_set_volume_direct(o, &new_volume);
}
}
pa_cvolume_remap(&volume, channel_map, &s->channel_map);
reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
- s->reference_volume = volume;
+ pa_source_set_reference_volume_direct(s, &volume);
s->save_volume = (!reference_volume_changed && s->save_volume) || save;
- if (reference_volume_changed)
- pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
- else if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
+ if (!reference_volume_changed && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
/* If the root source's volume doesn't change, then there can't be any
* changes in the other source in the source tree either.
*
return false;
PA_IDXSET_FOREACH(o, s->outputs, idx) {
- if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
+ if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
+ && PA_SOURCE_IS_LINKED(o->destination_source->state))
update_reference_volume(o->destination_source, v, channel_map, false);
}
bool send_msg,
bool save) {
- pa_cvolume new_reference_volume;
+ pa_cvolume new_reference_volume, root_real_volume;
pa_source *root_source;
pa_source_assert_ref(s);
/* Ok, let's determine the new real volume */
compute_real_volume(root_source);
- /* 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 its root don't have the same number of channels, we need to remap */
+ /* To propagate the reference volume from the filter to the root source,
+ * we first take the real volume from the root source and remap it to
+ * match the filter. Then, we merge in the reference volume from the
+ * filter on top of this, and remap it back to the root source channel
+ * count and map */
+ root_real_volume = root_source->real_volume;
+ /* First we remap root's real volume to filter channel count and map if needed */
+ if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
+ pa_cvolume_remap(&root_real_volume, &root_source->channel_map, &s->channel_map);
+ /* Then let's 'push' the reference volume if necessary */
+ pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_real_volume);
+ /* If the source and its root don't have the same number of channels, we need to remap back */
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'
}
if (pa_source_flat_volume_enabled(s)) {
-
PA_IDXSET_FOREACH(o, s->outputs, idx) {
- pa_cvolume old_volume = o->volume;
+ pa_cvolume new_volume;
/* 2. Since the source's reference and real volumes are equal
* now our ratios should be too. */
- o->reference_ratio = o->real_ratio;
+ pa_source_output_set_reference_ratio(o, &o->real_ratio);
/* 3. Recalculate the new stream reference volume based on the
* reference ratio and the sink's reference volume.
* o->volume = s->reference_volume * o->reference_ratio
*
* This is identical to propagate_reference_volume() */
- o->volume = s->reference_volume;
- pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
- pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
-
- /* Notify if something changed */
- if (!pa_cvolume_equal(&old_volume, &o->volume)) {
-
- if (o->volume_changed)
- o->volume_changed(o);
+ new_volume = s->reference_volume;
+ pa_cvolume_remap(&new_volume, &s->channel_map, &o->channel_map);
+ pa_sw_cvolume_multiply(&new_volume, &new_volume, &o->reference_ratio);
+ pa_source_output_set_volume_direct(o, &new_volume);
- pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
- }
-
- if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
+ if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)
+ && PA_SOURCE_IS_LINKED(o->destination_source->state))
propagate_real_volume(o->destination_source, old_real_volume);
}
}
pa_source_assert_ref(s);
pa_assert_ctl_context();
- pa_assert(PA_SOURCE_IS_LINKED(s->state));
old_muted = s->muted;
+
+ if (mute == old_muted) {
+ s->save_muted |= save;
+ return;
+ }
+
s->muted = mute;
- s->save_muted = (old_muted == s->muted && s->save_muted) || save;
+ s->save_muted = save;
- if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->set_mute)
+ if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->set_mute) {
+ s->set_mute_in_progress = true;
s->set_mute(s);
+ s->set_mute_in_progress = false;
+ }
- pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
+ if (!PA_SOURCE_IS_LINKED(s->state))
+ return;
- if (old_muted != s->muted)
- pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+ pa_log_debug("The mute of source %s changed from %s to %s.", s->name, pa_yes_no(old_muted), pa_yes_no(mute));
+ pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+ pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_MUTE_CHANGED], s);
}
/* Called from main thread */
pa_assert_ctl_context();
pa_assert(PA_SOURCE_IS_LINKED(s->state));
- if (s->refresh_muted || force_refresh) {
- bool old_muted = s->muted;
+ if ((s->refresh_muted || force_refresh) && s->get_mute) {
+ bool 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);
-
- if (old_muted != s->muted) {
- s->save_muted = true;
-
- pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
-
- /* Make sure the soft mute status stays in sync */
- pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
+ if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
+ if (pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, &mute, 0, NULL) >= 0)
+ pa_source_mute_changed(s, mute);
+ } else {
+ if (s->get_mute(s, &mute) >= 0)
+ pa_source_mute_changed(s, mute);
}
}
pa_assert_ctl_context();
pa_assert(PA_SOURCE_IS_LINKED(s->state));
- /* The source implementor may call this if the mute state changed to make sure everyone is notified */
-
- if (s->muted == new_muted)
+ if (s->set_mute_in_progress)
return;
- s->muted = new_muted;
- s->save_muted = true;
+ /* pa_source_set_mute() does this same check, so this may appear redundant,
+ * but we must have this here also, because the save parameter of
+ * pa_source_set_mute() would otherwise have unintended side effects
+ * (saving the mute state when it shouldn't be saved). */
+ if (new_muted == s->muted)
+ return;
- pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+ pa_source_set_mute(s, new_muted, true);
}
/* Called from main thread */
}
/* Called from main thread */
-unsigned pa_source_check_suspend(pa_source *s) {
+unsigned pa_source_check_suspend(pa_source *s, pa_source_output *ignore) {
unsigned ret;
pa_source_output *o;
uint32_t idx;
ret = 0;
PA_IDXSET_FOREACH(o, s->outputs, idx) {
- pa_source_output_state_t st;
-
- st = pa_source_output_get_state(o);
+ if (o == ignore)
+ continue;
/* 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
* towards our busy status.
*/
- if (!PA_SOURCE_OUTPUT_IS_LINKED(st))
+ if (!PA_SOURCE_OUTPUT_IS_LINKED(o->state))
continue;
- if (st == PA_SOURCE_OUTPUT_CORKED)
+ if (o->state == PA_SOURCE_OUTPUT_CORKED)
continue;
if (o->flags & PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND)
return ret;
}
+const char *pa_source_state_to_string(pa_source_state_t state) {
+ switch (state) {
+ case PA_SOURCE_INIT: return "INIT";
+ case PA_SOURCE_IDLE: return "IDLE";
+ case PA_SOURCE_RUNNING: return "RUNNING";
+ case PA_SOURCE_SUSPENDED: return "SUSPENDED";
+ case PA_SOURCE_UNLINKED: return "UNLINKED";
+ case PA_SOURCE_INVALID_STATE: return "INVALID_STATE";
+ }
+
+ pa_assert_not_reached();
+}
+
/* Called from the IO thread */
static void sync_output_volumes_within_thread(pa_source *s) {
pa_source_output *o;
pa_hashmap_put(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index), o);
}
- pa_assert(!o->thread_info.attached);
- o->thread_info.attached = true;
-
- if (o->attach)
- o->attach(o);
+ pa_source_output_attach(o);
pa_source_output_set_state_within_thread(o, o->state);
pa_source_output_set_state_within_thread(o, o->state);
- if (o->detach)
- o->detach(o);
-
- pa_assert(o->thread_info.attached);
- o->thread_info.attached = false;
+ pa_source_output_detach(o);
if (o->thread_info.direct_on_input) {
pa_hashmap_remove(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index));
o->thread_info.direct_on_input = NULL;
}
- if (pa_hashmap_remove(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index)))
- pa_source_output_unref(o);
-
+ pa_hashmap_remove_and_free(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index));
pa_source_invalidate_requested_latency(s, true);
/* In flat volume mode we need to update the volume as
case PA_SOURCE_MESSAGE_GET_MUTE:
if (s->flags & PA_SOURCE_DEFERRED_VOLUME && s->get_mute)
- s->get_mute(s);
+ return s->get_mute(s, userdata);
return 0;
case PA_SOURCE_MESSAGE_SET_STATE: {
-
+ struct set_state_data *data = userdata;
bool suspend_change =
- (s->thread_info.state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
- (PA_SOURCE_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SOURCE_SUSPENDED);
+ (s->thread_info.state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(data->state)) ||
+ (PA_SOURCE_IS_OPENED(s->thread_info.state) && data->state == PA_SOURCE_SUSPENDED);
+
+ if (s->set_state_in_io_thread) {
+ int r;
+
+ if ((r = s->set_state_in_io_thread(s, data->state, data->suspend_cause)) < 0)
+ return r;
+ }
- s->thread_info.state = PA_PTR_TO_UINT(userdata);
+ s->thread_info.state = data->state;
if (suspend_change) {
pa_source_output *o;
case PA_SOURCE_MESSAGE_GET_LATENCY:
if (s->monitor_of) {
- *((pa_usec_t*) userdata) = 0;
+ *((int64_t*) userdata) = -pa_sink_get_latency_within_thread(s->monitor_of, true);
return 0;
}
/* Implementors need to overwrite this implementation! */
return -1;
- case PA_SOURCE_MESSAGE_SET_PORT:
-
- pa_assert(userdata);
- if (s->set_port) {
- struct source_message_set_port *msg_data = userdata;
- msg_data->ret = s->set_port(s, msg_data->port);
- }
- return 0;
-
case PA_SOURCE_MESSAGE_UPDATE_VOLUME_AND_MUTE:
/* This message is sent from IO-thread and handled in main thread. */
pa_assert_ctl_context();
pa_source_get_mute(s, true);
return 0;
- case PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET:
- s->thread_info.latency_offset = offset;
+ case PA_SOURCE_MESSAGE_SET_PORT_LATENCY_OFFSET:
+ s->thread_info.port_latency_offset = offset;
return 0;
case PA_SOURCE_MESSAGE_MAX:
pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
- if (o->detach)
- o->detach(o);
+ pa_source_output_detach(o);
}
/* Called from IO thread */
pa_assert(PA_SOURCE_IS_LINKED(s->thread_info.state));
PA_HASHMAP_FOREACH(o, s->thread_info.outputs, state)
- if (o->attach)
- o->attach(o);
+ pa_source_output_attach(o);
}
/* Called from IO thread */
}
/* Called from main thread */
-void pa_source_set_latency_offset(pa_source *s, int64_t offset) {
+void pa_source_set_port_latency_offset(pa_source *s, int64_t offset) {
pa_source_assert_ref(s);
- s->latency_offset = offset;
+ s->port_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);
+ pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT_LATENCY_OFFSET, NULL, offset, NULL) == 0);
else
- s->thread_info.latency_offset = offset;
+ s->thread_info.port_latency_offset = offset;
+
+ pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_LATENCY_OFFSET_CHANGED], s);
}
/* Called from main thread */
/* Called from main context */
int pa_source_set_port(pa_source *s, const char *name, bool save) {
pa_device_port *port;
- int ret;
pa_source_assert_ref(s);
pa_assert_ctl_context();
return 0;
}
- 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;
- }
- else
- ret = s->set_port(s, port);
-
- if (ret < 0)
+ if (s->set_port(s, port) < 0)
return -PA_ERR_NOENTITY;
pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
s->active_port = port;
s->save_port = save;
+ /* The active port affects the default source selection. */
+ pa_core_update_default_source(s->core);
+
+ pa_source_set_port_latency_offset(s, s->active_port->latency_offset);
+
pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], s);
return 0;
void pa_source_volume_change_push(pa_source *s) {
pa_source_volume_change *c = NULL;
pa_source_volume_change *nc = NULL;
+ pa_source_volume_change *pc = NULL;
uint32_t safety_margin = s->thread_info.volume_change_safety_margin;
const char *direction = NULL;
return;
}
- nc->at = pa_source_get_latency_within_thread(s);
+ nc->at = pa_source_get_latency_within_thread(s, false);
nc->at += pa_rtclock_now() + s->thread_info.volume_change_extra_delay;
if (s->thread_info.volume_changes_tail) {
pa_log_debug("Volume going %s to %d at %llu", direction, pa_cvolume_avg(&nc->hw_volume), (long long unsigned) nc->at);
/* We can ignore volume events that came earlier but should happen later than this. */
- PA_LLIST_FOREACH(c, nc->next) {
+ PA_LLIST_FOREACH_SAFE(c, pc, nc->next) {
pa_log_debug("Volume change to %d at %llu was dropped", pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at);
pa_source_volume_change_free(c);
}
return out_formats;
}
+
+/* Called from the main thread */
+void pa_source_set_sample_format(pa_source *s, pa_sample_format_t format) {
+ pa_sample_format_t old_format;
+
+ pa_assert(s);
+ pa_assert(pa_sample_format_valid(format));
+
+ old_format = s->sample_spec.format;
+ if (old_format == format)
+ return;
+
+ pa_log_info("%s: format: %s -> %s",
+ s->name, pa_sample_format_to_string(old_format), pa_sample_format_to_string(format));
+
+ s->sample_spec.format = format;
+
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
+/* Called from the main thread */
+void pa_source_set_sample_rate(pa_source *s, uint32_t rate) {
+ uint32_t old_rate;
+
+ pa_assert(s);
+ pa_assert(pa_sample_rate_valid(rate));
+
+ old_rate = s->sample_spec.rate;
+ if (old_rate == rate)
+ return;
+
+ pa_log_info("%s: rate: %u -> %u", s->name, old_rate, rate);
+
+ s->sample_spec.rate = rate;
+
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}
+
+/* Called from the main thread. */
+void pa_source_set_reference_volume_direct(pa_source *s, const pa_cvolume *volume) {
+ pa_cvolume old_volume;
+ char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
+ char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
+
+ pa_assert(s);
+ pa_assert(volume);
+
+ old_volume = s->reference_volume;
+
+ if (pa_cvolume_equal(volume, &old_volume))
+ return;
+
+ s->reference_volume = *volume;
+ pa_log_debug("The reference volume of source %s changed from %s to %s.", s->name,
+ pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
+ s->flags & PA_SOURCE_DECIBEL_VOLUME),
+ pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
+ s->flags & PA_SOURCE_DECIBEL_VOLUME));
+
+ pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+ pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_VOLUME_CHANGED], s);
+}
projects / platform / upstream / pulseaudio.git / blobdiff