mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-10-29 05:40:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

volume: Rename 'sync volume' to 'deferred volume'.

Browse source 
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.
This commit is contained in:
Colin Guthrie 2011-09-13 21:15:49 +01:00
parent 83577aa373
commit aa3142ab20
20 changed files with 143 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

10
man/pulse-daemon.conf.5.xml.in
View file

@ -438,7 +438,7 @@ USA.
</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
@ -448,20 +448,20 @@ USA.
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>

20
src/daemon/daemon-conf.c
View file

@ -95,11 +95,11 @@ static const pa_daemon_conf default_conf = {
.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
@ -536,7 +536,7 @@ int pa_daemon_conf_load(pa_daemon_conf *c, const char *filename) {
{ "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 },
@ -552,8 +552,10 @@ int pa_daemon_conf_load(pa_daemon_conf *c, const char *filename) {
{ "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 },
@ -737,7 +739,6 @@ char *pa_daemon_conf_dump(pa_daemon_conf *c) {
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));
@ -754,8 +755,9 @@ char *pa_daemon_conf_dump(pa_daemon_conf *c) {
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));

6
src/daemon/daemon-conf.h
View file

@ -76,7 +76,7 @@ typedef struct pa_daemon_conf {
log_time,
flat_volumes,
lock_memory,
sync_volume;
deferred_volume;
pa_server_type_t local_server_type;
int exit_idle_time,
scache_idle_time,
@ -128,8 +128,8 @@ typedef struct pa_daemon_conf {
#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;

6
src/daemon/daemon.conf.in
View file

@ -86,6 +86,6 @@ ifelse(@HAVE_SYS_RESOURCE_H@, 1, [dnl
; 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

6
src/daemon/main.c
View file

@ -1016,8 +1016,8 @@ int main(int argc, char *argv[]) {
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;
@ -1025,7 +1025,7 @@ int main(int argc, char *argv[]) {
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;

10
src/modules/alsa/alsa-mixer.c
View file

@ -899,7 +899,7 @@ static int element_get_nearest_alsa_dB(snd_mixer_elem_t *me, snd_mixer_selem_cha
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;
@ -964,7 +964,7 @@ static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_chann
} 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 {
@ -992,7 +992,7 @@ static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_chann
} 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 {
@ -1059,7 +1059,7 @@ static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_chann
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;
@ -1085,7 +1085,7 @@ int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_ma
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) {

2
src/modules/alsa/alsa-mixer.h
View file

@ -214,7 +214,7 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t ignore_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);

34
src/modules/alsa/alsa-sink.c
View file

@ -131,7 +131,7 @@ struct 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;
@ -1278,7 +1278,7 @@ static void sink_set_volume_cb(pa_sink *s) {
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);
@ -1287,7 +1287,7 @@ static void sink_set_volume_cb(pa_sink *s) {
/* 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 */
@ -1339,7 +1339,7 @@ static void sink_write_volume_cb(pa_sink *s) {
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);
@ -1411,7 +1411,7 @@ static void mixer_volume_init(struct userdata *u) {
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
@ -1692,7 +1692,7 @@ static void thread_func(void *userdata) {
}
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)
@ -1708,7 +1708,7 @@ static void thread_func(void *userdata) {
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)
@ -1882,7 +1882,7 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
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;
@ -1918,7 +1918,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
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;
@ -1977,9 +1977,9 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
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;
}
@ -1990,7 +1990,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
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();
@ -2151,15 +2151,15 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
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;
}

34
src/modules/alsa/alsa-source.c
View file

@ -116,7 +116,7 @@ struct 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;
@ -1129,7 +1129,7 @@ static void source_set_volume_cb(pa_source *s) {
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);
@ -1138,7 +1138,7 @@ static void source_set_volume_cb(pa_source *s) {
/* 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 */
@ -1190,7 +1190,7 @@ static void source_write_volume_cb(pa_source *s) {
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);
@ -1262,7 +1262,7 @@ static void mixer_volume_init(struct userdata *u) {
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
@ -1405,7 +1405,7 @@ static void thread_func(void *userdata) {
}
}
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)
@ -1421,7 +1421,7 @@ static void thread_func(void *userdata) {
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)
@ -1593,7 +1593,7 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
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;
@ -1629,7 +1629,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
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;
@ -1682,9 +1682,9 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
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;
}
@ -1695,7 +1695,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
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);
@ -1851,15 +1851,15 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
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;
}

4
src/modules/alsa/module-alsa-card.c
View file

@ -65,7 +65,7 @@ PA_MODULE_USAGE(
"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[] = {
@ -88,7 +88,7 @@ static const char* const valid_modargs[] = {
"tsched_buffer_watermark",
"profile",
"ignore_dB",
"sync_volume",
"deferred_volume",
"profile_set",
NULL
};

12
src/modules/alsa/module-alsa-sink.c
View file

@ -56,9 +56,9 @@ PA_MODULE_USAGE(
"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",
@ -80,9 +80,9 @@ static const char* const valid_modargs[] = {
"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
};

12
src/modules/alsa/module-alsa-source.c
View file

@ -64,9 +64,9 @@ PA_MODULE_USAGE(
"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",
@ -87,9 +87,9 @@ static const char* const valid_modargs[] = {
"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
};

18
src/modules/module-udev-detect.c
View file

@ -46,7 +46,7 @@ PA_MODULE_LOAD_ONCE(TRUE);
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;
@ -63,7 +63,7 @@ struct userdata {
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;
@ -76,7 +76,7 @@ struct userdata {
static const char* const valid_modargs[] = {
"tsched",
"ignore_dB",
"sync_volume",
"deferred_volume",
NULL
};
@ -389,14 +389,14 @@ static void card_changed(struct userdata *u, struct udev_device *dev) {
"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);
@ -665,7 +665,7 @@ int pa__init(pa_module *m) {
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);
@ -692,11 +692,11 @@ int pa__init(pa_module *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.");

8
src/pulse/def.h
View file

@ -753,7 +753,7 @@ typedef enum pa_sink_flags {
/**< 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 */
@ -782,7 +782,7 @@ typedef enum pa_sink_flags {
#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
@ -869,7 +869,7 @@ typedef enum pa_source_flags {
/**< 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 */
@ -892,7 +892,7 @@ typedef enum pa_source_flags {
#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 */

6
src/pulsecore/core.c
View file

@ -113,8 +113,8 @@ pa_core* pa_core_new(pa_mainloop_api *m, pa_bool_t shared, size_t shm_size) {
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;
@ -140,7 +140,7 @@ pa_core* pa_core_new(pa_mainloop_api *m, pa_bool_t shared, size_t shm_size) {
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++)

6
src/pulsecore/core.h
View file

@ -144,8 +144,8 @@ struct pa_core {
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;
@ -169,7 +169,7 @@ struct pa_core {
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;

34
src/pulsecore/sink.c
View file

@ -343,8 +343,8 @@ pa_sink* pa_sink_new(
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);
@ -495,9 +495,9 @@ void pa_sink_set_write_volume_callback(pa_sink *s, pa_sink_cb_t cb) {
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)
@ -595,7 +595,7 @@ void pa_sink_put(pa_sink* s) {
* 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
@ -919,7 +919,7 @@ void pa_sink_process_rewind(pa_sink *s, size_t nbytes) {
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);
}
@ -1876,7 +1876,7 @@ void pa_sink_set_volume(
* 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
@ -1896,7 +1896,7 @@ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
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();
@ -1906,7 +1906,7 @@ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
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;
@ -1999,7 +1999,7 @@ const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh) {
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);
@ -2040,7 +2040,7 @@ void pa_sink_set_mute(pa_sink *s, pa_bool_t mute, pa_bool_t save) {
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);
@ -2059,7 +2059,7 @@ pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) {
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);
@ -2455,7 +2455,7 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse
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);
}
@ -2476,7 +2476,7 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse
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);
@ -2497,14 +2497,14 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse
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;
@ -3087,7 +3087,7 @@ int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) {
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;

18
src/pulsecore/sink.h
View file

@ -139,12 +139,12 @@ struct pa_sink {
* (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
@ -159,14 +159,14 @@ struct pa_sink {
* 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
@ -178,9 +178,9 @@ struct pa_sink {
* 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.
@ -195,7 +195,7 @@ struct pa_sink {
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.
*
@ -204,7 +204,7 @@ struct pa_sink {
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
@ -278,7 +278,7 @@ struct pa_sink {
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

32
src/pulsecore/source.c
View file

@ -307,8 +307,8 @@ pa_source* pa_source_new(
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);
@ -426,9 +426,9 @@ void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb) {
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)
@ -526,7 +526,7 @@ void pa_source_put(pa_source *s) {
* 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
@ -1452,7 +1452,7 @@ void pa_source_set_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
@ -1472,7 +1472,7 @@ void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) {
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();
@ -1482,7 +1482,7 @@ void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume) {
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;
@ -1575,7 +1575,7 @@ const pa_cvolume *pa_source_get_volume(pa_source *s, pa_bool_t force_refresh) {
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);
@ -1616,7 +1616,7 @@ void pa_source_set_mute(pa_source *s, pa_bool_t mute, pa_bool_t save) {
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);
@ -1635,7 +1635,7 @@ pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) {
if (s->refresh_muted || force_refresh) {
pa_bool_t old_muted = s->muted;
if (!(s->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);
@ -1885,7 +1885,7 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
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);
}
@ -1905,7 +1905,7 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
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);
@ -1924,14 +1924,14 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
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;
@ -2423,7 +2423,7 @@ int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save) {
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;

6
src/pulsecore/source.h
View file

@ -133,9 +133,9 @@ struct pa_source {
* 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.
@ -207,7 +207,7 @@ struct pa_source {
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