Import fastrpc code from upstream am: d6d6e3bba2 am: 3b85c51d27
am: 3704a6f17f

Change-Id: Id8410063d6653b065041b3807aec53cf83391636
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..8251c58
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,84 @@
+
+CFLAGS = -fno-short-enums -U_DEBUG -DARM_ARCH_7A -DLE_ENABLE -DUSE_SYSLOG -Iinc -Isrc -DDEFAULT_DOMAIN_ID=3
+LDFLAGS = -fPIC -pie -Wl,--version-script=src/symbols.lst -ldl -lpthread -lm
+
+
+
+prefix := /usr/local
+bindir := $(prefix)/bin
+libdir := $(prefix)/lib
+
+
+LIBADSPRPC_SRC_FILES := src/fastrpc_apps_user.c \
+		src/remotectl_stub.c \
+		src/listener_android.c \
+		src/adsp_current_process_stub.c \
+		src/adsp_current_process1_stub.c \
+		src/apps_std_skel.c \
+		src/apps_std_imp.c \
+		src/apps_mem_imp.c \
+		src/apps_mem_skel.c \
+		src/rpcmem_android.c \
+		src/apps_remotectl_skel.c \
+		src/std.c \
+		src/std_path.c \
+		src/std_mem.c \
+		src/std_dtoa.c \
+		src/std_strlprintf.c \
+		src/BufBound.c \
+		src/std_SwapBytes.c \
+		src/smath.c \
+		src/atomic.c \
+		src/cae.c \
+		src/adspmsgd_apps_skel.c \
+		src/adspmsgd_adsp_stub.c \
+		src/adspmsgd_adsp1_stub.c \
+		src/adspmsgd_apps.c \
+		src/platform_libs.c \
+		src/pl_list.c \
+		src/log_config.c \
+		src/gpls.c \
+		src/adsp_perf_stub.c \
+		src/fastrpc_perf.c \
+		src/mod_table.c
+
+LIBADSPRPC_OBJ := $(LIBADSPRPC_SRC_FILES:.c=.o)
+
+LIBDEFAULT_LISTENER_SRC_FILES := src/adsp_default_listener.c \
+				src/adsp_default_listener_stub.c \
+				src/std.c \
+				src/std_mem.c
+
+LIBDEFAULT_LISTENER_OBJ := $(LIBDEFAULT_LISTENER_SRC_FILES:.c=.o)
+
+ADSPRPCD_SRC_FILES := src/cdsprpcd.c
+
+ADSPRPCD_OBJ := $(ADSPRPCD_SRC_FILES:.c=.o)
+
+%.o: %.c
+	$(CC) -fpic -pie $(CFLAGS) -c $< -o $@
+
+cdsprpcd: $(ADSPRPCD_OBJ) libcdsp_default_listener.so
+	echo $(LD) -fpic -pie $(LDFLAGS) -o cdsprpcd
+	$(CC) -fpic -pie -fPIC -pie -Wl,--version-script=src/symbols.lst -ldl -lpthread -lm $(ADSPRPCD_OBJ) -o cdsprpcd -lcdsp_default_listener -L.
+	echo "cdsprpcd built successfully"
+
+LDFLAGS = -fPIC -pie -Wl,--version-script=src/symbols.lst -shared -ldl -lpthread -lm    
+    
+libcdsp_default_listener.so: $(LIBDEFAULT_LISTENER_OBJ) libcdsprpc.so
+	echo $(LD) -fpic -pie -shared $(LDFLAGS) -o libcdsp_default_listener.so
+	$(CC) -fpic -pie -shared -fPIC -pie -Wl,--version-script=src/adsp_def_symbols.lst -ldl -lpthread -lm $(LIBDEFAULT_LISTENER_OBJ) -o libcdsp_default_listener.so -lcdsprpc -L.
+	echo "libcdsp_default_listener built successfully"
+
+libcdsprpc.so: $(LIBADSPRPC_OBJ)
+	echo $(LD) -fpic -pie -shared $(LDFLAGS) -o libcdsprpc.so
+	$(CC) -fpic -pie -shared $(LDFLAGS) $(LIBADSPRPC_OBJ) -o libcdsprpc.so
+	echo "libcdsprpc built successfully"
+
+all: libcdsprpc.so libcdsp_default_listener.so cdsprpcd
+	echo "All binaries built"
+
+install: libcdsprpc.so libcdsp_default_listener.so cdsprpcd
+	@install -D -m 755 libcdsprpc.so $(DESTDIR)$(libdir)/libcdsprpc.so
+	@install -D -m 755 libcdsp_default_listener.so $(DESTDIR)$(libdir)/libcdsp_default_listener.so
+	@install -D -m 755 cdsprpcd $(DESTDIR)$(bindir)/cdsprpcd
\ No newline at end of file
diff --git a/inc/AEEBufBound.h b/inc/AEEBufBound.h
new file mode 100644
index 0000000..583844c
--- /dev/null
+++ b/inc/AEEBufBound.h
@@ -0,0 +1,567 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AEEBUFBOUND_H
+#define AEEBUFBOUND_H
+/*==============================================================================
+
+FILE:  AEEBufBound.h
+
+SERVICES:
+        BufBound APIs
+
+GENERAL DESCRIPTION:
+        BufBound provides a "bounded buffer" API that facilitates
+          measuring strings or character output.  It's design accomodates
+          the implementation of functions that can have the same exact logic
+          for measuring and outputting char buffer content.
+
+REVISION HISTORY:
+        Fri Aug 08 17:38:29 2003: Created
+
+==============================================================================*/
+
+typedef struct BufBound
+{
+   char* pcBuf;   /* original buffer */
+   char* pcWrite; /* write pointer */
+   char* pcEnd;   /* first illegal write pointer */
+} BufBound;
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* #ifdef __cplusplus */
+
+extern void BufBound_Init(BufBound *me, char *pBuf, int nLen);
+extern void BufBound_Write(BufBound *me, const char *pc, int nLen);
+extern void BufBound_Putc(BufBound *me, char c);
+extern void BufBound_Putnc(BufBound *me, char c, int nCount);
+extern void BufBound_ForceNullTerm(BufBound *me);
+extern void BufBound_Puts(BufBound *me, const char* cpsz);
+extern void BufBound_Advance(BufBound *me, int nLen);
+extern void BufBound_WriteLE(BufBound* me,
+                             const void *pvSrc, int nSrcSize,
+                             const char *pszFields);
+extern void BufBound_WriteBE(BufBound* me,
+                             const void *pvSrc, int nSrcSize,
+                             const char *pszFields);
+extern int BufBound_BufSize(BufBound *me);
+extern int BufBound_Left(BufBound* me);
+extern int BufBound_ReallyWrote(BufBound* me);
+extern int BufBound_Wrote(BufBound* me);
+
+static __inline int BufBound_IsFull(BufBound* me)
+{
+   return (BufBound_Left(me) <= 0);
+}
+
+// Deprecated:
+static __inline int BufBound_IsCounter(BufBound* me)
+{
+   return BufBound_BufSize(me) == 0;
+}
+
+#ifdef __cplusplus
+}
+#endif /* #ifdef __cplusplus */
+
+
+/*=====================================================================
+=======================================================================
+DATA STRUCTURE DOCUMENTATION
+=======================================================================
+
+BufBound
+
+Description:
+   An BufBound keeps track of whether appending to a bounded buffer
+    has overflowed.
+
+Definition:
+   typedef struct BufBound
+   {
+      char* pcBuf;
+      char* pcWrite;
+      char* pcEnd;
+   } BufBound;
+
+Members:
+      pcBuf: original start pointer
+      pcWrite: current write location
+      pcEnd: first illegal write position
+
+See Also:
+      BufBound Interface
+
+=======================================================================
+INTERFACE DOCUMENTATION
+=======================================================================
+BufBound Interface
+
+  BufBound is a statically-linked interface.
+
+  BufBound provides functions for safely appending to a character buffer.  On
+  initialization, the buffer start address and size are provided.  Subsequent
+  write operations are checked against the buffer bounds.
+
+  Once the buffer bounds are exceeded, no bytes will be written but the
+  BufBound will continue to increment its internal "write pointer" to reflect
+  the number of bytes that would have been written (had the bounds not been
+  exceeded).
+
+  When initialized with a buffer size of zero, a BufBound simply counts the
+  number of bytes that would be required to contain the result.  This design
+  accommodates implementations that use the same logic for generating output
+  and measuring the space required for generated output.
+
+  BufBound protects clients from numerical overflow by limiting the write
+  pointer to a maximum offset of INT_MAX from the start of the buffer.
+  Functions that write data into the buffer safely ignore negative size inputs
+  (Write and Putnc).
+
+=======================================================================
+BufBound_Init()
+
+Description:
+   initialize a BufBound for appending to a buffer
+
+Prototype:
+
+   void BufBound_Init(BufBound *me, char *pBuf, int nLen);
+
+Parameters:
+   me: the BufBound
+   pBuf: the bounded buffer
+   nLen: size of pBuf, in bytes
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+BufBound_Write()
+
+Description:
+   Appends some number of bytes to a BufBound, if possible.
+
+   When a negative size is passed, it is safely treated as zero.
+
+Prototype:
+
+   void BufBound_Write(BufBound *me, const char *pc, int nLen);
+
+Parameters:
+   me: the BufBound
+   pc: pointer to bytes to append
+   int nLen: number of bytes to write
+
+Return Value:
+   None
+
+Comments:
+   If the BufBound has overflowed, no bytes are written, but pcWrite is
+      *always* advanced by nLen.
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+BufBound_Advance()
+
+Description:
+
+   Moves the write pointer.  Advance is like a relative seek operation.  It
+   does not change the contents of the buffer, so when using a forward seek
+   (positive advance) be careful of advancing over uninitialized data.
+
+   Negative numbers will decrease the write pointer down to 0 (the start of
+   the buffer) and not below.  Positive numbers will increase the write
+   pointer up to offset INT_MAX and not beyond.
+
+Prototype:
+
+   void BufBound_Advance(BufBound *me, int nDelta);
+
+Parameters:
+   me: the BufBound
+   int nLen: number of bytes to advance
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+BufBound_Putc()
+
+Description:
+   Appends one byte to a BufBound, if possible.
+
+Prototype:
+
+   void BufBound_Putc(BufBound *me, char c);
+
+Parameters:
+   me: the BufBound
+   c: the byte
+
+Return Value:
+   None
+
+Comments:
+   If the BufBound has overflowed, no byte is written, but pcWrite is
+      *always* advanced by 1.
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_Putnc()
+
+Description:
+   Appends a byte to a BufBound repeatedly.
+
+   When a negative size is passed, it is safely treated as zero.
+
+Prototype:
+
+   void BufBound_Putnc(BufBound *me, char c, int nCount);
+
+Parameters:
+   me: the BufBound
+   c: the byte
+   nCount: number of times to append c
+
+Return Value:
+   None
+
+Comments:
+   If the BufBound has overflowed, no byte is written, but pcWrite is
+      *always* advanced by nCount.
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_ForceNullTerm()
+
+Description:
+   Appends a null terminating character to a BufBound, if possible.
+     If the BufBound has overflowed, the last legal location is
+     set to '\0'.
+
+Prototype:
+   void BufBound_ForceNullTerm(BufBound *me);
+
+Parameters:
+   me: the BufBound
+
+Return Value:
+   None
+
+Comments:
+   pcWrite is *always* advanced by 1.
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_Puts()
+
+Description:
+   Appends a null-terminated string to a BufBound, if possible
+
+Prototype:
+
+   void BufBound_Puts(BufBound *me, const char* cpsz);
+
+Parameters:
+   me: the BufBound
+   cpsz: the string to append
+
+Return Value:
+
+Comments:
+   If the BufBound has overflowed, no bytes are written, but pcWrite is
+      *always* advanced by strlen(cpsz).
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_BufSize()
+
+Description:
+   Returns the size of the buffer owned by the BufBound.  This is
+   the same as the number passed to BufBound_Init (MAXed with zero).
+
+Prototype:
+
+   int BufBound_IsCounter(BufBound* me);
+
+Parameters:
+   me: the BufBound
+
+Return Value:
+   1 if the BufBound is a counter, 0 otherwise
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_Left()
+
+Description:
+   Returns the number of bytes the BufBound can still accomodate,
+   without overflowing.  If overflow has occurred, it will return
+   a negative number.
+
+Prototype:
+
+   int BufBound_Left(BufBound* me);
+
+Parameters:
+    me: the BufBound
+
+Return Value:
+   The number of bytes the BufBound can still accomodate,
+     without overflowing.
+
+Comments:
+   The return value may be negative, if overflow has already occurred.
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_ReallyWrote()
+
+Description:
+   Returns the number of bytes actually written to the BufBound,
+     not including any overflow.
+
+Prototype:
+
+   int BufBound_ReallyWrote(BufBound* me);
+
+Parameters:
+    me: the BufBound
+
+Return Value:
+   The number of bytes actually written to the BufBound,
+     not including any overflow.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_Wrote()
+
+Description:
+
+   Returns the number of bytes written to the BufBound, including any
+   overflow, up to INT_MAX.
+
+Prototype:
+
+   int BufBound_Wrote(BufBound* me);
+
+Parameters:
+    me: the BufBound
+
+Return Value:
+
+   The number of bytes written to the BufBound, including any overflow.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+BufBound_IsFull()
+
+Description:
+   Tests whether an AEEBuffBound has overflowed.
+
+Prototype:
+
+   int BufBound_IsFull(BufBound* me);
+
+Parameters:
+    me: the BufBound
+
+Return Value:
+   1 if the BufBound has overflowed, 0 otherwise
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+BufBound_WriteLE()
+
+Description:
+
+   Writes data while translating numeric values between host byte ordering and
+   "little endian" byte ordering.
+
+   The input buffer is treated as an array of structures.  The 'abySizes'
+   parameter describes the sizes of fields in the structure.
+
+   When the host byte ordering matches the target byte ordering (little
+   endian) this operation is equivalent to BufBound_Write().
+
+Prototype:
+
+   void BufBound_WriteLE(BufBound* me,
+                         const void *pvSrc, int nSrcSize,
+                         const unsigned char *pszFields);
+
+Parameters:
+   me:        the BufBound
+   pvSrc:     the source buffer
+   nSrcSize:  number of bytes to copy from the source buffer
+   pszFields: Description of the fields that comprise the source data,
+              as defined in std_CopyLE.
+
+Return Value:
+   None
+
+See Also:
+   BufBound_WriteBE, std_CopyLE
+
+=======================================================================
+
+BufBound_WriteBE()
+
+Description:
+
+   BufBounf_WriteBE() has the same semantics as BufBound_WriteLE() except it
+   copies between host byte ordering and big-endian ("network") byte order.
+
+   See BufBound_WriteLE() for more details.
+
+
+Prototype:
+
+   void BufBound_WriteBE(BufBound* me,
+                         const void *pvSrc, int nSrcSize,
+                         const unsigned char *pszFields);
+
+Parameters:
+   me:        the BufBound
+   pvSrc:     the source buffer
+   nSrcSize:  number of bytes to copy from the source buffer
+   pszFields: Description of the fields that comprise the source data,
+              as defined in std_CopyLE.
+
+Return Value:
+   None
+
+See Also:
+   BufBound_WriteLE, std_CopyBE
+
+======================================================================= */
+#endif /* #ifndef AEEBUFBOUND_H */
+
diff --git a/inc/AEEQList.h b/inc/AEEQList.h
new file mode 100644
index 0000000..1b3b941
--- /dev/null
+++ b/inc/AEEQList.h
@@ -0,0 +1,851 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*===========================================================================
+
+FILE:  AEEQList.h
+
+GENERAL DESCRIPTION:  Doubly-linked circular list implementation
+
+===========================================================================*/
+#ifndef _AEEQLIST_H_
+#define _AEEQLIST_H_
+
+
+typedef struct QNode QNode;
+struct QNode {
+   QNode *pNext;
+   QNode *pPrev;
+};
+
+#define QLIST_DEFINE_INIT(f) QList f = { { &f.n, &f.n } }
+
+typedef struct QList QList;
+struct QList {
+   QNode n;
+};
+
+
+
+static __inline void QNode_InsPrev(QNode *me, QNode *pn)
+{
+   QNode *pPrev = me->pPrev;
+
+   pn->pNext    = me;
+   pn->pPrev    = pPrev;
+   pPrev->pNext = pn;
+   me->pPrev    = pn;
+}
+
+
+static __inline void QNode_InsNext(QNode *me, QNode *pn)
+{
+   QNode *pNext = me->pNext;
+
+   pn->pPrev    = me;
+   pn->pNext    = pNext;
+   pNext->pPrev = pn;
+   me->pNext    = pn;
+}
+
+
+
+static __inline void QNode_Dequeue(QNode *me)
+{
+   QNode *pNext = me->pNext;
+   QNode *pPrev = me->pPrev;
+
+   pPrev->pNext = pNext;
+   pNext->pPrev = pPrev;
+}
+
+static __inline void QNode_CtorZ(QNode *me)
+{
+   me->pNext = me->pPrev = 0;
+}
+
+static __inline int QNode_IsQueuedZ(QNode *me)
+{
+   return (0 != me->pNext);
+}
+
+static __inline void QNode_DequeueZ(QNode *me)
+{
+   if (QNode_IsQueuedZ(me)) {
+      QNode_Dequeue(me);
+      me->pNext = me->pPrev = 0;
+   }
+}
+
+//--------------------------------------------------------------------
+//--  QList functions  ----------------------------------------------
+//--------------------------------------------------------------------
+
+
+static __inline void QList_Zero(QList *me)
+{
+   me->n.pNext = me->n.pPrev = &me->n;
+}
+
+
+static __inline void QList_Ctor(QList *me)
+{
+   QList_Zero(me);
+}
+
+
+static __inline int QList_IsEmpty(QList *me)
+{
+   return me->n.pNext == &me->n;
+}
+
+static __inline int QList_IsNull(QList *me)
+{
+   return ((0 == me->n.pNext) && (0 == me->n.pPrev));
+}
+
+
+static __inline void QList_AppendNode(QList *me, QNode *pn)
+{
+   QNode_InsPrev(&me->n, pn);
+}
+
+
+static __inline void QList_PrependNode(QList *me, QNode *pn)
+{
+   QNode_InsNext(&me->n, pn);
+}
+
+
+static __inline void QList_CtorFrom(QList *me, QList *psrc)
+{
+   QNode *s = &psrc->n;
+   QNode *d = &me->n;
+
+   s->pNext->pPrev = d;
+   d->pPrev        = s->pPrev;
+   d->pNext        = s->pNext;
+   s->pPrev->pNext = d;
+
+   QList_Zero(psrc);
+}
+
+
+
+static __inline void QList_AppendList(QList *me, QList *psrc)
+{
+   QNode *s = &psrc->n;
+   QNode *d = &me->n;
+   QNode *dp = d->pPrev;
+   QNode *sn = s->pNext;
+   QNode *sp;
+
+   sn->pPrev   = dp;
+   dp->pNext   = sn;
+   d->pPrev    = (sp = s->pPrev);
+   sp->pNext   = d;
+
+   QList_Zero(psrc);
+}
+
+
+#define QLIST_FOR_ALL(pList, pNode) \
+   for ((pNode) = (pList)->n.pNext; \
+        (pNode) != &(pList)->n; \
+        (pNode) = (pNode)->pNext)
+
+#define QLIST_FOR_REST(pList, pNode) \
+   for (; \
+        (pNode) != &(pList)->n; \
+        (pNode) = (pNode)->pNext)
+
+#define QLIST_REV_FOR_ALL(pList, pNode) \
+   for ((pNode) = (pList)->n.pPrev; \
+        (pNode) != &(pList)->n; \
+        (pNode) = (pNode)->pPrev)
+
+#define QLIST_REV_FOR_REST(pList, pNode) \
+   for (; \
+        (pNode) != &(pList)->n; \
+        (pNode) = (pNode)->pPrev)
+
+/* Allows dequeing QNodes during iteration */
+#define QLIST_NEXTSAFE_FOR_ALL(pList, pNode, pNodeNext) \
+    for ((pNode) = (pList)->n.pNext, (pNodeNext) = (pNode)->pNext; \
+         (pNode) != &(pList)->n; \
+         (pNode) = (pNodeNext), (pNodeNext) = (pNode)->pNext)
+
+static __inline QNode *QList_GetFirst(QList *me)
+{
+   QNode *pn = me->n.pNext;
+
+   return (pn == &me->n ? 0 : pn);
+}
+
+static __inline QNode *QList_GetLast(QList *me)
+{
+   QNode *pn = me->n.pPrev;
+
+   return (pn == &me->n ? 0 : pn);
+}
+
+static __inline QNode *QList_Pop(QList *me)
+{
+   QNode *pn = me->n.pNext;
+   QNode *pnn = pn->pNext;
+
+   me->n.pNext = pnn;
+   pnn->pPrev   = &me->n;
+
+   return (pn == &me->n ? 0 : pn);
+}
+
+static __inline QNode *QList_PopZ(QList *me)
+{
+   QNode *pn = QList_Pop(me);
+   if (0 != pn) {
+      QNode_CtorZ(pn);
+   }
+   return pn;
+}
+
+static __inline QNode *QList_PopLast(QList *me)
+{
+   QNode *pp = me->n.pPrev;
+   QNode *ppp = pp->pPrev;
+
+   me->n.pPrev = ppp;
+   ppp->pNext  = &me->n;
+
+   return (pp == &me->n ? 0 : pp);
+}
+
+static __inline QNode *QList_PopLastZ(QList *me)
+{
+   QNode *pn = QList_PopLast(me);
+   if (0 != pn) {
+      QNode_CtorZ(pn);
+   }
+   return pn;
+}
+
+/*=====================================================================
+=======================================================================
+DATA STRUCTURE DOCUMENTATION
+=======================================================================
+
+QNode
+
+Description:
+ Qnode is the structure that is queued.  One or more Qnodes may be
+ embedded in other structures. An object can contain multiple QNodes if
+ it needs to be in different lists at the same time.
+
+Definition:
+
+   typedef struct QNode QNode;
+   struct QNode {
+      QNode *pNext;
+      QNode *pPrev;
+   };
+
+Members:
+
+See Also:
+
+=======================================================================
+
+QList
+
+Description:
+ QList keeps a doubly-linked list of QNode structures.
+ Each queue is represented by a 'head' node, not a head pointer,
+ simplifying and streamlining many operations.
+ Because it is doubly-linked it permits constant-time insertion or removal
+ of items or of entire queues.
+ Because it is circular it permits constant-time operations at both the
+ tail and the head of the queue.  Circularity also streamlines some
+ operations by eliminating conditional branches.
+
+ General rules:
+ QLists are always in a defined state; they should be constructed
+ before use, using one of the supplied Ctor...() functions.
+ QNodes do not track queued vs. unqueued state.  The client should
+ never dequeue an un-queued node or queue an already-queued node.
+ When not queued, QNode internal state is undefined.   A client may
+ implement marking and assertion externally.
+
+Definition:
+
+   typedef struct QList QList;
+   struct QList {
+      QNode n;
+   };
+
+Members:
+
+See Also:
+
+=======================================================================
+INTERFACE DOCUMENTATION
+=======================================================================
+QNode Interface
+
+  QNode is a statically-linked interface.
+
+=======================================================================
+QNode_CtorZ()
+
+Description:
+   Zero initialize a QNode.
+
+Prototype:
+
+   void QNode_CtorZ(QNode *me);
+
+Parameters:
+   me: the QNode
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QNode_IsQueued(), QNode_DequeueZ(), QList_PopZ()
+
+=======================================================================
+QNode_IsQueuedZ()
+
+Description:
+   Whether a QNode belongs in a Queue.
+
+Prototype:
+
+   int QNode_IsQueuedZ(QNode *me);
+
+Parameters:
+   me: the QNode
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   Does not work if a node needs to live at address 0x0.
+
+See Also:
+   QNode_CtorZ(), QNode_DequeueZ(), QList_PopZ()
+
+=======================================================================
+QNode_DequeueZ()
+
+Description:
+   Dequeue a QNode if it is in a queue. Idempotent operation.
+
+Prototype:
+
+   void QNode_DequeueZ(QNode *me);
+
+Parameters:
+   me: the QNode
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QNode_CtorZ(), QNode_IsQueued(), QList_PopZ()
+
+=======================================================================
+
+QNode_InsPrev()
+
+Description:
+	insert a node before this one.
+
+Prototype:
+	static __inline void QNode_InsPrev(QNode *me, QNode *pn)
+
+Parameters:
+	me: the QNode
+	pn: the node to be inserted.
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+QNode_InsNext()
+
+Description:
+	insert a node after this one.
+
+Prototype:
+	static __inline void QNode_InsNext(QNode *me, QNode *pn)
+
+Parameters:
+	me: the QNode
+	pn: the node to be inserted.
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QNode_Dequeue()
+
+Description:
+	dequeue this node.
+
+Prototype:
+	static __inline void QNode_Dequeue(QNode *me)
+
+Parameters:
+	me: the QNode to be dequeued
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList Interface
+
+  QList is a statically-linked interface.  It provides a Queue of
+  doubly linked nodes.
+
+=======================================================================
+QList_Zero()
+
+Description:
+   discard all queued nodes.
+
+Prototype:
+
+   void QList_Zero(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_Ctor()
+
+Description:
+   Initialize a queue to an empty state
+
+Prototype:
+
+   void QList_Ctor(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_IsEmpty()
+
+Description:
+   Check whether queue is empty.
+
+Prototype:
+
+   int QList_IsEmpty(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   TRUE if queue is empty.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_AppendNode()
+
+Description:
+   Append the node to the queue. Make it the last 'next' (and the
+   first 'prev')
+
+Prototype:
+
+   void QList_AppendNode(QList *me, QNode *pn)
+
+Parameters:
+   me: the QList
+   pn: the node to append.
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_PrependNode()
+
+Description:
+   Prepend a node to the queue. Make it the first 'next' (and the
+   last 'prev').
+
+Prototype:
+
+   void QList_PrependNode(QList *me, QNode *pn)
+
+Parameters:
+   me: the QList
+   pn: the node to prepend.
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_CtorFrom()
+
+Description:
+   Move nodes from one queue to a newly constructed queue.
+   Weird aliasing voodoo allows this to work without conditional branches, even
+   when psrc is empty.  In that case, "s->pNext->pPrev = d" overwrites s->pPrev with d,
+   so that "s->pPrev->pNext = d" will later overwrite d->pNext with d.
+
+Prototype:
+
+   void QList_CtorFrom(QList *me, QList *psrc)
+
+Parameters:
+   me: the QList
+   psrc: the Qlist from
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_AppendList()
+
+Description:
+  Move all nodes from a source queue to the end of this queue.
+  Note that weird aliasing voodoo allows this to work without conditional
+  branches when psrc is empty.  A summary:
+
+      SNP = DP      =>  SP = DP, because SNP aliases SP
+      DPN = SN      =>  DPN = S
+      DP = SP       =>  DP = DP, because SP was overwritten with DP
+      SPN = D       =>  DPN = D
+
+Prototype:
+
+   void QList_AppendList(QList *me, QList *psrc)
+
+Parameters:
+   me: the QList
+   psrc: the source Qlist.
+
+Return Value:
+   None
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+QList_GetFirst()
+
+Description:
+   Get the first item on the queue
+
+Prototype:
+
+   QNode *QList_GetFirst(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   pointer to QNode or 0 if queue is empty.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QList_GetLast
+
+=======================================================================
+QList_GetLast()
+
+Description:
+   Get the last item on the queue
+
+Prototype:
+
+   QNode *QList_GetLast(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   pointer to QNode or 0 if queue is empty.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QList_GetFirst
+
+=======================================================================
+QList_Pop()
+
+Description:
+   Remove and return the first item on the queue (FIFO).
+
+Prototype:
+
+   QNode *QList_Pop(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   pointer to QNode or 0 if queue is empty
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QNode_PopZ, QNode_PopLast(), QNode_PopLastZ, QNode_CtorZ(), QNode_IsQueued(),
+   QNode_DequeueZ()
+
+=======================================================================
+QList_PopZ()
+
+Description:
+   Remove and return the first item on the queue (FIFO). Same as QList_Pop(),
+   except the node retured is zero-initialized.
+
+Prototype:
+
+   QNode *QList_PopZ(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   pointer to QNode or 0 if queue is empty
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QNode_Pop, QNode_PopLast(), QNode_PopLastZ, QNode_CtorZ(), QNode_IsQueued(),
+   QNode_DequeueZ()
+
+=======================================================================
+QList_PopLast()
+
+Description:
+   Remove and return the first item on the queue (FILO).
+
+Prototype:
+
+   QNode *QList_PopLast(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   pointer to QNode or 0 if queue is empty
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QNode_PopLastZ, QNode_Pop(), QNode_PopZ, QNode_CtorZ(), QNode_IsQueued(),
+   QNode_DequeueZ()
+
+=======================================================================
+
+QList_IsNull()
+
+Description:
+Checks if the QList is null or not.
+
+Prototype:
+static __inline int QList_IsNull(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   True or False.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+	None
+
+=======================================================================
+
+QList_PopLastZ()
+
+Description:
+   Remove and return the first item on the queue (FILO).
+   Same as QList_PopLast(), except the node retured is zero-initialized.
+
+Prototype:
+
+   QNode *QList_PopLastZ(QList *me)
+
+Parameters:
+   me: the QList
+
+Return Value:
+   pointer to QNode or 0 if queue is empty
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   QNode_Pop(), QNode_PopZ, QNode_CtorZ(), QNode_IsQueued(), QNode_DequeueZ()
+
+=====================================================================*/
+#endif // _AEEQLIST_H_
diff --git a/inc/AEEStdDef.h b/inc/AEEStdDef.h
new file mode 100644
index 0000000..230950f
--- /dev/null
+++ b/inc/AEEStdDef.h
@@ -0,0 +1,1146 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AEESTDDEF_H
+#define AEESTDDEF_H
+/*
+=======================================================================
+
+FILE:         AEEStdDef.h
+
+DESCRIPTION:  definition of basic types, constants,
+                 preprocessor macros
+
+=======================================================================
+*/
+
+#include <stdint.h>
+
+#if defined(COMDEF_H) /* guards against a known re-definer */
+#define _BOOLEAN_DEFINED
+#define _UINT32_DEFINED
+#define _UINT16_DEFINED
+#define _UINT8_DEFINED
+#define _INT32_DEFINED
+#define _INT16_DEFINED
+#define _INT8_DEFINED
+#define _UINT64_DEFINED
+#define _INT64_DEFINED
+#define _BYTE_DEFINED
+#endif /* #if !defined(COMDEF_H) */
+
+/* -----------------------------------------------------------------------
+** Standard Types
+** ----------------------------------------------------------------------- */
+
+/* The following definitions are the same accross platforms.  This first
+** group are the sanctioned types.
+*/
+#ifndef _BOOLEAN_DEFINED
+typedef  unsigned char      boolean;     /* Boolean value type. */
+#define _BOOLEAN_DEFINED
+#endif
+
+#ifndef _UINT32_DEFINED
+typedef  uint32_t           uint32;      /* Unsigned 32 bit value */
+#define _UINT32_DEFINED
+#endif
+
+#ifndef _UINT16_DEFINED
+typedef  unsigned short     uint16;      /* Unsigned 16 bit value */
+#define _UINT16_DEFINED
+#endif
+
+#ifndef _UINT8_DEFINED
+typedef  unsigned char      uint8;       /* Unsigned 8  bit value */
+#define _UINT8_DEFINED
+#endif
+
+#ifndef _INT32_DEFINED
+typedef  int32_t            int32;       /* Signed 32 bit value */
+#define _INT32_DEFINED
+#endif
+
+#ifndef _INT16_DEFINED
+typedef  signed short       int16;       /* Signed 16 bit value */
+#define _INT16_DEFINED
+#endif
+
+#ifndef _INT8_DEFINED
+typedef  signed char        int8;        /* Signed 8  bit value */
+#define _INT8_DEFINED
+#endif
+
+#if defined(__GNUC__)
+#define __int64 long long
+#endif
+
+#ifndef _UINT64_DEFINED
+typedef  unsigned __int64   uint64;      /* Unsigned 64 bit value */
+#define _UINT64_DEFINED
+#endif
+
+#ifndef _INT64_DEFINED
+typedef  __int64            int64;       /* Signed 64 bit value */
+#define _INT64_DEFINED
+#endif
+
+#ifndef _BYTE_DEFINED
+typedef  unsigned char      byte;        /* byte type */
+#define  _BYTE_DEFINED
+#endif
+
+
+#ifndef _AEEUID_DEFINED
+typedef uint32             AEEUID;
+#define _AEEUID_DEFINED
+#endif
+
+#ifndef _AEEIID_DEFINED
+typedef uint32             AEEIID;
+#define _AEEIID_DEFINED
+#endif
+
+#ifndef _AEECLSID_DEFINED
+typedef uint32             AEECLSID;
+#define _AEECLSID_DEFINED
+#endif
+
+#ifndef _AEEPRIVID_DEFINED
+typedef uint32             AEEPRIVID;
+#define _AEEPRIVID_DEFINED
+#endif
+
+#ifndef _AECHAR_DEFINED
+typedef uint16             AECHAR;
+#define _AECHAR_DEFINED
+#endif
+
+#ifndef _AEERESULT_DEFINED
+typedef int                AEEResult;
+#define _AEERESULT_DEFINED
+#endif
+
+/* -----------------------------------------------------------------------
+** Function Calling Conventions
+** ----------------------------------------------------------------------- */
+
+#ifndef CDECL
+#ifdef _MSC_VER
+#define CDECL __cdecl
+#else
+#define CDECL
+#endif /* _MSC_VER */
+#endif /* CDECL */
+
+/* -----------------------------------------------------------------------
+** Constants
+** ----------------------------------------------------------------------- */
+
+#ifndef TRUE
+#define TRUE   1   /* Boolean true value. */
+#endif
+
+#ifndef FALSE
+#define FALSE  0   /* Boolean false value. */
+#endif
+
+#ifndef NULL
+#define NULL  0
+#endif
+
+#ifndef MIN_INT8
+#define MIN_INT8 -128
+#endif
+#ifndef MIN_INT16
+#define MIN_INT16 -32768
+#endif
+#ifndef MIN_INT32
+#define MIN_INT32 (~0x7fffffff)   /* -2147483648 is unsigned */
+#endif
+#ifndef MIN_INT64
+#define MIN_INT64 (~0x7fffffffffffffffLL) /* -9223372036854775808 is unsigned */
+#endif
+
+#ifndef MAX_INT8
+#define MAX_INT8 127
+#endif
+#ifndef MAX_INT16
+#define MAX_INT16 32767
+#endif
+#ifndef MAX_INT32
+#define MAX_INT32 2147483647
+#endif
+#ifndef MAX_INT64
+#define MAX_INT64 9223372036854775807LL
+#endif
+
+#ifndef MAX_UINT8
+#define MAX_UINT8 255
+#endif
+#ifndef MAX_UINT16
+#define MAX_UINT16 65535
+#endif
+#ifndef MAX_UINT32
+#define MAX_UINT32 4294967295u
+#endif
+#ifndef MAX_UINT64
+#define MAX_UINT64 18446744073709551615uLL
+#endif
+
+#ifndef MIN_AECHAR
+#define MIN_AECHAR 0
+#endif
+#ifndef MAX_AECHAR
+#define MAX_AECHAR 65535
+#endif
+
+
+/* -----------------------------------------------------------------------
+** Preprocessor helpers
+** ----------------------------------------------------------------------- */
+#define __STR__(x) #x
+#define __TOSTR__(x) __STR__(x)
+#define __FILE_LINE__ __FILE__ ":" __TOSTR__(__LINE__)
+
+/* -----------------------------------------------------------------------
+** Types for code generated from IDL
+** ----------------------------------------------------------------------- */
+
+#ifndef __QIDL_WCHAR_T_DEFINED__
+#define __QIDL_WCHAR_T_DEFINED__
+typedef uint16 _wchar_t;
+#endif
+
+/* __STRING_OBJECT__ will be deprecated in the future */
+#if !defined(__QIDL_STRING_OBJECT_DEFINED__) && !defined(__STRING_OBJECT__)
+#define __QIDL_STRING_OBJECT_DEFINED__
+#define __STRING_OBJECT__
+typedef struct _cstring_s {
+   char* data;
+   int dataLen;
+   int dataLenReq;
+} _cstring_t;
+
+typedef struct _wstring_s {
+   _wchar_t* data;
+   int dataLen;
+   int dataLenReq;
+} _wstring_t;
+#endif /* __QIDL_STRING_OBJECT_DEFINED__ */
+
+/*
+=======================================================================
+  DATA STRUCTURES DOCUMENTATION
+=======================================================================
+
+boolean
+
+Description:
+    This type is used to express boolean values (TRUE or FALSE).
+
+Definition:
+    typedef  unsigned char boolean
+
+See Also:
+   byte
+   int8
+   int16
+   int32
+   int64
+   uint32
+   uint16
+   uint8
+   uint64
+
+=======================================================================
+
+uint32
+
+Description:
+    This is a 32-bit unsigned integer.
+
+Definition:
+    typedef  uint32_t uint32
+
+See Also:
+   boolean
+   byte
+   int8
+   int16
+   int32
+   int64
+   uint8
+   uint16
+   uint64
+
+=======================================================================
+
+uint16
+
+Description:
+    This is a 16-bit unsigned integer.
+
+Definition:
+    typedef  unsigned short     uint16
+
+See Also:
+   boolean
+   byte
+   int8
+   int16
+   int32
+   int64
+   uint8
+   uint32
+   uint64
+
+=======================================================================
+
+uint8
+
+Description:
+    This is an 8-bit unsigned integer.
+
+Definition:
+    typedef  unsigned char      uint8
+
+See Also:
+   boolean
+   byte
+   int8
+   int16
+   int32
+   int64
+   uint16
+   uint32
+   uint64
+
+=======================================================================
+
+int32
+
+Description:
+    This is a 32-bit signed integer.
+
+Definition:
+    typedef  int32_t int32
+
+See Also:
+   boolean
+   byte
+   int8
+   int16
+   int64
+   uint8
+   uint16
+   uint32
+   uint64
+
+=======================================================================
+
+int16
+
+Description:
+    This is a 16-bit signed integer.
+
+Definition:
+    typedef  signed short       int16
+
+See Also:
+   boolean
+   byte
+   int8
+   int32
+   int64
+   uint8
+   uint16
+   uint32
+   uint64
+
+=======================================================================
+
+int8
+
+Description:
+    This is an 8-bit signed integer.
+
+Definition:
+    typedef  signed char        int8
+
+See Also:
+   boolean
+   byte
+   int16
+   int32
+   int64
+   uint8
+   uint16
+   uint32
+   uint64
+
+=======================================================================
+
+uint64
+
+Description:
+    This is a 64-bit unsigned integer.
+
+Definition:
+    typedef  unsigned __int64   uint64
+
+See Also:
+   boolean
+   byte
+   int8
+   int16
+   int32
+   int64
+   uint8
+   uint16
+   uint32
+
+=======================================================================
+
+int64
+
+Description:
+    This is a 64-bit signed integer.
+
+Definition:
+    typedef  __int64            int64
+
+See Also:
+   boolean
+   byte
+   int8
+   int16
+   int32
+   uint8
+   uint16
+   uint32
+   uint64
+
+=======================================================================
+
+byte
+
+Description:
+    This is a byte.
+
+Definition:
+    typedef  unsigned char     byte
+
+See Also:
+   boolean
+   int8
+   int16
+   int32
+   int64
+   uint8
+   uint16
+   uint32
+   uint64
+
+=======================================================================
+
+AEEUID
+
+Description:
+   This is a BREW unique ID.  Used to express unique types, interfaces, classes
+     groups and privileges.  The BREW ClassID Generator generates
+     unique IDs that can be used anywhere you need a new AEEIID, AEECLSID,
+     or AEEPRIVID.
+
+Definition:
+    typedef uint32             AEEUID
+
+See Also:
+   AECHAR
+   AEECLSID
+   AEEIID
+   AEEPRIVID
+   AEEResult
+
+=======================================================================
+
+AEEIID
+
+Description:
+   This is an interface ID type, used to denote a BREW interface. It is a special case
+     of AEEUID.
+
+Definition:
+    typedef uint32             AEEIID
+
+See Also:
+   AECHAR
+   AEECLSID
+   AEEPRIVID
+   AEEResult
+   AEEUID
+
+=======================================================================
+
+AEECLSID
+
+Description:
+   This is a classe ID type, used to denote a BREW class. It is a special case
+     of AEEUID.
+
+Definition:
+    typedef uint32             AEECLSID
+
+See Also:
+   AECHAR
+   AEECLSIDs
+   AEEIID
+   AEEPRIVID
+   AEEResult
+   AEEUID
+
+=======================================================================
+
+AEEPRIVID
+
+Description:
+   This is a privilege ID type, used to express a privilege.  It is a special case
+     of AEEUID.
+
+Definition:
+    typedef uint32             AEEPRIVID
+
+See Also:
+   AECHAR
+   AEECLSID
+   AEEIID
+   AEEResult
+   AEEUID
+
+=======================================================================
+
+AECHAR
+
+Description:
+   This is a 16-bit character type.
+
+Definition:
+   typedef uint16             AECHAR
+
+See Also:
+   AEEPRIVID
+   AEECLSID
+   AEEIID
+   AEEResult
+   AEEUID
+
+=======================================================================
+
+AEEResult
+
+Description:
+   This is the standard result type.
+
+Definition:
+   typedef int                AEEResult
+
+See Also:
+   AECHAR
+   AEEPRIVID
+   AEECLSID
+   AEEIID
+   AEEUID
+
+=======================================================================
+
+_wchar_t
+
+Description:
+   This is a 16-bit character type corresponding to the IDL 'wchar'
+   type.
+
+Definition:
+   typedef uint16             _wchar_t
+
+See Also:
+   _cstring_t
+   _wstring_t
+
+=======================================================================
+
+_cstring_t
+
+Description:
+   This structure is used to represent an IDL string when used inside a
+   sequence or union.
+
+Definition:
+   typedef struct _cstring_s {
+      char* data;
+      int dataLen;
+      int dataLenReq;
+   } _cstring_t;
+
+Members:
+   data       : A pointer to the NULL-terminated string.
+   dataLen    : The size, in chars, of the buffer pointed to by 'data',
+                including the NULL terminator.  This member is only used
+                when the structure is part of an rout or inrout
+                parameter, but must be supplied by the caller as an
+                input in these cases.
+   dataLenReq : The size that would have been required to store the
+                entire result string.  This member is only used when the
+                structure is part of an rout or inrout parameter, when
+                it is an output value set by the callee.  The length of
+                the returned string (including the NULL terminator)
+                after a call is the minimum of dataLen and dataLenReq.
+
+See Also:
+   _wchar_t
+   _wstring_t
+
+=======================================================================
+
+_wstring_t
+
+Description:
+   This structure is used to represent an IDL wstring when used inside a
+   sequence or union.
+
+Definition:
+   typedef struct _wstring_s {
+      _wchar_t* data;
+      int dataLen;
+      int dataLenReq;
+   } _wstring_t;
+
+Members:
+   data       : A pointer to the NULL-terminated wide string.
+   dataLen    : The size, in 16-bit characters, of the buffer pointed to
+                by 'data', including the NULL terminator.  This member
+                is only used when the structure is part of an rout or
+                inrout parameter, but must be supplied by the caller as
+                an input in these cases.
+   dataLenReq : The number of 16-bit characters that would have been
+                required to store the entire result string.  This member
+                is only used when the structure is part of an rout or
+                inrout parameter, when it is an output value set by the
+                callee.  The length of the returned wstring (including
+                the NULL terminator) after a call is the minimum of
+                dataLen and dataLenReq.
+
+See Also:
+   _cstring_t
+   _wchar_t
+
+=======================================================================
+CONSTANTS DOCUMENTATION
+=======================================================================
+
+TRUE
+
+Description:
+   TRUE is the boolean "true."
+
+Definition:
+
+   #define TRUE    1
+
+See Also:
+   FALSE
+   NULL
+
+=======================================================================
+
+FALSE
+
+Description:
+   FALSE is the boolean "false."
+
+Definition:
+
+   #define FALSE   0
+
+See Also:
+   NULL
+   TRUE
+
+=======================================================================
+
+NULL
+
+Description:
+   NULL is the null value, usually used to test a pointer.
+
+Definition:
+
+   #define NULL   0
+
+See Also:
+   FALSE
+   TRUE
+
+=======================================================================
+
+MIN_INT8
+
+Description:
+  MIN_INT8 is the minimum signed 8-bit integer value.
+
+Definition:
+
+   #define MIN_INT8  -128
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MIN_INT16
+
+Description:
+  MIN_INT16 is the minimum signed 16-bit integer value
+
+Definition:
+
+   #define MIN_INT16  -32768
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MIN_INT32
+
+Description:
+   MIN_INT32 is the minimum signed 32-bit integer value.
+
+Definition:
+
+   #define MIN_INT32 (~0x7fffffff)
+
+Comments:
+    Brew MP uses (~0x7fffffff), because -2147483648 is treated as unsigned by compilers.
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT64
+
+=======================================================================
+
+MIN_INT64
+
+Description:
+   MIN_INT64 is the minimum signed 64-bit integer value.
+
+Definition:
+
+   #define MIN_INT64 (~0x7fffffffffffffffll)
+
+Comments:
+    Brew MP uses (~0x7fffffffffffffffll), because -9223372036854775808 is
+       treated as unsigned by compilers.
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+
+=======================================================================
+
+MAX_INT8
+
+Description:
+   MAX_INT8 is the maximum signed 8-bit integer value
+
+Definition:
+
+   #define MAX_INT8  127
+
+See Also:
+   MAX_AECHAR
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_INT16
+
+Description:
+   MAX_INT16 is the maximum signed 16-bit integer value.
+
+Definition:
+
+   #define MAX_INT16  32767
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_INT32
+
+Description:
+   MAX_INT32 is the maximum signed 32-bit integer value.
+
+Definition:
+
+   #define MAX_INT32  2147483647
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_INT64
+
+Description:
+   MAX_INT64 is the maximum signed 64-bit integer value.
+
+Definition:
+
+   #define MAX_INT64  9223372036854775807ll
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_UINT8
+
+Description:
+   MAX_UINT8 is the maximum unsigned 8-bit integer value.
+
+Definition:
+
+   #define MAX_UINT8  255
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_UINT16
+
+Description:
+   MAX_UINT16 is the maximum unsigned 16-bit integer value.
+
+Definition:
+
+   #define MAX_UINT16  65535
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT32
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_UINT32
+
+Description:
+   MAX_UINT32 is the maximum unsigned 32-bit integer value.
+
+Definition:
+
+   #define MAX_UINT32  4294967295u
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT64
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_UINT64
+
+Description:
+   MAX_UINT64 is the maximum unsigned 64-bit integer value.
+
+Definition:
+
+   #define MAX_UINT64  18446744073709551615ull
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MIN_AECHAR
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MIN_AECHAR
+
+Description:
+  MIN_AECHAR is the minimum AECHAR value.
+
+Definition:
+
+   #define MIN_AECHAR  0
+
+See Also:
+   MAX_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+
+MAX_AECHAR
+
+Description:
+  MAX_AECHAR is the maximum AECHAR value.
+
+Definition:
+
+   #define MAX_AECHAR  65535
+
+See Also:
+   MIN_AECHAR
+   MAX_INT8
+   MAX_INT16
+   MAX_INT32
+   MAX_INT64
+   MAX_UINT8
+   MAX_UINT16
+   MAX_UINT32
+   MAX_UINT64
+   MIN_INT8
+   MIN_INT16
+   MIN_INT32
+   MIN_INT64
+
+=======================================================================
+MACROS DOCUMENTATION
+=======================================================================
+
+__STR__()
+
+Description:
+   The __STR__() makes a token into a string, used to string-ize things already
+      defined.
+
+Definition:
+
+   #define __STR__(x)  #x
+
+Parameters:
+    x: token to make into a string
+
+See Also:
+   __TOSTR__()
+   __FILE_LINE__
+
+=======================================================================
+
+__TOSTR__()
+
+Description:
+   The __TOSTR__() makes a token's value into a string, used to string-ize things
+    already defined, used with __STR__.
+
+Definition:
+
+   #define __TOSTR__(x)  __STR__(x)
+
+Parameters:
+    x: token to evaluate and string-ize
+
+Evaluation Value:
+    the token's replacement as a string
+
+See Also:
+   __FILE_LINE__
+   __STR__()
+
+=======================================================================
+
+__FILE_LINE__
+
+Description:
+   The compiler's __FILE__ (a string) and __LINE__ (an integer) are pasted
+     together as a single string with a ":" between.
+
+Definition:
+
+   #define __FILE_LINE__ __FILE__ ":"  __TOSTR__(__LINE__)
+
+Evaluation Value:
+   __FILE__":""__LINE__"
+
+See Also:
+   __STR__()
+   __TOSTR__()
+
+=======================================================================
+*/
+
+#endif /* #ifndef AEESTDDEF_H */
+
diff --git a/inc/AEEStdErr.h b/inc/AEEStdErr.h
new file mode 100644
index 0000000..638410d
--- /dev/null
+++ b/inc/AEEStdErr.h
@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AEESTDERR_H
+#define AEESTDERR_H
+
+//
+// Basic Error Codes
+//
+//
+#define AEE_SUCCESS              0  			///< No error
+#define AEE_EUNKNOWN		 -1   			/// Unknown error (should not use this)
+#define AEE_EOFFSET		 0x00000000
+#define AEE_EFAILED              (AEE_EOFFSET + 0x001)  ///< General failure
+#define AEE_ENOMEMORY            (AEE_EOFFSET + 0x002)  ///< Insufficient RAM
+#define AEE_ECLASSNOTSUPPORT     (AEE_EOFFSET + 0x003)  ///< Specified class unsupported
+#define AEE_EVERSIONNOTSUPPORT   (AEE_EOFFSET + 0x004)  ///< Version not supported
+#define AEE_EALREADYLOADED       (AEE_EOFFSET + 0x005)  ///< Object already loaded
+#define AEE_EUNABLETOLOAD        (AEE_EOFFSET + 0x006)  ///< Unable to load object/applet
+#define AEE_EUNABLETOUNLOAD      (AEE_EOFFSET + 0x007)  ///< Unable to unload
+							///< object/applet
+#define AEE_EALARMPENDING        (AEE_EOFFSET + 0x008)  ///< Alarm is pending
+#define AEE_EINVALIDTIME         (AEE_EOFFSET + 0x009)  ///< Invalid time
+#define AEE_EBADCLASS            (AEE_EOFFSET + 0x00A)  ///< NULL class object
+#define AEE_EBADMETRIC           (AEE_EOFFSET + 0x00B)  ///< Invalid metric specified
+#define AEE_EEXPIRED             (AEE_EOFFSET + 0x00C)  ///< App/Component Expired
+#define AEE_EBADSTATE            (AEE_EOFFSET + 0x00D)  ///< Invalid state
+#define AEE_EBADPARM             (AEE_EOFFSET + 0x00E)  ///< Invalid parameter
+#define AEE_ESCHEMENOTSUPPORTED  (AEE_EOFFSET + 0x00F)  ///< Invalid URL scheme
+#define AEE_EBADITEM             (AEE_EOFFSET + 0x010)  ///< Invalid item
+#define AEE_EINVALIDFORMAT       (AEE_EOFFSET + 0x011)  ///< Invalid format
+#define AEE_EINCOMPLETEITEM      (AEE_EOFFSET + 0x012)  ///< Incomplete item
+#define AEE_ENOPERSISTMEMORY     (AEE_EOFFSET + 0x013)  ///< Insufficient flash
+#define AEE_EUNSUPPORTED         (AEE_EOFFSET + 0x014)  ///< API is not supported
+#define AEE_EPRIVLEVEL           (AEE_EOFFSET + 0x015)  ///< Privileges are insufficient
+						        ///< for this operation
+#define AEE_ERESOURCENOTFOUND    (AEE_EOFFSET + 0x016)  ///< Unable to find specified
+							///< resource
+#define AEE_EREENTERED           (AEE_EOFFSET + 0x017)  ///< Non re-entrant API
+							///< re-entered
+#define AEE_EBADTASK             (AEE_EOFFSET + 0x018)  ///< API called in wrong task
+							///< context
+#define AEE_EALLOCATED           (AEE_EOFFSET + 0x019)  ///< App/Module left memory
+							///< allocated when released.
+#define AEE_EALREADY             (AEE_EOFFSET + 0x01A)  ///< Operation is already in
+							///< progress
+#define AEE_EADSAUTHBAD          (AEE_EOFFSET + 0x01B)  ///< ADS mutual authorization
+							///< failed
+#define AEE_ENEEDSERVICEPROG     (AEE_EOFFSET + 0x01C)  ///< Need service programming
+#define AEE_EMEMPTR              (AEE_EOFFSET + 0x01D)  ///< bad memory pointer
+#define AEE_EHEAP                (AEE_EOFFSET + 0x01E)  ///< heap corruption
+#define AEE_EIDLE                (AEE_EOFFSET + 0x01F)  ///< Context (system, interface,
+							///< etc.) is idle
+#define AEE_EITEMBUSY            (AEE_EOFFSET + 0x020)  ///< Context (system, interface,
+							///< etc.) is busy
+#define AEE_EBADSID              (AEE_EOFFSET + 0x021)  ///< Invalid subscriber ID
+#define AEE_ENOTYPE              (AEE_EOFFSET + 0x022)  ///< No type detected/found
+#define AEE_ENEEDMORE            (AEE_EOFFSET + 0x023)  ///< Need more data/info
+#define AEE_EADSCAPS             (AEE_EOFFSET + 0x024)  ///< ADS Capabilities do not
+							///< match those required for
+							///< phone
+#define AEE_EBADSHUTDOWN         (AEE_EOFFSET + 0x025)  ///< App failed to close properly
+#define AEE_EBUFFERTOOSMALL      (AEE_EOFFSET + 0x026)  ///< Destination buffer given is
+							///< too small
+#define AEE_ENOSUCH              (AEE_EOFFSET + 0x027)  ///< No such name, port, socket
+							///< or service exists or is
+							///< valid
+#define AEE_EACKPENDING          (AEE_EOFFSET + 0x028)  ///< ACK pending on application
+#define AEE_ENOTOWNER            (AEE_EOFFSET + 0x029)  ///< Not an owner authorized to
+							///< perform the operation
+#define AEE_EINVALIDITEM         (AEE_EOFFSET + 0x02A)  ///< Current item is invalid
+#define AEE_ENOTALLOWED          (AEE_EOFFSET + 0x02B)  ///< Not allowed to perform the
+							///< operation
+#define AEE_EBADHANDLE           (AEE_EOFFSET + 0x02C)  ///< Invalid handle
+#define AEE_EOUTOFHANDLES        (AEE_EOFFSET + 0x02D)  ///< Out of handles
+#define AEE_EINTERRUPTED         (AEE_EOFFSET + 0x02E)  ///< Waitable call is interrupted
+#define AEE_ENOMORE              (AEE_EOFFSET + 0x02F)  ///< No more items available --
+							///< reached end
+#define AEE_ECPUEXCEPTION        (AEE_EOFFSET + 0x030)  ///< A CPU exception occurred
+#define AEE_EREADONLY            (AEE_EOFFSET + 0x031)  ///< Cannot change read-only
+							///< object or parameter
+
+#define AEE_ECONNRESET           104 			///< Connection reset by peer
+#define AEE_EWOULDBLOCK          516 			///< Operation would block if not
+							///< non-blocking; wait and try
+							///< again
+
+//Error code for sigverify
+#define AEE_EUNSIGNEDMOD	     4096 				   /// 0x1000 test-sig not found, Unsigned shared object
+#define AEE_EINVALIDHASH	     8192 				   /// 0x2000 test-sig not found, Invalid hash object
+
+#define AEE_EINVALIDMSG		     (AEE_EOFFSET + 0x032)   /// Invalid SMD message from APPS
+#define AEE_EINVALIDTHREAD	     (AEE_EOFFSET + 0x033)   /// Invalid thread
+#define AEE_EINVALIDPROCESS	     (AEE_EOFFSET + 0x034)   /// Invalid Process
+#define AEE_EINVALIDFILENAME     (AEE_EOFFSET + 0x035)   /// Invalid filename
+#define AEE_EINVALIDDIGESTSIZE   (AEE_EOFFSET + 0x036)   /// Invalid digest size
+#define AEE_EINVALIDSEGS	     (AEE_EOFFSET + 0x037)   /// Invalid segments
+#define AEE_EINVALIDSIGNATURE    (AEE_EOFFSET + 0x038)   /// Invalid signature
+#define AEE_EINVALIDDOMAIN       (AEE_EOFFSET + 0x039)   /// Invalid domain
+#define AEE_EINVALIDFD           (AEE_EOFFSET + 0x03A)   /// Invalid file descriptor
+#define AEE_EINVALIDDEVICE       (AEE_EOFFSET + 0x03B)   /// Invalid Device
+#define AEE_EINVALIDMODE         (AEE_EOFFSET + 0x03C)   /// Invalid Mode
+#define AEE_EINVALIDPROCNAME     (AEE_EOFFSET + 0x03D)   /// Invalid Process name
+#define AEE_ENOSUCHMOD		     (AEE_EOFFSET + 0x03E)   /// No such module
+#define AEE_ENOSUCHINSTANCE	     (AEE_EOFFSET + 0x03F)   /// No instance in the list lookup
+#define AEE_ENOSUCHTHREAD	     (AEE_EOFFSET + 0x040)   /// No such thread
+#define AEE_ENOSUCHPROCESS	     (AEE_EOFFSET + 0x041)   /// No such process
+#define AEE_ENOSUCHSYMBOL	     (AEE_EOFFSET + 0x042)   /// No such symbol
+#define AEE_ENOSUCHDEVICE	     (AEE_EOFFSET + 0x043)   /// No such device
+#define AEE_ENOSUCHPROP	         (AEE_EOFFSET + 0x044)   /// No such dal property
+#define AEE_ENOSUCHFILE		     (AEE_EOFFSET + 0x045)   /// No such file
+#define AEE_ENOSUCHHANDLE	     (AEE_EOFFSET + 0x046)   /// No such handle
+#define AEE_ENOSUCHSTREAM        (AEE_EOFFSET + 0x047)   /// No such stream
+#define AEE_ENOSUCHMAP           (AEE_EOFFSET + 0x048)   /// No such Map
+#define AEE_ENOSUCHREGISTER	     (AEE_EOFFSET + 0x049)   /// No such register
+#define AEE_ENOSUCHCLIENT	     (AEE_EOFFSET + 0x04A)   /// No such QDI client
+#define AEE_EBADDOMAIN           (AEE_EOFFSET + 0x04B)   /// Bad domain (not initialized)
+#define AEE_EBADOFFSET		     (AEE_EOFFSET + 0x04C)   /// Bad buffer/page/heap offset
+#define AEE_EBADSIZE		     (AEE_EOFFSET + 0x04D)   /// Bad buffer/page/heap size
+#define AEE_EBADPERMS		     (AEE_EOFFSET + 0x04E)   /// Bad FILE/MAP/MEM permissions
+#define AEE_EBADFD			     (AEE_EOFFSET + 0x04F)   /// Bad file descriptor
+#define AEE_EBADPID			     (AEE_EOFFSET + 0x050)   /// Bad PID from HLOS
+#define AEE_EBADTID			     (AEE_EOFFSET + 0x051)   /// Bad TID
+#define AEE_EBADELF			     (AEE_EOFFSET + 0x052)   /// Bad elf file
+#define AEE_EBADASID		     (AEE_EOFFSET + 0x053)   /// Bad asid
+#define AEE_EBADCONTEXT		     (AEE_EOFFSET + 0x054)   /// Bad context
+#define AEE_EBADMEMALIGN	     (AEE_EOFFSET + 0x055)   /// Bad memory alignment
+#define AEE_EIOCTL               (AEE_EOFFSET + 0x056)   /// ioctl error
+#define AEE_EFOPEN               (AEE_EOFFSET + 0x057)   /// file open error
+#define AEE_EFGETS               (AEE_EOFFSET + 0x058)   /// file get string error
+#define AEE_EFFLUSH              (AEE_EOFFSET + 0x059)   /// file flush error
+#define AEE_EFCLOSE              (AEE_EOFFSET + 0x05A)   /// file close error
+#define AEE_EEOF		 	     (AEE_EOFFSET + 0x05B)   /// File EOF reached
+#define AEE_EFREAD               (AEE_EOFFSET + 0x05C)   /// file read failed
+#define AEE_EFWRITE              (AEE_EOFFSET + 0x05D)   /// file write failed
+#define AEE_EFGETPOS             (AEE_EOFFSET + 0x05E)   /// file get position failed
+#define AEE_EFSETPOS             (AEE_EOFFSET + 0x05F)   /// file set position failed
+#define AEE_EFTELL               (AEE_EOFFSET + 0x060)   /// file tell position failed
+#define AEE_EFSEEK               (AEE_EOFFSET + 0x061)   /// file seek failed
+#define AEE_EFLEN                (AEE_EOFFSET + 0x062)   /// file len failed
+#define AEE_EGETENV              (AEE_EOFFSET + 0x063)   /// get enviroment failed
+#define AEE_ESETENV              (AEE_EOFFSET + 0x064)   /// set enviroment failed
+#define AEE_EMMAP                (AEE_EOFFSET + 0x065)   /// mmap failed
+#define AEE_EIONMAP              (AEE_EOFFSET + 0x066)   /// ion map failed
+#define AEE_EIONALLOC            (AEE_EOFFSET + 0x067)   /// ion alloc failed
+#define AEE_ENORPCMEMORY         (AEE_EOFFSET + 0x068)   /// ION memory allocation failed
+#define AEE_ENOROOTOFTRUST	 (AEE_EOFFSET + 0x069)   /// No root of trust for sigverify
+#define AEE_ENOTLOCKED		 (AEE_EOFFSET + 0x06A)   /// Unlock failed, not locked before
+#define AEE_ENOTINITIALIZED	 (AEE_EOFFSET + 0x06B)   /// Not initialized
+#define AEE_EUNSUPPORTEDAPI      (AEE_EOFFSET + 0x06C)   /// unsupported API
+#define AEE_EUNPACK		 (AEE_EOFFSET + 0x06D)	 /// unpacking command failed
+#define AEE_EPOLL		 (AEE_EOFFSET + 0x06E)   /// error while polling for event
+#define AEE_EEVENTREAD		 (AEE_EOFFSET + 0x06F)   /// event read failed
+#define AEE_EMAXBUFS		 (AEE_EOFFSET + 0x070)   /// Maximum buffers
+#define AEE_EINVARGS		 (AEE_EOFFSET + 0x071)   /// Invalid Arguments
+
+#define AEE_ESMD_OFFSET		     (AEE_EOFFSET + 0x100)   /// SMD errors offset
+#define AEE_ESMDBADPACKET	     (AEE_EOFFSET + 0x101)   /// SMD invalid packet size
+#define AEE_ESMDALREADYOPEN	     (AEE_EOFFSET + 0x102)   /// SMD port is already open
+#define AEE_ESMDOPENFAILED	     (AEE_EOFFSET + 0x103)   /// SMD port open failed
+
+#define AEE_EDAL_OFFSET		     (AEE_EOFFSET + 0x120)   /// Dal error offset
+#define AEE_EDALDEVATTACH	     (AEE_EOFFSET + 0x121)   /// DAL attach error
+#define AEE_EDALINTREGISTER	     (AEE_EOFFSET + 0x122)   /// DAL interrupt register error
+#define AEE_EDALINTUNREGISTER    (AEE_EOFFSET + 0x123)   /// Dal interrupt unregister error
+#define AEE_EDALGETPROP		     (AEE_EOFFSET + 0x124)   /// Dal get property
+#define AEE_EDALGETVAL		     (AEE_EOFFSET + 0x125)   /// Dal get property value
+
+#define AEE_EQURT_OFFSET	     (AEE_EOFFSET + 0x140)   /// QURT error offset
+#define AEE_EQURTREGIONCREATE    (AEE_EOFFSET + 0x141)   /// QURT region create failed
+#define AEE_EQURTCACHECLEAN	     (AEE_EOFFSET + 0x142)   /// QURT cache clean failed
+#define AEE_EQURTREGIONGETATTR   (AEE_EOFFSET + 0x143)   /// QURT region get attribute failed
+#define AEE_EQURTBADREGIONPERMS  (AEE_EOFFSET + 0x144)   /// QURT bad permissions for region
+#define AEE_EQURTMEMPOOLADD	     (AEE_EOFFSET + 0x145)   /// QURT Add to memory pool failed
+#define AEE_EQURTREGISTERDEV     (AEE_EOFFSET + 0x146)   /// QURT register device failed
+#define AEE_EQURTMEMPOOLCREATE   (AEE_EOFFSET + 0x147)   /// QURT create memory pool failed
+#define AEE_EQURTGETVA		     (AEE_EOFFSET + 0x148)   /// QURT get VA failed
+#define AEE_EQURTREGIONDELETE    (AEE_EOFFSET + 0x149)   /// QURT region delete failed
+#define AEE_EQURTMEMPOOLATTACH   (AEE_EOFFSET + 0x14A)   /// QURT memory pool attach failed
+#define AEE_EQURTTHREADCREATE    (AEE_EOFFSET + 0x14B)   /// QURT thread create failed
+#define AEE_EQURTCOPYTOUSER	     (AEE_EOFFSET + 0x14C)   /// QURT copy to user memory failed
+#define AEE_EQURTMEMMAPCREATE    (AEE_EOFFSET + 0x14D)   /// QURT map create failed
+#define AEE_EQURTINVHANDLE	     (AEE_EOFFSET + 0x14E)   /// QURT Invalid client handle
+#define AEE_EQURTBADASID	     (AEE_EOFFSET + 0x14F)   /// QURT Bad ASIC from QURT
+#define AEE_EQURTOPENFAILED	     (AEE_EOFFSET + 0x150)   /// QURT QDI open failed
+#define AEE_EQURTCOPYFROMUSER    (AEE_EOFFSET + 0x151)   /// QURT Copy from user failed
+#define AEE_EQURTLINELOCK	     (AEE_EOFFSET + 0x152)   /// QURT Line lock failed
+#define AEE_EQURTQDIDEFMETHOD	 (AEE_EOFFSET + 0x153)	 /// QURT QDI default method failed
+
+#define AEE_EMMPM_OFFSET	     (AEE_EOFFSET + 0x170)   /// MMPM errors offset
+#define AEE_EMMPMREQUEST	     (AEE_EOFFSET + 0x171)   /// MMPM Power request to failed
+#define AEE_EMMPMRELEASE	     (AEE_EOFFSET + 0x172)   /// MMPM Release request failed
+#define AEE_EMMPMSETPARAM	     (AEE_EOFFSET + 0x173)   /// MMPM set param request failed
+#define AEE_EMMPMREGISTER	     (AEE_EOFFSET + 0x174)   /// MMPM Register request failed
+#define AEE_EMMPMGETINFO	     (AEE_EOFFSET + 0x175)   /// MMPM Get info failed
+
+
+/*
+============================================================================
+   ERRORS DOCUMENTATION
+==============================================================================
+
+Error Codes
+
+Description:
+This topic lists the categories of error codes that Brew MP returns. The topic for each
+category of error code includes the name of each error, the code that is associated with
+the error, and a description of the error.
+
+===H2>
+List of Error Code Types
+===/H2>
+===p>
+The categories of error codes include: ~
+~
+
+AddrBook error codes  ~
+AddrInfo error codes ~
+AEE_IS_REMOTE_ERR(): ~
+AEE_IS_REMOTE_ERR_PRE(): ~
+Basic AEE Error Codes   ~
+Database error codes  ~
+dbc Error Codes ~
+DNS Resolver error codes ~
+File error codes  ~
+FS AEE Error Codes ~
+ICamera error codes  ~
+ICMP error codes ~
+ILicenseSystem Error Codes ~
+Indeterminate errors: (transport failure) ~
+ISQL Error Codes ~
+ISVGDOM Error Codes: ~
+ISSL error codes  ~
+IX509Chain error codes   ~
+ModCollector Errors  ~
+ModInstallerCntx Errors ~
+ModMover Errors ~
+Multimedia error codes  ~
+Network AEE error codes ~
+Network subsystem error codes ~
+pim_IMessageStore Error Codes ~
+pim_IRecordStore Error Codes ~
+Port AEE Error Codes  ~
+PosDet error codes  ~
+Post-invocation errors: (remote errors) ~
+Pre-invocation errors: (remote errors) ~
+QoS error codes ~
+Remote error codes: ~
+SSL error codes  ~
+VOCODER error codes  ~
+VolumeDB Errors   ~
+Web error codes ~
+
+*
+
+==================================================================
+Basic AEE Error Codes
+
+Description:
+This section lists the set of basic AEE errors returned, the codes associated
+with the errors, and descriptions of the errors.
+
+Definition:
+
+Error                   Code   Description
+
+AEE_SUCCESS             0      operation Successful
+AEE_EFAILED             1      general failure
+AEE_ENOMEMORY           2      insufficient RAM
+AEE_ECLASSNOTSUPPORT    3      specified class unsupported
+AEE_EVERSIONNOTSUPPORT  4      version not supported
+AEE_EALREADYLOADED      5      object already loaded
+AEE_EUNABLETOLOAD       6      unable to load object/applet
+AEE_EUNABLETOUNLOAD     7      unable to unload object/applet
+AEE_EALARMPENDING       8      alarm is pending
+AEE_EINVALIDTIME        9      invalid time
+AEE_EBADCLASS           10     NULL class object
+AEE_EBADMETRIC          11     invalid metric specified
+AEE_EEXPIRED            12     Application/Component Expired
+AEE_EBADSTATE           13     invalid state
+AEE_EBADPARM            14     invalid parameter
+AEE_ESCHEMENOTSUPPORTED 15     invalid URL scheme
+AEE_EBADITEM            16     invalid item
+AEE_EINVALIDFORMAT      17     invalid format
+AEE_EINCOMPLETEITEM     18     incomplete item
+AEE_ENOPERSISTMEMORY    19     insufficient flash
+AEE_EUNSUPPORTED        20     API is not supported
+AEE_EPRIVLEVEL          21     application privileges are insufficient for this operation
+AEE_ERESOURCENOTFOUND   22     unable to find specified resource
+AEE_EREENTERED          23     non re-entrant API re-entered
+AEE_EBADTASK            24     API called in wrong task context
+AEE_EALLOCATED          25     Application/Module left memory allocated when released
+AEE_EALREADY            26     operation is already in progress
+AEE_EADSAUTHBAD         27     ADS mutual authorization failed
+AEE_ENEEDSERVICEPROG    28     need service programming
+AEE_EMEMPTR             29     bad memory pointer
+AEE_EHEAP               30     heap corruption
+AEE_EIDLE               31     context (system, interface, etc.) is idle
+AEE_EITEMBUSY           32     context (system, interface, etc.) is busy
+AEE_EBADSID             33     invalid subscriber ID
+AEE_ENOTYPE             34     no type detected/found
+AEE_ENEEDMORE           35     need more data/info
+AEE_EADSCAPS            36     capabilities do not match those required
+AEE_EBADSHUTDOWN        37     application failed to close properly
+AEE_EBUFFERTOOSMALL     38     destination buffer given is too small
+AEE_ENOSUCH             39     no such name/port/socket/service exists or valid
+AEE_EACKPENDING         40     ACK pending on application
+AEE_ENOTOWNER           41     not an owner authorized to perform the operation
+AEE_EINVALIDITEM        42     current item is invalid
+AEE_ENOTALLOWED         43     not allowed to perform the operation
+AEE_EBADHANDLE          44     invalid handle
+AEE_EOUTOFHANDLES       45     out of handles
+AEE_EINTERRUPTED        46     waitable call is interrupted
+AEE_ENOMORE             47     no more items available -- reached end
+AEE_ECPUEXCEPTION       48     a CPU exception occurred
+AEE_EREADONLY           49     cannot change read-only object or parameter
+AEE_ECONNRESET          104    connection reset by peer
+AEE_EWOULDBLOCK         516    operation would block if not non-blocking; wait and try again
+
+Comments:
+These Brew MP error codes have an up-to-date naming convention, and replace older BREW error
+codes that use a naming convention that did not include the "AEE_" prefix.
+
+See Also:
+  Error Codes
+
+==================================================================
+*/
+#endif /* #ifndef AEESTDERR_H */
+
diff --git a/inc/AEEVaList.h b/inc/AEEVaList.h
new file mode 100644
index 0000000..1ed8476
--- /dev/null
+++ b/inc/AEEVaList.h
@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AEEVALIST_H
+#define AEEVALIST_H
+
+#if !defined(__clang__) && (defined(__ARMCC_VERSION) || (defined(__GNUC__) && defined(__arm__)))
+
+
+
+#if (defined(__ARMCC_VERSION) && __ARMCC_VERSION >= 200000 && !defined(__APCS_ADSABI)) || \
+    (defined(__GNUC__) && defined(__arm__) && defined(__ARM_EABI__))
+
+# define __AEEVA_ATPCS 0
+
+#else
+
+# define __AEEVA_ATPCS 1
+
+#endif
+
+typedef void* AEEVaList;
+
+#define __AEEVA_ARGALIGN(t)   (((char*)(&((struct{char c;t x;}*)1)->x))-((char*)1))
+#define __AEEVA_ARGSIZE(t)    ((sizeof(t)+sizeof(int)-1) & ~(sizeof(int)-1))
+
+static __inline void __cpy(char*d, const char*s, int len)
+{
+   while (len-- > 0) *d++ = *s++;
+}
+
+static __inline AEEVaList __AEEVa_Arg(AEEVaList args, void* pv, int nVSize,
+                                      int nArgSize, int nArgAlign)
+{
+   int   nArgs = (int)args & ~1;
+   char* pcArgs = (char*)args;
+   int   bATPCS = (int)args & 1;
+   int   nArgsOffset = 0;
+   int   nVOffset = 0;
+
+   if (!bATPCS) { /* caller was compiled with AAPCS */
+
+      if (nArgAlign > (int)sizeof(int)) {
+         nArgAlign--; /* make a mask */
+         pcArgs += ((nArgs + nArgAlign) & (int)~(unsigned)nArgAlign) - nArgs;
+         /* move pv to next alignment */
+      }
+   }
+
+#if defined(AEE_BIGENDIAN)
+   if (nArgSize < (int)sizeof(int)) {
+      nArgsOffset = (int)sizeof(int) - nArgSize;
+   }
+   nVOffset = nVSize - nArgSize;
+#else
+   (void)nVSize;
+#endif /* AEE_BIGENDIAN */
+
+   __cpy((char*)pv + nVOffset, (pcArgs - bATPCS) + nArgsOffset, nArgSize);
+
+   /* round up */
+   nArgSize = (nArgSize+(int)sizeof(int)-1) & ~((int)sizeof(int)-1);
+
+   return pcArgs + nArgSize; /* increment va */
+}
+
+#define AEEVA_START(va,v)     ((va) = (char*)&(v) + __AEEVA_ARGSIZE(v) + __AEEVA_ATPCS)
+#define AEEVA_ARG(va,v,t)     ((void)((va) = __AEEVa_Arg(va,&v,sizeof(v),sizeof(t),__AEEVA_ARGALIGN(t))))
+#define AEEVA_END(va)         ((va) = (AEEVaList)0)
+#define AEEVA_COPY(dest, src) ((void)((dest) = (src)))
+
+#else /* !defined(__clang__) && (defined(__ARMCC_VERSION) || (defined(__GNUC__) && defined(__arm__))) */
+
+#include <stdarg.h>
+
+typedef va_list AEEVaList;
+
+#define AEEVA_START(va,v)     (va_start((va), (v)))
+#define AEEVA_ARG(va,v,t)     ((v) = va_arg((va),t))
+#define AEEVA_END(va)         (va_end((va)))
+#define AEEVA_COPY(dest, src) (va_copy((dest),(src)))
+
+#endif/* !defined(__clang__) && (defined(__ARMCC_VERSION) || (defined(__GNUC__) && defined(__arm__))) */
+
+#endif /* #ifndef AEEVALIST_H */
+
diff --git a/inc/AEEatomic.h b/inc/AEEatomic.h
new file mode 100644
index 0000000..c2f28b4
--- /dev/null
+++ b/inc/AEEatomic.h
@@ -0,0 +1,198 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AEEATOMIC_H
+#define AEEATOMIC_H
+/*
+=======================================================================
+
+FILE:         AEEatomic.h
+
+SERVICES:     atomic
+
+DESCRIPTION:  Fast Atomic ops
+
+=======================================================================
+*/
+
+#include "AEEStdDef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* #ifdef __cplusplus */
+
+uint32 atomic_Add(uint32 * volatile puDest, int nAdd);
+uint32 atomic_Exchange(uint32 * volatile puDest, uint32 uVal);
+uint32 atomic_CompareAndExchange(uint32 * volatile puDest, uint32 uExchange, uint32 uCompare);
+uint32 atomic_CompareOrAdd(uint32 * volatile puDest, uint32 uCompare, int nAdd);
+
+uint64 atomic_CompareAndExchange64(uint64 * volatile puDest, uint64 uExchange, uint64 uCompare);
+uintptr_t atomic_CompareAndExchangeUP(uintptr_t * volatile puDest, uintptr_t uExchange, uintptr_t uCompare);
+#ifdef __cplusplus
+}
+#endif /* #ifdef __cplusplus */
+
+/*=====================================================================
+INTERFACE DOCUMENTATION
+=======================================================================
+atomic Interface
+
+  The atomic interface provides fast "atomic" operations.  The
+   operations are defined to be atomic with respect to each other.
+
+=======================================================================
+
+=======================================================================
+
+atomic_Add()
+
+Description:
+
+   Performs an atomic sum operation.
+
+Prototype:
+
+   uint32 atomic_Add(uint32* puDest, int nInc);
+
+Parameters:
+   puDest [in|out] : Points to unsigned number to add nInc and save
+   nInc : increment
+
+Return Value:
+   result.
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+atomic_Exchange()
+
+Description:
+
+   Atomic exchange of 32bit value. Performs an atomic operation of :
+      write uVal to *puDest
+      return the previous value in *puDest
+
+Prototype:
+
+   uint32 atomic_Exchange(uint32* puDest, uint32 uVal);
+
+Parameters:
+   puDest [in|out] : Points to unsigned number to be exchanged
+   uVal : new value to write.
+
+Return Value:
+   previous value at *puDest.
+
+Comments:
+   None
+
+Side Effects:
+   May cause exception if puDest is not a 32 bit aligned address.
+
+See Also:
+   None
+=======================================================================
+
+atomic_CompareAndExchange()
+
+Description:
+
+   Performs an atomic operation of :
+      if (*puDest == uCompare) {
+         *puDest = uExchange;
+      }
+
+   returns the previous value in *puDest
+
+Prototype:
+
+   uint32 atomic_CompareAndExchange(uint32 *puDest, uint32 uExchange,
+                                    uint32 uCompare);
+
+Parameters:
+   puDest [in|out] : Points to unsigned number.
+   uExchange : A new value to write to *puDest
+   uCompare : Comparand
+
+Return Value:
+   previous value at *puDest.
+
+Comments:
+   None
+
+Side Effects:
+   May cause exception if puDest is not a 32 bit aligned address.
+
+See Also:
+   None
+
+=======================================================================
+atomic_CompareOrAdd()
+
+Description:
+
+   Performs an atomic operation of :
+      if (*puDest != uCompare) {
+         *puDest += nAdd;
+      }
+
+   returns the new value in *puDest
+
+Prototype:
+
+   uint32 atomic_CompareOrAdd(uint32 *puDest, uint32 uCompare, int nAdd);
+
+Parameters:
+   puDest [in|out] : Points to unsigned number.
+   uCompare : Comparand
+   nAdd : Add to *puDest
+
+Return Value:
+   new value at *puDest.
+
+Comments:
+   None
+
+Side Effects:
+   May cause exception if puDest is not a 32 bit aligned address.
+
+See Also:
+   None
+=======================================================================*/
+
+#endif /* #ifndef AEEATOMIC_H */
+
diff --git a/inc/AEEstd.h b/inc/AEEstd.h
new file mode 100644
index 0000000..2c832e6
--- /dev/null
+++ b/inc/AEEstd.h
@@ -0,0 +1,2681 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef AEESTD_H
+#define AEESTD_H
+/*====================================================================
+
+DESCRIPTION:  Standard library; general-purpose utility functions.
+
+====================================================================*/
+#include "AEEVaList.h"
+#include "AEEStdDef.h"
+#include "string.h"
+
+#define STD_CONSTRAIN( val, min, max ) (((val) < (min)) ? (min) : ((val) > (max)) ? (max) : (val))
+#define STD_BETWEEN( val, minGE, maxLT ) \
+                   ( (unsigned long)((unsigned long)(val) - (unsigned long)(minGE)) < \
+                   (unsigned long)((unsigned long)(maxLT) - (unsigned long)(minGE)) )
+#define STD_ARRAY_SIZE(a)             ((int)((sizeof((a))/sizeof((a)[0]))))
+#define STD_ARRAY_MEMBER(p,a) (((p) >= (a)) && ((p) < ((a) + STD_ARRAY_SIZE(a))))
+
+#define STD_SIZEOF(x)                 ((int)sizeof(x))
+#define STD_OFFSETOF(type,member)     (((char*)(&((type*)1)->member))-((char*)1))
+
+#define STD_RECOVER_REC(type,member,p) ((void)((p)-&(((type*)1)->member)),\
+                                        (type*)(void*)(((char*)(void*)(p))-STD_OFFSETOF(type,member)))
+#define STD_MIN(a,b)   ((a)<(b)?(a):(b))
+#define STD_MAX(a,b)   ((a)>(b)?(a):(b))
+//lint -emacro(545,STD_ZEROAT)
+#define STD_ZEROAT(p)  std_memset((p), 0, sizeof(*p))
+
+#define _STD_BITS_PER(bits)     (8*sizeof((bits)[0]))
+
+#define STD_BIT_SET(bits, ix)     ((bits)[(ix)/_STD_BITS_PER((bits))] |= 0x1<<((ix) & (_STD_BITS_PER((bits))-1)))
+#define STD_BIT_CLEAR(bits, ix)   ((bits)[(ix)/_STD_BITS_PER((bits))] &= ~(0x1<<((ix) & (_STD_BITS_PER((bits))-1))))
+#define STD_BIT_TEST(bits, ix)    ((bits)[(ix)/_STD_BITS_PER((bits))] & (0x1<<((ix) & (_STD_BITS_PER((bits))-1))))
+
+//
+// Error codes
+//
+#define STD_NODIGITS   1
+#define STD_NEGATIVE   2
+#define STD_OVERFLOW   3
+#define STD_BADPARAM   4
+#define STD_UNDERFLOW  5
+
+//Compute string length using strlen
+#define std_strlen strlen
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* #ifdef __cplusplus */
+
+//Version function
+extern int           std_getversion(char *pcDst, int nDestSize);
+
+//String functions
+extern int           std_strcmp(const char *s1, const char *s2);
+extern int           std_strncmp(const char *s1, const char *s2, int n);
+extern int           std_stricmp(const char *s1, const char *s2);
+extern int           std_strnicmp(const char *s1, const char *s2, int n);
+extern int           std_strlcpy(char *pcDst, const char *pszSrc, int nDestSize);
+extern int           std_strlcat(char *pcDst, const char *pszSrc, int nDestSize);
+extern char *        std_strstr(const char *pszString, const char *pszSearch);
+
+//Character functions
+extern char          std_tolower(char c);
+extern char          std_toupper(char c);
+
+// Mem functions
+extern void *        std_memset(void *p, int c, int nLen);
+extern void *        std_memmove(void *pTo, const void *cpFrom, int nLen);
+extern int           std_memscpy(void *dst, int dst_size, const void *src, int src_size);
+extern int           std_memsmove(void *dst, int dst_size, const void *src, int src_size);
+extern int           std_memcmp(const void *a, const void *b, int length);
+extern void *        std_memchr(const void* s, int c, int n);
+extern void *        std_memstr(const char* cpHaystack, const char* cpszNeedle, int nHaystackLen);
+extern void *        std_memrchr(const void* s, int c, int n);
+extern void *        std_memrchrbegin(const void* p, int c, int nLen);
+extern void *        std_memchrend(const void* cpcSrch, int c, int nLen);
+extern void *        std_memchrsend(const void *cpSrch, const char* cpszChars, int nLen);
+
+//Other String functions
+extern char *        std_strchr(const char* s, int c);
+extern char *        std_strchrs(const char* sSrch, const char *sChars);
+extern char *        std_strrchr(const char* s, int c);
+extern char *        std_strchrend(const char *cpszSrch, char c);
+extern char *        std_strchrsend(const char* s, const char* cpszSrch);
+extern char *        std_strends(const char* cpsz, const char* cpszSuffix);
+extern char *        std_striends(const char* cpsz, const char* cpszSuffix);
+extern char *        std_strbegins(const char* cpsz, const char* cpszPrefix);
+extern char *        std_stribegins(const char* cpsz, const char* cpszPrefix);
+extern int           std_strcspn(const char* s, const char* cpszSrch);
+extern int           std_strspn(const char* s, const char* cpszSrch);
+
+//Wide char string functions
+extern int           std_wstrlen(const AECHAR *s);
+extern int           std_wstrlcpy(AECHAR *pcDst, const AECHAR *pszSrc, int nDestSize);
+extern int           std_wstrlcat(AECHAR *pcDst, const AECHAR *pszSrc, int nDestSize);
+extern int           std_wstrncmp(const AECHAR* s1, const AECHAR* s2, int nLen);
+extern int           std_wstrcmp(const AECHAR* s1, const AECHAR* s2);
+extern AECHAR*       std_wstrchr(const AECHAR* cpwszText, AECHAR ch);
+extern AECHAR*       std_wstrrchr(const AECHAR* cpwszText, AECHAR ch);
+
+//Path functions
+extern int           std_makepath(const char *cpszDir,
+                                  const char *cpszFile,
+                                  char *pszDest, int nDestSize);
+extern char *        std_splitpath(const char *cpszPath, const char *cpszDir);
+extern char *        std_cleanpath(char *pszPath);
+extern char *        std_basename(const char *pszPath);
+
+//Inet functions, number functions
+extern unsigned int        std_scanul(const char *pchBuf, int nRadix,
+                                const char **ppchEnd, int *pnError);
+extern uint64        std_scanull(const char *pchBuf, int nRadix,
+                                 const char **ppchEnd, int *pnError);
+extern double        std_scand(const char *pchBuf, const char **ppchEnd);
+
+// Rand functions
+extern unsigned      std_rand_next(unsigned uRand);
+extern uint32        std_rand(uint32 uSeed, byte* pDest, int nSize);
+
+
+// printf functions
+extern int           std_vstrlprintf(char *pszDest, int nDestSize,
+                                     const char *pszFmt, AEEVaList args);
+
+extern int           std_strlprintf(char *pszDest, int nDestSize,
+                                    const char *pszFmt, ...);
+
+extern int           std_vsnprintf(char *pszDest, int nDestSize,
+                                   const char *cpszFmt, AEEVaList args);
+
+extern int           std_snprintf(char *pszDest, int nDestSize,
+                                  const char *pszFmt, ...);
+
+// endian swapping functions
+extern int           std_CopyLE(void *pvDest,       int nDestSize,
+                                const void *pvSrc,  int nSrcSize,
+                                const char *pszFields);
+
+extern int           std_CopyBE(void *pvDest,      int nDestSize,
+                                const void *pvSrc, int nSrcSize,
+                                const char *pszFields);
+
+// sorting utilities
+extern void  std_qsort(void* pElems, int nNumElems, int nElemWidth,
+                       int (*pfnCompare)(void*, const void*, const void*),
+                       void* pCompareCx);
+
+extern int   std_bisect(const void* pElems, int nNumElems, int nElemWidth,
+                        const void* pElem,
+                        int (*pfnCompare)(void*, const void*, const void*),
+                        void* pCompareCx);
+
+extern void  std_merge(void* vpDst, int nDst,
+                       const void* vpA, int nA,
+                       const void* vpB, int nB,
+                       int nElemWidth,
+                       int (*pfnCompare)(void*, const void*, const void*),
+                       void* pCompareCx);
+
+extern int   std_uniq(void* vpElems, int nNumElems, int nElemWidth,
+                      int (*pfnCompare)(void*, const void*, const void*),
+                      void* pCompareCx);
+
+#ifdef __cplusplus
+}
+#endif /* #ifdef __cplusplus */
+
+
+#define STD_SWAPS(us) \
+   ((((us) & 0xff) << 8) + (((us) & 0xff00) >> 8))
+
+
+static __inline unsigned short std_swaps(unsigned short us)
+{
+   return STD_SWAPS(us);
+}
+
+/* note, STD_SWAPL() requires that ul be an l-value, and destroyable.
+   this macro is not intended for use outside AEEstd.h */
+#define STD_SWAPL(ul) \
+    (((ul) = (((ul) & 0x00ff00ff) << 8) | (((ul)>>8) & 0x00ff00ff)),(((ul) >> 16) | ((ul) << 16)))
+
+static __inline unsigned long std_swapl(unsigned long ul)
+{
+   return STD_SWAPL(ul);
+}
+
+#ifdef AEE_BIGENDIAN
+#  define STD_HTONL(u)     (u)
+#  define STD_HTONS(u)     (u)
+#  define STD_HTOLEL(u)    (STD_SWAPL(u))
+#  define STD_HTOLES(u)    (STD_SWAPS(u))
+#else
+#  define STD_HTONL(u)     (STD_SWAPL(u))
+#  define STD_HTONS(u)     (STD_SWAPS(u))
+#  define STD_HTOLEL(u)    (u)
+#  define STD_HTOLES(u)    (u)
+#endif
+
+static __inline unsigned short std_letohs(unsigned short us)
+{
+   return STD_HTOLES(us);
+}
+
+static __inline unsigned short std_htoles(unsigned short us)
+{
+   return STD_HTOLES(us);
+}
+
+static __inline unsigned long std_letohl(unsigned long ul)
+{
+   return STD_HTOLEL(ul);
+}
+
+static __inline unsigned long std_htolel(unsigned long ul)
+{
+   return STD_HTOLEL(ul);
+}
+
+static __inline unsigned short std_ntohs(unsigned short us)
+{
+   return STD_HTONS(us);
+}
+
+static __inline unsigned short std_htons(unsigned short us)
+{
+   return STD_HTONS(us);
+}
+
+static __inline unsigned long std_ntohl(unsigned long ul)
+{
+   return STD_HTONL(ul);
+}
+
+static __inline unsigned long std_htonl(unsigned long ul)
+{
+   return STD_HTONL(ul);
+}
+
+
+#undef STD_HTONL   // private macro; not exported as a supported API
+#undef STD_HTONS   // private macro; not exported as a supported API
+#undef STD_HTOLEL  // private macro; not exported as a supported API
+#undef STD_HTOLES  // private macro; not exported as a supported API
+#undef STD_SWAPS   // private macro; not exported as a supported API
+#undef STD_SWAPL   // private macro; not exported as a supported API
+
+
+/*
+=======================================================================
+MACROS DOCUMENTATION
+=======================================================================
+
+STD_CONTSTRAIN()
+
+Description:
+  STD_CONTSTRAIN() constrains a number to be between two other numbers.
+
+Definition:
+   STD_CONSTRAIN( val, min, max ) \
+          (((val) < (min)) ? (min) : ((val) > (max)) ? (max) : (val))
+
+Parameters:
+  val: number to constrain
+  min: number to stay greater than or equal to
+  max: number to stay less than or equal to
+
+Evaluation Value:
+   the constrained number
+
+=======================================================================
+
+STD_BETWEEN()
+
+Description:
+    STD_BETWEEN() tests whether a number is between two other numbers.
+
+Definition:
+    STD_BETWEEN( val, minGE, maxLT ) \
+               ((unsigned)((unsigned)(val) - (unsigned)(minGE)) < \
+                (unsigned)((unsigned)(maxLT) - (unsigned)(minGE)))
+
+Parameters:
+     val: value to test
+     minGE: lower bound
+     maxLT: upper bound
+
+Evaluation Value:
+     1 if val >= minGE and val < maxLT
+
+=======================================================================
+
+STD_ARRAY_SIZE()
+
+Description:
+   STD_ARRAY_SIZE() gives the number of elements in a statically allocated array.
+
+Definition:
+    STD_ARRAY_SIZE(a) (sizeof((a))/sizeof((a)[0]))
+
+Parameters:
+    a: array to test
+
+Evaluation Value:
+    number of elements in a
+
+=======================================================================
+
+STD_ARRAY_MEMBER()
+
+Description:
+   STD_ARRAY_MEMBER() tests whether an item is a member of a statically allocated array.
+
+Definition:
+   STD_ARRAY_MEMBER(p,a) (((p) >= (a)) && ((p) < ((a) + STD_ARRAY_SIZE(a))))
+
+Parameters:
+    p: item to test
+    a: array to check
+
+Evaluation Value:
+    1 if p is in a
+
+=======================================================================
+
+STD_OFFSETOF()
+
+Description:
+  STD_OFFSETOF() gives the offset of member of a struct.
+
+Definition:
+   STD_OFFSETOF(type,member) (((char *)(&((type *)0)->member))-((char *)0))
+
+Parameters:
+    type: structured type
+    member: name of member in the struct
+
+Evaluation Value:
+    offset of member (in bytes) in type
+
+=======================================================================
+
+STD_RECOVER_REC()
+
+Description:
+  STD_RECOVER_REC() provides a safe cast from a pointer to a member
+    of a struct to a pointer to the containing struct
+
+Definition:
+  STD_RECOVER_REC(type,member,p) ((type*)(((char*)(p))-STD_OFFSETOF(type,member)))
+
+Parameters:
+    type: structured type
+    member: name of member in the struct
+    p: pointer to the member of the struct
+
+Evaluation Value:
+    a pointer of type type to the containing struct
+
+=======================================================================
+
+STD_MIN()
+
+Description:
+   STD_MIN() finds the smaller of two values.
+
+Definition:
+   STD_MIN(a,b)   ((a)<(b)?(a):(b))
+
+Parameters:
+    a, b: values to compare
+
+Evaluation Value:
+    smaller of a and b
+
+=======================================================================
+
+STD_MAX()
+
+Description:
+  STD_MAX() finds the larger of two values.
+
+Definition:
+   STD_MAX(a,b)   ((a)>(b)?(a):(b))
+
+Parameters:
+    a, b: values to compare
+
+Evaluation Value:
+    larger of a and b
+
+=======================================================================
+
+STD_ZEROAT()
+
+Description:
+   STD_ZEROAT() zero-initializes the contents of a typed chunk of memory.
+
+Definition:
+   STD_ZEROAT(p)  std_memset((p), 0, sizeof(*p))
+
+Parameters:
+    p: the chunk to initialize
+
+Evaluation Value:
+    p
+
+=======================================================================
+
+STD_BIT_SET()
+
+Description:
+   STD_BIT_SET(bits, ix) sets the bit in the memory stored in bits at
+                         index ix
+
+Parameters:
+    bits: the memory address holding the  bits
+    ix:   the index of the bit to set;
+
+=======================================================================
+
+STD_BIT_CLEAR()
+
+Description:
+   STD_BIT_CLEAR(bits, ix) clears the bit in the memory stored in bits
+                           at index ix
+
+Parameters:
+    bits: the memory address holding the  bits
+    ix:   the index of the bit to clear
+
+=======================================================================
+
+STD_BIT_TEST()
+
+Description:
+   STD_BIT_TEST(bits, ix) returns the bit in the memory stored in bits
+                          at index ix
+
+Parameters:
+    bits: the memory address holding the bits
+    ix:   the index of the bit to test
+
+Evaluation Value:
+    0x1 if set 0x0 if not set
+
+=====================================================================
+INTERFACES DOCUMENTATION
+=======================================================================
+
+std Interface
+
+Description:
+   This library provides a set of general-purpose utility functions.
+   Functionality may overlap that of a subset of the C standard library, but
+   this library differs in a few respects:
+
+   - Functions are fully reentrant and avoid use of static variables.
+
+   - The library can be supported consistently across all environments.
+   Compiler-supplied libraries sometimes behave inconsistently and are
+   unavailable in some environments.
+
+   - Omits "unsafe" functions.  C standard library includes many functions
+   that are best avoided entirely: strcpy, strcat, strtok, etc.
+
+
+=======================================================================
+
+std_getversion()
+
+Description:
+
+   The std_getversion() copies the stdlib version to pcDst.  This function
+   takes the size of the destination buffer as an argument and guarantees
+   to zero-terminate the result and not to overflow the nDestSize size.
+
+   This function copies up to size-1 characters from the stdlib version
+   string to pcDest and NUL-terminates the pcDest string.
+
+Prototype:
+   int  std_getversion(char *pcDst, int nDestSize)
+
+
+Parameters:
+   pcDst :     Destination string
+   nDestSize:  Size of the destination buffer in bytes
+
+Return Value:
+
+   Returns the length of the version string (in characters).
+
+=======================================================================
+
+std_strlen()
+
+Description:
+   The std_strlen() computes the length of the given string.
+
+Prototype:
+   int std_strlen(const char *cpszStr)
+
+Parameters:
+   cpszStr : String whose length will be computed
+
+Return Value:
+   Length of the string in characters that precede the terminating NULL character.
+
+=======================================================================
+
+std_strcmp()
+
+Description:
+   The std_strcmp() compares two NUL-terminated character strings.
+   Comparison is strictly by byte values with no character set
+   interpretation.
+
+Prototype:
+
+   int std_strcmp(const char *s1, const char *s2);
+
+Parameters:
+   s1, s2: strings to compare
+
+Return Value:
+   0 if strings are the same ~
+   < 0 if s1 is less than s2 ~
+   > 0 if s1 is greater than s2
+
+See Also:
+   std_wstrcmp
+
+=======================================================================
+
+std_strncmp()
+
+Description:
+   The std_strncmp() compares at most n bytes of two NUL-terminated character strings.
+
+Prototype:
+
+   int std_strncmp(const char *s1, const char *s2, int n);
+
+Parameters:
+   s1, s2: strings to compare
+   n: maximum number of bytes to compare.  if either s1 or s2 is
+       shorter than n, the function terminates there
+
+Return Value:
+   0 if strings are the same ~
+   < 0 if s1 is less than s2 ~
+   > 0 if s1 is greater than s2
+
+See Also:
+   std_wstrncmp
+
+=======================================================================
+
+std_stricmp()
+
+Description:
+   The std_stricmp() compares two NUL-terminated character strings, case-folding any
+   ASCII characters.
+
+Prototype:
+
+   int std_stricmp(const char *s1, const char *s2);
+
+Parameters:
+   s1, s2: strings to compare
+
+Return Value:
+   0 if strings are the same ~
+   < 0 if s1 is less than s2 ~
+   > 0 if s1 is greater than s2
+
+=======================================================================
+
+std_strnicmp()
+
+Description:
+   The std_strnicmp() compares at most n bytes of 2 NUL-terminated character strings,
+   case-folding any ASCII characters.
+
+Prototype:
+
+   int std_strnicmp(const char *s1, const char *s2, int n);
+
+Parameters:
+   s1, s2: strings to compare
+   n: maximum number of bytes to compare.  if either s1 or s2 is
+       shorter than n, the function terminates there
+
+Return Value:
+   0 if strings are the same ~
+   < 0 if s1 is less than s2 ~
+   > 0 if s1 is greater than s2
+
+=======================================================================
+
+std_strlcpy()
+
+Description:
+
+   The std_strlcpy() copies pszSrc string to the pcDst.  It is a safer
+   alternative to strcpy() or strncpy().  This function takes the size of the
+   destination buffer as an argument and guarantees to NUL-terminate the
+   result and not to overflow the nDestSize size.
+
+   This function copies up to nDestSize-1 characters from the pszSrc string
+   to pcDest and NUL-terminates the pcDest string.
+
+Prototype:
+   int std_strlcpy(char *pcDst, const char *pszSrc, int nDestSize)
+
+Parameters:
+   pcDst :     Destination string
+   pcSrc :     Source string
+   nDestSize:  Size of the destination buffer in bytes
+
+Return Value:
+
+   Returns the length of the string (in characters) it tried to create,
+   which is same as length of pszSrc.
+
+   Example:
+
+   {
+      char buf[64];
+      if (std_strlcpy(buf, file_name, STD_ARRAY_SIZE(buf) >=
+          STD_ARRAY_SIZE(buf)) {
+         //Truncated -- Handle overflow....
+      }
+   }
+
+Comment:
+
+   Unlike strlcpy, std_strlcpy accepts an integer size and does nothing when a
+   negative value is passed.  When passing valid sizes for objects on our
+   supported platforms, this should not result in any observed difference.
+   However, calling strlcpy() with UINT_MAX will result in the entire source
+   string being copied, whereas std_strlcpy() will do nothing.  Passing INT_MAX
+   to str_strlcpy() will achieve the same result (although both these cases are
+   bad practice since they defeat bounds checking).
+
+
+=======================================================================
+
+std_strlcat()
+
+Description:
+
+   The std_strlcat() function concatenates a string to a string already
+   residing in a buffer.  It is a safer alternative to strcat() or strncat().
+   This function takes the size of the destination buffer as an argument and
+   guarantees not to create an improperly terminated string and not to
+   overflow the nDestSize size.
+
+   This function appends pszSrc to pcDst, copying at most nDestSize minus
+   the length of the string in pcDest minus 1 bytes, always NUL-terminating
+   the result.
+
+   For compatibility with "strlcat()", std_strlcat() does *not* zero-terminate
+   the destination buffer in cases where the buffer lacks termination on entry
+   to the function.  Do not rely on std_strlcat() to zero-terminate a buffer
+   that is not already zero-terminated; instead ensure that the buffer is
+   properly initialized using std_strlcpy() or some other means.
+
+Prototype:
+
+   int std_strlcat(char *pcDst, const char *pszSrc, int nDestSize)
+
+Parameters:
+
+   pcDst :     Destination string
+   pcSrc :     Source string
+   nDestSize:  Size of the destination buffer in bytes
+
+Return Value:
+
+   Returns the length of the string (in characters) it tried to create,
+   which is same as length of pszSrc plus the length of pszDest.
+
+   Example:
+
+   {
+      char buf[64];
+      if (std_strlcat(buf, file_name, STD_ARRAY_SIZE(buf) >=
+          STD_ARRAY_SIZE(buf)) {
+         //Truncated -- Handle overflow....
+      }
+   }
+
+
+=======================================================================
+
+std_strstr()
+
+Description:
+   The std_strstr() finds the first occurrence of a substring in a string.
+
+Prototype:
+
+   char * std_strstr(const char *pszString, const char *pszSearch);
+
+Parameters:
+   pszString: string to search
+   pszSearch: sub string to search for
+
+Return Value:
+   A pointer to the first character in the first occurrence of the substring if found, NULL otherwise
+
+=======================================================================
+
+std_tolower()
+
+Description:
+   The std_tolower() converts an uppercase letter to the corresponding
+   lowercase letter.
+
+Prototype:
+   char std_tolower(char c);
+
+Parameters:
+   c: A character.
+
+Return Value:
+   the corresponding lowercase letter if c is an ASCII character whose
+   value is representable as an uppercase letter, else the same character
+   c is returned.
+
+=======================================================================
+
+std_toupper()
+
+Description:
+   The std_toupper() converts an lowercase letter to the corresponding
+   uppercase letter.
+
+Prototype:
+   char std_toupper(char c);
+
+Parameters:
+   c: is a character.
+
+Return Value:
+   The corresponding uppercase letter if c is an ASCII character whose
+   value is representable as an lowercase letter; else the same character
+   c is returned.
+
+=======================================================================
+
+std_memset()
+
+Description:
+   The std_memset() sets each byte in a block of memory to a value.
+
+Prototype:
+
+   void *std_memset(void *p, int c, int nLen);
+
+Parameters:
+   p: memory block to set
+   c: value to set each byte to
+   nLen: size of p in bytes
+
+Return Value:
+   p
+
+=======================================================================
+
+std_memmove()
+
+Description:
+   The std_memmove() copies a block of memory from one buffer to another.
+
+Prototype:
+
+   void *std_memmove(void *pTo, const void *cpFrom, int nLen);
+
+Parameters:
+   pTo: destination buffer
+   cpFrom: source buffer
+   nLen: number of bytes to copy
+
+Return Value:
+   pTo
+
+=======================================================================
+
+std_memsmove()
+
+Description:
+
+  Size bounded memory move.
+
+  Moves bytes from the source buffer to the destination buffer.
+
+  This function ensures that there will not be a copy beyond
+  the size of the destination buffer.
+
+  This function should be used in preference to memscpy() if there
+  is the possiblity of source and destination buffers overlapping.
+  The result of the operation is defined to be as if the copy were from
+  the source to a temporary buffer that overlaps neither source nor
+  destination, followed by a copy from that temporary buffer to the
+  destination.
+
+Prototype:
+
+  int std_memsmove(void *dst, int dst_size, const void *src, int src_size);
+
+Parameters:
+  @param[out] dst       Destination buffer.
+  @param[in]  dst_size  Size of the destination buffer in bytes.
+  @param[in]  src       Source buffer.
+  @param[in]  src_size  Number of bytes to copy from source buffer.
+
+Return value:
+  The number of bytes copied to the destination buffer.  It is the
+  caller's responsibility to check for trunction if it cares about it -
+  truncation has occurred if the return value is less than src_size.
+  A negative return value indicates an error
+
+=======================================================================
+
+std_memcmp()
+
+Description:
+   The std_memcmp() compares two memory buffers, byte-wise.
+
+Prototype:
+
+   int std_memcmp(const void *a, const void *b, int length);
+
+Parameters:
+   a, b: buffers to compare
+   length: number of bytes to compare
+
+Return Value:
+   0 if buffers are the same for nLength ~
+   < 0 if a is less than b ~
+   > 0 if a is greater than b
+
+=======================================================================
+
+std_memscpy - Size bounded memory copy.
+
+Description:
+
+  Copies bytes from the source buffer to the destination buffer.
+
+  This function ensures that there will not be a copy beyond
+  the size of the destination buffer.
+
+  The result of calling this on overlapping source and destination
+  buffers is undefined.
+
+Prototype:
+
+   int std_memscpy(void *dst, int dst_size, const void *src, int src_size);
+
+Parameters:
+
+  @param[out] dst       Destination buffer.
+  @param[in]  dst_size  Size of the destination buffer in bytes.
+  @param[in]  src       Source buffer.
+  @param[in]  src_size  Number of bytes to copy from source buffer.
+
+Return value:
+
+  The number of bytes copied to the destination buffer.  It is the
+  caller's responsibility to check for trunction if it cares about it -
+  truncation has occurred if the return value is less than src_size.
+  Returs a negative value on error.
+
+=======================================================================
+
+std_memchr()
+
+Description:
+   The std_memchr() finds the first occurrence of a character in a memory
+   buffer.
+
+Prototype:
+
+   void *std_memchr(const void* s, int c, int n);
+
+Parameters:
+   s: buffer to search
+   c: value of byte to look for
+   n: size of s in bytes
+
+Return Value:
+   A pointer to the occurrence of c. NULL if not found.
+
+=======================================================================
+
+std_memstr()
+
+Description:
+   The std_memstr() finds the first occurrence of a substring in a memory
+   buffer.
+
+Prototype:
+
+   void *std_memstr(const char* cpHaystack, const char* cpszNeedle,
+                    int nHaystackLen);
+
+Parameters:
+   cpHaystack: buffer to search
+   cpszNeedle: NUL-terminated string to search for
+   nHaystackLen: size of cpHaystack in bytes
+
+Return Value:
+   a pointer to the first occurrence of cpszNeedle if found,
+       NULL otherwise
+
+Comments:
+   None
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+std_memrchr()
+
+Description:
+
+   The std_memrchr() finds the last occurrence of a character in a memory
+   buffer.
+
+Prototype:
+
+   void *std_memrchr(const void* s, int c, int n);
+
+Parameters:
+   s: buffer to search
+   c: value of byte to look for
+   n: size of s in bytes
+
+Return Value:
+   a pointer to the last occurrence of c, NULL if not found
+
+=======================================================================
+
+std_memrchrbegin()
+
+Description:
+   The std_memrchrbegin() finds the last occurrence of a character in a
+   memory buffer.
+
+Prototype:
+
+   void *std_memrchrbegin(const void* s, int c, int n);
+
+Parameters:
+   s: buffer to search
+   c: value of byte to look for
+   n: size of s in bytes
+
+Return Value:
+   a pointer to the last occurrence of c, or s if not found
+
+=======================================================================
+
+std_memchrend()
+
+Description:
+   The std_memchrend() finds the first occurrence of a character in a
+   memory buffer.
+
+Prototype:
+
+   void *std_memchrend(const void* s, int c, int n);
+
+Parameters:
+   s: buffer to search
+   c: value of byte to look for
+   n: size of s in bytes
+
+Return Value:
+   a pointer to the occurrence of c, s + n if not found
+
+=======================================================================
+std_memchrsend()
+
+Description:
+   The std_memchrsend() finds the first occurrence of any character in a
+   NUL-terminated list of characters in a memory buffer.
+
+Prototype:
+
+   void *std_memchrend(const void* s, const char* cpszChars, int n);
+
+Parameters:
+   s: buffer to search
+   cpszChars: characters to look for
+   n: size of s in bytes
+
+Return Value:
+   a pointer to the first occurrence of one of cpszChars, s + n if not found
+
+=======================================================================
+
+std_strchr()
+
+Description:
+   The std_strchr() finds the first occurrence of a character in a
+   NUL-terminated string.
+
+Prototype:
+
+   char *std_strchr(const char* s, int c);
+
+Parameters:
+   s: string to search
+   c: char to search for
+
+Return Value:
+   pointer to first occurrence, NULL if not found
+
+See Also:
+   std_wstrchr
+
+=======================================================================
+
+std_strchrs()
+
+Description:
+   The std_strchrs() searches s, a NUL-terminated string, for the first
+   occurrence of any characters in cpszSrch, a NUL-terminated list of
+   characters.
+
+Prototype:
+
+   char *std_strchrs(const char* s, const char *cpszSrch);
+
+Parameters:
+   s: string to search
+   cpszSrch: a list of characters to search for
+
+Return Value:
+   first occurrence of any of cpszSrch, NULL if not found
+
+=======================================================================
+
+std_strrchr()
+
+Description:
+   The std_strrchr() finds the last occurrence of a character in a
+   NUL-terminated string.
+
+Prototype:
+
+   char *std_strrchr(const char* s, int c);
+
+Parameters:
+   s: string to search
+   c: char to search for
+
+Return Value:
+   pointer to last occurrence, NULL if not found
+
+See Also:
+   std_wstrrchr
+
+=======================================================================
+
+std_strchrend()
+
+Description:
+   The std_strchrend() finds the first occurrence of a character in a
+   NUL-terminated string.
+
+Prototype:
+
+   char *std_strchrend(const char* s, int c);
+
+Parameters:
+   s: string to search
+   c: char to search for
+
+Return Value:
+   pointer to first occurrence, s + std_strlen(s) if not found
+
+=======================================================================
+
+std_strchrsend()
+
+Description:
+   The std_strchrsend() searches s, a NUL-terminated string, for the first
+   occurrence of any characters in cpszSrch, a NUL-terminated list of
+   characters.
+
+Prototype:
+
+   char *std_strchrsend(const char* s, const char* cpszSrch);
+
+Parameters:
+   s: string to search
+   cpszSrch: a list of characters to search for
+
+Return Value:
+   first occurrence of any of cpszSrch or s+strlen(s) if not found
+
+=======================================================================
+
+std_strends()
+
+Description:
+   The std_strends() tests whether a string ends in a particular suffix.
+
+Prototype:
+
+   char *std_strends(const char* cpsz, const char* cpszSuffix);
+
+Parameters:
+   cpsz: string to test
+   cpszSuffix: suffix to test for
+
+Return Value:
+   the first character of cpsz+std_strlen(cpsz)-std_strlen(cpszSuffix)
+     if cpsz ends with cpszSuffix.  NULL otherwise.
+
+=======================================================================
+
+std_striends()
+
+Description:
+   The std_striends() tests whether a string ends in a particular suffix,
+   case-folding ASCII characters.
+
+Prototype:
+
+   char *std_striends(const char* cpsz, const char* cpszSuffix);
+
+Parameters:
+   cpsz: string to test
+   cpszSuffix: suffix to test for
+
+Return Value:
+   the first character of cpsz+std_strlen(cpsz)-std_strlen(cpszSuffix)
+     if cpsz ends with cpszSuffix.  NULL otherwise.
+
+=======================================================================
+
+std_strbegins()
+
+Description:
+   The std_strbegins() tests whether a string begins with a particular
+   prefix string.
+
+Prototype:
+
+   char *std_strbegins(const char* cpsz, const char* cpszPrefix);
+
+Parameters:
+   cpsz: string to test
+   cpszPrefix: prefix to test for
+
+Return Value:
+   cpsz + std_strlen(cpszPrefix) if cpsz does begin with cpszPrefix,
+     NULL otherwise
+
+=======================================================================
+
+std_stribegins()
+
+Description:
+   The std_stribegins() tests whether a string begins with a particular
+   prefix string, case-folding ASCII characters.
+
+Prototype:
+
+   char *std_stribegins(const char* cpsz, const char* cpszPrefix);
+
+Parameters:
+   cpsz: string to test
+   cpszPrefix: prefix to test for
+
+Return Value:
+   cpsz + std_strlen(cpszPrefix) if cpsz does begin with cpszPrefix,
+     NULL otherwise
+
+
+=======================================================================
+
+std_strcspn()
+
+Description:
+   The std_strcspn() function searches s, a NUL-terminated string, for
+   the first occurrence of any characters in cpszSrch, a NUL-terminated
+   list of characters. This function returns the length of the longest
+   initial substring of s which consists of characters not present in
+   cpszSrch.
+
+Prototype:
+
+   int std_strcspn(const char* s, const char* cpszSrch);
+
+Parameters:
+   s: string to search
+   cpszSrch: a list of characters to search for
+
+Return Value:
+   The index into the string s of the first occurrence of any of the
+   characters in cpszSrch. If no match is found, then index of the
+   terminating NUL character is returned.
+
+See Also:
+   std_strspn, std_strchr, std_strchrs
+
+=======================================================================
+
+std_strspn()
+
+Description:
+   The std_strspn() functions searches s, a NUL-terminated string, for
+   the first occurrence of a character that matches none of the
+   characters in cpszSrch, a NUL-terminated list of characters. This
+   function returns the length of the longest initial substring of s
+   which consists of characters present in cpszSrch.
+
+Prototype:
+
+   int std_strspn(const char* s, const char* cpszSrch);
+
+Parameters:
+   s: string to search
+   cpszSrch: a list of characters to search for
+
+Return Value:
+   The index into the string s of the first occurrence of any character
+   that matches none of the characters in cpszSrch. If all characters
+   in s are present in cpszSrch, the index of the terminating NUL
+   character is returned.
+
+See Also:
+   std_strcspn, std_strchr, std_strchrs
+
+=======================================================================
+
+std_wstrlcpy()
+
+Description:
+
+   The std_wstrlcpy() function copies a string.  It is equivalent to
+   str_strlcpy() except that it operates on wide (16-bit) character strings.
+   See std_strlcpy() for details.
+
+
+Prototype:
+
+   int std_wstrlcpy(AECHAR *pcDest, const AECHAR *pszSrc, int nDestSize);
+
+Parameters:
+   pcDst: destination string
+   pszSrc: source string
+   int nDestSize: size of pcDest __in AECHARs__
+
+Return Value:
+   Returns the length of the string (in AECHARs) it tried to create,
+   which is same as length of pszSrc.
+
+   Example:
+
+   {
+      AECHAR buf[64];
+      if (std_wstrlcpy(buf, file_name, STD_ARRAY_SIZE(buf)) >=
+          STD_ARRAY_SIZE(buf)) {
+         //Truncated -- Handle overflow....
+      }
+   }
+
+See Also:
+   std_wstrlcat
+
+=======================================================================
+
+std_wstrlcat()
+
+Description:
+
+   The std_wstrlcat() function concatenates two strings.  It is equivalent to
+   std_strlcat() except that it operates on wide (16-bit) character strings.
+   See std_strlcat() for more information.
+
+Prototype:
+   int std_wstrlcat(AECHAR *pcDst, const AECHAR *pszSrc, int nDestSize)
+
+Parameters:
+   pcDst[out]: Destination string
+   pcSrc :     Source string
+   nDestSize:  Size of the destination buffer in AECHARs
+
+Return Value:
+   Returns the length of the string (in AECHARs) it tried to create,
+   which is same as length of pszSrc + the length of pszDest.
+
+   Example:
+
+   {
+      char buf[64];
+      if (std_wstrlcat(buf, file_name, STD_ARRAY_SIZE(buf)) >=
+          STD_ARRAY_SIZE(buf)) {
+         //Truncated -- Handle overflow....
+      }
+   }
+
+See Also:
+   std_wstrlcpy
+
+=======================================================================
+
+std_wstrncmp()
+
+Description:
+
+   The std_wstrncmp() function compares up to a specified number of bytes
+   in two NUL-terminated strings. It is equivalent to std_strncmp() except
+   that it operates on wide (16-bit) character strings.
+
+Prototype:
+   int std_wstrncmp(const AECHAR* s1, const AECHAR* s2, int nLen);
+
+Parameters:
+   s1, s2: strings to compare
+   n: maximum number of AECHARs to compare.  if either s1 or s2 is
+      shorter than n, the function terminates there.
+
+Return Value:
+   0 if strings are the same ~
+   < 0 if s1 is less than s2 ~
+   > 0 if s1 is greater than s2
+
+See Also:
+   std_strncmp
+
+=======================================================================
+
+std_wstrcmp()
+
+Description:
+   The std_wstrcmp() compares two NUL-terminated strings. It is equivalent
+   to std_strncmp() except that it operates on wide (16-bit) character
+   strings. Comparison is strictly by byte values with no character set
+   interpretation.
+
+Prototype:
+
+   int std_wstrcmp(const AECHAR* s1, const AECHAR* s2);
+
+Parameters:
+   s1, s2: strings to compare
+
+Return Value:
+   0 if strings are the same ~
+   < 0 if s1 is less than s2 ~
+   > 0 if s1 is greater than s2
+
+See Also:
+   std_strcmp
+
+=======================================================================
+
+std_wstrchr()
+
+Description:
+   This function is the wide string counterpart of std_strchr().
+   The std_wstrchr() finds the first occurrence of a character in a
+   NUL-terminated wide (16-bit) character string.
+
+Prototype:
+
+   AECHAR* std_wstrchr(const AECHAR* s, AECHAR ch);
+
+Parameters:
+   s: string to search
+   ch: char to search for
+
+Return Value:
+   pointer to first occurrence, NULL if not found
+
+See Also:
+   std_strchr
+
+=======================================================================
+
+std_wstrrchr()
+
+Description:
+   This function is the wide string counterpart of std_strrchr().
+   The std_wstrrchr() finds the last occurrence of a character in a
+   NUL-terminated wide (16-bit) character string.
+
+Prototype:
+
+   AECHAR* std_wstrrchr(const AECHAR* s, AECHAR ch);
+
+Parameters:
+   s: string to search
+   ch: char to search for
+
+Return Value:
+   pointer to last occurrence, NULL if not found
+
+See Also:
+   std_strrchr
+
+=======================================================================
+
+std_makepath()
+
+Description:
+   The std_makepath() constructs a path from a directory portion and a file
+   portion, using forward slashes, adding necessary slashes and deleting extra
+    slashes.  This function guarantees NUL-termination of pszDest
+
+Prototype:
+
+   int std_makepath(const char *cpszDir, const char *cpszFile,
+                    char *pszDest, int nDestSize)
+
+Parameters:
+   cpszDir: directory part
+   cpszFile: file part
+   pszDest: output buffer
+   nDestSize: size of output buffer in bytes
+
+Return Value:
+   the required length to construct the path, not including
+   NUL-termination
+
+Comments:
+   The following list of examples shows the strings returned by
+   std_makepath() for different paths.
+
+Example:
+
+   cpszDir  cpszFile  std_makepath()
+   ""        ""           ""
+   ""        "/"          ""
+   "/"       ""           "/"
+   "/"       "/"          "/"
+   "/"       "f"          "/f"
+   "/"       "/f"         "/f"
+   "d"       "f"          "d/f"
+   "d/"      "f"          "d/f"
+   "d"       "/f"         "d/f"
+   "d/"      "/f"         "d/f"
+
+See Also:
+   std_splitpath
+
+=======================================================================
+
+std_splitpath()
+
+Description:
+   The std_splitpath() finds the filename part of a path given an inclusive
+   directory, tests for cpszPath being in cpszDir. The forward slashes are
+   used as directory delimiters.
+
+Prototype:
+
+   char *std_splitpath(const char *cpszPath, const char *cpszDir);
+
+Parameters:
+   cpszPath: path to test for inclusion
+   cpszDir: directory that cpszPath might be in
+
+Return Value:
+   the part of cpszPath that actually falls beneath cpszDir, NULL if
+   cpszPath is not under cpszDir
+
+Comments:
+   The std_splitpath() is similar to std_strbegins(), but it ignores trailing
+   slashes on cpszDir, and it returns a pointer to the first character of
+   the subpath.
+
+   The return value of std_splitpath() will never begin with a '/'.
+
+   The following list of examples shows the strings returned by
+   std_splitpath() for different paths.
+
+Example:
+   cpszPath cpszDir  std_splitpath()
+   ""        ""           ""
+   ""        "/"          ""
+   "/"       ""           ""
+   "/"       "/"          ""
+   "/d"      "d"          null
+   "/d"      "/"          "d"
+   "/d/"     "/d"         ""
+   "/d/f"    "/"          "d/f"
+   "/d/f"    "/d"         "f"
+   "/d/f"    "/d/"        "f"
+
+See Also:
+   std_makepath
+
+=======================================================================
+
+std_cleanpath()
+
+Description:
+   The std_cleanpath() removes double slashes, ".", and ".." from
+   slash-delimited paths,. It operates in-place.
+
+Prototype:
+
+   char *std_cleanpath(char *pszPath);
+
+Parameters:
+   pszPath[in/out]: path to "clean"
+
+Return Value:
+   pszPath
+
+Comments:
+   Passing an "fs:/" path to this function may produce undesirable
+   results.  This function assumes '/' is the root.
+
+Examples:
+       pszPath  std_cleanpath()
+         "",           "",
+         "/",          "/",
+
+         // here"s, mostly alone
+         "./",         "/",
+         "/.",         "/",
+         "/./",        "/",
+
+         // "up"s, mostly alone
+         "..",         "",
+         "/..",        "/",
+         "../",        "/",
+         "/../",       "/",
+
+         // fun with x
+         "x/.",        "x",
+         "x/./",       "x/",
+         "x/..",       "",
+         "/x/..",      "/",
+         "x/../",      "/",
+         "/x/../",     "/",
+         "/x/../..",   "/",
+         "x/../..",    "",
+         "x/../../",   "/",
+         "x/./../",    "/",
+         "x/././",     "x/",
+         "x/.././",    "/",
+         "x/../.",     "",
+         "x/./..",     "",
+         "../x",       "/x",
+         "../../x",    "/x",
+         "/../x",      "/x",
+         "./../x",     "/x",
+
+         // double slashes
+         "//",         "/",
+         "///",        "/",
+         "////",       "/",
+         "x//x",       "x/x",
+
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+
+=======================================================================
+
+std_basename()
+
+Description:
+   The std_basename() returns the filename part of a string,
+   assuming '/' delimited filenames.
+
+Prototype:
+
+   char *std_basename(const char *cpszPath);
+
+Parameters:
+   cpszPath: path of interest
+
+Return Value:
+   pointer into cpszPath that denotes part of the string immediately
+   following the last '/'
+
+Examples:
+     cpszPath       std_basename()
+         ""            ""
+         "/"           ""
+         "x"           "x"
+         "/x"          "x"
+         "y/x"         "x"
+         "/y/x"        "x"
+
+ See Also:
+    None
+
+=======================================================================
+
+std_rand_next()
+
+Description:
+  The std_rand_next() generates pseudo-random bytes.
+
+Prototype:
+
+   unsigned std_rand_next(unsigned uRand);
+
+Parameters:
+   uRand: a seed for the pseudo-random generator
+
+Return Value:
+   the next value in the generator from uRand
+
+Comments:
+   for best results, this function should be called with its last
+   generated output.
+
+   This is an example of code to generate 256 bytes of pseudo-random data.
+
+   This is not crypto quality and should not be used for key generation
+   and the like.
+
+Example:
+   {
+       unsigned rand_buf[256/sizeof(unsigned)];
+       int      i;
+       unsigned uLast = std_rand_next(uCurrentTime);
+       for (i = 0; i < STD_ARRAY_SIZE(rand_buf); i++) {
+          rand_buf[i] = (uLast = std_rand_next(uLast));
+       }
+   }
+
+See Also:
+   std_rand()
+
+=======================================================================
+
+std_rand()
+
+Description:
+  The std_rand() functions generates pseudo-random bytes and places it
+  in an output buffer of specified size.
+
+Prototype:
+
+   uint32 std_rand(uint32 uSeed, byte* pDest, int nSize);
+
+Parameters:
+   uSeed: A seed for the pseudo-random generator
+   pDest: The output buffer where the random bytes are placed.
+   nSize: The size in bytes of pDest.
+
+Return Value:
+   The new seed value that can be used in a subsequent call to
+   std_rand().
+
+Comments:
+
+   std_rand() is a linear congruent psuedo-random number generator that
+   is seeded using the input seed. This makes the ouput predictable if
+   you can determine (or influence) the seed value used. Furthermore,
+   the random sequence of bytes generated by two different calls to this
+   function will be identical if both the calls use the same seed value.
+
+   This is not crypto quality and should not be used for key generation
+   and other cryptographic uses.
+
+See Also:
+   std_rand_next()
+
+=======================================================================
+
+std_CopyLE()
+
+Description:
+
+   The std_CopyLE() function copies data while translating numeric values
+   between host byte ordering and "little endian" byte ordering.
+
+   pvDest and pvSrc are NOT required to be 16 or 32-bit word aligned.
+
+   Behavior is undefined when the destination and source arrays overlap,
+   except in the special case where pvDest and pvSrc are equal.  In that case,
+   std_CopyLE() modifies the buffer in-place.
+
+   When the target byte ordering (little endian) matches the host byte
+   ordering, in-place translations reduce to a no-op, and copies are
+   delegated directly to std_memmove().
+
+
+Prototype:
+   int std_CopyLE(void *pvDest, int nDestSize,
+                  const void *pvSrc,  int nSrcSize,
+                  const char *pszFields);
+
+Parameters:
+   pvDest:    Pointer to destination buffer.
+   nDestSize: Size of the destination buffer.
+   pvSrc:     Pointer to buffer containing source data.
+   nSrcSize:  Size of source data.
+   pszFields: Description of the fields that comprise the source data.
+
+              Each field size is given by a positive decimal integer or one of
+              the following characters: "S", "L", "Q", or "*".  The letters
+              denote fields that should be converted to the desired byte
+              ordering:
+
+===pre>
+                S : a 2 byte (16 bit) value.
+                L : a 4 byte (32 bit) value.
+                Q : a 8 byte (64 bit) value.
+===/pre>
+
+              An integer gives a number of bytes and "*" represents the
+              remainder of the pvSrc[] buffer.  No reordering is performed on
+              data in these fields.
+
+              Comparisons are case-sensitive.  Behavior is undefined when
+              other characters are supplied in pszFields.
+
+              For example: "L12S*" would be appropriate to copy a structure
+              containing a uint32 followed by a 12 byte character array,
+              followed by a uint16, followed by an arbitrary amount of
+              character data.
+
+              If nSrcSize is greater than the structure size (total of all the
+              sizes in pszFields[]) then pvSrc[] is treated as an array of
+              structures, each of which is described by pszFields.
+
+Return Value:
+
+   The number of bytes actually copied or translated in-place.  This will be
+   the smaller of nDestSize and nSrcSize, or zero if one of them are negative.
+
+
+=======================================================================
+
+std_CopyBE()
+
+Description:
+
+   The std_CopyBE() function has the same semantics as std_CopyLE() except it
+   copies between host byte ordering and big-endian ("network") byte order.
+
+   See std_CopyLE() for more details.
+
+
+Prototype:
+   void *std_CopyBE(void *pvDest, const void *pvSrc,
+                           int cbDest, int nItems, const char *pszFields);
+
+Parameters:
+   pvDest:    Pointer to destination buffer.
+   nDestSize: Size of the destination buffer.
+   pvSrc:     Pointer to buffer containing source data.
+   nSrcSize:  Size of source data.
+   pszFields: Description of the fields that comprise the source data,
+              as defined in std_CopyLE.
+
+Return Value:
+
+   The number of bytes actually copied or translated in-place.  This will be
+   the smaller of nDestSize and nSrcSize, or zero if one of them are negative.
+
+=======================================================================
+
+std_swapl()
+
+Description:
+   The std_swapl() changes endianness of an unsigned long.
+
+Prototype:
+
+   unsigned long std_swapl(unsigned long ul)
+
+Parameters:
+   ul: input unsigned long
+
+Return Value:
+   ul, reversed in byte-ordering
+
+=======================================================================
+
+std_swaps()
+
+Description:
+   The std_swaps() changes endianness of an unsigned short.
+
+Prototype:
+
+   unsigned short std_swaps(unsigned short us)
+
+Parameters:
+   us: input unsigned short
+
+Return Value:
+   us, reversed in byte-ordering
+
+=======================================================================
+
+std_letohs()
+
+Description:
+   The std_letohs() changes a short from little-endian to host byte order.
+
+Prototype:
+
+   unsigned short std_letohs(unsigned short us)
+
+Parameters:
+   us: short to convert
+
+Return Value:
+   us converted from little-endian to host byte order.  If the
+     host is little endian, just returns us
+
+=======================================================================
+
+std_htoles()
+
+Description:
+   The std_htoles() converts a short from host byte-order to little-endian.
+
+Prototype:
+
+   unsigned short std_htoles(unsigned short us)
+
+Parameters:
+   us: short to convert
+
+Return Value:
+   us converted from host byte order to little-endian.  If the
+   host is little endian, just returns us
+
+=======================================================================
+
+std_letohl()
+
+Description:
+   The std_letohl() changes a long from little-endian to host byte order.
+
+Prototype:
+
+   unsigned long std_letohl(unsigned long ul)
+
+Parameters:
+   ul: long to convert
+
+Return Value:
+   ul converted from little-endian to host byte order.  If the
+   host is little endian, just returns ul
+
+=======================================================================
+
+std_htolel()
+
+Description:
+   The std_htolel() converts a long from host byte-order to little-endian.
+
+Prototype:
+
+   unsigned long std_htolel(unsigned long ul)
+
+Parameters:
+   ul: long to convert
+
+Return Value:
+   ul converted from host byte order to little-endian.  If the
+   host is little endian, just returns ul.
+
+
+=======================================================================
+
+std_ntohs()
+
+Description:
+   The std_ntohs() changes a short from big-endian to host byte order.
+
+Prototype:
+
+   unsigned short std_ntohs(unsigned short us)
+
+Parameters:
+   us: short to convert
+
+Return Value:
+   us converted from big-endian to host byte order.  If the
+   host is big endian, just returns us.
+
+=======================================================================
+
+std_htons()
+
+Description:
+   The std_htons() converts a short from host byte-order to big-endian.
+
+Prototype:
+
+   unsigned short std_htons(unsigned short us)
+
+Parameters:
+   us: short to convert
+
+Return Value:
+   us converted from host byte order to big-endian.  If the
+   host is big endian, just returns us.
+
+=======================================================================
+
+std_ntohl()
+
+Description:
+   The std_ntohl() changes a long from big-endian to host byte order.
+
+Prototype:
+
+   unsigned long std_ntohl(unsigned long ul)
+
+Parameters:
+   ul: long to convert
+
+Return Value:
+   ul converted from big-endian to host byte order.  If the
+   host is big endian, just returns ul.
+
+=======================================================================
+
+std_htonl()
+
+Description:
+   The std_htonl() converts a long from host byte-order to big-endian.
+
+Prototype:
+
+   unsigned long std_htonl(unsigned long ul)
+
+Parameters:
+   ul: long to convert
+
+Return Value:
+   ul converted from host byte order to big-endian.  If the
+   host is big endian, just returns ul.
+
+
+=======================================================================
+
+std_strlprintf()
+
+Description:
+
+   The functions std_strlprintf() and std_vstrlprintf() write formatted
+   output to a string.  These functions guarantee NUL-termination of
+   the output buffer when its size is greater than zero.
+
+   A format string is copied to the output buffer, except for conversion
+   specifiers contained within the format string.  Conversion specifiers
+   begin with a "%" and specify some action that consumes an argument from
+   the argument list.
+
+   Conversion specifiers have the following form:
+===pre>
+       %[FLAGS] [WIDTH] [.PRECISION] [TYPE] CONV
+===/pre>
+
+   CONV is the only required field.  It is always a single character,
+   and determines the action to be taken.  Supported values are:
+
+===pre>
+    CONV | Description
+   ======|=======================================================
+     c   | Output a single character.
+         |
+     s   | Output a NUL-terminated single-byte character string.
+         |
+    d, i | Ouptut a signed decimal integer.
+         |
+     u   | Output an unsigned decimal integer.
+         |
+     o   | Output an unsigned octal integer.
+         |
+     x   | Output an unsigned hexadecimal integer, using
+         | lower case digits.
+         |
+     X   | Output an unsigned hexadecimal integer, using
+         | upper case digits.
+         |
+     p   | Output a pointer value as eight hexadecimal digits,
+         | using upper case digits.
+===/pre>
+
+   The next argument from the argument list supplies the value to be
+   formatted and output.
+
+   FLAGS, WIDTH, and PRECISION can modify the formatting of the value.
+
+   FLAGS consists of one or more of the following characters:
+
+===pre>
+   Flag | Meaning
+   =====|=================================================================
+     +  | Prefix positive numbers with "+" (%d and %i only).
+   -----|-----------------------------------------------------------------
+     -  | When padding to meet WIDTH, pad on the right.
+   -----|-----------------------------------------------------------------
+     0  | Pad with '0' characters when padding on the left to meet WIDTH.
+   -----|-----------------------------------------------------------------
+   blank| Prefix positive numbers with " " (%d and %i only).
+   space|
+   -----|-----------------------------------------------------------------
+     #  | With %x or %X: prefixes non-zero values with "0x"/"0X".
+        | With %o, ensure the value begins with "0" (increasing PRECISION
+        |    if necessary).
+        | Ignored for all other CONV specifiers.
+   -----|-----------------------------------------------------------------
+===/pre>
+
+   WIDTH is an unsigned decimal integer or the character "*".
+
+   WIDTH gives the minimum number of characters to be written.  The
+   formatted value will be padded with spaces until the minimum size is
+   met; it never causes a value to be truncated The sign of the WIDTH
+   integer selects between left and right padding.  Padding will be on
+   the left unless the "-" flag is specified.
+
+   When "*" is used, an 'int' argument is consumed from the argument
+   list and used as the WIDTH.  A negative argument specifies padding on
+   the right, and its absolute value gives the amount of padding.
+
+   If the "0" flags is specified, any padding on the left will consist
+   of "0" characters.  An exception to this rule is that the "0" flag is
+   ignored when precision is specified for a numeric value.
+
+   PRECISION is a non-negative decimal integer or "*" preceded by ".".
+
+   When PRECISION accompanies any of the numeric conversions, it
+   specifies the minimum number of digits to output.  Values are padded
+   on the left with '0' to meet the specified size.  PRECISION defaults
+   to 1 for numbers.
+
+   When PRECISION accompanies other conversions, it specifies the
+   maximum number of characters from the value to output.  The value
+   will be truncated to ensure that at most PRECISION characters are
+   output.
+
+   TYPE provides information about the type of arguments.  This is used
+   to determine the size of integer arguments. Values larger than 'int'
+   can be properly obtained from the argument list.  Their behavior
+   should be considered undefined for CONV operations other than integer
+   formatting.
+
+===pre>
+    TYPE  | Meaning
+   =======|=====================
+     hh   | sizeof(char)
+   -------|---------------------
+      h   | sizeof(short)
+   -------|---------------------
+      l   | sizeof(long)
+   -------|---------------------
+    L, ll | sizeof(long long)
+   -------|---------------------
+      j   | sizeof(int64)
+   -------|---------------------
+      z   | sizeof(size_t)
+   -------|---------------------
+===/pre>
+
+   For 64-bit integers, "ll" may be the most widely-supported type
+   specifier in other printf implementation, but "j" has been introduced
+   in ISO C99. This implementation supports both.
+
+   Note that arguments to variadic functions are promoted to 'int' when
+   smaller than 'int', so 'h' and 'hh' have no observable effect.
+   Static analysis tools that understand standard format string syntax
+   may use this information for other purposes.
+
+Prototype:
+
+   int std_strlprintf(char *pszDest, int nDestSize,
+                      const char *pszFmt, ...);
+Parameters:
+   pszDest [out]: output buffer, where output will be placed
+   nDestSize:     size of pszDest in bytes
+   pszFmt:        format string
+
+Return Value:
+
+   The size required to hold the entire untruncated output, NOT
+   including NUL-termination.
+
+Comments:
+
+   Notable omissions from std_strlprintf() are lack of support for
+   floating point and lack of support for "%n".
+
+Side Effects:
+   None
+
+See Also:
+   None
+
+=======================================================================
+
+std_vstrlprintf()
+
+Description:
+
+  The std_vstrlprintf() is documented with std_strlprintf(), it's the
+  vector form of std_strlprintf().  See std_strlprintf() for a
+  more complete description.
+
+Prototype:
+   int std_vstrlprintf(char *pszDest, int nDestSize,
+                       const char *pszFmt, AEEVaList args);
+
+Parameters:
+   pszDest [out]: output buffer, where output will be placed
+   nDestSize:     size of pszDest in bytes
+   pszFmt:        format string
+   args:          arguments
+
+
+=======================================================================
+
+std_snprintf()
+
+Description:
+
+   The functions std_snprintf() and std_vsnprintf() are similar to
+   std_strlprintf and std_vstrlprintf that write formatted output to a
+   string. Unlike std_strlprintf, std_snprintf also support the floating
+   point conversion specifiers. These functions guarantee NUL-termination
+   of the output buffer when its size is greater than zero.
+
+   A format string is copied to the output buffer, except for conversion
+   specifiers contained within the format string.  Conversion specifiers
+   begin with a "%" and specify some action that consumes an argument from
+   the argument list.
+
+   Conversion specifiers have the following form:
+===pre>
+       %[FLAGS] [WIDTH] [.PRECISION] [TYPE] CONV
+===/pre>
+
+   CONV is the only required field.  It is always a single character,
+   and determines the action to be taken.  For a detailed description of
+   conversion sepcifiers, please refer to the documentation of
+   std_strlprintf(). Here. we only provide description of these fields
+   as it applies to the additional CONV values supported by
+   std_snprintf().
+
+   In addition to the values for CONV supported by std_strlprintf, this
+   function supports the following values:
+
+===pre>
+    CONV | Description
+   ======|=======================================================
+    e, E | Outputs a double value representing a floating point
+         | number in the style [-]d.ddd e±dd, where there is one
+         | digit (which is nonzero if the argument is nonzero)
+         | before the decimal-point character and the number of
+         | digits after it is equal to the precision. If the
+         | precision is missing, it is taken as 6. If the precision
+         | is zero and the # flag is not specified, no decimal-point
+         | character appears. The value is rounded to the appropriate
+         | number of digits. The E conversion specifier produces a
+         | number with E instead of e introducing the exponent. The
+         | exponent always contains at least two digits, and only as
+         | many more digits as necessary to represent the exponent.
+         | If the value is zero, the exponent is zero.
+         |
+    f, F | Outputs a double value representing a floating point
+         | number in the style [-]ddd.ddd, where the number of
+         | digits after the decimal-point character is equal to the
+         | precision specification. If the precision is missing, it
+         | is taken as 6. If the precision is zero and the # flag is
+         | not specified, no decimal-point character appears. If a
+         | decimal-point character appears, at least one digit
+         | appears before it. The value is rounded to the appropriate
+         | number of digits.
+         |
+    g, G | Outputs a double value representing a floating point
+         | number in the style f or e (or in style F or E in the case
+         | of a G conversion specifier), with the precision specifying
+         | the number of significant digits. If the precision is zero,
+         | it is taken as 1. The style used depends on the value
+         | converted. Style e (or E) is used only if the exponent
+         | resulting from such a conversion is less than -4 or greater
+         | than or equal to the precision. Trailing zeros are removed
+         | from the fractional portion of the result unless the # flag
+         | is specified; a decimal-point character appears only if it
+         | is followed by a digit.
+         |
+    a, A | Outputs a double value representing a floating point
+         | number in the style [-]0xh.hhhh p±d, where there is one
+         | non-zero hexadecimal digit before the decimal-point
+         | character and the number of hexadecimal digits after it is
+         | equal to the precision. If the precision is missing then
+         | the precision is assumed to be sufficient for an exact
+         | representation of the value, except that trailing zeros
+         | may be omitted. If the precision is zero and the # flag is
+         | not specified, no decimal point character appears. The
+         | letters 'abcdef' are used for '%a' conversion and the
+         | letters ABCDEF for '%A' conversion. The '%A' conversion
+         | specifier produces a number with 'X' and 'P' instead of 'x'
+         | and 'p'. The exponent always contains at least one digit,
+         | and only as many more digits as necessary to represent the
+         | decimal exponent of 2. If the value is zero, the exponent
+         | is zero.
+         |
+===/pre>
+
+   For 'e', 'f', 'g' and 'a' convervsion specifiers, a double argument
+   representing an infinity is converted in to the style '[-]inf' and
+   a double argument representing a NaN is converted in to the stlye
+   'nan'. The 'E', 'F', 'G' and 'A' conversion specifiers result in
+   'INF' or 'NAN' instead of 'inf' or 'nan', respectively.
+
+Prototype:
+
+   int std_snprintf(char *pszDest, int nDestSize,
+                    const char *pszFmt, ...);
+Parameters:
+   pszDest [out]: output buffer, where output will be placed
+   nDestSize:     size of pszDest in bytes
+   pszFmt:        format string
+
+Return Value:
+
+   The size required to hold the entire untruncated output, NOT
+   including NUL-termination.
+
+Comments:
+
+   Notable omissions from std_strlprintf() lack of support for "%n".
+
+Side Effects:
+   None
+
+See Also:
+   std_strlprintf()
+
+=======================================================================
+
+std_vsnprintf()
+
+Description:
+
+  The std_vsnprintf() is documented with std_snprintf(), it's the
+  vector form of std_snprintf(). See std_snprintf() for a more complete
+  description.
+
+Prototype:
+   int std_vsnprintf(char *pszDest, int nDestSize,
+                     const char *pszFmt, AEEVaList args);
+
+Parameters:
+   pszDest [out]: output buffer, where output will be placed
+   nDestSize:     size of pszDest in bytes
+   pszFmt:        format string
+   args:          arguments
+
+
+=======================================================================
+
+std_scanul()
+
+Description:
+
+    The std_scanul() converts an ASCII representation of a number to an unsigned
+    long.  It expects strings that match the following pattern:
+===pre>
+         spaces [+|-] digits
+===/pre>
+
+    'Spaces' is zero or more ASCII space or tab characters.
+
+    'Digits' is any number of digits valid in the radix.  Letters 'A' through
+    'Z' are treated as digits with values 10 through 35.  'Digits' may begin
+    with "0x" when a radix of 0 or 16 is specified.
+
+    Upper and lower case letters can be used interchangeably.
+
+
+Prototype:
+
+    uint32 std_scanul( const char *pchBuf, int nRadix, const char **ppchEnd,
+                       int *pnError)
+
+Parameters:
+
+    pchBuf [in] : the start of the string to scan.
+
+    nRadix [in] : the numeric radix (or base) of the number.  Valid values are
+                  2 through 36 or zero, which implies auto-detection.
+                  Auto-detection examines the digits field.  If it begins with
+                  "0x", radix 16 is selected.  Otherwise, if it begins with
+                  "0" radix 8 is selected.  Otherwise, radix 10 is selected.
+
+    ppchEnd [out] : if ppchEnd is not NULL, *ppchEnd points to the first
+                    character that did not match the expected pattern shown
+                    above, except on STD_BADPARAM and STD_OVERFLOW when it is
+                    set to the start of the string.
+
+    pnError [out] : If pnError is not NULL, *pnError holds the error code,
+                    which is one of the following:
+~
+        0 : Numeric value is from 0 to MAX_UINT32.
+
+        STD_NEGATIVE : The scanned value was negative and its absolute value was
+                       from 1 to MAX_UINT32.  The result is the negated value
+                       (cast to a uint32).
+
+        STD_NODIGITS : No digits were found.  The result is zero.
+
+        STD_OVERFLOW : The absolute value exceeded MAX_UINT32.  The result
+                       is set to MAX_UINT32 and *ppchEnd is set to pchBuf.
+
+        STD_BADPARAM : An improper value for nRadix was received.  The result
+                       is set to zero, and *ppchEnd is set to pchBuf.
+*
+
+Return Value:
+
+    The converted numeric result.
+
+Comments:
+
+   The std_scanul() is similar to ANSI C's strtoul() but differs in the following
+   respects:
+
+     1. It returns an error/success code.  strtoul() results are ambiguous
+        unless the caller sets errno to zero before calling it.
+
+     2. std_scanul() is free of references to current locale and errno.  Some
+        strtoul() implementations use locale; some don't.
+
+     3. It provides more complete reporting of range underflow.  strtoul()
+        does not distinguish between "-1" and "0xFFFFFFFF", and underflow is
+        poorly defined.
+
+     4. std_scanul() reports a "no digits" error code to distinguish "0" from
+        whitespace, "+", etc..
+
+See Also:
+
+   std_scanull()
+
+=======================================================================
+
+std_scanull()
+
+Description:
+
+    The std_scanull() converts an ASCII representation of a number to an
+    unsigned long long.  It expects strings that match the following pattern:
+===pre>
+         spaces [+|-] digits
+===/pre>
+
+    'Spaces' is zero or more ASCII space or tab characters.
+
+    'Digits' is any number of digits valid in the radix.  Letters 'A' through
+    'Z' are treated as digits with values 10 through 35.  'Digits' may begin
+    with "0x" when a radix of 0 or 16 is specified.
+
+    Upper and lower case letters can be used interchangeably.
+
+
+Prototype:
+
+    uint64 std_scanull(const char *pchBuf, int nRadix, const char **ppchEnd,
+                       int *pnError)
+
+Parameters:
+
+    pchBuf [in] : the start of the string to scan.
+
+    nRadix [in] : the numeric radix (or base) of the number.  Valid values are
+                  2 through 36 or zero, which implies auto-detection.
+                  Auto-detection examines the digits field.  If it begins with
+                  "0x", radix 16 is selected.  Otherwise, if it begins with
+                  "0" radix 8 is selected.  Otherwise, radix 10 is selected.
+
+    ppchEnd [out] : if ppchEnd is not NULL, *ppchEnd points to the first
+                    character that did not match the expected pattern shown
+                    above, except on STD_BADPARAM and STD_OVERFLOW when it is
+                    set to the start of the string.
+
+    pnError [out] : If pnError is not NULL, *pnError holds the error code,
+                    which is one of the following:
+~
+        0 : Numeric value is from 0 to MAX_UINT64.
+
+        STD_NEGATIVE : The scanned value was negative and its absolute value was
+                       from 1 to MAX_UINT64.  The result is the negated value
+                       (cast to a uint64).
+
+        STD_NODIGITS : No digits were found.  The result is zero.
+
+        STD_OVERFLOW : The absolute value exceeded MAX_UINT64.  The result
+                       is set to MAX_UINT64 and *ppchEnd is set to pchBuf.
+
+        STD_BADPARAM : An improper value for nRadix was received.  The result
+                       is set to zero, and *ppchEnd is set to pchBuf.
+*
+
+Return Value:
+
+    The converted numeric result.
+
+Comments:
+
+   The std_scanull() is similar to ANSI C's strtoull() but differs in the following
+   respects:
+
+     1. It returns an error/success code.  strtoull() results are ambiguous
+        unless the caller sets errno to zero before calling it.
+
+     2. std_scanull() is free of references to current locale and errno.  Some
+        strtoull() implementations use locale; some don't.
+
+     3. It provides more complete reporting of range underflow.  strtoul()
+        does not distinguish between "-1" and "0xFFFFFFFFFFFFFFFF", and underflow
+        is poorly defined.
+
+     4. std_scanull() reports a "no digits" error code to distinguish "0" from
+        whitespace, "+", etc..
+
+See Also:
+
+   std_scanul()
+
+=======================================================================
+
+std_qsort()
+
+Description:
+
+  An implementation of the quicksort algorithm, a massively recursive,
+  in-place sorting algorithm for an array.
+
+  The contents of the array are sorted in ascending order according to
+  the comparison function pointed to by pfnCompare.
+
+  pfnCompare must return a value less than, equal to, or
+  greater than zero if the first argument is considered to be
+  less than, equal to, or greater than the second, respectively.
+
+  std_qsort() is not a stable sort.
+
+Prototype:
+   void std_qsort(void* pElems, int nNumElems, int nElemWidth,
+                  int (*pfnCompare)(void*, const void*, const void*),
+                  void* pCompareCx);
+
+
+Parameters:
+   pElems: array of elements to be sorted in place.  It's size
+           must be nNumElems * nElemWidth in bytes.
+   nNumElems: number of elements in pElems
+   nElemWidth: the width, in bytes of each element of pElems
+   pfnCompare: callback comparison function, should return 0, less than
+               zero or greater than zero if the left comparand is equal to, less
+               than, or greater than, the right comparand, respectively.
+   pCompareCx: the context passed as the first parameter by pfnCompare
+
+Return Value:
+   None
+
+Comments:
+   If nElemWidth is 2, 4, or 8, pElems is accessed internally as
+   integer values for the purposes of reading and writing elements.
+   Therefore, pElems must be aligned on a memory boundary compatible
+   with integer access of the array elements.  I.e. if you pass 4 as
+   nElemWidth, *(int*)pElems must succeed.
+
+=======================================================================
+
+std_bisect()
+
+Description:
+
+   Find an element in a sorted array of elements.  Uses a binary
+   search.
+
+Prototype:
+   int std_bisect(const void* pElems, int nNumElems, int nElemWidth,
+                  const void* pElemFind,
+                  int (*pfnCompare)(void*, const void*, const void*),
+                  void* pCompareCx);
+
+Parameters:
+   pElems: array of elements to be searched.  It's size
+           must be nNumElems * nElemWidth in bytes.
+   nNumElems: number of elements in pElems
+   nElemWidth: the width, in bytes of each element of pElems
+   pElemFind: the element value to find in the array
+   pfnCompare: callback comparison function, should return 0, less than
+               zero or greater than zero if the left comparand is equal to, less
+               than, or greater than, the right comparand, respectively.
+   pCompareCx: the context passed as the first parameter by pfnCompare
+
+Return Value:
+   index of the element such that pElems[index] <= elem < pElems[index + 1]
+   nNumElems if elem is greater than all the elements in the list
+   0 if the elem is less than or equal to the all the elements in the list
+
+=======================================================================
+
+std_merge()
+
+Description:
+
+   Merge two sorted arrays into another array.
+
+Prototype:
+   void std_merge(void* vpDst, int nDst,
+                  const void* vpA, int nA,
+                  const void* vpB, int nB,
+                  int nElemWidth,
+                  int (*pfnCompare)(void*, const void*, const void*),
+                  void* pCompareCx);
+
+Parameters:
+   vpDst: destination array.  It's size must be nDst * nElemWidth in bytes.
+   nDst: number of elements that vpDst can accomodate
+   vpA: array of elements to be merged,  it's size must be nA * nElemWidth
+         in bytes.
+   nA: number of elements in vpA
+   vpB: array of elements to be merged,  it's size must be nB * nElemWidth
+         in bytes.
+   nB: number of elements in vpB
+   nElemWidth: the width, in bytes of each element of pElems
+   pfnCompare: callback comparison function, should return 0, less than
+               zero or greater than zero if the left comparand is equal to, less
+               than, or greater than, the right comparand, respectively.
+   pCompareCx: the context passed as the first parameter by pfnCompare
+
+Return Value:
+  none
+
+=======================================================================
+
+std_uniq()
+
+Description:
+   Removes duplicate entries from a sorted array.
+
+Prototype:
+   int std_uniq(void* vpElems, int nNumElems, int nElemWidth,
+                int (*pfnCompare)(void*, const void*, const void*),
+                void* pCompareCx);
+
+Parameters:
+   pElems: array of elements to be searched.  It's size
+           must be nNumElems * nElemWidth in bytes.
+   nNumElems: number of elements in pElems
+   nElemWidth: the width, in bytes of each element of pElems
+   pfnCompare: callback comparison function, should return 0, less than
+               zero or greater than zero if the left comparand is equal to, less
+               than, or greater than, the right comparand, respectively.
+   pCompareCx: the context passed as the first parameter by pfnCompare
+
+Return Value:
+   the number of uniq elements left in vpElems
+
+=======================================================================
+
+std_scand()
+
+Description:
+
+   The std_scand() converts the initial portion of an input ASCII string
+   to it's corresponding floating point value. It expects the input
+   string to match the following pattern:
+===pre>
+         <Spaces><Subject String><Rest Of The String>
+===/pre>
+
+   'Spaces' - is zero or more ASCII space or tab characters.
+   'Subject String' - is the part of the input string that represents a
+                      valid floating point constant.
+   'Rest Of The String' - is the remaining sequence of one or more
+                          characters including the terminating null
+                          character of the input string.
+
+   A valid subject string can be one of the following:
+      -- <NAN>, ignoring case. This is interpreted as a quiet NAN.
+      -- [+|-]<INF|INFINITY>, ignoring case. This is interpreted as an
+         infinity.
+      -- [+|-]<Valid Floating Point Number>
+
+   In general, a valid floating poing number can either be a decimal
+   number or an hexadecimal number, and has the following form:
+      <Integral Part>[.[<Fractional Part>]][<Exponent>]
+   where the intergral, fractional and the exponent part may consist of
+   sequence of valid decimal or hexadecimal digits. More specifically:
+
+   For a decimal floating point number:
+      'Integral Part' - <Decimal Digits>
+      'Fractional Part' - <Decimal Digits>
+      'Exponent' - <e|E><Decimal Digits>
+   For a hexadecimal floating point number:
+      'Integral Part' - <Hexadecimal Digits>
+      'Fractional Part' - <Hexadecimal Digits>
+      'Exponent' - <p|P><Decimal Digits>
+
+   where:
+      'Decimal Digits' - is any number of digits in the range [0,10].
+      'Hexadecimal Digits' - is any number of digits in the range [0,10]
+                             or the alphabets A through F.
+      'e','E','p','P' - represent the exponent characters
+
+Prototype:
+
+    double std_scand(const char *pchBuf, const char **ppchEnd);
+
+Parameters:
+
+    pchBuf [in] : the start of the string to scan.
+
+    ppchEnd [out] : if ppchEnd is not NULL, *ppchEnd points to the first
+                    character after the parsed number.
+
+Return Value:
+
+    This function returns the converted numeric result. If the string
+    does not contain a valid floating point number then the function
+    returns zero. If the converted value is outside the range of
+    representable values (overflow), [-]INFINITY is
+    returned. In case of an underflow, the function returns zero.
+
+=======================================================================*/
+
+#endif // AEESTD_H
+
+
diff --git a/inc/HAP_debug.h b/inc/HAP_debug.h
new file mode 100644
index 0000000..c4c2b8c
--- /dev/null
+++ b/inc/HAP_debug.h
@@ -0,0 +1,102 @@
+#ifndef HAP_DEBUG_H
+#define HAP_DEBUG_H
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "AEEStdDef.h"
+#include <stdarg.h>
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HAP_LEVEL_LOW       0
+#define HAP_LEVEL_MEDIUM    1
+#define HAP_LEVEL_HIGH      2
+#define HAP_LEVEL_ERROR     3
+#define HAP_LEVEL_FATAL     4
+
+#define HAP_LEVEL_RUNTIME   (1 << 5)
+
+//Add a weak reference so shared objects work with older images
+#pragma weak HAP_debug_v2
+
+//Add a weak reference so runtime FARFs are ignored on older images
+#pragma weak HAP_debug_runtime
+
+/**************************************************************************
+    These HAP_debug* functions are not meant to be called directly.
+    Please use the FARF() macros to call them instead
+**************************************************************************/
+void HAP_debug_v2(int level, const char* file, int line, const char* format, ...);
+void HAP_debug_runtime(int level, const char* file, int line, const char* format, ...);
+int HAP_setFARFRuntimeLoggingParams(unsigned int mask, const char* files[],
+                                    unsigned short numberOfFiles);
+
+// Keep these around to support older shared objects and older images
+void HAP_debug(const char *msg, int level, const char *filename, int line);
+
+static __inline void _HAP_debug_v2(int level, const char* file, int line,
+                          const char* format, ...){
+   char buf[256];
+   va_list args;
+   va_start(args, format);
+   vsnprintf(buf, sizeof(buf), format, args);
+   va_end(args);
+   HAP_debug(buf, level, file, line);
+}
+
+/*!
+This function is called to log an accumlated log entry. If logging is
+enabled for the entry by the external device, then the entry is copied
+into the diag allocation manager and commited.
+
+    [in] log_code_type    ID of the event to be reported
+    [in] *data            data points to the log which is to be submitted
+    [in] dataLen          The length of the data to be logged.
+
+Returns
+    TRUE if log is submitted successfully into diag buffers
+    FALSE if there is no space left in the buffers.
+
+*/
+boolean HAP_log_data_packet(unsigned short log_code_type, unsigned int dataLen,
+                    byte* data);
+
+#define HAP_DEBUG_TRACEME 0
+
+long HAP_debug_ptrace(int req, unsigned int pid, void* addr, void* data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // HAP_DEBUG_H
+
diff --git a/inc/HAP_farf.h b/inc/HAP_farf.h
new file mode 100644
index 0000000..48e123a
--- /dev/null
+++ b/inc/HAP_farf.h
@@ -0,0 +1,226 @@
+#ifndef HAP_FARF_H
+#define HAP_FARF_H
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "AEEStdDef.h"
+#include "HAP_debug.h"
+
+/**
+ * FARF macro used for logging
+ *
+ * Compile time logging options
+ * -----------------------------
+ *
+ * Logging is controlled via conditional compilation. A FARF
+ * level should be defined to 1 for FARF macros to be compiled
+ * in. For example:
+ *
+ *    #define FARF_LOW 1
+ *    #include "HAP_farf.h"
+ *
+ *    FARF(LOW, "something happened: %s", (const char*)string);
+ *
+ * If FARF_LOW is defined to 0, as it is by default, the above
+ * FARF string will not be compiled in, if it is defined to 1 it
+ * will be compiled in.  Users can also define their own custom
+ * levels. For example:
+ *
+ *    #include "HAP_farf.h"
+ *    #define FARF_MYTRACE 1
+ *    #define FARF_MYTRACE_LEVEL HAP_LEVEL_LOW
+ *
+ *    FARF(MYTRACE, "custom trace in file %s on line %d", __FILE__, __LINE__);
+ *
+ * The LEVEL define tells FARF what logging level to
+ * use.  These are  mapped to their diag level counterparts, in
+ * the above example the message will be logged to diag's LOW
+ * level.
+ *
+ * Messages logged with ALWAYS level are always compiled in and logged
+ *                      ------
+ *
+ * When building the Debug variant or builds defining _DEBUG the
+ * following FARF levels will be enabled:
+ *
+ *    HIGH
+ *    ERROR
+ *    FATAL
+ *
+ *
+ *
+ * Run time logging options
+ * --------------------------
+ *
+ * In order to enable run-time logging (logging that can be enabled / disabled
+ * at run-time), the FARF_RUNTIME_* macros should be used.
+ *
+ * Log messages sent with these macros are compiled in by default. However by
+ * these messages WILL NOT be logged by default. In order to enable logging,
+ * the FASTRPC process will need to either call the
+ * HAP_SetFARFRuntimeLoggingParams() API, or by adding a <process_name>.farf
+ * file to the HLOS file system with the appropriate contents.
+ *
+ *      #include "HAP_farf.h"
+ *      FARF(RUNTIME_HIGH, "something happened: %s", (const char*)string);
+ *
+ */
+
+
+ /*
+ * @param x, the FARF level defined to either 0 to disable compilation or 1 to enable.
+ * @param ..., format string and arguments.
+ */
+#define FARF(x, ...) _FARF_PASTE(_FARF_,_FARF_VAL(FARF_##x))(x, ##__VA_ARGS__)
+
+/* by default _DEBUG turns on ALWAYS, HIGH, ERROR, FATAL
+ *
+ */
+#ifdef _DEBUG
+#ifndef FARF_HIGH
+#define FARF_HIGH 1
+#endif
+#ifndef FARF_ERROR
+#define FARF_ERROR 1
+#endif
+#ifndef FARF_FATAL
+#define FARF_FATAL 1
+#endif
+#endif
+
+/*  Compile time macros. Set these to 1 to enable logging at that
+    level. Setting them to 0 will cause them to be COMPILED out .
+
+    Example Usage:
+    #define FARF_HIGH 1
+    FARF(HIGH,"Log message");
+
+    Defining _DEBUG will automatically enable compiled log messages with
+    priority higher than HIGH.
+
+    The ALWAYS macro will cause log messages to be ALWAYS compiled in.
+    FARF(ALWAYS,"Log message")
+*/
+
+#ifndef FARF_ALWAYS
+#define FARF_ALWAYS        1    /* 0 turns me off */
+#endif
+#define FARF_ALWAYS_LEVEL  HAP_LEVEL_HIGH
+
+#ifndef FARF_LOW
+#define FARF_LOW           0    /* 0 turns me off */
+#endif
+#define FARF_LOW_LEVEL     HAP_LEVEL_LOW
+
+#ifndef FARF_MEDIUM
+#define FARF_MEDIUM        0    /* 0 turns me off */
+#endif
+#define FARF_MEDIUM_LEVEL  HAP_LEVEL_MEDIUM
+
+#ifndef FARF_HIGH
+#define FARF_HIGH          0    /* 0 turns me off */
+#endif
+#define FARF_HIGH_LEVEL    HAP_LEVEL_HIGH
+
+#ifndef FARF_ERROR
+#define FARF_ERROR         0    /* 0 turns me off */
+#endif
+#define FARF_ERROR_LEVEL   HAP_LEVEL_ERROR
+
+#ifndef FARF_FATAL
+#define FARF_FATAL         0    /* 0 turns me off */
+#endif
+#define FARF_FATAL_LEVEL   HAP_LEVEL_FATAL
+
+/* Runtime FARF macros. FARFs with these levels can be enabled at runtime.
+   They are turned OFF by default.
+
+    Example Usage:
+
+    FARF(RUNTIME_HIGH,"Log message");
+*/
+#ifndef FARF_RUNTIME_LOW
+#define FARF_RUNTIME_LOW           1    /* 0 turns me off */
+#endif
+#define FARF_RUNTIME_LOW_LEVEL     (HAP_LEVEL_RUNTIME | HAP_LEVEL_LOW)
+
+#ifndef FARF_RUNTIME_MEDIUM
+#define FARF_RUNTIME_MEDIUM        1    /* 0 turns me off */
+#endif
+#define FARF_RUNTIME_MEDIUM_LEVEL  (HAP_LEVEL_RUNTIME | HAP_LEVEL_MEDIUM)
+
+#ifndef FARF_RUNTIME_HIGH
+#define FARF_RUNTIME_HIGH          1    /* 0 turns me off */
+#endif
+#define FARF_RUNTIME_HIGH_LEVEL    (HAP_LEVEL_RUNTIME | HAP_LEVEL_HIGH)
+
+#ifndef FARF_RUNTIME_ERROR
+#define FARF_RUNTIME_ERROR         1    /* 0 turns me off */
+#endif
+#define FARF_RUNTIME_ERROR_LEVEL   (HAP_LEVEL_RUNTIME | HAP_LEVEL_ERROR)
+
+#ifndef FARF_RUNTIME_FATAL
+#define FARF_RUNTIME_FATAL         1    /* 0 turns me off */
+#endif
+#define FARF_RUNTIME_FATAL_LEVEL   (HAP_LEVEL_RUNTIME | HAP_LEVEL_FATAL)
+
+//internal macros
+#define _FARF_PASTE(a,b) _FARF_PASTE_(a,b)
+#define _FARF_PASTE_(a,b) a##b
+#define _FARF_VAL(a) a
+
+//internal macro
+//this one is used when farfs are not compiled in
+#define _FARF_0(x, ...)
+
+#ifndef __FILENAME__
+#define __FILENAME__ __FILE__
+#endif
+
+//lint -emacro(506,FARF) Constant Boolean Value
+//lint -emacro(774,FARF) Boolean within always evaluates to True
+//this one is used when farfs are compiled in
+#define _FARF_1(x, ...) \
+    do { \
+            if(0 == (HAP_debug_v2)) { \
+                _HAP_debug_v2(FARF_##x##_LEVEL, __FILENAME__, __LINE__, ##__VA_ARGS__); \
+            } else { \
+                if (FARF_##x##_LEVEL & HAP_LEVEL_RUNTIME) { \
+                    if (0 != HAP_debug_runtime) { \
+                        HAP_debug_runtime(FARF_##x##_LEVEL ^ HAP_LEVEL_RUNTIME , __FILENAME__, __LINE__, ##__VA_ARGS__); \
+                    } else { \
+                        break; \
+                    } \
+                } else { \
+                    HAP_debug_v2(FARF_##x##_LEVEL, __FILENAME__, __LINE__, ##__VA_ARGS__); \
+                } \
+            } \
+        } while (0)
+
+#endif /* #ifndef HAP_FARF_H */
diff --git a/inc/HAP_pls.h b/inc/HAP_pls.h
new file mode 100644
index 0000000..23d7ddd
--- /dev/null
+++ b/inc/HAP_pls.h
@@ -0,0 +1,129 @@
+#ifndef HAP_PLS_H
+#define HAP_PLS_H
+
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Process local storage is local storage for the hlos process context.
+ *
+ * Warning, this API should only be called from within a thread started by FastRPC, and not from
+ * any user created threads via the qurt apis.
+ *
+ * When used from within a FastRPC started thread this will attach
+ * desturctors to the lifetime of the HLOS process that is making the
+ * rpc calls.  Users can use this to store context for the lifetime of
+ * the calling process on the hlos.
+ *
+ * Recovering instances
+ * --------------------
+ *
+ * To maintain the same instance structure for a caller from the HLOS users
+ * can use the HAP_pls_add_lookup api, which will lookup the key, and add it
+ * if its not already present.
+ * For example:
+ *
+ *    static int my_instance(struct my_struct* me)  {
+ *       return HAP_pls_add_lookup((uintptr_t)my_ctor,   //type, some unique static address
+ *                                  0,                //key, for different type instances
+ *                                  sizeof(*me),      //size of our struture
+ *                                  my_ctor,          //structure ctor
+ *                                  0,                //aditional user context for ctor
+ *                                  my_dtor,          //desturctor
+ *                                  &me);             //result
+ *    }
+ *
+ * First call to my_instance will initialize the structure by allocating it and calling my_ctor.
+ * Second call to my_instance will return the created instance.
+ * This API is thread safe, but when two threads try to intialize the structure the first
+ * time they may both create an instance, but only 1 will be returned.
+ * The destructor will be called when the HLOS process exits.
+ *
+ * See HAP_pls_add and HAP_pls_add_lookup.
+ *
+ * Exit Hooks
+ * ----------
+ *
+ * Users can use either HAP_pls_add_lookup or HAP_pls_add to add a destructor that will be
+ * called when the HLOS process exits.  The main difference between the two functions is that
+ * HAP_pls_add will always add, and the last instance added will be the one returned by
+ * HAP_pls_lookup.
+ *
+ *
+ */
+
+/**
+ * adds a new type/key to the local storage, overriding
+ * any previous value at the key.  Overriding the key
+ * does not cause the destructor to run.  Destructors are
+ * run when the HLOS process exits.
+ *
+ * @param type, type part of the key to be used for lookup,
+ *        these should be static addresses, like the address of a function.
+ * @param key, the key to be used for lookup
+ * @param size, the size of the data
+ * @param ctor, constructor that takes a context and memory of size
+ * @param ctx, constructor context passed as the first argument to ctor
+ * @param dtor, destructor to run at pls shutdown
+ * @param ppo, output data
+ * @retval, 0 for success
+ */
+int HAP_pls_add(uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void*), void** ppo);
+
+/**
+ * Like add, but will only add 1 item, and return the same item on the
+ * next add.  If two threads try to call this function at teh same time
+ * they will both receive the same value as a result, but the constructors
+ * may be called twice.
+ * item if its already there, otherwise tries to add.
+ * ctor may be called twice
+ * callers should avoid calling pls_add for the same type/key which will override the singleton
+ */
+int HAP_pls_add_lookup(uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void*), void** ppo);
+
+/**
+ * finds the last data pointer added for key to the local storage
+ *
+ * @param key, the key to be used for lookup
+ * @param ppo, output data
+ * @retval, 0 for success
+ */
+int HAP_pls_lookup(uintptr_t type, uintptr_t key, void** ppo);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif //HAP_PLS_H
diff --git a/inc/adsp_current_process.h b/inc/adsp_current_process.h
new file mode 100644
index 0000000..a9bf630
--- /dev/null
+++ b/inc/adsp_current_process.h
@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+#ifndef _ADSP_CURRENT_PROCESS_H
+#define _ADSP_CURRENT_PROCESS_H
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if !defined(__QAIC_STRING1_OBJECT_DEFINED__) && !defined(__STRING1_OBJECT__)
+#define __QAIC_STRING1_OBJECT_DEFINED__
+#define __STRING1_OBJECT__
+typedef struct _cstring1_s {
+   char* data;
+   int dataLen;
+} _cstring1_t;
+
+#endif /* __QAIC_STRING1_OBJECT_DEFINED__ */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process_exit)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process_thread_exit)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process_set_logging_params)(unsigned short mask, const _cstring1_t* filesToLog, int filesToLogLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process_getASID)(unsigned int* asid) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_CURRENT_PROCESS_H
diff --git a/inc/adsp_current_process1.h b/inc/adsp_current_process1.h
new file mode 100644
index 0000000..67ab15d
--- /dev/null
+++ b/inc/adsp_current_process1.h
@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSP_CURRENT_PROCESS1_H
+#define _ADSP_CURRENT_PROCESS1_H
+#include "remote.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if !defined(__QAIC_STRING1_OBJECT_DEFINED__) && !defined(__STRING1_OBJECT__)
+#define __QAIC_STRING1_OBJECT_DEFINED__
+#define __STRING1_OBJECT__
+typedef struct _cstring1_s {
+   char* data;
+   int dataLen;
+} _cstring1_t;
+
+#endif /* __QAIC_STRING1_OBJECT_DEFINED__ */
+#define _const_adsp_current_process1_handle 4
+/**
+    * Opens the handle in the specified domain.  If this is the first
+    * handle, this creates the session.  Typically this means opening
+    * the device, aka open("/dev/adsprpc-smd"), then calling ioctl
+    * device APIs to create a PD on the DSP to execute our code in,
+    * then asking that PD to dlopen the .so and dlsym the skel function.
+    *
+    * @param uri, <interface>_URI"&_dom=aDSP"
+    *    <interface>_URI is a QAIC generated uri, or
+    *    "file:///<sofilename>?<interface>_skel_handle_invoke&_modver=1.0"
+    *    If the _dom parameter is not present, _dom=DEFAULT is assumed
+    *    but not forwarded.
+    *    Reserved uri keys:
+    *      [0]: first unamed argument is the skel invoke function
+    *      _dom: execution domain name, _dom=mDSP/aDSP/DEFAULT
+    *      _modver: module version, _modver=1.0
+    *      _*: any other key name starting with an _ is reserved
+    *    Unknown uri keys/values are forwarded as is.
+    * @param h, resulting handle
+    * @retval, 0 on success
+    */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process1_open)(const char* uri, remote_handle64* h) __QAIC_HEADER_ATTRIBUTE;
+/** 
+    * Closes a handle.  If this is the last handle to close, the session
+    * is closed as well, releasing all the allocated resources.
+
+    * @param h, the handle to close
+    * @retval, 0 on success, should always succeed
+    */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process1_close)(remote_handle64 h) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process1_exit)(remote_handle64 _h) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process1_thread_exit)(remote_handle64 _h) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process1_set_logging_params)(remote_handle64 _h, unsigned short mask, const _cstring1_t* filesToLog, int filesToLogLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_current_process1_getASID)(remote_handle64 _h, unsigned int* asid) __QAIC_HEADER_ATTRIBUTE;
+#ifndef adsp_current_process1_URI
+#define adsp_current_process1_URI "file:///libadsp_current_process1_skel.so?adsp_current_process1_skel_handle_invoke&_modver=1.0"
+#endif /*adsp_current_process1_URI*/
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_CURRENT_PROCESS1_H
diff --git a/inc/adsp_default_listener.h b/inc/adsp_default_listener.h
new file mode 100644
index 0000000..e4353d1
--- /dev/null
+++ b/inc/adsp_default_listener.h
@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSP_DEFAULT_LISTENER_H
+#define _ADSP_DEFAULT_LISTENER_H
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_default_listener_register)(void) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_DEFAULT_LISTENER_H
diff --git a/inc/adsp_listener.h b/inc/adsp_listener.h
new file mode 100644
index 0000000..dd05eec
--- /dev/null
+++ b/inc/adsp_listener.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSP_LISTENER_H
+#define _ADSP_LISTENER_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define _const_adsp_listener_handle 3
+typedef struct _adsp_listener_buffer__seq_uint8 _adsp_listener_buffer__seq_uint8;
+typedef _adsp_listener_buffer__seq_uint8 adsp_listener_buffer;
+struct _adsp_listener_buffer__seq_uint8 {
+   uint8* data;
+   int dataLen;
+};
+typedef uint32 adsp_listener_remote_handle;
+typedef uint32 adsp_listener_invoke_ctx;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_listener_next_invoke)(adsp_listener_invoke_ctx prevCtx, int prevResult, const adsp_listener_buffer* outBufs, int outBufsLen, adsp_listener_invoke_ctx* ctx, adsp_listener_remote_handle* handle, uint32* sc, adsp_listener_buffer* inBuffers, int inBuffersLen, int* inBufLenReq, int inBufLenReqLen, int* routBufLenReq, int routBufLenReqLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_listener_invoke_get_in_bufs)(adsp_listener_invoke_ctx ctx, adsp_listener_buffer* inBuffers, int inBuffersLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_listener_init)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_listener_init2)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_listener_next2)(adsp_listener_invoke_ctx prevCtx, int prevResult, const uint8* prevbufs, int prevbufsLen, adsp_listener_invoke_ctx* ctx, adsp_listener_remote_handle* handle, uint32* sc, uint8* bufs, int bufsLen, int* bufsLenReq) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_listener_get_in_bufs2)(adsp_listener_invoke_ctx ctx, int offset, uint8* bufs, int bufsLen, int* bufsLenReq) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_LISTENER_H
diff --git a/inc/adsp_perf.h b/inc/adsp_perf.h
new file mode 100644
index 0000000..d2ce8a0
--- /dev/null
+++ b/inc/adsp_perf.h
@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSP_PERF_H
+#define _ADSP_PERF_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * Interface for querying the adsp for counter data
+ * For example, to enable all the perf numbers:
+ * 
+ *     int perf_on(void) {
+ *       int nErr = 0;
+ *       int numKeys = 0, maxLen = 0, ii;
+ *       char keys[512];
+ *       char* buf = &keys[0];
+ *       VERIFY(0 == adsp_perf_get_keys(keys, 512, &maxLen, &numKeys)); 
+ *       assert(maxLen < 512);
+ *       for(ii = 0; ii < numKeys; ++ii) {
+ *          char* name = buf;
+ *          buf += strlen(name) + 1;
+ *          printf("perf on: %s\n", name);
+ *          VERIFY(0 == adsp_perf_enable(ii));
+ *       }
+ *    bail:
+ *       return nErr;
+ *    }
+ *
+ * To read all the results:
+ *
+ *    int rpcperf_perf_result(void) {
+ *       int nErr = 0;
+ *       int numKeys, maxLen, ii;
+ *       char keys[512];
+ *       char* buf = &keys[0];
+ *       long long usecs[16];
+ *       VERIFY(0 == adsp_perf_get_keys(keys, 512, &maxLen, &numKeys)); 
+ *       printf("perf keys: %d\n", numKeys);
+ *       VERIFY(0 == adsp_perf_get_usecs(usecs, 16));
+ *       assert(maxLen < 512);
+ *       assert(numKeys < 16);
+ *       for(ii = 0; ii < numKeys; ++ii) {
+ *          char* name = buf;
+ *          buf += strlen(name) + 1;
+ *          printf("perf result: %s %lld\n", name, usecs[ii]);
+ *       }
+ *    bail:
+ *       return nErr;
+ *    }
+ */
+#define _const_adsp_perf_handle 6
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_perf_enable)(int ix) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_perf_get_usecs)(int64* dst, int dstLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adsp_perf_get_keys)(char* keys, int keysLen, int* maxLen, int* numKeys) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_PERF_H
diff --git a/inc/adsp_pls.h b/inc/adsp_pls.h
new file mode 100644
index 0000000..e21679d
--- /dev/null
+++ b/inc/adsp_pls.h
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ADSP_PLS_H
+#define ADSP_PLS_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * internal header
+ */
+
+/**
+ * adsp process local storage is local storage for the fastrpc hlos
+ * process context.
+
+ * When used from within a fastrpc started thread this will attach
+ * desturctors to the lifetime of the hlos process that is making the
+ * rpc calls.  Users can use this to store context for the lifetime of
+ * the calling process on the hlos.
+ */
+
+/**
+ * adds a new key to the local storage, overriding
+ * any previous value at the key.  Overriding the key
+ * does not cause the destructor to run.
+ *
+ * @param type, type part of the key to be used for lookup,
+ *        these should be static addresses, like the address of a function.
+ * @param key, the key to be used for lookup
+ * @param size, the size of the data
+ * @param ctor, constructor that takes a context and memory of size
+ * @param ctx, constructor context passed as the first argument to ctor
+ * @param dtor, destructor to run at pls shutdown
+ * @param ppo, output data
+ * @retval, 0 for success
+ */
+int adsp_pls_add(uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void*), void** ppo);
+
+/**
+ * Like add, but will only add 1 item, and return the same item on the
+ * next add.  If two threads try to call this function at teh same time
+ * they will both receive the same value as a result, but the constructors
+ * may be called twice.
+ * item if its already there, otherwise tries to add.
+ * ctor may be called twice
+ * callers should avoid calling pls_add which will override the singleton
+ */
+int adsp_pls_add_lookup(uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void*), void** ppo);
+
+/**
+ * finds the last data pointer added for key to the local storage
+ *
+ * @param key, the key to be used for lookup
+ * @param ppo, output data
+ * @retval, 0 for success
+ */
+int adsp_pls_lookup(uintptr_t type, uintptr_t key, void** ppo);
+
+/**
+ * force init/deinit
+ */
+int gpls_init(void);
+void gpls_deinit(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif //ADSP_PLS_H
diff --git a/inc/adspmsgd_adsp.h b/inc/adspmsgd_adsp.h
new file mode 100644
index 0000000..b9094bd
--- /dev/null
+++ b/inc/adspmsgd_adsp.h
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSPMSGD_ADSP_H
+#define _ADSPMSGD_ADSP_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp_init)(int heapid, uint32 ion_flags, uint32 filter, uint32 buf_size, int* buff_addr) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp_init2)(void) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp_deinit)(void) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSPMSGD_ADSP_H
diff --git a/inc/adspmsgd_adsp1.h b/inc/adspmsgd_adsp1.h
new file mode 100644
index 0000000..1166004
--- /dev/null
+++ b/inc/adspmsgd_adsp1.h
@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSPMSGD_ADSP1_H
+#define _ADSPMSGD_ADSP1_H
+#include "AEEStdDef.h"
+#include "remote.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define _const_adspmsgd_adsp1_handle 5
+/**
+    * Opens the handle in the specified domain.  If this is the first
+    * handle, this creates the session.  Typically this means opening
+    * the device, aka open("/dev/adsprpc-smd"), then calling ioctl
+    * device APIs to create a PD on the DSP to execute our code in,
+    * then asking that PD to dlopen the .so and dlsym the skel function.
+    *
+    * @param uri, <interface>_URI"&_dom=aDSP"
+    *    <interface>_URI is a QAIC generated uri, or
+    *    "file:///<sofilename>?<interface>_skel_handle_invoke&_modver=1.0"
+    *    If the _dom parameter is not present, _dom=DEFAULT is assumed
+    *    but not forwarded.
+    *    Reserved uri keys:
+    *      [0]: first unamed argument is the skel invoke function
+    *      _dom: execution domain name, _dom=mDSP/aDSP/DEFAULT
+    *      _modver: module version, _modver=1.0
+    *      _*: any other key name starting with an _ is reserved
+    *    Unknown uri keys/values are forwarded as is.
+    * @param h, resulting handle
+    * @retval, 0 on success
+    */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp1_open)(const char* uri, remote_handle64* h) __QAIC_HEADER_ATTRIBUTE;
+/** 
+    * Closes a handle.  If this is the last handle to close, the session
+    * is closed as well, releasing all the allocated resources.
+
+    * @param h, the handle to close
+    * @retval, 0 on success, should always succeed
+    */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp1_close)(remote_handle64 h) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp1_init2)(remote_handle64 _h) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_adsp1_deinit)(remote_handle64 _h) __QAIC_HEADER_ATTRIBUTE;
+#ifndef adspmsgd_adsp1_URI
+#define adspmsgd_adsp1_URI "file:///libadspmsgd_adsp1_skel.so?adspmsgd_adsp1_skel_handle_invoke&_modver=1.0"
+#endif /*adspmsgd_adsp1_URI*/
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSPMSGD_ADSP1_H
diff --git a/inc/adspmsgd_apps.h b/inc/adspmsgd_apps.h
new file mode 100644
index 0000000..64db95d
--- /dev/null
+++ b/inc/adspmsgd_apps.h
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _ADSPMSGD_APPS_H
+#define _ADSPMSGD_APPS_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+enum adspmsgd_apps_Level {
+   LOW,
+   MEDIUM,
+   HIGH,
+   ERROR,
+   FATAL,
+   _32BIT_PLACEHOLDER_adspmsgd_apps_Level = 0x7fffffff
+};
+typedef enum adspmsgd_apps_Level adspmsgd_apps_Level;
+typedef struct _adspmsgd_apps_octetSeq__seq_octet _adspmsgd_apps_octetSeq__seq_octet;
+typedef _adspmsgd_apps_octetSeq__seq_octet adspmsgd_apps_octetSeq;
+struct _adspmsgd_apps_octetSeq__seq_octet {
+   unsigned char* data;
+   int dataLen;
+};
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(adspmsgd_apps_log)(const unsigned char* log_message_buffer, int log_message_bufferLen) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSPMSGD_APPS_H
diff --git a/inc/apps_mem.h b/inc/apps_mem.h
new file mode 100644
index 0000000..12f7001
--- /dev/null
+++ b/inc/apps_mem.h
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _APPS_MEM_H
+#define _APPS_MEM_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_mem_request_map)(int heapid, uint32 ion_flags, uint32 rflags, uint32 vin, int32 len, uint32* vapps, uint32* vadsp) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_mem_request_unmap)(uint32 vadsp, int32 len) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_mem_request_map64)(int heapid, uint32 ion_flags, uint32 rflags, uint64 vin, int64 len, uint64* vapps, uint64* vadsp) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_mem_request_unmap64)(uint64 vadsp, int64 len) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_mem_share_map)(int fd, int size, uint64* vapps, uint64* vadsp) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_mem_share_unmap)(uint64 vadsp, int size) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_APPS_MEM_H
diff --git a/inc/apps_remotectl.h b/inc/apps_remotectl.h
new file mode 100644
index 0000000..34f1692
--- /dev/null
+++ b/inc/apps_remotectl.h
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _APPS_REMOTECTL_H
+#define _APPS_REMOTECTL_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if !defined(__QAIC_STRING1_OBJECT_DEFINED__) && !defined(__STRING1_OBJECT__)
+#define __QAIC_STRING1_OBJECT_DEFINED__
+#define __STRING1_OBJECT__
+typedef struct _cstring1_s {
+   char* data;
+   int dataLen;
+} _cstring1_t;
+
+#endif /* __QAIC_STRING1_OBJECT_DEFINED__ */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_remotectl_open)(const char* name, int* handle, char* dlerror, int dlerrorLen, int* nErr) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_remotectl_close)(int handle, char* dlerror, int dlerrorLen, int* nErr) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_APPS_REMOTECTL_H
diff --git a/inc/apps_std.h b/inc/apps_std.h
new file mode 100644
index 0000000..e68a24b
--- /dev/null
+++ b/inc/apps_std.h
@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _APPS_STD_H
+#define _APPS_STD_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if !defined(__QAIC_STRING1_OBJECT_DEFINED__) && !defined(__STRING1_OBJECT__)
+#define __QAIC_STRING1_OBJECT_DEFINED__
+#define __STRING1_OBJECT__
+typedef struct _cstring1_s {
+   char* data;
+   int dataLen;
+} _cstring1_t;
+
+#endif /* __QAIC_STRING1_OBJECT_DEFINED__ */
+/**
+    * standard library functions remoted from the apps to the dsp
+    */
+typedef int apps_std_FILE;
+enum apps_std_SEEK {
+   APPS_STD_SEEK_SET,
+   APPS_STD_SEEK_CUR,
+   APPS_STD_SEEK_END,
+   _32BIT_PLACEHOLDER_apps_std_SEEK = 0x7fffffff
+};
+typedef enum apps_std_SEEK apps_std_SEEK;
+typedef struct apps_std_DIR apps_std_DIR;
+struct apps_std_DIR {
+   uint64 handle;
+};
+typedef struct apps_std_DIRENT apps_std_DIRENT;
+struct apps_std_DIRENT {
+   int ino;
+   char name[255];
+};
+typedef struct apps_std_STAT apps_std_STAT;
+struct apps_std_STAT {
+   uint64 tsz;
+   uint64 dev;
+   uint64 ino;
+   uint32 mode;
+   uint32 nlink;
+   uint64 rdev;
+   uint64 size;
+   int64 atime;
+   int64 atimensec;
+   int64 mtime;
+   int64 mtimensec;
+   int64 ctime;
+   int64 ctimensec;
+};
+/**
+       * @retval, if operation fails errno is returned
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fopen)(const char* name, const char* mode, apps_std_FILE* psout) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_freopen)(apps_std_FILE sin, const char* name, const char* mode, apps_std_FILE* psout) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fflush)(apps_std_FILE sin) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fclose)(apps_std_FILE sin) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @param,  bEOF, if read or write bytes <= bufLen bytes then feof() is called
+       *          and the result is returned in bEOF, otherwise bEOF is set to 0.
+       * @retval, if read or write return 0 for non zero length buffers, ferror is checked
+       *          and a non zero value is returned in case of error with no rout parameters
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fread)(apps_std_FILE sin, byte* buf, int bufLen, int* bytesRead, int* bEOF) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fwrite)(apps_std_FILE sin, const byte* buf, int bufLen, int* bytesWritten, int* bEOF) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @param, pos, this buffer is filled up to MIN(posLen, sizeof(fpos_t))
+       * @param, posLenReq, returns sizeof(fpos_t)
+       * @retval, if operation fails errno is returned
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fgetpos)(apps_std_FILE sin, byte* pos, int posLen, int* posLenReq) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @param, if size of pos doesn't match the system size an error is returned.
+       *         fgetpos can be used to query the size of fpos_t
+       * @retval, if operation fails errno is returned
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fsetpos)(apps_std_FILE sin, const byte* pos, int posLen) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @retval, if operation fails errno is returned
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_ftell)(apps_std_FILE sin, int* pos) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fseek)(apps_std_FILE sin, int offset, apps_std_SEEK whence) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_flen)(apps_std_FILE sin, uint64* len) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @retval, only fails if transport fails
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_rewind)(apps_std_FILE sin) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_feof)(apps_std_FILE sin, int* bEOF) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_ferror)(apps_std_FILE sin, int* err) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_clearerr)(apps_std_FILE sin) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_print_string)(const char* str) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @param val, must contain space for NULL
+       * @param valLenReq, length required with NULL
+       * @retval, if fails errno is returned
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_getenv)(const char* name, char* val, int valLen, int* valLenReq) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * @retval, if fails errno is returned
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_setenv)(const char* name, const char* val, int override) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_unsetenv)(const char* name) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * This function will try to open a file given directories in envvarname separated by
+       * delim.
+       * so given environment variable FOO_PATH=/foo;/bar
+       *    fopen_wth_env("FOO_PATH", ";", "path/to/file", "rw", &out);
+       * will try to open /foo/path/to/file, /bar/path/to/file
+       * if the variable is unset, it will open the file directly
+       *
+       * @param envvarname, name of the environment variable containing the path
+       * @param delim, delimiator string, such as ";"
+       * @param name, name of the file
+       * @param mode, mode
+       * @param psout, output handle
+       * @retval, 0 on success errno or -1 on failure
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fopen_with_env)(const char* envvarname, const char* delim, const char* name, const char* mode, apps_std_FILE* psout) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fgets)(apps_std_FILE sin, byte* buf, int bufLen, int* bEOF) __QAIC_HEADER_ATTRIBUTE;
+/**
+       * This method will return the paths that are searched when looking for a file.
+       *  The paths are defined by the environment variable (separated by delimiters)
+       *  that is passed to the method.
+       *
+       * @param envvarname, name of the environment variable containing the path
+       * @param delim, delimiator string, such as ";"
+       * @param name, name of the file
+       * @param paths, Search paths
+       * @param numPaths, Actual number of paths found
+       * @param maxPathLen, The max path length
+       * @retval, 0 on success errno or -1 on failure
+       *
+       */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_get_search_paths_with_env)(const char* envvarname, const char* delim, _cstring1_t* paths, int pathsLen, uint32* numPaths, uint16* maxPathLen) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fileExists)(const char* path, boolean* exists) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fsync)(apps_std_FILE sin) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fremove)(const char* name) __QAIC_HEADER_ATTRIBUTE;
+/**
+        * This function decrypts the file using the provided open file descriptor, closes the
+        * original descriptor and return a new file descriptor.
+        * @retval, if operation fails errno is returned
+        */
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_fdopen_decrypt)(apps_std_FILE sin, apps_std_FILE* psout) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_opendir)(const char* name, apps_std_DIR* dir) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_closedir)(const apps_std_DIR* dir) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_readdir)(const apps_std_DIR* dir, apps_std_DIRENT* dirent, int* bEOF) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_mkdir)(const char* name, int mode) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_rmdir)(const char* name) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_stat)(const char* name, apps_std_STAT* stat) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_ftrunc)(apps_std_FILE sin, int offset) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(apps_std_frename)(const char* oldname, const char* newname) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_APPS_STD_H
diff --git a/inc/fastrpc_apps_user.h b/inc/fastrpc_apps_user.h
new file mode 100644
index 0000000..46c5614
--- /dev/null
+++ b/inc/fastrpc_apps_user.h
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FASTRPC_ANDROID_USER_H
+#define FASTRPC_ANDROID_USER_H
+
+#include <assert.h>
+#include <fcntl.h>
+#include <asm/ioctl.h>
+#include <errno.h>
+
+/*
+ * API to check if kernel supports remote memory allocation
+ * Returns 0 if NOT supported
+ *
+ */
+int is_kernel_alloc_supported(int dev, int domain);
+
+/*
+ * API to allocate ION memory for internal purposes
+ * Returns NULL if allocation fails
+ *
+ */
+void* rpcmem_alloc_internal(int heapid, uint32 flags, int size);
+
+/*
+ * API to free internally allocated ION memory
+ *
+ */
+void rpcmem_free_internal(void* po);
+
+/*
+ * API to get fd of internally allocated ION buffer
+ * Returns valid fd on success and -1 on failure
+ *
+ */
+int rpcmem_to_fd_internal(void *po);
+
+#endif //FASTRPC_ANDROID_USER_H
diff --git a/inc/fastrpc_internal.h b/inc/fastrpc_internal.h
new file mode 100644
index 0000000..8cb57a2
--- /dev/null
+++ b/inc/fastrpc_internal.h
@@ -0,0 +1,308 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FASTRPC_INTERNAL_H
+#define FASTRPC_INTERNAL_H
+
+#include <linux/types.h>
+#include "remote64.h"
+#include "verify.h"
+#include "AEEstd.h"
+
+#define FASTRPC_IOCTL_ALLOC_DMA_BUFF 	_IOWR('R', 1, struct fastrpc_alloc_dma_buf)
+#define FASTRPC_IOCTL_FREE_DMA_BUFF 	_IOWR('R', 2, uint32_t)
+#define FASTRPC_IOCTL_INVOKE        	_IOWR('R', 3, struct fastrpc_invoke)
+#define FASTRPC_IOCTL_INIT_ATTACH 		_IO('R', 4)
+#define FASTRPC_IOCTL_INIT_CREATE 		_IOWR('R', 5, struct fastrpc_init_create)
+#define FASTRPC_IOCTL_MMAP				_IOWR('R', 6, struct fastrpc_ioctl_mmap)
+#define FASTRPC_IOCTL_MUNMAP			_IOWR('R', 7, struct fastrpc_ioctl_munmap)
+
+
+#define DEVICE_NAME "adsprpc-smd"
+
+#if !(defined __qdsp6__) && !(defined __hexagon__)
+static __inline uint32 Q6_R_cl0_R(uint32 num) {
+   int ii;
+   for(ii = 31; ii >= 0; --ii) {
+      if(num & (1 << ii)) {
+         return 31 - ii;
+      }
+   }
+   return 0;
+}
+#else
+#include "hexagon_protos.h"
+#include <types.h>
+#endif
+
+#define FASTRPC_INFO_SMMU   (1 << 0)
+
+/* struct fastrpc_invoke_args {
+	__u64 ptr;
+	__u64 length;
+	__s32 fd;
+	__u32 attrs;
+	__u32 crc;
+}; */
+
+struct fastrpc_invoke_args {
+	__u64 ptr;
+	__u64 length;
+	__s32 fd;
+	__u32 reserved;
+};
+
+struct fastrpc_invoke {
+	__u32 handle;
+	__u32 sc;
+	__u64 args;
+};
+
+#define FASTRPC_ATTR_NOVA (1)
+#define FASTRPC_ATTR_NOMAP (16)
+
+#define GUEST_OS   			0
+#define USER_PD   			-1
+#define STATIC_USER_PD  	1
+#define ATTACH_SENSORS_PD  	2
+#define GUEST_OS_SHARED  	3
+
+struct fastrpc_init_create {
+	__u32 filelen;	/* elf file length */
+	__s32 filefd;	/* fd for the file */
+	__u32 attrs;
+	__u32 siglen;
+	__u64 file;	/* pointer to elf file */
+};
+
+#define FASTRPC_ATTR_DEBUG_PROCESS (1)
+
+struct fastrpc_alloc_dma_buf {
+	__s32 fd;	/* fd */
+	__u32 flags;	/* flags to map with */
+	__u64 size;	/* size */
+};
+
+struct fastrpc_ioctl_mmap {
+	__s32 fd;	/* fd */
+	__u32 flags;	/* flags for dsp to map with */
+	__u64 vaddrin;	/* optional virtual address */
+	__u64 size;	/* size */
+	__u64 vaddrout;	/* dsps virtual address */
+};
+
+struct fastrpc_ioctl_munmap {
+	__u64 vaddrout;	/* address to unmap */
+	__u64 size;	/* size */
+};
+
+#define FASTRPC_CONTROL_LATENCY	(1)
+struct fastrpc_ctrl_latency {
+	uint32_t enable;	//!latency control enable
+	uint32_t level;		//!level of control
+};
+#define FASTRPC_CONTROL_SMMU	(2)
+struct fastrpc_ctrl_smmu {
+	uint32_t sharedcb;
+};
+
+#define FASTRPC_CONTROL_KALLOC	(3)
+struct fastrpc_ctrl_kalloc {
+	uint32_t kalloc_support;
+};
+
+struct fastrpc_ioctl_control {
+	uint32_t req;
+	union {
+		struct fastrpc_ctrl_latency lp;
+		struct fastrpc_ctrl_smmu smmu;
+		struct fastrpc_ctrl_kalloc kalloc;
+	};
+};
+
+#define FASTRPC_SMD_GUID "fastrpcsmd-apps-dsp"
+
+struct smq_null_invoke32 {
+   uint32_t ctx;         //! invoke caller context
+   remote_handle handle; //! handle to invoke
+   uint32_t sc;          //! scalars structure describing the rest of the data
+};
+
+struct smq_null_invoke {
+   uint64_t ctx;         //! invoke caller context
+   remote_handle handle; //! handle to invoke
+   uint32_t sc;          //! scalars structure describing the rest of the data
+};
+
+typedef uint32_t smq_invoke_buf_phy_addr;
+
+struct smq_phy_page {
+   uint64_t addr; //! physical address
+   int64_t size;  //! size
+};
+
+struct smq_phy_page32 {
+   uint32_t addr; //! physical address
+   uint32_t size; //! size
+};
+
+struct smq_invoke_buf {
+   int num;
+   int pgidx;
+};
+
+struct smq_invoke32 {
+   struct smq_null_invoke32 header;
+   struct smq_phy_page32 page;   //! remote arg and list of pages address
+};
+
+struct smq_invoke {
+   struct smq_null_invoke header;
+   struct smq_phy_page page;     //! remote arg and list of pages address
+};
+
+struct smq_msg32 {
+   uint32_t pid;
+   uint32_t tid;
+   struct smq_invoke32 invoke;
+};
+
+struct smq_msg {
+   uint32_t pid;
+   uint32_t tid;
+   struct smq_invoke invoke;
+};
+
+struct smq_msg_u {
+   union {
+      struct smq_msg32 msg32;
+      struct smq_msg msg64;
+   } msg;
+   int size;
+};
+
+struct smq_invoke_rsp32 {
+   uint32_t ctx;                 //! invoke caller context
+   int nRetVal;                  //! invoke return value
+};
+
+struct smq_invoke_rsp {
+   uint64_t ctx;                 //! invoke caller context
+   int nRetVal;                  //! invoke return value
+};
+
+struct smq_invoke_rsp_u {
+   union {
+      struct smq_invoke_rsp32 rsp32;
+      struct smq_invoke_rsp rsp64;
+   } rsp;
+   int size;
+};
+
+static __inline void to_smq_msg(uint32 mode, struct smq_msg_u* msg, struct smq_msg* msg64) {
+   if(0 == mode) {
+      msg64->pid = msg->msg.msg32.pid;
+      msg64->tid = msg->msg.msg32.tid;
+      msg64->invoke.header.ctx = msg->msg.msg32.invoke.header.ctx;
+      msg64->invoke.header.handle = msg->msg.msg32.invoke.header.handle;
+      msg64->invoke.header.sc = msg->msg.msg32.invoke.header.sc;
+      msg64->invoke.page.addr = msg->msg.msg32.invoke.page.addr;
+      msg64->invoke.page.size = msg->msg.msg32.invoke.page.size;
+   } else {
+      std_memmove(msg64, &msg->msg.msg64, sizeof(*msg64));
+   }
+}
+
+static __inline void to_smq_invoke_rsp(uint32 mode, uint64 ctx, int nRetVal, struct smq_invoke_rsp_u* rsp) {
+   if (0 == mode) {
+      rsp->rsp.rsp32.ctx = (uint32)ctx;
+      rsp->rsp.rsp32.nRetVal = nRetVal;
+      rsp->size = sizeof(rsp->rsp.rsp32);
+   } else {
+      rsp->rsp.rsp64.ctx = ctx;
+      rsp->rsp.rsp64.nRetVal = nRetVal;
+      rsp->size = sizeof(rsp->rsp.rsp64);
+   }
+}
+
+static __inline struct smq_invoke_buf* to_smq_invoke_buf_start(uint32 mode, void* virt, uint32 sc) {
+   struct smq_invoke_buf* buf;
+   int len = REMOTE_SCALARS_LENGTH(sc);
+   if(0 == mode) {
+      remote_arg* pra = (remote_arg*)virt;
+      buf = (struct smq_invoke_buf*)(&pra[len]);
+   } else {
+      remote_arg64* pra = (remote_arg64*)virt;
+      buf = (struct smq_invoke_buf*)(&pra[len]);
+   }
+   return buf;
+}
+
+static __inline struct smq_invoke_buf* smq_invoke_buf_start(remote_arg64 *pra, uint32 sc) {
+   int len = REMOTE_SCALARS_LENGTH(sc);
+   return (struct smq_invoke_buf*)(&pra[len]);
+}
+
+static __inline struct smq_phy_page* smq_phy_page_start(uint32 sc, struct smq_invoke_buf* buf) {
+   int nTotal =  REMOTE_SCALARS_INBUFS(sc) + REMOTE_SCALARS_OUTBUFS(sc);
+   return (struct smq_phy_page*)(&buf[nTotal]);
+}
+
+//! size of the out of band data
+static __inline int smq_data_size(uint32 sc, int nPages) {
+   struct smq_invoke_buf* buf = smq_invoke_buf_start(0, sc);
+   struct smq_phy_page* page = smq_phy_page_start(sc, buf);
+   return (int)(uintptr_t)(&(page[nPages]));
+}
+
+static __inline void to_smq_data(uint32 mode, uint32 sc, int nPages, void* pv, remote_arg64* rpra) {
+   if(0 == mode) {
+      struct smq_phy_page* page;
+      struct smq_phy_page32* page32;
+      remote_arg *pra = (remote_arg*)pv;
+      int ii, len;
+      len = REMOTE_SCALARS_LENGTH(sc);
+      for(ii = 0; ii < len; ++ii) {
+         rpra[ii].buf.pv = (uint64)(uintptr_t)pra[ii].buf.pv;
+         rpra[ii].buf.nLen = pra[ii].buf.nLen;
+      }
+      len = REMOTE_SCALARS_INBUFS(sc) + REMOTE_SCALARS_OUTBUFS(sc);
+      std_memmove(&rpra[ii], &pra[ii], len * sizeof(struct smq_invoke_buf));
+      page = (struct smq_phy_page*)((struct smq_invoke_buf*)&rpra[ii] + len);
+      page32 = (struct smq_phy_page32*)((struct smq_invoke_buf*)&pra[ii] + len);
+      for(ii = 0; ii < nPages; ++ii) {
+         page[ii].addr = page32[ii].addr;
+         page[ii].size = page32[ii].size;
+      }
+   } else {
+      std_memmove(rpra, pv, smq_data_size(sc, nPages));
+   }
+}
+
+#endif // FASTRPC_INTERNAL_H
diff --git a/inc/fastrpc_perf.h b/inc/fastrpc_perf.h
new file mode 100644
index 0000000..ab0deaa
--- /dev/null
+++ b/inc/fastrpc_perf.h
@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef FASTRPC_PERF_H
+#define FASTRPC_PERF_H
+
+#include "remote.h"
+#ifdef __ANDROID__
+#include "cutils/properties.h"
+#else
+#define PROPERTY_VALUE_MAX	32
+#endif
+
+#if (defined LE_ENABLE)
+#define FASTRPC_PROPERTY_GET_INT32(key, defvalue) ((int)0)
+#define FASTRPC_PROPERTY_GET_STR(key, buffer, defvalue)     ((int)0)
+#else
+#if  (defined __ANDROID__)
+#define FASTRPC_PROPERTY_GET_INT32(key, defvalue) ((int)property_get_int32((key), (defvalue)))
+#define FASTRPC_PROPERTY_GET_STR(key, buffer, defvalue)     ((int)property_get((key), (buffer), (defvalue)))
+#else
+#define FASTRPC_PROPERTY_GET_INT32(key, defvalue) ((int)0)
+#define FASTRPC_PROPERTY_GET_STR(key, buffer, defvalue)     ((int)0)
+#endif
+#endif
+
+#define FASTRPC_MAX_STATIC_HANDLE (10)
+#define IS_STATIC_HANDLE(handle) ((handle) >= 0 && (handle) <= FASTRPC_MAX_STATIC_HANDLE)
+extern int fastrpc_perf_init(int dev);
+extern void fastrpc_perf_update(int dev, remote_handle handle, uint32_t sc);
+extern void fastrpc_perf_deinit(void);
+
+#endif //FASTRPC_PERF_H
diff --git a/inc/listener_android.h b/inc/listener_android.h
new file mode 100644
index 0000000..bd76984
--- /dev/null
+++ b/inc/listener_android.h
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LISTENER_ANDROID_H
+#define LISTENER_ANDROID_H
+
+#include <pthread.h>
+#include <dlfcn.h>
+#include "pthread_rw_mutex.h"
+
+#define   MSG(a, b, c)              printf(__FILE_LINE__ ":" c )
+#define   MSG_1(a, b, c, d)         printf(__FILE_LINE__ ":" c , d)
+#define   MSG_2(a, b, c, d, e)      printf(__FILE_LINE__ ":" c , d, e)
+#define   MSG_3(a, b, c, d, e, f)   printf(__FILE_LINE__ ":" c , d, e, f)
+#define   MSG_4(a, b, c, d, e, f,g) printf(__FILE_LINE__ ":" c , d, e, f, g)
+
+#define DLW_RTLD_NOW RTLD_NOW
+#define dlw_Open dlopen
+#define dlw_Sym dlsym
+#define dlw_Close dlclose
+#define dlw_Error dlerror
+
+#endif
diff --git a/inc/listener_buf.h b/inc/listener_buf.h
new file mode 100644
index 0000000..ee95b1d
--- /dev/null
+++ b/inc/listener_buf.h
@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LISTENER_BUF_H
+#define LISTENER_BUF_H
+
+#include "sbuf.h"
+#include "remote.h"
+#include "verify.h"
+
+static __inline void pack_in_bufs(struct sbuf* buf, remote_arg* pra, int nBufs) {
+   int ii;
+   uint32_t len;
+   C_ASSERT(sizeof(len) == 4);
+   for(ii = 0; ii < nBufs; ++ii) {
+      len = (uint32_t)pra[ii].buf.nLen;
+      sbuf_write(buf, (uint8*)&len, 4);
+      if(len) {
+         sbuf_align(buf, 8);
+         sbuf_write(buf, pra[ii].buf.pv, len);
+      }
+   }
+}
+
+static __inline void pack_out_lens(struct sbuf* buf, remote_arg* pra, int nBufs) {
+   int ii;
+   uint32_t len;
+   C_ASSERT(sizeof(len) == 4);
+   for(ii = 0; ii < nBufs; ++ii) {
+      len = (uint32_t)pra[ii].buf.nLen;
+      sbuf_write(buf, (uint8*)&len, 4);
+   }
+}
+
+static __inline void unpack_in_bufs(struct sbuf* buf, remote_arg* pra, int nBufs) {
+   int ii;
+   uint32_t len=0;
+   C_ASSERT(sizeof(len) == 4);
+   for(ii = 0; ii < nBufs; ++ii) {
+      sbuf_read(buf, (uint8*)&len, 4);
+      pra[ii].buf.nLen = len;
+      if(pra[ii].buf.nLen) {
+         sbuf_align(buf, 8);
+         if((int)pra[ii].buf.nLen <= sbuf_left(buf)) {
+            pra[ii].buf.pv = sbuf_head(buf);
+         }
+         sbuf_advance(buf, pra[ii].buf.nLen);
+      }
+   }
+}
+
+static __inline void unpack_out_lens(struct sbuf* buf, remote_arg* pra, int nBufs) {
+   int ii;
+   uint32_t len=0;
+   C_ASSERT(sizeof(len) == 4);
+   for(ii = 0; ii < nBufs; ++ii) {
+      sbuf_read(buf, (uint8*)&len, 4);
+      pra[ii].buf.nLen = len;
+   }
+}
+
+//map out buffers on the hlos side to the remote_arg array
+//dst is the space required for buffers we coun't map from the adsp
+static __inline void pack_out_bufs(struct sbuf* buf, remote_arg* pra, int nBufs) {
+   int ii;
+   uint32_t len;
+   C_ASSERT(sizeof(len) == 4);
+   for(ii = 0; ii < nBufs; ++ii) {
+      len = (uint32_t)pra[ii].buf.nLen;
+      sbuf_write(buf, (uint8*)&len, 4);
+      if(pra[ii].buf.nLen) {
+         sbuf_align(buf, 8);
+         if((int)pra[ii].buf.nLen <= sbuf_left(buf)) {
+            pra[ii].buf.pv = sbuf_head(buf);
+         }
+         sbuf_advance(buf, pra[ii].buf.nLen);
+      }
+   }
+}
+
+//on the aDSP copy the data from buffers we had to copy to the local remote_arg structure
+static __inline int unpack_out_bufs(struct sbuf* buf, remote_arg* pra, int nBufs) {
+   int ii, nErr = 0;
+   uint32_t len;
+   C_ASSERT(sizeof(len) == 4);
+   for(ii = 0; ii < nBufs; ++ii) {
+      sbuf_read(buf, (uint8*)&len, 4);
+      VERIFY(len == pra[ii].buf.nLen);
+      if(pra[ii].buf.nLen) {
+         sbuf_align(buf, 8);
+         sbuf_read(buf, pra[ii].buf.pv, pra[ii].buf.nLen);
+      }
+   }
+bail:
+   return nErr;
+}
+
+#endif
diff --git a/inc/mod_table.h b/inc/mod_table.h
new file mode 100644
index 0000000..9e4e219
--- /dev/null
+++ b/inc/mod_table.h
@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MOD_TABLE_H
+#define MOD_TABLE_H
+
+#include "remote64.h"
+#include "AEEStdDef.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * multi-domain support
+ *
+ * multi domain modules return remote_handl64 on open/close, but mod_table
+ * creates uint32 handles as the "remote" facing handle.  These fit nicely
+ * into the transport layer.
+ *
+ */
+
+/**
+  * register a static component for invocations
+  * this can be called at any time including from a static constructor
+  *
+  * name, name of the interface to register
+  * pfn, function pointer to the skel invoke function
+  *
+  * for example:
+  *   __attribute__((constructor)) static void my_module_ctor(void) {
+  *      mod_table_register_static("my_module", my_module_skel_invoke);
+  *   }
+  *
+  */
+int mod_table_register_static(const char* name, int (*pfn)(uint32 sc, remote_arg* pra));
+
+/**
+  * same as register_static, but module with user defined handle lifetimes.
+  */
+int mod_table_register_static1(const char* uri, int (*pfn)(remote_handle64 h,uint32 sc, remote_arg* pra));
+
+/**
+  * register a static component for invocations
+  * this can be called at any time including from a static constructor
+  *
+  * overrides will be tried first, then dynamic modules, then regular
+  * static modules.  This api should only be use by system components
+  * that will never be upgradable.
+  *
+  * name, name of the interface to register
+  * pfn, function pointer to the skel invoke function
+  *
+  * for example:
+  *   __attribute__((constructor)) static void my_module_ctor(void) {
+  *      mod_table_register_static("my_module", my_module_skel_invoke);
+  *   }
+  *
+  */
+int mod_table_register_static_override(const char* name, int(*pfn)(uint32 sc, remote_arg* pra));
+
+/**
+  * same as register_static, but module with user defined handle lifetimes.
+  */
+int mod_table_register_static_override1(const char* uri, int(*pfn)(remote_handle64,uint32 sc, remote_arg* pra));
+
+/**
+ * Open a module and get a handle to it
+ *
+ * in_name, name of module to open
+ * handle, Output handle
+ * dlerr, Error String (if an error occurs)
+ * dlerrorLen, Length of error String (if an error occurs)
+ * pdlErr, Error identifier
+ */
+int mod_table_open(const char* in_name, remote_handle* handle, char* dlerr, int dlerrorLen, int* pdlErr);
+
+/**
+ * invoke a handle in the mod table
+ *
+ * handle, handle to invoke
+ * sc, scalars, see remote.h for documentation.
+ * pra, args, see remote.h for documentation.
+ */
+int mod_table_invoke(remote_handle handle, uint32 sc, remote_arg* pra);
+
+/**
+ * Closes a handle in the mod table
+ *
+ * handle, handle to close
+ * errStr, Error String (if an error occurs)
+ * errStrLen, Length of error String (if an error occurs)
+ * pdlErr, Error identifier
+ */
+int mod_table_close(remote_handle handle, char* errStr, int errStrLen, int* pdlErr);
+
+/**
+ * internal use only
+ */
+int mod_table_register_const_handle(remote_handle handle, const char* in_name, int (*pfn)(uint32 sc, remote_arg* pra));
+/**
+ * @param remote, the handle we should expect from the transport layer
+ * @param local, the local handle that will be passed to pfn
+ */
+int mod_table_register_const_handle1(remote_handle remote, remote_handle64 local, const char* uri, int (*pfn)(remote_handle64 h, uint32 sc, remote_arg* pra));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // MOD_TABLE_H
diff --git a/inc/mutex.h b/inc/mutex.h
new file mode 100644
index 0000000..a318c44
--- /dev/null
+++ b/inc/mutex.h
@@ -0,0 +1,105 @@
+#ifndef MUTEX_H
+#define MUTEX_H
+
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if (defined __qdsp6__) || (defined __hexagon__)
+#include "qurt_mutex.h"
+
+#define RW_MUTEX_T                  qurt_mutex_t
+#define RW_MUTEX_CTOR(mut)          qurt_mutex_init(& (mut))
+#define RW_MUTEX_LOCK_READ(mut)     qurt_mutex_lock(& (mut))
+#define RW_MUTEX_UNLOCK_READ(mut)   qurt_mutex_unlock(& (mut))
+#define RW_MUTEX_LOCK_WRITE(mut)    qurt_mutex_lock(& (mut))
+#define RW_MUTEX_UNLOCK_WRITE(mut)  qurt_mutex_unlock(& (mut))
+#define RW_MUTEX_DTOR(mut)          qurt_mutex_destroy(& (mut))
+
+#elif (1 == __linux) || (1 == __linux__) || (1 == __gnu_linux__) || (1 == linux)
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* asserts may be compiled out, this should always be present */
+#define ABORT_FAIL( ff ) \
+   do {\
+      if(! (ff) ) {\
+         fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", #ff, __FILE__, __LINE__);\
+         abort();\
+      }\
+   } while(0)
+
+#define RW_MUTEX_T                  pthread_rwlock_t
+#define RW_MUTEX_CTOR(mut)          ABORT_FAIL(0 == pthread_rwlock_init( & (mut), 0))
+#define RW_MUTEX_LOCK_READ(mut)     ABORT_FAIL(0 == pthread_rwlock_rdlock( & (mut)))
+#define RW_MUTEX_UNLOCK_READ(mut)   ABORT_FAIL(0 == pthread_rwlock_unlock( & (mut)))
+#define RW_MUTEX_LOCK_WRITE(mut)    ABORT_FAIL(0 == pthread_rwlock_wrlock( & (mut)))
+#define RW_MUTEX_UNLOCK_WRITE(mut)  ABORT_FAIL(0 == pthread_rwlock_unlock( & (mut)))
+#define RW_MUTEX_DTOR(mut)          ABORT_FAIL(0 == pthread_rwlock_destroy( & (mut)))
+
+
+#else
+
+#include "AEEstd.h"
+
+#define RW_MUTEX_T uint32
+#define RW_MUTEX_CTOR(mut) mut = 0
+#define RW_MUTEX_LOCK_READ(mut) \
+   do {\
+      assert(STD_BIT_TEST(&mut, 1) == 0); \
+      assert(STD_BIT_TEST(&mut, 2) == 0); \
+      STD_BIT_SET(&mut, 1); \
+   } while (0)
+
+#define RW_MUTEX_UNLOCK_READ(mut) \
+   do {\
+      assert(STD_BIT_TEST(&mut, 1)); \
+      assert(STD_BIT_TEST(&mut, 2) == 0); \
+      STD_BIT_CLEAR(&mut, 1); \
+   } while (0)
+
+#define RW_MUTEX_LOCK_WRITE(mut) \
+   do {\
+      assert(STD_BIT_TEST(&mut, 1) == 0); \
+      assert(STD_BIT_TEST(&mut, 2) == 0); \
+      STD_BIT_SET(&mut, 2); \
+   } while (0)
+
+#define RW_MUTEX_UNLOCK_WRITE(mut) \
+   do {\
+      assert(STD_BIT_TEST(&mut, 1) == 0); \
+      assert(STD_BIT_TEST(&mut, 2)); \
+      STD_BIT_CLEAR(&mut, 2); \
+   } while (0)
+
+#define RW_MUTEX_DTOR(mut) mut = 0
+
+#endif
+#endif //MUTEX_H
diff --git a/inc/platform_libs.h b/inc/platform_libs.h
new file mode 100644
index 0000000..fc6c751
--- /dev/null
+++ b/inc/platform_libs.h
@@ -0,0 +1,182 @@
+#ifndef PLATFORM_LIBS_H
+#define PLATFORM_LIBS_H
+
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+Platfrom Library Loader
+-----------------------
+
+proj/platform_libs is a library to help manage interdependencies between
+other libraries.
+
+
+to use you will need to add
+
+incs = { 'proj/platform_libs' }
+
+in source of the library implementation define the entry point
+
+#include "platform_libs.h"
+PL_DEFINE(svfs, svfs_init, svfs_deinit);
+
+Platfrom Library List
+---------------------
+
+This list contains top level libraries to be initialized at boot.  To make
+sure that this library is loaded you would need to call PLRegister or
+PLRegisterDefault in your scons build command.
+
+
+Handling Interdependencies and Order
+------------------------------------
+
+To make sure that library A is loaded before library B, library B's
+constructor and destructor should initialize and cleanup libraryB.
+
+#include "platform_libs.h"
+
+PL_DEP(libraryB)
+void libraryA_deinit(void) {
+ PL_DEINIT(libraryB);
+}
+
+int libraryA_init(void) {
+ int nErr = 0;
+ // my init code
+ VERIFY(0 == PL_INIT(libraryB));
+bail:
+ if(nErr) { libraryA_deinit() }
+ return nErr;
+}
+
+
+libraryB does not need to appear in the platform library list.
+*/
+
+#include <stdint.h>
+
+struct platform_lib {
+  const char* name;
+  uint32_t uRefs;
+  int nErr;
+  int (*init)(void);
+  void (*deinit)(void);
+};
+
+/**
+ * use this macro to pull in external dependencies
+ */
+#ifdef __cplusplus
+#define PL_DEP(name)\
+   extern "C" {\
+     extern struct platform_lib*  _pl_##name(void); \
+   }
+#else
+#define PL_DEP(name)\
+   extern struct platform_lib*  _pl_##name(void);
+#endif /* __cplusplus */
+
+/**
+ * should be declared in source in the library
+ * if constructor fails, destructor is not called
+ */
+#ifdef __cplusplus
+#define PL_DEFINE(name, init, deinit) \
+   extern "C" {\
+      struct platform_lib* _pl_##name(void) {\
+         static struct platform_lib  _gpl_##name = { #name, 0, -1, init, deinit };\
+         return &_gpl_##name;\
+      }\
+   }
+#else
+#define PL_DEFINE(name, init, deinit) \
+   struct platform_lib* _pl_##name(void) {\
+      static struct platform_lib  _gpl_##name = { #name, 0, -1, init, deinit };\
+      return &_gpl_##name;\
+   }
+#endif /* __cplusplus */
+
+/**
+ * should be added to platform_libs_list.c pl_list table
+ * for all top level modules
+ */
+#define PL_ENTRY(name) _pl_##name
+
+/**
+ * should be called within a constructor to ensure that a
+ * dependency has been initialized.  so if foo depends on bar
+ *
+ *    #include "bar.h"
+ *    int foo_init() {
+ *       return PL_INIT(bar);
+ *    }
+ */
+#define PL_INIT(name) pl_lib_init(PL_ENTRY(name))
+
+/**
+ * should be called within a destructor to ensure that a
+ * dependency has been cleaned up
+ */
+#define PL_DEINIT(name) pl_lib_deinit(PL_ENTRY(name))
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * initalize the static list of library constructors and destructors
+ * should be called from main()
+ *
+ * see platform_libs_list.h to add high level libraries
+ *
+ */
+int pl_init(void);
+
+/**
+ * calls all the destructors.
+ */
+void pl_deinit(void);
+
+/**
+ * initialize a single library.  called via PL_INIT
+ */
+int pl_lib_init(struct platform_lib* (*pl)(void));
+
+/**
+ * deinitialize a single library called via PL_DEINIT
+ */
+void pl_lib_deinit(struct platform_lib* (*pl)(void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //PLATFORM_LIBS
diff --git a/inc/pls.h b/inc/pls.h
new file mode 100644
index 0000000..c832aa9
--- /dev/null
+++ b/inc/pls.h
@@ -0,0 +1,213 @@
+#ifndef PLS_H
+#define PLS_H
+
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include "AEEStdDef.h"
+#include "AEEatomic.h"
+#include "verify.h"
+#include "HAP_farf.h"
+
+struct PLS;
+
+struct plskey {
+   uintptr_t type;
+   uintptr_t key;
+};
+
+struct PLS {
+   struct PLS* next;
+   struct plskey key;
+   void (*dtor)(void* data);
+   uint64_t data[1];
+};
+
+
+struct pls_table {
+   struct PLS* lst;
+   uint32_t uRefs;
+   uint32_t primThread;
+};
+
+/**
+ * initialize on every thread and stick the pls_thread_deinit
+ * function into the threads tls
+ */
+static __inline int pls_thread_init(struct pls_table* me, uintptr_t tid) {
+   if(tid == me->primThread) {
+      return 0;
+   }
+   if(0 == atomic_CompareOrAdd(&me->uRefs, 0, 1)) {
+      return -1;
+   }
+   return 0;
+}
+
+/* call this constructor before the first thread creation with the
+ * first threads id
+ */
+static __inline void pls_ctor(struct pls_table* me, uintptr_t primThread) {
+   me->uRefs = 1;
+   me->primThread = primThread;
+}
+
+static __inline struct pls_table* pls_thread_deinit(struct pls_table* me) {
+   if(me && 0 != me->uRefs && 0 == atomic_Add(&me->uRefs, -1)) {
+      struct PLS* lst, *next;
+      lst = me->lst;
+      me->lst = 0;
+      while(lst) {
+         next = lst->next;
+         if(lst->dtor) {
+            FARF(HIGH, "pls dtor %p", lst->dtor);
+            lst->dtor((void*)lst->data);
+         }
+         free(lst);
+         lst = next;
+      }
+      return me;
+   }
+   return 0;
+}
+
+/**
+ * adds a new key to the local storage, overriding
+ * any previous value at the key.  Overriding the key
+ * does not cause the destructor to run.
+ *
+ * @param type, type part of the key to be used for lookup,
+          these should be static addresses.
+ * @param key, the key to be used for lookup
+ * @param size, the size of the data
+ * @param ctor, constructor that takes a context and memory of size
+ * @param ctx, constructor context passed as the first argument to ctor
+ * @param dtor, destructor to run at pls shutdown
+ * @param ppo, output data
+ * @retval, 0 for success
+ */
+
+static __inline int pls_add(struct pls_table* me, uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* data), void** ppo) {
+   int nErr = 0;
+   struct PLS* pls = 0;
+   struct PLS* prev;
+   VERIFY(me->uRefs != 0);
+   VERIFY(0 != (pls = (struct PLS*)calloc(1, size + sizeof(*pls) - sizeof(pls->data))));
+   if(ctor) {
+      VERIFY(0 == ctor(ctx, (void*)pls->data));
+   }
+   pls->dtor = dtor;
+   pls->key.type = type;
+   pls->key.key = key;
+   do {
+      pls->next = me->lst;
+      prev = (struct PLS*)atomic_CompareAndExchangeUP((uintptr_t*)&me->lst, (uintptr_t)pls, (uintptr_t)pls->next);
+   } while(prev != pls->next);
+   if(ppo) {
+      *ppo = (void*)pls->data;
+   }
+   FARF(HIGH, "pls added %p", dtor);
+bail:
+   if(nErr && pls) {
+      free(pls);
+   }
+   return nErr;
+}
+
+static __inline int pls_lookup(struct pls_table* me, uintptr_t type, uintptr_t key, void** ppo);
+
+/**
+ * like add, but will only add 1 item if two threads try to add at the same time.  returns
+ * item if its already there, otherwise tries to add.
+ * ctor may be called twice
+ * callers should avoid calling pls_add which will override the singleton
+ */
+static __inline int pls_add_lookup_singleton(struct pls_table* me, uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* data), void** ppo) {
+   int nErr = 0;
+   struct PLS* pls = 0;
+   struct PLS* prev;
+   if(0 == pls_lookup(me, type, key, ppo)) {
+      return 0;
+   }
+   VERIFY(me->uRefs != 0);
+   VERIFY(0 != (pls = (struct PLS*)calloc(1, size + sizeof(*pls) - sizeof(pls->data))));
+   if(ctor) {
+      VERIFY(0 == ctor(ctx, (void*)pls->data));
+   }
+   pls->dtor = dtor;
+   pls->key.type = type;
+   pls->key.key = key;
+   do {
+      pls->next = me->lst;
+      if(0 == pls_lookup(me, type, key, ppo)) {
+         if(pls->dtor) {
+            pls->dtor((void*)pls->data);
+         }
+         free(pls);
+         return 0;
+      }
+      prev = (struct PLS*)atomic_CompareAndExchangeUP((uintptr_t*)&me->lst, (uintptr_t)pls, (uintptr_t)pls->next);
+   } while(prev != pls->next);
+   if(ppo) {
+      *ppo = (void*)pls->data;
+   }
+   FARF(HIGH, "pls added %p", dtor);
+bail:
+   if(nErr && pls) {
+      free(pls);
+   }
+   return nErr;
+}
+
+
+/**
+ * finds the last data pointer added for key to the local storage
+ *
+ * @param key, the key to be used for lookup
+ * @param ppo, output data
+ * @retval, 0 for success
+ */
+
+static __inline int pls_lookup(struct pls_table* me, uintptr_t type, uintptr_t key, void** ppo) {
+   struct PLS* lst;
+   for(lst = me->lst; me->uRefs != 0 && lst != 0; lst = lst->next) {
+      if(lst->key.type == type && lst->key.key == key) {
+         if(ppo) {
+            *ppo = lst->data;
+         }
+         return 0;
+      }
+   }
+   return -1;
+}
+
+#endif //PLS_H
+
+
diff --git a/inc/pthread_rw_mutex.h b/inc/pthread_rw_mutex.h
new file mode 100644
index 0000000..61e6278
--- /dev/null
+++ b/inc/pthread_rw_mutex.h
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef PTHREAD_RW_MUTEX_H
+#define PTHREAD_RW_MUTEX_H
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* asserts may be compiled out, this should always be present */
+#define ABORT_FAIL( ff ) \
+   do {\
+      if(! (ff) ) {\
+         fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", #ff, __FILE__, __LINE__);\
+         abort();\
+      }\
+   } while(0)
+
+#define RW_MUTEX_T                  pthread_rwlock_t
+#define RW_MUTEX_CTOR(mut)          ABORT_FAIL(0 == pthread_rwlock_init( & (mut), 0))
+#define RW_MUTEX_LOCK_READ(mut)     ABORT_FAIL(0 == pthread_rwlock_rdlock( & (mut)))
+
+#define RW_MUTEX_UNLOCK_READ(mut)   ABORT_FAIL(0 == pthread_rwlock_unlock( & (mut)))
+
+#define RW_MUTEX_LOCK_WRITE(mut)    ABORT_FAIL(0 == pthread_rwlock_wrlock( & (mut)))
+
+#define RW_MUTEX_UNLOCK_WRITE(mut)  ABORT_FAIL(0 == pthread_rwlock_unlock( & (mut)))
+
+#define RW_MUTEX_DTOR(mut)          ABORT_FAIL(0 == pthread_rwlock_destroy( & (mut)))
+
+
+#endif //PTHREAD_RW_MUTEX_H
diff --git a/inc/remote.h b/inc/remote.h
new file mode 100644
index 0000000..8125c2b
--- /dev/null
+++ b/inc/remote.h
@@ -0,0 +1,318 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef REMOTE_H
+#define REMOTE_H
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uint32_t remote_handle;
+typedef uint64_t remote_handle64; //! used by multi domain modules
+                                  //! 64 bit handles are translated to 32 bit values
+                                  //! by the transport layer
+
+typedef struct {
+   void *pv;
+   size_t nLen;
+} remote_buf;
+
+typedef struct {
+   int32_t fd;
+   uint32_t offset;
+} remote_dma_handle;
+
+typedef union {
+   remote_buf     buf;
+   remote_handle    h;
+   remote_handle64 h64; //! used by multi domain modules
+   remote_dma_handle dma;
+} remote_arg;
+
+/*Retrives method attribute from the scalars parameter*/
+#define REMOTE_SCALARS_METHOD_ATTR(dwScalars)   (((dwScalars) >> 29) & 0x7)
+
+/*Retrives method index from the scalars parameter*/
+#define REMOTE_SCALARS_METHOD(dwScalars)        (((dwScalars) >> 24) & 0x1f)
+
+/*Retrives number of input buffers from the scalars parameter*/
+#define REMOTE_SCALARS_INBUFS(dwScalars)        (((dwScalars) >> 16) & 0x0ff)
+
+/*Retrives number of output buffers from the scalars parameter*/
+#define REMOTE_SCALARS_OUTBUFS(dwScalars)       (((dwScalars) >> 8) & 0x0ff)
+
+/*Retrives number of input handles from the scalars parameter*/
+#define REMOTE_SCALARS_INHANDLES(dwScalars)     (((dwScalars) >> 4) & 0x0f)
+
+/*Retrives number of output handles from the scalars parameter*/
+#define REMOTE_SCALARS_OUTHANDLES(dwScalars)    ((dwScalars) & 0x0f)
+
+#define REMOTE_SCALARS_MAKEX(nAttr,nMethod,nIn,nOut,noIn,noOut) \
+          ((((uint32_t)   (nAttr) &  0x7) << 29) | \
+           (((uint32_t) (nMethod) & 0x1f) << 24) | \
+           (((uint32_t)     (nIn) & 0xff) << 16) | \
+           (((uint32_t)    (nOut) & 0xff) <<  8) | \
+           (((uint32_t)    (noIn) & 0x0f) <<  4) | \
+            ((uint32_t)   (noOut) & 0x0f))
+
+#define REMOTE_SCALARS_MAKE(nMethod,nIn,nOut)  REMOTE_SCALARS_MAKEX(0,nMethod,nIn,nOut,0,0)
+
+#define REMOTE_SCALARS_LENGTH(sc) (REMOTE_SCALARS_INBUFS(sc) +\
+                                   REMOTE_SCALARS_OUTBUFS(sc) +\
+                                   REMOTE_SCALARS_INHANDLES(sc) +\
+                                   REMOTE_SCALARS_OUTHANDLES(sc))
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_REMOTE_EXPORT
+#ifdef _WIN32
+#define __QAIC_REMOTE_EXPORT __declspec(dllexport)
+#else //_WIN32
+#define __QAIC_REMOTE_EXPORT
+#endif //_WIN32
+#endif //__QAIC_REMOTE_EXPORT
+
+#ifndef __QAIC_REMOTE_ATTRIBUTE
+#define __QAIC_REMOTE_ATTRIBUTE
+#endif
+
+#define NUM_DOMAINS 4
+#define NUM_SESSIONS 2
+#define DOMAIN_ID_MASK 3
+
+#ifndef DEFAULT_DOMAIN_ID
+#define DEFAULT_DOMAIN_ID 0
+#endif
+
+#define ADSP_DOMAIN_ID    0
+#define MDSP_DOMAIN_ID    1
+#define SDSP_DOMAIN_ID    2
+#define CDSP_DOMAIN_ID    3
+
+#define ADSP_DOMAIN "&_dom=adsp"
+#define MDSP_DOMAIN "&_dom=mdsp"
+#define SDSP_DOMAIN "&_dom=sdsp"
+#define CDSP_DOMAIN "&_dom=cdsp"
+
+/* All other values are reserved */
+
+/* opens a remote_handle "name"
+ * returns 0 on success
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle_open)(const char* name, remote_handle *ph) __QAIC_REMOTE_ATTRIBUTE;
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle64_open)(const char* name, remote_handle64 *ph) __QAIC_REMOTE_ATTRIBUTE;
+
+/* invokes the remote handle
+ * see retrive macro's on dwScalars format
+ * pra, contains the arguments in the following order, inbufs, outbufs, inhandles, outhandles.
+ * implementors should ignore and pass values asis that the transport doesn't understand.
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle_invoke)(remote_handle h, uint32_t dwScalars, remote_arg *pra) __QAIC_REMOTE_ATTRIBUTE;
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle64_invoke)(remote_handle64 h, uint32_t dwScalars, remote_arg *pra) __QAIC_REMOTE_ATTRIBUTE;
+
+/* closes the remote handle
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle_close)(remote_handle h) __QAIC_REMOTE_ATTRIBUTE;
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle64_close)(remote_handle64 h) __QAIC_REMOTE_ATTRIBUTE;
+
+/* remote handle control interface
+ */
+/* request ID for fastrpc latency control */
+#define DSPRPC_CONTROL_LATENCY    (1)
+struct remote_rpc_control_latency {
+   uint32_t enable;	// enable auto control of rpc latency
+   uint32_t latency;	// latency: reserved
+};
+
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle_control)(uint32_t req, void* data, uint32_t datalen) __QAIC_REMOTE_ATTRIBUTE;
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_handle64_control)(remote_handle64 h, uint32_t req, void* data, uint32_t datalen) __QAIC_REMOTE_ATTRIBUTE;
+
+/* remote session control interface
+ */
+/* request ID for setting DSP user thread params */
+#define FASTRPC_THREAD_PARAMS    (1)
+struct remote_rpc_thread_params {
+	int domain;			// Remote subsystem domain ID, pass -1 to set params for all domains
+	int prio;			// user thread priority (1 to 255), pass -1 to use default
+	int stack_size;		// user thread stack size, pass -1 to use default
+};
+
+/* request ID for fastrpc unsigned module */
+#define DSPRPC_CONTROL_UNSIGNED_MODULE    (2)
+struct remote_rpc_control_unsigned_module {
+   int domain;				// Remote subsystem domain ID, -1 to set params for all domains
+   int enable; 				// enable unsigned module loading
+};
+
+/* Set remote session parameters
+ *
+ * @param req, request ID
+ * @param data, address of structure with parameters
+ * @param datalen, length of data
+ * @retval, 0 on success
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_session_control)(uint32_t req, void *data, uint32_t datalen) __QAIC_REMOTE_ATTRIBUTE;
+
+/* map memory to the remote domain
+ *
+ * @param fd, fd assosciated with this memory
+ * @param flags, flags to be used for the mapping
+ * @param vaddrin, input address
+ * @param size, size of buffer
+ * @param vaddrout, output address
+ * @retval, 0 on success
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_mmap)(int fd, uint32_t flags, uint32_t vaddrin, int size, uint32_t* vaddrout) __QAIC_REMOTE_ATTRIBUTE;
+
+/* unmap memory from the remote domain
+ *
+ * @param vaddrout, remote address mapped
+ * @param size, size to unmap.  Unmapping a range partially may  not be supported.
+ * @retval, 0 on success, may fail if memory is still mapped
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_munmap)(uint32_t vaddrout, int size) __QAIC_REMOTE_ATTRIBUTE;
+
+/*
+ * Attribute to map a buffer as dma non-coherent
+ * Driver perform cache maintenance.
+ */
+#define FASTRPC_ATTR_NON_COHERENT  (2)
+
+/*
+ * Attribute to map a buffer as dma coherent
+ * Driver skips cache maintenenace
+ * It will be ignored if a device is marked as dma-coherent in device tree.
+ */
+#define FASTRPC_ATTR_COHERENT  (4)
+
+/* Attribute to keep the buffer persistant
+ * until unmap is called explicitly
+ */
+#define FASTRPC_ATTR_KEEP_MAP  (8)
+
+/*
+ * Attribute for secure buffers to skip
+ * smmu mapping in fastrpc driver
+ */
+#define FASTRPC_ATTR_NOMAP  (16)
+
+/* Register a file descriptor for a buffer.  This is only valid on
+ * android with ION allocated memory.  Users of fastrpc should register
+ * a buffer allocated with ION to enable sharing that buffer to the
+ * dsp via the smmu.  Some versions of libadsprpc.so lack this
+ * function, so users should set this symbol as weak.
+ *
+ * #pragma weak  remote_register_buf
+ * #pragma weak  remote_register_buf_attr
+ *
+ * @param buf, virtual address of the buffer
+ * @param size, size of the buffer
+ * @fd, the file descriptor, callers can use -1 to deregister.
+ * @attr, map buffer as coherent or non-coherent
+ */
+__QAIC_REMOTE_EXPORT void __QAIC_REMOTE(remote_register_buf)(void* buf, int size, int fd) __QAIC_REMOTE_ATTRIBUTE;
+__QAIC_REMOTE_EXPORT void __QAIC_REMOTE(remote_register_buf_attr)(void* buf, int size, int fd, int attr) __QAIC_REMOTE_ATTRIBUTE;
+
+/* Register a dma handle with fastrpc.  This is only valid on
+ * android with ION allocated memory.  Users of fastrpc should register
+ * a file descriptor allocated with ION to enable sharing that memory to the
+ * dsp via the smmu.  Some versions of libadsprpc.so lack this
+ * function, so users should set this symbol as weak.
+ *
+ * #pragma weak  remote_register_dma_handle
+ * #pragma weak  remote_register_dma_handle_attr
+ *
+ * @fd, the file descriptor, callers can use -1 to deregister.
+ * @param len, size of the buffer
+ * @attr, map buffer as coherent or non-coherent or no-map
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_register_dma_handle)(int fd, uint32_t len) __QAIC_REMOTE_ATTRIBUTE;
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_register_dma_handle_attr)(int fd, uint32_t len, uint32_t attr) __QAIC_REMOTE_ATTRIBUTE;
+
+/*
+ * This is the default mode for the driver.  While the driver is in parallel
+ * mode it will try to invalidate output buffers after it transfers control
+ * to the dsp.  This allows the invalidate operations to overlap with the
+ * dsp processing the call.  This mode should be used when output buffers
+ * are only read on the application processor and only written on the aDSP.
+ */
+#define REMOTE_MODE_PARALLEL  0
+
+/*
+ * When operating in SERIAL mode the driver will invalidate output buffers
+ * before calling into the dsp.  This mode should be used when output
+ * buffers have been written to somewhere besides the aDSP.
+ */
+#define REMOTE_MODE_SERIAL    1
+
+/*
+ * Internal transport prefix
+ */
+#define ITRANSPORT_PREFIX "'\":;./\\"
+
+/*
+ * Set the mode of operation.
+ *
+ * Some versions of libadsprpc.so lack this function, so users should set
+ * this symbol as weak.
+ *
+ * #pragma weak  remote_set_mode
+ *
+ * @param mode, the mode
+ * @retval, 0 on success
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_set_mode)(uint32_t mode) __QAIC_REMOTE_ATTRIBUTE;
+
+/* Register a file descriptor.  This can be used when users do not have
+ * a mapping to pass to the RPC layer.  The generated address is a mapping
+ * with PROT_NONE, any access to this memory will fail, so it should only
+ * be used as an ID to identify this file descriptor to the RPC layer.
+ *
+ * To deregister use remote_register_buf(addr, size, -1).
+ *
+ * #pragma weak  remote_register_fd
+ *
+ * @param fd, the file descriptor.
+ * @param size, size to of the buffer
+ * @retval, (void*)-1 on failure, address on success.
+ * 
+ */
+__QAIC_REMOTE_EXPORT void *__QAIC_REMOTE(remote_register_fd)(int fd, int size) __QAIC_REMOTE_ATTRIBUTE;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // REMOTE_H
diff --git a/inc/remote64.h b/inc/remote64.h
new file mode 100644
index 0000000..341b2ca
--- /dev/null
+++ b/inc/remote64.h
@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef REMOTE64_H
+#define REMOTE64_H
+
+#include "remote.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+   uint64_t pv;
+   int64_t nLen;
+} remote_buf64;
+
+typedef struct {
+   int32_t fd;
+   uint32_t offset;
+   uint32_t len;
+} remote_dma_handle64;
+
+typedef union {
+   remote_buf64	 buf;
+   remote_handle     h;
+   remote_handle64 h64; //! used by multi domain modules
+   remote_dma_handle64 dma;
+} remote_arg64;
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_REMOTE_EXPORT
+#ifdef _WIN32
+#define __QAIC_REMOTE_EXPORT __declspec(dllexport)
+#else //_WIN32
+#define __QAIC_REMOTE_EXPORT
+#endif //_WIN32
+#endif //__QAIC_REMOTE_EXPORT
+
+#ifndef __QAIC_REMOTE_ATTRIBUTE
+#define __QAIC_REMOTE_ATTRIBUTE
+#endif
+
+/* map memory to the remote domain
+ *
+ * @param fd, fd associated with this memory
+ * @param flags, flags to be used for the mapping
+ * @param vaddrin, input address
+ * @param size, size of buffer
+ * @param vaddrout, output address
+ * @retval, 0 on success
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_mmap64)(int fd, uint32_t flags, uint64_t vaddrin, int64_t size, uint64_t *vaddrout) __QAIC_REMOTE_ATTRIBUTE;
+
+/* unmap memory from the remote domain
+ *
+ * @param vaddrout, remote address mapped
+ * @param size, size to unmap.  Unmapping a range partially may  not be supported.
+ * @retval, 0 on success, may fail if memory is still mapped
+ */
+__QAIC_REMOTE_EXPORT int __QAIC_REMOTE(remote_munmap64)(uint64_t vaddrout, int64_t size) __QAIC_REMOTE_ATTRIBUTE;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // REMOTE64_H
diff --git a/inc/remotectl.h b/inc/remotectl.h
new file mode 100644
index 0000000..3302a46
--- /dev/null
+++ b/inc/remotectl.h
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _REMOTECTL_H
+#define _REMOTECTL_H
+#include "AEEStdDef.h"
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+#ifdef __cplusplus
+extern "C" {
+#endif
+#if !defined(__QAIC_STRING1_OBJECT_DEFINED__) && !defined(__STRING1_OBJECT__)
+#define __QAIC_STRING1_OBJECT_DEFINED__
+#define __STRING1_OBJECT__
+typedef struct _cstring1_s {
+   char* data;
+   int dataLen;
+} _cstring1_t;
+
+#endif /* __QAIC_STRING1_OBJECT_DEFINED__ */
+#define _const_remotectl_handle 0
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(remotectl_open)(const char* name, int* handle, char* dlerror, int dlerrorLen, int* nErr) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(remotectl_close)(int handle, char* dlerror, int dlerrorLen, int* nErr) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(remotectl_grow_heap)(uint32 phyAddr, uint32 nSize) __QAIC_HEADER_ATTRIBUTE;
+__QAIC_HEADER_EXPORT int __QAIC_HEADER(remotectl_set_param)(int reqID, const uint32* params, int paramsLen) __QAIC_HEADER_ATTRIBUTE;
+#ifdef __cplusplus
+}
+#endif
+#endif //_REMOTECTL_H
diff --git a/inc/rpcmem.h b/inc/rpcmem.h
new file mode 100644
index 0000000..28f3a77
--- /dev/null
+++ b/inc/rpcmem.h
@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef RPCMEM_H
+#define RPCMEM_H
+
+#include "AEEStdDef.h"
+
+/**
+ * RPCMEM_DEFAULT_HEAP
+ * Dynamicaly select the heap to use.  This should be ok for most usecases.
+ */
+#define RPCMEM_DEFAULT_HEAP -1
+
+
+/**
+ * RPCMEM_DEFAULT_FLAGS should allocate memory with the same properties
+ * as the ION_FLAG_CACHED flag
+ */
+#ifdef ION_FLAG_CACHED
+#define RPCMEM_DEFAULT_FLAGS ION_FLAG_CACHED
+#else
+#define RPCMEM_DEFAULT_FLAGS 1
+#endif
+
+/**
+ * RPCMEM_FLAG_UNCACHED
+ * ION_FLAG_CACHED should be defined as 1
+ */
+#define RPCMEM_FLAG_UNCACHED 0
+#define RPCMEM_FLAG_CACHED RPCMEM_DEFAULT_FLAGS
+
+/**
+ * examples:
+ *
+ * heap 22, uncached, 1kb
+ *    rpcmem_alloc(22, 0, 1024);
+ *    rpcmem_alloc(22, RPCMEM_FLAG_UNCACHED, 1024);
+ *
+ * heap 21, cached, 2kb
+ *    rpcmem_alloc(21, RPCMEM_FLAG_CACHED, 2048);
+ *    #include <ion.h>
+ *    rpcmem_alloc(21, ION_FLAG_CACHED, 2048);
+ *
+ * just give me the defaults, 2kb
+ *    rpcmem_alloc(RPCMEM_DEFAULT_HEAP, RPCMEM_DEFAULT_FLAGS, 2048);
+ *    rpcmem_alloc_def(2048);
+ *
+ * give me the default flags, but from heap 18, 4kb
+ *    rpcmem_alloc(18, RPCMEM_DEFAULT_FLAGS, 4096);
+ *
+ */
+#define ION_SECURE_FLAGS    ((1 << 31) | (1 << 19))
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * call once to initialize the library
+ * Note: should not call this if rpcmem is linked from libadsprpc.so
+ * /libcdsprpc.so/libmdsprpc.so/libsdsprpc.so
+ */
+void rpcmem_init(void);
+/**
+ * call once for cleanup
+ * Note: should not call this if rpcmem is linked from libadsprpc.so
+ * /libcdsprpc.so/libmdsprpc.so/libsdsprpc.so
+ */
+void rpcmem_deinit(void);
+
+/**
+ * Allocate via ION a buffer of size
+ * @heapid, the heap id to use
+ * @flags, ion flags to use to when allocating
+ * @size, the buffer size to allocate
+ * @retval, 0 on failure, pointer to buffer on success
+ *
+ * For example:
+ *    buf = rpcmem_alloc(RPCMEM_DEFAULT_HEAP, RPCMEM_DEFAULT_FLAGS, size);
+ */
+
+void* rpcmem_alloc(int heapid, uint32 flags, int size);
+
+/**
+ * allocate with default settings
+ */
+ #if !defined(WINNT) && !defined (_WIN32_WINNT)
+__attribute__((unused))
+#endif
+static __inline void* rpcmem_alloc_def(int size) {
+   return rpcmem_alloc(RPCMEM_DEFAULT_HEAP, RPCMEM_DEFAULT_FLAGS, size);
+}
+
+/**
+ * free buffer, ignores invalid buffers
+ */
+void rpcmem_free(void* po);
+
+/**
+ * returns associated fd
+ */
+int rpcmem_to_fd(void* po);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define RPCMEM_HEAP_DEFAULT     0x80000000
+#define RPCMEM_HEAP_NOREG       0x40000000
+#define RPCMEM_HEAP_UNCACHED    0x20000000
+#define RPCMEM_HEAP_NOVA        0x10000000
+#define RPCMEM_HEAP_NONCOHERENT 0x08000000
+
+#endif //RPCMEM_H
diff --git a/inc/sbuf.h b/inc/sbuf.h
new file mode 100644
index 0000000..96775c8
--- /dev/null
+++ b/inc/sbuf.h
@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SBUF_H
+#define SBUF_H
+
+#include <string.h>
+#include <stdint.h>
+#include "AEEstd.h"
+
+/**
+ * lightweight serialize/deserialize buffer.
+
+   For example
+
+   struct sbuf;
+   //initialize empty buffer;
+   sbuf_init(&sbuf, 0, 0, 0);
+
+   //fill it with data
+   sbuf_align(&sbuf, 8);
+   sbuf_write(&sbuf, ptr1, 10);
+   sbuf_align(&sbuf, 8);
+   sbuf_write(&sbuf, ptr2, 20);
+
+   //allocate the memory needed
+   mem = malloc(sbuf_needed(&sbuf));
+
+   //initialize with the data
+   sbuf_init(&sbuf, 0, mem, sbuf_needed(&sbuf));
+
+   //fill it with data, since it has memory, it will actually copy
+   sbuf_align(&sbuf, 8);
+   sbuf_write(&sbuf, ptr1, 10);
+   sbuf_align(&sbuf, 8);
+   sbuf_write(&sbuf, ptr2, 20);
+
+   See sbuf_q.c for more examples
+ */
+
+
+struct sbuf {
+   uintptr_t buf;      //! start of valid memory
+   uintptr_t bufEnd;   //! end of valid memory
+   uintptr_t bufStart; //! start with optinal offset from valid mem
+   uintptr_t bufCur;   //! current position, could be outside of valid range
+};
+
+/**
+ * @param buf, the buffer structure instance
+ * @param offset, this value indicates how far ahead the data buffer is
+ *                start = data - offset
+ * @param data, the valid memory
+ * @param dataLen, the length ov valid memory
+ */
+static __inline void sbuf_init(struct sbuf* buf, int offset, void* data, int dataLen) {
+   buf->buf = (uintptr_t)data;
+   buf->bufStart = buf->bufCur = (uintptr_t)data - offset;
+   buf->bufEnd = (uintptr_t)data + dataLen;
+}
+
+//! move the current pointer by len
+static __inline void sbuf_advance(struct sbuf* buf, int len) {
+   buf->bufCur += len;
+}
+
+/**
+ * @retval, the amount of memory needed for everything from the start (with the offset)
+ * to the current position of the buffer
+ */
+static __inline int sbuf_needed(struct sbuf* buf) {
+   return buf->bufCur - buf->bufStart;
+}
+/**
+ * @retval, the space left in the buffer. A negative value indicates overflow.
+ *          A positive value includes the offset.
+ */
+static __inline int sbuf_left(struct sbuf* buf) {
+   return buf->bufEnd - buf->bufCur;
+}
+
+//! @retval the current head pointer
+static __inline void* sbuf_head(struct sbuf* buf) {
+   return (void*)buf->bufCur;
+}
+
+//! @retval true if the current pointer is valid
+static __inline int sbuf_valid(struct sbuf* buf) {
+   return buf->bufCur >= buf->buf && buf->bufCur < buf->bufEnd;
+}
+
+//! advance the head pointer so the "needed" is aligned to the align value
+#define _SBUF_ALIGN(x, y) (((x) + ((y)-1)) & ~((y)-1))
+static __inline void sbuf_align(struct sbuf* buf, uint32_t align) {
+   sbuf_advance(buf, _SBUF_ALIGN(sbuf_needed(buf), align) - sbuf_needed(buf));
+}
+
+/**
+ * Write to the buffer.
+ * @param src, the memory to read from.  Will write srcLen bytes to buf from src
+ *             from the buf's current position.  Only the valid portion of data will
+ *             be written.
+ * @param srcLen, the length of src.  The buffer will be advanced by srcLen.
+ */
+static __inline void sbuf_write(struct sbuf* buf, void *psrc, int srcLen) {
+   uintptr_t src = (uintptr_t)psrc;
+   if(buf->bufCur + srcLen > buf->buf) {
+      int writeLen;
+      if(buf->bufCur < buf->buf) {
+         int len = buf->buf - buf->bufCur;
+         srcLen -= len;
+         src += len;
+         sbuf_advance(buf, len);
+      }
+      writeLen = STD_MIN(srcLen, sbuf_left(buf));
+      if(writeLen > 0) {
+         std_memsmove((void*)buf->bufCur, buf->bufEnd - buf->bufCur, (void*)src, writeLen);
+      }
+   }
+   sbuf_advance(buf, srcLen);
+}
+
+/**
+ * Read from the buffer into dst.
+ * @param dst, the data to write to. Will write dstLen to dst from buf
+ *             from the current position of buf.  Only valid memory
+ *             will be written to dst.  Invalid overlapping memory will
+ *             remain untouched.
+ * @param dstLen, the length of dst.  buf will be advanced by dstLen
+ */
+static __inline void sbuf_read(struct sbuf* buf, void *pdst, int dstLen) {
+   uintptr_t dst = (uintptr_t)pdst;
+   if(buf->bufCur + dstLen > buf->buf) {
+      int readLen;
+      if(buf->bufCur < buf->buf) {
+         int len = buf->buf - buf->bufCur;
+         dstLen -= len;
+         dst += len;
+         sbuf_advance(buf, len);
+      }
+      readLen = STD_MIN(dstLen, sbuf_left(buf));
+      if(readLen > 0) {
+         std_memsmove((void*)dst, dstLen, (void*)buf->bufCur, readLen);
+      }
+   }
+   sbuf_advance(buf, dstLen);
+}
+
+#endif
diff --git a/inc/sbuf_parser.h b/inc/sbuf_parser.h
new file mode 100644
index 0000000..b4e0b28
--- /dev/null
+++ b/inc/sbuf_parser.h
@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SBUF_PARSER_H
+#define SBUF_PARSER_H
+
+#include "sbuf.h"
+
+/**
+ * Greedy Recursive Descent Parser in C
+ *
+ * Stop using strstr or regular expressions.  This simple Recursive Descent Parser can be
+ * used to handle complex grammars.
+ *
+ * For example:
+ *   parsing a query string form a uri
+ *   input: "file:///foo/bar_far.so.1?_blah1&_bar=barval5&_barfar"
+ *   expected output:
+ *      parsed query: _blah1 =
+ *      parsed query: _bar = barval5
+ *      parsed query: _barfar =
+ *
+ *   static int qmark(struct sbuf *buf) {
+ *      return sbuf_char(buf, '?');
+ *   }
+ *   static int notandoreq(struct sbuf *buf) {
+ *      return sbuf_notchars(buf, "&=");
+ *   }
+ *   static int notand(struct sbuf *buf) {
+ *      return sbuf_notchar(buf, '&');
+ *   }
+ *
+ *   const char *name;
+ *   int nameLen;
+ *   const char *value;
+ *   int valueLen;
+ *   const char *data = "file:///foo/bar_far.so.1?_blah1&_bar=barval5&_barfar";
+ *
+ *   //initialize
+ *   sbuf_parser_init(&buf, data, strlen(data));
+ *
+ *   //parse until question mark
+ *   assert(sbuf_until(&buf, sbuf_any, qmark));
+ *
+ *   //parse each query
+ *   while(!sbuf_end(&buf)) {
+ *      //record where the name starts
+ *      name = sbuf_cur(&buf);
+ *
+ *      //name is valid until '=' or '&'
+ *      assert(sbuf_many1(&buf, notandoreq));
+ *      nameLen = sbuf_cur(&buf) - name;
+ *
+ *      value = 0;
+ *      valueLen = 0;
+ *      //if the next char is a '=' then we also get a value
+ *      if(sbuf_char(&buf, '=')) {
+ *         value = sbuf_cur(&buf);
+ *
+ *         //value is until the next query that starts with '&'
+ *         assert(sbuf_many1(&buf, notand));
+ *         valueLen = sbuf_cur(&buf) - value;
+ *      }
+ *      //expect '&' or end
+ *      sbuf_char(&buf, '&');
+ *      printf("parsed query: %.*s = %.*s\n", nameLen, name, valueLen, value);
+ *   }
+ *
+ */
+
+//! init
+static __inline void sbuf_parser_init(struct sbuf* buf, const char *data, int dataLen) {
+   sbuf_init(buf, 0, (void*)data, dataLen);
+}
+
+//! current postiion
+static __inline char *sbuf_cur(struct sbuf* buf) {
+   return (char*)sbuf_head(buf);
+}
+
+//! look at the next character if the buffer is still valid
+static __inline int sbuf_peek(struct sbuf* buf, char* c) {
+   if(!sbuf_valid(buf)) {
+      return 0;
+   }
+   *c = *sbuf_cur(buf);
+   return 1;
+}
+
+//! returns true if the buffer is ended
+static __inline int sbuf_end(struct sbuf* buf) {
+   return sbuf_left(buf) == 0;
+}
+
+//! consume 1 char if its in string chars
+static __inline int sbuf_chars(struct sbuf *buf, const char *chars) {
+   int i = 0;
+   char c;
+   if(!sbuf_peek(buf, &c)) {
+      return 0;
+   }
+   for(i = 0; chars[i] != 0; ++i) {
+      if(c == chars[i]) {
+         sbuf_advance(buf, 1);
+         return 1;
+      }
+   }
+   return 0;
+}
+
+//! consume 1 char only if its not in string chars
+static __inline int sbuf_notchars(struct sbuf *buf, const char *chars) {
+   int i = 0;
+   char c;
+   if(!sbuf_peek(buf, &c)) {
+      return 0;
+   }
+   for(i = 0; chars[i] != 0; ++i) {
+      if(c == chars[i]) {
+         return 0;
+      }
+   }
+   sbuf_advance(buf, 1);
+   return 1;
+}
+
+//! consume only char t
+static __inline int sbuf_char(struct sbuf *buf, const char t) {
+   char str[2] = {t, 0};
+   return sbuf_chars(buf, str);
+}
+
+//! consume any char except for t
+static __inline int sbuf_notchar(struct sbuf *buf, const char t) {
+   char str[2] = {t, 0};
+   return sbuf_notchars(buf, str);
+}
+
+/**
+ * consume any char
+ */
+static __inline int sbuf_any(struct sbuf* buf) {
+   return sbuf_notchars(buf, "");
+}
+
+
+/**
+ * range is pairs of characters
+ *
+ * pairs are inclusive, start must be less then or equal then the end
+ *
+ * for example: AZaz09--..
+ *   matches uppercase and lowercase letters, numbers, dashes and dots
+ *
+ */
+static __inline int sbuf_range(struct sbuf *buf, const char *chars) {
+   int i, j;
+   char c;
+   if(!sbuf_peek(buf, &c)) {
+      return 0;
+   }
+   for(i = 0, j = 1; chars[i] != 0 && chars[j] != 0; i+=2,j+=2) {
+      if(c >= chars[i] && c <= chars[j]) {
+         sbuf_advance(buf, 1);
+         return 1;
+      }
+   }
+   return 0;
+}
+
+
+/**
+ * greedly consume and match the entire string
+ * empty string always succeeds without consuming any data
+ */
+static __inline int sbuf_string(struct sbuf *buf, const char *str) {
+   int i = 0;
+   for(i = 0; str[i] != 0; ++i) {
+      if(!sbuf_char(buf, str[i])) {
+         return 0;
+      }
+   }
+   return 1;
+}
+
+/**
+ * consumes until fails
+ */
+static __inline int sbuf_many(struct sbuf *buf,
+                              int(*consume)(struct sbuf *buf))
+{
+   if(!sbuf_valid(buf)) {
+      return 0;
+   }
+   while(consume(buf)) {;}
+   return 1;
+}
+/**
+ * consumes until fails, must consume at least 1
+ */
+static __inline int sbuf_many1(struct sbuf *buf,
+                               int(*consume)(struct sbuf *buf))
+{
+   if(!consume(buf)) {
+      return 0;
+   }
+   sbuf_many(buf, consume);
+   return 1;
+}
+/**
+ * runs 'consume' until 'stop' succeeds
+ * 'stop' must fail in such a way that it doesn't consume any data
+ */
+static __inline int sbuf_until(struct sbuf *buf,
+                               int(*consume)(struct sbuf *buf),
+                               int(*stop)(struct sbuf *buf))
+{
+   while(!stop(buf)) {
+      if(!consume(buf))  {
+         return 0;
+      }
+   }
+   return 1;
+}
+
+/**
+ * allows for backtracking,
+ * @param parser, runs parser and only consume if it succeeds
+ */
+static __inline int sbuf_try(struct sbuf *buf, int(*parser)(struct sbuf *buf))
+{
+   struct sbuf tryp;
+   sbuf_parser_init(&tryp, sbuf_cur(buf), sbuf_left(buf));
+   if(parser(&tryp)) {
+      sbuf_advance(buf, sbuf_cur(&tryp) - sbuf_cur(buf));
+      return 1;
+   }
+   return 0;
+}
+#endif // SBUF_PARSER_H
diff --git a/inc/shared.h b/inc/shared.h
new file mode 100644
index 0000000..14c4f19
--- /dev/null
+++ b/inc/shared.h
@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SHARED_H
+#define SHARED_H
+
+#if defined(__NIX)
+// TODO these sections not supported?
+//static __so_func *__autostart[] __attribute__((section (".CRT$XIU"))) = { (__so_func*)__so_ctor };
+//static __so_func *__autoexit[] __attribute__((section (".CRT$XPU"))) = { (__so_func*)__so_dtor };
+
+#define SHARED_OBJECT_API_ENTRY(ctor, dtor)
+
+#elif defined(_WIN32)
+#include <windows.h>
+
+typedef int __so_cb(void);
+static __so_cb *__so_get_ctor();
+static __so_cb *__so_get_dtor();
+
+typedef void __so_func(void);
+static void __so_ctor() {
+   (void)(__so_get_ctor())();
+}
+
+static void __so_dtor() {
+   (void)(__so_get_dtor())();
+}
+
+#pragma data_seg(".CRT$XIU")
+   static __so_func *__autostart[] = { (__so_func*)__so_ctor };
+#pragma data_seg(".CRT$XPU")
+   static __so_func *__autoexit[] = { (__so_func*)__so_dtor };
+#pragma data_seg()
+
+#define SHARED_OBJECT_API_ENTRY(ctor, dtor)\
+   static __so_cb *__so_get_ctor() { return (__so_cb*)ctor; }\
+   static __so_cb *__so_get_dtor() { return (__so_cb*)dtor; }
+
+#else //better be gcc
+
+#define SHARED_OBJECT_API_ENTRY(ctor, dtor)\
+__attribute__((constructor)) \
+static void __ctor__##ctor(void) {\
+   (void)ctor();\
+}\
+\
+__attribute__((destructor))\
+static void  __dtor__##dtor(void) {\
+   (void)dtor();\
+}
+
+#endif //ifdef _WIN32
+
+#endif // SHARED_H
diff --git a/inc/uthash.h b/inc/uthash.h
new file mode 100644
index 0000000..dfee1c8
--- /dev/null
+++ b/inc/uthash.h
@@ -0,0 +1,920 @@
+/*
+Copyright (c) 2003-2011, Troy D. Hanson     http://uthash.sourceforge.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef UTHASH_H
+#define UTHASH_H
+
+#include <string.h>   /* memcmp,strlen */
+#include <stddef.h>   /* ptrdiff_t */
+#include <stdlib.h>   /* exit() */
+
+/* These macros use decltype or the earlier __typeof GNU extension.
+   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
+   when compiling c++ source) this code uses whatever method is needed
+   or, for VS2008 where neither is available, uses casting workarounds. */
+#ifdef _MSC_VER         /* MS compiler */
+#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
+#define DECLTYPE(x) (decltype(x))
+#else                   /* VS2008 or older (or VS2010 in C mode) */
+#define NO_DECLTYPE
+#define DECLTYPE(x)
+#endif
+#else                   /* GNU, Sun and other compilers */
+#define DECLTYPE(x) (__typeof(x))
+#endif
+
+#ifdef NO_DECLTYPE
+#define DECLTYPE_ASSIGN(dst,src)                                                 \
+do {                                                                             \
+  char **_da_dst = (char**)(&(dst));                                             \
+  *_da_dst = (char*)(src);                                                       \
+} while(0)
+#else
+#define DECLTYPE_ASSIGN(dst,src)                                                 \
+do {                                                                             \
+  (dst) = DECLTYPE(dst)(src);                                                    \
+} while(0)
+#endif
+
+/* a number of the hash function use uint32_t which isn't defined on win32 */
+#ifdef _MSC_VER
+typedef unsigned int uint32_t;
+typedef unsigned char uint8_t;
+#else
+#include <inttypes.h>   /* uint32_t */
+#endif
+
+#define UTHASH_VERSION 1.9.4
+
+#ifndef UTHASH_MALLOC
+#define UTHASH_MALLOC malloc
+#endif
+
+#ifndef UTHASH_FREE
+#define UTHASH_FREE free
+#endif
+
+#define uthash_fatal(msg) exit(-1)        /* fatal error (out of memory,etc) */
+#define uthash_malloc(sz) UTHASH_MALLOC(sz)      /* malloc fcn                      */
+#define uthash_free(ptr,sz) UTHASH_FREE(ptr)     /* free fcn                        */
+
+#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
+#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
+
+/* initial number of buckets */
+#define HASH_INITIAL_NUM_BUCKETS 32      /* initial number of buckets        */
+#define HASH_INITIAL_NUM_BUCKETS_LOG2 5  /* lg2 of initial number of buckets */
+#define HASH_BKT_CAPACITY_THRESH 10      /* expand when bucket count reaches */
+
+/* calculate the element whose hash handle address is hhe */
+#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
+
+#define HASH_FIND(hh,head,keyptr,keylen,out)                                     \
+do {                                                                             \
+  unsigned _hf_bkt,_hf_hashv;                                                    \
+  out=NULL;                                                                      \
+  if (head) {                                                                    \
+     HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt);   \
+     if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) {                           \
+       HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
+                        keyptr,keylen,out);                                      \
+     }                                                                           \
+  }                                                                              \
+} while (0)
+
+#ifdef HASH_BLOOM
+#define HASH_BLOOM_BITLEN (1ULL << HASH_BLOOM)
+#define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8) + ((HASH_BLOOM_BITLEN%8) ? 1:0)
+#define HASH_BLOOM_MAKE(tbl)                                                     \
+do {                                                                             \
+  (tbl)->bloom_nbits = HASH_BLOOM;                                               \
+  (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN);                 \
+  if (!((tbl)->bloom_bv))  { uthash_fatal( "out of memory"); }                   \
+  memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN);                                \
+  (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE;                                       \
+} while (0);
+
+#define HASH_BLOOM_FREE(tbl)                                                     \
+do {                                                                             \
+  uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN);                              \
+} while (0);
+
+#define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8] |= (1U << ((idx)%8)))
+#define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8] & (1U << ((idx)%8)))
+
+#define HASH_BLOOM_ADD(tbl,hashv)                                                \
+  HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
+
+#define HASH_BLOOM_TEST(tbl,hashv)                                               \
+  HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1)))
+
+#else
+#define HASH_BLOOM_MAKE(tbl)
+#define HASH_BLOOM_FREE(tbl)
+#define HASH_BLOOM_ADD(tbl,hashv)
+#define HASH_BLOOM_TEST(tbl,hashv) (1)
+#endif
+
+#define HASH_MAKE_TABLE(hh,head)                                                 \
+do {                                                                             \
+  (head)->hh.tbl = (UT_hash_table*)uthash_malloc(                                \
+                  sizeof(UT_hash_table));                                        \
+  if (!((head)->hh.tbl))  { uthash_fatal( "out of memory"); }                    \
+  memset((head)->hh.tbl, 0, sizeof(UT_hash_table));                              \
+  (head)->hh.tbl->tail = &((head)->hh);                                          \
+  (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;                        \
+  (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;              \
+  (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head);                    \
+  (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc(                      \
+          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));               \
+  if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); }             \
+  memset((head)->hh.tbl->buckets, 0,                                             \
+          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));               \
+  HASH_BLOOM_MAKE((head)->hh.tbl);                                               \
+  (head)->hh.tbl->signature = HASH_SIGNATURE;                                    \
+} while(0)
+
+#define HASH_ADD(hh,head,fieldname,keylen_in,add)                                \
+        HASH_ADD_KEYPTR(hh,head,&add->fieldname,keylen_in,add)
+
+#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                            \
+do {                                                                             \
+ unsigned _ha_bkt;                                                               \
+ (add)->hh.next = NULL;                                                          \
+ (add)->hh.key = (char*)keyptr;                                                  \
+ (add)->hh.keylen = keylen_in;                                                   \
+ if (!(head)) {                                                                  \
+    head = (add);                                                                \
+    (head)->hh.prev = NULL;                                                      \
+    HASH_MAKE_TABLE(hh,head);                                                    \
+ } else {                                                                        \
+    (head)->hh.tbl->tail->next = (add);                                          \
+    (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);         \
+    (head)->hh.tbl->tail = &((add)->hh);                                         \
+ }                                                                               \
+ (head)->hh.tbl->num_items++;                                                    \
+ (add)->hh.tbl = (head)->hh.tbl;                                                 \
+ HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets,                         \
+         (add)->hh.hashv, _ha_bkt);                                              \
+ HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh);                   \
+ HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv);                                 \
+ HASH_EMIT_KEY(hh,head,keyptr,keylen_in);                                        \
+ HASH_FSCK(hh,head);                                                             \
+} while(0)
+
+#define HASH_TO_BKT( hashv, num_bkts, bkt )                                      \
+do {                                                                             \
+  bkt = ((hashv) & ((num_bkts) - 1));                                            \
+} while(0)
+
+/* delete "delptr" from the hash table.
+ * "the usual" patch-up process for the app-order doubly-linked-list.
+ * The use of _hd_hh_del below deserves special explanation.
+ * These used to be expressed using (delptr) but that led to a bug
+ * if someone used the same symbol for the head and deletee, like
+ *  HASH_DELETE(hh,users,users);
+ * We want that to work, but by changing the head (users) below
+ * we were forfeiting our ability to further refer to the deletee (users)
+ * in the patch-up process. Solution: use scratch space to
+ * copy the deletee pointer, then the latter references are via that
+ * scratch pointer rather than through the repointed (users) symbol.
+ */
+#define HASH_DELETE(hh,head,delptr)                                              \
+do {                                                                             \
+    unsigned _hd_bkt;                                                            \
+    struct UT_hash_handle *_hd_hh_del;                                           \
+    if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) )  {         \
+        uthash_free((head)->hh.tbl->buckets,                                     \
+                    (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
+        HASH_BLOOM_FREE((head)->hh.tbl);                                         \
+        uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                      \
+        head = NULL;                                                             \
+    } else {                                                                     \
+        _hd_hh_del = &((delptr)->hh);                                            \
+        if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) {     \
+            (head)->hh.tbl->tail =                                               \
+                (UT_hash_handle*)((char*)((delptr)->hh.prev) +                   \
+                (head)->hh.tbl->hho);                                            \
+        }                                                                        \
+        if ((delptr)->hh.prev) {                                                 \
+            ((UT_hash_handle*)((char*)((delptr)->hh.prev) +                      \
+                    (head)->hh.tbl->hho))->next = (delptr)->hh.next;             \
+        } else {                                                                 \
+            DECLTYPE_ASSIGN(head,(delptr)->hh.next);                             \
+        }                                                                        \
+        if (_hd_hh_del->next) {                                                  \
+            ((UT_hash_handle*)((char*)_hd_hh_del->next +                         \
+                    (head)->hh.tbl->hho))->prev =                                \
+                    _hd_hh_del->prev;                                            \
+        }                                                                        \
+        HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt);   \
+        HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del);        \
+        (head)->hh.tbl->num_items--;                                             \
+    }                                                                            \
+    HASH_FSCK(hh,head);                                                          \
+} while (0)
+
+/* use this function to delete an item from a table only if its in that table */
+#define HASH_DELETE_IF(hh,group,ptr) \
+do {\
+   if(ptr && group && ptr->hh.tbl) { \
+      HASH_DELETE(hh,group,ptr); \
+      ptr->hh.tbl = 0;\
+   } \
+} while(0)
+
+/* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
+#define HASH_FIND_STR(head,findstr,out)                                          \
+    HASH_FIND(hh,head,findstr,strlen(findstr),out)
+#define HASH_ADD_STR(head,strfield,add)                                          \
+    HASH_ADD(hh,head,strfield,strlen(add->strfield),add)
+#define HASH_FIND_INT(head,findint,out)                                          \
+    HASH_FIND(hh,head,findint,sizeof(int),out)
+#define HASH_ADD_INT(head,intfield,add)                                          \
+    HASH_ADD(hh,head,intfield,sizeof(int),add)
+#define HASH_FIND_PTR(head,findptr,out)                                          \
+    HASH_FIND(hh,head,findptr,sizeof(void *),out)
+#define HASH_ADD_PTR(head,ptrfield,add)                                          \
+    HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
+#define HASH_DEL(head,delptr)                                                    \
+    HASH_DELETE(hh,head,delptr)
+
+/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
+ * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
+ */
+#ifdef HASH_DEBUG
+#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
+#define HASH_FSCK(hh,head)                                                       \
+do {                                                                             \
+    unsigned _bkt_i;                                                             \
+    unsigned _count, _bkt_count;                                                 \
+    char *_prev;                                                                 \
+    struct UT_hash_handle *_thh;                                                 \
+    if (head) {                                                                  \
+        _count = 0;                                                              \
+        for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) {       \
+            _bkt_count = 0;                                                      \
+            _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                      \
+            _prev = NULL;                                                        \
+            while (_thh) {                                                       \
+               if (_prev != (char*)(_thh->hh_prev)) {                            \
+                   HASH_OOPS("invalid hh_prev %p, actual %p\n",                  \
+                    _thh->hh_prev, _prev );                                      \
+               }                                                                 \
+               _bkt_count++;                                                     \
+               _prev = (char*)(_thh);                                            \
+               _thh = _thh->hh_next;                                             \
+            }                                                                    \
+            _count += _bkt_count;                                                \
+            if ((head)->hh.tbl->buckets[_bkt_i].count !=  _bkt_count) {          \
+               HASH_OOPS("invalid bucket count %d, actual %d\n",                 \
+                (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count);              \
+            }                                                                    \
+        }                                                                        \
+        if (_count != (head)->hh.tbl->num_items) {                               \
+            HASH_OOPS("invalid hh item count %d, actual %d\n",                   \
+                (head)->hh.tbl->num_items, _count );                             \
+        }                                                                        \
+        /* traverse hh in app order; check next/prev integrity, count */         \
+        _count = 0;                                                              \
+        _prev = NULL;                                                            \
+        _thh =  &(head)->hh;                                                     \
+        while (_thh) {                                                           \
+           _count++;                                                             \
+           if (_prev !=(char*)(_thh->prev)) {                                    \
+              HASH_OOPS("invalid prev %p, actual %p\n",                          \
+                    _thh->prev, _prev );                                         \
+           }                                                                     \
+           _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh);                    \
+           _thh = ( _thh->next ?  (UT_hash_handle*)((char*)(_thh->next) +        \
+                                  (head)->hh.tbl->hho) : NULL );                 \
+        }                                                                        \
+        if (_count != (head)->hh.tbl->num_items) {                               \
+            HASH_OOPS("invalid app item count %d, actual %d\n",                  \
+                (head)->hh.tbl->num_items, _count );                             \
+        }                                                                        \
+    }                                                                            \
+} while (0)
+#else
+#define HASH_FSCK(hh,head)
+#endif
+
+/* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
+ * the descriptor to which this macro is defined for tuning the hash function.
+ * The app can #include <unistd.h> to get the prototype for write(2). */
+#ifdef HASH_EMIT_KEYS
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)                                   \
+do {                                                                             \
+    unsigned _klen = fieldlen;                                                   \
+    write(HASH_EMIT_KEYS, &_klen, sizeof(_klen));                                \
+    write(HASH_EMIT_KEYS, keyptr, fieldlen);                                     \
+} while (0)
+#else
+#define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
+#endif
+
+/* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */
+#ifdef HASH_FUNCTION
+#define HASH_FCN HASH_FUNCTION
+#else
+#define HASH_FCN HASH_JEN
+#endif
+
+/* The Bernstein hash function, used in Perl prior to v5.6 */
+#define HASH_BER(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+  unsigned _hb_keylen=keylen;                                                    \
+  char *_hb_key=(char*)(key);                                                    \
+  (hashv) = 0;                                                                   \
+  while (_hb_keylen--)  { (hashv) = ((hashv) * 33) + *_hb_key++; }               \
+  bkt = (hashv) & (num_bkts-1);                                                  \
+} while (0)
+
+
+/* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
+ * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
+#define HASH_SAX(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+  unsigned _sx_i;                                                                \
+  char *_hs_key=(char*)(key);                                                    \
+  hashv = 0;                                                                     \
+  for(_sx_i=0; _sx_i < keylen; _sx_i++)                                          \
+      hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i];                     \
+  bkt = hashv & (num_bkts-1);                                                    \
+} while (0)
+
+#define HASH_FNV(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+  unsigned _fn_i;                                                                \
+  char *_hf_key=(char*)(key);                                                    \
+  hashv = 2166136261UL;                                                          \
+  for(_fn_i=0; _fn_i < keylen; _fn_i++)                                          \
+      hashv = (hashv * 16777619) ^ _hf_key[_fn_i];                               \
+  bkt = hashv & (num_bkts-1);                                                    \
+} while(0);
+
+#define HASH_OAT(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+  unsigned _ho_i;                                                                \
+  char *_ho_key=(char*)(key);                                                    \
+  hashv = 0;                                                                     \
+  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
+      hashv += _ho_key[_ho_i];                                                   \
+      hashv += (hashv << 10);                                                    \
+      hashv ^= (hashv >> 6);                                                     \
+  }                                                                              \
+  hashv += (hashv << 3);                                                         \
+  hashv ^= (hashv >> 11);                                                        \
+  hashv += (hashv << 15);                                                        \
+  bkt = hashv & (num_bkts-1);                                                    \
+} while(0)
+
+#define HASH_JEN_MIX(a,b,c)                                                      \
+do {                                                                             \
+  a -= b; a -= c; a ^= ( c >> 13 );                                              \
+  b -= c; b -= a; b ^= ( a << 8 );                                               \
+  c -= a; c -= b; c ^= ( b >> 13 );                                              \
+  a -= b; a -= c; a ^= ( c >> 12 );                                              \
+  b -= c; b -= a; b ^= ( a << 16 );                                              \
+  c -= a; c -= b; c ^= ( b >> 5 );                                               \
+  a -= b; a -= c; a ^= ( c >> 3 );                                               \
+  b -= c; b -= a; b ^= ( a << 10 );                                              \
+  c -= a; c -= b; c ^= ( b >> 15 );                                              \
+} while (0)
+
+#define HASH_JEN(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+  unsigned _hj_i,_hj_j,_hj_k;                                                    \
+  char *_hj_key=(char*)(key);                                                    \
+  hashv = 0xfeedbeef;                                                            \
+  _hj_i = _hj_j = 0x9e3779b9;                                                    \
+  _hj_k = keylen;                                                                \
+  while (_hj_k >= 12) {                                                          \
+    _hj_i +=    (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 )                      \
+        + ( (unsigned)_hj_key[2] << 16 )                                         \
+        + ( (unsigned)_hj_key[3] << 24 ) );                                      \
+    _hj_j +=    (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 )                      \
+        + ( (unsigned)_hj_key[6] << 16 )                                         \
+        + ( (unsigned)_hj_key[7] << 24 ) );                                      \
+    hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 )                         \
+        + ( (unsigned)_hj_key[10] << 16 )                                        \
+        + ( (unsigned)_hj_key[11] << 24 ) );                                     \
+                                                                                 \
+     HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                          \
+                                                                                 \
+     _hj_key += 12;                                                              \
+     _hj_k -= 12;                                                                \
+  }                                                                              \
+  hashv += keylen;                                                               \
+  switch ( _hj_k ) {                                                             \
+     case 11: hashv += ( (unsigned)_hj_key[10] << 24 );                          \
+     case 10: hashv += ( (unsigned)_hj_key[9] << 16 );                           \
+     case 9:  hashv += ( (unsigned)_hj_key[8] << 8 );                            \
+     case 8:  _hj_j += ( (unsigned)_hj_key[7] << 24 );                           \
+     case 7:  _hj_j += ( (unsigned)_hj_key[6] << 16 );                           \
+     case 6:  _hj_j += ( (unsigned)_hj_key[5] << 8 );                            \
+     case 5:  _hj_j += _hj_key[4];                                               \
+     case 4:  _hj_i += ( (unsigned)_hj_key[3] << 24 );                           \
+     case 3:  _hj_i += ( (unsigned)_hj_key[2] << 16 );                           \
+     case 2:  _hj_i += ( (unsigned)_hj_key[1] << 8 );                            \
+     case 1:  _hj_i += _hj_key[0];                                               \
+  }                                                                              \
+  HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                             \
+  bkt = hashv & (num_bkts-1);                                                    \
+} while(0)
+
+/* The Paul Hsieh hash function */
+#undef get16bits
+#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__)             \
+  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
+#define get16bits(d) (*((const uint16_t *) (d)))
+#endif
+
+#if !defined (get16bits)
+#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
+                       +(uint32_t)(((const uint8_t *)(d))[0]) )
+#endif
+#define HASH_SFH(key,keylen,num_bkts,hashv,bkt)                                  \
+do {                                                                             \
+  char *_sfh_key=(char*)(key);                                                   \
+  uint32_t _sfh_tmp, _sfh_len = keylen;                                          \
+                                                                                 \
+  int _sfh_rem = _sfh_len & 3;                                                   \
+  _sfh_len >>= 2;                                                                \
+  hashv = 0xcafebabe;                                                            \
+                                                                                 \
+  /* Main loop */                                                                \
+  for (;_sfh_len > 0; _sfh_len--) {                                              \
+    hashv    += get16bits (_sfh_key);                                            \
+    _sfh_tmp       = (get16bits (_sfh_key+2) << 11) ^ hashv;                     \
+    hashv     = (hashv << 16) ^ _sfh_tmp;                                        \
+    _sfh_key += 2*sizeof (uint16_t);                                             \
+    hashv    += hashv >> 11;                                                     \
+  }                                                                              \
+                                                                                 \
+  /* Handle end cases */                                                         \
+  switch (_sfh_rem) {                                                            \
+    case 3: hashv += get16bits (_sfh_key);                                       \
+            hashv ^= hashv << 16;                                                \
+            hashv ^= _sfh_key[sizeof (uint16_t)] << 18;                          \
+            hashv += hashv >> 11;                                                \
+            break;                                                               \
+    case 2: hashv += get16bits (_sfh_key);                                       \
+            hashv ^= hashv << 11;                                                \
+            hashv += hashv >> 17;                                                \
+            break;                                                               \
+    case 1: hashv += *_sfh_key;                                                  \
+            hashv ^= hashv << 10;                                                \
+            hashv += hashv >> 1;                                                 \
+  }                                                                              \
+                                                                                 \
+    /* Force "avalanching" of final 127 bits */                                  \
+    hashv ^= hashv << 3;                                                         \
+    hashv += hashv >> 5;                                                         \
+    hashv ^= hashv << 4;                                                         \
+    hashv += hashv >> 17;                                                        \
+    hashv ^= hashv << 25;                                                        \
+    hashv += hashv >> 6;                                                         \
+    bkt = hashv & (num_bkts-1);                                                  \
+} while(0);
+
+#ifdef HASH_USING_NO_STRICT_ALIASING
+/* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads.
+ * For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error.
+ * MurmurHash uses the faster approach only on CPU's where we know it's safe.
+ *
+ * Note the preprocessor built-in defines can be emitted using:
+ *
+ *   gcc -m64 -dM -E - < /dev/null                  (on gcc)
+ *   cc -## a.c (where a.c is a simple test file)   (Sun Studio)
+ */
+#if (defined(__i386__) || defined(__x86_64__))
+#define MUR_GETBLOCK(p,i) p[i]
+#else /* non intel */
+#define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 0x3) == 0)
+#define MUR_PLUS1_ALIGNED(p) (((unsigned long)p & 0x3) == 1)
+#define MUR_PLUS2_ALIGNED(p) (((unsigned long)p & 0x3) == 2)
+#define MUR_PLUS3_ALIGNED(p) (((unsigned long)p & 0x3) == 3)
+#define WP(p) ((uint32_t*)((unsigned long)(p) & ~3UL))
+#if (defined(__BIG_ENDIAN__) || defined(SPARC) || defined(__ppc__) || defined(__ppc64__))
+#define MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24))
+#define MUR_TWO_TWO(p)   ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16))
+#define MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >>  8))
+#else /* assume little endian non-intel */
+#define MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24))
+#define MUR_TWO_TWO(p)   ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16))
+#define MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) <<  8))
+#endif
+#define MUR_GETBLOCK(p,i) (MUR_PLUS0_ALIGNED(p) ? ((p)[i]) :           \
+                            (MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : \
+                             (MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) :  \
+                                                      MUR_ONE_THREE(p))))
+#endif
+#define MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
+#define MUR_FMIX(_h) \
+do {                 \
+  _h ^= _h >> 16;    \
+  _h *= 0x85ebca6b;  \
+  _h ^= _h >> 13;    \
+  _h *= 0xc2b2ae35l; \
+  _h ^= _h >> 16;    \
+} while(0)
+
+#define HASH_MUR(key,keylen,num_bkts,hashv,bkt)                        \
+do {                                                                   \
+  const uint8_t *_mur_data = (const uint8_t*)(key);                    \
+  const int _mur_nblocks = (keylen) / 4;                               \
+  uint32_t _mur_h1 = 0xf88D5353;                                       \
+  uint32_t _mur_c1 = 0xcc9e2d51;                                       \
+  uint32_t _mur_c2 = 0x1b873593;                                       \
+  const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+_mur_nblocks*4); \
+  int _mur_i;                                                          \
+  for(_mur_i = -_mur_nblocks; _mur_i; _mur_i++) {                      \
+    uint32_t _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i);               \
+    _mur_k1 *= _mur_c1;                                                \
+    _mur_k1 = MUR_ROTL32(_mur_k1,15);                                  \
+    _mur_k1 *= _mur_c2;                                                \
+                                                                       \
+    _mur_h1 ^= _mur_k1;                                                \
+    _mur_h1 = MUR_ROTL32(_mur_h1,13);                                  \
+    _mur_h1 = _mur_h1*5+0xe6546b64;                                    \
+  }                                                                    \
+  const uint8_t *_mur_tail = (const uint8_t*)(_mur_data + _mur_nblocks*4); \
+  uint32_t _mur_k1=0;                                                  \
+  switch((keylen) & 3) {                                               \
+    case 3: _mur_k1 ^= _mur_tail[2] << 16;                             \
+    case 2: _mur_k1 ^= _mur_tail[1] << 8;                              \
+    case 1: _mur_k1 ^= _mur_tail[0];                                   \
+    _mur_k1 *= _mur_c1;                                                \
+    _mur_k1 = MUR_ROTL32(_mur_k1,15);                                  \
+    _mur_k1 *= _mur_c2;                                                \
+    _mur_h1 ^= _mur_k1;                                                \
+  }                                                                    \
+  _mur_h1 ^= (keylen);                                                 \
+  MUR_FMIX(_mur_h1);                                                   \
+  hashv = _mur_h1;                                                     \
+  bkt = hashv & (num_bkts-1);                                          \
+} while(0)
+#endif  /* HASH_USING_NO_STRICT_ALIASING */
+
+/* key comparison function; return 0 if keys equal */
+#define HASH_KEYCMP(a,b,len) memcmp(a,b,len)
+
+/* iterate over items in a known bucket to find desired item */
+#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out)                       \
+do {                                                                             \
+ if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head));          \
+ else out=NULL;                                                                  \
+ while (out) {                                                                   \
+    if (out->hh.keylen == keylen_in) {                                           \
+        if ((HASH_KEYCMP(out->hh.key,keyptr,keylen_in)) == 0) break;             \
+    }                                                                            \
+    if (out->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,out->hh.hh_next)); \
+    else out = NULL;                                                             \
+ }                                                                               \
+} while(0)
+
+/* add an item to a bucket  */
+#define HASH_ADD_TO_BKT(head,addhh)                                              \
+do {                                                                             \
+ head.count++;                                                                   \
+ (addhh)->hh_next = head.hh_head;                                                \
+ (addhh)->hh_prev = NULL;                                                        \
+ if (head.hh_head) { (head).hh_head->hh_prev = (addhh); }                        \
+ (head).hh_head=addhh;                                                           \
+ if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH)             \
+     && (addhh)->tbl->noexpand != 1) {                                           \
+       HASH_EXPAND_BUCKETS((addhh)->tbl);                                        \
+ }                                                                               \
+} while(0)
+
+/* remove an item from a given bucket */
+#define HASH_DEL_IN_BKT(hh,head,hh_del)                                          \
+    (head).count--;                                                              \
+    if ((head).hh_head == hh_del) {                                              \
+      (head).hh_head = hh_del->hh_next;                                          \
+    }                                                                            \
+    if (hh_del->hh_prev) {                                                       \
+        hh_del->hh_prev->hh_next = hh_del->hh_next;                              \
+    }                                                                            \
+    if (hh_del->hh_next) {                                                       \
+        hh_del->hh_next->hh_prev = hh_del->hh_prev;                              \
+    }
+
+/* Bucket expansion has the effect of doubling the number of buckets
+ * and redistributing the items into the new buckets. Ideally the
+ * items will distribute more or less evenly into the new buckets
+ * (the extent to which this is true is a measure of the quality of
+ * the hash function as it applies to the key domain).
+ *
+ * With the items distributed into more buckets, the chain length
+ * (item count) in each bucket is reduced. Thus by expanding buckets
+ * the hash keeps a bound on the chain length. This bounded chain
+ * length is the essence of how a hash provides constant time lookup.
+ *
+ * The calculation of tbl->ideal_chain_maxlen below deserves some
+ * explanation. First, keep in mind that we're calculating the ideal
+ * maximum chain length based on the *new* (doubled) bucket count.
+ * In fractions this is just n/b (n=number of items,b=new num buckets).
+ * Since the ideal chain length is an integer, we want to calculate
+ * ceil(n/b). We don't depend on floating point arithmetic in this
+ * hash, so to calculate ceil(n/b) with integers we could write
+ *
+ *      ceil(n/b) = (n/b) + ((n%b)?1:0)
+ *
+ * and in fact a previous version of this hash did just that.
+ * But now we have improved things a bit by recognizing that b is
+ * always a power of two. We keep its base 2 log handy (call it lb),
+ * so now we can write this with a bit shift and logical AND:
+ *
+ *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
+ *
+ */
+#define HASH_EXPAND_BUCKETS(tbl)                                                 \
+do {                                                                             \
+    unsigned _he_bkt;                                                            \
+    unsigned _he_bkt_i;                                                          \
+    struct UT_hash_handle *_he_thh, *_he_hh_nxt;                                 \
+    UT_hash_bucket *_he_new_buckets, *_he_newbkt;                                \
+    _he_new_buckets = (UT_hash_bucket*)uthash_malloc(                            \
+             2 * tbl->num_buckets * sizeof(struct UT_hash_bucket));              \
+    if (!_he_new_buckets) { uthash_fatal( "out of memory"); }                    \
+    memset(_he_new_buckets, 0,                                                   \
+            2 * tbl->num_buckets * sizeof(struct UT_hash_bucket));               \
+    tbl->ideal_chain_maxlen =                                                    \
+       (tbl->num_items >> (tbl->log2_num_buckets+1)) +                           \
+       ((tbl->num_items & ((tbl->num_buckets*2)-1)) ? 1 : 0);                    \
+    tbl->nonideal_items = 0;                                                     \
+    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)                \
+    {                                                                            \
+        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;                             \
+        while (_he_thh) {                                                        \
+           _he_hh_nxt = _he_thh->hh_next;                                        \
+           HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2, _he_bkt);            \
+           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);                           \
+           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {                \
+             tbl->nonideal_items++;                                              \
+             _he_newbkt->expand_mult = _he_newbkt->count /                       \
+                                        tbl->ideal_chain_maxlen;                 \
+           }                                                                     \
+           _he_thh->hh_prev = NULL;                                              \
+           _he_thh->hh_next = _he_newbkt->hh_head;                               \
+           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =               \
+                _he_thh;                                                         \
+           _he_newbkt->hh_head = _he_thh;                                        \
+           _he_thh = _he_hh_nxt;                                                 \
+        }                                                                        \
+    }                                                                            \
+    uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
+    tbl->num_buckets *= 2;                                                       \
+    tbl->log2_num_buckets++;                                                     \
+    tbl->buckets = _he_new_buckets;                                              \
+    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?         \
+        (tbl->ineff_expands+1) : 0;                                              \
+    if (tbl->ineff_expands > 1) {                                                \
+        tbl->noexpand=1;                                                         \
+        uthash_noexpand_fyi(tbl);                                                \
+    }                                                                            \
+    uthash_expand_fyi(tbl);                                                      \
+} while(0)
+
+
+/* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
+/* Note that HASH_SORT assumes the hash handle name to be hh.
+ * HASH_SRT was added to allow the hash handle name to be passed in. */
+#define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
+#define HASH_SRT(hh,head,cmpfcn)                                                 \
+do {                                                                             \
+  unsigned _hs_i;                                                                \
+  unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize;               \
+  struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail;            \
+  if (head) {                                                                    \
+      _hs_insize = 1;                                                            \
+      _hs_looping = 1;                                                           \
+      _hs_list = &((head)->hh);                                                  \
+      while (_hs_looping) {                                                      \
+          _hs_p = _hs_list;                                                      \
+          _hs_list = NULL;                                                       \
+          _hs_tail = NULL;                                                       \
+          _hs_nmerges = 0;                                                       \
+          while (_hs_p) {                                                        \
+              _hs_nmerges++;                                                     \
+              _hs_q = _hs_p;                                                     \
+              _hs_psize = 0;                                                     \
+              for ( _hs_i = 0; _hs_i  < _hs_insize; _hs_i++ ) {                  \
+                  _hs_psize++;                                                   \
+                  _hs_q = (UT_hash_handle*)((_hs_q->next) ?                      \
+                          ((void*)((char*)(_hs_q->next) +                        \
+                          (head)->hh.tbl->hho)) : NULL);                         \
+                  if (! (_hs_q) ) break;                                         \
+              }                                                                  \
+              _hs_qsize = _hs_insize;                                            \
+              while ((_hs_psize > 0) || ((_hs_qsize > 0) && _hs_q )) {           \
+                  if (_hs_psize == 0) {                                          \
+                      _hs_e = _hs_q;                                             \
+                      _hs_q = (UT_hash_handle*)((_hs_q->next) ?                  \
+                              ((void*)((char*)(_hs_q->next) +                    \
+                              (head)->hh.tbl->hho)) : NULL);                     \
+                      _hs_qsize--;                                               \
+                  } else if ( (_hs_qsize == 0) || !(_hs_q) ) {                   \
+                      _hs_e = _hs_p;                                             \
+                      _hs_p = (UT_hash_handle*)((_hs_p->next) ?                  \
+                              ((void*)((char*)(_hs_p->next) +                    \
+                              (head)->hh.tbl->hho)) : NULL);                     \
+                      _hs_psize--;                                               \
+                  } else if ((                                                   \
+                      cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
+                             DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
+                             ) <= 0) {                                           \
+                      _hs_e = _hs_p;                                             \
+                      _hs_p = (UT_hash_handle*)((_hs_p->next) ?                  \
+                              ((void*)((char*)(_hs_p->next) +                    \
+                              (head)->hh.tbl->hho)) : NULL);                     \
+                      _hs_psize--;                                               \
+                  } else {                                                       \
+                      _hs_e = _hs_q;                                             \
+                      _hs_q = (UT_hash_handle*)((_hs_q->next) ?                  \
+                              ((void*)((char*)(_hs_q->next) +                    \
+                              (head)->hh.tbl->hho)) : NULL);                     \
+                      _hs_qsize--;                                               \
+                  }                                                              \
+                  if ( _hs_tail ) {                                              \
+                      _hs_tail->next = ((_hs_e) ?                                \
+                            ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL);          \
+                  } else {                                                       \
+                      _hs_list = _hs_e;                                          \
+                  }                                                              \
+                  _hs_e->prev = ((_hs_tail) ?                                    \
+                     ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL);              \
+                  _hs_tail = _hs_e;                                              \
+              }                                                                  \
+              _hs_p = _hs_q;                                                     \
+          }                                                                      \
+          _hs_tail->next = NULL;                                                 \
+          if ( _hs_nmerges <= 1 ) {                                              \
+              _hs_looping=0;                                                     \
+              (head)->hh.tbl->tail = _hs_tail;                                   \
+              DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list));      \
+          }                                                                      \
+          _hs_insize *= 2;                                                       \
+      }                                                                          \
+      HASH_FSCK(hh,head);                                                        \
+ }                                                                               \
+} while (0)
+
+/* This function selects items from one hash into another hash.
+ * The end result is that the selected items have dual presence
+ * in both hashes. There is no copy of the items made; rather
+ * they are added into the new hash through a secondary hash
+ * hash handle that must be present in the structure. */
+#define HASH_SELECT(hh_dst, dst, hh_src, src, cond)                              \
+do {                                                                             \
+  unsigned _src_bkt, _dst_bkt;                                                   \
+  void *_last_elt=NULL, *_elt;                                                   \
+  UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL;                         \
+  ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst));                 \
+  if (src) {                                                                     \
+    for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) {     \
+      for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head;                \
+          _src_hh;                                                               \
+          _src_hh = _src_hh->hh_next) {                                          \
+          _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh);                       \
+          if (cond(_elt)) {                                                      \
+            _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho);               \
+            _dst_hh->key = _src_hh->key;                                         \
+            _dst_hh->keylen = _src_hh->keylen;                                   \
+            _dst_hh->hashv = _src_hh->hashv;                                     \
+            _dst_hh->prev = _last_elt;                                           \
+            _dst_hh->next = NULL;                                                \
+            if (_last_elt_hh) { _last_elt_hh->next = _elt; }                     \
+            if (!dst) {                                                          \
+              DECLTYPE_ASSIGN(dst,_elt);                                         \
+              HASH_MAKE_TABLE(hh_dst,dst);                                       \
+            } else {                                                             \
+              _dst_hh->tbl = (dst)->hh_dst.tbl;                                  \
+            }                                                                    \
+            HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt);    \
+            HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh);            \
+            (dst)->hh_dst.tbl->num_items++;                                      \
+            _last_elt = _elt;                                                    \
+            _last_elt_hh = _dst_hh;                                              \
+          }                                                                      \
+      }                                                                          \
+    }                                                                            \
+  }                                                                              \
+  HASH_FSCK(hh_dst,dst);                                                         \
+} while (0)
+
+#define HASH_CLEAR(hh,head)                                                      \
+do {                                                                             \
+  if (head) {                                                                    \
+    uthash_free((head)->hh.tbl->buckets,                                         \
+                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
+    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
+    (head)=NULL;                                                                 \
+  }                                                                              \
+} while(0)
+
+#ifdef NO_DECLTYPE
+#define HASH_ITER(hh,head,el,tmp)                                                \
+for((el)=(head), (*(char**)(&(tmp)))=(char*)((head)?(head)->hh.next:NULL);       \
+  el; (el)=(tmp),(*(char**)(&(tmp)))=(char*)((tmp)?(tmp)->hh.next:NULL))
+#else
+#define HASH_ITER(hh,head,el,tmp)                                                \
+for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL);                 \
+  el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))
+#endif
+
+/* obtain a count of items in the hash */
+#define HASH_COUNT(head) HASH_CNT(hh,head)
+#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0)
+
+typedef struct UT_hash_bucket {
+   struct UT_hash_handle *hh_head;
+   unsigned count;
+
+   /* expand_mult is normally set to 0. In this situation, the max chain length
+    * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
+    * the bucket's chain exceeds this length, bucket expansion is triggered).
+    * However, setting expand_mult to a non-zero value delays bucket expansion
+    * (that would be triggered by additions to this particular bucket)
+    * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
+    * (The multiplier is simply expand_mult+1). The whole idea of this
+    * multiplier is to reduce bucket expansions, since they are expensive, in
+    * situations where we know that a particular bucket tends to be overused.
+    * It is better to let its chain length grow to a longer yet-still-bounded
+    * value, than to do an O(n) bucket expansion too often.
+    */
+   unsigned expand_mult;
+
+} UT_hash_bucket;
+
+/* random signature used only to find hash tables in external analysis */
+#define HASH_SIGNATURE 0xa0111fe1
+#define HASH_BLOOM_SIGNATURE 0xb12220f2
+
+typedef struct UT_hash_table {
+   UT_hash_bucket *buckets;
+   unsigned num_buckets, log2_num_buckets;
+   unsigned num_items;
+   struct UT_hash_handle *tail; /* tail hh in app order, for fast append    */
+   ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
+
+   /* in an ideal situation (all buckets used equally), no bucket would have
+    * more than ceil(#items/#buckets) items. that's the ideal chain length. */
+   unsigned ideal_chain_maxlen;
+
+   /* nonideal_items is the number of items in the hash whose chain position
+    * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
+    * hash distribution; reaching them in a chain traversal takes >ideal steps */
+   unsigned nonideal_items;
+
+   /* ineffective expands occur when a bucket doubling was performed, but
+    * afterward, more than half the items in the hash had nonideal chain
+    * positions. If this happens on two consecutive expansions we inhibit any
+    * further expansion, as it's not helping; this happens when the hash
+    * function isn't a good fit for the key domain. When expansion is inhibited
+    * the hash will still work, albeit no longer in constant time. */
+   unsigned ineff_expands, noexpand;
+
+   uint32_t signature; /* used only to find hash tables in external analysis */
+#ifdef HASH_BLOOM
+   uint32_t bloom_sig; /* used only to test bloom exists in external analysis */
+   uint8_t *bloom_bv;
+   char bloom_nbits;
+#endif
+
+} UT_hash_table;
+
+typedef struct UT_hash_handle {
+   struct UT_hash_table *tbl;
+   void *prev;                       /* prev element in app order      */
+   void *next;                       /* next element in app order      */
+   struct UT_hash_handle *hh_prev;   /* previous hh in bucket order    */
+   struct UT_hash_handle *hh_next;   /* next hh in bucket order        */
+   void *key;                        /* ptr to enclosing struct's key  */
+   unsigned keylen;                  /* enclosing struct's key len     */
+   unsigned hashv;                   /* result of hash-fcn(key)        */
+} UT_hash_handle;
+
+#endif /* UTHASH_H */
diff --git a/inc/verify.h b/inc/verify.h
new file mode 100644
index 0000000..b5e5c21
--- /dev/null
+++ b/inc/verify.h
@@ -0,0 +1,150 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VERIFY_H
+#define VERIFY_H
+
+#include "AEEstd.h"
+
+//#define VERIFY_PRINT_ERROR
+//#define VERIFY_PRINT_INFO
+
+
+#ifndef _WIN32
+#define C_ASSERT(test) \
+    switch(0) {\
+      case 0:\
+      case test:;\
+    }
+#endif // _WIN32
+
+#ifndef __V_STR__
+	#define __V_STR__(x) #x ":"
+#endif //__STR__
+#ifndef __V_TOSTR__
+	#define __V_TOSTR__(x) __V_STR__(x)
+#endif // __TOSTR__
+#ifndef __V_FILE_LINE__
+	#define __V_FILE_LINE__ __FILE__ ":" __V_TOSTR__(__LINE__)
+#endif /*__FILE_LINE__*/
+
+
+#ifdef __ANDROID__
+/*android */
+#if (defined VERIFY_PRINT_INFO) || (defined VERIFY_PRINT_ERROR)
+#include <android/log.h>
+#endif
+
+extern const char* __progname;
+#ifdef VERIFY_PRINT_INFO
+#define VERIFY_IPRINTF(format, ...) __android_log_print(ANDROID_LOG_DEBUG , __progname, __V_FILE_LINE__ format, ##__VA_ARGS__)
+#endif
+
+#ifdef VERIFY_PRINT_ERROR
+#define VERIFY_EPRINTF(format, ...) __android_log_print(ANDROID_LOG_ERROR , __progname, __V_FILE_LINE__ format, ##__VA_ARGS__)
+#endif
+
+/* end android */
+#elif (defined __hexagon__) || (defined __qdsp6__)
+/* q6 */
+
+#ifdef VERIFY_PRINT_INFO
+   #define FARF_VERIFY_LOW  1
+   #define FARF_VERIFY_LOW_LEVEL HAP_LEVEL_LOW
+   #define VERIFY_IPRINTF(args...) FARF(VERIFY_LOW, args)
+#endif
+
+#ifdef VERIFY_PRINT_ERROR
+   #define FARF_VERIFY_ERROR         1
+   #define FARF_VERIFY_ERROR_LEVEL HAP_LEVEL_ERROR
+   #define VERIFY_EPRINTF(args...) FARF(VERIFY_ERROR, args)
+#endif
+
+#if (defined VERIFY_PRINT_INFO) || (defined VERIFY_PRINT_ERROR)
+   #include "HAP_farf.h"
+#endif
+
+/* end q6 */
+#else
+/* generic */
+
+#if (defined VERIFY_PRINT_INFO) || (defined VERIFY_PRINT_ERROR)
+#include <stdio.h>
+#endif
+
+#ifdef VERIFY_PRINT_INFO
+#define VERIFY_IPRINTF(format, ...) printf(__V_FILE_LINE__ format, ##__VA_ARGS__)
+#endif
+
+#ifdef VERIFY_PRINT_ERROR
+#define VERIFY_EPRINTF(format, ...) printf(__V_FILE_LINE__ format, ##__VA_ARGS__)
+#endif
+
+/* end generic */
+#endif
+
+#ifndef VERIFY_PRINT_INFO
+#define VERIFY_IPRINTF(format, ...) (void)0
+#endif
+
+#ifndef VERIFY_PRINT_ERROR
+#define VERIFY_EPRINTF(format, ...) (void)0
+#endif
+
+#ifndef VERIFY
+	#define VERIFY(val) \
+	   do {\
+		  VERIFY_IPRINTF(":info: calling: " #val "\n");\
+		  if(0 == (val)) {\
+			 nErr = nErr == 0 ? -1 : nErr;\
+			 VERIFY_EPRINTF(":error: %d: " #val "\n", nErr);\
+			 goto bail;\
+		  } else {\
+			 VERIFY_IPRINTF(":info: passed: " #val "\n");\
+		  }\
+	   } while(0)
+#endif //VERIFY
+
+#ifndef VERIFYC
+        #define VERIFYC(val,err_code) \
+           do {\
+                  VERIFY_IPRINTF(":info: calling: " #val "\n");\
+                  if(0 == (val)) {\
+                         nErr = err_code;\
+                         VERIFY_EPRINTF(":Error: %x: " #val "\n", nErr);\
+                         goto bail;\
+                  } else {\
+                         VERIFY_IPRINTF(":info: passed: " #val "\n");\
+                  }\
+           } while(0)
+#endif //VERIFYC
+
+
+#endif //VERIFY_H
+
diff --git a/inc/verify_android.h b/inc/verify_android.h
new file mode 100644
index 0000000..43bc3a2
--- /dev/null
+++ b/inc/verify_android.h
@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VERIFY_ANDROID
+#define VERIFY_ANDROID
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+
+#ifdef VERIFY_PRINT_INFO
+#define VERIFY_IPRINTF(format) __android_log_print(ANDROID_LOG_DEBUG , "adsprpc", format)
+#endif
+
+#ifdef VERIFY_PRINT_ERROR
+#define VERIFY_EPRINTF(format, ...) __android_log_print(ANDROID_LOG_ERROR , "adsprpc", format, ##__VA_ARGS__)
+#endif
+
+#endif //ANDROID
+
+#endif //VERIFY_ANDROID
diff --git a/inc/version.h b/inc/version.h
new file mode 100644
index 0000000..c75bc86
--- /dev/null
+++ b/inc/version.h
@@ -0,0 +1,119 @@
+#ifndef VERSION_H
+#define VERSION_H
+/**
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#if !defined(VERSION_CL)
+#define VERSION_CL "?"
+#endif
+
+#if !defined(VERSION_PROD)
+#define VERSION_PROD "unknown"
+#endif
+
+#if !defined(VERSION_BRANCH)
+#define VERSION_BRANCH "?"
+#endif
+
+#if !defined(VERSION_NUM)
+#define VERSION_NUM "?.?.?.?"
+#endif
+
+#define VERSION_STRING                                              \
+   VERSION_PROD " "                                                 \
+   VERSION_NUM " "                                                  \
+   "(br=" VERSION_BRANCH "; cl=" VERSION_CL ")"
+
+/*
+=======================================================================
+MACROS DOCUMENTATION
+=======================================================================
+
+VERSION_MAJOR
+
+Description:
+	Defines the major release number of the version.
+
+Comments:
+    It has to be a valid numerical value
+=======================================================================
+
+VERSION_MINOR
+
+Description:
+	Defines the minor release number of the version.
+
+Comments:
+    It has to be a valid numerical value
+=======================================================================
+
+VERSION_MAINT
+
+Description:
+	Defines the maintenance release of the version.
+
+Comments:
+    It has to be a valid numerical value
+=======================================================================
+
+VERSION_BUILD
+
+Description:
+	Defines the build ID of the version.
+
+Comments:
+    It has to be a valid numerical value
+=======================================================================
+
+VERSION_STRING
+
+Description:
+	Defines the version string that specifies the version number.
+
+Definition:
+
+   #define VERSION_STRING "a.b.c.d (name=value;name=value;...)"
+	where a=major release number
+	      b=minor release number
+	      c=maintenance release number
+	      d=build number
+
+	name=value pair provides additional information about the build.
+	Example:
+	patch/feature=comma separated list of features/patches that have been installed.
+	br=p4 branch that was used for the build
+	cl=p4 change list number
+	machine=hostname of the machine that was used for the build.
+
+Comments:
+
+=======================================================================
+*/
+
+#endif // VERSION_H
diff --git a/src/AEEsmath.h b/src/AEEsmath.h
new file mode 100644
index 0000000..1acac47
--- /dev/null
+++ b/src/AEEsmath.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*======================================================================
+
+DESCRIPTION:  Safe math library; implements saturating add.
+
+====================================================================*/
+
+extern int smath_Add(int a, int b);
+extern int smath_Sub(int a, int b);
+extern int smath_Mul(int a, int b);
diff --git a/src/BufBound.c b/src/BufBound.c
new file mode 100644
index 0000000..e9e64e3
--- /dev/null
+++ b/src/BufBound.c
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*==============================================================================
+
+FILE:  AEEBufBound.c
+
+SERVICES:
+        AEEBufBound APIs
+
+GENERAL DESCRIPTION:
+        AEEBufBound provides a "bounded buffer" API that facilitates
+          measuring strings or character output.  It's design accomodates
+          the implementation of functions that can have the same exact logic
+          for measuring and outputting char buffer content.
+
+REVISION HISTORY:
+        Sun Mar 06 11:23:10 2005 Created
+
+==============================================================================*/
+#include <limits.h>
+#include "AEEBufBound.h"
+#include "AEEstd.h"
+
+// Note on bounds-checking logic and saturation:
+//
+// Simple pointer comparisons are not adequate for bounds checking.  pcBuf
+// and pcEnd are assumed to be valid pointers in the address space.  But
+// pcWrite is not ... it is a theoretical value that can exceed pcEnd, and
+// may in fact wrap around the end of the address space.  In that case the
+// test for (pcWrite < pcEnd) will yield TRUE, although pcWrite is outside
+// the buffer.  Use (pcEnd-pcWrite) > 0 to be accurate.
+//
+// In order to ensure this works in all cases, we need to avoid integer
+// overflows.  We do this by restricting pcWrite to the range
+// [pcBuf..pcBuf+INT_MAX].  The ensures that pcWrite-pcBuf and pcWrite-pcBuf
+// will always be valid integers.  It also allows us to ensure that
+// BufBound_Wrote() will not return wildly misleading results.
+//
+//                                            PCSAT
+//    pcBuf               pcEnd            pcBuf+MAXINT
+//      |-------------------| . . . . . . . . . |
+//                   ^            ^
+//    pcWrite:      (a)          (b)
+//
+
+#define PCSAT(me)   ((me)->pcBuf + INT_MAX)
+
+
+// Advance me->pcWrite, saturating.
+//
+// On entry:
+//    *pnLen = number of bytes to be written (non-negative)
+// On exit:
+//    return value = where to write (pointer into the buffer)
+//    *pnLen       = number of bytes to write
+//
+static char *
+BufBound_ValidateWrite(BufBound *me, int *pnLen)
+{
+   int nLen = *pnLen;
+   char *pcWrite = me->pcWrite;
+   int nMaxCopy = me->pcEnd - pcWrite;        // could be negative!
+
+   if ( nMaxCopy < nLen ) {
+      // Must check PCSAT to validate advance
+      int nMaxAdvance = PCSAT(me) - pcWrite;      // max amount to advance
+
+      if (nLen > nMaxAdvance) {
+         nLen = nMaxAdvance;
+      }
+      if (nMaxCopy < 0) {
+         nMaxCopy = 0;
+      }
+   } else {
+      // Simple case: all fits in the buffer
+      nMaxCopy = nLen;
+   }
+
+   *pnLen = nMaxCopy;
+   me->pcWrite = pcWrite + nLen;
+   return pcWrite;
+}
+
+void BufBound_Write(BufBound *me, const char *pc, int nLen)
+{
+   if (nLen > 0) {
+      char *pcDest = BufBound_ValidateWrite(me, &nLen);
+
+      while (--nLen >= 0) {
+         pcDest[nLen] = pc[nLen];
+      }
+   }
+}
+
+void BufBound_Putnc(BufBound *me, char c, int nLen)
+{
+   if (nLen > 0) {
+      char *pcDest = BufBound_ValidateWrite(me, &nLen);
+
+      while (--nLen >= 0) {
+         pcDest[nLen] = c;
+      }
+   }
+}
+
+void BufBound_Advance(BufBound *me, int nLen)
+{
+   uint32 uOffset = (uint32)((me->pcWrite - me->pcBuf) + nLen);
+
+   if (uOffset > INT_MAX) {
+      uOffset = INT_MAX;
+      if (nLen < 0) {
+         uOffset = 0;
+      }
+   }
+   me->pcWrite = me->pcBuf + uOffset;
+}
+
+void BufBound_Init(BufBound *me, char *pBuf, int nLen)
+{
+   if (nLen < 0) {
+      nLen = 0;
+   }
+   me->pcWrite = me->pcBuf = pBuf;
+   me->pcEnd   = pBuf + nLen;
+}
+
+void BufBound_Putc(BufBound *me, char c)
+{
+   if ( (me->pcEnd - me->pcWrite) > 0) {
+      *me->pcWrite++ = c;
+   } else if (me->pcWrite != PCSAT(me)) {
+      ++me->pcWrite;
+   }
+}
+
+void BufBound_ForceNullTerm(BufBound *me)
+{
+   if ( (me->pcEnd - me->pcWrite) > 0) {
+      *me->pcWrite++ = '\0';
+   } else {
+      if (me->pcWrite != PCSAT(me)) {
+         ++me->pcWrite;
+      }
+      // ensure null termination if non-empty buffer
+      if (me->pcEnd != me->pcBuf) {
+         me->pcEnd[-1] = '\0';
+      }
+   }
+}
+
+void BufBound_Puts(BufBound *me, const char* cpsz)
+{
+   BufBound_Write(me, cpsz, std_strlen(cpsz));
+}
+
+int BufBound_BufSize(BufBound* me)
+{
+   return me->pcEnd - me->pcBuf;
+}
+
+int BufBound_Left(BufBound* me)
+{
+   return (me->pcEnd - me->pcWrite);
+}
+
+int BufBound_ReallyWrote(BufBound* me)
+{
+   return STD_MIN(me->pcEnd - me->pcBuf, me->pcWrite - me->pcBuf);
+}
+
+int BufBound_Wrote(BufBound* me)
+{
+   return (me->pcWrite - me->pcBuf);
+}
+
+void BufBound_WriteLE(BufBound *me,
+                      const void *pvSrc, int nSrcSize,
+                      const char *pszFields)
+{
+   if (nSrcSize > 0) {
+      int nLen = nSrcSize;
+      char *pcDest = BufBound_ValidateWrite(me, &nLen);
+
+      (void)std_CopyLE(pcDest, nLen, pvSrc, nSrcSize, pszFields);
+   }
+}
+
+void BufBound_WriteBE(BufBound *me,
+                      const void *pvSrc, int nSrcSize,
+                      const char *pszFields)
+{
+   if (nSrcSize > 0) {
+      int nLen = nSrcSize;
+      char *pcDest = BufBound_ValidateWrite(me, &nLen);
+
+      (void)std_CopyBE(pcDest, nLen, pvSrc, nSrcSize, pszFields);
+   }
+}
diff --git a/src/adsp_current_process1_stub.c b/src/adsp_current_process1_stub.c
new file mode 100644
index 0000000..cffe9d8
--- /dev/null
+++ b/src/adsp_current_process1_stub.c
@@ -0,0 +1,587 @@
+#ifndef _ADSP_CURRENT_PROCESS1_STUB_H
+#define _ADSP_CURRENT_PROCESS1_STUB_H
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "adsp_current_process1.h"
+#ifndef _QAIC_ENV_H
+#define _QAIC_ENV_H
+
+#ifdef __GNUC__
+#ifdef __clang__
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#else
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+#ifndef _ATTRIBUTE_UNUSED
+
+#ifdef _WIN32
+#define _ATTRIBUTE_UNUSED
+#else
+#define _ATTRIBUTE_UNUSED __attribute__ ((unused))
+#endif
+
+#endif // _ATTRIBUTE_UNUSED
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+
+#ifndef __QAIC_STUB
+#define __QAIC_STUB(ff) ff
+#endif //__QAIC_STUB
+
+#ifndef __QAIC_STUB_EXPORT
+#define __QAIC_STUB_EXPORT
+#endif // __QAIC_STUB_EXPORT
+
+#ifndef __QAIC_STUB_ATTRIBUTE
+#define __QAIC_STUB_ATTRIBUTE
+#endif // __QAIC_STUB_ATTRIBUTE
+
+#ifndef __QAIC_SKEL
+#define __QAIC_SKEL(ff) ff
+#endif //__QAIC_SKEL__
+
+#ifndef __QAIC_SKEL_EXPORT
+#define __QAIC_SKEL_EXPORT
+#endif // __QAIC_SKEL_EXPORT
+
+#ifndef __QAIC_SKEL_ATTRIBUTE
+#define __QAIC_SKEL_ATTRIBUTE
+#endif // __QAIC_SKEL_ATTRIBUTE
+
+#ifdef __QAIC_DEBUG__
+   #ifndef __QAIC_DBG_PRINTF__
+   #include <stdio.h>
+   #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
+   #endif
+#else
+   #define __QAIC_DBG_PRINTF__( ee ) (void)0
+#endif
+
+
+#define _OFFSET(src, sof)  ((void*)(((char*)(src)) + (sof)))
+
+#define _COPY(dst, dof, src, sof, sz)  \
+   do {\
+         struct __copy { \
+            char ar[sz]; \
+         };\
+         *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\
+   } while (0)
+
+#define _COPYIF(dst, dof, src, sof, sz)  \
+   do {\
+      if(_OFFSET(dst, dof) != _OFFSET(src, sof)) {\
+         _COPY(dst, dof, src, sof, sz); \
+      } \
+   } while (0)
+
+_ATTRIBUTE_UNUSED
+static __inline void _qaic_memmove(void* dst, void* src, int size) {
+   int i;
+   for(i = 0; i < size; ++i) {
+      ((char*)dst)[i] = ((char*)src)[i];
+   }
+}
+
+#define _MEMMOVEIF(dst, src, sz)  \
+   do {\
+      if(dst != src) {\
+         _qaic_memmove(dst, src, sz);\
+      } \
+   } while (0)
+
+
+#define _ASSIGN(dst, src, sof)  \
+   do {\
+      dst = OFFSET(src, sof); \
+   } while (0)
+
+#define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))
+
+#include "AEEStdErr.h"
+
+#define _TRY(ee, func) \
+   do { \
+      if (AEE_SUCCESS != ((ee) = func)) {\
+         __QAIC_DBG_PRINTF__((__FILE__ ":%d:error:%d:%s\n", __LINE__, (int)(ee),#func));\
+         goto ee##bail;\
+      } \
+   } while (0)
+
+#define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)
+
+#define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)
+
+#ifdef __QAIC_DEBUG__
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
+#else
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, 0, size, alignment, (void**)&pv))
+#endif
+
+
+#endif // _QAIC_ENV_H
+
+#include "remote.h"
+#include <string.h>
+#ifndef _ALLOCATOR_H
+#define _ALLOCATOR_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct _heap _heap;
+struct _heap {
+   _heap* pPrev;
+   const char* loc;
+   uint64_t buf;
+};
+
+typedef struct _allocator {
+   _heap* pheap;
+   uint8_t* stack;
+   uint8_t* stackEnd;
+   int nSize;
+} _allocator;
+
+_ATTRIBUTE_UNUSED
+static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
+   _heap* pn = 0;
+   pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
+   if(pn != 0) {
+      pn->pPrev = *ppa;
+      pn->loc = loc;
+      *ppa = pn;
+      *ppbuf = (void*)&(pn->buf);
+      return 0;
+   } else {
+      return -1;
+   }
+}
+#define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))
+
+_ATTRIBUTE_UNUSED
+static __inline int _allocator_alloc(_allocator* me,
+                                    const char* loc,
+                                    int size,
+                                    unsigned int al,
+                                    void** ppbuf) {
+   if(size < 0) {
+      return -1;
+   } else if (size == 0) {
+      *ppbuf = 0;
+      return 0;
+   }
+   if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
+      *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
+      me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
+      return 0;
+   } else {
+      return _heap_alloc(&me->pheap, loc, size, ppbuf);
+   }
+}
+
+_ATTRIBUTE_UNUSED
+static __inline void _allocator_deinit(_allocator* me) {
+   _heap* pa = me->pheap;
+   while(pa != 0) {
+      _heap* pn = pa;
+      const char* loc = pn->loc;
+      (void)loc;
+      pa = pn->pPrev;
+      free(pn);
+   }
+}
+
+_ATTRIBUTE_UNUSED
+static __inline void _allocator_init(_allocator* me, uint8_t* stack, int stackSize) {
+   me->stack =  stack;
+   me->stackEnd =  stack + stackSize;
+   me->nSize = stackSize;
+   me->pheap = 0;
+}
+
+
+#endif // _ALLOCATOR_H
+
+#ifndef SLIM_H
+#define SLIM_H
+
+#include <stdint.h>
+
+//a C data structure for the idl types that can be used to implement
+//static and dynamic language bindings fairly efficiently.
+//
+//the goal is to have a minimal ROM and RAM footprint and without
+//doing too many allocations.  A good way to package these things seemed
+//like the module boundary, so all the idls within  one module can share
+//all the type references.
+
+
+#define PARAMETER_IN       0x0
+#define PARAMETER_OUT      0x1
+#define PARAMETER_INOUT    0x2
+#define PARAMETER_ROUT     0x3
+#define PARAMETER_INROUT   0x4
+
+//the types that we get from idl
+#define TYPE_OBJECT             0x0
+#define TYPE_INTERFACE          0x1
+#define TYPE_PRIMITIVE          0x2
+#define TYPE_ENUM               0x3
+#define TYPE_STRING             0x4
+#define TYPE_WSTRING            0x5
+#define TYPE_STRUCTURE          0x6
+#define TYPE_UNION              0x7
+#define TYPE_ARRAY              0x8
+#define TYPE_SEQUENCE           0x9
+
+//these require the pack/unpack to recurse
+//so it's a hint to those languages that can optimize in cases where
+//recursion isn't necessary.
+#define TYPE_COMPLEX_STRUCTURE  (0x10 | TYPE_STRUCTURE)
+#define TYPE_COMPLEX_UNION      (0x10 | TYPE_UNION)
+#define TYPE_COMPLEX_ARRAY      (0x10 | TYPE_ARRAY)
+#define TYPE_COMPLEX_SEQUENCE   (0x10 | TYPE_SEQUENCE)
+
+
+typedef struct Type Type;
+
+#define INHERIT_TYPE\
+   int32_t nativeSize;                /*in the simple case its the same as wire size and alignment*/\
+   union {\
+      struct {\
+         const uintptr_t         p1;\
+         const uintptr_t         p2;\
+      } _cast;\
+      struct {\
+         uint32_t  iid;\
+         uint32_t  bNotNil;\
+      } object;\
+      struct {\
+         const Type  *arrayType;\
+         int32_t      nItems;\
+      } array;\
+      struct {\
+         const Type *seqType;\
+         int32_t      nMaxLen;\
+      } seqSimple; \
+      struct {\
+         uint32_t bFloating;\
+         uint32_t bSigned;\
+      } prim; \
+      const SequenceType* seqComplex;\
+      const UnionType  *unionType;\
+      const StructType *structType;\
+      int32_t         stringMaxLen;\
+      uint8_t        bInterfaceNotNil;\
+   } param;\
+   uint8_t    type;\
+   uint8_t    nativeAlignment\
+
+typedef struct UnionType UnionType;
+typedef struct StructType StructType;
+typedef struct SequenceType SequenceType;
+struct Type {
+   INHERIT_TYPE;
+};
+
+struct SequenceType {
+   const Type *         seqType;
+   uint32_t               nMaxLen;
+   uint32_t               inSize;
+   uint32_t               routSizePrimIn;
+   uint32_t               routSizePrimROut;
+};
+
+//byte offset from the start of the case values for
+//this unions case value array.  it MUST be aligned
+//at the alignment requrements for the descriptor
+//
+//if negative it means that the unions cases are
+//simple enumerators, so the value read from the descriptor
+//can be used directly to find the correct case
+typedef union CaseValuePtr CaseValuePtr;
+union CaseValuePtr {
+   const uint8_t*   value8s;
+   const uint16_t*  value16s;
+   const uint32_t*  value32s;
+   const uint64_t*  value64s;
+};
+
+//these are only used in complex cases
+//so I pulled them out of the type definition as references to make
+//the type smaller
+struct UnionType {
+   const Type           *descriptor;
+   uint32_t               nCases;
+   const CaseValuePtr   caseValues;
+   const Type * const   *cases;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+   uint8_t                inCaseAlignment;
+   uint8_t                routCaseAlignmentPrimIn;
+   uint8_t                routCaseAlignmentPrimROut;
+   uint8_t                nativeCaseAlignment;
+   uint8_t              bDefaultCase;
+};
+
+struct StructType {
+   uint32_t               nMembers;
+   const Type * const   *members;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+};
+
+typedef struct Parameter Parameter;
+struct Parameter {
+   INHERIT_TYPE;
+   uint8_t    mode;
+   uint8_t  bNotNil;
+};
+
+#define SLIM_IFPTR32(is32,is64) (sizeof(uintptr_t) == 4 ? (is32) : (is64))
+#define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)
+
+typedef struct Method Method;
+struct Method {
+   uint32_t                    uScalars;            //no method index
+   int32_t                     primInSize;
+   int32_t                     primROutSize;
+   int                         maxArgs;
+   int                         numParams;
+   const Parameter * const     *params;
+   uint8_t                       primInAlignment;
+   uint8_t                       primROutAlignment;
+};
+
+typedef struct Interface Interface;
+
+struct Interface {
+   int                            nMethods;
+   const Method  * const          *methodArray;
+   int                            nIIds;
+   const uint32_t                   *iids;
+   const uint16_t*                  methodStringArray;
+   const uint16_t*                  methodStrings;
+   const char*                    strings;
+};
+
+
+#endif //SLIM_H
+
+
+#ifndef _ADSP_CURRENT_PROCESS1_SLIM_H
+#define _ADSP_CURRENT_PROCESS1_SLIM_H
+#include "remote.h"
+#include <stdint.h>
+
+#ifndef __QAIC_SLIM
+#define __QAIC_SLIM(ff) ff
+#endif
+#ifndef __QAIC_SLIM_EXPORT
+#define __QAIC_SLIM_EXPORT
+#endif
+
+static const Type types[1];
+static const SequenceType sequenceTypes[1] = {{&(types[0]),0x0,0x4,0x4,0x0}};
+static const Type types[1] = {{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)0x0,0}}, 4,SLIM_IFPTR32(0x4,0x8)}};
+static const Parameter parameters[6] = {{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)0x0,0}}, 4,SLIM_IFPTR32(0x4,0x8),0,0},{SLIM_IFPTR32(0x4,0x8),{{(const uintptr_t)0xdeadc0de,(const uintptr_t)0}}, 0,SLIM_IFPTR32(0x4,0x8),3,0},{SLIM_IFPTR32(0x4,0x8),{{(const uintptr_t)0xdeadc0de,(const uintptr_t)0}}, 0,SLIM_IFPTR32(0x4,0x8),0,0},{0x2,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x2,0,0},{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(sequenceTypes[0]),0}}, 25,SLIM_IFPTR32(0x4,0x8),0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x4,3,0}};
+static const Parameter* const parameterArrays[6] = {(&(parameters[3])),(&(parameters[4])),(&(parameters[0])),(&(parameters[1])),(&(parameters[5])),(&(parameters[2]))};
+static const Method methods[5] = {{REMOTE_SCALARS_MAKEX(0,0,0x2,0x0,0x0,0x1),0x4,0x0,2,2,(&(parameterArrays[2])),0x4,0x1},{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x1,0x0),0x0,0x0,1,1,(&(parameterArrays[5])),0x1,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x0,0x0),0x0,0x0,0,0,0,0x0,0x0},{REMOTE_SCALARS_MAKEX(0,0,255,255,15,15),0x8,0x0,3,2,(&(parameterArrays[0])),0x4,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x0,0x1,0x0,0x0),0x0,0x4,1,1,(&(parameterArrays[4])),0x1,0x4}};
+static const Method* const methodArrays[6] = {&(methods[0]),&(methods[1]),&(methods[2]),&(methods[2]),&(methods[3]),&(methods[4])};
+static const char strings[77] = "set_logging_params\0thread_exit\0filesToLog\0getASID\0close\0asid\0mask\0open\0uri\0h\0";
+static const uint16_t methodStrings[12] = {0,61,31,66,71,75,42,56,50,75,19,26};
+static const uint16_t methodStringsArrays[6] = {3,8,11,10,0,6};
+__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(adsp_current_process1_slim) = {6,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
+#endif //_ADSP_CURRENT_PROCESS1_SLIM_H
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_skel_handle_invoke)(remote_handle64 _h, uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle64_invoke)(_h, _sc, _pra);
+}
+#ifdef __cplusplus
+extern "C" {
+#endif
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_open)(const char* uri, remote_handle64* h) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle64_open)(uri, h);
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_close)(remote_handle64 h) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle64_close)(h);
+}
+static __inline int _stub_method(remote_handle64 _handle, uint32_t _mid) {
+   remote_arg* _pra = 0;
+   int _nErr = 0;
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle64_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 0, 0, 0), _pra));
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_exit)(remote_handle64 _handle) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 2;
+   return _stub_method(_handle, _mid);
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_thread_exit)(remote_handle64 _handle) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 3;
+   return _stub_method(_handle, _mid);
+}
+static __inline int _stub_unpack(remote_arg* _praROutPost, remote_arg* _ppraROutPost[1], void* _primROut, char* _in0[1], uint32_t _in0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praROutPostStart = _praROutPost;
+   remote_arg** _ppraROutPostStart = _ppraROutPost;
+   _ppraROutPost = &_praROutPost;
+   _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) +0;
+   return _nErr;
+}
+static __inline int _stub_pack(_allocator* _al, remote_arg* _praIn, remote_arg* _ppraIn[1], remote_arg* _praROut, remote_arg* _ppraROut[1], void* _primIn, void* _primROut, char* _in0[1], uint32_t _in0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praInStart = _praIn;
+   remote_arg** _ppraInStart = _ppraIn;
+   remote_arg* _praROutStart = _praROut;
+   remote_arg** _ppraROutStart = _ppraROut;
+   _ppraIn = &_praIn;
+   _ppraROut = &_praROut;
+   _in0Len[0] = (1 + strlen(_in0[0]));
+   _COPY(_primIn, 0, _in0Len, 0, 4);
+   _praIn[0].buf.pv = _in0[0];
+   _praIn[0].buf.nLen = (1 * _in0Len[0]);
+   _ppraInStart[0] += (_praIn - _praInStart) + 1;
+   _ppraROutStart[0] += (_praROut - _praROutStart) +0;
+   return _nErr;
+}
+static __inline void _count(int _numIn[1], int _numROut[1], char* _in0[1], uint32_t _in0Len[1]) {
+   _numIn[0] += 1;
+   _numROut[0] += 0;
+}
+static __inline int _stub_method_1(remote_handle64 _handle, uint32_t _mid, uint16_t _in0[1], void* _in1[1], uint32_t _in1Len[1]) {
+   remote_arg* _pra;
+   int _numIn[1];
+   int _numROut[1];
+   char* _seq_nat1;
+   int _ii;
+   _allocator _al[1] = {{0}};
+   uint32_t _primIn[2];
+   remote_arg* _praIn;
+   remote_arg** _ppraIn = &_praIn;
+   remote_arg* _praROut;
+   remote_arg** _ppraROut = &_praROut;
+   char* _seq_primIn1;
+   int _nErr = 0;
+   remote_arg* _praROutPost;
+   remote_arg** _ppraROutPost = &_praROutPost;
+   _numIn[0] = 1;
+   _numROut[0] = 0;
+   for(_ii = 0, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16)))
+   {
+      _count(_numIn, _numROut, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2])));
+   }
+   _allocator_init(_al, 0, 0);
+   _ALLOCATE(_nErr, _al, ((((_numIn[0] + _numROut[0]) + 1) + 0) * sizeof(_pra[0])), 4, _pra);
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _COPY(_primIn, 0, _in0, 0, 2);
+   _COPY(_primIn, 4, _in1Len, 0, 4);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 0);
+   _ALLOCATE(_nErr, _al, (_in1Len[0] * 4), 4, _praIn[0].buf.pv);
+   _praIn[0].buf.nLen = (4 * _in1Len[0]);
+   for(_ii = 0, _seq_primIn1 = (char*)_praIn[0].buf.pv, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_primIn1 = (_seq_primIn1 + 4), _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16)))
+   {
+      _TRY(_nErr, _stub_pack(_al, (_praIn + 1), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn1, 0, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2]))));
+   }
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle64_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, (_numIn[0] + 1), (_numROut[0] + 0), 0, 0), _pra));
+   _praROutPost = _praROut;
+   for(_ii = 0, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16)))
+   {
+      _TRY(_nErr, _stub_unpack((_praROutPost + 0), _ppraROutPost, 0, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2]))));
+   }
+   _CATCH(_nErr) {}
+   _allocator_deinit(_al);
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_set_logging_params)(remote_handle64 _handle, unsigned short mask, const _cstring1_t* filesToLog, int filesToLogLen) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 4;
+   return _stub_method_1(_handle, _mid, (uint16_t*)&mask, (void**)&filesToLog, (uint32_t*)&filesToLogLen);
+}
+static __inline int _stub_method_2(remote_handle64 _handle, uint32_t _mid, uint32_t _rout0[1]) {
+   int _numIn[1];
+   remote_arg _pra[1];
+   uint32_t _primROut[1];
+   int _nErr = 0;
+   _numIn[0] = 0;
+   _pra[(_numIn[0] + 0)].buf.pv = (void*)_primROut;
+   _pra[(_numIn[0] + 0)].buf.nLen = sizeof(_primROut);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle64_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 1, 0, 0), _pra));
+   _COPY(_rout0, 0, _primROut, 0, 4);
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process1_getASID)(remote_handle64 _handle, unsigned int* asid) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 5;
+   return _stub_method_2(_handle, _mid, (uint32_t*)asid);
+}
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_CURRENT_PROCESS1_STUB_H
diff --git a/src/adsp_current_process_stub.c b/src/adsp_current_process_stub.c
new file mode 100644
index 0000000..32c3047
--- /dev/null
+++ b/src/adsp_current_process_stub.c
@@ -0,0 +1,669 @@
+#ifndef _ADSP_CURRENT_PROCESS_STUB_H
+#define _ADSP_CURRENT_PROCESS_STUB_H
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "adsp_current_process.h"
+#ifndef _QAIC_ENV_H
+#define _QAIC_ENV_H
+
+#ifdef __GNUC__
+#ifdef __clang__
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#else
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+#ifndef _ATTRIBUTE_UNUSED
+
+#ifdef _WIN32
+#define _ATTRIBUTE_UNUSED
+#else
+#define _ATTRIBUTE_UNUSED __attribute__ ((unused))
+#endif
+
+#endif // _ATTRIBUTE_UNUSED
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+
+#ifndef __QAIC_STUB
+#define __QAIC_STUB(ff) ff
+#endif //__QAIC_STUB
+
+#ifndef __QAIC_STUB_EXPORT
+#define __QAIC_STUB_EXPORT
+#endif // __QAIC_STUB_EXPORT
+
+#ifndef __QAIC_STUB_ATTRIBUTE
+#define __QAIC_STUB_ATTRIBUTE
+#endif // __QAIC_STUB_ATTRIBUTE
+
+#ifndef __QAIC_SKEL
+#define __QAIC_SKEL(ff) ff
+#endif //__QAIC_SKEL__
+
+#ifndef __QAIC_SKEL_EXPORT
+#define __QAIC_SKEL_EXPORT
+#endif // __QAIC_SKEL_EXPORT
+
+#ifndef __QAIC_SKEL_ATTRIBUTE
+#define __QAIC_SKEL_ATTRIBUTE
+#endif // __QAIC_SKEL_ATTRIBUTE
+
+#ifdef __QAIC_DEBUG__
+   #ifndef __QAIC_DBG_PRINTF__
+   #include <stdio.h>
+   #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
+   #endif
+#else
+   #define __QAIC_DBG_PRINTF__( ee ) (void)0
+#endif
+
+
+#define _OFFSET(src, sof)  ((void*)(((char*)(src)) + (sof)))
+
+#define _COPY(dst, dof, src, sof, sz)  \
+   do {\
+         struct __copy { \
+            char ar[sz]; \
+         };\
+         *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\
+   } while (0)
+
+#define _COPYIF(dst, dof, src, sof, sz)  \
+   do {\
+      if(_OFFSET(dst, dof) != _OFFSET(src, sof)) {\
+         _COPY(dst, dof, src, sof, sz); \
+      } \
+   } while (0)
+
+_ATTRIBUTE_UNUSED
+static __inline void _qaic_memmove(void* dst, void* src, int size) {
+   int i;
+   for(i = 0; i < size; ++i) {
+      ((char*)dst)[i] = ((char*)src)[i];
+   }
+}
+
+#define _MEMMOVEIF(dst, src, sz)  \
+   do {\
+      if(dst != src) {\
+         _qaic_memmove(dst, src, sz);\
+      } \
+   } while (0)
+
+
+#define _ASSIGN(dst, src, sof)  \
+   do {\
+      dst = OFFSET(src, sof); \
+   } while (0)
+
+#define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))
+
+#include "AEEStdErr.h"
+
+#define _TRY(ee, func) \
+   do { \
+      if (AEE_SUCCESS != ((ee) = func)) {\
+         __QAIC_DBG_PRINTF__((__FILE__ ":%d:error:%d:%s\n", __LINE__, (int)(ee),#func));\
+         goto ee##bail;\
+      } \
+   } while (0)
+
+#define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)
+
+#define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)
+
+#ifdef __QAIC_DEBUG__
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
+#else
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, 0, size, alignment, (void**)&pv))
+#endif
+
+
+#endif // _QAIC_ENV_H
+
+#include "remote.h"
+#include <string.h>
+#ifndef _ALLOCATOR_H
+#define _ALLOCATOR_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct _heap _heap;
+struct _heap {
+   _heap* pPrev;
+   const char* loc;
+   uint64_t buf;
+};
+
+typedef struct _allocator {
+   _heap* pheap;
+   uint8_t* stack;
+   uint8_t* stackEnd;
+   int nSize;
+} _allocator;
+
+_ATTRIBUTE_UNUSED
+static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
+   _heap* pn = 0;
+   pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
+   if(pn != 0) {
+      pn->pPrev = *ppa;
+      pn->loc = loc;
+      *ppa = pn;
+      *ppbuf = (void*)&(pn->buf);
+      return 0;
+   } else {
+      return -1;
+   }
+}
+#define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))
+
+_ATTRIBUTE_UNUSED
+static __inline int _allocator_alloc(_allocator* me,
+                                    const char* loc,
+                                    int size,
+                                    unsigned int al,
+                                    void** ppbuf) {
+   if(size < 0) {
+      return -1;
+   } else if (size == 0) {
+      *ppbuf = 0;
+      return 0;
+   }
+   if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
+      *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
+      me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
+      return 0;
+   } else {
+      return _heap_alloc(&me->pheap, loc, size, ppbuf);
+   }
+}
+
+_ATTRIBUTE_UNUSED
+static __inline void _allocator_deinit(_allocator* me) {
+   _heap* pa = me->pheap;
+   while(pa != 0) {
+      _heap* pn = pa;
+      const char* loc = pn->loc;
+      (void)loc;
+      pa = pn->pPrev;
+      free(pn);
+   }
+}
+
+_ATTRIBUTE_UNUSED
+static __inline void _allocator_init(_allocator* me, uint8_t* stack, int stackSize) {
+   me->stack =  stack;
+   me->stackEnd =  stack + stackSize;
+   me->nSize = stackSize;
+   me->pheap = 0;
+}
+
+
+#endif // _ALLOCATOR_H
+
+#ifndef SLIM_H
+#define SLIM_H
+
+#include <stdint.h>
+
+//a C data structure for the idl types that can be used to implement
+//static and dynamic language bindings fairly efficiently.
+//
+//the goal is to have a minimal ROM and RAM footprint and without
+//doing too many allocations.  A good way to package these things seemed
+//like the module boundary, so all the idls within  one module can share
+//all the type references.
+
+
+#define PARAMETER_IN       0x0
+#define PARAMETER_OUT      0x1
+#define PARAMETER_INOUT    0x2
+#define PARAMETER_ROUT     0x3
+#define PARAMETER_INROUT   0x4
+
+//the types that we get from idl
+#define TYPE_OBJECT             0x0
+#define TYPE_INTERFACE          0x1
+#define TYPE_PRIMITIVE          0x2
+#define TYPE_ENUM               0x3
+#define TYPE_STRING             0x4
+#define TYPE_WSTRING            0x5
+#define TYPE_STRUCTURE          0x6
+#define TYPE_UNION              0x7
+#define TYPE_ARRAY              0x8
+#define TYPE_SEQUENCE           0x9
+
+//these require the pack/unpack to recurse
+//so it's a hint to those languages that can optimize in cases where
+//recursion isn't necessary.
+#define TYPE_COMPLEX_STRUCTURE  (0x10 | TYPE_STRUCTURE)
+#define TYPE_COMPLEX_UNION      (0x10 | TYPE_UNION)
+#define TYPE_COMPLEX_ARRAY      (0x10 | TYPE_ARRAY)
+#define TYPE_COMPLEX_SEQUENCE   (0x10 | TYPE_SEQUENCE)
+
+
+typedef struct Type Type;
+
+#define INHERIT_TYPE\
+   int32_t nativeSize;                /*in the simple case its the same as wire size and alignment*/\
+   union {\
+      struct {\
+         const uintptr_t         p1;\
+         const uintptr_t         p2;\
+      } _cast;\
+      struct {\
+         uint32_t  iid;\
+         uint32_t  bNotNil;\
+      } object;\
+      struct {\
+         const Type  *arrayType;\
+         int32_t      nItems;\
+      } array;\
+      struct {\
+         const Type *seqType;\
+         int32_t      nMaxLen;\
+      } seqSimple; \
+      struct {\
+         uint32_t bFloating;\
+         uint32_t bSigned;\
+      } prim; \
+      const SequenceType* seqComplex;\
+      const UnionType  *unionType;\
+      const StructType *structType;\
+      int32_t         stringMaxLen;\
+      uint8_t        bInterfaceNotNil;\
+   } param;\
+   uint8_t    type;\
+   uint8_t    nativeAlignment\
+
+typedef struct UnionType UnionType;
+typedef struct StructType StructType;
+typedef struct SequenceType SequenceType;
+struct Type {
+   INHERIT_TYPE;
+};
+
+struct SequenceType {
+   const Type          *seqType;
+   uint32_t               nMaxLen;
+   uint32_t               inSize;
+   uint32_t               routSizePrimIn;
+   uint32_t               routSizePrimROut;
+};
+
+//byte offset from the start of the case values for
+//this unions case value array.  it MUST be aligned
+//at the alignment requrements for the descriptor
+//
+//if negative it means that the unions cases are
+//simple enumerators, so the value read from the descriptor
+//can be used directly to find the correct case
+typedef union CaseValuePtr CaseValuePtr;
+union CaseValuePtr {
+   const uint8_t*   value8s;
+   const uint16_t*  value16s;
+   const uint32_t*  value32s;
+   const uint64_t*  value64s;
+};
+
+//these are only used in complex cases
+//so I pulled them out of the type definition as references to make
+//the type smaller
+struct UnionType {
+   const Type           *descriptor;
+   uint32_t               nCases;
+   const CaseValuePtr   caseValues;
+   const Type * const   *cases;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+   uint8_t                inCaseAlignment;
+   uint8_t                routCaseAlignmentPrimIn;
+   uint8_t                routCaseAlignmentPrimROut;
+   uint8_t                nativeCaseAlignment;
+   uint8_t              bDefaultCase;
+};
+
+struct StructType {
+   uint32_t               nMembers;
+   const Type * const   *members;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+};
+
+typedef struct Parameter Parameter;
+struct Parameter {
+   INHERIT_TYPE;
+   uint8_t    mode;
+   uint8_t  bNotNil;
+};
+
+#define SLIM_IFPTR32(is32,is64) (sizeof(uintptr_t) == 4 ? (is32) : (is64))
+#define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)
+
+typedef struct Method Method;
+struct Method {
+   uint32_t                    uScalars;            //no method index
+   int32_t                     primInSize;
+   int32_t                     primROutSize;
+   int                         maxArgs;
+   int                         numParams;
+   const Parameter * const     *params;
+   uint8_t                       primInAlignment;
+   uint8_t                       primROutAlignment;
+};
+
+typedef struct Interface Interface;
+
+struct Interface {
+   int                            nMethods;
+   const Method  * const          *methodArray;
+   int                            nIIds;
+   const uint32_t                   *iids;
+   const uint16_t*                  methodStringArray;
+   const uint16_t*                  methodStrings;
+   const char*                    strings;
+};
+
+
+#endif //SLIM_H
+
+
+#ifndef _ADSP_CURRENT_PROCESS_SLIM_H
+#define _ADSP_CURRENT_PROCESS_SLIM_H
+#include "remote.h"
+#include <stdint.h>
+
+#ifndef __QAIC_SLIM
+#define __QAIC_SLIM(ff) ff
+#endif
+#ifndef __QAIC_SLIM_EXPORT
+#define __QAIC_SLIM_EXPORT
+#endif
+
+static const Type types[1];
+static const SequenceType sequenceTypes[1] = {{&(types[0]),0x0,0x4,0x4,0x0}};
+static const Type types[1] = {{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)0x0,0}}, 4,SLIM_IFPTR32(0x4,0x8)}};
+static const Parameter parameters[3] = {{0x2,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x2,0,0},{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(sequenceTypes[0]),0}}, 25,SLIM_IFPTR32(0x4,0x8),0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x4,3,0}};
+static const Parameter* const parameterArrays[3] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2]))};
+static const Method methods[3] = {{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x0,0x0),0x0,0x0,0,0,0,0x0,0x0},{REMOTE_SCALARS_MAKEX(0,0,255,255,15,15),0x8,0x0,3,2,(&(parameterArrays[0])),0x4,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x0,0x1,0x0,0x0),0x0,0x4,1,1,(&(parameterArrays[2])),0x1,0x4}};
+static const Method* const methodArrays[4] = {&(methods[0]),&(methods[0]),&(methods[1]),&(methods[2])};
+static const char strings[60] = "set_logging_params\0thread_exit\0filesToLog\0getASID\0asid\0mask\0";
+static const uint16_t methodStrings[7] = {0,55,31,42,50,19,26};
+static const uint16_t methodStringsArrays[4] = {6,5,0,3};
+__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(adsp_current_process_slim) = {4,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
+#endif //_ADSP_CURRENT_PROCESS_SLIM_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _const_adsp_current_process_handle
+#define _const_adsp_current_process_handle ((remote_handle)-1)
+#endif //_const_adsp_current_process_handle
+
+static void _adsp_current_process_pls_dtor(void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   if(_const_adsp_current_process_handle != *ph) {
+      (void)__QAIC_REMOTE(remote_handle_close)(*ph);
+      *ph = _const_adsp_current_process_handle;
+   }
+}
+
+static int _adsp_current_process_pls_ctor(void* ctx, void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   *ph = _const_adsp_current_process_handle;
+   if(*ph == (remote_handle)-1) {
+      return __QAIC_REMOTE(remote_handle_open)((const char*)ctx, ph);
+   }
+   return 0;
+}
+
+#if (defined __qdsp6__) || (defined __hexagon__)
+#pragma weak  adsp_pls_add_lookup
+extern int adsp_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+#pragma weak  HAP_pls_add_lookup
+extern int HAP_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+
+__QAIC_STUB_EXPORT remote_handle _adsp_current_process_handle(void) {
+   remote_handle* ph;
+   if(adsp_pls_add_lookup) {
+      if(0 == adsp_pls_add_lookup((uint32_t)_adsp_current_process_handle, 0, sizeof(*ph),  _adsp_current_process_pls_ctor, "adsp_current_process",  _adsp_current_process_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   } else if(HAP_pls_add_lookup) {
+      if(0 == HAP_pls_add_lookup((uint32_t)_adsp_current_process_handle, 0, sizeof(*ph),  _adsp_current_process_pls_ctor, "adsp_current_process",  _adsp_current_process_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   }
+   return(remote_handle)-1;
+}
+
+#else //__qdsp6__ || __hexagon__
+
+uint32_t _adsp_current_process_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare);
+
+#ifdef _WIN32
+#include "Windows.h"
+uint32_t _adsp_current_process_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return (uint32_t)InterlockedCompareExchange((volatile LONG*)puDest, (LONG)uExchange, (LONG)uCompare);
+}
+#elif __GNUC__
+uint32_t _adsp_current_process_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return __sync_val_compare_and_swap(puDest, uCompare, uExchange);
+}
+#endif //_WIN32
+
+
+__QAIC_STUB_EXPORT remote_handle _adsp_current_process_handle(void) {
+   static remote_handle handle = _const_adsp_current_process_handle;
+   if((remote_handle)-1 != handle) {
+      return handle;
+   } else {
+      remote_handle tmp;
+      int nErr = _adsp_current_process_pls_ctor("adsp_current_process", (void*)&tmp);
+      if(nErr) {
+         return (remote_handle)-1;
+      }
+      if(((remote_handle)-1 != handle) || ((remote_handle)-1 != (remote_handle)_adsp_current_process_atomic_CompareAndExchange((uint32_t*)&handle, (uint32_t)tmp, (uint32_t)-1))) {
+         _adsp_current_process_pls_dtor(&tmp);
+      }
+      return handle;
+   }
+}
+
+#endif //__qdsp6__
+
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle_invoke)(_adsp_current_process_handle(), _sc, _pra);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static __inline int _stub_method(remote_handle _handle, uint32_t _mid) {
+   remote_arg* _pra = 0;
+   int _nErr = 0;
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 0, 0, 0), _pra));
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_exit)(void) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 0;
+   return _stub_method(_adsp_current_process_handle(), _mid);
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_thread_exit)(void) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 1;
+   return _stub_method(_adsp_current_process_handle(), _mid);
+}
+static __inline int _stub_unpack(remote_arg* _praROutPost, remote_arg* _ppraROutPost[1], void* _primROut, char* _in0[1], uint32_t _in0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praROutPostStart = _praROutPost;
+   remote_arg** _ppraROutPostStart = _ppraROutPost;
+   _ppraROutPost = &_praROutPost;
+   _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) +0;
+   return _nErr;
+}
+static __inline int _stub_pack(_allocator* _al, remote_arg* _praIn, remote_arg* _ppraIn[1], remote_arg* _praROut, remote_arg* _ppraROut[1], void* _primIn, void* _primROut, char* _in0[1], uint32_t _in0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praInStart = _praIn;
+   remote_arg** _ppraInStart = _ppraIn;
+   remote_arg* _praROutStart = _praROut;
+   remote_arg** _ppraROutStart = _ppraROut;
+   _ppraIn = &_praIn;
+   _ppraROut = &_praROut;
+   _in0Len[0] = (1 + strlen(_in0[0]));
+   _COPY(_primIn, 0, _in0Len, 0, 4);
+   _praIn[0].buf.pv = _in0[0];
+   _praIn[0].buf.nLen = (1 * _in0Len[0]);
+   _ppraInStart[0] += (_praIn - _praInStart) + 1;
+   _ppraROutStart[0] += (_praROut - _praROutStart) +0;
+   return _nErr;
+}
+static __inline void _count(int _numIn[1], int _numROut[1], char* _in0[1], uint32_t _in0Len[1]) {
+   _numIn[0] += 1;
+   _numROut[0] += 0;
+}
+static __inline int _stub_method_1(remote_handle _handle, uint32_t _mid, uint16_t _in0[1], void* _in1[1], uint32_t _in1Len[1]) {
+   remote_arg* _pra;
+   int _numIn[1];
+   int _numROut[1];
+   char* _seq_nat1;
+   int _ii;
+   _allocator _al[1] = {{0}};
+   uint32_t _primIn[2];
+   remote_arg* _praIn;
+   remote_arg** _ppraIn = &_praIn;
+   remote_arg* _praROut;
+   remote_arg** _ppraROut = &_praROut;
+   char* _seq_primIn1;
+   int _nErr = 0;
+   remote_arg* _praROutPost;
+   remote_arg** _ppraROutPost = &_praROutPost;
+   _numIn[0] = 1;
+   _numROut[0] = 0;
+   for(_ii = 0, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16)))
+   {
+      _count(_numIn, _numROut, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2])));
+   }
+   _allocator_init(_al, 0, 0);
+   _ALLOCATE(_nErr, _al, ((((_numIn[0] + _numROut[0]) + 1) + 0) * sizeof(_pra[0])), 4, _pra);
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _COPY(_primIn, 0, _in0, 0, 2);
+   _COPY(_primIn, 4, _in1Len, 0, 4);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 0);
+   _ALLOCATE(_nErr, _al, (_in1Len[0] * 4), 4, _praIn[0].buf.pv);
+   _praIn[0].buf.nLen = (4 * _in1Len[0]);
+   for(_ii = 0, _seq_primIn1 = (char*)_praIn[0].buf.pv, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_primIn1 = (_seq_primIn1 + 4), _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16)))
+   {
+      _TRY(_nErr, _stub_pack(_al, (_praIn + 1), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn1, 0, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2]))));
+   }
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, (_numIn[0] + 1), (_numROut[0] + 0), 0, 0), _pra));
+   _praROutPost = _praROut;
+   for(_ii = 0, _seq_nat1 = (char*)_in1[0];_ii < (int)_in1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + SLIM_IFPTR32(8, 16)))
+   {
+      _TRY(_nErr, _stub_unpack((_praROutPost + 0), _ppraROutPost, 0, SLIM_IFPTR32((char**)&(((uint32_t*)_seq_nat1)[0]), (char**)&(((uint64_t*)_seq_nat1)[0])), SLIM_IFPTR32((uint32_t*)&(((uint32_t*)_seq_nat1)[1]), (uint32_t*)&(((uint32_t*)_seq_nat1)[2]))));
+   }
+   _CATCH(_nErr) {}
+   _allocator_deinit(_al);
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_set_logging_params)(unsigned short mask, const _cstring1_t* filesToLog, int filesToLogLen) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 2;
+   return _stub_method_1(_adsp_current_process_handle(), _mid, (uint16_t*)&mask, (void**)&filesToLog, (uint32_t*)&filesToLogLen);
+}
+static __inline int _stub_method_2(remote_handle _handle, uint32_t _mid, uint32_t _rout0[1]) {
+   int _numIn[1];
+   remote_arg _pra[1];
+   uint32_t _primROut[1];
+   int _nErr = 0;
+   _numIn[0] = 0;
+   _pra[(_numIn[0] + 0)].buf.pv = (void*)_primROut;
+   _pra[(_numIn[0] + 0)].buf.nLen = sizeof(_primROut);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 1, 0, 0), _pra));
+   _COPY(_rout0, 0, _primROut, 0, 4);
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_current_process_getASID)(unsigned int* asid) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 3;
+   return _stub_method_2(_adsp_current_process_handle(), _mid, (uint32_t*)asid);
+}
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_CURRENT_PROCESS_STUB_H
diff --git a/src/adsp_def_symbols.lst b/src/adsp_def_symbols.lst
new file mode 100644
index 0000000..f998107
--- /dev/null
+++ b/src/adsp_def_symbols.lst
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ADSPRPC {
+   global:
+      adsp_default_listener_start;
+   local: *;
+};
diff --git a/src/adsp_default_listener.c b/src/adsp_default_listener.c
new file mode 100644
index 0000000..5f1cb80
--- /dev/null
+++ b/src/adsp_default_listener.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+//#ifndef VERIFY_PRINT_ERROR
+//#define VERIFY_PRINT_ERROR
+//#endif
+
+#define FARF_ERROR 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <poll.h>
+#include <unistd.h>
+#include <sys/eventfd.h>
+#include <string.h>
+#include "adsp_default_listener.h"
+#include "AEEStdErr.h"
+#include "verify.h"
+#include "remote.h"
+#include "HAP_farf.h"
+#include "adspmsgd_adsp.h"
+
+int adsp_default_listener_start(int argc, char* argv[]) {
+   struct pollfd pfd;
+   eventfd_t event = 0;
+   remote_handle fd;
+   int nErr = AEE_SUCCESS;
+   char *name = NULL;
+   int namelen = 0;
+   (void)argc;
+   (void)argv;
+   if (argc > 1) {
+      namelen = strlen(ITRANSPORT_PREFIX "createstaticpd:") + strlen(argv[1]);
+      name = (char *)malloc((namelen + 1) * sizeof(char));
+      VERIFYC(NULL != name, AEE_ENOMEMORY);
+      std_strlcpy(name,  ITRANSPORT_PREFIX "createstaticpd:", strlen(ITRANSPORT_PREFIX "createstaticpd:")+1);
+      std_strlcat(name, argv[1], namelen+1);
+   } else {
+      namelen = strlen(ITRANSPORT_PREFIX "attachguestos");
+      name = (char *)malloc((namelen + 1) * sizeof(char));
+      VERIFYC(NULL != name, AEE_ENOMEMORY);
+      std_strlcpy(name,  ITRANSPORT_PREFIX "attachguestos", strlen(ITRANSPORT_PREFIX "attachguestos")+1);
+   }
+   VERIFY_EPRINTF("adsp_default_listener_start started\n");
+   VERIFYC(!setenv("ADSP_LISTENER_MEM_CACHE_SIZE", "1048576", 0), AEE_ESETENV);
+   VERIFY(0 == (nErr = remote_handle_open(name, &fd)));
+   VERIFY(0 == (nErr = adsp_default_listener_register()));
+   VERIFY(0 == (nErr = remote_handle_open(ITRANSPORT_PREFIX "geteventfd",
+                                  (remote_handle*)&pfd.fd)));
+   free(name);
+   name = NULL;
+   pfd.events = POLLIN;
+   pfd.revents = 0;
+#ifdef PD_EXCEPTION_LOGGING
+
+if(argc == 1){
+	adspmsgd_adsp_init2();
+}
+
+#endif
+   while (1) {
+     VERIFYC(0 < poll(&pfd, 1, -1), AEE_EPOLL);
+     VERIFYC(0 == eventfd_read(pfd.fd, &event), AEE_EEVENTREAD);
+     if (event) {
+       break;
+     }
+   }
+bail:
+#ifdef PD_EXCEPTION_LOGGING
+if(argc == 1)
+	adspmsgd_adsp_deinit();
+#endif
+   if(nErr != AEE_SUCCESS) {
+      if(name != NULL){
+         free(name);
+         name = NULL;
+      }
+      //FARF(ERROR, "Error %x, adsp_default_listener_start exiting\n", nErr);
+   }
+   return nErr;
+}
diff --git a/src/adsp_default_listener_stub.c b/src/adsp_default_listener_stub.c
new file mode 100644
index 0000000..c2c0057
--- /dev/null
+++ b/src/adsp_default_listener_stub.c
@@ -0,0 +1,517 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _ADSP_DEFAULT_LISTENER_STUB_H
+#define _ADSP_DEFAULT_LISTENER_STUB_H
+#include "adsp_default_listener.h"
+#include "remote.h"
+#ifndef ALLOCATOR_H
+#define ALLOCATOR_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct _heap _heap;
+struct _heap {
+   _heap* pPrev;
+   const char* loc;
+   uint64_t buf;
+};
+
+typedef struct allocator {
+   _heap* pheap;
+   uint8_t* stack;
+   uint8_t* stackEnd;
+   int nSize;
+} allocator;
+
+static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
+   _heap* pn = 0;
+   pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
+   if(pn != 0) {
+      pn->pPrev = *ppa;
+      pn->loc = loc;
+      *ppa = pn;
+      *ppbuf = (void*)&(pn->buf);
+      return 0;
+   } else {
+      return -1;
+   }
+}
+#define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))
+
+
+static __inline int allocator_alloc(allocator* me,
+                                    const char* loc,
+                                    int size,
+                                    unsigned int al,
+                                    void** ppbuf) {
+   if(size < 0) {
+      return -1;
+   } else if (size == 0) {
+      *ppbuf = 0;
+      return 0;
+   }
+   if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
+      *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
+      me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
+      return 0;
+   } else {
+      return _heap_alloc(&me->pheap, loc, size, ppbuf);
+   }
+}
+
+
+static __inline void allocator_deinit(allocator* me) {
+   _heap* pa = me->pheap;
+   while(pa != 0) {
+      _heap* pn = pa;
+      const char* loc = pn->loc;
+      (void)loc;
+      pa = pn->pPrev;
+      free(pn);
+   }
+}
+
+static __inline void allocator_init(allocator* me, uint8_t* stack, int stackSize) {
+   me->stack =  stack;
+   me->stackEnd =  stack + stackSize;
+   me->nSize = stackSize;
+   me->pheap = 0;
+}
+
+
+#endif // ALLOCATOR_H
+
+#ifndef SLIM_H
+#define SLIM_H
+
+#include <stdint.h>
+
+//a C data structure for the idl types that can be used to implement
+//static and dynamic language bindings fairly efficiently.
+//
+//the goal is to have a minimal ROM and RAM footprint and without
+//doing too many allocations.  A good way to package these things seemed
+//like the module boundary, so all the idls within  one module can share
+//all the type references.
+
+
+#define PARAMETER_IN       0x0
+#define PARAMETER_OUT      0x1
+#define PARAMETER_INOUT    0x2
+#define PARAMETER_ROUT     0x3
+#define PARAMETER_INROUT   0x4
+
+//the types that we get from idl
+#define TYPE_OBJECT             0x0
+#define TYPE_INTERFACE          0x1
+#define TYPE_PRIMITIVE          0x2
+#define TYPE_ENUM               0x3
+#define TYPE_STRING             0x4
+#define TYPE_WSTRING            0x5
+#define TYPE_STRUCTURE          0x6
+#define TYPE_UNION              0x7
+#define TYPE_ARRAY              0x8
+#define TYPE_SEQUENCE           0x9
+
+//these require the pack/unpack to recurse
+//so it's a hint to those languages that can optimize in cases where
+//recursion isn't necessary.
+#define TYPE_COMPLEX_STRUCTURE  (0x10 | TYPE_STRUCTURE)
+#define TYPE_COMPLEX_UNION      (0x10 | TYPE_UNION)
+#define TYPE_COMPLEX_ARRAY      (0x10 | TYPE_ARRAY)
+#define TYPE_COMPLEX_SEQUENCE   (0x10 | TYPE_SEQUENCE)
+
+
+typedef struct Type Type;
+
+#define INHERIT_TYPE\
+   int32_t nativeSize;                /*in the simple case its the same as wire size and alignment*/\
+   union {\
+      struct {\
+         const uintptr_t         p1;\
+         const uintptr_t         p2;\
+      } _cast;\
+      struct {\
+         uint32_t  iid;\
+         uint32_t  bNotNil;\
+      } object;\
+      struct {\
+         const Type  *arrayType;\
+         int32_t      nItems;\
+      } array;\
+      struct {\
+         const Type *seqType;\
+         int32_t      nMaxLen;\
+      } seqSimple; \
+      struct {\
+         uint32_t bFloating;\
+         uint32_t bSigned;\
+      } prim; \
+      const SequenceType* seqComplex;\
+      const UnionType  *unionType;\
+      const StructType *structType;\
+      int32_t         stringMaxLen;\
+      uint8_t        bInterfaceNotNil;\
+   } param;\
+   uint8_t    type;\
+   uint8_t    nativeAlignment\
+
+typedef struct UnionType UnionType;
+typedef struct StructType StructType;
+typedef struct SequenceType SequenceType;
+struct Type {
+   INHERIT_TYPE;
+};
+
+struct SequenceType {
+   const Type *         seqType;
+   uint32_t               nMaxLen;
+   uint32_t               inSize;
+   uint32_t               routSizePrimIn;
+   uint32_t               routSizePrimROut;
+};
+
+//byte offset from the start of the case values for
+//this unions case value array.  it MUST be aligned
+//at the alignment requrements for the descriptor
+//
+//if negative it means that the unions cases are
+//simple enumerators, so the value read from the descriptor
+//can be used directly to find the correct case
+typedef union CaseValuePtr CaseValuePtr;
+union CaseValuePtr {
+   const uint8_t*   value8s;
+   const uint16_t*  value16s;
+   const uint32_t*  value32s;
+   const uint64_t*  value64s;
+};
+
+//these are only used in complex cases
+//so I pulled them out of the type definition as references to make
+//the type smaller
+struct UnionType {
+   const Type           *descriptor;
+   uint32_t               nCases;
+   const CaseValuePtr   caseValues;
+   const Type * const   *cases;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+   uint8_t                inCaseAlignment;
+   uint8_t                routCaseAlignmentPrimIn;
+   uint8_t                routCaseAlignmentPrimROut;
+   uint8_t                nativeCaseAlignment;
+   uint8_t              bDefaultCase;
+};
+
+struct StructType {
+   uint32_t               nMembers;
+   const Type * const   *members;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+};
+
+typedef struct Parameter Parameter;
+struct Parameter {
+   INHERIT_TYPE;
+   uint8_t    mode;
+   uint8_t  bNotNil;
+};
+
+#define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)
+
+typedef struct Method Method;
+struct Method {
+   uint32_t                    uScalars;            //no method index
+   int32_t                     primInSize;
+   int32_t                     primROutSize;
+   int                         maxArgs;
+   int                         numParams;
+   const Parameter * const     *params;
+   uint8_t                       primInAlignment;
+   uint8_t                       primROutAlignment;
+};
+
+typedef struct Interface Interface;
+
+struct Interface {
+   int                            nMethods;
+   const Method  * const          *methodArray;
+   int                            nIIds;
+   const uint32_t                   *iids;
+   const uint16_t*                  methodStringArray;
+   const uint16_t*                  methodStrings;
+   const char*                    strings;
+};
+
+
+#endif //SLIM_H
+
+
+#ifndef _ADSP_DEFAULT_LISTENER_SLIM_H
+#define _ADSP_DEFAULT_LISTENER_SLIM_H
+#include "remote.h"
+#include <stdint.h>
+
+#ifndef __QAIC_SLIM
+#define __QAIC_SLIM(ff) ff
+#endif
+#ifndef __QAIC_SLIM_EXPORT
+#define __QAIC_SLIM_EXPORT
+#endif
+
+static const Method methods[1] = {{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x0,0x0),0x0,0x0,0,0,0,0x0,0x0}};
+static const Method* const methodArrays[1] = {&(methods[0])};
+static const char strings[9] = "register\0";
+static const uint16_t methodStrings[1] = {0};
+static const uint16_t methodStringsArrays[1] = {0};
+__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(adsp_default_listener_slim) = {1,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
+#endif //_ADSP_DEFAULT_LISTENER_SLIM_H
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+
+#ifndef __QAIC_STUB
+#define __QAIC_STUB(ff) ff
+#endif //__QAIC_STUB
+
+#ifndef __QAIC_STUB_EXPORT
+#define __QAIC_STUB_EXPORT
+#endif // __QAIC_STUB_EXPORT
+
+#ifndef __QAIC_STUB_ATTRIBUTE
+#define __QAIC_STUB_ATTRIBUTE
+#endif // __QAIC_STUB_ATTRIBUTE
+
+#ifndef __QAIC_SKEL
+#define __QAIC_SKEL(ff) ff
+#endif //__QAIC_SKEL__
+
+#ifndef __QAIC_SKEL_EXPORT
+#define __QAIC_SKEL_EXPORT
+#endif // __QAIC_SKEL_EXPORT
+
+#ifndef __QAIC_SKEL_ATTRIBUTE
+#define __QAIC_SKEL_ATTRIBUTE
+#endif // __QAIC_SKEL_ATTRIBUTE
+
+#ifdef __QAIC_DEBUG__
+   #ifndef __QAIC_DBG_PRINTF__
+   #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
+   #endif
+#else
+   #define __QAIC_DBG_PRINTF__( ee ) (void)0
+#endif
+
+
+#define _OFFSET(src, sof)  ((void*)(((char*)(src)) + (sof)))
+
+#define _COPY(dst, dof, src, sof, sz)  \
+   do {\
+         struct __copy { \
+            char ar[sz]; \
+         };\
+         *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\
+   } while (0)
+
+#define _ASSIGN(dst, src, sof)  \
+   do {\
+      dst = OFFSET(src, sof); \
+   } while (0)
+
+#define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))
+
+#include "AEEStdErr.h"
+
+#define _TRY(ee, func) \
+   do { \
+      if (AEE_SUCCESS != ((ee) = func)) {\
+         __QAIC_DBG_PRINTF__((__FILE_LINE__  ": error: %d\n", (int)(ee)));\
+         goto ee##bail;\
+      } \
+   } while (0)
+
+#define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)
+
+#define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)
+
+#ifdef __QAIC_DEBUG__
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
+#else
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, 0, size, alignment, (void**)&pv))
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _const_adsp_default_listener_handle
+#define _const_adsp_default_listener_handle ((remote_handle)-1)
+#endif //_const_adsp_default_listener_handle
+
+static void _adsp_default_listener_pls_dtor(void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   if(_const_adsp_default_listener_handle != *ph) {
+      (void)__QAIC_REMOTE(remote_handle_close)(*ph);
+      *ph = _const_adsp_default_listener_handle;
+   }
+}
+
+static int _adsp_default_listener_pls_ctor(void* ctx, void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   *ph = _const_adsp_default_listener_handle;
+   if(*ph == (remote_handle)-1) {
+      return __QAIC_REMOTE(remote_handle_open)((const char*)ctx, ph);
+   }
+   return 0;
+}
+
+#if (defined __qdsp6__) || (defined __hexagon__)
+#pragma weak  adsp_pls_add_lookup
+extern int adsp_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+#pragma weak  HAP_pls_add_lookup
+extern int HAP_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+
+__QAIC_STUB_EXPORT remote_handle _adsp_default_listener_handle(void) {
+   remote_handle* ph;
+   if(adsp_pls_add_lookup) {
+      if(0 == adsp_pls_add_lookup((uint32_t)_adsp_default_listener_handle, 0, sizeof(*ph),  _adsp_default_listener_pls_ctor, "adsp_default_listener",  _adsp_default_listener_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   } else if(HAP_pls_add_lookup) {
+      if(0 == HAP_pls_add_lookup((uint32_t)_adsp_default_listener_handle, 0, sizeof(*ph),  _adsp_default_listener_pls_ctor, "adsp_default_listener",  _adsp_default_listener_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   }
+   return(remote_handle)-1;
+}
+
+#else //__qdsp6__ || __hexagon__
+
+uint32_t _adsp_default_listener_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare);
+
+#ifdef _WIN32
+#include "Windows.h"
+uint32_t _adsp_default_listener_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return (uint32_t)InterlockedCompareExchange((volatile LONG*)puDest, (LONG)uExchange, (LONG)uCompare);
+}
+#elif __GNUC__
+uint32_t _adsp_default_listener_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return __sync_val_compare_and_swap(puDest, uCompare, uExchange);
+}
+#endif //_WIN32
+
+
+__QAIC_STUB_EXPORT remote_handle _adsp_default_listener_handle(void) {
+   static remote_handle handle = _const_adsp_default_listener_handle;
+   if((remote_handle)-1 != handle) {
+      return handle;
+   } else {
+      remote_handle tmp;
+      int nErr = _adsp_default_listener_pls_ctor("adsp_default_listener", (void*)&tmp);
+      if(nErr) {
+         return (remote_handle)-1;
+      }
+      if(((remote_handle)-1 != handle) || ((remote_handle)-1 != (remote_handle)_adsp_default_listener_atomic_CompareAndExchange((uint32_t*)&handle, (uint32_t)tmp, (uint32_t)-1))) {
+         _adsp_default_listener_pls_dtor(&tmp);
+      }
+      return handle;
+   }
+}
+
+#endif //__qdsp6__
+
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_default_listener_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle_invoke)(_adsp_default_listener_handle(), _sc, _pra);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static __inline int _stub_method(remote_handle _handle, uint32_t _mid) {
+   remote_arg* _pra = 0;
+   int _nErr = 0;
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 0, 0, 0), _pra));
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_default_listener_register)(void) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 0;
+   return _stub_method(_adsp_default_listener_handle(), _mid);
+}
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_DEFAULT_LISTENER_STUB_H
diff --git a/src/adsp_listener_stub.c b/src/adsp_listener_stub.c
new file mode 100644
index 0000000..f94e2c4
--- /dev/null
+++ b/src/adsp_listener_stub.c
@@ -0,0 +1,797 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _ADSP_LISTENER_STUB_H
+#define _ADSP_LISTENER_STUB_H
+#include "adsp_listener.h"
+#include "remote.h"
+#ifndef ALLOCATOR_H
+#define ALLOCATOR_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct _heap _heap;
+struct _heap {
+   _heap* pPrev;
+   const char* loc;
+   uint64_t buf;
+};
+
+typedef struct allocator {
+   _heap* pheap;
+   uint8_t* stack;
+   uint8_t* stackEnd;
+   int nSize;
+} allocator;
+
+static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
+   _heap* pn = 0;
+   pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
+   if(pn != 0) {
+      pn->pPrev = *ppa;
+      pn->loc = loc;
+      *ppa = pn;
+      *ppbuf = (void*)&(pn->buf);
+      return 0;
+   } else {
+      return -1;
+   }
+}
+#define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))
+
+
+static __inline int allocator_alloc(allocator* me,
+                                    const char* loc,
+                                    int size,
+                                    unsigned int al,
+                                    void** ppbuf) {
+   if(size < 0) {
+      return -1;
+   } else if (size == 0) {
+      *ppbuf = 0;
+      return 0;
+   }
+   if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
+      *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
+      me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
+      return 0;
+   } else {
+      return _heap_alloc(&me->pheap, loc, size, ppbuf);
+   }
+}
+
+
+static __inline void allocator_deinit(allocator* me) {
+   _heap* pa = me->pheap;
+   while(pa != 0) {
+      _heap* pn = pa;
+      const char* loc = pn->loc;
+      (void)loc;
+      pa = pn->pPrev;
+      free(pn);
+   }
+}
+
+static __inline void allocator_init(allocator* me, uint8_t* stack, int stackSize) {
+   me->stack =  stack;
+   me->stackEnd =  stack + stackSize;
+   me->nSize = stackSize;
+   me->pheap = 0;
+}
+
+
+#endif // ALLOCATOR_H
+
+#ifndef SLIM_H
+#define SLIM_H
+
+#include <stdint.h>
+
+//a C data structure for the idl types that can be used to implement
+//static and dynamic language bindings fairly efficiently.
+//
+//the goal is to have a minimal ROM and RAM footprint and without
+//doing too many allocations.  A good way to package these things seemed
+//like the module boundary, so all the idls within  one module can share
+//all the type references.
+
+
+#define PARAMETER_IN       0x0
+#define PARAMETER_OUT      0x1
+#define PARAMETER_INOUT    0x2
+#define PARAMETER_ROUT     0x3
+#define PARAMETER_INROUT   0x4
+
+//the types that we get from idl
+#define TYPE_OBJECT             0x0
+#define TYPE_INTERFACE          0x1
+#define TYPE_PRIMITIVE          0x2
+#define TYPE_ENUM               0x3
+#define TYPE_STRING             0x4
+#define TYPE_WSTRING            0x5
+#define TYPE_STRUCTURE          0x6
+#define TYPE_UNION              0x7
+#define TYPE_ARRAY              0x8
+#define TYPE_SEQUENCE           0x9
+
+//these require the pack/unpack to recurse
+//so it's a hint to those languages that can optimize in cases where
+//recursion isn't necessary.
+#define TYPE_COMPLEX_STRUCTURE  (0x10 | TYPE_STRUCTURE)
+#define TYPE_COMPLEX_UNION      (0x10 | TYPE_UNION)
+#define TYPE_COMPLEX_ARRAY      (0x10 | TYPE_ARRAY)
+#define TYPE_COMPLEX_SEQUENCE   (0x10 | TYPE_SEQUENCE)
+
+
+typedef struct Type Type;
+
+#define INHERIT_TYPE\
+   int32_t nativeSize;                /*in the simple case its the same as wire size and alignment*/\
+   union {\
+      struct {\
+         const uintptr_t         p1;\
+         const uintptr_t         p2;\
+      } _cast;\
+      struct {\
+         uint32_t  iid;\
+         uint32_t  bNotNil;\
+      } object;\
+      struct {\
+         const Type  *arrayType;\
+         int32_t      nItems;\
+      } array;\
+      struct {\
+         const Type *seqType;\
+         int32_t      nMaxLen;\
+      } seqSimple; \
+      struct {\
+         uint32_t bFloating;\
+         uint32_t bSigned;\
+      } prim; \
+      const SequenceType* seqComplex;\
+      const UnionType  *unionType;\
+      const StructType *structType;\
+      int32_t         stringMaxLen;\
+      uint8_t        bInterfaceNotNil;\
+   } param;\
+   uint8_t    type;\
+   uint8_t    nativeAlignment\
+
+typedef struct UnionType UnionType;
+typedef struct StructType StructType;
+typedef struct SequenceType SequenceType;
+struct Type {
+   INHERIT_TYPE;
+};
+
+struct SequenceType {
+   const Type *         seqType;
+   uint32_t               nMaxLen;
+   uint32_t               inSize;
+   uint32_t               routSizePrimIn;
+   uint32_t               routSizePrimROut;
+};
+
+//byte offset from the start of the case values for
+//this unions case value array.  it MUST be aligned
+//at the alignment requrements for the descriptor
+//
+//if negative it means that the unions cases are
+//simple enumerators, so the value read from the descriptor
+//can be used directly to find the correct case
+typedef union CaseValuePtr CaseValuePtr;
+union CaseValuePtr {
+   const uint8_t*   value8s;
+   const uint16_t*  value16s;
+   const uint32_t*  value32s;
+   const uint64_t*  value64s;
+};
+
+//these are only used in complex cases
+//so I pulled them out of the type definition as references to make
+//the type smaller
+struct UnionType {
+   const Type           *descriptor;
+   uint32_t               nCases;
+   const CaseValuePtr   caseValues;
+   const Type * const   *cases;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+   uint8_t                inCaseAlignment;
+   uint8_t                routCaseAlignmentPrimIn;
+   uint8_t                routCaseAlignmentPrimROut;
+   uint8_t                nativeCaseAlignment;
+   uint8_t              bDefaultCase;
+};
+
+struct StructType {
+   uint32_t               nMembers;
+   const Type * const   *members;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+};
+
+typedef struct Parameter Parameter;
+struct Parameter {
+   INHERIT_TYPE;
+   uint8_t    mode;
+   uint8_t  bNotNil;
+};
+
+#define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)
+
+typedef struct Method Method;
+struct Method {
+   uint32_t                    uScalars;            //no method index
+   int32_t                     primInSize;
+   int32_t                     primROutSize;
+   int                         maxArgs;
+   int                         numParams;
+   const Parameter * const     *params;
+   uint8_t                       primInAlignment;
+   uint8_t                       primROutAlignment;
+};
+
+typedef struct Interface Interface;
+
+struct Interface {
+   int                            nMethods;
+   const Method  * const          *methodArray;
+   int                            nIIds;
+   const uint32_t                   *iids;
+   const uint16_t*                  methodStringArray;
+   const uint16_t*                  methodStrings;
+   const char*                    strings;
+};
+
+
+#endif //SLIM_H
+
+
+#ifndef _ADSP_LISTENER_SLIM_H
+#define _ADSP_LISTENER_SLIM_H
+#include "remote.h"
+#include <stdint.h>
+
+#ifndef __QAIC_SLIM
+#define __QAIC_SLIM(ff) ff
+#endif
+#ifndef __QAIC_SLIM_EXPORT
+#define __QAIC_SLIM_EXPORT
+#endif
+
+static const Type types[3];
+static const SequenceType sequenceTypes[1] = {{&(types[0]),0x0,0x4,0x4,0x0}};
+static const Type types[3] = {{0x8,{{(const uintptr_t)&(types[1]),(const uintptr_t)0x0}}, 9,0x4},{0x1,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x1},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4}};
+static const Parameter parameters[9] = {{0x4,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x4,0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,0,0},{0x8,{{(const uintptr_t)&(sequenceTypes[0]),0}}, 25,0x4,0,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x4,3,0},{0x8,{{(const uintptr_t)&(sequenceTypes[0]),0}}, 25,0x4,3,0},{0x8,{{(const uintptr_t)&(types[2]),(const uintptr_t)0x0}}, 9,0x4,3,0},{0x8,{{(const uintptr_t)&(types[1]),(const uintptr_t)0x0}}, 9,0x4,0,0},{0x8,{{(const uintptr_t)&(types[1]),(const uintptr_t)0x0}}, 9,0x4,3,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,3,0}};
+static const Parameter* const parameterArrays[23] = {(&(parameters[0])),(&(parameters[1])),(&(parameters[2])),(&(parameters[3])),(&(parameters[3])),(&(parameters[3])),(&(parameters[4])),(&(parameters[5])),(&(parameters[5])),(&(parameters[0])),(&(parameters[1])),(&(parameters[6])),(&(parameters[3])),(&(parameters[3])),(&(parameters[3])),(&(parameters[7])),(&(parameters[8])),(&(parameters[0])),(&(parameters[1])),(&(parameters[7])),(&(parameters[8])),(&(parameters[0])),(&(parameters[4]))};
+static const Method methods[5] = {{REMOTE_SCALARS_MAKEX(0,0,255,255,15,15),0x18,0xc,16,9,(&(parameterArrays[0])),0x4,0x4},{REMOTE_SCALARS_MAKEX(0,0,255,255,15,15),0x8,0x0,4,2,(&(parameterArrays[21])),0x4,0x1},{REMOTE_SCALARS_MAKEX(0,0,0x0,0x0,0x0,0x0),0x0,0x0,0,0,0,0x0,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x2,0x2,0x0,0x0),0x10,0x10,11,8,(&(parameterArrays[9])),0x4,0x4},{REMOTE_SCALARS_MAKEX(0,0,0x1,0x2,0x0,0x0),0xc,0x4,6,4,(&(parameterArrays[17])),0x4,0x4}};
+static const Method* const methodArrays[6] = {&(methods[0]),&(methods[1]),&(methods[2]),&(methods[2]),&(methods[3]),&(methods[4])};
+static const char strings[165] = "invoke_get_in_bufs\0routBufLenReq\0get_in_bufs2\0inBufLenReq\0next_invoke\0bufsLenReq\0prevResult\0inBuffers\0prevbufs\0outBufs\0prevCtx\0offset\0handle\0next2\0init2\0init\0ctx\0sc\0";
+static const uint16_t methodStrings[29] = {58,119,81,111,158,134,162,92,46,19,141,119,81,102,158,134,162,14,70,33,158,127,14,70,0,158,92,147,153};
+static const uint16_t methodStringsArrays[6] = {0,24,28,27,10,19};
+__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(adsp_listener_slim) = {6,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
+#endif //_ADSP_LISTENER_SLIM_H
+#ifdef __GNUC__
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+
+#ifndef __QAIC_STUB
+#define __QAIC_STUB(ff) ff
+#endif //__QAIC_STUB
+
+#ifndef __QAIC_STUB_EXPORT
+#define __QAIC_STUB_EXPORT
+#endif // __QAIC_STUB_EXPORT
+
+#ifndef __QAIC_STUB_ATTRIBUTE
+#define __QAIC_STUB_ATTRIBUTE
+#endif // __QAIC_STUB_ATTRIBUTE
+
+#ifndef __QAIC_SKEL
+#define __QAIC_SKEL(ff) ff
+#endif //__QAIC_SKEL__
+
+#ifndef __QAIC_SKEL_EXPORT
+#define __QAIC_SKEL_EXPORT
+#endif // __QAIC_SKEL_EXPORT
+
+#ifndef __QAIC_SKEL_ATTRIBUTE
+#define __QAIC_SKEL_ATTRIBUTE
+#endif // __QAIC_SKEL_ATTRIBUTE
+
+#ifdef __QAIC_DEBUG__
+   #ifndef __QAIC_DBG_PRINTF__
+   #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
+   #endif
+#else
+   #define __QAIC_DBG_PRINTF__( ee ) (void)0
+#endif
+
+
+#define _OFFSET(src, sof)  ((void*)(((char*)(src)) + (sof)))
+
+#define _COPY(dst, dof, src, sof, sz)  \
+   do {\
+         struct __copy { \
+            char ar[sz]; \
+         };\
+         *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\
+   } while (0)
+
+#define _ASSIGN(dst, src, sof)  \
+   do {\
+      dst = OFFSET(src, sof); \
+   } while (0)
+
+#define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))
+
+#include "AEEStdErr.h"
+
+#define _TRY(ee, func) \
+   do { \
+      if (AEE_SUCCESS != ((ee) = func)) {\
+         __QAIC_DBG_PRINTF__((__FILE_LINE__  ": error: %d\n", (int)(ee)));\
+         goto ee##bail;\
+      } \
+   } while (0)
+
+#define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)
+
+#define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)
+
+#ifdef __QAIC_DEBUG__
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
+#else
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, allocator_alloc(pal, 0, size, alignment, (void**)&pv))
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _const_adsp_listener_handle
+#define _const_adsp_listener_handle ((remote_handle)-1)
+#endif //_const_adsp_listener_handle
+
+static void _adsp_listener_pls_dtor(void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   if(_const_adsp_listener_handle != *ph) {
+      (void)__QAIC_REMOTE(remote_handle_close)(*ph);
+      *ph = _const_adsp_listener_handle;
+   }
+}
+
+static int _adsp_listener_pls_ctor(void* ctx, void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   *ph = _const_adsp_listener_handle;
+   if(*ph == (remote_handle)-1) {
+      return __QAIC_REMOTE(remote_handle_open)((const char*)ctx, ph);
+   }
+   return 0;
+}
+
+#if (defined __qdsp6__) || (defined __hexagon__)
+#pragma weak  adsp_pls_add_lookup
+extern int adsp_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+#pragma weak  HAP_pls_add_lookup
+extern int HAP_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+
+__QAIC_STUB_EXPORT remote_handle _adsp_listener_handle(void) {
+   remote_handle* ph;
+   if(adsp_pls_add_lookup) {
+      if(0 == adsp_pls_add_lookup((uint32_t)_adsp_listener_handle, 0, sizeof(*ph),  _adsp_listener_pls_ctor, "adsp_listener",  _adsp_listener_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   } else if(HAP_pls_add_lookup) {
+      if(0 == HAP_pls_add_lookup((uint32_t)_adsp_listener_handle, 0, sizeof(*ph),  _adsp_listener_pls_ctor, "adsp_listener",  _adsp_listener_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   }
+   return(remote_handle)-1;
+}
+
+#else //__qdsp6__ || __hexagon__
+
+uint32_t _adsp_listener_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare);
+
+#ifdef _WIN32
+#include "Windows.h"
+uint32_t _adsp_listener_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return (uint32_t)InterlockedCompareExchange((volatile LONG*)puDest, (LONG)uExchange, (LONG)uCompare);
+}
+#elif __GNUC__
+uint32_t _adsp_listener_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return __sync_val_compare_and_swap(puDest, uCompare, uExchange);
+}
+#endif //_WIN32
+
+
+__QAIC_STUB_EXPORT remote_handle _adsp_listener_handle(void) {
+   static remote_handle handle = _const_adsp_listener_handle;
+   if((remote_handle)-1 != handle) {
+      return handle;
+   } else {
+      remote_handle tmp;
+      int nErr = _adsp_listener_pls_ctor("adsp_listener", (void*)&tmp);
+      if(nErr) {
+         return (remote_handle)-1;
+      }
+      if(((remote_handle)-1 != handle) || ((remote_handle)-1 != (remote_handle)_adsp_listener_atomic_CompareAndExchange((uint32_t*)&handle, (uint32_t)tmp, (uint32_t)-1))) {
+         _adsp_listener_pls_dtor(&tmp);
+      }
+      return handle;
+   }
+}
+
+#endif //__qdsp6__
+
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle_invoke)(_adsp_listener_handle(), _sc, _pra);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static __inline int _stub_unpack(remote_arg* _praROutPost, remote_arg* _ppraROutPost[1], void* _primROut, char* _rout0[1], uint32_t _rout0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praROutPostStart = _praROutPost;
+   remote_arg** _ppraROutPostStart = _ppraROutPost;
+   _ppraROutPost = &_praROutPost;
+   _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) +1;
+   return _nErr;
+}
+static __inline int _stub_unpack_1(remote_arg* _praROutPost, remote_arg* _ppraROutPost[1], void* _primROut, char* _in0[1], uint32_t _in0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praROutPostStart = _praROutPost;
+   remote_arg** _ppraROutPostStart = _ppraROutPost;
+   _ppraROutPost = &_praROutPost;
+   _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) +0;
+   return _nErr;
+}
+static __inline int _stub_pack(allocator* _al, remote_arg* _praIn, remote_arg* _ppraIn[1], remote_arg* _praROut, remote_arg* _ppraROut[1], void* _primIn, void* _primROut, char* _rout0[1], uint32_t _rout0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praInStart = _praIn;
+   remote_arg** _ppraInStart = _ppraIn;
+   remote_arg* _praROutStart = _praROut;
+   remote_arg** _ppraROutStart = _ppraROut;
+   _ppraIn = &_praIn;
+   _ppraROut = &_praROut;
+   _COPY(_primIn, 0, _rout0Len, 0, 4);
+   _praROut[0].buf.pv = _rout0[0];
+   _praROut[0].buf.nLen = (1 * _rout0Len[0]);
+   _ppraInStart[0] += (_praIn - _praInStart) + 0;
+   _ppraROutStart[0] += (_praROut - _praROutStart) +1;
+   return _nErr;
+}
+static __inline int _stub_pack_1(allocator* _al, remote_arg* _praIn, remote_arg* _ppraIn[1], remote_arg* _praROut, remote_arg* _ppraROut[1], void* _primIn, void* _primROut, char* _in0[1], uint32_t _in0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praInStart = _praIn;
+   remote_arg** _ppraInStart = _ppraIn;
+   remote_arg* _praROutStart = _praROut;
+   remote_arg** _ppraROutStart = _ppraROut;
+   _ppraIn = &_praIn;
+   _ppraROut = &_praROut;
+   _COPY(_primIn, 0, _in0Len, 0, 4);
+   _praIn[0].buf.pv = _in0[0];
+   _praIn[0].buf.nLen = (1 * _in0Len[0]);
+   _ppraInStart[0] += (_praIn - _praInStart) + 1;
+   _ppraROutStart[0] += (_praROut - _praROutStart) +0;
+   return _nErr;
+}
+static __inline void _count(int _numIn[1], int _numROut[1], char* _rout0[1], uint32_t _rout0Len[1]) {
+   _numIn[0] += 0;
+   _numROut[0] += 1;
+}
+static __inline void _count_1(int _numIn[1], int _numROut[1], char* _in0[1], uint32_t _in0Len[1]) {
+   _numIn[0] += 1;
+   _numROut[0] += 0;
+}
+static __inline int _stub_method(remote_handle _handle, uint32_t _mid, uint32_t _in0[1], uint32_t _in1[1], void* _in2[1], uint32_t _in2Len[1], uint32_t _rout3[1], uint32_t _rout4[1], uint32_t _rout5[1], void* _rout6[1], uint32_t _rout6Len[1], char* _rout7[1], uint32_t _rout7Len[1], char* _rout8[1], uint32_t _rout8Len[1]) {
+   remote_arg* _pra;
+   int _numIn[1];
+   int _numROut[1];
+   char* _seq_nat2;
+   int _ii;
+   char* _seq_nat6;
+   allocator _al[1] = {{0}};
+   uint32_t _primIn[6];
+   uint32_t _primROut[3];
+   remote_arg* _praIn;
+   remote_arg* _praROut;
+   remote_arg* _praROutPost;
+   remote_arg** _ppraROutPost = &_praROutPost;
+   remote_arg** _ppraIn = &_praIn;
+   remote_arg** _ppraROut = &_praROut;
+   char* _seq_primIn2;
+   int _nErr = 0;
+   char* _seq_primIn6;
+   _numIn[0] = 2;
+   _numROut[0] = 2;
+   for(_ii = 0, _seq_nat2 = (char*)_in2[0];_ii < (int)_in2Len[0];++_ii, _seq_nat2 = (_seq_nat2 + 8))
+   {
+      _count_1(_numIn, _numROut, (char**)&(((uint32_t*)_seq_nat2)[0]), (uint32_t*)&(((uint32_t*)_seq_nat2)[1]));
+   }
+   for(_ii = 0, _seq_nat6 = (char*)_rout6[0];_ii < (int)_rout6Len[0];++_ii, _seq_nat6 = (_seq_nat6 + 8))
+   {
+      _count(_numIn, _numROut, (char**)&(((uint32_t*)_seq_nat6)[0]), (uint32_t*)&(((uint32_t*)_seq_nat6)[1]));
+   }
+   allocator_init(_al, 0, 0);
+   _ALLOCATE(_nErr, _al, ((((_numIn[0] + _numROut[0]) + 1) + 1) * sizeof(_pra[0])), 4, _pra);
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _pra[(_numIn[0] + 1)].buf.pv = (void*)_primROut;
+   _pra[(_numIn[0] + 1)].buf.nLen = sizeof(_primROut);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 1);
+   _praROutPost = _praROut;
+   _COPY(_primIn, 0, _in0, 0, 4);
+   _COPY(_primIn, 4, _in1, 0, 4);
+   _COPY(_primIn, 8, _in2Len, 0, 4);
+   _ALLOCATE(_nErr, _al, (_in2Len[0] * 4), 4, _praIn[0].buf.pv);
+   _praIn[0].buf.nLen = (4 * _in2Len[0]);
+   for(_ii = 0, _seq_primIn2 = (char*)_praIn[0].buf.pv, _seq_nat2 = (char*)_in2[0];_ii < (int)_in2Len[0];++_ii, _seq_primIn2 = (_seq_primIn2 + 4), _seq_nat2 = (_seq_nat2 + 8))
+   {
+      _TRY(_nErr, _stub_pack_1(_al, (_praIn + 1), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn2, 0, (char**)&(((uint32_t*)_seq_nat2)[0]), (uint32_t*)&(((uint32_t*)_seq_nat2)[1])));
+   }
+   _COPY(_primIn, 12, _rout6Len, 0, 4);
+   _ALLOCATE(_nErr, _al, (_rout6Len[0] * 4), 4, _praIn[1].buf.pv);
+   _praIn[1].buf.nLen = (4 * _rout6Len[0]);
+   for(_ii = 0, _seq_primIn6 = (char*)_praIn[1].buf.pv, _seq_nat6 = (char*)_rout6[0];_ii < (int)_rout6Len[0];++_ii, _seq_primIn6 = (_seq_primIn6 + 4), _seq_nat6 = (_seq_nat6 + 8))
+   {
+      _TRY(_nErr, _stub_pack(_al, (_praIn + 2), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn6, 0, (char**)&(((uint32_t*)_seq_nat6)[0]), (uint32_t*)&(((uint32_t*)_seq_nat6)[1])));
+   }
+   _COPY(_primIn, 16, _rout7Len, 0, 4);
+   _praROut[0].buf.pv = _rout7[0];
+   _praROut[0].buf.nLen = (4 * _rout7Len[0]);
+   _COPY(_primIn, 20, _rout8Len, 0, 4);
+   _praROut[1].buf.pv = _rout8[0];
+   _praROut[1].buf.nLen = (4 * _rout8Len[0]);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, (_numIn[0] + 1), (_numROut[0] + 1), 0, 0), _pra));
+   for(_ii = 0, _seq_nat2 = (char*)_in2[0];_ii < (int)_in2Len[0];++_ii, _seq_nat2 = (_seq_nat2 + 8))
+   {
+      _TRY(_nErr, _stub_unpack_1((_praROutPost + 0), _ppraROutPost, 0, (char**)&(((uint32_t*)_seq_nat2)[0]), (uint32_t*)&(((uint32_t*)_seq_nat2)[1])));
+   }
+   _COPY(_rout3, 0, _primROut, 0, 4);
+   _COPY(_rout4, 0, _primROut, 4, 4);
+   _COPY(_rout5, 0, _primROut, 8, 4);
+   for(_ii = 0, _seq_nat6 = (char*)_rout6[0];_ii < (int)_rout6Len[0];++_ii, _seq_nat6 = (_seq_nat6 + 8))
+   {
+      _TRY(_nErr, _stub_unpack((_praROutPost + 0), _ppraROutPost, 0, (char**)&(((uint32_t*)_seq_nat6)[0]), (uint32_t*)&(((uint32_t*)_seq_nat6)[1])));
+   }
+   _CATCH(_nErr) {}
+   allocator_deinit(_al);
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_next_invoke)(adsp_listener_invoke_ctx prevCtx, int prevResult, const adsp_listener_buffer* outBufs, int outBufsLen, adsp_listener_invoke_ctx* ctx, adsp_listener_remote_handle* handle, uint32* sc, adsp_listener_buffer* inBuffers, int inBuffersLen, int* inBufLenReq, int inBufLenReqLen, int* routBufLenReq, int routBufLenReqLen) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 0;
+   return _stub_method(_adsp_listener_handle(), _mid, (uint32_t*)&prevCtx, (uint32_t*)&prevResult, (void**)&outBufs, (uint32_t*)&outBufsLen, (uint32_t*)ctx, (uint32_t*)handle, (uint32_t*)sc, (void**)&inBuffers, (uint32_t*)&inBuffersLen, (char**)&inBufLenReq, (uint32_t*)&inBufLenReqLen, (char**)&routBufLenReq, (uint32_t*)&routBufLenReqLen);
+}
+static __inline int _stub_unpack_2(remote_arg* _praROutPost, remote_arg* _ppraROutPost[1], void* _primROut, char* _rout0[1], uint32_t _rout0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praROutPostStart = _praROutPost;
+   remote_arg** _ppraROutPostStart = _ppraROutPost;
+   _ppraROutPost = &_praROutPost;
+   _ppraROutPostStart[0] += (_praROutPost - _praROutPostStart) +1;
+   return _nErr;
+}
+static __inline int _stub_pack_2(allocator* _al, remote_arg* _praIn, remote_arg* _ppraIn[1], remote_arg* _praROut, remote_arg* _ppraROut[1], void* _primIn, void* _primROut, char* _rout0[1], uint32_t _rout0Len[1]) {
+   int _nErr = 0;
+   remote_arg* _praInStart = _praIn;
+   remote_arg** _ppraInStart = _ppraIn;
+   remote_arg* _praROutStart = _praROut;
+   remote_arg** _ppraROutStart = _ppraROut;
+   _ppraIn = &_praIn;
+   _ppraROut = &_praROut;
+   _COPY(_primIn, 0, _rout0Len, 0, 4);
+   _praROut[0].buf.pv = _rout0[0];
+   _praROut[0].buf.nLen = (1 * _rout0Len[0]);
+   _ppraInStart[0] += (_praIn - _praInStart) + 0;
+   _ppraROutStart[0] += (_praROut - _praROutStart) +1;
+   return _nErr;
+}
+static __inline int _stub_method_1(remote_handle _handle, uint32_t _mid, uint32_t _in0[1], void* _rout1[1], uint32_t _rout1Len[1]) {
+   remote_arg* _pra;
+   int _numIn[1];
+   int _numROut[1];
+   char* _seq_nat1;
+   int _ii;
+   allocator _al[1] = {{0}};
+   uint32_t _primIn[2];
+   remote_arg* _praIn;
+   remote_arg* _praROut;
+   remote_arg* _praROutPost;
+   remote_arg** _ppraROutPost = &_praROutPost;
+   remote_arg** _ppraIn = &_praIn;
+   remote_arg** _ppraROut = &_praROut;
+   char* _seq_primIn1;
+   int _nErr = 0;
+   _numIn[0] = 1;
+   _numROut[0] = 0;
+   for(_ii = 0, _seq_nat1 = (char*)_rout1[0];_ii < (int)_rout1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + 8))
+   {
+      _count(_numIn, _numROut, (char**)&(((uint32_t*)_seq_nat1)[0]), (uint32_t*)&(((uint32_t*)_seq_nat1)[1]));
+   }
+   allocator_init(_al, 0, 0);
+   _ALLOCATE(_nErr, _al, ((((_numIn[0] + _numROut[0]) + 1) + 0) * sizeof(_pra[0])), 4, _pra);
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 0);
+   _praROutPost = _praROut;
+   _COPY(_primIn, 0, _in0, 0, 4);
+   _COPY(_primIn, 4, _rout1Len, 0, 4);
+   _ALLOCATE(_nErr, _al, (_rout1Len[0] * 4), 4, _praIn[0].buf.pv);
+   _praIn[0].buf.nLen = (4 * _rout1Len[0]);
+   for(_ii = 0, _seq_primIn1 = (char*)_praIn[0].buf.pv, _seq_nat1 = (char*)_rout1[0];_ii < (int)_rout1Len[0];++_ii, _seq_primIn1 = (_seq_primIn1 + 4), _seq_nat1 = (_seq_nat1 + 8))
+   {
+      _TRY(_nErr, _stub_pack_2(_al, (_praIn + 1), _ppraIn, (_praROut + 0), _ppraROut, _seq_primIn1, 0, (char**)&(((uint32_t*)_seq_nat1)[0]), (uint32_t*)&(((uint32_t*)_seq_nat1)[1])));
+   }
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, (_numIn[0] + 1), (_numROut[0] + 0), 0, 0), _pra));
+   for(_ii = 0, _seq_nat1 = (char*)_rout1[0];_ii < (int)_rout1Len[0];++_ii, _seq_nat1 = (_seq_nat1 + 8))
+   {
+      _TRY(_nErr, _stub_unpack_2((_praROutPost + 0), _ppraROutPost, 0, (char**)&(((uint32_t*)_seq_nat1)[0]), (uint32_t*)&(((uint32_t*)_seq_nat1)[1])));
+   }
+   _CATCH(_nErr) {}
+   allocator_deinit(_al);
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_invoke_get_in_bufs)(adsp_listener_invoke_ctx ctx, adsp_listener_buffer* inBuffers, int inBuffersLen) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 1;
+   return _stub_method_1(_adsp_listener_handle(), _mid, (uint32_t*)&ctx, (void**)&inBuffers, (uint32_t*)&inBuffersLen);
+}
+static __inline int _stub_method_2(remote_handle _handle, uint32_t _mid) {
+   remote_arg* _pra = 0;
+   int _nErr = 0;
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 0, 0, 0, 0), _pra));
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_init)(void) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 2;
+   return _stub_method_2(_adsp_listener_handle(), _mid);
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_init2)(void) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 3;
+   return _stub_method_2(_adsp_listener_handle(), _mid);
+}
+static __inline int _stub_method_3(remote_handle _handle, uint32_t _mid, uint32_t _in0[1], uint32_t _in1[1], char* _in2[1], uint32_t _in2Len[1], uint32_t _rout3[1], uint32_t _rout4[1], uint32_t _rout5[1], char* _rout6[1], uint32_t _rout6Len[1], uint32_t _rout7[1]) {
+   int _numIn[1];
+   remote_arg _pra[4];
+   uint32_t _primIn[4];
+   uint32_t _primROut[4];
+   remote_arg* _praIn;
+   remote_arg* _praROut;
+   int _nErr = 0;
+   _numIn[0] = 1;
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _pra[(_numIn[0] + 1)].buf.pv = (void*)_primROut;
+   _pra[(_numIn[0] + 1)].buf.nLen = sizeof(_primROut);
+   _COPY(_primIn, 0, _in0, 0, 4);
+   _COPY(_primIn, 4, _in1, 0, 4);
+   _COPY(_primIn, 8, _in2Len, 0, 4);
+   _praIn = (_pra + 1);
+   _praIn[0].buf.pv = _in2[0];
+   _praIn[0].buf.nLen = (1 * _in2Len[0]);
+   _COPY(_primIn, 12, _rout6Len, 0, 4);
+   _praROut = (_praIn + _numIn[0] + 1);
+   _praROut[0].buf.pv = _rout6[0];
+   _praROut[0].buf.nLen = (1 * _rout6Len[0]);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 2, 2, 0, 0), _pra));
+   _COPY(_rout3, 0, _primROut, 0, 4);
+   _COPY(_rout4, 0, _primROut, 4, 4);
+   _COPY(_rout5, 0, _primROut, 8, 4);
+   _COPY(_rout7, 0, _primROut, 12, 4);
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_next2)(adsp_listener_invoke_ctx prevCtx, int prevResult, const uint8* prevbufs, int prevbufsLen, adsp_listener_invoke_ctx* ctx, adsp_listener_remote_handle* handle, uint32* sc, uint8* bufs, int bufsLen, int* bufsLenReq) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 4;
+   return _stub_method_3(_adsp_listener_handle(), _mid, (uint32_t*)&prevCtx, (uint32_t*)&prevResult, (char**)&prevbufs, (uint32_t*)&prevbufsLen, (uint32_t*)ctx, (uint32_t*)handle, (uint32_t*)sc, (char**)&bufs, (uint32_t*)&bufsLen, (uint32_t*)bufsLenReq);
+}
+static __inline int _stub_method_4(remote_handle _handle, uint32_t _mid, uint32_t _in0[1], uint32_t _in1[1], char* _rout2[1], uint32_t _rout2Len[1], uint32_t _rout3[1]) {
+   int _numIn[1];
+   remote_arg _pra[3];
+   uint32_t _primIn[3];
+   uint32_t _primROut[1];
+   remote_arg* _praIn;
+   remote_arg* _praROut;
+   int _nErr = 0;
+   _numIn[0] = 0;
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _pra[(_numIn[0] + 1)].buf.pv = (void*)_primROut;
+   _pra[(_numIn[0] + 1)].buf.nLen = sizeof(_primROut);
+   _COPY(_primIn, 0, _in0, 0, 4);
+   _COPY(_primIn, 4, _in1, 0, 4);
+   _COPY(_primIn, 8, _rout2Len, 0, 4);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 1);
+   _praROut[0].buf.pv = _rout2[0];
+   _praROut[0].buf.nLen = (1 * _rout2Len[0]);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 1, 2, 0, 0), _pra));
+   _COPY(_rout3, 0, _primROut, 0, 4);
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_listener_get_in_bufs2)(adsp_listener_invoke_ctx ctx, int offset, uint8* bufs, int bufsLen, int* bufsLenReq) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 5;
+   return _stub_method_4(_adsp_listener_handle(), _mid, (uint32_t*)&ctx, (uint32_t*)&offset, (char**)&bufs, (uint32_t*)&bufsLen, (uint32_t*)bufsLenReq);
+}
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_LISTENER_STUB_H
diff --git a/src/adsp_perf_stub.c b/src/adsp_perf_stub.c
new file mode 100644
index 0000000..46ecc78
--- /dev/null
+++ b/src/adsp_perf_stub.c
@@ -0,0 +1,623 @@
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _ADSP_PERF_STUB_H
+#define _ADSP_PERF_STUB_H
+#include "adsp_perf.h"
+#ifndef _QAIC_ENV_H
+#define _QAIC_ENV_H
+
+#ifdef __GNUC__
+#ifdef __clang__
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#else
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+#ifndef _ATTRIBUTE_UNUSED
+
+#ifdef _WIN32
+#define _ATTRIBUTE_UNUSED
+#else
+#define _ATTRIBUTE_UNUSED __attribute__ ((unused))
+#endif
+
+#endif // _ATTRIBUTE_UNUSED
+
+#ifndef __QAIC_REMOTE
+#define __QAIC_REMOTE(ff) ff
+#endif //__QAIC_REMOTE
+
+#ifndef __QAIC_HEADER
+#define __QAIC_HEADER(ff) ff
+#endif //__QAIC_HEADER
+
+#ifndef __QAIC_HEADER_EXPORT
+#define __QAIC_HEADER_EXPORT
+#endif // __QAIC_HEADER_EXPORT
+
+#ifndef __QAIC_HEADER_ATTRIBUTE
+#define __QAIC_HEADER_ATTRIBUTE
+#endif // __QAIC_HEADER_ATTRIBUTE
+
+#ifndef __QAIC_IMPL
+#define __QAIC_IMPL(ff) ff
+#endif //__QAIC_IMPL
+
+#ifndef __QAIC_IMPL_EXPORT
+#define __QAIC_IMPL_EXPORT
+#endif // __QAIC_IMPL_EXPORT
+
+#ifndef __QAIC_IMPL_ATTRIBUTE
+#define __QAIC_IMPL_ATTRIBUTE
+#endif // __QAIC_IMPL_ATTRIBUTE
+
+#ifndef __QAIC_STUB
+#define __QAIC_STUB(ff) ff
+#endif //__QAIC_STUB
+
+#ifndef __QAIC_STUB_EXPORT
+#define __QAIC_STUB_EXPORT
+#endif // __QAIC_STUB_EXPORT
+
+#ifndef __QAIC_STUB_ATTRIBUTE
+#define __QAIC_STUB_ATTRIBUTE
+#endif // __QAIC_STUB_ATTRIBUTE
+
+#ifndef __QAIC_SKEL
+#define __QAIC_SKEL(ff) ff
+#endif //__QAIC_SKEL__
+
+#ifndef __QAIC_SKEL_EXPORT
+#define __QAIC_SKEL_EXPORT
+#endif // __QAIC_SKEL_EXPORT
+
+#ifndef __QAIC_SKEL_ATTRIBUTE
+#define __QAIC_SKEL_ATTRIBUTE
+#endif // __QAIC_SKEL_ATTRIBUTE
+
+#ifdef __QAIC_DEBUG__
+   #ifndef __QAIC_DBG_PRINTF__
+   #include <stdio.h>
+   #define __QAIC_DBG_PRINTF__( ee ) do { printf ee ; } while(0)
+   #endif
+#else
+   #define __QAIC_DBG_PRINTF__( ee ) (void)0
+#endif
+
+
+#define _OFFSET(src, sof)  ((void*)(((char*)(src)) + (sof)))
+
+#define _COPY(dst, dof, src, sof, sz)  \
+   do {\
+         struct __copy { \
+            char ar[sz]; \
+         };\
+         *(struct __copy*)_OFFSET(dst, dof) = *(struct __copy*)_OFFSET(src, sof);\
+   } while (0)
+
+#define _COPYIF(dst, dof, src, sof, sz)  \
+   do {\
+      if(_OFFSET(dst, dof) != _OFFSET(src, sof)) {\
+         _COPY(dst, dof, src, sof, sz); \
+      } \
+   } while (0)
+
+_ATTRIBUTE_UNUSED
+static __inline void _qaic_memmove(void* dst, void* src, int size) {
+   int i;
+   for(i = 0; i < size; ++i) {
+      ((char*)dst)[i] = ((char*)src)[i];
+   }
+}
+
+#define _MEMMOVEIF(dst, src, sz)  \
+   do {\
+      if(dst != src) {\
+         _qaic_memmove(dst, src, sz);\
+      } \
+   } while (0)
+
+
+#define _ASSIGN(dst, src, sof)  \
+   do {\
+      dst = OFFSET(src, sof); \
+   } while (0)
+
+#define _STD_STRLEN_IF(str) (str == 0 ? 0 : strlen(str))
+
+#include "AEEStdErr.h"
+
+#define _TRY(ee, func) \
+   do { \
+      if (AEE_SUCCESS != ((ee) = func)) {\
+         __QAIC_DBG_PRINTF__((__FILE__ ":%d:error:%d:%s\n", __LINE__, (int)(ee),#func));\
+         goto ee##bail;\
+      } \
+   } while (0)
+
+#define _CATCH(exception) exception##bail: if (exception != AEE_SUCCESS)
+
+#define _ASSERT(nErr, ff) _TRY(nErr, 0 == (ff) ? AEE_EBADPARM : AEE_SUCCESS)
+
+#ifdef __QAIC_DEBUG__
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, __FILE_LINE__, size, alignment, (void**)&pv))
+#else
+#define _ALLOCATE(nErr, pal, size, alignment, pv) _TRY(nErr, _allocator_alloc(pal, 0, size, alignment, (void**)&pv))
+#endif
+
+
+#endif // _QAIC_ENV_H
+
+#include "remote.h"
+#ifndef _ALLOCATOR_H
+#define _ALLOCATOR_H
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct _heap _heap;
+struct _heap {
+   _heap* pPrev;
+   const char* loc;
+   uint64_t buf;
+};
+
+typedef struct _allocator {
+   _heap* pheap;
+   uint8_t* stack;
+   uint8_t* stackEnd;
+   int nSize;
+} _allocator;
+
+_ATTRIBUTE_UNUSED
+static __inline int _heap_alloc(_heap** ppa, const char* loc, int size, void** ppbuf) {
+   _heap* pn = 0;
+   pn = malloc(size + sizeof(_heap) - sizeof(uint64_t));
+   if(pn != 0) {
+      pn->pPrev = *ppa;
+      pn->loc = loc;
+      *ppa = pn;
+      *ppbuf = (void*)&(pn->buf);
+      return 0;
+   } else {
+      return -1;
+   }
+}
+#define _ALIGN_SIZE(x, y) (((x) + (y-1)) & ~(y-1))
+
+_ATTRIBUTE_UNUSED
+static __inline int _allocator_alloc(_allocator* me,
+                                    const char* loc,
+                                    int size,
+                                    unsigned int al,
+                                    void** ppbuf) {
+   if(size < 0) {
+      return -1;
+   } else if (size == 0) {
+      *ppbuf = 0;
+      return 0;
+   }
+   if((_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size) < (uintptr_t)me->stack + me->nSize) {
+      *ppbuf = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al);
+      me->stackEnd = (uint8_t*)_ALIGN_SIZE((uintptr_t)me->stackEnd, al) + size;
+      return 0;
+   } else {
+      return _heap_alloc(&me->pheap, loc, size, ppbuf);
+   }
+}
+
+_ATTRIBUTE_UNUSED
+static __inline void _allocator_deinit(_allocator* me) {
+   _heap* pa = me->pheap;
+   while(pa != 0) {
+      _heap* pn = pa;
+      const char* loc = pn->loc;
+      (void)loc;
+      pa = pn->pPrev;
+      free(pn);
+   }
+}
+
+_ATTRIBUTE_UNUSED
+static __inline void _allocator_init(_allocator* me, uint8_t* stack, int stackSize) {
+   me->stack =  stack;
+   me->stackEnd =  stack + stackSize;
+   me->nSize = stackSize;
+   me->pheap = 0;
+}
+
+
+#endif // _ALLOCATOR_H
+
+#ifndef SLIM_H
+#define SLIM_H
+
+#include <stdint.h>
+
+//a C data structure for the idl types that can be used to implement
+//static and dynamic language bindings fairly efficiently.
+//
+//the goal is to have a minimal ROM and RAM footprint and without
+//doing too many allocations.  A good way to package these things seemed
+//like the module boundary, so all the idls within  one module can share
+//all the type references.
+
+
+#define PARAMETER_IN       0x0
+#define PARAMETER_OUT      0x1
+#define PARAMETER_INOUT    0x2
+#define PARAMETER_ROUT     0x3
+#define PARAMETER_INROUT   0x4
+
+//the types that we get from idl
+#define TYPE_OBJECT             0x0
+#define TYPE_INTERFACE          0x1
+#define TYPE_PRIMITIVE          0x2
+#define TYPE_ENUM               0x3
+#define TYPE_STRING             0x4
+#define TYPE_WSTRING            0x5
+#define TYPE_STRUCTURE          0x6
+#define TYPE_UNION              0x7
+#define TYPE_ARRAY              0x8
+#define TYPE_SEQUENCE           0x9
+
+//these require the pack/unpack to recurse
+//so it's a hint to those languages that can optimize in cases where
+//recursion isn't necessary.
+#define TYPE_COMPLEX_STRUCTURE  (0x10 | TYPE_STRUCTURE)
+#define TYPE_COMPLEX_UNION      (0x10 | TYPE_UNION)
+#define TYPE_COMPLEX_ARRAY      (0x10 | TYPE_ARRAY)
+#define TYPE_COMPLEX_SEQUENCE   (0x10 | TYPE_SEQUENCE)
+
+
+typedef struct Type Type;
+
+#define INHERIT_TYPE\
+   int32_t nativeSize;                /*in the simple case its the same as wire size and alignment*/\
+   union {\
+      struct {\
+         const uintptr_t         p1;\
+         const uintptr_t         p2;\
+      } _cast;\
+      struct {\
+         uint32_t  iid;\
+         uint32_t  bNotNil;\
+      } object;\
+      struct {\
+         const Type  *arrayType;\
+         int32_t      nItems;\
+      } array;\
+      struct {\
+         const Type *seqType;\
+         int32_t      nMaxLen;\
+      } seqSimple; \
+      struct {\
+         uint32_t bFloating;\
+         uint32_t bSigned;\
+      } prim; \
+      const SequenceType* seqComplex;\
+      const UnionType  *unionType;\
+      const StructType *structType;\
+      int32_t         stringMaxLen;\
+      uint8_t        bInterfaceNotNil;\
+   } param;\
+   uint8_t    type;\
+   uint8_t    nativeAlignment\
+
+typedef struct UnionType UnionType;
+typedef struct StructType StructType;
+typedef struct SequenceType SequenceType;
+struct Type {
+   INHERIT_TYPE;
+};
+
+struct SequenceType {
+   const Type *         seqType;
+   uint32_t               nMaxLen;
+   uint32_t               inSize;
+   uint32_t               routSizePrimIn;
+   uint32_t               routSizePrimROut;
+};
+
+//byte offset from the start of the case values for
+//this unions case value array.  it MUST be aligned
+//at the alignment requrements for the descriptor
+//
+//if negative it means that the unions cases are
+//simple enumerators, so the value read from the descriptor
+//can be used directly to find the correct case
+typedef union CaseValuePtr CaseValuePtr;
+union CaseValuePtr {
+   const uint8_t*   value8s;
+   const uint16_t*  value16s;
+   const uint32_t*  value32s;
+   const uint64_t*  value64s;
+};
+
+//these are only used in complex cases
+//so I pulled them out of the type definition as references to make
+//the type smaller
+struct UnionType {
+   const Type           *descriptor;
+   uint32_t               nCases;
+   const CaseValuePtr   caseValues;
+   const Type * const   *cases;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+   uint8_t                inCaseAlignment;
+   uint8_t                routCaseAlignmentPrimIn;
+   uint8_t                routCaseAlignmentPrimROut;
+   uint8_t                nativeCaseAlignment;
+   uint8_t              bDefaultCase;
+};
+
+struct StructType {
+   uint32_t               nMembers;
+   const Type * const   *members;
+   int32_t               inSize;
+   int32_t               routSizePrimIn;
+   int32_t               routSizePrimROut;
+   uint8_t                inAlignment;
+   uint8_t                routAlignmentPrimIn;
+   uint8_t                routAlignmentPrimROut;
+};
+
+typedef struct Parameter Parameter;
+struct Parameter {
+   INHERIT_TYPE;
+   uint8_t    mode;
+   uint8_t  bNotNil;
+};
+
+#define SLIM_IFPTR32(is32,is64) (sizeof(uintptr_t) == 4 ? (is32) : (is64))
+#define SLIM_SCALARS_IS_DYNAMIC(u) (((u) & 0x00ffffff) == 0x00ffffff)
+
+typedef struct Method Method;
+struct Method {
+   uint32_t                    uScalars;            //no method index
+   int32_t                     primInSize;
+   int32_t                     primROutSize;
+   int                         maxArgs;
+   int                         numParams;
+   const Parameter * const     *params;
+   uint8_t                       primInAlignment;
+   uint8_t                       primROutAlignment;
+};
+
+typedef struct Interface Interface;
+
+struct Interface {
+   int                            nMethods;
+   const Method  * const          *methodArray;
+   int                            nIIds;
+   const uint32_t                   *iids;
+   const uint16_t*                  methodStringArray;
+   const uint16_t*                  methodStrings;
+   const char*                    strings;
+};
+
+
+#endif //SLIM_H
+
+
+#ifndef _ADSP_PERF_SLIM_H
+#define _ADSP_PERF_SLIM_H
+#include "remote.h"
+#include <stdint.h>
+
+#ifndef __QAIC_SLIM
+#define __QAIC_SLIM(ff) ff
+#endif
+#ifndef __QAIC_SLIM_EXPORT
+#define __QAIC_SLIM_EXPORT
+#endif
+
+static const Type types[2];
+static const Type types[2] = {{0x8,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x8},{0x1,{{(const uintptr_t)0,(const uintptr_t)0}}, 2,0x1}};
+static const Parameter parameters[4] = {{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,0,0},{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(types[0]),(const uintptr_t)0x0}}, 9,SLIM_IFPTR32(0x4,0x8),3,0},{SLIM_IFPTR32(0x8,0x10),{{(const uintptr_t)&(types[1]),(const uintptr_t)0x0}}, 9,SLIM_IFPTR32(0x4,0x8),3,0},{0x4,{{(const uintptr_t)0,(const uintptr_t)1}}, 2,0x4,3,0}};
+static const Parameter* const parameterArrays[5] = {(&(parameters[2])),(&(parameters[3])),(&(parameters[3])),(&(parameters[1])),(&(parameters[0]))};
+static const Method methods[3] = {{REMOTE_SCALARS_MAKEX(0,0,0x1,0x0,0x0,0x0),0x4,0x0,1,1,(&(parameterArrays[4])),0x4,0x0},{REMOTE_SCALARS_MAKEX(0,0,0x1,0x1,0x0,0x0),0x4,0x0,3,1,(&(parameterArrays[3])),0x4,0x1},{REMOTE_SCALARS_MAKEX(0,0,0x1,0x2,0x0,0x0),0x4,0x8,5,3,(&(parameterArrays[0])),0x4,0x4}};
+static const Method* const methodArrays[3] = {&(methods[0]),&(methods[1]),&(methods[2])};
+static const char strings[48] = "get_usecs\0get_keys\0numKeys\0maxLen\0enable\0dst\0ix\0";
+static const uint16_t methodStrings[8] = {10,14,27,19,0,41,34,45};
+static const uint16_t methodStringsArrays[3] = {6,4,0};
+__QAIC_SLIM_EXPORT const Interface __QAIC_SLIM(adsp_perf_slim) = {3,&(methodArrays[0]),0,0,&(methodStringsArrays [0]),methodStrings,strings};
+#endif //_ADSP_PERF_SLIM_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _const_adsp_perf_handle
+#define _const_adsp_perf_handle ((remote_handle)-1)
+#endif //_const_adsp_perf_handle
+
+static void _adsp_perf_pls_dtor(void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   if(_const_adsp_perf_handle != *ph) {
+      (void)__QAIC_REMOTE(remote_handle_close)(*ph);
+      *ph = _const_adsp_perf_handle;
+   }
+}
+
+static int _adsp_perf_pls_ctor(void* ctx, void* data) {
+   remote_handle* ph = (remote_handle*)data;
+   *ph = _const_adsp_perf_handle;
+   if(*ph == (remote_handle)-1) {
+      return __QAIC_REMOTE(remote_handle_open)((const char*)ctx, ph);
+   }
+   return 0;
+}
+
+#if (defined __qdsp6__) || (defined __hexagon__)
+#pragma weak  adsp_pls_add_lookup
+extern int adsp_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+#pragma weak  HAP_pls_add_lookup
+extern int HAP_pls_add_lookup(uint32_t type, uint32_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* ctx), void** ppo);
+
+__QAIC_STUB_EXPORT remote_handle _adsp_perf_handle(void) {
+   remote_handle* ph;
+   if(adsp_pls_add_lookup) {
+      if(0 == adsp_pls_add_lookup((uint32_t)_adsp_perf_handle, 0, sizeof(*ph),  _adsp_perf_pls_ctor, "adsp_perf",  _adsp_perf_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   } else if(HAP_pls_add_lookup) {
+      if(0 == HAP_pls_add_lookup((uint32_t)_adsp_perf_handle, 0, sizeof(*ph),  _adsp_perf_pls_ctor, "adsp_perf",  _adsp_perf_pls_dtor, (void**)&ph))  {
+         return *ph;
+      }
+      return (remote_handle)-1;
+   }
+   return(remote_handle)-1;
+}
+
+#else //__qdsp6__ || __hexagon__
+
+uint32_t _adsp_perf_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare);
+
+#ifdef _WIN32
+#include "Windows.h"
+uint32_t _adsp_perf_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return (uint32_t)InterlockedCompareExchange((volatile LONG*)puDest, (LONG)uExchange, (LONG)uCompare);
+}
+#elif __GNUC__
+uint32_t _adsp_perf_atomic_CompareAndExchange(uint32_t * volatile puDest, uint32_t uExchange, uint32_t uCompare) {
+   return __sync_val_compare_and_swap(puDest, uCompare, uExchange);
+}
+#endif //_WIN32
+
+
+__QAIC_STUB_EXPORT remote_handle _adsp_perf_handle(void) {
+   static remote_handle handle = _const_adsp_perf_handle;
+   if((remote_handle)-1 != handle) {
+      return handle;
+   } else {
+      remote_handle tmp;
+      int nErr = _adsp_perf_pls_ctor("adsp_perf", (void*)&tmp);
+      if(nErr) {
+         return (remote_handle)-1;
+      }
+      if(((remote_handle)-1 != handle) || ((remote_handle)-1 != (remote_handle)_adsp_perf_atomic_CompareAndExchange((uint32_t*)&handle, (uint32_t)tmp, (uint32_t)-1))) {
+         _adsp_perf_pls_dtor(&tmp);
+      }
+      return handle;
+   }
+}
+
+#endif //__qdsp6__
+
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_perf_skel_invoke)(uint32_t _sc, remote_arg* _pra) __QAIC_STUB_ATTRIBUTE {
+   return __QAIC_REMOTE(remote_handle_invoke)(_adsp_perf_handle(), _sc, _pra);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static __inline int _stub_method(remote_handle _handle, uint32_t _mid, uint32_t _in0[1]) {
+   remote_arg _pra[1];
+   uint32_t _primIn[1];
+   int _nErr = 0;
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _COPY(_primIn, 0, _in0, 0, 4);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 1, 0, 0, 0), _pra));
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_perf_enable)(int ix) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 0;
+   return _stub_method(_adsp_perf_handle(), _mid, (uint32_t*)&ix);
+}
+static __inline int _stub_method_1(remote_handle _handle, uint32_t _mid, char* _rout0[1], uint32_t _rout0Len[1]) {
+   int _numIn[1];
+   remote_arg _pra[2];
+   uint32_t _primIn[1];
+   remote_arg* _praIn;
+   remote_arg* _praROut;
+   int _nErr = 0;
+   _numIn[0] = 0;
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _COPY(_primIn, 0, _rout0Len, 0, 4);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 0);
+   _praROut[0].buf.pv = _rout0[0];
+   _praROut[0].buf.nLen = (8 * _rout0Len[0]);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 1, 1, 0, 0), _pra));
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_perf_get_usecs)(int64* dst, int dstLen) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 1;
+   return _stub_method_1(_adsp_perf_handle(), _mid, (char**)&dst, (uint32_t*)&dstLen);
+}
+static __inline int _stub_method_2(remote_handle _handle, uint32_t _mid, char* _rout0[1], uint32_t _rout0Len[1], uint32_t _rout1[1], uint32_t _rout2[1]) {
+   int _numIn[1];
+   remote_arg _pra[3];
+   uint32_t _primIn[1];
+   uint32_t _primROut[2];
+   remote_arg* _praIn;
+   remote_arg* _praROut;
+   int _nErr = 0;
+   _numIn[0] = 0;
+   _pra[0].buf.pv = (void*)_primIn;
+   _pra[0].buf.nLen = sizeof(_primIn);
+   _pra[(_numIn[0] + 1)].buf.pv = (void*)_primROut;
+   _pra[(_numIn[0] + 1)].buf.nLen = sizeof(_primROut);
+   _COPY(_primIn, 0, _rout0Len, 0, 4);
+   _praIn = (_pra + 1);
+   _praROut = (_praIn + _numIn[0] + 1);
+   _praROut[0].buf.pv = _rout0[0];
+   _praROut[0].buf.nLen = (1 * _rout0Len[0]);
+   _TRY(_nErr, __QAIC_REMOTE(remote_handle_invoke)(_handle, REMOTE_SCALARS_MAKEX(0, _mid, 1, 2, 0, 0), _pra));
+   _COPY(_rout1, 0, _primROut, 0, 4);
+   _COPY(_rout2, 0, _primROut, 4, 4);
+   _CATCH(_nErr) {}
+   return _nErr;
+}
+__QAIC_STUB_EXPORT int __QAIC_STUB(adsp_perf_get_keys)(char* keys, int keysLen, int* maxLen, int* numKeys) __QAIC_STUB_ATTRIBUTE {
+   uint32_t _mid = 2;
+   return _stub_method_2(_adsp_perf_handle(), _mid, (char**)&keys, (uint32_t*)&keysLen, (uint32_t*)maxLen, (uint32_t*)numKeys);
+}
+#ifdef __cplusplus
+}
+#endif
+#endif //_ADSP_PERF_STUB_H
diff --git a/src/adspmsgd_adsp1_stub.c b/src/adspmsgd_adsp1_stub.c
new file mode 100644
index 0000000..d4c0050
--- /dev/null
+++ b/src/adspmsgd_adsp1_stub.c
@@ -0,0 +1,489 @@
+#ifndef _ADSPMSGD_ADSP1_STUB_H
+#define _ADSPMSGD_ADSP1_STUB_H
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "adspmsgd_adsp1.h"
+#ifndef _QAIC_ENV_H
+#define _QAIC_ENV_H
+
+#ifdef __GNUC__
+#ifdef __clang__
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#else
+#pragma GCC diagnostic ignored "-Wpragmas"
+#endif
+#pragma GCC diagnostic ignored "-Wuninitialized"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+#ifndef _ATTRIBUTE_UNUSED
+
+#ifdef _WIN32
+#define _ATTRIBUTE_UNUSED