diff --git a/Android.mk b/Android.mk
index a33b9ae..fb97c6b 100644
--- a/Android.mk
+++ b/Android.mk
@@ -1,22 +1,84 @@
-ifeq  ($(strip $(BOARD_USES_TINY_AUDIO_HW)),true)
+#
+# Copyright (C) 2012 Wolfson Microelectronics plc
+# Copyright (C) 2011 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 LOCAL_PATH := $(call my-dir)
 
 include $(CLEAR_VARS)
 
-# Should change this so the enable variable gets used as the name?
-LOCAL_MODULE := audio.primary.herring
-LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
-LOCAL_SRC_FILES := audio_hw.c
-LOCAL_C_INCLUDES += \
-	external/tinyalsa/include \
-	external/expat/lib \
-	system/media/audio_utils/include \
-	system/media/audio_effects/include
-LOCAL_SHARED_LIBRARIES := liblog libcutils libtinyalsa libaudioutils \
-	libdl libexpat
+LOCAL_MODULE := libaudiohalcm
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)
 LOCAL_MODULE_TAGS := optional
 
+LOCAL_CFLAGS += -Werror
+
+LOCAL_C_INCLUDES += \
+	external/tinycompress/include \
+	external/tinyalsa/include \
+	external/tinyhal/audio \
+	external/expat/lib \
+	$(call include-path-for, audio-utils)
+
+LOCAL_SRC_FILES := \
+	audio_config.c
+
+LOCAL_SHARED_LIBRARIES := \
+	libcutils \
+	libutils \
+	libdl	\
+	liblog	\
+	libexpat	\
+	libtinyalsa	\
+
+include $(BUILD_SHARED_LIBRARY)
+
+ifeq ($(strip $(BOARD_USES_TINYHAL_AUDIO)),true)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := audio.primary.$(TARGET_DEVICE)
+LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_CFLAGS += -Werror
+
+LOCAL_C_INCLUDES += \
+	external/tinycompress/include \
+	external/tinyalsa/include \
+	external/tinyhal/audio \
+	external/expat/lib \
+	$(call include-path-for, audio-utils)
+
+LOCAL_SRC_FILES := \
+	audio_hw.c		\
+	voice_trigger.cpp
+
+LOCAL_STATIC_LIBRARIES := \
+	libmedia_helper
+
+LOCAL_SHARED_LIBRARIES := \
+	libcutils \
+	libutils \
+	libdl	\
+	liblog	\
+	libhardware_legacy \
+	libtinyalsa	\
+	libtinycompress	\
+	libaudiohalcm \
+	libaudioutils \
+	libsysutils
+
 include $(BUILD_SHARED_LIBRARY)
 
 endif
