mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-14 06:59:53 -05: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

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