From a9cf320bc15a95599a2fe1c7a4357c62555f82ca Mon Sep 17 00:00:00 2001 From: Colin Guthrie Date: Tue, 5 Jul 2011 23:44:06 +0100 Subject: [PATCH] devices: Set certain sink/source flags automatically. Some sink flags are really just a product of what callbacks are set on the device. We still enforce a degree of sanity that the flags match the callbacks set, but we also set the flags automatically in our callback setter functions to help ensure that a) people use them and b) flags & callbacks are kept in sync. --- src/modules/alsa/alsa-sink.c | 11 ++--- src/modules/alsa/alsa-source.c | 11 ++--- .../bluetooth/module-bluetooth-device.c | 4 +- src/modules/echo-cancel/module-echo-cancel.c | 4 +- src/modules/module-equalizer-sink.c | 2 +- src/modules/module-ladspa-sink.c | 2 +- src/modules/module-solaris.c | 4 +- src/modules/module-tunnel.c | 2 +- src/modules/oss/module-oss.c | 3 -- src/modules/raop/module-raop-sink.c | 2 +- src/pulse/def.h | 18 +++++--- src/pulsecore/sink.c | 41 ++++++++++++++++--- src/pulsecore/source.c | 41 ++++++++++++++++--- 13 files changed, 100 insertions(+), 45 deletions(-) diff --git a/src/modules/alsa/alsa-sink.c b/src/modules/alsa/alsa-sink.c index 98cb75fc..0dd1840a 100644 --- a/src/modules/alsa/alsa-sink.c +++ b/src/modules/alsa/alsa-sink.c @@ -1759,9 +1759,9 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_v return 0; } - if (!u->mixer_path->has_volume) + if (!u->mixer_path->has_volume) { pa_log_info("Driver does not support hardware volume control, falling back to software volume control."); - else { + } else { if (u->mixer_path->has_dB) { pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB); @@ -1779,13 +1779,11 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_v pa_sink_set_get_volume_callback(u->sink, sink_get_volume_cb); pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb); - pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb); - u->sink->flags |= PA_SINK_HW_VOLUME_CTRL; if (u->mixer_path->has_dB) { u->sink->flags |= PA_SINK_DECIBEL_VOLUME; if (sync_volume) { - u->sink->flags |= PA_SINK_SYNC_VOLUME; + pa_sink_set_write_volume_callback(u->sink, sink_write_volume_cb); pa_log_info("Successfully enabled synchronous volume."); } } @@ -1798,11 +1796,10 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_v } else { pa_sink_set_get_mute_callback(u->sink, sink_get_mute_cb); pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb); - u->sink->flags |= PA_SINK_HW_MUTE_CTRL; pa_log_info("Using hardware mute control."); } - if (u->sink->flags & (PA_SINK_HW_VOLUME_CTRL|PA_SINK_HW_MUTE_CTRL)) { + if (u->mixer_path->has_volume || u->mixer_path->has_mute) { int (*mixer_callback)(snd_mixer_elem_t *, unsigned int); if (u->sink->flags & PA_SINK_SYNC_VOLUME) { u->mixer_pd = pa_alsa_mixer_pdata_new(); diff --git a/src/modules/alsa/alsa-source.c b/src/modules/alsa/alsa-source.c index 94c14cbb..941aacbe 100644 --- a/src/modules/alsa/alsa-source.c +++ b/src/modules/alsa/alsa-source.c @@ -1534,9 +1534,9 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_v return 0; } - if (!u->mixer_path->has_volume) + if (!u->mixer_path->has_volume) { pa_log_info("Driver does not support hardware volume control, falling back to software volume control."); - else { + } else { if (u->mixer_path->has_dB) { pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB); @@ -1554,13 +1554,11 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_v pa_source_set_get_volume_callback(u->source, source_get_volume_cb); pa_source_set_set_volume_callback(u->source, source_set_volume_cb); - pa_source_set_write_volume_callback(u->source, source_write_volume_cb); - u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL; if (u->mixer_path->has_dB) { u->source->flags |= PA_SOURCE_DECIBEL_VOLUME; if (sync_volume) { - u->source->flags |= PA_SOURCE_SYNC_VOLUME; + pa_source_set_write_volume_callback(u->source, source_write_volume_cb); pa_log_info("Successfully enabled synchronous volume."); } } @@ -1573,11 +1571,10 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB, pa_bool_t sync_v } else { pa_source_set_get_mute_callback(u->source, source_get_mute_cb); pa_source_set_set_mute_callback(u->source, source_set_mute_cb); - u->source->flags |= PA_SOURCE_HW_MUTE_CTRL; pa_log_info("Using hardware mute control."); } - if (u->source->flags & (PA_SOURCE_HW_VOLUME_CTRL|PA_SOURCE_HW_MUTE_CTRL)) { + if (u->mixer_path->has_volume || u->mixer_path->has_mute) { int (*mixer_callback)(snd_mixer_elem_t *, unsigned int); if (u->source->flags & PA_SOURCE_SYNC_VOLUME) { u->mixer_pd = pa_alsa_mixer_pdata_new(); diff --git a/src/modules/bluetooth/module-bluetooth-device.c b/src/modules/bluetooth/module-bluetooth-device.c index 61600d9f..9f813363 100644 --- a/src/modules/bluetooth/module-bluetooth-device.c +++ b/src/modules/bluetooth/module-bluetooth-device.c @@ -2022,7 +2022,7 @@ static int add_sink(struct userdata *u) { return -1; } - u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY | (u->profile == PROFILE_HSP ? PA_SINK_HW_VOLUME_CTRL : 0)); + u->sink = pa_sink_new(u->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY); pa_sink_new_data_done(&data); if (!u->sink) { @@ -2084,7 +2084,7 @@ static int add_source(struct userdata *u) { return -1; } - u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY | (u->profile == PROFILE_HSP ? PA_SOURCE_HW_VOLUME_CTRL : 0)); + u->source = pa_source_new(u->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY); pa_source_new_data_done(&data); if (!u->source) { diff --git a/src/modules/echo-cancel/module-echo-cancel.c b/src/modules/echo-cancel/module-echo-cancel.c index cc06d471..62b436b6 100644 --- a/src/modules/echo-cancel/module-echo-cancel.c +++ b/src/modules/echo-cancel/module-echo-cancel.c @@ -1523,7 +1523,7 @@ int pa__init(pa_module*m) { } u->source = pa_source_new(m->core, &source_data, - PA_SOURCE_HW_MUTE_CTRL|PA_SOURCE_HW_VOLUME_CTRL|PA_SOURCE_DECIBEL_VOLUME| + PA_SOURCE_DECIBEL_VOLUME| (source_master->flags & (PA_SOURCE_LATENCY|PA_SOURCE_DYNAMIC_LATENCY))); pa_source_new_data_done(&source_data); @@ -1571,7 +1571,7 @@ int pa__init(pa_module*m) { } u->sink = pa_sink_new(m->core, &sink_data, - PA_SINK_HW_MUTE_CTRL|PA_SINK_HW_VOLUME_CTRL|PA_SINK_DECIBEL_VOLUME| + PA_SINK_DECIBEL_VOLUME| (sink_master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))); pa_sink_new_data_done(&sink_data); diff --git a/src/modules/module-equalizer-sink.c b/src/modules/module-equalizer-sink.c index 03b166b9..d01d453f 100644 --- a/src/modules/module-equalizer-sink.c +++ b/src/modules/module-equalizer-sink.c @@ -1178,7 +1178,7 @@ int pa__init(pa_module*m) { } u->sink = pa_sink_new(m->core, &sink_data, - PA_SINK_HW_MUTE_CTRL|PA_SINK_HW_VOLUME_CTRL|PA_SINK_DECIBEL_VOLUME| + PA_SINK_DECIBEL_VOLUME| (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))); pa_sink_new_data_done(&sink_data); diff --git a/src/modules/module-ladspa-sink.c b/src/modules/module-ladspa-sink.c index aed6270b..b962b1b3 100644 --- a/src/modules/module-ladspa-sink.c +++ b/src/modules/module-ladspa-sink.c @@ -883,7 +883,7 @@ int pa__init(pa_module*m) { } u->sink = pa_sink_new(m->core, &sink_data, - PA_SINK_HW_MUTE_CTRL|PA_SINK_HW_VOLUME_CTRL|PA_SINK_DECIBEL_VOLUME| + PA_SINK_DECIBEL_VOLUME| (master->flags & (PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY))); pa_sink_new_data_done(&sink_data); diff --git a/src/modules/module-solaris.c b/src/modules/module-solaris.c index ce6af8a3..61ea68c2 100644 --- a/src/modules/module-solaris.c +++ b/src/modules/module-solaris.c @@ -933,7 +933,7 @@ int pa__init(pa_module *m) { goto fail; } - u->source = pa_source_new(m->core, &source_new_data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|PA_SOURCE_HW_VOLUME_CTRL); + u->source = pa_source_new(m->core, &source_new_data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY); pa_source_new_data_done(&source_new_data); pa_xfree(name_buf); @@ -981,7 +981,7 @@ int pa__init(pa_module *m) { goto fail; } - u->sink = pa_sink_new(m->core, &sink_new_data, PA_SINK_HARDWARE|PA_SINK_LATENCY|PA_SINK_HW_VOLUME_CTRL|PA_SINK_HW_MUTE_CTRL); + u->sink = pa_sink_new(m->core, &sink_new_data, PA_SINK_HARDWARE|PA_SINK_LATENCY); pa_sink_new_data_done(&sink_new_data); pa_assert(u->sink); diff --git a/src/modules/module-tunnel.c b/src/modules/module-tunnel.c index e7e08717..3efb40b2 100644 --- a/src/modules/module-tunnel.c +++ b/src/modules/module-tunnel.c @@ -2003,7 +2003,7 @@ int pa__init(pa_module*m) { goto fail; } - u->sink = pa_sink_new(m->core, &data, PA_SINK_NETWORK|PA_SINK_LATENCY|PA_SINK_HW_VOLUME_CTRL|PA_SINK_HW_MUTE_CTRL); + u->sink = pa_sink_new(m->core, &data, PA_SINK_NETWORK|PA_SINK_LATENCY); pa_sink_new_data_done(&data); if (!u->sink) { diff --git a/src/modules/oss/module-oss.c b/src/modules/oss/module-oss.c index a22b315d..accac323 100644 --- a/src/modules/oss/module-oss.c +++ b/src/modules/oss/module-oss.c @@ -1418,11 +1418,9 @@ int pa__init(pa_module*m) { if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0) pa_log_warn("SOUND_MIXER_READ_DEVMASK failed: %s", pa_cstrerror(errno)); - else { if (u->sink && (u->mixer_devmask & (SOUND_MASK_VOLUME|SOUND_MASK_PCM))) { pa_log_debug("Found hardware mixer track for playback."); - u->sink->flags |= PA_SINK_HW_VOLUME_CTRL; pa_sink_set_get_volume_callback(u->sink, sink_get_volume); pa_sink_set_set_volume_callback(u->sink, sink_set_volume); u->sink->n_volume_steps = 101; @@ -1431,7 +1429,6 @@ int pa__init(pa_module*m) { if (u->source && (u->mixer_devmask & (SOUND_MASK_RECLEV|SOUND_MASK_IGAIN))) { pa_log_debug("Found hardware mixer track for recording."); - u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL; pa_source_set_get_volume_callback(u->source, source_get_volume); pa_source_set_set_volume_callback(u->source, source_set_volume); u->source->n_volume_steps = 101; diff --git a/src/modules/raop/module-raop-sink.c b/src/modules/raop/module-raop-sink.c index 26004415..4b21d39a 100644 --- a/src/modules/raop/module-raop-sink.c +++ b/src/modules/raop/module-raop-sink.c @@ -596,7 +596,7 @@ int pa__init(pa_module*m) { u->sink->userdata = u; pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb); pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb); - u->sink->flags = PA_SINK_LATENCY|PA_SINK_NETWORK|PA_SINK_HW_VOLUME_CTRL; + u->sink->flags = PA_SINK_LATENCY|PA_SINK_NETWORK; pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq); pa_sink_set_rtpoll(u->sink, u->rtpoll); diff --git a/src/pulse/def.h b/src/pulse/def.h index 16b2e596..32169deb 100644 --- a/src/pulse/def.h +++ b/src/pulse/def.h @@ -712,7 +712,8 @@ typedef enum pa_sink_flags { /**< Flag to pass when no specific options are needed (used to avoid casting) \since 0.9.19 */ PA_SINK_HW_VOLUME_CTRL = 0x0001U, - /**< Supports hardware volume control */ + /**< Supports hardware volume control. This is a dynamic flag and may + * change at runtime after the sink has initialized */ PA_SINK_LATENCY = 0x0002U, /**< Supports latency querying */ @@ -725,10 +726,12 @@ typedef enum pa_sink_flags { /**< Is a networked sink of some kind. \since 0.9.7 */ PA_SINK_HW_MUTE_CTRL = 0x0010U, - /**< Supports hardware mute control \since 0.9.11 */ + /**< Supports hardware mute control. This is a dynamic flag and may + * change at runtime after the sink has initialized \since 0.9.11 */ PA_SINK_DECIBEL_VOLUME = 0x0020U, - /**< Volume can be translated to dB with pa_sw_volume_to_dB() + /**< Volume can be translated to dB with pa_sw_volume_to_dB(). This is a + * dynamic flag and may change at runtime after the sink has initialized * \since 0.9.11 */ PA_SINK_FLAT_VOLUME = 0x0040U, @@ -820,7 +823,8 @@ typedef enum pa_source_flags { /**< Flag to pass when no specific options are needed (used to avoid casting) \since 0.9.19 */ PA_SOURCE_HW_VOLUME_CTRL = 0x0001U, - /**< Supports hardware volume control */ + /**< Supports hardware volume control. This is a dynamic flag and may + * change at runtime after the source has initialized */ PA_SOURCE_LATENCY = 0x0002U, /**< Supports latency querying */ @@ -833,10 +837,12 @@ typedef enum pa_source_flags { /**< Is a networked source of some kind. \since 0.9.7 */ PA_SOURCE_HW_MUTE_CTRL = 0x0010U, - /**< Supports hardware mute control \since 0.9.11 */ + /**< Supports hardware mute control. This is a dynamic flag and may + * change at runtime after the source has initialized \since 0.9.11 */ PA_SOURCE_DECIBEL_VOLUME = 0x0020U, - /**< Volume can be translated to dB with pa_sw_volume_to_dB() + /**< Volume can be translated to dB with pa_sw_volume_to_dB(). This is a + * dynamic flag and may change at runtime after the source has initialized * \since 0.9.11 */ PA_SOURCE_DYNAMIC_LATENCY = 0x0040U, diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c index f7e4b6a2..b51156f7 100644 --- a/src/pulsecore/sink.c +++ b/src/pulsecore/sink.c @@ -458,13 +458,27 @@ void pa_sink_set_get_volume_callback(pa_sink *s, pa_sink_cb_t cb) { void pa_sink_set_set_volume_callback(pa_sink *s, pa_sink_cb_t cb) { pa_assert(s); + pa_assert(!s->write_volume || cb); + s->set_volume = cb; + + if (cb) + s->flags |= PA_SINK_HW_VOLUME_CTRL; + else + s->flags &= ~PA_SINK_HW_VOLUME_CTRL; } void pa_sink_set_write_volume_callback(pa_sink *s, pa_sink_cb_t cb) { pa_assert(s); + pa_assert(!cb || s->set_volume); + s->write_volume = cb; + + if (cb) + s->flags |= PA_SINK_SYNC_VOLUME; + else + s->flags &= ~PA_SINK_SYNC_VOLUME; } void pa_sink_set_get_mute_callback(pa_sink *s, pa_sink_cb_t cb) { @@ -477,6 +491,11 @@ void pa_sink_set_set_mute_callback(pa_sink *s, pa_sink_cb_t cb) { pa_assert(s); s->set_mute = cb; + + if (cb) + s->flags |= PA_SINK_HW_MUTE_CTRL; + else + s->flags &= ~PA_SINK_HW_MUTE_CTRL; } /* Called from main context */ @@ -492,8 +511,18 @@ void pa_sink_put(pa_sink* s) { pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency); /* Generally, flags should be initialized via pa_sink_new(). As a - * special exception we allow volume related flags to be set - * between _new() and _put(). */ + * special exception we allow some volume related flags to be set + * between _new() and _put() by the callback setter functions above. + * + * Thus we implement a couple safeguards here which ensure the above + * setters were used (or at least the implementor made manual changes + * in a compatible way). + * + * 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_HW_MUTE_CTRL) || s->set_mute); /* XXX: Currently decibel volume is disabled for all sinks that use volume * sharing. When the master sink supports decibel volume, it would be good @@ -502,6 +531,10 @@ void pa_sink_put(pa_sink* s) { * a master sink to another. One solution for this problem would be to * remove user-visible volume altogether from filter sinks when volume * sharing is used, but the current approach was easier to implement... */ + /* We always support decibel volumes in software, otherwise we leave it to + * the sink implementor to set this flag as needed. + * + * Note: This flag can also change over the life time of the sink. */ if (!(s->flags & PA_SINK_HW_VOLUME_CTRL) && !(s->flags & PA_SINK_SHARE_VOLUME_WITH_MASTER)) s->flags |= PA_SINK_DECIBEL_VOLUME; @@ -536,10 +569,6 @@ void pa_sink_put(pa_sink* s) { pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0)); pa_assert(!(s->flags & PA_SINK_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_LATENCY)); pa_assert(!(s->flags & PA_SINK_DYNAMIC_LATENCY) == !(s->monitor_source->flags & PA_SOURCE_DYNAMIC_LATENCY)); - pa_assert(!(s->flags & PA_SINK_HW_VOLUME_CTRL) || s->set_volume); - pa_assert(!(s->flags & PA_SINK_SYNC_VOLUME) || (s->flags & PA_SINK_HW_VOLUME_CTRL)); - pa_assert(!(s->flags & PA_SINK_SYNC_VOLUME) || s->write_volume); - pa_assert(!(s->flags & PA_SINK_HW_MUTE_CTRL) || s->set_mute); pa_assert(s->monitor_source->thread_info.fixed_latency == s->thread_info.fixed_latency); pa_assert(s->monitor_source->thread_info.min_latency == s->thread_info.min_latency); diff --git a/src/pulsecore/source.c b/src/pulsecore/source.c index 1ec80271..120ecdd1 100644 --- a/src/pulsecore/source.c +++ b/src/pulsecore/source.c @@ -390,13 +390,27 @@ void pa_source_set_get_volume_callback(pa_source *s, pa_source_cb_t cb) { void pa_source_set_set_volume_callback(pa_source *s, pa_source_cb_t cb) { pa_assert(s); + pa_assert(!s->write_volume || cb); + s->set_volume = cb; + + if (cb) + s->flags |= PA_SOURCE_HW_VOLUME_CTRL; + else + s->flags &= ~PA_SOURCE_HW_VOLUME_CTRL; } void pa_source_set_write_volume_callback(pa_source *s, pa_source_cb_t cb) { pa_assert(s); + pa_assert(!cb || s->set_volume); + s->write_volume = cb; + + if (cb) + s->flags |= PA_SOURCE_SYNC_VOLUME; + else + s->flags &= ~PA_SOURCE_SYNC_VOLUME; } void pa_source_set_get_mute_callback(pa_source *s, pa_source_cb_t cb) { @@ -409,6 +423,11 @@ void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb) { pa_assert(s); s->set_mute = cb; + + if (cb) + s->flags |= PA_SOURCE_HW_MUTE_CTRL; + else + s->flags &= ~PA_SOURCE_HW_MUTE_CTRL; } /* Called from main context */ @@ -424,8 +443,18 @@ void pa_source_put(pa_source *s) { pa_assert(s->thread_info.min_latency <= s->thread_info.max_latency); /* Generally, flags should be initialized via pa_source_new(). As a - * special exception we allow volume related flags to be set - * between _new() and _put(). */ + * special exception we allow some volume related flags to be set + * between _new() and _put() by the callback setter functions above. + * + * Thus we implement a couple safeguards here which ensure the above + * setters were used (or at least the implementor made manual changes + * in a compatible way). + * + * 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_HW_MUTE_CTRL) || s->set_mute); /* XXX: Currently decibel volume is disabled for all sources that use volume * sharing. When the master source supports decibel volume, it would be good @@ -434,6 +463,10 @@ void pa_source_put(pa_source *s) { * a master source to another. One solution for this problem would be to * remove user-visible volume altogether from filter sources when volume * sharing is used, but the current approach was easier to implement... */ + /* We always support decibel volumes in software, otherwise we leave it to + * the source implementor to set this flag as needed. + * + * Note: This flag can also change over the life time of the source. */ if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) s->flags |= PA_SOURCE_DECIBEL_VOLUME; @@ -466,10 +499,6 @@ void pa_source_put(pa_source *s) { && ((s->flags & PA_SOURCE_DECIBEL_VOLUME || (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))))); pa_assert(!(s->flags & PA_SOURCE_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1); pa_assert(!(s->flags & PA_SOURCE_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0)); - pa_assert(!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) || s->set_volume); - pa_assert(!(s->flags & PA_SOURCE_SYNC_VOLUME) || (s->flags & PA_SOURCE_HW_VOLUME_CTRL)); - pa_assert(!(s->flags & PA_SOURCE_SYNC_VOLUME) || s->write_volume); - pa_assert(!(s->flags & PA_SOURCE_HW_MUTE_CTRL) || s->set_mute); pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0); -- 2.39.2