This just covers Lennart's concern over the terminology used.
The majority of this change is simply the following command:
grep -rli sync[-_]volume . | xargs sed -i 's/sync_volume/deferred_volume/g;s/PA_SINK_SYNC_VOLUME/PA_SINK_DEFERRED_VOLUME/g;s/PA_SOURCE_SYNC_VOLUME/PA_SOURCE_DEFERRED_VOLUME/g;s/sync-volume/deferred-volume/g'
Some minor tweaks were added on top to tidy up formatting and
a couple of phrases were clarified too.
</section>
- <section name="Default Sync Volume Settings">
+ <section name="Default Deferred Volume Settings">
<p>With the flat volume feature enabled, the sink HW volume is set
to the same level as the highest volume input stream. Any other streams
cause the resulting output sound to be momentarily too loud or too soft.
So to ensure SW and HW volumes are applied concurrently without any
glitches, their application needs to be synchronized. The sink
- implementation needs to support synchronized volumes. The following
+ implementation needs to support deferred volumes. The following
parameters can be used to refine the process.</p>
<option>
- <p><opt>enable-sync-volume=</opt> Enable sync volume for the sinks that
+ <p><opt>enable-deferred-volume=</opt> Enable deferred volume for the sinks that
support it. This feature is enabled by default.</p>
</option>
<option>
- <p><opt>sync-volume-safety-margin-usec=</opt> The amount of time (in
+ <p><opt>deferred-volume-safety-margin-usec=</opt> The amount of time (in
usec) by which the HW volume increases are delayed and HW volume
decreases are advanced. Defaults to 8000 usec.</p>
</option>
<option>
- <p><opt>sync-volume-extra-delay-usec=</opt> The amount of time (in usec)
+ <p><opt>deferred-volume-extra-delay-usec=</opt> The amount of time (in usec)
by which HW volume changes are delayed. Negative values are also allowed.
Defaults to 0.</p>
</option>
.no_cpu_limit = TRUE,
.disable_shm = FALSE,
.lock_memory = FALSE,
- .sync_volume = TRUE,
+ .deferred_volume = TRUE,
.default_n_fragments = 4,
.default_fragment_size_msec = 25,
- .sync_volume_safety_margin_usec = 8000,
- .sync_volume_extra_delay_usec = 0,
+ .deferred_volume_safety_margin_usec = 8000,
+ .deferred_volume_extra_delay_usec = 0,
.default_sample_spec = { .format = PA_SAMPLE_S16NE, .rate = 44100, .channels = 2 },
.default_channel_map = { .channels = 2, .map = { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT } },
.shm_size = 0
{ "enable-shm", pa_config_parse_not_bool, &c->disable_shm, NULL },
{ "flat-volumes", pa_config_parse_bool, &c->flat_volumes, NULL },
{ "lock-memory", pa_config_parse_bool, &c->lock_memory, NULL },
- { "enable-sync-volume", pa_config_parse_bool, &c->sync_volume, NULL },
+ { "enable-deferred-volume", pa_config_parse_bool, &c->deferred_volume, NULL },
{ "exit-idle-time", pa_config_parse_int, &c->exit_idle_time, NULL },
{ "scache-idle-time", pa_config_parse_int, &c->scache_idle_time, NULL },
{ "realtime-priority", parse_rtprio, c, NULL },
{ "default-channel-map", parse_channel_map, &ci, NULL },
{ "default-fragments", parse_fragments, c, NULL },
{ "default-fragment-size-msec", parse_fragment_size_msec, c, NULL },
- { "sync-volume-safety-margin-usec", pa_config_parse_unsigned, &c->sync_volume_safety_margin_usec, NULL },
- { "sync-volume-extra-delay-usec", pa_config_parse_int, &c->sync_volume_extra_delay_usec, NULL },
+ { "deferred-volume-safety-margin-usec",
+ pa_config_parse_unsigned, &c->deferred_volume_safety_margin_usec, NULL },
+ { "deferred-volume-extra-delay-usec",
+ pa_config_parse_int, &c->deferred_volume_extra_delay_usec, NULL },
{ "nice-level", parse_nice_level, c, NULL },
{ "disable-remixing", pa_config_parse_bool, &c->disable_remixing, NULL },
{ "enable-remixing", pa_config_parse_not_bool, &c->disable_remixing, NULL },
pa_strbuf_printf(s, "enable-shm = %s\n", pa_yes_no(!c->disable_shm));
pa_strbuf_printf(s, "flat-volumes = %s\n", pa_yes_no(c->flat_volumes));
pa_strbuf_printf(s, "lock-memory = %s\n", pa_yes_no(c->lock_memory));
- pa_strbuf_printf(s, "enable-sync-volume = %s\n", pa_yes_no(c->sync_volume));
pa_strbuf_printf(s, "exit-idle-time = %i\n", c->exit_idle_time);
pa_strbuf_printf(s, "scache-idle-time = %i\n", c->scache_idle_time);
pa_strbuf_printf(s, "dl-search-path = %s\n", pa_strempty(c->dl_search_path));
pa_strbuf_printf(s, "default-channel-map = %s\n", pa_channel_map_snprint(cm, sizeof(cm), &c->default_channel_map));
pa_strbuf_printf(s, "default-fragments = %u\n", c->default_n_fragments);
pa_strbuf_printf(s, "default-fragment-size-msec = %u\n", c->default_fragment_size_msec);
- pa_strbuf_printf(s, "sync-volume-safety-margin-usec = %u\n", c->sync_volume_safety_margin_usec);
- pa_strbuf_printf(s, "sync-volume-extra-delay-usec = %d\n", c->sync_volume_extra_delay_usec);
+ pa_strbuf_printf(s, "enable-deferred-volume = %s\n", pa_yes_no(c->deferred_volume));
+ pa_strbuf_printf(s, "deferred-volume-safety-margin-usec = %u\n", c->deferred_volume_safety_margin_usec);
+ pa_strbuf_printf(s, "deferred-volume-extra-delay-usec = %d\n", c->deferred_volume_extra_delay_usec);
pa_strbuf_printf(s, "shm-size-bytes = %lu\n", (unsigned long) c->shm_size);
pa_strbuf_printf(s, "log-meta = %s\n", pa_yes_no(c->log_meta));
pa_strbuf_printf(s, "log-time = %s\n", pa_yes_no(c->log_time));
log_time,
flat_volumes,
lock_memory,
- sync_volume;
+ deferred_volume;
pa_server_type_t local_server_type;
int exit_idle_time,
scache_idle_time,
#endif
unsigned default_n_fragments, default_fragment_size_msec;
- unsigned sync_volume_safety_margin_usec;
- int sync_volume_extra_delay_usec;
+ unsigned deferred_volume_safety_margin_usec;
+ int deferred_volume_extra_delay_usec;
pa_sample_spec default_sample_spec;
pa_channel_map default_channel_map;
size_t shm_size;
; default-fragments = 4
; default-fragment-size-msec = 25
-; enable-sync-volume = yes
-; sync-volume-safety-margin-usec = 8000
-; sync-volume-extra-delay-usec = 0
+; enable-deferred-volume = yes
+; deferred-volume-safety-margin-usec = 8000
+; deferred-volume-extra-delay-usec = 0
c->default_channel_map = conf->default_channel_map;
c->default_n_fragments = conf->default_n_fragments;
c->default_fragment_size_msec = conf->default_fragment_size_msec;
- c->sync_volume_safety_margin_usec = conf->sync_volume_safety_margin_usec;
- c->sync_volume_extra_delay_usec = conf->sync_volume_extra_delay_usec;
+ c->deferred_volume_safety_margin_usec = conf->deferred_volume_safety_margin_usec;
+ c->deferred_volume_extra_delay_usec = conf->deferred_volume_extra_delay_usec;
c->exit_idle_time = conf->exit_idle_time;
c->scache_idle_time = conf->scache_idle_time;
c->resample_method = conf->resample_method;
c->realtime_scheduling = !!conf->realtime_scheduling;
c->disable_remixing = !!conf->disable_remixing;
c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
- c->sync_volume = !!conf->sync_volume;
+ c->deferred_volume = !!conf->deferred_volume;
c->running_as_daemon = !!conf->daemonize;
c->disallow_exit = conf->disallow_exit;
c->flat_volumes = conf->flat_volumes;
return r;
}
-static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t sync_volume, pa_bool_t write_to_hw) {
+static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t deferred_volume, pa_bool_t write_to_hw) {
snd_mixer_selem_id_t *sid;
pa_cvolume rv;
} else {
if (write_to_hw) {
- if (sync_volume) {
+ if (deferred_volume) {
if ((r = element_get_nearest_alsa_dB(me, c, PA_ALSA_DIRECTION_OUTPUT, &value)) >= 0)
r = snd_mixer_selem_set_playback_dB(me, c, value, 0);
} else {
} else {
if (write_to_hw) {
- if (sync_volume) {
+ if (deferred_volume) {
if ((r = element_get_nearest_alsa_dB(me, c, PA_ALSA_DIRECTION_INPUT, &value)) >= 0)
r = snd_mixer_selem_set_capture_dB(me, c, value, 0);
} else {
return 0;
}
-int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t sync_volume, pa_bool_t write_to_hw) {
+int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t deferred_volume, pa_bool_t write_to_hw) {
pa_alsa_element *e;
pa_cvolume rv;
pa_assert(!p->has_dB || e->has_dB);
ev = rv;
- if (element_set_volume(e, m, cm, &ev, sync_volume, write_to_hw) < 0)
+ if (element_set_volume(e, m, cm, &ev, deferred_volume, write_to_hw) < 0)
return -1;
if (!p->has_dB) {
void pa_alsa_path_dump(pa_alsa_path *p);
int pa_alsa_path_get_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v);
int pa_alsa_path_get_mute(pa_alsa_path *path, snd_mixer_t *m, pa_bool_t *muted);
-int pa_alsa_path_set_volume(pa_alsa_path *path, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t sync_volume, pa_bool_t write_to_hw);
+int pa_alsa_path_set_volume(pa_alsa_path *path, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t deferred_volume, pa_bool_t write_to_hw);
int pa_alsa_path_set_mute(pa_alsa_path *path, snd_mixer_t *m, pa_bool_t muted);
int pa_alsa_path_select(pa_alsa_path *p, snd_mixer_t *m);
void pa_alsa_path_set_callback(pa_alsa_path *p, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata);
char *device_name; /* name of the PCM device */
char *control_device; /* name of the control device */
- pa_bool_t use_mmap:1, use_tsched:1, sync_volume:1;
+ pa_bool_t use_mmap:1, use_tsched:1, deferred_volume:1;
pa_bool_t first, after_rewind;
struct userdata *u = s->userdata;
pa_cvolume r;
char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
- pa_bool_t sync_volume = !!(s->flags & PA_SINK_SYNC_VOLUME);
+ pa_bool_t deferred_volume = !!(s->flags & PA_SINK_DEFERRED_VOLUME);
pa_assert(u);
pa_assert(u->mixer_path);
/* Shift up by the base volume */
pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
- if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, sync_volume, !sync_volume) < 0)
+ if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, deferred_volume, !deferred_volume) < 0)
return;
/* Shift down by the base volume, so that 0dB becomes maximum volume */
pa_assert(u);
pa_assert(u->mixer_path);
pa_assert(u->mixer_handle);
- pa_assert(s->flags & PA_SINK_SYNC_VOLUME);
+ pa_assert(s->flags & PA_SINK_DEFERRED_VOLUME);
/* Shift up by the base volume */
pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
pa_sink_set_get_volume_callback(u->sink, sink_get_volume_cb);
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
- if (u->mixer_path->has_dB && u->sync_volume) {
+ if (u->mixer_path->has_dB && u->deferred_volume) {
pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb);
pa_log_info("Successfully enabled synchronous volume.");
} else
}
- if (u->sink->flags & PA_SINK_SYNC_VOLUME) {
+ if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
pa_usec_t volume_sleep;
pa_sink_volume_change_apply(u->sink, &volume_sleep);
if (volume_sleep > 0)
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
goto fail;
- if (u->sink->flags & PA_SINK_SYNC_VOLUME)
+ if (u->sink->flags & PA_SINK_DEFERRED_VOLUME)
pa_sink_volume_change_apply(u->sink, NULL);
if (ret == 0)
if (need_mixer_callback) {
int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
- if (u->sink->flags & PA_SINK_SYNC_VOLUME) {
+ if (u->sink->flags & PA_SINK_DEFERRED_VOLUME) {
u->mixer_pd = pa_alsa_mixer_pdata_new();
mixer_callback = io_mixer_callback;
uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
size_t frame_size;
- pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, sync_volume = FALSE, set_formats = FALSE;
+ pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, deferred_volume = FALSE, set_formats = FALSE;
pa_sink_new_data data;
pa_alsa_profile_set *profile_set = NULL;
goto fail;
}
- sync_volume = m->core->sync_volume;
- if (pa_modargs_get_value_boolean(ma, "sync_volume", &sync_volume) < 0) {
- pa_log("Failed to parse sync_volume argument.");
+ deferred_volume = m->core->deferred_volume;
+ if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) {
+ pa_log("Failed to parse deferred_volume argument.");
goto fail;
}
u->module = m;
u->use_mmap = use_mmap;
u->use_tsched = use_tsched;
- u->sync_volume = sync_volume;
+ u->deferred_volume = deferred_volume;
u->first = TRUE;
u->rewind_safeguard = rewind_safeguard;
u->rtpoll = pa_rtpoll_new();
goto fail;
}
- if (pa_modargs_get_value_u32(ma, "sync_volume_safety_margin",
+ if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin",
&u->sink->thread_info.volume_change_safety_margin) < 0) {
- pa_log("Failed to parse sync_volume_safety_margin parameter");
+ pa_log("Failed to parse deferred_volume_safety_margin parameter");
goto fail;
}
- if (pa_modargs_get_value_s32(ma, "sync_volume_extra_delay",
+ if (pa_modargs_get_value_s32(ma, "deferred_volume_extra_delay",
&u->sink->thread_info.volume_change_extra_delay) < 0) {
- pa_log("Failed to parse sync_volume_extra_delay parameter");
+ pa_log("Failed to parse deferred_volume_extra_delay parameter");
goto fail;
}
char *device_name; /* name of the PCM device */
char *control_device; /* name of the control device */
- pa_bool_t use_mmap:1, use_tsched:1, sync_volume:1;
+ pa_bool_t use_mmap:1, use_tsched:1, deferred_volume:1;
pa_bool_t first;
struct userdata *u = s->userdata;
pa_cvolume r;
char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
- pa_bool_t sync_volume = !!(s->flags & PA_SOURCE_SYNC_VOLUME);
+ pa_bool_t deferred_volume = !!(s->flags & PA_SOURCE_DEFERRED_VOLUME);
pa_assert(u);
pa_assert(u->mixer_path);
/* Shift up by the base volume */
pa_sw_cvolume_divide_scalar(&r, &s->real_volume, s->base_volume);
- if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, sync_volume, !sync_volume) < 0)
+ if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r, deferred_volume, !deferred_volume) < 0)
return;
/* Shift down by the base volume, so that 0dB becomes maximum volume */
pa_assert(u);
pa_assert(u->mixer_path);
pa_assert(u->mixer_handle);
- pa_assert(s->flags & PA_SOURCE_SYNC_VOLUME);
+ pa_assert(s->flags & PA_SOURCE_DEFERRED_VOLUME);
/* Shift up by the base volume */
pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
pa_source_set_get_volume_callback(u->source, source_get_volume_cb);
pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
- if (u->mixer_path->has_dB && u->sync_volume) {
+ if (u->mixer_path->has_dB && u->deferred_volume) {
pa_source_set_write_volume_callback(u->source, source_write_volume_cb);
pa_log_info("Successfully enabled synchronous volume.");
} else
}
}
- if (u->source->flags & PA_SOURCE_SYNC_VOLUME) {
+ if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
pa_usec_t volume_sleep;
pa_source_volume_change_apply(u->source, &volume_sleep);
if (volume_sleep > 0)
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
goto fail;
- if (u->source->flags & PA_SOURCE_SYNC_VOLUME)
+ if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME)
pa_source_volume_change_apply(u->source, NULL);
if (ret == 0)
if (need_mixer_callback) {
int (*mixer_callback)(snd_mixer_elem_t *, unsigned int);
- if (u->source->flags & PA_SOURCE_SYNC_VOLUME) {
+ if (u->source->flags & PA_SOURCE_DEFERRED_VOLUME) {
u->mixer_pd = pa_alsa_mixer_pdata_new();
mixer_callback = io_mixer_callback;
uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark;
snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
size_t frame_size;
- pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, sync_volume = FALSE;
+ pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, deferred_volume = FALSE;
pa_source_new_data data;
pa_alsa_profile_set *profile_set = NULL;
goto fail;
}
- sync_volume = m->core->sync_volume;
- if (pa_modargs_get_value_boolean(ma, "sync_volume", &sync_volume) < 0) {
- pa_log("Failed to parse sync_volume argument.");
+ deferred_volume = m->core->deferred_volume;
+ if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) {
+ pa_log("Failed to parse deferred_volume argument.");
goto fail;
}
u->module = m;
u->use_mmap = use_mmap;
u->use_tsched = use_tsched;
- u->sync_volume = sync_volume;
+ u->deferred_volume = deferred_volume;
u->first = TRUE;
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
goto fail;
}
- if (pa_modargs_get_value_u32(ma, "sync_volume_safety_margin",
+ if (pa_modargs_get_value_u32(ma, "deferred_volume_safety_margin",
&u->source->thread_info.volume_change_safety_margin) < 0) {
- pa_log("Failed to parse sync_volume_safety_margin parameter");
+ pa_log("Failed to parse deferred_volume_safety_margin parameter");
goto fail;
}
- if (pa_modargs_get_value_s32(ma, "sync_volume_extra_delay",
+ if (pa_modargs_get_value_s32(ma, "deferred_volume_extra_delay",
&u->source->thread_info.volume_change_extra_delay) < 0) {
- pa_log("Failed to parse sync_volume_extra_delay parameter");
+ pa_log("Failed to parse deferred_volume_extra_delay parameter");
goto fail;
}
"tsched_buffer_watermark=<lower fill watermark> "
"profile=<profile name> "
"ignore_dB=<ignore dB information from the device?> "
- "sync_volume=<syncronize sw and hw voluchanges in IO-thread?> "
+ "deferred_volume=<Synchronize software and hardware volume changes to avoid momentary jumps?> "
"profile_set=<profile set configuration file> ");
static const char* const valid_modargs[] = {
"tsched_buffer_watermark",
"profile",
"ignore_dB",
- "sync_volume",
+ "deferred_volume",
"profile_set",
NULL
};
"ignore_dB=<ignore dB information from the device?> "
"control=<name of mixer control> "
"rewind_safeguard=<number of bytes that cannot be rewound> "
- "sync_volume=<syncronize sw and hw voluchanges in IO-thread?> "
- "sync_volume_safety_margin=<usec adjustment depending on volume direction> "
- "sync_volume_extra_delay=<usec adjustment to HW volume changes>");
+ "deferred_volume=<Synchronize software and hardware volume changes to avoid momentary jumps?> "
+ "deferred_volume_safety_margin=<usec adjustment depending on volume direction> "
+ "deferred_volume_extra_delay=<usec adjustment to HW volume changes>");
static const char* const valid_modargs[] = {
"name",
"ignore_dB",
"control",
"rewind_safeguard",
- "sync_volume",
- "sync_volume_safety_margin",
- "sync_volume_extra_delay",
+ "deferred_volume",
+ "deferred_volume_safety_margin",
+ "deferred_volume_extra_delay",
NULL
};
"tsched_buffer_watermark=<upper fill watermark> "
"ignore_dB=<ignore dB information from the device?> "
"control=<name of mixer control>"
- "sync_volume=<syncronize sw and hw voluchanges in IO-thread?> "
- "sync_volume_safety_margin=<usec adjustment depending on volume direction> "
- "sync_volume_extra_delay=<usec adjustment to HW volume changes>");
+ "deferred_volume=<Synchronize software and hardware volume changes to avoid momentary jumps?> "
+ "deferred_volume_safety_margin=<usec adjustment depending on volume direction> "
+ "deferred_volume_extra_delay=<usec adjustment to HW volume changes>");
static const char* const valid_modargs[] = {
"name",
"tsched_buffer_watermark",
"ignore_dB",
"control",
- "sync_volume",
- "sync_volume_safety_margin",
- "sync_volume_extra_delay",
+ "deferred_volume",
+ "deferred_volume_safety_margin",
+ "deferred_volume_extra_delay",
NULL
};
PA_MODULE_USAGE(
"tsched=<enable system timer based scheduling mode?> "
"ignore_dB=<ignore dB information from the device?> "
- "sync_volume=<syncronize sw and hw volume changes in IO-thread?>");
+ "deferred_volume=<syncronize sw and hw volume changes in IO-thread?>");
struct device {
char *path;
pa_bool_t use_tsched:1;
pa_bool_t ignore_dB:1;
- pa_bool_t sync_volume:1;
+ pa_bool_t deferred_volume:1;
struct udev* udev;
struct udev_monitor *monitor;
static const char* const valid_modargs[] = {
"tsched",
"ignore_dB",
- "sync_volume",
+ "deferred_volume",
NULL
};
"namereg_fail=false "
"tsched=%s "
"ignore_dB=%s "
- "sync_volume=%s "
+ "deferred_volume=%s "
"card_properties=\"module-udev-detect.discovered=1\"",
path_get_card_id(path),
n,
d->card_name,
pa_yes_no(u->use_tsched),
pa_yes_no(u->ignore_dB),
- pa_yes_no(u->sync_volume));
+ pa_yes_no(u->deferred_volume));
pa_xfree(n);
pa_hashmap_put(u->devices, d->path, d);
struct udev_enumerate *enumerate = NULL;
struct udev_list_entry *item = NULL, *first = NULL;
int fd;
- pa_bool_t use_tsched = TRUE, ignore_dB = FALSE, sync_volume = m->core->sync_volume;
+ pa_bool_t use_tsched = TRUE, ignore_dB = FALSE, deferred_volume = m->core->deferred_volume;
pa_assert(m);
}
u->ignore_dB = ignore_dB;
- if (pa_modargs_get_value_boolean(ma, "sync_volume", &sync_volume) < 0) {
- pa_log("Failed to parse sync_volume= argument.");
+ if (pa_modargs_get_value_boolean(ma, "deferred_volume", &deferred_volume) < 0) {
+ pa_log("Failed to parse deferred_volume= argument.");
goto fail;
}
- u->sync_volume = sync_volume;
+ u->deferred_volume = deferred_volume;
if (!(u->udev = udev_new())) {
pa_log("Failed to initialize udev library.");
/**< The latency can be adjusted dynamically depending on the
* needs of the connected streams. \since 0.9.15 */
- PA_SINK_SYNC_VOLUME = 0x0100U,
+ PA_SINK_DEFERRED_VOLUME = 0x0100U,
/**< The HW volume changes are syncronized with SW volume.
* \since 1.0 */
#define PA_SINK_DECIBEL_VOLUME PA_SINK_DECIBEL_VOLUME
#define PA_SINK_FLAT_VOLUME PA_SINK_FLAT_VOLUME
#define PA_SINK_DYNAMIC_LATENCY PA_SINK_DYNAMIC_LATENCY
-#define PA_SINK_SYNC_VOLUME PA_SINK_SYNC_VOLUME
+#define PA_SINK_DEFERRED_VOLUME PA_SINK_DEFERRED_VOLUME
#define PA_SINK_SHARE_VOLUME_WITH_MASTER PA_SINK_SHARE_VOLUME_WITH_MASTER
#define PA_SINK_SET_FORMATS PA_SINK_SET_FORMATS
/**< This source is in flat volume mode, i.e. always the maximum of
* the volume of all connected outputs. \since 1.0 */
- PA_SOURCE_SYNC_VOLUME = 0x0100U,
+ PA_SOURCE_DEFERRED_VOLUME = 0x0100U,
/**< The HW volume changes are syncronized with SW volume.
* \since 1.0 */
#define PA_SOURCE_DECIBEL_VOLUME PA_SOURCE_DECIBEL_VOLUME
#define PA_SOURCE_DYNAMIC_LATENCY PA_SOURCE_DYNAMIC_LATENCY
#define PA_SOURCE_FLAT_VOLUME PA_SOURCE_FLAT_VOLUME
-#define PA_SOURCE_SYNC_VOLUME PA_SOURCE_SYNC_VOLUME
+#define PA_SOURCE_DEFERRED_VOLUME PA_SOURCE_DEFERRED_VOLUME
#define PA_SOURCE_SHARE_VOLUME_WITH_MASTER PA_SOURCE_SHARE_VOLUME_WITH_MASTER
/** \endcond */
c->default_n_fragments = 4;
c->default_fragment_size_msec = 25;
- c->sync_volume_safety_margin_usec = 8000;
- c->sync_volume_extra_delay_usec = 0;
+ c->deferred_volume_safety_margin_usec = 8000;
+ c->deferred_volume_extra_delay_usec = 0;
c->module_defer_unload_event = NULL;
c->scache_auto_unload_event = NULL;
c->realtime_priority = 5;
c->disable_remixing = FALSE;
c->disable_lfe_remixing = FALSE;
- c->sync_volume = TRUE;
+ c->deferred_volume = TRUE;
c->resample_method = PA_RESAMPLER_SPEEX_FLOAT_BASE + 3;
for (j = 0; j < PA_CORE_HOOK_MAX; j++)
pa_channel_map default_channel_map;
pa_sample_spec default_sample_spec;
unsigned default_n_fragments, default_fragment_size_msec;
- unsigned sync_volume_safety_margin_usec;
- int sync_volume_extra_delay_usec;
+ unsigned deferred_volume_safety_margin_usec;
+ int deferred_volume_extra_delay_usec;
pa_defer_event *module_defer_unload_event;
pa_bool_t realtime_scheduling:1;
pa_bool_t disable_remixing:1;
pa_bool_t disable_lfe_remixing:1;
- pa_bool_t sync_volume:1;
+ pa_bool_t deferred_volume:1;
pa_resample_method_t resample_method;
int realtime_priority;
PA_LLIST_HEAD_INIT(pa_sink_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_sink_put() */
pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
flags = s->flags;
if (cb)
- s->flags |= PA_SINK_SYNC_VOLUME;
+ s->flags |= PA_SINK_DEFERRED_VOLUME;
else
- s->flags &= ~PA_SINK_SYNC_VOLUME;
+ s->flags &= ~PA_SINK_DEFERRED_VOLUME;
/* If the flags have changed after init, let any clients know via a change event */
if (s->state != PA_SINK_INIT && flags != s->flags)
* Note: All of these flags set here can change over the life time
* of the sink. */
pa_assert(!(s->flags & PA_SINK_HW_VOLUME_CTRL) || s->set_volume);
- pa_assert(!(s->flags & PA_SINK_SYNC_VOLUME) || s->write_volume);
+ pa_assert(!(s->flags & PA_SINK_DEFERRED_VOLUME) || s->write_volume);
pa_assert(!(s->flags & PA_SINK_HW_MUTE_CTRL) || s->set_mute);
/* XXX: Currently decibel volume is disabled for all sinks that use volume
if (nbytes > 0) {
pa_log_debug("Processing rewind...");
- if (s->flags & PA_SINK_SYNC_VOLUME)
+ if (s->flags & PA_SINK_DEFERRED_VOLUME)
pa_sink_volume_change_rewind(s, nbytes);
}
* apply one to root_sink->soft_volume */
pa_cvolume_reset(&root_sink->soft_volume, root_sink->sample_spec.channels);
- if (!(root_sink->flags & PA_SINK_SYNC_VOLUME))
+ if (!(root_sink->flags & PA_SINK_DEFERRED_VOLUME))
root_sink->set_volume(root_sink);
} else
pa_sink_assert_ref(s);
pa_assert(!(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER));
- if (s->flags & PA_SINK_SYNC_VOLUME)
+ if (s->flags & PA_SINK_DEFERRED_VOLUME)
pa_sink_assert_io_context(s);
else
pa_assert_ctl_context();
else
s->soft_volume = *volume;
- if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_SYNC_VOLUME))
+ if (PA_SINK_IS_LINKED(s->state) && !(s->flags & PA_SINK_DEFERRED_VOLUME))
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 = s->soft_volume;
old_real_volume = s->real_volume;
- if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume)
+ if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume)
s->get_volume(s);
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_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_SINK_SYNC_VOLUME) && s->set_mute)
+ if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->set_mute)
s->set_mute(s);
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_MUTE, NULL, 0, NULL) == 0);
if (s->refresh_muted || force_refresh) {
pa_bool_t old_muted = s->muted;
- if (!(s->flags & PA_SINK_SYNC_VOLUME) && s->get_mute)
+ if (!(s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_mute)
s->get_mute(s);
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
case PA_SINK_MESSAGE_SET_VOLUME_SYNCED:
- if (s->flags & PA_SINK_SYNC_VOLUME) {
+ if (s->flags & PA_SINK_DEFERRED_VOLUME) {
s->set_volume(s);
pa_sink_volume_change_push(s);
}
case PA_SINK_MESSAGE_GET_VOLUME:
- if ((s->flags & PA_SINK_SYNC_VOLUME) && s->get_volume) {
+ if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
s->get_volume(s);
pa_sink_volume_change_flush(s);
pa_sw_cvolume_divide(&s->thread_info.current_hw_volume, &s->real_volume, &s->soft_volume);
pa_sink_request_rewind(s, (size_t) -1);
}
- if (s->flags & PA_SINK_SYNC_VOLUME && s->set_mute)
+ if (s->flags & PA_SINK_DEFERRED_VOLUME && s->set_mute)
s->set_mute(s);
return 0;
case PA_SINK_MESSAGE_GET_MUTE:
- if (s->flags & PA_SINK_SYNC_VOLUME && s->get_mute)
+ if (s->flags & PA_SINK_DEFERRED_VOLUME && s->get_mute)
s->get_mute(s);
return 0;
return 0;
}
- if (s->flags & PA_SINK_SYNC_VOLUME) {
+ if (s->flags & PA_SINK_DEFERRED_VOLUME) {
struct sink_message_set_port msg = { .port = port, .ret = 0 };
pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
ret = msg.ret;
* (using pa_sink_set_soft_volume()) to match the current hardware
* volume.
*
- * If PA_SINK_SYNC_VOLUME is not set, then this is called from the
+ * If PA_SINK_DEFERRED_VOLUME is not set, then this is called from the
* main thread before sending PA_SINK_MESSAGE_GET_VOLUME, so in
* this case the driver can choose whether to read the volume from
* the hardware in the main thread or in the IO thread.
*
- * If PA_SINK_SYNC_VOLUME is set, then this is called from the IO
+ * If PA_SINK_DEFERRED_VOLUME is set, then this is called from the IO
* thread within the default handler for
* PA_SINK_MESSAGE_GET_VOLUME (the main thread is waiting while
* the message is being processed), so there's no choice of where
* callback. This is called when the hardware volume needs to be
* updated.
*
- * If PA_SINK_SYNC_VOLUME is not set, then this is called from the
+ * If PA_SINK_DEFERRED_VOLUME is not set, then this is called from the
* main thread. The callback implementation must set the hardware
* volume according to s->real_volume. If the driver can't set the
* hardware volume to the exact requested value, it has to update
* s->real_volume and/or s->soft_volume so that they together
* match the actual hardware volume that was set.
*
- * If PA_SINK_SYNC_VOLUME is set, then this is called from the IO
+ * If PA_SINK_DEFERRED_VOLUME is set, then this is called from the IO
* thread. The callback implementation must not actually set the
* hardware volume yet, but it must check how close to the
* requested volume the hardware volume can be set, and update
* set this callback. */
pa_sink_cb_t set_volume; /* may be NULL */
- /* Sink drivers that set PA_SINK_SYNC_VOLUME must provide this
+ /* Sink drivers that set PA_SINK_DEFERRED_VOLUME must provide this
* callback. This callback is not used with sinks that do not set
- * PA_SINK_SYNC_VOLUME. This is called from the IO thread when a
+ * PA_SINK_DEFERRED_VOLUME. This is called from the IO thread when a
* pending hardware volume change has to be written to the
* hardware. The requested volume is passed to the callback
* implementation in s->thread_info.current_hw_volume.
pa_sink_cb_t write_volume; /* may be NULL */
/* Called when the mute setting is queried. A PA_SINK_MESSAGE_GET_MUTE
- * message will also be sent. Called from IO thread if PA_SINK_SYNC_VOLUME
+ * message will also be sent. Called from IO thread if PA_SINK_DEFERRED_VOLUME
* flag is set otherwise from main loop context. If refresh_mute is FALSE
* neither this function is called nor a message is sent.
*
pa_sink_cb_t get_mute; /* may be NULL */
/* Called when the mute setting shall be changed. A PA_SINK_MESSAGE_SET_MUTE
- * message will also be sent. Called from IO thread if PA_SINK_SYNC_VOLUME
+ * message will also be sent. Called from IO thread if PA_SINK_DEFERRED_VOLUME
* flag is set otherwise from main loop context.
*
* You must use the function pa_sink_set_set_mute_callback() to
PA_LLIST_HEAD(pa_sink_volume_change, volume_changes);
pa_sink_volume_change *volume_changes_tail;
/* This value is updated in pa_sink_volume_change_apply() and
- * used only by sinks with PA_SINK_SYNC_VOLUME. */
+ * used only by sinks with PA_SINK_DEFERRED_VOLUME. */
pa_cvolume current_hw_volume;
/* The amount of usec volume up events are delayed and volume
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);
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
* 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);
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;
* set this callback. */
pa_source_cb_t set_volume; /* may be NULL */
- /* Source drivers that set PA_SOURCE_SYNC_VOLUME must provide this
+ /* Source drivers that set PA_SOURCE_DEFERRED_VOLUME must provide this
* callback. This callback is not used with source that do not set
- * PA_SOURCE_SYNC_VOLUME. This is called from the IO thread when a
+ * PA_SOURCE_DEFERRED_VOLUME. This is called from the IO thread when a
* pending hardware volume change has to be written to the
* hardware. The requested volume is passed to the callback
* implementation in s->thread_info.current_hw_volume.
PA_LLIST_HEAD(pa_source_volume_change, volume_changes);
pa_source_volume_change *volume_changes_tail;
/* This value is updated in pa_source_volume_change_apply() and
- * used only by sources with PA_SOURCE_SYNC_VOLUME. */
+ * used only by sources with PA_SOURCE_DEFERRED_VOLUME. */
pa_cvolume current_hw_volume;
/* The amount of usec volume up events are delayed and volume