diff --git a/audio.example.xml b/audio.example.xml
new file mode 100644
index 0000000..4b74272
--- /dev/null
+++ b/audio.example.xml
@@ -0,0 +1,264 @@
+<!-- This file is provided as a reference for writing config files
+It does NOT represent any particular device and will NOT work on
+real hardware. You must create a file with the correct settings for
+your hardware, and the comments here will explain the layout of this
+file and expected content.
+
+On the target device this file must be located in /system/etc and named
+audio.<device>.xml, where <device> is the string returned by the system
+property ro.product.device
+-->
+
+<audiohal>
+    <!-- mixer element _must_ be first. The 'card' attribute is optional
+    and sets the ALSA card number of the mixer device - if not given it
+    defaults to 0 -->
+
+	<mixer card="0">
+
+        <!-- init element lists control settings required to initialize the
+        hardware and driver. These settings are applied only once when the
+        library is first loaded during boot -->
+
+        <init>
+
+            <!-- A sequence of ctl elements. Each entry sets a mixer
+            control to a given value. The entries are applied in the
+            order they are listed here.
+            Each entry _must_ have these attributes
+                name - name of the ALSA mixer control
+                val  - value to set it to
+
+            It can also have an index attribute giving the numeric index
+            of the control value to set. This is used where a control
+            has multiple value slots (for example a volume control
+            with two values, one for left channel and one for right), If
+            an index attribute is not given the content of the val attribute
+            will be applied to all value slots of the control.
+
+            The numbers in val and index attributes can be given in either
+            decimal, or hex (hex is prefixed with 0x). For a control with
+            enumerated values the val attribute must be a string
+
+            BYTE ARRAYS: for controls that are a byte array val must be
+            a string of comma-separated byte values. This can be shorter
+            than the total size of the control, combined with the
+            optional index attribute this allows any subset of the byte
+            array to be changed.
+            -->
+
+            <ctl name="DAC1 Switch" val="1" />
+            <ctl name="Speaker Enable" val="0"/>
+            <ctl name="Jack Enable" val="0"/>
+            <ctl name="Codec Config" index="8" val="0x7f,0x54,0xaa,0xaa"/>
+
+        </init>
+	</mixer>
+
+<!-- Next you must list all the devices supported by the hardware. The
+name attribute of the <device> element identifies the device. These names are
+recognized:
+    "global"        dummy global device - see explanation below
+    "speaker"       AUDIO_DEVICE_OUT_SPEAKER
+    "earpiece"      AUDIO_DEVICE_OUT_EARPIECE
+    "headset"       AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_IN_WIRED_HEADSET
+    "headphone"     AUDIO_DEVICE_OUT_WIRED_HEADPHONE
+    "sco"           AUDIO_DEVICE_OUT_ALL_SCO | AUDIO_DEVICE_IN_ALL_SCO
+    "a2dp"          AUDIO_DEVICE_OUT_ALL_A2DP
+    "usb"           AUDIO_DEVICE_OUT_ALL_USB
+    "mic"           AUDIO_DEVICE_IN_BUILTIN_MIC
+    "back mic"      AUDIO_DEVICE_IN_BACK_MIC
+    "voice"         AUDIO_DEVICE_IN_VOICE_CALL
+    "aux"           AUDIO_DEVICE_IN_AUX_DIGITAL
+
+Within the <device> element you can declare a number of "paths", each path
+defines a group of control settings to be applied. Each path is identified by
+a name. The "on" and "off" paths are special and list a global enable and
+disable setting for the device. Use of devices is reference-counted, when
+routing of a stream is changed to use a device that is currently disabled its
+"on" path will be applied. When no streams are using a device its "off"
+path will be applied.
+
+Other paths are user-defined and you can give them any name you choose.
+They are used to apply custom paths when required by a stream and will
+be used only when a stream is connected to or disconnected from a
+device if the <stream> element has an <enable> or <disable> element requesting
+that path.
+
+It is not mandatory to provide paths. You only need to define paths
+if there are specific control settings that must be applied. So for example
+if no controls need be applied to enable or disable a device then you
+do not need to define the "on" and "off" paths.
+
+The <ctl> elements within each path have the same format and behaviour
+as described under <mixer><init>.
+
+The "global" device is a special device the represents the audio system as a
+whole and is used to invoke mixer settings that are independent of any real
+device and which apply globally to the audio system. A stream is automatically
+connected to "global" when it is opened and disconnected when it is closed.
+The behaviour is identical to the way paths are invoked in any other <device>
+entry so the effect is
+    - the "on" path will be applied when a stream is opened and there are
+        no other streams already open. As an example this could be used to
+        bring the audio hardware out of a standby state
+
+    - the "off" path will be applied when the last open stream is closed.
+        As an example this could be used to put the audio hardware into a
+        standby state
+
+    - the custom paths will be applied when the stream that requests them
+        is opened or closed.
+-->
+
+	<device name="speaker">
+        <path name="on">
+            <!-- List of ctl element for control values to apply
+            when this device is enabled -->
+            <ctl name="Speaker Enable" val="1"/>
+        </path>
+
+        <path name="off">
+            <!-- List of ctl element for control values to apply
+            when this device is disabled -->
+            <ctl name="Speaker Enable" val="0"/>
+        </path>
+
+        <!-- Following paths are user-defined and are applied when a
+        <stream> elements' routing is changed to add or remove this
+        device. If the path name matches the name given in the <stream>
+        element it will be applied. A stream could be routed to multiple
+        inputs or outputs - the paths for connecting and disconnecting
+        a stream to a device must therefore have the same name in each
+        <device>.
+
+        It is not mandatory to declare custom paths - depending on your
+        hardware there may not be any specific action required to route
+        a stream to a particular device. Also you do not have to define
+        the path in every device, only the devices where some action must
+        be taken to connect or disconnect a stream.
+
+        For this example four custom paths are defined:
+            pcm_out_en = control setting to connect PCM output to this device
+            pcm_out_dis = control setting to disconnect PCM output from this device
+         -->
+
+        <path name="pcm_out_en">
+            <ctl name="PCM Speaker switch" val="1"/>
+        </path>
+        <path name="pcm_out_dis">
+            <ctl name="PCM Speaker switch" val="0"/>
+        </path>
+	</device>
+
+	<device name="headphone">
+        <path name="on">
+            <ctl name="Jack Enable" val="1"/>
+        </path>
+        <path name="off">
+            <ctl name="Jack Enable" val="0"/>
+        </path>
+        <path name="pcm_out_en">
+            <ctl name="PCM Jack switch" val="1"/>
+        </path>
+        <path name="pcm_out_dis">
+            <ctl name="PCM Jack switch" val="0"/>
+        </path>
+	</device>
+
+<!-- Following the device definitions there must be a <stream> entry
+for every output and input stream supported by the hardware.
+There are two types of stream that can be declared here:
+- anonymous streams, these will be used to supply playback and record
+    streams for AudioFlinger
+
+- named streams, which are mainly used to declare custom streams to handle
+    special routing use-cases that are external to the normal Android audio
+    path - typically where the audio is routed entirely in hardware without
+    being passed through Android, for example the baseband audio link or
+    FM radio.
+
+For standard anonymous streams there are two that would normally be on
+any device: PCM input and PCM output. It is also possible to declare a stream
+as "compress" - this is intended for cases where a playback stream is
+decompressed in hardware, or a record stream provides raw compressed data that
+must be decompressed in software.
+
+Named streams can be declared as type "hw", to represent a hardware-hardware
+link where specifying a data type and direction would be meaningless.
+
+Mandatory attributes for PCM and compressed streams:
+    type    must be "pcm" or "compress"
+    dir     direction of stream, either "in" (recording) or "out" (playback)
+
+Mandatory for named streams:
+    type    must be "pcm", "compress" or "hw"
+    name    a custom name for a named stream. The name you choose here must
+                match the name your HAL will use to request this stream
+
+Mandatory for hw streams:
+    type    must be "hw"
+    name    a custom name for the stream (hw streams must be named streams)
+
+Optional attributes:
+    card    ALSA card number. If not given this defaults to 0
+    device  ALSA device number. If not given this defaults to 0
+    instances   limits the maximum number of instances of this stream, if not
+                specified the number of instances is unlimited
+    name    a custom name for a named stream. The name you choose here must
+                match the name your HAL will use to request this stream
+
+Anonymous PCM streams should not normally have an instance limit.
+-->
+
+    <stream type="pcm" dir="out" card="0" device="0">
+        <!-- The <enable> and <disable> tags give the name of a path
+        to apply for each connected device when the stream is either connected
+        to (enable) or disconnected from (disable) that device.
+        The way this works is that when stream routing changes, the HAL will
+        look through the paths of each device this stream is connected to,
+            - for each device the stream is being disconnected from, if it
+                contains a path matching the path name in <disable>, that path
+                will be applied.
+            - for each device the stream is being connected to, if it
+                contains a path matching the path name in <enable>, that path
+                will be applied.
+        -->
+        <enable path="pcm_out_en"/>
+        <disable path="pcm_out_dis"/>
+
+        <!-- The optional usecase block allows you to define custom use-cases that
+        are triggered by set_parameter() calls to the HAL. The set_parameter()
+        is a string of the form <setting>=<value>. The HAL will search for a
+        usecase block whose name attribute matches <setting> and within that
+        a case block whose name attribute matches <value>. If a matching case
+        block is found the enclosed <ctl> blocks will be applied.
+        The example below defines a use case for switching a codec algorithm
+        between wideband and narrowband response. The two cases will be
+        triggered by a set_parameter() of "bandwidth=narrow" or "bandwidth=wide".
+        -->
+        <usecase name="bandwidth">
+            <case name="narrow">
+                <ctl name="Codec Wideband" val="0" />
+            </case>
+            <case name="wide">
+                <ctl name="Codec Wideband" val="1" />
+            </case>
+        </usecase>
+
+    </stream>
+
+    <stream type="pcm" dir="in" card="0" device="0">
+    </stream>
+
+    <!-- Example named stream, in this case for an FM radio path . This will not
+    be available for standard AudioFlinger playback and record paths. It must
+    be explicitly requested by the audio HAL when FM radio is enabled
+    -->
+    <stream name="FM radio" type="pcm" dir="in" card="0" device="0">
+        <!-- control paths to be enabled when this stream is enabled or disabled -->
+        <enable path="fm_radio_en"/>
+        <disable path="fm_radio_dis"/>
+    </stream>
+
+</audiohal>
diff --git a/audio_config.c b/audio_config.c
new file mode 100644
index 0000000..34bccd3
--- /dev/null
+++ b/audio_config.c
@@ -0,0 +1,2154 @@
+/*
+ * Copyright (C) 2012-2013 Wolfson Microelectronics plc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "tiny_hal_config"
+/*#define LOG_NDEBUG 0*/
+/*#undef NDEBUG*/
+
+#include <stddef.h>
+#include <errno.h>
+#include <assert.h>
+#include <cutils/log.h>
+#include <cutils/properties.h>
+#include <cutils/compiler.h>
+
+#include <system/audio.h>
+
+/* Workaround for linker error if audio_effect.h is included in multiple
+ * source files. Prevent audio.h including it */
+#define ANDROID_AUDIO_EFFECT_H
+struct effect_interface_s;
+typedef struct effect_interface_s **effect_handle_t;
+#include <hardware/audio.h>
+
+#include <tinyalsa/asoundlib.h>
+#include <expat.h>
+
+#include "audio_config.h"
+
+#define MIXER_CARD_DEFAULT 0
+#define PCM_CARD_DEFAULT 0
+#define PCM_DEVICE_DEFAULT 0
+#define COMPRESS_CARD_DEFAULT 0
+#define COMPRESS_DEVICE_DEFAULT 0
+
+/* The dynamic arrays are extended in multiples of this number of objects */
+#define DYN_ARRAY_GRANULE 16
+
+/* Largest byte array control we handle */
+#define BYTE_ARRAY_MAX_SIZE 512
+
+#define INVALID_CTL_INDEX 0xFFFFFFFFUL
+
+struct config_mgr;
+struct stream;
+struct path;
+struct device;
+struct usecase;
+struct scase;
+
+/* Dynamically extended array of fixed-size objects */
+struct dyn_array {
+    uint                count;
+    uint16_t            max_count; /* current maximum size of allocated array */
+    uint16_t            elem_size;  /* size of array elements */
+    union {
+        void               *data;
+        struct device      *devices;
+        struct stream      *streams;
+        struct path        *paths;
+        struct usecase     *usecases;
+        struct scase       *cases;
+        struct ctl         *ctls;
+        const char         **path_names;
+    };
+};
+
+/* Paths for "on" and "off" are a special case and have fixed ids */
+enum {
+    e_path_id_off = 0,
+    e_path_id_on = 1,
+    e_path_id_custom_base = 2
+};
+
+struct ctl {
+    struct mixer_ctl    *ctl;
+    uint32_t            index;
+    uint32_t            array_count;
+    union {
+        uint32_t        uinteger;
+        const char      *name;
+        const uint8_t   *data;
+    } value;
+};
+
+struct path {
+    int                 id;         /* Integer identifier of this path */
+    struct dyn_array    ctl_array;
+};
+
+struct device {
+    uint32_t    type;               /* 0 is reserved for the global device */
+    int         use_count;          /* counts total streams using this device */
+    struct dyn_array path_array;
+};
+
+struct scase {
+    const char          *name;
+    struct dyn_array    ctl_array;
+};
+
+struct usecase {
+    const char          *name;
+    struct dyn_array    case_array;
+};
+
+struct stream_control {
+    struct mixer_ctl    *ctl;
+    uint                id;
+    uint                min;
+    uint                max;
+};
+
+struct volume_control {
+    struct stream_control control;
+    uint min;
+    uint max;
+};
+
+struct stream {
+    struct hw_stream  info;   /* must be first member */
+
+    struct config_mgr*  cm;
+    const char* name;
+
+    int     ref_count;
+    int     max_ref_count;
+
+    int     enable_path;    /* id of paths to invoke when enabled */
+    int     disable_path;   /* id of paths to invoke when disabled */
+
+    uint32_t current_devices;   /* devices currently active for this stream */
+
+    struct {
+        struct stream_control volume_left;
+        struct stream_control volume_right;
+    } controls;
+
+    struct dyn_array    usecase_array;
+};
+
+struct config_mgr {
+    pthread_mutex_t lock;
+
+    struct mixer    *mixer;
+
+    uint32_t        supported_output_devices;
+    uint32_t        supported_input_devices;
+
+    struct dyn_array device_array;
+    struct dyn_array stream_array;
+};
+
+/*********************************************************************
+ * Structures and enums for XML parser
+ *********************************************************************/
+
+#define MAX_PARSE_DEPTH     6
+
+/* For faster parsing put more commonly-used elements first */
+enum element_index {
+    e_elem_ctl = 0,
+    e_elem_path,
+    e_elem_device,
+    e_elem_stream,
+    e_elem_enable,
+    e_elem_disable,
+    e_elem_case,
+    e_elem_usecase,
+    e_elem_stream_ctl,
+    e_elem_init,
+    e_elem_mixer,
+    e_elem_audiohal,
+
+    e_elem_count
+};
+
+/* For faster parsing put more commonly-used attribs first */
+enum attrib_index {
+    e_attrib_name = 0,
+    e_attrib_val,
+    e_attrib_path,
+    e_attrib_function,
+    e_attrib_type,
+    e_attrib_index,
+    e_attrib_dir,
+    e_attrib_card,
+    e_attrib_device,
+    e_attrib_instances,
+    e_attrib_rate,
+    e_attrib_period_size,
+    e_attrib_period_count,
+    e_attrib_min,
+    e_attrib_max,
+
+    e_attrib_count
+};
+
+#define BIT(x)     (1<<(x))
+
+struct parse_state;
+typedef int(*elem_fn)(struct parse_state *state);
+
+struct parse_element {
+    const char      *name;
+    uint16_t        valid_attribs;  /* bitflags of valid attribs for this element */
+    uint16_t        required_attribs;   /* bitflags of attribs that must be present */
+    uint16_t        valid_subelem;  /* bitflags of valid sub-elements */
+    elem_fn         start_fn;
+    elem_fn         end_fn;
+};
+
+struct parse_attrib {
+    const char      *name;
+};
+
+struct parse_device {
+    const char      *name;
+    uint32_t        device;
+};
+
+struct parse_stack_entry {
+    uint16_t            elem_index;
+    uint16_t            valid_subelem;
+};
+
+/* Temporary state info for config file parser */
+struct parse_state {
+    struct config_mgr   *cm;
+    FILE                *file;
+    XML_Parser          parser;
+    char                read_buf[256];
+    int                 parse_error; /* value >0 aborts without error */
+    int                 error_line;
+    int                 mixer_card_number;
+
+    struct {
+        const char      *value[e_attrib_count];
+        const XML_Char  **all;
+    } attribs;
+
+    /* Current parent object. We don't need a stack because
+     * an object cannot be nested below an object of the same type
+     * so there can only ever be zero or one object of a given type
+     * active at any time
+     */
+    struct {
+        struct device   *device;
+        struct stream   *stream;
+        struct path     *path;
+        struct usecase  *usecase;
+        struct scase    *scase;
+    } current;
+
+    /* This array hold a de-duplicated list of all path names encountered */
+    struct dyn_array    path_name_array;
+
+    /* This is a temporary path object used to collect the initial
+     * mixer setup control settings under <mixer><init>
+     */
+    struct path         init_path;
+
+    struct {
+        int             index;
+        struct parse_stack_entry entry[MAX_PARSE_DEPTH];
+    } stack;
+};
+
+
+static const char *debug_device_to_name(uint32_t device);
+
+/*********************************************************************
+ * Routing control
+ *********************************************************************/
+
+static void apply_ctls_l( struct ctl *pctl, const int ctl_count )
+{
+    int i;
+    unsigned int vnum;
+    unsigned int value_count;
+    int err = 0;
+    uint8_t ctl_data[BYTE_ARRAY_MAX_SIZE];
+
+    ALOGV("+apply_ctls_l");
+
+    for (i = 0; i < ctl_count; ++i, ++pctl) {
+        switch (mixer_ctl_get_type(pctl->ctl)) {
+            case MIXER_CTL_TYPE_BOOL:
+            case MIXER_CTL_TYPE_INT:
+                value_count = mixer_ctl_get_num_values(pctl->ctl);
+
+                ALOGV("apply ctl '%s' = 0x%x (%d values)",
+                                        mixer_ctl_get_name(pctl->ctl),
+                                        pctl->value.uinteger,
+                                        value_count);
+
+                if (pctl->index == INVALID_CTL_INDEX) {
+                    for (vnum = 0; vnum < value_count; ++vnum) {
+                        err = mixer_ctl_set_value(pctl->ctl, vnum, pctl->value.uinteger);
+                        if (err < 0) {
+                            break;
+                        }
+                    }
+                } else {
+                    err = mixer_ctl_set_value(pctl->ctl, pctl->index, pctl->value.uinteger);
+                }
+                ALOGE_IF(err < 0, "Failed to set ctl '%s' to %u",
+                                        mixer_ctl_get_name(pctl->ctl),
+                                        pctl->value.uinteger);
+                break;
+
+            case MIXER_CTL_TYPE_BYTE:
+                /* byte array */
+                vnum = mixer_ctl_get_num_values(pctl->ctl);
+
+                ALOGV("apply ctl '%s' = byte data (%d bytes)",
+                                        mixer_ctl_get_name(pctl->ctl),
+                                        vnum);
+
+                if ((pctl->index == 0) && (pctl->array_count == vnum)) {
+                    err = mixer_ctl_set_array(pctl->ctl, pctl->value.data, pctl->array_count);
+                } else {
+                    /* read-modify-write */
+                    err = mixer_ctl_get_array(pctl->ctl, ctl_data, vnum);
+                    if (err >= 0) {
+                        memcpy(&ctl_data[pctl->index], pctl->value.data, pctl->array_count);
+                        err = mixer_ctl_set_array(pctl->ctl, ctl_data, vnum);
+                    }
+                }
+
+                ALOGE_IF(err < 0, "Failed to set ctl '%s'",
+                                            mixer_ctl_get_name(pctl->ctl));
+                break;
+
+            case MIXER_CTL_TYPE_ENUM:
+                ALOGV("apply ctl '%s' to '%s'",
+                                            mixer_ctl_get_name(pctl->ctl),
+                                            pctl->value.name);
+
+                err = mixer_ctl_set_enum_by_string(pctl->ctl, pctl->value.name);
+
+                ALOGE_IF(err < 0, "Failed to set ctl '%s' to '%s'",
+                                            mixer_ctl_get_name(pctl->ctl),
+                                            pctl->value.name);
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    ALOGV("-apply_ctls_l");
+}
+
+static void apply_path_l(struct path *path)
+{
+    ALOGV("+apply_path_l(%p) id=%u", path, path->id);
+
+    apply_ctls_l(path->ctl_array.ctls, path->ctl_array.count);
+
+    ALOGV("-apply_path_l(%p)", path);
+}
+
+static void apply_device_path_l(struct device *pdev, struct path *path)
+{
+    ALOGV("+apply_device_path_l(%p) id=%u", path, path->id);
+
+    /* The on and off paths for a device are reference-counted */
+    switch (path->id) {
+    case e_path_id_off:
+        if (--pdev->use_count > 0) {
+            ALOGV("Device still in use - not applying 'off' path");
+            return;
+        }
+        break;
+
+     case e_path_id_on:
+        if (++pdev->use_count > 1) {
+            ALOGV("Device already enabled - not applying 'on' path");
+            return;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    apply_path_l(path);
+
+    ALOGV("-apply_device_path_l(%p)", path);
+}
+
+static void apply_paths_by_id_l(struct device *pdev, int first_id,
+                                int second_id)
+{
+    struct path *ppath = pdev->path_array.paths;
+    struct path *found_paths[2] = {0};
+    int path_count = pdev->path_array.count;
+
+    ALOGV("Applying paths [first=%u second=%u] to device(@%p, mask=0x%x '%s')",
+                first_id, second_id, ppath, pdev->type, debug_device_to_name(pdev->type));
+
+    /* To save time we find both paths in a single walk of the list */
+    for (; path_count > 0; --path_count, ++ppath) {
+        if (ppath->id == first_id) {
+            found_paths[0] = ppath;
+            if ((found_paths[1] != NULL) || (first_id == second_id)) {
+                /* We have both paths or there is only one path to find */
+                break;
+            }
+        } else if (ppath->id == second_id) {
+            found_paths[1] = ppath;
+            if (found_paths[0] != NULL) {
+                break;
+            }
+        }
+    }
+
+    if (found_paths[0] != NULL) {
+        apply_device_path_l(pdev, found_paths[0]);
+    }
+
+    if (found_paths[1] != NULL) {
+        apply_device_path_l(pdev, found_paths[1]);
+    }
+}
+
+static void apply_paths_to_devices_l(struct config_mgr *cm, uint32_t devices,
+                                    int first_id, int second_id)
+{
+    struct device *pdev = cm->device_array.devices;
+    int dev_count = cm->device_array.count;
+    const uint32_t input_flag = devices & AUDIO_DEVICE_BIT_IN;
+
+    /* invoke path path_id on all struct device matching devices */
+    ALOGV("Apply paths [first=%u second=%u] to devices in 0x%x",
+            first_id, second_id, devices);
+
+    devices &= ~AUDIO_DEVICE_BIT_IN;
+
+    while ((dev_count > 0) && (devices != 0)) {
+        if (((pdev->type & input_flag) == input_flag)
+                    && ((pdev->type & devices) != 0)) {
+            devices &= ~pdev->type;
+            apply_paths_by_id_l(pdev, first_id, second_id);
+        }
+
+        --dev_count;
+        ++pdev;
+    }
+}
+
+static void apply_paths_to_global_l(struct config_mgr *cm,
+                                    int first_id, int second_id)
+{
+    struct device *pdev = cm->device_array.devices;
+    struct device * const pend = pdev + cm->device_array.count;
+
+    ALOGV("Apply global paths [first=%u second=%u]", first_id, second_id);
+
+    while (pdev < pend) {
+        if (pdev->type == 0) {
+            apply_paths_by_id_l(pdev, first_id, second_id);
+            break;
+        }
+        ++pdev;
+    }
+}
+
+uint32_t get_current_routes( const struct hw_stream *stream )
+{
+    struct stream *s = (struct stream *)stream;
+    ALOGV("get_current_routes(%p) 0x%x", stream, s->current_devices);
+    return s->current_devices;
+}
+
+void apply_route( const struct hw_stream *stream, uint32_t devices )
+{
+    struct stream *s = (struct stream *)stream;
+    struct config_mgr *cm = s->cm;
+
+    /* Only apply routes to devices that have changed state on this stream */
+    uint32_t enabling = devices & ~s->current_devices;
+    uint32_t disabling = ~devices & s->current_devices;
+
+    ALOGV("apply_route(%p) devices=0x%x", stream, devices);
+
+    if (stream_is_input(stream)) {
+        devices &= AUDIO_DEVICE_IN_ALL;
+        devices |= AUDIO_DEVICE_BIT_IN;
+    } else {
+        devices &= AUDIO_DEVICE_OUT_ALL;
+    }
+
+    pthread_mutex_lock(&cm->lock);
+
+    apply_paths_to_devices_l(cm, disabling, s->disable_path, e_path_id_off);
+    apply_paths_to_devices_l(cm, enabling, e_path_id_on, s->enable_path);
+
+    /* Save new set of devices for this stream */
+    s->current_devices = devices;
+
+    pthread_mutex_unlock(&cm->lock);
+}
+
+uint32_t get_routed_devices( const struct hw_stream *stream )
+{
+    struct stream *s = (struct stream *)stream;
+    return s->current_devices;
+}
+
+void rotate_routes( struct config_mgr *cm, int orientation )
+{
+    /* Route rotation not currently supported */
+}
+
+/*********************************************************************
+ * Stream control
+ *********************************************************************/
+
+static int set_vol_ctl( const struct stream_control *volctl, uint percent)
+{
+    uint val;
+    uint range;
+
+    switch (percent) {
+    case 0:
+        val = volctl->min;
+        break;
+
+    case 100:
+        val = volctl->max;
+        break;
+
+    default:
+        range = volctl->max - volctl->min;
+        val = volctl->min + ((percent * range)/100);
+        break;
+    }
+
+    ALOGW("set '%s' = %u", mixer_ctl_get_name(volctl->ctl), val);
+    mixer_ctl_set_value(volctl->ctl, volctl->id, val);
+    return 0;
+}
+
+int set_hw_volume( const struct hw_stream *stream, int left_pc, int right_pc)
+{
+    struct stream *s = (struct stream *)stream;
+    int ret = -ENOSYS;
+
+    if (s->controls.volume_left.ctl) {
+        if (!s->controls.volume_right.ctl) {
+            /* Control is mono so average left and right */
+            left_pc = (left_pc + right_pc) / 2;
+        }
+
+        ret = set_vol_ctl(&s->controls.volume_left, left_pc);
+    }
+
+    if (s->controls.volume_right.ctl) {
+        ret = set_vol_ctl(&s->controls.volume_right, right_pc);
+    }
+
+    ALOGV_IF(ret == 0, "set_hw_volume: L=%d%% R=%d%%", left_pc, right_pc);
+
+    return ret;
+}
+
+static struct stream *find_named_stream(struct config_mgr *cm,
+                                   const char *name)
+{
+    struct stream *s = cm->stream_array.streams;
+    int i;
+
+    for (i = cm->stream_array.count - 1; i >= 0; --i) {
+        if (s->name) {
+            if (strcmp(s->name, name) == 0) {
+                return s;
+            }
+        }
+        s++;
+    }
+    return NULL;
+}
+
+static bool open_stream_l(struct config_mgr *cm, struct stream *s)
+{
+    if (s->ref_count < s->max_ref_count) {
+        ++s->ref_count;
+        if (s->ref_count == 1) {
+            apply_paths_to_global_l(cm, e_path_id_on, s->enable_path);
+        }
+        return true;
+    } else {
+        ALOGV("stream at maximum refcount %d", s->ref_count);
+        return false;
+    }
+}
+
+const struct hw_stream *get_stream(struct config_mgr *cm,
+                                   const audio_devices_t devices,
+                                   const audio_output_flags_t flags,
+                                   const struct audio_config *config )
+{
+    int i;
+    struct stream *s = cm->stream_array.streams;
+    const bool pcm = audio_is_linear_pcm(config->format);
+    enum stream_type type;
+
+    ALOGV("+get_stream devices=0x%x flags=0x%x format=0x%x",
+                            devices, flags, config->format );
+
+    if (devices & AUDIO_DEVICE_BIT_IN) {
+        type = pcm ? e_stream_in_pcm : e_stream_in_compress;
+    } else {
+        type = pcm ? e_stream_out_pcm : e_stream_out_compress;
+    }
+
+    pthread_mutex_lock(&cm->lock);
+    for (i = cm->stream_array.count - 1; i >= 0; --i) {
+        ALOGV("get_stream: require type=%d; try type=%d refcount=%d refmax=%d",
+                    type, s[i].info.type, s[i].ref_count, s[i].max_ref_count );
+        if (s[i].info.type == type) {
+            if (open_stream_l(cm, &s[i])) {
+                break;
+            }
+        }
+    }
+    pthread_mutex_unlock(&cm->lock);
+
+    if (i >= 0) {
+        ALOGV("-get_stream =%p (refcount=%d)", &s[i].info,
+                                                s[i].ref_count );
+        return &s[i].info;
+    } else {
+        ALOGE("-get_stream no suitable stream" );
+        return NULL;
+    }
+}
+
+const struct hw_stream *get_named_stream(struct config_mgr *cm,
+                                   const char *name)
+{
+    int i;
+    struct stream *s;
+
+    ALOGV("+get_named_stream '%s'", name);
+
+    /* Streams can't be deleted so don't need to hold the lock during search */
+    s = find_named_stream(cm, name);
+
+    pthread_mutex_lock(&cm->lock);
+    if (s != NULL) {
+        if (!open_stream_l(cm, s)) {
+            s = NULL;
+        }
+    }
+    pthread_mutex_unlock(&cm->lock);
+
+    if (s != NULL) {
+        ALOGV("-get_named_stream =%p (refcount=%d)", &s->info, s->ref_count );
+        return &s->info;
+    } else {
+        ALOGE("-get_named_stream no suitable stream" );
+        return NULL;
+    }
+}
+
+bool is_named_stream_defined(struct config_mgr *cm, const char *name)
+{
+    struct stream *s;
+
+    /* Streams can't be deleted so don't need to hold the lock during search */
+    s = find_named_stream(cm, name);
+
+    ALOGV("is_named_stream_defined '%s' = %d", name, (s != NULL));
+    return (s != NULL);
+}
+
+void release_stream( const struct hw_stream* stream )
+{
+    struct stream *s = (struct stream *)stream;
+
+    ALOGV("release_stream %p", stream );
+
+    if (s) {
+        pthread_mutex_lock(&s->cm->lock);
+        if (--s->ref_count == 0) {
+            /* Ensure all paths it was using are disabled */
+            apply_paths_to_devices_l(s->cm, s->current_devices,
+                                    e_path_id_off, s->disable_path);
+            apply_paths_to_global_l(s->cm, s->disable_path, e_path_id_off);
+            s->current_devices = 0;
+        }
+        pthread_mutex_unlock(&s->cm->lock);
+    }
+}
+
+uint32_t get_supported_output_devices( struct config_mgr *cm )
+{
+    const uint32_t d = cm->supported_output_devices;
+
+    ALOGV("get_supported_output_devices=0x%x", d);
+    return d;
+}
+
+uint32_t get_supported_input_devices( struct config_mgr *cm )
+{
+    const uint32_t d = cm->supported_input_devices;
+
+    ALOGV("get_supported_input_devices=0x%x", d);
+    return d;
+}
+
+/*********************************************************************
+ * Use-case control
+ *********************************************************************/
+int apply_use_case( const struct hw_stream* stream,
+                    const char *setting,
+                    const char *case_name)
+{
+    struct stream *s = (struct stream *)stream;
+    struct usecase *puc = s->usecase_array.usecases;
+    int usecase_count = s->usecase_array.count;
+    struct scase *pcase;
+    int case_count;
+    int ret;
+
+    ALOGV("apply_use_case(%p) %s=%s", stream, setting, case_name);
+
+    for (; usecase_count > 0; usecase_count--, puc++) {
+        if (0 == strcmp(puc->name, setting)) {
+            pcase = puc->case_array.cases;
+            case_count = puc->case_array.count;
+            for(; case_count > 0; case_count--, pcase++) {
+                if (0 == strcmp(pcase->name, case_name)) {
+                    pthread_mutex_lock(&s->cm->lock);
+                    apply_ctls_l(pcase->ctl_array.ctls, pcase->ctl_array.count);
+                    pthread_mutex_unlock(&s->cm->lock);
+                    ret = 0;
+                    goto exit;
+                }
+            }
+        }
+    }
+
+    ret = -ENOSYS;      /* use-case not implemented */
+
+exit:
+    return ret;
+}
+
+/*********************************************************************
+ * Config file parsing
+ *
+ * To keep this simple we restrict the order that config file entries
+ * may appear:
+ * - The <mixer> section must always appear first
+ * - Paths must be defined before they can be referred to
+ *********************************************************************/
+static int parse_mixer_start(struct parse_state *state);
+static int parse_device_start(struct parse_state *state);
+static int parse_device_end(struct parse_state *state);
+static int parse_stream_start(struct parse_state *state);
+static int parse_stream_end(struct parse_state *state);
+static int parse_stream_ctl_start(struct parse_state *state);
+static int parse_path_start(struct parse_state *state);
+static int parse_path_end(struct parse_state *state);
+static int parse_case_start(struct parse_state *state);
+static int parse_case_end(struct parse_state *state);
+static int parse_usecase_start(struct parse_state *state);
+static int parse_usecase_end(struct parse_state *state);
+static int parse_enable_start(struct parse_state *state);
+static int parse_disable_start(struct parse_state *state);
+static int parse_ctl_start(struct parse_state *state);
+static int parse_init_start(struct parse_state *state);
+
+static const struct parse_element elem_table[e_elem_count] = {
+    [e_elem_ctl] =    {
+        .name = "ctl",
+        .valid_attribs = BIT(e_attrib_name) | BIT(e_attrib_val) | BIT(e_attrib_index),
+        .required_attribs = BIT(e_attrib_name) | BIT(e_attrib_val),
+        .valid_subelem = 0,
+        .start_fn = parse_ctl_start,
+        .end_fn = NULL
+        },
+
+    [e_elem_path] =    {
+        .name = "path",
+        .valid_attribs = BIT(e_attrib_name),
+        .required_attribs = BIT(e_attrib_name),
+        .valid_subelem = BIT(e_elem_ctl),
+        .start_fn = parse_path_start,
+        .end_fn = parse_path_end
+        },
+
+    [e_elem_device] =    {
+        .name = "device",
+        .valid_attribs = BIT(e_attrib_name),
+        .required_attribs = BIT(e_attrib_name),
+        .valid_subelem = BIT(e_elem_path),
+        .start_fn = parse_device_start,
+        .end_fn = parse_device_end
+        },
+
+    [e_elem_stream] =    {
+        .name = "stream",
+        .valid_attribs = BIT(e_attrib_name) | BIT(e_attrib_type)
+                            | BIT(e_attrib_dir) | BIT(e_attrib_card)
+                            | BIT(e_attrib_device) | BIT(e_attrib_instances)
+                            | BIT(e_attrib_rate) | BIT(e_attrib_period_size)
+                            | BIT(e_attrib_period_count),
+        .required_attribs = BIT(e_attrib_type),
+        .valid_subelem = BIT(e_elem_stream_ctl)
+                            | BIT(e_elem_enable) | BIT(e_elem_disable)
+                            | BIT(e_elem_usecase),
+        .start_fn = parse_stream_start,
+        .end_fn = parse_stream_end
+        },
+
+    [e_elem_enable] =    {
+        .name = "enable",
+        .valid_attribs = BIT(e_attrib_path),
+        .required_attribs = BIT(e_attrib_path),
+        .valid_subelem = 0,
+        .start_fn = parse_enable_start,
+        .end_fn = NULL
+        },
+
+    [e_elem_disable] =    {
+        .name = "disable",
+        .valid_attribs = BIT(e_attrib_path),
+        .required_attribs = BIT(e_attrib_path),
+        .valid_subelem = 0,
+        .start_fn = parse_disable_start,
+        .end_fn = NULL
+        },
+
+    [e_elem_case] =    {
+        .name = "case",
+        .valid_attribs = BIT(e_attrib_name),
+        .required_attribs = BIT(e_attrib_name),
+        .valid_subelem = BIT(e_elem_ctl),
+        .start_fn = parse_case_start,
+        .end_fn = parse_case_end
+        },
+
+    [e_elem_usecase] =    {
+        .name = "usecase",
+        .valid_attribs = BIT(e_attrib_name),
+        .required_attribs = BIT(e_attrib_name),
+        .valid_subelem = BIT(e_elem_case),
+        .start_fn = parse_usecase_start,
+        .end_fn = parse_usecase_end
+        },
+
+    [e_elem_stream_ctl] =    {
+        .name = "ctl",
+        .valid_attribs = BIT(e_attrib_name) | BIT(e_attrib_function)
+                            | BIT(e_attrib_index)
+                            | BIT(e_attrib_min) | BIT(e_attrib_max),
+        .required_attribs = BIT(e_attrib_name) | BIT(e_attrib_function),
+        .valid_subelem = 0,
+        .start_fn = parse_stream_ctl_start,
+        .end_fn = NULL
+        },
+
+    [e_elem_init] =     {
+        .name = "init",
+        .valid_attribs = 0,
+        .required_attribs = 0,
+        .valid_subelem = BIT(e_elem_ctl),
+        .start_fn = parse_init_start,
+        .end_fn = NULL
+        },
+
+    [e_elem_mixer] =    {
+        .name = "mixer",
+        .valid_attribs = BIT(e_attrib_card),
+        .required_attribs = 0,
+        .valid_subelem = BIT(e_elem_init),
+        .start_fn = parse_mixer_start,
+        .end_fn = NULL
+        },
+
+    [e_elem_audiohal] =    {
+        .name = "audiohal",
+        .valid_attribs = 0,
+        .required_attribs = 0,
+        .valid_subelem = BIT(e_elem_mixer),
+        .start_fn = NULL,
+        .end_fn = NULL
+        }
+};
+
+static const struct parse_attrib attrib_table[e_attrib_count] = {
+    [e_attrib_name] =       {"name"},
+    [e_attrib_val] =        {"val"},
+    [e_attrib_path] =       {"path"},
+    [e_attrib_function] =   {"function"},
+    [e_attrib_type] =       {"type"},
+    [e_attrib_index] =      {"index"},
+    [e_attrib_dir] =        {"dir"},
+    [e_attrib_card] =       {"card"},
+    [e_attrib_device] =     {"device"},
+    [e_attrib_instances] =  {"instances"},
+    [e_attrib_rate] =       {"rate"},
+    [e_attrib_period_size] = {"period_size"},
+    [e_attrib_period_count] = {"period_count"},
+    [e_attrib_min] = {"min"},
+    [e_attrib_max] = {"max"}
+ };
+
+static const struct parse_device device_table[] = {
+    {"global",      0}, /* special dummy device for global settings */
+    {"speaker",     AUDIO_DEVICE_OUT_SPEAKER},
+    {"earpiece",    AUDIO_DEVICE_OUT_EARPIECE},
+    {"headset",     AUDIO_DEVICE_OUT_WIRED_HEADSET},
+    {"headset_in",  AUDIO_DEVICE_IN_WIRED_HEADSET},
+    {"headphone",   AUDIO_DEVICE_OUT_WIRED_HEADPHONE},
+    {"sco",         AUDIO_DEVICE_OUT_ALL_SCO},
+    {"sco_in",      AUDIO_DEVICE_IN_ALL_SCO},
+    {"a2dp",        AUDIO_DEVICE_OUT_ALL_A2DP},
+    {"usb",         AUDIO_DEVICE_OUT_ALL_USB},
+    {"mic",         AUDIO_DEVICE_IN_BUILTIN_MIC},
+    {"back mic",    AUDIO_DEVICE_IN_BACK_MIC},
+    {"voice",       AUDIO_DEVICE_IN_VOICE_CALL},
+    {"aux",         AUDIO_DEVICE_IN_AUX_DIGITAL}
+};
+
+static const char *predefined_path_name_table[] = {
+    [e_path_id_off] = "off",
+    [e_path_id_on] = "on"
+};
+
+static int dyn_array_extend(struct dyn_array *array)
+{
+    const uint elem_size = array->elem_size;
+    const uint new_count = array->count + 1;
+    uint max_count = array->max_count;
+    uint old_size, new_size;
+    void *p;
+    uint8_t *pbyte;
+
+    if (new_count > max_count) {
+        if (max_count > 0xFFFF - DYN_ARRAY_GRANULE) {
+            return -ENOMEM;
+        }
+
+        old_size = max_count * elem_size;
+        max_count += DYN_ARRAY_GRANULE;
+        new_size = max_count * elem_size;
+
+        p = realloc(array->data, new_size);
+        if (!p) {
+            return -ENOMEM;
+        }
+
+        pbyte = p;
+        memset(pbyte + old_size, 0, new_size - old_size);
+
+        array->data = p;
+        array->max_count = max_count;
+    }
+
+    array->count = new_count;
+    return 0;
+}
+
+static void dyn_array_fix(struct dyn_array *array)
+{
+    /* Fixes the allocated memory to exactly the required length
+     * This will always be a shrink, discarding granular allocations
+     * that we don't need */
+    const uint size = array->count * array->elem_size;
+    void *p = realloc(array->data, size);
+
+    if (p)
+        {
+        array->data = p;
+        array->max_count = array->count;
+        }
+}
+
+static void dyn_array_free(struct dyn_array *array)
+{
+    free(array->data);
+}
+
+static struct ctl* new_ctl(struct dyn_array *array, struct mixer_ctl *ctl)
+{
+    struct ctl *c;
+
+    if (dyn_array_extend(array) < 0) {
+        return NULL;
+    }
+
+    c = &array->ctls[array->count - 1];
+    c->index = INVALID_CTL_INDEX;
+    c->ctl = ctl;
+    return c;
+}
+
+static void compress_ctl(struct ctl *ctl)
+{
+}
+
+static struct path* new_path(struct dyn_array *array, int id)
+{
+    struct path *path;
+
+    if (dyn_array_extend(array) < 0) {
+        return NULL;
+    }
+
+    path = &array->paths[array->count - 1];
+    path->ctl_array.elem_size = sizeof(struct ctl);
+    path->id = id;
+    return path;
+}
+
+static void compress_path(struct path *path)
+{
+    dyn_array_fix(&path->ctl_array);
+}
+
+static struct scase* new_case(struct dyn_array *array, const char *name)
+{
+    struct scase *sc;
+
+    if (dyn_array_extend(array) < 0) {
+        return NULL;
+    }
+
+    sc = &array->cases[array->count - 1];
+    sc->ctl_array.elem_size = sizeof(struct ctl);
+    sc->name = name;
+    return sc;
+}
+
+static void compress_case(struct scase *sc)
+{
+    dyn_array_fix(&sc->ctl_array);
+}
+
+static struct usecase* new_usecase(struct dyn_array *array, const char *name)
+{
+    struct usecase *puc;
+
+    if (dyn_array_extend(array) < 0) {
+        return NULL;
+    }
+
+    puc = &array->usecases[array->count - 1];
+    puc->case_array.elem_size = sizeof(struct scase);
+    puc->name = name;
+    return puc;
+}
+
+static void compress_usecase(struct usecase *puc)
+{
+    dyn_array_fix(&puc->case_array);
+}
+
+static struct device* new_device(struct dyn_array *array, uint32_t type)
+{
+    struct device *d;
+
+    if (dyn_array_extend(array) < 0) {
+        return NULL;
+    }
+
+    d = &array->devices[array->count - 1];
+    d->path_array.elem_size = sizeof(struct path);
+    d->type = type;
+    return d;
+}
+
+static void compress_device(struct device *d)
+{
+    dyn_array_fix(&d->path_array);
+}
+
+static struct stream* new_stream(struct dyn_array *array, struct config_mgr *cm)
+{
+    struct stream *s;
+
+    if (dyn_array_extend(array) < 0) {
+        return NULL;
+    }
+
+    s = &array->streams[array->count - 1];
+    s->usecase_array.elem_size = sizeof(struct usecase);
+    s->cm = cm;
+    s->enable_path = -1;    /* by default no special path to invoke */
+    s->disable_path = -1;
+    return s;
+}
+
+static void compress_stream(struct stream *s)
+{
+    dyn_array_fix(&s->usecase_array);
+}
+
+static int new_name(struct dyn_array *array, const char* name)
+{
+    int i;
+
+    if (dyn_array_extend(array) < 0) {
+        return -ENOMEM;
+    }
+
+    i = array->count - 1;
+    array->path_names[i] = name;
+    return i;
+}
+
+static struct config_mgr* new_config_mgr()
+{
+    struct config_mgr* mgr = calloc(1, sizeof(struct config_mgr));
+    if (!mgr) {
+        return NULL;
+    }
+    mgr->device_array.elem_size = sizeof(struct device);
+    mgr->stream_array.elem_size = sizeof(struct stream);
+    pthread_mutex_init(&mgr->lock, NULL);
+    return mgr;
+}
+
+static void compress_config_mgr(struct config_mgr *mgr)
+{
+    dyn_array_fix(&mgr->device_array);
+    dyn_array_fix(&mgr->stream_array);
+}
+
+static int find_path_name(struct parse_state *state, const char *name)
+{
+    struct dyn_array *array = &state->path_name_array;
+    int i;
+
+    for (i = array->count - 1; i >= 0; --i) {
+        if (0 == strcmp(array->path_names[i], name)) {
+            ALOGV("Existing path '%s' id=%d", name, i);
+            return i;   /* found - return existing index */
+        }
+    }
+    return -EINVAL;
+}
+
+static int add_path_name(struct parse_state *state, const char *name)
+{
+    struct dyn_array *array = &state->path_name_array;
+    int index;
+    const char *s;
+
+    /* Check if already in array */
+    index = find_path_name(state, name);
+    if (index >= 0) {
+        return index;   /* already exists */
+    }
+
+    s = strdup(name);
+    if (s == NULL) {
+        return -ENOMEM;
+    }
+
+    index = new_name(array, s);
+    if (index < 0) {
+        return -ENOMEM;
+    }
+
+    ALOGV("New path '%s' id=%d", name, index);
+    return index;
+}
+
+static void path_names_free(struct parse_state *state)
+{
+    struct dyn_array *array = &state->path_name_array;
+    int i;
+
+    for (i = array->count - 1; i >= 0; --i) {
+        free((void*)array->path_names[i]);
+    }
+    dyn_array_free(array);
+}
+
+static int string_to_uint(uint32_t *result, const char *str)
+{
+    char *endptr;
+    unsigned long int v;
+
+    if (!str) {
+        return -ENOENT;
+    }
+
+    /* return error if not a valid decimal or hex number */
+    v = strtoul(str, &endptr, 0);
+    if ((endptr[0] == '\0') && (endptr != str) && (v <= INT_MAX)) {
+        *result = (uint32_t)v;
+        return 0;
+    } else {
+        ALOGE("'%s' not a valid number", str);
+        return -EINVAL;
+    }
+}
+
+static int attrib_to_uint(uint32_t *result, struct parse_state *state,
+                                enum attrib_index index)
+{
+    const char *str = state->attribs.value[index];
+    return string_to_uint(result, str);
+}
+
+static int make_byte_array(struct parse_state *state, struct ctl *c)
+{
+    char *str = strdup(state->attribs.value[e_attrib_val]);
+    const unsigned int vnum = mixer_ctl_get_num_values(c->ctl);
+    uint8_t *bytes;
+    int count;
+    char *p;
+    uint32_t v;
+    int ret;
+
+    if (!str) {
+        ret = -ENOMEM;
+        goto fail;
+    }
+
+    if (vnum > BYTE_ARRAY_MAX_SIZE) {
+        ALOGE("Byte array control too big(%u)", vnum);
+        return -EINVAL;
+    }
+
+    if (c->index >= vnum) {
+        ALOGE("Control index out of range(%u>%u)", c->index, vnum);
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    /* get number of entries in value string by counting commas */
+    p = strtok(str, ",");
+    for (count = 0; p != NULL; count++) {
+        p = strtok(NULL, ",");
+    }
+
+    if ((c->index + count) > vnum) {
+        ALOGE("Array overflows control (%u+%u > %u)",
+                    c->index, count, vnum);
+        ret = -EINVAL;
+        goto fail;
+    }
+    c->array_count = count;
+
+    bytes = malloc(count);
+    if (!bytes) {
+        ALOGE("Out of memory for control data");
+        ret = -ENOMEM;
+        goto fail;
+    }
+    c->value.data = bytes;
+
+    strcpy(str,state->attribs.value[e_attrib_val]);
+
+    for (p = strtok(str, ","); p != NULL;) {
+        ret = string_to_uint(&v, p);
+        if (ret != 0) {
+            goto fail;
+        }
+        ALOGE_IF(v > 0xFF, "Byte out of range");
+
+        *bytes++ = (uint8_t)v;
+        p = strtok(NULL, ",");
+    }
+
+    free(str);
+    return 0;
+
+fail:
+    free((void *)c->value.data);
+    free(str);
+    return ret;
+}
+
+static const struct parse_device *parse_match_device(const char *name)
+{
+    const struct parse_device *p = &device_table[0];
+    const struct parse_device *p_end =
+            &device_table[ sizeof(device_table) / sizeof(device_table[0]) ];
+
+    for (; p < p_end; ++p) {
+        if (0 == strcmp(name, p->name)) {
+            return p;
+        }
+    }
+
+    return NULL;
+}
+
+static const char *debug_device_to_name(uint32_t device)
+{
+    const struct parse_device *p = &device_table[0];
+    const struct parse_device *p_end =
+            &device_table[ sizeof(device_table) / sizeof(device_table[0]) ];
+
+    /* Assumes device contains a single bitflag plus direction bit */
+
+    for (; p < p_end; ++p) {
+        if (device == p->device) {
+            return p->name;
+        }
+    }
+
+    return "unknown";
+}
+
+
+static int parse_ctl_start(struct parse_state *state)
+{
+    const char *name = state->attribs.value[e_attrib_name];
+    const char *index = state->attribs.value[e_attrib_index];
+    struct dyn_array *array;
+    struct ctl *c;
+    struct mixer_ctl *ctl;
+    enum mixer_ctl_type ctl_type;
+    int ret;
+
+    if (state->current.path) {
+        ALOGV("parse_ctl_start:path ctl");
+        array = &state->current.path->ctl_array;
+    } else {
+        ALOGV("parse_ctl_start:case ctl");
+        array = &state->current.scase->ctl_array;
+    }
+
+    ctl = mixer_get_ctl_by_name(state->cm->mixer, name);
+    if (!ctl) {
+        ALOGE("Control '%s' not found", name);
+        return -EINVAL;
+    }
+
+    c = new_ctl(array, ctl);
+    if (c == NULL) {
+        return -ENOMEM;
+    }
+
+    if (attrib_to_uint(&c->index, state, e_attrib_index) == -EINVAL) {
+        ALOGE("Invalid ctl index");
+        return -EINVAL;
+    }
+
+    ctl_type = mixer_ctl_get_type(ctl);
+    switch(ctl_type)
+        {
+        case MIXER_CTL_TYPE_BYTE:
+            if (c->index == INVALID_CTL_INDEX) {
+                c->index = 0;
+            }
+            ret = make_byte_array(state, c);
+            if (ret != 0) {
+                return ret;
+            }
+            ALOGV("Added ctl '%s' byte array", name);
+            break;
+
+        case MIXER_CTL_TYPE_BOOL:
+        case MIXER_CTL_TYPE_INT:
+            if (attrib_to_uint(&c->value.uinteger, state, e_attrib_val)
+                                                            == -EINVAL) {
+                return -EINVAL;
+            }
+            /* This log statement is just to aid to debugging */
+            ALOGE_IF((ctl_type == MIXER_CTL_TYPE_BOOL)
+                        && (c->value.uinteger > 1),
+                        "WARNING: Illegal value for bool control");
+            ALOGV("Added ctl '%s' value %u", name, c->value.uinteger);
+            break;
+
+        case MIXER_CTL_TYPE_ENUM:
+            c->value.name = strdup(state->attribs.value[e_attrib_val]);
+            if(!c->value.name) {
+                return -ENOMEM;
+            }
+            ALOGV("Added ctl '%s' value '%s'", name, c->value.name);
+            break;
+
+        case MIXER_CTL_TYPE_IEC958:
+        case MIXER_CTL_TYPE_INT64:
+        case MIXER_CTL_TYPE_UNKNOWN:
+        default:
+            ALOGE("Mixer control '%s' has unsupported type", name);
+            return -EINVAL;
+        };
+
+    return 0;
+}
+
+static int parse_init_start(struct parse_state *state)
+{
+    /* The <init> section inside <mixer> is really just a
+     * path that we only use once. We re-use the parsing of
+     * <ctl> entries by creating a temporary path which we
+     * apply at the end of parsing and then discard
+     */
+    state->current.path = &state->init_path;
+
+    ALOGV("Added init path");
+    return 0;
+}
+
+static int parse_path_start(struct parse_state *state)
+{
+    const char *name = state->attribs.value[e_attrib_name];
+    struct device *device = state->current.device;
+    struct dyn_array *array = &device->path_array;
+    struct path *path;
+    int id;
+
+    id = add_path_name(state, name);
+    if (id < 0) {
+        return id;
+    }
+
+    path = new_path(array, id);
+    if (path == NULL) {
+        return -ENOMEM;
+    }
+
+    state->current.path = path;
+
+    ALOGV("Added path '%s' id=%d", name, id);
+    return 0;
+}
+
+static int parse_path_end(struct parse_state *state)
+{
+    /* Free unused memory in the ctl array */
+    compress_path(state->current.path);
+    state->current.path = NULL;
+    return 0;
+}
+
+static int parse_case_start(struct parse_state *state)
+{
+    const char *name = strdup(state->attribs.value[e_attrib_name]);
+    struct usecase *puc = state->current.usecase;
+    struct dyn_array *array = &puc->case_array;
+    struct scase *sc;
+
+    if (!name) {
+        return -ENOMEM;
+    }
+
+    sc = new_case(array, name);
+    if (sc == NULL) {
+        return -ENOMEM;
+    }
+
+    state->current.scase = sc;
+
+    ALOGV("Added case '%s' to '%s'", name, puc->name);
+    return 0;
+}
+
+static int parse_case_end(struct parse_state *state)
+{
+    /* Free unused memory in the ctl array */
+    compress_case(state->current.scase);
+    state->current.scase = NULL;
+    return 0;
+}
+
+static int parse_usecase_start(struct parse_state *state)
+{
+    const char *name = strdup(state->attribs.value[e_attrib_name]);
+    struct dyn_array *array = &state->current.stream->usecase_array;
+    struct usecase *puc;
+
+    if (!name) {
+        return -ENOMEM;
+    }
+
+    puc = new_usecase(array, name);
+    if (puc == NULL) {
+        return -ENOMEM;
+    }
+
+    state->current.usecase = puc;
+
+    ALOGV("Added usecase '%s'", name);
+
+    return 0;
+}
+
+static int parse_usecase_end(struct parse_state *state)
+{
+    /* Free unused memory in the case array */
+    compress_usecase(state->current.usecase);
+    return 0;
+}
+
+static int parse_enable_disable_start(struct parse_state *state, bool is_enable)
+{
+    /* Handling of <enable> and <disable> is almost identical so
+     * they are both handled in this function
+     */
+
+    const char *path_name = state->attribs.value[e_attrib_path];
+    int i;
+
+    i = find_path_name(state,path_name);
+    if (i < 0) {
+        ALOGE("Path '%s' not defined", path_name);
+        return -EINVAL;
+    }
+
+    if (is_enable) {
+        ALOGV("Add enable path '%s' (id=%d)",
+                                state->path_name_array.path_names[i], i);
+        state->current.stream->enable_path = i;
+    } else {
+        ALOGV("Add disable path '%s' (id=%d)",
+                                state->path_name_array.path_names[i], i);
+        state->current.stream->disable_path = i;
+    }
+
+    return 0;
+}
+
+static int parse_enable_start(struct parse_state *state)
+{
+    return parse_enable_disable_start(state, true);
+}
+
+static int parse_disable_start(struct parse_state *state)
+{
+    return parse_enable_disable_start(state, false);
+}
+
+static int parse_stream_ctl_start(struct parse_state *state)
+{
+    /* Parse a <ctl> element within a stream which defines
+     * mixer controls - currently only supports volume controls
+     */
+
+    const char *name = state->attribs.value[e_attrib_name];
+    const char *function = state->attribs.value[e_attrib_function];
+    const char *index = state->attribs.value[e_attrib_index];
+    struct mixer_ctl *ctl;
+    struct stream_control *streamctl;
+    uint idx_val = 0;
+    uint32_t v;
+    int r;
+
+    ctl = mixer_get_ctl_by_name(state->cm->mixer, name);
+    if (!ctl) {
+        ALOGE("Control '%s' not found", name);
+        return -EINVAL;
+    }
+
+    if (index != NULL) {
+        if (attrib_to_uint(&idx_val, state, e_attrib_index) == -EINVAL) {
+            return -EINVAL;
+        }
+    }
+
+    if (0 == strcmp(function, "leftvol")) {
+        ALOGE_IF(state->current.stream->controls.volume_left.ctl,
+                                "Left volume control specified again");
+        streamctl = &(state->current.stream->controls.volume_left);
+    } else if (0 == strcmp(function, "rightvol")) {
+        ALOGE_IF(state->current.stream->controls.volume_right.ctl,
+                                "Right volume control specified again");
+        streamctl = &(state->current.stream->controls.volume_right);
+    } else {
+        ALOGE("'%s' is not a valid control function", function);
+        return -EINVAL;
+    }
+
+    streamctl->ctl = ctl;
+    streamctl->id = idx_val;
+
+    switch (attrib_to_uint(&v, state, e_attrib_min)) {
+    case -EINVAL:
+        return -EINVAL;
+
+    case -ENOENT:
+        /* Not specified, get control's min value */
+        r = mixer_ctl_get_range_min(ctl);
+        if (r < 0) {
+            ALOGE("Failed to get control min");
+            return r;
+        }
+        streamctl->min = (uint)r;
+        break;
+
+    default:
+        streamctl->min = v;
+        break;
+    }
+
+    switch (attrib_to_uint(&v, state, e_attrib_max)) {
+    case -EINVAL:
+        return -EINVAL;
+
+    case -ENOENT:
+        /* Not specified, get control's max value */
+        r = mixer_ctl_get_range_max(ctl);
+        if (r < 0) {
+            ALOGE("Failed to get control max");
+            return r;
+        }
+        streamctl->max = (uint)r;
+        break;
+
+    default:
+        streamctl->max = v;
+        break;
+    }
+
+    ALOGV("Added control '%s' function '%s' range %u-%u", name, function,
+                streamctl->min, streamctl->max);
+
+    return 0;
+}
+
+static int parse_stream_start(struct parse_state *state)
+{
+    const char *type = state->attribs.value[e_attrib_type];
+    const char *dir = state->attribs.value[e_attrib_dir];
+    const char *name = state->attribs.value[e_attrib_name];
+    bool out;
+    uint32_t card;
+    uint32_t device;
+    uint32_t maxref = INT_MAX;
+    struct stream *s;
+
+    if (name != NULL) {
+        name = strdup(name);
+        if (name == NULL) {
+            return -ENOMEM;
+        }
+    }
+
+    if (name != NULL) {
+        if (find_named_stream(state->cm, name) != NULL) {
+            ALOGE("Stream '%s' already declared", name);
+            return -EINVAL;
+        }
+    }
+
+    s = new_stream(&state->cm->stream_array, state->cm);
+    if (s == NULL) {
+        return -ENOMEM;
+    }
+
+    if (0 == strcmp(type, "hw")) {
+        if (name == NULL) {
+            ALOGE("Anonymous stream cannot be type hw");
+            return -EINVAL;
+        }
+        s->info.type = e_stream_hardware;
+    } else {
+        if (dir == NULL) {
+            ALOGE("dir tag missing");
+            return -EINVAL;
+        }
+
+        if (0 == strcmp(dir, "out")) {
+            out = true;
+        } else if (0 == strcmp(dir, "in")) {
+            out = false;
+        } else {
+            ALOGE("'%s' is not a valid direction", dir);
+            return -EINVAL;
+        }
+
+        if (0 == strcmp(type, "pcm")) {
+            s->info.type = out ? e_stream_out_pcm : e_stream_in_pcm;
+            card = PCM_CARD_DEFAULT;
+            device = PCM_DEVICE_DEFAULT;
+        } else if (0 == strcmp(type, "compress")) {
+            s->info.type = out ? e_stream_out_compress : e_stream_in_compress;
+            card = COMPRESS_CARD_DEFAULT;
+            device = COMPRESS_DEVICE_DEFAULT;
+        } else {
+            ALOGE("'%s' not a valid stream type", type);
+            return -EINVAL;
+        }
+    }
+
+    if (attrib_to_uint(&card, state, e_attrib_card) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    if (attrib_to_uint(&device, state, e_attrib_device) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    if (attrib_to_uint(&maxref, state, e_attrib_instances) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    if (attrib_to_uint(&s->info.rate, state, e_attrib_rate) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    if (attrib_to_uint(&s->info.period_count, state,
+                        e_attrib_period_count) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    if (attrib_to_uint(&s->info.period_count, state,
+                        e_attrib_period_size) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    s->name = name;
+    s->info.card_number = card;
+    s->info.device_number = device;
+    s->max_ref_count = maxref;
+
+    ALOGV("Added stream %s type=%u card=%u device=%u max_ref=%u",
+                    s->name ? s->name : "",
+                    s->info.type, s->info.card_number, s->info.device_number,
+                    s->max_ref_count );
+
+    state->current.stream = s;
+
+    return 0;
+}
+
+static int parse_stream_end(struct parse_state *state)
+{
+    /* Free unused memory in the ctl array */
+    compress_stream(state->current.stream);
+    return 0;
+}
+
+static int parse_device_start(struct parse_state *state)
+{
+    const char *dev_name = state->attribs.value[e_attrib_name];
+    struct dyn_array *array = &state->cm->device_array;
+    uint32_t device_flag;
+    uint32_t *existing_devices;
+    const struct parse_device *p;
+    struct device* d;
+
+    p = parse_match_device(dev_name);
+
+    if (p == NULL) {
+        ALOGE("'%s' is not a valid device", dev_name);
+        return -EINVAL;
+    }
+
+    device_flag = p->device;
+
+    if (device_flag != 0) {
+        /* not the global device - add it to list of available devices */
+        if (device_flag & AUDIO_DEVICE_BIT_IN) {
+                existing_devices = &state->cm->supported_input_devices;
+        } else {
+                existing_devices = &state->cm->supported_output_devices;
+        }
+
+        if ((device_flag & *existing_devices) == device_flag) {
+            ALOGE("Device '%s' already defined", dev_name);
+            ALOGE("Device = 0x%x extisting_devices = 0x%x", device_flag, *existing_devices);
+            ALOGE("supported_output_devices=0x%x supported_input_devices=0x%x",
+                            state->cm->supported_output_devices,
+                            state->cm->supported_input_devices );
+            return -EINVAL;
+        }
+        *existing_devices |= device_flag;
+    }
+
+    ALOGV("Add device '%s'", dev_name);
+
+    d = new_device(array, device_flag);
+    if (d == NULL) {
+        return -ENOMEM;
+    }
+    state->current.device = d;
+
+    return 0;
+}
+
+static int parse_device_end(struct parse_state *state)
+{
+    /* Free unused memory in the path array */
+    compress_device(state->current.device);
+    return 0;
+}
+
+static int parse_mixer_start(struct parse_state *state)
+{
+    uint32_t card = MIXER_CARD_DEFAULT;
+
+    ALOGV("parse_mixer_start");
+
+    if (attrib_to_uint(&card, state, e_attrib_card) == -EINVAL) {
+        return -EINVAL;
+    }
+
+    ALOGV("Opening mixer card %u", card);
+
+    state->cm->mixer = mixer_open(card);
+
+    if (!state->cm->mixer) {
+        ALOGE("Failed to open mixer card %u", card);
+        return -EINVAL;
+    }
+
+    /* Now we can allow all other root elements but not another <mixer> */
+    state->stack.entry[state->stack.index - 1].valid_subelem =
+                                                  BIT(e_elem_device)
+                                                | BIT(e_elem_stream);
+    return 0;
+}
+
+static int parse_set_error(struct parse_state *state, int error)
+{
+    state->parse_error = error;
+    state->error_line = XML_GetCurrentLineNumber(state->parser);
+    return error;
+}
+
+static int parse_log_error(struct parse_state *state)
+{
+    int err = state->parse_error;
+    int xml_err = XML_GetErrorCode(state->parser);
+
+    if((err < 0) || (xml_err != XML_ERROR_NONE)) {
+        ALOGE_IF(err < 0, "Error in config file at line %d", state->error_line);
+        ALOGE_IF(xml_err != XML_ERROR_NONE,
+                            "Parse error '%s' in config file at line %u",
+                            XML_ErrorString(xml_err),
+                            (uint)XML_GetCurrentLineNumber(state->parser));
+        return -EINVAL;
+    } else {
+        return 0;
+    }
+}
+
+static int extract_attribs(struct parse_state *state, int elem_index)
+{
+    const uint32_t valid_attribs = elem_table[elem_index].valid_attribs;
+    uint32_t required_attribs = elem_table[elem_index].required_attribs;
+    const XML_Char **attribs = state->attribs.all;
+    int i;
+
+    memset(&state->attribs.value, 0, sizeof(state->attribs.value));
+
+    while (attribs[0] != NULL) {
+        for (i = 0; i < e_attrib_count; ++i ) {
+            if ((BIT(i) & valid_attribs) != 0) {
+                if (0 == strcmp(attribs[0], attrib_table[i].name)) {
+                    state->attribs.value[i] = attribs[1];
+                    required_attribs &= ~BIT(i);
+                    break;
+                }
+            }
+        }
+        if (i >= e_attrib_count) {
+            ALOGE("Attribute '%s' not allowed here", attribs[0] );
+            return -EINVAL;
+        }
+
+        attribs += 2;
+    }
+
+    if (required_attribs != 0) {
+        for (i = 0; i < e_attrib_count; ++i ) {
+            if ((required_attribs & BIT(i)) != 0) {
+                ALOGE("Attribute '%s' required", attrib_table[i].name);
+            }
+        }
+        return -EINVAL;
+    }
+
+    return 0;
+}
+
+static void parse_section_start(void *data, const XML_Char *name,
+                                const XML_Char **attribs)
+{
+    struct parse_state *state = (struct parse_state *)data;
+    int stack_index = state->stack.index;
+    const uint32_t valid_elems =
+                        state->stack.entry[stack_index].valid_subelem;
+    int i;
+
+    if (state->parse_error != 0) {
+        return;
+    }
+
+    ALOGV("parse start <%s>", name );
+
+    /* Find element in list of elements currently valid */
+    for (i = 0; i < e_elem_count; ++i) {
+        if ((BIT(i) & valid_elems) != 0) {
+            if (0 == strcmp(name, elem_table[i].name)) {
+                break;
+            }
+        }
+    }
+
+    if ((i >= e_elem_count) || (stack_index >= MAX_PARSE_DEPTH)) {
+        ALOGE("Element '%s' not allowed here", name);
+        parse_set_error(state, -EINVAL);
+    } else {
+        /* element ok - push onto stack */
+        ++stack_index;
+        state->stack.entry[stack_index].elem_index = i;
+        state->stack.entry[stack_index].valid_subelem
+                                                = elem_table[i].valid_subelem;
+        state->stack.index = stack_index;
+
+        /* Extract attributes and call handler */
+        state->attribs.all = attribs;
+        if (extract_attribs(state, i) != 0) {
+            parse_set_error(state, -EINVAL);
+        } else {
+            if (elem_table[i].start_fn) {
+                parse_set_error(state, (*elem_table[i].start_fn)(state));
+            }
+        }
+    }
+}
+
+static void parse_section_end(void *data, const XML_Char *name)
+{
+    struct parse_state *state = (struct parse_state *)data;
+    const int i = state->stack.entry[state->stack.index].elem_index;
+
+    if (state->parse_error != 0) {
+        return;
+    }
+
+    ALOGV("parse end <%s>", name );
+
+    if (elem_table[i].end_fn) {
+        state->parse_error = (*elem_table[i].end_fn)(state);
+    }
+
+    --state->stack.index;
+}
+
+static int do_parse(struct parse_state *state)
+{
+    bool eof = false;
+    int len;
+    int ret = 0;
+
+    state->parse_error = 0;
+    state->stack.index = 0;
+    /* First element must be <audiohal> */
+    state->stack.entry[0].valid_subelem = BIT(e_elem_audiohal);
+
+    while (!eof && (state->parse_error == 0)) {
+        len = fread(state->read_buf, 1, sizeof(state->read_buf), state->file);
+        if (ferror(state->file)) {
+            ALOGE("I/O error reading config file");
+            ret = -EIO;
+            break;
+        }
+
+        eof = feof(state->file);
+
+        XML_Parse(state->parser, state->read_buf, len, eof);
+        if (parse_log_error(state) < 0) {
+            ret = -EINVAL;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+static int open_config_file(struct parse_state *state)
+{
+    char name[80];
+    char property[PROPERTY_VALUE_MAX];
+
+    property_get("ro.product.device", property, "generic");
+    snprintf(name, sizeof(name), "/system/etc/audio.%s.xml", property);
+
+    ALOGV("Reading configuration from %s\n", name);
+    state->file = fopen(name, "r");
+    if (state->file) {
+        return 0;
+    } else {
+        ALOGE_IF(!state->file, "Failed to open config file %s", name);
+        return -ENOSYS;
+    }
+}
+
+static void cleanup_parser(struct parse_state *state)
+{
+    if (state) {
+        path_names_free(state);
+
+        dyn_array_free(&state->init_path.ctl_array);
+
+        if (state->parser) {
+            XML_ParserFree(state->parser);
+        }
+
+        if (state->file) {
+            fclose(state->file);
+        }
+
+        free(state);
+    }
+}
+
+static int parse_config_file(struct config_mgr *cm)
+{
+    struct parse_state *state;
+    int ret = 0;
+
+    state = calloc(1, sizeof(struct parse_state));
+    if (!state) {
+        return -ENOMEM;
+    }
+    state->cm = cm;
+    state->path_name_array.elem_size = sizeof(const char *);
+    state->init_path.ctl_array.elem_size = sizeof(struct ctl);
+
+    /* "off" and "on" are pre-defined path names */
+    ret = add_path_name(state, predefined_path_name_table[0]);
+    if (ret < 0) {
+        goto fail;
+    }
+    ret = add_path_name(state, predefined_path_name_table[1]);
+    if (ret < 0) {
+        goto fail;
+    }
+
+    ret = open_config_file(state);
+    if (ret == 0) {
+        ret = -ENOMEM;
+        state->parser = XML_ParserCreate(NULL);
+        if (state->parser) {
+            XML_SetUserData(state->parser, state);
+            XML_SetElementHandler(state->parser, parse_section_start, parse_section_end);
+            ret = do_parse(state);
+        }
+    }
+
+    if (ret >= 0) {
+        /* Initialize the mixer by applying the <init> path */
+        /* No need to take mutex during initialization */
+        apply_path_l(&state->init_path);
+    }
+
+fail:
+    cleanup_parser(state);
+    return ret;
+}
+
+/*********************************************************************
+ * Initialization
+ *********************************************************************/
+
+struct config_mgr *init_audio_config()
+{
+    struct stream *streams;
+    int ret;
+
+    struct config_mgr* mgr = new_config_mgr();
+
+    if (0 != parse_config_file(mgr)) {
+        free(mgr);
+        return NULL;
+    }
+
+    /* Free unused memory in the device and stream arrays */
+    compress_config_mgr(mgr);
+
+    return mgr;
+}
+
+static void free_usecases( struct stream *stream )
+{
+    struct usecase *puc = stream->usecase_array.usecases;
+    int uc_count = stream->usecase_array.count;
+    struct scase *pcase;
+    int i;
+
+    for (; uc_count > 0; uc_count--, puc++) {
+        free((void *)puc->name);
+        pcase = puc->case_array.cases;
+        for (i = puc->case_array.count; i > 0; i--, pcase++) {
+            free((void *)pcase->name);
+        }
+    }
+}
+
+void free_audio_config( struct config_mgr *cm )
+{
+    struct dyn_array *path_array, *ctl_array, *stream_array;
+    int dev_idx, path_idx, ctl_idx, stream_idx;
+
+    if (cm) {
+        /* Free all devices */
+        for (dev_idx = cm->device_array.count - 1; dev_idx >= 0; --dev_idx) {
+            /* Free all paths in device */
+            path_array = &cm->device_array.devices[dev_idx].path_array;
+            for (path_idx = path_array->count - 1; path_idx >= 0; --path_idx) {
+                /* Free all ctls in path */
+                ctl_array = &path_array->paths[path_idx].ctl_array;
+                for (ctl_idx = ctl_array->count - 1; ctl_idx >= 0; --ctl_idx) {
+                    if (ctl_array->ctls[ctl_idx].value.name) {
+                        free((void*)ctl_array->ctls[ctl_idx].value.name);
+                        ctl_array->ctls[ctl_idx].value.name = NULL;
+                    }
+                    if (ctl_array->ctls[ctl_idx].value.data) {
+                        free((void*)ctl_array->ctls[ctl_idx].value.data);
+                        ctl_array->ctls[ctl_idx].value.data = NULL;
+                    }
+                }
+                dyn_array_free(ctl_array);
+            }
+
+            dyn_array_free(path_array);
+        }
+        dyn_array_free(&cm->device_array);
+
+        stream_array = &cm->stream_array;
+        for(stream_idx = stream_array->count - 1; stream_idx >= 0; --stream_idx) {
+            free_usecases(&stream_array->streams[stream_idx]);
+        }
+        dyn_array_free(&cm->stream_array);
+
+        if (cm->mixer) {
+            mixer_close(cm->mixer);
+        }
+        pthread_mutex_destroy(&cm->lock);
+        free(cm);
+    }
+}
+
diff --git a/audio_config.h b/audio_config.h
new file mode 100644
index 0000000..093a273
--- /dev/null
+++ b/audio_config.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2012-2013 Wolfson Microelectronics plc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_CONFIG_H
+#define AUDIO_CONFIG_H
+
+#include <stddef.h>
+#include <system/audio.h>
+
+struct mixer_ctl;
+struct config_mgr;
+struct audio_config;
+
+/** Stream type */
+enum stream_type {
+    e_stream_out_pcm,
+    e_stream_in_pcm,
+    e_stream_out_compress,
+    e_stream_in_compress,
+    e_stream_hardware           /* unspecified type routed in hardware */
+};
+
+/** Information about a stream */
+struct hw_stream {
+    enum stream_type    type : 8;
+    uint8_t             card_number;
+    uint8_t             device_number;
+    unsigned int        rate;
+    unsigned int        period_size;
+    unsigned int        period_count;
+};
+
+/** Test whether a stream is an input */
+static inline bool stream_is_input( const struct hw_stream *stream )
+{
+    return (stream->type == e_stream_in_pcm)
+        || (stream->type == e_stream_in_compress);
+}
+
+/** Test whether a stream is PCM */
+static inline bool stream_is_pcm( const struct hw_stream *stream )
+{
+    return (stream->type == e_stream_out_pcm)
+        || (stream->type == e_stream_in_pcm);
+}
+
+/** Test whether a stream is compressed */
+static inline bool stream_is_compressed( const struct hw_stream *stream )
+{
+    return (stream->type == e_stream_out_compress)
+        || (stream->type == e_stream_in_compress);
+}
+
+/** Test whether stream is PCM output */
+static inline bool stream_is_pcm_out( const struct hw_stream *stream )
+{
+return (stream->type == e_stream_out_pcm);
+}
+
+/** Test whether stream is PCM input */
+static inline bool stream_is_pcm_in( const struct hw_stream *stream )
+{
+return (stream->type == e_stream_in_pcm);
+}
+
+/** Test whether stream is compressed output */
+static inline bool stream_is_compressed_out( const struct hw_stream *stream )
+{
+return (stream->type == e_stream_out_compress);
+}
+
+/** Test whether stream is compressed input */
+static inline bool stream_is_compressed_in( const struct hw_stream *stream )
+{
+return (stream->type == e_stream_in_compress);
+}
+
+/** Test whether stream is a hardware link */
+static inline bool stream_is_hardware( const struct hw_stream *stream )
+{
+return (stream->type == e_stream_hardware);
+}
+
+/** Initialize audio config layer */
+struct config_mgr *init_audio_config();
+
+/** Delete audio config layer */
+void free_audio_config( struct config_mgr *cm );
+
+/** Get list of all supported devices */
+uint32_t get_supported_devices( struct config_mgr *cm );
+
+/** Find a suitable stream and return pointer to it */
+const struct hw_stream *get_stream(  struct config_mgr *cm,
+                                        const audio_devices_t devices,
+                                        const audio_output_flags_t flags,
+                                        const struct audio_config *config );
+
+/** Find a named custom stream and return a pointer to it */
+const struct hw_stream *get_named_stream(struct config_mgr *cm,
+                                   const char *name);
+
+/** Test whether a named custom stream is defined */
+bool is_named_stream_defined(struct config_mgr *cm, const char *name);
+
+/** Release stream */
+void release_stream( const struct hw_stream *stream );
+
+/** Get currently connected routes */
+uint32_t get_current_routes( const struct hw_stream *stream );
+
+/** Apply new device routing to a stream */
+void apply_route( const struct hw_stream *stream, uint32_t devices );
+
+/** Get bitmask of devices currently connected to this stream */
+uint32_t get_routed_devices( const struct hw_stream *stream );
+
+/** Adjust routing for all streams that alter with orentiation */
+void rotate_routes( struct config_mgr *cm, int orientation );
+
+/** Apply hardware volume */
+int set_hw_volume( const struct hw_stream *stream, int left_pc, int right_pc);
+
+/** Apply a custom use-case
+ *
+ * @return      0 on success
+ * @return      -ENOSYS if the usecase not declared
+ */
+int apply_use_case( const struct hw_stream* stream,
+                    const char *setting,
+                    const char *case_name);
+#endif  /* ifndef AUDIO_CONFIG_H */
diff --git a/audio_hw.c b/audio_hw.c
index be5cdff..dbf5e10 100644
--- a/audio_hw.c
+++ b/audio_hw.c
@@ -1,8 +1,9 @@
 /*
- * Copyright (C) 2012 Wolfson Microelectronics plc
- * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (C) 2012-13 Wolfson Microelectronics plc
  *
- * Liberal inspiration drawn from the AOSP code for Toro.
+ * This code is heavily based on AOSP HAL for the asus/grouper
+ *
+ * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,8 +18,8 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "tiny_hw"
-#define LOG_NDEBUG 0
+#define LOG_TAG "tinyhal"
+/*#define LOG_NDEBUG 0*/
 
 #include <errno.h>
 #include <pthread.h>
@@ -30,204 +31,280 @@
 #include <cutils/properties.h>
 #include <cutils/str_parms.h>
 
-#include <hardware/hardware.h>
-#include <system/audio.h>
-#include <hardware/audio.h>
+#include <utils/Timers.h>
 
-#include <expat.h>
+#include <hardware/audio.h>
+#include <hardware/hardware.h>
+
+#include <system/audio.h>
 
 #include <tinyalsa/asoundlib.h>
+#include <sound/compress_params.h>
+#include <sound/compress_offload.h>
+#include <tinycompress/tinycompress.h>
+
 #include <audio_utils/resampler.h>
-#include <hardware/audio_effect.h>
 
-struct route_setting
-{
-    char *ctl_name;
-    int intval;
-    char *strval;
+#include "audio_config.h"
+#include "voice_trigger.h"
+
+#include <math.h>
+
+
+#define OUT_PERIOD_SIZE_DEFAULT 1024
+#define OUT_PERIOD_COUNT_DEFAULT 4
+#define OUT_SAMPLING_RATE_DEFAULT 44100
+#define OUT_CHANNEL_MASK_DEFAULT AUDIO_CHANNEL_OUT_STEREO
+
+#define IN_PERIOD_COUNT_DEFAULT 4
+#define IN_PERIOD_SIZE_DEFAULT 1024
+#define IN_SAMPLING_RATE_DEFAULT 44100
+#define IN_CHANNEL_MASK_DEFAULT AUDIO_CHANNEL_IN_MONO
+
+/* AudioFlinger does not re-read the buffer size after
+ * issuing a routing or input_source change so the
+ * default buffer size must be suitable for both PCM
+ * and compressed inputs
+ */
+#define IN_COMPRESS_BUFFER_SIZE_DEFAULT 8192
+
+/* Maximum time we'll wait for data from a compress_pcm input */
+#define MAX_COMPRESS_PCM_TIMEOUT_MS     2100
+
+struct voice_control_trigger {
+    pthread_t thread;
+    pthread_mutex_t lock;
+    pthread_cond_t waitcv;
+    struct compress *compress;
+    void (*callback)(void *param);
+    void *callback_param;
+    bool own_compress;
+    volatile bool wait;
+    volatile bool terminate;
+    volatile bool triggered;
 };
 
-/* The enable flag when 0 makes the assumption that enums are disabled by
- * "Off" and integers/booleans by 0 */
-static int set_route_by_array(struct mixer *mixer, struct route_setting *route,
-			      unsigned int len)
-{
-    struct mixer_ctl *ctl;
-    unsigned int i, j, ret;
+struct audio_device {
+    struct audio_hw_device hw_device;
 
-    /* Go through the route array and set each value */
-    for (i = 0; i < len; i++) {
-        ctl = mixer_get_ctl_by_name(mixer, route[i].ctl_name);
-        if (!ctl) {
-	    LOGE("Unknown control '%s'\n", route[i].ctl_name);
-            return -EINVAL;
-	}
-
-        if (route[i].strval) {
-	    ret = mixer_ctl_set_enum_by_string(ctl, route[i].strval);
-	    if (ret != 0) {
-		LOGE("Failed to set '%s' to '%s'\n",
-		     route[i].ctl_name, route[i].strval);
-	    } else {
-		LOGV("Set '%s' to '%s'\n",
-		     route[i].ctl_name, route[i].strval);
-	    }
-	    
-        } else {
-            /* This ensures multiple (i.e. stereo) values are set jointly */
-            for (j = 0; j < mixer_ctl_get_num_values(ctl); j++) {
-		ret = mixer_ctl_set_value(ctl, j, route[i].intval);
-		if (ret != 0) {
-		    LOGE("Failed to set '%s'.%d to %d\n",
-			 route[i].ctl_name, j, route[i].intval);
-		} else {
-		    LOGV("Set '%s'.%d to %d\n",
-			 route[i].ctl_name, j, route[i].intval);
-		}
-	    }
-        }
-    }
-
-    return 0;
-}
-
-struct tiny_dev_cfg {
-    int mask;
-
-    struct route_setting *on;
-    unsigned int on_len;
-
-    struct route_setting *off;
-    unsigned int off_len;
-};
-
-struct tiny_audio_device {
-    struct audio_hw_device device;
-    struct mixer *mixer;
-
-    int mode;
-
-    pthread_mutex_t route_lock;
-    struct tiny_dev_cfg *dev_cfgs;
-    int num_dev_cfgs;
-    int active_devices;
-    int devices;
-
+    pthread_mutex_t lock; /* see note below on mutex acquisition order */
+    bool standby;
     bool mic_mute;
+    struct config_mgr *cm;
+    int orientation;
+    bool screen_off;
+
+    struct stream_out_pcm *active_out;
+    struct stream_in_pcm *active_in;
+    struct stream_in_pcm *active_voice_control;
 };
 
-struct tiny_stream_out {
+
+typedef void(*close_fn)(struct audio_stream *);
+
+/* Fields common to all types of output stream */
+struct stream_out_common {
     struct audio_stream_out stream;
 
-    struct tiny_audio_device *adev;
+    close_fn    close;
+    struct audio_device *dev;
+    const struct hw_stream* hw;
 
-    struct pcm_config config;
-    struct pcm *pcm;
+    pthread_mutex_t lock; /* see note below on mutex acquisition order */
+
+    bool standby;
+
+    /* Stream parameters as seen by AudioFlinger
+     * If stream is resampling AudioFlinger buffers before
+     * passing them to hardware, these members refer to the
+     * _input_ data from AudioFlinger
+     */
+    audio_format_t format;
+    uint32_t channel_mask;
+    int channel_count;
+    uint32_t sample_rate;
+    size_t frame_size;
+    uint32_t buffer_size;
+
+    struct {
+        uint32_t    screen_off;
+        uint32_t    screen_on;
+    } latency;
 };
 
-#define MAX_PREPROCESSORS 10
+struct stream_out_pcm {
+    struct stream_out_common common;
 
-struct tiny_stream_in {
+    struct pcm *pcm;
+
+    uint32_t hw_sample_rate;    /* actual sample rate of hardware */
+    int hw_channel_count;  /* actual number of output channels */
+};
+
+/* Fields common to all types of input stream */
+struct stream_in_common {
     struct audio_stream_in stream;
 
-    pthread_mutex_t lock;
+    close_fn    close;
+    struct audio_device *dev;
+    const struct hw_stream* hw;
 
-    struct tiny_audio_device *adev;
+    pthread_mutex_t lock; /* see note below on mutex acquisition order */
 
-    struct pcm_config config;
-    struct pcm *pcm;
+    bool standby;
+
+    /* Stream parameters as seen by AudioFlinger
+     * If stream is resampling AudioFlinger buffers before
+     * passing them to hardware, these members refer to the
+     * _input_ data from AudioFlinger
+     */
+    audio_format_t format;
+    uint32_t channel_mask;
+    int channel_count;
+    uint32_t sample_rate;
+    size_t frame_size;
+    size_t buffer_size;
+
+    int input_source;
+};
+
+struct stream_in_pcm {
+    struct stream_in_common common;
+
+    union {
+        struct pcm *pcm;
+        struct compress *compress;
+    };
+
+    uint32_t hw_sample_rate;    /* actual sample rate of hardware */
+    int hw_channel_count;  /* actual number of input channels */
+    uint32_t period_size;       /* ... of PCM input */
 
     struct resampler_itfe *resampler;
     struct resampler_buffer_provider buf_provider;
     int16_t *buffer;
+    size_t in_buffer_size;
+    int in_buffer_frames;
     size_t frames_in;
-    unsigned int requested_rate;
-    int standby;
-    int source;
-    effect_handle_t preprocessors[MAX_PREPROCESSORS];
-    int num_preprocessors;
-    int16_t *proc_buf;
-    size_t proc_buf_size;
-    size_t proc_frames_in;
     int read_status;
+
+    struct voice_control_trigger *vc_trigger;
 };
 
-/* Must be called with route_lock */
-void select_devices(struct tiny_audio_device *adev)
+enum {
+    ORIENTATION_LANDSCAPE,
+    ORIENTATION_PORTRAIT,
+    ORIENTATION_SQUARE,
+    ORIENTATION_UNDEFINED,
+};
+
+static uint32_t out_get_sample_rate(const struct audio_stream *stream);
+static uint32_t in_get_sample_rate(const struct audio_stream *stream);
+static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
+                                   struct resampler_buffer* buffer);
+static void release_buffer(struct resampler_buffer_provider *buffer_provider,
+                                  struct resampler_buffer* buffer);
+/*
+ * NOTE: when multiple mutexes have to be acquired, always take the
+ * audio_device mutex first, followed by the stream_in and/or
+ * stream_out mutexes.
+ */
+
+/*********************************************************************
+ * Stream common functions
+ *********************************************************************/
+
+static int common_set_parameters_locked(const struct hw_stream *stream, const char *kvpairs)
 {
-    int i;
+    char *parms = strdup(kvpairs);
+    char *p, *temp;
+    char *pval;
+    char value[32];
+    int ret;
 
-    if (adev->active_devices == adev->devices)
-	return;
+    ALOGV("+common_set_parameters(%p) '%s'", stream, kvpairs);
 
-    LOGV("Changing devices %x => %x\n", adev->active_devices, adev->devices);
+    if (!parms) {
+        return -ENOMEM;
+    }
 
-    /* Turn on new devices first so we don't glitch due to powerdown... */
-    for (i = 0; i < adev->num_dev_cfgs; i++)
-	if ((adev->devices & adev->dev_cfgs[i].mask) &&
-	    !(adev->active_devices & adev->dev_cfgs[i].mask))
-	    set_route_by_array(adev->mixer, adev->dev_cfgs[i].on,
-			       adev->dev_cfgs[i].on_len);
+    /* It's not obvious what we should do if multiple parameters
+     * are given and we only understand some. The action taken
+     * here is to process all that we understand and only return
+     * and error if we don't understand any
+     */
+    ret = -ENOTSUP;
+    p = strtok_r(parms, ";", &temp);
+    while(p) {
+        pval = strchr(p, '=');
+        if (pval && (pval[1] != '\0')) {
+            *pval = '\0';
+            if (apply_use_case(stream, p, pval+1) >= 0) {
+                ret = 0;
+            }
+            *pval = '=';
+        }
+        p = strtok_r(NULL, ";", &temp);
+    }
 
-    /* ...then disable old ones. */
-    for (i = 0; i < adev->num_dev_cfgs; i++)
-	if (!(adev->devices & adev->dev_cfgs[i].mask) &&
-	    (adev->active_devices & adev->dev_cfgs[i].mask))
-	    set_route_by_array(adev->mixer, adev->dev_cfgs[i].off,
-			       adev->dev_cfgs[i].off_len);
-
-    adev->active_devices = adev->devices;
+    return ret;
 }
 
+static int common_get_routing_param(uint32_t *vout, const char *kvpairs)
+{
+    struct str_parms *parms;
+    char value[32];
+    int ret;
+
+    parms = str_parms_create_str(kvpairs);
+
+    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
+                            value, sizeof(value));
+    if (ret >= 0) {
+        *vout = atoi(value);
+    }
+    str_parms_destroy(parms);
+    return ret;
+}
+
+/*********************************************************************
+ * Output stream common functions
+ *********************************************************************/
+
 static uint32_t out_get_sample_rate(const struct audio_stream *stream)
 {
-    return 44100;
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    return out->sample_rate;
 }
 
 static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 {
-    if (rate == out_get_sample_rate(stream))
-	return 0;
-    else
-	return -EINVAL;
+    return -ENOSYS;
 }
 
 static size_t out_get_buffer_size(const struct audio_stream *stream)
 {
-    return 4096;
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    ALOGV("out_get_buffer_size(%p): %u", stream, out->buffer_size );
+    return out->buffer_size;
 }
 
 static uint32_t out_get_channels(const struct audio_stream *stream)
 {
-    return AUDIO_CHANNEL_OUT_STEREO;
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    return out->channel_mask;
 }
 
-static int out_get_format(const struct audio_stream *stream)
+static audio_format_t out_get_format(const struct audio_stream *stream)
 {
-    return AUDIO_FORMAT_PCM_16_BIT;
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    /*ALOGV("out_get_format(%p): 0x%x", stream, out->format );*/
+    return out->format;
 }
 
-static int out_set_format(struct audio_stream *stream, int format)
+static int out_set_format(struct audio_stream *stream, audio_format_t format)
 {
-    return 0;
-}
-
-static int out_standby(struct audio_stream *stream)
-{
-    struct tiny_stream_out *out = (struct tiny_stream_out *)stream;
-    int ret;
-
-    if (out->pcm) {
-	LOGV("out_standby(%p) closing PCM\n", stream);
-	ret = pcm_close(out->pcm);
-	if (ret != 0) {
-	    LOGE("out_standby(%p) failed: %d\n", stream, ret);
-	    return ret;
-	}
-	out->pcm = NULL;
-    }
-
-    return 0;
+    return -ENOSYS;
 }
 
 static int out_dump(const struct audio_stream *stream, int fd)
@@ -237,36 +314,29 @@
 
 static int out_set_parameters(struct audio_stream *stream, const char *kvpairs)
 {
-    struct tiny_stream_out *out = (struct tiny_stream_out *)stream;
-    struct tiny_audio_device *adev = out->adev;
-    struct str_parms *parms;
-    char *str;
-    char value[32];
-    int ret, val = 0;
-    bool force_input_standby = false;
+    ALOGV("+out_set_parameters(%p) '%s'", stream, kvpairs);
 
-    parms = str_parms_create_str(kvpairs);
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    struct audio_device *adev = out->dev;
+    uint32_t v;
+    int ret;
 
-    ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
-			    value, sizeof(value));
+    ret = common_get_routing_param(&v, kvpairs);
+
+    pthread_mutex_lock(&adev->lock);
+
     if (ret >= 0) {
-        val = atoi(value);
-
-	if (val != 0) {
-	    pthread_mutex_lock(&adev->route_lock);
-
-            adev->devices &= ~AUDIO_DEVICE_OUT_ALL;
-            adev->devices |= val;
-            select_devices(adev);
-
-	    pthread_mutex_unlock(&adev->route_lock);
-	} else {
-	    LOGW("output routing with no devices\n");
-	}
+        apply_route(out->hw, v);
     }
 
-    str_parms_destroy(parms);
 
+    if (common_set_parameters_locked(out->hw, kvpairs) >= 0) {
+        ret = 0;
+    }
+
+    pthread_mutex_unlock(&adev->lock);
+
+    ALOGV("-out_set_parameters(%p):%d", out, ret);
     return ret;
 }
 
@@ -277,47 +347,50 @@
 
 static uint32_t out_get_latency(const struct audio_stream_out *stream)
 {
-    return 0;
-}
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    struct audio_device *adev = out->dev;
+    uint32_t latency;
 
-static int out_set_volume(struct audio_stream_out *stream, float left,
-                          float right)
-{
-    /* Use the soft volume control for now; AudioFlinger rarely
-     * actually calls down. */
-    return -EINVAL;
-}
+    pthread_mutex_lock(&adev->lock);
 
-static ssize_t out_write(struct audio_stream_out *stream, const void* buffer,
-                         size_t bytes)
-{
-    struct tiny_stream_out *out = (struct tiny_stream_out *)stream;
-    int ret;
-
-    if (!out->pcm) {
-	LOGV("out_write(%p) opening PCM\n", stream);
-	out->pcm = pcm_open(0, 0, PCM_OUT | PCM_MMAP, &out->config);
-
-	if (!pcm_is_ready(out->pcm)) {
-	    LOGE("Failed to open output PCM: %s", pcm_get_error(out->pcm));
-	    pcm_close(out->pcm);
-	    return -EBUSY;
-	}
+    if (adev->screen_off && !adev->active_in) {
+        latency = out->latency.screen_off;
+    } else {
+        latency = out->latency.screen_on;
     }
 
-    ret = pcm_mmap_write(out->pcm, buffer, bytes);
-    if (ret != 0) {
-	LOGE("out_write(%p) failed: %d\n", stream, ret);
-	return ret;
-    }
+    pthread_mutex_unlock(&adev->lock);
 
-    return bytes;
+    return latency;
 }
 
-static int out_get_render_position(const struct audio_stream_out *stream,
-                                   uint32_t *dsp_frames)
+static int volume_to_percent(float volume)
 {
-    return -EINVAL;
+    float decibels;
+    float percent;
+
+    /* Converting back to a decibel scale */
+    if(volume > 0) {
+        decibels = log(volume) / 0.115129f;
+    } else {
+        /* Use the maximum attenuation value 58 */
+        decibels = -58;
+    }
+
+    /* decibels range is -58..0, rescale to range 0..100 */
+    percent = ((decibels + 58.0) * (100.0/58.0));
+    return (int)percent;
+}
+
+static int out_set_volume(struct audio_stream_out *stream, float left, float right)
+{
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    int l_pc = volume_to_percent(left);
+    int r_pc = volume_to_percent(right);
+
+    ALOGV("out_set_volume (%f,%f) -> (%d%%,%d%%)", left, right, l_pc, r_pc);
+
+    return set_hw_volume(out->hw, l_pc, r_pc);
 }
 
 static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
@@ -330,40 +403,298 @@
     return 0;
 }
 
-/** audio_stream_in implementation **/
+static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
+                                        int64_t *timestamp)
+{
+    return -EINVAL;
+}
+
+static void do_close_out_common(struct audio_stream *stream)
+{
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    release_stream(out->hw);
+    free(stream);
+}
+
+static int do_init_out_common( struct stream_out_common *out,
+                                    const struct audio_config *config,
+                                    audio_devices_t devices )
+{
+    int ret;
+
+    out->standby = true;
+
+    out->stream.common.get_sample_rate = out_get_sample_rate;
+    out->stream.common.set_sample_rate = out_set_sample_rate;
+    out->stream.common.get_buffer_size = out_get_buffer_size;
+    out->stream.common.get_channels = out_get_channels;
+    out->stream.common.get_format = out_get_format;
+    out->stream.common.set_format = out_set_format;
+    out->stream.common.dump = out_dump;
+    out->stream.common.set_parameters = out_set_parameters;
+    out->stream.common.get_parameters = out_get_parameters;
+    out->stream.common.add_audio_effect = out_add_audio_effect;
+    out->stream.common.remove_audio_effect = out_remove_audio_effect;
+    out->stream.get_latency = out_get_latency;
+    out->stream.set_volume = out_set_volume;
+    out->stream.get_next_write_timestamp = out_get_next_write_timestamp;
+
+    /* init requested stream config */
+    out->format = config->format;
+    out->sample_rate = (config->sample_rate == 0)
+                                    ? OUT_SAMPLING_RATE_DEFAULT
+                                    : config->sample_rate;
+    out->channel_mask = (config->channel_mask == 0)
+                                    ? OUT_CHANNEL_MASK_DEFAULT
+                                    : config->channel_mask;
+    out->channel_count = popcount(out->channel_mask);
+
+    /* Default settings */
+    out->frame_size = audio_stream_frame_size(&out->stream.common);
+
+    /* Apply initial route */
+    apply_route(out->hw, devices);
+
+    return 0;
+}
+
+/*********************************************************************
+ * PCM output stream
+ *********************************************************************/
+
+static unsigned int out_pcm_cfg_period_count(struct stream_out_pcm *out)
+{
+    if (out->common.hw->period_count != 0) {
+        return out->common.hw->period_count;
+    } else {
+        return OUT_PERIOD_COUNT_DEFAULT;
+    }
+}
+
+static unsigned int out_pcm_cfg_period_size(struct stream_out_pcm *out)
+{
+    if (out->common.hw->period_size != 0) {
+        return out->common.hw->period_size;
+    } else {
+        return OUT_PERIOD_SIZE_DEFAULT;
+    }
+}
+
+static unsigned int out_pcm_cfg_rate(struct stream_out_pcm *out)
+{
+    if (out->common.hw->rate != 0) {
+        return out->common.hw->rate;
+    } else {
+        return OUT_SAMPLING_RATE_DEFAULT;
+    }
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static void do_out_pcm_standby(struct stream_out_pcm *out)
+{
+    struct audio_device *adev = out->common.dev;
+
+    ALOGV("+do_out_standby(%p)", out);
+
+    if (!out->common.standby) {
+        pcm_close(out->pcm);
+        out->pcm = NULL;
+        adev->active_out = NULL;
+        out->common.standby = true;
+    }
+
+    ALOGV("-do_out_standby(%p)", out);
+}
+
+static void out_pcm_fill_params(struct stream_out_pcm *out,
+                                const struct pcm_config *config )
+{
+    out->hw_sample_rate = config->rate;
+    out->hw_channel_count = config->channels;
+    out->common.buffer_size = pcm_frames_to_bytes(out->pcm,
+                                                pcm_get_buffer_size(out->pcm));
+
+    out->common.latency.screen_on = (config->period_size * config->period_count * 1000)
+                                / config->rate;
+    out->common.latency.screen_off = out->common.latency.screen_on;
+}
+
+/* must be called with hw device and output stream mutexes locked */
+static int start_output_pcm(struct stream_out_pcm *out)
+{
+    struct audio_device *adev = out->common.dev;
+    int ret;
+
+    struct pcm_config config = {
+        .channels = out->common.channel_count,
+        .rate = out_pcm_cfg_rate(out),
+        .period_size = out_pcm_cfg_period_size(out),
+        .period_count = out_pcm_cfg_period_count(out),
+        .format = PCM_FORMAT_S16_LE,
+        .start_threshold = 0,
+        .stop_threshold = 0,
+        .silence_threshold = 0
+    };
+
+    ALOGV("+start_output_stream(%p)", out);
+
+    out->pcm = pcm_open(out->common.hw->card_number,
+                        out->common.hw->device_number,
+                        PCM_OUT,
+                        &config);
+
+    if (out->pcm && !pcm_is_ready(out->pcm)) {
+        ALOGE("pcm_open(out) failed: %s", pcm_get_error(out->pcm));
+        pcm_close(out->pcm);
+        return -ENOMEM;
+    }
+
+    out_pcm_fill_params( out, &config );
+
+    adev->active_out = out;
+
+    ALOGV("-start_output_stream(%p)", out);
+    return 0;
+}
+
+static int out_pcm_standby(struct audio_stream *stream)
+{
+    struct stream_out_pcm *out = (struct stream_out_pcm *)stream;
+
+    pthread_mutex_lock(&out->common.dev->lock);
+    pthread_mutex_lock(&out->common.lock);
+    do_out_pcm_standby(out);
+    pthread_mutex_unlock(&out->common.lock);
+    pthread_mutex_unlock(&out->common.dev->lock);
+
+    return 0;
+}
+
+static ssize_t out_pcm_write(struct audio_stream_out *stream, const void* buffer,
+                         size_t bytes)
+{
+    ALOGV("+out_pcm_write(%p) l=%u", stream, bytes);
+
+    int ret = 0;
+    struct stream_out_pcm *out = (struct stream_out_pcm *)stream;
+    struct audio_device *adev = out->common.dev;
+
+    /* Check that we are routed to something. Android can send routing
+     * commands that tell us to disconnect from everything and in that
+     * state we shouldn't issue any write commands because we can't be
+     * sure that the driver will accept a write to nowhere
+     */
+    if (get_current_routes(out->common.hw) == 0) {
+        ALOGV("-out_pcm_write(%p) 0 (no routes)", stream);
+        return 0;
+    }
+
+    /*
+     * acquiring hw device mutex systematically is useful if a low
+     * priority thread is waiting on the output stream mutex - e.g.
+     * executing out_set_parameters() while holding the hw device
+     * mutex
+     */
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&out->common.lock);
+    if (out->common.standby) {
+        ret = start_output_pcm(out);
+        if (ret != 0) {
+            pthread_mutex_unlock(&adev->lock);
+            goto exit;
+        }
+        out->common.standby = false;
+    }
+    pthread_mutex_unlock(&adev->lock);
+
+    ret = pcm_write(out->pcm, buffer, bytes);
+    if (ret >= 0) {
+        ret = bytes;
+    }
+
+exit:
+    pthread_mutex_unlock(&out->common.lock);
+
+    ALOGV("-out_pcm_write(%p) r=%u", stream, ret);
+
+    return ret;
+}
+
+static int out_pcm_get_render_position(const struct audio_stream_out *stream,
+                                   uint32_t *dsp_frames)
+{
+    return -EINVAL;
+}
+static void do_close_out_pcm(struct audio_stream *stream)
+{
+    out_pcm_standby(stream);
+    do_close_out_common(stream);
+}
+
+static int do_init_out_pcm( struct stream_out_pcm *out,
+                                    const struct audio_config *config )
+{
+    if (config->sample_rate != out_pcm_cfg_rate(out)) {
+        ALOGE("AF requested rate %u not supported", config->sample_rate);
+        return -ENOTSUP;
+    }
+
+    out->common.close = do_close_out_pcm;
+    out->common.stream.common.standby = out_pcm_standby;
+    out->common.stream.write = out_pcm_write;
+    out->common.stream.get_render_position = out_pcm_get_render_position;
+
+    out->common.buffer_size = out_pcm_cfg_period_size(out)
+                               * out_pcm_cfg_period_count(out)
+                               * out->common.frame_size;
+    return 0;
+}
+
+/*********************************************************************
+ * Input stream common functions
+ *********************************************************************/
 static uint32_t in_get_sample_rate(const struct audio_stream *stream)
 {
-    return 8000;
+    const struct stream_in_common *in = (struct stream_in_common *)stream;
+
+    return in->sample_rate;
 }
 
 static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
 {
-    return 0;
+    const struct stream_in_common *in = (struct stream_in_common *)stream;
+
+    if (rate == in->sample_rate) {
+        return 0;
+    } else {
+        return -ENOTSUP;
+    }
+}
+
+static audio_channel_mask_t in_get_channels(const struct audio_stream *stream)
+{
+    const struct stream_in_common *in = (struct stream_in_common *)stream;
+
+    return in->channel_mask;
+}
+
+static audio_format_t in_get_format(const struct audio_stream *stream)
+{
+    const struct stream_in_common *in = (struct stream_in_common *)stream;
+
+    return in->format;
+}
+
+static int in_set_format(struct audio_stream *stream, audio_format_t format)
+{
+    return -ENOSYS;
 }
 
 static size_t in_get_buffer_size(const struct audio_stream *stream)
 {
-    return 320;
-}
-
-static uint32_t in_get_channels(const struct audio_stream *stream)
-{
-    return AUDIO_CHANNEL_IN_MONO;
-}
-
-static int in_get_format(const struct audio_stream *stream)
-{
-    return AUDIO_FORMAT_PCM_16_BIT;
-}
-
-static int in_set_format(struct audio_stream *stream, int format)
-{
-    return 0;
-}
-
-static int in_standby(struct audio_stream *stream)
-{
-    return 0;
+    const struct stream_in_common *in = (struct stream_in_common *)stream;
+    ALOGV("in_get_buffer_size(%p): %u", stream, in->buffer_size );
+    return in->buffer_size;
 }
 
 static int in_dump(const struct audio_stream *stream, int fd)
@@ -387,112 +718,1235 @@
     return 0;
 }
 
-static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
-                       size_t bytes)
-{
-    /* XXX: fake timing for audio input */
-    usleep(bytes * 1000000 / audio_stream_frame_size(&stream->common) /
-           in_get_sample_rate(&stream->common));
-    return bytes;
-}
-
 static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
 {
     return 0;
 }
 
-static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+static int in_add_audio_effect(const struct audio_stream *stream,
+                               effect_handle_t effect)
 {
     return 0;
 }
 
-static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+static int in_remove_audio_effect(const struct audio_stream *stream,
+                                  effect_handle_t effect)
 {
     return 0;
 }
 
-static int adev_open_output_stream(struct audio_hw_device *dev,
-                                   uint32_t devices, int *format,
-                                   uint32_t *channels, uint32_t *sample_rate,
-                                   struct audio_stream_out **stream_out)
+static void do_close_in_common(struct audio_stream *stream)
 {
-    struct tiny_audio_device *adev = (struct tiny_audio_device *)dev;
-    struct tiny_stream_out *out;
+    struct stream_in_common *in = (struct stream_in_common *)stream;
+    in->stream.common.standby(stream);
+
+    /* active_voice_control is not cleared by standby so we must
+     * clear it here when stream is closed
+     */
+    if ((struct stream_in_common *)in->dev->active_voice_control == in) {
+        in->dev->active_voice_control = NULL;
+    }
+    release_stream(in->hw);
+    free(stream);
+}
+
+static int do_init_in_common( struct stream_in_common *in,
+                                const struct audio_config *config,
+                                audio_devices_t devices )
+{
+    in->standby = true;
+
+    in->close = do_close_in_common;
+    in->stream.common.get_sample_rate = in_get_sample_rate;
+    in->stream.common.set_sample_rate = in_set_sample_rate;
+    in->stream.common.get_buffer_size = in_get_buffer_size;
+    in->stream.common.get_channels = in_get_channels;
+    in->stream.common.get_format = in_get_format;
+    in->stream.common.set_format = in_set_format;
+    in->stream.common.dump = in_dump;
+    in->stream.common.set_parameters = in_set_parameters;
+    in->stream.common.get_parameters = in_get_parameters;
+    in->stream.common.add_audio_effect = in_add_audio_effect;
+    in->stream.common.remove_audio_effect = in_remove_audio_effect;
+    in->stream.set_gain = in_set_gain;
+    in->stream.get_input_frames_lost = in_get_input_frames_lost;
+
+    /* init requested stream config */
+    in->format = config->format;
+    in->sample_rate = (config->sample_rate == 0)
+                                    ? IN_SAMPLING_RATE_DEFAULT
+                                    : config->sample_rate;
+    in->channel_mask = (config->channel_mask == 0)
+                                    ? IN_CHANNEL_MASK_DEFAULT
+                                    : config->channel_mask;
+    in->channel_count = popcount(in->channel_mask);
+
+    in->frame_size = audio_stream_frame_size(&in->stream.common);
+
+    /* Apply initial routing */
+    apply_route(in->hw, devices);
+
+    return 0;
+}
+
+/*********************************************************************
+ * Voice control triggering
+ * Currently assumes a compressed channel
+ *********************************************************************/
+
+static void* voice_control_trigger_thread(void *param)
+{
+    struct voice_control_trigger *self = param;
+    struct compress *compress;
     int ret;
 
-    out = calloc(1, sizeof(struct tiny_stream_out));
-    if (!out)
-        return -ENOMEM;
+    /* signal that we're alive and ready */
+    pthread_cond_signal(&self->waitcv);
 
-    out->stream.common.get_sample_rate = out_get_sample_rate;
-    out->stream.common.set_sample_rate = out_set_sample_rate;
-    out->stream.common.get_buffer_size = out_get_buffer_size;
-    out->stream.common.get_channels = out_get_channels;
-    out->stream.common.get_format = out_get_format;
-    out->stream.common.set_format = out_set_format;
-    out->stream.common.standby = out_standby;
-    out->stream.common.dump = out_dump;
-    out->stream.common.set_parameters = out_set_parameters;
-    out->stream.common.get_parameters = out_get_parameters;
-    out->stream.common.add_audio_effect = out_add_audio_effect;
-    out->stream.common.remove_audio_effect = out_remove_audio_effect;
-    out->stream.get_latency = out_get_latency;
-    out->stream.set_volume = out_set_volume;
-    out->stream.write = out_write;
-    out->stream.get_render_position = out_get_render_position;
+    while (!self->terminate) {
+        pthread_mutex_lock(&self->lock);
+        if (!self->wait) {
+            pthread_cond_wait(&self->waitcv, &self->lock);
+        }
+        self->wait = false;
+        pthread_mutex_unlock(&self->lock);
 
-    out->adev = adev;
+        if (self->terminate) {
+            break;
+        }
 
-    pthread_mutex_lock(&adev->route_lock);
-    adev->devices &= ~AUDIO_DEVICE_OUT_ALL;
-    adev->devices |= devices;
-    select_devices(adev);
-    pthread_mutex_unlock(&adev->route_lock);
+        /* We must protect against any failure by the main thread to open
+         * the compressed channel
+         */
+        compress = self->compress;
+        if (compress != NULL) {
+            ALOGV("VC wait");
+            ret = compress_wait(compress, -1);
 
-    *channels = out_get_channels(&out->stream.common);
-    *format = out_get_format(&out->stream.common);
-    *sample_rate = out_get_sample_rate(&out->stream.common);
+            if (self->terminate) {
+                break;
+            }
 
-    /* Should query the driver for parameters and compute defaults
-     * from those; should also support configuration from file and
-     * buffer resizing.
+            if (ret == 0) {
+                self->triggered = true;
+                ALOGV("VC trigger %d", ret);
+                (self->callback)(self->callback_param);
+            }
+        }
+    }
+
+    if (self->own_compress && self->compress) {
+        ALOGV("VC trigger thread closes compress");
+        compress_close(self->compress);
+    }
+    free(self);
+
+    ALOGV("VC trigger thread terminates");
+    return NULL;
+}
+
+static void start_voice_control_wait(struct voice_control_trigger *self)
+{
+    ALOGV("start_voice_control_wait");
+
+    pthread_mutex_lock(&self->lock);
+    self->triggered = false;
+    self->wait = true;
+    pthread_cond_signal(&self->waitcv);
+    pthread_mutex_unlock(&self->lock);
+}
+
+static void cancel_voice_control_wait(struct voice_control_trigger *in)
+{
+    ALOGV("cancel_voice_control_wait");
+}
+
+static struct voice_control_trigger* create_voice_control_trigger()
+{
+    static struct voice_control_trigger *t;
+    int ret;
+
+    t = calloc(1, sizeof(struct voice_control_trigger));
+
+    if (t != NULL) {
+        pthread_mutex_init(&t->lock, NULL);
+        pthread_cond_init(&t->waitcv, NULL);
+        pthread_mutex_lock(&t->lock);
+
+        ret = pthread_create(&t->thread, NULL, voice_control_trigger_thread, t);
+        if (ret != 0) {
+            goto fail;
+        }
+
+        /* Wait for thread to initialize */
+        pthread_cond_wait(&t->waitcv, &t->lock);
+        pthread_mutex_unlock(&t->lock);
+    }
+
+    return t;
+
+fail:
+    free(t);
+    return NULL;
+}
+
+static void destroy_voice_control_trigger(struct voice_control_trigger *self,
+                                                bool close_channel)
+{
+    ALOGV("+destroy_voice_control_trigger (close=%d)", close_channel);
+
+    if (self != NULL) {
+        pthread_mutex_lock(&self->lock);
+        if (close_channel && (self->compress != NULL)) {
+            /* Take ownership of the compressed channel and close */
+            /* it as we terminate */
+            /* Must stop the channel to force thread out of the poll */
+            self->own_compress = true;
+            self->terminate = true;
+
+            /* Kick the driver to create an error condition */
+            /* so wait thread will exit the poll */
+
+            if (!is_compress_running(self->compress)) {
+                /* If it's not running, do a dummy start so we */
+                /* can force a stop */
+                compress_start(self->compress);
+            }
+            compress_stop(self->compress);
+        }
+
+        pthread_cond_signal(&self->waitcv);
+        pthread_mutex_unlock(&self->lock);
+
+        /* A struct voice_control_trigger cannot be created without a thread */
+        /* so it is safe to just call pthread_join() here */
+        pthread_join(self->thread, NULL);
+    }
+
+    ALOGV("-destroy_voice_control_trigger");
+}
+
+static void voice_control_callback(void *param)
+{
+    struct stream_in_pcm *in = param;
+
+    if (in->common.standby) {
+        ALOGV("VC trig");
+        send_voice_trigger();
+    } else {
+        ALOGV("VC trig ignored (not in standby)");
+    }
+}
+
+static int init_voice_control(struct stream_in_pcm *in)
+{
+    struct audio_device *adev = in->common.dev;
+    struct voice_control_trigger *t;
+    int ret;
+
+    ALOGV("+init_voice_control");
+    if (!stream_is_compressed(in->common.hw)) {
+        /* We don't support triggering on PCM streams */
+        ret = -EINVAL;
+        goto out;
+    }
+
+    t = create_voice_control_trigger();
+    if (t == NULL) {
+        ret = -ENOMEM;
+        goto out;
+    }
+
+    t->compress = in->compress;
+    t->callback = voice_control_callback;
+    t->callback_param = in;
+    in->vc_trigger = t;
+    ret = 0;
+
+out:
+    ALOGV("-init_voice_control %d", ret);
+    return ret;
+}
+
+/*********************************************************************
+ * PCM input stream via compressed channel
+ *********************************************************************/
+
+/* must be called with hw device and input stream mutexes locked */
+static int do_open_compress_pcm_in(struct stream_in_pcm *in)
+{
+    struct snd_codec codec;
+    struct compress *compress;
+    int ret;
+
+    ALOGV("+do_open_compress_pcm_in");
+
+    memset(&codec, 0, sizeof(codec));
+    codec.id = SND_AUDIOCODEC_PCM;
+    codec.ch_in = in->common.channel_count;
+    codec.sample_rate = in->common.sample_rate;
+    codec.format = SNDRV_PCM_FORMAT_S16_LE;
+
+    /* Fragment and buffer sizes should be configurable or auto-detected
+     * but are currently just hardcoded
      */
-    out->config.channels = 2;
-    out->config.rate = out_get_sample_rate(&out->stream.common);
-    out->config.period_count = 4;
-    out->config.period_size = 1024;
-    out->config.format = PCM_FORMAT_S16_LE;
+    struct compr_config config = {
+        .fragment_size = 4096,
+        .fragments = 1,
+        .codec = &codec
+    };
 
-    LOGV("Opened output stream %p\n", out);
+    compress = compress_open(in->common.hw->card_number,
+                                in->common.hw->device_number,
+                                COMPRESS_OUT,
+                                &config);
 
-    *stream_out = &out->stream;
+    if (!compress || !is_compress_ready(compress)) {
+        ret = errno;
+        ALOGE_IF(compress,"compress_open(in) failed: %s", compress_get_error(compress));
+        ALOGE_IF(!compress,"compress_open(in) failed");
+        compress_close(compress);
+        goto exit;
+    }
+    in->compress = compress;
+    in->common.buffer_size = config.fragment_size * config.fragments * in->common.frame_size;
+    compress_start(in->compress);
+    ret = 0;
+
+exit:
+    ALOGV("-do_open_compress_pcm_in (%d)", ret);
+    return ret;
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static int start_compress_pcm_input_stream(struct stream_in_pcm *in)
+{
+    struct audio_device *adev = in->common.dev;
+    int ret;
+
+    ALOGV("start_compress_pcm_input_stream");
+
+    if (in->common.standby) {
+        /* For voice control we don't need to cancel a pending trigger because
+         * if it's still waiting for a trigger, we won't return any data and
+         * will eventually be put back into standby to continue waiting for
+         * a trigger
+         */
+        if (in->vc_trigger == NULL) {
+            ret = do_open_compress_pcm_in(in);
+            if (ret < 0) {
+                return ret;
+            }
+        }
+
+        adev->active_in = in;
+        in->common.standby = 0;
+    }
+
+    return 0;
+}
+
+static void do_in_compress_pcm_start_vc_trigger(struct stream_in_pcm *in)
+{
+    int ret = do_open_compress_pcm_in(in);
+    if (ret == 0) {
+        in->vc_trigger->compress = in->compress;
+        start_voice_control_wait(in->vc_trigger);
+    }
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static void do_in_compress_pcm_standby(struct stream_in_pcm *in)
+{
+    struct compress *c;
+    int ret;
+
+    ALOGV("+do_in_compress_pcm_standby");
+
+    if (!in->common.standby) {
+        /* Always close, even for a voice control channel.
+         * For voice control we must close the channel after each command
+         */
+        c = in->compress;
+        in->compress = NULL;
+
+        if (in->vc_trigger != NULL) {
+            destroy_voice_control_trigger(in->vc_trigger, true);
+            in->vc_trigger = NULL;
+
+            /* For voice control we must re-open the channel to */
+            /* wait for next trigger */
+            init_voice_control(in);
+            do_in_compress_pcm_start_vc_trigger(in);
+        } else {
+            compress_stop(c);
+            compress_close(c);
+        }
+
+    }
+    in->common.standby = true;
+
+    ALOGV("-do_in_compress_pcm_standby");
+}
+
+static ssize_t do_in_compress_pcm_read(struct audio_stream_in *stream, void* buffer,
+                                        size_t bytes)
+{
+    struct stream_in_pcm *in = (struct stream_in_pcm *)stream;
+    struct audio_device *adev = in->common.dev;
+    size_t frames_rq = bytes / in->common.frame_size;
+    nsecs_t t1;
+    nsecs_t t2;
+    nsecs_t interval;
+    struct timespec ts;
+    int ret = 0;
+
+    ALOGV("+do_in_compress_pcm_read %d", bytes);
+
+    if (get_current_routes(in->common.hw) == 0) {
+        ALOGV("-do_in_compress_pcm_read(%p) 0 (no routes)", stream);
+        return 0;
+    }
+
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&in->common.lock);
+    ret = start_compress_pcm_input_stream(in);
+    pthread_mutex_unlock(&adev->lock);
+
+    if (ret < 0) {
+        goto exit;
+    }
+
+    if (in->vc_trigger != NULL) {
+        if (!in->vc_trigger->triggered) {
+            /* Read without trigger, no data will be available */
+            ALOGV("read without voice trigger - not returning data");
+            ret = 0;
+            goto exit;
+        }
+    }
+
+    t1 = systemTime(SYSTEM_TIME_MONOTONIC);
+    ret = compress_read(in->compress, buffer, bytes);
+    t2 = systemTime(SYSTEM_TIME_MONOTONIC);
+
+    if (ret > 0) {
+        /* The interface between AudioFlinger and AudioRecord cannot cope
+         * with bursty data and will lockup for periods if the data does
+         * not come as a smooth stream. So we must limit the rate that we
+         * deliver PCM buffers to approximately how long the buffer would
+         * have taken to read at its PCM sample rate
+         */
+
+        interval = (1000000000LL * (int64_t)ret) / (in->common.frame_size * in->common.sample_rate);
+        interval -= (interval / 4); /* wait for 75% of PCM time to avoid gaps */
+        t2 -= t1; /* elapsed interval */
+        if (interval > t2) {
+            ts.tv_sec = 0;
+            ts.tv_nsec = interval - t2;
+            nanosleep(&ts, NULL);
+        }
+    }
+
+    /*
+     * Instead of writing zeroes here, we could trust the hardware
+     * to always provide zeroes when muted.
+     */
+    if (ret == 0 && adev->mic_mute) {
+        memset(buffer, 0, bytes);
+        ret = bytes;
+    }
+
+exit:
+    pthread_mutex_unlock(&in->common.lock);
+
+    ALOGV("-do_in_compress_pcm_read (%d)", ret);
+    return ret;
+}
+
+static void do_in_compress_pcm_close(struct stream_in_pcm *in)
+{
+    ALOGV("+do_in_compress_pcm_close");
+
+    if (in->vc_trigger != NULL) {
+        destroy_voice_control_trigger(in->vc_trigger, true);
+    } else if (in->compress != NULL) {
+        compress_stop(in->compress);
+        compress_close(in->compress);
+    }
+
+    ALOGV("-do_in_compress_pcm_close");
+}
+
+/*********************************************************************
+ * PCM input stream
+ *********************************************************************/
+
+static unsigned int in_pcm_cfg_period_count(struct stream_in_pcm *in)
+{
+    if (in->common.hw->period_count != 0) {
+        return in->common.hw->period_count;
+    } else {
+        return IN_PERIOD_COUNT_DEFAULT;
+    }
+}
+
+static unsigned int in_pcm_cfg_period_size(struct stream_in_pcm *in)
+{
+    if (in->common.hw->period_size != 0) {
+        return in->common.hw->period_size;
+    } else {
+        return IN_PERIOD_SIZE_DEFAULT;
+    }
+}
+
+static unsigned int in_pcm_cfg_rate(struct stream_in_pcm *in)
+{
+    if (in->common.hw->rate != 0) {
+        return in->common.hw->rate;
+    } else {
+        return IN_SAMPLING_RATE_DEFAULT;
+    }
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static void do_in_pcm_standby(struct stream_in_pcm *in)
+{
+    struct audio_device *adev = in->common.dev;
+
+    ALOGV("+do_in_pcm_standby");
+
+    if (!in->common.standby) {
+        pcm_close(in->pcm);
+        in->pcm = NULL;
+    }
+    adev->active_in = NULL;
+    if (in->resampler) {
+        release_resampler(in->resampler);
+        in->resampler = NULL;
+    }
+    if (in->buffer) {
+        free(in->buffer);
+        in->buffer = NULL;
+    }
+    in->common.standby = true;
+
+    ALOGV("-do_in_pcm_standby");
+}
+
+static void in_pcm_fill_params(struct stream_in_pcm *in,
+                                const struct pcm_config *config )
+{
+    size_t size;
+
+    in->hw_sample_rate = config->rate;
+    in->hw_channel_count = config->channels;
+    in->period_size = config->period_size;
+
+    /*
+     * take resampling into account and return the closest majoring
+     * multiple of 16 frames, as audioflinger expects audio buffers to
+     * be a multiple of 16 frames
+     */
+    size = (config->period_size * in->common.sample_rate) / config->rate;
+    size = ((size + 15) / 16) * 16;
+    in->common.buffer_size = size * in->common.frame_size;
+
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static int do_open_pcm_input(struct stream_in_pcm *in)
+{
+    int ret;
+
+    struct pcm_config config = {
+        .channels = popcount(IN_CHANNEL_MASK_DEFAULT),
+        .rate = in_pcm_cfg_rate(in),
+        .period_size = in_pcm_cfg_period_size(in),
+        .period_count = in_pcm_cfg_period_count(in),
+        .format = PCM_FORMAT_S16_LE,
+    };
+
+    config.start_threshold = config.period_size * config.period_count;
+
+    ALOGV("+do_open_pcm_input");
+
+    in->pcm = pcm_open(in->common.hw->card_number,
+                       in->common.hw->device_number,
+                       PCM_IN,
+                       &config);
+
+    if (!in->pcm || !pcm_is_ready(in->pcm)) {
+        ALOGE_IF(in->pcm,"pcm_open(in) failed: %s", pcm_get_error(in->pcm));
+        ALOGE_IF(!in->pcm,"pcm_open(in) failed");
+        ret = -ENOMEM;
+        goto fail;
+    }
+
+    in_pcm_fill_params( in, &config );
+
+    ALOGV("input buffer size=0x%x", in->common.buffer_size);
+
+    /*
+     * If the stream rate differs from the PCM rate, we need to
+     * create a resampler.
+     */
+    if (in_get_sample_rate(&in->common.stream.common) != config.rate) {
+        in->in_buffer_size = config.period_size * config.period_count *
+                             config.channels * 2;
+        in->in_buffer_frames = in->in_buffer_size / (config.channels * 2);
+        in->buffer = malloc(in->in_buffer_size);
+
+        if (!in->buffer) {
+            ret = -ENOMEM;
+            goto fail;
+        }
+
+        in->buf_provider.get_next_buffer = get_next_buffer;
+        in->buf_provider.release_buffer = release_buffer;
+
+        ret = create_resampler(config.rate,
+                               in->common.sample_rate,
+                               in->common.channel_count,
+                               RESAMPLER_QUALITY_DEFAULT,
+                               &in->buf_provider,
+                               &in->resampler);
+        if (ret < 0) {
+            goto fail;
+        }
+    }
+    ALOGV("-do_open_pcm_input");
+    return 0;
+
+fail:
+    pcm_close(in->pcm);
+    in->pcm = NULL;
+    ALOGV("-do_open_pcm_input error:%d", ret);
+    return ret;
+}
+
+/* must be called with hw device and input stream mutexes locked */
+static int start_pcm_input_stream(struct stream_in_pcm *in)
+{
+    struct audio_device *adev = in->common.dev;
+    int ret;
+
+    ret = do_open_pcm_input(in);
+
+    if (ret < 0) {
+        return ret;
+    }
+
+    adev->active_in = in;
+    return 0;
+}
+
+static int change_input_locale_locked(struct stream_in_pcm *in, const char *locale)
+{
+    int ret;
+
+    if (in->vc_trigger) {
+        if (!in->common.standby) {
+            ALOGE("attempt to change input locale while active");
+            return -EINVAL;
+        }
+
+        ALOGE("change voice control locale to %s", locale);
+
+        destroy_voice_control_trigger(in->vc_trigger, true);
+
+        /* Execute locale-change use-case */
+        ret = apply_use_case(in->common.hw, "locale", locale);
+        if (ret == -ENOSYS) {
+            /* use-case not implemented.
+             * As we don't support the requested locale switch to default
+             * rather than potentially staying in a totally wrong language
+             */
+             apply_use_case(in->common.hw, "locale", "");
+        }
+
+        /* restart the trigger wait */
+        init_voice_control(in);
+        do_in_compress_pcm_start_vc_trigger(in);
+    }
+
+    return 0;
+}
+
+static int change_input_source_locked(struct stream_in_pcm *in, const char *value,
+                                uint32_t devices, bool *was_changed)
+{
+    struct audio_device *adev = in->common.dev;
+    struct audio_config config;
+    const char *stream_name;
+    const struct hw_stream *hw;
+    bool voice_control = false;
+    const int new_source = atoi(value);
+
+    *was_changed = false;
+
+    if (!in->common.standby) {
+        ALOGE("attempt to change input source while active");
+        return -EINVAL;
+    }
+
+    if (in->common.input_source == new_source) {
+        ALOGV("input source not changed");
+        return 0;
+    }
+
+    /* Special input sources are obtained from the configuration
+     * by opening a named stream
+     */
+    switch (new_source) {
+    case AUDIO_SOURCE_VOICE_RECOGNITION:
+        /* We should verify here that current frame size, sample rate and
+         * channels are compatible
+         */
+
+        stream_name = "voice recognition";
+        voice_control = true;
+        break;
+
+    default:
+        stream_name = NULL;
+        break;
+    }
+
+    if (stream_name) {
+        hw = get_named_stream(in->common.dev->cm, stream_name);
+        ALOGV_IF(hw != NULL, "Changing input source to %s", stream_name);
+    } else {
+        memset(&config, 0, sizeof(config));
+        config.sample_rate = in->common.sample_rate;
+        config.channel_mask = in->common.channel_mask;
+        config.format = in->common.format;
+        hw = get_stream(in->common.dev->cm, devices, 0, &config);
+        ALOGV_IF(hw != NULL, "Changing to default input source for devices 0x%x",
+                        devices);
+    }
+
+    if (hw != NULL) {
+        /* A normal stream will be in standby and therefore device node */
+        /* is closed when we get here. Only in case of a voice control */
+        /* stream will it still be open */
+        if (in->vc_trigger != NULL) {
+            destroy_voice_control_trigger(in->vc_trigger, true);
+        }
+        release_stream(in->common.hw);
+        in->common.hw = hw;
+
+        in->vc_trigger = NULL;
+
+        if (voice_control) {
+            /* Voice control wait will be started when AudioFlinger
+             * puts stream into standby
+             */
+            init_voice_control(in);
+
+            adev->active_voice_control = in;
+        } else if (adev->active_voice_control == in) {
+            adev->active_voice_control = NULL;
+        }
+        in->common.input_source = new_source;
+        *was_changed = true;
+        return 0;
+    } else {
+        ALOGV("Could not open new input stream");
+        return -EINVAL;
+    }
+}
+
+static int get_next_buffer(struct resampler_buffer_provider *buffer_provider,
+                                   struct resampler_buffer* buffer)
+{
+    struct stream_in_pcm *in;
+
+    if (buffer_provider == NULL || buffer == NULL) {
+        return -EINVAL;
+    }
+
+    in = (struct stream_in_pcm *)((char *)buffer_provider -
+                                   offsetof(struct stream_in_pcm, buf_provider));
+
+    if (in->pcm == NULL) {
+        buffer->raw = NULL;
+        buffer->frame_count = 0;
+        in->read_status = -ENODEV;
+        return -ENODEV;
+    }
+
+    if (in->frames_in == 0) {
+        in->read_status = pcm_read(in->pcm,
+                                   (void*)in->buffer,
+                                   in->in_buffer_size);
+        if (in->read_status != 0) {
+            ALOGE("get_next_buffer() pcm_read error %d", errno);
+            buffer->raw = NULL;
+            buffer->frame_count = 0;
+            return in->read_status;
+        }
+        in->frames_in = in->in_buffer_frames;
+        if ((in->common.channel_count == 1) && (in->hw_channel_count == 2)) {
+            unsigned int i;
+
+            /* Discard right channel */
+            for (i = 1; i < in->frames_in; i++) {
+                in->buffer[i] = in->buffer[i * 2];
+            }
+        }
+    }
+
+    buffer->frame_count = (buffer->frame_count > in->frames_in) ?
+                                in->frames_in : buffer->frame_count;
+    buffer->i16 = (int16_t*)in->buffer + ((in->in_buffer_frames - in->frames_in));
+
+    return in->read_status;
+
+}
+
+static void release_buffer(struct resampler_buffer_provider *buffer_provider,
+                                  struct resampler_buffer* buffer)
+{
+    struct stream_in_pcm *in;
+
+    if (buffer_provider == NULL || buffer == NULL)
+        return;
+
+    in = (struct stream_in_pcm *)((char *)buffer_provider -
+                                   offsetof(struct stream_in_pcm, buf_provider));
+
+    in->frames_in -= buffer->frame_count;
+}
+
+/* read_frames() reads frames from kernel driver, down samples to capture rate
+ * if necessary and output the number of frames requested to the buffer specified */
+static ssize_t read_frames(struct stream_in_pcm *in, void *buffer, ssize_t frames)
+{
+    ssize_t frames_wr = 0;
+
+    while (frames_wr < frames) {
+        size_t frames_rd = frames - frames_wr;
+        if (in->resampler != NULL) {
+            in->resampler->resample_from_provider(in->resampler,
+                    (int16_t *)((char *)buffer +
+                            frames_wr * in->common.frame_size),
+                    &frames_rd);
+        } else {
+            struct resampler_buffer buf = {
+                    { raw : NULL, },
+                    frame_count : frames_rd,
+            };
+            get_next_buffer(&in->buf_provider, &buf);
+            if (buf.raw != NULL) {
+                memcpy((char *)buffer +
+                           frames_wr * in->common.frame_size,
+                        buf.raw,
+                        buf.frame_count * in->common.frame_size);
+                frames_rd = buf.frame_count;
+            }
+            release_buffer(&in->buf_provider, &buf);
+        }
+        /* in->read_status is updated by getNextBuffer() also called by
+         * in->resampler->resample_from_provider() */
+        if (in->read_status != 0)
+            return in->read_status;
+
+        frames_wr += frames_rd;
+    }
+    return frames_wr;
+}
+
+static ssize_t do_in_pcm_read(struct audio_stream_in *stream, void* buffer,
+                       size_t bytes)
+{
+    int ret = 0;
+    struct stream_in_pcm *in = (struct stream_in_pcm *)stream;
+    struct audio_device *adev = in->common.dev;
+    size_t frames_rq = bytes / in->common.frame_size;
+
+    ALOGV("+in_pcm_read %d", bytes);
+
+    if (get_current_routes(in->common.hw) == 0) {
+        ALOGV("-in_pcm_read(%p) 0 (no routes)", stream);
+        return 0;
+    }
+
+    /*
+     * acquiring hw device mutex systematically is useful if a low
+     * priority thread is waiting on the input stream mutex - e.g.
+     * executing in_set_parameters() while holding the hw device
+     * mutex
+     */
+    pthread_mutex_lock(&adev->lock);
+    pthread_mutex_lock(&in->common.lock);
+    if (in->common.standby) {
+        ret = start_pcm_input_stream(in);
+        if (ret == 0) {
+            in->common.standby = 0;
+        }
+    }
+    pthread_mutex_unlock(&adev->lock);
+
+    if (ret < 0) {
+        goto exit;
+    }
+
+    if (in->resampler != NULL) {
+        ret = read_frames(in, buffer, frames_rq);
+    } else {
+        ret = pcm_read(in->pcm, buffer, bytes);
+    }
+
+    /*
+     * Instead of writing zeroes here, we could trust the hardware
+     * to always provide zeroes when muted.
+     */
+    if (ret == 0 && adev->mic_mute) {
+        memset(buffer, 0, bytes);
+    }
+
+    if (ret >= 0) {
+        ret = bytes;
+    }
+
+exit:
+    if (ret < 0) {
+        usleep(bytes * 1000000 / in->common.frame_size /
+               in->common.sample_rate);
+    }
+
+    pthread_mutex_unlock(&in->common.lock);
+
+    ALOGV("-in_pcm_read (%d)", ret);
+    return ret;
+}
+
+static int in_pcm_standby(struct audio_stream *stream)
+{
+    struct stream_in_pcm *in = (struct stream_in_pcm *)stream;
+
+    pthread_mutex_lock(&in->common.dev->lock);
+    pthread_mutex_lock(&in->common.lock);
+
+    if (stream_is_compressed_in(in->common.hw)) {
+        do_in_compress_pcm_standby(in);
+    } else {
+        do_in_pcm_standby(in);
+    }
+
+    pthread_mutex_unlock(&in->common.lock);
+    pthread_mutex_unlock(&in->common.dev->lock);
+
+    return 0;
+}
+
+static ssize_t in_pcm_read(struct audio_stream_in *stream, void* buffer,
+                       size_t bytes)
+{
+    struct stream_in_pcm *in = (struct stream_in_pcm *)stream;
+
+    if (stream_is_compressed_in(in->common.hw)) {
+        return do_in_compress_pcm_read(stream, buffer, bytes);
+    } else {
+        return do_in_pcm_read(stream, buffer, bytes);
+    }
+}
+
+static int in_pcm_set_parameters(struct audio_stream *stream, const char *kvpairs)
+{
+    struct stream_in_pcm *in = (struct stream_in_pcm *)stream;
+    struct audio_device *adev = in->common.dev;
+    struct str_parms *parms;
+    char value[32];
+    uint32_t new_routing = 0;
+    bool routing_changed;
+    uint32_t devices;
+    bool input_was_changed;
+    bool start_vc_trig = false;
+    int ret;
+
+    ALOGV("+in_pcm_set_parameters(%p) '%s'", stream, kvpairs);
+
+    ret = common_get_routing_param(&new_routing, kvpairs);
+    routing_changed = (ret >= 0);
+    parms = str_parms_create_str(kvpairs);
+
+    pthread_mutex_lock(&adev->lock);
+
+    if(str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_INPUT_SOURCE,
+                            value, sizeof(value)) >= 0) {
+
+        if (routing_changed) {
+            devices = new_routing;
+        } else {
+            /* Route new stream to same devices as current stream */
+            devices = get_routed_devices(in->common.hw);
+        }
+
+        ret = change_input_source_locked(in, value, devices, &input_was_changed);
+        if (ret < 0) {
+            goto out;
+        }
+
+        /* We must apply any existing routing to the new stream */
+        new_routing = devices;
+        routing_changed = true;
+
+        /* Defer starting the voice control trigger wait until */
+        /* the routing has been set up */
+        if ((in->vc_trigger != NULL) && (input_was_changed)) {
+            start_vc_trig = true;
+        }
+    }
+
+    if (routing_changed) {
+        ALOGV("Apply routing=0x%x to input stream", new_routing);
+        apply_route(in->common.hw, new_routing);
+        ret = 0;
+    }
+
+    if (start_vc_trig) {
+        do_in_compress_pcm_start_vc_trigger(in);
+    }
+
+    common_set_parameters_locked(in->common.hw, kvpairs);
+
+out:
+    pthread_mutex_unlock(&adev->lock);
+    str_parms_destroy(parms);
+
+    ALOGV("-in_pcm_set_parameters(%p):%d", stream, ret);
+    return ret;
+}
+
+static void do_close_in_pcm(struct audio_stream *stream)
+{
+    struct stream_in_pcm *in = (struct stream_in_pcm *)stream;
+
+    if (stream_is_compressed(in->common.hw)) {
+        do_in_compress_pcm_close(in);
+    }
+    do_close_in_common(stream);
+}
+
+static int do_init_in_pcm( struct stream_in_pcm *in,
+                                    struct audio_config *config )
+{
+    in->common.close = do_close_in_pcm;
+    in->common.stream.common.standby = in_pcm_standby;
+    in->common.stream.common.set_parameters = in_pcm_set_parameters;
+    in->common.stream.read = in_pcm_read;
+
+    /* Default settings for stereo capture */
+    in->common.buffer_size = in_pcm_cfg_period_size(in)
+                           * in_pcm_cfg_period_count(in)
+                           * 2;
+
+    if (in->common.buffer_size > IN_COMPRESS_BUFFER_SIZE_DEFAULT) {
+        in->common.buffer_size = IN_COMPRESS_BUFFER_SIZE_DEFAULT;
+    }
+
+    return 0;
+}
+
+/*********************************************************************
+ * Stream open and close
+ *********************************************************************/
+static int adev_open_output_stream(struct audio_hw_device *dev,
+                                   audio_io_handle_t handle,
+                                   audio_devices_t devices,
+                                   audio_output_flags_t flags,
+                                   struct audio_config *config,
+                                   struct audio_stream_out **stream_out)
+{
+    struct audio_device *adev = (struct audio_device *)dev;
+    union {
+        struct stream_out_common *common;
+        struct stream_out_pcm *pcm;
+    } out;
+    int ret;
+
+    ALOGV("+adev_open_output_stream");
+
+    devices &= AUDIO_DEVICE_OUT_ALL;
+    const struct hw_stream *hw = get_stream(adev->cm, devices, flags, config);
+    if (!hw) {
+        ALOGE("No suitable output stream for devices=0x%x flags=0x%x format=0x%x",
+                    devices, flags, config->format );
+        ret = -EINVAL;
+        goto err_fail;
+    }
+
+    out.common = calloc(1, sizeof(struct stream_out_pcm));
+    if (!out.common) {
+        ret = -ENOMEM;
+        goto err_fail;
+    }
+
+    out.common->dev = adev;
+    out.common->hw = hw;
+    ret = do_init_out_common( out.common, config, devices );
+    if (ret < 0) {
+        goto err_open;
+    }
+
+    ret = do_init_out_pcm( out.pcm, config );
+    if (ret < 0) {
+        goto err_open;
+    }
+
+    /* Update config with initial stream settings */
+    config->format = out.common->format;
+    config->channel_mask = out.common->channel_mask;
+    config->sample_rate = out.common->sample_rate;
+
+    *stream_out = &out.common->stream;
+    ALOGV("-adev_open_output_stream=%p", *stream_out);
     return 0;
 
 err_open:
-    free(out);
+    free(out.common);
     *stream_out = NULL;
+err_fail:
+    ALOGV("-adev_open_output_stream (%d)", ret);
     return ret;
 }
 
 static void adev_close_output_stream(struct audio_hw_device *dev,
                                      struct audio_stream_out *stream)
 {
-    struct tiny_stream_out *out = (struct tiny_stream_out *)stream;
-    LOGV("Closing output stream %p\n", stream);
-    if (out->pcm)
-	pcm_close(out->pcm);
-    free(stream);
+    struct stream_out_common *out = (struct stream_out_common *)stream;
+    ALOGV("adev_close_output_stream(%p)", stream);
+    (out->close)(&stream->common);
 }
 
+static int adev_open_input_stream(struct audio_hw_device *dev,
+                                  audio_io_handle_t handle,
+                                  audio_devices_t devices,
+                                  struct audio_config *config,
+                                  struct audio_stream_in **stream_in)
+{
+    struct audio_device *adev = (struct audio_device *)dev;
+    struct stream_in_pcm *in = NULL;
+    const struct hw_stream *hw = NULL;
+    int ret;
+
+    ALOGV("+adev_open_input_stream");
+
+    *stream_in = NULL;
+
+    /* Respond with a request for mono if a different format is given. */
+    if (config->channel_mask != AUDIO_CHANNEL_IN_MONO) {
+        config->channel_mask = AUDIO_CHANNEL_IN_MONO;
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    devices &= AUDIO_DEVICE_IN_ALL;
+    hw = get_stream(adev->cm, devices, 0, config);
+    if (!hw) {
+        ALOGE("No suitable input stream for devices=0x%x format=0x%x",
+                    devices, config->format );
+        ret = -EINVAL;
+        goto fail;
+    }
+
+    in = (struct stream_in_pcm *)calloc(1, sizeof(struct stream_in_pcm));
+    if (!in) {
+        ret = -ENOMEM;
+        goto fail;
+    }
+
+    in->common.dev = adev;
+    in->common.hw = hw;
+    ret = do_init_in_common( &in->common, config, devices );
+    if (ret < 0) {
+        goto fail;
+    }
+    ret = do_init_in_pcm( in, config );
+    if (ret < 0) {
+        goto fail;
+    }
+
+    *stream_in = &in->common.stream;
+    return 0;
+
+fail:
+    free(in);
+    free((void *)hw);
+    ALOGV("-adev_open_input_stream (%d)", ret);
+    return ret;
+}
+
+static void adev_close_input_stream(struct audio_hw_device *dev,
+                                   struct audio_stream_in *stream)
+{
+    struct stream_in_common *in = (struct stream_in_common *)stream;
+    ALOGV("adev_close_input_stream(%p)", stream);
+    (in->close)(&stream->common);
+}
+
+/*********************************************************************
+ * Global API functions
+ *********************************************************************/
 static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs)
 {
-    return -ENOSYS;
+    struct audio_device *adev = (struct audio_device *)dev;
+    struct str_parms *parms;
+    char *str;
+    char value[32];
+    int ret;
+
+    parms = str_parms_create_str(kvpairs);
+    ret = str_parms_get_str(parms, "orientation", value, sizeof(value));
+    if (ret >= 0) {
+        int orientation;
+
+        if (strcmp(value, "landscape") == 0)
+            orientation = ORIENTATION_LANDSCAPE;
+        else if (strcmp(value, "portrait") == 0)
+            orientation = ORIENTATION_PORTRAIT;
+        else if (strcmp(value, "square") == 0)
+            orientation = ORIENTATION_SQUARE;
+        else
+            orientation = ORIENTATION_UNDEFINED;
+
+        pthread_mutex_lock(&adev->lock);
+        if (orientation != adev->orientation) {
+            adev->orientation = orientation;
+            /* Change routing for any streams that change with orientation */
+            rotate_routes(adev->cm, orientation);
+        }
+        pthread_mutex_unlock(&adev->lock);
+    }
+
+    ret = str_parms_get_str(parms, "screen_state", value, sizeof(value));
+    if (ret >= 0) {
+        if (strcmp(value, AUDIO_PARAMETER_VALUE_ON) == 0)
+            adev->screen_off = false;
+        else
+            adev->screen_off = true;
+    }
+
+    /* locale changes are only relevant to the voice control stream but
+     * Android does not expose the per-stream setParameters() ability to
+     * Java apps so we must handle this through the global setParameters
+     */
+    if(str_parms_get_str(parms, "locale", value, sizeof(value)) >= 0) {
+        if (adev->active_voice_control) {
+            ret = change_input_locale_locked(adev->active_voice_control, value);
+        }
+    }
+
+    str_parms_destroy(parms);
+    return ret;
 }
 
 static char * adev_get_parameters(const struct audio_hw_device *dev,
                                   const char *keys)
 {
-    return NULL;
+    return strdup("");
 }
 
 static int adev_init_check(const struct audio_hw_device *dev)
@@ -510,92 +1964,38 @@
     return -ENOSYS;
 }
 
-static int adev_set_mode(struct audio_hw_device *dev, int mode)
+static int adev_set_mode(struct audio_hw_device *dev, audio_mode_t mode)
 {
     return 0;
 }
 
 static int adev_set_mic_mute(struct audio_hw_device *dev, bool state)
 {
-    return -ENOSYS;
+    struct audio_device *adev = (struct audio_device *)dev;
+
+    adev->mic_mute = state;
+
+    return 0;
 }
 
 static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
 {
-    return -ENOSYS;
+    struct audio_device *adev = (struct audio_device *)dev;
+
+    *state = adev->mic_mute;
+
+    return 0;
 }
 
 static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
-                                         uint32_t sample_rate, int format,
-                                         int channel_count)
+                                         const struct audio_config *config)
 {
-    return 320;
-}
+    size_t s = IN_PERIOD_SIZE_DEFAULT * IN_PERIOD_COUNT_DEFAULT * 2;
+    if (s > IN_COMPRESS_BUFFER_SIZE_DEFAULT) {
+        s = IN_COMPRESS_BUFFER_SIZE_DEFAULT;
+    }
 
-static int adev_open_input_stream(struct audio_hw_device *dev, uint32_t devices,
-                                  int *format, uint32_t *channels,
-                                  uint32_t *sample_rate,
-                                  audio_in_acoustics_t acoustics,
-                                  struct audio_stream_in **stream_in)
-{
-    struct tiny_audio_device *adev = (struct tiny_audio_device *)dev;
-    struct tiny_stream_in *in;
-    int ret;
-    int channel_count = popcount(*channels);
-
-    in = calloc(1, sizeof(struct tiny_stream_in));
-    if (!in)
-        return -ENOMEM;
-
-    pthread_mutex_init(&in->lock, NULL);
-    in->adev = adev;
-
-    in->stream.common.get_sample_rate = in_get_sample_rate;
-    in->stream.common.set_sample_rate = in_set_sample_rate;
-    in->stream.common.get_buffer_size = in_get_buffer_size;
-    in->stream.common.get_channels = in_get_channels;
-    in->stream.common.get_format = in_get_format;
-    in->stream.common.set_format = in_set_format;
-    in->stream.common.standby = in_standby;
-    in->stream.common.dump = in_dump;
-    in->stream.common.set_parameters = in_set_parameters;
-    in->stream.common.get_parameters = in_get_parameters;
-    in->stream.common.add_audio_effect = in_add_audio_effect;
-    in->stream.common.remove_audio_effect = in_remove_audio_effect;
-    in->stream.set_gain = in_set_gain;
-    in->stream.read = in_read;
-    in->stream.get_input_frames_lost = in_get_input_frames_lost;
-
-    pthread_mutex_lock(&adev->route_lock);
-    adev->devices &= ~AUDIO_DEVICE_IN_ALL;
-    adev->devices |= devices;
-    select_devices(adev);
-    pthread_mutex_unlock(&adev->route_lock);
-
-    in->config.channels = 2;
-    in->config.rate = 44100;
-    in->config.period_count = 4;
-    in->config.period_size = 320;
-    in->config.format = PCM_FORMAT_S16_LE;
-
-    *stream_in = &in->stream;
-    return 0;
-
-err_open:
-    free(in);
-    *stream_in = NULL;
-    return ret;
-}
-
-static void adev_close_input_stream(struct audio_hw_device *dev,
-                                   struct audio_stream_in *stream)
-{
-    struct tiny_stream_in *in = (struct tiny_stream_in *)stream;
-
-    if (in->pcm)
-	pcm_close(in->pcm);
-    free(in);
-    return;
+    return s;
 }
 
 static int adev_dump(const audio_hw_device_t *device, int fd)
@@ -605,306 +2005,72 @@
 
 static int adev_close(hw_device_t *device)
 {
+    struct audio_device *adev = (struct audio_device *)device;
+
+    free_audio_config(adev->cm);
+
     free(device);
     return 0;
 }
 
-static uint32_t adev_get_supported_devices(const struct audio_hw_device *dev)
-{
-    struct tiny_audio_device *adev = (struct tiny_audio_device *)dev;
-    uint32_t supported = 0;
-    int i;
-
-    for (i = 0; i < adev->num_dev_cfgs; i++)
-	supported |= adev->dev_cfgs[i].mask;
-
-    return supported;
-}
-
-struct config_parse_state {
-    struct tiny_audio_device *adev;
-    struct tiny_dev_cfg *dev;
-    bool on;
-
-    struct route_setting *path;
-    unsigned int path_len;
-};
-
-static const struct {
-    int mask;
-    const char *name;
-} dev_names[] = {
-    { AUDIO_DEVICE_OUT_SPEAKER, "speaker" },
-    { AUDIO_DEVICE_OUT_WIRED_HEADSET | AUDIO_DEVICE_OUT_WIRED_HEADPHONE,
-      "headphone" },
-    { AUDIO_DEVICE_OUT_EARPIECE, "earpiece" },
-    { AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET, "analog-dock" },
-    { AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET, "digital-dock" },
-
-    { AUDIO_DEVICE_IN_COMMUNICATION, "comms" },
-    { AUDIO_DEVICE_IN_AMBIENT, "ambient" },
-    { AUDIO_DEVICE_IN_BUILTIN_MIC, "builtin-mic" },
-    { AUDIO_DEVICE_IN_WIRED_HEADSET, "headset" },
-    { AUDIO_DEVICE_IN_AUX_DIGITAL, "digital" },
-    { AUDIO_DEVICE_IN_BACK_MIC, "back-mic" },
-};
-
-static void adev_config_start(void *data, const XML_Char *elem,
-			      const XML_Char **attr)
-{
-    struct config_parse_state *s = data;
-    struct tiny_dev_cfg *dev_cfg;
-    const XML_Char *name = NULL;
-    const XML_Char *val = NULL;
-    unsigned int i, j;
-
-    for (i = 0; attr[i]; i += 2) {
-	if (strcmp(attr[i], "name") == 0)
-	    name = attr[i + 1];
-
-	if (strcmp(attr[i], "val") == 0)
-	    val = attr[i + 1];
-    }
-
-    if (strcmp(elem, "device") == 0) {
-	if (!name) {
-	    LOGE("Unnamed device\n");
-	    return;
-	}
-
-	for (i = 0; i < sizeof(dev_names) / sizeof(dev_names[0]); i++) {
-	    if (strcmp(dev_names[i].name, name) == 0) {
-		LOGI("Allocating device %s\n", name);
-		dev_cfg = realloc(s->adev->dev_cfgs,
-				  (s->adev->num_dev_cfgs + 1)
-				  * sizeof(*dev_cfg));
-		if (!dev_cfg) {
-		    LOGE("Unable to allocate dev_cfg\n");
-		    return;
-		}
-
-		s->dev = &dev_cfg[s->adev->num_dev_cfgs];
-		memset(s->dev, 0, sizeof(*s->dev));
-		s->dev->mask = dev_names[i].mask;
-
-		s->adev->dev_cfgs = dev_cfg;
-		s->adev->num_dev_cfgs++;
-	    }
-	}
-
-    } else if (strcmp(elem, "path") == 0) {
-	if (s->path_len)
-	    LOGW("Nested paths\n");
-
-	/* If this a path for a device it must have a role */
-	if (s->dev) {
-	    /* Need to refactor a bit... */
-	    if (strcmp(name, "on") == 0) {
-		s->on = true;
-	    } else if (strcmp(name, "off") == 0) {
-		s->on = false;
-	    } else {
-		LOGW("Unknown path name %s\n", name);
-	    }
-	}
-
-    } else if (strcmp(elem, "ctl") == 0) {
-	struct route_setting *r;
-
-	if (!name) {
-	    LOGE("Unnamed control\n");
-	    return;
-	}
-
-	if (!val) {
-	    LOGE("No value specified for %s\n", name);
-	    return;
-	}
-
-	LOGV("Parsing control %s => %s\n", name, val);
-
-	r = realloc(s->path, sizeof(*r) * (s->path_len + 1));
-	if (!r) {
-	    LOGE("Out of memory handling %s => %s\n", name, val);
-	    return;
-	}
-
-	r[s->path_len].ctl_name = strdup(name);
-	r[s->path_len].strval = NULL;
-
-	/* This can be fooled but it'll do */
-	r[s->path_len].intval = atoi(val);
-	if (!r[s->path_len].intval && strcmp(val, "0") != 0)
-	    r[s->path_len].strval = strdup(val);
-
-	s->path = r;
-	s->path_len++;
-    }
-}
-
-static void adev_config_end(void *data, const XML_Char *name)
-{
-    struct config_parse_state *s = data;
-    unsigned int i;
-
-    if (strcmp(name, "path") == 0) {
-	if (!s->path_len)
-	    LOGW("Empty path\n");
-
-	if (!s->dev) {
-	    LOGV("Applying %d element default route\n", s->path_len);
-
-	    set_route_by_array(s->adev->mixer, s->path, s->path_len);
-
-	    for (i = 0; i < s->path_len; i++) {
-		free(s->path[i].ctl_name);
-		free(s->path[i].strval);
-	    }
-
-	    free(s->path);
-
-	    /* Refactor! */
-	} else if (s->on) {
-	    LOGV("%d element on sequence\n", s->path_len);
-	    s->dev->on = s->path;
-	    s->dev->on_len = s->path_len;
-
-	} else {
-	    LOGV("%d element off sequence\n", s->path_len);
-
-	    /* Apply it, we'll reenable anything that's wanted later */
-	    set_route_by_array(s->adev->mixer, s->path, s->path_len);
-
-	    s->dev->off = s->path;
-	    s->dev->off_len = s->path_len;
-	}
-
-	s->path_len = 0;
-	s->path = NULL;
-
-    } else if (strcmp(name, "device") == 0) {
-	s->dev = NULL;
-    }
-}
-
-static int adev_config_parse(struct tiny_audio_device *adev)
-{
-    struct config_parse_state s;
-    FILE *f;
-    XML_Parser p;
-    char property[PROPERTY_VALUE_MAX];
-    char file[80];
-    int ret = 0;
-    bool eof = false;
-    int len;
-
-    property_get("ro.product.device", property, "tiny_hw");
-    snprintf(file, sizeof(file), "/system/etc/sound/%s", property);
-
-    LOGV("Reading configuration from %s\n", file);
-    f = fopen(file, "r");
-    if (!f) {
-	LOGE("Failed to open %s\n", file);
-	return -ENODEV;
-    }
-
-    p = XML_ParserCreate(NULL);
-    if (!p) {
-	LOGE("Failed to create XML parser\n");
-	ret = -ENOMEM;
-	goto out;
-    }
-
-    memset(&s, 0, sizeof(s));
-    s.adev = adev;
-    XML_SetUserData(p, &s);
-
-    XML_SetElementHandler(p, adev_config_start, adev_config_end);
-
-    while (!eof) {
-	len = fread(file, 1, sizeof(file), f);
-	if (ferror(f)) {
-	    LOGE("I/O error reading config\n");
-	    ret = -EIO;
-	    goto out_parser;
-	}
-	eof = feof(f);
-
-	if (XML_Parse(p, file, len, eof) == XML_STATUS_ERROR) {
-	    LOGE("Parse error at line %u:\n%s\n",
-		 (unsigned int)XML_GetCurrentLineNumber(p),
-		 XML_ErrorString(XML_GetErrorCode(p)));
-	    ret = -EINVAL;
-	    goto out_parser;
-	}
-    }
-
- out_parser:
-    XML_ParserFree(p);
- out:
-    fclose(f);
-
-    return ret;
-}
-
 static int adev_open(const hw_module_t* module, const char* name,
                      hw_device_t** device)
 {
-    struct tiny_audio_device *adev;
+    struct audio_device *adev;
     int ret;
 
     if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0)
         return -EINVAL;
 
-    adev = calloc(1, sizeof(struct tiny_audio_device));
+    adev = calloc(1, sizeof(struct audio_device));
     if (!adev)
         return -ENOMEM;
 
-    adev->device.common.tag = HARDWARE_DEVICE_TAG;
-    adev->device.common.version = 0;
-    adev->device.common.module = (struct hw_module_t *) module;
-    adev->device.common.close = adev_close;
+    adev->hw_device.common.tag = HARDWARE_DEVICE_TAG;
+    adev->hw_device.common.version = AUDIO_DEVICE_API_VERSION_2_0;
+    adev->hw_device.common.module = (struct hw_module_t *) module;
+    adev->hw_device.common.close = adev_close;
 
-    adev->device.get_supported_devices = adev_get_supported_devices;
-    adev->device.init_check = adev_init_check;
-    adev->device.set_voice_volume = adev_set_voice_volume;
-    adev->device.set_master_volume = adev_set_master_volume;
-    adev->device.set_mode = adev_set_mode;
-    adev->device.set_mic_mute = adev_set_mic_mute;
-    adev->device.get_mic_mute = adev_get_mic_mute;
-    adev->device.set_parameters = adev_set_parameters;
-    adev->device.get_parameters = adev_get_parameters;
-    adev->device.get_input_buffer_size = adev_get_input_buffer_size;
-    adev->device.open_output_stream = adev_open_output_stream;
-    adev->device.close_output_stream = adev_close_output_stream;
-    adev->device.open_input_stream = adev_open_input_stream;
-    adev->device.close_input_stream = adev_close_input_stream;
-    adev->device.dump = adev_dump;
+    adev->hw_device.init_check = adev_init_check;
+    adev->hw_device.set_voice_volume = adev_set_voice_volume;
+    adev->hw_device.set_master_volume = adev_set_master_volume;
+    adev->hw_device.set_mode = adev_set_mode;
+    adev->hw_device.set_mic_mute = adev_set_mic_mute;
+    adev->hw_device.get_mic_mute = adev_get_mic_mute;
+    adev->hw_device.set_parameters = adev_set_parameters;
+    adev->hw_device.get_parameters = adev_get_parameters;
+    adev->hw_device.get_input_buffer_size = adev_get_input_buffer_size;
+    adev->hw_device.open_output_stream = adev_open_output_stream;
+    adev->hw_device.close_output_stream = adev_close_output_stream;
+    adev->hw_device.open_input_stream = adev_open_input_stream;
+    adev->hw_device.close_input_stream = adev_close_input_stream;
+    adev->hw_device.dump = adev_dump;
 
-    adev->mixer = mixer_open(0);
-    if (!adev->mixer) {
-	LOGE("Failed to open mixer 0\n");
-	goto err;
+    adev->cm = init_audio_config();
+    if (!adev->cm) {
+        ret = -EINVAL;
+        goto fail;
     }
-    
-    ret = adev_config_parse(adev);
-    if (ret != 0)
-	goto err_mixer;
 
-    /* Bootstrap routing */
-    pthread_mutex_init(&adev->route_lock, NULL);
-    adev->mode = AUDIO_MODE_NORMAL;
-    adev->devices = AUDIO_DEVICE_OUT_SPEAKER | AUDIO_DEVICE_IN_BUILTIN_MIC;
-    select_devices(adev);
+    if (is_named_stream_defined(adev->cm, "voice recognition")) {
+        ret = init_voice_trigger_service();
+        if (ret != 0) {
+            goto fail;
+        }
+    }
 
-    *device = &adev->device.common;
+    adev->orientation = ORIENTATION_UNDEFINED;
 
+    *device = &adev->hw_device.common;
     return 0;
 
-err_mixer:
-    mixer_close(adev->mixer);
-err:
-    return -EINVAL;
+fail:
+    if (adev->cm) {
+        /*free_audio_config(adev->cm);*/ /* Currently broken */
+    }
+
+    free(adev);
+    return ret;
 }
 
 static struct hw_module_methods_t hal_module_methods = {
@@ -914,11 +2080,11 @@
 struct audio_module HAL_MODULE_INFO_SYM = {
     .common = {
         .tag = HARDWARE_MODULE_TAG,
-        .version_major = 1,
-        .version_minor = 0,
+        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,
+        .hal_api_version = HARDWARE_HAL_API_VERSION,
         .id = AUDIO_HARDWARE_MODULE_ID,
         .name = "TinyHAL",
-        .author = "Mark Brown <broonie@opensource.wolfsonmicro.com>",
+        .author = "Richard Fitzgerald <rf@opensource.wolfsonmicro.com>",
         .methods = &hal_module_methods,
     },
 };
diff --git a/voice_trigger.cpp b/voice_trigger.cpp
new file mode 100644
index 0000000..a33781e
--- /dev/null
+++ b/voice_trigger.cpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2013 Wolfson Microelectronics plc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "tinyhal-vctrig"
+/*#define LOG_NDEBUG 0*/
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include <cutils/log.h>
+#include <sysutils/FrameworkListener.h>
+#include <sysutils/FrameworkCommand.h>
+#include <utils/Mutex.h>
+#include <utils/Condition.h>
+
+#include "voice_trigger.h"
+
+static CVoiceTriggerService* TriggerService;
+
+CVoiceTriggerCommand::CVoiceTriggerCommand()
+    : FrameworkCommand("wait")
+{
+}
+
+CVoiceTriggerCommand::~CVoiceTriggerCommand()
+{
+}
+
+int CVoiceTriggerCommand::runCommand(SocketClient *c, int argc, char **argv)
+{
+    return 0;
+}
+
+CVoiceTriggerService::CVoiceTriggerService()
+    : FrameworkListener("voice-trigger", true)
+{
+    registerCmd(&mTriggerCommand);
+}
+
+CVoiceTriggerService::~CVoiceTriggerService()
+{
+}
+
+
+// As the rest of TinyHAL is currently written in C we provide a
+// C interface to the voice trigger service
+
+extern "C"
+void send_voice_trigger()
+{
+    if (TriggerService != NULL) {
+        ALOGV("trigger");
+        TriggerService->sendBroadcast(0, "trig", 0);
+    }
+}
+
+extern "C"
+int init_voice_trigger_service()
+{
+    ALOGV("init_voice_trigger_service");
+
+    CVoiceTriggerService *svc = new CVoiceTriggerService;
+    if (svc->startListener() != 0) {
+        int ret = errno;
+        delete svc;
+        return ret;
+    }
+
+    TriggerService = svc;
+    return 0;
+}
+
+
+
+
diff --git a/voice_trigger.h b/voice_trigger.h
new file mode 100644
index 0000000..43507b3
--- /dev/null
+++ b/voice_trigger.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2012-13 Wolfson Microelectronics plc
+ *
+ * This code is heavily based on AOSP HAL for the asus/grouper
+ *
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef VOICE_TRIGGER_H
+#define VOICE_TRIGGER_H
+
+#if defined(__cplusplus)
+#include <sysutils/FrameworkListener.h>
+#include <sysutils/FrameworkCommand.h>
+#include <utils/Mutex.h>
+#include <utils/Condition.h>
+
+class CVoiceTriggerCommand : public FrameworkCommand
+{
+public:
+    CVoiceTriggerCommand();
+    virtual ~CVoiceTriggerCommand();
+
+private:
+    int runCommand(SocketClient *c, int argc, char **argv);
+};
+
+class CVoiceTriggerService : public FrameworkListener
+{
+public:
+    CVoiceTriggerService();
+    virtual ~CVoiceTriggerService();
+
+public:
+    CVoiceTriggerCommand mTriggerCommand;
+};
+
+extern "C" {
+#endif
+
+void send_voice_trigger();
+int init_voice_trigger_service();
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif