Attachment 121428 Details for Bug 56993 – Same as opus patch, with extra patches to fix module-combine-sink with network sinks.

[patch] Same as opus patch, with extra patches to fix module-combine-sink with network sinks.

pa-rapoll-mainloop-opus-tunnel-combine-fixes.patch (text/plain), 406.19 KB, created by gavin_darkglider on 2016-01-31 21:00:31 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: gavin_darkglider

Created: 2016-01-31 21:00:31 UTC

Size: 406.19 KB

patch

obsolete

>diff -Naur a/configure.ac b/configure.ac
>--- a/configure.ac	2016-01-30 17:31:05.000000000 -0800
>+++ b/configure.ac	2016-01-31 12:11:22.000000000 -0800
>@@ -1154,6 +1154,21 @@
> AM_CONDITIONAL([HAVE_SPEEX], [test "x$HAVE_SPEEX" = "x1"])
> AS_IF([test "x$HAVE_SPEEX" = "x1"], AC_DEFINE([HAVE_SPEEX], 1, [Have speex]))
> 
>+#### opus (optional) ####
>+
>+AC_ARG_WITH([opus],
>+    AS_HELP_STRING([--without-opus],[Omit opus (transcoding, tunnel)]))
>+
>+AS_IF([test "x$with_opus" != "xno"],
>+    [PKG_CHECK_MODULES(LIBOPUS, [ opus >= 1.1 ], HAVE_OPUS=1, HAVE_OPUS=0)],
>+    HAVE_OPUS=0)
>+
>+AS_IF([test "x$with_opus" = "xyes" && test "x$HAVE_OPUS" = "x0"],
>+    [AC_MSG_ERROR([*** opus support not found])])
>+
>+AM_CONDITIONAL([HAVE_OPUS], [test "x$HAVE_OPUS" = "x1"])
>+AS_IF([test "x$HAVE_OPUS" = "x1"], AC_DEFINE([HAVE_OPUS], 1, [Have opus]))
>+
> #### soxr (optional) ####
> 
> AC_ARG_WITH([soxr],
>@@ -1575,6 +1590,7 @@
> AS_IF([test "x$HAVE_GCOV" = "x1"], ENABLE_GCOV=yes, ENABLE_GCOV=no)
> AS_IF([test "x$HAVE_LIBCHECK" = "x1"], ENABLE_TESTS=yes, ENABLE_TESTS=no)
> AS_IF([test "x$enable_legacy_database_entry_format" != "xno"], ENABLE_LEGACY_DATABASE_ENTRY_FORMAT=yes, ENABLE_LEGACY_DATABASE_ENTRY_FORMAT=no)
>+AS_IF([test "x$HAVE_OPUS" = "x1"], ENABLE_OPUS=yes, ENABLE_OPUS=no)
> 
> echo "
>  ---{ $PACKAGE_NAME $VERSION }---
>@@ -1632,6 +1648,7 @@
>     Enable WebRTC echo canceller:  ${ENABLE_WEBRTC}
>     Enable gcov coverage:          ${ENABLE_GCOV}
>     Enable unit tests:             ${ENABLE_TESTS}
>+    Enable opus (transcoding):     ${ENABLE_OPUS}
>     Database
>       tdb:                         ${ENABLE_TDB}
>       gdbm:                        ${ENABLE_GDBM}
>diff -Naur a/configure.ac.orig b/configure.ac.orig
>--- a/configure.ac.orig	1969-12-31 16:00:00.000000000 -0800
>+++ b/configure.ac.orig	2016-01-31 12:11:22.000000000 -0800
>@@ -0,0 +1,1687 @@
>+# -*- Autoconf -*-
>+# Process this file with autoconf to produce a configure script.
>+
>+# This file is part of PulseAudio.
>+#
>+# Copyright 2004-2008 Lennart Poettering
>+# Copyright 2006-2007 Pierre Ossman <ossman@cendio.se> for Cendio AB
>+#
>+# PulseAudio is free software; you can redistribute it and/or modify it
>+# under the terms of the GNU Lesser General Public License as published by
>+# the Free Software Foundation; either version 2 of the License, or
>+# (at your option) any later version.
>+#
>+# PulseAudio is distributed in the hope that it will be useful, but
>+# WITHOUT ANY WARRANTY; without even the implied warranty of
>+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
>+# General Public License for more details.
>+#
>+# You should have received a copy of the GNU Lesser General Public License
>+# along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
>+
>+AC_PREREQ(2.63)
>+
>+AC_INIT([pulseaudio],[m4_esyscmd(./git-version-gen .tarball-version)],[pulseaudio-discuss (at) lists (dot) freedesktop (dot) org],[pulseaudio],[http://pulseaudio.org/])
>+AC_CONFIG_SRCDIR([src/daemon/main.c])
>+AC_CONFIG_MACRO_DIR([m4])
>+AC_CONFIG_HEADERS([config.h])
>+AC_CONFIG_AUX_DIR([build-aux])
>+AM_INIT_AUTOMAKE([foreign 1.11 -Wall -Wno-portability subdir-objects silent-rules color-tests dist-xz tar-ustar])
>+
>+AS_IF([! test -n "$VERSION"], [
>+   AC_MSG_ERROR([git-version-gen failed])
>+])
>+
>+m4_define(pa_major, `echo $VERSION | cut -d. -f1 | cut -d- -f1`)
>+m4_define(pa_minor, `echo $VERSION | cut -d. -f2 | cut -d- -f1`)
>+
>+AC_SUBST(PA_MAJOR, pa_major)
>+AC_SUBST(PA_MINOR, pa_minor)
>+AC_SUBST(PA_MAJORMINOR, pa_major.pa_minor)
>+
>+AC_SUBST(PA_API_VERSION, 12)
>+AC_SUBST(PA_PROTOCOL_VERSION, 30)
>+
>+# The stable ABI for client applications, for the version info x:y:z
>+# always will hold y=z
>+AC_SUBST(LIBPULSE_VERSION_INFO, [19:0:19])
>+
>+# A simplified, synchronous, ABI-stable interface for client
>+# applications, for the version info x:y:z always will hold y=z
>+AC_SUBST(LIBPULSE_SIMPLE_VERSION_INFO, [1:0:1])
>+
>+# The ABI-stable GLib adapter for client applications, for the version
>+# info x:y:z always will hold y=z
>+AC_SUBST(LIBPULSE_MAINLOOP_GLIB_VERSION_INFO, [0:5:0])
>+
>+AC_CANONICAL_HOST
>+AC_DEFINE_UNQUOTED([CANONICAL_HOST], "$host", [Canonical host string.])
>+
>+AC_CHECK_PROG([STOW], [stow], [yes], [no])
>+
>+AS_IF([test "x$STOW" = "xyes" && test -d /usr/local/stow], [
>+    AC_MSG_NOTICE([*** Found /usr/local/stow: default install prefix set to /usr/local/stow/${PACKAGE_NAME}-${PACKAGE_VERSION} ***])
>+    ac_default_prefix="/usr/local/stow/${PACKAGE_NAME}-${PACKAGE_VERSION}"
>+])
>+
>+AM_SILENT_RULES([yes])
>+
>+
>+#### Checks for programs. ####
>+
>+# mkdir -p
>+
>+AC_PROG_MKDIR_P
>+
>+# ln -s
>+
>+AC_PROG_LN_S
>+
>+# CC
>+
>+AC_PROG_CC
>+AC_PROG_CC_C99
>+AM_PROG_CC_C_O
>+# Only required if you want the WebRTC canceller -- no runtime dep on
>+# libstdc++ otherwise
>+AC_PROG_CXX
>+AC_PROG_GCC_TRADITIONAL
>+AC_USE_SYSTEM_EXTENSIONS
>+
>+# M4
>+
>+AC_CHECK_PROGS([M4], gm4 m4, no)
>+AS_IF([test "x$M4" = "xno"], AC_MSG_ERROR([m4 missing]))
>+
>+# pkg-config
>+
>+PKG_PROG_PKG_CONFIG
>+
>+# gettext
>+
>+if test "x$enable_nls" != "xno"; then
>+IT_PROG_INTLTOOL([0.35.0])
>+
>+AM_GNU_GETTEXT_VERSION([0.18.1])
>+AM_GNU_GETTEXT([external])
>+
>+GETTEXT_PACKAGE=pulseaudio
>+AC_SUBST([GETTEXT_PACKAGE])
>+AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE],["$GETTEXT_PACKAGE"],[Gettext package])
>+else
>+# workaround till an intltool m4 bug is fixed upstream
>+# (https://bugs.launchpad.net/intltool/+bug/904647)
>+USE_NLS=no
>+AC_SUBST(USE_NLS)
>+fi
>+
>+
>+#### Determine host OS ####
>+
>+# if the host has the possibility of sys/capability.h for dropping privileges
>+# used to determine if we should error out if it is not found
>+host_has_caps=0
>+
>+os_is_linux=0
>+os_is_win32=0
>+os_is_darwin=0
>+
>+AC_MSG_CHECKING([host operating system])
>+case "$host_os" in
>+    linux*)
>+        AC_MSG_RESULT([linux])
>+        host_has_caps=1
>+        os_is_linux=1
>+    ;;
>+    freebsd*)
>+        AC_MSG_RESULT([freebsd])
>+        host_has_caps=1
>+    ;;
>+    netbsd*)
>+        AC_MSG_RESULT([netbsd])
>+    ;;
>+    darwin*)
>+        AC_MSG_RESULT([darwin])
>+        os_is_darwin=1
>+        AC_DEFINE([OS_IS_DARWIN], 1, [Build target is Darwin.])
>+    ;;
>+    mingw*)
>+        AC_MSG_RESULT([win32])
>+        os_is_win32=1
>+        AC_DEFINE([OS_IS_WIN32], 1, [Build target is Windows.])
>+    ;;
>+    *)
>+        AC_MSG_RESULT([unknown])
>+    ;;
>+esac
>+
>+AM_CONDITIONAL(OS_IS_DARWIN, test "x$os_is_darwin" = "x1")
>+AM_CONDITIONAL(OS_IS_WIN32, test "x$os_is_win32" = "x1")
>+AC_SUBST([OS_IS_WIN32], [$os_is_win32])
>+
>+# Platform specific hacks
>+case "$host_os" in
>+    darwin* )
>+        AC_DEFINE([_DARWIN_C_SOURCE], [200112L], [Needed to get NSIG on Mac OS X])
>+    ;;
>+    mingw* )
>+        AC_DEFINE([WIN32_LEAN_AND_MEAN], 1, [Needed to avoid including unnecessary headers on Windows])
>+    ;;
>+    solaris* )
>+        AC_DEFINE(_XOPEN_SOURCE,       600, [Needed to get declarations for msg_control and msg_controllen on Solaris])
>+        AC_DEFINE(__EXTENSIONS__,        1, [Needed to get declarations for msg_control and msg_controllen on Solaris])
>+    ;;
>+esac
>+
>+
>+#### Compiler flags ####
>+
>+AX_APPEND_COMPILE_FLAGS(
>+    [-Wall -W -Wextra -pipe -Wno-long-long -Wno-overlength-strings -Wunsafe-loop-optimizations -Wundef -Wformat=2 -Wlogical-op -Wsign-compare -Wformat-security -Wmissing-include-dirs -Wformat-nonliteral -Wold-style-definition -Wpointer-arith -Winit-self -Wdeclaration-after-statement -Wfloat-equal -Wmissing-prototypes -Wstrict-prototypes -Wredundant-decls -Wmissing-declarations -Wmissing-noreturn -Wshadow -Wendif-labels -Wcast-align -Wstrict-aliasing -Wwrite-strings -Wno-unused-parameter -ffast-math -fno-common -fdiagnostics-show-option -fdiagnostics-color=auto],
>+    [], [-pedantic -Werror])
>+
>+AS_CASE([" $CFLAGS "], [*" -O0 "*], [], [
>+    # Don't append the flag if it already exists.
>+    # Only enable fastpath asserts when doing a debug build, e.g. from bootstrap.sh.
>+    AX_APPEND_FLAG([-DFASTPATH], [CPPFLAGS])
>+
>+    # Cannot use AX_APPEND_FLAG here, as it assumes no space inside the added flags.
>+    # Cannot append flags with AX_APPEND_FLAG one by one, as this would destroy all fortifications
>+    # if CPPFLAGS already contain -D_FORTIFY_SOURCE=2.
>+
>+    # Warnings to be aware of that appear with -D_FORTIFY_SOURCE=2 but without -U_FORTIFY_SOURCE:
>+    # On Fedora 20 with -O0: #warning _FORTIFY_SOURCE requires compiling with optimization (-O) [-Wcpp]
>+    # On Gentoo with -O2:    "_FORTIFY_SOURCE" redefined [enabled by default]
>+    AS_VAR_APPEND([CPPFLAGS],[" -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"])
>+])
>+
>+#### Linker flags ####
>+
>+# Check whether the linker supports the -version-script option.
>+# The Make variable $(srcdir) needs to be in the LDFLAGS in that form,
>+# so that it is expanded the right way in every subdir.
>+AX_CHECK_LINK_FLAG(["-Wl,-version-script=${srcdir}/src/map-file"],
>+    [VERSIONING_LDFLAGS='-Wl,-version-script=$(abs_top_srcdir)/src/map-file'])
>+AC_SUBST([VERSIONING_LDFLAGS])
>+
>+# Use immediate (now) bindings; avoids the funky re-call in itself.
>+# The -z now syntax is lifted from Sun's linker and works with GNU's too, other linkers might be added later.
>+AX_APPEND_LINK_FLAGS([-Wl,-z,now], [IMMEDIATE_LDFLAGS])
>+AC_SUBST([IMMEDIATE_LDFLAGS])
>+
>+# On ELF systems we don't want the libraries to be unloaded since we don't clean them up properly,
>+# so we request the nodelete flag to be enabled.
>+# On other systems, we don't really know how to do that, but it's welcome if somebody can tell.
>+AX_APPEND_LINK_FLAGS([-Wl,-z,nodelete], [NODELETE_LDFLAGS], [-shared])
>+AC_SUBST([NODELETE_LDFLAGS])
>+
>+# Check for the proper way to build libraries that have no undefined symbols
>+case $host in
>+    # FreeBSD (et al.) does not complete linking for shared objects when pthreads
>+    # are requested, as different implementations are present.
>+    *-freebsd* | *-openbsd*) ;;
>+    *)
>+        for possible_flag in "-Wl,--no-undefined" "-Wl,-z,defs"; do
>+            AX_CHECK_LINK_FLAG([$possible_flag], [NOUNDEFINED_LDFLAGS="$possible_flag"; break])
>+        done
>+    ;;
>+esac
>+AC_SUBST([NOUNDEFINED_LDFLAGS])
>+
>+
>+#### Atomic operations ####
>+
>+# Native atomic operation support
>+AC_ARG_ENABLE([atomic-arm-linux-helpers],
>+    AS_HELP_STRING([--disable-atomic-arm-linux-helpers],[use inline asm or libatomic_ops instead]))
>+
>+AC_ARG_ENABLE([atomic-arm-memory-barrier],
>+    AS_HELP_STRING([--enable-atomic-arm-memory-barrier],[only really needed in SMP arm systems]))
>+
>+if test "x$enable_atomic_arm_memory_barrier" = "xyes"; then
>+    AC_DEFINE_UNQUOTED(ATOMIC_ARM_MEMORY_BARRIER_ENABLED, 1, [Enable memory barriers])
>+fi
>+
>+# If everything else fails use libatomic_ops
>+need_libatomic_ops=yes
>+
>+AC_CACHE_CHECK([whether $CC knows __sync_bool_compare_and_swap()],
>+    pulseaudio_cv_sync_bool_compare_and_swap, [
>+    AC_LINK_IFELSE(
>+        [AC_LANG_PROGRAM([], [[int a = 4; __sync_bool_compare_and_swap(&a, 4, 5);]])],
>+        [pulseaudio_cv_sync_bool_compare_and_swap=yes],
>+        [pulseaudio_cv_sync_bool_compare_and_swap=no])
>+    ])
>+
>+if test "$pulseaudio_cv_sync_bool_compare_and_swap" = "yes" ; then
>+    AC_DEFINE([HAVE_ATOMIC_BUILTINS], 1, [Have __sync_bool_compare_and_swap() and friends.])
>+    need_libatomic_ops=no
>+else
>+    # HW specific atomic ops stuff
>+    AC_MSG_CHECKING([architecture for native atomic operations])
>+    case $host in
>+        *-netbsd*)
>+            AC_MSG_RESULT([yes])
>+            need_libatomic_ops=no
>+        ;;
>+        arm*)
>+            AC_MSG_RESULT([arm])
>+            AC_MSG_CHECKING([whether we can use Linux kernel helpers])
>+            # The Linux kernel helper functions have been there since 2.6.16. However
>+            # compile time checking for kernel version in cross compile environment
>+            # (which is usually the case for arm cpu) is tricky (or impossible).
>+            if test "x$os_is_linux" = "x1" && test "x$enable_atomic_arm_linux_helpers" != "xno"; then
>+                AC_MSG_RESULT([yes])
>+                AC_DEFINE_UNQUOTED(ATOMIC_ARM_LINUX_HELPERS, 1, [special arm linux implementation])
>+                need_libatomic_ops=no
>+            else
>+                AC_MSG_RESULT([no])
>+                AC_CACHE_CHECK([compiler support for arm inline asm atomic operations],
>+                    pulseaudio_cv_support_arm_atomic_ops, [
>+                    AC_COMPILE_IFELSE(
>+                        [AC_LANG_PROGRAM([], [[
>+                            volatile int a=0;
>+                            int o=0, n=1, r;
>+                            asm volatile ("ldrex    %0, [%1]\n"
>+                                          "subs  %0, %0, %2\n"
>+                                          "strexeq %0, %3, [%1]\n"
>+                                          : "=&r" (r)
>+                                          : "r" (&a), "Ir" (o), "r" (n)
>+                                          : "cc");
>+                            return (a==1 ? 0 : -1);
>+                        ]])],
>+                        [pulseaudio_cv_support_arm_atomic_ops=yes],
>+                        [pulseaudio_cv_support_arm_atomic_ops=no])
>+                ])
>+                AS_IF([test "$pulseaudio_cv_support_arm_atomic_ops" = "yes"], [
>+                    AC_DEFINE([ATOMIC_ARM_INLINE_ASM], 1, [Have ARM atomic instructions.])
>+                    need_libatomic_ops=no
>+                ])
>+            fi
>+        ;;
>+        *-freebsd*)
>+            AC_MSG_RESULT([yes])
>+            need_libatomic_ops=no
>+        ;;
>+        *)
>+            AC_MSG_RESULT([unknown])
>+        ;;
>+    esac
>+fi
>+
>+# If we're on ARM, check for the ARMV6 instructions we need */
>+case $host in
>+  arm*)
>+    AC_CACHE_CHECK([support for required armv6 instructions],
>+      pulseaudio_cv_support_armv6,
>+      [AC_COMPILE_IFELSE(
>+         [AC_LANG_PROGRAM([],
>+           [[volatile int a = -60000, b = 0xaaaabbbb, c = 0xccccdddd;
>+             asm volatile ("ldr r0, %2 \n"
>+                           "ldr r2, %3 \n"
>+                           "ldr r3, %4 \n"
>+                           "ssat r1, #8, r0 \n"
>+                           "str r1, %0 \n"
>+                           "pkhbt r1, r3, r2, LSL #8 \n"
>+                           "str r1, %1 \n"
>+                           : "=m" (a), "=m" (b)
>+                           : "m" (a), "m" (b), "m" (c)
>+                           : "r0", "r1", "r2", "r3", "cc");
>+             return (a == -128 && b == 0xaabbdddd) ? 0 : -1;
>+           ]])],
>+         [pulseaudio_cv_support_armv6=yes],
>+         [pulseaudio_cv_support_armv6=no])
>+      ])
>+    AS_IF([test "$pulseaudio_cv_support_armv6" = "yes"], [
>+        AC_DEFINE([HAVE_ARMV6], 1, [Have ARMv6 instructions.])
>+      ])
>+  ;;
>+  *)
>+  ;;
>+esac
>+
>+#### NEON optimisations ####
>+AC_ARG_ENABLE([neon-opt],
>+    AS_HELP_STRING([--enable-neon-opt], [Enable NEON optimisations on ARM CPUs that support it]))
>+
>+AS_IF([test "x$enable_neon_opt" != "xno"],
>+    [save_CFLAGS="$CFLAGS"; CFLAGS="-mfpu=neon $CFLAGS"
>+     AC_COMPILE_IFELSE(
>+        [AC_LANG_PROGRAM([[#include <arm_neon.h>]], [])],
>+        [
>+         HAVE_NEON=1
>+         NEON_CFLAGS="-mfpu=neon"
>+        ],
>+        [
>+         HAVE_NEON=0
>+         NEON_CFLAGS=
>+        ])
>+     CFLAGS="$save_CFLAGS"
>+    ],
>+    [HAVE_NEON=0])
>+
>+AS_IF([test "x$enable_neon_opt" = "xyes" && test "x$HAVE_NEON" = "x0"],
>+      [AC_MSG_ERROR([*** Compiler does not support -mfpu=neon or CFLAGS override -mfpu])])
>+
>+AC_SUBST(HAVE_NEON)
>+AC_SUBST(NEON_CFLAGS)
>+AM_CONDITIONAL([HAVE_NEON], [test "x$HAVE_NEON" = x1])
>+AS_IF([test "x$HAVE_NEON" = "x1"], AC_DEFINE([HAVE_NEON], 1, [Have NEON support?]))
>+
>+
>+#### libtool stuff ####
>+
>+LT_PREREQ(2.4)
>+LT_INIT([dlopen win32-dll disable-static])
>+
>+dnl As an extra safety device, check for lt_dladvise_init() which is
>+dnl only implemented in libtool 2.x, and refine as we go if we have
>+dnl refined requirements.
>+dnl
>+dnl Check the header files first since the system may have a
>+dnl libltdl.so for runtime, but no headers, and we want to bail out as
>+dnl soon as possible.
>+dnl
>+dnl We don't need any special variable for this though, since the user
>+dnl can give the proper place to find libltdl through the standard
>+dnl variables like LDFLAGS and CPPFLAGS.
>+
>+AC_CHECK_HEADER([ltdl.h],
>+    [AC_CHECK_LIB([ltdl], [lt_dladvise_init], [LIBLTDL=-lltdl], [LIBLTDL=])],
>+    [LIBLTDL=])
>+
>+AS_IF([test "x$LIBLTDL" = "x"],
>+    [AC_MSG_ERROR([Unable to find libltdl version 2. Makes sure you have libtool 2.4 or later installed.])])
>+AC_SUBST([LIBLTDL])
>+
>+
>+###################################
>+#   Basic environment checks      #
>+###################################
>+
>+#### Checks for header files. ####
>+
>+# ISO
>+AC_HEADER_STDC
>+
>+# POSIX
>+AC_CHECK_HEADERS_ONCE([arpa/inet.h glob.h grp.h netdb.h netinet/in.h \
>+    netinet/in_systm.h netinet/tcp.h poll.h pwd.h sched.h \
>+    sys/mman.h sys/select.h sys/socket.h sys/wait.h \
>+    sys/uio.h syslog.h sys/dl.h dlfcn.h linux/sockios.h])
>+AC_CHECK_HEADERS([netinet/ip.h], [], [],
>+                 [#include <sys/types.h>
>+                  #if HAVE_NETINET_IN_H
>+                  # include <netinet/in.h>
>+                  #endif
>+                  #if HAVE_NETINET_IN_SYSTM_H
>+                  # include <netinet/in_systm.h>
>+                  #endif
>+                 ])
>+AC_CHECK_HEADERS([sys/resource.h], [HAVE_SYS_RESOURCE_H=1], [HAVE_SYS_RESOURCE_H=0])
>+AC_SUBST(HAVE_SYS_RESOURCE_H)
>+AC_CHECK_HEADERS([sys/un.h], [HAVE_AF_UNIX=1], [HAVE_AF_UNIX=0])
>+AM_CONDITIONAL(HAVE_AF_UNIX, test "x$HAVE_AF_UNIX" = "x1")
>+AC_SUBST(HAVE_AF_UNIX)
>+
>+# Linux
>+AC_CHECK_HEADERS([linux/input.h], [HAVE_EVDEV=1], [HAVE_EVDEV=0])
>+AM_CONDITIONAL([HAVE_EVDEV], [test "x$HAVE_EVDEV" = "x1"])
>+
>+AC_CHECK_HEADERS_ONCE([sys/prctl.h])
>+
>+# Solaris
>+AC_CHECK_HEADERS_ONCE([sys/filio.h])
>+
>+# Windows
>+AC_CHECK_HEADERS_ONCE([windows.h winsock2.h ws2tcpip.h])
>+
>+# NetBSD
>+AC_CHECK_HEADERS_ONCE([sys/atomic.h])
>+
>+# Other
>+AC_CHECK_HEADERS_ONCE([sys/ioctl.h])
>+AC_CHECK_HEADERS_ONCE([byteswap.h])
>+AC_CHECK_HEADERS_ONCE([sys/syscall.h])
>+AC_CHECK_HEADERS_ONCE([sys/eventfd.h])
>+AC_CHECK_HEADERS_ONCE([execinfo.h])
>+AC_CHECK_HEADERS_ONCE([langinfo.h])
>+AC_CHECK_HEADERS_ONCE([regex.h pcreposix.h])
>+AC_CHECK_HEADERS_ONCE([locale.h xlocale.h])
>+
>+AM_CONDITIONAL(HAVE_SYS_EVENTFD_H, test "x$ac_cv_header_sys_eventfd_h" = "xyes")
>+
>+#### Typdefs, structures, etc. ####
>+
>+AC_C_CONST
>+AC_C_BIGENDIAN
>+AC_TYPE_PID_T
>+AC_TYPE_SIZE_T
>+AC_CHECK_TYPES(ssize_t, , AC_DEFINE([ssize_t], [signed long], [Define ssize_t if it is not done by the standard libs.]))
>+AC_TYPE_OFF_T
>+
>+AC_TYPE_UID_T
>+AC_CHECK_DECLS(environ)
>+
>+AC_CHECK_SIZEOF(void*)
>+
>+fast_64bit_operations="no"
>+# This check covers x32-ABI
>+AC_CHECK_DECL([__x86_64__], [fast_64bit_operations="yes"], [], [])
>+if test "x$fast_64bit_operations" = "xno"; then
>+    AS_IF([test $ac_cv_sizeof_voidp -ge 8], [fast_64bit_operations="yes"])
>+fi
>+
>+AS_IF([test "x$fast_64bit_operations" = "xyes"], AC_DEFINE([HAVE_FAST_64BIT_OPERATIONS], 1, [Have CPU with fast 64-bit operations?]))
>+
>+# SIGXCPU
>+AX_CHECK_DEFINE([signal.h], [SIGXCPU], [HAVE_SIGXCPU=1], [HAVE_SIGXCPU=0])
>+AS_IF([test "x$HAVE_SIGXCPU" = "x1"], AC_DEFINE([HAVE_SIGXCPU], 1, [Have SIGXCPU?]))
>+AM_CONDITIONAL(HAVE_SIGXCPU, test "x$HAVE_SIGXCPU" = "x1")
>+
>+# INADDR_NONE, Solaris lacks this
>+AX_CHECK_DEFINE([netinet/in.h], [INADDR_NONE], [],
>+    [AX_CHECK_DEFINE([winsock2.h], [INADDR_NONE], [],
>+        [AC_DEFINE([INADDR_NONE],  [0xffffffff], [Define INADDR_NONE if not found in <netinet/in.h>])])])
>+
>+
>+# _Bool
>+AC_CACHE_CHECK([whether $CC knows _Bool],
>+    pulseaudio_cv__Bool,
>+    [AC_COMPILE_IFELSE(
>+        [AC_LANG_PROGRAM([], [[_Bool b;]])],
>+        [pulseaudio_cv__Bool=yes],
>+        [pulseaudio_cv__Bool=no])
>+    ])
>+
>+AS_IF([test "$pulseaudio_cv__Bool" = "yes"], AC_DEFINE([HAVE_STD_BOOL], 1, [Have _Bool.]))
>+
>+
>+#### Thread support ####
>+
>+AX_TLS
>+AS_IF([test "$ac_cv_tls" = "__thread"],
>+    AC_DEFINE([SUPPORT_TLS___THREAD], 1, [Define this if the compiler supports __thread for Thread-Local Storage]))
>+
>+# Win32 build breaks with win32 pthread installed
>+AS_IF([test "x$os_is_win32" != "x1"],
>+  [AX_PTHREAD])
>+
>+AS_IF([test "x$ax_pthread_ok" = "xyes"],
>+    AC_DEFINE([_POSIX_PTHREAD_SEMANTICS], 1, [Needed on Solaris]))
>+
>+
>+#### Check for libs ####
>+
>+# ISO
>+AC_SEARCH_LIBS([pow], [m])
>+
>+# POSIX
>+AC_SEARCH_LIBS([sched_setscheduler], [rt])
>+AC_SEARCH_LIBS([dlopen], [dl])
>+AC_SEARCH_LIBS([shm_open], [rt])
>+AC_SEARCH_LIBS([inet_ntop], [nsl])
>+AC_SEARCH_LIBS([timer_create], [rt])
>+AC_SEARCH_LIBS([pthread_setaffinity_np], [pthread])
>+AC_SEARCH_LIBS([pthread_getname_np], [pthread])
>+AC_SEARCH_LIBS([pthread_setname_np], [pthread])
>+
>+# BSD
>+AC_SEARCH_LIBS([connect], [socket])
>+AC_SEARCH_LIBS([backtrace], [execinfo ubacktrace])
>+
>+# Darwin/OS X
>+if test "x$os_is_darwin" = "x1" ; then
>+    AC_MSG_CHECKING([looking for Apple CoreService Framework])
>+    # How do I check a framework "library" - AC_CHECK_LIB prob. won't work??, just assign LIBS & hope
>+    AC_CHECK_HEADER([/Developer/Headers/FlatCarbon/CoreServices.h],
>+        [LIBS="$LIBS -framework CoreServices"],
>+        [AC_CHECK_HEADERS([/System/Library/Frameworks/CoreServices.framework/Headers/CoreServices.h],
>+            [LIBS="$LIBS -framework CoreServices"],
>+            [AC_MSG_ERROR([CoreServices.h header file not found])]
>+        )]
>+    )
>+
>+    AC_MSG_RESULT([ok])
>+    AC_DEFINE([HAVE_CLOCK_GETTIME], 1, [Using clock_gettime() replacement])
>+    HAVE_BONJOUR=1
>+fi
>+
>+AM_CONDITIONAL([HAVE_BONJOUR], [test "x$HAVE_BONJOUR" = x1])
>+
>+# Windows
>+AC_SEARCH_LIBS([regexec], [pcreposix])
>+# This magic is needed so we do not needlessly add static libs to the win32  build, disabling its ability to make dlls.
>+AC_CHECK_FUNCS([getopt_long], [], [AC_CHECK_LIB([iberty], [getopt_long])])
>+
>+
>+#### Check for functions ####
>+
>+# ISO
>+AC_CHECK_FUNCS_ONCE([lrintf strtof])
>+
>+# POSIX
>+AC_FUNC_FORK
>+AC_FUNC_GETGROUPS
>+AC_CHECK_FUNCS_ONCE([chmod chown fstat fchown fchmod clock_gettime getaddrinfo getgrgid_r getgrnam_r \
>+    getpwnam_r getpwuid_r gettimeofday getuid mlock nanosleep \
>+    pipe posix_fadvise posix_madvise posix_memalign setpgid setsid shm_open \
>+    sigaction sleep symlink sysconf uname pthread_setaffinity_np pthread_getname_np pthread_setname_np])
>+AC_CHECK_FUNCS([mkfifo], [HAVE_MKFIFO=1], [HAVE_MKFIFO=0])
>+AC_SUBST(HAVE_MKFIFO)
>+AM_CONDITIONAL(HAVE_MKFIFO, test "x$HAVE_MKFIFO" = "x1")
>+
>+# X/OPEN
>+AC_CHECK_FUNCS_ONCE([readlink])
>+
>+# SUSv2
>+AC_CHECK_FUNCS_ONCE([ctime_r usleep])
>+
>+# SUSv3
>+AC_CHECK_FUNCS_ONCE([strerror_r])
>+
>+# BSD
>+AC_CHECK_FUNCS_ONCE([lstat paccept])
>+
>+# Non-standard
>+AC_CHECK_FUNCS_ONCE([setresuid setresgid setreuid setregid seteuid setegid ppoll strsignal sig2str strtod_l pipe2 accept4])
>+
>+AC_FUNC_ALLOCA
>+
>+AC_CHECK_FUNCS([regexec], [HAVE_REGEX=1], [HAVE_REGEX=0])
>+AM_CONDITIONAL(HAVE_REGEX, [test "x$HAVE_REGEX" = "x1"])
>+
>+# Large File-Support (LFS)
>+AC_SYS_LARGEFILE
>+# Check for open64 to know if the current system does have open64() and similar functions
>+AC_CHECK_FUNCS_ONCE([open64])
>+
>+AC_SEARCH_LIBS([dladdr], [dl], [HAVE_DLADDR=1], [HAVE_DLADDR=0])
>+AC_DEFINE(HAVE_DLADDR, [1], [Have dladdr?])
>+
>+###################################
>+#      External libraries         #
>+###################################
>+
>+#### [lib]iconv ####
>+
>+AM_ICONV
>+
>+#### X11 (optional) ####
>+
>+AC_ARG_ENABLE([x11],
>+    AS_HELP_STRING([--disable-x11],[Disable optional X11 support]))
>+
>+AS_IF([test "x$enable_x11" != "xno"],
>+    [PKG_CHECK_MODULES(X11, [ x11-xcb xcb >= 1.6 ice sm xtst ], HAVE_X11=1, HAVE_X11=0)],
>+    HAVE_X11=0)
>+
>+AS_IF([test "x$enable_x11" = "xyes" && test "x$HAVE_X11" = "x0"],
>+    [AC_MSG_ERROR([*** X11 not found])])
>+
>+AC_SUBST(HAVE_X11)
>+AM_CONDITIONAL([HAVE_X11], [test "x$HAVE_X11" = x1])
>+AS_IF([test "x$HAVE_X11" = "x1"], AC_DEFINE([HAVE_X11], 1, [Have X11?]))
>+
>+#### Capabilities (optional) ####
>+
>+CAP_LIBS=''
>+
>+AC_ARG_WITH([caps],
>+    AS_HELP_STRING([--without-caps],[Omit support for dropping capabilities.]))
>+
>+if test "x${with_caps}" != "xno"; then
>+    AC_SEARCH_LIBS([cap_init], [cap], [], [])
>+
>+    # Only give an error on hosts that we know could support capabilities
>+    AC_CHECK_HEADERS([sys/capability.h], [], [
>+      if test "${host_has_caps}" = "1"; then
>+        AC_MSG_ERROR([*** sys/capability.h not found.  Use --without-caps to disable capabilities support.])
>+      fi])
>+fi
>+
>+#### Valgrind (optional) ####
>+
>+AC_CHECK_HEADERS_ONCE([valgrind/memcheck.h])
>+
>+#### check unit tests ####
>+
>+AC_ARG_ENABLE([tests],
>+    AS_HELP_STRING([--disable-tests],[Disable unit tests]))
>+
>+AS_IF([test "x$enable_tests" != "xno"],
>+    [PKG_CHECK_MODULES(LIBCHECK, [ check ], HAVE_LIBCHECK=1, HAVE_LIBCHECK=0)],
>+    HAVE_LIBCHECK=0)
>+
>+AS_IF([test "x$enable_tests" = "xyes" && test "x$HAVE_LIBCHECK" = "x0"],
>+    [AC_MSG_ERROR([*** check library not found])])
>+
>+AM_CONDITIONAL([HAVE_TESTS], [test "x$HAVE_LIBCHECK" = x1])
>+
>+#### json parsing ####
>+
>+PKG_CHECK_MODULES(LIBJSON, [ json-c >= 0.11 ])
>+
>+#### Sound file ####
>+
>+PKG_CHECK_MODULES(LIBSNDFILE, [ sndfile >= 1.0.20 ])
>+
>+#### atomic-ops ####
>+
>+AC_MSG_CHECKING([whether we need libatomic_ops])
>+if test "x$need_libatomic_ops" = "xyes"; then
>+    AC_MSG_RESULT([yes])
>+    AC_CHECK_HEADERS([atomic_ops.h],
>+        [CFLAGS="$CFLAGS -DAO_REQUIRE_CAS"],
>+        [AC_MSG_ERROR([*** libatomic-ops headers not found])])
>+
>+    # Win32 does not need the lib and breaks horribly if we try to include it
>+    AS_IF([test "x$os_is_win32" != "x1"], [LIBS="$LIBS -latomic_ops"])
>+else
>+    AC_MSG_RESULT([no])
>+fi
>+
>+#### Libsamplerate support (optional) ####
>+
>+AC_ARG_ENABLE([samplerate],
>+    AS_HELP_STRING([--enable-samplerate],[Enable optional libsamplerate support (DEPRECATED)]))
>+
>+AS_IF([test "x$enable_samplerate" = "xyes"],
>+    [PKG_CHECK_MODULES(LIBSAMPLERATE, [ samplerate >= 0.1.0 ], HAVE_LIBSAMPLERATE=1, HAVE_LIBSAMPLERATE=0)],
>+    HAVE_LIBSAMPLERATE=0)
>+
>+AS_IF([test "x$enable_samplerate" = "xyes" && test "x$HAVE_LIBSAMPLERATE" = "x0"],
>+    [AC_MSG_ERROR([*** Libsamplerate not found])])
>+
>+AM_CONDITIONAL([HAVE_LIBSAMPLERATE], [test "x$HAVE_LIBSAMPLERATE" = x1])
>+AS_IF([test "x$HAVE_LIBSAMPLERATE" = "x1"], AC_DEFINE([HAVE_LIBSAMPLERATE], 1, [Have libsamplerate?]))
>+
>+AS_IF([test "x$HAVE_LIBSAMPLERATE" = "x1"], AC_MSG_WARN([Support for libsamplerate is DEPRECATED]))
>+
>+#### Database support ####
>+
>+AC_ARG_WITH([database],
>+    AS_HELP_STRING([--with-database=auto|tdb|gdbm|simple],[Choose database backend.]),[],[with_database=auto])
>+
>+
>+AS_IF([test "x$with_database" = "xauto" -o "x$with_database" = "xtdb"],
>+    [PKG_CHECK_MODULES(TDB, [ tdb ], HAVE_TDB=1, HAVE_TDB=0)],
>+    HAVE_TDB=0)
>+AS_IF([test "x$HAVE_TDB" = "x1"], with_database=tdb)
>+
>+AS_IF([test "x$with_database" = "xtdb" && test "x$HAVE_TDB" = "x0"],
>+    [AC_MSG_ERROR([*** tdb not found])])
>+
>+
>+AS_IF([test "x$with_database" = "xauto" -o "x$with_database" = "xgdbm"],
>+    [
>+        HAVE_GDBM=1
>+        AC_CHECK_LIB(gdbm, gdbm_open, [], HAVE_GDBM=0)
>+        AC_CHECK_HEADERS(gdbm.h, [], HAVE_GDBM=0)
>+    ],
>+    HAVE_GDBM=0)
>+AS_IF([test "x$HAVE_GDBM" = "x1"],
>+    [
>+        with_database=gdbm
>+        GDBM_CFLAGS=
>+        GDBM_LIBS=-lgdbm
>+    ])
>+
>+AS_IF([test "x$with_database" = "xgdbm" && test "x$HAVE_GDBM" = "x0"],
>+    [AC_MSG_ERROR([*** gdbm not found])])
>+
>+
>+AS_IF([test "x$with_database" = "xauto" -o "x$with_database" = "xsimple"],
>+    HAVE_SIMPLEDB=1,
>+    HAVE_SIMPLEDB=0)
>+AS_IF([test "x$HAVE_SIMPLEDB" = "x1"], with_database=simple)
>+
>+AS_IF([test "x$HAVE_TDB" != x1 -a "x$HAVE_GDBM" != x1 -a "x$HAVE_SIMPLEDB" != x1],
>+    AC_MSG_ERROR([*** missing database backend]))
>+
>+
>+AM_CONDITIONAL([HAVE_TDB], [test "x$HAVE_TDB" = x1])
>+AS_IF([test "x$HAVE_TDB" = "x1"], AC_DEFINE([HAVE_TDB], 1, [Have tdb?]))
>+
>+AC_SUBST(GDBM_CFLAGS)
>+AC_SUBST(GDBM_LIBS)
>+AM_CONDITIONAL([HAVE_GDBM], [test "x$HAVE_GDBM" = x1])
>+AS_IF([test "x$HAVE_GDBM" = "x1"], AC_DEFINE([HAVE_GDBM], 1, [Have gdbm?]))
>+
>+AM_CONDITIONAL([HAVE_SIMPLEDB], [test "x$HAVE_SIMPLEDB" = x1])
>+AS_IF([test "x$HAVE_SIMPLEDB" = "x1"], AC_DEFINE([HAVE_SIMPLEDB], 1, [Have simple?]))
>+
>+#### OSS support (optional) ####
>+
>+AC_ARG_ENABLE([oss-output],
>+    AS_HELP_STRING([--disable-oss-output],[Disable optional OSS output support]))
>+
>+AC_ARG_ENABLE([oss-wrapper],
>+    AS_HELP_STRING([--disable-oss-wrapper],[Disable optional OSS wrapper support]))
>+
>+AS_IF([test "x$enable_oss_output" != "xno" -o "x$enable_oss_wrapper" != "xno"],
>+    [AC_CHECK_HEADERS([sys/soundcard.h], HAVE_OSS=1, HAVE_OSS=0)],
>+    HAVE_OSS=0)
>+
>+AS_IF([test "x$enable_oss_output" = "xyes" -o "x$enable_oss_wrapper" = "xyes" && test "x$HAVE_OSS" = "x0"],
>+    [AC_MSG_ERROR([*** OSS support not found])])
>+
>+AS_IF([test "x$enable_oss_output" != "xno"],
>+    [AS_IF([test "x$HAVE_OSS" = "x1"], HAVE_OSS_OUTPUT=1, HAVE_OSS_OUTPUT=0)],
>+    HAVE_OSS_OUTPUT=0)
>+
>+AS_IF([test "x$enable_oss_wrapper" != "xno"],
>+    [AS_IF([test "x$HAVE_OSS" = "x1"], HAVE_OSS_WRAPPER=1, HAVE_OSS_WRAPPER=0)],
>+    HAVE_OSS_WRAPPER=0)
>+
>+AC_SUBST(HAVE_OSS_OUTPUT)
>+AM_CONDITIONAL([HAVE_OSS_OUTPUT], [test "x$HAVE_OSS_OUTPUT" = "x1"])
>+AM_CONDITIONAL([HAVE_OSS_WRAPPER], [test "x$HAVE_OSS_WRAPPER" = "x1"])
>+AS_IF([test "x$HAVE_OSS_OUTPUT" = "x1"], AC_DEFINE([HAVE_OSS_OUTPUT], 1, [Have OSS output?]))
>+AS_IF([test "x$HAVE_OSS_WRAPPER" = "x1"], AC_DEFINE([HAVE_OSS_WRAPPER], 1, [Have OSS wrapper (padsp)?]))
>+
>+#### CoreAudio support (optional) ####
>+
>+AC_ARG_ENABLE([coreaudio-output],
>+    AS_HELP_STRING([--disable-coreaudio-output],[Disable optional CoreAudio output support]))
>+
>+AS_IF([test "x$enable_coreaudio_output" != "xno"],
>+    [AC_CHECK_HEADERS([CoreAudio/CoreAudio.h], HAVE_COREAUDIO=1, HAVE_COREAUDIO=0)],
>+    HAVE_COREAUDIO=0)
>+
>+AS_IF([test "x$enable_coreaudio_output" = "xyes" && test "x$HAVE_COREAUDIO" = "x0"],
>+    [AC_MSG_ERROR([*** CoreAudio output support not found])])
>+
>+AC_SUBST(HAVE_COREAUDIO)
>+AM_CONDITIONAL([HAVE_COREAUDIO], [test "x$HAVE_COREAUDIO" = "x1" && test "x$enable_coreaudio_output" != "xno"])
>+
>+AS_IF([test "x$HAVE_COREAUDIO" = "x1"], AC_DEFINE([HAVE_COREAUDIO], 1, [Have CoreAudio?]))
>+
>+#### ALSA support (optional) ####
>+
>+AC_ARG_ENABLE([alsa],
>+    AS_HELP_STRING([--disable-alsa],[Disable optional ALSA support]))
>+
>+AS_IF([test "x$enable_alsa" != "xno"],
>+    [PKG_CHECK_MODULES(ASOUNDLIB, [ alsa >= 1.0.19 ], HAVE_ALSA=1, HAVE_ALSA=0)],
>+    HAVE_ALSA=0)
>+
>+AS_IF([test "x$enable_alsa" = "xyes" && test "x$HAVE_ALSA" = "x0"],
>+    [AC_MSG_ERROR([*** Needed alsa >= 1.0.19 support not found])])
>+
>+AS_IF([test "x$HAVE_ALSA" = "x1"],
>+    [
>+        save_CPPFLAGS="$CPPFLAGS"; CPPFLAGS="$CPPFLAGS $ASOUNDLIB_CFLAGS"
>+        AC_CHECK_HEADERS([use-case.h], HAVE_ALSA_UCM=1, HAVE_ALSA_UCM=0)
>+        CPPFLAGS="$save_CPPFLAGS"
>+    ],
>+    HAVE_ALSA_UCM=0)
>+
>+AC_SUBST(HAVE_ALSA)
>+AM_CONDITIONAL([HAVE_ALSA], [test "x$HAVE_ALSA" = x1])
>+AS_IF([test "x$HAVE_ALSA" = "x1"], AC_DEFINE([HAVE_ALSA], 1, [Have ALSA?]))
>+AS_IF([test "x$HAVE_ALSA_UCM" = "x1"], AC_DEFINE([HAVE_ALSA_UCM], 1, [Have ALSA UCM?]))
>+
>+#### EsounD support (optional) ####
>+
>+AC_ARG_ENABLE([esound],
>+    AS_HELP_STRING([--disable-esound],[Disable optional EsounD support]))
>+AM_CONDITIONAL([HAVE_ESOUND], [test "x$enable_esound" != "xno"])
>+AS_IF([test "x$enable_esound" != "xno"], [HAVE_ESOUND=1])
>+
>+#### Solaris audio support (optional) ####
>+
>+AC_ARG_ENABLE([solaris],
>+    AS_HELP_STRING([--disable-solaris],[Disable optional Solaris audio support]))
>+
>+AS_IF([test "x$enable_solaris" != "xno"],
>+    [AC_CHECK_HEADERS([sys/audio.h], HAVE_SOLARIS=1, HAVE_SOLARIS=0)],
>+    HAVE_SOLARIS=0)
>+
>+AS_IF([test "x$enable_solaris" = "xyes" && test "x$HAVE_SOLARIS" = "x0"],
>+    [AC_MSG_ERROR([*** Solaris audio support not found])])
>+
>+AM_CONDITIONAL([HAVE_SOLARIS], [test "x$HAVE_SOLARIS" = x1])
>+AS_IF([test "x$HAVE_SOLARIS" = "x1"], AC_DEFINE([HAVE_SOLARIS], 1, [Have Solaris audio?]))
>+
>+#### WaveOut audio support (optional) ####
>+
>+AC_ARG_ENABLE([waveout],
>+    AS_HELP_STRING([--disable-waveout],[Disable optional WaveOut audio support]))
>+
>+AS_IF([test "x$enable_waveout" != "xno"],
>+    [AC_CHECK_HEADERS([mmsystem.h], HAVE_WAVEOUT=1, HAVE_WAVEOUT=0, [#include <windows.h>])],
>+    HAVE_WAVEOUT=0)
>+
>+AS_IF([test "x$enable_waveout" = "xyes" && test "x$HAVE_WAVEOUT" = "x0"],
>+    [AC_MSG_ERROR([*** WaveOut audio support not found])])
>+
>+AC_SUBST(HAVE_WAVEOUT)
>+AM_CONDITIONAL([HAVE_WAVEOUT], [test "x$HAVE_WAVEOUT" = x1])
>+AS_IF([test "x$HAVE_WAVEOUT" = "x1"], AC_DEFINE([HAVE_WAVEOUT], 1, [Have WaveOut audio?]))
>+
>+#### GLib 2 support (optional) ####
>+
>+AC_ARG_ENABLE([glib2],
>+    AS_HELP_STRING([--disable-glib2],[Disable optional GLib 2 support]))
>+
>+AS_IF([test "x$enable_glib2" != "xno"],
>+    [PKG_CHECK_MODULES(GLIB20, [ glib-2.0 >= 2.4.0 ], HAVE_GLIB20=1, HAVE_GLIB20=0)],
>+    HAVE_GLIB20=0)
>+
>+AS_IF([test "x$enable_glib2" = "xyes" && test "x$HAVE_GLIB20" = "x0"],
>+    [AC_MSG_ERROR([*** GLib 2 support not found])])
>+
>+AC_SUBST(HAVE_GLIB20)
>+AM_CONDITIONAL([HAVE_GLIB20], [test "x$HAVE_GLIB20" = x1])
>+AS_IF([test "x$HAVE_GLIB20" = "x1"], AC_DEFINE([HAVE_GLIB], 1, [Have GLIB?]))
>+
>+#### GTK3 support (optional) ####
>+
>+AC_ARG_ENABLE([gtk3],
>+    AS_HELP_STRING([--disable-gtk3],[Disable optional Gtk+ 3 support]))
>+
>+AS_IF([test "x$enable_gtk3" != "xno"],
>+    [PKG_CHECK_MODULES(GTK30, [ gtk+-3.0 ], HAVE_GTK30=1, HAVE_GTK30=0)],
>+    HAVE_GTK30=0)
>+
>+AS_IF([test "x$enable_gtk3" = "xyes" && test "x$HAVE_GTK30" = "x0"],
>+    [AC_MSG_ERROR([*** Gtk+ 3 support not found])])
>+
>+AM_CONDITIONAL([HAVE_GTK30], [test "x$HAVE_GTK30" = x1])
>+AS_IF([test "x$HAVE_GTK30" = "x1"], AC_DEFINE([HAVE_GTK], 1, [Have GTK?]))
>+
>+#### GConf support (optional) ####
>+
>+AC_ARG_ENABLE([gconf],
>+    AS_HELP_STRING([--disable-gconf],[Disable optional GConf support]))
>+
>+AS_IF([test "x$enable_gconf" != "xno"],
>+    [PKG_CHECK_MODULES(GCONF, [ gconf-2.0 >= 2.4.0 gobject-2.0 ], HAVE_GCONF=1, HAVE_GCONF=0)],
>+    HAVE_GCONF=0)
>+
>+AS_IF([test "x$enable_gconf" = "xyes" && test "x$HAVE_GCONF" = "x0"],
>+    [AC_MSG_ERROR([*** GConf support not found])])
>+
>+AM_CONDITIONAL([HAVE_GCONF], [test "x$HAVE_GCONF" = x1])
>+
>+#### Avahi support (optional) ####
>+
>+AC_ARG_ENABLE([avahi],
>+    AS_HELP_STRING([--disable-avahi],[Disable optional Avahi support]))
>+
>+AS_IF([test "x$enable_avahi" != "xno"],
>+    [PKG_CHECK_MODULES(AVAHI, [ avahi-client >= 0.6.0 ], HAVE_AVAHI=1, HAVE_AVAHI=0)],
>+    HAVE_AVAHI=0)
>+
>+AS_IF([test "x$enable_avahi" = "xyes" && test "x$HAVE_AVAHI" = "x0"],
>+    [AC_MSG_ERROR([*** Avahi support not found])])
>+
>+AC_SUBST(HAVE_AVAHI)
>+AM_CONDITIONAL([HAVE_AVAHI], [test "x$HAVE_AVAHI" = x1])
>+
>+#### JACK (optional) ####
>+
>+AC_ARG_ENABLE([jack],
>+    AS_HELP_STRING([--disable-jack],[Disable optional JACK support]))
>+
>+AS_IF([test "x$enable_jack" != "xno"],
>+    [PKG_CHECK_MODULES(JACK, [ jack >= 0.117.0 ], HAVE_JACK=1, HAVE_JACK=0)],
>+    HAVE_JACK=0)
>+
>+AS_IF([test "x$enable_jack" = "xyes" && test "x$HAVE_JACK" = "x0"],
>+    [AC_MSG_ERROR([*** JACK support not found])])
>+
>+AM_CONDITIONAL([HAVE_JACK], [test "x$HAVE_JACK" = x1])
>+
>+#### Async DNS support (optional) ####
>+
>+AC_ARG_ENABLE([asyncns],
>+    AS_HELP_STRING([--disable-asyncns],[Disable optional Async DNS support]))
>+
>+AS_IF([test "x$enable_asyncns" != "xno"],
>+    [PKG_CHECK_MODULES(LIBASYNCNS, [ libasyncns >= 0.1 ], HAVE_LIBASYNCNS=1, HAVE_LIBASYNCNS=0)],
>+    HAVE_LIBASYNCNS=0)
>+
>+AS_IF([test "x$enable_asyncns" = "xyes" && test "x$HAVE_LIBASYNCNS" = "x0"],
>+    [AC_MSG_ERROR([*** Async DNS support not found])])
>+
>+AM_CONDITIONAL([HAVE_LIBASYNCNS], [test "x$HAVE_LIBASYNCNS" = x1])
>+AS_IF([test "x$HAVE_LIBASYNCNS" = "x1"], AC_DEFINE([HAVE_LIBASYNCNS], 1, [Have libasyncns?]))
>+
>+#### TCP wrappers (optional) ####
>+
>+AC_ARG_ENABLE([tcpwrap],
>+    AS_HELP_STRING([--disable-tcpwrap],[Disable optional TCP wrappers support]))
>+
>+AS_IF([test "x$enable_tcpwrap" != "xno"],
>+    [
>+        ACX_LIBWRAP
>+        AS_IF([test "x$LIBWRAP_LIBS" != "x"], HAVE_TCPWRAP=1, HAVE_TCPWRAP=0)
>+    ],
>+    HAVE_TCPWRAP=0)
>+
>+AS_IF([test "x$enable_tcpwrap" = "xyes" && test "x$HAVE_TCPWRAP" = "x0"],
>+    [AC_MSG_ERROR([*** TCP wrappers support not found])])
>+
>+AC_SUBST(LIBWRAP_LIBS)
>+
>+#### LIRC support (optional) ####
>+
>+AC_ARG_ENABLE([lirc],
>+    AS_HELP_STRING([--disable-lirc],[Disable optional LIRC support]))
>+
>+LIRC_CFLAGS=
>+LIRC_LIBS=
>+
>+AS_IF([test "x$enable_lirc" != "xno"],
>+    [
>+        HAVE_LIRC=1
>+        AC_CHECK_HEADER(lirc/lirc_client.h, [], [HAVE_LIRC=0])
>+        AC_CHECK_LIB(lirc_client, lirc_init, [LIRC_LIBS=-llirc_client], [HAVE_LIRC=0])
>+    ],
>+    HAVE_LIRC=0)
>+
>+AS_IF([test "x$enable_lirc" = "xyes" && test "x$HAVE_LIRC" = "x0"],
>+    [AC_MSG_ERROR([*** LIRC support not found])])
>+
>+AC_SUBST(LIRC_CFLAGS)
>+AC_SUBST(LIRC_LIBS)
>+AM_CONDITIONAL([HAVE_LIRC], [test "x$HAVE_LIRC" = x1])
>+
>+#### D-Bus support (optional) ####
>+
>+AC_ARG_ENABLE([dbus],
>+    AS_HELP_STRING([--disable-dbus],[Disable optional D-Bus support]))
>+
>+AS_IF([test "x$enable_dbus" != "xno"],
>+    [PKG_CHECK_MODULES(DBUS, [ dbus-1 >= 1.4.12 ], HAVE_DBUS=1, HAVE_DBUS=0)],
>+    HAVE_DBUS=0)
>+
>+AS_IF([test "x$enable_dbus" = "xyes" && test "x$HAVE_DBUS" = "x0"],
>+    [AC_MSG_ERROR([*** D-Bus not available or too old version])])
>+
>+AS_IF([test "x$HAVE_DBUS" = "x1"],
>+    [
>+        save_CFLAGS="$CFLAGS"; CFLAGS="$CFLAGS $DBUS_CFLAGS"
>+        save_LIBS="$LIBS"; LIBS="$LIBS $DBUS_LIBS"
>+        AC_CHECK_FUNCS(dbus_watch_get_unix_fd)
>+        CFLAGS="$save_CFLAGS"
>+        LIBS="$save_LIBS"
>+    ])
>+
>+AC_SUBST(HAVE_DBUS)
>+AM_CONDITIONAL([HAVE_DBUS], [test "x$HAVE_DBUS" = x1])
>+AS_IF([test "x$HAVE_DBUS" = "x1"], AC_DEFINE([HAVE_DBUS], 1, [Have D-Bus.]))
>+
>+PA_MACHINE_ID="${sysconfdir}/machine-id"
>+AX_DEFINE_DIR(PA_MACHINE_ID, PA_MACHINE_ID, [D-Bus machine-id file])
>+PA_MACHINE_ID_FALLBACK="${localstatedir}/lib/dbus/machine-id"
>+AX_DEFINE_DIR(PA_MACHINE_ID_FALLBACK, PA_MACHINE_ID_FALLBACK,
>+	      [Fallback machine-id file])
>+
>+#### BlueZ support (optional, dependent on D-Bus and SBC) ####
>+
>+AC_ARG_ENABLE([bluez4],
>+    AS_HELP_STRING([--disable-bluez4],[Disable optional BlueZ 4 support]))
>+AC_ARG_ENABLE([bluez5],
>+    AS_HELP_STRING([--disable-bluez5],[Disable optional BlueZ 5 support]))
>+
>+## SBC ##
>+AS_IF([test "x$enable_bluez4" != "xno" || test "x$enable_bluez5" != "xno"],
>+    [PKG_CHECK_MODULES(SBC, [ sbc >= 1.0 ], HAVE_SBC=1, HAVE_SBC=0)],
>+    HAVE_SBC=0)
>+
>+## BlueZ 4 ##
>+AS_IF([test "x$enable_bluez4" != "xno" && test "x$HAVE_DBUS" = "x1" && test "x$HAVE_SBC" = "x1"], HAVE_BLUEZ_4=1,
>+      HAVE_BLUEZ_4=0)
>+AS_IF([test "x$enable_bluez4" = "xyes" && test "x$HAVE_BLUEZ_4" != "x1"],
>+    [AC_MSG_ERROR([*** BLUEZ 4 support not found (requires sbc and D-Bus)])])
>+AC_SUBST(HAVE_BLUEZ_4)
>+AM_CONDITIONAL([HAVE_BLUEZ_4], [test "x$HAVE_BLUEZ_4" = x1])
>+
>+## BlueZ 5 ##
>+AS_IF([test "x$enable_bluez5" != "xno" && test "x$HAVE_DBUS" = "x1" && test "x$HAVE_SBC" = "x1"], HAVE_BLUEZ_5=1,
>+      HAVE_BLUEZ_5=0)
>+AS_IF([test "x$enable_bluez5" = "xyes" && test "x$HAVE_BLUEZ_5" != "x1"],
>+    [AC_MSG_ERROR([*** BLUEZ 5 support not found (requires sbc and D-Bus)])])
>+AC_SUBST(HAVE_BLUEZ_5)
>+AM_CONDITIONAL([HAVE_BLUEZ_5], [test "x$HAVE_BLUEZ_5" = x1])
>+
>+AS_IF([test "x$HAVE_BLUEZ_4" = "x1" || test "x$HAVE_BLUEZ_5" = "x1"], HAVE_BLUEZ=1, HAVE_BLUEZ=0)
>+AC_SUBST(HAVE_BLUEZ)
>+AM_CONDITIONAL([HAVE_BLUEZ], [test "x$HAVE_BLUEZ" = x1])
>+
>+## Bluetooth Headset profiles backend ##
>+
>+AC_ARG_ENABLE([bluez5-ofono-headset],
>+    AS_HELP_STRING([--disable-bluez5-ofono-headset],[Disable optional ofono headset backend support (Bluez 5)]))
>+AS_IF([test "x$HAVE_BLUEZ_5" = "x1" && test "x$enable_bluez5_ofono_headset" != "xno"], HAVE_BLUEZ_5_OFONO_HEADSET=1,
>+      HAVE_BLUEZ_5_OFONO_HEADSET=0)
>+AC_SUBST(HAVE_BLUEZ_5_OFONO_HEADSET)
>+AM_CONDITIONAL([HAVE_BLUEZ_5_OFONO_HEADSET], [test "x$HAVE_BLUEZ_5_OFONO_HEADSET" = x1])
>+AS_IF([test "x$HAVE_BLUEZ_5_OFONO_HEADSET" = "x1"], AC_DEFINE([HAVE_BLUEZ_5_OFONO_HEADSET], 1, [Bluez 5 ofono headset backend enabled]))
>+
>+AC_ARG_ENABLE([bluez5-native-headset],
>+    AS_HELP_STRING([--disable-bluez5-native-headset],[Disable optional native headset backend support (Bluez 5)]))
>+AS_IF([test "x$HAVE_BLUEZ_5" = "x1" && test "x$enable_bluez5_native_headset" != "xno"],
>+      [PKG_CHECK_MODULES(BLUEZ, [ bluez >= 4.101 ], HAVE_BLUEZ_5_NATIVE_HEADSET=1, HAVE_BLUEZ_5_NATIVE_HEADSET=0)],
>+      HAVE_BLUEZ_5_NATIVE_HEADSET=0)
>+AS_IF([test "x$enable_bluez5_native_headset" = "xyes" && test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = "x0"],
>+      [AC_MSG_ERROR([*** BlueZ 5 native headset backend support not available (requires the libbluetooth headers)])])
>+AC_SUBST(HAVE_BLUEZ_5_NATIVE_HEADSET)
>+AM_CONDITIONAL([HAVE_BLUEZ_5_NATIVE_HEADSET], [test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = x1])
>+AS_IF([test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = "x1"], AC_DEFINE([HAVE_BLUEZ_5_NATIVE_HEADSET], 1, [Bluez 5 native headset backend enabled]))
>+
>+#### UDEV support (optional) ####
>+
>+AC_ARG_ENABLE([udev],
>+    AS_HELP_STRING([--disable-udev],[Disable optional UDEV support]))
>+
>+AS_IF([test "x$enable_udev" != "xno" -a $ "x$HAVE_OSS" = "x1" -o "x$HAVE_ALSA" = "x1" $],
>+    [PKG_CHECK_MODULES(UDEV, [ libudev >= 143 ], HAVE_UDEV=1, HAVE_UDEV=0)],
>+    HAVE_UDEV=0)
>+
>+AS_IF([test "x$enable_udev" = "xyes" && test "x$HAVE_UDEV" = "x0"],
>+    [AC_MSG_ERROR([*** UDEV support not found])])
>+
>+AC_SUBST(HAVE_UDEV)
>+AM_CONDITIONAL([HAVE_UDEV], [test "x$HAVE_UDEV" = x1])
>+AS_IF([test "x$HAVE_UDEV" = "x1"], AC_DEFINE([HAVE_UDEV], 1, [Have UDEV.]))
>+
>+#### HAL compat support (optional, dependent on UDEV) ####
>+
>+AC_ARG_ENABLE([hal-compat],
>+    AS_HELP_STRING([--disable-hal-compat],[Disable optional HAL->udev transition compatibility support]))
>+
>+AS_IF([test "x$enable_hal_compat" != "xno"],
>+    [AS_IF([test "x$HAVE_UDEV" = "x1"], HAVE_HAL_COMPAT=1, HAVE_HAL_COMPAT=0)],
>+    HAVE_HAL_COMPAT=0)
>+
>+AM_CONDITIONAL([HAVE_HAL_COMPAT], [test "x$HAVE_HAL_COMPAT" = x1])
>+AS_IF([test "x$HAVE_HAL_COMPAT" = "x1"], AC_DEFINE([HAVE_HAL_COMPAT], 1, [Have HAL compatibility.]))
>+
>+#### IPv6 connection support (optional) ####
>+
>+AC_ARG_ENABLE([ipv6],
>+    AS_HELP_STRING([--disable-ipv6],[Disable optional IPv6 support]))
>+
>+AS_IF([test "x$enable_ipv6" != "xno"], [HAVE_IPV6=1], [HAVE_IPV6=0])
>+
>+AS_IF([test "x$HAVE_IPV6" = "x1"], AC_DEFINE([HAVE_IPV6], 1, [Define this to enable IPv6 connection support]))
>+
>+#### OpenSSL support (optional) ####
>+
>+AC_ARG_ENABLE([openssl],
>+    AS_HELP_STRING([--disable-openssl],[Disable OpenSSL support (used for Airtunes/RAOP)]))
>+
>+AS_IF([test "x$enable_openssl" != "xno"],
>+    [PKG_CHECK_MODULES(OPENSSL, [ openssl > 0.9 ], HAVE_OPENSSL=1, HAVE_OPENSSL=0)],
>+    HAVE_OPENSSL=0)
>+
>+AS_IF([test "x$enable_openssl" = "xyes" && test "x$HAVE_OPENSSL" = "x0"],
>+    [AC_MSG_ERROR([*** OpenSSL support not found])])
>+
>+AM_CONDITIONAL([HAVE_OPENSSL], [test "x$HAVE_OPENSSL" = x1])
>+AS_IF([test "x$HAVE_OPENSSL" = "x1"], AC_DEFINE([HAVE_OPENSSL], 1, [Have OpenSSL]))
>+
>+#### FFTW (optional) ####
>+
>+AC_ARG_WITH([fftw],
>+    AS_HELP_STRING([--without-fftw],[Omit FFTW-using modules (equalizer)]))
>+
>+AS_IF([test "x$with_fftw" != "xno"],
>+    [PKG_CHECK_MODULES(FFTW, [ fftw3f ], HAVE_FFTW=1, HAVE_FFTW=0)],
>+    HAVE_FFTW=0)
>+
>+AS_IF([test "x$with_fftw" = "xyes" && test "x$HAVE_FFTW" = "x0"],
>+    [AC_MSG_ERROR([*** FFTW support not found])])
>+
>+AM_CONDITIONAL([HAVE_FFTW], [test "x$HAVE_FFTW" = "x1"])
>+
>+#### speex (optional) ####
>+
>+AC_ARG_WITH([speex],
>+    AS_HELP_STRING([--without-speex],[Omit speex (resampling, AEC)]))
>+
>+AS_IF([test "x$with_speex" != "xno"],
>+    [PKG_CHECK_MODULES(LIBSPEEX, [ speexdsp >= 1.2 ], HAVE_SPEEX=1, HAVE_SPEEX=0)],
>+    HAVE_SPEEX=0)
>+
>+AS_IF([test "x$with_speex" = "xyes" && test "x$HAVE_SPEEX" = "x0"],
>+    [AC_MSG_ERROR([*** speex support not found])])
>+
>+AM_CONDITIONAL([HAVE_SPEEX], [test "x$HAVE_SPEEX" = "x1"])
>+AS_IF([test "x$HAVE_SPEEX" = "x1"], AC_DEFINE([HAVE_SPEEX], 1, [Have speex]))
>+
>+#### soxr (optional) ####
>+
>+AC_ARG_WITH([soxr],
>+    AS_HELP_STRING([--without-soxr],[Omit soxr (resampling)]))
>+
>+AS_IF([test "x$with_soxr" != "xno"],
>+    [PKG_CHECK_MODULES(LIBSOXR, [ soxr >= 0.1.1 ], HAVE_SOXR=1, HAVE_SOXR=0)],
>+    HAVE_SOXR=0)
>+
>+AS_IF([test "x$with_soxr" = "xyes" && test "x$HAVE_SOXR" = "x0"],
>+    [AC_MSG_ERROR([*** soxr support not found])])
>+
>+AM_CONDITIONAL([HAVE_SOXR], [test "x$HAVE_SOXR" = "x1"])
>+AS_IF([test "x$HAVE_SOXR" = "x1"], AC_DEFINE([HAVE_SOXR], 1, [Have soxr]))
>+
>+#### Xen support (optional) ####
>+
>+AC_ARG_ENABLE([xen],
>+    AS_HELP_STRING([--disable-xen],[Disable optional Xen paravirtualized driver]))
>+
>+XEN_CFLAGS=
>+XEN_LIBS=
>+
>+AS_IF([test "x$enable_xen" != "xno"],
>+    [
>+        HAVE_XEN=1
>+        AC_CHECK_HEADER(xenctrl.h, [], [HAVE_XEN=0])
>+        AC_CHECK_HEADER(xs.h, [], [HAVE_XEN=0])
>+        AC_CHECK_LIB(xenctrl, xc_interface_open, [XEN_LIBS="$XEN_LIBS -lxenctrl"], [HAVE_XEN=0])
>+        AC_CHECK_LIB(xenstore, xs_domain_open, [XEN_LIBS="$XEN_LIBS -lxenstore"], [HAVE_XEN=0])
>+    ],
>+    HAVE_XEN=0)
>+
>+AS_IF([test "x$enable_xen" = "xyes" && test "x$HAVE_XEN" = "x0"],
>+    [AC_MSG_ERROR([*** Xen development headers or libraries not found])])
>+
>+AC_SUBST(XEN_CFLAGS)
>+AC_SUBST(XEN_LIBS)
>+AM_CONDITIONAL([HAVE_XEN], [test "x$HAVE_XEN" = x1])
>+
>+#### gcov support (optional) #####
>+
>+AC_ARG_ENABLE([gcov],
>+    AS_HELP_STRING([--enable-gcov],[Enable optional gcov coverage analysis]))
>+
>+GCOV_CFLAGS=
>+GCOV_LIBS=" -lgcov"
>+
>+AS_IF([test "x$enable_gcov" = "xyes"],
>+    [
>+        HAVE_GCOV=1
>+        GCOV_CFLAGS="$GCOV_CFLAGS -fprofile-arcs -ftest-coverage"
>+        GCOV_LIBS="$GCOV_LIBS -fprofile-arcs"
>+    ],
>+    HAVE_GCOV=0)
>+
>+AC_SUBST(GCOV_CFLAGS)
>+AC_SUBST(GCOV_LIBS)
>+AM_CONDITIONAL([HAVE_GCOV], [test "x$HAVE_GCOV" = x1])
>+
>+#### ORC (optional) ####
>+
>+ORC_CHECK([0.4.11])
>+
>+#### systemd support (optional) ####
>+
>+AC_ARG_ENABLE([systemd-daemon],
>+    AS_HELP_STRING([--disable-systemd-daemon],[Disable optional systemd daemon (socket activation) support]))
>+
>+AC_ARG_ENABLE([systemd-login],
>+    AS_HELP_STRING([--disable-systemd-login],[Disable optional systemd login support]))
>+
>+AC_ARG_ENABLE([systemd-journal],
>+    AS_HELP_STRING([--disable-systemd-journal],[Disable optional systemd journal support]))
>+
>+# Newer systemd's combine their subcomponent libraries into one
>+# If it exists, we should use it for the further checks
>+
>+AS_IF([test "x$enable_systemd_daemon" != "xno" || test "x$enable_systemd_login" != "xno" || test "x$enable_systemd_journal" != "xno"],
>+    [PKG_CHECK_MODULES(SYSTEMD, [ libsystemd ], HAVE_SYSTEMD=1, HAVE_SYSTEMD=0)],
>+    HAVE_SYSTEMD=0)
>+
>+AS_IF([test "x$HAVE_SYSTEMD" = "x1"],
>+    [
>+        HAVE_SYSTEMD_DAEMON=1
>+        HAVE_SYSTEMD_LOGIN=1
>+        HAVE_SYSTEMD_JOURNAL=1
>+    ])
>+
>+AC_ARG_WITH([systemduserunitdir],
>+        AS_HELP_STRING([--with-systemduserunitdir=DIR], [Directory for systemd user service files]),
>+        [], [with_systemduserunitdir=$($PKG_CONFIG --variable=systemduserunitdir systemd)])
>+if test "x$with_systemduserunitdir" != xno; then
>+        AC_SUBST([systemduserunitdir], [$with_systemduserunitdir])
>+fi
>+
>+#### systemd daemon support (optional) ####
>+
>+AS_IF([test "x$enable_systemd_daemon" != "xno"],
>+    [AS_IF([test "x$HAVE_SYSTEMD_DAEMON" != "x1"], [PKG_CHECK_MODULES(SYSTEMDDAEMON, [ libsystemd-daemon ], HAVE_SYSTEMD_DAEMON=1, HAVE_SYSTEMD_DAEMON=0)])],
>+    HAVE_SYSTEMD_DAEMON=0)
>+
>+AS_IF([test "x$enable_systemd_daemon" = "xyes" && test "x$HAVE_SYSTEMD_DAEMON" = "x0"],
>+    [AC_MSG_ERROR([*** Needed systemd daemon support not found])])
>+
>+AC_SUBST(HAVE_SYSTEMD_DAEMON)
>+AM_CONDITIONAL([HAVE_SYSTEMD_DAEMON], [test "x$HAVE_SYSTEMD_DAEMON" = x1])
>+AS_IF([test "x$HAVE_SYSTEMD_DAEMON" = "x1"], AC_DEFINE([HAVE_SYSTEMD_DAEMON], 1, [Have SYSTEMDDAEMON?]))
>+
>+#### systemd login support (optional) ####
>+
>+AS_IF([test "x$enable_systemd_login" != "xno"],
>+    [AS_IF([test "x$HAVE_SYSTEMD_LOGIN" != "x1"], [PKG_CHECK_MODULES(SYSTEMDLOGIN, [ libsystemd-login ], HAVE_SYSTEMD_LOGIN=1, HAVE_SYSTEMD_LOGIN=0)])],
>+    HAVE_SYSTEMD_LOGIN=0)
>+
>+AS_IF([test "x$enable_systemd_login" = "xyes" && test "x$HAVE_SYSTEMD_LOGIN" = "x0"],
>+    [AC_MSG_ERROR([*** Needed systemd login support not found])])
>+
>+AC_SUBST(HAVE_SYSTEMD_LOGIN)
>+AM_CONDITIONAL([HAVE_SYSTEMD_LOGIN], [test "x$HAVE_SYSTEMD_LOGIN" = x1])
>+AS_IF([test "x$HAVE_SYSTEMD_LOGIN" = "x1"], AC_DEFINE([HAVE_SYSTEMD_LOGIN], 1, [Have SYSTEMDLOGIN?]))
>+
>+#### systemd journal support (optional) ####
>+
>+AS_IF([test "x$enable_systemd_journal" != "xno"],
>+    [AS_IF([test "x$HAVE_SYSTEMD_JOURNAL" != "x1"], [PKG_CHECK_MODULES(SYSTEMDJOURNAL, [ libsystemd-journal ], HAVE_SYSTEMD_JOURNAL=1, HAVE_SYSTEMD_JOURNAL=0)])],
>+    HAVE_SYSTEMD_JOURNAL=0)
>+
>+AS_IF([test "x$enable_systemd_journal" = "xyes" && test "x$HAVE_SYSTEMD_JOURNAL" = "x0"],
>+    [AC_MSG_ERROR([*** Needed systemd journal support not found])])
>+
>+AC_SUBST(HAVE_SYSTEMD_JOURNAL)
>+AM_CONDITIONAL([HAVE_SYSTEMD_JOURNAL], [test "x$HAVE_SYSTEMD_JOURNAL" = x1])
>+AS_IF([test "x$HAVE_SYSTEMD_JOURNAL" = "x1"], AC_DEFINE([HAVE_SYSTEMD_JOURNAL], 1, [Have SYSTEMDJOURNAL?]))
>+
>+#### Build and Install man pages ####
>+
>+AC_ARG_ENABLE([manpages],
>+    AS_HELP_STRING([--disable-manpages],[Disable building and installation of man pages]))
>+
>+AM_CONDITIONAL([BUILD_MANPAGES], [test "x$enable_manpages" != "xno"])
>+
>+#### PulseAudio system group & user  #####
>+
>+AC_ARG_WITH(system_user, AS_HELP_STRING([--with-system-user=<user>],[User for running the PulseAudio daemon as a system-wide instance (pulse)]))
>+if test -z "$with_system_user" ; then
>+    PA_SYSTEM_USER=pulse
>+else
>+    PA_SYSTEM_USER=$with_system_user
>+fi
>+AC_SUBST(PA_SYSTEM_USER)
>+AC_DEFINE_UNQUOTED(PA_SYSTEM_USER,"$PA_SYSTEM_USER", [User for running the PulseAudio system daemon])
>+
>+AC_ARG_WITH(system_group,AS_HELP_STRING([--with-system-group=<group>],[Group for running the PulseAudio daemon as a system-wide instance (pulse)]))
>+if test -z "$with_system_group" ; then
>+    PA_SYSTEM_GROUP=pulse
>+else
>+    PA_SYSTEM_GROUP=$with_system_group
>+fi
>+AC_SUBST(PA_SYSTEM_GROUP)
>+AC_DEFINE_UNQUOTED(PA_SYSTEM_GROUP,"$PA_SYSTEM_GROUP", [Group for the PulseAudio system daemon])
>+
>+AC_ARG_WITH(access_group,AS_HELP_STRING([--with-access-group=<group>],[Group which is allowed access to a system-wide PulseAudio daemon (pulse-access)]))
>+if test -z "$with_access_group" ; then
>+    PA_ACCESS_GROUP=pulse-access
>+else
>+    PA_ACCESS_GROUP=$with_access_group
>+fi
>+AC_SUBST(PA_ACCESS_GROUP)
>+AC_DEFINE_UNQUOTED(PA_ACCESS_GROUP,"$PA_ACCESS_GROUP", [Access group])
>+
>+AC_ARG_ENABLE([per-user-esound-socket],
>+    AS_HELP_STRING([--disable-per-user-esound-socket],[Use global esound socket directory /tmp/.esd/socket.]))
>+
>+if test "x$enable_per_user_esound_socket" != "xno"; then
>+    USE_PER_USER_ESOUND_SOCKET=1
>+    AC_DEFINE([USE_PER_USER_ESOUND_SOCKET], [1], [Define this if you want per-user esound socket directories])
>+else
>+    USE_PER_USER_ESOUND_SOCKET=0
>+fi
>+
>+#### PulseAudio system runtime dir ####
>+
>+PA_SYSTEM_RUNTIME_PATH="${localstatedir}/run/pulse"
>+AX_DEFINE_DIR(PA_SYSTEM_RUNTIME_PATH, PA_SYSTEM_RUNTIME_PATH, [System runtime dir])
>+PA_SYSTEM_CONFIG_PATH="${localstatedir}/lib/pulse"
>+AX_DEFINE_DIR(PA_SYSTEM_CONFIG_PATH, PA_SYSTEM_CONFIG_PATH, [System config dir])
>+PA_SYSTEM_STATE_PATH="${localstatedir}/lib/pulse"
>+AX_DEFINE_DIR(PA_SYSTEM_STATE_PATH, PA_SYSTEM_STATE_PATH, [System state dir])
>+
>+PA_BINARY=${bindir}/pulseaudio${EXEEXT}
>+AX_DEFINE_DIR(PA_BINARY, PA_BINARY, [Location of pulseaudio binary])
>+
>+PACTL_BINARY=${bindir}/pactl${EXEEXT}
>+AX_DEFINE_DIR(PACTL_BINARY, PACTL_BINARY, [Location of pactl binary])
>+
>+AC_SUBST(PA_SOEXT, [.so])
>+AC_DEFINE(PA_SOEXT, [".so"], [Shared object extension])
>+
>+AC_SUBST(pulseconfdir, ["${sysconfdir}/pulse"])
>+AX_DEFINE_DIR(PA_DEFAULT_CONFIG_DIR, pulseconfdir, [Location of configuration files])
>+
>+#### Mac OSX specific stuff #####
>+
>+AC_ARG_ENABLE(mac-universal,
>+    AS_HELP_STRING([--enable-mac-universal], [Build Mac universal binaries]),
>+    enable_mac_universal=$enableval, enable_mac_universal="no")
>+
>+AC_ARG_WITH(mac-version-min,
>+    AS_HELP_STRING([--with-mac-version-min=<version>], [Defines the earliest version of MacOS X that the executables will run on.]),
>+    mac_version_min=$withval, mac_version_min="10.5")
>+
>+AC_ARG_WITH(mac-sysroot,
>+    AS_HELP_STRING([--with-mac-sysroot=<path>], [SDK basedir to use as the logical root directory for headers and libraries.]),
>+    mac_sysroot=$withval, mac_sysroot="/Developer/SDKs/MacOSX10.5.sdk")
>+
>+if test "x$os_is_darwin" = "x1" ; then
>+    LDFLAGS="$LDFLAGS -isysroot $mac_sysroot -mmacosx-version-min=$mac_version_min"
>+    CFLAGS="$CFLAGS -isysroot $mac_sysroot -mmacosx-version-min=$mac_version_min"
>+
>+    if test "x$enable_mac_universal" = "xyes" ; then
>+        mac_arches="-arch i386 -arch x86_64"
>+        LDFLAGS="$LDFLAGS $mac_arches"
>+        CFLAGS="$CFLAGS $mac_arches"
>+    fi
>+fi
>+
>+AC_ARG_ENABLE([webrtc-aec],
>+    AS_HELP_STRING([--enable-webrtc-aec], [Enable the optional WebRTC-based echo canceller]))
>+
>+AS_IF([test "x$enable_webrtc_aec" != "xno"],
>+    [PKG_CHECK_MODULES(WEBRTC, [ webrtc-audio-processing ], [HAVE_WEBRTC=1], [HAVE_WEBRTC=0])],
>+    [HAVE_WEBRTC=0])
>+
>+AS_IF([test "x$enable_webrtc_aec" = "xyes" && test "x$HAVE_WEBRTC" = "x0"],
>+    [AC_MSG_ERROR([*** webrtc-audio-processing library not found])])
>+
>+AM_CONDITIONAL([HAVE_WEBRTC], [test "x$HAVE_WEBRTC" = "x1"])
>+
>+AC_ARG_ENABLE([adrian-aec],
>+    AS_HELP_STRING([--enable-adrian-aec], [Enable Adrian's optional echo canceller]))
>+AS_IF([test "x$enable_adrian_aec" != "xno"],
>+    [HAVE_ADRIAN_EC=1])
>+AM_CONDITIONAL([HAVE_ADRIAN_EC], [test "x$HAVE_ADRIAN_EC" = "x1"])
>+
>+
>+
>+###################################
>+#            Output               #
>+###################################
>+
>+AC_DEFINE_UNQUOTED(PA_CFLAGS, "$CFLAGS", [The CFLAGS used during compilation])
>+
>+# Check whether to build tests by default (as compile-test) or not
>+AC_ARG_ENABLE([default-build-tests],
>+    AS_HELP_STRING([--disable-default-build-tests], [Build test programs only during make check]))
>+AM_CONDITIONAL([BUILD_TESTS_DEFAULT], [test "x$enable_default_build_tests" != "xno"])
>+
>+AC_ARG_ENABLE([legacy-database-entry-format],
>+        AS_HELP_STRING([--disable-legacy-database-entry-format], [Try to load legacy (< 1.0) database files (card, device and volume restore).]))
>+if test "x$enable_legacy_database_entry_format" != "xno" ; then
>+        AC_DEFINE(ENABLE_LEGACY_DATABASE_ENTRY_FORMAT, [1], [Legacy database entry format])
>+fi
>+
>+AC_ARG_ENABLE([static-bins],
>+    AS_HELP_STRING([--enable-static-bins],[Statically link executables.]))
>+AM_CONDITIONAL([STATIC_BINS], [test "x$enable_static_bins" = "xyes"])
>+
>+AC_ARG_WITH(
>+        [preopen-mods],
>+        AS_HELP_STRING([--with-preopen-mods],[Modules to preopen in daemon (default: all).]),
>+        [PREOPEN_MODS=$withval], [PREOPEN_MODS="all"])
>+AM_CONDITIONAL([PREOPEN_MODS], [test "x$PREOPEN_MODS" != "xall"])
>+if test "x$PREOPEN_MODS" != "xall" ; then
>+    tmpLIBS=""
>+    for mod in $PREOPEN_MODS; do
>+        tmpLIBS="$tmpLIBS module-$mod.la"
>+    done
>+    PREOPEN_MODS="$tmpLIBS"
>+    AC_SUBST(PREOPEN_MODS)
>+fi
>+
>+AC_ARG_WITH(
>+        [module-dir],
>+        AS_HELP_STRING([--with-module-dir],[Directory where to install the modules to (defaults to ${libdir}/pulse-${PA_MAJORMINOR}/modules]),
>+        [modlibexecdir=$withval], [modlibexecdir="${libdir}/pulse-${PA_MAJORMINOR}/modules"])
>+
>+AC_SUBST(modlibexecdir)
>+AX_DEFINE_DIR(PA_DLSEARCHPATH, modlibexecdir, [Modules dir])
>+
>+AC_ARG_WITH(
>+        [udev-rules-dir],
>+        AS_HELP_STRING([--with-udev-rules-dir],[Directory where to install udev rules to (defaults to /lib/udev/rules.d)]),
>+        [udevrulesdir=$withval], [udevrulesdir="/lib/udev/rules.d"])
>+
>+AC_SUBST(udevrulesdir)
>+
>+AC_ARG_WITH([bash-completion-dir],
>+        AS_HELP_STRING([--with-bash-completion-dir=DIR], [Directory for bash completion files]),
>+        [bashcompletiondir=$withval], [bashcompletiondir=$($PKG_CONFIG --variable=completionsdir bash-completion)])
>+if test "x$bashcompletionsdir" = "x"; then
>+	bashcompletiondir="${datadir}/bash-completion/completions"
>+fi
>+
>+AC_SUBST(bashcompletiondir)
>+
>+AC_ARG_WITH(
>+        [zsh-completion-dir],
>+        AS_HELP_STRING([--with-zsh-completion-dir], [Zsh completions directory (defaults to ${datadir}/zsh/site-functions)]),
>+        [zshcompletiondir=$withval], [zshcompletiondir="${datadir}/zsh/site-functions"])
>+
>+AC_SUBST(zshcompletiondir)
>+
>+AC_ARG_ENABLE([force-preopen],
>+    AS_HELP_STRING([--enable-force-preopen],[Preopen modules, even when dlopen() is supported.]))
>+
>+if test "x$enable_force_preopen" = "xyes"; then
>+    FORCE_PREOPEN=yes
>+else
>+    FORCE_PREOPEN=no
>+fi
>+
>+AM_CONDITIONAL([FORCE_PREOPEN], [test "x$FORCE_PREOPEN" = "xyes"])
>+
>+AC_CONFIG_FILES([
>+Makefile
>+src/Makefile
>+man/Makefile
>+libpulse.pc
>+libpulse-simple.pc
>+libpulse-mainloop-glib.pc
>+doxygen/Makefile
>+doxygen/doxygen.conf
>+src/pulse/version.h
>+po/Makefile.in
>+man/pulseaudio.1.xml
>+man/esdcompat.1.xml
>+man/pax11publish.1.xml
>+man/pacat.1.xml
>+man/pacmd.1.xml
>+man/pactl.1.xml
>+man/pasuspender.1.xml
>+man/padsp.1.xml
>+man/pulse-daemon.conf.5.xml
>+man/pulse-client.conf.5.xml
>+man/default.pa.5.xml
>+man/pulse-cli-syntax.5.xml
>+man/start-pulseaudio-x11.1.xml
>+])
>+
>+AC_CONFIG_FILES([src/esdcompat:src/daemon/esdcompat.in], [chmod +x src/esdcompat])
>+AC_CONFIG_FILES([src/start-pulseaudio-x11:src/daemon/start-pulseaudio-x11.in], [chmod +x src/start-pulseaudio-x11])
>+AC_CONFIG_FILES([src/client.conf:src/pulse/client.conf.in])
>+AC_CONFIG_FILES([src/daemon.conf:src/daemon/daemon.conf.in],
>+    [m4 src/daemon.conf > src/daemon.conf.gen && mv src/daemon.conf.gen src/daemon.conf])
>+AC_CONFIG_FILES([src/default.pa:src/daemon/default.pa.in],
>+    [m4 src/default.pa > src/default.pa.gen && mv src/default.pa.gen src/default.pa])
>+AC_CONFIG_FILES([src/system.pa:src/daemon/system.pa.in],
>+    [m4 src/system.pa > src/system.pa.gen && mv src/system.pa.gen src/system.pa])
>+AS_IF([test "x$HAVE_SYSTEMD_DAEMON" = "x1"],
>+    [
>+        AC_CONFIG_FILES([src/pulseaudio.service:src/daemon/systemd/user/pulseaudio.service.in])
>+    ])
>+
>+# CMake related ProjectConfig files
>+PA_LIBDIR="$libdir"
>+AX_DEFINE_DIR(PA_LIBDIR, PA_LIBDIR, [PulseAudio library dir])
>+PA_INCDIR="$includedir"
>+AX_DEFINE_DIR(PA_INCDIR, PA_INCDIR, [PulseAudio include dir])
>+
>+AC_CONFIG_FILES([PulseAudioConfig.cmake:PulseAudioConfig.cmake.in],
>+    [m4 PulseAudioConfig.cmake > PulseAudioConfig.cmake.gen && mv PulseAudioConfig.cmake.gen PulseAudioConfig.cmake])
>+AC_CONFIG_FILES([PulseAudioConfigVersion.cmake])
>+
>+AC_OUTPUT
>+
>+# ==========================================================================
>+
>+AS_IF([test "x$HAVE_X11" = "x1"], ENABLE_X11=yes, ENABLE_X11=no)
>+AS_IF([test "x$HAVE_OSS_OUTPUT" = "x1"], ENABLE_OSS_OUTPUT=yes, ENABLE_OSS_OUTPUT=no)
>+AS_IF([test "x$HAVE_OSS_WRAPPER" = "x1"], ENABLE_OSS_WRAPPER=yes, ENABLE_OSS_WRAPPER=no)
>+AS_IF([test "x$HAVE_ALSA" = "x1"], ENABLE_ALSA=yes, ENABLE_ALSA=no)
>+AS_IF([test "x$HAVE_COREAUDIO" = "x1"], ENABLE_COREAUDIO=yes, ENABLE_COREAUDIO=no)
>+AS_IF([test "x$HAVE_SOLARIS" = "x1"], ENABLE_SOLARIS=yes, ENABLE_SOLARIS=no)
>+AS_IF([test "x$HAVE_WAVEOUT" = "x1"], ENABLE_WAVEOUT=yes, ENABLE_WAVEOUT=no)
>+AS_IF([test "x$HAVE_GLIB20" = "x1"], ENABLE_GLIB20=yes, ENABLE_GLIB20=no)
>+AS_IF([test "x$HAVE_GTK30" = "x1"], ENABLE_GTK30=yes, ENABLE_GTK30=no)
>+AS_IF([test "x$HAVE_GCONF" = "x1"], ENABLE_GCONF=yes, ENABLE_GCONF=no)
>+AS_IF([test "x$HAVE_AVAHI" = "x1"], ENABLE_AVAHI=yes, ENABLE_AVAHI=no)
>+AS_IF([test "x$HAVE_JACK" = "x1"], ENABLE_JACK=yes, ENABLE_JACK=no)
>+AS_IF([test "x$HAVE_LIBASYNCNS" = "x1"], ENABLE_LIBASYNCNS=yes, ENABLE_LIBASYNCNS=no)
>+AS_IF([test "x$HAVE_LIRC" = "x1"], ENABLE_LIRC=yes, ENABLE_LIRC=no)
>+AS_IF([test "x$HAVE_XEN" = "x1"], ENABLE_XEN=yes, ENABLE_XEN=no)
>+AS_IF([test "x$HAVE_DBUS" = "x1"], ENABLE_DBUS=yes, ENABLE_DBUS=no)
>+AS_IF([test "x$HAVE_UDEV" = "x1"], ENABLE_UDEV=yes, ENABLE_UDEV=no)
>+AS_IF([test "x$HAVE_SYSTEMD_DAEMON" = "x1"], ENABLE_SYSTEMD_DAEMON=yes, ENABLE_SYSTEMD_DAEMON=no)
>+AS_IF([test "x$HAVE_SYSTEMD_LOGIN" = "x1"], ENABLE_SYSTEMD_LOGIN=yes, ENABLE_SYSTEMD_LOGIN=no)
>+AS_IF([test "x$HAVE_SYSTEMD_JOURNAL" = "x1"], ENABLE_SYSTEMD_JOURNAL=yes, ENABLE_SYSTEMD_JOURNAL=no)
>+AS_IF([test "x$HAVE_BLUEZ_4" = "x1"], ENABLE_BLUEZ_4=yes, ENABLE_BLUEZ_4=no)
>+AS_IF([test "x$HAVE_BLUEZ_5" = "x1"], ENABLE_BLUEZ_5=yes, ENABLE_BLUEZ_5=no)
>+AS_IF([test "x$HAVE_BLUEZ_5_OFONO_HEADSET" = "x1"], ENABLE_BLUEZ_5_OFONO_HEADSET=yes, ENABLE_BLUEZ_5_OFONO_HEADSET=no)
>+AS_IF([test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = "x1"], ENABLE_BLUEZ_5_NATIVE_HEADSET=yes, ENABLE_BLUEZ_5_NATIVE_HEADSET=no)
>+AS_IF([test "x$HAVE_HAL_COMPAT" = "x1"], ENABLE_HAL_COMPAT=yes, ENABLE_HAL_COMPAT=no)
>+AS_IF([test "x$HAVE_TCPWRAP" = "x1"], ENABLE_TCPWRAP=yes, ENABLE_TCPWRAP=no)
>+AS_IF([test "x$HAVE_LIBSAMPLERATE" = "x1"], ENABLE_LIBSAMPLERATE="yes (DEPRECATED)", ENABLE_LIBSAMPLERATE=no)
>+AS_IF([test "x$HAVE_IPV6" = "x1"], ENABLE_IPV6=yes, ENABLE_IPV6=no)
>+AS_IF([test "x$HAVE_OPENSSL" = "x1"], ENABLE_OPENSSL=yes, ENABLE_OPENSSL=no)
>+AS_IF([test "x$HAVE_FFTW" = "x1"], ENABLE_FFTW=yes, ENABLE_FFTW=no)
>+AS_IF([test "x$HAVE_ORC" = "xyes"], ENABLE_ORC=yes, ENABLE_ORC=no)
>+AS_IF([test "x$HAVE_ADRIAN_EC" = "x1"], ENABLE_ADRIAN_EC=yes, ENABLE_ADRIAN_EC=no)
>+AS_IF([test "x$HAVE_SPEEX" = "x1"], ENABLE_SPEEX=yes, ENABLE_SPEEX=no)
>+AS_IF([test "x$HAVE_SOXR" = "x1"], ENABLE_SOXR=yes, ENABLE_SOXR=no)
>+AS_IF([test "x$HAVE_WEBRTC" = "x1"], ENABLE_WEBRTC=yes, ENABLE_WEBRTC=no)
>+AS_IF([test "x$HAVE_TDB" = "x1"], ENABLE_TDB=yes, ENABLE_TDB=no)
>+AS_IF([test "x$HAVE_GDBM" = "x1"], ENABLE_GDBM=yes, ENABLE_GDBM=no)
>+AS_IF([test "x$HAVE_SIMPLEDB" = "x1"], ENABLE_SIMPLEDB=yes, ENABLE_SIMPLEDB=no)
>+AS_IF([test "x$HAVE_ESOUND" = "x1"], ENABLE_ESOUND=yes, ENABLE_ESOUND=no)
>+AS_IF([test "x$HAVE_ESOUND" = "x1" -a "x$USE_PER_USER_ESOUND_SOCKET" = "x1"], ENABLE_PER_USER_ESOUND_SOCKET=yes, ENABLE_PER_USER_ESOUND_SOCKET=no)
>+AS_IF([test "x$HAVE_GCOV" = "x1"], ENABLE_GCOV=yes, ENABLE_GCOV=no)
>+AS_IF([test "x$HAVE_LIBCHECK" = "x1"], ENABLE_TESTS=yes, ENABLE_TESTS=no)
>+AS_IF([test "x$enable_legacy_database_entry_format" != "xno"], ENABLE_LEGACY_DATABASE_ENTRY_FORMAT=yes, ENABLE_LEGACY_DATABASE_ENTRY_FORMAT=no)
>+
>+echo "
>+ ---{ $PACKAGE_NAME $VERSION }---
>+
>+    prefix:                        ${prefix}
>+    sysconfdir:                    ${sysconfdir}
>+    localstatedir:                 ${localstatedir}
>+    modlibexecdir:                 ${modlibexecdir}
>+    System Runtime Path:           ${PA_SYSTEM_RUNTIME_PATH}
>+    System State Path:             ${PA_SYSTEM_STATE_PATH}
>+    System Config Path:            ${PA_SYSTEM_CONFIG_PATH}
>+    Zsh completions directory:     ${zshcompletiondir}
>+    Bash completions directory:    ${bashcompletiondir}
>+    Compiler:                      ${CC}
>+    CFLAGS:                        ${CFLAGS}
>+    CPPFLAGS:                      ${CPPFLAGS}
>+    LIBS:                          ${LIBS}
>+
>+    Enable X11:                    ${ENABLE_X11}
>+    Enable OSS Output:             ${ENABLE_OSS_OUTPUT}
>+    Enable OSS Wrapper:            ${ENABLE_OSS_WRAPPER}
>+    Enable EsounD:                 ${ENABLE_ESOUND}
>+    Enable Alsa:                   ${ENABLE_ALSA}
>+    Enable CoreAudio:              ${ENABLE_COREAUDIO}
>+    Enable Solaris:                ${ENABLE_SOLARIS}
>+    Enable WaveOut:                ${ENABLE_WAVEOUT}
>+    Enable GLib 2.0:               ${ENABLE_GLIB20}
>+    Enable Gtk+ 3.0:               ${ENABLE_GTK30}
>+    Enable GConf:                  ${ENABLE_GCONF}
>+    Enable Avahi:                  ${ENABLE_AVAHI}
>+    Enable Jack:                   ${ENABLE_JACK}
>+    Enable Async DNS:              ${ENABLE_LIBASYNCNS}
>+    Enable LIRC:                   ${ENABLE_LIRC}
>+    Enable Xen PV driver:          ${ENABLE_XEN}
>+    Enable D-Bus:                  ${ENABLE_DBUS}
>+      Enable BlueZ 4:              ${ENABLE_BLUEZ_4}
>+      Enable BlueZ 5:              ${ENABLE_BLUEZ_5}
>+        Enable ofono headsets:     ${ENABLE_BLUEZ_5_OFONO_HEADSET}
>+        Enable native headsets:    ${ENABLE_BLUEZ_5_NATIVE_HEADSET}
>+    Enable udev:                   ${ENABLE_UDEV}
>+      Enable HAL->udev compat:     ${ENABLE_HAL_COMPAT}
>+    Enable systemd
>+      Daemon (Socket Activation):  ${ENABLE_SYSTEMD_DAEMON}
>+      Login (Session Tracking):    ${ENABLE_SYSTEMD_LOGIN}
>+      Journal (Logging):           ${ENABLE_SYSTEMD_JOURNAL}
>+    Enable TCP Wrappers:           ${ENABLE_TCPWRAP}
>+    Enable libsamplerate:          ${ENABLE_LIBSAMPLERATE}
>+    Enable IPv6:                   ${ENABLE_IPV6}
>+    Enable OpenSSL (for Airtunes): ${ENABLE_OPENSSL}
>+    Enable fftw:                   ${ENABLE_FFTW}
>+    Enable orc:                    ${ENABLE_ORC}
>+    Enable Adrian echo canceller:  ${ENABLE_ADRIAN_EC}
>+    Enable speex (resampler, AEC): ${ENABLE_SPEEX}
>+    Enable soxr (resampler):       ${ENABLE_SOXR}
>+    Enable WebRTC echo canceller:  ${ENABLE_WEBRTC}
>+    Enable gcov coverage:          ${ENABLE_GCOV}
>+    Enable unit tests:             ${ENABLE_TESTS}
>+    Database
>+      tdb:                         ${ENABLE_TDB}
>+      gdbm:                        ${ENABLE_GDBM}
>+      simple database:             ${ENABLE_SIMPLEDB}
>+
>+    System User:                   ${PA_SYSTEM_USER}
>+    System Group:                  ${PA_SYSTEM_GROUP}
>+    Access Group:                  ${PA_ACCESS_GROUP}
>+    Enable per-user EsounD socket: ${ENABLE_PER_USER_ESOUND_SOCKET}
>+    Force preopen:                 ${FORCE_PREOPEN}
>+    Preopened modules:             ${PREOPEN_MODS}
>+
>+    Legacy Database Entry Support: ${ENABLE_LEGACY_DATABASE_ENTRY_FORMAT}
>+"
>+
>+if test "${ENABLE_SPEEX}" = "no" && test "${ENABLE_WEBRTC}" = "no" && test "${ENABLE_ADRIAN_EC}" = "no" ; then
>+AC_MSG_ERROR([At least one echo canceller implementation must be available.])
>+fi
>+
>+if test "${ENABLE_DBUS}" = "no" && test "x$os_is_win32" != "x1" ; then
>+   echo "
>+===== WARNING WARNING WARNING WARNING WARNING WARNING WARNING =====
>+You do not have D-Bus support enabled. It is strongly recommended
>+that you enable D-Bus support if your platform supports it.
>+Many parts of PulseAudio use D-Bus, from ConsoleKit interaction
>+to the Device Reservation Protocol to speak to JACK, Bluetooth
>+support and even a native control protocol for communicating and
>+controling the PulseAudio daemon itself.
>+===== WARNING WARNING WARNING WARNING WARNING WARNING WARNING =====
>+"
>+fi
>+
>+if test "${ENABLE_UDEV}" = "no" && test "x$os_is_win32" != "x1" ; then
>+   echo "
>+===== WARNING WARNING WARNING WARNING WARNING WARNING WARNING =====
>+You do not have udev support enabled. It is strongly recommended
>+that you enable udev support if your platform supports it as it is
>+the primary method used to detect hardware audio devices (on Linux)
>+and is thus a critical part of PulseAudio on that platform.
>+===== WARNING WARNING WARNING WARNING WARNING WARNING WARNING =====
>+"
>+fi
>+
>+if test "${ENABLE_SPEEX}" = "no" && test "x$os_is_win32" != "x1" ; then
>+   echo "
>+===== WARNING WARNING WARNING WARNING WARNING WARNING WARNING =====
>+You do not have speex support enabled. It is strongly recommended
>+that you enable speex support if your platform supports it as it is
>+the primary method used for audio resampling and is thus a critical
>+part of PulseAudio on that platform.
>+===== WARNING WARNING WARNING WARNING WARNING WARNING WARNING =====
>+"
>+fi
>diff -Naur a/src/Makefile.am b/src/Makefile.am
>--- a/src/Makefile.am	2016-01-30 17:31:03.000000000 -0800
>+++ b/src/Makefile.am	2016-01-31 12:11:22.000000000 -0800
>@@ -972,7 +972,8 @@
> 		pulsecore/source.c pulsecore/source.h \
> 		pulsecore/start-child.c pulsecore/start-child.h \
> 		pulsecore/thread-mq.c pulsecore/thread-mq.h \
>-		pulsecore/database.h
>+		pulsecore/database.h \
>+		pulsecore/transcode.c pulsecore/transcode.h
> 
> libpulsecore_@PA_MAJORMINOR@_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS) $(LIBSNDFILE_CFLAGS) $(WINSOCK_CFLAGS)
> libpulsecore_@PA_MAJORMINOR@_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>@@ -1045,6 +1046,11 @@
> libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(LIBSAMPLERATE_LIBS)
> endif
> 
>+if HAVE_OPUS
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(LIBOPUS_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(LIBOPUS_LIBS)
>+endif
>+
> # We split the foreign code off to not be annoyed by warnings we don't care about
> noinst_LTLIBRARIES += libpulsecore-foreign.la
> 
>diff -Naur a/src/Makefile.am.orig b/src/Makefile.am.orig
>--- a/src/Makefile.am.orig	1969-12-31 16:00:00.000000000 -0800
>+++ b/src/Makefile.am.orig	2016-01-31 12:11:22.000000000 -0800
>@@ -0,0 +1,2293 @@
>+# This file is part of PulseAudio.
>+#
>+# Copyright 2004-2006 Lennart Poettering
>+# Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
>+# Copyright 2006 Diego PettenÃ²
>+#
>+# PulseAudio is free software; you can redistribute it and/or modify
>+# it under the terms of the GNU Lesser General Public License as published by
>+# the Free Software Foundation; either version 2 of the License, or
>+# (at your option) any later version.
>+#
>+# PulseAudio is distributed in the hope that it will be useful, but
>+# WITHOUT ANY WARRANTY; without even the implied warranty of
>+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
>+# General Public License for more details.
>+#
>+# You should have received a copy of the GNU Lesser General Public License
>+# along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
>+
>+###################################
>+#       Extra directories         #
>+###################################
>+
>+pulseincludedir=$(includedir)/pulse
>+pulsecoreincludedir=$(includedir)/pulsecore
>+pulselibexecdir=$(libexecdir)/pulse
>+if HAVE_X11
>+xdgautostartdir=$(sysconfdir)/xdg/autostart
>+endif
>+if HAVE_ALSA
>+alsaprofilesetsdir=$(datadir)/pulseaudio/alsa-mixer/profile-sets
>+alsapathsdir=$(datadir)/pulseaudio/alsa-mixer/paths
>+endif
>+if HAVE_DBUS
>+dbuspolicydir=$(sysconfdir)/dbus-1/system.d
>+endif
>+
>+###################################
>+#     Compiler/linker flags       #
>+###################################
>+
>+AM_CPPFLAGS = \
>+	-I$(top_srcdir)/src \
>+	-I$(top_srcdir)/src/modules \
>+	-I$(top_builddir)/src/modules \
>+	-DPA_ALSA_PATHS_DIR=\"$(alsapathsdir)\" \
>+	-DPA_ALSA_PROFILE_SETS_DIR=\"$(alsaprofilesetsdir)\" \
>+	-DPA_SRCDIR=\"$(abs_srcdir)\" \
>+	-DPA_BUILDDIR=\"$(abs_builddir)\" \
>+	-DPULSE_LOCALEDIR=\"$(localedir)\"
>+AM_CFLAGS = \
>+	$(PTHREAD_CFLAGS)
>+AM_CXXFLAGS = $(AM_CFLAGS)
>+SERVER_CFLAGS = -D__INCLUDED_FROM_PULSE_AUDIO
>+
>+AM_LIBADD = $(PTHREAD_LIBS) $(INTLLIBS)
>+AM_LDADD = $(PTHREAD_LIBS) $(INTLLIBS)
>+AM_LDFLAGS =
>+# Should only be applied to libraries.
>+AM_LIBLDFLAGS = $(NODELETE_LDFLAGS)
>+
>+if HAVE_GCOV
>+AM_CFLAGS+=$(GCOV_CFLAGS)
>+AM_CXXFLAGS+=$(GCOV_CFLAGS)
>+AM_LDFLAGS+=$(GCOV_LIBS)
>+endif
>+
>+if STATIC_BINS
>+BINLDFLAGS = -static
>+endif
>+
>+if OS_IS_WIN32
>+AM_LDFLAGS+=-Wl,--export-all-symbols,--enable-auto-import -no-undefined
>+WINSOCK_LIBS=-lwsock32 -lws2_32 -lwininet
>+endif
>+
>+if OS_IS_DARWIN
>+AM_LDFLAGS+=-Wl,-headerpad_max_install_names -headerpad_max_install_names
>+endif
>+
>+FOREIGN_CFLAGS = -w
>+
>+MODULE_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -module -disable-static -avoid-version $(NOUNDEFINED_LDFLAGS)
>+MODULE_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+###################################
>+#          Extra files            #
>+###################################
>+
>+EXTRA_DIST = \
>+		pulse/client.conf.in \
>+		pulse/version.h.in \
>+		daemon/daemon.conf.in \
>+		daemon/default.pa.in \
>+		daemon/system.pa.in \
>+		depmod.py \
>+		daemon/esdcompat.in \
>+		daemon/start-pulseaudio-x11.in \
>+		daemon/systemd/user/pulseaudio.service.in \
>+		daemon/systemd/user/pulseaudio.socket \
>+		utils/padsp.in \
>+		utils/qpaeq \
>+		modules/module-defs.h.m4 \
>+		daemon/pulseaudio.desktop.in \
>+		map-file \
>+		daemon/pulseaudio-system.conf \
>+		modules/echo-cancel/adrian-license.txt
>+
>+pulseconf_DATA = \
>+		default.pa \
>+		system.pa \
>+		daemon.conf \
>+		client.conf
>+
>+if HAVE_DBUS
>+dbuspolicy_DATA = \
>+		daemon/pulseaudio-system.conf
>+endif
>+
>+if HAVE_X11
>+xdgautostart_in_files = \
>+		daemon/pulseaudio.desktop.in
>+xdgautostart_DATA = $(xdgautostart_in_files:.desktop.in=.desktop)
>+@INTLTOOL_DESKTOP_RULE@
>+endif
>+
>+
>+###################################
>+#          Includes               #
>+###################################
>+
>+BUILT_SOURCES =
>+CLEANFILES =
>+include $(top_srcdir)/orc.mak
>+ORC_SOURCE =
>+
>+###################################
>+#          Main daemon            #
>+###################################
>+
>+bin_PROGRAMS = pulseaudio
>+
>+pulseaudio_SOURCES = \
>+		daemon/caps.c daemon/caps.h \
>+		daemon/cmdline.c daemon/cmdline.h \
>+		daemon/cpulimit.c daemon/cpulimit.h \
>+		daemon/daemon-conf.c daemon/daemon-conf.h \
>+		daemon/dumpmodules.c daemon/dumpmodules.h \
>+		daemon/ltdl-bind-now.c daemon/ltdl-bind-now.h \
>+		daemon/main.c
>+
>+pulseaudio_CFLAGS = $(AM_CFLAGS) $(CAP_CFLAGS)
>+pulseaudio_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la $(LIBLTDL) $(CAP_LIBS)
>+# This is needed because automake doesn't properly expand the foreach below
>+pulseaudio_DEPENDENCIES = libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la $(PREOPEN_LIBS)
>+
>+if HAVE_DBUS
>+pulseaudio_CFLAGS += $(DBUS_CFLAGS)
>+pulseaudio_SOURCES += daemon/server-lookup.c daemon/server-lookup.h
>+pulseaudio_LDADD += $(DBUS_LIBS)
>+endif
>+
>+if PREOPEN_MODS
>+PREOPEN_LIBS = $(PREOPEN_MODS)
>+else
>+PREOPEN_LIBS = $(modlibexec_LTLIBRARIES)
>+endif
>+
>+if FORCE_PREOPEN
>+pulseaudio_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(IMMEDIATE_LDFLAGS) -dlpreopen force $(foreach f,$(PREOPEN_LIBS),-dlpreopen $(f))
>+else
>+pulseaudio_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(IMMEDIATE_LDFLAGS) -dlopen force $(foreach f,$(PREOPEN_LIBS),-dlopen $(f))
>+endif
>+
>+if HAVE_SYSTEMD_DAEMON
>+pulseaudio_CFLAGS += $(SYSTEMD_FLAGS) $(SYSTEMDDAEMON_FLAGS)
>+pulseaudio_LDFLAGS += $(SYSTEMD_LIBS) $(SYSTEMDDAEMON_LIBS)
>+endif
>+
>+###################################
>+#       Utility programs          #
>+###################################
>+
>+bin_SCRIPTS = esdcompat
>+
>+bin_PROGRAMS += \
>+		pacat \
>+		pactl
>+
>+if !OS_IS_WIN32
>+bin_PROGRAMS += pasuspender
>+endif
>+
>+if HAVE_AF_UNIX
>+bin_PROGRAMS += pacmd
>+endif
>+
>+if HAVE_X11
>+bin_PROGRAMS += pax11publish
>+bin_SCRIPTS += start-pulseaudio-x11
>+endif
>+
>+pacat_SOURCES = utils/pacat.c
>+pacat_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la $(LIBSNDFILE_LIBS)
>+pacat_CFLAGS = $(AM_CFLAGS) $(LIBSNDFILE_CFLAGS)
>+pacat_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+pactl_SOURCES = utils/pactl.c
>+pactl_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la $(LIBSNDFILE_LIBS)
>+pactl_CFLAGS = $(AM_CFLAGS) $(LIBSNDFILE_CFLAGS)
>+pactl_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+pasuspender_SOURCES = utils/pasuspender.c
>+pasuspender_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+pasuspender_CFLAGS = $(AM_CFLAGS)
>+pasuspender_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+pacmd_SOURCES = utils/pacmd.c
>+pacmd_CFLAGS = $(AM_CFLAGS)
>+pacmd_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+pacmd_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+pax11publish_SOURCES = utils/pax11publish.c
>+pax11publish_CFLAGS = $(AM_CFLAGS) $(X11_CFLAGS)
>+pax11publish_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la $(X11_LIBS)
>+pax11publish_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+if HAVE_SYSTEMD_DAEMON
>+
>+systemduserunit_DATA = \
>+    pulseaudio.service \
>+    daemon/systemd/user/pulseaudio.socket
>+
>+endif
>+
>+###################################
>+#         Test programs           #
>+###################################
>+noinst_LTLIBRARIES =
>+
>+TESTS_default = \
>+		mainloop-test \
>+		strlist-test \
>+		close-test \
>+		memblockq-test \
>+		channelmap-test \
>+		thread-mainloop-test \
>+		utf8-test \
>+		format-test \
>+		get-binary-name-test \
>+		hook-list-test \
>+		memblock-test \
>+		asyncq-test \
>+		asyncmsgq-test \
>+		queue-test \
>+		rtpoll-test \
>+		resampler-test \
>+		smoother-test \
>+		thread-test \
>+		volume-test \
>+		mix-test \
>+		proplist-test \
>+		cpu-mix-test \
>+		cpu-remap-test \
>+		cpu-sconv-test \
>+		cpu-volume-test \
>+		mult-s16-test \
>+		lfe-filter-test
>+
>+TESTS_norun = \
>+		ipacl-test \
>+		mcalign-test \
>+		pacat-simple \
>+		parec-simple \
>+		flist-test \
>+		remix-test \
>+		rtstutter \
>+		sig2str-test \
>+		stripnul \
>+		echo-cancel-test \
>+		lo-latency-test
>+
>+# These tests need a running pulseaudio daemon
>+TESTS_daemon = \
>+		connect-stress \
>+		extended-test \
>+		interpol-test \
>+		sync-playback
>+
>+if !OS_IS_WIN32
>+TESTS_default += \
>+		sigbus-test \
>+		usergroup-test
>+endif
>+
>+if HAVE_SYS_EVENTFD_H
>+TESTS_default += \
>+		srbchannel-test
>+endif
>+
>+if !OS_IS_DARWIN
>+TESTS_default += \
>+		once-test
>+endif
>+
>+if HAVE_SIGXCPU
>+TESTS_norun += \
>+		cpulimit-test \
>+		cpulimit-test2
>+endif
>+
>+if HAVE_GLIB20
>+TESTS_default += \
>+		mainloop-test-glib
>+endif
>+
>+if HAVE_GTK30
>+TESTS_norun += \
>+		gtk-test
>+endif
>+
>+if HAVE_ALSA
>+TESTS_norun += \
>+		alsa-time-test
>+TESTS_default += \
>+		alsa-mixer-path-test
>+endif
>+
>+if HAVE_TESTS
>+TESTS_ENVIRONMENT=MAKE_CHECK=1
>+TESTS = $(TESTS_default)
>+
>+if BUILD_TESTS_DEFAULT
>+noinst_PROGRAMS = $(TESTS_default) $(TESTS_norun) $(TESTS_daemon)
>+else
>+check_PROGRAMS = $(TESTS_default) $(TESTS_norun)
>+endif
>+
>+check-daemon: $(TESTS_daemon)
>+	PATH=$(builddir):${PATH} $(top_srcdir)/src/tests/test-daemon.sh $(TESTS_daemon)
>+
>+else
>+TESTS_ENVIRONMENT=
>+TESTS =
>+noinst_PROGRAMS =
>+check_PROGRAMS =
>+
>+check-daemon:
>+	@echo "Tests are disabled!"
>+	@echo "Pass option \"--enable-tests\" to configure and install \"check\" library properly!"
>+	false
>+
>+endif
>+
>+mainloop_test_SOURCES = tests/mainloop-test.c
>+mainloop_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+mainloop_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+mainloop_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+thread_mainloop_test_SOURCES = tests/thread-mainloop-test.c
>+thread_mainloop_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+thread_mainloop_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+thread_mainloop_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+utf8_test_SOURCES = tests/utf8-test.c
>+utf8_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+utf8_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+utf8_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+format_test_SOURCES = tests/format-test.c
>+format_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+format_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+format_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+srbchannel_test_SOURCES = tests/srbchannel-test.c
>+srbchannel_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+srbchannel_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+srbchannel_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+get_binary_name_test_SOURCES = tests/get-binary-name-test.c
>+get_binary_name_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+get_binary_name_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+get_binary_name_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+ipacl_test_SOURCES = tests/ipacl-test.c
>+ipacl_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+ipacl_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+ipacl_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+hook_list_test_SOURCES = tests/hook-list-test.c
>+hook_list_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+hook_list_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+hook_list_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+memblock_test_SOURCES = tests/memblock-test.c
>+memblock_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+memblock_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+memblock_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+thread_test_SOURCES = tests/thread-test.c
>+thread_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+thread_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+thread_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+once_test_SOURCES = tests/once-test.c
>+once_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+once_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+once_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+flist_test_SOURCES = tests/flist-test.c
>+flist_test_CFLAGS = $(AM_CFLAGS)
>+flist_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+flist_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+asyncq_test_SOURCES = tests/asyncq-test.c
>+asyncq_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+asyncq_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+asyncq_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+asyncmsgq_test_SOURCES = tests/asyncmsgq-test.c
>+asyncmsgq_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+asyncmsgq_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+asyncmsgq_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+queue_test_SOURCES = tests/queue-test.c
>+queue_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+queue_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+queue_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+rtpoll_test_SOURCES = tests/rtpoll-test.c
>+rtpoll_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+rtpoll_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+rtpoll_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+mcalign_test_SOURCES = tests/mcalign-test.c
>+mcalign_test_CFLAGS = $(AM_CFLAGS)
>+mcalign_test_LDADD = $(AM_LDADD) $(WINSOCK_LIBS) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+mcalign_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+pacat_simple_SOURCES = tests/pacat-simple.c
>+pacat_simple_LDADD = $(AM_LDADD) libpulse.la libpulse-simple.la
>+pacat_simple_CFLAGS = $(AM_CFLAGS)
>+pacat_simple_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+parec_simple_SOURCES = tests/parec-simple.c
>+parec_simple_LDADD = $(AM_LDADD) libpulse.la libpulse-simple.la
>+parec_simple_CFLAGS = $(AM_CFLAGS)
>+parec_simple_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+extended_test_SOURCES = tests/extended-test.c
>+extended_test_LDADD = $(AM_LDADD) libpulse.la
>+extended_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+extended_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+strlist_test_SOURCES = tests/strlist-test.c
>+strlist_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+strlist_test_LDADD = $(AM_LDADD) $(WINSOCK_LIBS) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+strlist_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+close_test_SOURCES = tests/close-test.c
>+close_test_CFLAGS = $(AM_CFLAGS)
>+close_test_LDADD = $(AM_LDADD) $(WINSOCK_LIBS) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+close_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+volume_test_SOURCES = tests/volume-test.c
>+volume_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+volume_test_LDADD = $(AM_LDADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+volume_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+channelmap_test_SOURCES = tests/channelmap-test.c
>+channelmap_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+channelmap_test_LDADD = $(AM_LDADD) libpulse.la
>+channelmap_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+cpulimit_test_SOURCES = tests/cpulimit-test.c daemon/cpulimit.c daemon/cpulimit.h
>+cpulimit_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+cpulimit_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+cpulimit_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+cpulimit_test2_SOURCES = tests/cpulimit-test.c daemon/cpulimit.c daemon/cpulimit.h
>+cpulimit_test2_CFLAGS = $(AM_CFLAGS) -DTEST2 $(LIBCHECK_CFLAGS)
>+cpulimit_test2_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+cpulimit_test2_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+mainloop_test_glib_SOURCES = $(mainloop_test_SOURCES)
>+mainloop_test_glib_CFLAGS = $(mainloop_test_CFLAGS) $(LIBCHECK_CFLAGS) $(GLIB20_CFLAGS) -DGLIB_MAIN_LOOP
>+mainloop_test_glib_LDADD = $(mainloop_test_LDADD) $(GLIB20_LIBS) libpulse-mainloop-glib.la
>+mainloop_test_glib_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+memblockq_test_SOURCES = tests/memblockq-test.c
>+memblockq_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+memblockq_test_LDADD = $(AM_LDADD) $(WINSOCK_LIBS) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+memblockq_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+sync_playback_SOURCES = tests/sync-playback.c
>+sync_playback_LDADD = $(AM_LDADD) libpulse.la
>+sync_playback_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+sync_playback_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+interpol_test_SOURCES = tests/interpol-test.c
>+interpol_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+interpol_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+interpol_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+sig2str_test_SOURCES = tests/sig2str-test.c
>+sig2str_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+sig2str_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+sig2str_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+resampler_test_SOURCES = tests/resampler-test.c
>+resampler_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+resampler_test_CFLAGS = $(AM_CFLAGS)
>+resampler_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+mix_test_SOURCES = tests/mix-test.c
>+mix_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+mix_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+mix_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+remix_test_SOURCES = tests/remix-test.c
>+remix_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+remix_test_CFLAGS = $(AM_CFLAGS)
>+remix_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+smoother_test_SOURCES = tests/smoother-test.c
>+smoother_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+smoother_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+smoother_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+proplist_test_SOURCES = tests/proplist-test.c
>+proplist_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+proplist_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+proplist_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+cpu_mix_test_SOURCES = tests/cpu-mix-test.c tests/runtime-test-util.h
>+cpu_mix_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+cpu_mix_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+cpu_mix_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+cpu_remap_test_SOURCES = tests/cpu-remap-test.c tests/runtime-test-util.h
>+cpu_remap_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+cpu_remap_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+cpu_remap_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+cpu_sconv_test_SOURCES = tests/cpu-sconv-test.c tests/runtime-test-util.h
>+cpu_sconv_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+cpu_sconv_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+cpu_sconv_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+cpu_volume_test_SOURCES = tests/cpu-volume-test.c tests/runtime-test-util.h
>+cpu_volume_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+cpu_volume_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+cpu_volume_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+mult_s16_test_SOURCES = tests/mult-s16-test.c tests/runtime-test-util.h
>+mult_s16_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+mult_s16_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+mult_s16_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+lfe_filter_test_SOURCES = tests/lfe-filter-test.c
>+lfe_filter_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+lfe_filter_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+lfe_filter_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+rtstutter_SOURCES = tests/rtstutter.c
>+rtstutter_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+rtstutter_CFLAGS = $(AM_CFLAGS)
>+rtstutter_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+stripnul_SOURCES = tests/stripnul.c
>+stripnul_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+stripnul_CFLAGS = $(AM_CFLAGS)
>+stripnul_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+lock_autospawn_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+lock_autospawn_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+lock_autospawn_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+sigbus_test_SOURCES = tests/sigbus-test.c
>+sigbus_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+sigbus_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+sigbus_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+gtk_test_SOURCES = tests/gtk-test.c
>+gtk_test_LDADD = $(AM_LDADD) $(GTK30_LIBS) libpulse-mainloop-glib.la libpulse.la
>+gtk_test_CFLAGS = $(AM_CFLAGS) $(GTK30_CFLAGS)
>+gtk_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+alsa_time_test_SOURCES = tests/alsa-time-test.c
>+alsa_time_test_LDADD = $(AM_LDADD) $(ASOUNDLIB_LIBS)
>+alsa_time_test_CFLAGS = $(AM_CFLAGS) $(ASOUNDLIB_CFLAGS)
>+alsa_time_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+alsa_mixer_path_test_SOURCES = tests/alsa-mixer-path-test.c
>+alsa_mixer_path_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS) $(ASOUNDLIB_CFLAGS)
>+alsa_mixer_path_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la libalsa-util.la
>+alsa_mixer_path_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+usergroup_test_SOURCES = tests/usergroup-test.c
>+usergroup_test_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+usergroup_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+usergroup_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+connect_stress_SOURCES = tests/connect-stress.c
>+connect_stress_LDADD = $(AM_LDADD) libpulse.la
>+connect_stress_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+connect_stress_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+echo_cancel_test_SOURCES = $(module_echo_cancel_la_SOURCES)
>+nodist_echo_cancel_test_SOURCES = $(nodist_module_echo_cancel_la_SOURCES)
>+echo_cancel_test_LDADD = $(module_echo_cancel_la_LIBADD)
>+echo_cancel_test_CFLAGS = $(module_echo_cancel_la_CFLAGS) -DECHO_CANCEL_TEST=1
>+if HAVE_WEBRTC
>+echo_cancel_test_CXXFLAGS = $(module_echo_cancel_la_CXXFLAGS) -DECHO_CANCEL_TEST=1
>+endif
>+echo_cancel_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+liblo_test_util_la_SOURCES = tests/lo-test-util.h tests/lo-test-util.c
>+liblo_test_util_la_LIBADD = libpulsecore-@PA_MAJORMINOR@.la
>+liblo_test_util_la_LDFLAGS = -avoid-version
>+noinst_LTLIBRARIES += liblo-test-util.la
>+
>+lo_latency_test_SOURCES = tests/lo-latency-test.c
>+lo_latency_test_LDADD = $(AM_LDADD) libpulse.la liblo-test-util.la
>+lo_latency_test_CFLAGS = $(AM_CFLAGS) $(LIBCHECK_CFLAGS)
>+lo_latency_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS) $(LIBCHECK_LIBS)
>+
>+###################################
>+#         Common library          #
>+###################################
>+
>+commonlibdir = $(pkglibdir)
>+commonlib_LTLIBRARIES = \
>+		libpulsecommon-@PA_MAJORMINOR@.la
>+
>+# We duplicate files from pulse/ in this to allow as-needed linking. If we did
>+# not do this, in situations where code in libpulsecommon uses code in
>+# libpulse, we would then need to link libpulsecommon to libpulse (in addition
>+# to the existing libpulse being linked to libpulsecommon). Duplicating the
>+# code allows us to prevent this circular linking.
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES = \
>+		pulse/client-conf.c pulse/client-conf.h \
>+		pulse/fork-detect.c pulse/fork-detect.h \
>+		pulse/format.c pulse/format.h \
>+		pulse/xmalloc.c pulse/xmalloc.h \
>+		pulse/proplist.c pulse/proplist.h \
>+		pulse/utf8.c pulse/utf8.h \
>+		pulse/channelmap.c pulse/channelmap.h \
>+		pulse/sample.c pulse/sample.h \
>+		pulse/util.c pulse/util.h \
>+		pulse/timeval.c pulse/timeval.h \
>+		pulse/rtclock.c pulse/rtclock.h \
>+		pulse/volume.c pulse/volume.h \
>+		pulsecore/atomic.h \
>+		pulsecore/authkey.c pulsecore/authkey.h \
>+		pulsecore/conf-parser.c pulsecore/conf-parser.h \
>+		pulsecore/core-error.c pulsecore/core-error.h \
>+		pulsecore/core-format.c pulsecore/core-format.h \
>+		pulsecore/core-rtclock.c pulsecore/core-rtclock.h \
>+		pulsecore/core-util.c pulsecore/core-util.h \
>+		pulsecore/creds.h \
>+		pulsecore/dynarray.c pulsecore/dynarray.h \
>+		pulsecore/endianmacros.h \
>+		pulsecore/fdsem.c pulsecore/fdsem.h \
>+		pulsecore/flist.c pulsecore/flist.h \
>+		pulsecore/g711.c pulsecore/g711.h \
>+		pulsecore/hashmap.c pulsecore/hashmap.h \
>+		pulsecore/i18n.c pulsecore/i18n.h \
>+		pulsecore/idxset.c pulsecore/idxset.h \
>+		pulsecore/arpa-inet.c pulsecore/arpa-inet.h \
>+		pulsecore/iochannel.c pulsecore/iochannel.h \
>+		pulsecore/ioline.c pulsecore/ioline.h \
>+		pulsecore/ipacl.c pulsecore/ipacl.h \
>+		pulsecore/llist.h \
>+		pulsecore/lock-autospawn.c pulsecore/lock-autospawn.h \
>+		pulsecore/log.c pulsecore/log.h \
>+		pulsecore/ratelimit.c pulsecore/ratelimit.h \
>+		pulsecore/macro.h \
>+		pulsecore/mcalign.c pulsecore/mcalign.h \
>+		pulsecore/memblock.c pulsecore/memblock.h \
>+		pulsecore/memblockq.c pulsecore/memblockq.h \
>+		pulsecore/memchunk.c pulsecore/memchunk.h \
>+		pulsecore/native-common.h \
>+		pulsecore/once.c pulsecore/once.h \
>+		pulsecore/packet.c pulsecore/packet.h \
>+		pulsecore/parseaddr.c pulsecore/parseaddr.h \
>+		pulsecore/pdispatch.c pulsecore/pdispatch.h \
>+		pulsecore/pid.c pulsecore/pid.h \
>+		pulsecore/pipe.c pulsecore/pipe.h \
>+		pulsecore/memtrap.c pulsecore/memtrap.h \
>+		pulsecore/aupdate.c pulsecore/aupdate.h \
>+		pulsecore/proplist-util.c pulsecore/proplist-util.h \
>+		pulsecore/pstream-util.c pulsecore/pstream-util.h \
>+		pulsecore/pstream.c pulsecore/pstream.h \
>+		pulsecore/queue.c pulsecore/queue.h \
>+		pulsecore/random.c pulsecore/random.h \
>+		pulsecore/refcnt.h \
>+		pulsecore/srbchannel.c pulsecore/srbchannel.h \
>+		pulsecore/sample-util.c pulsecore/sample-util.h \
>+		pulsecore/shm.c pulsecore/shm.h \
>+		pulsecore/bitset.c pulsecore/bitset.h \
>+		pulsecore/socket-client.c pulsecore/socket-client.h \
>+		pulsecore/socket-server.c pulsecore/socket-server.h \
>+		pulsecore/socket-util.c pulsecore/socket-util.h \
>+		pulsecore/strbuf.c pulsecore/strbuf.h \
>+		pulsecore/strlist.c pulsecore/strlist.h \
>+		pulsecore/svolume_c.c pulsecore/svolume_arm.c \
>+		pulsecore/svolume_mmx.c pulsecore/svolume_sse.c \
>+		pulsecore/tagstruct.c pulsecore/tagstruct.h \
>+		pulsecore/time-smoother.c pulsecore/time-smoother.h \
>+		pulsecore/tokenizer.c pulsecore/tokenizer.h \
>+		pulsecore/usergroup.c pulsecore/usergroup.h \
>+		pulsecore/sndfile-util.c pulsecore/sndfile-util.h \
>+		pulsecore/socket.h
>+
>+if OS_IS_WIN32
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulsecore/poll-win32.c pulsecore/poll.h \
>+		pulsecore/winerrno.h
>+else
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += pulsecore/poll-posix.c pulsecore/poll.h
>+endif
>+
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS = $(AM_CFLAGS) $(LIBJSON_CFLAGS) $(LIBSNDFILE_CFLAGS)
>+libpulsecommon_@PA_MAJORMINOR@_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libpulsecommon_@PA_MAJORMINOR@_la_LIBADD = $(AM_LIBADD) $(LIBJSON_LIBS)  $(LIBWRAP_LIBS) $(WINSOCK_LIBS) $(LTLIBICONV) $(LIBSNDFILE_LIBS)
>+
>+if HAVE_X11
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulse/client-conf-x11.c pulse/client-conf-x11.h \
>+		pulsecore/x11prop.c pulsecore/x11prop.h
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += $(X11_CFLAGS)
>+libpulsecommon_@PA_MAJORMINOR@_la_LDFLAGS += $(X11_LIBS)
>+endif
>+
>+if HAVE_SYSTEMD_DAEMON
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += $(SYSTEMD_FLAGS) $(SYSTEMDDAEMON_FLAGS)
>+libpulsecommon_@PA_MAJORMINOR@_la_LDFLAGS += $(SYSTEMD_LIBS) $(SYSTEMDDAEMON_LIBS)
>+endif
>+if HAVE_SYSTEMD_JOURNAL
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += $(SYSTEMD_FLAGS) $(SYSTEMDJOURNAL_FLAGS)
>+libpulsecommon_@PA_MAJORMINOR@_la_LDFLAGS += $(SYSTEMD_LIBS) $(SYSTEMDJOURNAL_LIBS)
>+endif
>+
>+# proplist-util.h uses these header files, but not the library itself!
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += $(GLIB20_CFLAGS) $(GTK30_CFLAGS)
>+
>+## Please note that libpulsecommon implicitly also depends on<
>+## libpulse! i.e. we have a cyclic dependancy here. Which is intended
>+## since libpulse only includes stable, official APIs, while
>+## libpulsecommon only includes unofficial APIs.
>+
>+if OS_IS_WIN32
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulsecore/mutex-win32.c pulsecore/mutex.h \
>+		pulsecore/thread-win32.c pulsecore/thread.h \
>+		pulsecore/semaphore-win32.c pulsecore/semaphore.h
>+else !OS_IS_WIN32
>+if OS_IS_DARWIN
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulsecore/mutex-posix.c pulsecore/mutex.h \
>+		pulsecore/thread-posix.c pulsecore/thread.h \
>+		pulsecore/semaphore-osx.c pulsecore/semaphore.h
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += "-I/Developer/Headers/FlatCarbon/"
>+#libpulsecommon_@PA_MAJORMINOR@_la_LDFLAGS += "-framework CoreServices"
>+else !OS_IS_DARWIN
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulsecore/mutex-posix.c pulsecore/mutex.h \
>+		pulsecore/thread-posix.c pulsecore/thread.h \
>+		pulsecore/semaphore-posix.c pulsecore/semaphore.h
>+endif !OS_IS_DARWIN
>+endif !OS_IS_WIN32
>+
>+if HAVE_LIBASYNCNS
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += $(LIBASYNCNS_CFLAGS)
>+libpulsecommon_@PA_MAJORMINOR@_la_LIBADD += $(LIBASYNCNS_LIBS)
>+endif
>+
>+if OS_IS_WIN32
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += pulsecore/dllmain.c
>+endif
>+
>+if HAVE_DBUS
>+libpulsecommon_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulsecore/dbus-util.c pulsecore/dbus-util.h \
>+		pulsecore/rtkit.c pulsecore/rtkit.h
>+libpulsecommon_@PA_MAJORMINOR@_la_CFLAGS += $(DBUS_CFLAGS)
>+libpulsecommon_@PA_MAJORMINOR@_la_LIBADD += $(DBUS_LIBS)
>+endif
>+
>+###################################
>+#         Client library          #
>+###################################
>+
>+pulseinclude_HEADERS = \
>+		pulse/cdecl.h \
>+		pulse/channelmap.h \
>+		pulse/context.h \
>+		pulse/def.h \
>+		pulse/direction.h \
>+		pulse/error.h \
>+		pulse/ext-device-manager.h \
>+		pulse/ext-device-restore.h \
>+		pulse/ext-stream-restore.h \
>+		pulse/format.h \
>+		pulse/gccmacro.h \
>+		pulse/introspect.h \
>+		pulse/mainloop-api.h \
>+		pulse/mainloop-signal.h \
>+		pulse/mainloop.h \
>+		pulse/operation.h \
>+		pulse/proplist.h \
>+		pulse/pulseaudio.h \
>+		pulse/rtclock.h \
>+		pulse/sample.h \
>+		pulse/scache.h \
>+		pulse/simple.h \
>+		pulse/stream.h \
>+		pulse/subscribe.h \
>+		pulse/thread-mainloop.h \
>+		pulse/timeval.h \
>+		pulse/utf8.h \
>+		pulse/util.h \
>+		pulse/version.h \
>+		pulse/volume.h \
>+		pulse/xmalloc.h
>+
>+lib_LTLIBRARIES = \
>+		libpulse.la \
>+		libpulse-simple.la
>+
>+if HAVE_GLIB20
>+pulseinclude_HEADERS += \
>+		pulse/glib-mainloop.h
>+
>+lib_LTLIBRARIES += \
>+		libpulse-mainloop-glib.la
>+endif
>+
>+# Public interface
>+libpulse_la_SOURCES = \
>+		pulse/cdecl.h \
>+		pulse/channelmap.c pulse/channelmap.h \
>+		pulse/context.c pulse/context.h \
>+		pulse/def.h \
>+		pulse/direction.c pulse/direction.h \
>+		pulse/error.c pulse/error.h \
>+		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/format.c pulse/format.h \
>+		pulse/gccmacro.h \
>+		pulse/internal.h \
>+		pulse/introspect.c pulse/introspect.h \
>+		pulse/mainloop-api.c pulse/mainloop-api.h \
>+		pulse/mainloop-signal.c pulse/mainloop-signal.h \
>+		pulse/mainloop.c pulse/mainloop.h \
>+		pulse/operation.c pulse/operation.h \
>+		pulse/proplist.c pulse/proplist.h \
>+		pulse/pulseaudio.h \
>+		pulse/rtclock.c pulse/rtclock.h \
>+		pulse/sample.c pulse/sample.h \
>+		pulse/scache.c pulse/scache.h \
>+		pulse/stream.c pulse/stream.h \
>+		pulse/subscribe.c pulse/subscribe.h \
>+		pulse/thread-mainloop.c pulse/thread-mainloop.h \
>+		pulse/timeval.c pulse/timeval.h \
>+		pulse/utf8.c pulse/utf8.h \
>+		pulse/util.c pulse/util.h \
>+		pulse/volume.c pulse/volume.h \
>+		pulse/xmalloc.c pulse/xmalloc.h
>+
>+libpulse_la_CFLAGS = $(AM_CFLAGS) $(LIBJSON_CFLAGS)
>+libpulse_la_LIBADD = $(AM_LIBADD) $(WINSOCK_LIBS) $(LTLIBICONV) $(LIBJSON_LIBS) libpulsecommon-@PA_MAJORMINOR@.la
>+libpulse_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) $(VERSIONING_LDFLAGS) -version-info $(LIBPULSE_VERSION_INFO)
>+
>+if HAVE_DBUS
>+libpulse_la_CFLAGS += $(DBUS_CFLAGS)
>+libpulse_la_LIBADD += $(DBUS_LIBS)
>+endif
>+
>+libpulse_simple_la_SOURCES = pulse/simple.c pulse/simple.h
>+libpulse_simple_la_CFLAGS = $(AM_CFLAGS)
>+libpulse_simple_la_LIBADD = $(AM_LIBADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+libpulse_simple_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) $(VERSIONING_LDFLAGS) -version-info $(LIBPULSE_SIMPLE_VERSION_INFO)
>+
>+libpulse_mainloop_glib_la_SOURCES = pulse/glib-mainloop.h pulse/glib-mainloop.c
>+libpulse_mainloop_glib_la_CFLAGS = $(AM_CFLAGS) $(GLIB20_CFLAGS)
>+libpulse_mainloop_glib_la_LIBADD = $(AM_LIBADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la $(GLIB20_LIBS)
>+libpulse_mainloop_glib_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) $(VERSIONING_LDFLAGS) -version-info $(LIBPULSE_MAINLOOP_GLIB_VERSION_INFO)
>+
>+###################################
>+#         OSS emulation           #
>+###################################
>+
>+if HAVE_OSS_WRAPPER
>+padsplibdir = $(pkglibdir)
>+padsplib_LTLIBRARIES = libpulsedsp.la
>+bin_SCRIPTS += padsp
>+
>+edit = @SED@ \
>+       -e "s|@pkglibdir[@]|$(pkglibdir)|g"
>+
>+padsp: utils/padsp.in
>+	$(edit) $< > $@
>+
>+CLEANFILES += padsp
>+
>+endif
>+
>+libpulsedsp_la_SOURCES = utils/padsp.c
>+libpulsedsp_la_CFLAGS = $(AM_CFLAGS)
>+libpulsedsp_la_LIBADD = $(AM_LIBADD) libpulse.la libpulsecommon-@PA_MAJORMINOR@.la
>+libpulsedsp_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version -disable-static
>+
>+###################################
>+#      Daemon core library        #
>+###################################
>+
>+pkglib_LTLIBRARIES = libpulsecore-@PA_MAJORMINOR@.la
>+
>+# Pure core stuff
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES = \
>+		pulsecore/filter/lfe-filter.c pulsecore/filter/lfe-filter.h \
>+		pulsecore/filter/biquad.c pulsecore/filter/biquad.h \
>+		pulsecore/filter/crossover.c pulsecore/filter/crossover.h \
>+		pulsecore/asyncmsgq.c pulsecore/asyncmsgq.h \
>+		pulsecore/asyncq.c pulsecore/asyncq.h \
>+		pulsecore/auth-cookie.c pulsecore/auth-cookie.h \
>+		pulsecore/cli-command.c pulsecore/cli-command.h \
>+		pulsecore/cli-text.c pulsecore/cli-text.h \
>+		pulsecore/client.c pulsecore/client.h \
>+		pulsecore/typedefs.h \
>+		pulsecore/card.c pulsecore/card.h \
>+		pulsecore/core-scache.c pulsecore/core-scache.h \
>+		pulsecore/core-subscribe.c pulsecore/core-subscribe.h \
>+		pulsecore/core.c pulsecore/core.h \
>+		pulsecore/hook-list.c pulsecore/hook-list.h \
>+		pulsecore/ltdl-helper.c pulsecore/ltdl-helper.h \
>+		pulsecore/modargs.c pulsecore/modargs.h \
>+		pulsecore/modinfo.c pulsecore/modinfo.h \
>+		pulsecore/module.c pulsecore/module.h \
>+		pulsecore/msgobject.c pulsecore/msgobject.h \
>+		pulsecore/namereg.c pulsecore/namereg.h \
>+		pulsecore/object.c pulsecore/object.h \
>+		pulsecore/play-memblockq.c pulsecore/play-memblockq.h \
>+		pulsecore/play-memchunk.c pulsecore/play-memchunk.h \
>+		pulsecore/remap.c pulsecore/remap.h \
>+		pulsecore/remap_mmx.c pulsecore/remap_sse.c \
>+		pulsecore/resampler.c pulsecore/resampler.h \
>+		pulsecore/resampler/ffmpeg.c pulsecore/resampler/peaks.c \
>+		pulsecore/resampler/trivial.c \
>+		pulsecore/rtpoll.c pulsecore/rtpoll.h \
>+		pulsecore/stream-util.c pulsecore/stream-util.h \
>+		pulsecore/mix.c pulsecore/mix.h \
>+		pulsecore/cpu.c pulsecore/cpu.h \
>+		pulsecore/cpu-arm.c pulsecore/cpu-arm.h \
>+		pulsecore/cpu-x86.c pulsecore/cpu-x86.h \
>+		pulsecore/cpu-orc.c pulsecore/cpu-orc.h \
>+		pulsecore/sconv-s16be.c pulsecore/sconv-s16be.h \
>+		pulsecore/sconv-s16le.c pulsecore/sconv-s16le.h \
>+		pulsecore/sconv_sse.c \
>+		pulsecore/sconv.c pulsecore/sconv.h \
>+		pulsecore/shared.c pulsecore/shared.h \
>+		pulsecore/sink-input.c pulsecore/sink-input.h \
>+		pulsecore/sink.c pulsecore/sink.h \
>+		pulsecore/device-port.c pulsecore/device-port.h \
>+		pulsecore/sioman.c pulsecore/sioman.h \
>+		pulsecore/sound-file-stream.c pulsecore/sound-file-stream.h \
>+		pulsecore/sound-file.c pulsecore/sound-file.h \
>+		pulsecore/source-output.c pulsecore/source-output.h \
>+		pulsecore/source.c pulsecore/source.h \
>+		pulsecore/start-child.c pulsecore/start-child.h \
>+		pulsecore/thread-mq.c pulsecore/thread-mq.h \
>+		pulsecore/database.h
>+
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS) $(LIBSNDFILE_CFLAGS) $(WINSOCK_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD = $(AM_LIBADD) $(LIBLTDL) $(LIBSNDFILE_LIBS) $(WINSOCK_LIBS) $(LTLIBICONV) libpulsecommon-@PA_MAJORMINOR@.la libpulse.la libpulsecore-foreign.la
>+
>+if HAVE_NEON
>+noinst_LTLIBRARIES += libpulsecore_sconv_neon.la libpulsecore_mix_neon.la libpulsecore_remap_neon.la
>+libpulsecore_sconv_neon_la_SOURCES = pulsecore/sconv_neon.c
>+libpulsecore_sconv_neon_la_CFLAGS = $(AM_CFLAGS) $(NEON_CFLAGS)
>+libpulsecore_mix_neon_la_SOURCES = pulsecore/mix_neon.c
>+libpulsecore_mix_neon_la_CFLAGS = $(AM_CFLAGS) $(NEON_CFLAGS)
>+libpulsecore_remap_neon_la_SOURCES = pulsecore/remap_neon.c
>+libpulsecore_remap_neon_la_CFLAGS = $(AM_CFLAGS) $(NEON_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += libpulsecore_sconv_neon.la libpulsecore_mix_neon.la libpulsecore_remap_neon.la
>+endif
>+
>+ORC_SOURCE += pulsecore/svolume
>+if HAVE_ORC
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/svolume_orc.c
>+nodist_libpulsecore_@PA_MAJORMINOR@_la_SOURCES = pulsecore/svolume-orc-gen.c pulsecore/svolume-orc-gen.h
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(ORC_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(ORC_LIBS)
>+endif
>+
>+if HAVE_X11
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/x11wrap.c pulsecore/x11wrap.h
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(X11_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LDFLAGS += $(X11_LIBS)
>+endif
>+
>+if HAVE_DBUS
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += \
>+		pulsecore/dbus-shared.c pulsecore/dbus-shared.h \
>+		pulsecore/protocol-dbus.c pulsecore/protocol-dbus.h
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(DBUS_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(DBUS_LIBS)
>+endif
>+
>+if HAVE_GDBM
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/database-gdbm.c
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(GDBM_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(GDBM_LIBS)
>+endif
>+
>+if HAVE_TDB
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/database-tdb.c
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(TDB_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(TDB_LIBS)
>+endif
>+
>+if HAVE_SIMPLEDB
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/database-simple.c
>+endif
>+
>+if HAVE_SPEEX
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/resampler/speex.c
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(LIBSPEEX_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(LIBSPEEX_LIBS)
>+endif
>+
>+if HAVE_SOXR
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/resampler/soxr.c
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(LIBSOXR_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(LIBSOXR_LIBS)
>+endif
>+
>+if HAVE_LIBSAMPLERATE
>+libpulsecore_@PA_MAJORMINOR@_la_SOURCES += pulsecore/resampler/libsamplerate.c
>+libpulsecore_@PA_MAJORMINOR@_la_CFLAGS += $(LIBSAMPLERATE_CFLAGS)
>+libpulsecore_@PA_MAJORMINOR@_la_LIBADD += $(LIBSAMPLERATE_LIBS)
>+endif
>+
>+# We split the foreign code off to not be annoyed by warnings we don't care about
>+noinst_LTLIBRARIES += libpulsecore-foreign.la
>+
>+libpulsecore_foreign_la_SOURCES = \
>+		pulsecore/ffmpeg/resample2.c pulsecore/ffmpeg/avcodec.h pulsecore/ffmpeg/dsputil.h
>+
>+libpulsecore_foreign_la_CFLAGS = $(AM_CFLAGS) $(FOREIGN_CFLAGS)
>+
>+###################################
>+#   Plug-in support libraries     #
>+###################################
>+
>+### Warning! Due to an obscure bug in libtool/automake it is required
>+### that the libraries in modlibexec_LTLIBRARIES are specified in-order,
>+### i.e. libraries near the end of the list depend on libraries near
>+### the head, and not the other way!
>+
>+modlibexec_LTLIBRARIES = \
>+		libcli.la \
>+		libprotocol-cli.la \
>+		libprotocol-simple.la \
>+		libprotocol-http.la \
>+		libprotocol-native.la
>+
>+if HAVE_WEBRTC
>+modlibexec_LTLIBRARIES += libwebrtc-util.la
>+endif
>+
>+if HAVE_ESOUND
>+modlibexec_LTLIBRARIES += \
>+		libprotocol-esound.la
>+endif
>+
>+# We need to emulate sendmsg/recvmsg to support this on Win32
>+if !OS_IS_WIN32
>+modlibexec_LTLIBRARIES += \
>+		librtp.la
>+endif
>+
>+if HAVE_AVAHI
>+modlibexec_LTLIBRARIES += \
>+		libavahi-wrap.la
>+endif
>+
>+libprotocol_simple_la_SOURCES = pulsecore/protocol-simple.c pulsecore/protocol-simple.h
>+libprotocol_simple_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libprotocol_simple_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+libcli_la_SOURCES = pulsecore/cli.c pulsecore/cli.h
>+libcli_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libcli_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+libprotocol_cli_la_SOURCES = pulsecore/protocol-cli.c pulsecore/protocol-cli.h
>+libprotocol_cli_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libprotocol_cli_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la libcli.la
>+
>+libprotocol_http_la_SOURCES = pulsecore/protocol-http.c pulsecore/protocol-http.h pulsecore/mime-type.c pulsecore/mime-type.h
>+libprotocol_http_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libprotocol_http_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+libprotocol_native_la_SOURCES = pulsecore/protocol-native.c pulsecore/protocol-native.h pulsecore/native-common.h
>+libprotocol_native_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS)
>+libprotocol_native_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libprotocol_native_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+if HAVE_DBUS
>+libprotocol_native_la_CFLAGS += $(DBUS_CFLAGS)
>+libprotocol_native_la_LIBADD += $(DBUS_LIBS)
>+endif
>+
>+if HAVE_ESOUND
>+libprotocol_esound_la_SOURCES = pulsecore/protocol-esound.c pulsecore/protocol-esound.h pulsecore/esound.h
>+libprotocol_esound_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libprotocol_esound_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+endif
>+
>+librtp_la_SOURCES = \
>+		modules/rtp/rtp.c modules/rtp/rtp.h \
>+		modules/rtp/sdp.c modules/rtp/sdp.h \
>+		modules/rtp/sap.c modules/rtp/sap.h \
>+		modules/rtp/rtsp_client.c modules/rtp/rtsp_client.h \
>+		modules/rtp/headerlist.c modules/rtp/headerlist.h
>+librtp_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+librtp_la_LIBADD = $(AM_LIBADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+libraop_la_SOURCES = \
>+        modules/raop/raop_client.c modules/raop/raop_client.h \
>+        modules/raop/base64.c modules/raop/base64.h
>+libraop_la_CFLAGS = $(AM_CFLAGS) $(OPENSSL_CFLAGS) -I$(top_srcdir)/src/modules/rtp
>+libraop_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libraop_la_LIBADD = $(AM_LIBADD) $(OPENSSL_LIBS) libpulsecore-@PA_MAJORMINOR@.la librtp.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+# Avahi
>+libavahi_wrap_la_SOURCES = pulsecore/avahi-wrap.c pulsecore/avahi-wrap.h
>+libavahi_wrap_la_LDFLAGS = $(AM_LDFLAGS) $(AM_LIBLDFLAGS) -avoid-version
>+libavahi_wrap_la_CFLAGS = $(AM_CFLAGS) $(AVAHI_CFLAGS)
>+libavahi_wrap_la_LIBADD = $(AM_LIBADD) $(AVAHI_CFLAGS) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la
>+
>+###################################
>+#        Plug-in libraries        #
>+###################################
>+
>+if HAVE_DBUS
>+# Serveral module (e.g. libalsa-util.la)
>+modlibexec_LTLIBRARIES += \
>+		module-console-kit.la
>+endif
>+
>+modlibexec_LTLIBRARIES += \
>+		module-cli.la \
>+		module-cli-protocol-tcp.la \
>+		module-simple-protocol-tcp.la \
>+		module-null-sink.la \
>+		module-null-source.la \
>+		module-sine-source.la \
>+		module-detect.la \
>+		module-volume-restore.la \
>+		module-device-manager.la \
>+		module-device-restore.la \
>+		module-stream-restore.la \
>+		module-card-restore.la \
>+		module-default-device-restore.la \
>+		module-always-sink.la \
>+		module-rescue-streams.la \
>+		module-intended-roles.la \
>+		module-suspend-on-idle.la \
>+		module-echo-cancel.la \
>+		module-http-protocol-tcp.la \
>+		module-sine.la \
>+		module-native-protocol-tcp.la \
>+		module-native-protocol-fd.la \
>+		module-combine.la \
>+		module-combine-sink.la \
>+		module-remap-sink.la \
>+		module-remap-source.la \
>+		module-ladspa-sink.la \
>+		module-tunnel-sink-new.la \
>+		module-tunnel-source-new.la \
>+		module-tunnel-sink.la \
>+		module-tunnel-source.la \
>+		module-position-event-sounds.la \
>+		module-augment-properties.la \
>+		module-role-cork.la \
>+		module-loopback.la \
>+		module-virtual-sink.la \
>+		module-virtual-source.la \
>+		module-virtual-surround-sink.la \
>+		module-switch-on-connect.la \
>+		module-switch-on-port-available.la \
>+		module-filter-apply.la \
>+		module-filter-heuristics.la \
>+		module-role-ducking.la
>+
>+if HAVE_ESOUND
>+modlibexec_LTLIBRARIES += \
>+		module-esound-protocol-tcp.la \
>+		module-esound-sink.la
>+endif
>+
>+# See comment at librtp.la above
>+if !OS_IS_WIN32
>+modlibexec_LTLIBRARIES += \
>+		module-rtp-send.la \
>+		module-rtp-recv.la
>+endif
>+
>+if HAVE_AF_UNIX
>+modlibexec_LTLIBRARIES += \
>+		module-cli-protocol-unix.la \
>+		module-simple-protocol-unix.la \
>+		module-http-protocol-unix.la \
>+		module-native-protocol-unix.la
>+if HAVE_ESOUND
>+modlibexec_LTLIBRARIES += \
>+		module-esound-protocol-unix.la
>+endif
>+endif
>+
>+if HAVE_MKFIFO
>+modlibexec_LTLIBRARIES += \
>+		module-pipe-sink.la \
>+		module-pipe-source.la
>+endif
>+
>+if !OS_IS_WIN32
>+if HAVE_ESOUND
>+modlibexec_LTLIBRARIES += \
>+		module-esound-compat-spawnfd.la \
>+		module-esound-compat-spawnpid.la
>+endif
>+endif
>+
>+if HAVE_REGEX
>+modlibexec_LTLIBRARIES += \
>+		module-match.la
>+endif
>+
>+if HAVE_X11
>+modlibexec_LTLIBRARIES += \
>+		module-x11-bell.la \
>+		module-x11-publish.la \
>+		module-x11-xsmp.la \
>+		module-x11-cork-request.la
>+endif
>+
>+if HAVE_OSS_OUTPUT
>+modlibexec_LTLIBRARIES += \
>+		liboss-util.la \
>+		module-oss.la
>+endif
>+
>+if HAVE_COREAUDIO
>+modlibexec_LTLIBRARIES += \
>+		module-coreaudio-detect.la \
>+		module-coreaudio-device.la
>+endif
>+
>+pulselibexec_PROGRAMS =
>+
>+if HAVE_ALSA
>+modlibexec_LTLIBRARIES += \
>+		libalsa-util.la \
>+		module-alsa-sink.la \
>+		module-alsa-source.la \
>+		module-alsa-card.la
>+
>+dist_alsaprofilesets_DATA = \
>+		modules/alsa/mixer/profile-sets/default.conf \
>+		modules/alsa/mixer/profile-sets/force-speaker.conf \
>+		modules/alsa/mixer/profile-sets/force-speaker-and-int-mic.conf \
>+		modules/alsa/mixer/profile-sets/maudio-fasttrack-pro.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-audio4dj.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-audio8dj.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-traktor-audio2.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-traktor-audio6.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-traktor-audio10.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-traktorkontrol-s4.conf \
>+		modules/alsa/mixer/profile-sets/native-instruments-korecontroller.conf \
>+		modules/alsa/mixer/profile-sets/kinect-audio.conf \
>+		modules/alsa/mixer/profile-sets/sb-omni-surround-5.1.conf
>+
>+if HAVE_UDEV
>+dist_udevrules_DATA = \
>+		modules/alsa/mixer/profile-sets/90-pulseaudio.rules
>+endif
>+
>+dist_alsapaths_DATA = \
>+		modules/alsa/mixer/paths/analog-input-aux.conf \
>+		modules/alsa/mixer/paths/analog-input.conf \
>+		modules/alsa/mixer/paths/analog-input.conf.common \
>+		modules/alsa/mixer/paths/analog-input-fm.conf \
>+		modules/alsa/mixer/paths/analog-input-linein.conf \
>+		modules/alsa/mixer/paths/analog-input-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-dock-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-front-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-headphone-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-headset-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-internal-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-internal-mic-always.conf \
>+		modules/alsa/mixer/paths/analog-input-rear-mic.conf \
>+		modules/alsa/mixer/paths/analog-input-mic.conf.common \
>+		modules/alsa/mixer/paths/analog-input-mic-line.conf \
>+		modules/alsa/mixer/paths/analog-input-tvtuner.conf \
>+		modules/alsa/mixer/paths/analog-input-video.conf \
>+		modules/alsa/mixer/paths/analog-output.conf \
>+		modules/alsa/mixer/paths/analog-output-speaker.conf \
>+		modules/alsa/mixer/paths/analog-output-speaker-always.conf \
>+		modules/alsa/mixer/paths/analog-output.conf.common \
>+		modules/alsa/mixer/paths/analog-output-headphones.conf \
>+		modules/alsa/mixer/paths/analog-output-headphones-2.conf \
>+		modules/alsa/mixer/paths/analog-output-lineout.conf \
>+		modules/alsa/mixer/paths/analog-output-mono.conf \
>+		modules/alsa/mixer/paths/iec958-stereo-output.conf \
>+		modules/alsa/mixer/paths/hdmi-output-0.conf \
>+		modules/alsa/mixer/paths/hdmi-output-1.conf \
>+		modules/alsa/mixer/paths/hdmi-output-2.conf \
>+		modules/alsa/mixer/paths/hdmi-output-3.conf \
>+		modules/alsa/mixer/paths/hdmi-output-4.conf \
>+		modules/alsa/mixer/paths/hdmi-output-5.conf \
>+		modules/alsa/mixer/paths/hdmi-output-6.conf \
>+		modules/alsa/mixer/paths/hdmi-output-7.conf
>+
>+endif
>+
>+if HAVE_SOLARIS
>+modlibexec_LTLIBRARIES += \
>+		module-solaris.la
>+endif
>+
>+if HAVE_AVAHI
>+modlibexec_LTLIBRARIES += \
>+		module-zeroconf-publish.la \
>+		module-zeroconf-discover.la
>+endif
>+
>+if HAVE_BONJOUR
>+modlibexec_LTLIBRARIES += \
>+		module-bonjour-publish.la
>+endif
>+
>+if HAVE_LIRC
>+modlibexec_LTLIBRARIES += \
>+		module-lirc.la
>+endif
>+
>+if HAVE_XEN
>+modlibexec_LTLIBRARIES += \
>+		module-xenpv-sink.la
>+endif
>+
>+
>+if HAVE_EVDEV
>+modlibexec_LTLIBRARIES += \
>+		module-mmkbd-evdev.la
>+endif
>+
>+if HAVE_JACK
>+modlibexec_LTLIBRARIES += \
>+		module-jack-sink.la \
>+		module-jack-source.la
>+
>+if HAVE_DBUS
>+modlibexec_LTLIBRARIES += \
>+		module-jackdbus-detect.la
>+endif
>+
>+endif
>+
>+if HAVE_GCONF
>+modlibexec_LTLIBRARIES += \
>+		module-gconf.la
>+
>+pulselibexec_PROGRAMS += \
>+		gconf-helper
>+endif
>+
>+if HAVE_WAVEOUT
>+modlibexec_LTLIBRARIES += \
>+		module-waveout.la
>+endif
>+
>+if HAVE_HAL_COMPAT
>+modlibexec_LTLIBRARIES += \
>+		module-hal-detect.la
>+endif
>+
>+if HAVE_UDEV
>+modlibexec_LTLIBRARIES += \
>+		module-udev-detect.la
>+endif
>+
>+if HAVE_SYSTEMD_LOGIN
>+modlibexec_LTLIBRARIES += \
>+		module-systemd-login.la
>+endif
>+
>+if HAVE_DBUS
>+modlibexec_LTLIBRARIES += \
>+		module-rygel-media-server.la \
>+		module-dbus-protocol.la
>+endif
>+
>+if HAVE_BLUEZ
>+modlibexec_LTLIBRARIES += \
>+		module-bluetooth-discover.la \
>+		module-bluetooth-policy.la
>+endif
>+
>+if HAVE_BLUEZ_4
>+modlibexec_LTLIBRARIES += \
>+		libbluez4-util.la \
>+		module-bluez4-discover.la \
>+		module-bluez4-device.la
>+endif
>+
>+if HAVE_BLUEZ_5
>+modlibexec_LTLIBRARIES += \
>+		libbluez5-util.la \
>+		module-bluez5-discover.la \
>+		module-bluez5-device.la
>+endif
>+
>+# RAOP depends on RTP, and we don't support RTP on Windows, see comment at
>+# librtp.la above.
>+if !OS_IS_WIN32
>+if HAVE_OPENSSL
>+modlibexec_LTLIBRARIES += \
>+		libraop.la \
>+		module-raop-sink.la
>+if HAVE_AVAHI
>+modlibexec_LTLIBRARIES += \
>+		module-raop-discover.la
>+endif
>+endif
>+endif
>+
>+if HAVE_DBUS
>+if HAVE_FFTW
>+modlibexec_LTLIBRARIES += \
>+		module-equalizer-sink.la
>+bin_SCRIPTS += utils/qpaeq
>+endif
>+endif
>+
>+# These are generated by an M4 script
>+SYMDEF_FILES = \
>+		module-cli-symdef.h \
>+		module-cli-protocol-tcp-symdef.h \
>+		module-cli-protocol-unix-symdef.h \
>+		module-pipe-sink-symdef.h \
>+		module-pipe-source-symdef.h \
>+		module-simple-protocol-tcp-symdef.h \
>+		module-simple-protocol-unix-symdef.h \
>+		module-native-protocol-tcp-symdef.h \
>+		module-native-protocol-unix-symdef.h \
>+		module-native-protocol-fd-symdef.h \
>+		module-sine-symdef.h \
>+		module-combine-symdef.h \
>+		module-combine-sink-symdef.h \
>+		module-remap-sink-symdef.h \
>+		module-remap-source-symdef.h \
>+		module-ladspa-sink-symdef.h \
>+		module-equalizer-sink-symdef.h \
>+		module-match-symdef.h \
>+		module-tunnel-sink-new-symdef.h \
>+		module-tunnel-source-new-symdef.h \
>+		module-tunnel-sink-symdef.h \
>+		module-tunnel-source-symdef.h \
>+		module-null-sink-symdef.h \
>+		module-null-source-symdef.h \
>+		module-sine-source-symdef.h \
>+		module-zeroconf-publish-symdef.h \
>+		module-zeroconf-discover-symdef.h \
>+		module-bonjour-publish-symdef.h \
>+		module-lirc-symdef.h \
>+		module-xenpv-sink-symdef.h \
>+		module-mmkbd-evdev-symdef.h \
>+		module-http-protocol-tcp-symdef.h \
>+		module-http-protocol-unix-symdef.h \
>+		module-rygel-media-server-symdef.h \
>+		module-x11-bell-symdef.h \
>+		module-x11-publish-symdef.h \
>+		module-x11-xsmp-symdef.h \
>+		module-x11-cork-request-symdef.h \
>+		module-oss-symdef.h \
>+		module-alsa-sink-symdef.h \
>+		module-alsa-source-symdef.h \
>+		module-alsa-card-symdef.h \
>+		module-coreaudio-detect-symdef.h \
>+		module-coreaudio-device-symdef.h \
>+		module-solaris-symdef.h \
>+		module-waveout-symdef.h \
>+		module-detect-symdef.h \
>+		module-rtp-send-symdef.h \
>+		module-rtp-recv-symdef.h \
>+		module-jackdbus-detect-symdef.h \
>+		module-jack-sink-symdef.h \
>+		module-jack-source-symdef.h \
>+		module-volume-restore-symdef.h \
>+		module-device-manager-symdef.h \
>+		module-device-restore-symdef.h \
>+		module-stream-restore-symdef.h \
>+		module-card-restore-symdef.h \
>+		module-default-device-restore-symdef.h \
>+		module-always-sink-symdef.h \
>+		module-rescue-streams-symdef.h \
>+		module-intended-roles-symdef.h \
>+		module-suspend-on-idle-symdef.h \
>+		module-echo-cancel-symdef.h \
>+		module-hal-detect-symdef.h \
>+		module-udev-detect-symdef.h \
>+		module-systemd-login-symdef.h \
>+		module-bluetooth-policy-symdef.h \
>+		module-bluetooth-discover-symdef.h \
>+		module-bluez4-discover-symdef.h \
>+		module-bluez4-device-symdef.h \
>+		module-bluez5-discover-symdef.h \
>+		module-bluez5-device-symdef.h \
>+		module-raop-sink-symdef.h \
>+		module-raop-discover-symdef.h \
>+		module-gconf-symdef.h \
>+		module-position-event-sounds-symdef.h \
>+		module-role-ducking-symdef.h \
>+		module-augment-properties-symdef.h \
>+		module-role-cork-symdef.h \
>+		module-console-kit-symdef.h \
>+		module-dbus-protocol-symdef.h \
>+		module-loopback-symdef.h \
>+		module-virtual-sink-symdef.h \
>+		module-virtual-source-symdef.h \
>+		module-virtual-surround-sink-symdef.h \
>+		module-switch-on-connect-symdef.h \
>+		module-switch-on-port-available-symdef.h \
>+		module-filter-apply-symdef.h \
>+		module-filter-heuristics-symdef.h
>+
>+if HAVE_ESOUND
>+SYMDEF_FILES += \
>+		module-esound-protocol-tcp-symdef.h \
>+		module-esound-protocol-unix-symdef.h \
>+		module-esound-compat-spawnfd-symdef.h \
>+		module-esound-compat-spawnpid-symdef.h \
>+		module-esound-sink-symdef.h
>+endif
>+
>+EXTRA_DIST += $(SYMDEF_FILES)
>+BUILT_SOURCES += $(SYMDEF_FILES) builddirs
>+
>+$(SYMDEF_FILES): modules/module-defs.h.m4
>+	$(AM_V_at)$(MKDIR_P) modules
>+	$(AM_V_GEN)$(M4) -Dfname="$@" $< > $@
>+
>+.PHONY: builddirs
>+builddirs:
>+	$(AM_V_at)$(MKDIR_P) daemon modules
>+
>+# Simple protocol
>+
>+module_simple_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
>+module_simple_protocol_tcp_la_CFLAGS = -DUSE_TCP_SOCKETS -DUSE_PROTOCOL_SIMPLE $(AM_CFLAGS)
>+module_simple_protocol_tcp_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_simple_protocol_tcp_la_LIBADD = $(MODULE_LIBADD) libprotocol-simple.la
>+
>+module_simple_protocol_unix_la_SOURCES = modules/module-protocol-stub.c
>+module_simple_protocol_unix_la_CFLAGS = -DUSE_UNIX_SOCKETS -DUSE_PROTOCOL_SIMPLE $(AM_CFLAGS)
>+module_simple_protocol_unix_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_simple_protocol_unix_la_LIBADD = $(MODULE_LIBADD) libprotocol-simple.la
>+
>+# CLI protocol
>+
>+module_cli_la_SOURCES = modules/module-cli.c
>+module_cli_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_cli_la_LIBADD = $(MODULE_LIBADD) libcli.la
>+
>+module_cli_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
>+module_cli_protocol_tcp_la_CFLAGS = -DUSE_TCP_SOCKETS -DUSE_PROTOCOL_CLI $(AM_CFLAGS)
>+module_cli_protocol_tcp_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_cli_protocol_tcp_la_LIBADD = $(MODULE_LIBADD) libprotocol-cli.la
>+
>+module_cli_protocol_unix_la_SOURCES = modules/module-protocol-stub.c
>+module_cli_protocol_unix_la_CFLAGS = -DUSE_UNIX_SOCKETS -DUSE_PROTOCOL_CLI $(AM_CFLAGS)
>+module_cli_protocol_unix_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_cli_protocol_unix_la_LIBADD = $(MODULE_LIBADD) libprotocol-cli.la
>+
>+# HTTP protocol
>+
>+module_http_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
>+module_http_protocol_tcp_la_CFLAGS = -DUSE_TCP_SOCKETS -DUSE_PROTOCOL_HTTP $(AM_CFLAGS)
>+module_http_protocol_tcp_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_http_protocol_tcp_la_LIBADD = $(MODULE_LIBADD) libprotocol-http.la
>+
>+module_http_protocol_unix_la_SOURCES = modules/module-protocol-stub.c
>+module_http_protocol_unix_la_CFLAGS = -DUSE_UNIX_SOCKETS -DUSE_PROTOCOL_HTTP $(AM_CFLAGS)
>+module_http_protocol_unix_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_http_protocol_unix_la_LIBADD = $(MODULE_LIBADD) libprotocol-http.la
>+
>+# D-Bus protocol
>+
>+module_dbus_protocol_la_SOURCES = \
>+		modules/dbus/iface-card.c modules/dbus/iface-card.h \
>+		modules/dbus/iface-card-profile.c modules/dbus/iface-card-profile.h \
>+		modules/dbus/iface-client.c modules/dbus/iface-client.h \
>+		modules/dbus/iface-core.c modules/dbus/iface-core.h \
>+		modules/dbus/iface-device.c modules/dbus/iface-device.h \
>+		modules/dbus/iface-device-port.c modules/dbus/iface-device-port.h \
>+		modules/dbus/iface-memstats.c modules/dbus/iface-memstats.h \
>+		modules/dbus/iface-module.c modules/dbus/iface-module.h \
>+		modules/dbus/iface-sample.c modules/dbus/iface-sample.h \
>+		modules/dbus/iface-stream.c modules/dbus/iface-stream.h \
>+		modules/dbus/module-dbus-protocol.c
>+module_dbus_protocol_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+module_dbus_protocol_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_dbus_protocol_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS)
>+
>+# Native protocol
>+
>+module_native_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
>+module_native_protocol_tcp_la_CFLAGS = -DUSE_TCP_SOCKETS -DUSE_PROTOCOL_NATIVE $(AM_CFLAGS)
>+module_native_protocol_tcp_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_native_protocol_tcp_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+
>+module_native_protocol_unix_la_SOURCES = modules/module-protocol-stub.c
>+module_native_protocol_unix_la_CFLAGS = -DUSE_UNIX_SOCKETS -DUSE_PROTOCOL_NATIVE $(AM_CFLAGS)
>+module_native_protocol_unix_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_native_protocol_unix_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+
>+module_native_protocol_fd_la_SOURCES = modules/module-native-protocol-fd.c
>+module_native_protocol_fd_la_CFLAGS = $(AM_CFLAGS)
>+module_native_protocol_fd_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_native_protocol_fd_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+
>+# EsounD protocol
>+
>+if HAVE_ESOUND
>+module_esound_protocol_tcp_la_SOURCES = modules/module-protocol-stub.c
>+module_esound_protocol_tcp_la_CFLAGS = -DUSE_TCP_SOCKETS -DUSE_PROTOCOL_ESOUND $(AM_CFLAGS)
>+module_esound_protocol_tcp_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_esound_protocol_tcp_la_LIBADD = $(MODULE_LIBADD) libprotocol-esound.la
>+
>+module_esound_protocol_unix_la_SOURCES = modules/module-protocol-stub.c
>+module_esound_protocol_unix_la_CFLAGS = -DUSE_UNIX_SOCKETS -DUSE_PROTOCOL_ESOUND $(AM_CFLAGS)
>+module_esound_protocol_unix_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_esound_protocol_unix_la_LIBADD = $(MODULE_LIBADD) libprotocol-esound.la
>+
>+module_esound_compat_spawnfd_la_SOURCES = modules/module-esound-compat-spawnfd.c
>+module_esound_compat_spawnfd_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_esound_compat_spawnfd_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_esound_compat_spawnpid_la_SOURCES = modules/module-esound-compat-spawnpid.c
>+module_esound_compat_spawnpid_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_esound_compat_spawnpid_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_esound_sink_la_SOURCES = modules/module-esound-sink.c
>+module_esound_sink_la_LDFLAGS = $(MODULE_LDFLAGS) $(WINSOCK_LIBS)
>+module_esound_sink_la_LIBADD = $(MODULE_LIBADD)
>+endif
>+
>+# Pipes
>+
>+module_pipe_sink_la_SOURCES = modules/module-pipe-sink.c
>+module_pipe_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_pipe_sink_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_pipe_source_la_SOURCES = modules/module-pipe-source.c
>+module_pipe_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_pipe_source_la_LIBADD = $(MODULE_LIBADD)
>+
>+# Fake sources/sinks
>+
>+module_sine_la_SOURCES = modules/module-sine.c
>+module_sine_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_sine_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_null_sink_la_SOURCES = modules/module-null-sink.c
>+module_null_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_null_sink_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_null_source_la_SOURCES = modules/module-null-source.c
>+module_null_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_null_source_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_sine_source_la_SOURCES = modules/module-sine-source.c
>+module_sine_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_sine_source_la_LIBADD = $(MODULE_LIBADD)
>+
>+# Couplings
>+
>+module_combine_la_SOURCES = modules/module-combine.c
>+module_combine_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_combine_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_combine_sink_la_SOURCES = modules/module-combine-sink.c
>+module_combine_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_combine_sink_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_switch_on_connect_la_SOURCES = modules/module-switch-on-connect.c
>+module_switch_on_connect_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_switch_on_connect_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_switch_on_port_available_la_SOURCES = modules/module-switch-on-port-available.c
>+module_switch_on_port_available_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_switch_on_port_available_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_filter_apply_la_SOURCES = modules/module-filter-apply.c
>+module_filter_apply_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_filter_apply_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_filter_heuristics_la_SOURCES = modules/module-filter-heuristics.c
>+module_filter_heuristics_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_filter_heuristics_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_remap_sink_la_SOURCES = modules/module-remap-sink.c
>+module_remap_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_remap_sink_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_remap_source_la_SOURCES = modules/module-remap-source.c
>+module_remap_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_remap_source_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_ladspa_sink_la_SOURCES = modules/module-ladspa-sink.c modules/ladspa.h
>+module_ladspa_sink_la_CFLAGS = -DLADSPA_PATH=\"$(libdir)/ladspa:/usr/local/lib/ladspa:/usr/lib/ladspa:/usr/local/lib64/ladspa:/usr/lib64/ladspa\" $(AM_CFLAGS) $(SERVER_CFLAGS)
>+module_ladspa_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_ladspa_sink_la_LIBADD = $(MODULE_LIBADD) $(LIBLTDL)
>+
>+if HAVE_DBUS
>+module_ladspa_sink_la_CFLAGS += $(DBUS_CFLAGS)
>+module_ladspa_sink_la_LIBADD += $(DBUS_LIBS)
>+endif
>+
>+module_equalizer_sink_la_SOURCES = modules/module-equalizer-sink.c
>+module_equalizer_sink_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS) $(DBUS_CFLAGS) $(FFTW_CFLAGS)
>+module_equalizer_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_equalizer_sink_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) $(FFTW_LIBS)
>+
>+module_match_la_SOURCES = modules/module-match.c
>+module_match_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_match_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_tunnel_sink_new_la_SOURCES = modules/module-tunnel-sink-new.c
>+module_tunnel_sink_new_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_tunnel_sink_new_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_tunnel_source_new_la_SOURCES = modules/module-tunnel-source-new.c
>+module_tunnel_source_new_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_tunnel_source_new_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_tunnel_sink_la_SOURCES = modules/module-tunnel.c
>+module_tunnel_sink_la_CFLAGS = -DTUNNEL_SINK=1 $(AM_CFLAGS) $(X11_CFLAGS)
>+module_tunnel_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_tunnel_sink_la_LIBADD = $(MODULE_LIBADD) $(X11_LIBS)
>+
>+module_tunnel_source_la_SOURCES = modules/module-tunnel.c
>+module_tunnel_source_la_LDFLAGS = $(MODULE_LDFLAGS) $(X11_CFLAGS)
>+module_tunnel_source_la_LIBADD = $(MODULE_LIBADD) $(X11_LIBS)
>+
>+module_loopback_la_SOURCES = modules/module-loopback.c
>+module_loopback_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_loopback_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_virtual_sink_la_SOURCES = modules/module-virtual-sink.c
>+module_virtual_sink_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS)
>+module_virtual_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_virtual_sink_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_virtual_source_la_SOURCES = modules/module-virtual-source.c
>+module_virtual_source_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS)
>+module_virtual_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_virtual_source_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_virtual_surround_sink_la_SOURCES = modules/module-virtual-surround-sink.c
>+module_virtual_surround_sink_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS)
>+module_virtual_surround_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_virtual_surround_sink_la_LIBADD = $(MODULE_LIBADD)
>+
>+# X11
>+
>+module_x11_bell_la_SOURCES = modules/x11/module-x11-bell.c
>+module_x11_bell_la_CFLAGS = $(AM_CFLAGS) $(X11_CFLAGS)
>+module_x11_bell_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_x11_bell_la_LIBADD = $(MODULE_LIBADD) $(X11_LIBS)
>+
>+module_x11_publish_la_SOURCES = modules/x11/module-x11-publish.c
>+module_x11_publish_la_CFLAGS = $(AM_CFLAGS) $(X11_CFLAGS)
>+module_x11_publish_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_x11_publish_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la $(X11_LIBS)
>+
>+module_x11_xsmp_la_SOURCES = modules/x11/module-x11-xsmp.c
>+module_x11_xsmp_la_CFLAGS = $(AM_CFLAGS) $(X11_CFLAGS)
>+module_x11_xsmp_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_x11_xsmp_la_LIBADD = $(MODULE_LIBADD) $(X11_LIBS)
>+
>+module_x11_cork_request_la_SOURCES = modules/x11/module-x11-cork-request.c
>+module_x11_cork_request_la_CFLAGS = $(AM_CFLAGS) $(X11_CFLAGS)
>+module_x11_cork_request_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_x11_cork_request_la_LIBADD = $(MODULE_LIBADD) $(X11_LIBS)
>+
>+# OSS
>+
>+liboss_util_la_SOURCES = modules/oss/oss-util.c modules/oss/oss-util.h
>+liboss_util_la_LDFLAGS = -avoid-version
>+liboss_util_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_oss_la_SOURCES = modules/oss/module-oss.c
>+module_oss_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_oss_la_LIBADD = $(MODULE_LIBADD) liboss-util.la
>+
>+# COREAUDIO
>+
>+module_coreaudio_detect_la_SOURCES = modules/macosx/module-coreaudio-detect.c
>+module_coreaudio_detect_la_LDFLAGS = $(MODULE_LDFLAGS) \
>+		-Wl,-framework -Wl,Cocoa -framework CoreAudio \
>+		-Wl,-framework -Wl,AudioUnit -framework AudioUnit
>+module_coreaudio_detect_la_LIBADD = $(MODULE_LIBADD)
>+
>+module_coreaudio_device_la_SOURCES = modules/macosx/module-coreaudio-device.c
>+module_coreaudio_device_la_LDFLAGS = $(MODULE_LDFLAGS) \
>+		-Wl,-framework -Wl,Cocoa -framework CoreAudio \
>+		-Wl,-framework -Wl,AudioUnit -framework AudioUnit
>+module_coreaudio_device_la_LIBADD = $(MODULE_LIBADD)
>+
>+# ALSA
>+
>+libalsa_util_la_SOURCES = \
>+		modules/alsa/alsa-util.c modules/alsa/alsa-util.h \
>+		modules/alsa/alsa-ucm.c modules/alsa/alsa-ucm.h \
>+		modules/alsa/alsa-mixer.c modules/alsa/alsa-mixer.h \
>+		modules/alsa/alsa-sink.c modules/alsa/alsa-sink.h \
>+		modules/alsa/alsa-source.c modules/alsa/alsa-source.h \
>+		modules/reserve-wrap.c modules/reserve-wrap.h
>+libalsa_util_la_LDFLAGS = -avoid-version
>+libalsa_util_la_LIBADD = $(MODULE_LIBADD) $(ASOUNDLIB_LIBS)
>+libalsa_util_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS) $(ASOUNDLIB_CFLAGS)
>+
>+if HAVE_UDEV
>+libalsa_util_la_SOURCES += modules/udev-util.h modules/udev-util.c
>+libalsa_util_la_LIBADD += $(UDEV_LIBS)
>+libalsa_util_la_CFLAGS += $(UDEV_CFLAGS)
>+endif
>+
>+if HAVE_DBUS
>+libalsa_util_la_SOURCES += modules/reserve.h modules/reserve.c modules/reserve-monitor.h modules/reserve-monitor.c
>+libalsa_util_la_LIBADD += $(DBUS_LIBS)
>+libalsa_util_la_CFLAGS += $(DBUS_CFLAGS)
>+endif
>+
>+module_alsa_sink_la_SOURCES = modules/alsa/module-alsa-sink.c
>+module_alsa_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_alsa_sink_la_LIBADD = $(MODULE_LIBADD) $(ASOUNDLIB_LIBS) libalsa-util.la
>+module_alsa_sink_la_CFLAGS = $(AM_CFLAGS) $(ASOUNDLIB_CFLAGS)
>+
>+module_alsa_source_la_SOURCES = modules/alsa/module-alsa-source.c
>+module_alsa_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_alsa_source_la_LIBADD = $(MODULE_LIBADD) $(ASOUNDLIB_LIBS) libalsa-util.la
>+module_alsa_source_la_CFLAGS = $(AM_CFLAGS) $(ASOUNDLIB_CFLAGS)
>+
>+module_alsa_card_la_SOURCES = modules/alsa/module-alsa-card.c
>+module_alsa_card_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_alsa_card_la_LIBADD = $(MODULE_LIBADD) $(ASOUNDLIB_LIBS) libalsa-util.la
>+module_alsa_card_la_CFLAGS = $(AM_CFLAGS) $(ASOUNDLIB_CFLAGS)
>+
>+# Solaris
>+
>+module_solaris_la_SOURCES = modules/module-solaris.c
>+module_solaris_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_solaris_la_LIBADD = $(MODULE_LIBADD)
>+
>+# Avahi
>+
>+module_zeroconf_publish_la_SOURCES = modules/module-zeroconf-publish.c
>+module_zeroconf_publish_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_zeroconf_publish_la_LIBADD = $(MODULE_LIBADD) $(AVAHI_LIBS) libavahi-wrap.la libprotocol-native.la
>+module_zeroconf_publish_la_CFLAGS = $(AM_CFLAGS) $(AVAHI_CFLAGS)
>+
>+module_zeroconf_discover_la_SOURCES = modules/module-zeroconf-discover.c
>+module_zeroconf_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_zeroconf_discover_la_LIBADD = $(MODULE_LIBADD) $(AVAHI_LIBS) libavahi-wrap.la
>+module_zeroconf_discover_la_CFLAGS = $(AM_CFLAGS) $(AVAHI_CFLAGS)
>+
>+# Bonjour
>+
>+module_bonjour_publish_la_SOURCES = modules/macosx/module-bonjour-publish.c
>+module_bonjour_publish_la_LDFLAGS = $(MODULE_LDFLAGS) \
>+			-Wl,-framework -Wl,CoreFoundation -framework CoreFoundation
>+module_bonjour_publish_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+
>+# LIRC
>+
>+module_lirc_la_SOURCES = modules/module-lirc.c
>+module_lirc_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_lirc_la_LIBADD = $(MODULE_LIBADD) $(LIRC_LIBS)
>+module_lirc_la_CFLAGS = $(AM_CFLAGS) $(LIRC_CFLAGS)
>+
>+
>+# Xen PV driver
>+
>+module_xenpv_sink_la_SOURCES = modules/xen/module-xenpv-sink.c modules/xen/gntalloc.h modules/xen/gntdev.h
>+module_xenpv_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_xenpv_sink_la_LIBADD = $(MODULE_LIBADD) $(XEN_LIBS)
>+module_xenpv_sink_la_CFLAGS = $(AM_CFLAGS) $(XEN_CFLAGS) -I$(top_srcdir)/src/modules/xen
>+
>+
>+# Linux evdev
>+
>+module_mmkbd_evdev_la_SOURCES = modules/module-mmkbd-evdev.c
>+module_mmkbd_evdev_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_mmkbd_evdev_la_LIBADD = $(MODULE_LIBADD)
>+module_mmkbd_evdev_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Windows waveout
>+module_waveout_la_SOURCES = modules/module-waveout.c
>+module_waveout_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_waveout_la_LIBADD = $(MODULE_LIBADD) -lwinmm
>+module_waveout_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Hardware autodetection module
>+module_detect_la_SOURCES = modules/module-detect.c
>+module_detect_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_detect_la_LIBADD = $(MODULE_LIBADD)
>+module_detect_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Volume restore module
>+module_volume_restore_la_SOURCES = modules/module-volume-restore.c
>+module_volume_restore_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_volume_restore_la_LIBADD = $(MODULE_LIBADD)
>+module_volume_restore_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Position event sounds in space
>+module_position_event_sounds_la_SOURCES = modules/module-position-event-sounds.c
>+module_position_event_sounds_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_position_event_sounds_la_LIBADD = $(MODULE_LIBADD)
>+module_position_event_sounds_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Ducking effect based on stream roles
>+module_role_ducking_la_SOURCES = modules/module-role-ducking.c
>+module_role_ducking_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_role_ducking_la_LIBADD = $(MODULE_LIBADD)
>+module_role_ducking_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Augment properties from XDG .desktop files
>+module_augment_properties_la_SOURCES = modules/module-augment-properties.c
>+module_augment_properties_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_augment_properties_la_LIBADD = $(MODULE_LIBADD)
>+#module_augment_properties_la_CFLAGS = $(AM_CFLAGS) -DDESKTOPFILEDIR=\"$(datadir)/applications\"
>+module_augment_properties_la_CFLAGS = $(AM_CFLAGS) -DDESKTOPFILEDIR=\"/usr/share/applications\"
>+
>+# Cork certain streams while others are active (e.g. cork music when phone streams appear)
>+module_role_cork_la_SOURCES = modules/module-role-cork.c
>+module_role_cork_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_role_cork_la_LIBADD = $(MODULE_LIBADD)
>+module_role_cork_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Device description restore module
>+module_device_manager_la_SOURCES = modules/module-device-manager.c
>+module_device_manager_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_device_manager_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+module_device_manager_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Device volume/muted restore module
>+module_device_restore_la_SOURCES = modules/module-device-restore.c
>+module_device_restore_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_device_restore_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+module_device_restore_la_CFLAGS = $(AM_CFLAGS)
>+
>+if HAVE_DBUS
>+module_device_restore_la_LIBADD += $(DBUS_LIBS)
>+module_device_restore_la_CFLAGS += $(DBUS_CFLAGS)
>+endif
>+
>+# Stream volume/muted/device restore module
>+module_stream_restore_la_SOURCES = modules/module-stream-restore.c
>+module_stream_restore_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_stream_restore_la_LIBADD = $(MODULE_LIBADD) libprotocol-native.la
>+module_stream_restore_la_CFLAGS = $(AM_CFLAGS)
>+
>+if HAVE_DBUS
>+module_stream_restore_la_LIBADD += $(DBUS_LIBS)
>+module_stream_restore_la_CFLAGS += $(DBUS_CFLAGS)
>+endif
>+
>+# Card profile restore module
>+module_card_restore_la_SOURCES = modules/module-card-restore.c
>+module_card_restore_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_card_restore_la_LIBADD = $(MODULE_LIBADD)
>+module_card_restore_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Default sink/source restore module
>+module_default_device_restore_la_SOURCES = modules/module-default-device-restore.c
>+module_default_device_restore_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_default_device_restore_la_LIBADD = $(MODULE_LIBADD)
>+module_default_device_restore_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Always Sink module
>+module_always_sink_la_SOURCES = modules/module-always-sink.c
>+module_always_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_always_sink_la_LIBADD = $(MODULE_LIBADD)
>+module_always_sink_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Rescue streams module
>+module_rescue_streams_la_SOURCES = modules/module-rescue-streams.c
>+module_rescue_streams_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_rescue_streams_la_LIBADD = $(MODULE_LIBADD)
>+module_rescue_streams_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Automatically move streams to devices that are intended for their roles
>+module_intended_roles_la_SOURCES = modules/module-intended-roles.c
>+module_intended_roles_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_intended_roles_la_LIBADD = $(MODULE_LIBADD)
>+module_intended_roles_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Suspend-on-idle module
>+module_suspend_on_idle_la_SOURCES = modules/module-suspend-on-idle.c
>+module_suspend_on_idle_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_suspend_on_idle_la_LIBADD = $(MODULE_LIBADD)
>+module_suspend_on_idle_la_CFLAGS = $(AM_CFLAGS)
>+
>+# echo-cancel module
>+module_echo_cancel_la_SOURCES = \
>+		modules/echo-cancel/module-echo-cancel.c \
>+		modules/echo-cancel/null.c \
>+		modules/echo-cancel/echo-cancel.h
>+module_echo_cancel_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_echo_cancel_la_LIBADD = $(MODULE_LIBADD)
>+module_echo_cancel_la_CFLAGS = $(AM_CFLAGS) $(SERVER_CFLAGS)
>+if HAVE_ADRIAN_EC
>+module_echo_cancel_la_SOURCES += \
>+		modules/echo-cancel/adrian-aec.c modules/echo-cancel/adrian-aec.h \
>+		modules/echo-cancel/adrian.c modules/echo-cancel/adrian.h
>+module_echo_cancel_la_CFLAGS += -DHAVE_ADRIAN_EC=1
>+ORC_SOURCE += modules/echo-cancel/adrian-aec
>+if HAVE_ORC
>+nodist_module_echo_cancel_la_SOURCES = \
>+		modules/echo-cancel/adrian-aec-orc-gen.c \
>+		modules/echo-cancel/adrian-aec-orc-gen.h
>+module_echo_cancel_la_LIBADD += $(ORC_LIBS)
>+module_echo_cancel_la_CFLAGS += $(ORC_CFLAGS) -I$(top_builddir)/src/modules/echo-cancel
>+endif
>+endif
>+if HAVE_SPEEX
>+module_echo_cancel_la_SOURCES += modules/echo-cancel/speex.c
>+module_echo_cancel_la_CFLAGS += $(LIBSPEEX_CFLAGS)
>+module_echo_cancel_la_LIBADD += $(LIBSPEEX_LIBS)
>+endif
>+if HAVE_WEBRTC
>+# The webrtc code is split off into a helper library to avoid having automake
>+# link module-echo-cancel with C++ (which it does if there are any C++ deps,
>+# even conditional ones).
>+
>+libwebrtc_util_la_SOURCES = modules/echo-cancel/webrtc.cc
>+libwebrtc_util_la_CXXFLAGS = $(AM_CXXFLAGS) $(SERVER_CFLAGS) $(WEBRTC_CFLAGS) -DHAVE_WEBRTC=1
>+libwebrtc_util_la_LIBADD = libpulsecore-@PA_MAJORMINOR@.la $(WEBRTC_LIBS)
>+libwebrtc_util_la_LDFLAGS = -avoid-version
>+
>+module_echo_cancel_la_CFLAGS += -DHAVE_WEBRTC=1
>+module_echo_cancel_la_LIBADD += libwebrtc-util.la
>+endif
>+
>+# RTP modules
>+module_rtp_send_la_SOURCES = modules/rtp/module-rtp-send.c
>+module_rtp_send_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_rtp_send_la_LIBADD = $(MODULE_LIBADD) librtp.la
>+module_rtp_send_la_CFLAGS = $(AM_CFLAGS)
>+
>+module_rtp_recv_la_SOURCES = modules/rtp/module-rtp-recv.c
>+module_rtp_recv_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_rtp_recv_la_LIBADD = $(MODULE_LIBADD) librtp.la
>+module_rtp_recv_la_CFLAGS = $(AM_CFLAGS)
>+
>+# JACK
>+
>+module_jackdbus_detect_la_SOURCES = modules/jack/module-jackdbus-detect.c
>+module_jackdbus_detect_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_jackdbus_detect_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) $(JACK_LIBS)
>+module_jackdbus_detect_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS) $(JACK_CFLAGS)
>+
>+module_jack_sink_la_SOURCES = modules/jack/module-jack-sink.c
>+module_jack_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_jack_sink_la_LIBADD = $(MODULE_LIBADD) $(JACK_LIBS)
>+module_jack_sink_la_CFLAGS = $(AM_CFLAGS) $(JACK_CFLAGS)
>+
>+module_jack_source_la_SOURCES = modules/jack/module-jack-source.c
>+module_jack_source_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_jack_source_la_LIBADD = $(MODULE_LIBADD) $(JACK_LIBS)
>+module_jack_source_la_CFLAGS = $(AM_CFLAGS) $(JACK_CFLAGS)
>+
>+module_hal_detect_la_SOURCES = modules/module-hal-detect-compat.c
>+module_hal_detect_la_LIBADD = $(MODULE_LIBADD)
>+module_hal_detect_la_CFLAGS = $(AM_CFLAGS)
>+module_hal_detect_la_LDFLAGS = $(MODULE_LDFLAGS)
>+
>+module_udev_detect_la_SOURCES = modules/module-udev-detect.c
>+module_udev_detect_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_udev_detect_la_LIBADD = $(MODULE_LIBADD) $(UDEV_LIBS)
>+module_udev_detect_la_CFLAGS = $(AM_CFLAGS) $(UDEV_CFLAGS)
>+
>+module_console_kit_la_SOURCES = modules/module-console-kit.c
>+module_console_kit_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_console_kit_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS)
>+module_console_kit_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+module_systemd_login_la_SOURCES = modules/module-systemd-login.c
>+module_systemd_login_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_systemd_login_la_LIBADD = $(MODULE_LIBADD) $(SYSTEMD_LIBS) $(SYSTEMDLOGIN_LIBS)
>+module_systemd_login_la_CFLAGS = $(AM_CFLAGS) $(SYSTEMD_CFLAGS) $(SYSTEMDLOGIN_CFLAGS)
>+
>+# GConf support
>+module_gconf_la_SOURCES = modules/gconf/module-gconf.c
>+module_gconf_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_gconf_la_LIBADD = $(MODULE_LIBADD)
>+module_gconf_la_CFLAGS = $(AM_CFLAGS) -DPA_GCONF_HELPER=\"$(pulselibexecdir)/gconf-helper\"
>+
>+gconf_helper_SOURCES = modules/gconf/gconf-helper.c
>+gconf_helper_LDADD = $(AM_LDADD) libpulsecore-@PA_MAJORMINOR@.la libpulsecommon-@PA_MAJORMINOR@.la libpulse.la $(GCONF_LIBS)
>+gconf_helper_CFLAGS = $(AM_CFLAGS) $(GCONF_CFLAGS)
>+gconf_helper_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
>+
>+# Bluetooth policy
>+module_bluetooth_policy_la_SOURCES = modules/bluetooth/module-bluetooth-policy.c
>+module_bluetooth_policy_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_bluetooth_policy_la_LIBADD = $(MODULE_LIBADD)
>+module_bluetooth_policy_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+# Bluetooth discover
>+module_bluetooth_discover_la_SOURCES = modules/bluetooth/module-bluetooth-discover.c
>+module_bluetooth_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_bluetooth_discover_la_LIBADD = $(MODULE_LIBADD)
>+module_bluetooth_discover_la_CFLAGS = $(AM_CFLAGS)
>+
>+# Bluetooth BlueZ 4 sink / source
>+module_bluez4_discover_la_SOURCES = modules/bluetooth/module-bluez4-discover.c
>+module_bluez4_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_bluez4_discover_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) libbluez4-util.la
>+module_bluez4_discover_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+libbluez4_util_la_SOURCES = \
>+		modules/bluetooth/a2dp-codecs.h \
>+		modules/bluetooth/bluez4-util.c \
>+		modules/bluetooth/bluez4-util.h
>+libbluez4_util_la_LDFLAGS = -avoid-version
>+libbluez4_util_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS)
>+libbluez4_util_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+module_bluez4_device_la_SOURCES = modules/bluetooth/module-bluez4-device.c modules/bluetooth/rtp.h
>+module_bluez4_device_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_bluez4_device_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) $(SBC_LIBS) libbluez4-util.la
>+module_bluez4_device_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS) $(SBC_CFLAGS)
>+
>+# Bluetooth BlueZ 5 sink / source
>+libbluez5_util_la_SOURCES = \
>+		modules/bluetooth/bluez5-util.c \
>+		modules/bluetooth/bluez5-util.h \
>+		modules/bluetooth/a2dp-codecs.h
>+if HAVE_BLUEZ_5_OFONO_HEADSET
>+libbluez5_util_la_SOURCES += \
>+		modules/bluetooth/backend-ofono.c
>+endif
>+if HAVE_BLUEZ_5_NATIVE_HEADSET
>+libbluez5_util_la_SOURCES += \
>+		modules/bluetooth/backend-native.c
>+endif
>+
>+libbluez5_util_la_LDFLAGS = -avoid-version
>+libbluez5_util_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS)
>+libbluez5_util_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+module_bluez5_discover_la_SOURCES = modules/bluetooth/module-bluez5-discover.c
>+module_bluez5_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_bluez5_discover_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) libbluez5-util.la
>+module_bluez5_discover_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+module_bluez5_device_la_SOURCES = modules/bluetooth/module-bluez5-device.c
>+module_bluez5_device_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_bluez5_device_la_LIBADD = $(MODULE_LIBADD) $(SBC_LIBS) libbluez5-util.la
>+module_bluez5_device_la_CFLAGS = $(AM_CFLAGS) $(SBC_CFLAGS)
>+
>+# Apple Airtunes/RAOP
>+module_raop_sink_la_SOURCES = modules/raop/module-raop-sink.c
>+module_raop_sink_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_raop_sink_la_LIBADD = $(MODULE_LIBADD) librtp.la libraop.la
>+module_raop_sink_la_CFLAGS = $(AM_CFLAGS) -I$(top_srcdir)/src/modules/rtp
>+
>+module_raop_discover_la_SOURCES = modules/raop/module-raop-discover.c
>+module_raop_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_raop_discover_la_LIBADD = $(MODULE_LIBADD) $(AVAHI_LIBS) libavahi-wrap.la
>+module_raop_discover_la_CFLAGS = $(AM_CFLAGS) $(AVAHI_CFLAGS)
>+
>+# Rygel
>+module_rygel_media_server_la_SOURCES = modules/module-rygel-media-server.c
>+module_rygel_media_server_la_LDFLAGS = $(MODULE_LDFLAGS)
>+module_rygel_media_server_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) libprotocol-http.la
>+module_rygel_media_server_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS)
>+
>+###################################
>+#        Some minor stuff         #
>+###################################
>+
>+CLEANFILES += daemon/pulseaudio.desktop
>+DISTCLEANFILES = esdcompat client.conf default.pa system.pa daemon.conf start-pulseaudio-x11 pulseaudio.service
>+
>+if OS_IS_WIN32
>+SYMLINK_PROGRAM=cd $(DESTDIR)$(bindir) && cp
>+else
>+SYMLINK_PROGRAM=ln -sf
>+endif
>+install-exec-hook:
>+	$(SYMLINK_PROGRAM) pacat$(EXEEXT) $(DESTDIR)$(bindir)/parec$(EXEEXT)
>+	$(SYMLINK_PROGRAM) pacat$(EXEEXT) $(DESTDIR)$(bindir)/pamon$(EXEEXT)
>+	$(SYMLINK_PROGRAM) pacat$(EXEEXT) $(DESTDIR)$(bindir)/paplay$(EXEEXT)
>+	$(SYMLINK_PROGRAM) pacat$(EXEEXT) $(DESTDIR)$(bindir)/parecord$(EXEEXT)
>+	rm -f $(DESTDIR)$(libdir)/libpulsedsp.la
>+	rm -f $(DESTDIR)$(modlibexecdir)/*.la
>+
>+uninstall-hook:
>+	rm -f $(DESTDIR)$(bindir)/parec$(EXEEXT)
>+	rm -f $(DESTDIR)$(bindir)/pamon$(EXEEXT)
>+	rm -f $(DESTDIR)$(bindir)/paplay$(EXEEXT)
>+	rm -f $(DESTDIR)$(bindir)/parecord$(EXEEXT)
>+	rm -f $(DESTDIR)$(libdir)/libpulsedsp.*
>+	rm -f $(DESTDIR)$(modlibexecdir)/*.so
>+
>+massif: pulseaudio
>+	libtool --mode=execute valgrind --tool=massif --depth=6  --alloc-fn=pa_xmalloc --alloc-fn=pa_xmalloc0 --alloc-fn=pa_xrealloc --alloc-fn=dbus_realloc --alloc-fn=pa_xnew0_internal --alloc-fn=pa_xnew_internal ./pulseaudio
>+
>+update-ffmpeg:
>+	wget -O pulsecore/ffmpeg/resample2.c http://svn.mplayerhq.hu/ffmpeg/trunk/libavcodec/resample2.c?view=co
>+
>+update-reserve:
>+	for i in reserve.c reserve.h reserve-monitor.c reserve-monitor.h ; do \
>+		wget -O $(top_srcdir)/src/modules/$$i http://git.0pointer.de/\?p=reserve.git\;a=blob_plain\;f=$$i\;hb=master ; \
>+	done
>+
>+update-rtkit:
>+	for i in rtkit.c rtkit.h ; do \
>+		wget -O $(top_srcdir)/src/pulsecore/$$i http://git.0pointer.de/\?p=rtkit.git\;a=blob_plain\;f=$$i\;hb=master ; \
>+	done
>+
>+# Automatically generate linker version script. We use the same one for all public .sos
>+update-map-file:
>+	( echo "PULSE_0 {" ; \
>+	  echo "global:" ; \
>+	  ctags -I PA_GCC_MALLOC,PA_GCC_ALLOC_SIZE2,PA_GCC_ALLOC_SIZE,PA_GCC_PURE,PA_GCC_CONST,PA_GCC_DEPRECATED,PA_GCC_PRINTF_ATTR -f - --c-kinds=p $(pulseinclude_HEADERS) | awk '/^pa_/ { print $$1 ";" }' | sort ; \
>+	  echo "local:" ;  \
>+	  echo "*;" ; \
>+	  echo "};" ) > $(srcdir)/map-file
>+
>+update-all: update-ffmpeg update-map-file
>+
>+# Force installation order of libraries. libtool relinks on install time, in
>+# which case libpulsecommon has to be installed before others, but the padsp
>+# preload library has to be done after the normal libraries (e.g. libpulse)
>+# ...
>+# Unfortunately automake behaviour means that rules without commands also
>+# override build-in rules, so it's not trivial to add dependencies.
>+# See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=7328 for the workaround
>+# ...
>+# Isn't libtool/autotools fun!
>+
>+installlibLTLIBRARIES = install-libLTLIBRARIES
>+$(installlibLTLIBRARIES): install-commonlibLTLIBRARIES
>+
>+installpkglibLTLIBRARIES = install-pkglibLTLIBRARIES
>+$(installpkglibLTLIBRARIES): install-libLTLIBRARIES
>+
>+installmodlibexecLTLIBRARIES = install-modlibexecLTLIBRARIES
>+$(installmodlibexecLTLIBRARIES): install-pkglibLTLIBRARIES install-libLTLIBRARIES
>+
>+installpadsplibLTLIBRARIES = install-padsplibLTLIBRARIES
>+$(installpadsplibLTLIBRARIES): install-libLTLIBRARIES
>+
>+if HAVE_GCOV
>+coverage:
>+	@echo ""
>+	@echo "Don't forget to run 'make check' before generating coverage stats."
>+	@echo ""
>+	lcov --capture --directory . --output-file $(builddir)/gcov-all.info
>+	-rm -r $(builddir)/coverage
>+	genhtml --output-directory $(builddir)/coverage gcov-all.info
>+	@echo ""
>+	@echo "Coverage data now available at: $(abs_builddir)/coverage/index.html"
>+else
>+coverage:
>+	@echo ""
>+	@echo "To generate coverage stats, rerun configure with '--enable-gcov',"
>+	@echo "and don't forget to disable it again for regular builds."
>+	@echo ""
>+endif
>+
>+.PHONY: massif update-all update-ffmpeg update-map-file coverage
>diff -Naur a/src/map-file b/src/map-file
>--- a/src/map-file	2016-01-30 17:31:02.000000000 -0800
>+++ b/src/map-file	2016-01-31 12:11:22.000000000 -0800
>@@ -333,7 +333,9 @@
> pa_stream_update_timing_info;
> pa_stream_writable_size;
> pa_stream_write;
>+pa_stream_write_compressed;
> pa_stream_write_ext_free;
>+pa_stream_write_ext_compressed_free;
> pa_strerror;
> pa_sw_cvolume_divide;
> pa_sw_cvolume_divide_scalar;
>diff -Naur a/src/map-file.orig b/src/map-file.orig
>--- a/src/map-file.orig	1969-12-31 16:00:00.000000000 -0800
>+++ b/src/map-file.orig	2016-01-31 12:11:22.000000000 -0800
>@@ -0,0 +1,385 @@
>+PULSE_0 {
>+global:
>+pa_ascii_filter;
>+pa_ascii_valid;
>+pa_bytes_per_second;
>+pa_bytes_snprint;
>+pa_bytes_to_usec;
>+pa_channel_map_can_balance;
>+pa_channel_map_can_fade;
>+pa_channel_map_can_lfe_balance;
>+pa_channel_map_compatible;
>+pa_channel_map_equal;
>+pa_channel_map_has_position;
>+pa_channel_map_init;
>+pa_channel_map_init_auto;
>+pa_channel_map_init_extend;
>+pa_channel_map_init_mono;
>+pa_channel_map_init_stereo;
>+pa_channel_map_mask;
>+pa_channel_map_parse;
>+pa_channel_map_snprint;
>+pa_channel_map_superset;
>+pa_channel_map_to_name;
>+pa_channel_map_to_pretty_name;
>+pa_channel_map_valid;
>+pa_channel_position_from_string;
>+pa_channel_position_to_pretty_string;
>+pa_channel_position_to_string;
>+pa_channels_valid;
>+pa_context_add_autoload;
>+pa_context_connect;
>+pa_context_disconnect;
>+pa_context_drain;
>+pa_context_errno;
>+pa_context_exit_daemon;
>+pa_context_get_autoload_info_by_index;
>+pa_context_get_autoload_info_by_name;
>+pa_context_get_autoload_info_list;
>+pa_context_get_card_info_by_index;
>+pa_context_get_card_info_by_name;
>+pa_context_get_card_info_list;
>+pa_context_get_client_info;
>+pa_context_get_client_info_list;
>+pa_context_get_index;
>+pa_context_get_module_info;
>+pa_context_get_module_info_list;
>+pa_context_get_protocol_version;
>+pa_context_get_sample_info_by_index;
>+pa_context_get_sample_info_by_name;
>+pa_context_get_sample_info_list;
>+pa_context_get_server;
>+pa_context_get_server_info;
>+pa_context_get_server_protocol_version;
>+pa_context_get_sink_info_by_index;
>+pa_context_get_sink_info_by_name;
>+pa_context_get_sink_info_list;
>+pa_context_get_sink_input_info;
>+pa_context_get_sink_input_info_list;
>+pa_context_get_source_info_by_index;
>+pa_context_get_source_info_by_name;
>+pa_context_get_source_info_list;
>+pa_context_get_source_output_info;
>+pa_context_get_source_output_info_list;
>+pa_context_set_port_latency_offset;
>+pa_context_get_state;
>+pa_context_get_tile_size;
>+pa_context_is_local;
>+pa_context_is_pending;
>+pa_context_kill_client;
>+pa_context_kill_sink_input;
>+pa_context_kill_source_output;
>+pa_context_load_cookie_from_file;
>+pa_context_load_module;
>+pa_context_move_sink_input_by_index;
>+pa_context_move_sink_input_by_name;
>+pa_context_move_source_output_by_index;
>+pa_context_move_source_output_by_name;
>+pa_context_new;
>+pa_context_new_with_proplist;
>+pa_context_play_sample;
>+pa_context_play_sample_with_proplist;
>+pa_context_proplist_remove;
>+pa_context_proplist_update;
>+pa_context_ref;
>+pa_context_remove_autoload_by_index;
>+pa_context_remove_autoload_by_name;
>+pa_context_remove_sample;
>+pa_context_rttime_new;
>+pa_context_rttime_restart;
>+pa_context_set_card_profile_by_index;
>+pa_context_set_card_profile_by_name;
>+pa_context_set_default_sink;
>+pa_context_set_default_source;
>+pa_context_set_event_callback;
>+pa_context_set_name;
>+pa_context_set_sink_input_mute;
>+pa_context_set_sink_input_volume;
>+pa_context_set_sink_mute_by_index;
>+pa_context_set_sink_mute_by_name;
>+pa_context_set_sink_port_by_index;
>+pa_context_set_sink_port_by_name;
>+pa_context_set_sink_volume_by_index;
>+pa_context_set_sink_volume_by_name;
>+pa_context_set_source_output_mute;
>+pa_context_set_source_output_volume;
>+pa_context_set_source_mute_by_index;
>+pa_context_set_source_mute_by_name;
>+pa_context_set_source_port_by_index;
>+pa_context_set_source_port_by_name;
>+pa_context_set_source_volume_by_index;
>+pa_context_set_source_volume_by_name;
>+pa_context_set_state_callback;
>+pa_context_set_subscribe_callback;
>+pa_context_stat;
>+pa_context_subscribe;
>+pa_context_suspend_sink_by_index;
>+pa_context_suspend_sink_by_name;
>+pa_context_suspend_source_by_index;
>+pa_context_suspend_source_by_name;
>+pa_context_unload_module;
>+pa_context_unref;
>+pa_cvolume_avg;
>+pa_cvolume_avg_mask;
>+pa_cvolume_channels_equal_to;
>+pa_cvolume_compatible;
>+pa_cvolume_compatible_with_channel_map;
>+pa_cvolume_dec;
>+pa_cvolume_equal;
>+pa_cvolume_get_balance;
>+pa_cvolume_get_fade;
>+pa_cvolume_get_lfe_balance;
>+pa_cvolume_get_position;
>+pa_cvolume_inc;
>+pa_cvolume_inc_clamp;
>+pa_cvolume_init;
>+pa_cvolume_max;
>+pa_cvolume_max_mask;
>+pa_cvolume_merge;
>+pa_cvolume_min;
>+pa_cvolume_min_mask;
>+pa_cvolume_remap;
>+pa_cvolume_scale;
>+pa_cvolume_scale_mask;
>+pa_cvolume_set;
>+pa_cvolume_set_balance;
>+pa_cvolume_set_fade;
>+pa_cvolume_set_lfe_balance;
>+pa_cvolume_set_position;
>+pa_cvolume_snprint;
>+pa_cvolume_snprint_verbose;
>+pa_cvolume_valid;
>+pa_direction_to_string;
>+pa_direction_valid;
>+pa_encoding_to_string;
>+pa_ext_device_manager_delete;
>+pa_ext_device_manager_enable_role_device_priority_routing;
>+pa_ext_device_manager_read;
>+pa_ext_device_manager_reorder_devices_for_role;
>+pa_ext_device_manager_set_device_description;
>+pa_ext_device_manager_set_subscribe_cb;
>+pa_ext_device_manager_subscribe;
>+pa_ext_device_manager_test;
>+pa_ext_device_restore_read_formats;
>+pa_ext_device_restore_read_formats_all;
>+pa_ext_device_restore_save_formats;
>+pa_ext_device_restore_set_subscribe_cb;
>+pa_ext_device_restore_subscribe;
>+pa_ext_device_restore_test;
>+pa_ext_stream_restore_delete;
>+pa_ext_stream_restore_read;
>+pa_ext_stream_restore_set_subscribe_cb;
>+pa_ext_stream_restore_subscribe;
>+pa_ext_stream_restore_test;
>+pa_ext_stream_restore_write;
>+pa_format_info_copy;
>+pa_format_info_free;
>+pa_format_info_from_string;
>+pa_format_info_from_sample_spec;
>+pa_format_info_get_prop_type;
>+pa_format_info_get_prop_int;
>+pa_format_info_get_prop_int_range;
>+pa_format_info_get_prop_int_array;
>+pa_format_info_get_prop_string;
>+pa_format_info_get_prop_string_array;
>+pa_format_info_free_string_array;
>+pa_format_info_is_compatible;
>+pa_format_info_is_pcm;
>+pa_format_info_new;
>+pa_format_info_set_channel_map;
>+pa_format_info_set_channels;
>+pa_format_info_set_prop_int;
>+pa_format_info_set_prop_int_array;
>+pa_format_info_set_prop_int_range;
>+pa_format_info_set_prop_string;
>+pa_format_info_set_prop_string_array;
>+pa_format_info_set_rate;
>+pa_format_info_set_sample_format;
>+pa_format_info_snprint;
>+pa_format_info_to_sample_spec;
>+pa_format_info_valid;
>+pa_frame_size;
>+pa_get_binary_name;
>+pa_get_fqdn;
>+pa_get_home_dir;
>+pa_get_host_name;
>+pa_get_library_version;
>+pa_gettimeofday;
>+pa_get_user_name;
>+pa_glib_mainloop_free;
>+pa_glib_mainloop_get_api;
>+pa_glib_mainloop_new;
>+pa_locale_to_utf8;
>+pa_mainloop_api_once;
>+pa_mainloop_dispatch;
>+pa_mainloop_free;
>+pa_mainloop_get_api;
>+pa_mainloop_get_retval;
>+pa_mainloop_iterate;
>+pa_mainloop_new;
>+pa_mainloop_poll;
>+pa_mainloop_prepare;
>+pa_mainloop_quit;
>+pa_mainloop_run;
>+pa_mainloop_set_poll_func;
>+pa_mainloop_wakeup;
>+pa_msleep;
>+pa_operation_cancel;
>+pa_operation_get_state;
>+pa_operation_ref;
>+pa_operation_set_state_callback;
>+pa_operation_unref;
>+pa_parse_sample_format;
>+pa_path_get_filename;
>+pa_proplist_clear;
>+pa_proplist_contains;
>+pa_proplist_copy;
>+pa_proplist_equal;
>+pa_proplist_free;
>+pa_proplist_from_string;
>+pa_proplist_get;
>+pa_proplist_gets;
>+pa_proplist_isempty;
>+pa_proplist_iterate;
>+pa_proplist_key_valid;
>+pa_proplist_new;
>+pa_proplist_set;
>+pa_proplist_setf;
>+pa_proplist_setp;
>+pa_proplist_sets;
>+pa_proplist_size;
>+pa_proplist_to_string;
>+pa_proplist_to_string_sep;
>+pa_proplist_unset;
>+pa_proplist_unset_many;
>+pa_proplist_update;
>+pa_rtclock_now;
>+pa_sample_format_is_be;
>+pa_sample_format_is_le;
>+pa_sample_format_to_string;
>+pa_sample_format_valid;
>+pa_sample_rate_valid;
>+pa_sample_size;
>+pa_sample_size_of_format;
>+pa_sample_spec_equal;
>+pa_sample_spec_init;
>+pa_sample_spec_snprint;
>+pa_sample_spec_valid;
>+pa_signal_done;
>+pa_signal_free;
>+pa_signal_init;
>+pa_signal_new;
>+pa_signal_set_destroy;
>+pa_simple_drain;
>+pa_simple_flush;
>+pa_simple_free;
>+pa_simple_get_latency;
>+pa_simple_new;
>+pa_simple_read;
>+pa_simple_write;
>+pa_stream_begin_write;
>+pa_stream_cancel_write;
>+pa_stream_connect_playback;
>+pa_stream_connect_record;
>+pa_stream_connect_upload;
>+pa_stream_cork;
>+pa_stream_disconnect;
>+pa_stream_drain;
>+pa_stream_drop;
>+pa_stream_finish_upload;
>+pa_stream_flush;
>+pa_stream_get_buffer_attr;
>+pa_stream_get_channel_map;
>+pa_stream_get_context;
>+pa_stream_get_device_index;
>+pa_stream_get_device_name;
>+pa_stream_get_format_info;
>+pa_stream_get_index;
>+pa_stream_get_latency;
>+pa_stream_get_monitor_stream;
>+pa_stream_get_sample_spec;
>+pa_stream_get_state;
>+pa_stream_get_time;
>+pa_stream_get_timing_info;
>+pa_stream_get_underflow_index;
>+pa_stream_is_corked;
>+pa_stream_is_suspended;
>+pa_stream_new;
>+pa_stream_new_extended;
>+pa_stream_new_with_proplist;
>+pa_stream_peek;
>+pa_stream_prebuf;
>+pa_stream_proplist_remove;
>+pa_stream_proplist_update;
>+pa_stream_readable_size;
>+pa_stream_ref;
>+pa_stream_set_buffer_attr;
>+pa_stream_set_buffer_attr_callback;
>+pa_stream_set_event_callback;
>+pa_stream_set_latency_update_callback;
>+pa_stream_set_monitor_stream;
>+pa_stream_set_moved_callback;
>+pa_stream_set_name;
>+pa_stream_set_overflow_callback;
>+pa_stream_set_read_callback;
>+pa_stream_set_started_callback;
>+pa_stream_set_state_callback;
>+pa_stream_set_suspended_callback;
>+pa_stream_set_underflow_callback;
>+pa_stream_set_write_callback;
>+pa_stream_trigger;
>+pa_stream_unref;
>+pa_stream_update_sample_rate;
>+pa_stream_update_timing_info;
>+pa_stream_writable_size;
>+pa_stream_write;
>+pa_stream_write_ext_free;
>+pa_strerror;
>+pa_sw_cvolume_divide;
>+pa_sw_cvolume_divide_scalar;
>+pa_sw_cvolume_multiply;
>+pa_sw_cvolume_multiply_scalar;
>+pa_sw_cvolume_snprint_dB;
>+pa_sw_volume_divide;
>+pa_sw_volume_from_dB;
>+pa_sw_volume_from_linear;
>+pa_sw_volume_multiply;
>+pa_sw_volume_snprint_dB;
>+pa_sw_volume_to_dB;
>+pa_sw_volume_to_linear;
>+pa_threaded_mainloop_accept;
>+pa_threaded_mainloop_free;
>+pa_threaded_mainloop_get_api;
>+pa_threaded_mainloop_get_retval;
>+pa_threaded_mainloop_in_thread;
>+pa_threaded_mainloop_lock;
>+pa_threaded_mainloop_new;
>+pa_threaded_mainloop_set_name;
>+pa_threaded_mainloop_signal;
>+pa_threaded_mainloop_start;
>+pa_threaded_mainloop_stop;
>+pa_threaded_mainloop_unlock;
>+pa_threaded_mainloop_wait;
>+pa_timeval_add;
>+pa_timeval_age;
>+pa_timeval_cmp;
>+pa_timeval_diff;
>+pa_timeval_load;
>+pa_timeval_store;
>+pa_timeval_sub;
>+pa_usec_to_bytes;
>+pa_utf8_filter;
>+pa_utf8_to_locale;
>+pa_utf8_valid;
>+pa_volume_snprint;
>+pa_volume_snprint_verbose;
>+pa_xfree;
>+pa_xmalloc;
>+pa_xmalloc0;
>+pa_xmemdup;
>+pa_xrealloc;
>+pa_xstrdup;
>+pa_xstrndup;
>+local:
>+*;
>+};
>diff -Naur a/src/modules/module-tunnel-sink-new.c b/src/modules/module-tunnel-sink-new.c
>--- a/src/modules/module-tunnel-sink-new.c	2016-01-30 17:31:01.000000000 -0800
>+++ b/src/modules/module-tunnel-sink-new.c	2016-01-31 12:11:22.000000000 -0800
>@@ -39,6 +39,8 @@
> #include <pulsecore/thread-mq.h>
> #include <pulsecore/poll.h>
> #include <pulsecore/proplist-util.h>
>+#include <pulsecore/transcode.h>
>+
> 
> #include "module-tunnel-sink-new-symdef.h"
> 
>@@ -56,6 +58,9 @@
>         "rate=<sample rate> "
>         "channel_map=<channel map> "
>         "cookie=<cookie file path>"
>+        "compression=<compression format> "
>+        "compression_frame_size=<frame_size of compression (opus: 120, 240, 480, 960, 1920, 2880)> "
>+        "compression_bitrate=<bitrate of compression> "
>         );
> 
> #define MAX_LATENCY_USEC (200 * PA_USEC_PER_MSEC)
>@@ -72,7 +77,7 @@
>     pa_sink *sink;
>     pa_thread *thread;
>     pa_thread_mq *thread_mq;
>-    pa_mainloop *thread_mainloop;
>+    pa_rtpoll *rtpoll;
>     pa_mainloop_api *thread_mainloop_api;
> 
>     pa_context *context;
>@@ -85,6 +90,8 @@
>     char *cookie_file;
>     char *remote_server;
>     char *remote_sink_name;
>+
>+    pa_transcode transcode;
> };
> 
> static const char* const valid_modargs[] = {
>@@ -97,6 +104,9 @@
>     "rate",
>     "channel_map",
>     "cookie",
>+    "compression",
>+    "compression-bitrate",
>+    "compression-frame_size",
>    /* "reconnect", reconnect if server comes back again - unimplemented */
>     NULL,
> };
>@@ -176,13 +186,6 @@
>     for (;;) {
>         int ret;
> 
>-        if (pa_mainloop_iterate(u->thread_mainloop, 1, &ret) < 0) {
>-            if (ret == 0)
>-                goto finish;
>-            else
>-                goto fail;
>-        }
>-
>         if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
>             pa_sink_process_rewind(u->sink, 0);
> 
>@@ -193,32 +196,78 @@
> 
>             writable = pa_stream_writable_size(u->stream);
>             if (writable > 0) {
>-                pa_memchunk memchunk;
>-                const void *p;
>-
>-                pa_sink_render_full(u->sink, writable, &memchunk);
> 
>-                pa_assert(memchunk.length > 0);
>+                if(u->transcode.encoding != -1) {
>+                         pa_memchunk memchunk;
>+                         const void *p;
>+                         size_t nbBytes;
>+                         unsigned char *cbits;
>+
>+                         pa_sink_render_full(u->sink, u->transcode.frame_size*u->transcode.channels*u->transcode.sample_size, &memchunk);
>+
>+                         pa_assert(memchunk.length > 0);
>+                         pa_assert(memchunk.length >=  u->transcode.frame_size*u->transcode.channels);
>+
>+
>+                         pa_log_debug("received memchunk length: %zu bytes", memchunk.length );
>+                         /* we have new data to write */
>+                         p = pa_memblock_acquire(memchunk.memblock);
>+
>+                         nbBytes = pa_transcode_encode(&u->transcode, (uint8_t*) p + memchunk.index, &cbits);
>+                         pa_log_debug("encoded length: %zu bytes", nbBytes);
>+
>+                         /* TODO: Use pa_stream_begin_write() to reduce copying. */
>+                         ret = pa_stream_write_compressed(u->stream,
>+                                               (uint8_t*) cbits,
>+                                               nbBytes,
>+                                               NULL,     /**< A cleanup routine for the data or NULL to request an internal copy */
>+                                               0,        /** offset */
>+                                              PA_SEEK_RELATIVE, u->transcode.frame_size*u->transcode.channels*u->transcode.sample_size);
>+                         pa_memblock_release(memchunk.memblock);
>+                         pa_memblock_unref(memchunk.memblock);
>+                         if(nbBytes > 0) free(cbits);
>+
>+                         if (ret != 0) {
>+                             pa_log_error("Could not write data into the stream ... ret = %i", ret);
>+                             u->thread_mainloop_api->quit(u->thread_mainloop_api, TUNNEL_THREAD_FAILED_MAINLOOP);
>+                         }
>+                }
>+                else {
>+                         pa_memchunk memchunk;
>+                         const void *p;
>+
>+                         pa_sink_render_full(u->sink, writable, &memchunk);
>+
>+                         pa_assert(memchunk.length > 0);
>+
>+                         /* we have new data to write */
>+                         p = pa_memblock_acquire(memchunk.memblock);
>+                         /* TODO: Use pa_stream_begin_write() to reduce copying. */
>+                         ret = pa_stream_write(u->stream,
>+                                               (uint8_t*) p + memchunk.index,
>+                                               memchunk.length,
>+                                               NULL,     /**< A cleanup routine for the data or NULL to request an internal copy */
>+                                               0,        /** offset */
>+                                               PA_SEEK_RELATIVE);
>+                         pa_memblock_release(memchunk.memblock);
>+                         pa_memblock_unref(memchunk.memblock);
>+
>+                         if (ret != 0) {
>+                             pa_log_error("Could not write data into the stream ... ret = %i", ret);
>+                             u->thread_mainloop_api->quit(u->thread_mainloop_api, TUNNEL_THREAD_FAILED_MAINLOOP);
>+                         }
> 
>-                /* we have new data to write */
>-                p = pa_memblock_acquire(memchunk.memblock);
>-                /* TODO: Use pa_stream_begin_write() to reduce copying. */
>-                ret = pa_stream_write(u->stream,
>-                                      (uint8_t*) p + memchunk.index,
>-                                      memchunk.length,
>-                                      NULL,     /**< A cleanup routine for the data or NULL to request an internal copy */
>-                                      0,        /** offset */
>-                                      PA_SEEK_RELATIVE);
>-                pa_memblock_release(memchunk.memblock);
>-                pa_memblock_unref(memchunk.memblock);
>-
>-                if (ret != 0) {
>-                    pa_log_error("Could not write data into the stream ... ret = %i", ret);
>-                    u->thread_mainloop_api->quit(u->thread_mainloop_api, TUNNEL_THREAD_FAILED_MAINLOOP);
>                 }
> 
>             }
>         }
>+        if ((ret = pa_rtpoll_run(u->rtpoll)) < 0)
>+            goto fail;
>+
>+        /* ret is zero only when the module is being unloaded, i.e. we're doing
>+         * clean shutdown. */
>+        if (ret == 0)
>+            goto finish;  
>     }
> fail:
>     pa_asyncmsgq_post(u->thread_mq->outq, PA_MSGOBJECT(u->module->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
>@@ -312,7 +361,25 @@
>             pa_assert(!u->stream);
> 
>             proplist = tunnel_new_proplist(u);
>-            u->stream = pa_stream_new_with_proplist(u->context,
>+
>+            if(u->transcode.encoding != -1) {
>+
>+                  unsigned int n_formats = 1;
>+                  pa_format_info *formats[1];
>+
>+                  formats[0] = pa_format_info_new();
>+                  formats[0]->encoding = u->transcode.encoding;
>+                  pa_format_info_set_sample_format(formats[0], u->sink->sample_spec.format);
>+                  pa_format_info_set_rate(formats[0], u->sink->sample_spec.rate);
>+                  pa_format_info_set_channels(formats[0], u->sink->sample_spec.channels);
>+                  pa_format_info_set_channel_map(formats[0],  &u->sink->channel_map);
>+                  pa_transcode_set_format_info(&u->transcode, formats[0]);
>+
>+                  u->stream = pa_stream_new_extended(u->context, stream_name, formats, n_formats, proplist);
>+
>+            }
>+            else
>+                  u->stream = pa_stream_new_with_proplist(u->context,
>                                                     stream_name,
>                                                     &u->sink->sample_spec,
>                                                     &u->sink->channel_map,
>@@ -461,6 +528,7 @@
>     pa_channel_map map;
>     const char *remote_server = NULL;
>     const char *sink_name = NULL;
>+    const char *compression = NULL;
>     char *default_sink_name = NULL;
> 
>     pa_assert(m);
>@@ -487,18 +555,13 @@
>     u->module = m;
>     m->userdata = u;
>     u->remote_server = pa_xstrdup(remote_server);
>-    u->thread_mainloop = pa_mainloop_new();
>-    if (u->thread_mainloop == NULL) {
>-        pa_log("Failed to create mainloop");
>-        goto fail;
>-    }
>-    u->thread_mainloop_api = pa_mainloop_get_api(u->thread_mainloop);
>+        u->rtpoll = pa_rtpoll_new();
>+    u->thread_mq = pa_xnew0(pa_thread_mq, 1);
>+    pa_thread_mq_init(u->thread_mq, m->core->mainloop, u->rtpoll);
>+    u->thread_mainloop_api = pa_rtpoll_get_mainloop_api(u->rtpoll);
>     u->cookie_file = pa_xstrdup(pa_modargs_get_value(ma, "cookie", NULL));
>     u->remote_sink_name = pa_xstrdup(pa_modargs_get_value(ma, "sink", NULL));
> 
>-    u->thread_mq = pa_xnew0(pa_thread_mq, 1);
>-    pa_thread_mq_init_thread_mainloop(u->thread_mq, m->core->mainloop, u->thread_mainloop_api);
>-
>     /* Create sink */
>     pa_sink_new_data_init(&sink_data);
>     sink_data.driver = __FILE__;
>@@ -507,6 +570,24 @@
>     default_sink_name = pa_sprintf_malloc("tunnel-sink-new.%s", remote_server);
>     sink_name = pa_modargs_get_value(ma, "sink_name", default_sink_name);
> 
>+    compression = pa_modargs_get_value(ma, "compression", NULL);
>+    if (compression) {
>+        pa_log("compression activated");
>+        memset(&u->transcode, 0, sizeof(pa_transcode));
>+
>+        if(strcmp(compression, "opus") == 0 && pa_transcode_supported(PA_ENCODING_OPUS)){
>+
>+             compression = pa_modargs_get_value(ma, "compression-frame_size", NULL);
>+             if(compression) u->transcode.frame_size = atoi(compression);
>+             compression = pa_modargs_get_value(ma, "compression-bitrate", NULL);
>+             if(compression) u->transcode.bitrate = atoi(compression);
>+
>+             pa_transcode_init(&u->transcode, PA_ENCODING_OPUS, PA_TRANSCODE_ENCODER, NULL, &ss);
>+
>+         }
>+    }
>+    else u->transcode.encoding = -1;
>+
>     pa_sink_new_data_set_name(&sink_data, sink_name);
>     pa_sink_new_data_set_sample_spec(&sink_data, &ss);
>     pa_sink_new_data_set_channel_map(&sink_data, &map);
>@@ -537,7 +618,8 @@
> 
>     /* set thread message queue */
>     pa_sink_set_asyncmsgq(u->sink, u->thread_mq->inq);
>-
>+	pa_sink_set_rtpoll(u->sink, u->rtpoll);
>+	
>     if (!(u->thread = pa_thread_new("tunnel-sink", thread_func, u))) {
>         pa_log("Failed to create thread.");
>         goto fail;
>@@ -582,8 +664,8 @@
>         pa_xfree(u->thread_mq);
>     }
> 
>-    if (u->thread_mainloop)
>-        pa_mainloop_free(u->thread_mainloop);
>+    if (u->rtpoll)
>+        pa_rtpoll_free(u->rtpoll);
> 
>     if (u->cookie_file)
>         pa_xfree(u->cookie_file);
>@@ -597,5 +679,8 @@
>     if (u->sink)
>         pa_sink_unref(u->sink);
> 
>+     if(u->transcode.encoding != -1)
>+         pa_transcode_free(&u->transcode);
>+
>     pa_xfree(u);
> }
>diff -Naur a/src/modules/module-tunnel-source-new.c b/src/modules/module-tunnel-source-new.c
>--- a/src/modules/module-tunnel-source-new.c	2016-01-30 17:31:01.000000000 -0800
>+++ b/src/modules/module-tunnel-source-new.c	2016-01-31 12:11:22.000000000 -0800
>@@ -70,7 +70,7 @@
>     pa_source *source;
>     pa_thread *thread;
>     pa_thread_mq *thread_mq;
>-    pa_mainloop *thread_mainloop;
>+    pa_rtpoll *rtpoll;
>     pa_mainloop_api *thread_mainloop_api;
> 
>     pa_context *context;
>@@ -224,16 +224,17 @@
> 
>     for (;;) {
>         int ret;
>-
>-        if (pa_mainloop_iterate(u->thread_mainloop, 1, &ret) < 0) {
>-            if (ret == 0)
>-                goto finish;
>-            else
>-                goto fail;
>-        }
>-
>+        
>         if (u->new_data)
>             read_new_samples(u);
>+
>+        if ((ret = pa_rtpoll_run(u->rtpoll)) < 0)
>+            goto fail;
>+
>+        /* ret is zero only when the module is being unloaded, i.e. we're doing
>+         * clean shutdown. */
>+        if (ret == 0)
>+            goto finish;            
>     }
> fail:
>     pa_asyncmsgq_post(u->thread_mq->outq, PA_MSGOBJECT(u->module->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL, NULL);
>@@ -486,17 +487,13 @@
>     u->module = m;
>     m->userdata = u;
>     u->remote_server = pa_xstrdup(remote_server);
>-    u->thread_mainloop = pa_mainloop_new();
>-    if (u->thread_mainloop == NULL) {
>-        pa_log("Failed to create mainloop");
>-        goto fail;
>-    }
>-    u->thread_mainloop_api = pa_mainloop_get_api(u->thread_mainloop);
>+    u->rtpoll = pa_rtpoll_new();
>+    u->thread_mq = pa_xnew0(pa_thread_mq, 1);
>+    pa_thread_mq_init(u->thread_mq, m->core->mainloop, u->rtpoll);
>+    u->thread_mainloop_api = pa_rtpoll_get_mainloop_api(u->rtpoll);    
>     u->cookie_file = pa_xstrdup(pa_modargs_get_value(ma, "cookie", NULL));
>     u->remote_source_name = pa_xstrdup(pa_modargs_get_value(ma, "source", NULL));
> 
>-    u->thread_mq = pa_xnew0(pa_thread_mq, 1);
>-    pa_thread_mq_init_thread_mainloop(u->thread_mq, m->core->mainloop, u->thread_mainloop_api);
> 
>     /* Create source */
>     pa_source_new_data_init(&source_data);
>@@ -534,7 +531,9 @@
>     u->source->update_requested_latency = source_update_requested_latency_cb;
> 
>     pa_source_set_asyncmsgq(u->source, u->thread_mq->inq);
>-
>+	
>+	pa_source_set_rtpoll(u->source, u->rtpoll);
>+	
>     if (!(u->thread = pa_thread_new("tunnel-source", thread_func, u))) {
>         pa_log("Failed to create thread.");
>         goto fail;
>@@ -579,9 +578,9 @@
>         pa_xfree(u->thread_mq);
>     }
> 
>-    if (u->thread_mainloop)
>-        pa_mainloop_free(u->thread_mainloop);
>-
>+    if (u->rtpoll)
>+        pa_rtpoll_free(u->rtpoll);
>+    
>     if (u->cookie_file)
>         pa_xfree(u->cookie_file);
> 
>diff -Naur a/src/pulse/format.h b/src/pulse/format.h
>--- a/src/pulse/format.h	2016-01-30 17:31:02.000000000 -0800
>+++ b/src/pulse/format.h	2016-01-31 12:11:22.000000000 -0800
>@@ -56,6 +56,9 @@
>     PA_ENCODING_MPEG2_AAC_IEC61937,
>     /**< MPEG-2 AAC data encapsulated in IEC 61937 header/padding. \since 4.0 */
> 
>+    PA_ENCODING_OPUS,
>+    /**< Opus encoding (used for network tunnels) */
>+
>     PA_ENCODING_MAX,
>     /**< Valid encoding types must be less than this value */
> 
>diff -Naur a/src/pulse/stream.c b/src/pulse/stream.c
>--- a/src/pulse/stream.c	2016-01-30 17:31:02.000000000 -0800
>+++ b/src/pulse/stream.c	2016-01-31 12:11:22.000000000 -0800
>@@ -1472,14 +1472,14 @@
>     return 0;
> }
> 
>-int pa_stream_write_ext_free(
>+int pa_stream_write_ext_compressed_free(
>         pa_stream *s,
>         const void *data,
>         size_t length,
>         pa_free_cb_t free_cb,
>         void *free_cb_data,
>         int64_t offset,
>-        pa_seek_mode_t seek) {
>+        pa_seek_mode_t seek, size_t decoded_length) {
> 
>     pa_assert(s);
>     pa_assert(PA_REFCNT_VALUE(s) >= 1);
>@@ -1496,7 +1496,9 @@
>                        ((const char*) data + length <= (const char*) s->write_data + pa_memblock_get_length(s->write_memblock))),
>                       PA_ERR_INVALID);
>     PA_CHECK_VALIDITY(s->context, offset % pa_frame_size(&s->sample_spec) == 0, PA_ERR_INVALID);
>-    PA_CHECK_VALIDITY(s->context, length % pa_frame_size(&s->sample_spec) == 0, PA_ERR_INVALID);
>+    if(decoded_length==0) {
>+         PA_CHECK_VALIDITY(s->context, length % pa_frame_size(&s->sample_spec) == 0, PA_ERR_INVALID);
>+    }
>     PA_CHECK_VALIDITY(s->context, !free_cb || !s->write_memblock, PA_ERR_INVALID);
> 
>     if (s->write_memblock) {
>@@ -1558,6 +1560,10 @@
>             free_cb(free_cb_data);
>     }
> 
>+    /* use uncompressed length in the following */
>+    if(decoded_length != 0)
>+         length = decoded_length;
>+
>     /* This is obviously wrong since we ignore the seeking index . But
>      * that's OK, the server side applies the same error */
>     s->requested_bytes -= (seek == PA_SEEK_RELATIVE ? offset : 0) + (int64_t) length;
>@@ -1602,6 +1608,18 @@
>     return 0;
> }
> 
>+int pa_stream_write_ext_free(
>+        pa_stream *s,
>+        const void *data,
>+        size_t length,
>+        pa_free_cb_t free_cb,
>+        void *free_cb_data,
>+        int64_t offset,
>+        pa_seek_mode_t seek) {
>+
>+    return pa_stream_write_ext_compressed_free(s, data, length, free_cb, (void*) data, offset, seek, 0);
>+}
>+
> int pa_stream_write(
>         pa_stream *s,
>         const void *data,
>@@ -1610,7 +1628,19 @@
>         int64_t offset,
>         pa_seek_mode_t seek) {
> 
>-    return pa_stream_write_ext_free(s, data, length, free_cb, (void*) data, offset, seek);
>+    return pa_stream_write_ext_compressed_free(s, data, length, free_cb, (void*) data, offset, seek, 0);
>+}
>+
>+int pa_stream_write_compressed(
>+        pa_stream *s,
>+        const void *data,
>+        size_t length,
>+        pa_free_cb_t free_cb,
>+        int64_t offset,
>+        pa_seek_mode_t seek,
>+        size_t decoded_length) {
>+
>+    return pa_stream_write_ext_compressed_free(s, data, length, free_cb, (void*) data, offset, seek, decoded_length);
> }
> 
> int pa_stream_peek(pa_stream *s, const void **data, size_t *length) {
>diff -Naur a/src/pulse/stream.h b/src/pulse/stream.h
>--- a/src/pulse/stream.h	2016-01-30 17:31:02.000000000 -0800
>+++ b/src/pulse/stream.h	2016-01-31 12:11:22.000000000 -0800
>@@ -552,8 +552,27 @@
>         int64_t offset,          /**< Offset for seeking, must be 0 for upload streams */
>         pa_seek_mode_t seek      /**< Seek mode, must be PA_SEEK_RELATIVE for upload streams */);
> 
>+int pa_stream_write_compressed(
>+        pa_stream *s,
>+        const void *data,
>+        size_t length,
>+        pa_free_cb_t free_cb,
>+        int64_t offset,
>+        pa_seek_mode_t seek,
>+        size_t decoded_length    /**< Length of data without compression */);
>+
> /** Function does exactly the same as pa_stream_write() with the difference
>  *  that free_cb_data is passed to free_cb instead of data. \since 6.0 */
>+int pa_stream_write_ext_compressed_free(
>+        pa_stream *p             /**< The stream to use */,
>+        const void *data         /**< The data to write */,
>+        size_t nbytes            /**< The length of the data to write in bytes */,
>+        pa_free_cb_t free_cb     /**< A cleanup routine for the data or NULL to request an internal copy */,
>+        void *free_cb_data       /**< Argument passed to free_cb function */,
>+        int64_t offset           /**< Offset for seeking, must be 0 for upload streams */,
>+        pa_seek_mode_t seek      /**< Seek mode, must be PA_SEEK_RELATIVE for upload streams */,
>+        size_t decoded_length    /**< Length of data without compression */);
>+
> int pa_stream_write_ext_free(
>         pa_stream *p             /**< The stream to use */,
>         const void *data         /**< The data to write */,
>diff -Naur a/src/pulsecore/protocol-native.c b/src/pulsecore/protocol-native.c
>--- a/src/pulsecore/protocol-native.c	2016-01-30 17:31:03.000000000 -0800
>+++ b/src/pulsecore/protocol-native.c	2016-01-31 12:11:22.000000000 -0800
>@@ -55,6 +55,8 @@
> #include <pulsecore/core-util.h>
> #include <pulsecore/ipacl.h>
> #include <pulsecore/thread-mq.h>
>+#include <pulsecore/core-format.h>
>+#include <pulsecore/transcode.h>
> 
> #include "protocol-native.h"
> 
>@@ -143,6 +145,8 @@
>     size_t render_memblockq_length;
>     pa_usec_t current_sink_latency;
>     uint64_t playing_for, underrun_for;
>+
>+    pa_transcode transcode;
> } playback_stream;
> 
> #define PLAYBACK_STREAM(o) (playback_stream_cast(o))
>@@ -793,6 +797,9 @@
> 
>     playback_stream_unlink(s);
> 
>+    if(s->transcode.encoding != -1)
>+         pa_transcode_free(&s->transcode);
>+
>     pa_memblockq_free(s->memblockq);
>     pa_xfree(s);
> }
>@@ -1112,6 +1119,9 @@
>     int64_t start_index;
>     pa_sink_input_new_data data;
>     char *memblockq_name;
>+    pa_encoding_t transcode_encoding = -1;
>+    pa_format_info *f_in, *transcode_format_info;
>+    uint32_t j;
> 
>     pa_assert(c);
>     pa_assert(ss);
>@@ -1146,17 +1156,52 @@
>     data.driver = __FILE__;
>     data.module = c->options->module;
>     data.client = c->client;
>-    if (sink)
>-        pa_sink_input_new_data_set_sink(&data, sink, false);
>+
>     if (pa_sample_spec_valid(ss))
>         pa_sink_input_new_data_set_sample_spec(&data, ss);
>     if (pa_channel_map_valid(map))
>         pa_sink_input_new_data_set_channel_map(&data, map);
>+
>+    if (!sink){
>+        sink = pa_namereg_get(c->protocol->core, NULL, PA_NAMEREG_SINK);
>+    }
>+
>     if (formats) {
>         pa_sink_input_new_data_set_formats(&data, formats);
>         /* Ownership transferred to new_data, so we don't free it ourselves */
>         formats = NULL;
>     }
>+
>+    *ret = pa_sink_input_new_data_set_sink(&data, sink, false);
>+
>+    if(*ret == false)
>+    {
>+         PA_IDXSET_FOREACH(f_in, data.req_formats, j) {
>+              if(pa_transcode_supported(f_in->encoding)){
>+
>+                       transcode_encoding = f_in->encoding;
>+
>+                       f_in->encoding = PA_ENCODING_PCM;
>+
>+                       pa_sink_input_new_data_set_sink(&data, sink, false);
>+
>+                       #ifdef PROTOCOL_NATIVE_DEBUG
>+                           pa_log("enabling transcoding");
>+                       #endif
>+
>+                       transcode_format_info = pa_format_info_copy(f_in);
>+
>+                       break;
>+              }
>+         }
>+    }
>+
>+
>+
>+
>+
>+
>+
>     if (volume) {
>         pa_sink_input_new_data_set_volume(&data, volume);
>         data.volume_is_absolute = !relative_volume;
>@@ -1191,6 +1236,12 @@
>     pa_atomic_store(&s->seek_or_post_in_queue, 0);
>     s->seek_windex = -1;
> 
>+    s->transcode.encoding = transcode_encoding;
>+    if(transcode_encoding != -1) {
>+         pa_transcode_init(&s->transcode, transcode_encoding, PA_TRANSCODE_DECODER, transcode_format_info, NULL);
>+         pa_format_info_free(transcode_format_info);
>+     }
>+
>     s->sink_input->parent.process_msg = sink_input_process_msg;
>     s->sink_input->pop = sink_input_pop_cb;
>     s->sink_input->process_underrun = sink_input_process_underrun_cb;
>@@ -1459,6 +1510,10 @@
>     pa_sink_input *i = PA_SINK_INPUT(o);
>     playback_stream *s;
> 
>+    struct pa_memchunk transcode_chunk;
>+    void *input_encoded_bytes, *output_pcm_bytes;
>+    int32_t frame_size;
>+
>     pa_sink_input_assert_ref(i);
>     s = PLAYBACK_STREAM(i->userdata);
>     playback_stream_assert_ref(s);
>@@ -1478,11 +1533,38 @@
>                 windex = PA_MIN(windex, pa_memblockq_get_write_index(s->memblockq));
>             }
> 
>-            if (chunk && pa_memblockq_push_align(s->memblockq, chunk) < 0) {
>-                if (pa_log_ratelimit(PA_LOG_WARN))
>-                    pa_log_warn("Failed to push data into queue");
>-                pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
>-                pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, true);
>+            if(s->transcode.encoding != -1) {
>+                input_encoded_bytes = pa_memblock_acquire(chunk->memblock);
>+                transcode_chunk.memblock = pa_memblock_new( pa_memblock_get_pool(chunk->memblock), s->transcode.max_frame_size*s->transcode.channels*s->transcode.sample_size);
>+                transcode_chunk.index = transcode_chunk.length = 0;
>+
>+                output_pcm_bytes = pa_memblock_acquire(transcode_chunk.memblock);
>+
>+                frame_size = pa_transcode_decode(&s->transcode, input_encoded_bytes, chunk->length, output_pcm_bytes);
>+                transcode_chunk.length = frame_size*s->transcode.channels*s->transcode.sample_size;
>+
>+                pa_log_info("transcode: decoded frame (framesize: %d total length: %d)", frame_size, (int)transcode_chunk.length);
>+
>+                pa_memblock_release(chunk->memblock);
>+                pa_memblock_release(transcode_chunk.memblock);
>+
>+
>+                if (pa_memblockq_push_align(s->memblockq, &transcode_chunk) < 0) {
>+                     if (pa_log_ratelimit(PA_LOG_WARN))
>+                         pa_log_warn("Failed to push data into queue");
>+                     pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
>+                     pa_memblockq_seek(s->memblockq, (int64_t) transcode_chunk.length, PA_SEEK_RELATIVE, true);
>+                 }
>+                 pa_memblock_unref(transcode_chunk.memblock);
>+
>+            }
>+            else {
>+                     if (chunk && pa_memblockq_push_align(s->memblockq, chunk) < 0) {
>+                         if (pa_log_ratelimit(PA_LOG_WARN))
>+                             pa_log_warn("Failed to push data into queue");
>+                         pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
>+                         pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, true);
>+                 }
>             }
> 
>             /* If more data is in queue, we rewind later instead. */
>@@ -4924,7 +5006,7 @@
>         playback_stream *ps = PLAYBACK_STREAM(stream);
> 
>         size_t frame_size = pa_frame_size(&ps->sink_input->sample_spec);
>-        if (chunk->index % frame_size != 0 || chunk->length % frame_size != 0) {
>+        if ((ps->transcode.encoding == -1) && (chunk->index % frame_size != 0 || chunk->length % frame_size != 0)) {
>             pa_log_warn("Client sent non-aligned memblock: index %d, length %d, frame size: %d",
>                         (int) chunk->index, (int) chunk->length, (int) frame_size);
>             return;
>diff -Naur a/src/pulsecore/protocol-native.c.orig b/src/pulsecore/protocol-native.c.orig
>--- a/src/pulsecore/protocol-native.c.orig	1969-12-31 16:00:00.000000000 -0800
>+++ b/src/pulsecore/protocol-native.c.orig	2016-01-31 12:11:22.000000000 -0800
>@@ -0,0 +1,5424 @@
>+/***
>+  This file is part of PulseAudio.
>+
>+  Copyright 2004-2006 Lennart Poettering
>+  Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
>+
>+  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, see <http://www.gnu.org/licenses/>.
>+***/
>+
>+#ifdef HAVE_CONFIG_H
>+#include <config.h>
>+#endif
>+
>+#include <string.h>
>+#include <stdio.h>
>+#include <stdlib.h>
>+#include <unistd.h>
>+
>+#include <pulse/rtclock.h>
>+#include <pulse/timeval.h>
>+#include <pulse/version.h>
>+#include <pulse/utf8.h>
>+#include <pulse/util.h>
>+#include <pulse/xmalloc.h>
>+#include <pulse/internal.h>
>+
>+#include <pulsecore/native-common.h>
>+#include <pulsecore/packet.h>
>+#include <pulsecore/client.h>
>+#include <pulsecore/source-output.h>
>+#include <pulsecore/sink-input.h>
>+#include <pulsecore/pstream.h>
>+#include <pulsecore/tagstruct.h>
>+#include <pulsecore/pdispatch.h>
>+#include <pulsecore/pstream-util.h>
>+#include <pulsecore/namereg.h>
>+#include <pulsecore/core-scache.h>
>+#include <pulsecore/core-subscribe.h>
>+#include <pulsecore/log.h>
>+#include <pulsecore/strlist.h>
>+#include <pulsecore/shared.h>
>+#include <pulsecore/sample-util.h>
>+#include <pulsecore/creds.h>
>+#include <pulsecore/core-util.h>
>+#include <pulsecore/ipacl.h>
>+#include <pulsecore/thread-mq.h>
>+
>+#include "protocol-native.h"
>+
>+/* #define PROTOCOL_NATIVE_DEBUG */
>+
>+/* Kick a client if it doesn't authenticate within this time */
>+#define AUTH_TIMEOUT (60 * PA_USEC_PER_SEC)
>+
>+/* Don't accept more connection than this */
>+#define MAX_CONNECTIONS 64
>+
>+#define MAX_MEMBLOCKQ_LENGTH (4*1024*1024) /* 4MB */
>+#define DEFAULT_TLENGTH_MSEC 2000 /* 2s */
>+#define DEFAULT_PROCESS_MSEC 20   /* 20ms */
>+#define DEFAULT_FRAGSIZE_MSEC DEFAULT_TLENGTH_MSEC
>+
>+struct pa_native_protocol;
>+
>+typedef struct record_stream {
>+    pa_msgobject parent;
>+
>+    pa_native_connection *connection;
>+    uint32_t index;
>+
>+    pa_source_output *source_output;
>+    pa_memblockq *memblockq;
>+
>+    bool adjust_latency:1;
>+    bool early_requests:1;
>+
>+    /* Requested buffer attributes */
>+    pa_buffer_attr buffer_attr_req;
>+    /* Fixed-up and adjusted buffer attributes */
>+    pa_buffer_attr buffer_attr;
>+
>+    pa_atomic_t on_the_fly;
>+    pa_usec_t configured_source_latency;
>+    size_t drop_initial;
>+
>+    /* Only updated after SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY */
>+    size_t on_the_fly_snapshot;
>+    pa_usec_t current_monitor_latency;
>+    pa_usec_t current_source_latency;
>+} record_stream;
>+
>+#define RECORD_STREAM(o) (record_stream_cast(o))
>+PA_DEFINE_PRIVATE_CLASS(record_stream, pa_msgobject);
>+
>+typedef struct output_stream {
>+    pa_msgobject parent;
>+} output_stream;
>+
>+#define OUTPUT_STREAM(o) (output_stream_cast(o))
>+PA_DEFINE_PRIVATE_CLASS(output_stream, pa_msgobject);
>+
>+typedef struct playback_stream {
>+    output_stream parent;
>+
>+    pa_native_connection *connection;
>+    uint32_t index;
>+
>+    pa_sink_input *sink_input;
>+    pa_memblockq *memblockq;
>+
>+    bool adjust_latency:1;
>+    bool early_requests:1;
>+
>+    bool is_underrun:1;
>+    bool drain_request:1;
>+    uint32_t drain_tag;
>+    uint32_t syncid;
>+
>+    /* Optimization to avoid too many rewinds with a lot of small blocks */
>+    pa_atomic_t seek_or_post_in_queue;
>+    int64_t seek_windex;
>+
>+    pa_atomic_t missing;
>+    pa_usec_t configured_sink_latency;
>+    /* Requested buffer attributes */
>+    pa_buffer_attr buffer_attr_req;
>+    /* Fixed-up and adjusted buffer attributes */
>+    pa_buffer_attr buffer_attr;
>+
>+    /* Only updated after SINK_INPUT_MESSAGE_UPDATE_LATENCY */
>+    int64_t read_index, write_index;
>+    size_t render_memblockq_length;
>+    pa_usec_t current_sink_latency;
>+    uint64_t playing_for, underrun_for;
>+} playback_stream;
>+
>+#define PLAYBACK_STREAM(o) (playback_stream_cast(o))
>+PA_DEFINE_PRIVATE_CLASS(playback_stream, output_stream);
>+
>+typedef struct upload_stream {
>+    output_stream parent;
>+
>+    pa_native_connection *connection;
>+    uint32_t index;
>+
>+    pa_memchunk memchunk;
>+    size_t length;
>+    char *name;
>+    pa_sample_spec sample_spec;
>+    pa_channel_map channel_map;
>+    pa_proplist *proplist;
>+} upload_stream;
>+
>+#define UPLOAD_STREAM(o) (upload_stream_cast(o))
>+PA_DEFINE_PRIVATE_CLASS(upload_stream, output_stream);
>+
>+struct pa_native_connection {
>+    pa_msgobject parent;
>+    pa_native_protocol *protocol;
>+    pa_native_options *options;
>+    bool authorized:1;
>+    bool is_local:1;
>+    uint32_t version;
>+    pa_client *client;
>+    pa_pstream *pstream;
>+    pa_pdispatch *pdispatch;
>+    pa_idxset *record_streams, *output_streams;
>+    uint32_t rrobin_index;
>+    pa_subscription *subscription;
>+    pa_time_event *auth_timeout_event;
>+    pa_srbchannel *srbpending;
>+};
>+
>+#define PA_NATIVE_CONNECTION(o) (pa_native_connection_cast(o))
>+PA_DEFINE_PRIVATE_CLASS(pa_native_connection, pa_msgobject);
>+
>+struct pa_native_protocol {
>+    PA_REFCNT_DECLARE;
>+
>+    pa_core *core;
>+    pa_idxset *connections;
>+
>+    pa_strlist *servers;
>+    pa_hook hooks[PA_NATIVE_HOOK_MAX];
>+
>+    pa_hashmap *extensions;
>+};
>+
>+enum {
>+    SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY = PA_SOURCE_OUTPUT_MESSAGE_MAX
>+};
>+
>+enum {
>+    SINK_INPUT_MESSAGE_POST_DATA = PA_SINK_INPUT_MESSAGE_MAX, /* data from main loop to sink input */
>+    SINK_INPUT_MESSAGE_DRAIN, /* disabled prebuf, get playback started. */
>+    SINK_INPUT_MESSAGE_FLUSH,
>+    SINK_INPUT_MESSAGE_TRIGGER,
>+    SINK_INPUT_MESSAGE_SEEK,
>+    SINK_INPUT_MESSAGE_PREBUF_FORCE,
>+    SINK_INPUT_MESSAGE_UPDATE_LATENCY,
>+    SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR
>+};
>+
>+enum {
>+    PLAYBACK_STREAM_MESSAGE_REQUEST_DATA,      /* data requested from sink input from the main loop */
>+    PLAYBACK_STREAM_MESSAGE_UNDERFLOW,
>+    PLAYBACK_STREAM_MESSAGE_OVERFLOW,
>+    PLAYBACK_STREAM_MESSAGE_DRAIN_ACK,
>+    PLAYBACK_STREAM_MESSAGE_STARTED,
>+    PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH
>+};
>+
>+enum {
>+    RECORD_STREAM_MESSAGE_POST_DATA         /* data from source output to main loop */
>+};
>+
>+enum {
>+    CONNECTION_MESSAGE_RELEASE,
>+    CONNECTION_MESSAGE_REVOKE
>+};
>+
>+static bool sink_input_process_underrun_cb(pa_sink_input *i);
>+static int sink_input_pop_cb(pa_sink_input *i, size_t length, pa_memchunk *chunk);
>+static void sink_input_kill_cb(pa_sink_input *i);
>+static void sink_input_suspend_cb(pa_sink_input *i, bool suspend);
>+static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest);
>+static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes);
>+static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes);
>+static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes);
>+static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl);
>+
>+static void native_connection_send_memblock(pa_native_connection *c);
>+static void playback_stream_request_bytes(struct playback_stream*s);
>+
>+static void source_output_kill_cb(pa_source_output *o);
>+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk);
>+static void source_output_suspend_cb(pa_source_output *o, bool suspend);
>+static void source_output_moving_cb(pa_source_output *o, pa_source *dest);
>+static pa_usec_t source_output_get_latency_cb(pa_source_output *o);
>+static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl);
>+
>+static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
>+static int source_output_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk);
>+
>+static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_volume(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_mute(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_set_port_latency_offset(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+static void command_enable_srbchannel(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
>+
>+static const pa_pdispatch_cb_t command_table[PA_COMMAND_MAX] = {
>+    [PA_COMMAND_ERROR] = NULL,
>+    [PA_COMMAND_TIMEOUT] = NULL,
>+    [PA_COMMAND_REPLY] = NULL,
>+    [PA_COMMAND_CREATE_PLAYBACK_STREAM] = command_create_playback_stream,
>+    [PA_COMMAND_DELETE_PLAYBACK_STREAM] = command_delete_stream,
>+    [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = command_drain_playback_stream,
>+    [PA_COMMAND_CREATE_RECORD_STREAM] = command_create_record_stream,
>+    [PA_COMMAND_DELETE_RECORD_STREAM] = command_delete_stream,
>+    [PA_COMMAND_AUTH] = command_auth,
>+    [PA_COMMAND_REQUEST] = NULL,
>+    [PA_COMMAND_EXIT] = command_exit,
>+    [PA_COMMAND_SET_CLIENT_NAME] = command_set_client_name,
>+    [PA_COMMAND_LOOKUP_SINK] = command_lookup,
>+    [PA_COMMAND_LOOKUP_SOURCE] = command_lookup,
>+    [PA_COMMAND_STAT] = command_stat,
>+    [PA_COMMAND_GET_PLAYBACK_LATENCY] = command_get_playback_latency,
>+    [PA_COMMAND_GET_RECORD_LATENCY] = command_get_record_latency,
>+    [PA_COMMAND_CREATE_UPLOAD_STREAM] = command_create_upload_stream,
>+    [PA_COMMAND_DELETE_UPLOAD_STREAM] = command_delete_stream,
>+    [PA_COMMAND_FINISH_UPLOAD_STREAM] = command_finish_upload_stream,
>+    [PA_COMMAND_PLAY_SAMPLE] = command_play_sample,
>+    [PA_COMMAND_REMOVE_SAMPLE] = command_remove_sample,
>+    [PA_COMMAND_GET_SINK_INFO] = command_get_info,
>+    [PA_COMMAND_GET_SOURCE_INFO] = command_get_info,
>+    [PA_COMMAND_GET_CLIENT_INFO] = command_get_info,
>+    [PA_COMMAND_GET_CARD_INFO] = command_get_info,
>+    [PA_COMMAND_GET_MODULE_INFO] = command_get_info,
>+    [PA_COMMAND_GET_SINK_INPUT_INFO] = command_get_info,
>+    [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = command_get_info,
>+    [PA_COMMAND_GET_SAMPLE_INFO] = command_get_info,
>+    [PA_COMMAND_GET_SINK_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_SOURCE_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_MODULE_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_CLIENT_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_CARD_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_SAMPLE_INFO_LIST] = command_get_info_list,
>+    [PA_COMMAND_GET_SERVER_INFO] = command_get_server_info,
>+    [PA_COMMAND_SUBSCRIBE] = command_subscribe,
>+
>+    [PA_COMMAND_SET_SINK_VOLUME] = command_set_volume,
>+    [PA_COMMAND_SET_SINK_INPUT_VOLUME] = command_set_volume,
>+    [PA_COMMAND_SET_SOURCE_VOLUME] = command_set_volume,
>+    [PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME] = command_set_volume,
>+
>+    [PA_COMMAND_SET_SINK_MUTE] = command_set_mute,
>+    [PA_COMMAND_SET_SINK_INPUT_MUTE] = command_set_mute,
>+    [PA_COMMAND_SET_SOURCE_MUTE] = command_set_mute,
>+    [PA_COMMAND_SET_SOURCE_OUTPUT_MUTE] = command_set_mute,
>+
>+    [PA_COMMAND_SUSPEND_SINK] = command_suspend,
>+    [PA_COMMAND_SUSPEND_SOURCE] = command_suspend,
>+
>+    [PA_COMMAND_CORK_PLAYBACK_STREAM] = command_cork_playback_stream,
>+    [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
>+    [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
>+    [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = command_trigger_or_flush_or_prebuf_playback_stream,
>+
>+    [PA_COMMAND_CORK_RECORD_STREAM] = command_cork_record_stream,
>+    [PA_COMMAND_FLUSH_RECORD_STREAM] = command_flush_record_stream,
>+
>+    [PA_COMMAND_SET_DEFAULT_SINK] = command_set_default_sink_or_source,
>+    [PA_COMMAND_SET_DEFAULT_SOURCE] = command_set_default_sink_or_source,
>+    [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = command_set_stream_name,
>+    [PA_COMMAND_SET_RECORD_STREAM_NAME] = command_set_stream_name,
>+    [PA_COMMAND_KILL_CLIENT] = command_kill,
>+    [PA_COMMAND_KILL_SINK_INPUT] = command_kill,
>+    [PA_COMMAND_KILL_SOURCE_OUTPUT] = command_kill,
>+    [PA_COMMAND_LOAD_MODULE] = command_load_module,
>+    [PA_COMMAND_UNLOAD_MODULE] = command_unload_module,
>+
>+    [PA_COMMAND_GET_AUTOLOAD_INFO___OBSOLETE] = NULL,
>+    [PA_COMMAND_GET_AUTOLOAD_INFO_LIST___OBSOLETE] = NULL,
>+    [PA_COMMAND_ADD_AUTOLOAD___OBSOLETE] = NULL,
>+    [PA_COMMAND_REMOVE_AUTOLOAD___OBSOLETE] = NULL,
>+
>+    [PA_COMMAND_MOVE_SINK_INPUT] = command_move_stream,
>+    [PA_COMMAND_MOVE_SOURCE_OUTPUT] = command_move_stream,
>+
>+    [PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
>+    [PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR] = command_set_stream_buffer_attr,
>+
>+    [PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
>+    [PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE] = command_update_stream_sample_rate,
>+
>+    [PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST] = command_update_proplist,
>+    [PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST] = command_update_proplist,
>+    [PA_COMMAND_UPDATE_CLIENT_PROPLIST] = command_update_proplist,
>+
>+    [PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST] = command_remove_proplist,
>+    [PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST] = command_remove_proplist,
>+    [PA_COMMAND_REMOVE_CLIENT_PROPLIST] = command_remove_proplist,
>+
>+    [PA_COMMAND_SET_CARD_PROFILE] = command_set_card_profile,
>+
>+    [PA_COMMAND_SET_SINK_PORT] = command_set_sink_or_source_port,
>+    [PA_COMMAND_SET_SOURCE_PORT] = command_set_sink_or_source_port,
>+
>+    [PA_COMMAND_SET_PORT_LATENCY_OFFSET] = command_set_port_latency_offset,
>+
>+    [PA_COMMAND_ENABLE_SRBCHANNEL] = command_enable_srbchannel,
>+
>+    [PA_COMMAND_EXTENSION] = command_extension
>+};
>+
>+/* structure management */
>+
>+/* Called from main context */
>+static void upload_stream_unlink(upload_stream *s) {
>+    pa_assert(s);
>+
>+    if (!s->connection)
>+        return;
>+
>+    pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
>+    s->connection = NULL;
>+    upload_stream_unref(s);
>+}
>+
>+/* Called from main context */
>+static void upload_stream_free(pa_object *o) {
>+    upload_stream *s = UPLOAD_STREAM(o);
>+    pa_assert(s);
>+
>+    upload_stream_unlink(s);
>+
>+    pa_xfree(s->name);
>+
>+    if (s->proplist)
>+        pa_proplist_free(s->proplist);
>+
>+    if (s->memchunk.memblock)
>+        pa_memblock_unref(s->memchunk.memblock);
>+
>+    pa_xfree(s);
>+}
>+
>+/* Called from main context */
>+static upload_stream* upload_stream_new(
>+        pa_native_connection *c,
>+        const pa_sample_spec *ss,
>+        const pa_channel_map *map,
>+        const char *name,
>+        size_t length,
>+        pa_proplist *p) {
>+
>+    upload_stream *s;
>+
>+    pa_assert(c);
>+    pa_assert(ss);
>+    pa_assert(name);
>+    pa_assert(length > 0);
>+    pa_assert(p);
>+
>+    s = pa_msgobject_new(upload_stream);
>+    s->parent.parent.parent.free = upload_stream_free;
>+    s->connection = c;
>+    s->sample_spec = *ss;
>+    s->channel_map = *map;
>+    s->name = pa_xstrdup(name);
>+    pa_memchunk_reset(&s->memchunk);
>+    s->length = length;
>+    s->proplist = pa_proplist_copy(p);
>+    pa_proplist_update(s->proplist, PA_UPDATE_MERGE, c->client->proplist);
>+
>+    pa_idxset_put(c->output_streams, s, &s->index);
>+
>+    return s;
>+}
>+
>+/* Called from main context */
>+static void record_stream_unlink(record_stream *s) {
>+    pa_assert(s);
>+
>+    if (!s->connection)
>+        return;
>+
>+    if (s->source_output) {
>+        pa_source_output_unlink(s->source_output);
>+        pa_source_output_unref(s->source_output);
>+        s->source_output = NULL;
>+    }
>+
>+    pa_assert_se(pa_idxset_remove_by_data(s->connection->record_streams, s, NULL) == s);
>+    s->connection = NULL;
>+    record_stream_unref(s);
>+}
>+
>+/* Called from main context */
>+static void record_stream_free(pa_object *o) {
>+    record_stream *s = RECORD_STREAM(o);
>+    pa_assert(s);
>+
>+    record_stream_unlink(s);
>+
>+    pa_memblockq_free(s->memblockq);
>+    pa_xfree(s);
>+}
>+
>+/* Called from main context */
>+static int record_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
>+    record_stream *s = RECORD_STREAM(o);
>+    record_stream_assert_ref(s);
>+
>+    if (!s->connection)
>+        return -1;
>+
>+    switch (code) {
>+
>+        case RECORD_STREAM_MESSAGE_POST_DATA:
>+
>+            /* We try to keep up to date with how many bytes are
>+             * currently on the fly */
>+            pa_atomic_sub(&s->on_the_fly, chunk->length);
>+
>+            if (pa_memblockq_push_align(s->memblockq, chunk) < 0) {
>+/*                 pa_log_warn("Failed to push data into output queue."); */
>+                return -1;
>+            }
>+
>+            if (!pa_pstream_is_pending(s->connection->pstream))
>+                native_connection_send_memblock(s->connection);
>+
>+            break;
>+    }
>+
>+    return 0;
>+}
>+
>+/* Called from main context */
>+static void fix_record_buffer_attr_pre(record_stream *s) {
>+
>+    size_t frame_size;
>+    pa_usec_t orig_fragsize_usec, fragsize_usec, source_usec;
>+
>+    pa_assert(s);
>+
>+    /* This function will be called from the main thread, before as
>+     * well as after the source output has been activated using
>+     * pa_source_output_put()! That means it may not touch any
>+     * ->thread_info data! */
>+
>+    frame_size = pa_frame_size(&s->source_output->sample_spec);
>+    s->buffer_attr = s->buffer_attr_req;
>+
>+    if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
>+        s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
>+    if (s->buffer_attr.maxlength <= 0)
>+        s->buffer_attr.maxlength = (uint32_t) frame_size;
>+
>+    if (s->buffer_attr.fragsize == (uint32_t) -1)
>+        s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(DEFAULT_FRAGSIZE_MSEC*PA_USEC_PER_MSEC, &s->source_output->sample_spec);
>+    if (s->buffer_attr.fragsize <= 0)
>+        s->buffer_attr.fragsize = (uint32_t) frame_size;
>+
>+    orig_fragsize_usec = fragsize_usec = pa_bytes_to_usec(s->buffer_attr.fragsize, &s->source_output->sample_spec);
>+
>+    if (s->early_requests) {
>+
>+        /* In early request mode we need to emulate the classic
>+         * fragment-based playback model. Unfortunately we have no
>+         * mechanism to tell the source how often we want it to send us
>+         * data. The next best thing we can do is to set the source's
>+         * total buffer (i.e. its latency) to the fragment size. That
>+         * way it will have to send data at least that often. */
>+
>+        source_usec = fragsize_usec;
>+
>+    } else if (s->adjust_latency) {
>+
>+        /* So, the user asked us to adjust the latency according to
>+         * what the source can provide. We set the source to whatever
>+         * latency it can provide that is closest to what we want, and
>+         * let the client buffer be equally large. This does NOT mean
>+         * that we are doing (2 * fragsize) bytes of buffering, since
>+         * the client-side buffer is only data that is on the way to
>+         * the client. */
>+
>+        source_usec = fragsize_usec;
>+
>+    } else {
>+
>+        /* Ok, the user didn't ask us to adjust the latency, hence we
>+         * don't */
>+
>+        source_usec = (pa_usec_t) -1;
>+    }
>+
>+    if (source_usec != (pa_usec_t) -1)
>+        s->configured_source_latency = pa_source_output_set_requested_latency(s->source_output, source_usec);
>+    else
>+        s->configured_source_latency = 0;
>+
>+    if (s->early_requests) {
>+
>+        /* Ok, we didn't necessarily get what we were asking for. We
>+         * might still get the proper fragment interval, we just can't
>+         * guarantee it. */
>+
>+        if (fragsize_usec != s->configured_source_latency)
>+            pa_log_debug("Could not configure a sufficiently low latency. Early requests might not be satisifed.");
>+
>+    } else if (s->adjust_latency) {
>+
>+        /* We keep the client buffer large enough to transfer one
>+         * hardware-buffer-sized chunk at a time to the client. */
>+
>+        fragsize_usec = s->configured_source_latency;
>+    }
>+
>+    if (pa_usec_to_bytes(orig_fragsize_usec, &s->source_output->sample_spec) !=
>+        pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec))
>+
>+        s->buffer_attr.fragsize = (uint32_t) pa_usec_to_bytes(fragsize_usec, &s->source_output->sample_spec);
>+
>+    if (s->buffer_attr.fragsize <= 0)
>+        s->buffer_attr.fragsize = (uint32_t) frame_size;
>+}
>+
>+/* Called from main context */
>+static void fix_record_buffer_attr_post(record_stream *s) {
>+    size_t base;
>+
>+    pa_assert(s);
>+
>+    /* This function will be called from the main thread, before as
>+     * well as after the source output has been activated using
>+     * pa_source_output_put()! That means it may not touch and
>+     * ->thread_info data! */
>+
>+    base = pa_frame_size(&s->source_output->sample_spec);
>+
>+    s->buffer_attr.fragsize = (s->buffer_attr.fragsize/base)*base;
>+    if (s->buffer_attr.fragsize <= 0)
>+        s->buffer_attr.fragsize = base;
>+
>+    if (s->buffer_attr.fragsize > s->buffer_attr.maxlength)
>+        s->buffer_attr.fragsize = s->buffer_attr.maxlength;
>+}
>+
>+/* Called from main context */
>+static record_stream* record_stream_new(
>+        pa_native_connection *c,
>+        pa_source *source,
>+        pa_sample_spec *ss,
>+        pa_channel_map *map,
>+        pa_idxset *formats,
>+        pa_buffer_attr *attr,
>+        pa_cvolume *volume,
>+        bool muted,
>+        bool muted_set,
>+        pa_source_output_flags_t flags,
>+        pa_proplist *p,
>+        bool adjust_latency,
>+        bool early_requests,
>+        bool relative_volume,
>+        bool peak_detect,
>+        pa_sink_input *direct_on_input,
>+        int *ret) {
>+
>+    record_stream *s;
>+    pa_source_output *source_output = NULL;
>+    pa_source_output_new_data data;
>+    char *memblockq_name;
>+
>+    pa_assert(c);
>+    pa_assert(ss);
>+    pa_assert(p);
>+    pa_assert(ret);
>+
>+    pa_source_output_new_data_init(&data);
>+
>+    pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
>+    data.driver = __FILE__;
>+    data.module = c->options->module;
>+    data.client = c->client;
>+    if (source)
>+        pa_source_output_new_data_set_source(&data, source, false);
>+    if (pa_sample_spec_valid(ss))
>+        pa_source_output_new_data_set_sample_spec(&data, ss);
>+    if (pa_channel_map_valid(map))
>+        pa_source_output_new_data_set_channel_map(&data, map);
>+    if (formats)
>+        pa_source_output_new_data_set_formats(&data, formats);
>+    data.direct_on_input = direct_on_input;
>+    if (volume) {
>+        pa_source_output_new_data_set_volume(&data, volume);
>+        data.volume_is_absolute = !relative_volume;
>+        data.save_volume = false;
>+    }
>+    if (muted_set) {
>+        pa_source_output_new_data_set_muted(&data, muted);
>+        data.save_muted = false;
>+    }
>+    if (peak_detect)
>+        data.resample_method = PA_RESAMPLER_PEAKS;
>+    data.flags = flags;
>+
>+    *ret = -pa_source_output_new(&source_output, c->protocol->core, &data);
>+
>+    pa_source_output_new_data_done(&data);
>+
>+    if (!source_output)
>+        return NULL;
>+
>+    s = pa_msgobject_new(record_stream);
>+    s->parent.parent.free = record_stream_free;
>+    s->parent.process_msg = record_stream_process_msg;
>+    s->connection = c;
>+    s->source_output = source_output;
>+    s->buffer_attr_req = *attr;
>+    s->adjust_latency = adjust_latency;
>+    s->early_requests = early_requests;
>+    pa_atomic_store(&s->on_the_fly, 0);
>+
>+    s->source_output->parent.process_msg = source_output_process_msg;
>+    s->source_output->push = source_output_push_cb;
>+    s->source_output->kill = source_output_kill_cb;
>+    s->source_output->get_latency = source_output_get_latency_cb;
>+    s->source_output->moving = source_output_moving_cb;
>+    s->source_output->suspend = source_output_suspend_cb;
>+    s->source_output->send_event = source_output_send_event_cb;
>+    s->source_output->userdata = s;
>+
>+    fix_record_buffer_attr_pre(s);
>+
>+    memblockq_name = pa_sprintf_malloc("native protocol record stream memblockq [%u]", s->source_output->index);
>+    s->memblockq = pa_memblockq_new(
>+            memblockq_name,
>+            0,
>+            s->buffer_attr.maxlength,
>+            0,
>+            &source_output->sample_spec,
>+            1,
>+            0,
>+            0,
>+            NULL);
>+    pa_xfree(memblockq_name);
>+
>+    pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
>+    fix_record_buffer_attr_post(s);
>+
>+    *ss = s->source_output->sample_spec;
>+    *map = s->source_output->channel_map;
>+
>+    pa_idxset_put(c->record_streams, s, &s->index);
>+
>+    pa_log_info("Final latency %0.2f ms = %0.2f ms + %0.2f ms",
>+                ((double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) + (double) s->configured_source_latency) / PA_USEC_PER_MSEC,
>+                (double) pa_bytes_to_usec(s->buffer_attr.fragsize, &source_output->sample_spec) / PA_USEC_PER_MSEC,
>+                (double) s->configured_source_latency / PA_USEC_PER_MSEC);
>+
>+    pa_source_output_put(s->source_output);
>+    return s;
>+}
>+
>+/* Called from main context */
>+static void record_stream_send_killed(record_stream *r) {
>+    pa_tagstruct *t;
>+    record_stream_assert_ref(r);
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_KILLED);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, r->index);
>+    pa_pstream_send_tagstruct(r->connection->pstream, t);
>+}
>+
>+/* Called from main context */
>+static void playback_stream_unlink(playback_stream *s) {
>+    pa_assert(s);
>+
>+    if (!s->connection)
>+        return;
>+
>+    if (s->sink_input) {
>+        pa_sink_input_unlink(s->sink_input);
>+        pa_sink_input_unref(s->sink_input);
>+        s->sink_input = NULL;
>+    }
>+
>+    if (s->drain_request)
>+        pa_pstream_send_error(s->connection->pstream, s->drain_tag, PA_ERR_NOENTITY);
>+
>+    pa_assert_se(pa_idxset_remove_by_data(s->connection->output_streams, s, NULL) == s);
>+    s->connection = NULL;
>+    playback_stream_unref(s);
>+}
>+
>+/* Called from main context */
>+static void playback_stream_free(pa_object* o) {
>+    playback_stream *s = PLAYBACK_STREAM(o);
>+    pa_assert(s);
>+
>+    playback_stream_unlink(s);
>+
>+    pa_memblockq_free(s->memblockq);
>+    pa_xfree(s);
>+}
>+
>+/* Called from main context */
>+static int playback_stream_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
>+    playback_stream *s = PLAYBACK_STREAM(o);
>+    playback_stream_assert_ref(s);
>+
>+    if (!s->connection)
>+        return -1;
>+
>+    switch (code) {
>+
>+        case PLAYBACK_STREAM_MESSAGE_REQUEST_DATA: {
>+            pa_tagstruct *t;
>+            int l = 0;
>+
>+            for (;;) {
>+                if ((l = pa_atomic_load(&s->missing)) <= 0)
>+                    return 0;
>+
>+                if (pa_atomic_cmpxchg(&s->missing, l, 0))
>+                    break;
>+            }
>+
>+            t = pa_tagstruct_new();
>+            pa_tagstruct_putu32(t, PA_COMMAND_REQUEST);
>+            pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+            pa_tagstruct_putu32(t, s->index);
>+            pa_tagstruct_putu32(t, (uint32_t) l);
>+            pa_pstream_send_tagstruct(s->connection->pstream, t);
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+            pa_log("Requesting %lu bytes", (unsigned long) l);
>+#endif
>+            break;
>+        }
>+
>+        case PLAYBACK_STREAM_MESSAGE_UNDERFLOW: {
>+            pa_tagstruct *t;
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+            pa_log("signalling underflow");
>+#endif
>+
>+            /* Report that we're empty */
>+            t = pa_tagstruct_new();
>+            pa_tagstruct_putu32(t, PA_COMMAND_UNDERFLOW);
>+            pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+            pa_tagstruct_putu32(t, s->index);
>+            if (s->connection->version >= 23)
>+                pa_tagstruct_puts64(t, offset);
>+            pa_pstream_send_tagstruct(s->connection->pstream, t);
>+            break;
>+        }
>+
>+        case PLAYBACK_STREAM_MESSAGE_OVERFLOW: {
>+            pa_tagstruct *t;
>+
>+            /* Notify the user we're overflowed*/
>+            t = pa_tagstruct_new();
>+            pa_tagstruct_putu32(t, PA_COMMAND_OVERFLOW);
>+            pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+            pa_tagstruct_putu32(t, s->index);
>+            pa_pstream_send_tagstruct(s->connection->pstream, t);
>+            break;
>+        }
>+
>+        case PLAYBACK_STREAM_MESSAGE_STARTED:
>+
>+            if (s->connection->version >= 13) {
>+                pa_tagstruct *t;
>+
>+                /* Notify the user we started playback */
>+                t = pa_tagstruct_new();
>+                pa_tagstruct_putu32(t, PA_COMMAND_STARTED);
>+                pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+                pa_tagstruct_putu32(t, s->index);
>+                pa_pstream_send_tagstruct(s->connection->pstream, t);
>+            }
>+
>+            break;
>+
>+        case PLAYBACK_STREAM_MESSAGE_DRAIN_ACK:
>+            pa_pstream_send_simple_ack(s->connection->pstream, PA_PTR_TO_UINT(userdata));
>+            break;
>+
>+        case PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH:
>+
>+            s->buffer_attr.tlength = (uint32_t) offset;
>+
>+            if (s->connection->version >= 15) {
>+                pa_tagstruct *t;
>+
>+                t = pa_tagstruct_new();
>+                pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_BUFFER_ATTR_CHANGED);
>+                pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+                pa_tagstruct_putu32(t, s->index);
>+                pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
>+                pa_tagstruct_putu32(t, s->buffer_attr.tlength);
>+                pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
>+                pa_tagstruct_putu32(t, s->buffer_attr.minreq);
>+                pa_tagstruct_put_usec(t, s->configured_sink_latency);
>+                pa_pstream_send_tagstruct(s->connection->pstream, t);
>+            }
>+
>+            break;
>+    }
>+
>+    return 0;
>+}
>+
>+/* Called from main context */
>+static void fix_playback_buffer_attr(playback_stream *s) {
>+    size_t frame_size, max_prebuf;
>+    pa_usec_t orig_tlength_usec, tlength_usec, orig_minreq_usec, minreq_usec, sink_usec;
>+
>+    pa_assert(s);
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("Client requested: maxlength=%li bytes tlength=%li bytes minreq=%li bytes prebuf=%li bytes",
>+           (long) s->buffer_attr_req.maxlength,
>+           (long) s->buffer_attr_req.tlength,
>+           (long) s->buffer_attr_req.minreq,
>+           (long) s->buffer_attr_req.prebuf);
>+
>+    pa_log("Client requested: maxlength=%lu ms tlength=%lu ms minreq=%lu ms prebuf=%lu ms",
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr_req.maxlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr_req.tlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr_req.minreq, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr_req.prebuf, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC));
>+#endif
>+
>+    /* This function will be called from the main thread, before as
>+     * well as after the sink input has been activated using
>+     * pa_sink_input_put()! That means it may not touch any
>+     * ->thread_info data, such as the memblockq! */
>+
>+    frame_size = pa_frame_size(&s->sink_input->sample_spec);
>+    s->buffer_attr = s->buffer_attr_req;
>+
>+    if (s->buffer_attr.maxlength == (uint32_t) -1 || s->buffer_attr.maxlength > MAX_MEMBLOCKQ_LENGTH)
>+        s->buffer_attr.maxlength = MAX_MEMBLOCKQ_LENGTH;
>+    if (s->buffer_attr.maxlength <= 0)
>+        s->buffer_attr.maxlength = (uint32_t) frame_size;
>+
>+    if (s->buffer_attr.tlength == (uint32_t) -1)
>+        s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_TLENGTH_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
>+    if (s->buffer_attr.tlength <= 0)
>+        s->buffer_attr.tlength = (uint32_t) frame_size;
>+    if (s->buffer_attr.tlength > s->buffer_attr.maxlength)
>+        s->buffer_attr.tlength = s->buffer_attr.maxlength;
>+
>+    if (s->buffer_attr.minreq == (uint32_t) -1) {
>+        uint32_t process = (uint32_t) pa_usec_to_bytes_round_up(DEFAULT_PROCESS_MSEC*PA_USEC_PER_MSEC, &s->sink_input->sample_spec);
>+        /* With low-latency, tlength/4 gives a decent default in all of traditional, adjust latency and early request modes. */
>+        uint32_t m = s->buffer_attr.tlength / 4;
>+        if (frame_size)
>+            m -= m % frame_size;
>+        s->buffer_attr.minreq = PA_MIN(process, m);
>+    }
>+    if (s->buffer_attr.minreq <= 0)
>+        s->buffer_attr.minreq = (uint32_t) frame_size;
>+
>+    if (s->buffer_attr.tlength < s->buffer_attr.minreq+frame_size)
>+        s->buffer_attr.tlength = s->buffer_attr.minreq+(uint32_t) frame_size;
>+
>+    orig_tlength_usec = tlength_usec = pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec);
>+    orig_minreq_usec = minreq_usec = pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec);
>+
>+    pa_log_info("Requested tlength=%0.2f ms, minreq=%0.2f ms",
>+                (double) tlength_usec / PA_USEC_PER_MSEC,
>+                (double) minreq_usec / PA_USEC_PER_MSEC);
>+
>+    if (s->early_requests) {
>+
>+        /* In early request mode we need to emulate the classic
>+         * fragment-based playback model. Unfortunately we have no
>+         * mechanism to tell the sink how often we want to be queried
>+         * for data. The next best thing we can do is to set the sink's
>+         * total buffer (i.e. its latency) to the fragment size. That
>+         * way it will have to query us at least that often. */
>+
>+        sink_usec = minreq_usec;
>+        pa_log_debug("Early requests mode enabled, configuring sink latency to minreq.");
>+
>+    } else if (s->adjust_latency) {
>+
>+        /* So, the user asked us to adjust the latency of the stream
>+         * buffer according to the what the sink can provide. The
>+         * tlength passed in shall be the overall latency. Roughly
>+         * half the latency will be spent on the hw buffer, the other
>+         * half of it in the async buffer queue we maintain for each
>+         * client. In between we'll have a safety space of size
>+         * 2*minreq. Why the 2*minreq? When the hw buffer is completely
>+         * empty and needs to be filled, then our buffer must have
>+         * enough data to fulfill this request immediately and thus
>+         * have at least the same tlength as the size of the hw
>+         * buffer. It additionally needs space for 2 times minreq
>+         * because if the buffer ran empty and a partial fillup
>+         * happens immediately on the next iteration we need to be
>+         * able to fulfill it and give the application also minreq
>+         * time to fill it up again for the next request Makes 2 times
>+         * minreq in plus.. */
>+
>+        if (tlength_usec > minreq_usec*2)
>+            sink_usec = (tlength_usec - minreq_usec*2)/2;
>+        else
>+            sink_usec = 0;
>+
>+        pa_log_debug("Adjust latency mode enabled, configuring sink latency to half of overall latency.");
>+
>+    } else {
>+
>+        /* Ok, the user didn't ask us to adjust the latency, but we
>+         * still need to make sure that the parameters from the user
>+         * do make sense. */
>+
>+        if (tlength_usec > minreq_usec*2)
>+            sink_usec = (tlength_usec - minreq_usec*2);
>+        else
>+            sink_usec = 0;
>+
>+        pa_log_debug("Traditional mode enabled, modifying sink usec only for compat with minreq.");
>+    }
>+
>+    s->configured_sink_latency = pa_sink_input_set_requested_latency(s->sink_input, sink_usec);
>+
>+    if (s->early_requests) {
>+
>+        /* Ok, we didn't necessarily get what we were asking for. We
>+         * might still get the proper fragment interval, we just can't
>+         * guarantee it. */
>+
>+        if (minreq_usec != s->configured_sink_latency)
>+            pa_log_debug("Could not configure a sufficiently low latency. Early requests might not be satisifed.");
>+
>+    } else if (s->adjust_latency) {
>+
>+        /* Ok, we didn't necessarily get what we were asking for, so
>+         * let's subtract from what we asked for for the remaining
>+         * buffer space */
>+
>+        if (tlength_usec >= s->configured_sink_latency)
>+            tlength_usec -= s->configured_sink_latency;
>+    }
>+
>+    pa_log_debug("Requested latency=%0.2f ms, Received latency=%0.2f ms",
>+                 (double) sink_usec / PA_USEC_PER_MSEC,
>+                 (double) s->configured_sink_latency / PA_USEC_PER_MSEC);
>+
>+    /* FIXME: This is actually larger than necessary, since not all of
>+     * the sink latency is actually rewritable. */
>+    if (tlength_usec < s->configured_sink_latency + 2*minreq_usec)
>+        tlength_usec = s->configured_sink_latency + 2*minreq_usec;
>+
>+    if (pa_usec_to_bytes_round_up(orig_tlength_usec, &s->sink_input->sample_spec) !=
>+        pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec))
>+        s->buffer_attr.tlength = (uint32_t) pa_usec_to_bytes_round_up(tlength_usec, &s->sink_input->sample_spec);
>+
>+    if (pa_usec_to_bytes(orig_minreq_usec, &s->sink_input->sample_spec) !=
>+        pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec))
>+        s->buffer_attr.minreq = (uint32_t) pa_usec_to_bytes(minreq_usec, &s->sink_input->sample_spec);
>+
>+    if (s->buffer_attr.minreq <= 0) {
>+        s->buffer_attr.minreq = (uint32_t) frame_size;
>+        s->buffer_attr.tlength += (uint32_t) frame_size*2;
>+    }
>+
>+    if (s->buffer_attr.tlength <= s->buffer_attr.minreq)
>+        s->buffer_attr.tlength = s->buffer_attr.minreq*2 + (uint32_t) frame_size;
>+
>+    max_prebuf = s->buffer_attr.tlength + (uint32_t)frame_size - s->buffer_attr.minreq;
>+
>+    if (s->buffer_attr.prebuf == (uint32_t) -1 ||
>+        s->buffer_attr.prebuf > max_prebuf)
>+        s->buffer_attr.prebuf = max_prebuf;
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("Client accepted: maxlength=%lu ms tlength=%lu ms minreq=%lu ms prebuf=%lu ms",
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr.maxlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr.tlength, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr.minreq, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC),
>+           (unsigned long) (pa_bytes_to_usec(s->buffer_attr.prebuf, &s->sink_input->sample_spec) / PA_USEC_PER_MSEC));
>+#endif
>+}
>+
>+/* Called from main context */
>+static playback_stream* playback_stream_new(
>+        pa_native_connection *c,
>+        pa_sink *sink,
>+        pa_sample_spec *ss,
>+        pa_channel_map *map,
>+        pa_idxset *formats,
>+        pa_buffer_attr *a,
>+        pa_cvolume *volume,
>+        bool muted,
>+        bool muted_set,
>+        pa_sink_input_flags_t flags,
>+        pa_proplist *p,
>+        bool adjust_latency,
>+        bool early_requests,
>+        bool relative_volume,
>+        uint32_t syncid,
>+        uint32_t *missing,
>+        int *ret) {
>+
>+    /* Note: This function takes ownership of the 'formats' param, so we need
>+     * to take extra care to not leak it */
>+
>+    playback_stream *ssync;
>+    playback_stream *s = NULL;
>+    pa_sink_input *sink_input = NULL;
>+    pa_memchunk silence;
>+    uint32_t idx;
>+    int64_t start_index;
>+    pa_sink_input_new_data data;
>+    char *memblockq_name;
>+
>+    pa_assert(c);
>+    pa_assert(ss);
>+    pa_assert(missing);
>+    pa_assert(p);
>+    pa_assert(ret);
>+
>+    /* Find syncid group */
>+    PA_IDXSET_FOREACH(ssync, c->output_streams, idx) {
>+
>+        if (!playback_stream_isinstance(ssync))
>+            continue;
>+
>+        if (ssync->syncid == syncid)
>+            break;
>+    }
>+
>+    /* Synced streams must connect to the same sink */
>+    if (ssync) {
>+
>+        if (!sink)
>+            sink = ssync->sink_input->sink;
>+        else if (sink != ssync->sink_input->sink) {
>+            *ret = PA_ERR_INVALID;
>+            goto out;
>+        }
>+    }
>+
>+    pa_sink_input_new_data_init(&data);
>+
>+    pa_proplist_update(data.proplist, PA_UPDATE_REPLACE, p);
>+    data.driver = __FILE__;
>+    data.module = c->options->module;
>+    data.client = c->client;
>+    if (sink)
>+        pa_sink_input_new_data_set_sink(&data, sink, false);
>+    if (pa_sample_spec_valid(ss))
>+        pa_sink_input_new_data_set_sample_spec(&data, ss);
>+    if (pa_channel_map_valid(map))
>+        pa_sink_input_new_data_set_channel_map(&data, map);
>+    if (formats) {
>+        pa_sink_input_new_data_set_formats(&data, formats);
>+        /* Ownership transferred to new_data, so we don't free it ourselves */
>+        formats = NULL;
>+    }
>+    if (volume) {
>+        pa_sink_input_new_data_set_volume(&data, volume);
>+        data.volume_is_absolute = !relative_volume;
>+        data.save_volume = false;
>+    }
>+    if (muted_set) {
>+        pa_sink_input_new_data_set_muted(&data, muted);
>+        data.save_muted = false;
>+    }
>+    data.sync_base = ssync ? ssync->sink_input : NULL;
>+    data.flags = flags;
>+
>+    *ret = -pa_sink_input_new(&sink_input, c->protocol->core, &data);
>+
>+    pa_sink_input_new_data_done(&data);
>+
>+    if (!sink_input)
>+        goto out;
>+
>+    s = pa_msgobject_new(playback_stream);
>+    s->parent.parent.parent.free = playback_stream_free;
>+    s->parent.parent.process_msg = playback_stream_process_msg;
>+    s->connection = c;
>+    s->syncid = syncid;
>+    s->sink_input = sink_input;
>+    s->is_underrun = true;
>+    s->drain_request = false;
>+    pa_atomic_store(&s->missing, 0);
>+    s->buffer_attr_req = *a;
>+    s->adjust_latency = adjust_latency;
>+    s->early_requests = early_requests;
>+    pa_atomic_store(&s->seek_or_post_in_queue, 0);
>+    s->seek_windex = -1;
>+
>+    s->sink_input->parent.process_msg = sink_input_process_msg;
>+    s->sink_input->pop = sink_input_pop_cb;
>+    s->sink_input->process_underrun = sink_input_process_underrun_cb;
>+    s->sink_input->process_rewind = sink_input_process_rewind_cb;
>+    s->sink_input->update_max_rewind = sink_input_update_max_rewind_cb;
>+    s->sink_input->update_max_request = sink_input_update_max_request_cb;
>+    s->sink_input->kill = sink_input_kill_cb;
>+    s->sink_input->moving = sink_input_moving_cb;
>+    s->sink_input->suspend = sink_input_suspend_cb;
>+    s->sink_input->send_event = sink_input_send_event_cb;
>+    s->sink_input->userdata = s;
>+
>+    start_index = ssync ? pa_memblockq_get_read_index(ssync->memblockq) : 0;
>+
>+    fix_playback_buffer_attr(s);
>+
>+    pa_sink_input_get_silence(sink_input, &silence);
>+    memblockq_name = pa_sprintf_malloc("native protocol playback stream memblockq [%u]", s->sink_input->index);
>+    s->memblockq = pa_memblockq_new(
>+            memblockq_name,
>+            start_index,
>+            s->buffer_attr.maxlength,
>+            s->buffer_attr.tlength,
>+            &sink_input->sample_spec,
>+            s->buffer_attr.prebuf,
>+            s->buffer_attr.minreq,
>+            0,
>+            &silence);
>+    pa_xfree(memblockq_name);
>+    pa_memblock_unref(silence.memblock);
>+
>+    pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
>+
>+    *missing = (uint32_t) pa_memblockq_pop_missing(s->memblockq);
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("missing original: %li", (long int) *missing);
>+#endif
>+
>+    *ss = s->sink_input->sample_spec;
>+    *map = s->sink_input->channel_map;
>+
>+    pa_idxset_put(c->output_streams, s, &s->index);
>+
>+    pa_log_info("Final latency %0.2f ms = %0.2f ms + 2*%0.2f ms + %0.2f ms",
>+                ((double) pa_bytes_to_usec(s->buffer_attr.tlength, &sink_input->sample_spec) + (double) s->configured_sink_latency) / PA_USEC_PER_MSEC,
>+                (double) pa_bytes_to_usec(s->buffer_attr.tlength-s->buffer_attr.minreq*2, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
>+                (double) pa_bytes_to_usec(s->buffer_attr.minreq, &sink_input->sample_spec) / PA_USEC_PER_MSEC,
>+                (double) s->configured_sink_latency / PA_USEC_PER_MSEC);
>+
>+    pa_sink_input_put(s->sink_input);
>+
>+out:
>+    if (formats)
>+        pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
>+
>+    return s;
>+}
>+
>+/* Called from IO context */
>+static void playback_stream_request_bytes(playback_stream *s) {
>+    size_t m, minreq;
>+    int previous_missing;
>+
>+    playback_stream_assert_ref(s);
>+
>+    m = pa_memblockq_pop_missing(s->memblockq);
>+
>+    /* pa_log("request_bytes(%lu) (tlength=%lu minreq=%lu length=%lu really missing=%lli)", */
>+    /*        (unsigned long) m, */
>+    /*        pa_memblockq_get_tlength(s->memblockq), */
>+    /*        pa_memblockq_get_minreq(s->memblockq), */
>+    /*        pa_memblockq_get_length(s->memblockq), */
>+    /*        (long long) pa_memblockq_get_tlength(s->memblockq) - (long long) pa_memblockq_get_length(s->memblockq)); */
>+
>+    if (m <= 0)
>+        return;
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("request_bytes(%lu)", (unsigned long) m);
>+#endif
>+
>+    previous_missing = pa_atomic_add(&s->missing, (int) m);
>+    minreq = pa_memblockq_get_minreq(s->memblockq);
>+
>+    if (pa_memblockq_prebuf_active(s->memblockq) ||
>+        (previous_missing < (int) minreq && previous_missing + (int) m >= (int) minreq))
>+        pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_REQUEST_DATA, NULL, 0, NULL, NULL);
>+}
>+
>+/* Called from main context */
>+static void playback_stream_send_killed(playback_stream *p) {
>+    pa_tagstruct *t;
>+    playback_stream_assert_ref(p);
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_KILLED);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, p->index);
>+    pa_pstream_send_tagstruct(p->connection->pstream, t);
>+}
>+
>+/* Called from main context */
>+static int native_connection_process_msg(pa_msgobject *o, int code, void*userdata, int64_t offset, pa_memchunk *chunk) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(o);
>+    pa_native_connection_assert_ref(c);
>+
>+    if (!c->protocol)
>+        return -1;
>+
>+    switch (code) {
>+
>+        case CONNECTION_MESSAGE_REVOKE:
>+            pa_pstream_send_revoke(c->pstream, PA_PTR_TO_UINT(userdata));
>+            break;
>+
>+        case CONNECTION_MESSAGE_RELEASE:
>+            pa_pstream_send_release(c->pstream, PA_PTR_TO_UINT(userdata));
>+            break;
>+    }
>+
>+    return 0;
>+}
>+
>+/* Called from main context */
>+static void native_connection_unlink(pa_native_connection *c) {
>+    record_stream *r;
>+    output_stream *o;
>+
>+    pa_assert(c);
>+
>+    if (!c->protocol)
>+        return;
>+
>+    pa_hook_fire(&c->protocol->hooks[PA_NATIVE_HOOK_CONNECTION_UNLINK], c);
>+
>+    if (c->options)
>+        pa_native_options_unref(c->options);
>+
>+    if (c->srbpending)
>+        pa_srbchannel_free(c->srbpending);
>+
>+    while ((r = pa_idxset_first(c->record_streams, NULL)))
>+        record_stream_unlink(r);
>+
>+    while ((o = pa_idxset_first(c->output_streams, NULL)))
>+        if (playback_stream_isinstance(o))
>+            playback_stream_unlink(PLAYBACK_STREAM(o));
>+        else
>+            upload_stream_unlink(UPLOAD_STREAM(o));
>+
>+    if (c->subscription)
>+        pa_subscription_free(c->subscription);
>+
>+    if (c->pstream)
>+        pa_pstream_unlink(c->pstream);
>+
>+    if (c->auth_timeout_event) {
>+        c->protocol->core->mainloop->time_free(c->auth_timeout_event);
>+        c->auth_timeout_event = NULL;
>+    }
>+
>+    pa_assert_se(pa_idxset_remove_by_data(c->protocol->connections, c, NULL) == c);
>+    c->protocol = NULL;
>+    pa_native_connection_unref(c);
>+}
>+
>+/* Called from main context */
>+static void native_connection_free(pa_object *o) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(o);
>+
>+    pa_assert(c);
>+
>+    native_connection_unlink(c);
>+
>+    pa_idxset_free(c->record_streams, NULL);
>+    pa_idxset_free(c->output_streams, NULL);
>+
>+    pa_pdispatch_unref(c->pdispatch);
>+    pa_pstream_unref(c->pstream);
>+    pa_client_free(c->client);
>+
>+    pa_xfree(c);
>+}
>+
>+/* Called from main context */
>+static void native_connection_send_memblock(pa_native_connection *c) {
>+    uint32_t start;
>+    record_stream *r;
>+
>+    start = PA_IDXSET_INVALID;
>+    for (;;) {
>+        pa_memchunk chunk;
>+
>+        if (!(r = RECORD_STREAM(pa_idxset_rrobin(c->record_streams, &c->rrobin_index))))
>+            return;
>+
>+        if (start == PA_IDXSET_INVALID)
>+            start = c->rrobin_index;
>+        else if (start == c->rrobin_index)
>+            return;
>+
>+        if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) {
>+            pa_memchunk schunk = chunk;
>+
>+            if (schunk.length > r->buffer_attr.fragsize)
>+                schunk.length = r->buffer_attr.fragsize;
>+
>+            pa_pstream_send_memblock(c->pstream, r->index, 0, PA_SEEK_RELATIVE, &schunk);
>+
>+            pa_memblockq_drop(r->memblockq, schunk.length);
>+            pa_memblock_unref(schunk.memblock);
>+
>+            return;
>+        }
>+    }
>+}
>+
>+/*** sink input callbacks ***/
>+
>+/* Called from thread context */
>+static void handle_seek(playback_stream *s, int64_t indexw) {
>+    playback_stream_assert_ref(s);
>+
>+/*     pa_log("handle_seek: %llu -- %i", (unsigned long long) s->sink_input->thread_info.underrun_for, pa_memblockq_is_readable(s->memblockq)); */
>+
>+    if (s->sink_input->thread_info.underrun_for > 0) {
>+
>+/*         pa_log("%lu vs. %lu", (unsigned long) pa_memblockq_get_length(s->memblockq), (unsigned long) pa_memblockq_get_prebuf(s->memblockq)); */
>+
>+        if (pa_memblockq_is_readable(s->memblockq)) {
>+
>+            /* We just ended an underrun, let's ask the sink
>+             * for a complete rewind rewrite */
>+
>+            pa_log_debug("Requesting rewind due to end of underrun.");
>+            pa_sink_input_request_rewind(s->sink_input,
>+                                         (size_t) (s->sink_input->thread_info.underrun_for == (uint64_t) -1 ? 0 :
>+                                                   s->sink_input->thread_info.underrun_for),
>+                                         false, true, false);
>+        }
>+
>+    } else {
>+        int64_t indexr;
>+
>+        indexr = pa_memblockq_get_read_index(s->memblockq);
>+
>+        if (indexw < indexr) {
>+            /* OK, the sink already asked for this data, so
>+             * let's have it ask us again */
>+
>+            pa_log_debug("Requesting rewind due to rewrite.");
>+            pa_sink_input_request_rewind(s->sink_input, (size_t) (indexr - indexw), true, false, false);
>+        }
>+    }
>+
>+    playback_stream_request_bytes(s);
>+}
>+
>+static void flush_write_no_account(pa_memblockq *q) {
>+    pa_memblockq_flush_write(q, false);
>+}
>+
>+/* Called from thread context */
>+static int sink_input_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
>+    pa_sink_input *i = PA_SINK_INPUT(o);
>+    playback_stream *s;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    switch (code) {
>+
>+        case SINK_INPUT_MESSAGE_SEEK:
>+        case SINK_INPUT_MESSAGE_POST_DATA: {
>+            int64_t windex = pa_memblockq_get_write_index(s->memblockq);
>+
>+            if (code == SINK_INPUT_MESSAGE_SEEK) {
>+                /* The client side is incapable of accounting correctly
>+                 * for seeks of a type != PA_SEEK_RELATIVE. We need to be
>+                 * able to deal with that. */
>+
>+                pa_memblockq_seek(s->memblockq, offset, PA_PTR_TO_UINT(userdata), PA_PTR_TO_UINT(userdata) == PA_SEEK_RELATIVE);
>+                windex = PA_MIN(windex, pa_memblockq_get_write_index(s->memblockq));
>+            }
>+
>+            if (chunk && pa_memblockq_push_align(s->memblockq, chunk) < 0) {
>+                if (pa_log_ratelimit(PA_LOG_WARN))
>+                    pa_log_warn("Failed to push data into queue");
>+                pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_OVERFLOW, NULL, 0, NULL, NULL);
>+                pa_memblockq_seek(s->memblockq, (int64_t) chunk->length, PA_SEEK_RELATIVE, true);
>+            }
>+
>+            /* If more data is in queue, we rewind later instead. */
>+            if (s->seek_windex != -1)
>+                windex = PA_MIN(windex, s->seek_windex);
>+            if (pa_atomic_dec(&s->seek_or_post_in_queue) > 1)
>+                s->seek_windex = windex;
>+            else {
>+                s->seek_windex = -1;
>+                handle_seek(s, windex);
>+            }
>+            return 0;
>+        }
>+
>+        case SINK_INPUT_MESSAGE_DRAIN:
>+        case SINK_INPUT_MESSAGE_FLUSH:
>+        case SINK_INPUT_MESSAGE_PREBUF_FORCE:
>+        case SINK_INPUT_MESSAGE_TRIGGER: {
>+
>+            int64_t windex;
>+            pa_sink_input *isync;
>+            void (*func)(pa_memblockq *bq);
>+
>+            switch (code) {
>+                case SINK_INPUT_MESSAGE_FLUSH:
>+                    func = flush_write_no_account;
>+                    break;
>+
>+                case SINK_INPUT_MESSAGE_PREBUF_FORCE:
>+                    func = pa_memblockq_prebuf_force;
>+                    break;
>+
>+                case SINK_INPUT_MESSAGE_DRAIN:
>+                case SINK_INPUT_MESSAGE_TRIGGER:
>+                    func = pa_memblockq_prebuf_disable;
>+                    break;
>+
>+                default:
>+                    pa_assert_not_reached();
>+            }
>+
>+            windex = pa_memblockq_get_write_index(s->memblockq);
>+            func(s->memblockq);
>+            handle_seek(s, windex);
>+
>+            /* Do the same for all other members in the sync group */
>+            for (isync = i->sync_prev; isync; isync = isync->sync_prev) {
>+                playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
>+                windex = pa_memblockq_get_write_index(ssync->memblockq);
>+                func(ssync->memblockq);
>+                handle_seek(ssync, windex);
>+            }
>+
>+            for (isync = i->sync_next; isync; isync = isync->sync_next) {
>+                playback_stream *ssync = PLAYBACK_STREAM(isync->userdata);
>+                windex = pa_memblockq_get_write_index(ssync->memblockq);
>+                func(ssync->memblockq);
>+                handle_seek(ssync, windex);
>+            }
>+
>+            if (code == SINK_INPUT_MESSAGE_DRAIN) {
>+                if (!pa_memblockq_is_readable(s->memblockq))
>+                    pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, userdata, 0, NULL, NULL);
>+                else {
>+                    s->drain_tag = PA_PTR_TO_UINT(userdata);
>+                    s->drain_request = true;
>+                }
>+            }
>+
>+            return 0;
>+        }
>+
>+        case SINK_INPUT_MESSAGE_UPDATE_LATENCY:
>+            /* Atomically get a snapshot of all timing parameters... */
>+            s->read_index = pa_memblockq_get_read_index(s->memblockq);
>+            s->write_index = pa_memblockq_get_write_index(s->memblockq);
>+            s->render_memblockq_length = pa_memblockq_get_length(s->sink_input->thread_info.render_memblockq);
>+            s->current_sink_latency = pa_sink_get_latency_within_thread(s->sink_input->sink);
>+            s->underrun_for = s->sink_input->thread_info.underrun_for;
>+            s->playing_for = s->sink_input->thread_info.playing_for;
>+
>+            return 0;
>+
>+        case PA_SINK_INPUT_MESSAGE_SET_STATE: {
>+            int64_t windex;
>+
>+            windex = pa_memblockq_get_write_index(s->memblockq);
>+
>+            /* We enable prebuffering so that after CORKED -> RUNNING
>+             * transitions we don't have trouble with underruns in case the
>+             * buffer has too little data. This must not be done when draining
>+             * has been requested, however, otherwise the buffered audio would
>+             * never play. */
>+            if (!s->drain_request)
>+                pa_memblockq_prebuf_force(s->memblockq);
>+
>+            handle_seek(s, windex);
>+
>+            /* Fall through to the default handler */
>+            break;
>+        }
>+
>+        case PA_SINK_INPUT_MESSAGE_GET_LATENCY: {
>+            pa_usec_t *r = userdata;
>+
>+            *r = pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &i->sample_spec);
>+
>+            /* Fall through, the default handler will add in the extra
>+             * latency added by the resampler */
>+            break;
>+        }
>+
>+        case SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR: {
>+            pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
>+            pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
>+            return 0;
>+        }
>+    }
>+
>+    return pa_sink_input_process_msg(o, code, userdata, offset, chunk);
>+}
>+
>+static bool handle_input_underrun(playback_stream *s, bool force) {
>+    bool send_drain;
>+
>+    if (pa_memblockq_is_readable(s->memblockq))
>+        return false;
>+
>+    if (!s->is_underrun)
>+        pa_log_debug("%s %s of '%s'", force ? "Actual" : "Implicit",
>+            s->drain_request ? "drain" : "underrun", pa_strnull(pa_proplist_gets(s->sink_input->proplist, PA_PROP_MEDIA_NAME)));
>+
>+    send_drain = s->drain_request && (force || pa_sink_input_safe_to_remove(s->sink_input));
>+
>+    if (send_drain) {
>+         s->drain_request = false;
>+         pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_DRAIN_ACK, PA_UINT_TO_PTR(s->drain_tag), 0, NULL, NULL);
>+         pa_log_debug("Drain acknowledged of '%s'", pa_strnull(pa_proplist_gets(s->sink_input->proplist, PA_PROP_MEDIA_NAME)));
>+    } else if (!s->is_underrun) {
>+         pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UNDERFLOW, NULL, pa_memblockq_get_read_index(s->memblockq), NULL, NULL);
>+    }
>+    s->is_underrun = true;
>+    playback_stream_request_bytes(s);
>+    return true;
>+}
>+
>+/* Called from thread context */
>+static bool sink_input_process_underrun_cb(pa_sink_input *i) {
>+    playback_stream *s;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    return handle_input_underrun(s, true);
>+}
>+
>+/* Called from thread context */
>+static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk) {
>+    playback_stream *s;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+    pa_assert(chunk);
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("%s, pop(): %lu", pa_proplist_gets(i->proplist, PA_PROP_MEDIA_NAME), (unsigned long) pa_memblockq_get_length(s->memblockq));
>+#endif
>+
>+    if (!handle_input_underrun(s, false))
>+        s->is_underrun = false;
>+
>+    /* This call will not fail with prebuf=0, hence we check for
>+       underrun explicitly in handle_input_underrun */
>+    if (pa_memblockq_peek(s->memblockq, chunk) < 0)
>+        return -1;
>+
>+    chunk->length = PA_MIN(nbytes, chunk->length);
>+
>+    if (i->thread_info.underrun_for > 0)
>+        pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_STARTED, NULL, 0, NULL, NULL);
>+
>+    pa_memblockq_drop(s->memblockq, chunk->length);
>+    playback_stream_request_bytes(s);
>+
>+    return 0;
>+}
>+
>+/* Called from thread context */
>+static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
>+    playback_stream *s;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    /* If we are in an underrun, then we don't rewind */
>+    if (i->thread_info.underrun_for > 0)
>+        return;
>+
>+    pa_memblockq_rewind(s->memblockq, nbytes);
>+}
>+
>+/* Called from thread context */
>+static void sink_input_update_max_rewind_cb(pa_sink_input *i, size_t nbytes) {
>+    playback_stream *s;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    pa_memblockq_set_maxrewind(s->memblockq, nbytes);
>+}
>+
>+/* Called from thread context */
>+static void sink_input_update_max_request_cb(pa_sink_input *i, size_t nbytes) {
>+    playback_stream *s;
>+    size_t new_tlength, old_tlength;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    old_tlength = pa_memblockq_get_tlength(s->memblockq);
>+    new_tlength = nbytes+2*pa_memblockq_get_minreq(s->memblockq);
>+
>+    if (old_tlength < new_tlength) {
>+        pa_log_debug("max_request changed, trying to update from %zu to %zu.", old_tlength, new_tlength);
>+        pa_memblockq_set_tlength(s->memblockq, new_tlength);
>+        new_tlength = pa_memblockq_get_tlength(s->memblockq);
>+
>+        if (new_tlength == old_tlength)
>+            pa_log_debug("Failed to increase tlength");
>+        else {
>+            pa_log_debug("Notifying client about increased tlength");
>+            pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), PLAYBACK_STREAM_MESSAGE_UPDATE_TLENGTH, NULL, pa_memblockq_get_tlength(s->memblockq), NULL, NULL);
>+        }
>+    }
>+}
>+
>+/* Called from main context */
>+static void sink_input_kill_cb(pa_sink_input *i) {
>+    playback_stream *s;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    playback_stream_send_killed(s);
>+    playback_stream_unlink(s);
>+}
>+
>+/* Called from main context */
>+static void sink_input_send_event_cb(pa_sink_input *i, const char *event, pa_proplist *pl) {
>+    playback_stream *s;
>+    pa_tagstruct *t;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    if (s->connection->version < 15)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_EVENT);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_puts(t, event);
>+    pa_tagstruct_put_proplist(t, pl);
>+    pa_pstream_send_tagstruct(s->connection->pstream, t);
>+}
>+
>+/* Called from main context */
>+static void sink_input_suspend_cb(pa_sink_input *i, bool suspend) {
>+    playback_stream *s;
>+    pa_tagstruct *t;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    if (s->connection->version < 12)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_SUSPENDED);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_put_boolean(t, suspend);
>+    pa_pstream_send_tagstruct(s->connection->pstream, t);
>+}
>+
>+/* Called from main context */
>+static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
>+    playback_stream *s;
>+    pa_tagstruct *t;
>+
>+    pa_sink_input_assert_ref(i);
>+    s = PLAYBACK_STREAM(i->userdata);
>+    playback_stream_assert_ref(s);
>+
>+    if (!dest)
>+        return;
>+
>+    fix_playback_buffer_attr(s);
>+    pa_memblockq_apply_attr(s->memblockq, &s->buffer_attr);
>+    pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
>+
>+    if (s->connection->version < 12)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_PLAYBACK_STREAM_MOVED);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_putu32(t, dest->index);
>+    pa_tagstruct_puts(t, dest->name);
>+    pa_tagstruct_put_boolean(t, pa_sink_get_state(dest) == PA_SINK_SUSPENDED);
>+
>+    if (s->connection->version >= 13) {
>+        pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
>+        pa_tagstruct_putu32(t, s->buffer_attr.tlength);
>+        pa_tagstruct_putu32(t, s->buffer_attr.prebuf);
>+        pa_tagstruct_putu32(t, s->buffer_attr.minreq);
>+        pa_tagstruct_put_usec(t, s->configured_sink_latency);
>+    }
>+
>+    pa_pstream_send_tagstruct(s->connection->pstream, t);
>+}
>+
>+/*** source_output callbacks ***/
>+
>+/* Called from thread context */
>+static int source_output_process_msg(pa_msgobject *_o, int code, void *userdata, int64_t offset, pa_memchunk *chunk) {
>+    pa_source_output *o = PA_SOURCE_OUTPUT(_o);
>+    record_stream *s;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+
>+    switch (code) {
>+        case SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY:
>+            /* Atomically get a snapshot of all timing parameters... */
>+            s->current_monitor_latency = o->source->monitor_of ? pa_sink_get_latency_within_thread(o->source->monitor_of) : 0;
>+            s->current_source_latency = pa_source_get_latency_within_thread(o->source);
>+            s->on_the_fly_snapshot = pa_atomic_load(&s->on_the_fly);
>+            return 0;
>+    }
>+
>+    return pa_source_output_process_msg(_o, code, userdata, offset, chunk);
>+}
>+
>+/* Called from thread context */
>+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
>+    record_stream *s;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+    pa_assert(chunk);
>+
>+    pa_atomic_add(&s->on_the_fly, chunk->length);
>+    pa_asyncmsgq_post(pa_thread_mq_get()->outq, PA_MSGOBJECT(s), RECORD_STREAM_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
>+}
>+
>+static void source_output_kill_cb(pa_source_output *o) {
>+    record_stream *s;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+
>+    record_stream_send_killed(s);
>+    record_stream_unlink(s);
>+}
>+
>+static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
>+    record_stream *s;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+
>+    /*pa_log("get_latency: %u", pa_memblockq_get_length(s->memblockq));*/
>+
>+    return pa_bytes_to_usec(pa_memblockq_get_length(s->memblockq), &o->sample_spec);
>+}
>+
>+/* Called from main context */
>+static void source_output_send_event_cb(pa_source_output *o, const char *event, pa_proplist *pl) {
>+    record_stream *s;
>+    pa_tagstruct *t;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+
>+    if (s->connection->version < 15)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_EVENT);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_puts(t, event);
>+    pa_tagstruct_put_proplist(t, pl);
>+    pa_pstream_send_tagstruct(s->connection->pstream, t);
>+}
>+
>+/* Called from main context */
>+static void source_output_suspend_cb(pa_source_output *o, bool suspend) {
>+    record_stream *s;
>+    pa_tagstruct *t;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+
>+    if (s->connection->version < 12)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_SUSPENDED);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_put_boolean(t, suspend);
>+    pa_pstream_send_tagstruct(s->connection->pstream, t);
>+}
>+
>+/* Called from main context */
>+static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
>+    record_stream *s;
>+    pa_tagstruct *t;
>+
>+    pa_source_output_assert_ref(o);
>+    s = RECORD_STREAM(o->userdata);
>+    record_stream_assert_ref(s);
>+
>+    if (!dest)
>+        return;
>+
>+    fix_record_buffer_attr_pre(s);
>+    pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
>+    pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
>+    fix_record_buffer_attr_post(s);
>+
>+    if (s->connection->version < 12)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_RECORD_STREAM_MOVED);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_putu32(t, dest->index);
>+    pa_tagstruct_puts(t, dest->name);
>+    pa_tagstruct_put_boolean(t, pa_source_get_state(dest) == PA_SOURCE_SUSPENDED);
>+
>+    if (s->connection->version >= 13) {
>+        pa_tagstruct_putu32(t, s->buffer_attr.maxlength);
>+        pa_tagstruct_putu32(t, s->buffer_attr.fragsize);
>+        pa_tagstruct_put_usec(t, s->configured_source_latency);
>+    }
>+
>+    pa_pstream_send_tagstruct(s->connection->pstream, t);
>+}
>+
>+/*** pdispatch callbacks ***/
>+
>+static void protocol_error(pa_native_connection *c) {
>+    pa_log("protocol error, kicking client");
>+    native_connection_unlink(c);
>+}
>+
>+#define CHECK_VALIDITY(pstream, expression, tag, error) do { \
>+if (!(expression)) { \
>+    pa_pstream_send_error((pstream), (tag), (error)); \
>+    return; \
>+} \
>+} while(0);
>+
>+#define CHECK_VALIDITY_GOTO(pstream, expression, tag, error, label) do { \
>+if (!(expression)) { \
>+    pa_pstream_send_error((pstream), (tag), (error)); \
>+    goto label; \
>+} \
>+} while(0);
>+
>+static pa_tagstruct *reply_new(uint32_t tag) {
>+    pa_tagstruct *reply;
>+
>+    reply = pa_tagstruct_new();
>+    pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
>+    pa_tagstruct_putu32(reply, tag);
>+    return reply;
>+}
>+
>+static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    playback_stream *s;
>+    uint32_t sink_index, syncid, missing = 0;
>+    pa_buffer_attr attr;
>+    const char *name = NULL, *sink_name;
>+    pa_sample_spec ss;
>+    pa_channel_map map;
>+    pa_tagstruct *reply;
>+    pa_sink *sink = NULL;
>+    pa_cvolume volume;
>+    bool
>+        corked = false,
>+        no_remap = false,
>+        no_remix = false,
>+        fix_format = false,
>+        fix_rate = false,
>+        fix_channels = false,
>+        no_move = false,
>+        variable_rate = false,
>+        muted = false,
>+        adjust_latency = false,
>+        early_requests = false,
>+        dont_inhibit_auto_suspend = false,
>+        volume_set = true,
>+        muted_set = false,
>+        fail_on_suspend = false,
>+        relative_volume = false,
>+        passthrough = false;
>+
>+    pa_sink_input_flags_t flags = 0;
>+    pa_proplist *p = NULL;
>+    int ret = PA_ERR_INVALID;
>+    uint8_t n_formats = 0;
>+    pa_format_info *format;
>+    pa_idxset *formats = NULL;
>+    uint32_t i;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+    memset(&attr, 0, sizeof(attr));
>+
>+    if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
>+        pa_tagstruct_get(
>+                t,
>+                PA_TAG_SAMPLE_SPEC, &ss,
>+                PA_TAG_CHANNEL_MAP, &map,
>+                PA_TAG_U32, &sink_index,
>+                PA_TAG_STRING, &sink_name,
>+                PA_TAG_U32, &attr.maxlength,
>+                PA_TAG_BOOLEAN, &corked,
>+                PA_TAG_U32, &attr.tlength,
>+                PA_TAG_U32, &attr.prebuf,
>+                PA_TAG_U32, &attr.minreq,
>+                PA_TAG_U32, &syncid,
>+                PA_TAG_CVOLUME, &volume,
>+                PA_TAG_INVALID) < 0) {
>+
>+        protocol_error(c);
>+        goto finish;
>+    }
>+
>+    CHECK_VALIDITY_GOTO(c->pstream, c->authorized, tag, PA_ERR_ACCESS, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, !sink_name || pa_namereg_is_valid_name_or_wildcard(sink_name, PA_NAMEREG_SINK), tag, PA_ERR_INVALID, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID, finish);
>+
>+    p = pa_proplist_new();
>+
>+    if (name)
>+        pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
>+
>+    if (c->version >= 12) {
>+        /* Since 0.9.8 the user can ask for a couple of additional flags */
>+
>+        if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
>+            pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
>+            pa_tagstruct_get_boolean(t, &no_move) < 0 ||
>+            pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 13) {
>+
>+        if (pa_tagstruct_get_boolean(t, &muted) < 0 ||
>+            pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
>+            pa_tagstruct_get_proplist(t, p) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 14) {
>+
>+        if (pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
>+            pa_tagstruct_get_boolean(t, &early_requests) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 15) {
>+
>+        if (pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
>+            pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 17) {
>+
>+        if (pa_tagstruct_get_boolean(t, &relative_volume) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 18) {
>+
>+        if (pa_tagstruct_get_boolean(t, &passthrough) < 0 ) {
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 21) {
>+
>+        if (pa_tagstruct_getu8(t, &n_formats) < 0) {
>+            protocol_error(c);
>+            goto finish;
>+        }
>+
>+        if (n_formats)
>+            formats = pa_idxset_new(NULL, NULL);
>+
>+        for (i = 0; i < n_formats; i++) {
>+            format = pa_format_info_new();
>+            if (pa_tagstruct_get_format_info(t, format) < 0) {
>+                protocol_error(c);
>+                goto finish;
>+            }
>+            pa_idxset_put(formats, format, NULL);
>+        }
>+    }
>+
>+    if (n_formats == 0) {
>+        CHECK_VALIDITY_GOTO(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID, finish);
>+        CHECK_VALIDITY_GOTO(c->pstream, map.channels == ss.channels && volume.channels == ss.channels, tag, PA_ERR_INVALID, finish);
>+        CHECK_VALIDITY_GOTO(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID, finish);
>+    } else {
>+        PA_IDXSET_FOREACH(format, formats, i) {
>+            CHECK_VALIDITY_GOTO(c->pstream, pa_format_info_valid(format), tag, PA_ERR_INVALID, finish);
>+        }
>+    }
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        goto finish;
>+    }
>+
>+    if (sink_index != PA_INVALID_INDEX) {
>+
>+        if (!(sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index))) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+            goto finish;
>+        }
>+
>+    } else if (sink_name) {
>+
>+        if (!(sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK))) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+            goto finish;
>+        }
>+    }
>+
>+    flags =
>+        (corked ? PA_SINK_INPUT_START_CORKED : 0) |
>+        (no_remap ? PA_SINK_INPUT_NO_REMAP : 0) |
>+        (no_remix ? PA_SINK_INPUT_NO_REMIX : 0) |
>+        (fix_format ? PA_SINK_INPUT_FIX_FORMAT : 0) |
>+        (fix_rate ? PA_SINK_INPUT_FIX_RATE : 0) |
>+        (fix_channels ? PA_SINK_INPUT_FIX_CHANNELS : 0) |
>+        (no_move ? PA_SINK_INPUT_DONT_MOVE : 0) |
>+        (variable_rate ? PA_SINK_INPUT_VARIABLE_RATE : 0) |
>+        (dont_inhibit_auto_suspend ? PA_SINK_INPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
>+        (fail_on_suspend ? PA_SINK_INPUT_NO_CREATE_ON_SUSPEND|PA_SINK_INPUT_KILL_ON_SUSPEND : 0) |
>+        (passthrough ? PA_SINK_INPUT_PASSTHROUGH : 0);
>+
>+    /* Only since protocol version 15 there's a separate muted_set
>+     * flag. For older versions we synthesize it here */
>+    muted_set = muted_set || muted;
>+
>+    s = playback_stream_new(c, sink, &ss, &map, formats, &attr, volume_set ? &volume : NULL, muted, muted_set, flags, p, adjust_latency, early_requests, relative_volume, syncid, &missing, &ret);
>+    /* We no longer own the formats idxset */
>+    formats = NULL;
>+
>+    CHECK_VALIDITY_GOTO(c->pstream, s, tag, ret, finish);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_putu32(reply, s->index);
>+    pa_assert(s->sink_input);
>+    pa_tagstruct_putu32(reply, s->sink_input->index);
>+    pa_tagstruct_putu32(reply, missing);
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("initial request is %u", missing);
>+#endif
>+
>+    if (c->version >= 9) {
>+        /* Since 0.9.0 we support sending the buffer metrics back to the client */
>+
>+        pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
>+        pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.tlength);
>+        pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.prebuf);
>+        pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.minreq);
>+    }
>+
>+    if (c->version >= 12) {
>+        /* Since 0.9.8 we support sending the chosen sample
>+         * spec/channel map/device/suspend status back to the
>+         * client */
>+
>+        pa_tagstruct_put_sample_spec(reply, &ss);
>+        pa_tagstruct_put_channel_map(reply, &map);
>+
>+        pa_tagstruct_putu32(reply, s->sink_input->sink->index);
>+        pa_tagstruct_puts(reply, s->sink_input->sink->name);
>+
>+        pa_tagstruct_put_boolean(reply, pa_sink_get_state(s->sink_input->sink) == PA_SINK_SUSPENDED);
>+    }
>+
>+    if (c->version >= 13)
>+        pa_tagstruct_put_usec(reply, s->configured_sink_latency);
>+
>+    if (c->version >= 21) {
>+        /* Send back the format we negotiated */
>+        if (s->sink_input->format)
>+            pa_tagstruct_put_format_info(reply, s->sink_input->format);
>+        else {
>+            pa_format_info *f = pa_format_info_new();
>+            pa_tagstruct_put_format_info(reply, f);
>+            pa_format_info_free(f);
>+        }
>+    }
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+
>+finish:
>+    if (p)
>+        pa_proplist_free(p);
>+    if (formats)
>+        pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
>+}
>+
>+static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t channel;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &channel) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    switch (command) {
>+
>+        case PA_COMMAND_DELETE_PLAYBACK_STREAM: {
>+            playback_stream *s;
>+            if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !playback_stream_isinstance(s)) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
>+                return;
>+            }
>+
>+            playback_stream_unlink(s);
>+            break;
>+        }
>+
>+        case PA_COMMAND_DELETE_RECORD_STREAM: {
>+            record_stream *s;
>+            if (!(s = pa_idxset_get_by_index(c->record_streams, channel))) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
>+                return;
>+            }
>+
>+            record_stream_unlink(s);
>+            break;
>+        }
>+
>+        case PA_COMMAND_DELETE_UPLOAD_STREAM: {
>+            upload_stream *s;
>+
>+            if (!(s = pa_idxset_get_by_index(c->output_streams, channel)) || !upload_stream_isinstance(s)) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_EXIST);
>+                return;
>+            }
>+
>+            upload_stream_unlink(s);
>+            break;
>+        }
>+
>+        default:
>+            pa_assert_not_reached();
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    record_stream *s;
>+    pa_buffer_attr attr;
>+    uint32_t source_index;
>+    const char *name = NULL, *source_name;
>+    pa_sample_spec ss;
>+    pa_channel_map map;
>+    pa_tagstruct *reply;
>+    pa_source *source = NULL;
>+    pa_cvolume volume;
>+    bool
>+        corked = false,
>+        no_remap = false,
>+        no_remix = false,
>+        fix_format = false,
>+        fix_rate = false,
>+        fix_channels = false,
>+        no_move = false,
>+        variable_rate = false,
>+        muted = false,
>+        adjust_latency = false,
>+        peak_detect = false,
>+        early_requests = false,
>+        dont_inhibit_auto_suspend = false,
>+        volume_set = false,
>+        muted_set = false,
>+        fail_on_suspend = false,
>+        relative_volume = false,
>+        passthrough = false;
>+
>+    pa_source_output_flags_t flags = 0;
>+    pa_proplist *p = NULL;
>+    uint32_t direct_on_input_idx = PA_INVALID_INDEX;
>+    pa_sink_input *direct_on_input = NULL;
>+    int ret = PA_ERR_INVALID;
>+    uint8_t n_formats = 0;
>+    pa_format_info *format;
>+    pa_idxset *formats = NULL;
>+    uint32_t i;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    memset(&attr, 0, sizeof(attr));
>+
>+    if ((c->version < 13 && (pa_tagstruct_gets(t, &name) < 0 || !name)) ||
>+        pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
>+        pa_tagstruct_get_channel_map(t, &map) < 0 ||
>+        pa_tagstruct_getu32(t, &source_index) < 0 ||
>+        pa_tagstruct_gets(t, &source_name) < 0 ||
>+        pa_tagstruct_getu32(t, &attr.maxlength) < 0 ||
>+        pa_tagstruct_get_boolean(t, &corked) < 0 ||
>+        pa_tagstruct_getu32(t, &attr.fragsize) < 0) {
>+
>+        protocol_error(c);
>+        goto finish;
>+    }
>+
>+    CHECK_VALIDITY_GOTO(c->pstream, c->authorized, tag, PA_ERR_ACCESS, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, !source_name || pa_namereg_is_valid_name_or_wildcard(source_name, PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, source_index == PA_INVALID_INDEX || !source_name, tag, PA_ERR_INVALID, finish);
>+    CHECK_VALIDITY_GOTO(c->pstream, !source_name || source_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID, finish);
>+
>+    p = pa_proplist_new();
>+
>+    if (name)
>+        pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
>+
>+    if (c->version >= 12) {
>+        /* Since 0.9.8 the user can ask for a couple of additional flags */
>+
>+        if (pa_tagstruct_get_boolean(t, &no_remap) < 0 ||
>+            pa_tagstruct_get_boolean(t, &no_remix) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fix_format) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fix_rate) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fix_channels) < 0 ||
>+            pa_tagstruct_get_boolean(t, &no_move) < 0 ||
>+            pa_tagstruct_get_boolean(t, &variable_rate) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 13) {
>+
>+        if (pa_tagstruct_get_boolean(t, &peak_detect) < 0 ||
>+            pa_tagstruct_get_boolean(t, &adjust_latency) < 0 ||
>+            pa_tagstruct_get_proplist(t, p) < 0 ||
>+            pa_tagstruct_getu32(t, &direct_on_input_idx) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 14) {
>+
>+        if (pa_tagstruct_get_boolean(t, &early_requests) < 0) {
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 15) {
>+
>+        if (pa_tagstruct_get_boolean(t, &dont_inhibit_auto_suspend) < 0 ||
>+            pa_tagstruct_get_boolean(t, &fail_on_suspend) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+    }
>+
>+    if (c->version >= 22) {
>+        /* For newer client versions (with per-source-output volumes), we try
>+         * to make the behaviour for playback and record streams the same. */
>+        volume_set = true;
>+
>+        if (pa_tagstruct_getu8(t, &n_formats) < 0) {
>+            protocol_error(c);
>+            goto finish;
>+        }
>+
>+        if (n_formats)
>+            formats = pa_idxset_new(NULL, NULL);
>+
>+        for (i = 0; i < n_formats; i++) {
>+            format = pa_format_info_new();
>+            if (pa_tagstruct_get_format_info(t, format) < 0) {
>+                protocol_error(c);
>+                goto finish;
>+            }
>+            pa_idxset_put(formats, format, NULL);
>+        }
>+
>+        if (pa_tagstruct_get_cvolume(t, &volume) < 0 ||
>+            pa_tagstruct_get_boolean(t, &muted) < 0 ||
>+            pa_tagstruct_get_boolean(t, &volume_set) < 0 ||
>+            pa_tagstruct_get_boolean(t, &muted_set) < 0 ||
>+            pa_tagstruct_get_boolean(t, &relative_volume) < 0 ||
>+            pa_tagstruct_get_boolean(t, &passthrough) < 0) {
>+
>+            protocol_error(c);
>+            goto finish;
>+        }
>+
>+        CHECK_VALIDITY_GOTO(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID, finish);
>+    }
>+
>+    if (n_formats == 0) {
>+        CHECK_VALIDITY_GOTO(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID, finish);
>+        CHECK_VALIDITY_GOTO(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID, finish);
>+        CHECK_VALIDITY_GOTO(c->pstream, c->version < 22 || (volume.channels == ss.channels), tag, PA_ERR_INVALID, finish);
>+        CHECK_VALIDITY_GOTO(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID, finish);
>+    } else {
>+        PA_IDXSET_FOREACH(format, formats, i) {
>+            CHECK_VALIDITY_GOTO(c->pstream, pa_format_info_valid(format), tag, PA_ERR_INVALID, finish);
>+        }
>+    }
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        goto finish;
>+    }
>+
>+    if (source_index != PA_INVALID_INDEX) {
>+
>+        if (!(source = pa_idxset_get_by_index(c->protocol->core->sources, source_index))) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+            goto finish;
>+        }
>+
>+    } else if (source_name) {
>+
>+        if (!(source = pa_namereg_get(c->protocol->core, source_name, PA_NAMEREG_SOURCE))) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+            goto finish;
>+        }
>+    }
>+
>+    if (direct_on_input_idx != PA_INVALID_INDEX) {
>+
>+        if (!(direct_on_input = pa_idxset_get_by_index(c->protocol->core->sink_inputs, direct_on_input_idx))) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+            goto finish;
>+        }
>+    }
>+
>+    flags =
>+        (corked ? PA_SOURCE_OUTPUT_START_CORKED : 0) |
>+        (no_remap ? PA_SOURCE_OUTPUT_NO_REMAP : 0) |
>+        (no_remix ? PA_SOURCE_OUTPUT_NO_REMIX : 0) |
>+        (fix_format ? PA_SOURCE_OUTPUT_FIX_FORMAT : 0) |
>+        (fix_rate ? PA_SOURCE_OUTPUT_FIX_RATE : 0) |
>+        (fix_channels ? PA_SOURCE_OUTPUT_FIX_CHANNELS : 0) |
>+        (no_move ? PA_SOURCE_OUTPUT_DONT_MOVE : 0) |
>+        (variable_rate ? PA_SOURCE_OUTPUT_VARIABLE_RATE : 0) |
>+        (dont_inhibit_auto_suspend ? PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND : 0) |
>+        (fail_on_suspend ? PA_SOURCE_OUTPUT_NO_CREATE_ON_SUSPEND|PA_SOURCE_OUTPUT_KILL_ON_SUSPEND : 0) |
>+        (passthrough ? PA_SOURCE_OUTPUT_PASSTHROUGH : 0);
>+
>+    s = record_stream_new(c, source, &ss, &map, formats, &attr, volume_set ? &volume : NULL, muted, muted_set, flags, p, adjust_latency, early_requests, relative_volume, peak_detect, direct_on_input, &ret);
>+
>+    CHECK_VALIDITY_GOTO(c->pstream, s, tag, ret, finish);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_putu32(reply, s->index);
>+    pa_assert(s->source_output);
>+    pa_tagstruct_putu32(reply, s->source_output->index);
>+
>+    if (c->version >= 9) {
>+        /* Since 0.9 we support sending the buffer metrics back to the client */
>+
>+        pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.maxlength);
>+        pa_tagstruct_putu32(reply, (uint32_t) s->buffer_attr.fragsize);
>+    }
>+
>+    if (c->version >= 12) {
>+        /* Since 0.9.8 we support sending the chosen sample
>+         * spec/channel map/device/suspend status back to the
>+         * client */
>+
>+        pa_tagstruct_put_sample_spec(reply, &ss);
>+        pa_tagstruct_put_channel_map(reply, &map);
>+
>+        pa_tagstruct_putu32(reply, s->source_output->source->index);
>+        pa_tagstruct_puts(reply, s->source_output->source->name);
>+
>+        pa_tagstruct_put_boolean(reply, pa_source_get_state(s->source_output->source) == PA_SOURCE_SUSPENDED);
>+    }
>+
>+    if (c->version >= 13)
>+        pa_tagstruct_put_usec(reply, s->configured_source_latency);
>+
>+    if (c->version >= 22) {
>+        /* Send back the format we negotiated */
>+        if (s->source_output->format)
>+            pa_tagstruct_put_format_info(reply, s->source_output->format);
>+        else {
>+            pa_format_info *f = pa_format_info_new();
>+            pa_tagstruct_put_format_info(reply, f);
>+            pa_format_info_free(f);
>+        }
>+    }
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+
>+finish:
>+    if (p)
>+        pa_proplist_free(p);
>+    if (formats)
>+        pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
>+}
>+
>+static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    int ret;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    ret = pa_core_exit(c->protocol->core, false, 0);
>+    CHECK_VALIDITY(c->pstream, ret >= 0, tag, PA_ERR_ACCESS);
>+
>+    pa_log_debug("Client %s asks us to terminate.", pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY)));
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag); /* nonsense */
>+}
>+
>+static void setup_srbchannel(pa_native_connection *c) {
>+    pa_srbchannel_template srbt;
>+    pa_srbchannel *srb;
>+    pa_memchunk mc;
>+    pa_tagstruct *t;
>+    int fdlist[2];
>+
>+    if (!c->options->srbchannel) {
>+        pa_log_debug("Disabling srbchannel, reason: Must be enabled by module parameter");
>+        return;
>+    }
>+
>+    if (c->version < 30) {
>+        pa_log_debug("Disabling srbchannel, reason: Protocol too old");
>+        return;
>+    }
>+
>+    if (!pa_pstream_get_shm(c->pstream)) {
>+        pa_log_debug("Disabling srbchannel, reason: No SHM support");
>+        return;
>+    }
>+
>+    if (!c->protocol->core->rw_mempool) {
>+        pa_log_debug("Disabling srbchannel, reason: No rw memory pool");
>+        return;
>+    }
>+
>+    srb = pa_srbchannel_new(c->protocol->core->mainloop, c->protocol->core->rw_mempool);
>+    if (!srb) {
>+        pa_log_debug("Failed to create srbchannel");
>+        return;
>+    }
>+    pa_log_debug("Enabling srbchannel...");
>+    pa_srbchannel_export(srb, &srbt);
>+
>+    /* Send enable command to client */
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_ENABLE_SRBCHANNEL);
>+    pa_tagstruct_putu32(t, (size_t) srb); /* tag */
>+    fdlist[0] = srbt.readfd;
>+    fdlist[1] = srbt.writefd;
>+    pa_pstream_send_tagstruct_with_fds(c->pstream, t, 2, fdlist);
>+
>+    /* Send ringbuffer memblock to client */
>+    mc.memblock = srbt.memblock;
>+    mc.index = 0;
>+    mc.length = pa_memblock_get_length(srbt.memblock);
>+    pa_pstream_send_memblock(c->pstream, 0, 0, 0, &mc);
>+
>+    c->srbpending = srb;
>+}
>+
>+static void command_enable_srbchannel(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+
>+    if (tag != (uint32_t) (size_t) c->srbpending) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    pa_log_debug("Client enabled srbchannel.");
>+    pa_pstream_set_srbchannel(c->pstream, c->srbpending);
>+    c->srbpending = NULL;
>+}
>+
>+static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    const void*cookie;
>+    pa_tagstruct *reply;
>+    bool shm_on_remote = false, do_shm;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &c->version) < 0 ||
>+        pa_tagstruct_get_arbitrary(t, &cookie, PA_NATIVE_COOKIE_LENGTH) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    /* Minimum supported version */
>+    if (c->version < 8) {
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_VERSION);
>+        return;
>+    }
>+
>+    /* Starting with protocol version 13 the MSB of the version tag
>+       reflects if shm is available for this pa_native_connection or
>+       not. */
>+    if (c->version >= 13) {
>+        shm_on_remote = !!(c->version & 0x80000000U);
>+        c->version &= 0x7FFFFFFFU;
>+    }
>+
>+    pa_log_debug("Protocol version: remote %u, local %u", c->version, PA_PROTOCOL_VERSION);
>+
>+    pa_proplist_setf(c->client->proplist, "native-protocol.version", "%u", c->version);
>+
>+    if (!c->authorized) {
>+        bool success = false;
>+
>+#ifdef HAVE_CREDS
>+        const pa_creds *creds;
>+
>+        if ((creds = pa_pdispatch_creds(pd))) {
>+            if (creds->uid == getuid())
>+                success = true;
>+            else if (c->options->auth_group) {
>+                int r;
>+                gid_t gid;
>+
>+                if ((gid = pa_get_gid_of_group(c->options->auth_group)) == (gid_t) -1)
>+                    pa_log_warn("Failed to get GID of group '%s'", c->options->auth_group);
>+                else if (gid == creds->gid)
>+                    success = true;
>+
>+                if (!success) {
>+                    if ((r = pa_uid_in_group(creds->uid, c->options->auth_group)) < 0)
>+                        pa_log_warn("Failed to check group membership.");
>+                    else if (r > 0)
>+                        success = true;
>+                }
>+            }
>+
>+            pa_log_info("Got credentials: uid=%lu gid=%lu success=%i",
>+                        (unsigned long) creds->uid,
>+                        (unsigned long) creds->gid,
>+                        (int) success);
>+        }
>+#endif
>+
>+        if (!success && c->options->auth_cookie) {
>+            const uint8_t *ac;
>+
>+            if ((ac = pa_auth_cookie_read(c->options->auth_cookie, PA_NATIVE_COOKIE_LENGTH)))
>+                if (memcmp(ac, cookie, PA_NATIVE_COOKIE_LENGTH) == 0)
>+                    success = true;
>+        }
>+
>+        if (!success) {
>+            pa_log_warn("Denied access to client with invalid authentication data.");
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_ACCESS);
>+            return;
>+        }
>+
>+        c->authorized = true;
>+        if (c->auth_timeout_event) {
>+            c->protocol->core->mainloop->time_free(c->auth_timeout_event);
>+            c->auth_timeout_event = NULL;
>+        }
>+    }
>+
>+    /* Enable shared memory support if possible */
>+    do_shm =
>+        pa_mempool_is_shared(c->protocol->core->mempool) &&
>+        c->is_local;
>+
>+    pa_log_debug("SHM possible: %s", pa_yes_no(do_shm));
>+
>+    if (do_shm)
>+        if (c->version < 10 || (c->version >= 13 && !shm_on_remote))
>+            do_shm = false;
>+
>+#ifdef HAVE_CREDS
>+    if (do_shm) {
>+        /* Only enable SHM if both sides are owned by the same
>+         * user. This is a security measure because otherwise data
>+         * private to the user might leak. */
>+
>+        const pa_creds *creds;
>+        if (!(creds = pa_pdispatch_creds(pd)) || getuid() != creds->uid)
>+            do_shm = false;
>+    }
>+#endif
>+
>+    pa_log_debug("Negotiated SHM: %s", pa_yes_no(do_shm));
>+    pa_pstream_enable_shm(c->pstream, do_shm);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_putu32(reply, PA_PROTOCOL_VERSION | (do_shm ? 0x80000000 : 0));
>+
>+#ifdef HAVE_CREDS
>+{
>+    /* SHM support is only enabled after both sides made sure they are the same user. */
>+
>+    pa_creds ucred;
>+
>+    ucred.uid = getuid();
>+    ucred.gid = getgid();
>+
>+    pa_pstream_send_tagstruct_with_creds(c->pstream, reply, &ucred);
>+}
>+#else
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+#endif
>+
>+    setup_srbchannel(c);
>+}
>+
>+static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    const char *name = NULL;
>+    pa_proplist *p;
>+    pa_tagstruct *reply;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    p = pa_proplist_new();
>+
>+    if ((c->version < 13 && pa_tagstruct_gets(t, &name) < 0) ||
>+        (c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
>+        !pa_tagstruct_eof(t)) {
>+
>+        protocol_error(c);
>+        pa_proplist_free(p);
>+        return;
>+    }
>+
>+    if (name)
>+        if (pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name) < 0) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+            pa_proplist_free(p);
>+            return;
>+        }
>+
>+    pa_client_update_proplist(c->client, PA_UPDATE_REPLACE, p);
>+    pa_proplist_free(p);
>+
>+    reply = reply_new(tag);
>+
>+    if (c->version >= 13)
>+        pa_tagstruct_putu32(reply, c->client->index);
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    const char *name;
>+    uint32_t idx = PA_IDXSET_INVALID;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_gets(t, &name) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_LOOKUP_SINK ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_LOOKUP_SINK) {
>+        pa_sink *sink;
>+        if ((sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK)))
>+            idx = sink->index;
>+    } else {
>+        pa_source *source;
>+        pa_assert(command == PA_COMMAND_LOOKUP_SOURCE);
>+        if ((source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE)))
>+            idx = source->index;
>+    }
>+
>+    if (idx == PA_IDXSET_INVALID)
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+    else {
>+        pa_tagstruct *reply;
>+        reply = reply_new(tag);
>+        pa_tagstruct_putu32(reply, idx);
>+        pa_pstream_send_tagstruct(c->pstream, reply);
>+    }
>+}
>+
>+static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    playback_stream *s;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    s = pa_idxset_get_by_index(c->output_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+    CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+    pa_asyncmsgq_post(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_DRAIN, PA_UINT_TO_PTR(tag), 0, NULL, NULL);
>+}
>+
>+static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_tagstruct *reply;
>+    const pa_mempool_stat *stat;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    stat = pa_mempool_get_stat(c->protocol->core->mempool);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_allocated));
>+    pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->allocated_size));
>+    pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->n_accumulated));
>+    pa_tagstruct_putu32(reply, (uint32_t) pa_atomic_load(&stat->accumulated_size));
>+    pa_tagstruct_putu32(reply, (uint32_t) pa_scache_total_size(c->protocol->core));
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_tagstruct *reply;
>+    playback_stream *s;
>+    struct timeval tv, now;
>+    uint32_t idx;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_get_timeval(t, &tv) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    s = pa_idxset_get_by_index(c->output_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+    CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+    /* Get an atomic snapshot of all timing parameters */
>+    pa_assert_se(pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_UPDATE_LATENCY, s, 0, NULL) == 0);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_put_usec(reply,
>+                          s->current_sink_latency +
>+                          pa_bytes_to_usec(s->render_memblockq_length, &s->sink_input->sink->sample_spec));
>+    pa_tagstruct_put_usec(reply, 0);
>+    pa_tagstruct_put_boolean(reply,
>+                             s->playing_for > 0 &&
>+                             pa_sink_get_state(s->sink_input->sink) == PA_SINK_RUNNING &&
>+                             pa_sink_input_get_state(s->sink_input) == PA_SINK_INPUT_RUNNING);
>+    pa_tagstruct_put_timeval(reply, &tv);
>+    pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
>+    pa_tagstruct_puts64(reply, s->write_index);
>+    pa_tagstruct_puts64(reply, s->read_index);
>+
>+    if (c->version >= 13) {
>+        pa_tagstruct_putu64(reply, s->underrun_for);
>+        pa_tagstruct_putu64(reply, s->playing_for);
>+    }
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_tagstruct *reply;
>+    record_stream *s;
>+    struct timeval tv, now;
>+    uint32_t idx;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_get_timeval(t, &tv) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    s = pa_idxset_get_by_index(c->record_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+    /* Get an atomic snapshot of all timing parameters */
>+    pa_assert_se(pa_asyncmsgq_send(s->source_output->source->asyncmsgq, PA_MSGOBJECT(s->source_output), SOURCE_OUTPUT_MESSAGE_UPDATE_LATENCY, s, 0, NULL) == 0);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_put_usec(reply, s->current_monitor_latency);
>+    pa_tagstruct_put_usec(reply,
>+                          s->current_source_latency +
>+                          pa_bytes_to_usec(s->on_the_fly_snapshot, &s->source_output->source->sample_spec));
>+    pa_tagstruct_put_boolean(reply,
>+                             pa_source_get_state(s->source_output->source) == PA_SOURCE_RUNNING &&
>+                             pa_source_output_get_state(s->source_output) == PA_SOURCE_OUTPUT_RUNNING);
>+    pa_tagstruct_put_timeval(reply, &tv);
>+    pa_tagstruct_put_timeval(reply, pa_gettimeofday(&now));
>+    pa_tagstruct_puts64(reply, pa_memblockq_get_write_index(s->memblockq));
>+    pa_tagstruct_puts64(reply, pa_memblockq_get_read_index(s->memblockq));
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    upload_stream *s;
>+    uint32_t length;
>+    const char *name = NULL;
>+    pa_sample_spec ss;
>+    pa_channel_map map;
>+    pa_tagstruct *reply;
>+    pa_proplist *p;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_gets(t, &name) < 0 ||
>+        pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
>+        pa_tagstruct_get_channel_map(t, &map) < 0 ||
>+        pa_tagstruct_getu32(t, &length) < 0) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, pa_sample_spec_valid(&ss), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, pa_channel_map_valid(&map), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, map.channels == ss.channels, tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (length % pa_frame_size(&ss)) == 0 && length > 0, tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, length <= PA_SCACHE_ENTRY_SIZE_MAX, tag, PA_ERR_TOOLARGE);
>+
>+    p = pa_proplist_new();
>+
>+    if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
>+        !pa_tagstruct_eof(t)) {
>+
>+        protocol_error(c);
>+        pa_proplist_free(p);
>+        return;
>+    }
>+
>+    if (c->version < 13)
>+        pa_proplist_sets(p, PA_PROP_MEDIA_NAME, name);
>+    else if (!name)
>+        if (!(name = pa_proplist_gets(p, PA_PROP_EVENT_ID)))
>+            name = pa_proplist_gets(p, PA_PROP_MEDIA_NAME);
>+
>+    if (!name || !pa_namereg_is_valid_name(name)) {
>+        pa_proplist_free(p);
>+        CHECK_VALIDITY(c->pstream, false, tag, PA_ERR_INVALID);
>+    }
>+
>+    s = upload_stream_new(c, &ss, &map, name, length, p);
>+    pa_proplist_free(p);
>+
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_INVALID);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_putu32(reply, s->index);
>+    pa_tagstruct_putu32(reply, length);
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t channel;
>+    upload_stream *s;
>+    uint32_t idx;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &channel) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    s = pa_idxset_get_by_index(c->output_streams, channel);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+    CHECK_VALIDITY(c->pstream, upload_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+    if (!s->memchunk.memblock)
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_TOOLARGE);
>+    else if (pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->channel_map, &s->memchunk, s->proplist, &idx) < 0)
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_INTERNAL);
>+    else
>+        pa_pstream_send_simple_ack(c->pstream, tag);
>+
>+    upload_stream_unlink(s);
>+}
>+
>+static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t sink_index;
>+    pa_volume_t volume;
>+    pa_sink *sink;
>+    const char *name, *sink_name;
>+    uint32_t idx;
>+    pa_proplist *p;
>+    pa_tagstruct *reply;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    if (pa_tagstruct_getu32(t, &sink_index) < 0 ||
>+        pa_tagstruct_gets(t, &sink_name) < 0 ||
>+        pa_tagstruct_getu32(t, &volume) < 0 ||
>+        pa_tagstruct_gets(t, &name) < 0) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, !sink_name || pa_namereg_is_valid_name_or_wildcard(sink_name, PA_NAMEREG_SINK), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, sink_index == PA_INVALID_INDEX || !sink_name, tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, !sink_name || sink_index == PA_INVALID_INDEX, tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
>+
>+    if (sink_index != PA_INVALID_INDEX)
>+        sink = pa_idxset_get_by_index(c->protocol->core->sinks, sink_index);
>+    else
>+        sink = pa_namereg_get(c->protocol->core, sink_name, PA_NAMEREG_SINK);
>+
>+    CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
>+
>+    p = pa_proplist_new();
>+
>+    if ((c->version >= 13 && pa_tagstruct_get_proplist(t, p) < 0) ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        pa_proplist_free(p);
>+        return;
>+    }
>+
>+    pa_proplist_update(p, PA_UPDATE_MERGE, c->client->proplist);
>+
>+    if (pa_scache_play_item(c->protocol->core, name, sink, volume, p, &idx) < 0) {
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+        pa_proplist_free(p);
>+        return;
>+    }
>+
>+    pa_proplist_free(p);
>+
>+    reply = reply_new(tag);
>+
>+    if (c->version >= 13)
>+        pa_tagstruct_putu32(reply, idx);
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    const char *name;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_gets(t, &name) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, name && pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
>+
>+    if (pa_scache_remove_item(c->protocol->core, name) < 0) {
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+        return;
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void fixup_sample_spec(pa_native_connection *c, pa_sample_spec *fixed, const pa_sample_spec *original) {
>+    pa_assert(c);
>+    pa_assert(fixed);
>+    pa_assert(original);
>+
>+    *fixed = *original;
>+
>+    if (c->version < 12) {
>+        /* Before protocol version 12 we didn't support S32 samples,
>+         * so we need to lie about this to the client */
>+
>+        if (fixed->format == PA_SAMPLE_S32LE)
>+            fixed->format = PA_SAMPLE_FLOAT32LE;
>+        if (fixed->format == PA_SAMPLE_S32BE)
>+            fixed->format = PA_SAMPLE_FLOAT32BE;
>+    }
>+
>+    if (c->version < 15) {
>+        if (fixed->format == PA_SAMPLE_S24LE || fixed->format == PA_SAMPLE_S24_32LE)
>+            fixed->format = PA_SAMPLE_FLOAT32LE;
>+        if (fixed->format == PA_SAMPLE_S24BE || fixed->format == PA_SAMPLE_S24_32BE)
>+            fixed->format = PA_SAMPLE_FLOAT32BE;
>+    }
>+}
>+
>+static void sink_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink *sink) {
>+    pa_sample_spec fixed_ss;
>+
>+    pa_assert(t);
>+    pa_sink_assert_ref(sink);
>+
>+    fixup_sample_spec(c, &fixed_ss, &sink->sample_spec);
>+
>+    pa_tagstruct_put(
>+        t,
>+        PA_TAG_U32, sink->index,
>+        PA_TAG_STRING, sink->name,
>+        PA_TAG_STRING, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)),
>+        PA_TAG_SAMPLE_SPEC, &fixed_ss,
>+        PA_TAG_CHANNEL_MAP, &sink->channel_map,
>+        PA_TAG_U32, sink->module ? sink->module->index : PA_INVALID_INDEX,
>+        PA_TAG_CVOLUME, pa_sink_get_volume(sink, false),
>+        PA_TAG_BOOLEAN, pa_sink_get_mute(sink, false),
>+        PA_TAG_U32, sink->monitor_source ? sink->monitor_source->index : PA_INVALID_INDEX,
>+        PA_TAG_STRING, sink->monitor_source ? sink->monitor_source->name : NULL,
>+        PA_TAG_USEC, pa_sink_get_latency(sink),
>+        PA_TAG_STRING, sink->driver,
>+        PA_TAG_U32, sink->flags & PA_SINK_CLIENT_FLAGS_MASK,
>+        PA_TAG_INVALID);
>+
>+    if (c->version >= 13) {
>+        pa_tagstruct_put_proplist(t, sink->proplist);
>+        pa_tagstruct_put_usec(t, pa_sink_get_requested_latency(sink));
>+    }
>+
>+    if (c->version >= 15) {
>+        pa_tagstruct_put_volume(t, sink->base_volume);
>+        if (PA_UNLIKELY(pa_sink_get_state(sink) == PA_SINK_INVALID_STATE))
>+            pa_log_error("Internal sink state is invalid.");
>+        pa_tagstruct_putu32(t, pa_sink_get_state(sink));
>+        pa_tagstruct_putu32(t, sink->n_volume_steps);
>+        pa_tagstruct_putu32(t, sink->card ? sink->card->index : PA_INVALID_INDEX);
>+    }
>+
>+    if (c->version >= 16) {
>+        void *state;
>+        pa_device_port *p;
>+
>+        pa_tagstruct_putu32(t, pa_hashmap_size(sink->ports));
>+
>+        PA_HASHMAP_FOREACH(p, sink->ports, state) {
>+            pa_tagstruct_puts(t, p->name);
>+            pa_tagstruct_puts(t, p->description);
>+            pa_tagstruct_putu32(t, p->priority);
>+            if (c->version >= 24)
>+                pa_tagstruct_putu32(t, p->available);
>+        }
>+
>+        pa_tagstruct_puts(t, sink->active_port ? sink->active_port->name : NULL);
>+    }
>+
>+    if (c->version >= 21) {
>+        uint32_t i;
>+        pa_format_info *f;
>+        pa_idxset *formats = pa_sink_get_formats(sink);
>+
>+        pa_tagstruct_putu8(t, (uint8_t) pa_idxset_size(formats));
>+        PA_IDXSET_FOREACH(f, formats, i) {
>+            pa_tagstruct_put_format_info(t, f);
>+        }
>+
>+        pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
>+    }
>+}
>+
>+static void source_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source *source) {
>+    pa_sample_spec fixed_ss;
>+
>+    pa_assert(t);
>+    pa_source_assert_ref(source);
>+
>+    fixup_sample_spec(c, &fixed_ss, &source->sample_spec);
>+
>+    pa_tagstruct_put(
>+        t,
>+        PA_TAG_U32, source->index,
>+        PA_TAG_STRING, source->name,
>+        PA_TAG_STRING, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)),
>+        PA_TAG_SAMPLE_SPEC, &fixed_ss,
>+        PA_TAG_CHANNEL_MAP, &source->channel_map,
>+        PA_TAG_U32, source->module ? source->module->index : PA_INVALID_INDEX,
>+        PA_TAG_CVOLUME, pa_source_get_volume(source, false),
>+        PA_TAG_BOOLEAN, pa_source_get_mute(source, false),
>+        PA_TAG_U32, source->monitor_of ? source->monitor_of->index : PA_INVALID_INDEX,
>+        PA_TAG_STRING, source->monitor_of ? source->monitor_of->name : NULL,
>+        PA_TAG_USEC, pa_source_get_latency(source),
>+        PA_TAG_STRING, source->driver,
>+        PA_TAG_U32, source->flags & PA_SOURCE_CLIENT_FLAGS_MASK,
>+        PA_TAG_INVALID);
>+
>+    if (c->version >= 13) {
>+        pa_tagstruct_put_proplist(t, source->proplist);
>+        pa_tagstruct_put_usec(t, pa_source_get_requested_latency(source));
>+    }
>+
>+    if (c->version >= 15) {
>+        pa_tagstruct_put_volume(t, source->base_volume);
>+        if (PA_UNLIKELY(pa_source_get_state(source) == PA_SOURCE_INVALID_STATE))
>+            pa_log_error("Internal source state is invalid.");
>+        pa_tagstruct_putu32(t, pa_source_get_state(source));
>+        pa_tagstruct_putu32(t, source->n_volume_steps);
>+        pa_tagstruct_putu32(t, source->card ? source->card->index : PA_INVALID_INDEX);
>+    }
>+
>+    if (c->version >= 16) {
>+        void *state;
>+        pa_device_port *p;
>+
>+        pa_tagstruct_putu32(t, pa_hashmap_size(source->ports));
>+
>+        PA_HASHMAP_FOREACH(p, source->ports, state) {
>+            pa_tagstruct_puts(t, p->name);
>+            pa_tagstruct_puts(t, p->description);
>+            pa_tagstruct_putu32(t, p->priority);
>+            if (c->version >= 24)
>+                pa_tagstruct_putu32(t, p->available);
>+        }
>+
>+        pa_tagstruct_puts(t, source->active_port ? source->active_port->name : NULL);
>+    }
>+
>+    if (c->version >= 22) {
>+        uint32_t i;
>+        pa_format_info *f;
>+        pa_idxset *formats = pa_source_get_formats(source);
>+
>+        pa_tagstruct_putu8(t, (uint8_t) pa_idxset_size(formats));
>+        PA_IDXSET_FOREACH(f, formats, i) {
>+            pa_tagstruct_put_format_info(t, f);
>+        }
>+
>+        pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
>+    }
>+}
>+
>+static void client_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_client *client) {
>+    pa_assert(t);
>+    pa_assert(client);
>+
>+    pa_tagstruct_putu32(t, client->index);
>+    pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(client->proplist, PA_PROP_APPLICATION_NAME)));
>+    pa_tagstruct_putu32(t, client->module ? client->module->index : PA_INVALID_INDEX);
>+    pa_tagstruct_puts(t, client->driver);
>+
>+    if (c->version >= 13)
>+        pa_tagstruct_put_proplist(t, client->proplist);
>+}
>+
>+static void card_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_card *card) {
>+    void *state = NULL;
>+    pa_card_profile *p;
>+    pa_device_port *port;
>+
>+    pa_assert(t);
>+    pa_assert(card);
>+
>+    pa_tagstruct_putu32(t, card->index);
>+    pa_tagstruct_puts(t, card->name);
>+    pa_tagstruct_putu32(t, card->module ? card->module->index : PA_INVALID_INDEX);
>+    pa_tagstruct_puts(t, card->driver);
>+
>+    pa_tagstruct_putu32(t, pa_hashmap_size(card->profiles));
>+
>+    PA_HASHMAP_FOREACH(p, card->profiles, state) {
>+        pa_tagstruct_puts(t, p->name);
>+        pa_tagstruct_puts(t, p->description);
>+        pa_tagstruct_putu32(t, p->n_sinks);
>+        pa_tagstruct_putu32(t, p->n_sources);
>+        pa_tagstruct_putu32(t, p->priority);
>+
>+        if (c->version >= 29)
>+            pa_tagstruct_putu32(t, (p->available != PA_AVAILABLE_NO));
>+    }
>+
>+    pa_tagstruct_puts(t, card->active_profile->name);
>+    pa_tagstruct_put_proplist(t, card->proplist);
>+
>+    if (c->version < 26)
>+        return;
>+
>+    pa_tagstruct_putu32(t, pa_hashmap_size(card->ports));
>+
>+    PA_HASHMAP_FOREACH(port, card->ports, state) {
>+        void *state2;
>+
>+        pa_tagstruct_puts(t, port->name);
>+        pa_tagstruct_puts(t, port->description);
>+        pa_tagstruct_putu32(t, port->priority);
>+        pa_tagstruct_putu32(t, port->available);
>+        pa_tagstruct_putu8(t, port->direction);
>+        pa_tagstruct_put_proplist(t, port->proplist);
>+
>+        pa_tagstruct_putu32(t, pa_hashmap_size(port->profiles));
>+
>+        PA_HASHMAP_FOREACH(p, port->profiles, state2)
>+            pa_tagstruct_puts(t, p->name);
>+
>+        if (c->version >= 27)
>+            pa_tagstruct_puts64(t, port->latency_offset);
>+    }
>+}
>+
>+static void module_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_module *module) {
>+    pa_assert(t);
>+    pa_assert(module);
>+
>+    pa_tagstruct_putu32(t, module->index);
>+    pa_tagstruct_puts(t, module->name);
>+    pa_tagstruct_puts(t, module->argument);
>+    pa_tagstruct_putu32(t, (uint32_t) pa_module_get_n_used(module));
>+
>+    if (c->version < 15)
>+        pa_tagstruct_put_boolean(t, false); /* autoload is obsolete */
>+
>+    if (c->version >= 15)
>+        pa_tagstruct_put_proplist(t, module->proplist);
>+}
>+
>+static void sink_input_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_sink_input *s) {
>+    pa_sample_spec fixed_ss;
>+    pa_usec_t sink_latency;
>+    pa_cvolume v;
>+    bool has_volume = false;
>+
>+    pa_assert(t);
>+    pa_sink_input_assert_ref(s);
>+
>+    fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
>+
>+    has_volume = pa_sink_input_is_volume_readable(s);
>+    if (has_volume)
>+        pa_sink_input_get_volume(s, &v, true);
>+    else
>+        pa_cvolume_reset(&v, fixed_ss.channels);
>+
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
>+    pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
>+    pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
>+    pa_tagstruct_putu32(t, s->sink->index);
>+    pa_tagstruct_put_sample_spec(t, &fixed_ss);
>+    pa_tagstruct_put_channel_map(t, &s->channel_map);
>+    pa_tagstruct_put_cvolume(t, &v);
>+    pa_tagstruct_put_usec(t, pa_sink_input_get_latency(s, &sink_latency));
>+    pa_tagstruct_put_usec(t, sink_latency);
>+    pa_tagstruct_puts(t, pa_resample_method_to_string(pa_sink_input_get_resample_method(s)));
>+    pa_tagstruct_puts(t, s->driver);
>+    if (c->version >= 11)
>+        pa_tagstruct_put_boolean(t, s->muted);
>+    if (c->version >= 13)
>+        pa_tagstruct_put_proplist(t, s->proplist);
>+    if (c->version >= 19)
>+        pa_tagstruct_put_boolean(t, (pa_sink_input_get_state(s) == PA_SINK_INPUT_CORKED));
>+    if (c->version >= 20) {
>+        pa_tagstruct_put_boolean(t, has_volume);
>+        pa_tagstruct_put_boolean(t, s->volume_writable);
>+    }
>+    if (c->version >= 21)
>+        pa_tagstruct_put_format_info(t, s->format);
>+}
>+
>+static void source_output_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_source_output *s) {
>+    pa_sample_spec fixed_ss;
>+    pa_usec_t source_latency;
>+    pa_cvolume v;
>+    bool has_volume = false;
>+
>+    pa_assert(t);
>+    pa_source_output_assert_ref(s);
>+
>+    fixup_sample_spec(c, &fixed_ss, &s->sample_spec);
>+
>+    has_volume = pa_source_output_is_volume_readable(s);
>+    if (has_volume)
>+        pa_source_output_get_volume(s, &v, true);
>+    else
>+        pa_cvolume_reset(&v, fixed_ss.channels);
>+
>+    pa_tagstruct_putu32(t, s->index);
>+    pa_tagstruct_puts(t, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_MEDIA_NAME)));
>+    pa_tagstruct_putu32(t, s->module ? s->module->index : PA_INVALID_INDEX);
>+    pa_tagstruct_putu32(t, s->client ? s->client->index : PA_INVALID_INDEX);
>+    pa_tagstruct_putu32(t, s->source->index);
>+    pa_tagstruct_put_sample_spec(t, &fixed_ss);
>+    pa_tagstruct_put_channel_map(t, &s->channel_map);
>+    pa_tagstruct_put_usec(t, pa_source_output_get_latency(s, &source_latency));
>+    pa_tagstruct_put_usec(t, source_latency);
>+    pa_tagstruct_puts(t, pa_resample_method_to_string(pa_source_output_get_resample_method(s)));
>+    pa_tagstruct_puts(t, s->driver);
>+    if (c->version >= 13)
>+        pa_tagstruct_put_proplist(t, s->proplist);
>+    if (c->version >= 19)
>+        pa_tagstruct_put_boolean(t, (pa_source_output_get_state(s) == PA_SOURCE_OUTPUT_CORKED));
>+    if (c->version >= 22) {
>+        pa_tagstruct_put_cvolume(t, &v);
>+        pa_tagstruct_put_boolean(t, s->muted);
>+        pa_tagstruct_put_boolean(t, has_volume);
>+        pa_tagstruct_put_boolean(t, s->volume_writable);
>+        pa_tagstruct_put_format_info(t, s->format);
>+    }
>+}
>+
>+static void scache_fill_tagstruct(pa_native_connection *c, pa_tagstruct *t, pa_scache_entry *e) {
>+    pa_sample_spec fixed_ss;
>+    pa_cvolume v;
>+
>+    pa_assert(t);
>+    pa_assert(e);
>+
>+    if (e->memchunk.memblock)
>+        fixup_sample_spec(c, &fixed_ss, &e->sample_spec);
>+    else
>+        memset(&fixed_ss, 0, sizeof(fixed_ss));
>+
>+    pa_tagstruct_putu32(t, e->index);
>+    pa_tagstruct_puts(t, e->name);
>+
>+    if (e->volume_is_set)
>+        v = e->volume;
>+    else
>+        pa_cvolume_init(&v);
>+
>+    pa_tagstruct_put_cvolume(t, &v);
>+    pa_tagstruct_put_usec(t, e->memchunk.memblock ? pa_bytes_to_usec(e->memchunk.length, &e->sample_spec) : 0);
>+    pa_tagstruct_put_sample_spec(t, &fixed_ss);
>+    pa_tagstruct_put_channel_map(t, &e->channel_map);
>+    pa_tagstruct_putu32(t, (uint32_t) e->memchunk.length);
>+    pa_tagstruct_put_boolean(t, e->lazy);
>+    pa_tagstruct_puts(t, e->filename);
>+
>+    if (c->version >= 13)
>+        pa_tagstruct_put_proplist(t, e->proplist);
>+}
>+
>+static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    pa_sink *sink = NULL;
>+    pa_source *source = NULL;
>+    pa_client *client = NULL;
>+    pa_card *card = NULL;
>+    pa_module *module = NULL;
>+    pa_sink_input *si = NULL;
>+    pa_source_output *so = NULL;
>+    pa_scache_entry *sce = NULL;
>+    const char *name = NULL;
>+    pa_tagstruct *reply;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        (command != PA_COMMAND_GET_CLIENT_INFO &&
>+         command != PA_COMMAND_GET_MODULE_INFO &&
>+         command != PA_COMMAND_GET_SINK_INPUT_INFO &&
>+         command != PA_COMMAND_GET_SOURCE_OUTPUT_INFO &&
>+         pa_tagstruct_gets(t, &name) < 0) ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name ||
>+                   (command == PA_COMMAND_GET_SINK_INFO &&
>+                    pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SINK)) ||
>+                   (command == PA_COMMAND_GET_SOURCE_INFO &&
>+                    pa_namereg_is_valid_name_or_wildcard(name, PA_NAMEREG_SOURCE)) ||
>+                   pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, command == PA_COMMAND_GET_SINK_INFO ||
>+                   command == PA_COMMAND_GET_SOURCE_INFO ||
>+                   (idx != PA_INVALID_INDEX || name), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, idx == PA_INVALID_INDEX || !name, tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_GET_SINK_INFO) {
>+        if (idx != PA_INVALID_INDEX)
>+            sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
>+        else
>+            sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
>+    } else if (command == PA_COMMAND_GET_SOURCE_INFO) {
>+        if (idx != PA_INVALID_INDEX)
>+            source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
>+        else
>+            source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
>+    } else if (command == PA_COMMAND_GET_CARD_INFO) {
>+        if (idx != PA_INVALID_INDEX)
>+            card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
>+        else
>+            card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
>+    } else if (command == PA_COMMAND_GET_CLIENT_INFO)
>+        client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
>+    else if (command == PA_COMMAND_GET_MODULE_INFO)
>+        module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
>+    else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
>+        si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
>+    else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
>+        so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
>+    else {
>+        pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO);
>+        if (idx != PA_INVALID_INDEX)
>+            sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
>+        else
>+            sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE);
>+    }
>+
>+    if (!sink && !source && !client && !card && !module && !si && !so && !sce) {
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_NOENTITY);
>+        return;
>+    }
>+
>+    reply = reply_new(tag);
>+    if (sink)
>+        sink_fill_tagstruct(c, reply, sink);
>+    else if (source)
>+        source_fill_tagstruct(c, reply, source);
>+    else if (client)
>+        client_fill_tagstruct(c, reply, client);
>+    else if (card)
>+        card_fill_tagstruct(c, reply, card);
>+    else if (module)
>+        module_fill_tagstruct(c, reply, module);
>+    else if (si)
>+        sink_input_fill_tagstruct(c, reply, si);
>+    else if (so)
>+        source_output_fill_tagstruct(c, reply, so);
>+    else
>+        scache_fill_tagstruct(c, reply, sce);
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_idxset *i;
>+    uint32_t idx;
>+    void *p;
>+    pa_tagstruct *reply;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    reply = reply_new(tag);
>+
>+    if (command == PA_COMMAND_GET_SINK_INFO_LIST)
>+        i = c->protocol->core->sinks;
>+    else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
>+        i = c->protocol->core->sources;
>+    else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
>+        i = c->protocol->core->clients;
>+    else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
>+        i = c->protocol->core->cards;
>+    else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
>+        i = c->protocol->core->modules;
>+    else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
>+        i = c->protocol->core->sink_inputs;
>+    else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
>+        i = c->protocol->core->source_outputs;
>+    else {
>+        pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
>+        i = c->protocol->core->scache;
>+    }
>+
>+    if (i) {
>+        PA_IDXSET_FOREACH(p, i, idx) {
>+            if (command == PA_COMMAND_GET_SINK_INFO_LIST)
>+                sink_fill_tagstruct(c, reply, p);
>+            else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
>+                source_fill_tagstruct(c, reply, p);
>+            else if (command == PA_COMMAND_GET_CLIENT_INFO_LIST)
>+                client_fill_tagstruct(c, reply, p);
>+            else if (command == PA_COMMAND_GET_CARD_INFO_LIST)
>+                card_fill_tagstruct(c, reply, p);
>+            else if (command == PA_COMMAND_GET_MODULE_INFO_LIST)
>+                module_fill_tagstruct(c, reply, p);
>+            else if (command == PA_COMMAND_GET_SINK_INPUT_INFO_LIST)
>+                sink_input_fill_tagstruct(c, reply, p);
>+            else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST)
>+                source_output_fill_tagstruct(c, reply, p);
>+            else {
>+                pa_assert(command == PA_COMMAND_GET_SAMPLE_INFO_LIST);
>+                scache_fill_tagstruct(c, reply, p);
>+            }
>+        }
>+    }
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_tagstruct *reply;
>+    pa_sink *def_sink;
>+    pa_source *def_source;
>+    pa_sample_spec fixed_ss;
>+    char *h, *u;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_puts(reply, PACKAGE_NAME);
>+    pa_tagstruct_puts(reply, PACKAGE_VERSION);
>+
>+    u = pa_get_user_name_malloc();
>+    pa_tagstruct_puts(reply, u);
>+    pa_xfree(u);
>+
>+    h = pa_get_host_name_malloc();
>+    pa_tagstruct_puts(reply, h);
>+    pa_xfree(h);
>+
>+    fixup_sample_spec(c, &fixed_ss, &c->protocol->core->default_sample_spec);
>+    pa_tagstruct_put_sample_spec(reply, &fixed_ss);
>+
>+    def_sink = pa_namereg_get_default_sink(c->protocol->core);
>+    pa_tagstruct_puts(reply, def_sink ? def_sink->name : NULL);
>+    def_source = pa_namereg_get_default_source(c->protocol->core);
>+    pa_tagstruct_puts(reply, def_source ? def_source->name : NULL);
>+
>+    pa_tagstruct_putu32(reply, c->protocol->core->cookie);
>+
>+    if (c->version >= 15)
>+        pa_tagstruct_put_channel_map(reply, &c->protocol->core->default_channel_map);
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void subscription_cb(pa_core *core, pa_subscription_event_type_t e, uint32_t idx, void *userdata) {
>+    pa_tagstruct *t;
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+
>+    pa_native_connection_assert_ref(c);
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
>+    pa_tagstruct_putu32(t, (uint32_t) -1);
>+    pa_tagstruct_putu32(t, e);
>+    pa_tagstruct_putu32(t, idx);
>+    pa_pstream_send_tagstruct(c->pstream, t);
>+}
>+
>+static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_subscription_mask_t m;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &m) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, (m & ~PA_SUBSCRIPTION_MASK_ALL) == 0, tag, PA_ERR_INVALID);
>+
>+    if (c->subscription)
>+        pa_subscription_free(c->subscription);
>+
>+    if (m != 0) {
>+        c->subscription = pa_subscription_new(c->protocol->core, m, subscription_cb, c);
>+        pa_assert(c->subscription);
>+    } else
>+        c->subscription = NULL;
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_set_volume(
>+        pa_pdispatch *pd,
>+        uint32_t command,
>+        uint32_t tag,
>+        pa_tagstruct *t,
>+        void *userdata) {
>+
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    pa_cvolume volume;
>+    pa_sink *sink = NULL;
>+    pa_source *source = NULL;
>+    pa_sink_input *si = NULL;
>+    pa_source_output *so = NULL;
>+    const char *name = NULL;
>+    const char *client_name;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        (command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
>+        (command == PA_COMMAND_SET_SOURCE_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
>+        pa_tagstruct_get_cvolume(t, &volume) ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_VOLUME ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, pa_cvolume_valid(&volume), tag, PA_ERR_INVALID);
>+
>+    switch (command) {
>+
>+        case PA_COMMAND_SET_SINK_VOLUME:
>+            if (idx != PA_INVALID_INDEX)
>+                sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
>+            else
>+                sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
>+            break;
>+
>+        case PA_COMMAND_SET_SOURCE_VOLUME:
>+            if (idx != PA_INVALID_INDEX)
>+                source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
>+            else
>+                source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
>+            break;
>+
>+        case PA_COMMAND_SET_SINK_INPUT_VOLUME:
>+            si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
>+            break;
>+
>+        case PA_COMMAND_SET_SOURCE_OUTPUT_VOLUME:
>+            so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
>+            break;
>+
>+        default:
>+            pa_assert_not_reached();
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
>+
>+    client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
>+
>+    if (sink) {
>+        CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &sink->sample_spec), tag, PA_ERR_INVALID);
>+
>+        pa_log_debug("Client %s changes volume of sink %s.", client_name, sink->name);
>+        pa_sink_set_volume(sink, &volume, true, true);
>+    } else if (source) {
>+        CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &source->sample_spec), tag, PA_ERR_INVALID);
>+
>+        pa_log_debug("Client %s changes volume of source %s.", client_name, source->name);
>+        pa_source_set_volume(source, &volume, true, true);
>+    } else if (si) {
>+        CHECK_VALIDITY(c->pstream, si->volume_writable, tag, PA_ERR_BADSTATE);
>+        CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &si->sample_spec), tag, PA_ERR_INVALID);
>+
>+        pa_log_debug("Client %s changes volume of sink input %s.",
>+                     client_name,
>+                     pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
>+        pa_sink_input_set_volume(si, &volume, true, true);
>+    } else if (so) {
>+        CHECK_VALIDITY(c->pstream, so->volume_writable, tag, PA_ERR_BADSTATE);
>+        CHECK_VALIDITY(c->pstream, volume.channels == 1 || pa_cvolume_compatible(&volume, &so->sample_spec), tag, PA_ERR_INVALID);
>+
>+        pa_log_debug("Client %s changes volume of source output %s.",
>+                     client_name,
>+                     pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
>+        pa_source_output_set_volume(so, &volume, true, true);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_set_mute(
>+        pa_pdispatch *pd,
>+        uint32_t command,
>+        uint32_t tag,
>+        pa_tagstruct *t,
>+        void *userdata) {
>+
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    bool mute;
>+    pa_sink *sink = NULL;
>+    pa_source *source = NULL;
>+    pa_sink_input *si = NULL;
>+    pa_source_output *so = NULL;
>+    const char *name = NULL, *client_name;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        (command == PA_COMMAND_SET_SINK_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
>+        (command == PA_COMMAND_SET_SOURCE_MUTE && pa_tagstruct_gets(t, &name) < 0) ||
>+        pa_tagstruct_get_boolean(t, &mute) ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_MUTE ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
>+
>+    switch (command) {
>+
>+        case PA_COMMAND_SET_SINK_MUTE:
>+            if (idx != PA_INVALID_INDEX)
>+                sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
>+            else
>+                sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
>+
>+            break;
>+
>+        case PA_COMMAND_SET_SOURCE_MUTE:
>+            if (idx != PA_INVALID_INDEX)
>+                source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
>+            else
>+                source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
>+
>+            break;
>+
>+        case PA_COMMAND_SET_SINK_INPUT_MUTE:
>+            si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
>+            break;
>+
>+        case PA_COMMAND_SET_SOURCE_OUTPUT_MUTE:
>+            so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
>+            break;
>+
>+        default:
>+            pa_assert_not_reached();
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, si || so || sink || source, tag, PA_ERR_NOENTITY);
>+
>+    client_name = pa_strnull(pa_proplist_gets(c->client->proplist, PA_PROP_APPLICATION_PROCESS_BINARY));
>+
>+    if (sink) {
>+        pa_log_debug("Client %s changes mute of sink %s.", client_name, sink->name);
>+        pa_sink_set_mute(sink, mute, true);
>+    } else if (source) {
>+        pa_log_debug("Client %s changes mute of source %s.", client_name, source->name);
>+        pa_source_set_mute(source, mute, true);
>+    } else if (si) {
>+        pa_log_debug("Client %s changes mute of sink input %s.",
>+                     client_name,
>+                     pa_strnull(pa_proplist_gets(si->proplist, PA_PROP_MEDIA_NAME)));
>+        pa_sink_input_set_mute(si, mute, true);
>+    } else if (so) {
>+        pa_log_debug("Client %s changes mute of source output %s.",
>+                     client_name,
>+                     pa_strnull(pa_proplist_gets(so->proplist, PA_PROP_MEDIA_NAME)));
>+        pa_source_output_set_mute(so, mute, true);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    bool b;
>+    playback_stream *s;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_get_boolean(t, &b) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
>+    s = pa_idxset_get_by_index(c->output_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+    CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+    pa_sink_input_cork(s->sink_input, b);
>+
>+    if (b)
>+        s->is_underrun = true;
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_trigger_or_flush_or_prebuf_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    playback_stream *s;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
>+    s = pa_idxset_get_by_index(c->output_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+    CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+    switch (command) {
>+        case PA_COMMAND_FLUSH_PLAYBACK_STREAM:
>+            pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_FLUSH, NULL, 0, NULL);
>+            break;
>+
>+        case PA_COMMAND_PREBUF_PLAYBACK_STREAM:
>+            pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_PREBUF_FORCE, NULL, 0, NULL);
>+            break;
>+
>+        case PA_COMMAND_TRIGGER_PLAYBACK_STREAM:
>+            pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_TRIGGER, NULL, 0, NULL);
>+            break;
>+
>+        default:
>+            pa_assert_not_reached();
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    record_stream *s;
>+    bool b;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_get_boolean(t, &b) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    s = pa_idxset_get_by_index(c->record_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+    pa_source_output_cork(s->source_output, b);
>+    pa_memblockq_prebuf_force(s->memblockq);
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    record_stream *s;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    s = pa_idxset_get_by_index(c->record_streams, idx);
>+    CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+    pa_memblockq_flush_read(s->memblockq);
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_set_stream_buffer_attr(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    pa_buffer_attr a;
>+    pa_tagstruct *reply;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    memset(&a, 0, sizeof(a));
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    if (command == PA_COMMAND_SET_PLAYBACK_STREAM_BUFFER_ATTR) {
>+        playback_stream *s;
>+        bool adjust_latency = false, early_requests = false;
>+
>+        s = pa_idxset_get_by_index(c->output_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+        CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+        if (pa_tagstruct_get(
>+                    t,
>+                    PA_TAG_U32, &a.maxlength,
>+                    PA_TAG_U32, &a.tlength,
>+                    PA_TAG_U32, &a.prebuf,
>+                    PA_TAG_U32, &a.minreq,
>+                    PA_TAG_INVALID) < 0 ||
>+            (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
>+            (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
>+            !pa_tagstruct_eof(t)) {
>+            protocol_error(c);
>+            return;
>+        }
>+
>+        s->adjust_latency = adjust_latency;
>+        s->early_requests = early_requests;
>+        s->buffer_attr_req = a;
>+
>+        fix_playback_buffer_attr(s);
>+        pa_assert_se(pa_asyncmsgq_send(s->sink_input->sink->asyncmsgq, PA_MSGOBJECT(s->sink_input), SINK_INPUT_MESSAGE_UPDATE_BUFFER_ATTR, NULL, 0, NULL) == 0);
>+
>+        reply = reply_new(tag);
>+        pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
>+        pa_tagstruct_putu32(reply, s->buffer_attr.tlength);
>+        pa_tagstruct_putu32(reply, s->buffer_attr.prebuf);
>+        pa_tagstruct_putu32(reply, s->buffer_attr.minreq);
>+
>+        if (c->version >= 13)
>+            pa_tagstruct_put_usec(reply, s->configured_sink_latency);
>+
>+    } else {
>+        record_stream *s;
>+        bool adjust_latency = false, early_requests = false;
>+        pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_BUFFER_ATTR);
>+
>+        s = pa_idxset_get_by_index(c->record_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+        if (pa_tagstruct_get(
>+                    t,
>+                    PA_TAG_U32, &a.maxlength,
>+                    PA_TAG_U32, &a.fragsize,
>+                    PA_TAG_INVALID) < 0 ||
>+            (c->version >= 13 && pa_tagstruct_get_boolean(t, &adjust_latency) < 0) ||
>+            (c->version >= 14 && pa_tagstruct_get_boolean(t, &early_requests) < 0) ||
>+            !pa_tagstruct_eof(t)) {
>+            protocol_error(c);
>+            return;
>+        }
>+
>+        s->adjust_latency = adjust_latency;
>+        s->early_requests = early_requests;
>+        s->buffer_attr_req = a;
>+
>+        fix_record_buffer_attr_pre(s);
>+        pa_memblockq_set_maxlength(s->memblockq, s->buffer_attr.maxlength);
>+        pa_memblockq_get_attr(s->memblockq, &s->buffer_attr);
>+        fix_record_buffer_attr_post(s);
>+
>+        reply = reply_new(tag);
>+        pa_tagstruct_putu32(reply, s->buffer_attr.maxlength);
>+        pa_tagstruct_putu32(reply, s->buffer_attr.fragsize);
>+
>+        if (c->version >= 13)
>+            pa_tagstruct_put_usec(reply, s->configured_source_latency);
>+    }
>+
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_update_stream_sample_rate(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    uint32_t rate;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_getu32(t, &rate) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, pa_sample_rate_valid(rate), tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_SAMPLE_RATE) {
>+        playback_stream *s;
>+
>+        s = pa_idxset_get_by_index(c->output_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+        CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+        pa_sink_input_set_rate(s->sink_input, rate);
>+
>+    } else {
>+        record_stream *s;
>+        pa_assert(command == PA_COMMAND_UPDATE_RECORD_STREAM_SAMPLE_RATE);
>+
>+        s = pa_idxset_get_by_index(c->record_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+        pa_source_output_set_rate(s->source_output, rate);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_update_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    uint32_t mode;
>+    pa_proplist *p;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    p = pa_proplist_new();
>+
>+    if (command == PA_COMMAND_UPDATE_CLIENT_PROPLIST) {
>+
>+        if (pa_tagstruct_getu32(t, &mode) < 0 ||
>+            pa_tagstruct_get_proplist(t, p) < 0 ||
>+            !pa_tagstruct_eof(t)) {
>+            protocol_error(c);
>+            pa_proplist_free(p);
>+            return;
>+        }
>+
>+    } else {
>+
>+        if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+            pa_tagstruct_getu32(t, &mode) < 0 ||
>+            pa_tagstruct_get_proplist(t, p) < 0 ||
>+            !pa_tagstruct_eof(t)) {
>+            protocol_error(c);
>+            pa_proplist_free(p);
>+            return;
>+        }
>+    }
>+
>+    if (!(mode == PA_UPDATE_SET || mode == PA_UPDATE_MERGE || mode == PA_UPDATE_REPLACE)) {
>+        pa_proplist_free(p);
>+        CHECK_VALIDITY(c->pstream, false, tag, PA_ERR_INVALID);
>+    }
>+
>+    if (command == PA_COMMAND_UPDATE_PLAYBACK_STREAM_PROPLIST) {
>+        playback_stream *s;
>+
>+        s = pa_idxset_get_by_index(c->output_streams, idx);
>+        if (!s || !playback_stream_isinstance(s)) {
>+            pa_proplist_free(p);
>+            CHECK_VALIDITY(c->pstream, false, tag, PA_ERR_NOENTITY);
>+        }
>+        pa_sink_input_update_proplist(s->sink_input, mode, p);
>+
>+    } else if (command == PA_COMMAND_UPDATE_RECORD_STREAM_PROPLIST) {
>+        record_stream *s;
>+
>+        if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
>+            pa_proplist_free(p);
>+            CHECK_VALIDITY(c->pstream, false, tag, PA_ERR_NOENTITY);
>+        }
>+        pa_source_output_update_proplist(s->source_output, mode, p);
>+
>+    } else {
>+        pa_assert(command == PA_COMMAND_UPDATE_CLIENT_PROPLIST);
>+
>+        pa_client_update_proplist(c->client, mode, p);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+    pa_proplist_free(p);
>+}
>+
>+static void command_remove_proplist(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    unsigned changed = 0;
>+    pa_proplist *p;
>+    pa_strlist *l = NULL;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    if (command != PA_COMMAND_REMOVE_CLIENT_PROPLIST) {
>+
>+        if (pa_tagstruct_getu32(t, &idx) < 0) {
>+            protocol_error(c);
>+            return;
>+        }
>+    }
>+
>+    if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
>+        playback_stream *s;
>+
>+        s = pa_idxset_get_by_index(c->output_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+        CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+        p = s->sink_input->proplist;
>+
>+    } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
>+        record_stream *s;
>+
>+        s = pa_idxset_get_by_index(c->record_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+        p = s->source_output->proplist;
>+    } else {
>+        pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
>+
>+        p = c->client->proplist;
>+    }
>+
>+    for (;;) {
>+        const char *k;
>+
>+        if (pa_tagstruct_gets(t, &k) < 0) {
>+            protocol_error(c);
>+            pa_strlist_free(l);
>+            return;
>+        }
>+
>+        if (!k)
>+            break;
>+
>+        l = pa_strlist_prepend(l, k);
>+    }
>+
>+    if (!pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        pa_strlist_free(l);
>+        return;
>+    }
>+
>+    for (;;) {
>+        char *z;
>+
>+        l = pa_strlist_pop(l, &z);
>+
>+        if (!z)
>+            break;
>+
>+        changed += (unsigned) (pa_proplist_unset(p, z) >= 0);
>+        pa_xfree(z);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+
>+    if (changed) {
>+        if (command == PA_COMMAND_REMOVE_PLAYBACK_STREAM_PROPLIST) {
>+            playback_stream *s;
>+
>+            s = pa_idxset_get_by_index(c->output_streams, idx);
>+            pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->sink_input->index);
>+
>+        } else if (command == PA_COMMAND_REMOVE_RECORD_STREAM_PROPLIST) {
>+            record_stream *s;
>+
>+            s = pa_idxset_get_by_index(c->record_streams, idx);
>+            pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, s->source_output->index);
>+
>+        } else {
>+            pa_assert(command == PA_COMMAND_REMOVE_CLIENT_PROPLIST);
>+            pa_subscription_post(c->protocol->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_CHANGE, c->client->index);
>+        }
>+    }
>+}
>+
>+static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    const char *s;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_gets(t, &s) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !s || pa_namereg_is_valid_name(s), tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_SET_DEFAULT_SOURCE) {
>+        pa_source *source;
>+
>+        source = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SOURCE);
>+        CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
>+
>+        pa_namereg_set_default_source(c->protocol->core, source);
>+    } else {
>+        pa_sink *sink;
>+        pa_assert(command == PA_COMMAND_SET_DEFAULT_SINK);
>+
>+        sink = pa_namereg_get(c->protocol->core, s, PA_NAMEREG_SINK);
>+        CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
>+
>+        pa_namereg_set_default_sink(c->protocol->core, sink);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    const char *name;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_gets(t, &name) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, name && pa_utf8_valid(name), tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
>+        playback_stream *s;
>+
>+        s = pa_idxset_get_by_index(c->output_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+        CHECK_VALIDITY(c->pstream, playback_stream_isinstance(s), tag, PA_ERR_NOENTITY);
>+
>+        pa_sink_input_set_name(s->sink_input, name);
>+
>+    } else {
>+        record_stream *s;
>+        pa_assert(command == PA_COMMAND_SET_RECORD_STREAM_NAME);
>+
>+        s = pa_idxset_get_by_index(c->record_streams, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+        pa_source_output_set_name(s->source_output, name);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+
>+    if (command == PA_COMMAND_KILL_CLIENT) {
>+        pa_client *client;
>+
>+        client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
>+        CHECK_VALIDITY(c->pstream, client, tag, PA_ERR_NOENTITY);
>+
>+        pa_native_connection_ref(c);
>+        pa_client_kill(client);
>+
>+    } else if (command == PA_COMMAND_KILL_SINK_INPUT) {
>+        pa_sink_input *s;
>+
>+        s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+        pa_native_connection_ref(c);
>+        pa_sink_input_kill(s);
>+    } else {
>+        pa_source_output *s;
>+
>+        pa_assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
>+
>+        s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
>+        CHECK_VALIDITY(c->pstream, s, tag, PA_ERR_NOENTITY);
>+
>+        pa_native_connection_ref(c);
>+        pa_source_output_kill(s);
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+    pa_native_connection_unref(c);
>+}
>+
>+static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    pa_module *m;
>+    const char *name, *argument;
>+    pa_tagstruct *reply;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_gets(t, &name) < 0 ||
>+        pa_tagstruct_gets(t, &argument) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, name && *name && pa_utf8_valid(name) && !strchr(name, '/'), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, !argument || pa_utf8_valid(argument), tag, PA_ERR_INVALID);
>+
>+    if (!(m = pa_module_load(c->protocol->core, name, argument))) {
>+        pa_pstream_send_error(c->pstream, tag, PA_ERR_MODINITFAILED);
>+        return;
>+    }
>+
>+    reply = reply_new(tag);
>+    pa_tagstruct_putu32(reply, m->index);
>+    pa_pstream_send_tagstruct(c->pstream, reply);
>+}
>+
>+static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx;
>+    pa_module *m;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
>+    CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOENTITY);
>+
>+    pa_module_unload_request(m, false);
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_move_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx = PA_INVALID_INDEX, idx_device = PA_INVALID_INDEX;
>+    const char *name_device = NULL;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_getu32(t, &idx_device) < 0 ||
>+        pa_tagstruct_gets(t, &name_device) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
>+
>+    CHECK_VALIDITY(c->pstream, !name_device || pa_namereg_is_valid_name_or_wildcard(name_device, command == PA_COMMAND_MOVE_SINK_INPUT ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx_device != PA_INVALID_INDEX) ^ (name_device != NULL), tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_MOVE_SINK_INPUT) {
>+        pa_sink_input *si = NULL;
>+        pa_sink *sink = NULL;
>+
>+        si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
>+
>+        if (idx_device != PA_INVALID_INDEX)
>+            sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx_device);
>+        else
>+            sink = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SINK);
>+
>+        CHECK_VALIDITY(c->pstream, si && sink, tag, PA_ERR_NOENTITY);
>+
>+        if (pa_sink_input_move_to(si, sink, true) < 0) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+            return;
>+        }
>+    } else {
>+        pa_source_output *so = NULL;
>+        pa_source *source;
>+
>+        pa_assert(command == PA_COMMAND_MOVE_SOURCE_OUTPUT);
>+
>+        so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
>+
>+        if (idx_device != PA_INVALID_INDEX)
>+            source = pa_idxset_get_by_index(c->protocol->core->sources, idx_device);
>+        else
>+            source = pa_namereg_get(c->protocol->core, name_device, PA_NAMEREG_SOURCE);
>+
>+        CHECK_VALIDITY(c->pstream, so && source, tag, PA_ERR_NOENTITY);
>+
>+        if (pa_source_output_move_to(so, source, true) < 0) {
>+            pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+            return;
>+        }
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_suspend(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx = PA_INVALID_INDEX;
>+    const char *name = NULL;
>+    bool b;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_gets(t, &name) < 0 ||
>+        pa_tagstruct_get_boolean(t, &b) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SUSPEND_SINK ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE) || *name == 0, tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_SUSPEND_SINK) {
>+
>+        if (idx == PA_INVALID_INDEX && name && !*name) {
>+
>+            pa_log_debug("%s all sinks", b ? "Suspending" : "Resuming");
>+
>+            if (pa_sink_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+                return;
>+            }
>+        } else {
>+            pa_sink *sink = NULL;
>+
>+            if (idx != PA_INVALID_INDEX)
>+                sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
>+            else
>+                sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
>+
>+            CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
>+
>+            pa_log_debug("%s of sink %s requested by client %" PRIu32 ".",
>+                         b ? "Suspending" : "Resuming", sink->name, c->client->index);
>+
>+            if (pa_sink_suspend(sink, b, PA_SUSPEND_USER) < 0) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+                return;
>+            }
>+        }
>+    } else {
>+
>+        pa_assert(command == PA_COMMAND_SUSPEND_SOURCE);
>+
>+        if (idx == PA_INVALID_INDEX && name && !*name) {
>+
>+            pa_log_debug("%s all sources", b ? "Suspending" : "Resuming");
>+
>+            if (pa_source_suspend_all(c->protocol->core, b, PA_SUSPEND_USER) < 0) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+                return;
>+            }
>+
>+        } else {
>+            pa_source *source;
>+
>+            if (idx != PA_INVALID_INDEX)
>+                source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
>+            else
>+                source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
>+
>+            CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
>+
>+            pa_log_debug("%s of source %s requested by client %" PRIu32 ".",
>+                         b ? "Suspending" : "Resuming", source->name, c->client->index);
>+
>+            if (pa_source_suspend(source, b, PA_SUSPEND_USER) < 0) {
>+                pa_pstream_send_error(c->pstream, tag, PA_ERR_INVALID);
>+                return;
>+            }
>+        }
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_extension(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx = PA_INVALID_INDEX;
>+    const char *name = NULL;
>+    pa_module *m;
>+    pa_native_protocol_ext_cb_t cb;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_gets(t, &name) < 0) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name || pa_utf8_valid(name), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
>+
>+    if (idx != PA_INVALID_INDEX)
>+        m = pa_idxset_get_by_index(c->protocol->core->modules, idx);
>+    else
>+        PA_IDXSET_FOREACH(m, c->protocol->core->modules, idx)
>+            if (pa_streq(name, m->name))
>+                break;
>+
>+    CHECK_VALIDITY(c->pstream, m, tag, PA_ERR_NOEXTENSION);
>+    CHECK_VALIDITY(c->pstream, m->load_once || idx != PA_INVALID_INDEX, tag, PA_ERR_INVALID);
>+
>+    cb = (pa_native_protocol_ext_cb_t) (unsigned long) pa_hashmap_get(c->protocol->extensions, m);
>+    CHECK_VALIDITY(c->pstream, cb, tag, PA_ERR_NOEXTENSION);
>+
>+    if (cb(c->protocol, m, c, tag, t) < 0)
>+        protocol_error(c);
>+}
>+
>+static void command_set_card_profile(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx = PA_INVALID_INDEX;
>+    const char *name = NULL, *profile_name = NULL;
>+    pa_card *card = NULL;
>+    pa_card_profile *profile;
>+    int ret;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_gets(t, &name) < 0 ||
>+        pa_tagstruct_gets(t, &profile_name) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name(name), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, profile_name, tag, PA_ERR_INVALID);
>+
>+    if (idx != PA_INVALID_INDEX)
>+        card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
>+    else
>+        card = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_CARD);
>+
>+    CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
>+
>+    profile = pa_hashmap_get(card->profiles, profile_name);
>+
>+    CHECK_VALIDITY(c->pstream, profile, tag, PA_ERR_NOENTITY);
>+
>+    if ((ret = pa_card_set_profile(card, profile, true)) < 0) {
>+        pa_pstream_send_error(c->pstream, tag, -ret);
>+        return;
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_set_sink_or_source_port(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    uint32_t idx = PA_INVALID_INDEX;
>+    const char *name = NULL, *port = NULL;
>+    int ret;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_gets(t, &name) < 0 ||
>+        pa_tagstruct_gets(t, &port) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !name || pa_namereg_is_valid_name_or_wildcard(name, command == PA_COMMAND_SET_SINK_PORT ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (name != NULL), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, port, tag, PA_ERR_INVALID);
>+
>+    if (command == PA_COMMAND_SET_SINK_PORT) {
>+        pa_sink *sink;
>+
>+        if (idx != PA_INVALID_INDEX)
>+            sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
>+        else
>+            sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK);
>+
>+        CHECK_VALIDITY(c->pstream, sink, tag, PA_ERR_NOENTITY);
>+
>+        if ((ret = pa_sink_set_port(sink, port, true)) < 0) {
>+            pa_pstream_send_error(c->pstream, tag, -ret);
>+            return;
>+        }
>+    } else {
>+        pa_source *source;
>+
>+        pa_assert(command == PA_COMMAND_SET_SOURCE_PORT);
>+
>+        if (idx != PA_INVALID_INDEX)
>+            source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
>+        else
>+            source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE);
>+
>+        CHECK_VALIDITY(c->pstream, source, tag, PA_ERR_NOENTITY);
>+
>+        if ((ret = pa_source_set_port(source, port, true)) < 0) {
>+            pa_pstream_send_error(c->pstream, tag, -ret);
>+            return;
>+        }
>+    }
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+static void command_set_port_latency_offset(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    const char *port_name, *card_name;
>+    uint32_t idx = PA_INVALID_INDEX;
>+    int64_t offset;
>+    pa_card *card = NULL;
>+    pa_device_port *port = NULL;
>+
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(t);
>+
>+    if (pa_tagstruct_getu32(t, &idx) < 0 ||
>+        pa_tagstruct_gets(t, &card_name) < 0 ||
>+        pa_tagstruct_gets(t, &port_name) < 0 ||
>+        pa_tagstruct_gets64(t, &offset) < 0 ||
>+        !pa_tagstruct_eof(t)) {
>+        protocol_error(c);
>+        return;
>+    }
>+
>+    CHECK_VALIDITY(c->pstream, c->authorized, tag, PA_ERR_ACCESS);
>+    CHECK_VALIDITY(c->pstream, !card_name || pa_namereg_is_valid_name(card_name), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, (idx != PA_INVALID_INDEX) ^ (card_name != NULL), tag, PA_ERR_INVALID);
>+    CHECK_VALIDITY(c->pstream, port_name, tag, PA_ERR_INVALID);
>+
>+    if (idx != PA_INVALID_INDEX)
>+        card = pa_idxset_get_by_index(c->protocol->core->cards, idx);
>+    else
>+        card = pa_namereg_get(c->protocol->core, card_name, PA_NAMEREG_CARD);
>+
>+    CHECK_VALIDITY(c->pstream, card, tag, PA_ERR_NOENTITY);
>+
>+    port = pa_hashmap_get(card->ports, port_name);
>+    CHECK_VALIDITY(c->pstream, port, tag, PA_ERR_NOENTITY);
>+
>+    pa_device_port_set_latency_offset(port, offset);
>+
>+    pa_pstream_send_simple_ack(c->pstream, tag);
>+}
>+
>+/*** pstream callbacks ***/
>+
>+static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_cmsg_ancil_data *ancil_data, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+
>+    pa_assert(p);
>+    pa_assert(packet);
>+    pa_native_connection_assert_ref(c);
>+
>+    if (pa_pdispatch_run(c->pdispatch, packet, ancil_data, c) < 0) {
>+        pa_log("invalid packet.");
>+        native_connection_unlink(c);
>+    }
>+}
>+
>+static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, int64_t offset, pa_seek_mode_t seek, const pa_memchunk *chunk, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+    output_stream *stream;
>+
>+    pa_assert(p);
>+    pa_assert(chunk);
>+    pa_native_connection_assert_ref(c);
>+
>+    if (!(stream = OUTPUT_STREAM(pa_idxset_get_by_index(c->output_streams, channel)))) {
>+        pa_log_debug("Client sent block for invalid stream.");
>+        /* Ignoring */
>+        return;
>+    }
>+
>+#ifdef PROTOCOL_NATIVE_DEBUG
>+    pa_log("got %lu bytes from client", (unsigned long) chunk->length);
>+#endif
>+
>+    if (playback_stream_isinstance(stream)) {
>+        playback_stream *ps = PLAYBACK_STREAM(stream);
>+
>+        size_t frame_size = pa_frame_size(&ps->sink_input->sample_spec);
>+        if (chunk->index % frame_size != 0 || chunk->length % frame_size != 0) {
>+            pa_log_warn("Client sent non-aligned memblock: index %d, length %d, frame size: %d",
>+                        (int) chunk->index, (int) chunk->length, (int) frame_size);
>+            return;
>+        }
>+
>+        pa_atomic_inc(&ps->seek_or_post_in_queue);
>+        if (chunk->memblock) {
>+            if (seek != PA_SEEK_RELATIVE || offset != 0)
>+                pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset, chunk, NULL);
>+            else
>+                pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_POST_DATA, NULL, 0, chunk, NULL);
>+        } else
>+            pa_asyncmsgq_post(ps->sink_input->sink->asyncmsgq, PA_MSGOBJECT(ps->sink_input), SINK_INPUT_MESSAGE_SEEK, PA_UINT_TO_PTR(seek), offset+chunk->length, NULL, NULL);
>+
>+    } else {
>+        upload_stream *u = UPLOAD_STREAM(stream);
>+        size_t l;
>+
>+        if (!u->memchunk.memblock) {
>+            if (u->length == chunk->length && chunk->memblock) {
>+                u->memchunk = *chunk;
>+                pa_memblock_ref(u->memchunk.memblock);
>+                u->length = 0;
>+            } else {
>+                u->memchunk.memblock = pa_memblock_new(c->protocol->core->mempool, u->length);
>+                u->memchunk.index = u->memchunk.length = 0;
>+            }
>+        }
>+
>+        pa_assert(u->memchunk.memblock);
>+
>+        l = u->length;
>+        if (l > chunk->length)
>+            l = chunk->length;
>+
>+        if (l > 0) {
>+            void *dst;
>+            dst = pa_memblock_acquire(u->memchunk.memblock);
>+
>+            if (chunk->memblock) {
>+                void *src;
>+                src = pa_memblock_acquire(chunk->memblock);
>+
>+                memcpy((uint8_t*) dst + u->memchunk.index + u->memchunk.length,
>+                       (uint8_t*) src + chunk->index, l);
>+
>+                pa_memblock_release(chunk->memblock);
>+            } else
>+                pa_silence_memory((uint8_t*) dst + u->memchunk.index + u->memchunk.length, l, &u->sample_spec);
>+
>+            pa_memblock_release(u->memchunk.memblock);
>+
>+            u->memchunk.length += l;
>+            u->length -= l;
>+        }
>+    }
>+}
>+
>+static void pstream_die_callback(pa_pstream *p, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+
>+    pa_assert(p);
>+    pa_native_connection_assert_ref(c);
>+
>+    native_connection_unlink(c);
>+    pa_log_info("Connection died.");
>+}
>+
>+static void pstream_drain_callback(pa_pstream *p, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+
>+    pa_assert(p);
>+    pa_native_connection_assert_ref(c);
>+
>+    native_connection_send_memblock(c);
>+}
>+
>+static void pstream_revoke_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
>+    pa_thread_mq *q;
>+
>+    if (!(q = pa_thread_mq_get()))
>+        pa_pstream_send_revoke(p, block_id);
>+    else
>+        pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_REVOKE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
>+}
>+
>+static void pstream_release_callback(pa_pstream *p, uint32_t block_id, void *userdata) {
>+    pa_thread_mq *q;
>+
>+    if (!(q = pa_thread_mq_get()))
>+        pa_pstream_send_release(p, block_id);
>+    else
>+        pa_asyncmsgq_post(q->outq, PA_MSGOBJECT(userdata), CONNECTION_MESSAGE_RELEASE, PA_UINT_TO_PTR(block_id), 0, NULL, NULL);
>+}
>+
>+/*** client callbacks ***/
>+
>+static void client_kill_cb(pa_client *c) {
>+    pa_assert(c);
>+
>+    native_connection_unlink(PA_NATIVE_CONNECTION(c->userdata));
>+    pa_log_info("Connection killed.");
>+}
>+
>+static void client_send_event_cb(pa_client *client, const char*event, pa_proplist *pl) {
>+    pa_tagstruct *t;
>+    pa_native_connection *c;
>+
>+    pa_assert(client);
>+    c = PA_NATIVE_CONNECTION(client->userdata);
>+    pa_native_connection_assert_ref(c);
>+
>+    if (c->version < 15)
>+      return;
>+
>+    t = pa_tagstruct_new();
>+    pa_tagstruct_putu32(t, PA_COMMAND_CLIENT_EVENT);
>+    pa_tagstruct_putu32(t, (uint32_t) -1); /* tag */
>+    pa_tagstruct_puts(t, event);
>+    pa_tagstruct_put_proplist(t, pl);
>+    pa_pstream_send_tagstruct(c->pstream, t);
>+}
>+
>+/*** module entry points ***/
>+
>+static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *t, void *userdata) {
>+    pa_native_connection *c = PA_NATIVE_CONNECTION(userdata);
>+
>+    pa_assert(m);
>+    pa_native_connection_assert_ref(c);
>+    pa_assert(c->auth_timeout_event == e);
>+
>+    if (!c->authorized) {
>+        native_connection_unlink(c);
>+        pa_log_info("Connection terminated due to authentication timeout.");
>+    }
>+}
>+
>+void pa_native_protocol_connect(pa_native_protocol *p, pa_iochannel *io, pa_native_options *o) {
>+    pa_native_connection *c;
>+    char pname[128];
>+    pa_client *client;
>+    pa_client_new_data data;
>+
>+    pa_assert(p);
>+    pa_assert(io);
>+    pa_assert(o);
>+
>+    if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
>+        pa_log_warn("Warning! Too many connections (%u), dropping incoming connection.", MAX_CONNECTIONS);
>+        pa_iochannel_free(io);
>+        return;
>+    }
>+
>+    pa_client_new_data_init(&data);
>+    data.module = o->module;
>+    data.driver = __FILE__;
>+    pa_iochannel_socket_peer_to_string(io, pname, sizeof(pname));
>+    pa_proplist_setf(data.proplist, PA_PROP_APPLICATION_NAME, "Native client (%s)", pname);
>+    pa_proplist_sets(data.proplist, "native-protocol.peer", pname);
>+    client = pa_client_new(p->core, &data);
>+    pa_client_new_data_done(&data);
>+
>+    if (!client)
>+        return;
>+
>+    c = pa_msgobject_new(pa_native_connection);
>+    c->parent.parent.free = native_connection_free;
>+    c->parent.process_msg = native_connection_process_msg;
>+    c->protocol = p;
>+    c->options = pa_native_options_ref(o);
>+    c->authorized = false;
>+    c->srbpending = NULL;
>+
>+    if (o->auth_anonymous) {
>+        pa_log_info("Client authenticated anonymously.");
>+        c->authorized = true;
>+    }
>+
>+    if (!c->authorized &&
>+        o->auth_ip_acl &&
>+        pa_ip_acl_check(o->auth_ip_acl, pa_iochannel_get_recv_fd(io)) > 0) {
>+
>+        pa_log_info("Client authenticated by IP ACL.");
>+        c->authorized = true;
>+    }
>+
>+    if (!c->authorized)
>+        c->auth_timeout_event = pa_core_rttime_new(p->core, pa_rtclock_now() + AUTH_TIMEOUT, auth_timeout, c);
>+    else
>+        c->auth_timeout_event = NULL;
>+
>+    c->is_local = pa_iochannel_socket_is_local(io);
>+    c->version = 8;
>+
>+    c->client = client;
>+    c->client->kill = client_kill_cb;
>+    c->client->send_event = client_send_event_cb;
>+    c->client->userdata = c;
>+
>+    c->pstream = pa_pstream_new(p->core->mainloop, io, p->core->mempool);
>+    pa_pstream_set_receive_packet_callback(c->pstream, pstream_packet_callback, c);
>+    pa_pstream_set_receive_memblock_callback(c->pstream, pstream_memblock_callback, c);
>+    pa_pstream_set_die_callback(c->pstream, pstream_die_callback, c);
>+    pa_pstream_set_drain_callback(c->pstream, pstream_drain_callback, c);
>+    pa_pstream_set_revoke_callback(c->pstream, pstream_revoke_callback, c);
>+    pa_pstream_set_release_callback(c->pstream, pstream_release_callback, c);
>+
>+    c->pdispatch = pa_pdispatch_new(p->core->mainloop, true, command_table, PA_COMMAND_MAX);
>+
>+    c->record_streams = pa_idxset_new(NULL, NULL);
>+    c->output_streams = pa_idxset_new(NULL, NULL);
>+
>+    c->rrobin_index = PA_IDXSET_INVALID;
>+    c->subscription = NULL;
>+
>+    pa_idxset_put(p->connections, c, NULL);
>+
>+#ifdef HAVE_CREDS
>+    if (pa_iochannel_creds_supported(io))
>+        pa_iochannel_creds_enable(io);
>+#endif
>+
>+    pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_CONNECTION_PUT], c);
>+}
>+
>+void pa_native_protocol_disconnect(pa_native_protocol *p, pa_module *m) {
>+    pa_native_connection *c;
>+    void *state = NULL;
>+
>+    pa_assert(p);
>+    pa_assert(m);
>+
>+    while ((c = pa_idxset_iterate(p->connections, &state, NULL)))
>+        if (c->options->module == m)
>+            native_connection_unlink(c);
>+}
>+
>+static pa_native_protocol* native_protocol_new(pa_core *c) {
>+    pa_native_protocol *p;
>+    pa_native_hook_t h;
>+
>+    pa_assert(c);
>+
>+    p = pa_xnew(pa_native_protocol, 1);
>+    PA_REFCNT_INIT(p);
>+    p->core = c;
>+    p->connections = pa_idxset_new(NULL, NULL);
>+
>+    p->servers = NULL;
>+
>+    p->extensions = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
>+
>+    for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
>+        pa_hook_init(&p->hooks[h], p);
>+
>+    pa_assert_se(pa_shared_set(c, "native-protocol", p) >= 0);
>+
>+    return p;
>+}
>+
>+pa_native_protocol* pa_native_protocol_get(pa_core *c) {
>+    pa_native_protocol *p;
>+
>+    if ((p = pa_shared_get(c, "native-protocol")))
>+        return pa_native_protocol_ref(p);
>+
>+    return native_protocol_new(c);
>+}
>+
>+pa_native_protocol* pa_native_protocol_ref(pa_native_protocol *p) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+
>+    PA_REFCNT_INC(p);
>+
>+    return p;
>+}
>+
>+void pa_native_protocol_unref(pa_native_protocol *p) {
>+    pa_native_connection *c;
>+    pa_native_hook_t h;
>+
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+
>+    if (PA_REFCNT_DEC(p) > 0)
>+        return;
>+
>+    while ((c = pa_idxset_first(p->connections, NULL)))
>+        native_connection_unlink(c);
>+
>+    pa_idxset_free(p->connections, NULL);
>+
>+    pa_strlist_free(p->servers);
>+
>+    for (h = 0; h < PA_NATIVE_HOOK_MAX; h++)
>+        pa_hook_done(&p->hooks[h]);
>+
>+    pa_hashmap_free(p->extensions);
>+
>+    pa_assert_se(pa_shared_remove(p->core, "native-protocol") >= 0);
>+
>+    pa_xfree(p);
>+}
>+
>+void pa_native_protocol_add_server_string(pa_native_protocol *p, const char *name) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+    pa_assert(name);
>+
>+    p->servers = pa_strlist_prepend(p->servers, name);
>+
>+    pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
>+}
>+
>+void pa_native_protocol_remove_server_string(pa_native_protocol *p, const char *name) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+    pa_assert(name);
>+
>+    p->servers = pa_strlist_remove(p->servers, name);
>+
>+    pa_hook_fire(&p->hooks[PA_NATIVE_HOOK_SERVERS_CHANGED], p->servers);
>+}
>+
>+pa_hook *pa_native_protocol_hooks(pa_native_protocol *p) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+
>+    return p->hooks;
>+}
>+
>+pa_strlist *pa_native_protocol_servers(pa_native_protocol *p) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+
>+    return p->servers;
>+}
>+
>+int pa_native_protocol_install_ext(pa_native_protocol *p, pa_module *m, pa_native_protocol_ext_cb_t cb) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+    pa_assert(m);
>+    pa_assert(cb);
>+    pa_assert(!pa_hashmap_get(p->extensions, m));
>+
>+    pa_assert_se(pa_hashmap_put(p->extensions, m, (void*) (unsigned long) cb) == 0);
>+    return 0;
>+}
>+
>+void pa_native_protocol_remove_ext(pa_native_protocol *p, pa_module *m) {
>+    pa_assert(p);
>+    pa_assert(PA_REFCNT_VALUE(p) >= 1);
>+    pa_assert(m);
>+
>+    pa_assert_se(pa_hashmap_remove(p->extensions, m));
>+}
>+
>+pa_native_options* pa_native_options_new(void) {
>+    pa_native_options *o;
>+
>+    o = pa_xnew0(pa_native_options, 1);
>+    PA_REFCNT_INIT(o);
>+
>+    return o;
>+}
>+
>+pa_native_options* pa_native_options_ref(pa_native_options *o) {
>+    pa_assert(o);
>+    pa_assert(PA_REFCNT_VALUE(o) >= 1);
>+
>+    PA_REFCNT_INC(o);
>+
>+    return o;
>+}
>+
>+void pa_native_options_unref(pa_native_options *o) {
>+    pa_assert(o);
>+    pa_assert(PA_REFCNT_VALUE(o) >= 1);
>+
>+    if (PA_REFCNT_DEC(o) > 0)
>+        return;
>+
>+    pa_xfree(o->auth_group);
>+
>+    if (o->auth_ip_acl)
>+        pa_ip_acl_free(o->auth_ip_acl);
>+
>+    if (o->auth_cookie)
>+        pa_auth_cookie_unref(o->auth_cookie);
>+
>+    pa_xfree(o);
>+}
>+
>+int pa_native_options_parse(pa_native_options *o, pa_core *c, pa_modargs *ma) {
>+    bool enabled;
>+    const char *acl;
>+
>+    pa_assert(o);
>+    pa_assert(PA_REFCNT_VALUE(o) >= 1);
>+    pa_assert(ma);
>+
>+    o->srbchannel = true;
>+    if (pa_modargs_get_value_boolean(ma, "srbchannel", &o->srbchannel) < 0) {
>+        pa_log("srbchannel= expects a boolean argument.");
>+        return -1;
>+    }
>+
>+    if (pa_modargs_get_value_boolean(ma, "auth-anonymous", &o->auth_anonymous) < 0) {
>+        pa_log("auth-anonymous= expects a boolean argument.");
>+        return -1;
>+    }
>+
>+    enabled = true;
>+    if (pa_modargs_get_value_boolean(ma, "auth-group-enable", &enabled) < 0) {
>+        pa_log("auth-group-enable= expects a boolean argument.");
>+        return -1;
>+    }
>+
>+    pa_xfree(o->auth_group);
>+    o->auth_group = enabled ? pa_xstrdup(pa_modargs_get_value(ma, "auth-group", pa_in_system_mode() ? PA_ACCESS_GROUP : NULL)) : NULL;
>+
>+#ifndef HAVE_CREDS
>+    if (o->auth_group)
>+        pa_log_warn("Authentication group configured, but not available on local system. Ignoring.");
>+#endif
>+
>+    if ((acl = pa_modargs_get_value(ma, "auth-ip-acl", NULL))) {
>+        pa_ip_acl *ipa;
>+
>+        if (!(ipa = pa_ip_acl_new(acl))) {
>+            pa_log("Failed to parse IP ACL '%s'", acl);
>+            return -1;
>+        }
>+
>+        if (o->auth_ip_acl)
>+            pa_ip_acl_free(o->auth_ip_acl);
>+
>+        o->auth_ip_acl = ipa;
>+    }
>+
>+    enabled = true;
>+    if (pa_modargs_get_value_boolean(ma, "auth-cookie-enabled", &enabled) < 0) {
>+        pa_log("auth-cookie-enabled= expects a boolean argument.");
>+        return -1;
>+    }
>+
>+    if (o->auth_cookie)
>+        pa_auth_cookie_unref(o->auth_cookie);
>+
>+    if (enabled) {
>+        const char *cn;
>+
>+        /* The new name for this is 'auth-cookie', for compat reasons
>+         * we check the old name too */
>+        cn = pa_modargs_get_value(ma, "auth-cookie", NULL);
>+        if (!cn)
>+            cn = pa_modargs_get_value(ma, "cookie", NULL);
>+
>+        if (cn)
>+            o->auth_cookie = pa_auth_cookie_get(c, cn, true, PA_NATIVE_COOKIE_LENGTH);
>+        else {
>+            o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE, false, PA_NATIVE_COOKIE_LENGTH);
>+            if (!o->auth_cookie) {
>+                char *fallback_path;
>+
>+                if (pa_append_to_home_dir(PA_NATIVE_COOKIE_FILE_FALLBACK, &fallback_path) >= 0) {
>+                    o->auth_cookie = pa_auth_cookie_get(c, fallback_path, false, PA_NATIVE_COOKIE_LENGTH);
>+                    pa_xfree(fallback_path);
>+                }
>+
>+                if (!o->auth_cookie)
>+                    o->auth_cookie = pa_auth_cookie_get(c, PA_NATIVE_COOKIE_FILE, true, PA_NATIVE_COOKIE_LENGTH);
>+            }
>+        }
>+
>+        if (!o->auth_cookie)
>+            return -1;
>+
>+    } else
>+          o->auth_cookie = NULL;
>+
>+    return 0;
>+}
>+
>+pa_pstream* pa_native_connection_get_pstream(pa_native_connection *c) {
>+    pa_native_connection_assert_ref(c);
>+
>+    return c->pstream;
>+}
>+
>+pa_client* pa_native_connection_get_client(pa_native_connection *c) {
>+    pa_native_connection_assert_ref(c);
>+
>+    return c->client;
>+}
>diff -Naur a/src/pulsecore/rtpoll.c b/src/pulsecore/rtpoll.c
>--- a/src/pulsecore/rtpoll.c	2016-01-30 17:31:02.000000000 -0800
>+++ b/src/pulsecore/rtpoll.c	2016-01-31 12:11:50.000000000 -0800
>@@ -27,6 +27,7 @@
> #include <string.h>
> #include <errno.h>
> 
>+#include <pulsecore/dynarray.h>
> #include <pulse/xmalloc.h>
> #include <pulse/timeval.h>
> 
>@@ -63,6 +64,18 @@
> #endif
> 
>     PA_LLIST_HEAD(pa_rtpoll_item, items);
>+    
>+    pa_mainloop_api mainloop_api;
>+
>+    pa_dynarray *io_events;
>+
>+    pa_dynarray *time_events;
>+    pa_dynarray *enabled_time_events;
>+    pa_dynarray *expired_time_events;
>+    pa_time_event *cached_next_time_event;
>+
>+    pa_dynarray *defer_events;
>+    pa_dynarray *enabled_defer_events;
> };
> 
> struct pa_rtpoll_item {
>@@ -82,8 +95,325 @@
>     PA_LLIST_FIELDS(pa_rtpoll_item);
> };
> 
>+struct pa_io_event {
>+    pa_rtpoll *rtpoll;
>+    pa_rtpoll_item *rtpoll_item;
>+    pa_io_event_flags_t events;
>+    pa_io_event_cb_t callback;
>+    pa_io_event_destroy_cb_t destroy_callback;
>+    void *userdata;
>+};
>+
>+static void io_event_enable(pa_io_event *event, pa_io_event_flags_t events);
>+
>+struct pa_time_event {
>+    pa_rtpoll *rtpoll;
>+    pa_usec_t time;
>+    bool use_rtclock;
>+    bool enabled;
>+    pa_time_event_cb_t callback;
>+    pa_time_event_destroy_cb_t destroy_callback;
>+    void *userdata;
>+};
>+
>+static void time_event_restart(pa_time_event *event, const struct timeval *tv);
>+
>+struct pa_defer_event {
>+    pa_rtpoll *rtpoll;
>+    bool enabled;
>+    pa_defer_event_cb_t callback;
>+    pa_defer_event_destroy_cb_t destroy_callback;
>+    void *userdata;
>+};
>+
>+static void defer_event_enable(pa_defer_event *event, int enable);
>+
> PA_STATIC_FLIST_DECLARE(items, 0, pa_xfree);
> 
>+static short map_flags_to_libc(pa_io_event_flags_t flags) {
>+    return (short)
>+        ((flags & PA_IO_EVENT_INPUT ? POLLIN : 0) |
>+         (flags & PA_IO_EVENT_OUTPUT ? POLLOUT : 0) |
>+         (flags & PA_IO_EVENT_ERROR ? POLLERR : 0) |
>+         (flags & PA_IO_EVENT_HANGUP ? POLLHUP : 0));
>+}
>+
>+static pa_io_event_flags_t map_flags_from_libc(short flags) {
>+    return
>+        (flags & POLLIN ? PA_IO_EVENT_INPUT : 0) |
>+        (flags & POLLOUT ? PA_IO_EVENT_OUTPUT : 0) |
>+        (flags & POLLERR ? PA_IO_EVENT_ERROR : 0) |
>+        (flags & POLLHUP ? PA_IO_EVENT_HANGUP : 0);
>+}
>+
>+static int io_event_work_cb(pa_rtpoll_item *item) {
>+    pa_io_event *event;
>+    struct pollfd *pollfd;
>+
>+    pa_assert(item);
>+
>+    event = pa_rtpoll_item_get_userdata(item);
>+    pollfd = pa_rtpoll_item_get_pollfd(item, NULL);
>+    event->callback(&event->rtpoll->mainloop_api, event, pollfd->fd,
>+map_flags_from_libc(pollfd->revents), event->userdata);
>+
>+    return 0;
>+}
>+
>+static pa_io_event* io_event_new(pa_mainloop_api *api, int fd, pa_io_event_flags_t events,
>+pa_io_event_cb_t callback,
>+                                 void *userdata) {
>+    pa_rtpoll *rtpoll;
>+    pa_io_event *event;
>+    struct pollfd *pollfd;
>+
>+    pa_assert(api);
>+    pa_assert(api->userdata);
>+    pa_assert(fd >= 0);
>+    pa_assert(callback);
>+
>+    rtpoll = api->userdata;
>+    pa_assert(api == &rtpoll->mainloop_api);
>+
>+    event = pa_xnew0(pa_io_event, 1);
>+    event->rtpoll = rtpoll;
>+    event->rtpoll_item = pa_rtpoll_item_new(rtpoll, PA_RTPOLL_NORMAL, 1);
>+    pa_rtpoll_item_set_work_callback(event->rtpoll_item, io_event_work_cb);
>+    pa_rtpoll_item_set_userdata(event->rtpoll_item, event);
>+    pollfd = pa_rtpoll_item_get_pollfd(event->rtpoll_item, NULL);
>+    pollfd->fd = fd;
>+    event->callback = callback;
>+    event->userdata = userdata;
>+
>+    pa_dynarray_append(rtpoll->io_events, event);
>+    io_event_enable(event, events);
>+
>+    return event;
>+}
>+
>+static void io_event_free(pa_io_event *event) {
>+    pa_assert(event);
>+
>+    pa_dynarray_remove_by_data(event->rtpoll->io_events, event);
>+
>+    if (event->destroy_callback)
>+        event->destroy_callback(&event->rtpoll->mainloop_api, event, event->userdata);
>+
>+    if (event->rtpoll_item)
>+        pa_rtpoll_item_free(event->rtpoll_item);
>+
>+    pa_xfree(event);
>+}
>+
>+static void io_event_enable(pa_io_event *event, pa_io_event_flags_t events) {
>+    struct pollfd *pollfd;
>+
>+    pa_assert(event);
>+
>+    if (events == event->events)
>+        return;
>+
>+    event->events = events;
>+
>+    pollfd = pa_rtpoll_item_get_pollfd(event->rtpoll_item, NULL);
>+    pollfd->events = map_flags_to_libc(events);
>+}
>+
>+static void io_event_set_destroy(pa_io_event *event, pa_io_event_destroy_cb_t callback) {
>+    pa_assert(event);
>+
>+    event->destroy_callback = callback;
>+}
>+
>+static pa_usec_t make_rt(const struct timeval *tv, bool *use_rtclock) {
>+    struct timeval ttv;
>+
>+    if (!tv) {
>+        *use_rtclock = false;
>+        return PA_USEC_INVALID;
>+    }
>+
>+    ttv = *tv;
>+    *use_rtclock = !!(ttv.tv_usec & PA_TIMEVAL_RTCLOCK);
>+
>+    if (*use_rtclock)
>+        ttv.tv_usec &= ~PA_TIMEVAL_RTCLOCK;
>+    else
>+        pa_rtclock_from_wallclock(&ttv);
>+
>+    return pa_timeval_load(&ttv);
>+}
>+
>+static pa_time_event* time_event_new(pa_mainloop_api *api, const struct timeval *tv,
>+pa_time_event_cb_t callback,
>+                                     void *userdata) {
>+    pa_rtpoll *rtpoll;
>+    pa_time_event *event;
>+
>+    pa_assert(api);
>+    pa_assert(api->userdata);
>+    pa_assert(callback);
>+
>+    rtpoll = api->userdata;
>+    pa_assert(api == &rtpoll->mainloop_api);
>+
>+    event = pa_xnew0(pa_time_event, 1);
>+    event->rtpoll = rtpoll;
>+    event->time = PA_USEC_INVALID;
>+    event->callback = callback;
>+    event->userdata = userdata;
>+
>+    pa_dynarray_append(rtpoll->time_events, event);
>+    time_event_restart(event, tv);
>+
>+    return event;
>+}
>+
>+static void time_event_free(pa_time_event *event) {
>+    pa_assert(event);
>+
>+    time_event_restart(event, NULL);
>+    pa_dynarray_remove_by_data(event->rtpoll->time_events, event);
>+
>+    if (event->destroy_callback)
>+        event->destroy_callback(&event->rtpoll->mainloop_api, event, event->userdata);
>+
>+    pa_xfree(event);
>+}
>+
>+static void time_event_restart(pa_time_event *event, const struct timeval *tv) {
>+    pa_usec_t t;
>+    bool use_rtclock;
>+    bool enabled;
>+    bool old_enabled;
>+
>+    pa_assert(event);
>+
>+    t = make_rt(tv, &use_rtclock);
>+    enabled = (t != PA_USEC_INVALID);
>+    old_enabled = event->enabled;
>+
>+    /* We return early only if the event stays disabled. If the event stays
>+     * enabled, we can't return early, because the event time may change. */
>+    if (!enabled && !old_enabled)
>+        return;
>+
>+    event->enabled = enabled;
>+    event->time = t;
>+    event->use_rtclock = use_rtclock;
>+
>+    if (enabled && !old_enabled)
>+        pa_dynarray_append(event->rtpoll->enabled_time_events, event);
>+    else if (!enabled) {
>+        pa_dynarray_remove_by_data(event->rtpoll->enabled_time_events, event);
>+        pa_dynarray_remove_by_data(event->rtpoll->expired_time_events, event);
>+    }
>+
>+    if (event->rtpoll->cached_next_time_event == event)
>+        event->rtpoll->cached_next_time_event = NULL;
>+
>+    if (event->rtpoll->cached_next_time_event && enabled) {
>+        pa_assert(event->rtpoll->cached_next_time_event->enabled);
>+
>+        if (t < event->rtpoll->cached_next_time_event->time)
>+            event->rtpoll->cached_next_time_event = event;
>+    }
>+}
>+
>+static void time_event_set_destroy(pa_time_event *event, pa_time_event_destroy_cb_t callback) {
>+    pa_assert(event);
>+
>+    event->destroy_callback = callback;
>+}
>+
>+static pa_defer_event* defer_event_new(pa_mainloop_api *api, pa_defer_event_cb_t callback, void *userdata) {
>+    pa_rtpoll *rtpoll;
>+    pa_defer_event *event;
>+
>+    pa_assert(api);
>+    pa_assert(api->userdata);
>+    pa_assert(callback);
>+
>+    rtpoll = api->userdata;
>+    pa_assert(api == &rtpoll->mainloop_api);
>+
>+    event = pa_xnew0(pa_defer_event, 1);
>+    event->rtpoll = rtpoll;
>+    event->callback = callback;
>+    event->userdata = userdata;
>+
>+    pa_dynarray_append(rtpoll->defer_events, event);
>+    defer_event_enable(event, true);
>+
>+    return event;
>+}
>+
>+static void defer_event_free(pa_defer_event *event) {
>+    pa_assert(event);
>+
>+    defer_event_enable(event, false);
>+    pa_dynarray_remove_by_data(event->rtpoll->defer_events, event);
>+
>+    if (event->destroy_callback)
>+        event->destroy_callback(&event->rtpoll->mainloop_api, event, event->userdata);
>+
>+    pa_xfree(event);
>+}
>+
>+static void defer_event_enable(pa_defer_event *event, int enable) {
>+    pa_assert(event);
>+
>+    if (enable == event->enabled)
>+        return;
>+
>+    event->enabled = enable;
>+
>+    if (enable)
>+        pa_dynarray_append(event->rtpoll->enabled_defer_events, event);
>+    else
>+        pa_dynarray_remove_by_data(event->rtpoll->enabled_defer_events, event);
>+}
>+
>+static void defer_event_set_destroy(pa_defer_event *event, pa_defer_event_destroy_cb_t
>+callback) {
>+    pa_assert(event);
>+
>+    event->destroy_callback = callback;
>+}
>+
>+static void mainloop_api_quit(pa_mainloop_api *api, int retval) {
>+    pa_rtpoll *rtpoll;
>+
>+    pa_assert(api);
>+    pa_assert(api->userdata);
>+
>+    rtpoll = api->userdata;
>+    pa_assert(api == &rtpoll->mainloop_api);
>+
>+    //pa_rtpoll_quit(rtpoll);
>+}
>+
>+static const pa_mainloop_api vtable = {
>+    .userdata = NULL,
>+
>+    .io_new = io_event_new,
>+    .io_enable = io_event_enable,
>+    .io_free = io_event_free,
>+    .io_set_destroy = io_event_set_destroy,
>+
>+    .time_new = time_event_new,
>+    .time_restart = time_event_restart,
>+    .time_free = time_event_free,
>+    .time_set_destroy = time_event_set_destroy,
>+
>+    .defer_new = defer_event_new,
>+    .defer_enable = defer_event_enable,
>+    .defer_free = defer_event_free,
>+    .defer_set_destroy = defer_event_set_destroy,
>+
>+    .quit = mainloop_api_quit,
>+};
>+
> pa_rtpoll *pa_rtpoll_new(void) {
>     pa_rtpoll *p;
> 
>@@ -96,6 +426,14 @@
> #ifdef DEBUG_TIMING
>     p->timestamp = pa_rtclock_now();
> #endif
>+    p->mainloop_api = vtable;
>+    p->mainloop_api.userdata = p;
>+    p->io_events = pa_dynarray_new(NULL);
>+    p->time_events = pa_dynarray_new(NULL);
>+    p->enabled_time_events = pa_dynarray_new(NULL);
>+    p->expired_time_events = pa_dynarray_new(NULL);
>+    p->defer_events = pa_dynarray_new(NULL);
>+    p->enabled_defer_events = pa_dynarray_new(NULL);
> 
>     return p;
> }
>@@ -164,15 +502,105 @@
> 
> void pa_rtpoll_free(pa_rtpoll *p) {
>     pa_assert(p);
>+    if (p->defer_events) {
>+        pa_defer_event *event;
>+
>+        while ((event = pa_dynarray_last(p->defer_events)))
>+            defer_event_free(event);
>+    }
>+
>+    if (p->time_events) {
>+        pa_time_event *event;
>+
>+        while ((event = pa_dynarray_last(p->time_events)))
>+            time_event_free(event);
>+    }
>+
>+    if (p->io_events) {
>+        pa_io_event *event;
>+
>+        while ((event = pa_dynarray_last(p->io_events)))
>+            io_event_free(event);
>+    }
> 
>     while (p->items)
>         rtpoll_item_destroy(p->items);
>+    if (p->enabled_defer_events) {
>+        pa_assert(pa_dynarray_size(p->enabled_defer_events) == 0);
>+        pa_dynarray_free(p->enabled_defer_events);
>+    }
>+
>+    if (p->defer_events) {
>+        pa_assert(pa_dynarray_size(p->defer_events) == 0);
>+        pa_dynarray_free(p->defer_events);
>+    }
>+
>+    if (p->expired_time_events) {
>+        pa_assert(pa_dynarray_size(p->expired_time_events) == 0);
>+        pa_dynarray_free(p->expired_time_events);
>+    }
>+
>+    if (p->enabled_time_events) {
>+        pa_assert(pa_dynarray_size(p->enabled_time_events) == 0);
>+        pa_dynarray_free(p->enabled_time_events);
>+    }
>+
>+    if (p->time_events) {
>+        pa_assert(pa_dynarray_size(p->time_events) == 0);
>+        pa_dynarray_free(p->time_events);
>+    }
>+
>+    if (p->io_events) {
>+        pa_assert(pa_dynarray_size(p->io_events) == 0);
>+        pa_dynarray_free(p->io_events);
>+    }
> 
>     pa_xfree(p->pollfd);
>     pa_xfree(p->pollfd2);
> 
>     pa_xfree(p);
> }
>+pa_mainloop_api *pa_rtpoll_get_mainloop_api(pa_rtpoll *rtpoll) {
>+    pa_assert(rtpoll);
>+
>+    return &rtpoll->mainloop_api;
>+}
>+
>+static void find_expired_time_events(pa_rtpoll *rtpoll) {
>+    pa_usec_t now;
>+    pa_time_event *event;
>+    unsigned idx;
>+
>+    pa_assert(rtpoll);
>+    pa_assert(pa_dynarray_size(rtpoll->expired_time_events) == 0);
>+
>+    now = pa_rtclock_now();
>+
>+    PA_DYNARRAY_FOREACH(event, rtpoll->enabled_time_events, idx) {
>+        if (event->time <= now)
>+            pa_dynarray_append(rtpoll->expired_time_events, event);
>+    }
>+}
>+
>+static pa_time_event *find_next_time_event(pa_rtpoll *rtpoll) {
>+    pa_time_event *event;
>+    pa_time_event *result = NULL;
>+    unsigned idx;
>+
>+    pa_assert(rtpoll);
>+
>+    if (rtpoll->cached_next_time_event)
>+        return rtpoll->cached_next_time_event;
>+
>+    PA_DYNARRAY_FOREACH(event, rtpoll->enabled_time_events, idx) {
>+        if (!result || event->time < result->time)
>+            result = event;
>+    }
>+
>+    rtpoll->cached_next_time_event = result;
>+
>+    return result;
>+}
> 
> static void reset_revents(pa_rtpoll_item *i) {
>     struct pollfd *f;
>@@ -202,10 +630,14 @@
> }
> 
> int pa_rtpoll_run(pa_rtpoll *p) {
>+    pa_defer_event *defer_event;
>+    pa_time_event *time_event;
>     pa_rtpoll_item *i;
>     int r = 0;
>     struct timeval timeout;
>-
>+    pa_time_event *next_time_event;
>+    struct timeval next_time_event_elapse;
>+    bool timer_enabled;
>     pa_assert(p);
>     pa_assert(!p->running);
> 
>@@ -216,7 +648,29 @@
>     p->running = true;
>     p->timer_elapsed = false;
> 
>-    /* First, let's do some work */
>+    /* Dispatch all enabled defer events. */
>+    while ((defer_event = pa_dynarray_last(p->enabled_defer_events))) {
>+        if (p->quit)
>+            break;
>+
>+        defer_event->callback(&p->mainloop_api, defer_event, defer_event->userdata);
>+    }
>+
>+    /* Dispatch all expired time events. */
>+    find_expired_time_events(p);
>+    while ((time_event = pa_dynarray_last(p->expired_time_events))) {
>+        struct timeval tv;
>+
>+        if (p->quit)
>+            break;
>+
>+        time_event_restart(time_event, NULL);
>+        time_event->callback(&p->mainloop_api, time_event, pa_timeval_rtstore(&tv, time_event->time, time_event->use_rtclock),
>+                             time_event->userdata);
>+    }
>+
>+    /* Let's do some work */
>+
>     for (i = p->items; i && i->priority < PA_RTPOLL_NEVER; i = i->next) {
>         int k;
> 
>@@ -280,15 +734,40 @@
>     if (p->rebuild_needed)
>         rtpoll_rebuild(p);
> 
>+    /* Calculate timeout */
>+
>     pa_zero(timeout);
> 
>-    /* Calculate timeout */
>-    if (!p->quit && p->timer_enabled) {
>-        struct timeval now;
>-        pa_rtclock_get(&now);
>+    next_time_event = find_next_time_event(p);
>+    if (next_time_event)
>+        pa_timeval_rtstore(&next_time_event_elapse, next_time_event->time, next_time_event->use_rtclock);
>+
>+    /* p->timer_enabled and p->next_elapse are controlled by the rtpoll owner,
>+     * while the time events can be created by anyone through pa_mainloop_api.
>+     * It might be a good idea to merge p->timer_enabled and p->next_elapse
>+     * with the time events so that we wouldn't need to handle them separately
>+     * here. The reason why they are currently separate is that the
>+     * pa_mainloop_api interface was bolted on pa_rtpoll as an afterthought. */
>+    timer_enabled = p->timer_enabled || next_time_event;
>+
>+    if (!p->quit && timer_enabled) {
>+        struct timeval *next_elapse;
>+         struct timeval now;
>+
>+        if (p->timer_enabled && next_time_event) {
>+            if (pa_timeval_cmp(&p->next_elapse, &next_time_event_elapse) > 0)
>+                next_elapse = &next_time_event_elapse;
>+            else
>+                next_elapse = &p->next_elapse;
>+        } else if (p->timer_enabled)
>+            next_elapse = &p->next_elapse;
>+        else
>+            next_elapse = &next_time_event_elapse;
> 
>-        if (pa_timeval_cmp(&p->next_elapse, &now) > 0)
>-            pa_timeval_add(&timeout, pa_timeval_diff(&p->next_elapse, &now));
>+        pa_rtclock_get(&now);
>+        if (pa_timeval_cmp(next_elapse, &now) > 0)
>+            pa_timeval_add(&timeout, pa_timeval_diff(next_elapse, &now));
>+        
>     }
> 
> #ifdef DEBUG_TIMING
>@@ -296,7 +775,7 @@
>         pa_usec_t now = pa_rtclock_now();
>         p->awake = now - p->timestamp;
>         p->timestamp = now;
>-        if (!p->quit && p->timer_enabled)
>+        if (!p->quit && timer_enabled)
>             pa_log("poll timeout: %d ms ",(int) ((timeout.tv_sec*1000) + (timeout.tv_usec / 1000)));
>         else if (p->quit)
>             pa_log("poll timeout is ZERO");
>@@ -311,12 +790,22 @@
>         struct timespec ts;
>         ts.tv_sec = timeout.tv_sec;
>         ts.tv_nsec = timeout.tv_usec * 1000;
>-        r = ppoll(p->pollfd, p->n_pollfd_used, (p->quit || p->timer_enabled) ? &ts : NULL, NULL);
>+        r = ppoll(p->pollfd, p->n_pollfd_used, (p->quit || timer_enabled) ? &ts : NULL, NULL);
>     }
> #else
>-    r = pa_poll(p->pollfd, p->n_pollfd_used, (p->quit || p->timer_enabled) ? (int) ((timeout.tv_sec*1000) + (timeout.tv_usec / 1000)) : -1);
>+    r = pa_poll(p->pollfd, p->n_pollfd_used, (p->quit || timer_enabled) ? (int) ((timeout.tv_sec*1000)
>+ (timeout.tv_usec / 1000)) : -1);
> #endif
> 
>+    /* FIXME: We don't know whether the pa_rtpoll owner's timer elapsed or one
>+     * of the time events created by others through pa_mainloop_api. The alsa
>+     * sink and source use pa_rtpoll_timer_elapsed() to check whether *their*
>+     * timer elapsed, so this ambiguity is a problem for them in theory.
>+     * However, currently the pa_rtpoll objects of the alsa sink and source are
>+     * not being used through pa_mainloop_api, so in practice there's no
>+     * ambiguity. We could use pa_rtclock_now() to check whether p->next_elapse
>+     * is in the past, but we don't do that currently, because pa_rtclock_now()
>+     * is somewhat expensive and this ambiguity isn't currently a big issue. */
>     p->timer_elapsed = r == 0;
> 
> #ifdef DEBUG_TIMING
>diff -Naur a/src/pulsecore/rtpoll.h b/src/pulsecore/rtpoll.h
>--- a/src/pulsecore/rtpoll.h	2016-01-30 17:31:03.000000000 -0800
>+++ b/src/pulsecore/rtpoll.h	2016-01-31 12:11:22.000000000 -0800
>@@ -23,6 +23,7 @@
> #include <sys/types.h>
> #include <limits.h>
> 
>+#include <pulse/mainloop-api.h>
> #include <pulse/sample.h>
> #include <pulsecore/asyncmsgq.h>
> #include <pulsecore/fdsem.h>
>@@ -53,6 +54,7 @@
> 
> pa_rtpoll *pa_rtpoll_new(void);
> void pa_rtpoll_free(pa_rtpoll *p);
>+pa_mainloop_api *pa_rtpoll_get_mainloop_api(pa_rtpoll *rtpoll);
> 
> /* Sleep on the rtpoll until the time event, or any of the fd events
>  * is triggered. Returns negative on error, positive if the loop
>diff -Naur a/src/pulsecore/transcode.c b/src/pulsecore/transcode.c
>--- a/src/pulsecore/transcode.c	1969-12-31 16:00:00.000000000 -0800
>+++ b/src/pulsecore/transcode.c	2016-01-31 12:11:22.000000000 -0800
>@@ -0,0 +1,227 @@
>+
>+#ifdef HAVE_CONFIG_H
>+#include <config.h>
>+#endif
>+
>+
>+#include <pulsecore/macro.h>
>+#include <pulsecore/core-format.h>
>+
>+
>+#include "transcode.h"
>+
>+
>+
>+#ifdef HAVE_OPUS
>+
>+#include <opus.h>
>+
>+#define OPUS_DEFAULT_FRAME_SIZE 2880
>+#define OPUS_DEFAULT_BITRATE 64000
>+
>+#define OPUS_DEFAULT_SAMPLE_RATE 48000
>+#define OPUS_DEFAULT_SAMPLE_SIZE 2
>+
>+
>+
>+OpusEncoder *tc_opus_create_encoder(int sample_rate, int channels, int bitrate);
>+OpusDecoder *tc_opus_create_decoder(int sample_rate, int channels);
>+int tc_opus_encode(OpusEncoder *encoder, unsigned char *pcm_bytes, unsigned char *cbits, int channels, int frame_size);
>+int tc_opus_decode(OpusDecoder *decoder, unsigned char *cbits, int nbBytes, unsigned char *pcm_bytes, int channels, int max_frame_size);
>+
>+
>+OpusDecoder *tc_opus_create_decoder(int sample_rate, int channels)
>+{
>+   int err;
>+
>+   OpusDecoder * decoder = opus_decoder_create(sample_rate, channels, &err);
>+   if (err<0) {
>+      pa_log_error("failed to create decoder: %s", opus_strerror(err));
>+      return NULL;
>+   }
>+
>+   return decoder;
>+}
>+
>+
>+
>+OpusEncoder *tc_opus_create_encoder(int sample_rate, int channels, int bitrate)
>+{
>+   int err;
>+
>+   OpusEncoder *encoder = opus_encoder_create(sample_rate, channels, OPUS_APPLICATION_AUDIO, &err);
>+   if (err<0){
>+      pa_log_error("failed to create an encoder: %s", opus_strerror(err));
>+      return NULL;
>+   }
>+
>+   err = opus_encoder_ctl(encoder, OPUS_SET_BITRATE(bitrate));
>+   if (err<0)
>+   {
>+      pa_log_error("failed to set bitrate: %s", opus_strerror(err));
>+      return NULL;
>+   }
>+
>+   return encoder;
>+}
>+
>+
>+int tc_opus_encode(OpusEncoder *encoder, unsigned char *pcm_bytes, unsigned char *cbits, int channels, int frame_size)
>+{
>+      int i;
>+      int nbBytes;
>+      opus_int16 in[frame_size*channels];
>+
>+      /* Convert from little-endian ordering. */
>+      for (i=0;i<channels*frame_size;i++)
>+         in[i]=pcm_bytes[2*i+1]<<8|pcm_bytes[2*i];
>+
>+
>+      nbBytes = opus_encode(encoder, in, frame_size, cbits, frame_size*channels*2);
>+      if (nbBytes<0)
>+      {
>+         pa_log_error("encode failed: %s", opus_strerror(nbBytes));
>+         return EXIT_FAILURE;
>+      }
>+
>+      return nbBytes;
>+}
>+
>+
>+int tc_opus_decode(OpusDecoder *decoder, unsigned char *cbits, int nbBytes, unsigned char *pcm_bytes, int channels, int max_frame_size)
>+{
>+      int err=0, i;
>+      opus_int16 out[max_frame_size*channels];
>+
>+      int frame_size = opus_decode(decoder, cbits, nbBytes, out, max_frame_size, 0);
>+      if (frame_size<0)
>+      {
>+         pa_log_error("decoder failed: %s", opus_strerror(err));
>+         return EXIT_FAILURE;
>+      }
>+
>+      /* Convert to little-endian ordering. */
>+      for(i=0;i<channels*frame_size;i++)
>+      {
>+         pcm_bytes[2*i]=out[i]&0xFF;
>+         pcm_bytes[2*i+1]=(out[i]>>8)&0xFF;
>+      }
>+
>+      return frame_size;
>+}
>+
>+#endif
>+
>+
>+bool pa_transcode_supported(pa_encoding_t encoding) {
>+         #ifdef HAVE_OPUS
>+         if(encoding == PA_ENCODING_OPUS)
>+                  return 1;
>+         #endif
>+
>+         return 0;
>+}
>+
>+void pa_transcode_set_format_info(pa_transcode *transcode, pa_format_info *f) {
>+         pa_format_info_set_prop_int(f, "frame_size", transcode->frame_size);
>+         pa_format_info_set_prop_int(f, "bitrate", transcode->bitrate);
>+}
>+
>+
>+void pa_transcode_init(pa_transcode *transcode, pa_encoding_t encoding, pa_transcode_flags_t flags, pa_format_info *transcode_format_info, pa_sample_spec *transcode_sink_spec) {
>+
>+         pa_assert((flags & PA_TRANSCODE_DECODER) || (flags & PA_TRANSCODE_ENCODER));
>+
>+         transcode->flags = flags;
>+         transcode->encoding = encoding;
>+
>+         switch(encoding) {
>+                  #ifdef HAVE_OPUS
>+                  case PA_ENCODING_OPUS:
>+
>+                           transcode->sample_size = OPUS_DEFAULT_SAMPLE_SIZE;
>+
>+
>+                           if(flags & PA_TRANSCODE_DECODER) {
>+                                    if(pa_format_info_get_prop_int(transcode_format_info, "max_frame_size", (int *)&transcode->max_frame_size) != 0)
>+                                             transcode->max_frame_size = OPUS_DEFAULT_FRAME_SIZE;
>+                                    if(pa_format_info_get_prop_int(transcode_format_info, "frame_size", (int *)&transcode->frame_size) != 0)
>+                                             transcode->frame_size = OPUS_DEFAULT_FRAME_SIZE;
>+                                    if(pa_format_info_get_prop_int(transcode_format_info, "bitrate", (int *)&transcode->bitrate) != 0)
>+                                             transcode->bitrate = OPUS_DEFAULT_BITRATE;
>+
>+                                    pa_format_info_get_rate(transcode_format_info, &transcode->rate);
>+                                    pa_format_info_get_channels(transcode_format_info, &transcode->channels);
>+
>+                                    transcode->decoder = tc_opus_create_decoder(transcode->rate, transcode->channels);
>+
>+                           }
>+                           else {
>+                                    if(transcode->bitrate == 0)
>+                                             transcode->bitrate = OPUS_DEFAULT_BITRATE;
>+                                    if(transcode->frame_size == 0)
>+                                             transcode->frame_size = OPUS_DEFAULT_FRAME_SIZE;
>+
>+                                    transcode->channels = transcode_sink_spec->channels;
>+                                    transcode->rate = OPUS_DEFAULT_SAMPLE_RATE;
>+                                    transcode->encoder = tc_opus_create_encoder(transcode->rate, transcode->channels, transcode->bitrate);
>+
>+
>+                                    transcode_sink_spec->rate = transcode->rate;
>+                                    transcode_sink_spec->format = PA_SAMPLE_S16LE;
>+                           }
>+
>+                           break;
>+                  #endif
>+                  default:
>+                           transcode->decoder = NULL;
>+                           transcode->encoder = NULL;
>+         }
>+
>+}
>+
>+void pa_transcode_free(pa_transcode *transcode) {
>+
>+         switch(transcode->encoding) {
>+                  #ifdef HAVE_OPUS
>+                  case PA_ENCODING_OPUS:
>+                           opus_decoder_destroy(transcode->decoder);
>+                           break;
>+                  #endif
>+                  default:
>+                           transcode->decoder = NULL;
>+         }
>+
>+}
>+
>+
>+int32_t pa_transcode_encode(pa_transcode *transcode, unsigned char *pcm_input, unsigned char **compressed_output) {
>+         int nbBytes=0;
>+
>+         switch(transcode->encoding) {
>+                  #ifdef HAVE_OPUS
>+                  case PA_ENCODING_OPUS:
>+                           *compressed_output = malloc(transcode->frame_size*transcode->channels*transcode->sample_size);
>+                           nbBytes = tc_opus_encode(transcode->encoder, pcm_input, *compressed_output, transcode->channels, transcode->frame_size);
>+                           break;
>+                  #endif
>+
>+         }
>+
>+         return nbBytes;
>+}
>+
>+int32_t pa_transcode_decode(pa_transcode *transcode, unsigned char *compressed_input, int input_length, unsigned char *pcm_output) {
>+         int32_t frame_length=0;
>+
>+         switch(transcode->encoding) {
>+                  #ifdef HAVE_OPUS
>+                  case PA_ENCODING_OPUS:
>+                           frame_length = tc_opus_decode(transcode->decoder, compressed_input, input_length, pcm_output, transcode->channels, transcode->max_frame_size);
>+                           break;
>+                  #endif
>+
>+         }
>+
>+         return frame_length;
>+}
>diff -Naur a/src/pulsecore/transcode.h b/src/pulsecore/transcode.h
>--- a/src/pulsecore/transcode.h	1969-12-31 16:00:00.000000000 -0800
>+++ b/src/pulsecore/transcode.h	2016-01-31 12:11:22.000000000 -0800
>@@ -0,0 +1,36 @@
>+#ifndef footranscodehfoo
>+#define footranscodehfoo
>+
>+#include <pulsecore/core-format.h>
>+
>+
>+
>+
>+typedef enum pa_transcode_flags {
>+         PA_TRANSCODE_DECODER=(1<<0),
>+         PA_TRANSCODE_ENCODER=(1<<1)
>+         } pa_transcode_flags_t;
>+
>+typedef struct pa_transcode {
>+ int32_t encoding;
>+ uint8_t channels;
>+ uint32_t frame_size;
>+ uint32_t max_frame_size;
>+ uint32_t sample_size;
>+ uint32_t rate;
>+ uint32_t bitrate;
>+ pa_transcode_flags_t flags;
>+ union {
>+         void *decoder;
>+         void *encoder;
>+ };
>+} pa_transcode;
>+
>+bool pa_transcode_supported(pa_encoding_t encoding);
>+void pa_transcode_set_format_info(pa_transcode *transcode, pa_format_info *f);
>+void pa_transcode_init(pa_transcode *transcode, pa_encoding_t encoding, pa_transcode_flags_t flags, pa_format_info *transcode_format_info, pa_sample_spec *transcode_sink_spec);
>+void pa_transcode_free(pa_transcode *transcode);
>+int32_t pa_transcode_encode(pa_transcode *transcode, unsigned char *pcm_input, unsigned char **compressed_output);
>+int32_t pa_transcode_decode(pa_transcode *transcode, unsigned char *compressed_input, int input_length, unsigned char *pcm_output);
>+
>+#endif

Actions: View | Splinter Review

Attachments on bug 56993: 117144 | 121428

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.