a lot of minor cleanups

git-svn-id: file:///home/lennart/svn/public/libsydney/trunk@36 9ba3c220-e4d3-45a2-8aa3-73fcc9aff6ce

36 files changed, 809 insertions, 696 deletions

diff --git a/configure.ac b/configure.ac
index 5a3f555..3d77e70 100644
--- a/configure.ac
+++ b/configure.ac
@@ -137,7 +137,7 @@ AC_CHECK_FUNCS([lrintf strtof])
 
 # POSIX
 AC_FUNC_SELECT_ARGTYPES
-AC_CHECK_FUNCS([gettimeofday nanosleep posix_memalign sigaction sleep sysconf])
+AC_CHECK_FUNCS([gettimeofday nanosleep posix_memalign sigaction sleep sysconf pthread_yield])
 
 # SUSv3
 AC_CHECK_FUNCS([strerror_r])
diff --git a/src/Makefile.am b/src/Makefile.am
index b6b57ea..ad13181 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -40,7 +40,7 @@ libsydney_la_SOURCES = \
 	bbuffer.c bbuffer.h \
 	format.c fomat.h \
 	volscale.c volscale.h \
-	byteswap.c byteswap.h \
+	bswap.c bswap.h \
 	continued-fraction.c continued-fraction.h \
 	zero.c zero.h \
 	add.c add.h \
@@ -49,9 +49,8 @@ libsydney_la_SOURCES = \
 	interleave.c interleave.h \
 	converter.c converter.h \
 	g711.c g711.h \
-	mutex.c mutex.h \
-	once.c once.h \
-	thread.c thread.h \
+	mutex-posix.c mutex.h \
+	thread-posix.c thread.h \
 	bufferq.c buffer.h \
 	meta-name-table.h
 #	asyncq.c asyncq.h
@@ -97,7 +96,7 @@ BUILT_SOURCES = \
 	meta-name-table.h
 
 meta-name-table.h: meta-name-table.gperf Makefile
-	gperf -t -N sa_lookup_meta_name -H sa_hash_meta_name -p -C < $< | sed -e 's/{""}/{"", 0}/g' > $@
+	gperf -L ANSI-C -t -N sa_lookup_meta_name -H sa_hash_meta_name -p -C < $< | sed -e 's/{""}/{"", 0}/g' > $@
 
 fixme:
 	find -name '*.c' -exec fgrep -H -A 3 -B 3 -i FIXME \{\} \;
diff --git a/src/add.c b/src/add.c
index b7714f4..74eef31 100644
--- a/src/add.c
+++ b/src/add.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <liboil/liboil.h>
 
 #include "macro.h"
diff --git a/src/asyncq.c b/src/asyncq.c
index 54d7d5b..ad5b795 100644
--- a/src/asyncq.c
+++ b/src/asyncq.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include "sydney.h"
 #include "asyncq.h"
 #include "malloc.h"
