Merge branch 'flatvol'

10 files changed, 311 insertions, 21 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index f2771980..7487839a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1032,6 +1032,7 @@ libavahi_wrap_la_LIBADD = $(AM_LIBADD) $(AVAHI_CFLAGS) libpulsecore.la
 ###################################
 
 modlibexec_LTLIBRARIES += \
+		module-flat-volume.la \
 		module-cli.la \
 		module-cli-protocol-tcp.la \
 		module-simple-protocol-tcp.la \
@@ -1235,7 +1236,8 @@ SYMDEF_FILES = \
 		modules/bluetooth/module-bluetooth-device-symdef.h \
 		modules/gconf/module-gconf-symdef.h \
 		modules/module-position-event-sounds-symdef.h \
-		modules/module-console-kit-symdef.h
+		modules/module-console-kit-symdef.h \
+		modules/module-flat-volume-symdef.h
 
 EXTRA_DIST += $(SYMDEF_FILES)
 BUILT_SOURCES += $(SYMDEF_FILES)
@@ -1247,6 +1249,12 @@ $(SYMDEF_FILES): modules/module-defs.h.m4
 	$(MKDIR_P) modules/bluetooth
 	$(M4) -Dfname="$@" $< > $@
 
+# Flat volume
+
+module_flat_volume_la_SOURCES = modules/module-flat-volume.c
+module_flat_volume_la_LDFLAGS = -module -avoid-version
+module_flat_volume_la_LIBADD = $(AM_LIBADD) libpulsecore.la
+
 # Simple protocol
 
 module_simple_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
