aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0008-install-files-for-a-module-development.patch53
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0010-volume-ramp-additions-to-the-low-level-infra.patch503
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0011-volume-ramp-adding-volume-ramping-to-sink-input.patch159
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0012-volume-ramp-add-volume-ramping-to-sink.patch159
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0013-add-internal-corking-state-for-sink-input.patch72
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0020-core-util-Add-pa_join.patch37
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0021-dynarray-Add-pa_dynarray_get_raw_array.patch21
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0022-device-port-Add-pa_device_port.active.patch198
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0030-volume-api-Add-libvolume-api.patch6118
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0031-Add-module-main-volume-policy.patch1418
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio/0039-main-volume-policy-adapt-to-pa6rev.patch11
-rw-r--r--meta-ivi-common/recipes-multimedia/pulseaudio/pulseaudio_6.0.bbappend19
12 files changed, 8768 insertions, 0 deletions
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
index 000000000..ac164d643
--- /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
index 000000000..e249bc438
--- /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
index 000000000..08fb79248
--- /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
index 000000000..43e8283ef
--- /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
index 000000000..cb68e26af
--- /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
index 000000000..891a5b83a
--- /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
index 000000000..040913c8f
--- /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
index 000000000..4a8143f61
--- /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
index 000000000..b904ac315
--- /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
index 000000000..216ed21e9
--- /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
index 000000000..4f2777112
--- /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
index 000000000..7b1ffbe0e
--- /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"