@@ -10,7 +14,7 @@ int sa_asyncq_init(sa_asyncq_t *a, size_t item_size) {
 
     a->last = NULL;
     a->item_size = item_size;
-    
+
     if (!(a->mutex = sa_mutex_new(0)))
         return SA_ERROR_OOM;
 
@@ -19,7 +23,7 @@ int sa_asyncq_init(sa_asyncq_t *a, size_t item_size) {
 
 sa_asyncq_item_t *sa_asyncq_get(sa_asyncq_t *a) {
     sa_assert(a);
-    
+
     sa_mutex_lock(a->mutex);
 
     if ((i = a->unused))
@@ -53,7 +57,7 @@ void sa_asyncq_push(sa_asyncq_t *a, sa_asyncq_item_t *i) {
         SA_LLIST_INSERT_AFTER(sa_asyncq_item_t, items, a->items, a->last, i);
     else
         SA_LLIST_PREPEND(sa_asyncq_item_t, items, a->items, i);
-    
+
     a->last = i;
 
     sa_mutex_unlock(a->mutex);
@@ -63,7 +67,7 @@ void sa_asyncq_push(sa_asyncq_t *a, sa_asyncq_item_t *i) {
 
 sa_asyncq_item_t sa_asyncq_pop(sa_asyncq_t *a, int wait) {
     sa_asyncq_item_t *i;
-    
+
     sa_assert(a);
 
     if (wait)
@@ -75,10 +79,10 @@ sa_asyncq_item_t sa_asyncq_pop(sa_asyncq_t *a, int wait) {
     if ((i = a->items)) {
         if (i == a->last)
             a->last = NULL;
-        
+
         SA_LLIST_REMOVE(sa_asyncq_item_t, items, a->items, i);
     }
-    
+
     sa_mutex_unlock(a->mutex);
 
     return i;
@@ -91,7 +95,7 @@ void sa_asyncq_done(sa_asyncq_t *a) {
     /* The caller *must* pop all items from the queue before
      * destructing us! */
     sa_assert(!a->items);
-    
+
     if (a->mutex)
         sa_mutex_free(a->mutex);
 
diff --git a/src/asyncq.h b/src/asyncq.h
index 2e60c23..5d26283 100644
--- a/src/asyncq.h
+++ b/src/asyncq.h
@@ -1,5 +1,5 @@
-#ifndef foosydneyhasynchfoo
-#define foosydneyhasynchfoo
+#ifndef foosydneyasynchfoo
+#define foosydneyasynchfoo
 
 #include "llist.h"
 #include "mutex.h"
@@ -11,7 +11,7 @@ struct sa_asyncq_item {
     SA_LLIST_ITEM(sa_asyncq_item_t, items);
 };
 
-#define SA_ASYNCQ_ITEM_DATA(x) ((void*) ((uint8_t*) (x) + ALIGN(sizeof(sa_asyncq_item_t))))
+#define SA_ASYNCQ_ITEM_DATA(x) ((void*) ((uint8_t*) (x) + SA_ALIGN(sizeof(sa_asyncq_item_t))))
 
 struct sa_asyncq {
     sa_mutex_t *mutex;
diff --git a/src/bbuffer.c b/src/bbuffer.c
index c8cbaa0..86bc5ee 100644
--- a/src/bbuffer.c
+++ b/src/bbuffer.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <sys/types.h>
 
 #include "bbuffer.h"
@@ -12,7 +16,7 @@ int sa_bbuffer_init(sa_bbuffer_t *b, unsigned nchannels, size_t sample_size) {
 
     b->nchannels = nchannels;
     b->sample_size = sample_size;
-    
+
     if (!(b->data = sa_new0(void *, nchannels))) {
         b->size = NULL;
         return SA_ERROR_OOM;
@@ -23,7 +27,7 @@ int sa_bbuffer_init(sa_bbuffer_t *b, unsigned nchannels, size_t sample_size) {
         b->data = NULL;
         return SA_ERROR_OOM;
     }
-        
+
     return SA_SUCCESS;
 }
 
@@ -34,7 +38,7 @@ void sa_bbuffer_done(sa_bbuffer_t *b) {
     if (b->data) {
         for (i = 0; i < b->nchannels; i++)
             sa_free(b->data[i]);
-        
+
         sa_free(b->data);
     }
 
@@ -50,7 +54,7 @@ void* sa_bbuffer_get(sa_bbuffer_t *b, unsigned channel, size_t size, int interle
     sa_assert(size > 0);
 
     if (interleave) {
-        
+
         if (!b->data[0] || size * b->nchannels > b->size[0]) {
             sa_free(b->data[0]);
             b->size[0] = size * b->nchannels;
@@ -60,7 +64,7 @@ void* sa_bbuffer_get(sa_bbuffer_t *b, unsigned channel, size_t size, int interle
         }
 
         return (uint8_t*) b->data[0] + (b->sample_size * channel);
-        
+
     } else {
 
         if (!b->data[channel] || size > b->size[channel]) {
diff --git a/src/byteswap.c b/src/bswap.c
index 8ae0b7a..501f98a 100644
--- a/src/byteswap.c
+++ b/src/bswap.c
@@ -1,7 +1,15 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_BYTESWAP_H
+#include <byteswap.h>
+#endif
+
 #include <inttypes.h>
 
 #include "macro.h"
-#include "byteswap.h"
+#include "bswap.h"
 
 static void byteswap16(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) {
     uint16_t *dst = _dst;
@@ -9,7 +17,13 @@ static void byteswap16(void *_dst, size_t dstr, const void *_src, size_t sstr, s
     unsigned n = bytes / sizeof(uint16_t);
 
     for (; n > 0; n--) {
+
+#ifdef HAVE_BYTESWAP_H
+        *dst = bswap_16(*src);
+#else
         *dst = (*src >> 8) | (*src << 8);
+#endif
+
         src += sstr / sizeof(uint16_t);
         dst += dstr / sizeof(uint16_t);
     }
@@ -19,11 +33,11 @@ static void byteswap24(void *_dst, size_t dstr, const void *_src, size_t sstr, s
     uint8_t *dst = _dst;
     const uint8_t *src = _src;
     unsigned n = bytes / (sizeof(uint8_t)*3);
-    
+
     for (; n > 0; n--) {
         dst[0] = src[2];
         dst[2] = src[0];
-        
+
         src += sstr / (sizeof(uint8_t)*3);
         dst += dstr / (sizeof(uint8_t)*3);
     }
@@ -33,16 +47,20 @@ static void byteswap32(void *_dst, size_t dstr, const void *_src, size_t sstr, s
     uint32_t *dst = _dst;
     const uint32_t *src = _src;
     unsigned n = bytes / sizeof(uint32_t);
-    
+
     for (; n > 0; n--) {
+#ifdef HAVE_BYTESWAP_H
+        *dst = bswap_32(*src);
+#else
         *dst = (*src << 24) | ((*src & 0xFF00) << 8) | ((*src >> 8) & 0xFF00) | (*src >> 24);
+#endif
         src += sstr / sizeof(uint32_t);
         dst += dstr / sizeof(uint32_t);
     }
 }
 
 sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f) {
-    
+
     static const sa_byteswap_func_t funcs[_SA_PCM_FORMAT_MAX] = {
         [SA_PCM_FORMAT_S16_RE] = byteswap16,
         [SA_PCM_FORMAT_S24_RE] = byteswap24,
@@ -50,8 +68,7 @@ sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f) {
         [SA_PCM_FORMAT_FLOAT32_BE] = byteswap32,
     };
 
-    sa_assert(f < _SA_PCM_FORMAT_MAX); 
+    sa_assert(f < _SA_PCM_FORMAT_MAX);
 
     return funcs[f];
 }
-
diff --git a/src/byteswap.h b/src/bswap.h
index 4116677..4eeb24f 100644
--- a/src/byteswap.h
+++ b/src/bswap.h
@@ -1,5 +1,5 @@
-#ifndef foosydneyhbyteswaphfoo
-#define foosydneyhbyteswaphfoo
+#ifndef foosydneybswaphfoo
+#define foosydneybswaphfoo
 
 #include <sys/types.h>
 
diff --git a/src/bufferq.c b/src/bufferq.c
index 1965dda..bafcaa1 100644
--- a/src/bufferq.c
+++ b/src/bufferq.c
@@ -1,10 +1,14 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <string.h>
 
 #include "malloc.h"
 #include "macro.h"
 #include "bufferq.h"
 
-#define SA_BUFFERQ_ITEM_CONCAT_DATA(x) ((void*) (uint8_t*) (x) + SA_ALIGN(sizeof(sa_bufferq_item_t)))
+#define SA_BUFFERQ_ITEM_CONCAT_DATA(x) ((void*) ((uint8_t*) (x) + SA_ALIGN(sizeof(sa_bufferq_item_t))))
 
 int sa_bufferq_init(sa_bufferq_t *q, unsigned nchannels, size_t sample_size) {
     sa_assert(q);
@@ -23,7 +27,7 @@ int sa_bufferq_init(sa_bufferq_t *q, unsigned nchannels, size_t sample_size) {
         q->items = NULL;
         return SA_ERROR_OOM;
     }
-    
+
     return SA_SUCCESS;
 }
 
@@ -33,7 +37,7 @@ void sa_bufferq_done(sa_bufferq_t *q) {
 
     for (u = 0; u < q->nchannels; u++) {
         sa_bufferq_item_t *i;
-        
+
         while ((i = q->items[u])) {
             SA_LLIST_REMOVE(sa_bufferq_item_t, bufferq, q->items[u], i);
             sa_free(i);
@@ -62,7 +66,7 @@ static sa_bufferq_item_t* bufferq_item_new(const void *d, int64_t idx, size_t si
 
         if (!(i = sa_new(sa_bufferq_item_t, 1)))
             return NULL;
-        
+
         i->data = (void*) d;
     }
 
@@ -77,7 +81,7 @@ static sa_bufferq_item_t* bufferq_item_new(const void *d, int64_t idx, size_t si
 static sa_bufferq_item_t* bufferq_item_make_writable(sa_bufferq_item_t *i) {
     void *d;
     sa_assert(i);
-    
+
     if (i->type == SA_BUFFERQ_ITEM_CONCATENATED || i->type == SA_BUFFERQ_ITEM_DYNAMIC)
         return i;
 
@@ -91,7 +95,7 @@ static sa_bufferq_item_t* bufferq_item_make_writable(sa_bufferq_item_t *i) {
 
 static void bufferq_item_free(sa_bufferq_item_t *i) {
     sa_assert(i);
-    
+
     if (i->type == SA_BUFFERQ_ITEM_DYNAMIC)
         sa_free(i->data);
     sa_free(i);
@@ -100,7 +104,7 @@ static void bufferq_item_free(sa_bufferq_item_t *i) {
 int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence, sa_bufferq_item_type_t type) {
     int64_t idx;
     sa_bufferq_item_t *i, *j, *n;
-    
+
     sa_assert(q);
 
     switch (whence) {
@@ -122,11 +126,11 @@ int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t
 
         if (l > nbytes)
             l = nbytes;
-        
+
         idx += l;
-        data += l;
+        data = (const uint8_t*) data + l;
         nbytes -= l;
-        
+
     }
 
     /* Allocate the new entry */
@@ -142,7 +146,7 @@ int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t
         i->size = idx - i->idx;
         i = i->bufferq_next;
     }
-    
+
     /* Insert the entry */
     if (i)
         SA_LLIST_INSERT_BEFORE(sa_bufferq_item_t, bufferq, q->items[channel], i, j);
@@ -154,14 +158,14 @@ int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t
 
         q->last[channel] = j;
     }
-    
+
     /* Now kick all the entries that overlap entirely with our new entry */
     for (i = j->bufferq_next; i && i->idx + i->size < j->idx + j->size ; i = n) {
         n = i->bufferq_next;
         SA_LLIST_REMOVE(sa_bufferq_item_t, bufferq, q->items[channel], i);
         bufferq_item_free(i);
     }
-        
+
     q->write_index = idx + nbytes;
 
     if (q->write_index > q->end_index)
@@ -176,7 +180,7 @@ void sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) {
     sa_assert(q);
 
     *bytes = 0;
-    
+
     for (u = 0; u < q->nchannels; u++) {
 
         if (q->items[u]) {
@@ -198,14 +202,14 @@ void sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) {
                 i[u] = (uint8_t*) q->items[u]->data + q->read_index - q->items[u]->idx;
 
                 l = q->items[u]->size - (q->read_index - q->items[u]->idx);
-                
+
                 if (first) {
                     *bytes = l;
                     first = 0;
                 } else
                     *bytes = l < *bytes ? l : *bytes;
             }
-            
+
         } else
             i[u] = NULL;
     }
@@ -214,16 +218,16 @@ void sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) {
 
 void sa_bufferq_drop(sa_bufferq_t *q, int64_t bytes) {
     unsigned u;
-    
+
     sa_assert(q);
 
     q->read_index += bytes;
 
     for (u = 0; u < q->nchannels; u++) {
         sa_bufferq_item_t *i;
-        
+
         i = q->items[u];
-        
+
         while (i && q->read_index >= i->idx + i->size) {
             sa_bufferq_item_t *n = i->bufferq_next;
 
@@ -258,7 +262,7 @@ int sa_bufferq_realloc(sa_bufferq_t *q) {
                  * return without doing anything, hence let's at least
                  * drop the reference to the statically allocated
                  * data */
-                
+
                 i->size = 0;
                 i->data = SA_BUFFERQ_ITEM_CONCAT_DATA(i);
                 i->type = SA_BUFFERQ_ITEM_CONCATENATED;
diff --git a/src/common.c b/src/common.c
index 5a81d02..c8017e8 100644
--- a/src/common.c
+++ b/src/common.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <string.h>
 #include <errno.h>
 #include <liboil/liboil.h>
@@ -21,11 +25,11 @@ static sa_stream_t *stream_alloc(void) {
     /* All fields a carefully chosen in a way that initializing them
      * NUL bytes is sufficient */
 
-    if (!(d->mutex = sa_mutex_new(0))) {
+    if (!(d->mutex = sa_mutex_new(FALSE, FALSE))) {
         sa_free(d);
         return NULL;
     }
-    
+
     return d;
 }
 
@@ -34,7 +38,7 @@ int sa_stream_create_opaque(
         const char *client_name,
         sa_mode_t mode,
         const char *codec) {
-    
+
     int error;
 
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
@@ -74,7 +78,7 @@ int sa_stream_create_pcm(
 
     int ret;
     size_t lwm;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(mode == SA_MODE_RDONLY || mode == SA_MODE_WRONLY || mode == SA_MODE_RDWR, SA_ERROR_INVALID);
     sa_return_val_if_fail(format < _SA_PCM_FORMAT_MAX, SA_ERROR_INVALID);
@@ -100,12 +104,12 @@ int sa_stream_create_pcm(
 
     if ((ret = sa_stream_change_rate(*s, rate)))
         goto fail;
-    
+
     lwm = ((*s)->pcm_frame_size * (*s)->pcm_attrs.rate) / 20; /* 50 ms */
 
     if (lwm <= 0)
         lwm = (*s)->pcm_frame_size * (*s)->pcm_attrs.rate; /* 1s */
-            
+
     if (mode & SA_MODE_RDONLY) {
 
         if ((ret = sa_stream_set_read_lower_watermark(*s, lwm)))
@@ -113,7 +117,7 @@ int sa_stream_create_pcm(
 
         if ((ret = sa_stream_set_read_upper_watermark(*s, lwm*2)))
             goto fail;
-    } 
+    }
 
     if (mode & SA_MODE_WRONLY) {
 
@@ -123,24 +127,24 @@ int sa_stream_create_pcm(
         if ((ret = sa_stream_set_write_upper_watermark(*s, lwm*2)))
             goto fail;
     }
-    
+
     oil_init();
 
     if (client_name)
         if ((ret = sa_stream_change_meta_data(*s, SA_META_CLIENT_NAME, client_name, strlen(client_name))) < 0)
             goto fail;
-    
+
     return SA_SUCCESS;
 
 fail:
-    
+
     sa_stream_destroy(*s);
     return ret;
 }
 
 int sa_stream_open(sa_stream_t *s) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
     sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE);
@@ -161,7 +165,7 @@ int sa_stream_open(sa_stream_t *s) {
 int sa_stream_destroy(sa_stream_t *s) {
     int ret;
     unsigned u;
-    
+
     sa_return_val_if_fail_mutex(s->mutex, s, SA_ERROR_INVALID);
 
     ret = driver_destroy(s);
@@ -241,7 +245,7 @@ int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size) {
 int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map, unsigned n) {
     const sa_channel_t *c;
     sa_channel_t *m;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(map, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -254,7 +258,7 @@ int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map, unsigned
             sa_mutex_unlock(s->mutex);
             return SA_ERROR_INVALID;
         }
-    
+
     if (!(m = sa_memdup(map, sizeof(sa_channel_t) * s->pcm_attrs.nchannels))) {
         sa_mutex_unlock(s->mutex);
         return SA_ERROR_OOM;
@@ -305,7 +309,7 @@ int sa_stream_set_dynamic_rate(sa_stream_t *s, int enable) {
 
 int sa_stream_set_driver(sa_stream_t *s, const char *driver) {
     char *d;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(driver, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -315,17 +319,17 @@ int sa_stream_set_driver(sa_stream_t *s, const char *driver) {
         sa_mutex_unlock(s->mutex);
         return SA_ERROR_OOM;
     }
-    
+
     sa_free(s->driver);
     s->driver = d;
-    
+
     sa_mutex_unlock(s->mutex);
     return SA_SUCCESS;
 }
 
 int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t callback) {
     int r;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(callback, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -336,14 +340,14 @@ int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t callback) {
 
     if (r == SA_SUCCESS)
         s->callback = callback;
-    
+
     sa_mutex_unlock(s->mutex);
     return r;
 }
 
 int sa_stream_stop_thread(sa_stream_t *s) {
     int r;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
     sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
@@ -353,7 +357,7 @@ int sa_stream_stop_thread(sa_stream_t *s) {
 
     if (r == SA_SUCCESS)
         s->callback = NULL;
-    
+
     sa_mutex_unlock(s->mutex);
     return r;
 }
@@ -361,7 +365,7 @@ int sa_stream_stop_thread(sa_stream_t *s) {
 int sa_stream_change_device(sa_stream_t *s, const char *device_name) {
     char *d;
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(device_name, SA_ERROR_INVALID);
 
@@ -379,7 +383,7 @@ int sa_stream_change_device(sa_stream_t *s, const char *device_name) {
         sa_free(d);
 
     sa_mutex_unlock(s->mutex);
-    
+
     return ret;
 }
 
@@ -404,11 +408,11 @@ int sa_stream_change_read_volume(sa_stream_t *s, const int32_t vol[], unsigned n
             sa_mutex_unlock(s->mutex);
             return SA_ERROR_OOM;
         }
-        
+
         for (i = 0; i < s->pcm_attrs.nchannels; i++)
             v[i] = vol[0];
     }
-    
+
     ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_read_volume(s, v);
 
     if (ret == SA_SUCCESS) {
@@ -442,7 +446,7 @@ int sa_stream_change_write_volume(sa_stream_t *s, const int32_t vol[], unsigned
             sa_mutex_unlock(s->mutex);
             return SA_ERROR_OOM;
         }
-        
+
         for (i = 0; i < s->pcm_attrs.nchannels; i++)
             v[i] = vol[0];
     }
@@ -461,7 +465,7 @@ int sa_stream_change_write_volume(sa_stream_t *s, const int32_t vol[], unsigned
 
 int sa_stream_change_rate(sa_stream_t *s, unsigned rate) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(rate > 0, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -480,9 +484,9 @@ int sa_stream_change_rate(sa_stream_t *s, unsigned rate) {
 int sa_stream_change_user_data(sa_stream_t *s, const void *value) {
     sa_return_val_if_fail(s->mutex, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
-    
+
     s->user_data = (void*) value;
-    
+
     sa_mutex_unlock(s->mutex);
     return SA_SUCCESS;
 }
@@ -597,7 +601,7 @@ int sa_stream_get_mode(sa_stream_t *s, sa_mode_t *access_mode) {
 
 int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size) {
     size_t n;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size && (*size == 0 || codec), SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -612,7 +616,7 @@ int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size) {
     if (codec)
         strcpy(codec, s->codec);
     *size = n;
-                
+
     sa_mutex_unlock(s->mutex);
     return SA_SUCCESS;
 }
@@ -719,7 +723,7 @@ int sa_stream_get_dynamic_rate(sa_stream_t *s, int *enabled) {
 
 int sa_stream_get_driver(sa_stream_t *s, char *driver, size_t *size) {
     size_t n;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size && (*size == 0 || driver), SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -734,7 +738,7 @@ int sa_stream_get_driver(sa_stream_t *s, char *driver, size_t *size) {
     if (driver)
         strcpy(driver, s->driver);
     *size = n;
-                
+
     sa_mutex_unlock(s->mutex);
     return SA_SUCCESS;
 }
@@ -885,7 +889,7 @@ int sa_stream_get_event_notify(sa_stream_t *s, sa_notify_t *notify) {
 
 int sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(pos, SA_ERROR_INVALID);
     sa_return_val_if_fail(position < _SA_POSITION_MAX, SA_ERROR_INVALID);
@@ -930,7 +934,7 @@ int sa_stream_read_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbyte
     sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
     ret = driver_read_ni(s, channel, data, nbytes);
-    
+
     sa_mutex_unlock(s->mutex);
     return ret;
 }
@@ -945,7 +949,7 @@ int sa_stream_write_ni(sa_stream_t *s, unsigned channel, const void *data, size_
 
 int sa_stream_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(data, SA_ERROR_INVALID);
     sa_return_val_if_fail(nbytes > 0, SA_ERROR_INVALID);
@@ -1002,7 +1006,7 @@ int sa_stream_get_read_size(sa_stream_t *s, size_t *size) {
 
 int sa_stream_get_write_size(sa_stream_t *s, size_t *size) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -1017,7 +1021,7 @@ int sa_stream_get_write_size(sa_stream_t *s, size_t *size) {
 
 int sa_stream_resume(sa_stream_t *s) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
     sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
@@ -1043,7 +1047,7 @@ int sa_stream_pause(sa_stream_t *s) {
 
 int sa_stream_drain(sa_stream_t *s) {
     int ret;
-    
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
     sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
@@ -1056,7 +1060,7 @@ int sa_stream_drain(sa_stream_t *s) {
 }
 
 size_t sa_get_pcm_sample_size(sa_pcm_format_t f) {
-    
+
     switch (f) {
         case SA_PCM_FORMAT_U8:
         case SA_PCM_FORMAT_ULAW:
@@ -1069,7 +1073,7 @@ size_t sa_get_pcm_sample_size(sa_pcm_format_t f) {
         case SA_PCM_FORMAT_S24_LE:
         case SA_PCM_FORMAT_S24_BE:
             return 3;
-            
+
         case SA_PCM_FORMAT_S32_LE:
         case SA_PCM_FORMAT_S32_BE:
         case SA_PCM_FORMAT_FLOAT32_LE:
@@ -1089,13 +1093,13 @@ static int meta_check_png(const void *data, size_t size) {
 
     if (size < sizeof(png_signature))
         return 0;
-    
+
     return memcmp(data, png_signature, 8) == 0;
 }
 
 static int meta_check_utf8(const void *data, size_t size) {
     int32_t idx;
-    
+
     oil_utf8_validate(&idx, data, size);
 
     return (size_t) idx == size;
@@ -1110,14 +1114,14 @@ static int meta_check_pid(const void *data, size_t size) {
 
     if (memchr(data, 0, size))
         return 0;
-    
+
     if (!(t = sa_strndup(data, size)))
         return 0;
-    
+
     errno = 0;
     pid = strtol(t, NULL, 10);
     sa_free(t);
-    
+
     if (errno != 0)
         return 0;
 
@@ -1135,7 +1139,7 @@ static int meta_check_icon_name(const void *data, size_t size) {
 
     if (memchr(data, 0, size))
         return 0;
-    
+
     if (size == 1 && t[0] == '.')
         return 0;
 
@@ -1144,7 +1148,7 @@ static int meta_check_icon_name(const void *data, size_t size) {
 
     if (memchr(t, '/', size))
         return 0;
-    
+
     return 1;
 }
 
@@ -1154,7 +1158,7 @@ static int meta_check_word(const void *data, size_t size) {
     for (; size > 0; size --, t++)
         if (*t <= 32 || *t >= 127)
             return 0;
-    
+
     return 1;
 }
 
@@ -1175,7 +1179,7 @@ int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *dat
         meta_check_word, /* FIXME */
         meta_check_word, /* FIXME */
     };
-        
+
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(name, SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
@@ -1205,7 +1209,7 @@ int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *dat
         s->meta_data_size[m->idx] = size;
     } else
         sa_free(d);
-    
+
     sa_mutex_unlock(s->mutex);
     return ret;
 }
@@ -1217,7 +1221,7 @@ int sa_stream_get_meta_data(sa_stream_t *s, const char *name, void *data, size_t
     sa_return_val_if_fail(name, SA_ERROR_INVALID);
     sa_return_val_if_fail(size && (*size == 0 || data), SA_ERROR_INVALID);
     sa_mutex_lock(s->mutex);
-    
+
     if (!(m = sa_lookup_meta_name(name, strlen(name)))) {
         sa_mutex_unlock(s->mutex);
         return SA_ERROR_NO_META;
diff --git a/src/common.h b/src/common.h
index b5f316c..dbf03b0 100644
--- a/src/common.h
+++ b/src/common.h
@@ -1,5 +1,5 @@
-#ifndef foocommonh
-#define foocommonh
+#ifndef foosydneycommonh
+#define foosydneycommonh
 
 #include "sydney.h"
 #include "mutex.h"
@@ -30,12 +30,12 @@ struct sa_stream {
     sa_xrun_mode_t xrun_mode;
     int ni_enabled;
     int dynamic_rate_enabled;
-    
+
     sa_event_callback_t event_callback;
 
     char *device;
     char *driver;
-    
+
     int32_t *read_volume;
     int32_t *write_volume;
 
@@ -57,7 +57,7 @@ struct sa_stream {
     void *meta_data[_META_NAMES_MAX];
     size_t meta_data_size[_META_NAMES_MAX];
 
-    sa_mutex_t *mutex;
+    sa_mutex *mutex;
 
     sa_event_callback_t callback;
 };
diff --git a/src/continued-fraction.c b/src/continued-fraction.c
index 6cbf8a5..5aa7a4f 100644
--- a/src/continued-fraction.c
+++ b/src/continued-fraction.c
@@ -1,6 +1,9 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 /*
  * Stolen from gnumeric
- * 
+ *
  * Original code from Morten Welinder <terra@gnome.org>
  */
 
diff --git a/src/converter.c b/src/converter.c
index 3b146ce..c5283f6 100644
--- a/src/converter.c
+++ b/src/converter.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <math.h>
 #include <string.h>
 
@@ -9,7 +13,7 @@
 #include "common.h"
 #include "format.h"
 #include "volscale.h"
-#include "byteswap.h"
+#include "bswap.h"
 #include "zero.h"
 #include "add.h"
 #include "bbuffer.h"
@@ -36,21 +40,21 @@ static int native_pcm_format_resample(sa_pcm_format_t f) {
 }
 
 static sa_pcm_format_t byteswap_fix(sa_pcm_format_t f) {
-    
+
     switch (f) {
         case SA_PCM_FORMAT_U8:
         case SA_PCM_FORMAT_ULAW:
         case SA_PCM_FORMAT_ALAW:
             return f;
-            
+
         case SA_PCM_FORMAT_S16_NE:
         case SA_PCM_FORMAT_S16_RE:
             return SA_PCM_FORMAT_S16_NE;
-                
+
         case SA_PCM_FORMAT_S24_NE:
         case SA_PCM_FORMAT_S24_RE:
             return SA_PCM_FORMAT_S24_NE;
-            
+
         case SA_PCM_FORMAT_S32_NE:
         case SA_PCM_FORMAT_S32_RE:
             return SA_PCM_FORMAT_S32_NE;
@@ -67,12 +71,12 @@ static sa_pcm_format_t byteswap_fix(sa_pcm_format_t f) {
 }
 
 static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
-    
+
     switch (a) {
         case SA_PCM_FORMAT_U8:
         case SA_PCM_FORMAT_ULAW:
         case SA_PCM_FORMAT_ALAW:
-            
+
             switch (b) {
                 case SA_PCM_FORMAT_U8:
                     return SA_PCM_FORMAT_U8;
@@ -88,7 +92,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
                 case SA_PCM_FORMAT_S32_LE:
                 case SA_PCM_FORMAT_S32_BE:
                     return SA_PCM_FORMAT_S32_NE;
-                    
+
                 case SA_PCM_FORMAT_FLOAT32_LE:
                 case SA_PCM_FORMAT_FLOAT32_BE:
                     return SA_PCM_FORMAT_FLOAT32_NE;
@@ -98,7 +102,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
             }
 
             break;
-            
+
         case SA_PCM_FORMAT_S16_LE:
         case SA_PCM_FORMAT_S16_BE:
 
@@ -115,7 +119,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
                 case SA_PCM_FORMAT_S32_LE:
                 case SA_PCM_FORMAT_S32_BE:
                     return SA_PCM_FORMAT_S32_NE;
-                    
+
                 case SA_PCM_FORMAT_FLOAT32_LE:
                 case SA_PCM_FORMAT_FLOAT32_BE:
                     return SA_PCM_FORMAT_FLOAT32_NE;
@@ -124,7 +128,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
                     ;
             }
             break;
-            
+
         case SA_PCM_FORMAT_S24_LE:
         case SA_PCM_FORMAT_S24_BE:
         case SA_PCM_FORMAT_S32_LE:
@@ -141,7 +145,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
                 case SA_PCM_FORMAT_S32_LE:
                 case SA_PCM_FORMAT_S32_BE:
                     return SA_PCM_FORMAT_S32_NE;
-                    
+
                 case SA_PCM_FORMAT_FLOAT32_LE:
                 case SA_PCM_FORMAT_FLOAT32_BE:
                     return SA_PCM_FORMAT_FLOAT32_NE;
@@ -150,7 +154,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) {
                     ;
             }
             break;
-            
+
         case SA_PCM_FORMAT_FLOAT32_LE:
         case SA_PCM_FORMAT_FLOAT32_BE:
             return SA_PCM_FORMAT_FLOAT32_NE;
@@ -169,12 +173,12 @@ static sa_pcm_format_t fix_work_format_for_resample(sa_pcm_format_t f) {
         case SA_PCM_FORMAT_S16_NE:
             return  SA_PCM_FORMAT_S16_NE;
             break;
-            
+
         case SA_PCM_FORMAT_S32_NE:
         case SA_PCM_FORMAT_FLOAT32_NE:
             return SA_PCM_FORMAT_FLOAT32_NE;
             break;
-            
+
         default:
             ;
     }
@@ -190,7 +194,7 @@ int sa_converter_init(
 
     unsigned u, t;
     int resample_required;
-    
+
     sa_assert(c);
     sa_assert(from);
     sa_assert(to);
@@ -211,26 +215,26 @@ int sa_converter_init(
 
     for (u = 0; u < to->nchannels; u++) {
         unsigned k = 0;
-        
+
         for (t = 0; t < from->nchannels; t++) {
 
             if (from->channel_map[u] == to->channel_map[t]) {
                 if (u != t)
                     c->remap_required = 1;
-                
+
                 c->channel_map_table[u * (from->nchannels+1) + k++] += t;
             }
         }
 
         if (k > 1)
             c->sum_required = 1;
-        
+
         c->channel_map_table[k] = (unsigned) -1;
     }
 
     if (c->from_nchannels != c->to_nchannels)
-        c->remap_required = 1;    
-    
+        c->remap_required = 1;
+
     resample_required =
         from->rate != to->rate ||
         dynamic_rate_enabled;
@@ -238,7 +242,7 @@ int sa_converter_init(
     c->work_pcm_format = get_work_format(from->format, to->format);
     if (resample_required)
         c->work_pcm_format = fix_work_format_for_resample(c->work_pcm_format);
-    
+
     sa_assert(native_pcm_format_process(c->work_pcm_format));
     sa_assert(!resample_required || native_pcm_format_resample(c->work_pcm_format));
 
@@ -253,31 +257,31 @@ int sa_converter_init(
         c->pre_format_func = sa_get_format_func(byteswap_fix(from->format), c->work_pcm_format);
         sa_assert(c->pre_format_func);
     }
-        
+
     c->volscale_func = sa_get_volscale_func(c->work_pcm_format);
     sa_assert(c->volscale_func);
-    
+
     c->zero_func = sa_get_zero_func(c->work_pcm_format);
     sa_assert(c->zero_func);
-    
+
     c->add_func = sa_get_add_func(c->work_pcm_format);
     sa_assert(c->add_func);
 
     if (resample_required) {
         c->resample_func = sa_get_resample_func(c->work_pcm_format);
         sa_assert(c->resample_func);
-    } 
+    }
 
     if (c->work_pcm_format != byteswap_fix(to->format)) {
         c->post_format_func = sa_get_format_func(c->work_pcm_format, byteswap_fix(to->format));
         sa_assert(c->post_format_func);
     }
-    
+
     c->post_byteswap_func = sa_get_byteswap_func(to->format);
 
     c->interleave_func = sa_get_interleave_func(to->format);
     sa_assert(c->interleave_func);
-    
+
     /* Initialize resampler */
 
     if (resample_required) {
@@ -309,7 +313,7 @@ int sa_converter_init(
     c->no_volume = 1;
 
     /* Initialize bounce buffers */
-    
+
     if (sa_bbuffer_init(&c->bb_pre_byteswap, c->from_nchannels, c->from_sample_size) < 0)
         goto fail;
     if (sa_bbuffer_init(&c->bb_pre_format, c->from_nchannels, c->work_sample_size) < 0)
@@ -328,7 +332,7 @@ int sa_converter_init(
         goto fail;
     if (sa_bbuffer_init(&c->bb_tmp, 1, 1) < 0)
         goto fail;
-    
+
     return 0;
 
 fail:
@@ -341,7 +345,7 @@ void sa_converter_done(sa_converter_t *c) {
     sa_assert(c);
 
     sa_free(c->channel_map_table);
-    
+
     sa_free(c->from_process_data);
     sa_free(c->to_process_data);
     sa_free(c->from_stride);
@@ -369,7 +373,7 @@ void sa_converter_done(sa_converter_t *c) {
 
 void* sa_converter_get_zero_buffer(sa_converter_t *c, size_t size) {
     void *b;
-    
+
     sa_assert(c);
     sa_assert(size > 0);
 
@@ -382,7 +386,7 @@ void* sa_converter_get_zero_buffer(sa_converter_t *c, size_t size) {
         return NULL;
 
     c->zero_func(b, c->work_sample_size, size);
-    return c->zero_func;
+    return c->zero_buffer;
 }
 
 int sa_converter_go(
@@ -390,13 +394,13 @@ int sa_converter_go(
         const void *const src[], const size_t sstr[], int sinterleave,
         void **dst[], size_t *dstr[], int dinterleave,
         size_t *size) {
-    
+
     size_t* stride;
     void** process_data;
     int is_bounce;
     int interleave;
     unsigned i;
-    
+
     sa_assert(c);
 
     is_bounce = 0;
@@ -404,7 +408,7 @@ int sa_converter_go(
     process_data = (void**) src;
     interleave = !!sinterleave;
     dinterleave = !!dinterleave;
-    
+
     if (c->no_volume &&
         !c->remap_required &&
         !c->resample_func &&
@@ -414,18 +418,18 @@ int sa_converter_go(
 
         goto do_interleave;
     }
-    
+
     if (c->pre_byteswap_func) {
         size_t k;
-        
+
         k = dinterleave ? c->from_sample_size*c->from_nchannels : c->from_sample_size;
-        
+
         for (i = 0; i < c->from_nchannels; i++) {
             void *b;
 
             if (!(b = sa_bbuffer_get(&c->bb_pre_byteswap, i, *size, dinterleave)))
                 return SA_ERROR_OOM;
-            
+
             c->pre_byteswap_func(b, k, process_data[i], stride[i], *size);
             c->from_process_data[i] = b;
             c->from_stride[i] = k;
@@ -436,7 +440,7 @@ int sa_converter_go(
         interleave = dinterleave;
         is_bounce = 1;
     }
-    
+
     if (c->pre_format_func) {
 
         if (is_bounce && c->from_sample_size == c->to_sample_size) {
@@ -446,24 +450,24 @@ int sa_converter_go(
 
             for (i = 0; i < c->from_nchannels; i++)
                 c->pre_format_func(&c->bb_tmp, process_data[i], stride[i], process_data[i], stride[i], *size);
-            
+
         } else {
             size_t k, new_size;
-        
+
             new_size = *size / c->from_sample_size * c->work_sample_size;
             k = dinterleave ? c->work_sample_size*c->from_nchannels : c->work_sample_size;
-            
+
             for (i = 0; i < c->from_nchannels; i++) {
                 void *b;
-                
+
                 if (!(b = sa_bbuffer_get(&c->bb_pre_format, i, new_size, dinterleave)))
                     return SA_ERROR_OOM;
-                
+
                 c->pre_format_func(&c->bb_tmp, b, k, process_data[i], stride[i], *size);
                 c->from_process_data[i] = b;
                 c->from_stride[i] = k;
             }
-            
+
             process_data = c->from_process_data;
             stride = c->from_stride;
             *size = new_size;
@@ -480,7 +484,7 @@ int sa_converter_go(
 
             /* The data to process is already in a bounce buffer, we
              * can do this in-place */
-            
+
             for (i = 0; i < c->from_nchannels; i++);
                 c->volscale_func(process_data[i], stride[i], process_data[i], stride[i], c->volume_factor[i], c->volume_divisor[i], *size);
 
@@ -491,15 +495,15 @@ int sa_converter_go(
 
             for (i = 0; i < c->from_nchannels; i++) {
                 void *b;
-                
+
                 if (!(b = sa_bbuffer_get(&c->bb_volscale, i, *size, dinterleave)))
                     return SA_ERROR_OOM;
-                
+
                 c->volscale_func(b, k, process_data[i], stride[i], c->volume_factor[i], c->volume_divisor[i], *size);
                 c->from_process_data[i] = b;
                 c->from_stride[i] = k;
             }
-            
+
             process_data = c->from_process_data;
             stride = c->from_stride;
             interleave = dinterleave;
@@ -516,7 +520,7 @@ int sa_converter_go(
         for (i = 0; i < c->to_nchannels; i++) {
             void *b;
             int *p = &c->channel_map_table[i * (c->from_nchannels+1)];
-            
+
             if (p[0] == -1) {
                 /* We have to write silence to this channel */
 
@@ -536,8 +540,8 @@ int sa_converter_go(
                 need_proper_interleave = 1;
             } else {
                 int j;
-                
-                /* We have to mix two or more channels */ 
+
+                /* We have to mix two or more channels */
 
                 if (!(b = sa_bbuffer_get(&c->bb_remap, i, *size, dinterleave)))
                     return SA_ERROR_OOM;
@@ -546,7 +550,7 @@ int sa_converter_go(
 
                 for (j = 2; p[j] != -1; j++)
                     c->add_func(b, k, b, k, process_data[p[j]], stride[p[j]], *size);
-                
+
                 c->to_process_data[i] = b;
                 c->to_stride[i] = k;
             }
@@ -565,7 +569,7 @@ int sa_converter_go(
         k = dinterleave ? c->work_sample_size*c->to_nchannels : c->work_sample_size;
 
         new_size = (size_t) (((((uint64_t) *size+c->work_sample_size-1)/c->work_sample_size)*c->to_rate)/c->from_rate+1)*c->work_sample_size; /* FIXME */
-        
+
         for (i = 0; i < c->to_nchannels; i++) {
             void *b;
 
@@ -590,7 +594,7 @@ int sa_converter_go(
 
             /* The data to process is already in a bounce buffer, we
              * can do this in-place */
-            
+
             for (i = 0; i < c->to_nchannels; i++)
                 c->post_format_func(&c->bb_tmp, process_data[i], stride[i], process_data[i], stride[i], *size);
 
@@ -599,18 +603,18 @@ int sa_converter_go(
 
             k = dinterleave ? c->to_sample_size*c->to_nchannels : c->to_sample_size;
             new_size = *size / c->work_sample_size * c->to_sample_size;
-        
+
             for (i = 0; i < c->to_nchannels; i++) {
                 void *b;
-                
+
                 if (!(b = sa_bbuffer_get(&c->bb_post_format, i, new_size, dinterleave)))
                     return SA_ERROR_OOM;
-                
+
                 c->post_format_func(&c->bb_tmp, b, k, process_data[i], stride[i], *size);
                 c->to_process_data[i] = b;
                 c->to_stride[i] = k;
             }
-            
+
             process_data = c->to_process_data;
             stride = c->to_stride;
             *size = new_size;
@@ -618,14 +622,14 @@ int sa_converter_go(
             is_bounce = 1;
         }
     }
-    
+
     if (c->post_byteswap_func) {
 
         if (is_bounce) {
 
             /* The data to process is already in a bounce buffer, we
              * can do this in-place */
-            
+
             for (i = 0; i < c->to_nchannels; i++)
                 c->post_byteswap_func(process_data[i], stride[i], process_data[i], stride[i], *size);
 
@@ -633,15 +637,15 @@ int sa_converter_go(
             size_t k;
 
             k = dinterleave ? c->to_sample_size*c->to_nchannels : c->to_sample_size;
-        
+
             for (i = 0; i < c->to_nchannels; i++) {
                 void *b;
-                
+
                 if (!(b = sa_bbuffer_get(&c->bb_post_byteswap, i, *size, dinterleave)))
                     return SA_ERROR_OOM;
-                
+
                 c->post_byteswap_func(b, k, process_data[i], stride[i], *size);
-                
+
                 c->to_process_data[i] = b;
                 c->to_stride[i] = k;
             }
@@ -654,7 +658,7 @@ int sa_converter_go(
     }
 
 do_interleave:
-    
+
     if (interleave != dinterleave) {
         size_t k;
 
@@ -662,16 +666,16 @@ do_interleave:
 
         for (i = 0; i < c->to_nchannels; i++) {
             void *b;
-            
+
             if (!(b = sa_bbuffer_get(&c->bb_interleave, i, *size, dinterleave)))
                 return SA_ERROR_OOM;
-            
+
             c->interleave_func(b, k, process_data[i], stride[i], *size);
-            
+
             c->to_process_data[i] = b;
             c->to_stride[i] = k;
         }
-        
+
         process_data = c->to_process_data;
         stride = c->to_stride;
         interleave = dinterleave;
@@ -687,7 +691,7 @@ do_interleave:
 void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) {
     unsigned i;
     int no_volume = 1;
-    
+
     sa_assert(c);
 
     for (i = 0; i < c->from_nchannels; i++) {
@@ -702,12 +706,12 @@ void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) {
             no_volume = 0;
         } else {
             float f = powf(10.0, (float) vol[i] / 2000);
-            
+
             sa_continued_fraction(f, 0x7FFF, &num, &denom);
-            
+
             if (num != 1 || denom != 1)
                 no_volume = 0;
-            
+
             c->volume_factor[i] = (int32_t) num;
             c->volume_divisor[i] = (int32_t) denom;
         }
@@ -718,7 +722,7 @@ void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) {
 
 int sa_converter_go_interleaved(
         sa_converter_t *c,
-        const void *const data, 
+        const void *const data,
         void **dst[], size_t *dstr[], int dinterleave,
         size_t *size) {
 
diff --git a/src/converter.h b/src/converter.h
index 8112231..30453df 100644
--- a/src/converter.h
+++ b/src/converter.h
@@ -3,7 +3,7 @@
 
 #include "sydney.h"
 #include "volscale.h"
-#include "byteswap.h"
+#include "bswap.h"
 #include "zero.h"
 #include "add.h"
 #include "bbuffer.h"
@@ -21,9 +21,9 @@ struct sa_converter {
 
     int sum_required;
     int remap_required;
-    
+
     sa_pcm_format_t work_pcm_format;
-    
+
     size_t from_sample_size, work_sample_size, to_sample_size;
 
     sa_byteswap_func_t pre_byteswap_func, post_byteswap_func;
@@ -69,7 +69,7 @@ int sa_converter_go(
 
 int sa_converter_go_interleaved(
         sa_converter_t *c,
-        const void *const data, 
+        const void *const data,
         void **dst[], size_t *dstr[], int dinterleave,
         size_t *size);
 
diff --git a/src/driver.h b/src/driver.h
index be5d4b8..15d690e 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -1,5 +1,5 @@
-#ifndef foodriverhfoo
-#define foodriverhfoo
+#ifndef foosydneydriverhfoo
+#define foosydneydriverhfoo
 
 #include "sydney.h"
 
diff --git a/src/format.c b/src/format.c
index f7a8755..adac878 100644
--- a/src/format.c
+++ b/src/format.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <inttypes.h>
 #include <sys/types.h>
 
@@ -11,7 +15,7 @@
 
 static int format_u8_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) {
     int16_t d = -0x80, f = 0x100;
-    
+
     oil_conv_s16_u8(dst, dstr, src, sstr, bytes);
     oil_scalaradd_s16(dst, dstr, dst, dstr, &d, bytes);
     oil_scalarmult_s16(dst, dstr, dst, dstr, &f, bytes);
@@ -21,7 +25,7 @@ static int format_u8_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 
 static int format_u8_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) {
     int32_t d = -0x80, f = 0x1000000;
-    
+
     oil_conv_s16_u8(dst, dstr, src, sstr, bytes);
     oil_scalaradd_s32(dst, dstr, dst, dstr, &d, bytes);
     oil_scalarmult_s32(dst, dstr, dst, dstr, &f, bytes);
@@ -34,7 +38,7 @@ static int format_u8_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 
     oil_conv_f32_u8(dst, dstr, src, sstr, bytes);
     oil_scalaradd_f32(dst, dstr, dst, dstr, &d, bytes);
-    oil_scalarmult_f32(dst, dstr, dst, dstr, &f, bytes);                       
+    oil_scalarmult_f32(dst, dstr, dst, dstr, &f, bytes);
 
     return SA_SUCCESS;
 }
@@ -112,7 +116,7 @@ static int format_s16_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 
     for (; n > 0; n--, d += dstr, s += sstr/sizeof(int16_t))
         *d = (uint8_t) (*s / 0x100 + 0x80);
-    
+
     return SA_SUCCESS;
 }
 
@@ -143,7 +147,7 @@ static int format_s16_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void
     unsigned n = bytes/sizeof(int16_t);
 
     oil_conv_s32_s16(dst, dstr, src, sstr, n);
-    oil_scalarmult_s32(dst, dstr, dst, dstr, &f, n);                       
+    oil_scalarmult_s32(dst, dstr, dst, dstr, &f, n);
 
     return SA_SUCCESS;
 }
@@ -151,9 +155,9 @@ static int format_s16_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 static int format_s16_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) {
     float f = 1.0/0x7ffff;
     unsigned n = bytes/sizeof(int16_t);
-    
+
     oil_conv_f32_s16(dst, dstr, src, sstr, n);
-    oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n);                       
+    oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n);
 
     return SA_SUCCESS;
 }
@@ -173,7 +177,7 @@ static int format_s24_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 #else
 #error "Unknown byte order"
 #endif
-    
+
     return SA_SUCCESS;
 }
 
@@ -190,7 +194,7 @@ static int format_s24_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 #else
 #error "Unknown byte order"
 #endif
-    
+
     return SA_SUCCESS;
 }
 
@@ -203,7 +207,7 @@ static int format_s32_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 
     for (; n > 0; n--, d += dstr, s += sstr/sizeof(int32_t))
         *d = (uint8_t) (*s / 0x1000000 + 0x80);
-    
+
     return SA_SUCCESS;
 }
 
@@ -236,7 +240,7 @@ static int format_s32_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 
     for (; n > 0; n--, d += dstr/sizeof(int16_t), s += sstr/sizeof(int32_t))
         *d = (int16_t) (*s / 0x10000);
-    
+
     return SA_SUCCESS;
 }
 
@@ -247,7 +251,7 @@ static int format_s32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 
     for (; n > 0; n--, d += dstr/3, s += sstr/sizeof(int32_t)) {
         uint32_t j = (uint32_t) (*s) >> 8;
-        
+
 #if defined(SA_LITTLE_ENDIAN)
         d[0] = j & 0xFF;
         d[1] = (j >> 8) & 0xFF;
@@ -260,16 +264,16 @@ static int format_s32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 #error "Unknown byte order"
 #endif
     }
-    
+
     return SA_SUCCESS;
 }
 
 static int format_s32_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) {
     float f = 1.0/0x7fffffff;
     unsigned n = bytes/sizeof(int32_t);
-    
+
     oil_conv_f32_s32(dst, dstr, src, sstr, n);
-    oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n);                       
+    oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n);
 
     return SA_SUCCESS;
 }
@@ -312,7 +316,7 @@ static int format_f32_to_alaw(sa_bbuffer_t *b, void *dst, size_t dstr, const voi
     uint8_t *d = dst;
     const float *s = src;
     unsigned n = bytes/sizeof(float);
-    
+
     for (; n > 0; n --, d += dstr, s += sstr/sizeof(float)) {
         float v = *s * 0x7FFF;
         if (v < -0x8000) v = -0x8000;
@@ -333,7 +337,7 @@ static int format_f32_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void
     if (!(buf = sa_bbuffer_get(b, 0, bytes, 1)))
         return SA_ERROR_OOM;
 
-    oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n);                       
+    oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n);
     oil_clipconv_s16_f32(d, dstr, buf, sizeof(float), n);
 
     return SA_SUCCESS;
@@ -352,7 +356,7 @@ static int format_f32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void
         if (f < -0x800000) f = -0x800000;
 
         j = (uint32_t) ((int32_t) f);
-        
+
 #if defined(SA_LITTLE_ENDIAN)
         d[0] = j & 0xFF;
         d[1] = (j >> 8) & 0xFF;
@@ -365,7 +369,7 @@ static int format_f32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void
 #error "Unknown byte order"
 #endif
     }
-    
+
     return SA_SUCCESS;
 }
 
@@ -379,7 +383,7 @@ static int format_f32_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void
     if (!(buf = sa_bbuffer_get(b, 0, bytes, 1)))
         return SA_ERROR_OOM;
 
-    oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n);                       
+    oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n);
     oil_clipconv_s32_f32(d, dstr, buf, sizeof(float), n);
 
     return SA_SUCCESS;
@@ -393,7 +397,7 @@ sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) {
      *  2. from all work formats to all "lower" formats
      *  3. only for NE types
      */
-    
+
     static const sa_format_func_t funcs[_SA_PCM_FORMAT_MAX * _SA_PCM_FORMAT_MAX] = {
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_U8         + SA_PCM_FORMAT_S16_NE    ] = format_u8_to_s16,      /* done */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_U8         + SA_PCM_FORMAT_S32_NE    ] = format_u8_to_s32,      /* done */
@@ -412,17 +416,17 @@ sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) {
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S16_NE     + SA_PCM_FORMAT_ALAW      ] = format_s16_to_alaw,    /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S16_NE     + SA_PCM_FORMAT_S32_NE    ] = format_s16_to_s32,     /* done */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S16_NE     + SA_PCM_FORMAT_FLOAT32_NE] = format_s16_to_f32,     /* done */
- 
+
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S24_NE     + SA_PCM_FORMAT_S32_NE    ] = format_s24_to_s32,     /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S24_NE     + SA_PCM_FORMAT_FLOAT32_NE] = format_s24_to_f32,     /* done, no liboil */
-        
+
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE     + SA_PCM_FORMAT_U8        ] = format_s32_to_u8,      /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE     + SA_PCM_FORMAT_ULAW      ] = format_s32_to_ulaw,    /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE     + SA_PCM_FORMAT_ALAW      ] = format_s32_to_alaw,    /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE     + SA_PCM_FORMAT_S16_NE    ] = format_s32_to_s16,     /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE     + SA_PCM_FORMAT_S24_NE    ] = format_s32_to_s24,     /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE     + SA_PCM_FORMAT_FLOAT32_NE] = format_s32_to_f32,     /* done, but suboptimal */
-        
+
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_FLOAT32_NE + SA_PCM_FORMAT_U8        ] = format_f32_to_u8,      /* done */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_FLOAT32_NE + SA_PCM_FORMAT_ULAW      ] = format_f32_to_ulaw,    /* done, no liboil */
         [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_FLOAT32_NE + SA_PCM_FORMAT_ALAW      ] = format_f32_to_alaw,    /* done, no liboil */
@@ -433,6 +437,6 @@ sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) {
 
     sa_assert(from < _SA_PCM_FORMAT_MAX);
     sa_assert(to < _SA_PCM_FORMAT_MAX);
-    
+
     return funcs[from * _SA_PCM_FORMAT_MAX + to];
 }
diff --git a/src/interleave.c b/src/interleave.c
index d0470f7..31d1a6b 100644
--- a/src/interleave.c
+++ b/src/interleave.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <inttypes.h>
 
 #include "macro.h"
@@ -42,7 +46,7 @@ static void interleave32(void *_dst, size_t dstr, const void *_src, size_t sstr,
 }
 
 sa_interleave_func_t sa_get_interleave_func(sa_pcm_format_t f) {
-    
+
     static const sa_interleave_func_t funcs[_SA_PCM_FORMAT_MAX] = {
         [SA_PCM_FORMAT_U8] = interleave8,
         [SA_PCM_FORMAT_ULAW] = interleave8,
@@ -56,9 +60,8 @@ sa_interleave_func_t sa_get_interleave_func(sa_pcm_format_t f) {
         [SA_PCM_FORMAT_FLOAT32_LE] = interleave32,
         [SA_PCM_FORMAT_FLOAT32_BE] = interleave32,
     };
-            
-    sa_assert(f < _SA_PCM_FORMAT_MAX); 
+
+    sa_assert(f < _SA_PCM_FORMAT_MAX);
 
     return funcs[f];
 }
-
diff --git a/src/interleave.h b/src/interleave.h
index ed4a527..add447f 100644
--- a/src/interleave.h
+++ b/src/interleave.h
@@ -1,5 +1,5 @@
-#ifndef foosydneyhinterleavehfoo
-#define foosydneyhinterleavehfoo
+#ifndef foosydneyinterleavehfoo
+#define foosydneyinterleavehfoo
 
 #include <sys/types.h>
 
diff --git a/src/macro.h b/src/macro.h
index d664c3e..4f2d018 100644
--- a/src/macro.h
+++ b/src/macro.h
@@ -1,5 +1,5 @@
-#ifndef foomacrohfoo
-#define foomacrohfoo
+#ifndef foosydneymacrohfoo
+#define foosydneymacrohfoo
 
 #include <stdio.h>
 #include <assert.h>
@@ -101,4 +101,8 @@ static inline size_t sa_align(size_t l) {
 
 #define SA_ALIGN(x) (sa_align(x))
 
+typedef void (*sa_free_cb_t)(void *);
+
+typedef int sa_bool_t;
+
 #endif
diff --git a/src/malloc.c b/src/malloc.c
index 6a89554..a5171fa 100644
--- a/src/malloc.c
+++ b/src/malloc.c
@@ -1,10 +1,17 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <string.h>
 
+#include "macro.h"
 #include "malloc.h"
 
 void* sa_memdup(const void* p, size_t size) {
     void *r;
 
+    sa_assert(p);
+
     if (!(r = sa_malloc(size)))
         return NULL;
 
diff --git a/src/malloc.h b/src/malloc.h
index bcaf53e..b969988 100644
--- a/src/malloc.h
+++ b/src/malloc.h
@@ -1,5 +1,5 @@
-#ifndef foomallochfoo
-#define foomallochfoo
+#ifndef foosydneymallochfoo
+#define foosydneymallochfoo
 
 #include <stdlib.h>
 #include <string.h>
diff --git a/src/mutex-posix.c b/src/mutex-posix.c
new file mode 100644
index 0000000..436696c
--- /dev/null
+++ b/src/mutex-posix.c
@@ -0,0 +1,107 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <pthread.h>
+#include <errno.h>
+
+#include "malloc.h"
+#include "macro.h"
+#include "mutex.h"
+
+struct sa_mutex {
+    pthread_mutex_t mutex;
+};
+
+struct sa_cond {
+    pthread_cond_t cond;
+};
+
+sa_mutex* sa_mutex_new(sa_bool_t recursive, sa_bool_t inherit_priority) {
+    sa_mutex *m;
+    pthread_mutexattr_t attr;
+    int r;
+
+    sa_assert_se(pthread_mutexattr_init(&attr) == 0);
+
+    if (recursive)
+        sa_assert_se(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0);
+
+#ifdef HAVE_PTHREAD_PRIO_INHERIT
+    if (inherit_priority)
+        sa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) == 0);
+#endif
+
+    if (!(m = sa_new(sa_mutex, 1)))
+        return NULL;
+
+#ifndef HAVE_PTHREAD_PRIO_INHERIT
+    sa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
+
+#else
+    if ((r = pthread_mutex_init(&m->mutex, &attr))) {
+
+        /* If this failed, then this was probably due to non-available
+         * priority inheritance. In which case we fall back to normal
+         * mutexes. */
+        sa_assert(r == ENOTSUP && inherit_priority);
+
+        sa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_NONE) == 0);
+        sa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0);
+    }
+#endif
+
+    return m;
+}
+
+void sa_mutex_free(sa_mutex *m) {
+    sa_assert(m);
+
+    sa_assert_se(pthread_mutex_destroy(&m->mutex) == 0);
+    sa_free(m);
+}
+
+void sa_mutex_lock(sa_mutex *m) {
+    sa_assert(m);
+
+    sa_assert_se(pthread_mutex_lock(&m->mutex) == 0);
+}
+
+void sa_mutex_unlock(sa_mutex *m) {
+    sa_assert(m);
+
+    sa_assert_se(pthread_mutex_unlock(&m->mutex) == 0);
+}
+
+sa_cond *sa_cond_new(void) {
+    sa_cond *c;
+
+    if (!(c = sa_new(sa_cond, 1)))
+        return NULL;
+
+    sa_assert_se(pthread_cond_init(&c->cond, NULL) == 0);
+    return c;
+}
+
+void sa_cond_free(sa_cond *c) {
+    sa_assert(c);
+
+    sa_assert_se(pthread_cond_destroy(&c->cond) == 0);
+    sa_free(c);
+}
+
+void sa_cond_signal(sa_cond *c, int broadcast) {
+    sa_assert(c);
+
+    if (broadcast)
+        sa_assert_se(pthread_cond_broadcast(&c->cond) == 0);
+    else
+        sa_assert_se(pthread_cond_signal(&c->cond) == 0);
+}
+
+int sa_cond_wait(sa_cond *c, sa_mutex *m) {
+    sa_assert(c);
+    sa_assert(m);
+
+    return pthread_cond_wait(&c->cond, &m->mutex);
+}
diff --git a/src/mutex.c b/src/mutex.c
deleted file mode 100644
index 12a4f4a..0000000
--- a/src/mutex.c
+++ /dev/null
@@ -1,97 +0,0 @@
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <pthread.h>
-#include <errno.h>
-
-#include "macro.h"
-#include "malloc.h"
-#include "mutex.h"
-
-struct sa_mutex {
-    pthread_mutex_t mutex;
-};
-
-struct sa_cond {
-    pthread_cond_t cond;
-};
-
-sa_mutex_t* sa_mutex_new(int recursive) {
-    sa_mutex_t *m;
-    pthread_mutexattr_t attr;
-
-    pthread_mutexattr_init(&attr);
-
-    if (recursive)
-        sa_assert_success(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
-
-    if (!(m = sa_new(sa_mutex_t, 1)))
-        return NULL;
-
-    sa_assert_success(pthread_mutex_init(&m->mutex, &attr));
-    return m;
-}
-
-void sa_mutex_free(sa_mutex_t *m) {
-    sa_assert(m);
-
-    sa_assert_success(pthread_mutex_destroy(&m->mutex));
-    sa_free(m);
-}
-
-void sa_mutex_lock(sa_mutex_t *m) {
-    sa_assert(m);
-
-    sa_assert_success(pthread_mutex_lock(&m->mutex));
-}
-
-int sa_mutex_try_lock(sa_mutex_t *m) {
-    int e;
-    sa_assert(m);
-
-    if ((e = pthread_mutex_trylock(&m->mutex)) == 0)
-        return 1;
-
-    sa_assert(e == EBUSY);
-    return 0;
-}
-
-void sa_mutex_unlock(sa_mutex_t *m) {
-        sa_assert(m);
-
-    sa_assert_success(pthread_mutex_unlock(&m->mutex));
-}
-
-sa_cond_t *sa_cond_new(void) {
-    sa_cond_t *c;
-
-    if (!(c = sa_new(sa_cond_t, 1)))
-        return NULL;
-
-    sa_assert_success(pthread_cond_init(&c->cond, NULL));
-    return c;
-}
-
-void sa_cond_free(sa_cond_t *c) {
-    sa_assert(c);
-
-    sa_assert_success(pthread_cond_destroy(&c->cond));
-    sa_free(c);
-}
-
-void sa_cond_signal(sa_cond_t *c, int broadcast) {
-    sa_assert(c);
-
-    if (broadcast)
-        sa_assert_success(pthread_cond_broadcast(&c->cond));
-    else
-        sa_assert_success(pthread_cond_signal(&c->cond));
-}
-
-int sa_cond_wait(sa_cond_t *c, sa_mutex_t *m) {
-    sa_assert(c);
-    sa_assert(m);
-
-    return pthread_cond_wait(&c->cond, &m->mutex);
-}
diff --git a/src/mutex.h b/src/mutex.h
index e83feb8..c24acb6 100644
--- a/src/mutex.h
+++ b/src/mutex.h
@@ -1,19 +1,20 @@
 #ifndef foosydneymutexhfoo
 #define foosydneymutexhfoo
 
-typedef struct sa_mutex sa_mutex_t;
+#include "macro.h"
 
-sa_mutex_t* sa_mutex_new(int recursive);
-void sa_mutex_free(sa_mutex_t *m);
-void sa_mutex_lock(sa_mutex_t *m);
-void sa_mutex_unlock(sa_mutex_t *m);
-int sa_mutex_try_lock(sa_mutex_t *m);
+typedef struct sa_mutex sa_mutex;
 
-typedef struct sa_cond sa_cond_t;
+sa_mutex* sa_mutex_new(sa_bool_t recursive, sa_bool_t inherit_priority);
+void sa_mutex_free(sa_mutex *m);
+void sa_mutex_lock(sa_mutex *m);
+void sa_mutex_unlock(sa_mutex *m);
 
-sa_cond_t *sa_cond_new(void);
-void sa_cond_free(sa_cond_t *c);
-void sa_cond_signal(sa_cond_t *c, int broadcast);
-int sa_cond_wait(sa_cond_t *c, sa_mutex_t *m);
+typedef struct sa_cond sa_cond;
+
+sa_cond *sa_cond_new(void);
+void sa_cond_free(sa_cond *c);
+void sa_cond_signal(sa_cond *c, int broadcast);
+int sa_cond_wait(sa_cond *c, sa_mutex *m);
 
 #endif
diff --git a/src/oss.c b/src/oss.c
index d09f8aa..3ad1a9d 100644
--- a/src/oss.c
+++ b/src/oss.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <signal.h>
 #include <string.h>
 #include <unistd.h>
@@ -31,7 +35,7 @@ struct oss_stream {
     sa_converter_t converter_read, converter_write;
     size_t read_fragment_size, write_fragment_size;
     unsigned read_nfragments, write_nfragments;
-    sa_thread_t *thread;
+    sa_thread *thread;
     int socket_fds[2];
     sa_bufferq_t bufferq;
 };
@@ -47,6 +51,9 @@ static int simple_log2(int v) {
 
     return k;
 }
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 
 static size_t fixup_bps(size_t s, size_t bps1, size_t bps2) {
     return (s*bps2)/bps1;
@@ -54,12 +61,12 @@ static size_t fixup_bps(size_t s, size_t bps1, size_t bps2) {
 
 int driver_open(sa_stream_t *s) {
     oss_stream_t *oss;
-    char *n;
+    const char *n;
     int f, arg, bs, r, phase, i, found, suggested, fs, l, m;
     unsigned c;
     size_t real_bps = 0, bps;
     int loops = 0;
-    
+
     static const int format_map[_SA_PCM_FORMAT_MAX] = {
         [SA_PCM_FORMAT_U8] = AFMT_U8,
         [SA_PCM_FORMAT_ULAW] = AFMT_MU_LAW,
@@ -98,23 +105,23 @@ int driver_open(sa_stream_t *s) {
          * device again. */
 
         if ((oss->fd = open(n, s->mode == SA_MODE_RDONLY ? O_RDONLY : (s->mode == SA_MODE_WRONLY ? O_WRONLY : O_RDWR) | O_NOCTTY | O_NONBLOCK)) < 0) {
-            
+
             if (errno == ENODEV || errno == ENOENT)
                 r = SA_ERROR_NO_DEVICE;
             else
                 r = SA_ERROR_SYSTEM;
-            
+
             goto fail;
         }
-        
+
         fcntl(oss->fd, F_SETFL, fcntl(oss->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/
-        
+
         if (!s->device) {
             if (!(n = sa_strdup(n))) {
                 r = SA_ERROR_OOM;
                 goto fail;
             }
-            
+
             s->device = n;
         }
 
@@ -122,12 +129,12 @@ int driver_open(sa_stream_t *s) {
         if (s->mode & SA_MODE_WRONLY) {
             bs = s->write_lower_watermark;
         }
-        
+
         if (s->mode & SA_MODE_RDONLY) {
             int rbs;
-            
+
             rbs = s->read_upper_watermark;
-            
+
             if (s->mode & SA_MODE_WRONLY)
                 bs = bs > rbs ? bs : rbs;
             else
@@ -145,14 +152,14 @@ int driver_open(sa_stream_t *s) {
         if (m > 0x7FFF) m = 0x7FFF;
 
         printf("Asking OSS for: %u fragments, %u fragsize\n", m, 1 << l);
-        
+
         arg = (m << 16) | l;
-        
+
         ioctl(oss->fd, SNDCTL_DSP_SETFRAGMENT, &arg);
         /* We ignore errors on this call, since it's merely a hint anyway */
-        
+
         if (s->codec) {
-            
+
             if (strcmp(s->codec, SA_CODEC_AC3) == 0)
                 f = AFMT_AC3;
             else if (strcmp(s->codec, SA_CODEC_MPEG) == 0)
@@ -161,27 +168,27 @@ int driver_open(sa_stream_t *s) {
                 r = SA_ERROR_NO_CODEC;
                 goto fail;
             }
-            
+
         } else
             f = format_map[s->pcm_attrs.format];
-        
+
         bs = 0;
-        
+
         for (;;) {
             arg = f;
-            
+
             if (ioctl(oss->fd, SNDCTL_DSP_SETFMT, &arg) < 0) {
                 r = SA_ERROR_SYSTEM;
                 goto fail;
             }
-            
+
             if (arg == f)
                 break;
-            
+
             /* Hmm, the device doesn't support what we're looking for,
              * let's try our luck */
-            
-            if (f == AFMT_S16_LE && !bs) { 
+
+            if (f == AFMT_S16_LE && !bs) {
                 f = AFMT_S16_BE;
                 bs = 1;
             } else if (f == AFMT_S16_BE && !bs) {
@@ -206,39 +213,39 @@ int driver_open(sa_stream_t *s) {
                 goto fail;
             }
         }
-        
+
         if (!s->codec) {
-            
+
             switch (f) {
                 case AFMT_MU_LAW:
                     oss->real_pcm_attrs.format = SA_PCM_FORMAT_ULAW;
                     break;
-                    
+
                 case AFMT_A_LAW:
                     oss->real_pcm_attrs.format = SA_PCM_FORMAT_ALAW;
                     break;
-                    
+
                 case AFMT_U8:
                     oss->real_pcm_attrs.format = SA_PCM_FORMAT_U8;
                     break;
-                    
+
                 case AFMT_S16_LE:
                     oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_LE;
                     break;
-                    
+
                 case AFMT_S16_BE:
                     oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_BE;
                     break;
-                    
+
                 default:
                     sa_assert_not_reached();
             }
-            
-            
+
+
             found = 0;
-            
+
             if (s->adjust_nchannels >= 0) {
-                
+
                 /* First try more channels ... */
                 for (c = s->pcm_attrs.nchannels; c < 8 || c == s->pcm_attrs.nchannels; c ++) {
                     arg = c;
@@ -246,13 +253,13 @@ int driver_open(sa_stream_t *s) {
                         r = SA_ERROR_SYSTEM;
                         goto fail;
                     }
-                    
+
                     if (arg == (int) c) {
                         found = 1;
                         break;
                     }
                 }
-                
+
                 /* ... then try less channels */
                 if (!found) {
                     for (c = s->pcm_attrs.nchannels - 1; c > 0; c --) {
@@ -261,7 +268,7 @@ int driver_open(sa_stream_t *s) {
                             r = SA_ERROR_SYSTEM;
                             goto fail;
                         }
-                        
+
                         if (arg == (int) c) {
                             found = 1;
                             break;
@@ -269,7 +276,7 @@ int driver_open(sa_stream_t *s) {
                     }
                 }
             } else {
-                
+
                 /* First try less channels ... */
                 for (c = s->pcm_attrs.nchannels; c > 0; c --) {
                     arg = c;
@@ -277,13 +284,13 @@ int driver_open(sa_stream_t *s) {
                         r = SA_ERROR_SYSTEM;
                         goto fail;
                     }
-                    
+
                     if (arg == (int) c) {
                         found = 1;
                         break;
                     }
                 }
-                
+
                 /* ... then try more channels */
                 if (!found) {
                     for (c = s->pcm_attrs.nchannels + 1; c < 8; c ++) {
@@ -292,28 +299,28 @@ int driver_open(sa_stream_t *s) {
                             r = SA_ERROR_SYSTEM;
                             goto fail;
                         }
-                        
+
                         if (arg == (int) c) {
                             found = 1;
                             break;
                         }
                     }
-                }            
+                }
             }
-            
+
             if (!found) {
                 errno = EIO;
                 r = SA_ERROR_SYSTEM;
                 goto fail;
             }
-            
+
             oss->real_pcm_attrs.nchannels = c;
-            
+
             if (!(oss->real_pcm_attrs.channel_map = sa_new(sa_channel_t, c))) {
                 r = SA_ERROR_OOM;
                 goto fail;
             }
-            
+
             switch (c) {
                 case 8:
                     oss->real_pcm_attrs.channel_map[7] = SA_CHANNEL_REAR_RIGHT;
@@ -335,25 +342,25 @@ int driver_open(sa_stream_t *s) {
                     oss->real_pcm_attrs.channel_map[0] = SA_CHANNEL_MONO;
                     break;
             }
-            
+
             r = s->pcm_attrs.rate;
-            
+
             if (r < 8000)
                 r = 8000;
-            
+
             suggested = 0;
             phase = 0;
-            
+
             for (;;) {
                 arg = r;
-            
+
                 if (ioctl(oss->fd, SNDCTL_DSP_SPEED, &arg) < 0) {
                     r = SA_ERROR_SYSTEM;
                     goto fail;
                 }
 
                 sa_assert(arg > 0);
-            
+
                 if (arg >= r*0.95 || arg <= r *1.05)
                     break;
 
@@ -361,20 +368,20 @@ int driver_open(sa_stream_t *s) {
                     suggested = arg;
 
                 if (s->adjust_rate >= 0) {
-                
+
                     if (phase == 0) {
                         /* Find the next higher sample rate to try */
-                    
+
                         for (i = 0; i < (int) SA_ELEMENTSOF(try_rates); i++) {
                             /* Yes, we could optimize a little here */
-                        
+
                             if (try_rates[i] > r) {
                                 r = try_rates[i];
-                                break; 
+                                break;
                             }
                         }
-                    
-                    
+
+
                         if (i == SA_ELEMENTSOF(try_rates)) {
                             phase = 1;
                             r = s->pcm_attrs.rate;
@@ -393,23 +400,23 @@ int driver_open(sa_stream_t *s) {
                                 break;
                             }
                         }
-                    
+
                         sa_assert(i > 0);
                     }
-                
+
                 } else {
 
                     if (phase == 0) {
                         /* Find the next lower sample rate to try */
 
                         for (i = SA_ELEMENTSOF(try_rates); i > 0; i--) {
-                        
+
                             if (try_rates[i-1] < r) {
                                 r = try_rates[i-1];
-                                break; 
+                                break;
                             }
                         }
-                    
+
                         if (i == 0) {
                             phase = 1;
                             r = s->pcm_attrs.rate;
@@ -428,7 +435,7 @@ int driver_open(sa_stream_t *s) {
                                 break;
                             }
                         }
-                    
+
                         sa_assert(i < (int) SA_ELEMENTSOF(try_rates));
                     }
                 }
@@ -463,38 +470,38 @@ int driver_open(sa_stream_t *s) {
             oss->read_fragment_size = arg;
             oss->read_nfragments = 2;
         }
-        
+
         if (s->mode & SA_MODE_WRONLY) {
             oss->write_fragment_size = arg;
             oss->write_nfragments = 2;
         }
     }
-    
+
     /* Now, let's use GETxSPACE */
     if (s->mode & SA_MODE_RDONLY) {
         audio_buf_info info;
-        
+
         if (ioctl(oss->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
             oss->read_fragment_size = info.fragsize;
             oss->read_nfragments = info.fragstotal;
         }
     }
-    
+
     if (s->mode & SA_MODE_WRONLY) {
         audio_buf_info info;
-        
+
         if (ioctl(oss->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
             oss->write_fragment_size = info.fragsize;
             oss->write_nfragments = info.fragstotal;
         }
     }
-    
+
     if (s->mode & SA_MODE_WRONLY && (oss->write_fragment_size <= 0 || oss->write_nfragments <= 1)) {
         errno = EIO;
         r = SA_ERROR_SYSTEM;
         goto fail;
     }
-    
+
     if (s->mode & SA_MODE_RDONLY && (oss->read_fragment_size <= 0 || oss->read_nfragments <= 1)) {
         errno = EIO;
         r = SA_ERROR_SYSTEM;
@@ -502,7 +509,7 @@ int driver_open(sa_stream_t *s) {
     }
 
     if (!s->codec) {
-        
+
         if (s->adjust_nchannels != 0) {
             sa_channel_t *cm;
 
@@ -524,7 +531,7 @@ int driver_open(sa_stream_t *s) {
         if (s->mode & SA_MODE_RDONLY)
             if ((r = sa_converter_init(&oss->converter_read, &oss->real_pcm_attrs, &s->pcm_attrs, s->dynamic_rate_enabled)) < 0)
                 goto fail;
-        
+
         if (s->mode & SA_MODE_WRONLY)
             if ((r = sa_converter_init(&oss->converter_write, &s->pcm_attrs, &oss->real_pcm_attrs, s->dynamic_rate_enabled)) < 0)
                 goto fail;
@@ -542,7 +549,7 @@ int driver_open(sa_stream_t *s) {
             s->write_upper_watermark = oss->write_fragment_size * oss->write_nfragments;
         }
     }
-    
+
     if (s->mode & SA_MODE_RDONLY)
         printf("Chosen for read: %u fragments, %u fragsize\n", oss->read_nfragments, oss->read_fragment_size);
 
@@ -551,7 +558,7 @@ int driver_open(sa_stream_t *s) {
 
     if (sa_bufferq_init(&oss->bufferq, s->pcm_attrs.nchannels, s->pcm_sample_size) < 0)
         goto fail;
-    
+
     return SA_SUCCESS;
 
 fail:
@@ -566,19 +573,19 @@ int driver_destroy(sa_stream_t *s) {
 
         if (oss->thread)
             driver_stop_thread(s);
-        
+
         if (oss->fd >= 0)
             close(oss->fd);
-        
+
         sa_bufferq_done(&oss->bufferq);
-        
+
         sa_free(oss->real_pcm_attrs.channel_map);
         sa_converter_done(&oss->converter_read);
         sa_converter_done(&oss->converter_write);
 
         sa_free(oss);
     }
-    
+
     return SA_SUCCESS;
 }
 
@@ -586,7 +593,7 @@ static int feed(sa_stream_t *s) {
     oss_stream_t *oss = OSS_STREAM(s);
     size_t w;
     int ret;
-    
+
     sa_assert(s);
 
     for (;;) {
@@ -612,10 +619,10 @@ static int feed(sa_stream_t *s) {
                 drop = 1;
 
                 s->state = SA_STATE_RUNNING;
-                
+
             } else {
                 nbytes = w > oss->write_fragment_size ? oss->write_fragment_size : w;
-                
+
                 if (!(d = sa_converter_get_zero_buffer(&oss->converter_write, nbytes)))
                     return SA_ERROR_OOM;
 
@@ -627,17 +634,17 @@ static int feed(sa_stream_t *s) {
 
             while (nbytes > 0) {
                 ssize_t l;
-                
+
                 if ((l = write(oss->fd, d, nbytes)) < 0)
                     return SA_ERROR_SYSTEM;
-                
+
                 sa_assert(l > 0);
-                
+
                 nbytes -= l;
                 d += l;
 
                 w -= 1;
-                
+
                 if (drop)
                     sa_bufferq_drop(&oss->bufferq, l);
             }
@@ -667,15 +674,15 @@ static void thread_func(void *data) {
         if (s->callback(s, SA_EVENT_INIT_THREAD) < 0)
             return;
     }
-    
+
     memset(pollfds, 0, sizeof(pollfds));
 
     pollfds[POLLFD_SOCKET_FD].fd = oss->socket_fds[0];
     pollfds[POLLFD_SOCKET_FD].events = POLLIN;
-    
+
     pollfds[POLLFD_OSS_FD].fd = oss->fd;
     pollfds[POLLFD_OSS_FD].events = ((s->mode & SA_MODE_RDONLY) ? POLLIN : 0) | ((s->mode & SA_MODE_WRONLY) ? POLLOUT : 0);
-    
+
     for (;;) {
         int ret;
         if (poll(pollfds, POLLFD_MAX, -1) < 0) {
@@ -732,7 +739,7 @@ int driver_start_thread(sa_stream_t *s, sa_event_callback_t callback) {
 
     if (!(oss->thread = sa_thread_new(thread_func, s)))
         return SA_ERROR_OOM;
-    
+
     return SA_SUCCESS;
 }
 
@@ -743,13 +750,13 @@ int driver_stop_thread(sa_stream_t *s) {
 
     if (oss->socket_fds[0] >= 0)
         close(oss->socket_fds[0]);
-    
+
     if (oss->socket_fds[1] >= 0)
         close(oss->socket_fds[1]);
-    
+
     if (oss->thread)
         sa_thread_free(oss->thread);
-    
+
     oss->thread = NULL;
     oss->socket_fds[0] = oss->socket_fds[1] = -1;
 
@@ -762,7 +769,7 @@ int driver_change_read_volume(sa_stream_t *s, const int32_t vol[]) {
     sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
 
     sa_converter_set_volume(&oss->converter_read, vol);
-    
+
     return SA_SUCCESS;
 }
 
@@ -772,7 +779,7 @@ int driver_change_write_volume(sa_stream_t *s, const int32_t vol[]) {
     sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
 
     sa_converter_set_volume(&oss->converter_write, vol);
-    
+
     return SA_SUCCESS;
 }
 
@@ -806,7 +813,7 @@ int driver_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offse
 
     if ((ret = sa_bufferq_push(&oss->bufferq, 0, data, nbytes, offset, whence, SA_BUFFERQ_ITEM_STATIC)))
         return ret;
-    
+
     ret = feed(s);
     ret2 = sa_bufferq_realloc(&oss->bufferq);
 
@@ -843,7 +850,7 @@ int driver_drain(sa_stream_t *s) {
 
     if (ioctl(oss->fd, SNDCTL_DSP_SYNC, NULL) < 0)
         return SA_ERROR_SYSTEM;
-    
+
     return SA_SUCCESS;
 }
 
diff --git a/src/resample.c b/src/resample.c
index 23c63a5..7babe05 100644
--- a/src/resample.c
+++ b/src/resample.c
@@ -1,10 +1,14 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include "macro.h"
 #include "resample.h"
 
 static void resample_s16(SpeexResamplerState *speex, unsigned channel, void *dst, size_t dstr, const void *src, size_t sstr, size_t in_bytes, size_t *out_bytes) {
 
     spx_uint32_t in_samples = in_bytes/sizeof(int16_t), out_samples = *out_bytes/sizeof(int16_t);
-    
+
     speex_resampler_set_input_stride(speex, sstr/sizeof(int16_t));
     speex_resampler_set_input_stride(speex, dstr/sizeof(int16_t));
 
@@ -18,7 +22,7 @@ static void resample_s16(SpeexResamplerState *speex, unsigned channel, void *dst
 static void resample_f32(SpeexResamplerState *speex, unsigned channel, void *dst, size_t dstr, const void *src, size_t sstr, size_t in_bytes, size_t *out_bytes) {
 
     spx_uint32_t in_samples = in_bytes/sizeof(float), out_samples = *out_bytes/sizeof(float);
-    
+
     speex_resampler_set_input_stride(speex, sstr/sizeof(float));
     speex_resampler_set_input_stride(speex, dstr/sizeof(float));
 
diff --git a/src/test-asyncq.c b/src/test-asyncq.c
index 26dbc55..e32c5c9 100644
--- a/src/test-asyncq.c
+++ b/src/test-asyncq.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <stdlib.h>
 
 #include "asyncq.h"
@@ -9,7 +13,7 @@
 static void thread(void *userdata) {
     sa_asyncq_t *q = userdata;
     int i;
-    
+
     for (i = 0; i < ITERATIONS_MAX; i++) {
         sa_asyncq_item_t *i;
 
@@ -30,12 +34,12 @@ int main(int argc, char *argv[]) {
     sa_asyncq_item_t *i;
 
     sa_assert_success(sa_asyncq_init(&q));
-    
+
     t = sa_thread_new(thread, &q);
     sa_assert(t);
 
     for (j = 0; j < ITERATIONS_MAX; j++) {
-        
+
         do {
             i = sa_asyncq_pop(&q, 0);
             printf("%s ", i ? "gotcha" : "miss");
@@ -49,14 +53,14 @@ int main(int argc, char *argv[]) {
     }
 
     printf("\n");
-    
+
     sa_thread_free(t);
 
     while (sa_asyncq_pop(&q, 1))
         ;
 
     sa_asyncq_done(&q);
-    
+
 
     return 0;
 }
diff --git a/src/test-bufferq.c b/src/test-bufferq.c
index 45d65eb..79cd618 100644
--- a/src/test-bufferq.c
+++ b/src/test-bufferq.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include "bufferq.h"
 #include "malloc.h"
 
@@ -19,7 +23,7 @@ int main(int argc, char *argv[]) {
     for (;;) {
         void *b[1];
         size_t size;
-        
+
         sa_bufferq_get(&q, b, &size);
 
         if (size == 0)
@@ -35,7 +39,7 @@ int main(int argc, char *argv[]) {
 
         sa_bufferq_drop(&q, size);
     }
-    
+
     sa_bufferq_done(&q);
 
     return 0;
diff --git a/src/test-llist.c b/src/test-llist.c
index 2059ef8..814690e 100644
--- a/src/test-llist.c
+++ b/src/test-llist.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include "llist.h"
 
 struct foobar {
@@ -11,7 +15,7 @@ int main(int argc, char *argv[]) {
     struct foobar a, b, c;
 
     SA_LLIST_HEAD_INIT(struct foobar, list);
-    
+
     SA_LLIST_ITEM_INIT(struct foobar, list, &a);
     SA_LLIST_ITEM_INIT(struct foobar, list, &b);
     SA_LLIST_ITEM_INIT(struct foobar, list, &c);
@@ -29,6 +33,6 @@ int main(int argc, char *argv[]) {
     SA_LLIST_REMOVE(struct foobar, list, list, &c);
 
     sa_assert(!list);
-    
+
     return 0;
 }
diff --git a/src/test-pull.c b/src/test-pull.c
index 7f93906..993b7a3 100644
--- a/src/test-pull.c
+++ b/src/test-pull.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <errno.h>
 #include <stdio.h>
 #include <assert.h>
@@ -29,9 +33,9 @@ static int callback(sa_stream_t *s, sa_event_t e) {
             return 0;
 
         case SA_EVENT_ERROR: {
-            int e;
-            ASSERT_SUCCESS(sa_stream_get_event_error(s, &e));
-            printf("Error: %s\n", sa_strerror(e));
+            int err;
+            ASSERT_SUCCESS(sa_stream_get_event_error(s, &err));
+            printf("Error: %s\n", sa_strerror(err));
             return -1;
         }
 
@@ -62,12 +66,12 @@ int main(int argc, char *argv[]) {
     ASSERT_SUCCESS(sa_stream_start_thread(s, callback));
 
     sleep(20);
-    
+
     ASSERT_SUCCESS(sa_stream_stop_thread(s));
 
     ASSERT_SUCCESS(sa_stream_drain(s));
 
     ASSERT_SUCCESS(sa_stream_destroy(s));
-    
+
     return 0;
 }
diff --git a/src/test-sine.c b/src/test-sine.c
index 07f3868..633fabb 100644
--- a/src/test-sine.c
+++ b/src/test-sine.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <errno.h>
 #include <stdio.h>
 #include <assert.h>
@@ -26,7 +30,6 @@ int main(int argc, char *argv[]) {
 
     ASSERT_SUCCESS(sa_stream_create_pcm(&s, "Sine Test", SA_MODE_WRONLY, SA_PCM_FORMAT_FLOAT32_NE, FREQ * 4, 1));
     ASSERT_SUCCESS(sa_stream_change_device(s, "/dev/dsp1"));
-    ASSERT_SUCCESS(sa_stream_set_dynamic_rate(s, 1));
     sa_stream_change_meta_data(s, SA_META_CLIENT_NAME, argv[0], strlen(argv[0]));
     ASSERT_SUCCESS(sa_stream_open(s));
 
@@ -34,18 +37,18 @@ int main(int argc, char *argv[]) {
         int v;
 
         v = -j*500;
-        
+
 /*         ASSERT_SUCCESS(sa_stream_change_rate(dev, FREQ*4+100*j)); */
         ASSERT_SUCCESS(sa_stream_change_write_volume(s, &v, 1));
-                
+
         for (i = 0; i < FREQ; i++)
             ASSERT_SUCCESS(sa_stream_write(s, data, sizeof(data)));
     }
 
-        
+
     ASSERT_SUCCESS(sa_stream_drain(s));
 
     ASSERT_SUCCESS(sa_stream_destroy(s));
-    
+
     return 0;
 }
diff --git a/src/thread-posix.c b/src/thread-posix.c
new file mode 100644
index 0000000..d76e8d5
--- /dev/null
+++ b/src/thread-posix.c
@@ -0,0 +1,215 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <pthread.h>
+#include <sched.h>
+#include <errno.h>
+
+#include "malloc.h"
+#include "mutex.h"
+#include "macro.h"
+#include "thread.h"
+
+struct sa_thread {
+    pthread_t id;
+    sa_thread_func_t thread_func;
+    void *userdata;
+    int running;
+    sa_mutex *mutex;
+};
+
+struct sa_tls {
+    pthread_key_t key;
+};
+
+static pthread_once_t tid_once = PTHREAD_ONCE_INIT;
+static sa_tls *tid_tls = NULL;
+
+static void tid_free_cb(void *p) {
+    sa_thread *t = p;
+
+    sa_assert(t);
+
+    if (!t->thread_func) {
+        /* This is a foreign thread, we need to free the struct */
+        sa_mutex_free(t->mutex);
+        sa_free(t);
+    }
+}
+
+static void tid_init(void) {
+    tid_tls = sa_tls_new(tid_free_cb);
+}
+
+static void* internal_thread_func(void *userdata) {
+    sa_thread *t = userdata;
+    sa_assert(t);
+
+    t->id = pthread_self();
+    sa_tls_set(tid_tls, t);
+
+    sa_mutex_lock(t->mutex);
+    t->running++;
+    sa_mutex_unlock(t->mutex);
+
+    t->thread_func(t->userdata);
+
+    sa_mutex_lock(t->mutex);
+    t->running -= 2;
+    sa_mutex_unlock(t->mutex);
+
+    return NULL;
+}
+
+sa_thread* sa_thread_new(sa_thread_func_t thread_func, void *userdata) {
+    sa_thread *t;
+
+    sa_assert(thread_func);
+
+    pthread_once(&tid_once, tid_init);
+
+    if (!tid_tls)
+        return NULL;
+
+    if (!(t = sa_new(sa_thread, 1)))
+        return NULL;
+
+    t->thread_func = thread_func;
+    t->userdata = userdata;
+    t->running = 1;
+
+    if (!(t->mutex = sa_mutex_new(FALSE, FALSE))) {
+        sa_free(t);
+        return NULL;
+    }
+
+    if (pthread_create(&t->id, NULL, internal_thread_func, t) < 0) {
+        sa_mutex_free(t->mutex);
+        sa_free(t);
+        return NULL;
+    }
+
+    return t;
+}
+
+sa_bool_t sa_thread_is_running(sa_thread *t) {
+    sa_bool_t b;
+    sa_assert(t);
+
+    /* Unfortunately there is no way to tell whether a "foreign"
+     * thread is still running. See
+     * http://udrepper.livejournal.com/16844.html for more
+     * information */
+    sa_assert(t->thread_func);
+
+    sa_mutex_lock(t->mutex);
+    b = t->running > 0;
+    sa_mutex_unlock(t->mutex);
+
+    return b;
+}
+
+void sa_thread_free(sa_thread *t) {
+    sa_assert(t);
+
+    /* Only allowed when this is not a foreign thread */
+    sa_assert(t->thread_func);
+
+    sa_thread_join(t);
+    sa_mutex_free(t->mutex);
+    sa_free(t);
+}
+
+int sa_thread_join(sa_thread *t) {
+    sa_assert(t);
+
+    /* Only allowed when this is not a foreign thread */
+    sa_assert(t->thread_func);
+
+    return pthread_join(t->id, NULL);
+}
+
+sa_thread* sa_thread_self(void) {
+    sa_thread *t;
+
+    pthread_once(&tid_once, tid_init);
+
+    if (!tid_tls)
+        return NULL;
+
+    if ((t = sa_tls_get(tid_tls)))
+        return t;
+
+    /* This is a foreign thread, let's create a pthread structure to
+     * make sure that we can always return a sensible pointer */
+
+    if (!(t = sa_new(sa_thread, 1)))
+        return NULL;
+
+    t->id = pthread_self();
+    t->thread_func = NULL;
+    t->userdata = NULL;
+    t->running = 2;
+    t->mutex = sa_mutex_new(FALSE, FALSE);
+
+    sa_tls_set(tid_tls, t);
+
+    return t;
+}
+
+void* sa_thread_get_data(sa_thread *t) {
+    sa_assert(t);
+
+    return t->userdata;
+}
+
+void sa_thread_set_data(sa_thread *t, void *userdata) {
+    sa_assert(t);
+
+    t->userdata = userdata;
+}
+
+void sa_thread_yield(void) {
+#ifdef HAVE_PTHREAD_YIELD
+    pthread_yield();
+#else
+    sa_assert_se(sched_yield() == 0);
+#endif
+}
+
+sa_tls* sa_tls_new(sa_free_cb_t free_cb) {
+    sa_tls *t;
+
+    if (!(t = sa_new(sa_tls, 1)))
+        return NULL;
+
+    if (pthread_key_create(&t->key, free_cb) < 0) {
+        sa_free(t);
+        return NULL;
+    }
+
+    return t;
+}
+
+void sa_tls_free(sa_tls *t) {
+    sa_assert(t);
+
+    sa_assert_se(pthread_key_delete(t->key) == 0);
+    sa_free(t);
+}
+
+void *sa_tls_get(sa_tls *t) {
+    sa_assert(t);
+
+    return pthread_getspecific(t->key);
+}
+
+void *sa_tls_set(sa_tls *t, void *userdata) {
+    void *r;
+
+    sa_assert(t);
+    r = pthread_getspecific(t->key);
+    sa_assert_se(pthread_setspecific(t->key, userdata) == 0);
+    return r;
+}
diff --git a/src/thread.c b/src/thread.c
deleted file mode 100644
index 26deccb..0000000
--- a/src/thread.c
+++ /dev/null
@@ -1,214 +0,0 @@
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <pthread.h>
-#include <sched.h>
-#include <errno.h>
-
-#include "thread.h"
-#include "malloc.h"
-#include "once.h"
-#include "macro.h"
-
-struct sa_thread {
-    pthread_t id;
-    sa_thread_func_t thread_func;
-    void *userdata;
-    int running;
-    pthread_mutex_t running_mutex;
-};
-
-struct sa_tls {
-    pthread_key_t key;
-};
-
-static sa_tls_t *thread_tls;
-static sa_once_t thread_tls_once = SA_ONCE_INIT;
-
-static void tls_free_cb(void *p) {
-    sa_thread_t *t = p;
-
-    sa_assert(t);
-    
-    if (!t->thread_func) 
-        /* This is a foreign thread, we need to free the struct */
-        sa_free(t);
-}
-
-static void thread_tls_once_func(void) {
-    thread_tls = sa_tls_new(tls_free_cb);
-}
-
-static void* internal_thread_func(void *userdata) {
-    sa_thread_t *t = userdata;
-    sa_assert(t);
-
-    t->id = pthread_self();
-    sa_tls_set(thread_tls, t);
-
-    t->thread_func(t->userdata);
-
-    sa_assert_success(pthread_mutex_lock(&t->running_mutex));
-    t->running = 0;
-    sa_assert_success(pthread_mutex_unlock(&t->running_mutex));
-    
-    return NULL;
-}
-
-sa_thread_t* sa_thread_new(sa_thread_func_t thread_func, void *userdata) {
-    sa_thread_t *t;
-
-    sa_assert(thread_func);
-    
-    if (sa_once(&thread_tls_once, thread_tls_once_func) < 0 || !thread_tls)
-        return NULL;
-
-    if (!(t = sa_new(sa_thread_t, 1)))
-        return NULL;
-    
-    t->thread_func = thread_func;
-    t->userdata = userdata;
-
-    sa_assert_success(pthread_mutex_init(&t->running_mutex, NULL));
-    t->running = 1;
-    
-    if (pthread_create(&t->id, NULL, internal_thread_func, t) < 0) {
-        sa_assert_success(pthread_mutex_destroy(&t->running_mutex));
-        sa_free(t);
-        return NULL;
-    }
-
-    return t;
-}
-
-int sa_thread_is_running(sa_thread_t *t) {
-    int b;
-    sa_assert(t);
-
-    if (!t->thread_func) {
-        /* Mhmm, this is a foreign thread, t->running is not
-         * necessarily valid. We misuse pthread_getschedparam() to
-         * check if the thread is valid. This might not be portable. */
-
-        int policy;
-        struct sched_param param;
-        
-        return pthread_getschedparam(t->id, &policy, &param) >= 0 || errno != ESRCH;
-    }
-
-    sa_assert_success(pthread_mutex_lock(&t->running_mutex));
-    b = t->running;
-    sa_assert_success(pthread_mutex_unlock(&t->running_mutex));
-    
-    return !!b;
-}
-
-void sa_thread_free(sa_thread_t *t) {
-    sa_assert(t);
-    
-    sa_thread_join(t);
-    sa_assert_success(pthread_mutex_destroy(&t->running_mutex));
-    sa_free(t);
-}
-
-int sa_thread_join(sa_thread_t *t) {
-    sa_assert(t);
-    
-    return pthread_join(t->id, NULL);
-}
-
-sa_thread_t* sa_thread_self(void) {
-    sa_thread_t *t;
-    
-    if (sa_once(&thread_tls_once, thread_tls_once_func) < 0 || !thread_tls)
-        return NULL;
-
-    if ((t = sa_tls_get(thread_tls)))
-        return t;
-
-    /* This is a foreign thread, let's create a pthread structure to
-     * make sure that we can always return a sensible pointer */
-    
-    if (!(t = sa_new(sa_thread_t, 1)))
-        return NULL;
-    
-    t->id = pthread_self();
-    t->thread_func = NULL;
-    t->userdata = NULL;
-    t->running = 1;
-
-    sa_tls_set(thread_tls, t);
-    
-    return t;
-}
-
-int sa_thread_is_self(sa_thread_t *t) {
-    sa_thread_t *c;
-    sa_assert(t);
-
-    if (sa_once(&thread_tls_once, thread_tls_once_func) < 0 || !thread_tls)
-        return 0;
-
-    if ((c = sa_tls_get(thread_tls)))
-        return c == t;
-
-    return 0;
-}
-
-
-void* sa_thread_get_data(sa_thread_t *t) {
-    sa_assert(t);
-
-    return t->userdata;
-}
-
-void sa_thread_set_data(sa_thread_t *t, void *userdata) {
-    sa_assert(t);
-
-    t->userdata = userdata;
-}
-
-void sa_thread_yield(void) {
-#ifdef HAVE_PTHREAD_YIELD
-    pthread_yield();
-#else
-    sa_assert_success(sched_yield());
-#endif
-}
-
-sa_tls_t* sa_tls_new(sa_free_func_t free_cb) {
-    sa_tls_t *t;
-
-    if (!(t = sa_new(sa_tls_t, 1)))
-        return NULL;
-
-    if (pthread_key_create(&t->key, free_cb) < 0) {
-        sa_free(t);
-        return NULL;
-    }
-        
-    return t;
-}
-
-void sa_tls_free(sa_tls_t *t) {
-    sa_assert(t);
-
-    sa_assert_success(pthread_key_delete(t->key));
-    sa_free(t);
-}
-
-void *sa_tls_get(sa_tls_t *t) {
-    sa_assert(t);
-    
-    return pthread_getspecific(t->key);
-}
-
-void *sa_tls_set(sa_tls_t *t, void *userdata) {
-    void *r;
-    
-    r = pthread_getspecific(t->key);
-    sa_assert_success(pthread_setspecific(t->key, userdata));
-    return r;
-}
-
diff --git a/src/thread.h b/src/thread.h
index ddd2604..66071e1 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -1,28 +1,27 @@
 #ifndef foosydneythreadhfoo
 #define foosydneythreadhfoo
 
-typedef struct sa_thread sa_thread_t;
+#include "macro.h"
+
+typedef struct sa_thread sa_thread;
 
 typedef void (*sa_thread_func_t) (void *userdata);
 
-sa_thread_t* sa_thread_new(sa_thread_func_t sa_thread_func, void *userdata);
-void sa_thread_free(sa_thread_t *t);
-int sa_thread_join(sa_thread_t *t);
-int sa_thread_is_running(sa_thread_t *t);
-sa_thread_t *sa_thread_self(void);
+sa_thread* sa_thread_new(sa_thread_func_t thread_func, void *userdata);
+void sa_thread_free(sa_thread *t);
+int sa_thread_join(sa_thread *t);
+sa_bool_t sa_thread_is_running(sa_thread *t);
+sa_thread *sa_thread_self(void);
 void sa_thread_yield(void);
-int sa_thread_is_self(sa_thread_t *t);
-
-void* sa_thread_get_data(sa_thread_t *t);
-void sa_thread_set_data(sa_thread_t *t, void *userdata);
 
-typedef struct sa_tls sa_tls_t;
+void* sa_thread_get_data(sa_thread *t);
+void sa_thread_set_data(sa_thread *t, void *userdata);
 
-typedef void (*sa_free_func_t) (void *data);
+typedef struct sa_tls sa_tls;
 
-sa_tls_t* sa_tls_new(sa_free_func_t f);
-void sa_tls_free(sa_tls_t *t);
-void * sa_tls_get(sa_tls_t *t);
-void *sa_tls_set(sa_tls_t *t, void *userdata);
+sa_tls* sa_tls_new(sa_free_cb_t free_cb);
+void sa_tls_free(sa_tls *t);
+void * sa_tls_get(sa_tls *t);
+void *sa_tls_set(sa_tls *t, void *userdata);
 
 #endif
diff --git a/src/volscale.c b/src/volscale.c
index 2075b90..f29cb0e 100644
--- a/src/volscale.c
+++ b/src/volscale.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <liboil/liboil.h>
 
 #include "macro.h"
@@ -6,11 +10,12 @@
 static void volscale_u8(void *_dst, size_t dstr, const void *_src, size_t sstr, int32_t factor, int32_t divisor, size_t bytes) {
     uint8_t *dst = _dst;
     const uint8_t *src = _src;
-    
+
     for (; bytes > 0; bytes --) {
         int32_t t = (((int32_t) *src - 0x80) * factor) / divisor;
-        *dst = t < -0x80 ? 0 : (t > 0x7F ? 0xFF : (int8_t) (t+0x80));
-        
+        t = CLAMP(t, -0x80, 0x7F);
+        *dst = (int8_t) (t+0x80);
+
         src += sstr;
         dst += dstr;
     }
@@ -20,11 +25,12 @@ static void volscale_s16(void *_dst, size_t dstr, const void *_src, size_t sstr,
     int16_t *dst = _dst;
     const int16_t *src = _src;
     unsigned n = bytes / sizeof(int16_t);
-    
+
     for (; n > 0; n--) {
         int32_t t = ((int32_t) *src * factor) / divisor;
-        *dst = t < -0x8000 ? 0x8000 : (t > 0x7FFF ? 0x7FFF : (int16_t) t);
-        
+        t = CLAMP(t, -0x8000, 0x7FFF);
+        *dst = (int16_t) t;
+
         src += sstr / sizeof(int16_t);
         dst += dstr / sizeof(int16_t);
     }
@@ -34,11 +40,12 @@ static void volscale_s32(void *_dst, size_t dstr, const void *_src, size_t sstr,
     int32_t *dst = _dst;
     const int32_t *src = _src;
     unsigned n = bytes / sizeof(int32_t);
-    
+
     for (; n > 0; n--) {
         int64_t t = ((int64_t) *src * factor) / divisor;
-        *dst = t < -0x80000000L ? (int32_t) 0x80000000L : (t > 0x7fffffffL ? (int32_t) 0x7fffffffL : (int32_t) t);
-        
+        t = CLAMP(t, -0x80000000L, 0x7FFFFFFFL);
+        *dst = (int32_t) t;
+
         src += sstr / sizeof(int32_t);
         dst += dstr / sizeof(int32_t);
     }
@@ -48,12 +55,12 @@ static void volscale_f32(void *_dst, size_t dstr, const void *_src, size_t sstr,
     float *dst = _dst;
     const float *src = _src;
     float f = (float) factor / (float) divisor;
-    
+
     oil_scalarmult_f32(dst, dstr, src, sstr, &f, size / sizeof(float));
 }
 
 sa_volscale_func_t sa_get_volscale_func(sa_pcm_format_t f) {
-    
+
     static const sa_volscale_func_t funcs[_SA_PCM_FORMAT_MAX] = {
         [SA_PCM_FORMAT_U8] = volscale_u8,
         [SA_PCM_FORMAT_S16_NE] = volscale_s16,
diff --git a/src/zero.c b/src/zero.c
index 4f477dc..9d4c054 100644
--- a/src/zero.c
+++ b/src/zero.c
@@ -1,3 +1,7 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <string.h>
 
 #include "macro.h"
@@ -11,7 +15,7 @@ static void zero_u8(void *dst, size_t dstr, size_t bytes) {
     else {
         for (; bytes > 0; bytes --, d += dstr)
             *d = 0x80;
-    }       
+    }
 }
 
 static void zero_16(void *dst, size_t dstr, size_t bytes) {
@@ -23,7 +27,7 @@ static void zero_16(void *dst, size_t dstr, size_t bytes) {
     else {
         for (; n > 0; n --, d += dstr/sizeof(uint16_t))
             *d = 0;
-    }       
+    }
 }
 
 static void zero_32(void *dst, size_t dstr, size_t bytes) {
@@ -35,7 +39,7 @@ static void zero_32(void *dst, size_t dstr, size_t bytes) {
     else {
         for (; n > 0; n --, d += dstr/sizeof(uint32_t))
             *d = 0;
-    }       
+    }
 }
 
 sa_zero_func_t sa_get_zero_func(sa_pcm_format_t f) {