big pile of updates to match more what happened with libcanberra

1 files changed, 219 insertions, 184 deletions

diff --git a/src/oss.c b/src/oss.c
index 410fa45..a60412b 100644
--- a/src/oss.c
+++ b/src/oss.c
@@ -1,3 +1,23 @@
+/***
+  This file is part of libsydney.
+
+  Copyright 2007-2008 Lennart Poettering
+
+  libsydney is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as
+  published by the Free Software Foundation, either version 2.1 of the
+  License, or (at your option) any later version.
+
+  libsydney is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with libsydney. If not, see
+  <http://www.gnu.org/licenses/>.
+***/
+
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -13,6 +33,17 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 
+#ifdef HAVE_MACHINE_SOUNDCARD_H
+#  include <machine/soundcard.h>
+#else
+#  ifdef HAVE_SOUNDCARD_H
+#    include <soundcard.h>
+#  else
+#    include <sys/soundcard.h>
+#  endif
+#endif
+
+
 #include "sydney.h"
 #include "common.h"
 #include "macro.h"
@@ -23,13 +54,9 @@
 #include "bufferq.h"
 
 #define DEFAULT_DEVICE "/dev/dsp"
-#define DRIVER_NAME "oss"
-
-typedef struct oss_stream oss_stream_t;
-#define OSS_STREAM(x) ((oss_stream_t*) (x->private))
 
