Add IVI-specific PulseAudio patches and development files

This is a stripped-down port of Tizen IVI PulseAudio 5.0
patches to AGL PulseAudio 6.0.
These patches mainly:
- provide a new "pulseaudio-module-dev" package, including
headers and libraries for out-of-tree module development;
- add generic helper functions;
- add a helper "libvolume" library;
- add helper functions for an efficient "volume ramp
up/down" feature, so that a module does not need to track
volume changes' timing and state in realtime.

These patches are needed for the PulseAudio Routing Module
described on: https://wiki.automotivelinux.org/
eg-ui-graphics-req-audiorouting (which is itself a stripped
-down version of the Tizen IVI Audio Routing module).

Change-Id: Ib826f3106b91ffdef639c2719a580373f84449c7
Signed-off-by: Manuel Bachmann <mbc@iot.bzh>

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0008-install-files-for-a-module-development.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0008-install-files-for-a-module-development.patch
new file mode 100644 (file)
index 0000000..ac164d6
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0008-install-files-for-a-module-development.patch
@@ -0,0 +1,53 @@
+--- a/Makefile.am      2016-04-12 11:28:10.832997230 +0200
++++ b/Makefile.am      2016-04-12 11:32:41.868996777 +0200
+@@ -49,7 +49,13 @@
+               vala/libpulse-simple.deps vala/libpulse-simple.vapi
+ 
+ pkgconfigdir = $(libdir)/pkgconfig
+-pkgconfig_DATA = libpulse.pc libpulse-simple.pc
++pkgconfig_DATA = libpulse.pc libpulse-simple.pc pulseaudio-module-devel.pc
++
++moduledev_DATA = pulsecore-config.h $(top_srcdir)/src/pulsecore/*.h
++moduledevdir = $(includedir)/pulsemodule/pulsecore
++
++moduledevinternal_DATA = src/pulse/internal.h src/pulse/client-conf.h src/pulse/fork-detect.h 
++moduledevinternaldir = $(includedir)/pulsemodule/pulse
+ 
+ if HAVE_GLIB20
+ pkgconfig_DATA += \
+@@ -103,6 +109,9 @@
+ check-daemon:
+       $(MAKE) -C src check-daemon
+ 
++pulsecore-config.h: config.h
++      cp $< $@
++
+ .PHONY: homepage distcleancheck doxygen
+ 
+ # see git-version-gen
+--- a/configure.ac     2016-04-12 11:34:10.605996629 +0200
++++ b/configure.ac     2016-04-12 11:37:43.502996274 +0200
+@@ -1464,6 +1464,7 @@
+ man/default.pa.5.xml
+ man/pulse-cli-syntax.5.xml
+ man/start-pulseaudio-x11.1.xml
++pulseaudio-module-devel.pc
+ ])
+ 
+ AC_CONFIG_FILES([src/esdcompat:src/daemon/esdcompat.in], [chmod +x src/esdcompat])
+--- /dev/null  2016-03-15 16:08:23.302999643 +0100
++++ b/pulseaudio-module-devel.pc.in    2016-03-17 16:16:58.427977484 +0100
+@@ -0,0 +1,12 @@
++prefix=@prefix@
++exec_prefix=@exec_prefix@
++libdir=@libdir@
++includedir=@includedir@
++modlibexecdir=@modlibexecdir@
++
++Name: pulseaudio-module-devel
++Description: PulseAudio Module Development Interface
++Version: @PACKAGE_VERSION@
++Libs: -L${libdir} -L${libdir}/pulseaudio -L${modlibexecdir} -lpulsecommon-@PA_MAJORMINOR@ -lpulsecore-@PA_MAJORMINOR@ -lprotocol-native
++Libs.private:
++Cflags: -I${includedir}/pulsemodule -D_REENTRANT
+

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0010-volume-ramp-additions-to-the-low-level-infra.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0010-volume-ramp-additions-to-the-low-level-infra.patch
new file mode 100644 (file)
index 0000000..e249bc4
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0010-volume-ramp-additions-to-the-low-level-infra.patch
@@ -0,0 +1,503 @@
+--- a/src/map-file     2016-04-12 15:03:17.009975690 +0200
++++ b/src/map-file     2016-04-12 15:03:52.389975631 +0200
+@@ -136,6 +136,9 @@
+ pa_cvolume_merge;
+ pa_cvolume_min;
+ pa_cvolume_min_mask;
++pa_cvolume_ramp_init;
++pa_cvolume_ramp_set;
++pa_cvolume_ramp_channel_ramp_set;
+ pa_cvolume_remap;
+ pa_cvolume_scale;
+ pa_cvolume_scale_mask;
+--- a/src/pulse/def.h  2016-04-12 15:05:58.245975421 +0200
++++ b/src/pulse/def.h  2016-04-12 15:13:19.424974685 +0200
+@@ -347,11 +347,15 @@
+      * consider absolute when the sink is in flat volume mode,
+      * relative otherwise. \since 0.9.20 */
+ 
+-    PA_STREAM_PASSTHROUGH = 0x80000U
++    PA_STREAM_PASSTHROUGH = 0x80000U,
+     /**< Used to tag content that will be rendered by passthrough sinks.
+      * The data will be left as is and not reformatted, resampled.
+      * \since 1.0 */
+ 
++    PA_STREAM_START_RAMP_MUTED = 0x100000U
++    /**< Used to tag content that the stream will be started ramp volume
++     * muted so that you can nicely fade it in */
++
+ } pa_stream_flags_t;
+ 
+ /** \cond fulldocs */
+@@ -380,6 +384,7 @@
+ #define PA_STREAM_FAIL_ON_SUSPEND PA_STREAM_FAIL_ON_SUSPEND
+ #define PA_STREAM_RELATIVE_VOLUME PA_STREAM_RELATIVE_VOLUME
+ #define PA_STREAM_PASSTHROUGH PA_STREAM_PASSTHROUGH
++#define PA_STREAM_START_RAMP_MUTED PA_STREAM_START_RAMP_MUTED
+ 
+ /** \endcond */
+ 
+@@ -1047,6 +1052,13 @@
+ /** \endcond */
+ #endif
+ 
++/** \cond fulldocs */
++#define PA_VOLUMER_RAMP_TYPE_LINEAR PA_VOLUMER_RAMP_TYPE_LINEAR
++#define PA_VOLUMER_RAMP_TYPE_LOGARITHMIC PA_VOLUMER_RAMP_TYPE_LOGARITHMIC
++#define PA_VOLUMER_RAMP_TYPE_CUBIC PA_VOLUMER_RAMP_TYPE_CUBIC
++
++/** \endcond */
++
+ PA_C_DECL_END
+ 
+ #endif
+--- a/src/pulse/volume.c       2016-04-12 15:13:38.598974653 +0200
++++ b/src/pulse/volume.c       2016-04-12 15:27:57.729973219 +0200
+@@ -445,7 +445,10 @@
+     unsigned c;
+     pa_assert(a);
+ 
+-    pa_return_val_if_fail(pa_cvolume_valid(a), 0);
++    if (pa_cvolume_valid(a) == 0)
++        abort();
++
++    /* pa_return_val_if_fail(pa_cvolume_valid(a), 0); */
+     pa_return_val_if_fail(PA_VOLUME_IS_VALID(v), 0);
+ 
+     for (c = 0; c < a->channels; c++)
+@@ -986,3 +989,51 @@
+ 
+     return pa_cvolume_scale(v, m);
+ }
++
++pa_cvolume_ramp* pa_cvolume_ramp_init(pa_cvolume_ramp *ramp) {
++    unsigned c;
++
++    pa_assert(ramp);
++
++    ramp->channels = 0;
++
++    for (c = 0; c < PA_CHANNELS_MAX; c++) {
++        ramp->ramps[c].type = PA_VOLUME_RAMP_TYPE_LINEAR;
++        ramp->ramps[c].length = 0;
++        ramp->ramps[c].target = PA_VOLUME_INVALID;
++    }
++
++    return ramp;
++}
++
++pa_cvolume_ramp* pa_cvolume_ramp_set(pa_cvolume_ramp *ramp, unsigned channels, pa_volume_ramp_type_t type, long time, pa_volume_t vol) {
++    int i;
++
++    pa_assert(ramp);
++    pa_assert(channels > 0);
++    pa_assert(time >= 0);
++    pa_assert(channels <= PA_CHANNELS_MAX);
++
++    ramp->channels = (uint8_t) channels;
++
++    for (i = 0; i < ramp->channels; i++) {
++        ramp->ramps[i].type = type;
++        ramp->ramps[i].length = time;
++        ramp->ramps[i].target = PA_CLAMP_VOLUME(vol);
++    }
++
++    return ramp;
++}
++
++pa_cvolume_ramp* pa_cvolume_ramp_channel_ramp_set(pa_cvolume_ramp *ramp, unsigned channel, pa_volume_ramp_type_t type, long time, pa_volume_t vol) {
++
++    pa_assert(ramp);
++    pa_assert(channel <= ramp->channels);
++    pa_assert(time >= 0);
++
++    ramp->ramps[channel].type = type;
++    ramp->ramps[channel].length = time;
++    ramp->ramps[channel].target = PA_CLAMP_VOLUME(vol);
++
++    return ramp;
++}
+--- a/src/pulse/volume.h       2016-04-12 15:40:34.989971955 +0200
++++ b/src/pulse/volume.h       2016-04-12 15:38:50.708972129 +0200
+@@ -413,6 +413,36 @@
+  * the channels are kept. \since 0.9.16 */
+ pa_cvolume* pa_cvolume_dec(pa_cvolume *v, pa_volume_t dec);
+ 
++/** Volume ramp type
++*/
++typedef enum pa_volume_ramp_type {
++    PA_VOLUME_RAMP_TYPE_LINEAR = 0,        /**< linear */
++    PA_VOLUME_RAMP_TYPE_LOGARITHMIC = 1,   /**< logarithmic */
++    PA_VOLUME_RAMP_TYPE_CUBIC = 2,
++} pa_volume_ramp_type_t;
++
++/** A structure encapsulating a volume ramp */
++typedef struct pa_volume_ramp_t {
++    pa_volume_ramp_type_t type;
++    long length;
++    pa_volume_t target;
++} pa_volume_ramp_t;
++
++/** A structure encapsulating a multichannel volume ramp */
++typedef struct pam_cvolume_ramp {
++    uint8_t channels;
++    pa_volume_ramp_t ramps[PA_CHANNELS_MAX];
++} pa_cvolume_ramp;
++
++/** Init volume ramp struct */
++pa_cvolume_ramp* pa_cvolume_ramp_init(pa_cvolume_ramp *ramp);
++
++/** Set first n channels of ramp struct to certain value */
++pa_cvolume_ramp* pa_cvolume_ramp_set(pa_cvolume_ramp *ramp, unsigned channel, pa_volume_ramp_type_t type, long time, pa_volume_t vol);
++
++/** Set individual channel in the channel struct */
++pa_cvolume_ramp* pa_cvolume_ramp_channel_ramp_set(pa_cvolume_ramp *ramp, unsigned channel, pa_volume_ramp_type_t type, long time, pa_volume_t vol);
++
+ PA_C_DECL_END
+ 
+ #endif
+--- a/src/pulsecore/sample-util.c      2016-04-12 15:41:51.812971827 +0200
++++ b/src/pulsecore/sample-util.c      2016-04-12 16:31:56.795966812 +0200
+@@ -41,6 +41,13 @@
+ 
+ #define PA_SILENCE_MAX (PA_PAGE_SIZE*16)
+ 
++#define VOLUME_PADDING 32
++
++typedef union {
++    float f;
++    uint32_t i;
++} volume_val;
++
+ pa_memblock *pa_silence_memblock(pa_memblock* b, const pa_sample_spec *spec) {
+     void *data;
+ 
+@@ -403,3 +410,292 @@
+     usec = pa_bytes_to_usec_round_up(size, from);
+     return pa_usec_to_bytes_round_up(usec, to);
+ }
++
++static void calc_linear_integer_volume_no_mapping(int32_t linear[], float volume[], unsigned nchannels) {
++    unsigned channel, padding;
++
++    pa_assert(linear);
++    pa_assert(volume);
++
++    for (channel = 0; channel < nchannels; channel++)
++        linear[channel] = (int32_t) lrint(volume[channel] * 0x10000U);
++
++    for (padding = 0; padding < VOLUME_PADDING; padding++, channel++)
++        linear[channel] = linear[padding];
++}
++
++static void calc_linear_float_volume_no_mapping(float linear[], float volume[], unsigned nchannels) {
++    unsigned channel, padding;
++
++    pa_assert(linear);
++    pa_assert(volume);
++
++    for (channel = 0; channel < nchannels; channel++)
++        linear[channel] = volume[channel];
++
++    for (padding = 0; padding < VOLUME_PADDING; padding++, channel++)
++        linear[channel] = linear[padding];
++}
++
++typedef void (*pa_calc_volume_no_mapping_func_t) (void *volumes, float *volume, int channels);
++
++static const pa_calc_volume_no_mapping_func_t calc_volume_table_no_mapping[] = {
++  [PA_SAMPLE_U8]        = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_ALAW]      = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_ULAW]      = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S16LE]     = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S16BE]     = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_FLOAT32LE] = (pa_calc_volume_no_mapping_func_t) calc_linear_float_volume_no_mapping,
++  [PA_SAMPLE_FLOAT32BE] = (pa_calc_volume_no_mapping_func_t) calc_linear_float_volume_no_mapping,
++  [PA_SAMPLE_S32LE]     = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S32BE]     = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S24LE]     = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S24BE]     = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S24_32LE]  = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping,
++  [PA_SAMPLE_S24_32BE]  = (pa_calc_volume_no_mapping_func_t) calc_linear_integer_volume_no_mapping
++};
++
++static const unsigned format_sample_size_table[] = {
++  [PA_SAMPLE_U8]        = 1,
++  [PA_SAMPLE_ALAW]      = 1,
++  [PA_SAMPLE_ULAW]      = 1,
++  [PA_SAMPLE_S16LE]     = 2,
++  [PA_SAMPLE_S16BE]     = 2,
++  [PA_SAMPLE_FLOAT32LE] = 4,
++  [PA_SAMPLE_FLOAT32BE] = 4,
++  [PA_SAMPLE_S32LE]     = 4,
++  [PA_SAMPLE_S32BE]     = 4,
++  [PA_SAMPLE_S24LE]     = 3,
++  [PA_SAMPLE_S24BE]     = 3,
++  [PA_SAMPLE_S24_32LE]  = 4,
++  [PA_SAMPLE_S24_32BE]  = 4
++};
++
++static float calc_volume_ramp_linear(pa_volume_ramp_int_t *ramp) {
++    pa_assert(ramp);
++    pa_assert(ramp->length > 0);
++
++    /* basic linear interpolation */
++    return ramp->start + (ramp->length - ramp->left) * (ramp->end - ramp->start) / (float) ramp->length;
++}
++
++static float calc_volume_ramp_logarithmic(pa_volume_ramp_int_t *ramp) {
++    float x_val, s, e;
++    long temp;
++
++    pa_assert(ramp);
++    pa_assert(ramp->length > 0);
++
++    if (ramp->end > ramp->start) {
++        temp = ramp->left;
++        s = ramp->end;
++        e = ramp->start;
++    } else {
++        temp = ramp->length - ramp->left;
++        s = ramp->start;
++        e = ramp->end;
++    }
++
++    x_val = temp == 0 ? 0.0 : powf(temp, 10);
++
++    /* base 10 logarithmic interpolation */
++    return s + x_val * (e - s) / powf(ramp->length, 10);
++}
++
++static float calc_volume_ramp_cubic(pa_volume_ramp_int_t *ramp) {
++    float x_val, s, e;
++    long temp;
++
++    pa_assert(ramp);
++    pa_assert(ramp->length > 0);
++
++    if (ramp->end > ramp->start) {
++        temp = ramp->left;
++        s = ramp->end;
++        e = ramp->start;
++    } else {
++        temp = ramp->length - ramp->left;
++        s = ramp->start;
++        e = ramp->end;
++    }
++
++    x_val = temp == 0 ? 0.0 : cbrtf(temp);
++
++    /* cubic interpolation */
++    return s + x_val * (e - s) / cbrtf(ramp->length);
++}
++
++typedef float (*pa_calc_volume_ramp_func_t) (pa_volume_ramp_int_t *);
++
++static const pa_calc_volume_ramp_func_t calc_volume_ramp_table[] = {
++    [PA_VOLUME_RAMP_TYPE_LINEAR] = (pa_calc_volume_ramp_func_t) calc_volume_ramp_linear,
++    [PA_VOLUME_RAMP_TYPE_LOGARITHMIC] = (pa_calc_volume_ramp_func_t) calc_volume_ramp_logarithmic,
++    [PA_VOLUME_RAMP_TYPE_CUBIC] = (pa_calc_volume_ramp_func_t) calc_volume_ramp_cubic
++};
++
++static void calc_volume_ramps(pa_cvolume_ramp_int *ram, float *vol)
++{
++    int i;
++
++    for (i = 0; i < ram->channels; i++) {
++        if (ram->ramps[i].left <= 0) {
++            if (ram->ramps[i].target == PA_VOLUME_NORM) {
++                vol[i] = 1.0;
++            }
++        } else {
++            vol[i] = ram->ramps[i].curr = calc_volume_ramp_table[ram->ramps[i].type] (&ram->ramps[i]);
++            ram->ramps[i].left--;
++        }
++    }
++}
++
++void pa_volume_ramp_memchunk(
++        pa_memchunk *c,
++        const pa_sample_spec *spec,
++        pa_cvolume_ramp_int *ramp) {
++
++    void *ptr;
++    volume_val linear[PA_CHANNELS_MAX + VOLUME_PADDING];
++    float vol[PA_CHANNELS_MAX + VOLUME_PADDING];
++    pa_do_volume_func_t do_volume;
++    long length_in_frames;
++    int i;
++
++    pa_assert(c);
++    pa_assert(spec);
++    pa_assert(pa_frame_aligned(c->length, spec));
++    pa_assert(ramp);
++
++    length_in_frames = c->length / format_sample_size_table[spec->format] / spec->channels;
++
++    if (pa_memblock_is_silence(c->memblock)) {
++        for (i = 0; i < ramp->channels; i++) {
++            if (ramp->ramps[i].length > 0)
++                ramp->ramps[i].length -= length_in_frames;
++        }
++        return;
++    }
++
++    if (spec->format < 0 || spec->format >= PA_SAMPLE_MAX) {
++      pa_log_warn("Unable to change volume of format");
++      return;
++    }
++
++    do_volume = pa_get_volume_func(spec->format);
++    pa_assert(do_volume);
++
++    ptr = (uint8_t*) pa_memblock_acquire(c->memblock) + c->index;
++
++    for (i = 0; i < length_in_frames; i++) {
++        calc_volume_ramps(ramp, vol);
++        calc_volume_table_no_mapping[spec->format] ((void *)linear, vol, spec->channels);
++
++        /* we only process one frame per iteration */
++        do_volume (ptr, (void *)linear, spec->channels, format_sample_size_table[spec->format] * spec->channels);
++
++        /* pa_log_debug("1: %d  2: %d", linear[0], linear[1]); */
++
++        ptr = (uint8_t*)ptr + format_sample_size_table[spec->format] * spec->channels;
++    }
++
++    pa_memblock_release(c->memblock);
++}
++
++pa_cvolume_ramp_int* pa_cvolume_ramp_convert(const pa_cvolume_ramp *src, pa_cvolume_ramp_int *dst, int sample_rate) {
++    int i;
++    float temp;
++
++    for (i = 0; i < dst->channels; i++) {
++        dst->ramps[i].type = src->ramps[i].type;
++        /* ms to samples */
++        dst->ramps[i].length = src->ramps[i].length * sample_rate / 1000;
++        dst->ramps[i].left = dst->ramps[i].length;
++        dst->ramps[i].start = dst->ramps[i].end;
++        dst->ramps[i].target = src->ramps[i].target;
++        /* scale to pulse internal mapping so that when ramp is over there's no glitch in volume */
++        temp = src->ramps[i].target / (float)0x10000U;
++        dst->ramps[i].end = temp * temp * temp;
++    }
++
++    return dst;
++}
++
++bool pa_cvolume_ramp_active(pa_cvolume_ramp_int *ramp) {
++    int i;
++
++    for (i = 0; i < ramp->channels; i++) {
++        if (ramp->ramps[i].left > 0)
++            return true;
++    }
++
++    return false;
++}
++
++bool pa_cvolume_ramp_target_active(pa_cvolume_ramp_int *ramp) {
++    int i;
++
++    for (i = 0; i < ramp->channels; i++) {
++        if (ramp->ramps[i].target != PA_VOLUME_NORM)
++            return true;
++    }
++
++    return false;
++}
++
++pa_cvolume * pa_cvolume_ramp_get_targets(pa_cvolume_ramp_int *ramp, pa_cvolume *volume) {
++    int i = 0;
++
++    volume->channels = ramp->channels;
++
++    for (i = 0; i < ramp->channels; i++)
++        volume->values[i] = ramp->ramps[i].target;
++
++    return volume;
++}
++
++pa_cvolume_ramp_int* pa_cvolume_ramp_start_from(pa_cvolume_ramp_int *src, pa_cvolume_ramp_int *dst) {
++    int i;
++
++    for (i = 0; i < src->channels; i++) {
++        /* if new vols are invalid, copy old ramp i.e. no effect */
++        if (dst->ramps[i].target == PA_VOLUME_INVALID)
++            dst->ramps[i] = src->ramps[i];
++        /* if there's some old ramp still left */
++        else if (src->ramps[i].left > 0)
++            dst->ramps[i].start = src->ramps[i].curr;
++    }
++
++    return dst;
++}
++
++pa_cvolume_ramp_int* pa_cvolume_ramp_int_init(pa_cvolume_ramp_int *src, pa_volume_t vol, int channels) {
++    int i;
++    float temp;
++
++    src->channels = channels;
++
++    for (i = 0; i < channels; i++) {
++        src->ramps[i].type = PA_VOLUME_RAMP_TYPE_LINEAR;
++        src->ramps[i].length = 0;
++        src->ramps[i].left = 0;
++        if (vol == PA_VOLUME_NORM) {
++            src->ramps[i].start = 1.0;
++            src->ramps[i].end = 1.0;
++            src->ramps[i].curr = 1.0;
++        }
++        else if (vol == PA_VOLUME_MUTED) {
++            src->ramps[i].start = 0.0;
++            src->ramps[i].end = 0.0;
++            src->ramps[i].curr = 0.0;
++        }
++        else {
++            temp = vol / (float)0x10000U;
++            src->ramps[i].start = temp * temp * temp;
++            src->ramps[i].end = src->ramps[i].start;
++            src->ramps[i].curr = src->ramps[i].start;
++        }
++        src->ramps[i].target = vol;
++    }
++
++    return src;
++}
+--- a/src/pulsecore/sample-util.h      2016-04-12 15:53:06.327970701 +0200
++++ b/src/pulsecore/sample-util.h      2016-04-12 16:24:16.356967580 +0200
+@@ -45,6 +45,33 @@
+ 
+ pa_memchunk* pa_silence_memchunk_get(pa_silence_cache *cache, pa_mempool *pool, pa_memchunk* ret, const pa_sample_spec *spec, size_t length);
+ 
++typedef struct pa_volume_ramp_int_t {
++    pa_volume_ramp_type_t type;
++    long length;
++    long left;
++    float start;
++    float end;
++    float curr;
++    pa_volume_t target;
++} pa_volume_ramp_int_t;
++
++typedef struct pa_cvolume_ramp_int {
++    uint8_t channels;
++    pa_volume_ramp_int_t ramps[PA_CHANNELS_MAX];
++} pa_cvolume_ramp_int;
++
++pa_cvolume_ramp_int* pa_cvolume_ramp_convert(const pa_cvolume_ramp *src, pa_cvolume_ramp_int *dst, int sample_rate);
++bool pa_cvolume_ramp_active(pa_cvolume_ramp_int *ramp);
++bool pa_cvolume_ramp_target_active(pa_cvolume_ramp_int *ramp);
++pa_cvolume_ramp_int* pa_cvolume_ramp_start_from(pa_cvolume_ramp_int *src, pa_cvolume_ramp_int *dst);
++pa_cvolume_ramp_int* pa_cvolume_ramp_int_init(pa_cvolume_ramp_int *src, pa_volume_t vol, int channels);
++pa_cvolume * pa_cvolume_ramp_get_targets(pa_cvolume_ramp_int *ramp, pa_cvolume *volume);
++
++void pa_volume_ramp_memchunk(
++        pa_memchunk *c,
++        const pa_sample_spec *spec,
++        pa_cvolume_ramp_int *ramp);
++
+ size_t pa_frame_align(size_t l, const pa_sample_spec *ss) PA_GCC_PURE;
+ 
+ bool pa_frame_aligned(size_t l, const pa_sample_spec *ss) PA_GCC_PURE;

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0011-volume-ramp-adding-volume-ramping-to-sink-input.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0011-volume-ramp-adding-volume-ramping-to-sink-input.patch
new file mode 100644 (file)
index 0000000..08fb792
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0011-volume-ramp-adding-volume-ramping-to-sink-input.patch
@@ -0,0 +1,159 @@
+--- a/src/pulsecore/sink-input.c       2016-04-12 16:50:41.311964935 +0200
++++ b/src/pulsecore/sink-input.c       2016-04-12 17:22:40.420961732 +0200
+@@ -525,6 +525,11 @@
+     reset_callbacks(i);
+     i->userdata = NULL;
+ 
++    if (data->flags & PA_SINK_INPUT_START_RAMP_MUTED)
++        pa_cvolume_ramp_int_init(&i->ramp, PA_VOLUME_MUTED, data->sample_spec.channels);
++    else
++        pa_cvolume_ramp_int_init(&i->ramp, PA_VOLUME_NORM, data->sample_spec.channels);
++
+     i->thread_info.state = i->state;
+     i->thread_info.attached = false;
+     pa_atomic_store(&i->thread_info.drained, 1);
+@@ -541,6 +546,8 @@
+     i->thread_info.playing_for = 0;
+     i->thread_info.direct_outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
+ 
++    i->thread_info.ramp = i->ramp;
++
+     pa_assert_se(pa_idxset_put(core->sink_inputs, i, &i->index) == 0);
+     pa_assert_se(pa_idxset_put(i->sink->inputs, pa_sink_input_ref(i), NULL) == 0);
+ 
+@@ -922,6 +929,8 @@
+         while (tchunk.length > 0) {
+             pa_memchunk wchunk;
+             bool nvfs = need_volume_factor_sink;
++            pa_cvolume target;
++            bool tmp;
+ 
+             wchunk = tchunk;
+             pa_memblock_ref(wchunk.memblock);
+@@ -958,6 +967,16 @@
+                     pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &i->volume_factor_sink);
+                 }
+ 
++                /* check for possible volume ramp */
++                if (pa_cvolume_ramp_active(&i->thread_info.ramp)) {
++                    pa_memchunk_make_writable(&wchunk, 0);
++                    pa_volume_ramp_memchunk(&wchunk, &i->sink->sample_spec, &(i->thread_info.ramp));
++                } else if ((tmp = pa_cvolume_ramp_target_active(&(i->thread_info.ramp)))) {
++                    pa_memchunk_make_writable(&wchunk, 0);
++                    pa_cvolume_ramp_get_targets(&i->thread_info.ramp, &target);
++                    pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &target);
++                }
++
+                 pa_memblockq_push_align(i->thread_info.render_memblockq, &wchunk);
+             } else {
+                 pa_memchunk rchunk;
+@@ -974,6 +993,16 @@
+                         pa_volume_memchunk(&rchunk, &i->sink->sample_spec, &i->volume_factor_sink);
+                     }
+ 
++                    /* check for possible volume ramp */
++                    if (pa_cvolume_ramp_active(&i->thread_info.ramp)) {
++                        pa_memchunk_make_writable(&wchunk, 0);
++                        pa_volume_ramp_memchunk(&wchunk, &i->sink->sample_spec, &(i->thread_info.ramp));
++                    } else if ((tmp = pa_cvolume_ramp_target_active(&(i->thread_info.ramp)))) {
++                        pa_memchunk_make_writable(&wchunk, 0);
++                        pa_cvolume_ramp_get_targets(&i->thread_info.ramp, &target);
++                        pa_volume_memchunk(&wchunk, &i->sink->sample_spec, &target);
++                    }
++
+                     pa_memblockq_push_align(i->thread_info.render_memblockq, &rchunk);
+                     pa_memblock_unref(rchunk.memblock);
+                 }
+@@ -1338,6 +1367,31 @@
+     return 0;
+ }
+ 
++/* Called from main thread */
++void pa_sink_input_set_volume_ramp(
++        pa_sink_input *i,
++        const pa_cvolume_ramp *ramp,
++        bool send_msg,
++        bool save) {
++
++    pa_sink_input_assert_ref(i);
++    pa_assert_ctl_context();
++    pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
++    pa_assert(ramp);
++
++    pa_cvolume_ramp_convert(ramp, &i->ramp, i->sample_spec.rate);
++
++    pa_log_debug("setting volume ramp with target vol:%d and length:%ld",
++                i->ramp.ramps[0].target,
++                i->ramp.ramps[0].length);
++
++
++    /* This tells the sink that volume ramp changed */
++    if (send_msg)
++        pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i), PA_SINK_INPUT_MESSAGE_SET_VOLUME_RAMP,
++                                       NULL, 0, NULL) == 0);
++}
++
+ /* Called from main context */
+ static void set_real_ratio(pa_sink_input *i, const pa_cvolume *v) {
+     pa_sink_input_assert_ref(i);
+@@ -1929,6 +1983,12 @@
+             }
+             return 0;
+ 
++        case PA_SINK_INPUT_MESSAGE_SET_VOLUME_RAMP:
++            /* we have ongoing ramp where we take current start values */
++            pa_cvolume_ramp_start_from(&i->thread_info.ramp, &i->ramp);
++            i->thread_info.ramp = i->ramp;
++            return 0;
++
+         case PA_SINK_INPUT_MESSAGE_SET_SOFT_MUTE:
+             if (i->thread_info.muted != i->muted) {
+                 i->thread_info.muted = i->muted;
+--- a/src/pulsecore/sink-input.h       2016-04-12 16:50:46.712964926 +0200
++++ b/src/pulsecore/sink-input.h       2016-04-12 17:30:24.289960958 +0200
+@@ -59,7 +59,8 @@
+     PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND = 256,
+     PA_SINK_INPUT_NO_CREATE_ON_SUSPEND = 512,
+     PA_SINK_INPUT_KILL_ON_SUSPEND = 1024,
+-    PA_SINK_INPUT_PASSTHROUGH = 2048
++    PA_SINK_INPUT_PASSTHROUGH = 2048,
++    PA_SINK_INPUT_START_RAMP_MUTED = 4096,
+ } pa_sink_input_flags_t;
+ 
+ struct pa_sink_input {
+@@ -122,6 +123,9 @@
+      * this.*/
+     bool save_sink:1, save_volume:1, save_muted:1;
+ 
++    /* for volume ramps */
++    pa_cvolume_ramp_int ramp;
++
+     pa_resample_method_t requested_resample_method, actual_resample_method;
+ 
+     /* Returns the chunk of audio data and drops it from the
+@@ -250,6 +254,8 @@
+         pa_usec_t requested_sink_latency;
+ 
+         pa_hashmap *direct_outputs;
++
++        pa_cvolume_ramp_int ramp;
+     } thread_info;
+ 
+     void *userdata;
+@@ -266,6 +272,7 @@
+     PA_SINK_INPUT_MESSAGE_SET_STATE,
+     PA_SINK_INPUT_MESSAGE_SET_REQUESTED_LATENCY,
+     PA_SINK_INPUT_MESSAGE_GET_REQUESTED_LATENCY,
++    PA_SINK_INPUT_MESSAGE_SET_VOLUME_RAMP,
+     PA_SINK_INPUT_MESSAGE_MAX
+ };
+ 
+@@ -374,6 +381,8 @@
+ 
+ void pa_sink_input_set_mute(pa_sink_input *i, bool mute, bool save);
+ 
++void pa_sink_input_set_volume_ramp(pa_sink_input *i, const pa_cvolume_ramp *ramp, bool send_msg, bool save);
++
+ void pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_proplist *p);
+ 
+ pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i);

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0012-volume-ramp-add-volume-ramping-to-sink.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0012-volume-ramp-add-volume-ramping-to-sink.patch
new file mode 100644 (file)
index 0000000..43e8283
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0012-volume-ramp-add-volume-ramping-to-sink.patch
@@ -0,0 +1,159 @@
+--- a/src/pulsecore/sink.c     2016-04-12 18:01:23.403957855 +0200
++++ b/src/pulsecore/sink.c     2016-04-12 18:44:49.677953506 +0200
+@@ -324,6 +324,8 @@
+             &s->sample_spec,
+             0);
+ 
++    pa_cvolume_ramp_int_init(&s->ramp, PA_VOLUME_NORM, data->sample_spec.channels);
++
+     s->thread_info.rtpoll = NULL;
+     s->thread_info.inputs = pa_hashmap_new_full(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func, NULL,
+                                                 (pa_free_cb_t) pa_sink_input_unref);
+@@ -347,6 +349,8 @@
+     s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
+     s->thread_info.latency_offset = s->latency_offset;
+ 
++    s->thread_info.ramp = s->ramp;
++
+     /* FIXME: This should probably be moved to pa_sink_put() */
+     pa_assert_se(pa_idxset_put(core->sinks, s, &s->index) >= 0);
+ 
+@@ -1182,6 +1186,7 @@
+ 
+     } else if (n == 1) {
+         pa_cvolume volume;
++        pa_cvolume target;
+ 
+         *result = info[0].chunk;
+         pa_memblock_ref(result->memblock);
+@@ -1198,9 +1203,20 @@
+                                     result,
+                                     &s->sample_spec,
+                                     result->length);
+-        } else if (!pa_cvolume_is_norm(&volume)) {
++        } else if (!pa_cvolume_is_norm(&volume) || pa_cvolume_ramp_target_active(&s->thread_info.ramp) || pa_cvolume_ramp_active(&s->thread_info.ramp)) {
+             pa_memchunk_make_writable(result, 0);
+-            pa_volume_memchunk(result, &s->sample_spec, &volume);
++            if (!pa_cvolume_ramp_active(&s->thread_info.ramp)) {
++                if (!pa_cvolume_is_norm(&volume))
++                    pa_volume_memchunk(result, &s->sample_spec, &volume);
++                pa_volume_ramp_memchunk(result, &s->sample_spec, &(s->thread_info.ramp));
++            }
++            else {
++                if (pa_cvolume_ramp_target_active(&s->thread_info.ramp)) {
++                    pa_cvolume_ramp_get_targets(&s->thread_info.ramp, &target);
++                    pa_sw_cvolume_multiply(&volume, &volume, &target);
++                }
++                pa_volume_memchunk(result, &s->sample_spec, &volume);
++            }
+         }
+     } else {
+         void *ptr;
+@@ -1290,6 +1306,7 @@
+ 
+     } else {
+         void *ptr;
++        pa_cvolume target_vol;
+ 
+         ptr = pa_memblock_acquire(target->memblock);
+ 
+@@ -1299,6 +1316,15 @@
+                                 &s->thread_info.soft_volume,
+                                 s->thread_info.soft_muted);
+ 
++        if (pa_cvolume_ramp_target_active(&s->thread_info.ramp) || pa_cvolume_ramp_active(&s->thread_info.ramp)) {
++            if (pa_cvolume_ramp_active(&s->thread_info.ramp))
++                pa_volume_ramp_memchunk(target, &s->sample_spec, &(s->thread_info.ramp));
++            else {
++                pa_cvolume_ramp_get_targets(&s->thread_info.ramp, &target_vol);
++                pa_volume_memchunk(target, &s->sample_spec, &target_vol);
++            }
++        }
++
+         pa_memblock_release(target->memblock);
+     }
+ 
+@@ -2058,6 +2084,32 @@
+         pa_assert_se(pa_asyncmsgq_send(root_sink->asyncmsgq, PA_MSGOBJECT(root_sink), PA_SINK_MESSAGE_SET_SHARED_VOLUME, NULL, 0, NULL) == 0);
+ }
+ 
++/* Called from main thread */
++void pa_sink_set_volume_ramp(
++        pa_sink *s,
++        const pa_cvolume_ramp *ramp,
++        bool send_msg,
++        bool save) {
++
++    pa_sink_assert_ref(s);
++    pa_assert_ctl_context();
++    pa_assert(PA_SINK_IS_LINKED(s->state));
++    pa_assert(ramp);
++
++    /* make sure we don't change the volume when a PASSTHROUGH input is connected ...
++     * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
++    if (pa_sink_is_passthrough(s)) {
++        pa_log_warn("Cannot do volume ramp, Sink is connected to PASSTHROUGH input");
++        return;
++    }
++
++    pa_cvolume_ramp_convert(ramp, &s->ramp, s->sample_spec.rate);
++
++    /* This tells the sink that volume ramp changed */
++    if (send_msg)
++        pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SINK_MESSAGE_SET_VOLUME_RAMP, NULL, 0, NULL) == 0);
++}
++
+ /* Called from the io thread if sync volume is used, otherwise from the main thread.
+  * Only to be called by sink implementor */
+ void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume) {
+@@ -2713,6 +2765,12 @@
+             sync_input_volumes_within_thread(s);
+             return 0;
+ 
++        case PA_SINK_MESSAGE_SET_VOLUME_RAMP:
++            /* if we have ongoing ramp where we take current start values */
++            pa_cvolume_ramp_start_from(&s->thread_info.ramp, &s->ramp);
++            s->thread_info.ramp = s->ramp;
++            return 0;
++
+         case PA_SINK_MESSAGE_GET_VOLUME:
+ 
+             if ((s->flags & PA_SINK_DEFERRED_VOLUME) && s->get_volume) {
+--- a/src/pulsecore/sink.h     2016-04-12 18:01:42.117957824 +0200
++++ b/src/pulsecore/sink.h     2016-04-12 18:23:29.394955642 +0200
+@@ -105,6 +105,9 @@
+     pa_cvolume saved_volume;
+     bool saved_save_volume:1;
+ 
++    /* for volume ramps */
++    pa_cvolume_ramp_int ramp;
++
+     pa_asyncmsgq *asyncmsgq;
+ 
+     pa_memchunk silence;
+@@ -300,6 +303,8 @@
+         uint32_t volume_change_safety_margin;
+         /* Usec delay added to all volume change events, may be negative. */
+         int32_t volume_change_extra_delay;
++
++        pa_cvolume_ramp_int ramp;
+     } thread_info;
+ 
+     void *userdata;
+@@ -333,6 +338,7 @@
+     PA_SINK_MESSAGE_SET_MAX_REQUEST,
+     PA_SINK_MESSAGE_SET_PORT,
+     PA_SINK_MESSAGE_UPDATE_VOLUME_AND_MUTE,
++    PA_SINK_MESSAGE_SET_VOLUME_RAMP,
+     PA_SINK_MESSAGE_SET_LATENCY_OFFSET,
+     PA_SINK_MESSAGE_MAX
+ } pa_sink_message_t;
+@@ -453,6 +459,8 @@
+ void pa_sink_set_mute(pa_sink *sink, bool mute, bool save);
+ bool pa_sink_get_mute(pa_sink *sink, bool force_refresh);
+ 
++void pa_sink_set_volume_ramp(pa_sink *s, const pa_cvolume_ramp *ramp, bool send_msg, bool save); 
++
+ bool pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p);
+ 
+ int pa_sink_set_port(pa_sink *s, const char *name, bool save);

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0013-add-internal-corking-state-for-sink-input.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0013-add-internal-corking-state-for-sink-input.patch
new file mode 100644 (file)
index 0000000..cb68e26
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0013-add-internal-corking-state-for-sink-input.patch
@@ -0,0 +1,72 @@
+--- a/src/pulsecore/sink-input.c       2016-04-13 11:44:04.389999429 +0200
++++ b/src/pulsecore/sink-input.c       2016-04-13 11:52:45.167998560 +0200
+@@ -786,6 +786,9 @@
+     update_n_corked(i, state);
+     i->state = state;
+ 
++    i->corked = false;
++    i->corked_internal = false;
++
+     /* We might need to update the sink's volume if we are in flat volume mode. */
+     if (pa_sink_flat_volume_enabled(i->sink))
+         pa_sink_set_volume(i->sink, NULL, false, i->save_volume);
+@@ -1493,13 +1496,38 @@
+     }
+ }
+ 
++static void pa_sink_input_cork_really(pa_sink_input *i, bool b) {
++    pa_sink_input_assert_ref(i);
++    pa_assert_ctl_context();
++    pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
++
++    if (i->corked_internal == false && i->corked == false)
++        b = false;
++    else
++        b = true;
++
++    sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
++}
++
+ /* Called from main context */
+ void pa_sink_input_cork(pa_sink_input *i, bool b) {
+     pa_sink_input_assert_ref(i);
+     pa_assert_ctl_context();
+     pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
+ 
+-    sink_input_set_state(i, b ? PA_SINK_INPUT_CORKED : PA_SINK_INPUT_RUNNING);
++    i->corked = b;
++
++    pa_sink_input_cork_really(i, b);
++}
++
++void pa_sink_input_cork_internal(pa_sink_input *i, bool b) {
++    pa_sink_input_assert_ref(i);
++    pa_assert_ctl_context();
++    pa_assert(PA_SINK_INPUT_IS_LINKED(i->state));
++
++    i->corked_internal = b;
++
++    pa_sink_input_cork_really(i, b);
+ }
+ 
+ /* Called from main context */
+--- a/src/pulsecore/sink-input.h       2016-04-13 11:44:28.035999390 +0200
++++ b/src/pulsecore/sink-input.h       2016-04-13 11:53:56.325998441 +0200
+@@ -126,6 +126,9 @@
+     /* for volume ramps */
+     pa_cvolume_ramp_int ramp;
+ 
++    bool corked;
++    bool corked_internal;
++
+     pa_resample_method_t requested_resample_method, actual_resample_method;
+ 
+     /* Returns the chunk of audio data and drops it from the
+@@ -357,6 +360,7 @@
+ void pa_sink_input_request_rewind(pa_sink_input *i, size_t nbytes, bool rewrite, bool flush, bool dont_rewind_render);
+ 
+ void pa_sink_input_cork(pa_sink_input *i, bool b);
++void pa_sink_input_cork_internal(pa_sink_input *i, bool b);
+ 
+ int pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate);
+ int pa_sink_input_update_rate(pa_sink_input *i);

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0020-core-util-Add-pa_join.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0020-core-util-Add-pa_join.patch
new file mode 100644 (file)
index 0000000..891a5b8
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0020-core-util-Add-pa_join.patch
@@ -0,0 +1,37 @@
+--- a/src/pulsecore/core-util.c        2016-04-13 16:17:33.314016929 +0200
++++ b/src/pulsecore/core-util.c        2016-04-13 16:18:31.186016833 +0200
+@@ -1104,6 +1104,24 @@
+     return pa_xstrndup(current, l);
+ }
+ 
++char *pa_join(const char * const *strings, unsigned n_strings, const char *delimiter) {
++    pa_strbuf *buf;
++    unsigned i;
++
++    pa_assert(strings || n_strings == 0);
++
++    buf = pa_strbuf_new();
++
++    for (i = 0; i < n_strings; i++) {
++        if (i > 0 && delimiter)
++            pa_strbuf_puts(buf, delimiter);
++
++        pa_strbuf_puts(buf, strings[i]);
++    }
++
++    return pa_strbuf_tostring_free(buf);
++}
++
+ PA_STATIC_TLS_DECLARE(signame, pa_xfree);
+ 
+ /* Return the name of an UNIX signal. Similar to Solaris sig2str() */
+--- a/src/pulsecore/core-util.h        2016-04-13 16:17:39.177016919 +0200
++++ b/src/pulsecore/core-util.h        2016-04-13 16:19:09.141016769 +0200
+@@ -108,6 +108,7 @@
+ char *pa_split(const char *c, const char*delimiters, const char **state);
+ const char *pa_split_in_place(const char *c, const char*delimiters, int *n, const char **state);
+ char *pa_split_spaces(const char *c, const char **state);
++char *pa_join(const char * const *strings, unsigned n_strings, const char *delimiter);
+ 
+ char *pa_strip_nl(char *s);
+ char *pa_strip(char *s);

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0021-dynarray-Add-pa_dynarray_get_raw_array.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0021-dynarray-Add-pa_dynarray_get_raw_array.patch
new file mode 100644 (file)
index 0000000..040913c
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0021-dynarray-Add-pa_dynarray_get_raw_array.patch
@@ -0,0 +1,21 @@
+--- a/src/pulsecore/dynarray.c 2016-04-13 16:25:38.628016119 +0200
++++ b/src/pulsecore/dynarray.c 2016-04-13 16:26:54.694015992 +0200
+@@ -91,3 +91,9 @@
+ 
+     return array->n_entries;
+ }
++
++void * const *pa_dynarray_get_raw_array(pa_dynarray *array) {
++    pa_assert(array);
++
++    return array->data;
++}
+--- a/src/pulsecore/dynarray.h 2016-04-13 16:25:43.225016112 +0200
++++ b/src/pulsecore/dynarray.h 2016-04-13 16:27:47.414015904 +0200
+@@ -52,5 +52,5 @@
+ void *pa_dynarray_steal_last(pa_dynarray *array);
+ 
+ unsigned pa_dynarray_size(pa_dynarray *array);
+-
++void * const *pa_dynarray_get_raw_array(pa_dynarray *array);
+ #endif

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0022-device-port-Add-pa_device_port.active.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0022-device-port-Add-pa_device_port.active.patch
new file mode 100644 (file)
index 0000000..4a8143f
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0022-device-port-Add-pa_device_port.active.patch
@@ -0,0 +1,198 @@
+--- a/src/pulsecore/core.h     2016-04-13 16:38:56.392014788 +0200
++++ b/src/pulsecore/core.h     2016-04-13 16:41:50.331014498 +0200
+@@ -125,6 +125,7 @@
+     PA_CORE_HOOK_CARD_PROFILE_ADDED,
+     PA_CORE_HOOK_CARD_PROFILE_AVAILABLE_CHANGED,
+     PA_CORE_HOOK_PORT_AVAILABLE_CHANGED,
++    PA_CORE_HOOK_PORT_ACTIVE_CHANGED,
+     PA_CORE_HOOK_PORT_LATENCY_OFFSET_CHANGED,
+     PA_CORE_HOOK_MAX
+ } pa_core_hook_t;
+--- a/src/pulsecore/device-port.c      2016-04-13 16:39:37.411014719 +0200
++++ b/src/pulsecore/device-port.c      2016-04-13 17:06:47.393011999 +0200
+@@ -175,6 +175,21 @@
+     pa_hook_fire(&core->hooks[PA_CORE_HOOK_PORT_LATENCY_OFFSET_CHANGED], p);
+ }
+ 
++void pa_device_port_active_changed(pa_device_port *port, bool new_active) {
++    bool old_active;
++
++    pa_assert(port);
++
++    old_active = port->active;
++
++    if (new_active == old_active)
++        return;
++
++    port->active = new_active;
++    pa_log_debug("Port %s %s.", port->name, new_active ? "activated" : "deactivated");
++    pa_hook_fire(&port->core->hooks[PA_CORE_HOOK_PORT_ACTIVE_CHANGED], port);
++}
++
+ pa_device_port *pa_device_port_find_best(pa_hashmap *ports)
+ {
+     void *state;
+--- a/src/pulsecore/device-port.h      2016-04-13 16:39:51.603014696 +0200
++++ b/src/pulsecore/device-port.h      2016-04-13 17:07:12.649011957 +0200
+@@ -46,6 +46,7 @@
+ 
+     unsigned priority;
+     pa_available_t available;         /* PA_AVAILABLE_UNKNOWN, PA_AVAILABLE_NO or PA_AVAILABLE_YES */
++    bool active;
+ 
+     pa_proplist *proplist;
+     pa_hashmap *profiles; /* Does not own the profiles */
+--- a/src/pulsecore/sink.c     2016-04-13 16:40:11.131014663 +0200
++++ b/src/pulsecore/sink.c     2016-04-13 17:14:30.963011225 +0200
+@@ -658,6 +658,9 @@
+     else
+         pa_assert_se(sink_set_state(s, PA_SINK_IDLE) == 0);
+ 
++    if (s->active_port)
++        pa_device_port_active_changed(s->active_port, true);
++
+     pa_source_put(s->monitor_source);
+ 
+     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_NEW, s->index);
+@@ -685,6 +688,9 @@
+     if (linked)
+         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_UNLINK], s);
+ 
++    if (s->active_port)
++        pa_device_port_active_changed(s->active_port, false);
++
+     if (s->state != PA_SINK_UNLINKED)
+         pa_namereg_unregister(s->core, s->name);
+     pa_idxset_remove_by_data(s->core->sinks, s, NULL);
+@@ -3297,6 +3303,7 @@
+ /* Called from main context */
+ int pa_sink_set_port(pa_sink *s, const char *name, bool save) {
+     pa_device_port *port;
++    pa_device_port *old_port;
+     int ret;
+ 
+     pa_sink_assert_ref(s);
+@@ -3313,11 +3320,15 @@
+     if (!(port = pa_hashmap_get(s->ports, name)))
+         return -PA_ERR_NOENTITY;
+ 
+-    if (s->active_port == port) {
++    old_port = s->active_port;
++
++    if (port == old_port) {
+         s->save_port = s->save_port || save;
+         return 0;
+     }
+ 
++    pa_device_port_active_changed(old_port, false);
++
+     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);
+@@ -3326,17 +3337,26 @@
+     else
+         ret = s->set_port(s, port);
+ 
+-    if (ret < 0)
+-        return -PA_ERR_NOENTITY;
++    if (ret < 0) {
++        pa_log("Failed to set the port of sink %s from %s to %s.", s->name, old_port->name, port->name);
++
++        /* We don't know the real state of the device, but let's assume that
++         * the old port is still active, because s->active_port is left to
++         * point to the old port anyway. */
++        pa_device_port_active_changed(old_port, true);
++
++        return ret;
++    }
+ 
+     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+ 
+-    pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name);
++    pa_log_info("Changed port of sink %u \"%s\" from %s to %s", s->index, s->name, old_port->name, port->name);
+ 
+     s->active_port = port;
+     s->save_port = save;
+ 
+     pa_sink_set_latency_offset(s, s->active_port->latency_offset);
++    pa_device_port_active_changed(port, true);
+ 
+     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], s);
+ 
+--- a/src/pulsecore/source.c   2016-04-13 16:40:25.290014640 +0200
++++ b/src/pulsecore/source.c   2016-04-13 17:21:26.051010533 +0200
+@@ -603,6 +603,9 @@
+     else
+         pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
+ 
++    if (s->active_port)
++        pa_device_port_active_changed(s->active_port, true);
++
+     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index);
+     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
+ }
+@@ -623,6 +626,9 @@
+     if (linked)
+         pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], s);
+ 
++    if (s->active_port)
++        pa_device_port_active_changed(s->active_port, false);
++
+     if (s->state != PA_SOURCE_UNLINKED)
+         pa_namereg_unregister(s->core, s->name);
+     pa_idxset_remove_by_data(s->core->sources, s, NULL);
+@@ -2576,6 +2582,7 @@
+ /* Called from main context */
+ int pa_source_set_port(pa_source *s, const char *name, bool save) {
+     pa_device_port *port;
++    pa_device_port *old_port;
+     int ret;
+ 
+     pa_source_assert_ref(s);
+@@ -2592,11 +2599,15 @@
+     if (!(port = pa_hashmap_get(s->ports, name)))
+         return -PA_ERR_NOENTITY;
+ 
+-    if (s->active_port == port) {
++    old_port = s->active_port;
++
++    if (port == old_port) {
+         s->save_port = s->save_port || save;
+         return 0;
+     }
+ 
++    pa_device_port_active_changed(old_port, false);
++
+     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);
+@@ -2605,16 +2616,26 @@
+     else
+         ret = s->set_port(s, port);
+ 
+-    if (ret < 0)
+-        return -PA_ERR_NOENTITY;
++    if (ret < 0) {
++        pa_log("Failed to set the port of sink %s from %s to %s.", s->name, old_port->name, port->name);
++
++        /* We don't know the real state of the device, but let's assume that
++         * the old port is still active, because s->active_port is left to
++         * point to the old port anyway. */
++        pa_device_port_active_changed(old_port, true);
++
++        return ret;
++    }
+ 
+     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+ 
+-    pa_log_info("Changed port of source %u \"%s\" to %s", s->index, s->name, port->name);
++    pa_log_info("Changed port of source %u \"%s\" from %s to %s", s->index, s->name, old_port->name, port->name);
+ 
+     s->active_port = port;
+     s->save_port = save;
+ 
++    pa_device_port_active_changed(port, true);
++
+     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], s);
+ 
+     return 0;

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0030-volume-api-Add-libvolume-api.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0030-volume-api-Add-libvolume-api.patch
new file mode 100644 (file)
index 0000000..b904ac3
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0030-volume-api-Add-libvolume-api.patch
@@ -0,0 +1,6118 @@
+From 0223ac3e092249c792bedcab2bf5dbaec443f960 Mon Sep 17 00:00:00 2001
+From: Tanu Kaskinen <tanu.kaskinen@linux.intel.com>
+Date: Wed, 21 May 2014 11:51:27 +0300
+Subject: [PATCH 1/1] volume-api: Add libvolume-api.so
+
+This library implements the "core" of the new volume system, which
+will be used by several modules.
+
+Change-Id: Ib25ada1392e83237a3908e6064ee0ad6dff7afaf
+Signed-off-by: Jaska Uimonen <jaska.uimonen@intel.com>
+---
+ Makefile.am                             |    3 +
+ src/Makefile.am                         |   19 +-
+ src/map-file                            |   15 +
+ src/modules/volume-api/audio-group.c    |  448 +++++++++++++
+ src/modules/volume-api/audio-group.h    |   85 +++
+ src/modules/volume-api/binding.c        |  386 +++++++++++
+ src/modules/volume-api/binding.h        |  128 ++++
+ src/modules/volume-api/bvolume.h        |   43 ++
+ src/modules/volume-api/device-creator.c | 1108 +++++++++++++++++++++++++++++++
+ src/modules/volume-api/device-creator.h |   32 +
+ src/modules/volume-api/device.c         |  293 ++++++++
+ src/modules/volume-api/device.h         |   76 +++
+ src/modules/volume-api/mute-control.c   |  306 +++++++++
+ src/modules/volume-api/mute-control.h   |  102 +++
+ src/modules/volume-api/sstream.c        |  366 ++++++++++
+ src/modules/volume-api/sstream.h        |  108 +++
+ src/modules/volume-api/stream-creator.c |  691 +++++++++++++++++++
+ src/modules/volume-api/stream-creator.h |   32 +
+ src/modules/volume-api/volume-api.c     |  647 ++++++++++++++++++
+ src/modules/volume-api/volume-api.h     |  163 +++++
+ src/modules/volume-api/volume-control.c |  363 ++++++++++
+ src/modules/volume-api/volume-control.h |  112 ++++
+ src/pulse/ext-volume-api.c              |  275 ++++++++
+ src/pulse/ext-volume-api.h              |   68 ++
+ 24 files changed, 5868 insertions(+), 1 deletion(-)
+ create mode 100644 src/modules/volume-api/audio-group.c
+ create mode 100644 src/modules/volume-api/audio-group.h
+ create mode 100644 src/modules/volume-api/binding.c
+ create mode 100644 src/modules/volume-api/binding.h
+ create mode 100644 src/modules/volume-api/bvolume.h
+ create mode 100644 src/modules/volume-api/device-creator.c
+ create mode 100644 src/modules/volume-api/device-creator.h
+ create mode 100644 src/modules/volume-api/device.c
+ create mode 100644 src/modules/volume-api/device.h
+ create mode 100644 src/modules/volume-api/mute-control.c
+ create mode 100644 src/modules/volume-api/mute-control.h
+ create mode 100644 src/modules/volume-api/sstream.c
+ create mode 100644 src/modules/volume-api/sstream.h
+ create mode 100644 src/modules/volume-api/stream-creator.c
+ create mode 100644 src/modules/volume-api/stream-creator.h
+ create mode 100644 src/modules/volume-api/volume-api.c
+ create mode 100644 src/modules/volume-api/volume-api.h
+ create mode 100644 src/modules/volume-api/volume-control.c
+ create mode 100644 src/modules/volume-api/volume-control.h
+ create mode 100644 src/pulse/ext-volume-api.c
+ create mode 100644 src/pulse/ext-volume-api.h
+
+diff --git a/Makefile.am b/Makefile.am
+index 9431d4a..cf4a648 100644
+--- a/Makefile.am
++++ b/Makefile.am
+@@ -57,6 +57,9 @@
+ moduledevinternal_DATA = src/pulse/internal.h src/pulse/client-conf.h src/pulse/fork-detect.h 
+ moduledevinternaldir = $(includedir)/pulsemodule/pulse
+ 
++moduledevvolumeapi_DATA = $(top_srcdir)/src/modules/volume-api/*.h
++moduledevvolumeapidir   = $(includedir)/pulsemodule/modules/volume-api
++
+ if HAVE_GLIB20
+ pkgconfig_DATA += \
+        libpulse-mainloop-glib.pc
+diff --git a/src/Makefile.am b/src/Makefile.am
+index 22b9b81..bc41dca 100644
+--- a/src/Makefile.am  2016-04-13 15:51:34.439019531 +0200
++++ b/src/Makefile.am  2016-04-13 15:53:03.721019382 +0200
+@@ -792,6 +792,7 @@
+               pulse/ext-device-manager.h \
+               pulse/ext-device-restore.h \
+               pulse/ext-stream-restore.h \
++              pulse/ext-volume-api.h \
+               pulse/format.h \
+               pulse/gccmacro.h \
+               pulse/introspect.h \
+@@ -838,6 +839,7 @@
+               pulse/ext-device-manager.c pulse/ext-device-manager.h \
+               pulse/ext-device-restore.c pulse/ext-device-restore.h \
+               pulse/ext-stream-restore.c pulse/ext-stream-restore.h \
++              pulse/ext-volume-api.c pulse/ext-volume-api.h \
+               pulse/format.c pulse/format.h \
+               pulse/gccmacro.h \
+               pulse/internal.h \
+@@ -1018,7 +1020,8 @@ modlibexec_LTLIBRARIES = \
+               libprotocol-cli.la \
+               libprotocol-simple.la \
+               libprotocol-http.la \
+-              libprotocol-native.la
++              libprotocol-native.la \
++              libvolume-api.la
+ 
+ if HAVE_WEBRTC
+ modlibexec_LTLIBRARIES += libwebrtc-util.la
+@@ -1065,6 +1068,20 @@ libprotocol_native_la_CFLAGS += $(DBUS_CFLAGS)
+ libprotocol_native_la_LIBADD += $(DBUS_LIBS)
+ endif
+ 
++libvolume_api_la_SOURCES = \
++              modules/volume-api/audio-group.c modules/volume-api/audio-group.h \
++              modules/volume-api/binding.c modules/volume-api/binding.h \
++              modules/volume-api/bvolume.h \
++              modules/volume-api/device.c modules/volume-api/device.h \
++              modules/volume-api/device-creator.c modules/volume-api/device-creator.h \
++              modules/volume-api/mute-control.c modules/volume-api/mute-control.h \
++              modules/volume-api/sstream.c modules/volume-api/sstream.h \
++              modules/volume-api/stream-creator.c modules/volume-api/stream-creator.h \
++              modules/volume-api/volume-api.c modules/volume-api/volume-api.h \
++              modules/volume-api/volume-control.c modules/volume-api/volume-control.h
++libvolume_api_la_LDFLAGS = $(AM_LDFLAGS) -avoid-version
++libvolume_api_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
++
+ if HAVE_ESOUND
+ libprotocol_esound_la_SOURCES = pulsecore/protocol-esound.c pulsecore/protocol-esound.h pulsecore/esound.h
+ libprotocol_esound_la_LDFLAGS = $(AM_LDFLAGS) -avoid-version
+diff --git a/src/map-file b/src/map-file
+index fbf3f22..1f64a2f 100644
+--- a/src/map-file
++++ b/src/map-file
+@@ -172,6 +172,21 @@
+ pa_ext_stream_restore_subscribe;
+ pa_ext_stream_restore_test;
+ pa_ext_stream_restore_write;
++pa_ext_volume_api_balance_valid;
++pa_ext_volume_api_bvolume_copy_balance;
++pa_ext_volume_api_bvolume_get_left_right_balance;
++pa_ext_volume_api_bvolume_get_rear_front_balance;
++pa_ext_volume_api_bvolume_equal;
++pa_ext_volume_api_bvolume_from_cvolume;
++pa_ext_volume_api_bvolume_init_invalid;
++pa_ext_volume_api_bvolume_init_mono;
++pa_ext_volume_api_bvolume_remap;
++pa_ext_volume_api_bvolume_reset_balance;
++pa_ext_volume_api_bvolume_set_left_right_balance;
++pa_ext_volume_api_bvolume_set_rear_front_balance;
++pa_ext_volume_api_bvolume_snprint_balance;
++pa_ext_volume_api_bvolume_to_cvolume;
++pa_ext_volume_api_bvolume_valid;
+ pa_format_info_copy;
+ pa_format_info_free;
+ pa_format_info_from_string;
+diff --git a/src/modules/volume-api/audio-group.c b/src/modules/volume-api/audio-group.c
+new file mode 100644
+index 0000000..76bfa69
+--- /dev/null
++++ b/src/modules/volume-api/audio-group.c
+@@ -0,0 +1,448 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "audio-group.h"
++
++#include <modules/volume-api/sstream.h>
++
++#include <pulsecore/core-util.h>
++
++int pa_audio_group_new(pa_volume_api *api, const char *name, const char *description, pa_audio_group **group) {
++    pa_audio_group *group_local;
++    int r;
++
++    pa_assert(api);
++    pa_assert(name);
++    pa_assert(description);
++    pa_assert(group);
++
++    group_local = pa_xnew0(pa_audio_group, 1);
++    group_local->volume_api = api;
++    group_local->index = pa_volume_api_allocate_audio_group_index(api);
++
++    r = pa_volume_api_register_name(api, name, true, &group_local->name);
++    if (r < 0)
++        goto fail;
++
++    group_local->description = pa_xstrdup(description);
++    group_local->proplist = pa_proplist_new();
++    group_local->volume_streams = pa_hashmap_new(NULL, NULL);
++    group_local->mute_streams = pa_hashmap_new(NULL, NULL);
++
++    *group = group_local;
++
++    return 0;
++
++fail:
++    pa_audio_group_free(group_local);
++
++    return r;
++}
++
++void pa_audio_group_put(pa_audio_group *group) {
++    const char *prop_key;
++    void *state = NULL;
++
++    pa_assert(group);
++
++    pa_volume_api_add_audio_group(group->volume_api, group);
++
++    group->linked = true;
++
++    pa_log_debug("Created audio group #%u.", group->index);
++    pa_log_debug("    Name: %s", group->name);
++    pa_log_debug("    Description: %s", group->description);
++    pa_log_debug("    Volume control: %s", group->volume_control ? group->volume_control->name : "(unset)");
++    pa_log_debug("    Mute control: %s", group->mute_control ? group->mute_control->name : "(unset)");
++    pa_log_debug("    Properties:");
++
++    while ((prop_key = pa_proplist_iterate(group->proplist, &state)))
++        pa_log_debug("        %s = %s", prop_key, pa_strnull(pa_proplist_gets(group->proplist, prop_key)));
++
++    pa_hook_fire(&group->volume_api->hooks[PA_VOLUME_API_HOOK_AUDIO_GROUP_PUT], group);
++}
++
++void pa_audio_group_unlink(pa_audio_group *group) {
++    pas_stream *stream;
++
++    pa_assert(group);
++
++    if (group->unlinked) {
++        pa_log_debug("Unlinking audio group %s (already unlinked, this is a no-op).", group->name);
++        return;
++    }
++
++    group->unlinked = true;
++
++    pa_log_debug("Unlinking audio group %s.", group->name);
++
++    if (group->linked)
++        pa_hook_fire(&group->volume_api->hooks[PA_VOLUME_API_HOOK_AUDIO_GROUP_UNLINK], group);
++
++    pa_volume_api_remove_audio_group(group->volume_api, group);
++
++    while ((stream = pa_hashmap_first(group->mute_streams)))
++        pas_stream_set_audio_group_for_mute(stream, NULL);
++
++    while ((stream = pa_hashmap_first(group->volume_streams)))
++        pas_stream_set_audio_group_for_volume(stream, NULL);
++
++    if (group->mute_control_binding) {
++        pa_binding_free(group->mute_control_binding);
++        group->mute_control_binding = NULL;
++    }
++
++    if (group->volume_control_binding) {
++        pa_binding_free(group->volume_control_binding);
++        group->volume_control_binding = NULL;
++    }
++
++    pa_audio_group_set_have_own_mute_control(group, false);
++    pa_audio_group_set_have_own_volume_control(group, false);
++
++    if (group->mute_control) {
++        pa_mute_control_remove_audio_group(group->mute_control, group);
++        group->mute_control = NULL;
++    }
++
++    if (group->volume_control) {
++        pa_volume_control_remove_audio_group(group->volume_control, group);
++        group->volume_control = NULL;
++    }
++}
++
++void pa_audio_group_free(pa_audio_group *group) {
++    pa_assert(group);
++
++    if (!group->unlinked)
++        pa_audio_group_unlink(group);
++
++    if (group->mute_streams)
++        pa_hashmap_free(group->mute_streams);
++
++    if (group->volume_streams)
++        pa_hashmap_free(group->volume_streams);
++
++    if (group->proplist)
++        pa_proplist_free(group->proplist);
++
++    pa_xfree(group->description);
++
++    if (group->name)
++        pa_volume_api_unregister_name(group->volume_api, group->name);
++
++    pa_xfree(group);
++}
++
++const char *pa_audio_group_get_name(pa_audio_group *group) {
++    pa_assert(group);
++
++    return group->name;
++}
++
++static int volume_control_set_volume_cb(pa_volume_control *control, const pa_bvolume *volume, bool set_volume,
++                                        bool set_balance) {
++    pa_audio_group *group;
++    pas_stream *stream;
++    void *state;
++
++    pa_assert(control);
++    pa_assert(volume);
++
++    group = control->userdata;
++
++    PA_HASHMAP_FOREACH(stream, group->volume_streams, state) {
++        if (stream->own_volume_control)
++            pa_volume_control_set_volume(stream->own_volume_control, volume, set_volume, set_balance);
++    }
++
++    return 0;
++}
++
++static void volume_control_set_initial_volume_cb(pa_volume_control *control) {
++    pa_audio_group *group;
++    pas_stream *stream;
++    void *state;
++
++    pa_assert(control);
++
++    group = control->userdata;
++
++    PA_HASHMAP_FOREACH(stream, group->volume_streams, state) {
++        if (stream->own_volume_control)
++            pa_volume_control_set_volume(stream->own_volume_control, &control->volume, true, true);
++    }
++}
++
++void pa_audio_group_set_have_own_volume_control(pa_audio_group *group, bool have) {
++    pa_assert(group);
++
++    if (have == group->have_own_volume_control)
++        return;
++
++    if (have) {
++        pa_bvolume initial_volume;
++
++        if (group->volume_api->core->flat_volumes)
++            /* Usually the initial volume should get overridden by some module
++             * that manages audio group volume levels, but if there's no such
++             * module, let's try to avoid too high volume in flat volume
++             * mode. */
++            pa_bvolume_init_mono(&initial_volume, 0.3 * PA_VOLUME_NORM);
++        else
++            pa_bvolume_init_mono(&initial_volume, PA_VOLUME_NORM);
++
++        pa_assert(!group->own_volume_control);
++        group->own_volume_control = pa_volume_control_new(group->volume_api, "audio-group-volume-control",
++                                                          group->description, false, false);
++        pa_volume_control_set_owner_audio_group(group->own_volume_control, group);
++        group->own_volume_control->set_volume = volume_control_set_volume_cb;
++        group->own_volume_control->userdata = group;
++        pa_volume_control_put(group->own_volume_control, &initial_volume, volume_control_set_initial_volume_cb);
++    } else {
++        pa_volume_control_free(group->own_volume_control);
++        group->own_volume_control = NULL;
++    }
++
++    group->have_own_volume_control = have;
++}
++
++static int mute_control_set_mute_cb(pa_mute_control *control, bool mute) {
++    pa_audio_group *group;
++    pas_stream *stream;
++    void *state;
++
++    pa_assert(control);
++
++    group = control->userdata;
++
++    PA_HASHMAP_FOREACH(stream, group->mute_streams, state) {
++        if (stream->own_mute_control)
++            pa_mute_control_set_mute(stream->own_mute_control, mute);
++    }
++
++    return 0;
++}
++
++static void mute_control_set_initial_mute_cb(pa_mute_control *control) {
++    pa_audio_group *group;
++    pas_stream *stream;
++    void *state;
++
++    pa_assert(control);
++
++    group = control->userdata;
++
++    PA_HASHMAP_FOREACH(stream, group->mute_streams, state) {
++        if (stream->own_mute_control)
++            pa_mute_control_set_mute(stream->own_mute_control, control->mute);
++    }
++}
++
++void pa_audio_group_set_have_own_mute_control(pa_audio_group *group, bool have) {
++    pa_assert(group);
++
++    if (have == group->have_own_mute_control)
++        return;
++
++    group->have_own_mute_control = have;
++
++    if (have) {
++        pa_assert(!group->own_mute_control);
++        group->own_mute_control = pa_mute_control_new(group->volume_api, "audio-group-mute-control", group->description);
++        pa_mute_control_set_owner_audio_group(group->own_mute_control, group);
++        group->own_mute_control->set_mute = mute_control_set_mute_cb;
++        group->own_mute_control->userdata = group;
++        pa_mute_control_put(group->own_mute_control, false, true, mute_control_set_initial_mute_cb);
++    } else {
++        pa_mute_control_free(group->own_mute_control);
++        group->own_mute_control = NULL;
++    }
++}
++
++static void set_volume_control_internal(pa_audio_group *group, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(group);
++
++    old_control = group->volume_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control)
++        pa_volume_control_remove_audio_group(old_control, group);
++
++    group->volume_control = control;
++
++    if (control)
++        pa_volume_control_add_audio_group(control, group);
++
++    if (!group->linked || group->unlinked)
++        return;
++
++    pa_log_debug("The volume control of audio group %s changed from %s to %s.", group->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&group->volume_api->hooks[PA_VOLUME_API_HOOK_AUDIO_GROUP_VOLUME_CONTROL_CHANGED], group);
++}
++
++void pa_audio_group_set_volume_control(pa_audio_group *group, pa_volume_control *control) {
++    pa_assert(group);
++
++    if (group->volume_control_binding) {
++        pa_binding_free(group->volume_control_binding);
++        group->volume_control_binding = NULL;
++    }
++
++    set_volume_control_internal(group, control);
++}
++
++static void set_mute_control_internal(pa_audio_group *group, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(group);
++
++    old_control = group->mute_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control)
++        pa_mute_control_remove_audio_group(old_control, group);
++
++    group->mute_control = control;
++
++    if (control)
++        pa_mute_control_add_audio_group(control, group);
++
++    if (!group->linked || group->unlinked)
++        return;
++
++    pa_log_debug("The mute control of audio group %s changed from %s to %s.", group->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&group->volume_api->hooks[PA_VOLUME_API_HOOK_AUDIO_GROUP_MUTE_CONTROL_CHANGED], group);
++}
++
++void pa_audio_group_set_mute_control(pa_audio_group *group, pa_mute_control *control) {
++    pa_assert(group);
++
++    if (group->mute_control_binding) {
++        pa_binding_free(group->mute_control_binding);
++        group->mute_control_binding = NULL;
++    }
++
++    set_mute_control_internal(group, control);
++}
++
++void pa_audio_group_bind_volume_control(pa_audio_group *group, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = group,
++        .set_value = (pa_binding_set_value_cb_t) set_volume_control_internal,
++    };
++
++    pa_assert(group);
++    pa_assert(target_info);
++
++    if (group->volume_control_binding)
++        pa_binding_free(group->volume_control_binding);
++
++    group->volume_control_binding = pa_binding_new(group->volume_api, &owner_info, target_info);
++}
++
++void pa_audio_group_bind_mute_control(pa_audio_group *group, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = group,
++        .set_value = (pa_binding_set_value_cb_t) set_mute_control_internal,
++    };
++
++    pa_assert(group);
++    pa_assert(target_info);
++
++    if (group->mute_control_binding)
++        pa_binding_free(group->mute_control_binding);
++
++    group->mute_control_binding = pa_binding_new(group->volume_api, &owner_info, target_info);
++}
++
++void pa_audio_group_add_volume_stream(pa_audio_group *group, pas_stream *stream) {
++    pa_assert(group);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_put(group->volume_streams, stream, stream) >= 0);
++
++    if (stream->own_volume_control && group->own_volume_control)
++        pa_volume_control_set_volume(stream->own_volume_control, &group->own_volume_control->volume, true, true);
++
++    pa_log_debug("Stream %s added to audio group %s (volume).", stream->name, group->name);
++}
++
++void pa_audio_group_remove_volume_stream(pa_audio_group *group, pas_stream *stream) {
++    pa_assert(group);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_remove(group->volume_streams, stream));
++
++    pa_log_debug("Stream %s removed from audio group %s (volume).", stream->name, group->name);
++}
++
++void pa_audio_group_add_mute_stream(pa_audio_group *group, pas_stream *stream) {
++    pa_assert(group);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_put(group->mute_streams, stream, stream) >= 0);
++
++    if (stream->own_mute_control && group->own_mute_control)
++        pa_mute_control_set_mute(stream->own_mute_control, group->own_mute_control->mute);
++
++    pa_log_debug("Stream %s added to audio group %s (mute).", stream->name, group->name);
++}
++
++void pa_audio_group_remove_mute_stream(pa_audio_group *group, pas_stream *stream) {
++    pa_assert(group);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_remove(group->mute_streams, stream));
++
++    pa_log_debug("Stream %s removed from audio group %s (mute).", stream->name, group->name);
++}
++
++pa_binding_target_type *pa_audio_group_create_binding_target_type(pa_volume_api *api) {
++    pa_binding_target_type *type;
++
++    pa_assert(api);
++
++    type = pa_binding_target_type_new(PA_AUDIO_GROUP_BINDING_TARGET_TYPE, api->audio_groups,
++                                      &api->hooks[PA_VOLUME_API_HOOK_AUDIO_GROUP_PUT],
++                                      &api->hooks[PA_VOLUME_API_HOOK_AUDIO_GROUP_UNLINK],
++                                      (pa_binding_target_type_get_name_cb_t) pa_audio_group_get_name);
++    pa_binding_target_type_add_field(type, PA_AUDIO_GROUP_BINDING_TARGET_FIELD_VOLUME_CONTROL,
++                                     PA_BINDING_CALCULATE_FIELD_OFFSET(pa_audio_group, volume_control));
++    pa_binding_target_type_add_field(type, PA_AUDIO_GROUP_BINDING_TARGET_FIELD_MUTE_CONTROL,
++                                     PA_BINDING_CALCULATE_FIELD_OFFSET(pa_audio_group, mute_control));
++
++    return type;
++}
+diff --git a/src/modules/volume-api/audio-group.h b/src/modules/volume-api/audio-group.h
+new file mode 100644
+index 0000000..41591ba
+--- /dev/null
++++ b/src/modules/volume-api/audio-group.h
+@@ -0,0 +1,85 @@
++#ifndef fooaudiogrouphfoo
++#define fooaudiogrouphfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/binding.h>
++#include <modules/volume-api/mute-control.h>
++#include <modules/volume-api/volume-control.h>
++
++#include <pulse/proplist.h>
++
++#include <inttypes.h>
++
++typedef struct pa_audio_group pa_audio_group;
++
++#define PA_AUDIO_GROUP_BINDING_TARGET_TYPE "AudioGroup"
++#define PA_AUDIO_GROUP_BINDING_TARGET_FIELD_VOLUME_CONTROL "volume_control"
++#define PA_AUDIO_GROUP_BINDING_TARGET_FIELD_MUTE_CONTROL "mute_control"
++
++struct pa_audio_group {
++    pa_volume_api *volume_api;
++    uint32_t index;
++    const char *name;
++    char *description;
++    pa_proplist *proplist;
++    pa_volume_control *volume_control;
++    pa_mute_control *mute_control;
++    bool have_own_volume_control;
++    bool have_own_mute_control;
++    pa_volume_control *own_volume_control;
++    pa_mute_control *own_mute_control;
++
++    pa_binding *volume_control_binding;
++    pa_binding *mute_control_binding;
++    pa_hashmap *volume_streams; /* pas_stream -> pas_stream (hashmap-as-a-set) */
++    pa_hashmap *mute_streams; /* pas_stream -> pas_stream (hashmap-as-a-set) */
++
++    bool linked;
++    bool unlinked;
++};
++
++int pa_audio_group_new(pa_volume_api *api, const char *name, const char *description, pa_audio_group **group);
++void pa_audio_group_put(pa_audio_group *group);
++void pa_audio_group_unlink(pa_audio_group *group);
++void pa_audio_group_free(pa_audio_group *group);
++
++const char *pa_audio_group_get_name(pa_audio_group *group);
++
++/* Called by policy modules. */
++void pa_audio_group_set_have_own_volume_control(pa_audio_group *group, bool have);
++void pa_audio_group_set_have_own_mute_control(pa_audio_group *group, bool have);
++void pa_audio_group_set_volume_control(pa_audio_group *group, pa_volume_control *control);
++void pa_audio_group_set_mute_control(pa_audio_group *group, pa_mute_control *control);
++void pa_audio_group_bind_volume_control(pa_audio_group *group, pa_binding_target_info *target_info);
++void pa_audio_group_bind_mute_control(pa_audio_group *group, pa_binding_target_info *target_info);
++
++/* Called from sstream.c only. */
++void pa_audio_group_add_volume_stream(pa_audio_group *group, pas_stream *stream);
++void pa_audio_group_remove_volume_stream(pa_audio_group *group, pas_stream *stream);
++void pa_audio_group_add_mute_stream(pa_audio_group *group, pas_stream *stream);
++void pa_audio_group_remove_mute_stream(pa_audio_group *group, pas_stream *stream);
++
++/* Called from volume-api.c only. */
++pa_binding_target_type *pa_audio_group_create_binding_target_type(pa_volume_api *api);
++
++#endif
+diff --git a/src/modules/volume-api/binding.c b/src/modules/volume-api/binding.c
+new file mode 100644
+index 0000000..6e73119
+--- /dev/null
++++ b/src/modules/volume-api/binding.c
+@@ -0,0 +1,386 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "binding.h"
++
++#include <pulse/def.h>
++#include <pulse/xmalloc.h>
++
++#include <pulsecore/core-util.h>
++#include <pulsecore/macro.h>
++
++struct field_entry {
++    char *name;
++    size_t offset;
++};
++
++static void set_target_type(pa_binding *binding, pa_binding_target_type *type);
++static void set_target_object(pa_binding *binding, void *object);
++
++pa_binding_owner_info *pa_binding_owner_info_new(pa_binding_set_value_cb_t set_value, void *userdata) {
++    pa_binding_owner_info *info;
++
++    pa_assert(set_value);
++
++    info = pa_xnew0(pa_binding_owner_info, 1);
++    info->set_value = set_value;
++    info->userdata = userdata;
++
++    return info;
++}
++
++pa_binding_owner_info *pa_binding_owner_info_copy(const pa_binding_owner_info *info) {
++    pa_assert(info);
++
++    return pa_binding_owner_info_new(info->set_value, info->userdata);
++}
++
++void pa_binding_owner_info_free(pa_binding_owner_info *info) {
++    pa_assert(info);
++
++    pa_xfree(info);
++}
++
++pa_binding_target_info *pa_binding_target_info_new(const char *type, const char *name, const char *field) {
++    pa_binding_target_info *info;
++
++    pa_assert(type);
++    pa_assert(name);
++    pa_assert(field);
++
++    info = pa_xnew0(pa_binding_target_info, 1);
++    info->type = pa_xstrdup(type);
++    info->name = pa_xstrdup(name);
++    info->field = pa_xstrdup(field);
++
++    return info;
++}
++
++int pa_binding_target_info_new_from_string(const char *str, const char *field, pa_binding_target_info **info) {
++    const char *colon;
++    char *type = NULL;
++    char *name = NULL;
++
++    pa_assert(str);
++    pa_assert(field);
++    pa_assert(info);
++
++    if (!pa_startswith(str, "bind:"))
++        goto fail;
++
++    colon = strchr(str + 5, ':');
++    if (!colon)
++        goto fail;
++
++    type = pa_xstrndup(str + 5, colon - (str + 5));
++
++    if (!*type)
++        goto fail;
++
++    name = pa_xstrdup(colon + 1);
++
++    if (!*name)
++        goto fail;
++
++    *info = pa_binding_target_info_new(type, name, field);
++    pa_xfree(name);
++    pa_xfree(type);
++
++    return 0;
++
++fail:
++    pa_log("Invalid binding target: %s", str);
++    pa_xfree(name);
++    pa_xfree(type);
++
++    return -PA_ERR_INVALID;
++}
++
++pa_binding_target_info *pa_binding_target_info_copy(const pa_binding_target_info *info) {
++    pa_assert(info);
++
++    return pa_binding_target_info_new(info->type, info->name, info->field);
++}
++
++void pa_binding_target_info_free(pa_binding_target_info *info) {
++    pa_assert(info);
++
++    pa_xfree(info->field);
++    pa_xfree(info->name);
++    pa_xfree(info->type);
++    pa_xfree(info);
++}
++
++static void field_entry_free(struct field_entry *entry) {
++    pa_assert(entry);
++
++    pa_xfree(entry->name);
++    pa_xfree(entry);
++}
++
++pa_binding_target_type *pa_binding_target_type_new(const char *name, pa_hashmap *objects, pa_hook *put_hook,
++                                                   pa_hook *unlink_hook, pa_binding_target_type_get_name_cb_t get_name) {
++    pa_binding_target_type *type;
++
++    pa_assert(name);
++    pa_assert(objects);
++    pa_assert(put_hook);
++    pa_assert(unlink_hook);
++    pa_assert(get_name);
++
++    type = pa_xnew0(pa_binding_target_type, 1);
++    type->name = pa_xstrdup(name);
++    type->objects = objects;
++    type->put_hook = put_hook;
++    type->unlink_hook = unlink_hook;
++    type->get_name = get_name;
++    type->fields = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) field_entry_free);
++
++    return type;
++}
++
++void pa_binding_target_type_free(pa_binding_target_type *type) {
++    pa_assert(type);
++
++    if (type->fields)
++        pa_hashmap_free(type->fields);
++
++    pa_xfree(type->name);
++    pa_xfree(type);
++}
++
++void pa_binding_target_type_add_field(pa_binding_target_type *type, const char *name, size_t offset) {
++    struct field_entry *entry;
++
++    pa_assert(type);
++    pa_assert(name);
++
++    entry = pa_xnew0(struct field_entry, 1);
++    entry->name = pa_xstrdup(name);
++    entry->offset = offset;
++
++    pa_assert_se(pa_hashmap_put(type->fields, entry->name, entry) >= 0);
++}
++
++int pa_binding_target_type_get_field_offset(pa_binding_target_type *type, const char *field, size_t *offset) {
++    struct field_entry *entry;
++
++    pa_assert(type);
++    pa_assert(field);
++    pa_assert(offset);
++
++    entry = pa_hashmap_get(type->fields, field);
++    if (!entry)
++        return -PA_ERR_NOENTITY;
++
++    *offset = entry->offset;
++
++    return 0;
++}
++
++static pa_hook_result_t target_type_added_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_binding_target_type *type = call_data;
++    pa_binding *binding = userdata;
++
++    pa_assert(type);
++    pa_assert(binding);
++
++    if (!pa_streq(type->name, binding->target_info->type))
++        return PA_HOOK_OK;
++
++    set_target_type(binding, type);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t target_type_removed_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_binding_target_type *type = call_data;
++    pa_binding *binding = userdata;
++
++    pa_assert(type);
++    pa_assert(binding);
++
++    if (type != binding->target_type)
++        return PA_HOOK_OK;
++
++    set_target_type(binding, NULL);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t target_put_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_binding *binding = userdata;
++
++    pa_assert(call_data);
++    pa_assert(binding);
++
++    if (!pa_streq(binding->target_type->get_name(call_data), binding->target_info->name))
++        return PA_HOOK_OK;
++
++    set_target_object(binding, call_data);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t target_unlink_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_binding *binding = userdata;
++
++    pa_assert(call_data);
++    pa_assert(binding);
++
++    if (call_data != binding->target_object)
++        return PA_HOOK_OK;
++
++    set_target_object(binding, NULL);
++
++    return PA_HOOK_OK;
++}
++
++static void set_target_object(pa_binding *binding, void *object) {
++    pa_assert(binding);
++
++    binding->target_object = object;
++
++    if (object) {
++        if (binding->target_put_slot) {
++            pa_hook_slot_free(binding->target_put_slot);
++            binding->target_put_slot = NULL;
++        }
++
++        if (!binding->target_unlink_slot)
++            binding->target_unlink_slot = pa_hook_connect(binding->target_type->unlink_hook, PA_HOOK_NORMAL, target_unlink_cb,
++                                                          binding);
++
++        if (binding->target_field_offset_valid)
++            binding->owner_info->set_value(binding->owner_info->userdata,
++                                           *((void **) (((uint8_t *) object) + binding->target_field_offset)));
++        else
++            binding->owner_info->set_value(binding->owner_info->userdata, NULL);
++    } else {
++        if (binding->target_unlink_slot) {
++            pa_hook_slot_free(binding->target_unlink_slot);
++            binding->target_unlink_slot = NULL;
++        }
++
++        if (binding->target_type) {
++            if (!binding->target_put_slot)
++                binding->target_put_slot = pa_hook_connect(binding->target_type->put_hook, PA_HOOK_NORMAL, target_put_cb, binding);
++        } else {
++            if (binding->target_put_slot) {
++                pa_hook_slot_free(binding->target_put_slot);
++                binding->target_put_slot = NULL;
++            }
++        }
++
++        binding->owner_info->set_value(binding->owner_info->userdata, NULL);
++    }
++}
++
++static void set_target_type(pa_binding *binding, pa_binding_target_type *type) {
++    pa_assert(binding);
++
++    binding->target_type = type;
++
++    if (type) {
++        int r;
++
++        if (binding->target_type_added_slot) {
++            pa_hook_slot_free(binding->target_type_added_slot);
++            binding->target_type_added_slot = NULL;
++        }
++
++        if (!binding->target_type_removed_slot)
++            binding->target_type_removed_slot =
++                    pa_hook_connect(&binding->volume_api->hooks[PA_VOLUME_API_HOOK_BINDING_TARGET_TYPE_REMOVED],
++                                    PA_HOOK_NORMAL, target_type_removed_cb, binding);
++
++        r = pa_binding_target_type_get_field_offset(type, binding->target_info->field, &binding->target_field_offset);
++        if (r >= 0)
++            binding->target_field_offset_valid = true;
++        else {
++            pa_log_warn("Reference to non-existing field \"%s\" in binding target type \"%s\".", binding->target_info->field,
++                        type->name);
++            binding->target_field_offset_valid = false;
++        }
++
++        set_target_object(binding, pa_hashmap_get(type->objects, binding->target_info->name));
++    } else {
++        if (binding->target_type_removed_slot) {
++            pa_hook_slot_free(binding->target_type_removed_slot);
++            binding->target_type_removed_slot = NULL;
++        }
++
++        if (!binding->target_type_added_slot)
++            binding->target_type_added_slot =
++                    pa_hook_connect(&binding->volume_api->hooks[PA_VOLUME_API_HOOK_BINDING_TARGET_TYPE_ADDED],
++                                    PA_HOOK_NORMAL, target_type_added_cb, binding);
++
++        binding->target_field_offset_valid = false;
++
++        set_target_object(binding, NULL);
++    }
++}
++
++pa_binding *pa_binding_new(pa_volume_api *api, const pa_binding_owner_info *owner_info,
++                           const pa_binding_target_info *target_info) {
++    pa_binding *binding;
++
++    pa_assert(api);
++    pa_assert(owner_info);
++    pa_assert(target_info);
++
++    binding = pa_xnew0(pa_binding, 1);
++    binding->volume_api = api;
++    binding->owner_info = pa_binding_owner_info_copy(owner_info);
++    binding->target_info = pa_binding_target_info_copy(target_info);
++
++    set_target_type(binding, pa_hashmap_get(api->binding_target_types, target_info->type));
++
++    return binding;
++}
++
++void pa_binding_free(pa_binding *binding) {
++    pa_assert(binding);
++
++    if (binding->target_unlink_slot)
++        pa_hook_slot_free(binding->target_unlink_slot);
++
++    if (binding->target_put_slot)
++        pa_hook_slot_free(binding->target_put_slot);
++
++    if (binding->target_type_removed_slot)
++        pa_hook_slot_free(binding->target_type_removed_slot);
++
++    if (binding->target_type_added_slot)
++        pa_hook_slot_free(binding->target_type_added_slot);
++
++    if (binding->target_info)
++        pa_binding_target_info_free(binding->target_info);
++
++    if (binding->owner_info)
++        pa_binding_owner_info_free(binding->owner_info);
++
++    pa_xfree(binding);
++}
+diff --git a/src/modules/volume-api/binding.h b/src/modules/volume-api/binding.h
+new file mode 100644
+index 0000000..ba4dea8
+--- /dev/null
++++ b/src/modules/volume-api/binding.h
+@@ -0,0 +1,128 @@
++#ifndef foobindinghfoo
++#define foobindinghfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/volume-api.h>
++
++typedef struct pa_binding pa_binding;
++typedef struct pa_binding_owner_info pa_binding_owner_info;
++typedef struct pa_binding_target_info pa_binding_target_info;
++typedef struct pa_binding_target_type pa_binding_target_type;
++
++typedef void (*pa_binding_set_value_cb_t)(void *userdata, void *value);
++
++struct pa_binding_owner_info {
++    /* This is the object that has the variable that the binding is created
++     * for. */
++    void *userdata;
++
++    /* Called when the owner object's value needs to be updated. The userdata
++     * parameter of the callback is the same as the userdata field in this
++     * struct, and the value parameter is the new value for whatever variable
++     * the binding was created for. */
++    pa_binding_set_value_cb_t set_value;
++};
++
++pa_binding_owner_info *pa_binding_owner_info_new(pa_binding_set_value_cb_t set_value, void *userdata);
++pa_binding_owner_info *pa_binding_owner_info_copy(const pa_binding_owner_info *info);
++void pa_binding_owner_info_free(pa_binding_owner_info *info);
++
++struct pa_binding_target_info {
++    /* The target type name as registered with
++     * pa_binding_target_type_register(). */
++    char *type;
++
++    /* The target object name as returned by the get_name callback of
++     * pa_binding_target_type. */
++    char *name;
++
++    /* The target field of the target object. */
++    char *field;
++};
++
++pa_binding_target_info *pa_binding_target_info_new(const char *type, const char *name, const char *field);
++
++/* The string format is "bind:TYPE:NAME". */
++int pa_binding_target_info_new_from_string(const char *str, const char *field, pa_binding_target_info **info);
++
++pa_binding_target_info *pa_binding_target_info_copy(const pa_binding_target_info *info);
++void pa_binding_target_info_free(pa_binding_target_info *info);
++
++typedef const char *(*pa_binding_target_type_get_name_cb_t)(void *object);
++
++struct pa_binding_target_type {
++    /* Identifier for this target type. */
++    char *name;
++
++    /* name -> object. Points directly to some "master" object hashmap, so the
++     * hashmap is not owned by pa_binding_target_type. */
++    pa_hashmap *objects;
++
++    /* The hook that notifies of new objects if this target type. The call data
++     * of the hook must be a pointer to the new object (this should be true for
++     * all PUT hooks, so don't worry too much). */
++    pa_hook *put_hook;
++
++    /* The hook that notifies of unlinked objects of this target type. The call
++     * data of the hook must be a pointer to the removed object (this should be
++     * true for all UNLINK hooks, so don't worry too much). */
++    pa_hook *unlink_hook;
++
++    /* Function for getting the name of an object of this target type. */
++    pa_binding_target_type_get_name_cb_t get_name;
++
++    pa_hashmap *fields;
++};
++
++pa_binding_target_type *pa_binding_target_type_new(const char *name, pa_hashmap *objects, pa_hook *put_hook,
++                                                   pa_hook *unlink_hook, pa_binding_target_type_get_name_cb_t get_name);
++void pa_binding_target_type_free(pa_binding_target_type *type);
++
++/* Useful when calling pa_binding_target_type_add_field(). */
++#define PA_BINDING_CALCULATE_FIELD_OFFSET(type, field) ((size_t) &(((type *) 0)->field))
++
++/* Called during the type initialization (right after
++ * pa_binding_target_type_new()). */
++void pa_binding_target_type_add_field(pa_binding_target_type *type, const char *name, size_t offset);
++
++int pa_binding_target_type_get_field_offset(pa_binding_target_type *type, const char *field, size_t *offset);
++
++struct pa_binding {
++    pa_volume_api *volume_api;
++    pa_binding_owner_info *owner_info;
++    pa_binding_target_info *target_info;
++    pa_binding_target_type *target_type;
++    void *target_object;
++    size_t target_field_offset;
++    bool target_field_offset_valid;
++    pa_hook_slot *target_type_added_slot;
++    pa_hook_slot *target_type_removed_slot;
++    pa_hook_slot *target_put_slot;
++    pa_hook_slot *target_unlink_slot;
++};
++
++pa_binding *pa_binding_new(pa_volume_api *api, const pa_binding_owner_info *owner_info,
++                           const pa_binding_target_info *target_info);
++void pa_binding_free(pa_binding *binding);
++
++#endif
+diff --git a/src/modules/volume-api/bvolume.h b/src/modules/volume-api/bvolume.h
+new file mode 100644
+index 0000000..0317fb6
+--- /dev/null
++++ b/src/modules/volume-api/bvolume.h
+@@ -0,0 +1,43 @@
++#ifndef foobvolumehfoo
++#define foobvolumehfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <pulse/ext-volume-api.h>
++
++typedef pa_ext_volume_api_bvolume pa_bvolume;
++
++#define pa_balance_valid pa_ext_volume_api_balance_valid
++#define pa_bvolume_valid pa_ext_volume_api_bvolume_valid
++#define pa_bvolume_init_invalid pa_ext_volume_api_bvolume_init_invalid
++#define pa_bvolume_init_mono pa_ext_volume_api_bvolume_init_mono
++#define pa_bvolume_equal pa_ext_volume_api_bvolume_equal
++#define pa_bvolume_from_cvolume pa_ext_volume_api_bvolume_from_cvolume
++#define pa_bvolume_to_cvolume pa_ext_volume_api_bvolume_to_cvolume
++#define pa_bvolume_copy_balance pa_ext_volume_api_bvolume_copy_balance
++#define pa_bvolume_reset_balance pa_ext_volume_api_bvolume_reset_balance
++#define pa_bvolume_remap pa_ext_volume_api_bvolume_remap
++
++#define PA_BVOLUME_SNPRINT_BALANCE_MAX PA_EXT_VOLUME_API_BVOLUME_SNPRINT_BALANCE_MAX
++#define pa_bvolume_snprint_balance pa_ext_volume_api_bvolume_snprint_balance
++
++#endif
+diff --git a/src/modules/volume-api/device-creator.c b/src/modules/volume-api/device-creator.c
+new file mode 100644
+index 0000000..1d912ba
+--- /dev/null
++++ b/src/modules/volume-api/device-creator.c
+@@ -0,0 +1,1108 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "device-creator.h"
++
++#include <modules/volume-api/device.h>
++#include <modules/volume-api/mute-control.h>
++#include <modules/volume-api/volume-control.h>
++
++#include <pulsecore/core-util.h>
++#include <pulsecore/i18n.h>
++
++struct pa_device_creator {
++    pa_volume_api *volume_api;
++    pa_hashmap *devices; /* pa_device_port/pa_sink/pa_source -> struct device */
++    pa_hook_slot *card_put_slot;
++    pa_hook_slot *card_unlink_slot;
++    pa_hook_slot *sink_put_slot;
++    pa_hook_slot *sink_unlink_slot;
++    pa_hook_slot *source_put_slot;
++    pa_hook_slot *source_unlink_slot;
++};
++
++enum device_type {
++    DEVICE_TYPE_PORT,
++    DEVICE_TYPE_PORT_MONITOR,
++    DEVICE_TYPE_SINK,
++    DEVICE_TYPE_SOURCE,
++};
++
++struct device_volume_control {
++    struct device *device;
++    pa_volume_control *volume_control;
++
++    bool unlinked;
++
++    pa_hook_slot *volume_changed_slot;
++};
++
++struct device_mute_control {
++    struct device *device;
++    pa_mute_control *mute_control;
++
++    bool unlinked;
++
++    pa_hook_slot *mute_changed_slot;
++};
++
++struct device {
++    pa_device_creator *creator;
++    enum device_type type;
++    pa_device_port *port;
++    pa_sink *sink;
++    pa_source *source;
++    pa_device *device;
++    struct device_volume_control *volume_control;
++    struct device_mute_control *mute_control;
++
++    bool unlinked;
++
++    pa_hook_slot *proplist_changed_slot;
++    pa_hook_slot *port_active_changed_slot;
++    struct device *monitor;
++};
++
++static const char *device_type_from_icon_name(const char *icon_name) {
++    if (!icon_name)
++        return NULL;
++
++    if (pa_streq(icon_name, "audio-input-microphone"))
++        return "microphone";
++
++    if (pa_streq(icon_name, "audio-speakers"))
++        return "speakers";
++
++    if (pa_streq(icon_name, "audio-headphones"))
++        return "headphones";
++
++    return NULL;
++}
++
++static const char *device_type_from_port_name(pa_device_port *port) {
++    pa_assert(port);
++
++    if (strstr(port->name, "analog")) {
++        if (port->direction == PA_DIRECTION_INPUT)
++            return "analog-input";
++        else
++            return "analog-output";
++    }
++
++    if (strstr(port->name, "hdmi")) {
++        if (port->direction == PA_DIRECTION_INPUT)
++            return "hdmi-input";
++        else
++            return "hdmi-output";
++    }
++
++    if (strstr(port->name, "iec958")) {
++        if (port->direction == PA_DIRECTION_INPUT)
++            return "spdif-input";
++        else
++            return "spdif-output";
++    }
++
++    return NULL;
++}
++
++static const char *device_type_from_port(pa_device_port *port) {
++    const char *device_type;
++
++    pa_assert(port);
++
++    device_type = device_type_from_icon_name(pa_proplist_gets(port->proplist, PA_PROP_DEVICE_ICON_NAME));
++    if (device_type)
++        return device_type;
++
++    device_type = device_type_from_port_name(port);
++    if (device_type)
++        return device_type;
++
++    return NULL;
++}
++
++static const char *get_sink_description(pa_sink *sink) {
++    const char *description;
++
++    pa_assert(sink);
++
++    description = pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION);
++    if (description)
++        return description;
++
++    return sink->name;
++}
++
++static const char *get_source_description(pa_source *source) {
++    const char *description;
++
++    pa_assert(source);
++
++    description = pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION);
++    if (description)
++        return description;
++
++    return source->name;
++}
++
++static int volume_control_set_volume_cb(pa_volume_control *c, const pa_bvolume *volume, bool set_volume, bool set_balance) {
++    struct device_volume_control *control;
++    struct device *device;
++    pa_bvolume bvolume;
++    pa_cvolume cvolume;
++
++    pa_assert(c);
++    pa_assert(volume);
++
++    control = c->userdata;
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                pa_bvolume_from_cvolume(&bvolume, &device->sink->reference_volume, &device->sink->channel_map);
++            else
++                pa_bvolume_from_cvolume(&bvolume, &device->source->reference_volume, &device->source->channel_map);
++            break;
++
++        case DEVICE_TYPE_SINK:
++            pa_bvolume_from_cvolume(&bvolume, &device->sink->reference_volume, &device->sink->channel_map);
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            pa_bvolume_from_cvolume(&bvolume, &device->source->reference_volume, &device->source->channel_map);
++            break;
++    }
++
++    if (set_volume)
++        bvolume.volume = volume->volume;
++
++    if (set_balance)
++        pa_bvolume_copy_balance(&bvolume, volume);
++
++    pa_bvolume_to_cvolume(&bvolume, &cvolume);
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                pa_sink_set_volume(device->sink, &cvolume, true, true);
++            else
++                pa_source_set_volume(device->source, &cvolume, true, true);
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            pa_source_set_volume(device->source, &cvolume, true, true);
++            break;
++
++        case DEVICE_TYPE_SINK:
++            pa_sink_set_volume(device->sink, &cvolume, true, true);
++            break;
++    }
++
++    return 0;
++}
++
++static struct device_volume_control *device_volume_control_new(struct device *device) {
++    struct device_volume_control *control;
++    const char *name = NULL;
++    bool convertible_to_dB = false;
++    bool channel_map_is_writable;
++
++    pa_assert(device);
++
++    control = pa_xnew0(struct device_volume_control, 1);
++    control->device = device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            name = "port-volume-control";
++
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                convertible_to_dB = device->sink->flags & PA_SINK_DECIBEL_VOLUME;
++            else
++                convertible_to_dB = device->source->flags & PA_SOURCE_DECIBEL_VOLUME;
++
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++            name = "port-monitor-volume-control";
++            convertible_to_dB = device->source->flags & PA_SOURCE_DECIBEL_VOLUME;
++            break;
++
++        case DEVICE_TYPE_SINK:
++            name = "sink-volume-control";
++            convertible_to_dB = device->sink->flags & PA_SINK_DECIBEL_VOLUME;
++            break;
++
++        case DEVICE_TYPE_SOURCE:
++            name = "source-volume-control";
++            convertible_to_dB = device->source->flags & PA_SOURCE_DECIBEL_VOLUME;
++            break;
++    }
++
++    channel_map_is_writable = false;
++    control->volume_control = pa_volume_control_new(device->creator->volume_api, name, device->device->description,
++                                                    convertible_to_dB, channel_map_is_writable);
++    control->volume_control->set_volume = volume_control_set_volume_cb;
++    control->volume_control->userdata = control;
++
++    return control;
++}
++
++static pa_hook_result_t sink_or_source_volume_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct device_volume_control *control = userdata;
++    struct device *device;
++    pa_sink *sink = NULL;
++    pa_source *source = NULL;
++    pa_bvolume bvolume;
++
++    pa_assert(control);
++    pa_assert(call_data);
++
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                sink = call_data;
++            else
++                source = call_data;
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            source = call_data;
++            break;
++
++        case DEVICE_TYPE_SINK:
++            sink = call_data;
++            break;
++    }
++
++    if ((sink && sink != device->sink) || (source && source != device->source))
++        return PA_HOOK_OK;
++
++    if (sink)
++        pa_bvolume_from_cvolume(&bvolume, &sink->reference_volume, &sink->channel_map);
++    else
++        pa_bvolume_from_cvolume(&bvolume, &source->reference_volume, &source->channel_map);
++
++    pa_volume_control_volume_changed(control->volume_control, &bvolume, true, true);
++
++    return PA_HOOK_OK;
++}
++
++static void volume_control_set_initial_volume_cb(pa_volume_control *c) {
++    struct device_volume_control *control;
++    struct device *device;
++    pa_cvolume cvolume;
++
++    pa_assert(c);
++
++    control = c->userdata;
++    device = control->device;
++    pa_bvolume_to_cvolume(&control->volume_control->volume, &cvolume);
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                pa_sink_set_volume(device->sink, &cvolume, true, true);
++            else
++                pa_source_set_volume(device->source, &cvolume, true, true);
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            pa_source_set_volume(device->source, &cvolume, true, true);
++            break;
++
++        case DEVICE_TYPE_SINK:
++            pa_sink_set_volume(device->sink, &cvolume, true, true);
++            break;
++    }
++}
++
++static void device_volume_control_put(struct device_volume_control *control) {
++    struct device *device;
++    pa_bvolume volume;
++
++    pa_assert(control);
++
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT) {
++                control->volume_changed_slot = pa_hook_connect(&device->port->core->hooks[PA_CORE_HOOK_SINK_VOLUME_CHANGED],
++                                                               PA_HOOK_NORMAL, sink_or_source_volume_changed_cb, control);
++                pa_bvolume_from_cvolume(&volume, &device->sink->reference_volume, &device->sink->channel_map);
++            } else {
++                control->volume_changed_slot = pa_hook_connect(&device->port->core->hooks[PA_CORE_HOOK_SOURCE_VOLUME_CHANGED],
++                                                               PA_HOOK_NORMAL, sink_or_source_volume_changed_cb, control);
++                pa_bvolume_from_cvolume(&volume, &device->source->reference_volume, &device->source->channel_map);
++            }
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            control->volume_changed_slot = pa_hook_connect(&device->source->core->hooks[PA_CORE_HOOK_SOURCE_VOLUME_CHANGED],
++                                                           PA_HOOK_NORMAL, sink_or_source_volume_changed_cb, control);
++            pa_bvolume_from_cvolume(&volume, &device->source->reference_volume, &device->source->channel_map);
++            break;
++
++        case DEVICE_TYPE_SINK:
++            control->volume_changed_slot = pa_hook_connect(&device->sink->core->hooks[PA_CORE_HOOK_SINK_VOLUME_CHANGED],
++                                                           PA_HOOK_NORMAL, sink_or_source_volume_changed_cb, control);
++            pa_bvolume_from_cvolume(&volume, &device->sink->reference_volume, &device->sink->channel_map);
++            break;
++    }
++
++    pa_volume_control_put(control->volume_control, &volume, volume_control_set_initial_volume_cb);
++}
++
++static void device_volume_control_unlink(struct device_volume_control *control) {
++    pa_assert(control);
++
++    if (control->unlinked)
++        return;
++
++    control->unlinked = true;
++
++    if (control->volume_control)
++        pa_volume_control_unlink(control->volume_control);
++
++    if (control->volume_changed_slot) {
++        pa_hook_slot_free(control->volume_changed_slot);
++        control->volume_changed_slot = NULL;
++    }
++}
++
++static void device_volume_control_free(struct device_volume_control *control) {
++    pa_assert(control);
++
++    if (!control->unlinked)
++        device_volume_control_unlink(control);
++
++    if (control->volume_control)
++        pa_volume_control_free(control->volume_control);
++
++    pa_xfree(control);
++}
++
++static int mute_control_set_mute_cb(pa_mute_control *c, bool mute) {
++    struct device_mute_control *control;
++    struct device *device;
++
++    pa_assert(c);
++
++    control = c->userdata;
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                pa_sink_set_mute(device->sink, mute, true);
++            else
++                pa_source_set_mute(device->source, mute, true);
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            pa_source_set_mute(device->source, mute, true);
++            break;
++
++        case DEVICE_TYPE_SINK:
++            pa_sink_set_mute(device->sink, mute, true);
++            break;
++    }
++
++    return 0;
++}
++
++static struct device_mute_control *device_mute_control_new(struct device *device) {
++    struct device_mute_control *control;
++    const char *name = NULL;
++
++    pa_assert(device);
++
++    control = pa_xnew0(struct device_mute_control, 1);
++    control->device = device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            name = "port-mute-control";
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++            name = "port-monitor-mute-control";
++            break;
++
++        case DEVICE_TYPE_SINK:
++            name = "sink-mute-control";
++            break;
++
++        case DEVICE_TYPE_SOURCE:
++            name = "source-mute-control";
++            break;
++    }
++
++    control->mute_control = pa_mute_control_new(device->creator->volume_api, name, device->device->description);
++    control->mute_control->set_mute = mute_control_set_mute_cb;
++    control->mute_control->userdata = control;
++
++    return control;
++}
++
++static pa_hook_result_t sink_or_source_mute_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct device_mute_control *control = userdata;
++    struct device *device;
++    pa_sink *sink = NULL;
++    pa_source *source = NULL;
++    bool mute;
++
++    pa_assert(control);
++    pa_assert(call_data);
++
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                sink = call_data;
++            else
++                source = call_data;
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            source = call_data;
++            break;
++
++        case DEVICE_TYPE_SINK:
++            sink = call_data;
++            break;
++    }
++
++    if ((sink && sink != device->sink) || (source && source != device->source))
++        return PA_HOOK_OK;
++
++    if (sink)
++        mute = sink->muted;
++    else
++        mute = source->muted;
++
++    pa_mute_control_mute_changed(control->mute_control, mute);
++
++    return PA_HOOK_OK;
++}
++
++static void mute_control_set_initial_mute_cb(pa_mute_control *c) {
++    struct device_volume_control *control;
++    struct device *device;
++
++    pa_assert(c);
++
++    control = c->userdata;
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                pa_sink_set_mute(device->sink, c->mute, true);
++            else
++                pa_source_set_mute(device->source, c->mute, true);
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            pa_source_set_mute(device->source, c->mute, true);
++            break;
++
++        case DEVICE_TYPE_SINK:
++            pa_sink_set_mute(device->sink, c->mute, true);
++            break;
++    }
++}
++
++static void device_mute_control_put(struct device_mute_control *control) {
++    struct device *device;
++    bool mute = false;
++
++    pa_assert(control);
++
++    device = control->device;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT) {
++                control->mute_changed_slot = pa_hook_connect(&device->port->core->hooks[PA_CORE_HOOK_SINK_MUTE_CHANGED],
++                                                             PA_HOOK_NORMAL, sink_or_source_mute_changed_cb, control);
++                mute = device->sink->muted;
++            } else {
++                control->mute_changed_slot = pa_hook_connect(&device->port->core->hooks[PA_CORE_HOOK_SOURCE_MUTE_CHANGED],
++                                                             PA_HOOK_NORMAL, sink_or_source_mute_changed_cb, control);
++                mute = device->source->muted;
++            }
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++        case DEVICE_TYPE_SOURCE:
++            control->mute_changed_slot = pa_hook_connect(&device->source->core->hooks[PA_CORE_HOOK_SOURCE_MUTE_CHANGED],
++                                                         PA_HOOK_NORMAL, sink_or_source_mute_changed_cb, control);
++            mute = device->source->muted;
++            break;
++
++        case DEVICE_TYPE_SINK:
++            control->mute_changed_slot = pa_hook_connect(&device->sink->core->hooks[PA_CORE_HOOK_SINK_MUTE_CHANGED],
++                                                         PA_HOOK_NORMAL, sink_or_source_mute_changed_cb, control);
++            mute = device->sink->muted;
++            break;
++    }
++
++    pa_mute_control_put(control->mute_control, mute, true, mute_control_set_initial_mute_cb);
++}
++
++static void device_mute_control_unlink(struct device_mute_control *control) {
++    pa_assert(control);
++
++    if (control->unlinked)
++        return;
++
++    control->unlinked = true;
++
++    if (control->mute_control)
++        pa_mute_control_unlink(control->mute_control);
++
++    if (control->mute_changed_slot) {
++        pa_hook_slot_free(control->mute_changed_slot);
++        control->mute_changed_slot = NULL;
++    }
++}
++
++static void device_mute_control_free(struct device_mute_control *control) {
++    pa_assert(control);
++
++    if (!control->unlinked)
++        device_mute_control_unlink(control);
++
++    if (control->mute_control)
++        pa_mute_control_free(control->mute_control);
++
++    pa_xfree(control);
++}
++
++static void device_set_sink_and_source_from_port(struct device *device) {
++    pa_sink *sink;
++    pa_source *source;
++    uint32_t idx;
++
++    pa_assert(device);
++
++    device->sink = NULL;
++    device->source = NULL;
++
++    if (!device->port->active)
++        return;
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT) {
++                PA_IDXSET_FOREACH(sink, device->port->card->sinks, idx) {
++                    if (sink->active_port == device->port) {
++                        device->sink = sink;
++                        break;
++                    }
++                }
++
++                pa_assert(device->sink);
++            } else {
++                PA_IDXSET_FOREACH(source, device->port->card->sources, idx) {
++                    if (source->active_port == device->port) {
++                        device->source = source;
++                        break;
++                    }
++                }
++
++                pa_assert(device->source);
++            }
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR: {
++            PA_IDXSET_FOREACH(sink, device->port->card->sinks, idx) {
++                if (sink->active_port == device->port) {
++                    device->sink = sink;
++                    device->source = sink->monitor_source;
++                    break;
++                }
++            }
++
++            pa_assert(device->sink);
++            break;
++        }
++
++        case DEVICE_TYPE_SINK:
++        case DEVICE_TYPE_SOURCE:
++            pa_assert_not_reached();
++    }
++}
++
++static pa_hook_result_t sink_or_source_proplist_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct device *device = userdata;
++    pa_sink *sink = NULL;
++    pa_source *source = NULL;
++    const char *description = NULL;
++
++    pa_assert(device);
++    pa_assert(call_data);
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++        case DEVICE_TYPE_PORT_MONITOR:
++            pa_assert_not_reached();
++
++        case DEVICE_TYPE_SINK:
++            sink = call_data;
++
++            if (sink != device->sink)
++                return PA_HOOK_OK;
++
++            description = get_sink_description(sink);
++            break;
++
++        case DEVICE_TYPE_SOURCE:
++            source = call_data;
++
++            if (source != device->source)
++                return PA_HOOK_OK;
++
++            description = get_source_description(source);
++            break;
++    }
++
++    pa_device_description_changed(device->device, description);
++    pa_volume_control_description_changed(device->volume_control->volume_control, description);
++    pa_mute_control_description_changed(device->mute_control->mute_control, description);
++
++    return PA_HOOK_OK;
++}
++
++static struct device *device_new(pa_device_creator *creator, enum device_type type, void *core_device) {
++    struct device *device = NULL;
++    const char *name = NULL;
++    char *description = NULL;
++    pa_direction_t direction = PA_DIRECTION_OUTPUT;
++    const char *device_type = NULL;
++    bool create_volume_and_mute_controls = true;
++
++    pa_assert(creator);
++    pa_assert(core_device);
++
++    device = pa_xnew0(struct device, 1);
++    device->creator = creator;
++    device->type = type;
++
++    switch (type) {
++        case DEVICE_TYPE_PORT:
++            device->port = core_device;
++            device_set_sink_and_source_from_port(device);
++            name = "port-device";
++            description = pa_xstrdup(device->port->description);
++            direction = device->port->direction;
++            device_type = device_type_from_port(device->port);
++
++            if (!device->sink && !device->source)
++                create_volume_and_mute_controls = false;
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++            device->port = core_device;
++            device_set_sink_and_source_from_port(device);
++            name = "port-monitor-device";
++            description = pa_sprintf_malloc(_("Monitor of %s"), device->port->description);
++            direction = PA_DIRECTION_INPUT;
++
++            if (!device->source)
++                create_volume_and_mute_controls = false;
++            break;
++
++        case DEVICE_TYPE_SINK:
++            device->sink = core_device;
++            name = "sink-device";
++            description = pa_xstrdup(get_sink_description(device->sink));
++            direction = PA_DIRECTION_OUTPUT;
++            break;
++
++        case DEVICE_TYPE_SOURCE:
++            device->source = core_device;
++            name = "source-device";
++            description = pa_xstrdup(get_source_description(device->source));
++            direction = PA_DIRECTION_INPUT;
++            break;
++    }
++
++    device->device = pa_device_new(creator->volume_api, name, description, direction, &device_type, device_type ? 1 : 0);
++    pa_xfree(description);
++
++    if (create_volume_and_mute_controls) {
++        device->volume_control = device_volume_control_new(device);
++        device->mute_control = device_mute_control_new(device);
++    }
++
++    switch (type) {
++        case DEVICE_TYPE_PORT:
++            if (device->port->direction == PA_DIRECTION_OUTPUT)
++                device->monitor = device_new(creator, DEVICE_TYPE_PORT_MONITOR, device->port);
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++            break;
++
++        case DEVICE_TYPE_SINK:
++            device->proplist_changed_slot = pa_hook_connect(&device->sink->core->hooks[PA_CORE_HOOK_SINK_PROPLIST_CHANGED],
++                                                            PA_HOOK_NORMAL, sink_or_source_proplist_changed_cb, device);
++            break;
++
++        case DEVICE_TYPE_SOURCE:
++            device->proplist_changed_slot = pa_hook_connect(&device->source->core->hooks[PA_CORE_HOOK_SOURCE_PROPLIST_CHANGED],
++                                                            PA_HOOK_NORMAL, sink_or_source_proplist_changed_cb, device);
++            break;
++    }
++
++    return device;
++}
++
++static pa_hook_result_t port_active_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct device *device = userdata;
++    pa_device_port *port = call_data;
++    bool should_have_volume_and_mute_controls = false;
++
++    pa_assert(device);
++    pa_assert(port);
++
++    if (port != device->port)
++        return PA_HOOK_OK;
++
++    device_set_sink_and_source_from_port(device);
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++            should_have_volume_and_mute_controls = device->sink || device->source;
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++            should_have_volume_and_mute_controls = !!device->source;
++            break;
++
++        case DEVICE_TYPE_SINK:
++        case DEVICE_TYPE_SOURCE:
++            pa_assert_not_reached();
++    }
++
++    if (should_have_volume_and_mute_controls && !device->volume_control) {
++        pa_assert(!device->mute_control);
++
++        device->volume_control = device_volume_control_new(device);
++        device_volume_control_put(device->volume_control);
++        pa_device_set_default_volume_control(device->device, device->volume_control->volume_control);
++
++        device->mute_control = device_mute_control_new(device);
++        device_mute_control_put(device->mute_control);
++        pa_device_set_default_mute_control(device->device, device->mute_control->mute_control);
++    }
++
++    if (!should_have_volume_and_mute_controls && device->volume_control) {
++        pa_assert(device->mute_control);
++
++        device_mute_control_free(device->mute_control);
++        device->mute_control = NULL;
++        device_volume_control_free(device->volume_control);
++        device->volume_control = NULL;
++    }
++
++    return PA_HOOK_OK;
++}
++
++static void device_put(struct device *device) {
++    pa_assert(device);
++
++    switch (device->type) {
++        case DEVICE_TYPE_PORT:
++        case DEVICE_TYPE_PORT_MONITOR:
++            device->port_active_changed_slot = pa_hook_connect(&device->port->core->hooks[PA_CORE_HOOK_PORT_ACTIVE_CHANGED],
++                                                               PA_HOOK_NORMAL, port_active_changed_cb, device);
++
++        case DEVICE_TYPE_SINK:
++        case DEVICE_TYPE_SOURCE:
++            break;
++    }
++
++    if (device->volume_control)
++        device_volume_control_put(device->volume_control);
++
++    if (device->mute_control)
++        device_mute_control_put(device->mute_control);
++
++    pa_device_put(device->device, device->volume_control ? device->volume_control->volume_control : NULL,
++                  device->mute_control ? device->mute_control->mute_control : NULL);
++
++    if (device->monitor)
++        device_put(device->monitor);
++}
++
++static void device_unlink(struct device *device) {
++    pa_assert(device);
++
++    if (device->unlinked)
++        return;
++
++    device->unlinked = true;
++
++    if (device->monitor)
++        device_unlink(device->monitor);
++
++    if (device->device)
++        pa_device_unlink(device->device);
++
++    if (device->mute_control)
++        device_mute_control_unlink(device->mute_control);
++
++    if (device->volume_control)
++        device_volume_control_unlink(device->volume_control);
++
++    if (device->port_active_changed_slot) {
++        pa_hook_slot_free(device->port_active_changed_slot);
++        device->port_active_changed_slot = NULL;
++    }
++}
++
++static void device_free(struct device *device) {
++    pa_assert(device);
++
++    if (!device->unlinked)
++        device_unlink(device);
++
++    if (device->monitor)
++        device_free(device->monitor);
++
++    if (device->proplist_changed_slot)
++        pa_hook_slot_free(device->proplist_changed_slot);
++
++    if (device->mute_control)
++        device_mute_control_free(device->mute_control);
++
++    if (device->volume_control)
++        device_volume_control_free(device->volume_control);
++
++    if (device->device)
++        pa_device_free(device->device);
++
++    pa_xfree(device);
++}
++
++static void create_device(pa_device_creator *creator, enum device_type type, void *core_device) {
++    struct device *device;
++
++    pa_assert(creator);
++    pa_assert(core_device);
++
++    switch (type) {
++        case DEVICE_TYPE_PORT:
++            break;
++
++        case DEVICE_TYPE_PORT_MONITOR:
++            pa_assert_not_reached();
++
++        case DEVICE_TYPE_SINK:
++            if (!pa_hashmap_isempty(((pa_sink *) core_device)->ports))
++                return;
++            break;
++
++        case DEVICE_TYPE_SOURCE: {
++            pa_source *source = core_device;
++
++            if (source->monitor_of && !pa_hashmap_isempty(source->monitor_of->ports))
++                return;
++
++            if (!pa_hashmap_isempty(((pa_source *) core_device)->ports))
++                return;
++            break;
++        }
++    }
++
++    device = device_new(creator, type, core_device);
++    pa_hashmap_put(creator->devices, core_device, device);
++    device_put(device);
++}
++
++static pa_hook_result_t card_put_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_device_creator *creator = userdata;
++    pa_card *card = call_data;
++    pa_device_port *port;
++    void *state;
++
++    pa_assert(creator);
++    pa_assert(card);
++
++    PA_HASHMAP_FOREACH(port, card->ports, state)
++        create_device(creator, DEVICE_TYPE_PORT, port);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t card_unlink_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_device_creator *creator = userdata;
++    pa_card *card = call_data;
++    pa_device_port *port;
++    void *state;
++
++    pa_assert(creator);
++    pa_assert(card);
++
++    PA_HASHMAP_FOREACH(port, card->ports, state)
++        pa_hashmap_remove_and_free(creator->devices, port);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t sink_put_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_device_creator *creator = userdata;
++    pa_sink *sink = call_data;
++
++    pa_assert(creator);
++    pa_assert(sink);
++
++    create_device(creator, DEVICE_TYPE_SINK, sink);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t sink_unlink_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_device_creator *creator = userdata;
++    pa_sink *sink = call_data;
++
++    pa_assert(creator);
++    pa_assert(sink);
++
++    pa_hashmap_remove_and_free(creator->devices, sink);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t source_put_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_device_creator *creator = userdata;
++    pa_source *source = call_data;
++
++    pa_assert(creator);
++    pa_assert(source);
++
++    create_device(creator, DEVICE_TYPE_SOURCE, source);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t source_unlink_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_device_creator *creator = userdata;
++    pa_source *source = call_data;
++
++    pa_assert(creator);
++    pa_assert(source);
++
++    pa_hashmap_remove_and_free(creator->devices, source);
++
++    return PA_HOOK_OK;
++}
++
++pa_device_creator *pa_device_creator_new(pa_volume_api *api) {
++    pa_device_creator *creator;
++    pa_card *card;
++    uint32_t idx;
++    pa_sink *sink;
++    pa_source *source;
++
++    pa_assert(api);
++
++    creator = pa_xnew0(pa_device_creator, 1);
++    creator->volume_api = api;
++    creator->devices = pa_hashmap_new_full(NULL, NULL, NULL, (pa_free_cb_t) device_free);
++    creator->card_put_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_CARD_PUT], PA_HOOK_NORMAL, card_put_cb, creator);
++    creator->card_unlink_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_CARD_UNLINK], PA_HOOK_NORMAL, card_unlink_cb,
++                                                creator);
++    creator->sink_put_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_NORMAL, sink_put_cb, creator);
++    creator->sink_unlink_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SINK_UNLINK], PA_HOOK_NORMAL, sink_unlink_cb,
++                                                creator);
++    creator->source_put_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_NORMAL, source_put_cb,
++                                               creator);
++    creator->source_unlink_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_NORMAL,
++                                                  source_unlink_cb, creator);
++
++    PA_IDXSET_FOREACH(card, api->core->cards, idx) {
++        pa_device_port *port;
++        void *state;
++
++        PA_HASHMAP_FOREACH(port, card->ports, state)
++            create_device(creator, DEVICE_TYPE_PORT, port);
++    }
++
++    PA_IDXSET_FOREACH(sink, api->core->sinks, idx)
++        create_device(creator, DEVICE_TYPE_SINK, sink);
++
++    PA_IDXSET_FOREACH(source, api->core->sources, idx)
++        create_device(creator, DEVICE_TYPE_SOURCE, source);
++
++    return creator;
++}
++
++void pa_device_creator_free(pa_device_creator *creator) {
++    pa_assert(creator);
++
++    if (creator->devices)
++        pa_hashmap_remove_all(creator->devices);
++
++    if (creator->source_unlink_slot)
++        pa_hook_slot_free(creator->source_unlink_slot);
++
++    if (creator->source_put_slot)
++        pa_hook_slot_free(creator->source_put_slot);
++
++    if (creator->sink_unlink_slot)
++        pa_hook_slot_free(creator->sink_unlink_slot);
++
++    if (creator->sink_put_slot)
++        pa_hook_slot_free(creator->sink_put_slot);
++
++    if (creator->card_unlink_slot)
++        pa_hook_slot_free(creator->card_unlink_slot);
++
++    if (creator->card_put_slot)
++        pa_hook_slot_free(creator->card_put_slot);
++
++    if (creator->devices)
++        pa_hashmap_free(creator->devices);
++
++    pa_xfree(creator);
++}
+diff --git a/src/modules/volume-api/device-creator.h b/src/modules/volume-api/device-creator.h
+new file mode 100644
+index 0000000..bcec8d9
+--- /dev/null
++++ b/src/modules/volume-api/device-creator.h
+@@ -0,0 +1,32 @@
++#ifndef foodevicecreatorhfoo
++#define foodevicecreatorhfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/volume-api.h>
++
++typedef struct pa_device_creator pa_device_creator;
++
++pa_device_creator *pa_device_creator_new(pa_volume_api *api);
++void pa_device_creator_free(pa_device_creator *creator);
++
++#endif
+diff --git a/src/modules/volume-api/device.c b/src/modules/volume-api/device.c
+new file mode 100644
+index 0000000..ea496ba
+--- /dev/null
++++ b/src/modules/volume-api/device.c
+@@ -0,0 +1,293 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "device.h"
++
++#include <modules/volume-api/mute-control.h>
++#include <modules/volume-api/volume-control.h>
++
++#include <pulse/direction.h>
++
++#include <pulsecore/core-util.h>
++
++pa_device *pa_device_new(pa_volume_api *api, const char *name, const char *description, pa_direction_t direction,
++                         const char * const *device_types, unsigned n_device_types) {
++    pa_device *device;
++    unsigned i;
++
++    pa_assert(api);
++    pa_assert(name);
++    pa_assert(description);
++    pa_assert(device_types || n_device_types == 0);
++
++    device = pa_xnew0(pa_device, 1);
++    device->volume_api = api;
++    device->index = pa_volume_api_allocate_device_index(api);
++    pa_assert_se(pa_volume_api_register_name(api, name, false, &device->name) >= 0);
++    device->description = pa_xstrdup(description);
++    device->direction = direction;
++    device->device_types = pa_dynarray_new(pa_xfree);
++
++    for (i = 0; i < n_device_types; i++)
++        pa_dynarray_append(device->device_types, pa_xstrdup(device_types[i]));
++
++    device->proplist = pa_proplist_new();
++    device->use_default_volume_control = true;
++    device->use_default_mute_control = true;
++
++    return device;
++}
++
++void pa_device_put(pa_device *device, pa_volume_control *default_volume_control, pa_mute_control *default_mute_control) {
++    char *device_types_str;
++    const char *prop_key;
++    void *state = NULL;
++
++    pa_assert(device);
++
++    if (default_volume_control) {
++        device->default_volume_control = default_volume_control;
++        pa_volume_control_add_default_for_device(default_volume_control, device);
++
++        device->volume_control = default_volume_control;
++        pa_volume_control_add_device(default_volume_control, device);
++    }
++
++    if (default_mute_control) {
++        device->default_mute_control = default_mute_control;
++        pa_mute_control_add_default_for_device(default_mute_control, device);
++
++        device->mute_control = default_mute_control;
++        pa_mute_control_add_device(default_mute_control, device);
++    }
++
++    pa_volume_api_add_device(device->volume_api, device);
++
++    device->linked = true;
++
++    device_types_str = pa_join((const char * const *) pa_dynarray_get_raw_array(device->device_types),
++                               pa_dynarray_size(device->device_types), ", ");
++
++    pa_log_debug("Created device #%u.", device->index);
++    pa_log_debug("    Name: %s", device->name);
++    pa_log_debug("    Description: %s", device->description);
++    pa_log_debug("    Direction: %s", pa_direction_to_string(device->direction));
++    pa_log_debug("    Device Types: %s", *device_types_str ? device_types_str : "(none)");
++    pa_log_debug("    Volume control: %s", device->volume_control ? device->volume_control->name : "(unset)");
++    pa_log_debug("    Mute control: %s", device->mute_control ? device->mute_control->name : "(unset)");
++    pa_log_debug("    Properties:");
++
++    while ((prop_key = pa_proplist_iterate(device->proplist, &state)))
++        pa_log_debug("        %s = %s", prop_key, pa_strnull(pa_proplist_gets(device->proplist, prop_key)));
++
++    pa_xfree(device_types_str);
++
++    pa_hook_fire(&device->volume_api->hooks[PA_VOLUME_API_HOOK_DEVICE_PUT], device);
++}
++
++void pa_device_unlink(pa_device *device) {
++    pa_assert(device);
++
++    if (device->unlinked) {
++        pa_log_debug("Unlinking device %s (already unlinked, this is a no-op).", device->name);
++        return;
++    }
++
++    device->unlinked = true;
++
++    pa_log_debug("Unlinking device %s.", device->name);
++
++    if (device->linked)
++        pa_hook_fire(&device->volume_api->hooks[PA_VOLUME_API_HOOK_DEVICE_UNLINK], device);
++
++    pa_volume_api_remove_device(device->volume_api, device);
++
++    if (device->mute_control) {
++        pa_mute_control_remove_device(device->mute_control, device);
++        device->mute_control = NULL;
++    }
++
++    if (device->default_mute_control) {
++        pa_mute_control_remove_default_for_device(device->default_mute_control, device);
++        device->default_mute_control = NULL;
++    }
++
++    if (device->volume_control) {
++        pa_volume_control_remove_device(device->volume_control, device);
++        device->volume_control = NULL;
++    }
++
++    if (device->default_volume_control) {
++        pa_volume_control_remove_default_for_device(device->default_volume_control, device);
++        device->default_volume_control = NULL;
++    }
++}
++
++void pa_device_free(pa_device *device) {
++    pa_assert(device);
++
++    if (!device->unlinked)
++        pa_device_unlink(device);
++
++    if (device->proplist)
++        pa_proplist_free(device->proplist);
++
++    if (device->device_types)
++        pa_dynarray_free(device->device_types);
++
++    pa_xfree(device->description);
++
++    if (device->name)
++        pa_volume_api_unregister_name(device->volume_api, device->name);
++
++    pa_xfree(device);
++}
++
++static void set_volume_control_internal(pa_device *device, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(device);
++
++    old_control = device->volume_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control)
++        pa_volume_control_remove_device(old_control, device);
++
++    device->volume_control = control;
++
++    if (control)
++        pa_volume_control_add_device(control, device);
++
++    if (!device->linked || device->unlinked)
++        return;
++
++    pa_log_debug("The volume control of device %s changed from %s to %s.", device->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&device->volume_api->hooks[PA_VOLUME_API_HOOK_DEVICE_VOLUME_CONTROL_CHANGED], device);
++}
++
++void pa_device_set_volume_control(pa_device *device, pa_volume_control *control) {
++    pa_assert(device);
++
++    device->use_default_volume_control = false;
++    set_volume_control_internal(device, control);
++}
++
++static void set_mute_control_internal(pa_device *device, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(device);
++
++    old_control = device->mute_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control)
++        pa_mute_control_remove_device(old_control, device);
++
++    device->mute_control = control;
++
++    if (control)
++        pa_mute_control_add_device(control, device);
++
++    pa_log_debug("The mute control of device %s changed from %s to %s.", device->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&device->volume_api->hooks[PA_VOLUME_API_HOOK_DEVICE_MUTE_CONTROL_CHANGED], device);
++}
++
++void pa_device_set_mute_control(pa_device *device, pa_mute_control *control) {
++    pa_assert(device);
++
++    device->use_default_mute_control = false;
++    set_mute_control_internal(device, control);
++}
++
++void pa_device_description_changed(pa_device *device, const char *new_description) {
++    char *old_description;
++
++    pa_assert(device);
++    pa_assert(new_description);
++
++    old_description = device->description;
++
++    if (pa_streq(new_description, old_description))
++        return;
++
++    device->description = pa_xstrdup(new_description);
++    pa_log_debug("The description of device %s changed from \"%s\" to \"%s\".", device->name, old_description,
++                 new_description);
++    pa_xfree(old_description);
++    pa_hook_fire(&device->volume_api->hooks[PA_VOLUME_API_HOOK_DEVICE_DESCRIPTION_CHANGED], device);
++}
++
++void pa_device_set_default_volume_control(pa_device *device, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(device);
++
++    old_control = device->default_volume_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control)
++        pa_volume_control_remove_default_for_device(old_control, device);
++
++    device->default_volume_control = control;
++
++    if (control)
++        pa_volume_control_add_default_for_device(control, device);
++
++    if (device->use_default_volume_control)
++        set_volume_control_internal(device, control);
++}
++
++void pa_device_set_default_mute_control(pa_device *device, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(device);
++
++    old_control = device->default_mute_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control)
++        pa_mute_control_remove_default_for_device(old_control, device);
++
++    device->default_mute_control = control;
++
++    if (control)
++        pa_mute_control_add_default_for_device(control, device);
++
++    if (device->use_default_mute_control)
++        set_mute_control_internal(device, control);
++}
+diff --git a/src/modules/volume-api/device.h b/src/modules/volume-api/device.h
+new file mode 100644
+index 0000000..9eac7e9
+--- /dev/null
++++ b/src/modules/volume-api/device.h
+@@ -0,0 +1,76 @@
++#ifndef foodevicehfoo
++#define foodevicehfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/volume-api.h>
++
++#include <pulsecore/dynarray.h>
++
++typedef struct pa_device pa_device;
++
++struct pa_device {
++    pa_volume_api *volume_api;
++    uint32_t index;
++    const char *name;
++    char *description;
++    pa_direction_t direction;
++    pa_dynarray *device_types;
++    pa_proplist *proplist;
++    pa_volume_control *volume_control;
++    pa_mute_control *mute_control;
++
++    /* The device implementation can provide default volume and mute controls,
++     * which are used in case there's no policy module that wants to override
++     * the defaults. */
++    pa_volume_control *default_volume_control;
++    bool use_default_volume_control;
++    pa_mute_control *default_mute_control;
++    bool use_default_mute_control;
++
++    bool linked;
++    bool unlinked;
++};
++
++pa_device *pa_device_new(pa_volume_api *api, const char *name, const char *description, pa_direction_t direction,
++                         const char * const *device_types, unsigned n_device_types);
++void pa_device_put(pa_device *device, pa_volume_control *default_volume_control, pa_mute_control *default_mute_control);
++void pa_device_unlink(pa_device *device);
++void pa_device_free(pa_device *device);
++
++/* Called by policy modules. */
++void pa_device_set_volume_control(pa_device *device, pa_volume_control *control);
++void pa_device_set_mute_control(pa_device *device, pa_mute_control *control);
++
++/* Called by policy modules. Note that pa_device_set_volume_control() and
++ * pa_device_set_mute_control() automatically disable the corresponding
++ * use_default flags, so these functions are mainly useful for re-enabling the
++ * flags. */
++void pa_device_set_use_default_volume_control(pa_device *device, bool use);
++void pa_device_set_use_default_mute_control(pa_device *device, bool use);
++
++/* Called by the device implementation. */
++void pa_device_description_changed(pa_device *device, const char *new_description);
++void pa_device_set_default_volume_control(pa_device *device, pa_volume_control *control);
++void pa_device_set_default_mute_control(pa_device *device, pa_mute_control *control);
++
++#endif
+diff --git a/src/modules/volume-api/mute-control.c b/src/modules/volume-api/mute-control.c
+new file mode 100644
+index 0000000..adc008e
+--- /dev/null
++++ b/src/modules/volume-api/mute-control.c
+@@ -0,0 +1,306 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "mute-control.h"
++
++#include <modules/volume-api/audio-group.h>
++#include <modules/volume-api/device.h>
++#include <modules/volume-api/sstream.h>
++
++#include <pulsecore/core-util.h>
++
++pa_mute_control *pa_mute_control_new(pa_volume_api *api, const char *name, const char *description) {
++    pa_mute_control *control;
++
++    pa_assert(api);
++    pa_assert(name);
++    pa_assert(description);
++
++    control = pa_xnew0(pa_mute_control, 1);
++    control->volume_api = api;
++    control->index = pa_volume_api_allocate_mute_control_index(api);
++    pa_assert_se(pa_volume_api_register_name(api, name, false, &control->name) >= 0);
++    control->description = pa_xstrdup(description);
++    control->proplist = pa_proplist_new();
++    control->devices = pa_hashmap_new(NULL, NULL);
++    control->default_for_devices = pa_hashmap_new(NULL, NULL);
++    control->streams = pa_hashmap_new(NULL, NULL);
++    control->audio_groups = pa_hashmap_new(NULL, NULL);
++
++    return control;
++}
++
++void pa_mute_control_put(pa_mute_control *control, bool initial_mute, bool initial_mute_is_set,
++                         pa_mute_control_set_initial_mute_cb_t set_initial_mute_cb) {
++    const char *prop_key;
++    void *state = NULL;
++
++    pa_assert(control);
++    pa_assert(initial_mute_is_set || control->set_mute);
++    pa_assert(set_initial_mute_cb || !control->set_mute);
++
++    if (initial_mute_is_set)
++        control->mute = initial_mute;
++    else
++        control->mute = false;
++
++    if (set_initial_mute_cb)
++        set_initial_mute_cb(control);
++
++    pa_volume_api_add_mute_control(control->volume_api, control);
++
++    control->linked = true;
++
++    pa_log_debug("Created mute control #%u.", control->index);
++    pa_log_debug("    Name: %s", control->name);
++    pa_log_debug("    Description: %s", control->description);
++    pa_log_debug("    Mute: %s", pa_yes_no(control->mute));
++    pa_log_debug("    Properties:");
++
++    while ((prop_key = pa_proplist_iterate(control->proplist, &state)))
++        pa_log_debug("        %s = %s", prop_key, pa_strnull(pa_proplist_gets(control->proplist, prop_key)));
++
++    pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_MUTE_CONTROL_PUT], control);
++}
++
++void pa_mute_control_unlink(pa_mute_control *control) {
++    pa_audio_group *group;
++    pa_device *device;
++    pas_stream *stream;
++
++    pa_assert(control);
++
++    if (control->unlinked) {
++        pa_log_debug("Unlinking mute control %s (already unlinked, this is a no-op).", control->name);
++        return;
++    }
++
++    control->unlinked = true;
++
++    pa_log_debug("Unlinking mute control %s.", control->name);
++
++    if (control->linked)
++        pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_MUTE_CONTROL_UNLINK], control);
++
++    pa_volume_api_remove_mute_control(control->volume_api, control);
++
++    while ((group = pa_hashmap_first(control->audio_groups)))
++        pa_audio_group_set_mute_control(group, NULL);
++
++    while ((stream = pa_hashmap_first(control->streams)))
++        pas_stream_set_mute_control(stream, NULL);
++
++    while ((device = pa_hashmap_first(control->default_for_devices)))
++        pa_device_set_default_mute_control(device, NULL);
++
++    while ((device = pa_hashmap_first(control->devices))) {
++        /* Why do we have this assertion here? The concern is that if we call
++         * pa_device_set_mute_control() for some device that has the
++         * use_default_mute_control flag set, then that flag will be unset as
++         * a side effect, and we don't want that side effect. This assertion
++         * should be safe, because we just called
++         * pa_device_set_default_mute_control(NULL) for each device that this
++         * control was the default for, and that should ensure that we don't
++         * any more hold any references to devices that used to use this
++         * control as the default. */
++        pa_assert(!device->use_default_mute_control);
++        pa_device_set_mute_control(device, NULL);
++    }
++}
++
++void pa_mute_control_free(pa_mute_control *control) {
++    pa_assert(control);
++
++    if (!control->unlinked)
++        pa_mute_control_unlink(control);
++
++    if (control->audio_groups) {
++        pa_assert(pa_hashmap_isempty(control->audio_groups));
++        pa_hashmap_free(control->audio_groups);
++    }
++
++    if (control->streams) {
++        pa_assert(pa_hashmap_isempty(control->streams));
++        pa_hashmap_free(control->streams);
++    }
++
++    if (control->default_for_devices) {
++        pa_assert(pa_hashmap_isempty(control->default_for_devices));
++        pa_hashmap_free(control->default_for_devices);
++    }
++
++    if (control->devices) {
++        pa_assert(pa_hashmap_isempty(control->devices));
++        pa_hashmap_free(control->devices);
++    }
++
++    if (control->proplist)
++        pa_proplist_free(control->proplist);
++
++    pa_xfree(control->description);
++
++    if (control->name)
++        pa_volume_api_unregister_name(control->volume_api, control->name);
++
++    pa_xfree(control);
++}
++
++void pa_mute_control_set_owner_audio_group(pa_mute_control *control, pa_audio_group *group) {
++    pa_assert(control);
++    pa_assert(group);
++
++    control->owner_audio_group = group;
++}
++
++static void set_mute_internal(pa_mute_control *control, bool mute) {
++    bool old_mute;
++
++    pa_assert(control);
++
++    old_mute = control->mute;
++
++    if (mute == old_mute)
++        return;
++
++    control->mute = mute;
++
++    if (!control->linked || control->unlinked)
++        return;
++
++    pa_log_debug("The mute of mute control %s changed from %s to %s.", control->name, pa_yes_no(old_mute),
++                 pa_yes_no(control->mute));
++
++    pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_MUTE_CONTROL_MUTE_CHANGED], control);
++}
++
++int pa_mute_control_set_mute(pa_mute_control *control, bool mute) {
++    int r;
++
++    pa_assert(control);
++
++    if (!control->set_mute) {
++        pa_log_info("Tried to set the mute of mute control %s, but the mute control doesn't support the operation.",
++                    control->name);
++        return -PA_ERR_NOTSUPPORTED;
++    }
++
++    if (mute == control->mute)
++        return 0;
++
++    control->set_mute_in_progress = true;
++    r = control->set_mute(control, mute);
++    control->set_mute_in_progress = false;
++
++    if (r >= 0)
++        set_mute_internal(control, mute);
++
++    return r;
++}
++
++void pa_mute_control_description_changed(pa_mute_control *control, const char *new_description) {
++    char *old_description;
++
++    pa_assert(control);
++    pa_assert(new_description);
++
++    old_description = control->description;
++
++    if (pa_streq(new_description, old_description))
++        return;
++
++    control->description = pa_xstrdup(new_description);
++    pa_log_debug("The description of mute control %s changed from \"%s\" to \"%s\".", control->name, old_description,
++                 new_description);
++    pa_xfree(old_description);
++    pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_MUTE_CONTROL_DESCRIPTION_CHANGED], control);
++}
++
++void pa_mute_control_mute_changed(pa_mute_control *control, bool new_mute) {
++    pa_assert(control);
++
++    if (!control->linked)
++        return;
++
++    if (control->set_mute_in_progress)
++        return;
++
++    set_mute_internal(control, new_mute);
++}
++
++void pa_mute_control_add_device(pa_mute_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_put(control->devices, device, device) >= 0);
++}
++
++void pa_mute_control_remove_device(pa_mute_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_remove(control->devices, device));
++}
++
++void pa_mute_control_add_default_for_device(pa_mute_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_put(control->default_for_devices, device, device) >= 0);
++}
++
++void pa_mute_control_remove_default_for_device(pa_mute_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_remove(control->default_for_devices, device));
++}
++
++void pa_mute_control_add_stream(pa_mute_control *control, pas_stream *stream) {
++    pa_assert(control);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_put(control->streams, stream, stream) >= 0);
++}
++
++void pa_mute_control_remove_stream(pa_mute_control *control, pas_stream *stream) {
++    pa_assert(control);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_remove(control->streams, stream));
++}
++
++void pa_mute_control_add_audio_group(pa_mute_control *control, pa_audio_group *group) {
++    pa_assert(control);
++    pa_assert(group);
++
++    pa_assert_se(pa_hashmap_put(control->audio_groups, group, group) >= 0);
++}
++
++void pa_mute_control_remove_audio_group(pa_mute_control *control, pa_audio_group *group) {
++    pa_assert(control);
++    pa_assert(group);
++
++    pa_assert_se(pa_hashmap_remove(control->audio_groups, group));
++}
+diff --git a/src/modules/volume-api/mute-control.h b/src/modules/volume-api/mute-control.h
+new file mode 100644
+index 0000000..1f70a43
+--- /dev/null
++++ b/src/modules/volume-api/mute-control.h
+@@ -0,0 +1,102 @@
++#ifndef foomutecontrolhfoo
++#define foomutecontrolhfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/volume-api.h>
++
++typedef struct pa_mute_control pa_mute_control;
++
++struct pa_mute_control {
++    pa_volume_api *volume_api;
++    uint32_t index;
++    const char *name;
++    char *description;
++    pa_proplist *proplist;
++    bool mute;
++
++    /* If this mute control is the "own mute control" of an audio group, this
++     * is set to point to that group, otherwise this is NULL. */
++    pa_audio_group *owner_audio_group;
++
++    pa_hashmap *devices; /* pa_device -> pa_device (hashmap-as-a-set) */
++    pa_hashmap *default_for_devices; /* pa_device -> pa_device (hashmap-as-a-set) */
++    pa_hashmap *streams; /* pas_stream -> pas_stream (hashmap-as-a-set) */
++    pa_hashmap *audio_groups; /* pa_audio_group -> pa_audio_group (hashmap-as-a-set) */
++
++    bool linked;
++    bool unlinked;
++    bool set_mute_in_progress;
++
++    /* Called from pa_mute_control_set_mute(). The implementation is expected
++     * to return a negative error code on failure. May be NULL, if the mute
++     * control is read-only. */
++    int (*set_mute)(pa_mute_control *control, bool mute);
++
++    void *userdata;
++};
++
++pa_mute_control *pa_mute_control_new(pa_volume_api *api, const char *name, const char *description);
++
++typedef void (*pa_mute_control_set_initial_mute_cb_t)(pa_mute_control *control);
++
++/* initial_mute is the preferred initial mute of the mute control
++ * implementation. It may be unset, if the implementation doesn't care about
++ * the initial state of the mute control. Read-only mute controls, however,
++ * must always set initial_mute.
++ *
++ * The implementation's initial mute preference may be overridden by policy, if
++ * the mute control isn't read-only. When the final initial mute is known, the
++ * the implementation is notified via set_initial_mute_cb (the mute can be read
++ * from control->mute). set_initial_mute_cb may be NULL, if the mute control is
++ * read-only. */
++void pa_mute_control_put(pa_mute_control *control, bool initial_mute, bool initial_mute_is_set,
++                         pa_mute_control_set_initial_mute_cb_t set_initial_mute_cb);
++
++void pa_mute_control_unlink(pa_mute_control *control);
++void pa_mute_control_free(pa_mute_control *control);
++
++/* Called by audio-group.c only. */
++void pa_mute_control_set_owner_audio_group(pa_mute_control *control, pa_audio_group *group);
++
++/* Called by clients and policy modules. */
++int pa_mute_control_set_mute(pa_mute_control *control, bool mute);
++
++/* Called by the mute control implementation. */
++void pa_mute_control_description_changed(pa_mute_control *control, const char *new_description);
++void pa_mute_control_mute_changed(pa_mute_control *control, bool new_mute);
++
++/* Called from device.c only. */
++void pa_mute_control_add_device(pa_mute_control *control, pa_device *device);
++void pa_mute_control_remove_device(pa_mute_control *control, pa_device *device);
++void pa_mute_control_add_default_for_device(pa_mute_control *control, pa_device *device);
++void pa_mute_control_remove_default_for_device(pa_mute_control *control, pa_device *device);
++
++/* Called from sstream.c only. */
++void pa_mute_control_add_stream(pa_mute_control *control, pas_stream *stream);
++void pa_mute_control_remove_stream(pa_mute_control *control, pas_stream *stream);
++
++/* Called from audio-group.c only. */
++void pa_mute_control_add_audio_group(pa_mute_control *control, pa_audio_group *group);
++void pa_mute_control_remove_audio_group(pa_mute_control *control, pa_audio_group *group);
++
++#endif
+diff --git a/src/modules/volume-api/sstream.c b/src/modules/volume-api/sstream.c
+new file mode 100644
+index 0000000..e3531a8
+--- /dev/null
++++ b/src/modules/volume-api/sstream.c
+@@ -0,0 +1,366 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "sstream.h"
++
++#include <modules/volume-api/audio-group.h>
++#include <modules/volume-api/binding.h>
++#include <modules/volume-api/mute-control.h>
++#include <modules/volume-api/volume-control.h>
++
++#include <pulse/direction.h>
++
++#include <pulsecore/core-util.h>
++
++pas_stream *pas_stream_new(pa_volume_api *api, const char *name, const char *description, pa_direction_t direction) {
++    pas_stream *stream;
++
++    pa_assert(api);
++    pa_assert(name);
++    pa_assert(description);
++
++    stream = pa_xnew0(pas_stream, 1);
++    stream->volume_api = api;
++    stream->index = pa_volume_api_allocate_stream_index(api);
++    pa_assert_se(pa_volume_api_register_name(api, name, false, &stream->name) >= 0);
++    stream->description = pa_xstrdup(description);
++    stream->direction = direction;
++    stream->proplist = pa_proplist_new();
++    stream->use_default_volume_control = true;
++    stream->use_default_mute_control = true;
++
++    return stream;
++}
++
++static void set_volume_control_internal(pas_stream *stream, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(stream);
++
++    old_control = stream->volume_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control) {
++        /* If the old control pointed to the own volume control of an audio
++         * group, then the stream's audio group for volume needs to be
++         * updated. We set it to NULL here, and if it should be non-NULL, that
++         * will be fixed very soon (a few lines down). */
++        pas_stream_set_audio_group_for_volume(stream, NULL);
++
++        pa_volume_control_remove_stream(old_control, stream);
++    }
++
++    stream->volume_control = control;
++
++    if (control) {
++        pa_volume_control_add_stream(control, stream);
++        pas_stream_set_audio_group_for_volume(stream, control->owner_audio_group);
++    }
++
++    if (!stream->linked || stream->unlinked)
++        return;
++
++    pa_log_debug("The volume control of stream %s changed from %s to %s.", stream->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_VOLUME_CONTROL_CHANGED], stream);
++}
++
++static void set_mute_control_internal(pas_stream *stream, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(stream);
++
++    old_control = stream->mute_control;
++
++    if (control == old_control)
++        return;
++
++    if (old_control) {
++        /* If the old control pointed to the own mute control of an audio
++         * group, then the stream's audio group for mute needs to be updated.
++         * We set it to NULL here, and if it should be non-NULL, that will be
++         * fixed very soon (a few lines down). */
++        pas_stream_set_audio_group_for_mute(stream, NULL);
++
++        pa_mute_control_remove_stream(old_control, stream);
++    }
++
++    stream->mute_control = control;
++
++    if (control) {
++        pa_mute_control_add_stream(control, stream);
++        pas_stream_set_audio_group_for_mute(stream, control->owner_audio_group);
++    }
++
++    if (!stream->linked || stream->unlinked)
++        return;
++
++    pa_log_debug("The mute control of stream %s changed from %s to %s.", stream->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_MUTE_CONTROL_CHANGED], stream);
++}
++
++void pas_stream_put(pas_stream *stream, pa_proplist *initial_properties) {
++    const char *prop_key;
++    void *state = NULL;
++
++    pa_assert(stream);
++    pa_assert(!stream->create_own_volume_control || stream->delete_own_volume_control);
++    pa_assert(!stream->create_own_mute_control || stream->delete_own_mute_control);
++
++    if (initial_properties)
++        pa_proplist_update(stream->proplist, PA_UPDATE_REPLACE, initial_properties);
++
++    pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_SET_INITIAL_VOLUME_CONTROL], stream);
++
++    if (stream->use_default_volume_control)
++        set_volume_control_internal(stream, stream->own_volume_control);
++
++    pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_SET_INITIAL_MUTE_CONTROL], stream);
++
++    if (stream->use_default_mute_control)
++        set_mute_control_internal(stream, stream->own_mute_control);
++
++    pa_volume_api_add_stream(stream->volume_api, stream);
++
++    stream->linked = true;
++
++    pa_log_debug("Created stream #%u.", stream->index);
++    pa_log_debug("    Name: %s", stream->name);
++    pa_log_debug("    Description: %s", stream->description);
++    pa_log_debug("    Direction: %s", pa_direction_to_string(stream->direction));
++    pa_log_debug("    Volume control: %s", stream->volume_control ? stream->volume_control->name : "(unset)");
++    pa_log_debug("    Mute control: %s", stream->mute_control ? stream->mute_control->name : "(unset)");
++    pa_log_debug("    Properties:");
++
++    while ((prop_key = pa_proplist_iterate(stream->proplist, &state)))
++        pa_log_debug("        %s = %s", prop_key, pa_strnull(pa_proplist_gets(stream->proplist, prop_key)));
++
++    pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_PUT], stream);
++}
++
++void pas_stream_unlink(pas_stream *stream) {
++    pa_assert(stream);
++
++    if (stream->unlinked) {
++        pa_log_debug("Unlinking stream %s (already unlinked, this is a no-op).", stream->name);
++        return;
++    }
++
++    stream->unlinked = true;
++
++    pa_log_debug("Unlinking stream %s.", stream->name);
++
++    if (stream->linked)
++        pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_UNLINK], stream);
++
++    pa_volume_api_remove_stream(stream->volume_api, stream);
++
++    pas_stream_set_audio_group_for_mute(stream, NULL);
++    pas_stream_set_audio_group_for_volume(stream, NULL);
++    pas_stream_set_mute_control(stream, NULL);
++    pas_stream_set_volume_control(stream, NULL);
++    pas_stream_set_have_own_mute_control(stream, false);
++    pas_stream_set_have_own_volume_control(stream, false);
++}
++
++void pas_stream_free(pas_stream *stream) {
++    pa_assert(stream);
++
++    if (!stream->unlinked)
++        pas_stream_unlink(stream);
++
++    if (stream->proplist)
++        pa_proplist_free(stream->proplist);
++
++    pa_xfree(stream->description);
++
++    if (stream->name)
++        pa_volume_api_unregister_name(stream->volume_api, stream->name);
++
++    pa_xfree(stream);
++}
++
++int pas_stream_set_have_own_volume_control(pas_stream *stream, bool have) {
++    pa_assert(stream);
++
++    if (have == stream->have_own_volume_control)
++        return 0;
++
++    if (have) {
++        pa_assert(!stream->own_volume_control);
++
++        if (!stream->create_own_volume_control) {
++            pa_log_debug("Stream %s doesn't support own volume control.", stream->name);
++            return -PA_ERR_NOTSUPPORTED;
++        }
++
++        stream->own_volume_control = stream->create_own_volume_control(stream);
++    } else {
++        stream->delete_own_volume_control(stream);
++        stream->own_volume_control = NULL;
++    }
++
++    stream->have_own_volume_control = have;
++
++    return 0;
++}
++
++int pas_stream_set_have_own_mute_control(pas_stream *stream, bool have) {
++    pa_assert(stream);
++
++    if (have == stream->have_own_mute_control)
++        return 0;
++
++    if (have) {
++        pa_assert(!stream->own_mute_control);
++
++        if (!stream->create_own_mute_control) {
++            pa_log_debug("Stream %s doesn't support own mute control.", stream->name);
++            return -PA_ERR_NOTSUPPORTED;
++        }
++
++        stream->own_mute_control = stream->create_own_mute_control(stream);
++    } else {
++        stream->delete_own_mute_control(stream);
++        stream->own_mute_control = NULL;
++    }
++
++    stream->have_own_mute_control = have;
++
++    return 0;
++}
++
++void pas_stream_set_volume_control(pas_stream *stream, pa_volume_control *control) {
++    pa_assert(stream);
++
++    stream->use_default_volume_control = false;
++
++    if (stream->volume_control_binding) {
++        pa_binding_free(stream->volume_control_binding);
++        stream->volume_control_binding = NULL;
++    }
++
++    set_volume_control_internal(stream, control);
++}
++
++void pas_stream_set_mute_control(pas_stream *stream, pa_mute_control *control) {
++    pa_assert(stream);
++
++    stream->use_default_mute_control = false;
++
++    if (stream->mute_control_binding) {
++        pa_binding_free(stream->mute_control_binding);
++        stream->mute_control_binding = NULL;
++    }
++
++    set_mute_control_internal(stream, control);
++}
++
++void pas_stream_bind_volume_control(pas_stream *stream, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = stream,
++        .set_value = (pa_binding_set_value_cb_t) set_volume_control_internal,
++    };
++
++    pa_assert(stream);
++    pa_assert(target_info);
++
++    stream->use_default_volume_control = false;
++
++    if (stream->volume_control_binding)
++        pa_binding_free(stream->volume_control_binding);
++
++    stream->volume_control_binding = pa_binding_new(stream->volume_api, &owner_info, target_info);
++}
++
++void pas_stream_bind_mute_control(pas_stream *stream, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = stream,
++        .set_value = (pa_binding_set_value_cb_t) set_mute_control_internal,
++    };
++
++    pa_assert(stream);
++    pa_assert(target_info);
++
++    stream->use_default_mute_control = false;
++
++    if (stream->mute_control_binding)
++        pa_binding_free(stream->mute_control_binding);
++
++    stream->mute_control_binding = pa_binding_new(stream->volume_api, &owner_info, target_info);
++}
++
++void pas_stream_description_changed(pas_stream *stream, const char *new_description) {
++    char *old_description;
++
++    pa_assert(stream);
++    pa_assert(new_description);
++
++    old_description = stream->description;
++
++    if (pa_streq(new_description, old_description))
++        return;
++
++    stream->description = pa_xstrdup(new_description);
++    pa_log_debug("The description of stream %s changed from \"%s\" to \"%s\".", stream->name, old_description,
++                 new_description);
++    pa_xfree(old_description);
++    pa_hook_fire(&stream->volume_api->hooks[PA_VOLUME_API_HOOK_STREAM_DESCRIPTION_CHANGED], stream);
++}
++
++void pas_stream_set_audio_group_for_volume(pas_stream *stream, pa_audio_group *group) {
++    pa_assert(stream);
++
++    if (group == stream->audio_group_for_volume)
++        return;
++
++    if (stream->audio_group_for_volume)
++        pa_audio_group_remove_volume_stream(stream->audio_group_for_volume, stream);
++
++    stream->audio_group_for_volume = group;
++
++    if (group)
++        pa_audio_group_add_volume_stream(group, stream);
++}
++
++void pas_stream_set_audio_group_for_mute(pas_stream *stream, pa_audio_group *group) {
++    pa_assert(stream);
++
++    if (group == stream->audio_group_for_mute)
++        return;
++
++    if (stream->audio_group_for_mute)
++        pa_audio_group_remove_mute_stream(stream->audio_group_for_mute, stream);
++
++    stream->audio_group_for_mute = group;
++
++    if (group)
++        pa_audio_group_add_mute_stream(group, stream);
++}
+diff --git a/src/modules/volume-api/sstream.h b/src/modules/volume-api/sstream.h
+new file mode 100644
+index 0000000..a65b34c
+--- /dev/null
++++ b/src/modules/volume-api/sstream.h
+@@ -0,0 +1,108 @@
++#ifndef foosstreamhfoo
++#define foosstreamhfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/volume-api.h>
++
++/* We use the "pas_" prefix in pas_stream, because there's already pa_stream in
++ * the client API, and there's no good alternative term for streams. The 's' in
++ * "pas" means "server", i.e. the point is that this stuff is for servers,
++ * while pa_stream is for clients. */
++
++typedef struct pas_stream pas_stream;
++
++struct pas_stream {
++    pa_volume_api *volume_api;
++    uint32_t index;
++    const char *name;
++    char *description;
++    pa_direction_t direction;
++    pa_proplist *proplist;
++    pa_volume_control *volume_control;
++    pa_mute_control *mute_control;
++    bool use_default_volume_control;
++    bool use_default_mute_control;
++    bool have_own_volume_control;
++    bool have_own_mute_control;
++    pa_volume_control *own_volume_control;
++    pa_mute_control *own_mute_control;
++
++    pa_binding *volume_control_binding;
++    pa_binding *mute_control_binding;
++    pa_audio_group *audio_group_for_volume;
++    pa_audio_group *audio_group_for_mute;
++
++    bool linked;
++    bool unlinked;
++
++    /* Called when the own volume control is enabled. The callback
++     * implementation should return a new linked volume control object. The
++     * callback may be NULL, in which case the own volume control can't be
++     * enabled. */
++    pa_volume_control *(*create_own_volume_control)(pas_stream *stream);
++
++    /* Called when the own volume control is disabled. The implementation
++     * should free stream->own_volume_control. The callback may be NULL only if
++     * create_own_volume_control is NULL also. */
++    void (*delete_own_volume_control)(pas_stream *stream);
++
++    /* Called when the own mute control is enabled. The callback implementation
++     * should return a new linked mute control object. The callback may be
++     * NULL, in which case the own mute control can't be enabled. */
++    pa_mute_control *(*create_own_mute_control)(pas_stream *stream);
++
++    /* Called when the own mute control is disabled. The implementation should
++     * free stream->own_mute_control. The callback may be NULL only if
++     * create_own_mute_control is NULL also. */
++    void (*delete_own_mute_control)(pas_stream *stream);
++
++    void *userdata;
++};
++
++pas_stream *pas_stream_new(pa_volume_api *api, const char *name, const char *description, pa_direction_t direction);
++void pas_stream_put(pas_stream *stream, pa_proplist *initial_properties);
++void pas_stream_unlink(pas_stream *stream);
++void pas_stream_free(pas_stream *stream);
++
++/* Called by the stream implementation and possibly by policy modules.
++ * Enabling own controls may fail (the stream may not support own controls),
++ * disabling will never fail. */
++int pas_stream_set_have_own_volume_control(pas_stream *stream, bool have);
++int pas_stream_set_have_own_mute_control(pas_stream *stream, bool have);
++
++/* Called by policy modules. */
++void pas_stream_set_volume_control(pas_stream *stream, pa_volume_control *control);
++void pas_stream_set_mute_control(pas_stream *stream, pa_mute_control *control);
++void pas_stream_bind_volume_control(pas_stream *stream, pa_binding_target_info *target_info);
++void pas_stream_bind_mute_control(pas_stream *stream, pa_binding_target_info *target_info);
++
++/* Called by the stream implementation. */
++void pas_stream_description_changed(pas_stream *stream, const char *new_description);
++
++/* Called by audio-group.c only. Adding a stream to an audio group happens
++ * implicitly when the volume or mute control of a stream is set to point to
++ * the own control of an audio group. */
++void pas_stream_set_audio_group_for_volume(pas_stream *stream, pa_audio_group *group);
++void pas_stream_set_audio_group_for_mute(pas_stream *stream, pa_audio_group *group);
++
++#endif
+diff --git a/src/modules/volume-api/stream-creator.c b/src/modules/volume-api/stream-creator.c
+new file mode 100644
+index 0000000..2bd0053
+--- /dev/null
++++ b/src/modules/volume-api/stream-creator.c
+@@ -0,0 +1,691 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "stream-creator.h"
++
++#include <modules/volume-api/sstream.h>
++#include <modules/volume-api/mute-control.h>
++#include <modules/volume-api/volume-control.h>
++
++#include <pulsecore/core-util.h>
++#include <pulsecore/i18n.h>
++
++struct pa_stream_creator {
++    pa_volume_api *volume_api;
++    pa_hashmap *streams; /* pa_sink_input/pa_source_output -> struct stream */
++    pa_hook_slot *sink_input_put_slot;
++    pa_hook_slot *sink_input_unlink_slot;
++    pa_hook_slot *source_output_put_slot;
++    pa_hook_slot *source_output_unlink_slot;
++};
++
++enum stream_type {
++    STREAM_TYPE_SINK_INPUT,
++    STREAM_TYPE_SOURCE_OUTPUT,
++};
++
++struct stream {
++    pa_stream_creator *creator;
++    enum stream_type type;
++    pa_sink_input *sink_input;
++    pa_source_output *source_output;
++    pa_client *client;
++    pas_stream *stream;
++
++    bool unlinked;
++
++    pa_hook_slot *proplist_changed_slot;
++    pa_hook_slot *client_proplist_changed_slot;
++    pa_hook_slot *volume_changed_slot;
++    pa_hook_slot *mute_changed_slot;
++};
++
++static char *get_stream_volume_and_mute_control_description_malloc(struct stream *stream) {
++    const char *application_name = NULL;
++    char *description;
++
++    pa_assert(stream);
++
++    if (stream->client)
++        application_name = pa_proplist_gets(stream->client->proplist, PA_PROP_APPLICATION_NAME);
++
++    if (application_name)
++        description = pa_sprintf_malloc("%s: %s", application_name, stream->stream->description);
++    else
++        description = pa_xstrdup(stream->stream->description);
++
++    return description;
++}
++
++static int volume_control_set_volume_cb(pa_volume_control *control, const pa_bvolume *volume, bool set_volume, bool set_balance) {
++    struct stream *stream;
++    pa_bvolume bvolume;
++    pa_cvolume cvolume;
++
++    pa_assert(control);
++    pa_assert(volume);
++
++    stream = control->userdata;
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            pa_bvolume_from_cvolume(&bvolume, &stream->sink_input->volume, &stream->sink_input->channel_map);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            pa_bvolume_from_cvolume(&bvolume, &stream->source_output->volume, &stream->source_output->channel_map);
++            break;
++    }
++
++    if (set_volume)
++        bvolume.volume = volume->volume;
++
++    if (set_balance)
++        pa_bvolume_copy_balance(&bvolume, volume);
++
++    pa_bvolume_to_cvolume(&bvolume, &cvolume);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            pa_sink_input_set_volume(stream->sink_input, &cvolume, true, true);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            pa_source_output_set_volume(stream->source_output, &cvolume, true, true);
++            break;
++    }
++
++    return 0;
++}
++
++static pa_hook_result_t sink_input_or_source_output_volume_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct stream *stream = userdata;
++    pa_sink_input *input = NULL;
++    pa_source_output *output = NULL;
++    pa_bvolume bvolume;
++
++    pa_assert(stream);
++    pa_assert(call_data);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            input = call_data;
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            output = call_data;
++            break;
++    }
++
++    if ((input && input != stream->sink_input) || (output && output != stream->source_output))
++        return PA_HOOK_OK;
++
++    if (input)
++        pa_bvolume_from_cvolume(&bvolume, &input->volume, &input->channel_map);
++    else
++        pa_bvolume_from_cvolume(&bvolume, &output->volume, &output->channel_map);
++
++    pa_volume_control_volume_changed(stream->stream->own_volume_control, &bvolume, true, true);
++
++    return PA_HOOK_OK;
++}
++
++static void volume_control_set_initial_volume_cb(pa_volume_control *control) {
++    struct stream *stream;
++    pa_cvolume cvolume;
++
++    pa_assert(control);
++
++    stream = control->userdata;
++    pa_bvolume_to_cvolume(&control->volume, &cvolume);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            pa_sink_input_set_volume(stream->sink_input, &cvolume, true, true);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            pa_source_output_set_volume(stream->source_output, &cvolume, true, true);
++            break;
++    }
++}
++
++static int mute_control_set_mute_cb(pa_mute_control *control, bool mute) {
++    struct stream *stream;
++
++    pa_assert(control);
++
++    stream = control->userdata;
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            pa_sink_input_set_mute(stream->sink_input, mute, true);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            pa_source_output_set_mute(stream->source_output, mute, true);
++            break;
++    }
++
++    return 0;
++}
++
++static pa_hook_result_t sink_input_or_source_output_mute_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct stream *stream = userdata;
++    pa_sink_input *input = NULL;
++    pa_source_output *output = NULL;
++    bool mute;
++
++    pa_assert(stream);
++    pa_assert(call_data);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            input = call_data;
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            output = call_data;
++            break;
++    }
++
++    if ((input && input != stream->sink_input) || (output && output != stream->source_output))
++        return PA_HOOK_OK;
++
++    if (input)
++        mute = input->muted;
++    else
++        mute = output->muted;
++
++    pa_mute_control_mute_changed(stream->stream->own_mute_control, mute);
++
++    return PA_HOOK_OK;
++}
++
++static void mute_control_set_initial_mute_cb(pa_mute_control *control) {
++    struct stream *stream;
++
++    pa_assert(control);
++
++    stream = control->userdata;
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            pa_sink_input_set_mute(stream->sink_input, control->mute, true);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            pa_source_output_set_mute(stream->source_output, control->mute, true);
++            break;
++    }
++}
++
++static const char *get_sink_input_description(pa_sink_input *input) {
++    const char *description;
++
++    pa_assert(input);
++
++    description = pa_proplist_gets(input->proplist, PA_PROP_MEDIA_NAME);
++    if (description)
++        return description;
++
++    return NULL;
++}
++
++static const char *get_source_output_description(pa_source_output *output) {
++    const char *description;
++
++    pa_assert(output);
++
++    description = pa_proplist_gets(output->proplist, PA_PROP_MEDIA_NAME);
++    if (description)
++        return description;
++
++    return NULL;
++}
++
++static pa_volume_control *stream_create_own_volume_control_cb(pas_stream *s) {
++    struct stream *stream;
++    const char *name = NULL;
++    char *description;
++    pa_volume_control *control;
++    pa_bvolume volume;
++
++    pa_assert(s);
++
++    stream = s->userdata;
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            name = "sink-input-volume-control";
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            name = "source-output-volume-control";
++            break;
++    }
++
++    description = get_stream_volume_and_mute_control_description_malloc(stream);
++    control = pa_volume_control_new(stream->creator->volume_api, name, description, true, false);
++    pa_xfree(description);
++    control->set_volume = volume_control_set_volume_cb;
++    control->userdata = stream;
++
++    pa_assert(!stream->volume_changed_slot);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            stream->volume_changed_slot =
++                    pa_hook_connect(&stream->sink_input->core->hooks[PA_CORE_HOOK_SINK_INPUT_VOLUME_CHANGED], PA_HOOK_NORMAL,
++                                    sink_input_or_source_output_volume_changed_cb, stream);
++            pa_bvolume_from_cvolume(&volume, &stream->sink_input->volume, &stream->sink_input->channel_map);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            stream->volume_changed_slot =
++                    pa_hook_connect(&stream->source_output->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_VOLUME_CHANGED],
++                                    PA_HOOK_NORMAL, sink_input_or_source_output_volume_changed_cb, stream);
++            pa_bvolume_from_cvolume(&volume, &stream->source_output->volume, &stream->source_output->channel_map);
++            break;
++    }
++
++    pa_volume_control_put(control, &volume, volume_control_set_initial_volume_cb);
++
++    return control;
++}
++
++static void stream_delete_own_volume_control_cb(pas_stream *s) {
++    struct stream *stream;
++
++    pa_assert(s);
++
++    stream = s->userdata;
++    pa_hook_slot_free(stream->volume_changed_slot);
++    stream->volume_changed_slot = NULL;
++    pa_volume_control_free(s->own_volume_control);
++}
++
++static pa_mute_control *stream_create_own_mute_control_cb(pas_stream *s) {
++    struct stream *stream;
++    const char *name = NULL;
++    char *description;
++    pa_mute_control *control;
++    bool mute = false;
++
++    pa_assert(s);
++
++    stream = s->userdata;
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            name = "sink-input-mute-control";
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            name = "source-output-mute-control";
++            break;
++    }
++
++    description = get_stream_volume_and_mute_control_description_malloc(stream);
++    control = pa_mute_control_new(stream->creator->volume_api, name, description);
++    pa_xfree(description);
++    control->set_mute = mute_control_set_mute_cb;
++    control->userdata = stream;
++
++    pa_assert(!stream->mute_changed_slot);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            stream->mute_changed_slot =
++                    pa_hook_connect(&stream->sink_input->core->hooks[PA_CORE_HOOK_SINK_INPUT_MUTE_CHANGED], PA_HOOK_NORMAL,
++                                    sink_input_or_source_output_mute_changed_cb, stream);
++            mute = stream->sink_input->muted;
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            stream->mute_changed_slot =
++                    pa_hook_connect(&stream->source_output->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MUTE_CHANGED],
++                                    PA_HOOK_NORMAL, sink_input_or_source_output_mute_changed_cb, stream);
++            mute = stream->source_output->muted;
++            break;
++    }
++
++    pa_mute_control_put(control, mute, true, mute_control_set_initial_mute_cb);
++
++    return control;
++}
++
++static void stream_delete_own_mute_control_cb(pas_stream *s) {
++    struct stream *stream;
++
++    pa_assert(s);
++
++    stream = s->userdata;
++    pa_hook_slot_free(stream->mute_changed_slot);
++    stream->mute_changed_slot = NULL;
++    pa_mute_control_free(s->own_mute_control);
++}
++
++static pa_hook_result_t sink_input_or_source_output_proplist_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct stream *stream = userdata;
++    pa_sink_input *input = NULL;
++    pa_source_output *output = NULL;
++    const char *new_stream_description = NULL;
++    char *new_control_description;
++
++    pa_assert(stream);
++    pa_assert(call_data);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            input = call_data;
++
++            if (input != stream->sink_input)
++                return PA_HOOK_OK;
++
++            new_stream_description = get_sink_input_description(input);
++            if (!new_stream_description)
++                new_stream_description = stream->stream->name;
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            output = call_data;
++
++            if (output != stream->source_output)
++                return PA_HOOK_OK;
++
++            new_stream_description = get_source_output_description(output);
++            if (!new_stream_description)
++                new_stream_description = stream->stream->name;
++            break;
++    }
++
++    pas_stream_description_changed(stream->stream, new_stream_description);
++
++    new_control_description = get_stream_volume_and_mute_control_description_malloc(stream);
++
++    if (stream->stream->own_volume_control)
++        pa_volume_control_description_changed(stream->stream->own_volume_control, new_control_description);
++
++    if (stream->stream->own_mute_control)
++        pa_mute_control_description_changed(stream->stream->own_mute_control, new_control_description);
++
++    pa_xfree(new_control_description);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t client_proplist_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct stream *stream = userdata;
++    pa_client *client = call_data;
++    char *description;
++
++    pa_assert(stream);
++    pa_assert(client);
++
++    if (client != stream->client)
++        return PA_HOOK_OK;
++
++    description = get_stream_volume_and_mute_control_description_malloc(stream);
++
++    if (stream->stream->own_volume_control)
++        pa_volume_control_description_changed(stream->stream->own_volume_control, description);
++
++    if (stream->stream->own_mute_control)
++        pa_mute_control_description_changed(stream->stream->own_mute_control, description);
++
++    pa_xfree(description);
++
++    return PA_HOOK_OK;
++}
++
++static struct stream *stream_new(pa_stream_creator *creator, enum stream_type type, void *core_stream) {
++    struct stream *stream;
++    const char *name = NULL;
++    const char *description = NULL;
++    pa_direction_t direction = PA_DIRECTION_OUTPUT;
++
++    pa_assert(creator);
++    pa_assert(core_stream);
++
++    stream = pa_xnew0(struct stream, 1);
++    stream->creator = creator;
++    stream->type = type;
++
++    switch (type) {
++        case STREAM_TYPE_SINK_INPUT:
++            stream->sink_input = core_stream;
++            stream->client = stream->sink_input->client;
++            name = "sink-input-stream";
++
++            description = get_sink_input_description(stream->sink_input);
++            if (!description)
++                description = name;
++
++            direction = PA_DIRECTION_OUTPUT;
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            stream->source_output = core_stream;
++            stream->client = stream->source_output->client;
++            name = "source-output-stream";
++
++            description = get_source_output_description(stream->source_output);
++            if (!description)
++                description = name;
++
++            direction = PA_DIRECTION_INPUT;
++            break;
++    }
++
++    stream->stream = pas_stream_new(creator->volume_api, name, description, direction);
++    stream->stream->create_own_volume_control = stream_create_own_volume_control_cb;
++    stream->stream->delete_own_volume_control = stream_delete_own_volume_control_cb;
++    stream->stream->create_own_mute_control = stream_create_own_mute_control_cb;
++    stream->stream->delete_own_mute_control = stream_delete_own_mute_control_cb;
++    stream->stream->userdata = stream;
++    pas_stream_set_have_own_volume_control(stream->stream, true);
++    pas_stream_set_have_own_mute_control(stream->stream, true);
++
++    switch (type) {
++        case STREAM_TYPE_SINK_INPUT:
++            stream->proplist_changed_slot =
++                    pa_hook_connect(&stream->sink_input->core->hooks[PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED], PA_HOOK_NORMAL,
++                                    sink_input_or_source_output_proplist_changed_cb, stream);
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            stream->proplist_changed_slot =
++                    pa_hook_connect(&stream->source_output->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_PROPLIST_CHANGED],
++                                    PA_HOOK_NORMAL, sink_input_or_source_output_proplist_changed_cb, stream);
++            break;
++    }
++
++    stream->client_proplist_changed_slot =
++            pa_hook_connect(&stream->creator->volume_api->core->hooks[PA_CORE_HOOK_CLIENT_PROPLIST_CHANGED],
++                            PA_HOOK_NORMAL, client_proplist_changed_cb, stream);
++
++    return stream;
++}
++
++static void stream_put(struct stream *stream) {
++    pa_proplist *proplist = NULL;
++
++    pa_assert(stream);
++
++    switch (stream->type) {
++        case STREAM_TYPE_SINK_INPUT:
++            proplist = stream->sink_input->proplist;
++            break;
++
++        case STREAM_TYPE_SOURCE_OUTPUT:
++            proplist = stream->source_output->proplist;
++            break;
++    }
++
++    pas_stream_put(stream->stream, proplist);
++}
++
++static void stream_unlink(struct stream *stream) {
++    pa_assert(stream);
++
++    if (stream->unlinked)
++        return;
++
++    stream->unlinked = true;
++
++    if (stream->stream)
++        pas_stream_unlink(stream->stream);
++}
++
++static void stream_free(struct stream *stream) {
++    pa_assert(stream);
++
++    if (!stream->unlinked)
++        stream_unlink(stream);
++
++    if (stream->client_proplist_changed_slot)
++        pa_hook_slot_free(stream->client_proplist_changed_slot);
++
++    if (stream->proplist_changed_slot)
++        pa_hook_slot_free(stream->proplist_changed_slot);
++
++    if (stream->stream)
++        pas_stream_free(stream->stream);
++
++    pa_xfree(stream);
++}
++
++static void create_stream(pa_stream_creator *creator, enum stream_type type, void *core_stream) {
++    struct stream *stream;
++
++    pa_assert(creator);
++    pa_assert(core_stream);
++
++    stream = stream_new(creator, type, core_stream);
++    pa_hashmap_put(creator->streams, core_stream, stream);
++    stream_put(stream);
++}
++
++static pa_hook_result_t sink_input_put_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_stream_creator *creator = userdata;
++    pa_sink_input *input = call_data;
++
++    pa_assert(creator);
++    pa_assert(input);
++
++    create_stream(creator, STREAM_TYPE_SINK_INPUT, input);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t sink_input_unlink_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_stream_creator *creator = userdata;
++    pa_sink_input *input = call_data;
++
++    pa_assert(creator);
++    pa_assert(input);
++
++    pa_hashmap_remove_and_free(creator->streams, input);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t source_output_put_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_stream_creator *creator = userdata;
++    pa_source_output *output = call_data;
++
++    pa_assert(creator);
++    pa_assert(output);
++
++    create_stream(creator, STREAM_TYPE_SOURCE_OUTPUT, output);
++
++    return PA_HOOK_OK;
++}
++
++static pa_hook_result_t source_output_unlink_cb(void *hook_data, void *call_data, void *userdata) {
++    pa_stream_creator *creator = userdata;
++    pa_source_output *output = call_data;
++
++    pa_assert(creator);
++    pa_assert(output);
++
++    pa_hashmap_remove_and_free(creator->streams, output);
++
++    return PA_HOOK_OK;
++}
++
++pa_stream_creator *pa_stream_creator_new(pa_volume_api *api) {
++    pa_stream_creator *creator;
++    uint32_t idx;
++    pa_sink_input *input;
++    pa_source_output *output;
++
++    pa_assert(api);
++
++    creator = pa_xnew0(pa_stream_creator, 1);
++    creator->volume_api = api;
++    creator->streams = pa_hashmap_new_full(NULL, NULL, NULL, (pa_free_cb_t) stream_free);
++    creator->sink_input_put_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SINK_INPUT_PUT], PA_HOOK_NORMAL,
++                                                   sink_input_put_cb, creator);
++    creator->sink_input_unlink_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK], PA_HOOK_NORMAL,
++                                                      sink_input_unlink_cb, creator);
++    creator->source_output_put_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_PUT], PA_HOOK_NORMAL,
++                                                      source_output_put_cb, creator);
++    creator->source_output_unlink_slot = pa_hook_connect(&api->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK], PA_HOOK_NORMAL,
++                                                         source_output_unlink_cb, creator);
++
++    PA_IDXSET_FOREACH(input, api->core->sink_inputs, idx)
++        create_stream(creator, STREAM_TYPE_SINK_INPUT, input);
++
++    PA_IDXSET_FOREACH(output, api->core->source_outputs, idx)
++        create_stream(creator, STREAM_TYPE_SOURCE_OUTPUT, output);
++
++    return creator;
++}
++
++void pa_stream_creator_free(pa_stream_creator *creator) {
++    pa_assert(creator);
++
++    if (creator->streams)
++        pa_hashmap_remove_all(creator->streams);
++
++    if (creator->source_output_unlink_slot)
++        pa_hook_slot_free(creator->source_output_unlink_slot);
++
++    if (creator->source_output_put_slot)
++        pa_hook_slot_free(creator->source_output_put_slot);
++
++    if (creator->sink_input_unlink_slot)
++        pa_hook_slot_free(creator->sink_input_unlink_slot);
++
++    if (creator->sink_input_put_slot)
++        pa_hook_slot_free(creator->sink_input_put_slot);
++
++    if (creator->streams)
++        pa_hashmap_free(creator->streams);
++
++    pa_xfree(creator);
++}
+diff --git a/src/modules/volume-api/stream-creator.h b/src/modules/volume-api/stream-creator.h
+new file mode 100644
+index 0000000..97a03a4
+--- /dev/null
++++ b/src/modules/volume-api/stream-creator.h
+@@ -0,0 +1,32 @@
++#ifndef foostreamcreatorhfoo
++#define foostreamcreatorhfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/volume-api.h>
++
++typedef struct pa_stream_creator pa_stream_creator;
++
++pa_stream_creator *pa_stream_creator_new(pa_volume_api *api);
++void pa_stream_creator_free(pa_stream_creator *creator);
++
++#endif
+diff --git a/src/modules/volume-api/volume-api.c b/src/modules/volume-api/volume-api.c
+new file mode 100644
+index 0000000..9abea7e
+--- /dev/null
++++ b/src/modules/volume-api/volume-api.c
+@@ -0,0 +1,647 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "volume-api.h"
++
++#include <modules/volume-api/audio-group.h>
++#include <modules/volume-api/binding.h>
++#include <modules/volume-api/device.h>
++#include <modules/volume-api/device-creator.h>
++#include <modules/volume-api/sstream.h>
++#include <modules/volume-api/stream-creator.h>
++#include <modules/volume-api/volume-control.h>
++
++#include <pulsecore/core-util.h>
++#include <pulsecore/shared.h>
++
++static pa_volume_api *volume_api_new(pa_core *core);
++static void volume_api_free(pa_volume_api *api);
++
++pa_volume_api *pa_volume_api_get(pa_core *core) {
++    pa_volume_api *api;
++
++    pa_assert(core);
++
++    api = pa_shared_get(core, "volume-api");
++
++    if (api)
++        pa_volume_api_ref(api);
++    else {
++        api = volume_api_new(core);
++        pa_assert_se(pa_shared_set(core, "volume-api", api) >= 0);
++    }
++
++    return api;
++}
++
++pa_volume_api *pa_volume_api_ref(pa_volume_api *api) {
++    pa_assert(api);
++
++    api->refcnt++;
++
++    return api;
++}
++
++void pa_volume_api_unref(pa_volume_api *api) {
++    pa_assert(api);
++    pa_assert(api->refcnt > 0);
++
++    api->refcnt--;
++
++    if (api->refcnt == 0) {
++        pa_assert_se(pa_shared_remove(api->core, "volume-api") >= 0);
++        volume_api_free(api);
++    }
++}
++
++void pa_volume_api_add_binding_target_type(pa_volume_api *api, pa_binding_target_type *type) {
++    pa_assert(api);
++    pa_assert(type);
++
++    pa_assert_se(pa_hashmap_put(api->binding_target_types, type->name, type) >= 0);
++
++    pa_log_debug("Added binding target type %s.", type->name);
++
++    pa_hook_fire(&api->hooks[PA_VOLUME_API_HOOK_BINDING_TARGET_TYPE_ADDED], type);
++}
++
++void pa_volume_api_remove_binding_target_type(pa_volume_api *api, pa_binding_target_type *type) {
++    pa_assert(api);
++    pa_assert(type);
++
++    pa_log_debug("Removing binding target type %s.", type->name);
++
++    pa_hook_fire(&api->hooks[PA_VOLUME_API_HOOK_BINDING_TARGET_TYPE_REMOVED], type);
++
++    pa_assert_se(pa_hashmap_remove(api->binding_target_types, type->name));
++}
++
++static void create_builtin_binding_target_types(pa_volume_api *api) {
++    pa_binding_target_type *type;
++
++    pa_assert(api);
++
++    type = pa_audio_group_create_binding_target_type(api);
++    pa_volume_api_add_binding_target_type(api, type);
++}
++
++static void delete_builtin_binding_target_types(pa_volume_api *api) {
++    pa_binding_target_type *type;
++
++    pa_assert(api);
++
++    type = pa_hashmap_get(api->binding_target_types, PA_AUDIO_GROUP_BINDING_TARGET_TYPE);
++    pa_volume_api_remove_binding_target_type(api, type);
++}
++
++static void create_objects_defer_event_cb(pa_mainloop_api *mainloop_api, pa_defer_event *event, void *userdata) {
++    pa_volume_api *volume_api = userdata;
++
++    pa_assert(volume_api);
++    pa_assert(event == volume_api->create_objects_defer_event);
++
++    mainloop_api->defer_free(event);
++    volume_api->create_objects_defer_event = NULL;
++
++    volume_api->device_creator = pa_device_creator_new(volume_api);
++    volume_api->stream_creator = pa_stream_creator_new(volume_api);
++}
++
++static pa_volume_api *volume_api_new(pa_core *core) {
++    pa_volume_api *api;
++    unsigned i;
++
++    pa_assert(core);
++
++    api = pa_xnew0(pa_volume_api, 1);
++    api->core = core;
++    api->refcnt = 1;
++    api->binding_target_types = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++    api->names = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, pa_xfree);
++    api->volume_controls = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++    api->mute_controls = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++    api->devices = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++    api->streams = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++    api->audio_groups = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++
++    for (i = 0; i < PA_VOLUME_API_HOOK_MAX; i++)
++        pa_hook_init(&api->hooks[i], api);
++
++    create_builtin_binding_target_types(api);
++
++    /* We delay the object creation to ensure that policy modules have a chance
++     * to affect the initialization of the objects. If we created the objects
++     * immediately, policy modules wouldn't have a chance of connecting to the
++     * object creation hooks before the objects are created. */
++    api->create_objects_defer_event = core->mainloop->defer_new(core->mainloop, create_objects_defer_event_cb, api);
++
++    pa_log_debug("Created a pa_volume_api object.");
++
++    return api;
++}
++
++static void volume_api_free(pa_volume_api *api) {
++    unsigned i;
++
++    pa_assert(api);
++    pa_assert(api->refcnt == 0);
++
++    pa_log_debug("Freeing the pa_volume_api object.");
++
++    if (api->stream_creator)
++        pa_stream_creator_free(api->stream_creator);
++
++    if (api->device_creator)
++        pa_device_creator_free(api->device_creator);
++
++    if (api->create_objects_defer_event)
++        api->core->mainloop->defer_free(api->create_objects_defer_event);
++
++    if (api->binding_target_types)
++        delete_builtin_binding_target_types(api);
++
++    for (i = 0; i < PA_VOLUME_API_HOOK_MAX; i++)
++        pa_hook_done(&api->hooks[i]);
++
++    if (api->audio_groups) {
++        pa_assert(pa_hashmap_isempty(api->audio_groups));
++        pa_hashmap_free(api->audio_groups);
++    }
++
++    if (api->streams) {
++        pa_assert(pa_hashmap_isempty(api->streams));
++        pa_hashmap_free(api->streams);
++    }
++
++    if (api->devices) {
++        pa_assert(pa_hashmap_isempty(api->devices));
++        pa_hashmap_free(api->devices);
++    }
++
++    if (api->mute_controls) {
++        pa_assert(pa_hashmap_isempty(api->mute_controls));
++        pa_hashmap_free(api->mute_controls);
++    }
++
++    if (api->volume_controls) {
++        pa_assert(pa_hashmap_isempty(api->volume_controls));
++        pa_hashmap_free(api->volume_controls);
++    }
++
++    if (api->names) {
++        pa_assert(pa_hashmap_isempty(api->names));
++        pa_hashmap_free(api->names);
++    }
++
++    if (api->binding_target_types) {
++        pa_assert(pa_hashmap_isempty(api->binding_target_types));
++        pa_hashmap_free(api->binding_target_types);
++    }
++
++    pa_xfree(api);
++}
++
++int pa_volume_api_register_name(pa_volume_api *api, const char *requested_name, bool fail_if_already_registered,
++                                const char **registered_name) {
++    char *n;
++
++    pa_assert(api);
++    pa_assert(requested_name);
++    pa_assert(registered_name);
++
++    n = pa_xstrdup(requested_name);
++
++    if (pa_hashmap_put(api->names, n, n) < 0) {
++        unsigned i = 1;
++
++        pa_xfree(n);
++
++        if (fail_if_already_registered) {
++            pa_log("Name %s already registered.", requested_name);
++            return -PA_ERR_EXIST;
++        }
++
++        do {
++            i++;
++            n = pa_sprintf_malloc("%s.%u", requested_name, i);
++        } while (pa_hashmap_put(api->names, n, n) < 0);
++    }
++
++    *registered_name = n;
++
++    return 0;
++}
++
++void pa_volume_api_unregister_name(pa_volume_api *api, const char *name) {
++    pa_assert(api);
++    pa_assert(name);
++
++    pa_assert_se(pa_hashmap_remove_and_free(api->names, name) >= 0);
++}
++
++uint32_t pa_volume_api_allocate_volume_control_index(pa_volume_api *api) {
++    uint32_t idx;
++
++    pa_assert(api);
++
++    idx = api->next_volume_control_index++;
++
++    return idx;
++}
++
++static void set_main_output_volume_control_internal(pa_volume_api *api, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(api);
++
++    old_control = api->main_output_volume_control;
++
++    if (control == old_control)
++        return;
++
++    api->main_output_volume_control = control;
++    pa_log_debug("Main output volume control changed from %s to %s.", old_control ? old_control->name : "(unset)",
++                 control ? control->name : "(unset)");
++    pa_hook_fire(&api->hooks[PA_VOLUME_API_HOOK_MAIN_OUTPUT_VOLUME_CONTROL_CHANGED], api);
++}
++
++static void set_main_input_volume_control_internal(pa_volume_api *api, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(api);
++
++    old_control = api->main_input_volume_control;
++
++    if (control == old_control)
++        return;
++
++    api->main_input_volume_control = control;
++    pa_log_debug("Main input volume control changed from %s to %s.", old_control ? old_control->name : "(unset)",
++                 control ? control->name : "(unset)");
++    pa_hook_fire(&api->hooks[PA_VOLUME_API_HOOK_MAIN_INPUT_VOLUME_CONTROL_CHANGED], api);
++}
++
++void pa_volume_api_add_volume_control(pa_volume_api *api, pa_volume_control *control) {
++    pa_assert(api);
++    pa_assert(control);
++
++    pa_assert_se(pa_hashmap_put(api->volume_controls, (void *) control->name, control) >= 0);
++}
++
++int pa_volume_api_remove_volume_control(pa_volume_api *api, pa_volume_control *control) {
++    pa_assert(api);
++    pa_assert(control);
++
++    if (!pa_hashmap_remove(api->volume_controls, control->name))
++        return -1;
++
++    if (control == api->main_output_volume_control)
++        set_main_output_volume_control_internal(api, NULL);
++
++    if (control == api->main_input_volume_control)
++        set_main_input_volume_control_internal(api, NULL);
++
++    return 0;
++}
++
++pa_volume_control *pa_volume_api_get_volume_control_by_index(pa_volume_api *api, uint32_t idx) {
++    pa_volume_control *control;
++    void *state;
++
++    pa_assert(api);
++
++    PA_HASHMAP_FOREACH(control, api->volume_controls, state) {
++        if (control->index == idx)
++            return control;
++    }
++
++    return NULL;
++}
++
++uint32_t pa_volume_api_allocate_mute_control_index(pa_volume_api *api) {
++    uint32_t idx;
++
++    pa_assert(api);
++
++    idx = api->next_mute_control_index++;
++
++    return idx;
++}
++
++static void set_main_output_mute_control_internal(pa_volume_api *api, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(api);
++
++    old_control = api->main_output_mute_control;
++
++    if (control == old_control)
++        return;
++
++    api->main_output_mute_control = control;
++    pa_log_debug("Main output mute control changed from %s to %s.", old_control ? old_control->name : "(unset)",
++                 control ? control->name : "(unset)");
++    pa_hook_fire(&api->hooks[PA_VOLUME_API_HOOK_MAIN_OUTPUT_MUTE_CONTROL_CHANGED], api);
++}
++
++static void set_main_input_mute_control_internal(pa_volume_api *api, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(api);
++
++    old_control = api->main_input_mute_control;
++
++    if (control == old_control)
++        return;
++
++    api->main_input_mute_control = control;
++    pa_log_debug("Main input mute control changed from %s to %s.", old_control ? old_control->name : "(unset)",
++                 control ? control->name : "(unset)");
++    pa_hook_fire(&api->hooks[PA_VOLUME_API_HOOK_MAIN_INPUT_MUTE_CONTROL_CHANGED], api);
++}
++
++void pa_volume_api_add_mute_control(pa_volume_api *api, pa_mute_control *control) {
++    pa_assert(api);
++    pa_assert(control);
++
++    pa_assert_se(pa_hashmap_put(api->mute_controls, (void *) control->name, control) >= 0);
++}
++
++int pa_volume_api_remove_mute_control(pa_volume_api *api, pa_mute_control *control) {
++    pa_assert(api);
++    pa_assert(control);
++
++    if (!pa_hashmap_remove(api->mute_controls, control->name))
++        return -1;
++
++    if (control == api->main_output_mute_control)
++        set_main_output_mute_control_internal(api, NULL);
++
++    if (control == api->main_input_mute_control)
++        set_main_input_mute_control_internal(api, NULL);
++
++    return 0;
++}
++
++pa_mute_control *pa_volume_api_get_mute_control_by_index(pa_volume_api *api, uint32_t idx) {
++    pa_mute_control *control;
++    void *state;
++
++    pa_assert(api);
++
++    PA_HASHMAP_FOREACH(control, api->mute_controls, state) {
++        if (control->index == idx)
++            return control;
++    }
++
++    return NULL;
++}
++
++uint32_t pa_volume_api_allocate_device_index(pa_volume_api *api) {
++    uint32_t idx;
++
++    pa_assert(api);
++
++    idx = api->next_device_index++;
++
++    return idx;
++}
++
++void pa_volume_api_add_device(pa_volume_api *api, pa_device *device) {
++    pa_assert(api);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_put(api->devices, (void *) device->name, device) >= 0);
++}
++
++int pa_volume_api_remove_device(pa_volume_api *api, pa_device *device) {
++    pa_assert(api);
++    pa_assert(device);
++
++    if (!pa_hashmap_remove(api->devices, device->name))
++        return -1;
++
++    return 0;
++}
++
++pa_device *pa_volume_api_get_device_by_index(pa_volume_api *api, uint32_t idx) {
++    pa_device *device;
++    void *state;
++
++    pa_assert(api);
++
++    PA_HASHMAP_FOREACH(device, api->devices, state) {
++        if (device->index == idx)
++            return device;
++    }
++
++    return NULL;
++}
++
++uint32_t pa_volume_api_allocate_stream_index(pa_volume_api *api) {
++    uint32_t idx;
++
++    pa_assert(api);
++
++    idx = api->next_stream_index++;
++
++    return idx;
++}
++
++void pa_volume_api_add_stream(pa_volume_api *api, pas_stream *stream) {
++    pa_assert(api);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_put(api->streams, (void *) stream->name, stream) >= 0);
++}
++
++int pa_volume_api_remove_stream(pa_volume_api *api, pas_stream *stream) {
++    pa_assert(api);
++    pa_assert(stream);
++
++    if (!pa_hashmap_remove(api->streams, stream->name))
++        return -1;
++
++    return 0;
++}
++
++pas_stream *pa_volume_api_get_stream_by_index(pa_volume_api *api, uint32_t idx) {
++    pas_stream *stream;
++    void *state;
++
++    pa_assert(api);
++
++    PA_HASHMAP_FOREACH(stream, api->streams, state) {
++        if (stream->index == idx)
++            return stream;
++    }
++
++    return NULL;
++}
++
++uint32_t pa_volume_api_allocate_audio_group_index(pa_volume_api *api) {
++    uint32_t idx;
++
++    pa_assert(api);
++
++    idx = api->next_audio_group_index++;
++
++    return idx;
++}
++
++void pa_volume_api_add_audio_group(pa_volume_api *api, pa_audio_group *group) {
++    pa_assert(api);
++    pa_assert(group);
++
++    pa_assert_se(pa_hashmap_put(api->audio_groups, (void *) group->name, group) >= 0);
++}
++
++int pa_volume_api_remove_audio_group(pa_volume_api *api, pa_audio_group *group) {
++    pa_assert(api);
++    pa_assert(group);
++
++    if (!pa_hashmap_remove(api->audio_groups, group->name))
++        return -1;
++
++    return 0;
++}
++
++pa_audio_group *pa_volume_api_get_audio_group_by_index(pa_volume_api *api, uint32_t idx) {
++    pa_audio_group *group;
++    void *state;
++
++    pa_assert(api);
++
++    PA_HASHMAP_FOREACH(group, api->audio_groups, state) {
++        if (group->index == idx)
++            return group;
++    }
++
++    return NULL;
++}
++
++void pa_volume_api_set_main_output_volume_control(pa_volume_api *api, pa_volume_control *control) {
++    pa_assert(api);
++
++    if (api->main_output_volume_control_binding) {
++        pa_binding_free(api->main_output_volume_control_binding);
++        api->main_output_volume_control_binding = NULL;
++    }
++
++    set_main_output_volume_control_internal(api, control);
++}
++
++void pa_volume_api_set_main_input_volume_control(pa_volume_api *api, pa_volume_control *control) {
++    pa_assert(api);
++
++    if (api->main_input_volume_control_binding) {
++        pa_binding_free(api->main_input_volume_control_binding);
++        api->main_input_volume_control_binding = NULL;
++    }
++
++    set_main_input_volume_control_internal(api, control);
++}
++
++void pa_volume_api_set_main_output_mute_control(pa_volume_api *api, pa_mute_control *control) {
++    pa_assert(api);
++
++    if (api->main_output_mute_control_binding) {
++        pa_binding_free(api->main_output_mute_control_binding);
++        api->main_output_mute_control_binding = NULL;
++    }
++
++    set_main_output_mute_control_internal(api, control);
++}
++
++void pa_volume_api_set_main_input_mute_control(pa_volume_api *api, pa_mute_control *control) {
++    pa_assert(api);
++
++    if (api->main_input_mute_control_binding) {
++        pa_binding_free(api->main_input_mute_control_binding);
++        api->main_input_mute_control_binding = NULL;
++    }
++
++    set_main_input_mute_control_internal(api, control);
++}
++
++void pa_volume_api_bind_main_output_volume_control(pa_volume_api *api, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = api,
++        .set_value = (pa_binding_set_value_cb_t) set_main_output_volume_control_internal,
++    };
++
++    pa_assert(api);
++    pa_assert(target_info);
++
++    if (api->main_output_volume_control_binding)
++        pa_binding_free(api->main_output_volume_control_binding);
++
++    api->main_output_volume_control_binding = pa_binding_new(api, &owner_info, target_info);
++}
++
++void pa_volume_api_bind_main_input_volume_control(pa_volume_api *api, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = api,
++        .set_value = (pa_binding_set_value_cb_t) set_main_input_volume_control_internal,
++    };
++
++    pa_assert(api);
++    pa_assert(target_info);
++
++    if (api->main_input_volume_control_binding)
++        pa_binding_free(api->main_input_volume_control_binding);
++
++    api->main_input_volume_control_binding = pa_binding_new(api, &owner_info, target_info);
++}
++
++void pa_volume_api_bind_main_output_mute_control(pa_volume_api *api, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = api,
++        .set_value = (pa_binding_set_value_cb_t) set_main_output_mute_control_internal,
++    };
++
++    pa_assert(api);
++    pa_assert(target_info);
++
++    if (api->main_output_mute_control_binding)
++        pa_binding_free(api->main_output_mute_control_binding);
++
++    api->main_output_mute_control_binding = pa_binding_new(api, &owner_info, target_info);
++}
++
++void pa_volume_api_bind_main_input_mute_control(pa_volume_api *api, pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = api,
++        .set_value = (pa_binding_set_value_cb_t) set_main_input_mute_control_internal,
++    };
++
++    pa_assert(api);
++    pa_assert(target_info);
++
++    if (api->main_input_mute_control_binding)
++        pa_binding_free(api->main_input_mute_control_binding);
++
++    api->main_input_mute_control_binding = pa_binding_new(api, &owner_info, target_info);
++}
+diff --git a/src/modules/volume-api/volume-api.h b/src/modules/volume-api/volume-api.h
+new file mode 100644
+index 0000000..73a1410
+--- /dev/null
++++ b/src/modules/volume-api/volume-api.h
+@@ -0,0 +1,163 @@
++#ifndef foovolumeapihfoo
++#define foovolumeapihfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <pulsecore/core.h>
++
++typedef struct pa_volume_api pa_volume_api;
++
++/* Avoid circular dependencies... */
++typedef struct pa_audio_group pa_audio_group;
++typedef struct pa_binding pa_binding;
++typedef struct pa_binding_target_info pa_binding_target_info;
++typedef struct pa_binding_target_type pa_binding_target_type;
++typedef struct pa_device pa_device;
++typedef struct pa_device_creator pa_device_creator;
++typedef struct pa_mute_control pa_mute_control;
++typedef struct pas_stream pas_stream;
++typedef struct pa_stream_creator pa_stream_creator;
++typedef struct pa_volume_control pa_volume_control;
++
++enum {
++    PA_VOLUME_API_HOOK_BINDING_TARGET_TYPE_ADDED,
++    PA_VOLUME_API_HOOK_BINDING_TARGET_TYPE_REMOVED,
++    PA_VOLUME_API_HOOK_VOLUME_CONTROL_PUT,
++    PA_VOLUME_API_HOOK_VOLUME_CONTROL_UNLINK,
++    PA_VOLUME_API_HOOK_VOLUME_CONTROL_DESCRIPTION_CHANGED,
++    PA_VOLUME_API_HOOK_VOLUME_CONTROL_VOLUME_CHANGED,
++    PA_VOLUME_API_HOOK_MUTE_CONTROL_PUT,
++    PA_VOLUME_API_HOOK_MUTE_CONTROL_UNLINK,
++    PA_VOLUME_API_HOOK_MUTE_CONTROL_DESCRIPTION_CHANGED,
++    PA_VOLUME_API_HOOK_MUTE_CONTROL_MUTE_CHANGED,
++    PA_VOLUME_API_HOOK_DEVICE_PUT,
++    PA_VOLUME_API_HOOK_DEVICE_UNLINK,
++    PA_VOLUME_API_HOOK_DEVICE_DESCRIPTION_CHANGED,
++    PA_VOLUME_API_HOOK_DEVICE_VOLUME_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_DEVICE_MUTE_CONTROL_CHANGED,
++
++    /* Policy modules can use this to set the initial volume control for a
++     * stream. The hook callback should use pas_stream_set_volume_control() to
++     * set the volume control. The hook callback should not do anything if
++     * stream->volume_control is already non-NULL. */
++    PA_VOLUME_API_HOOK_STREAM_SET_INITIAL_VOLUME_CONTROL,
++
++    /* Policy modules can use this to set the initial mute control for a
++     * stream. The hook callback should use pas_stream_set_mute_control() to
++     * set the mute control. The hook callback should not do anything if
++     * stream->mute_control is already non-NULL. */
++    PA_VOLUME_API_HOOK_STREAM_SET_INITIAL_MUTE_CONTROL,
++
++    PA_VOLUME_API_HOOK_STREAM_PUT,
++    PA_VOLUME_API_HOOK_STREAM_UNLINK,
++    PA_VOLUME_API_HOOK_STREAM_DESCRIPTION_CHANGED,
++    PA_VOLUME_API_HOOK_STREAM_VOLUME_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_STREAM_MUTE_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_AUDIO_GROUP_PUT,
++    PA_VOLUME_API_HOOK_AUDIO_GROUP_UNLINK,
++    PA_VOLUME_API_HOOK_AUDIO_GROUP_VOLUME_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_AUDIO_GROUP_MUTE_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_MAIN_OUTPUT_VOLUME_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_MAIN_INPUT_VOLUME_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_MAIN_OUTPUT_MUTE_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_MAIN_INPUT_MUTE_CONTROL_CHANGED,
++    PA_VOLUME_API_HOOK_MAX
++};
++
++struct pa_volume_api {
++    pa_core *core;
++    unsigned refcnt;
++    pa_hashmap *binding_target_types; /* name -> pa_binding_target_type */
++    pa_hashmap *names; /* object name -> object name (hashmap-as-a-set) */
++    pa_hashmap *volume_controls; /* name -> pa_volume_control */
++    pa_hashmap *mute_controls; /* name -> pa_mute_control */
++    pa_hashmap *devices; /* name -> pa_device */
++    pa_hashmap *streams; /* name -> pas_stream */
++    pa_hashmap *audio_groups; /* name -> pa_audio_group */
++    pa_volume_control *main_output_volume_control;
++    pa_volume_control *main_input_volume_control;
++    pa_mute_control *main_output_mute_control;
++    pa_mute_control *main_input_mute_control;
++
++    uint32_t next_volume_control_index;
++    uint32_t next_mute_control_index;
++    uint32_t next_device_index;
++    uint32_t next_stream_index;
++    uint32_t next_audio_group_index;
++    pa_binding *main_output_volume_control_binding;
++    pa_binding *main_input_volume_control_binding;
++    pa_binding *main_output_mute_control_binding;
++    pa_binding *main_input_mute_control_binding;
++    pa_hook hooks[PA_VOLUME_API_HOOK_MAX];
++    pa_defer_event *create_objects_defer_event;
++    pa_device_creator *device_creator;
++    pa_stream_creator *stream_creator;
++};
++
++pa_volume_api *pa_volume_api_get(pa_core *core);
++pa_volume_api *pa_volume_api_ref(pa_volume_api *api);
++void pa_volume_api_unref(pa_volume_api *api);
++
++void pa_volume_api_add_binding_target_type(pa_volume_api *api, pa_binding_target_type *type);
++void pa_volume_api_remove_binding_target_type(pa_volume_api *api, pa_binding_target_type *type);
++
++/* If fail_if_already_registered is false, this function never fails. */
++int pa_volume_api_register_name(pa_volume_api *api, const char *requested_name, bool fail_if_already_registered,
++                                const char **registered_name);
++
++void pa_volume_api_unregister_name(pa_volume_api *api, const char *name);
++
++uint32_t pa_volume_api_allocate_volume_control_index(pa_volume_api *api);
++void pa_volume_api_add_volume_control(pa_volume_api *api, pa_volume_control *control);
++int pa_volume_api_remove_volume_control(pa_volume_api *api, pa_volume_control *control);
++pa_volume_control *pa_volume_api_get_volume_control_by_index(pa_volume_api *api, uint32_t idx);
++
++uint32_t pa_volume_api_allocate_mute_control_index(pa_volume_api *api);
++void pa_volume_api_add_mute_control(pa_volume_api *api, pa_mute_control *control);
++int pa_volume_api_remove_mute_control(pa_volume_api *api, pa_mute_control *control);
++pa_mute_control *pa_volume_api_get_mute_control_by_index(pa_volume_api *api, uint32_t idx);
++
++uint32_t pa_volume_api_allocate_device_index(pa_volume_api *api);
++void pa_volume_api_add_device(pa_volume_api *api, pa_device *device);
++int pa_volume_api_remove_device(pa_volume_api *api, pa_device *device);
++pa_device *pa_volume_api_get_device_by_index(pa_volume_api *api, uint32_t idx);
++
++uint32_t pa_volume_api_allocate_stream_index(pa_volume_api *api);
++void pa_volume_api_add_stream(pa_volume_api *api, pas_stream *stream);
++int pa_volume_api_remove_stream(pa_volume_api *api, pas_stream *stream);
++pas_stream *pa_volume_api_get_stream_by_index(pa_volume_api *api, uint32_t idx);
++
++uint32_t pa_volume_api_allocate_audio_group_index(pa_volume_api *api);
++void pa_volume_api_add_audio_group(pa_volume_api *api, pa_audio_group *group);
++int pa_volume_api_remove_audio_group(pa_volume_api *api, pa_audio_group *group);
++pa_audio_group *pa_volume_api_get_audio_group_by_index(pa_volume_api *api, uint32_t idx);
++
++void pa_volume_api_set_main_output_volume_control(pa_volume_api *api, pa_volume_control *control);
++void pa_volume_api_set_main_input_volume_control(pa_volume_api *api, pa_volume_control *control);
++void pa_volume_api_set_main_output_mute_control(pa_volume_api *api, pa_mute_control *control);
++void pa_volume_api_set_main_input_mute_control(pa_volume_api *api, pa_mute_control *control);
++void pa_volume_api_bind_main_output_volume_control(pa_volume_api *api, pa_binding_target_info *target_info);
++void pa_volume_api_bind_main_input_volume_control(pa_volume_api *api, pa_binding_target_info *target_info);
++void pa_volume_api_bind_main_output_mute_control(pa_volume_api *api, pa_binding_target_info *target_info);
++void pa_volume_api_bind_main_input_mute_control(pa_volume_api *api, pa_binding_target_info *target_info);
++
++#endif
+diff --git a/src/modules/volume-api/volume-control.c b/src/modules/volume-api/volume-control.c
+new file mode 100644
+index 0000000..c7f5dbb
+--- /dev/null
++++ b/src/modules/volume-api/volume-control.c
+@@ -0,0 +1,363 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "volume-control.h"
++
++#include <modules/volume-api/audio-group.h>
++#include <modules/volume-api/device.h>
++#include <modules/volume-api/sstream.h>
++
++#include <pulsecore/core-util.h>
++
++pa_volume_control *pa_volume_control_new(pa_volume_api *api, const char *name, const char *description, bool convertible_to_dB,
++                                         bool channel_map_is_writable) {
++    pa_volume_control *control;
++
++    pa_assert(api);
++    pa_assert(name);
++    pa_assert(description);
++
++    control = pa_xnew0(pa_volume_control, 1);
++    control->volume_api = api;
++    control->index = pa_volume_api_allocate_volume_control_index(api);
++    pa_assert_se(pa_volume_api_register_name(api, name, false, &control->name) >= 0);
++    control->description = pa_xstrdup(description);
++    control->proplist = pa_proplist_new();
++    pa_bvolume_init_invalid(&control->volume);
++    control->convertible_to_dB = convertible_to_dB;
++    control->channel_map_is_writable = channel_map_is_writable;
++    control->devices = pa_hashmap_new(NULL, NULL);
++    control->default_for_devices = pa_hashmap_new(NULL, NULL);
++    control->streams = pa_hashmap_new(NULL, NULL);
++    control->audio_groups = pa_hashmap_new(NULL, NULL);
++
++    return control;
++}
++
++void pa_volume_control_put(pa_volume_control *control, const pa_bvolume *initial_volume,
++                           pa_volume_control_set_initial_volume_cb_t set_initial_volume_cb) {
++    const char *prop_key;
++    void *state = NULL;
++    char volume_str[PA_VOLUME_SNPRINT_VERBOSE_MAX];
++    char balance_str[PA_BVOLUME_SNPRINT_BALANCE_MAX];
++
++    pa_assert(control);
++    pa_assert((initial_volume && pa_bvolume_valid(initial_volume, true, true)) || control->set_volume);
++    pa_assert((initial_volume && pa_channel_map_valid(&initial_volume->channel_map)) || control->channel_map_is_writable);
++    pa_assert(set_initial_volume_cb || !control->set_volume);
++
++    if (initial_volume && pa_bvolume_valid(initial_volume, true, false))
++        control->volume.volume = initial_volume->volume;
++    else
++        control->volume.volume = PA_VOLUME_NORM / 3;
++
++    if (initial_volume && pa_bvolume_valid(initial_volume, false, true))
++        pa_bvolume_copy_balance(&control->volume, initial_volume);
++    else if (initial_volume && pa_channel_map_valid(&initial_volume->channel_map))
++        pa_bvolume_reset_balance(&control->volume, &initial_volume->channel_map);
++    else {
++        pa_channel_map_init_mono(&control->volume.channel_map);
++        pa_bvolume_reset_balance(&control->volume, &control->volume.channel_map);
++    }
++
++    if (set_initial_volume_cb)
++        set_initial_volume_cb(control);
++
++    pa_volume_api_add_volume_control(control->volume_api, control);
++
++    control->linked = true;
++
++    pa_log_debug("Created volume control #%u.", control->index);
++    pa_log_debug("    Name: %s", control->name);
++    pa_log_debug("    Description: %s", control->description);
++    pa_log_debug("    Properties:");
++
++    while ((prop_key = pa_proplist_iterate(control->proplist, &state)))
++        pa_log_debug("        %s = %s", prop_key, pa_strnull(pa_proplist_gets(control->proplist, prop_key)));
++
++    pa_log_debug("    Volume: %s", pa_volume_snprint_verbose(volume_str, sizeof(volume_str), control->volume.volume,
++                 control->convertible_to_dB));
++    pa_log_debug("    Balance: %s", pa_bvolume_snprint_balance(balance_str, sizeof(balance_str), &control->volume));
++    pa_log_debug("    Channel map is writable: %s", pa_yes_no(control->channel_map_is_writable));
++
++    pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_VOLUME_CONTROL_PUT], control);
++}
++
++void pa_volume_control_unlink(pa_volume_control *control) {
++    pa_audio_group *group;
++    pa_device *device;
++    pas_stream *stream;
++
++    pa_assert(control);
++
++    if (control->unlinked) {
++        pa_log_debug("Unlinking volume control %s (already unlinked, this is a no-op).", control->name);
++        return;
++    }
++
++    control->unlinked = true;
++
++    pa_log_debug("Unlinking volume control %s.", control->name);
++
++    if (control->linked)
++        pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_VOLUME_CONTROL_UNLINK], control);
++
++    pa_volume_api_remove_volume_control(control->volume_api, control);
++
++    while ((group = pa_hashmap_first(control->audio_groups)))
++        pa_audio_group_set_volume_control(group, NULL);
++
++    while ((stream = pa_hashmap_first(control->streams)))
++        pas_stream_set_volume_control(stream, NULL);
++
++    while ((device = pa_hashmap_first(control->default_for_devices)))
++        pa_device_set_default_volume_control(device, NULL);
++
++    while ((device = pa_hashmap_first(control->devices))) {
++        /* Why do we have this assertion here? The concern is that if we call
++         * pa_device_set_volume_control() for some device that has the
++         * use_default_volume_control flag set, then that flag will be unset as
++         * a side effect, and we don't want that side effect. This assertion
++         * should be safe, because we just called
++         * pa_device_set_default_volume_control(NULL) for each device that this
++         * control was the default for, and that should ensure that we don't
++         * any more hold any references to devices that used to use this
++         * control as the default. */
++        pa_assert(!device->use_default_volume_control);
++        pa_device_set_volume_control(device, NULL);
++    }
++}
++
++void pa_volume_control_free(pa_volume_control *control) {
++    pa_assert(control);
++
++    if (!control->unlinked)
++        pa_volume_control_unlink(control);
++
++    if (control->audio_groups) {
++        pa_assert(pa_hashmap_isempty(control->audio_groups));
++        pa_hashmap_free(control->audio_groups);
++    }
++
++    if (control->streams) {
++        pa_assert(pa_hashmap_isempty(control->streams));
++        pa_hashmap_free(control->streams);
++    }
++
++    if (control->default_for_devices) {
++        pa_assert(pa_hashmap_isempty(control->default_for_devices));
++        pa_hashmap_free(control->default_for_devices);
++    }
++
++    if (control->devices) {
++        pa_assert(pa_hashmap_isempty(control->devices));
++        pa_hashmap_free(control->devices);
++    }
++
++    if (control->proplist)
++        pa_proplist_free(control->proplist);
++
++    pa_xfree(control->description);
++
++    if (control->name)
++        pa_volume_api_unregister_name(control->volume_api, control->name);
++
++    pa_xfree(control);
++}
++
++void pa_volume_control_set_owner_audio_group(pa_volume_control *control, pa_audio_group *group) {
++    pa_assert(control);
++    pa_assert(group);
++
++    control->owner_audio_group = group;
++}
++
++static void set_volume_internal(pa_volume_control *control, const pa_bvolume *volume, bool set_volume, bool set_balance) {
++    pa_bvolume old_volume;
++    bool volume_changed;
++    bool balance_changed;
++
++    pa_assert(control);
++    pa_assert(volume);
++
++    old_volume = control->volume;
++    volume_changed = !pa_bvolume_equal(volume, &old_volume, set_volume, false);
++    balance_changed = !pa_bvolume_equal(volume, &old_volume, false, set_balance);
++
++    if (!volume_changed && !balance_changed)
++        return;
++
++    if (volume_changed)
++        control->volume.volume = volume->volume;
++
++    if (balance_changed)
++        pa_bvolume_copy_balance(&control->volume, volume);
++
++    if (!control->linked || control->unlinked)
++        return;
++
++    if (volume_changed) {
++        char old_volume_str[PA_VOLUME_SNPRINT_VERBOSE_MAX];
++        char new_volume_str[PA_VOLUME_SNPRINT_VERBOSE_MAX];
++
++        pa_log_debug("The volume of volume control %s changed from %s to %s.", control->name,
++                     pa_volume_snprint_verbose(old_volume_str, sizeof(old_volume_str), old_volume.volume,
++                                               control->convertible_to_dB),
++                     pa_volume_snprint_verbose(new_volume_str, sizeof(new_volume_str), control->volume.volume,
++                                               control->convertible_to_dB));
++    }
++
++    if (balance_changed) {
++        char old_balance_str[PA_BVOLUME_SNPRINT_BALANCE_MAX];
++        char new_balance_str[PA_BVOLUME_SNPRINT_BALANCE_MAX];
++
++        pa_log_debug("The balance of volume control %s changed from %s to %s.", control->name,
++                     pa_bvolume_snprint_balance(old_balance_str, sizeof(old_balance_str), &control->volume),
++                     pa_bvolume_snprint_balance(new_balance_str, sizeof(new_balance_str), &control->volume));
++    }
++
++    pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_VOLUME_CONTROL_VOLUME_CHANGED], control);
++}
++
++int pa_volume_control_set_volume(pa_volume_control *control, const pa_bvolume *volume, bool set_volume, bool set_balance) {
++    pa_bvolume volume_local;
++    int r;
++
++    pa_assert(control);
++    pa_assert(volume);
++
++    volume_local = *volume;
++
++    if (!control->set_volume) {
++        pa_log_info("Tried to set the volume of volume control %s, but the volume control doesn't support the operation.",
++                    control->name);
++        return -PA_ERR_NOTSUPPORTED;
++    }
++
++    if (set_balance
++            && !control->channel_map_is_writable
++            && !pa_channel_map_equal(&volume_local.channel_map, &control->volume.channel_map))
++        pa_bvolume_remap(&volume_local, &control->volume.channel_map);
++
++    if (pa_bvolume_equal(&volume_local, &control->volume, set_volume, set_balance))
++        return 0;
++
++    control->set_volume_in_progress = true;
++    r = control->set_volume(control, &volume_local, set_volume, set_balance);
++    control->set_volume_in_progress = false;
++
++    if (r >= 0)
++        set_volume_internal(control, &volume_local, set_volume, set_balance);
++
++    return r;
++}
++
++void pa_volume_control_description_changed(pa_volume_control *control, const char *new_description) {
++    char *old_description;
++
++    pa_assert(control);
++    pa_assert(new_description);
++
++    old_description = control->description;
++
++    if (pa_streq(new_description, old_description))
++        return;
++
++    control->description = pa_xstrdup(new_description);
++    pa_log_debug("The description of volume control %s changed from \"%s\" to \"%s\".", control->name, old_description,
++                 new_description);
++    pa_xfree(old_description);
++    pa_hook_fire(&control->volume_api->hooks[PA_VOLUME_API_HOOK_VOLUME_CONTROL_DESCRIPTION_CHANGED], control);
++}
++
++void pa_volume_control_volume_changed(pa_volume_control *control, const pa_bvolume *new_volume, bool volume_changed,
++                                      bool balance_changed) {
++    pa_assert(control);
++    pa_assert(new_volume);
++
++    if (!control->linked)
++        return;
++
++    if (control->set_volume_in_progress)
++        return;
++
++    set_volume_internal(control, new_volume, volume_changed, balance_changed);
++}
++
++void pa_volume_control_add_device(pa_volume_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_put(control->devices, device, device) >= 0);
++}
++
++void pa_volume_control_remove_device(pa_volume_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_remove(control->devices, device));
++}
++
++void pa_volume_control_add_default_for_device(pa_volume_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_put(control->default_for_devices, device, device) >= 0);
++}
++
++void pa_volume_control_remove_default_for_device(pa_volume_control *control, pa_device *device) {
++    pa_assert(control);
++    pa_assert(device);
++
++    pa_assert_se(pa_hashmap_remove(control->default_for_devices, device));
++}
++
++void pa_volume_control_add_stream(pa_volume_control *control, pas_stream *stream) {
++    pa_assert(control);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_put(control->streams, stream, stream) >= 0);
++}
++
++void pa_volume_control_remove_stream(pa_volume_control *control, pas_stream *stream) {
++    pa_assert(control);
++    pa_assert(stream);
++
++    pa_assert_se(pa_hashmap_remove(control->streams, stream));
++}
++
++void pa_volume_control_add_audio_group(pa_volume_control *control, pa_audio_group *group) {
++    pa_assert(control);
++    pa_assert(group);
++
++    pa_assert_se(pa_hashmap_put(control->audio_groups, group, group) >= 0);
++}
++
++void pa_volume_control_remove_audio_group(pa_volume_control *control, pa_audio_group *group) {
++    pa_assert(control);
++    pa_assert(group);
++
++    pa_assert_se(pa_hashmap_remove(control->audio_groups, group));
++}
+diff --git a/src/modules/volume-api/volume-control.h b/src/modules/volume-api/volume-control.h
+new file mode 100644
+index 0000000..aaba758
+--- /dev/null
++++ b/src/modules/volume-api/volume-control.h
+@@ -0,0 +1,112 @@
++#ifndef foovolumecontrolhfoo
++#define foovolumecontrolhfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/bvolume.h>
++#include <modules/volume-api/volume-api.h>
++
++typedef struct pa_volume_control pa_volume_control;
++
++struct pa_volume_control {
++    pa_volume_api *volume_api;
++    uint32_t index;
++    const char *name;
++    char *description;
++    pa_proplist *proplist;
++    pa_bvolume volume;
++    bool convertible_to_dB;
++    bool channel_map_is_writable;
++
++    /* If this volume control is the "own volume control" of an audio group,
++     * this is set to point to that group, otherwise this is NULL. */
++    pa_audio_group *owner_audio_group;
++
++    pa_hashmap *devices; /* pa_device -> pa_device (hashmap-as-a-set) */
++    pa_hashmap *default_for_devices; /* pa_device -> pa_device (hashmap-as-a-set) */
++    pa_hashmap *streams; /* pas_stream -> pas_stream (hashmap-as-a-set) */
++    pa_hashmap *audio_groups; /* pa_audio_group -> pa_audio_group (hashmap-as-a-set) */
++
++    bool linked;
++    bool unlinked;
++    bool set_volume_in_progress;
++
++    /* Called from pa_volume_control_set_volume(). The implementation is
++     * expected to return a negative error code on failure. May be NULL, if the
++     * volume control is read-only. */
++    int (*set_volume)(pa_volume_control *control, const pa_bvolume *volume, bool set_volume, bool set_balance);
++
++    void *userdata;
++};
++
++pa_volume_control *pa_volume_control_new(pa_volume_api *api, const char *name, const char *description, bool convertible_to_dB,
++                                         bool channel_map_is_writable);
++
++typedef void (*pa_volume_control_set_initial_volume_cb_t)(pa_volume_control *control);
++
++/* initial_volume is the preferred initial volume of the volume control
++ * implementation. It may be NULL or partially invalid, if the implementation
++ * doesn't care about the initial state of the volume control, as long as these
++ * two rules are followed:
++ *
++ *   1) Read-only volume controls must always specify fully valid initial
++ *      volume.
++ *   2) Volume controls with read-only channel map must always specify a valid
++ *      channel map in initial_volume.
++ *
++ * The implementation's initial volume preference may be overridden by policy,
++ * if the volume control isn't read-only. When the final initial volume is
++ * known, the implementation is notified via set_initial_volume_cb (the volume
++ * can be read from control->volume). set_initial_volume_cb may be NULL, if the
++ * volume control is read-only. */
++void pa_volume_control_put(pa_volume_control *control, const pa_bvolume *initial_volume,
++                           pa_volume_control_set_initial_volume_cb_t set_initial_volume_cb);
++
++void pa_volume_control_unlink(pa_volume_control *control);
++void pa_volume_control_free(pa_volume_control *control);
++
++/* Called by audio-group.c only. */
++void pa_volume_control_set_owner_audio_group(pa_volume_control *control, pa_audio_group *group);
++
++/* Called by clients and policy modules. */
++int pa_volume_control_set_volume(pa_volume_control *control, const pa_bvolume *volume, bool set_volume, bool set_balance);
++
++/* Called by the volume control implementation. */
++void pa_volume_control_description_changed(pa_volume_control *control, const char *new_description);
++void pa_volume_control_volume_changed(pa_volume_control *control, const pa_bvolume *new_volume, bool volume_changed,
++                                      bool balance_changed);
++
++/* Called from device.c only. */
++void pa_volume_control_add_device(pa_volume_control *control, pa_device *device);
++void pa_volume_control_remove_device(pa_volume_control *control, pa_device *device);
++void pa_volume_control_add_default_for_device(pa_volume_control *control, pa_device *device);
++void pa_volume_control_remove_default_for_device(pa_volume_control *control, pa_device *device);
++
++/* Called from sstream.c only. */
++void pa_volume_control_add_stream(pa_volume_control *control, pas_stream *stream);
++void pa_volume_control_remove_stream(pa_volume_control *control, pas_stream *stream);
++
++/* Called from audio-group.c only. */
++void pa_volume_control_add_audio_group(pa_volume_control *control, pa_audio_group *group);
++void pa_volume_control_remove_audio_group(pa_volume_control *control, pa_audio_group *group);
++
++#endif
+diff --git a/src/pulse/ext-volume-api.c b/src/pulse/ext-volume-api.c
+new file mode 100644
+index 0000000..8e93bce
+--- /dev/null
++++ b/src/pulse/ext-volume-api.c
+@@ -0,0 +1,275 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "ext-volume-api.h"
++
++#include <pulsecore/core-util.h>
++#include <pulsecore/i18n.h>
++#include <pulsecore/macro.h>
++
++#include <math.h>
++
++int pa_ext_volume_api_balance_valid(double balance) {
++    return balance >= 0.0 && balance <= 1.0;
++}
++
++int pa_ext_volume_api_bvolume_valid(const pa_ext_volume_api_bvolume *volume, int check_volume, int check_balance) {
++    unsigned channel;
++
++    pa_assert(volume);
++
++    if (check_volume && !PA_VOLUME_IS_VALID(volume->volume))
++        return 0;
++
++    if (!check_balance)
++        return 1;
++
++    if (!pa_channel_map_valid(&volume->channel_map))
++        return 0;
++
++    for (channel = 0; channel < volume->channel_map.channels; channel++) {
++        if (!pa_ext_volume_api_balance_valid(volume->balance[channel]))
++            return 0;
++    }
++
++    return 1;
++}
++
++void pa_ext_volume_api_bvolume_init_invalid(pa_ext_volume_api_bvolume *volume) {
++    unsigned i;
++
++    pa_assert(volume);
++
++    volume->volume = PA_VOLUME_INVALID;
++
++    for (i = 0; i < PA_CHANNELS_MAX; i++)
++        volume->balance[i] = -1.0;
++
++    pa_channel_map_init(&volume->channel_map);
++}
++
++void pa_ext_volume_api_bvolume_init_mono(pa_ext_volume_api_bvolume *bvolume, pa_volume_t volume) {
++    pa_assert(bvolume);
++    pa_assert(PA_VOLUME_IS_VALID(volume));
++
++    bvolume->volume = volume;
++    bvolume->balance[0] = 1.0;
++    pa_channel_map_init_mono(&bvolume->channel_map);
++}
++
++int pa_ext_volume_api_bvolume_equal(const pa_ext_volume_api_bvolume *a, const pa_ext_volume_api_bvolume *b,
++                                    int check_volume, int check_balance) {
++    unsigned i;
++
++    pa_assert(a);
++    pa_assert(b);
++
++    if (check_volume && a->volume != b->volume)
++        return 0;
++
++    if (!check_balance)
++        return 1;
++
++    if (!pa_channel_map_equal(&a->channel_map, &b->channel_map))
++        return 0;
++
++    for (i = 0; i < a->channel_map.channels; i++) {
++        if (fabs(a->balance[i] - b->balance[i]) > 0.00001)
++            return 0;
++    }
++
++    return 1;
++}
++
++void pa_ext_volume_api_bvolume_from_cvolume(pa_ext_volume_api_bvolume *bvolume, const pa_cvolume *cvolume,
++                                            const pa_channel_map *map) {
++    unsigned i;
++
++    pa_assert(bvolume);
++    pa_assert(cvolume);
++    pa_assert(map);
++    pa_assert(cvolume->channels == map->channels);
++
++    bvolume->volume = pa_cvolume_max(cvolume);
++    bvolume->channel_map = *map;
++
++    for (i = 0; i < map->channels; i++) {
++        if (bvolume->volume != PA_VOLUME_MUTED)
++            bvolume->balance[i] = ((double) cvolume->values[i]) / ((double) bvolume->volume);
++        else
++            bvolume->balance[i] = 1.0;
++    }
++}
++
++void pa_ext_volume_api_bvolume_to_cvolume(const pa_ext_volume_api_bvolume *bvolume, pa_cvolume *cvolume) {
++    unsigned i;
++
++    pa_assert(bvolume);
++    pa_assert(cvolume);
++    pa_assert(pa_ext_volume_api_bvolume_valid(bvolume, true, true));
++
++    cvolume->channels = bvolume->channel_map.channels;
++
++    for (i = 0; i < bvolume->channel_map.channels; i++)
++        cvolume->values[i] = bvolume->volume * bvolume->balance[i];
++}
++
++void pa_ext_volume_api_bvolume_copy_balance(pa_ext_volume_api_bvolume *to,
++                                            const pa_ext_volume_api_bvolume *from) {
++    pa_assert(to);
++    pa_assert(from);
++
++    memcpy(to->balance, from->balance, sizeof(from->balance));
++    to->channel_map = from->channel_map;
++}
++
++void pa_ext_volume_api_bvolume_reset_balance(pa_ext_volume_api_bvolume *volume, const pa_channel_map *map) {
++    unsigned i;
++
++    pa_assert(volume);
++    pa_assert(map);
++    pa_assert(pa_channel_map_valid(map));
++
++    for (i = 0; i < map->channels; i++)
++        volume->balance[i] = 1.0;
++
++    volume->channel_map = *map;
++}
++
++void pa_ext_volume_api_bvolume_remap(pa_ext_volume_api_bvolume *volume, const pa_channel_map *to) {
++    unsigned i;
++    pa_cvolume cvolume;
++
++    pa_assert(volume);
++    pa_assert(to);
++    pa_assert(pa_ext_volume_api_bvolume_valid(volume, false, true));
++    pa_assert(pa_channel_map_valid(to));
++
++    cvolume.channels = volume->channel_map.channels;
++
++    for (i = 0; i < cvolume.channels; i++)
++        cvolume.values[i] = volume->balance[i] * (double) PA_VOLUME_NORM;
++
++    pa_cvolume_remap(&cvolume, &volume->channel_map, to);
++
++    for (i = 0; i < to->channels; i++)
++        volume->balance[i] = (double) cvolume.values[i] / (double) PA_VOLUME_NORM;
++
++    volume->channel_map = *to;
++}
++
++double pa_ext_volume_api_bvolume_get_left_right_balance(const pa_ext_volume_api_bvolume *volume) {
++    pa_ext_volume_api_bvolume bvolume;
++    pa_cvolume cvolume;
++    double ret;
++
++    pa_assert(volume);
++
++    bvolume.volume = PA_VOLUME_NORM;
++    pa_ext_volume_api_bvolume_copy_balance(&bvolume, volume);
++    pa_ext_volume_api_bvolume_to_cvolume(&bvolume, &cvolume);
++    ret = pa_cvolume_get_balance(&cvolume, &volume->channel_map);
++
++    return ret;
++}
++
++void pa_ext_volume_api_bvolume_set_left_right_balance(pa_ext_volume_api_bvolume *volume, double balance) {
++    pa_cvolume cvolume;
++    pa_volume_t old_volume;
++
++    pa_assert(volume);
++
++    if (!pa_channel_map_can_balance(&volume->channel_map))
++        return;
++
++    pa_cvolume_reset(&cvolume, volume->channel_map.channels);
++    pa_cvolume_set_balance(&cvolume, &volume->channel_map, balance);
++    old_volume = volume->volume;
++    pa_ext_volume_api_bvolume_from_cvolume(volume, &cvolume, &volume->channel_map);
++    volume->volume = old_volume;
++}
++
++double pa_ext_volume_api_bvolume_get_rear_front_balance(const pa_ext_volume_api_bvolume *volume) {
++    pa_ext_volume_api_bvolume bvolume;
++    pa_cvolume cvolume;
++    double ret;
++
++    pa_assert(volume);
++
++    bvolume.volume = PA_VOLUME_NORM;
++    pa_ext_volume_api_bvolume_copy_balance(&bvolume, volume);
++    pa_ext_volume_api_bvolume_to_cvolume(&bvolume, &cvolume);
++    ret = pa_cvolume_get_fade(&cvolume, &volume->channel_map);
++
++    return ret;
++}
++
++void pa_ext_volume_api_bvolume_set_rear_front_balance(pa_ext_volume_api_bvolume *volume, double balance) {
++    pa_cvolume cvolume;
++    pa_volume_t old_volume;
++
++    pa_assert(volume);
++
++    if (!pa_channel_map_can_fade(&volume->channel_map))
++        return;
++
++    pa_cvolume_reset(&cvolume, volume->channel_map.channels);
++    pa_cvolume_set_fade(&cvolume, &volume->channel_map, balance);
++    old_volume = volume->volume;
++    pa_ext_volume_api_bvolume_from_cvolume(volume, &cvolume, &volume->channel_map);
++    volume->volume = old_volume;
++}
++
++char *pa_ext_volume_api_bvolume_snprint_balance(char *buf, size_t buf_len,
++                                                const pa_ext_volume_api_bvolume *volume) {
++    char *e;
++    unsigned channel;
++    bool first = true;
++
++    pa_assert(buf);
++    pa_assert(buf_len > 0);
++    pa_assert(volume);
++
++    pa_init_i18n();
++
++    if (!pa_ext_volume_api_bvolume_valid(volume, true, true)) {
++        pa_snprintf(buf, buf_len, _("(invalid)"));
++        return buf;
++    }
++
++    *(e = buf) = 0;
++
++    for (channel = 0; channel < volume->channel_map.channels && buf_len > 1; channel++) {
++        buf_len -= pa_snprintf(e, buf_len, "%s%s: %u%%",
++                               first ? "" : ", ",
++                               pa_channel_position_to_string(volume->channel_map.map[channel]),
++                               (unsigned) (volume->balance[channel] * 100 + 0.5));
++
++        e = strchr(e, 0);
++        first = false;
++    }
++
++    return buf;
++}
+diff --git a/src/pulse/ext-volume-api.h b/src/pulse/ext-volume-api.h
+new file mode 100644
+index 0000000..36b7748
+--- /dev/null
++++ b/src/pulse/ext-volume-api.h
+@@ -0,0 +1,68 @@
++#ifndef fooextvolumeapihfoo
++#define fooextvolumeapihfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <pulse/cdecl.h>
++#include <pulse/context.h>
++#include <pulse/volume.h>
++
++/* This API is temporary, and has no stability guarantees whatsoever. Think
++ * twice before making anything that relies on this API. This is undocumented
++ * for a reason. */
++
++PA_C_DECL_BEGIN
++
++typedef struct pa_ext_volume_api_bvolume pa_ext_volume_api_bvolume;
++
++struct pa_ext_volume_api_bvolume {
++    pa_volume_t volume;
++    double balance[PA_CHANNELS_MAX];
++    pa_channel_map channel_map;
++};
++
++int pa_ext_volume_api_balance_valid(double balance) PA_GCC_CONST;
++int pa_ext_volume_api_bvolume_valid(const pa_ext_volume_api_bvolume *volume, int check_volume, int check_balance)
++        PA_GCC_PURE;
++void pa_ext_volume_api_bvolume_init_invalid(pa_ext_volume_api_bvolume *volume);
++void pa_ext_volume_api_bvolume_init_mono(pa_ext_volume_api_bvolume *bvolume, pa_volume_t volume);
++int pa_ext_volume_api_bvolume_equal(const pa_ext_volume_api_bvolume *a, const pa_ext_volume_api_bvolume *b,
++                                    int check_volume, int check_balance) PA_GCC_PURE;
++void pa_ext_volume_api_bvolume_from_cvolume(pa_ext_volume_api_bvolume *bvolume, const pa_cvolume *cvolume,
++                                            const pa_channel_map *map);
++void pa_ext_volume_api_bvolume_to_cvolume(const pa_ext_volume_api_bvolume *bvolume, pa_cvolume *cvolume);
++void pa_ext_volume_api_bvolume_copy_balance(pa_ext_volume_api_bvolume *to,
++                                            const pa_ext_volume_api_bvolume *from);
++void pa_ext_volume_api_bvolume_reset_balance(pa_ext_volume_api_bvolume *volume, const pa_channel_map *map);
++void pa_ext_volume_api_bvolume_remap(pa_ext_volume_api_bvolume *volume, const pa_channel_map *to);
++double pa_ext_volume_api_bvolume_get_left_right_balance(const pa_ext_volume_api_bvolume *volume) PA_GCC_PURE;
++void pa_ext_volume_api_bvolume_set_left_right_balance(pa_ext_volume_api_bvolume *volume, double balance);
++double pa_ext_volume_api_bvolume_get_rear_front_balance(const pa_ext_volume_api_bvolume *volume) PA_GCC_PURE;
++void pa_ext_volume_api_bvolume_set_rear_front_balance(pa_ext_volume_api_bvolume *volume, double balance);
++
++#define PA_EXT_VOLUME_API_BVOLUME_SNPRINT_BALANCE_MAX 500
++char *pa_ext_volume_api_bvolume_snprint_balance(char *buf, size_t buf_size,
++                                                const pa_ext_volume_api_bvolume *volume);
++
++PA_C_DECL_END
++
++#endif
+-- 
+2.1.4
+
+--- a/po/POTFILES.in   2016-04-13 17:40:00.818008672 +0200
++++ b/po/POTFILES.in   2016-04-13 17:40:30.885008622 +0200
+@@ -198,3 +198,5 @@
+ src/utils/padsp.c
+ src/utils/pasuspender.c
+ src/utils/pax11publish.c
++src/modules/volume-api/device-creator.c
++src/pulse/ext-volume-api.c

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0031-Add-module-main-volume-policy.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0031-Add-module-main-volume-policy.patch
new file mode 100644 (file)
index 0000000..216ed21
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0031-Add-module-main-volume-policy.patch
@@ -0,0 +1,1418 @@
+From cfb39f18569679f59c9b6283c47e8d90ddd9763d Mon Sep 17 00:00:00 2001
+From: Tanu Kaskinen <tanu.kaskinen@linux.intel.com>
+Date: Wed, 21 May 2014 14:13:41 +0300
+Subject: [PATCH] Add module-main-volume-policy
+
+Change-Id: I787141b43cafb652aa752c64ae28b6b7aa052d8e
+Signed-off-by: Jaska Uimonen <jaska.uimonen@intel.com>
+---
+ Makefile.am                                        |   3 +
+ src/Makefile.am                                    |  15 +
+ src/daemon/default.pa.in                           |   4 +
+ .../main-volume-policy/main-volume-context.c       | 325 ++++++++++++
+ .../main-volume-policy/main-volume-context.h       |  75 +++
+ .../main-volume-policy/main-volume-policy.c        | 213 ++++++++
+ .../main-volume-policy.conf.example                |  20 +
+ .../main-volume-policy/main-volume-policy.h        |  72 +++
+ .../main-volume-policy/module-main-volume-policy.c | 556 +++++++++++++++++++++
+ 9 files changed, 1283 insertions(+)
+ create mode 100644 src/modules/main-volume-policy/main-volume-context.c
+ create mode 100644 src/modules/main-volume-policy/main-volume-context.h
+ create mode 100644 src/modules/main-volume-policy/main-volume-policy.c
+ create mode 100644 src/modules/main-volume-policy/main-volume-policy.conf.example
+ create mode 100644 src/modules/main-volume-policy/main-volume-policy.h
+ create mode 100644 src/modules/main-volume-policy/module-main-volume-policy.c
+
+diff --git a/Makefile.am b/Makefile.am
+index cf4a648..646b7fc 100644
+--- a/Makefile.am      2016-04-13 15:14:28.942023245 +0200
++++ b/Makefile.am      2016-04-13 15:16:32.691023039 +0200
+@@ -60,6 +60,9 @@
+ moduledevvolumeapi_DATA = src/modules/volume-api/*.h
+ moduledevvolumeapidir   = $(includedir)/pulsemodule/modules/volume-api
+ 
++moduledevmainvolumepolicy_DATA = $(top_srcdir)/src/modules/main-volume-policy/*.h
++moduledevmainvolumepolicydir = $(includedir)/pulsemodule/modules/main-volume-policy
++
+ if HAVE_GLIB20
+ pkgconfig_DATA += \
+        libpulse-mainloop-glib.pc
+        libpulse-mainloop-glib.pc
+diff --git a/src/Makefile.am b/src/Makefile.am
+index a6bb319..8fa60ec 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -1050,7 +1050,8 @@
+               libprotocol-simple.la \
+               libprotocol-http.la \
+               libprotocol-native.la \
+-              libvolume-api.la
++              libvolume-api.la \
++              libmain-volume-policy.la
+ 
+ if HAVE_WEBRTC
+ modlibexec_LTLIBRARIES += libwebrtc-util.la
+@@ -1051,6 +1052,12 @@ libcli_la_SOURCES = pulsecore/cli.c pulsecore/cli.h
+ libcli_la_LDFLAGS = $(AM_LDFLAGS) -avoid-version
+ libcli_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
+ 
++libmain_volume_policy_la_SOURCES = \
++              modules/main-volume-policy/main-volume-context.c modules/main-volume-policy/main-volume-context.h \
++              modules/main-volume-policy/main-volume-policy.c modules/main-volume-policy/main-volume-policy.h
++libmain_volume_policy_la_LDFLAGS = $(AM_LDFLAGS) -avoid-version
++libmain_volume_policy_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la libvolume-api.la
++
+ libprotocol_cli_la_SOURCES = pulsecore/protocol-cli.c pulsecore/protocol-cli.h
+ libprotocol_cli_la_LDFLAGS = $(AM_LDFLAGS) -avoid-version
+ libprotocol_cli_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la libcli.la
+@@ -1136,6 +1136,7 @@ endif
+ modlibexec_LTLIBRARIES += \
+               module-cli.la \
+               module-cli-protocol-tcp.la \
++              module-main-volume-policy.la \
+               module-simple-protocol-tcp.la \
+               module-null-sink.la \
+               module-null-source.la \
+@@ -1426,6 +1434,7 @@ SYMDEF_FILES = \
+               module-cli-symdef.h \
+               module-cli-protocol-tcp-symdef.h \
+               module-cli-protocol-unix-symdef.h \
++              module-main-volume-policy-symdef.h \
+               module-pipe-sink-symdef.h \
+               module-pipe-source-symdef.h \
+               module-simple-protocol-tcp-symdef.h \
+@@ -1575,6 +1584,12 @@ module_cli_protocol_unix_la_CFLAGS = -DUSE_UNIX_SOCKETS -DUSE_PROTOCOL_CLI $(AM_
+ module_cli_protocol_unix_la_LDFLAGS = $(MODULE_LDFLAGS)
+ module_cli_protocol_unix_la_LIBADD = $(MODULE_LIBADD) libprotocol-cli.la
+ 
++# Main volume and mute policy
++
++module_main_volume_policy_la_SOURCES = modules/main-volume-policy/module-main-volume-policy.c
++module_main_volume_policy_la_LDFLAGS = $(MODULE_LDFLAGS)
++module_main_volume_policy_la_LIBADD = $(MODULE_LIBADD) libmain-volume-policy.la libvolume-api.la
++
+ # HTTP protocol
+ 
+ module_http_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
+diff --git a/src/daemon/default.pa.in b/src/daemon/default.pa.in
+index 7cf52a4..f70804c 100755
+--- a/src/daemon/default.pa.in
++++ b/src/daemon/default.pa.in
+@@ -188,6 +188,10 @@
+ #.endif
+ ])dnl
+ 
++.ifexists module-main-volume-policy
++load-module module-main-volume-policy
++.endif
++
+ ### Make some devices default
+ #set-default-sink output
+ #set-default-source input
+diff --git a/src/modules/main-volume-policy/main-volume-context.c b/src/modules/main-volume-policy/main-volume-context.c
+new file mode 100644
+index 0000000..7ac35c6
+--- /dev/null
++++ b/src/modules/main-volume-policy/main-volume-context.c
+@@ -0,0 +1,325 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "main-volume-context.h"
++
++#include <modules/volume-api/mute-control.h>
++#include <modules/volume-api/volume-control.h>
++
++int pa_main_volume_context_new(pa_main_volume_policy *policy, const char *name, const char *description,
++                               pa_main_volume_context **context) {
++    pa_main_volume_context *context_local;
++    int r;
++
++    pa_assert(policy);
++    pa_assert(name);
++    pa_assert(description);
++    pa_assert(context);
++
++    context_local = pa_xnew0(struct pa_main_volume_context, 1);
++    context_local->main_volume_policy = policy;
++    context_local->index = pa_main_volume_policy_allocate_main_volume_context_index(policy);
++
++    r = pa_main_volume_policy_register_name(policy, name, true, &context_local->name);
++    if (r < 0)
++        goto fail;
++
++    context_local->description = pa_xstrdup(description);
++
++    *context = context_local;
++
++    return 0;
++
++fail:
++    pa_main_volume_context_free(context_local);
++
++    return r;
++}
++
++void pa_main_volume_context_put(pa_main_volume_context *context) {
++    pa_assert(context);
++
++    pa_main_volume_policy_add_main_volume_context(context->main_volume_policy, context);
++
++    context->linked = true;
++
++    pa_log_debug("Created main volume context #%u.", context->index);
++    pa_log_debug("    Name: %s", context->name);
++    pa_log_debug("    Description: %s", context->description);
++    pa_log_debug("    Main output volume control: %s",
++                 context->main_output_volume_control ? context->main_output_volume_control->name : "(unset)");
++    pa_log_debug("    Main input volume control: %s",
++                 context->main_input_volume_control ? context->main_input_volume_control->name : "(unset)");
++    pa_log_debug("    Main output mute control: %s",
++                 context->main_output_mute_control ? context->main_output_mute_control->name : "(unset)");
++    pa_log_debug("    Main input mute control: %s",
++                 context->main_input_mute_control ? context->main_input_mute_control->name : "(unset)");
++
++    pa_hook_fire(&context->main_volume_policy->hooks[PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_PUT], context);
++}
++
++void pa_main_volume_context_unlink(pa_main_volume_context *context) {
++    pa_assert(context);
++
++    if (context->unlinked) {
++        pa_log_debug("Unlinking main volume context %s (already unlinked, this is a no-op).", context->name);
++        return;
++    }
++
++    context->unlinked = true;
++
++    pa_log_debug("Unlinking main volume context %s.", context->name);
++
++    if (context->linked)
++        pa_hook_fire(&context->main_volume_policy->hooks[PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_UNLINK], context);
++
++    if (context->main_input_mute_control_binding) {
++        pa_binding_free(context->main_input_mute_control_binding);
++        context->main_input_mute_control_binding = NULL;
++    }
++
++    if (context->main_output_mute_control_binding) {
++        pa_binding_free(context->main_output_mute_control_binding);
++        context->main_output_mute_control_binding = NULL;
++    }
++
++    if (context->main_input_volume_control_binding) {
++        pa_binding_free(context->main_input_volume_control_binding);
++        context->main_input_volume_control_binding = NULL;
++    }
++
++    if (context->main_output_volume_control_binding) {
++        pa_binding_free(context->main_output_volume_control_binding);
++        context->main_output_volume_control_binding = NULL;
++    }
++
++    context->main_input_mute_control = NULL;
++    context->main_output_mute_control = NULL;
++    context->main_input_volume_control = NULL;
++    context->main_output_volume_control = NULL;
++
++    pa_main_volume_policy_remove_main_volume_context(context->main_volume_policy, context);
++}
++
++void pa_main_volume_context_free(pa_main_volume_context *context) {
++    pa_assert(context);
++
++    if (!context->unlinked)
++        pa_main_volume_context_unlink(context);
++
++    pa_xfree(context->description);
++
++    if (context->name)
++        pa_main_volume_policy_unregister_name(context->main_volume_policy, context->name);
++
++    pa_xfree(context);
++}
++
++const char *pa_main_volume_context_get_name(pa_main_volume_context *context) {
++    pa_assert(context);
++
++    return context->name;
++}
++
++static void set_main_output_volume_control_internal(pa_main_volume_context *context, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(context);
++
++    old_control = context->main_output_volume_control;
++
++    if (control == old_control)
++        return;
++
++    context->main_output_volume_control = control;
++
++    if (!context->linked || context->unlinked)
++        return;
++
++    pa_log_debug("The main output volume control of main volume context %s changed from %s to %s.", context->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&context->main_volume_policy->hooks
++                     [PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_OUTPUT_VOLUME_CONTROL_CHANGED],
++                 context);
++}
++
++void pa_main_volume_context_bind_main_output_volume_control(pa_main_volume_context *context,
++                                                            pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = context,
++        .set_value = (pa_binding_set_value_cb_t) set_main_output_volume_control_internal,
++    };
++
++    pa_assert(context);
++    pa_assert(target_info);
++
++    if (context->main_output_volume_control_binding)
++        pa_binding_free(context->main_output_volume_control_binding);
++
++    context->main_output_volume_control_binding = pa_binding_new(context->main_volume_policy->volume_api, &owner_info,
++                                                                 target_info);
++}
++
++static void set_main_input_volume_control_internal(pa_main_volume_context *context, pa_volume_control *control) {
++    pa_volume_control *old_control;
++
++    pa_assert(context);
++
++    old_control = context->main_input_volume_control;
++
++    if (control == old_control)
++        return;
++
++    context->main_input_volume_control = control;
++
++    if (!context->linked || context->unlinked)
++        return;
++
++    pa_log_debug("The main input volume control of main volume context %s changed from %s to %s.", context->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&context->main_volume_policy->hooks
++                     [PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_INPUT_VOLUME_CONTROL_CHANGED],
++                 context);
++}
++
++void pa_main_volume_context_bind_main_input_volume_control(pa_main_volume_context *context,
++                                                           pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = context,
++        .set_value = (pa_binding_set_value_cb_t) set_main_input_volume_control_internal,
++    };
++
++    pa_assert(context);
++    pa_assert(target_info);
++
++    if (context->main_input_volume_control_binding)
++        pa_binding_free(context->main_input_volume_control_binding);
++
++    context->main_input_volume_control_binding = pa_binding_new(context->main_volume_policy->volume_api, &owner_info,
++                                                                target_info);
++}
++
++static void set_main_output_mute_control_internal(pa_main_volume_context *context, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(context);
++
++    old_control = context->main_output_mute_control;
++
++    if (control == old_control)
++        return;
++
++    context->main_output_mute_control = control;
++
++    if (!context->linked || context->unlinked)
++        return;
++
++    pa_log_debug("The main output mute control of main volume context %s changed from %s to %s.", context->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&context->main_volume_policy->hooks
++                     [PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_OUTPUT_MUTE_CONTROL_CHANGED],
++                 context);
++}
++
++void pa_main_volume_context_bind_main_output_mute_control(pa_main_volume_context *context,
++                                                          pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = context,
++        .set_value = (pa_binding_set_value_cb_t) set_main_output_mute_control_internal,
++    };
++
++    pa_assert(context);
++    pa_assert(target_info);
++
++    if (context->main_output_mute_control_binding)
++        pa_binding_free(context->main_output_mute_control_binding);
++
++    context->main_output_mute_control_binding = pa_binding_new(context->main_volume_policy->volume_api, &owner_info,
++                                                               target_info);
++}
++
++static void set_main_input_mute_control_internal(pa_main_volume_context *context, pa_mute_control *control) {
++    pa_mute_control *old_control;
++
++    pa_assert(context);
++
++    old_control = context->main_input_mute_control;
++
++    if (control == old_control)
++        return;
++
++    context->main_input_mute_control = control;
++
++    if (!context->linked || context->unlinked)
++        return;
++
++    pa_log_debug("The main input mute control of main volume context %s changed from %s to %s.", context->name,
++                 old_control ? old_control->name : "(unset)", control ? control->name : "(unset)");
++
++    pa_hook_fire(&context->main_volume_policy->hooks
++                     [PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_INPUT_MUTE_CONTROL_CHANGED],
++                 context);
++}
++
++void pa_main_volume_context_bind_main_input_mute_control(pa_main_volume_context *context,
++                                                         pa_binding_target_info *target_info) {
++    pa_binding_owner_info owner_info = {
++        .userdata = context,
++        .set_value = (pa_binding_set_value_cb_t) set_main_input_mute_control_internal,
++    };
++
++    pa_assert(context);
++    pa_assert(target_info);
++
++    if (context->main_input_mute_control_binding)
++        pa_binding_free(context->main_input_mute_control_binding);
++
++    context->main_input_mute_control_binding = pa_binding_new(context->main_volume_policy->volume_api, &owner_info,
++                                                              target_info);
++}
++
++pa_binding_target_type *pa_main_volume_context_create_binding_target_type(pa_main_volume_policy *policy) {
++    pa_binding_target_type *type;
++
++    pa_assert(policy);
++
++    type = pa_binding_target_type_new(PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_TYPE, policy->main_volume_contexts,
++                                      &policy->hooks[PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_PUT],
++                                      &policy->hooks[PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_UNLINK],
++                                      (pa_binding_target_type_get_name_cb_t) pa_main_volume_context_get_name);
++    pa_binding_target_type_add_field(type, PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_OUTPUT_VOLUME_CONTROL,
++                                     PA_BINDING_CALCULATE_FIELD_OFFSET(pa_main_volume_context, main_output_volume_control));
++    pa_binding_target_type_add_field(type, PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_INPUT_VOLUME_CONTROL,
++                                     PA_BINDING_CALCULATE_FIELD_OFFSET(pa_main_volume_context, main_input_volume_control));
++    pa_binding_target_type_add_field(type, PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_OUTPUT_MUTE_CONTROL,
++                                     PA_BINDING_CALCULATE_FIELD_OFFSET(pa_main_volume_context, main_output_mute_control));
++    pa_binding_target_type_add_field(type, PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_INPUT_MUTE_CONTROL,
++                                     PA_BINDING_CALCULATE_FIELD_OFFSET(pa_main_volume_context, main_input_mute_control));
++
++    return type;
++}
+diff --git a/src/modules/main-volume-policy/main-volume-context.h b/src/modules/main-volume-policy/main-volume-context.h
+new file mode 100644
+index 0000000..4a0a6f7
+--- /dev/null
++++ b/src/modules/main-volume-policy/main-volume-context.h
+@@ -0,0 +1,75 @@
++#ifndef foomainvolumecontexthfoo
++#define foomainvolumecontexthfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/main-volume-policy/main-volume-policy.h>
++
++#include <modules/volume-api/binding.h>
++
++typedef struct pa_main_volume_context pa_main_volume_context;
++
++#define PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_TYPE "MainVolumeContext"
++#define PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_OUTPUT_VOLUME_CONTROL "main_output_volume_control"
++#define PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_INPUT_VOLUME_CONTROL "main_input_volume_control"
++#define PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_OUTPUT_MUTE_CONTROL "main_output_mute_control"
++#define PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_INPUT_MUTE_CONTROL "main_input_mute_control"
++
++struct pa_main_volume_context {
++    pa_main_volume_policy *main_volume_policy;
++    uint32_t index;
++    const char *name;
++    char *description;
++    pa_volume_control *main_output_volume_control;
++    pa_volume_control *main_input_volume_control;
++    pa_mute_control *main_output_mute_control;
++    pa_mute_control *main_input_mute_control;
++
++    pa_binding *main_output_volume_control_binding;
++    pa_binding *main_input_volume_control_binding;
++    pa_binding *main_output_mute_control_binding;
++    pa_binding *main_input_mute_control_binding;
++
++    bool linked;
++    bool unlinked;
++};
++
++int pa_main_volume_context_new(pa_main_volume_policy *policy, const char *name, const char *description,
++                               pa_main_volume_context **context);
++void pa_main_volume_context_put(pa_main_volume_context *context);
++void pa_main_volume_context_unlink(pa_main_volume_context *context);
++void pa_main_volume_context_free(pa_main_volume_context *context);
++
++const char *pa_main_volume_context_get_name(pa_main_volume_context *context);
++
++void pa_main_volume_context_bind_main_output_volume_control(pa_main_volume_context *context,
++                                                            pa_binding_target_info *target_info);
++void pa_main_volume_context_bind_main_input_volume_control(pa_main_volume_context *context,
++                                                           pa_binding_target_info *target_info);
++void pa_main_volume_context_bind_main_output_mute_control(pa_main_volume_context *context,
++                                                          pa_binding_target_info *target_info);
++void pa_main_volume_context_bind_main_input_mute_control(pa_main_volume_context *context, pa_binding_target_info *target_info);
++
++/* Called from main-volume-policy.c only. */
++pa_binding_target_type *pa_main_volume_context_create_binding_target_type(pa_main_volume_policy *policy);
++
++#endif
+diff --git a/src/modules/main-volume-policy/main-volume-policy.c b/src/modules/main-volume-policy/main-volume-policy.c
+new file mode 100644
+index 0000000..b0b4ede
+--- /dev/null
++++ b/src/modules/main-volume-policy/main-volume-policy.c
+@@ -0,0 +1,213 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "main-volume-policy.h"
++
++#include <modules/main-volume-policy/main-volume-context.h>
++
++#include <pulsecore/core-util.h>
++#include <pulsecore/shared.h>
++
++static pa_main_volume_policy *main_volume_policy_new(pa_core *core);
++static void main_volume_policy_free(pa_main_volume_policy *policy);
++
++pa_main_volume_policy *pa_main_volume_policy_get(pa_core *core) {
++    pa_main_volume_policy *policy;
++
++    pa_assert(core);
++
++    policy = pa_shared_get(core, "main-volume-policy");
++
++    if (policy)
++        pa_main_volume_policy_ref(policy);
++    else {
++        policy = main_volume_policy_new(core);
++        pa_assert_se(pa_shared_set(core, "main-volume-policy", policy) >= 0);
++    }
++
++    return policy;
++}
++
++pa_main_volume_policy *pa_main_volume_policy_ref(pa_main_volume_policy *policy) {
++    pa_assert(policy);
++
++    policy->refcnt++;
++
++    return policy;
++}
++
++void pa_main_volume_policy_unref(pa_main_volume_policy *policy) {
++    pa_assert(policy);
++    pa_assert(policy->refcnt > 0);
++
++    policy->refcnt--;
++
++    if (policy->refcnt == 0) {
++        pa_assert_se(pa_shared_remove(policy->core, "main-volume-policy") >= 0);
++        main_volume_policy_free(policy);
++    }
++}
++
++static pa_main_volume_policy *main_volume_policy_new(pa_core *core) {
++    pa_main_volume_policy *policy;
++    unsigned i;
++
++    pa_assert(core);
++
++    policy = pa_xnew0(pa_main_volume_policy, 1);
++    policy->core = core;
++    policy->refcnt = 1;
++    policy->volume_api = pa_volume_api_get(core);
++    policy->names = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, pa_xfree);
++    policy->main_volume_contexts = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
++
++    for (i = 0; i < PA_MAIN_VOLUME_POLICY_HOOK_MAX; i++)
++        pa_hook_init(&policy->hooks[i], policy);
++
++    policy->main_volume_context_binding_target_type = pa_main_volume_context_create_binding_target_type(policy);
++    pa_volume_api_add_binding_target_type(policy->volume_api, policy->main_volume_context_binding_target_type);
++
++    pa_log_debug("Created a pa_main_volume_policy object.");
++
++    return policy;
++}
++
++static void main_volume_policy_free(pa_main_volume_policy *policy) {
++    unsigned i;
++
++    pa_assert(policy);
++    pa_assert(policy->refcnt == 0);
++
++    pa_log_debug("Freeing the pa_main_volume_policy object.");
++
++    if (policy->main_volume_context_binding_target_type) {
++        pa_volume_api_remove_binding_target_type(policy->volume_api, policy->main_volume_context_binding_target_type);
++        pa_binding_target_type_free(policy->main_volume_context_binding_target_type);
++    }
++
++    for (i = 0; i < PA_MAIN_VOLUME_POLICY_HOOK_MAX; i++)
++        pa_hook_done(&policy->hooks[i]);
++
++    if (policy->main_volume_contexts) {
++        pa_assert(pa_hashmap_isempty(policy->main_volume_contexts));
++        pa_hashmap_free(policy->main_volume_contexts);
++    }
++
++    if (policy->names) {
++        pa_assert(pa_hashmap_isempty(policy->names));
++        pa_hashmap_free(policy->names);
++    }
++
++    if (policy->volume_api)
++        pa_volume_api_unref(policy->volume_api);
++
++    pa_xfree(policy);
++}
++
++int pa_main_volume_policy_register_name(pa_main_volume_policy *policy, const char *requested_name,
++                                        bool fail_if_already_registered, const char **registered_name) {
++    char *n;
++
++    pa_assert(policy);
++    pa_assert(requested_name);
++    pa_assert(registered_name);
++
++    n = pa_xstrdup(requested_name);
++
++    if (pa_hashmap_put(policy->names, n, n) < 0) {
++        unsigned i = 1;
++
++        pa_xfree(n);
++
++        if (fail_if_already_registered) {
++            pa_log("Name %s already registered.", requested_name);
++            return -PA_ERR_EXIST;
++        }
++
++        do {
++            i++;
++            n = pa_sprintf_malloc("%s.%u", requested_name, i);
++        } while (pa_hashmap_put(policy->names, n, n) < 0);
++    }
++
++    *registered_name = n;
++
++    return 0;
++}
++
++void pa_main_volume_policy_unregister_name(pa_main_volume_policy *policy, const char *name) {
++    pa_assert(policy);
++    pa_assert(name);
++
++    pa_assert_se(pa_hashmap_remove_and_free(policy->names, name) >= 0);
++}
++
++uint32_t pa_main_volume_policy_allocate_main_volume_context_index(pa_main_volume_policy *policy) {
++    uint32_t idx;
++
++    pa_assert(policy);
++
++    idx = policy->next_main_volume_context_index++;
++
++    return idx;
++}
++
++void pa_main_volume_policy_add_main_volume_context(pa_main_volume_policy *policy, pa_main_volume_context *context) {
++    pa_assert(policy);
++    pa_assert(context);
++
++    pa_assert_se(pa_hashmap_put(policy->main_volume_contexts, (void *) context->name, context) >= 0);
++}
++
++int pa_main_volume_policy_remove_main_volume_context(pa_main_volume_policy *policy, pa_main_volume_context *context) {
++    pa_assert(policy);
++    pa_assert(context);
++
++    if (!pa_hashmap_remove(policy->main_volume_contexts, context->name))
++        return -1;
++
++    if (context == policy->active_main_volume_context)
++        pa_main_volume_policy_set_active_main_volume_context(policy, NULL);
++
++    return 0;
++}
++
++void pa_main_volume_policy_set_active_main_volume_context(pa_main_volume_policy *policy, pa_main_volume_context *context) {
++    pa_main_volume_context *old_context;
++
++    pa_assert(policy);
++
++    old_context = policy->active_main_volume_context;
++
++    if (context == old_context)
++        return;
++
++    policy->active_main_volume_context = context;
++
++    pa_log_debug("The active main volume context changed from %s to %s.", old_context ? old_context->name : "(unset)",
++                 context ? context->name : "(unset)");
++
++    pa_hook_fire(&policy->hooks[PA_MAIN_VOLUME_POLICY_HOOK_ACTIVE_MAIN_VOLUME_CONTEXT_CHANGED], NULL);
++}
+diff --git a/src/modules/main-volume-policy/main-volume-policy.conf.example b/src/modules/main-volume-policy/main-volume-policy.conf.example
+new file mode 100644
+index 0000000..a4a35d3
+--- /dev/null
++++ b/src/modules/main-volume-policy/main-volume-policy.conf.example
+@@ -0,0 +1,20 @@
++[General]
++output-volume-model = by-active-main-volume-context
++input-volume-model = by-active-main-volume-context
++output-mute-model = none
++input-mute-model = none
++main-volume-contexts = x-example-call-main-volume-context x-example-default-main-volume-context
++
++[MainVolumeContext x-example-call-main-volume-context]
++description = Call main volume context
++main-output-volume-control = bind:AudioGroup:x-example-call-downlink-audio-group
++main-input-volume-control = bind:AudioGroup:x-example-call-uplink-audio-group
++main-output-mute-control = none
++main-input-mute-control = none
++
++[MainVolumeContext x-example-default-main-volume-context]
++description = Default main volume context
++main-output-volume-control = bind:AudioGroup:x-example-default-output-audio-group
++main-input-volume-control = bind:AudioGroup:x-example-default-input-audio-group
++main-output-mute-control = none
++main-input-mute-control = none
+diff --git a/src/modules/main-volume-policy/main-volume-policy.h b/src/modules/main-volume-policy/main-volume-policy.h
+new file mode 100644
+index 0000000..5cd669e
+--- /dev/null
++++ b/src/modules/main-volume-policy/main-volume-policy.h
+@@ -0,0 +1,72 @@
++#ifndef foomainvolumepolicyhfoo
++#define foomainvolumepolicyhfoo
++
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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.
++***/
++
++#include <modules/volume-api/binding.h>
++#include <modules/volume-api/volume-api.h>
++
++#include <pulsecore/core.h>
++
++typedef struct pa_main_volume_policy pa_main_volume_policy;
++
++/* Avoid circular dependencies... */
++typedef struct pa_main_volume_context pa_main_volume_context;
++
++enum {
++    PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_PUT,
++    PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_UNLINK,
++    PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_OUTPUT_VOLUME_CONTROL_CHANGED,
++    PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_INPUT_VOLUME_CONTROL_CHANGED,
++    PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_OUTPUT_MUTE_CONTROL_CHANGED,
++    PA_MAIN_VOLUME_POLICY_HOOK_MAIN_VOLUME_CONTEXT_MAIN_INPUT_MUTE_CONTROL_CHANGED,
++    PA_MAIN_VOLUME_POLICY_HOOK_ACTIVE_MAIN_VOLUME_CONTEXT_CHANGED,
++    PA_MAIN_VOLUME_POLICY_HOOK_MAX,
++};
++
++struct pa_main_volume_policy {
++    pa_core *core;
++    unsigned refcnt;
++    pa_volume_api *volume_api;
++    pa_hashmap *names; /* object name -> object name (hashmap-as-a-set) */
++    pa_hashmap *main_volume_contexts; /* name -> pa_main_volume_context */
++    pa_main_volume_context *active_main_volume_context;
++
++    uint32_t next_main_volume_context_index;
++    pa_hook hooks[PA_MAIN_VOLUME_POLICY_HOOK_MAX];
++    pa_binding_target_type *main_volume_context_binding_target_type;
++};
++
++pa_main_volume_policy *pa_main_volume_policy_get(pa_core *core);
++pa_main_volume_policy *pa_main_volume_policy_ref(pa_main_volume_policy *policy);
++void pa_main_volume_policy_unref(pa_main_volume_policy *policy);
++
++int pa_main_volume_policy_register_name(pa_main_volume_policy *policy, const char *requested_name,
++                                        bool fail_if_already_registered, const char **registered_name);
++void pa_main_volume_policy_unregister_name(pa_main_volume_policy *policy, const char *name);
++
++uint32_t pa_main_volume_policy_allocate_main_volume_context_index(pa_main_volume_policy *policy);
++void pa_main_volume_policy_add_main_volume_context(pa_main_volume_policy *policy, pa_main_volume_context *context);
++int pa_main_volume_policy_remove_main_volume_context(pa_main_volume_policy *policy, pa_main_volume_context *context);
++void pa_main_volume_policy_set_active_main_volume_context(pa_main_volume_policy *policy, pa_main_volume_context *context);
++
++#endif
+diff --git a/src/modules/main-volume-policy/module-main-volume-policy.c b/src/modules/main-volume-policy/module-main-volume-policy.c
+new file mode 100644
+index 0000000..a14699d
+--- /dev/null
++++ b/src/modules/main-volume-policy/module-main-volume-policy.c
+@@ -0,0 +1,556 @@
++/***
++  This file is part of PulseAudio.
++
++  Copyright 2014 Intel Corporation
++
++  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.1 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 "module-main-volume-policy-symdef.h"
++
++#include <modules/main-volume-policy/main-volume-context.h>
++
++#include <modules/volume-api/binding.h>
++#include <modules/volume-api/volume-api.h>
++
++#include <pulse/direction.h>
++
++#include <pulsecore/conf-parser.h>
++#include <pulsecore/core-util.h>
++#include <pulsecore/i18n.h>
++
++PA_MODULE_AUTHOR("Tanu Kaskinen");
++PA_MODULE_DESCRIPTION(_("Main volume and mute policy"));
++PA_MODULE_VERSION(PACKAGE_VERSION);
++PA_MODULE_LOAD_ONCE(true);
++
++enum control_type {
++    CONTROL_TYPE_VOLUME,
++    CONTROL_TYPE_MUTE,
++};
++
++enum model {
++    MODEL_NONE,
++    MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT,
++};
++
++struct userdata {
++    pa_main_volume_policy *main_volume_policy;
++    enum model output_volume_model;
++    enum model input_volume_model;
++    enum model output_mute_model;
++    enum model input_mute_model;
++    pa_hashmap *contexts; /* name -> struct context */
++
++    pa_hook_slot *active_main_volume_context_changed_slot;
++
++    /* The following fields are only used during initialization. */
++    pa_hashmap *context_names; /* name -> name (hashmap-as-a-set) */
++    pa_hashmap *unused_contexts; /* name -> struct context */
++};
++
++struct context {
++    struct userdata *userdata;
++    char *name;
++    char *description;
++    pa_binding_target_info *main_output_volume_control_target_info;
++    pa_binding_target_info *main_input_volume_control_target_info;
++    pa_binding_target_info *main_output_mute_control_target_info;
++    pa_binding_target_info *main_input_mute_control_target_info;
++    pa_main_volume_context *main_volume_context;
++
++    bool unlinked;
++};
++
++static void context_unlink(struct context *context);
++
++static const char *model_to_string(enum model model) {
++    switch (model) {
++        case MODEL_NONE:
++            return "none";
++
++        case MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT:
++            return "by-active-main-volume-context";
++    }
++
++    pa_assert_not_reached();
++}
++
++static int model_from_string(const char *str, enum model *model) {
++    pa_assert(str);
++    pa_assert(model);
++
++    if (pa_streq(str, "none"))
++        *model = MODEL_NONE;
++    else if (pa_streq(str, "by-active-main-volume-context"))
++        *model = MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT;
++    else
++        return -PA_ERR_INVALID;
++
++    return 0;
++}
++
++static struct context *context_new(struct userdata *u, const char *name) {
++    struct context *context;
++
++    pa_assert(u);
++    pa_assert(name);
++
++    context = pa_xnew0(struct context, 1);
++    context->userdata = u;
++    context->name = pa_xstrdup(name);
++    context->description = pa_xstrdup(name);
++
++    return context;
++}
++
++static int context_put(struct context *context) {
++    int r;
++
++    pa_assert(context);
++
++    r = pa_main_volume_context_new(context->userdata->main_volume_policy, context->name, context->description,
++                                   &context->main_volume_context);
++    if (r < 0)
++        goto fail;
++
++    if (context->main_output_volume_control_target_info)
++        pa_main_volume_context_bind_main_output_volume_control(context->main_volume_context,
++                                                               context->main_output_volume_control_target_info);
++
++    if (context->main_input_volume_control_target_info)
++        pa_main_volume_context_bind_main_input_volume_control(context->main_volume_context,
++                                                              context->main_input_volume_control_target_info);
++
++    if (context->main_output_mute_control_target_info)
++        pa_main_volume_context_bind_main_output_mute_control(context->main_volume_context,
++                                                             context->main_output_mute_control_target_info);
++
++    if (context->main_input_mute_control_target_info)
++        pa_main_volume_context_bind_main_input_mute_control(context->main_volume_context,
++                                                            context->main_input_mute_control_target_info);
++
++    pa_main_volume_context_put(context->main_volume_context);
++
++    return 0;
++
++fail:
++    context_unlink(context);
++
++    return r;
++}
++
++static void context_unlink(struct context *context) {
++    pa_assert(context);
++
++    if (context->unlinked)
++        return;
++
++    context->unlinked = true;
++
++    if (context->main_volume_context) {
++        pa_main_volume_context_free(context->main_volume_context);
++        context->main_volume_context = NULL;
++    }
++}
++
++static void context_free(struct context *context) {
++    pa_assert(context);
++
++    if (!context->unlinked)
++        context_unlink(context);
++
++    if (context->main_input_mute_control_target_info)
++        pa_binding_target_info_free(context->main_input_mute_control_target_info);
++
++    if (context->main_output_mute_control_target_info)
++        pa_binding_target_info_free(context->main_output_mute_control_target_info);
++
++    if (context->main_input_volume_control_target_info)
++        pa_binding_target_info_free(context->main_input_volume_control_target_info);
++
++    if (context->main_output_volume_control_target_info)
++        pa_binding_target_info_free(context->main_output_volume_control_target_info);
++
++    pa_xfree(context->description);
++    pa_xfree(context->name);
++    pa_xfree(context);
++}
++
++static void context_set_description(struct context *context, const char *description) {
++    pa_assert(context);
++    pa_assert(description);
++
++    pa_xfree(context->description);
++    context->description = pa_xstrdup(description);
++}
++
++static void context_set_main_control_target_info(struct context *context, enum control_type type, pa_direction_t direction,
++                                                 pa_binding_target_info *info) {
++    pa_assert(context);
++
++    switch (type) {
++        case CONTROL_TYPE_VOLUME:
++            if (direction == PA_DIRECTION_OUTPUT) {
++                if (context->main_output_volume_control_target_info)
++                    pa_binding_target_info_free(context->main_output_volume_control_target_info);
++
++                if (info)
++                    context->main_output_volume_control_target_info = pa_binding_target_info_copy(info);
++                else
++                    context->main_output_volume_control_target_info = NULL;
++            } else {
++                if (context->main_input_volume_control_target_info)
++                    pa_binding_target_info_free(context->main_input_volume_control_target_info);
++
++                if (info)
++                    context->main_input_volume_control_target_info = pa_binding_target_info_copy(info);
++                else
++                    context->main_input_volume_control_target_info = NULL;
++            }
++            break;
++
++        case CONTROL_TYPE_MUTE:
++            if (direction == PA_DIRECTION_OUTPUT) {
++                if (context->main_output_mute_control_target_info)
++                    pa_binding_target_info_free(context->main_output_mute_control_target_info);
++
++                if (info)
++                    context->main_output_mute_control_target_info = pa_binding_target_info_copy(info);
++                else
++                    context->main_output_mute_control_target_info = NULL;
++            } else {
++                if (context->main_input_mute_control_target_info)
++                    pa_binding_target_info_free(context->main_input_mute_control_target_info);
++
++                if (info)
++                    context->main_input_mute_control_target_info = pa_binding_target_info_copy(info);
++                else
++                    context->main_input_mute_control_target_info = NULL;
++            }
++            break;
++    }
++}
++
++static pa_hook_result_t active_main_volume_context_changed_cb(void *hook_data, void *call_data, void *userdata) {
++    struct userdata *u = userdata;
++    pa_main_volume_context *context;
++    pa_volume_api *api;
++    pa_binding_target_info *info = NULL;
++
++    pa_assert(u);
++
++    context = u->main_volume_policy->active_main_volume_context;
++    api = u->main_volume_policy->volume_api;
++
++    if (u->output_volume_model == MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT) {
++        if (context) {
++            info = pa_binding_target_info_new(PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_TYPE, context->name,
++                                              PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_OUTPUT_VOLUME_CONTROL);
++            pa_volume_api_bind_main_output_volume_control(api, info);
++        } else
++            pa_volume_api_set_main_output_volume_control(api, NULL);
++    }
++
++    if (u->input_volume_model == MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT) {
++        if (context) {
++            info = pa_binding_target_info_new(PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_TYPE, context->name,
++                                              PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_INPUT_VOLUME_CONTROL);
++            pa_volume_api_bind_main_input_volume_control(api, info);
++        } else
++            pa_volume_api_set_main_input_volume_control(api, NULL);
++    }
++
++    if (u->output_mute_model == MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT) {
++        if (context) {
++            info = pa_binding_target_info_new(PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_TYPE, context->name,
++                                              PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_OUTPUT_MUTE_CONTROL);
++            pa_volume_api_bind_main_output_mute_control(api, info);
++        } else
++            pa_volume_api_set_main_output_mute_control(api, NULL);
++    }
++
++    if (u->input_mute_model == MODEL_BY_ACTIVE_MAIN_VOLUME_CONTEXT) {
++        if (context) {
++            info = pa_binding_target_info_new(PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_TYPE, context->name,
++                                              PA_MAIN_VOLUME_CONTEXT_BINDING_TARGET_FIELD_MAIN_INPUT_MUTE_CONTROL);
++            pa_volume_api_bind_main_input_mute_control(api, info);
++        } else
++            pa_volume_api_set_main_input_mute_control(api, NULL);
++    }
++
++    if (info)
++        pa_binding_target_info_free(info);
++
++    return PA_HOOK_OK;
++}
++
++static int parse_model(pa_config_parser_state *state) {
++    int r;
++
++    pa_assert(state);
++
++    r = model_from_string(state->rvalue, state->data);
++    if (r < 0)
++        pa_log("[%s:%u] Failed to parse model: %s", state->filename, state->lineno, state->rvalue);
++
++    return r;
++}
++
++static int parse_main_volume_contexts(pa_config_parser_state *state) {
++    struct userdata *u;
++    char *name;
++    const char *split_state = NULL;
++
++    pa_assert(state);
++
++    u = state->userdata;
++
++    while ((name = pa_split_spaces(state->rvalue, &split_state)))
++        pa_hashmap_put(u->context_names, name, name);
++
++    return 0;
++}
++
++static struct context *get_context(struct userdata *u, const char *section) {
++    const char *name;
++    struct context *context;
++
++    pa_assert(u);
++
++    if (!section)
++        return NULL;
++
++    if (!pa_startswith(section, "MainVolumeContext "))
++        return NULL;
++
++    name = section + 18;
++
++    context = pa_hashmap_get(u->unused_contexts, name);
++    if (!context) {
++        context = context_new(u, name);
++        pa_hashmap_put(u->unused_contexts, context->name, context);
++    }
++
++    return context;
++}
++
++static int parse_description(pa_config_parser_state *state) {
++    struct userdata *u;
++    struct context *context;
++
++    pa_assert(state);
++
++    u = state->userdata;
++
++    context = get_context(u, state->section);
++    if (!context) {
++        pa_log("[%s:%u] Key \"%s\" not expected in section %s.", state->filename, state->lineno, state->lvalue,
++               pa_strnull(state->section));
++        return -PA_ERR_INVALID;
++    }
++
++    context_set_description(context, state->rvalue);
++
++    return 0;
++}
++
++static const char *get_target_field_name(enum control_type type) {
++    switch (type) {
++        case CONTROL_TYPE_VOLUME:
++            return "volume_control";
++
++        case CONTROL_TYPE_MUTE:
++            return "mute_control";
++    }
++
++    pa_assert_not_reached();
++}
++
++static int parse_main_control(pa_config_parser_state *state, enum control_type type, pa_direction_t direction) {
++    struct userdata *u;
++    struct context *context;
++
++    pa_assert(state);
++
++    u = state->userdata;
++
++    context = get_context(u, state->section);
++    if (!context) {
++        pa_log("[%s:%u] Key \"%s\" not expected in section %s.", state->filename, state->lineno, state->lvalue,
++               pa_strnull(state->section));
++        return -PA_ERR_INVALID;
++    }
++
++    if (pa_streq(state->rvalue, "none"))
++        context_set_main_control_target_info(context, type, direction, NULL);
++    else if (pa_startswith(state->rvalue, "bind:")) {
++        int r;
++        pa_binding_target_info *info;
++
++        r = pa_binding_target_info_new_from_string(state->rvalue, get_target_field_name(type), &info);
++        if (r < 0) {
++            pa_log("[%s:%u] Failed to parse binding target \"%s\".", state->filename, state->lineno, state->rvalue);
++            return r;
++        }
++
++        context_set_main_control_target_info(context, type, direction, info);
++        pa_binding_target_info_free(info);
++    } else {
++        pa_log("[%s:%u] Failed to parse value \"%s\".", state->filename, state->lineno, state->rvalue);
++        return -PA_ERR_INVALID;
++    }
++
++    return 0;
++}
++
++static int parse_main_output_volume_control(pa_config_parser_state *state) {
++    pa_assert(state);
++
++    return parse_main_control(state, CONTROL_TYPE_VOLUME, PA_DIRECTION_OUTPUT);
++}
++
++static int parse_main_input_volume_control(pa_config_parser_state *state) {
++    pa_assert(state);
++
++    return parse_main_control(state, CONTROL_TYPE_VOLUME, PA_DIRECTION_INPUT);
++}
++
++static int parse_main_output_mute_control(pa_config_parser_state *state) {
++    pa_assert(state);
++
++    return parse_main_control(state, CONTROL_TYPE_MUTE, PA_DIRECTION_OUTPUT);
++}
++
++static int parse_main_input_mute_control(pa_config_parser_state *state) {
++    pa_assert(state);
++
++    return parse_main_control(state, CONTROL_TYPE_MUTE, PA_DIRECTION_INPUT);
++}
++
++static void finalize_config(struct userdata *u) {
++    const char *context_name;
++    void *state;
++    struct context *context;
++
++    pa_assert(u);
++
++    PA_HASHMAP_FOREACH(context_name, u->context_names, state) {
++        int r;
++
++        context = pa_hashmap_remove(u->unused_contexts, context_name);
++        if (!context)
++            context = context_new(u, context_name);
++
++        r = context_put(context);
++        if (r < 0) {
++            pa_log_warn("Failed to create main volume context %s.", context_name);
++            context_free(context);
++            continue;
++        }
++
++        pa_assert_se(pa_hashmap_put(u->contexts, context->name, context) >= 0);
++    }
++
++    PA_HASHMAP_FOREACH(context, u->unused_contexts, state)
++        pa_log_debug("Main volume context %s is not used.", context->name);
++
++    pa_hashmap_free(u->unused_contexts);
++    u->unused_contexts = NULL;
++
++    pa_hashmap_free(u->context_names);
++    u->context_names = NULL;
++}
++
++int pa__init(pa_module *module) {
++    struct userdata *u;
++    FILE *f;
++    char *fn = NULL;
++
++    pa_assert(module);
++
++    u = module->userdata = pa_xnew0(struct userdata, 1);
++    u->main_volume_policy = pa_main_volume_policy_get(module->core);
++    u->output_volume_model = MODEL_NONE;
++    u->input_volume_model = MODEL_NONE;
++    u->output_mute_model = MODEL_NONE;
++    u->input_mute_model = MODEL_NONE;
++    u->contexts = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
++                                      (pa_free_cb_t) context_free);
++    u->active_main_volume_context_changed_slot =
++            pa_hook_connect(&u->main_volume_policy->hooks[PA_MAIN_VOLUME_POLICY_HOOK_ACTIVE_MAIN_VOLUME_CONTEXT_CHANGED],
++                            PA_HOOK_NORMAL, active_main_volume_context_changed_cb, u);
++    u->context_names = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, pa_xfree);
++    u->unused_contexts = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL,
++                                             (pa_free_cb_t) context_free);
++
++    f = pa_open_config_file(PA_DEFAULT_CONFIG_DIR PA_PATH_SEP "main-volume-policy.conf", "main-volume-policy.conf", NULL, &fn);
++    if (f) {
++        pa_config_item config_items[] = {
++            { "output-volume-model", parse_model, &u->output_volume_model, "General" },
++            { "input-volume-model", parse_model, &u->input_volume_model, "General" },
++            { "output-mute-model", parse_model, &u->output_mute_model, "General" },
++            { "input-mute-model", parse_model, &u->input_mute_model, "General" },
++            { "main-volume-contexts", parse_main_volume_contexts, NULL, "General" },
++            { "description", parse_description, NULL, NULL },
++            { "main-output-volume-control", parse_main_output_volume_control, NULL, NULL },
++            { "main-input-volume-control", parse_main_input_volume_control, NULL, NULL },
++            { "main-output-mute-control", parse_main_output_mute_control, NULL, NULL },
++            { "main-input-mute-control", parse_main_input_mute_control, NULL, NULL },
++            { NULL },
++        };
++
++        pa_config_parse(fn, f, config_items, NULL, u);
++        pa_xfree(fn);
++        fn = NULL;
++        fclose(f);
++        f = NULL;
++    }
++
++    finalize_config(u);
++
++    pa_log_debug("Output volume model: %s", model_to_string(u->output_volume_model));
++    pa_log_debug("Input volume model: %s", model_to_string(u->input_volume_model));
++    pa_log_debug("Output mute model: %s", model_to_string(u->output_mute_model));
++    pa_log_debug("Input mute model: %s", model_to_string(u->input_mute_model));
++
++    return 0;
++}
++
++void pa__done(pa_module *module) {
++    struct userdata *u;
++
++    pa_assert(module);
++
++    u = module->userdata;
++    if (!u)
++        return;
++
++    if (u->active_main_volume_context_changed_slot)
++        pa_hook_slot_free(u->active_main_volume_context_changed_slot);
++
++    if (u->contexts)
++        pa_hashmap_free(u->contexts);
++
++    if (u->main_volume_policy)
++        pa_main_volume_policy_unref(u->main_volume_policy);
++
++    pa_xfree(u);
++}
+-- 
+2.1.4
+
+--- a/po/POTFILES.in   2016-04-14 13:03:50.715006116 +0200
++++ b/po/POTFILES.in   2016-04-14 13:04:23.097006062 +0200
+@@ -200,3 +200,4 @@
+ src/utils/pax11publish.c
+ src/modules/volume-api/device-creator.c
+ src/pulse/ext-volume-api.c
++src/modules/main-volume-policy/module-main-volume-policy.c

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0039-main-volume-policy-adapt-to-pa6rev.patch b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0039-main-volume-policy-adapt-to-pa6rev.patch
new file mode 100644 (file)
index 0000000..4f27771
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0039-main-volume-policy-adapt-to-pa6rev.patch
@@ -0,0 +1,11 @@
+--- a/src/modules/main-volume-policy/module-main-volume-policy.c       2016-04-18 10:59:46.124086205 +0200
++++ b/src/modules/main-volume-policy/module-main-volume-policy.c       2016-04-18 11:01:31.497089360 +0200
+@@ -517,7 +517,7 @@
+             { NULL },
+         };
+ 
+-        pa_config_parse(fn, f, config_items, NULL, u);
++        pa_config_parse(fn, f, config_items, NULL, false, u);
+         pa_xfree(fn);
+         fn = NULL;
+         fclose(f);