diff --git a/src/modules/module-flat-volume.c b/src/modules/module-flat-volume.c
new file mode 100644
index 00000000..9bc8055a
--- /dev/null
+++ b/src/modules/module-flat-volume.c
@@ -0,0 +1,224 @@
+/***
+  This file is part of PulseAudio.
+
+  Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
+  Copyright 2004-2006, 2008 Lennart Poettering
+
+  Contact: Marc-Andre Lureau <marc-andre.lureau@nokia.com>
+
+  PulseAudio is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published
+  by the Free Software Foundation; either version 2 of the License,
+  or (at your option) any later version.
+
+  PulseAudio is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with PulseAudio; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+  USA.
+***/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <regex.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <pulse/xmalloc.h>
+
+#include <pulsecore/core-error.h>
+#include <pulsecore/module.h>
+#include <pulsecore/core-util.h>
+#include <pulsecore/log.h>
+#include <pulsecore/sink-input.h>
+#include <pulsecore/core-util.h>
+#include <pulsecore/macro.h>
+
+#include "module-flat-volume-symdef.h"
+
+PA_MODULE_AUTHOR("Marc-Andre Lureau");
+PA_MODULE_DESCRIPTION("Flat volume");
+PA_MODULE_VERSION(PACKAGE_VERSION);
+PA_MODULE_LOAD_ONCE(TRUE);
+PA_MODULE_USAGE("");
+
+struct userdata {
+    pa_subscription *subscription;
+    pa_hook_slot *sink_input_set_volume_hook_slot;
+    pa_hook_slot *sink_input_fixate_hook_slot;
+};
+
+static void process_input_volume_change(
+        pa_cvolume *dest_volume,
+        const pa_cvolume *dest_virtual_volume,
+        pa_channel_map *dest_channel_map,
+        pa_sink_input *this,
+        pa_sink *sink) {
+
+    pa_sink_input *i;
+    uint32_t idx;
+    pa_cvolume max_volume, sink_volume;
+
+    pa_assert(dest_volume);
+    pa_assert(dest_virtual_volume);
+    pa_assert(dest_channel_map);
+    pa_assert(sink);
+
+    if (!(sink->flags & PA_SINK_DECIBEL_VOLUME))
+        return;
+
+    pa_log_debug("Sink input volume changed");
+
+    max_volume = *dest_virtual_volume;
+    pa_cvolume_remap(&max_volume, dest_channel_map, &sink->channel_map);
+
+    for (i = PA_SINK_INPUT(pa_idxset_first(sink->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(sink->inputs, &idx))) {
+        /* skip this sink-input if we are processing a volume change request */
+        if (this && this == i)
+            continue;
+
+        if (pa_cvolume_max(&i->virtual_volume) > pa_cvolume_max(&max_volume)) {
+            max_volume = i->virtual_volume;
+            pa_cvolume_remap(&max_volume, &i->channel_map, &sink->channel_map);
+        }
+    }
+
+    /* Set the master volume, and normalize inputs */
+    if (!pa_cvolume_equal(&max_volume, &sink->volume)) {
+
+        pa_sink_set_volume(sink, &max_volume);
+
+        pa_log_debug("sink = %.2f (changed)", (double)pa_cvolume_avg(&sink->volume)/PA_VOLUME_NORM);
+
+        /* Now, normalize each of the internal volume (client sink-input volume / sink master volume) */
+        for (i = PA_SINK_INPUT(pa_idxset_first(sink->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(sink->inputs, &idx))) {
+            /* skip this sink-input if we are processing a volume change request */
+            if (this && this == i)
+                continue;
+
+            sink_volume = max_volume;
+            pa_cvolume_remap(&sink_volume, &sink->channel_map, &i->channel_map);
+            pa_sw_cvolume_divide(&i->volume, &i->virtual_volume, &sink_volume);
+            pa_log_debug("sink input { id = %d, flat = %.2f, true = %.2f }",
+                         i->index,
+                         (double)pa_cvolume_avg(&i->virtual_volume)/PA_VOLUME_NORM,
+                         (double)pa_cvolume_avg(&i->volume)/PA_VOLUME_NORM);
+            pa_asyncmsgq_post(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_VOLUME, pa_xnewdup(struct pa_cvolume, &i->volume, 1), 0, NULL, pa_xfree);
+        }
+    } else
+        pa_log_debug("sink = %.2f", (double)pa_cvolume_avg(&sink->volume)/PA_VOLUME_NORM);
+
+    /* and this one */
+
+    sink_volume = max_volume;
+    pa_cvolume_remap(&sink_volume, &sink->channel_map, dest_channel_map);
+    pa_sw_cvolume_divide(dest_volume, dest_virtual_volume, &sink_volume);
+    pa_log_debug("caller sink input: { id = %d, flat = %.2f, true = %.2f }",
+                 this ? (int)this->index : -1,
+                 (double)pa_cvolume_avg(dest_virtual_volume)/PA_VOLUME_NORM,
+                 (double)pa_cvolume_avg(dest_volume)/PA_VOLUME_NORM);
+}
+
+static pa_hook_result_t sink_input_set_volume_hook_callback(pa_core *c, pa_sink_input_set_volume_data *this, struct userdata *u) {
+    pa_assert(this);
+    pa_assert(this->sink_input);
+
+    process_input_volume_change(&this->volume, &this->virtual_volume, &this->sink_input->channel_map,
+                                this->sink_input, this->sink_input->sink);
+
+    return PA_HOOK_OK;
+}
+
+static pa_hook_result_t sink_input_fixate_hook_callback(pa_core *core, pa_sink_input_new_data *this, struct userdata *u) {
+    pa_assert(this);
+    pa_assert(this->sink);
+
+    process_input_volume_change(&this->volume, &this->virtual_volume, &this->channel_map,
+                                NULL, this->sink);
+
+    return PA_HOOK_OK;
+}
+
+static void subscribe_callback(pa_core *core, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
+    struct userdata *u = userdata;
+    pa_sink *sink;
+    pa_sink_input *i;
+    uint32_t iidx;
+    pa_cvolume sink_volume;
+
+    pa_assert(core);
+    pa_assert(u);
+
+    if (t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW) &&
+        t != (PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE))
+        return;
+
+    if (!(sink = pa_idxset_get_by_index(core->sinks, idx)))
+        return;
+
+    if (!(sink->flags & PA_SINK_DECIBEL_VOLUME))
+        return;
+
+    pa_log_debug("Sink volume changed");
+    pa_log_debug("sink = %.2f", (double)pa_cvolume_avg(pa_sink_get_volume(sink, FALSE)) / PA_VOLUME_NORM);
+
+    sink_volume = *pa_sink_get_volume(sink, FALSE);
+
+    for (i = PA_SINK_INPUT(pa_idxset_first(sink->inputs, &iidx)); i; i = PA_SINK_INPUT(pa_idxset_next(sink->inputs, &iidx))) {
+        pa_cvolume si_volume;
+
+        si_volume = sink_volume;
+        pa_cvolume_remap(&si_volume, &sink->channel_map, &i->channel_map);
+        pa_sw_cvolume_multiply(&i->virtual_volume, &i->volume, &si_volume);
+        pa_log_debug("sink input = { id = %d, flat = %.2f, true = %.2f }",
+                     i->index,
+                     (double)pa_cvolume_avg(&i->virtual_volume)/PA_VOLUME_NORM,
+                     (double)pa_cvolume_avg(&i->volume)/PA_VOLUME_NORM);
+        pa_subscription_post(i->sink->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
+    }
+}
+
+int pa__init(pa_module*m) {
+    struct userdata *u;
+
+    pa_assert(m);
+
+    u = pa_xnew(struct userdata, 1);
+    m->userdata = u;
+
+    u->sink_input_fixate_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], PA_HOOK_LATE, (pa_hook_cb_t) sink_input_fixate_hook_callback, u);
+    u->sink_input_set_volume_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], PA_HOOK_LATE, (pa_hook_cb_t) sink_input_set_volume_hook_callback, u);
+
+    u->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_SINK, subscribe_callback, u);
+
+    return 0;
+}
+
+void pa__done(pa_module*m) {
+    struct userdata* u;
+
+    pa_assert(m);
+
+    if (!(u = m->userdata))
+        return;
+
+    if (u->subscription)
+      pa_subscription_free(u->subscription);
+
+    if (u->sink_input_set_volume_hook_slot)
+        pa_hook_slot_free(u->sink_input_set_volume_hook_slot);
+    if (u->sink_input_fixate_hook_slot)
+        pa_hook_slot_free(u->sink_input_fixate_hook_slot);
+
+    pa_xfree(u);
+}
diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c
index fe79291e..e1381a5e 100644
--- a/src/modules/module-stream-restore.c
+++ b/src/modules/module-stream-restore.c
@@ -134,7 +134,7 @@ static char *get_name(pa_proplist *p, const char *prefix) {
     else if ((r = pa_proplist_gets(p, PA_PROP_MEDIA_NAME)))
         return pa_sprintf_malloc("%s-by-media-name:%s", prefix, r);
 
-    return NULL;
+    return pa_sprintf_malloc("%s-fallback:%s", prefix);
 }
 
 static struct entry* read_entry(struct userdata *u, char *name) {
diff --git a/src/pulsecore/core.h b/src/pulsecore/core.h
index 39559082..f796fb93 100644
--- a/src/pulsecore/core.h
+++ b/src/pulsecore/core.h
@@ -49,6 +49,7 @@ typedef enum pa_core_hook {
     PA_CORE_HOOK_SINK_UNLINK_POST,
     PA_CORE_HOOK_SINK_STATE_CHANGED,
     PA_CORE_HOOK_SINK_PROPLIST_CHANGED,
+    PA_CORE_HOOK_SINK_SET_VOLUME,
     PA_CORE_HOOK_SOURCE_NEW,
     PA_CORE_HOOK_SOURCE_FIXATE,
     PA_CORE_HOOK_SOURCE_PUT,
@@ -65,6 +66,7 @@ typedef enum pa_core_hook {
     PA_CORE_HOOK_SINK_INPUT_MOVE_POST,
     PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED,
     PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED,
+    PA_CORE_HOOK_SINK_INPUT_SET_VOLUME,
     PA_CORE_HOOK_SOURCE_OUTPUT_NEW,
     PA_CORE_HOOK_SOURCE_OUTPUT_FIXATE,
     PA_CORE_HOOK_SOURCE_OUTPUT_PUT,
diff --git a/src/pulsecore/protocol-native.c b/src/pulsecore/protocol-native.c
index 778aab57..46dcb14a 100644
--- a/src/pulsecore/protocol-native.c
+++ b/src/pulsecore/protocol-native.c
@@ -2722,7 +2722,7 @@ static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t,
     pa_tagstruct_putu32(t, s->sink->index);
     pa_tagstruct_put_sample_spec(t, &fixed_ss);
     pa_tagstruct_put_channel_map(t, &s->channel_map);
-    pa_tagstruct_put_cvolume(t, &s->volume);
+    pa_tagstruct_put_cvolume(t, pa_sink_input_get_volume(s));
     pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
     pa_tagstruct_put_usec(t, sink_latency);
     pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
diff --git a/src/pulsecore/sink-input.c b/src/pulsecore/sink-input.c
index 4f70347f..8505c63f 100644
--- a/src/pulsecore/sink-input.c
+++ b/src/pulsecore/sink-input.c
@@ -75,7 +75,7 @@ void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cv
     pa_assert(data);
 
     if ((data->volume_is_set = !!volume))
-        data->volume = *volume;
+        data->volume = data->virtual_volume = *volume;
 }
 
 void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute) {
@@ -119,6 +119,7 @@ pa_sink_input* pa_sink_input_new(
     pa_sink_input *i;
     pa_resampler *resampler = NULL;
     char st[PA_SAMPLE_SPEC_SNPRINT_MAX], cm[PA_CHANNEL_MAP_SNPRINT_MAX];
+    pa_channel_map original_cm;
 
     pa_assert(core);
     pa_assert(data);
@@ -141,20 +142,25 @@ pa_sink_input* pa_sink_input_new(
     pa_return_null_if_fail(pa_sample_spec_valid(&data->sample_spec));
 
     if (!data->channel_map_is_set) {
-        if (data->sink->channel_map.channels == data->sample_spec.channels)
+        if (pa_channel_map_compatible(&data->sink->channel_map, &data->sample_spec))
             data->channel_map = data->sink->channel_map;
         else
-            pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
+            pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
     }
 
     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
-    pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
+    pa_return_null_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec));
 
-    if (!data->volume_is_set)
+    if (!data->volume_is_set) {
         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
+        pa_cvolume_reset(&data->virtual_volume, data->sample_spec.channels);
+    }
 
     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
-    pa_return_null_if_fail(data->volume.channels == data->sample_spec.channels);
+    pa_return_null_if_fail(pa_cvolume_compatible(&data->volume.channels, &data->sample_spec));
+
+    pa_return_null_if_fail(pa_cvolume_valid(&data->virtual_volume));
+    pa_return_null_if_fail(pa_cvolume_compatible(&data->virtual_volume.channels, &data->sample_spec));
 
     if (!data->muted_is_set)
         data->muted = FALSE;
@@ -165,6 +171,8 @@ pa_sink_input* pa_sink_input_new(
     if (flags & PA_SINK_INPUT_FIX_RATE)
         data->sample_spec.rate = data->sink->sample_spec.rate;
 
+    original_cm = data->channel_map;
+
     if (flags & PA_SINK_INPUT_FIX_CHANNELS) {
         data->sample_spec.channels = data->sink->sample_spec.channels;
         data->channel_map = data->sink->channel_map;
@@ -174,8 +182,7 @@ pa_sink_input* pa_sink_input_new(
     pa_assert(pa_channel_map_valid(&data->channel_map));
 
     /* Due to the fixing of the sample spec the volume might not match anymore */
-    if (data->volume.channels != data->sample_spec.channels)
-        pa_cvolume_set(&data->volume, data->sample_spec.channels, pa_cvolume_avg(&data->volume));
+    pa_cvolume_remap(&data->volume, &original_cm, &data->channel_map);
 
     if (data->resample_method == PA_RESAMPLER_INVALID)
         data->resample_method = core->resample_method;
@@ -227,7 +234,9 @@ pa_sink_input* pa_sink_input_new(
     i->sample_spec = data->sample_spec;
     i->channel_map = data->channel_map;
 
+    i->virtual_volume = data->virtual_volume;
     i->volume = data->volume;
+
     i->muted = data->muted;
 
     if (data->sync_base) {
@@ -784,17 +793,34 @@ pa_usec_t pa_sink_input_get_requested_latency(pa_sink_input *i) {
 
 /* Called from main context */
 void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume) {
+    pa_sink_input_set_volume_data data;
+
     pa_sink_input_assert_ref(i);
     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
     pa_assert(volume);
+    pa_assert(pa_cvolume_valid(volume));
+    pa_assert(pa_cvolume_compatible(volume, &i->sample_spec));
+
+    data.sink_input = i;
+    data.virtual_volume = *volume;
+    data.volume = *volume;
 
-    if (pa_cvolume_equal(&i->volume, volume))
+    /* If you change something here, consider looking into
+     * module-flat-volume.c as well since it uses very similar
+     * code. */
+
+    if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_SET_VOLUME], &data) < 0)
         return;
 
-    i->volume = *volume;
+    if (!pa_cvolume_equal(&i->volume, &data.volume)) {
+        i->volume = data.volume;
+        pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_VOLUME, &data.volume, 0, NULL) == 0);
+    }
 
-    pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_VOLUME, &i->volume, 0, NULL) == 0);
-    pa_subscription_post(i->sink->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
+    if (!pa_cvolume_equal(&i->virtual_volume, &data.virtual_volume)) {
+        i->virtual_volume = data.virtual_volume;
+        pa_subscription_post(i->sink->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
+    }
 }
 
 /* Called from main context */
@@ -802,7 +828,7 @@ const pa_cvolume *pa_sink_input_get_volume(pa_sink_input *i) {
     pa_sink_input_assert_ref(i);
     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
 
-    return &i->volume;
+    return &i->virtual_volume;
 }
 
 /* Called from main context */
diff --git a/src/pulsecore/sink-input.h b/src/pulsecore/sink-input.h
index 7663f22c..ed95fe4b 100644
--- a/src/pulsecore/sink-input.h
+++ b/src/pulsecore/sink-input.h
@@ -89,6 +89,8 @@ struct pa_sink_input {
 
     pa_sink_input *sync_prev, *sync_next;
 
+    pa_cvolume virtual_volume;
+
     pa_cvolume volume;
     pa_bool_t muted;
 
@@ -218,6 +220,9 @@ typedef struct pa_sink_input_new_data {
 
     pa_sample_spec sample_spec;
     pa_channel_map channel_map;
+
+    pa_cvolume virtual_volume;
+
     pa_cvolume volume;
     pa_bool_t muted:1;
 
@@ -239,6 +244,12 @@ typedef struct pa_sink_input_move_hook_data {
     pa_sink *destination;
 } pa_sink_input_move_hook_data;
 
+typedef struct pa_sink_set_input_volume_data {
+  pa_sink_input *sink_input;
+  pa_cvolume virtual_volume;
+  pa_cvolume volume;
+} pa_sink_input_set_volume_data;
+
 /* To be called by the implementing module only */
 
 pa_sink_input* pa_sink_input_new(
diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c
index e04fc08a..d8d1f792 100644
--- a/src/pulsecore/sink.c
+++ b/src/pulsecore/sink.c
@@ -843,13 +843,27 @@ pa_usec_t pa_sink_get_latency(pa_sink *s) {
 /* Called from main thread */
 void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume) {
     pa_bool_t changed;
+    pa_sink_set_volume_data data;
 
     pa_sink_assert_ref(s);
     pa_assert(PA_SINK_IS_LINKED(s->state));
     pa_assert(volume);
+    pa_assert(pa_cvolume_valid(volume));
+    pa_assert(pa_cvolume_compatible(volume, &s->sample_spec));
 
-    changed = !pa_cvolume_equal(volume, &s->volume);
-    s->volume = *volume;
+    data.sink = s;
+    data.volume = *volume;
+
+    changed = !pa_cvolume_equal(&data.volume, &s->volume);
+
+    if (changed) {
+        if (pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_SET_VOLUME], &data) < 0)
+            return;
+
+        changed = !pa_cvolume_equal(&data.volume, &s->volume);
+    }
+
+    s->volume = data.volume;
 
     if (s->set_volume && s->set_volume(s) < 0)
         s->set_volume = NULL;
diff --git a/src/pulsecore/sink.h b/src/pulsecore/sink.h
index 672bdd39..74671b44 100644
--- a/src/pulsecore/sink.h
+++ b/src/pulsecore/sink.h
@@ -206,6 +206,11 @@ void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volum
 void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute);
 void pa_sink_new_data_done(pa_sink_new_data *data);
 
+typedef struct pa_sink_set_volume_data {
+  pa_sink *sink;
+  pa_cvolume volume;
+} pa_sink_set_volume_data;
+
 /* To be called exclusively by the sink driver, from main context */
 
 pa_sink* pa_sink_new(
diff --git a/src/pulsecore/source-output.c b/src/pulsecore/source-output.c
index d76f6e4e..7adc7572 100644
--- a/src/pulsecore/source-output.c
+++ b/src/pulsecore/source-output.c
@@ -124,14 +124,14 @@ pa_source_output* pa_source_output_new(
     pa_return_null_if_fail(pa_sample_spec_valid(&data->sample_spec));
 
     if (!data->channel_map_is_set) {
-        if (data->source->channel_map.channels == data->sample_spec.channels)
+        if (pa_channel_map_compatible(&data->source->channel_map, &data->sample_spec))
             data->channel_map = data->source->channel_map;
         else
-            pa_return_null_if_fail(pa_channel_map_init_auto(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT));
+            pa_channel_map_init_extend(&data->channel_map, data->sample_spec.channels, PA_CHANNEL_MAP_DEFAULT);
     }
 
     pa_return_null_if_fail(pa_channel_map_valid(&data->channel_map));
-    pa_return_null_if_fail(data->channel_map.channels == data->sample_spec.channels);
+    pa_return_null_if_fail(pa_channel_map_compatible(&data->channel_map, &data->sample_spec));
 
     if (flags & PA_SOURCE_OUTPUT_FIX_FORMAT)
         data->sample_spec.format = data->source->sample_spec.format;