-struct oss_stream {
-    sa_stream_t *parent;
+struct private {
+    sa_stream *parent;
     int fd;
     pcm_attrs_t real_pcm_attrs;
     sa_converter_t converter_read, converter_write;
@@ -42,27 +69,37 @@ struct oss_stream {
     void *cdata;
 };
 
-static int simple_log2(int v) {
-    int k = 0;
+#define PRIVATE(c) ((struct private *) ((c)->private))
+
+static inline unsigned ulog2(unsigned n) {
+
+    if (n <= 1)
+        return 0;
+
+#if __GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+    return 8U * (unsigned) sizeof(unsigned) - (unsigned) __builtin_clz(n) - 1;
+#else
+{
+    unsigned r = 0;
 
     for (;;) {
-        v >>= 1;
-        if (!v) break;
-        k++;
-    }
+        n = n >> 1;
+
+        if (!n)
+            return r;
 
-    return k;
+        r++;
+    }
 }
-#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;
 }
 
-int driver_open(sa_stream_t *s) {
-    oss_stream_t *oss;
+int driver_open(sa_stream *s) {
+    struct private *p;
     char *n;
     int f, arg, bs, r, phase, i, found, suggested, fs, l, m;
     unsigned c;
@@ -84,14 +121,14 @@ int driver_open(sa_stream_t *s) {
     };
     static const int try_rates[] = { 8000, 16000, 32000, 44100, 48000, 96000, 192000 };
 
-    if (s->driver && strcmp(s->driver, DRIVER_NAME))
-        return SA_ERROR_NO_DRIVER;
+    if (s->driver && !sa_streq(s->driver, "oss"))
+        return SA_ERROR_NODRIVER;
 
-    if (!(s->private = oss = sa_new0(oss_stream_t, 1)))
+    if (!(s->private = p = sa_new0(struct private, 1)))
         return SA_ERROR_OOM;
 
-    oss->parent = s;
-    oss->socket_fds[0] = oss->socket_fds[1] = -1;
+    p->parent = s;
+    p->socket_fds[0] = p->socket_fds[1] = -1;
 
     n = s->device ? s->device : (char*) DEFAULT_DEVICE;
     if (!s->codec)
@@ -106,17 +143,17 @@ int driver_open(sa_stream_t *s) {
          * SETFRAGMENT again which can do only after reopening the
          * 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 ((p->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;
+                r = SA_ERROR_NODEVICE;
             else
                 r = SA_ERROR_SYSTEM;
 
             goto fail;
         }
 
-        fcntl(oss->fd, F_SETFL, fcntl(oss->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/
+        fcntl(p->fd, F_SETFL, fcntl(p->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/
 
         if (!s->device) {
             if (!(n = sa_strdup(n))) {
@@ -146,10 +183,10 @@ int driver_open(sa_stream_t *s) {
         }
 
         if (!s->codec && real_bps)
-            bs = fixup_bps(bs, bps, real_bps);
+            bs = (int) fixup_bps((size_t) bs, bps, real_bps);
 
         fs = bs/4;
-        l = simple_log2(fs);
+        l = ulog2(fs);
         if (l < 1) l = 1;
         m = (bs+(1<<l)-1)/(1<<l);
         if (m < 2) m = 2;
@@ -159,7 +196,7 @@ int driver_open(sa_stream_t *s) {
 
         arg = (m << 16) | l;
 
-        ioctl(oss->fd, SNDCTL_DSP_SETFRAGMENT, &arg);
+        ioctl(p->fd, SNDCTL_DSP_SETFRAGMENT, &arg);
         /* We ignore errors on this call, since it's merely a hint anyway */
 
         if (s->codec) {
@@ -169,7 +206,7 @@ int driver_open(sa_stream_t *s) {
             else if (strcmp(s->codec, SA_CODEC_MPEG) == 0)
                 f = AFMT_MPEG;
             else {
-                r = SA_ERROR_NO_CODEC;
+                r = SA_ERROR_NOCODEC;
                 goto fail;
             }
 
@@ -181,7 +218,7 @@ int driver_open(sa_stream_t *s) {
         for (;;) {
             arg = f;
 
-            if (ioctl(oss->fd, SNDCTL_DSP_SETFMT, &arg) < 0) {
+            if (ioctl(p->fd, SNDCTL_DSP_SETFMT, &arg) < 0) {
                 r = SA_ERROR_SYSTEM;
                 goto fail;
             }
@@ -210,10 +247,10 @@ int driver_open(sa_stream_t *s) {
             } else if (f == AFMT_A_LAW || f == AFMT_MU_LAW) {
                 f = AFMT_U8;
             } else if (f == AFMT_AC3 || f == AFMT_MPEG) {
-                r = SA_ERROR_NO_CODEC;
+                r = SA_ERROR_NOCODEC;
                 goto fail;
             } else {
-                r = SA_ERROR_NO_PCM_FORMAT;
+                r = SA_ERROR_NOPCMFORMAT;
                 goto fail;
             }
         }
@@ -222,23 +259,23 @@ int driver_open(sa_stream_t *s) {
 
             switch (f) {
                 case AFMT_MU_LAW:
-                    oss->real_pcm_attrs.format = SA_PCM_FORMAT_ULAW;
+                    p->real_pcm_attrs.format = SA_PCM_FORMAT_ULAW;
                     break;
 
                 case AFMT_A_LAW:
-                    oss->real_pcm_attrs.format = SA_PCM_FORMAT_ALAW;
+                    p->real_pcm_attrs.format = SA_PCM_FORMAT_ALAW;
                     break;
 
                 case AFMT_U8:
-                    oss->real_pcm_attrs.format = SA_PCM_FORMAT_U8;
+                    p->real_pcm_attrs.format = SA_PCM_FORMAT_U8;
                     break;
 
                 case AFMT_S16_LE:
-                    oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_LE;
+                    p->real_pcm_attrs.format = SA_PCM_FORMAT_S16_LE;
                     break;
 
                 case AFMT_S16_BE:
-                    oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_BE;
+                    p->real_pcm_attrs.format = SA_PCM_FORMAT_S16_BE;
                     break;
 
                 default:
@@ -252,8 +289,8 @@ int driver_open(sa_stream_t *s) {
 
                 /* First try more channels ... */
                 for (c = s->pcm_attrs.nchannels; c < 8 || c == s->pcm_attrs.nchannels; c ++) {
-                    arg = c;
-                    if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
+                    arg = (int) c;
+                    if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
                         r = SA_ERROR_SYSTEM;
                         goto fail;
                     }
@@ -267,8 +304,8 @@ int driver_open(sa_stream_t *s) {
                 /* ... then try less channels */
                 if (!found) {
                     for (c = s->pcm_attrs.nchannels - 1; c > 0; c --) {
-                        arg = c;
-                        if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
+                        arg = (int) c;
+                        if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
                             r = SA_ERROR_SYSTEM;
                             goto fail;
                         }
@@ -283,8 +320,8 @@ int driver_open(sa_stream_t *s) {
 
                 /* First try less channels ... */
                 for (c = s->pcm_attrs.nchannels; c > 0; c --) {
-                    arg = c;
-                    if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
+                    arg = (int) c;
+                    if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
                         r = SA_ERROR_SYSTEM;
                         goto fail;
                     }
@@ -299,7 +336,7 @@ int driver_open(sa_stream_t *s) {
                 if (!found) {
                     for (c = s->pcm_attrs.nchannels + 1; c < 8; c ++) {
                         arg = c;
-                        if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
+                        if (ioctl(p->fd, SNDCTL_DSP_CHANNELS, &arg) < 0) {
                             r = SA_ERROR_SYSTEM;
                             goto fail;
                         }
@@ -318,32 +355,32 @@ int driver_open(sa_stream_t *s) {
                 goto fail;
             }
 
-            oss->real_pcm_attrs.nchannels = c;
+            p->real_pcm_attrs.nchannels = c;
 
-            if (!(oss->real_pcm_attrs.channel_map = sa_new(sa_channel_t, c))) {
+            if (!(p->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;
+                    p->real_pcm_attrs.channel_map[7] = SA_CHANNEL_REAR_RIGHT;
                 case 7:
-                    oss->real_pcm_attrs.channel_map[6] = SA_CHANNEL_REAR_LEFT;
+                    p->real_pcm_attrs.channel_map[6] = SA_CHANNEL_REAR_LEFT;
                 case 6:
-                    oss->real_pcm_attrs.channel_map[5] = SA_CHANNEL_FRONT_LEFT;
+                    p->real_pcm_attrs.channel_map[5] = SA_CHANNEL_FRONT_LEFT;
                 case 5:
-                    oss->real_pcm_attrs.channel_map[4] = SA_CHANNEL_FRONT_RIGHT;
+                    p->real_pcm_attrs.channel_map[4] = SA_CHANNEL_FRONT_RIGHT;
                 case 4:
-                    oss->real_pcm_attrs.channel_map[3] = SA_CHANNEL_LFE;
+                    p->real_pcm_attrs.channel_map[3] = SA_CHANNEL_LFE;
                 case 3:
-                    oss->real_pcm_attrs.channel_map[2] = SA_CHANNEL_CENTER;
+                    p->real_pcm_attrs.channel_map[2] = SA_CHANNEL_CENTER;
                 case 2:
-                    oss->real_pcm_attrs.channel_map[1] = SA_CHANNEL_RIGHT;
-                    oss->real_pcm_attrs.channel_map[0] = SA_CHANNEL_LEFT;
+                    p->real_pcm_attrs.channel_map[1] = SA_CHANNEL_RIGHT;
+                    p->real_pcm_attrs.channel_map[0] = SA_CHANNEL_LEFT;
                     break;
                 case 1:
-                    oss->real_pcm_attrs.channel_map[0] = SA_CHANNEL_MONO;
+                    p->real_pcm_attrs.channel_map[0] = SA_CHANNEL_MONO;
                     break;
             }
 
@@ -358,7 +395,7 @@ int driver_open(sa_stream_t *s) {
             for (;;) {
                 arg = r;
 
-                if (ioctl(oss->fd, SNDCTL_DSP_SPEED, &arg) < 0) {
+                if (ioctl(p->fd, SNDCTL_DSP_SPEED, &arg) < 0) {
                     r = SA_ERROR_SYSTEM;
                     goto fail;
                 }
@@ -446,19 +483,19 @@ int driver_open(sa_stream_t *s) {
 
             }
 
-            oss->real_pcm_attrs.rate = r;
+            p->real_pcm_attrs.rate = r;
 
-            printf("Chosen: %u channels, %uHz, format=%u\n", oss->real_pcm_attrs.nchannels, oss->real_pcm_attrs.rate, oss->real_pcm_attrs.format);
+            printf("Chosen: %u channels, %uHz, format=%u\n", p->real_pcm_attrs.nchannels, p->real_pcm_attrs.rate, p->real_pcm_attrs.format);
 
-            real_bps = oss->real_pcm_attrs.nchannels * oss->real_pcm_attrs.rate * sa_get_pcm_sample_size(oss->real_pcm_attrs.format);
+            real_bps = p->real_pcm_attrs.nchannels * p->real_pcm_attrs.rate * sa_get_pcm_sample_size(p->real_pcm_attrs.format);
 
             if (real_bps != bps && loops < 1) {
                 loops++;
 
-                sa_free(oss->real_pcm_attrs.channel_map);
-                oss->real_pcm_attrs.channel_map = NULL;
+                sa_free(p->real_pcm_attrs.channel_map);
+                p->real_pcm_attrs.channel_map = NULL;
 
-                close(oss->fd);
+                close(p->fd);
 
                 printf("bps changed, retrying...\n");
                 continue;
@@ -469,15 +506,15 @@ int driver_open(sa_stream_t *s) {
     }
 
     /* First, let's try GETBLKSIZE */
-    if (ioctl(oss->fd, SNDCTL_DSP_GETBLKSIZE, &arg) >= 0) {
+    if (ioctl(p->fd, SNDCTL_DSP_GETBLKSIZE, &arg) >= 0) {
         if (s->mode & SA_MODE_RDONLY) {
-            oss->read_fragment_size = arg;
-            oss->read_nfragments = 2;
+            p->read_fragment_size = arg;
+            p->read_nfragments = 2;
         }
 
         if (s->mode & SA_MODE_WRONLY) {
-            oss->write_fragment_size = arg;
-            oss->write_nfragments = 2;
+            p->write_fragment_size = arg;
+            p->write_nfragments = 2;
         }
     }
 
@@ -485,28 +522,28 @@ int driver_open(sa_stream_t *s) {
     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 (ioctl(p->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) {
+            p->read_fragment_size = info.fragsize;
+            p->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 (ioctl(p->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
+            p->write_fragment_size = info.fragsize;
+            p->write_nfragments = info.fragstotal;
         }
     }
 
-    if (s->mode & SA_MODE_WRONLY && (oss->write_fragment_size <= 0 || oss->write_nfragments <= 1)) {
+    if (s->mode & SA_MODE_WRONLY && (p->write_fragment_size <= 0 || p->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)) {
+    if (s->mode & SA_MODE_RDONLY && (p->read_fragment_size <= 0 || p->read_nfragments <= 1)) {
         errno = EIO;
         r = SA_ERROR_SYSTEM;
         goto fail;
@@ -517,7 +554,7 @@ int driver_open(sa_stream_t *s) {
         if (s->adjust_nchannels != 0) {
             sa_channel_t *cm;
 
-            if (!(cm = sa_newdup(sa_channel_t, oss->real_pcm_attrs.channel_map, oss->real_pcm_attrs.nchannels))) {
+            if (!(cm = sa_newdup(sa_channel_t, p->real_pcm_attrs.channel_map, p->real_pcm_attrs.nchannels))) {
                 r = SA_ERROR_OOM;
                 goto fail;
             }
@@ -525,45 +562,45 @@ int driver_open(sa_stream_t *s) {
             sa_free(s->pcm_attrs.channel_map);
             s->pcm_attrs.channel_map = cm;
 
-            s->pcm_attrs.nchannels = oss->real_pcm_attrs.nchannels;
+            s->pcm_attrs.nchannels = p->real_pcm_attrs.nchannels;
         }
         if (s->adjust_rate != 0)
-            s->pcm_attrs.rate = oss->real_pcm_attrs.rate;
+            s->pcm_attrs.rate = p->real_pcm_attrs.rate;
         if (s->adjust_pcm_format != 0)
-            s->pcm_attrs.format = oss->real_pcm_attrs.format;
+            s->pcm_attrs.format = p->real_pcm_attrs.format;
 
         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)
+            if ((r = sa_converter_init(&p->converter_read, &p->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)
+            if ((r = sa_converter_init(&p->converter_write, &s->pcm_attrs, &p->real_pcm_attrs, s->dynamic_rate_enabled)) < 0)
                 goto fail;
     }
 
 /*     if (s->adjust_watermarks) { */
 
 /*         if (s->mode & SA_MODE_RDONLY) { */
-/*             s->read_lower_watermark = oss->read_fragment_size; */
-/*             s->read_upper_watermark = oss->read_fragment_size * oss->read_nfragments; */
+/*             s->read_lower_watermark = p->read_fragment_size; */
+/*             s->read_upper_watermark = p->read_fragment_size * p->read_nfragments; */
 /*         } */
 
 /*         if (s->mode & SA_MODE_WRONLY) { */
-/*             s->write_lower_watermark = oss->write_fragment_size; */
-/*             s->write_upper_watermark = oss->write_fragment_size * oss->write_nfragments; */
+/*             s->write_lower_watermark = p->write_fragment_size; */
+/*             s->write_upper_watermark = p->write_fragment_size * p->write_nfragments; */
 /*         } */
 /*     } */
 
     if (s->mode & SA_MODE_RDONLY)
-        printf("Chosen for read: %u fragments, %u fragsize\n", oss->read_nfragments, oss->read_fragment_size);
+        printf("Chosen for read: %u fragments, %lu fragsize\n", p->read_nfragments, (unsigned long) p->read_fragment_size);
 
     if (s->mode & SA_MODE_WRONLY)
-        printf("Chosen for write: %u fragments, %u fragsize\n", oss->write_nfragments, oss->write_fragment_size);
+        printf("Chosen for write: %u fragments, %lu fragsize\n", p->write_nfragments, (unsigned long) p->write_fragment_size);
 
-    if (sa_bufferq_init(&oss->bufferq, s->ni_enabled ? s->pcm_attrs.nchannels : 1) < 0)
+    if (sa_bufferq_init(&p->bufferq, s->ni_enabled ? s->pcm_attrs.nchannels : 1) < 0)
         goto fail;
 
-    if ((oss->cdata = pa_new(void*, s->ni_enabled ? s->pcm_attrs.nchannels : 1) < 0)
+    if (!(p->cdata = sa_new(void*, s->ni_enabled ? s->pcm_attrs.nchannels : 1)))
         goto fail;
 
     return SA_SUCCESS;
@@ -573,33 +610,33 @@ fail:
     return r;
 }
 
-int driver_destroy(sa_stream_t *s) {
-    oss_stream_t *oss = OSS_STREAM(s);
+int driver_destroy(sa_stream *s) {
+    struct private *p = PRIVATE(s);
 
-    if (oss) {
+    if (p) {
 
-        if (oss->thread)
-            driver_stop_thread(s);
+        if (p->thread)
+            sa_thread_free(p->thread);
 
-        if (oss->fd >= 0)
-            close(oss->fd);
+        if (p->fd >= 0)
+            close(p->fd);
 
-        sa_bufferq_done(&oss->bufferq);
+        sa_bufferq_done(&p->bufferq);
 
-        sa_free(oss->real_pcm_attrs.channel_map);
-        sa_converter_done(&oss->converter_read);
-        sa_converter_done(&oss->converter_write);
+        sa_free(p->real_pcm_attrs.channel_map);
+        sa_converter_done(&p->converter_read);
+        sa_converter_done(&p->converter_write);
 
-        sa_free(oss->cdata);
+        sa_free(p->cdata);
 
-        sa_free(oss);
+        sa_free(p);
     }
 
     return SA_SUCCESS;
 }
 
-static int feed(sa_stream_t *s) {
-    oss_stream_t *oss = OSS_STREAM(s);
+static int feed(sa_stream *s) {
+    struct private *p = PRIVATE(s);
     size_t w;
     int ret;
 
@@ -613,8 +650,9 @@ static int feed(sa_stream_t *s) {
             size_t nbytes;
             uint8_t *d;
             sa_bool_t drop;
+            void *cdata;
 
-            sa_bufferq_get(&oss->bufferq, cdata, &nbytes);
+            sa_bufferq_get(&p->bufferq, cdata, &nbytes);
 
             if (nbytes > 0) {
                 void **dst;
@@ -622,11 +660,11 @@ static int feed(sa_stream_t *s) {
 
                 if (s->ni_enabled) {
 
-                    if ((ret = sa_converter_go(&oss->converter_write, cdata, &dst, &stride,
+/*                     if ((ret = sa_converter_go(&p->converter_write, cdata, &dst, &stride, */
 
                 } else {
 
-                    if ((ret = sa_converter_go_interleaved(&oss->converter_write, cdata, &dst, &stride, 1, &nbytes)))
+                    if ((ret = sa_converter_go_interleaved(&p->converter_write, cdata, &dst, &stride, 1, &nbytes)))
                         goto fail;
 
                     d = dst[0];
@@ -636,11 +674,12 @@ static int feed(sa_stream_t *s) {
                 s->state = SA_STATE_RUNNING;
 
             } else {
-                nbytes = w > oss->write_fragment_size ? oss->write_fragment_size : w;
+                nbytes = w > p->write_fragment_size ? p->write_fragment_size : w;
 
-                if (!(d = sa_converter_get_zero_buffer(&oss->converter_write, nbytes))) {
+                if (!(d = sa_converter_get_zero_buffer(&p->converter_write, nbytes))) {
                     ret = SA_ERROR_OOM;
                     goto fail;
+                }
 
                 drop = s->xrun_mode == SA_XRUN_MODE_SPIN;
 
@@ -651,7 +690,7 @@ static int feed(sa_stream_t *s) {
             while (nbytes > 0) {
                 ssize_t l;
 
-                if ((l = write(oss->fd, d, nbytes)) < 0) {
+                if ((l = write(p->fd, d, nbytes)) < 0) {
                     ret = SA_ERROR_SYSTEM;
                     goto fail;
                 }
@@ -664,7 +703,7 @@ static int feed(sa_stream_t *s) {
                 w -= 1;
 
                 if (drop)
-                    sa_bufferq_drop(&oss->bufferq, l);
+                    sa_bufferq_drop(&p->bufferq, l);
             }
         }
     }
@@ -673,21 +712,21 @@ static int feed(sa_stream_t *s) {
 
 fail:
 
-    sa_free(i);
+/*     sa_free(i); */
 
     return ret;
 }
 
 enum {
     POLLFD_OSS_FD,
-    POLLFD_PIPE_FD,
+    POLLFD_SOCKET_FD,
     POLLFD_MAX
 };
 
 static void thread_func(void *data) {
     struct pollfd pollfds[POLLFD_MAX];
-    sa_stream_t *s = data;
-    oss_stream_t *oss = OSS_STREAM(s);
+    sa_stream *s = data;
+    struct private *p = PRIVATE(s);
     sigset_t mask;
 
     sa_assert_se(sigfillset(&mask) == 0);
@@ -701,10 +740,10 @@ static void thread_func(void *data) {
 
     memset(pollfds, 0, sizeof(pollfds));
 
-    pollfds[POLLFD_SOCKET_FD].fd = oss->socket_fds[0];
+    pollfds[POLLFD_SOCKET_FD].fd = p->socket_fds[0];
     pollfds[POLLFD_SOCKET_FD].events = POLLIN;
 
-    pollfds[POLLFD_OSS_FD].fd = oss->fd;
+    pollfds[POLLFD_OSS_FD].fd = p->fd;
     pollfds[POLLFD_OSS_FD].events = ((s->mode & SA_MODE_RDONLY) ? POLLIN : 0) | ((s->mode & SA_MODE_WRONLY) ? POLLOUT : 0);
 
     for (;;) {
@@ -753,127 +792,127 @@ static void thread_func(void *data) {
     }
 }
 
-int driver_start_thread(sa_stream_t *s, sa_event_callback_t callback) {
-    oss_stream_t *oss = OSS_STREAM(s);
-    sa_return_val_if_fail(!oss->thread, SA_ERROR_STATE);
+/* int driver_start_thread(sa_stream *s, sa_event_callback_t callback) { */
+/*     struct private *p = PRIVATE(s); */
+/*     sa_return_val_if_fail(!p->thread, SA_ERROR_STATE); */
 
-    s->callback = callback;
+/*     s->callback = callback; */
 
-    if ((socketpair(AF_UNIX, SOCK_DGRAM, 0, oss->socket_fds)) < 0)
-        return SA_ERROR_SYSTEM;
+/*     if ((socketpair(AF_UNIX, SOCK_DGRAM, 0, p->socket_fds)) < 0) */
+/*         return SA_ERROR_SYSTEM; */
 
-    if (!(oss->thread = sa_thread_new(thread_func, s)))
-        return SA_ERROR_OOM;
+/*     if (!(p->thread = sa_thread_new(thread_func, s))) */
+/*         return SA_ERROR_OOM; */
 
-    return SA_SUCCESS;
-}
+/*     return SA_SUCCESS; */
+/* } */
 
-int driver_stop_thread(sa_stream_t *s) {
-    oss_stream_t *oss = OSS_STREAM(s);
-    sa_return_val_if_fail(oss->thread, SA_ERROR_STATE);
-    sa_return_val_if_fail(oss->thread != sa_thread_self(), SA_ERROR_STATE);
+/* int driver_stop_thread(sa_stream *s) { */
+/*     struct private *p = PRIVATE(s); */
+/*     sa_return_val_if_fail(p->thread, SA_ERROR_STATE); */
+/*     sa_return_val_if_fail(p->thread != sa_thread_self(), SA_ERROR_STATE); */
 
-    if (oss->socket_fds[0] >= 0)
-        close(oss->socket_fds[0]);
+/*     if (p->socket_fds[0] >= 0) */
+/*         close(p->socket_fds[0]); */
 
-    if (oss->socket_fds[1] >= 0)
-        close(oss->socket_fds[1]);
+/*     if (p->socket_fds[1] >= 0) */
+/*         close(p->socket_fds[1]); */
 
-    if (oss->thread)
-        sa_thread_free(oss->thread);
+/*     if (p->thread) */
+/*         sa_thread_free(p->thread); */
 
-    oss->thread = NULL;
-    oss->socket_fds[0] = oss->socket_fds[1] = -1;
+/*     p->thread = NULL; */
+/*     p->socket_fds[0] = p->socket_fds[1] = -1; */
 
-    return SA_SUCCESS;
-}
+/*     return SA_SUCCESS; */
+/* } */
 
-int driver_change_read_volume(sa_stream_t *s, const int32_t vol[]) {
-    oss_stream_t *oss = OSS_STREAM(s);
+int driver_change_read_volume(sa_stream *s, const int32_t vol[]) {
+    struct private *p = PRIVATE(s);
 
-    sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_NOTSUPPORTED);
 
-    sa_converter_set_volume(&oss->converter_read, vol);
+    sa_converter_set_volume(&p->converter_read, vol);
 
     return SA_SUCCESS;
 }
 
-int driver_change_write_volume(sa_stream_t *s, const int32_t vol[]) {
-    oss_stream_t *oss = OSS_STREAM(s);
+int driver_change_write_volume(sa_stream *s, const int32_t vol[]) {
+    struct private *p = PRIVATE(s);
 
-    sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_NOTSUPPORTED);
 
-    sa_converter_set_volume(&oss->converter_write, vol);
+    sa_converter_set_volume(&p->converter_write, vol);
 
     return SA_SUCCESS;
 }
 
-int driver_change_rate(sa_stream_t *s, unsigned rate) {
-    oss_stream_t *oss = OSS_STREAM(s);
+int driver_change_pcm_rate(sa_stream *s, unsigned rate) {
+    struct private *p = PRIVATE(s);
 
     if (s->mode & SA_MODE_RDONLY)
-        sa_converter_set_ratio(&oss->converter_read, oss->real_pcm_attrs.rate, s->pcm_attrs.rate);
+        sa_converter_set_ratio(&p->converter_read, p->real_pcm_attrs.rate, s->pcm_attrs.rate);
     if (s->mode & SA_MODE_WRONLY)
-        sa_converter_set_ratio(&oss->converter_write, s->pcm_attrs.rate, oss->real_pcm_attrs.rate);
+        sa_converter_set_ratio(&p->converter_write, s->pcm_attrs.rate, p->real_pcm_attrs.rate);
 
     return SA_SUCCESS;
 }
 
-int driver_get_state(sa_stream_t *s, sa_state_t *state) {
+int driver_get_state(sa_stream *s, sa_state_t *state) {
     *state = s->state;
     return SA_SUCCESS;
 }
 
-int driver_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_get_position(sa_stream *s, sa_position_t position, int64_t *pos) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_read(sa_stream_t *s, void *data, size_t nbytes) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_read(sa_stream *s, void *data, size_t nbytes) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    oss_stream_t *oss = OSS_STREAM(s);
+int driver_pwrite(sa_stream *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+    struct private *p = PRIVATE(s);
     int ret, ret2;
 
-    if ((ret = sa_bufferq_push(&oss->bufferq, 0, data, nbytes, offset, whence, SA_BUFFERQ_ITEM_STATIC)))
+    if ((ret = sa_bufferq_push(&p->bufferq, 0, data, nbytes, offset, whence, SA_BUFFERQ_ITEM_STATIC)))
         return ret;
 
     ret = feed(s);
-    ret2 = sa_bufferq_realloc(&oss->bufferq);
+    ret2 = sa_bufferq_realloc(&p->bufferq);
 
     return ret ? ret : ret2;
 }
 
-int driver_read_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_read_ni(sa_stream *s, unsigned channel, void *data, size_t nbytes) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_pwrite_ni(sa_stream_t *s, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_pwrite_ni(sa_stream *s, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_get_read_size(sa_stream_t *s, size_t *size) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_get_read_size(sa_stream *s, size_t *size) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_get_write_size(sa_stream_t *s, size_t *size)  {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_get_write_size(sa_stream *s, size_t *size)  {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_resume(sa_stream_t *s) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_resume(sa_stream *s) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_pause(sa_stream_t *s) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_pause(sa_stream *s) {
+    return SA_ERROR_NOTSUPPORTED;
 }
 
-int driver_drain(sa_stream_t *s) {
-    oss_stream_t *oss = OSS_STREAM(s);
-    sa_return_val_if_fail(!oss->thread, SA_ERROR_STATE);
+int driver_drain(sa_stream *s) {
+    struct private *p = PRIVATE(s);
+    sa_return_val_if_fail(!p->thread, SA_ERROR_STATE);
 
-    if (ioctl(oss->fd, SNDCTL_DSP_SYNC, NULL) < 0)
+    if (ioctl(p->fd, SNDCTL_DSP_SYNC, NULL) < 0)
         return SA_ERROR_SYSTEM;
 
     return SA_SUCCESS;
@@ -881,10 +920,6 @@ int driver_drain(sa_stream_t *s) {
 
 /* Unsupported operations */
 
-int driver_change_device(sa_stream_t *s, const char *device) {
-    return SA_ERROR_NOT_SUPPORTED;
-}
-
-int driver_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size) {
-    return SA_ERROR_NOT_SUPPORTED;
+int driver_change_device(sa_stream *s, const char *device) {
+    return SA_ERROR_NOTSUPPORTED;
 }