diff --git a/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio_6.0.bbappend b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio_6.0.bbappend
new file mode 100644 (file)
index 0000000..7b1ffbe
--- /dev/null
+++ b/meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio_6.0.bbappend
@@ -0,0 +1,19 @@
+FILESEXTRAPATHS_prepend := "${THISDIR}/pulseaudio:"
+
+SRC_URI += " \
+             file://0008-install-files-for-a-module-development.patch \
+             file://0010-volume-ramp-additions-to-the-low-level-infra.patch \
+             file://0011-volume-ramp-adding-volume-ramping-to-sink-input.patch \
+             file://0012-volume-ramp-add-volume-ramping-to-sink.patch \
+             file://0013-add-internal-corking-state-for-sink-input.patch \
+             file://0020-core-util-Add-pa_join.patch \
+             file://0021-dynarray-Add-pa_dynarray_get_raw_array.patch \
+             file://0022-device-port-Add-pa_device_port.active.patch \
+             file://0030-volume-api-Add-libvolume-api.patch \
+             file://0031-Add-module-main-volume-policy.patch \
+             file://0039-main-volume-policy-adapt-to-pa6rev.patch \
+           "
+
+PACKAGES =+ " pulseaudio-module-dev"
+
+FILES_pulseaudio-module-dev = "${includedir}/pulsemodule/* ${libdir}/pkgconfig/pulseaudio-module-devel.pc"