s/device/stream

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

1 files changed, 68 insertions, 67 deletions

diff --git a/oss.c b/oss.c
index bd4f12b..0a80379 100644
--- a/oss.c
+++ b/oss.c
@@ -10,22 +10,23 @@
 #include "macro.h"
 #include "malloc.h"
 #include "converter.h"
+#include "driver.h"
 
 #define DEFAULT_DEVICE "/dev/dsp"
 #define DRIVER_NAME "oss"
 
-typedef struct oss_device oss_device_t;
-#define OSS_DEVICE(x) ((oss_device_t*) (x->private))
+typedef struct oss_stream oss_stream_t;
+#define OSS_STREAM(x) ((oss_stream_t*) (x->private))
 
-struct oss_device {
-    sa_device_t *parent;
+struct oss_stream {
+    sa_stream_t *parent;
     int fd;
     pcm_attrs_t real_pcm_attrs;
     converter_t converter_read, converter_write;
 };
 
-int device_open(sa_device_t *dev) {
-    oss_device_t *oss;
+int driver_open(sa_stream_t *s) {
+    oss_stream_t *oss;
     char *n;
     int f, arg, bs, r, phase, i, found, suggested;
     unsigned c;
@@ -45,16 +46,16 @@ int device_open(sa_device_t *dev) {
     };
     static const int try_rates[] = { 8000, 16000, 32000, 44100, 48000, 96000, 192000 };
 
-    if (dev->driver && strcmp(dev->driver, DRIVER_NAME))
+    if (s->driver && strcmp(s->driver, DRIVER_NAME))
         return SA_ERROR_NO_DRIVER;
 
-    if (!(dev->private = oss = sa_new0(oss_device_t, 1)))
+    if (!(s->private = oss = sa_new0(oss_stream_t, 1)))
         return SA_ERROR_OOM;
 
-    oss->parent = dev;
+    oss->parent = s;
 
-    n = dev->device ? dev->device : DEFAULT_DEVICE;
-    if ((oss->fd = open(n, dev->mode == SA_MODE_RDONLY ? O_RDONLY : (dev->mode == SA_MODE_WRONLY ? O_WRONLY : O_RDWR) | O_NOCTTY | O_NONBLOCK)) < 0) {
+    n = s->device ? s->device : DEFAULT_DEVICE;
+    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)
             return SA_ERROR_NO_DEVICE;
@@ -64,24 +65,24 @@ int device_open(sa_device_t *dev) {
 
     fcntl(oss->fd, F_SETFL, fcntl(oss->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/
     
-    if (!dev->device) {
+    if (!s->device) {
         if (!(n = sa_strdup(n)))
             return SA_ERROR_OOM;
 
-        dev->device = n;
+        s->device = n;
     }
 
-    if (dev->codec) {
+    if (s->codec) {
 
-        if (strcmp(dev->codec, SA_CODEC_AC3) == 0)
+        if (strcmp(s->codec, SA_CODEC_AC3) == 0)
             f = AFMT_AC3;
-        else if (strcmp(dev->codec, SA_CODEC_MPEG) == 0)
+        else if (strcmp(s->codec, SA_CODEC_MPEG) == 0)
             f = AFMT_MPEG;
         else
             return SA_ERROR_NO_CODEC;
         
     } else
-        f = format_map[dev->pcm_attrs.format];
+        f = format_map[s->pcm_attrs.format];
 
     bs = 0;
     
@@ -120,7 +121,7 @@ int device_open(sa_device_t *dev) {
             return SA_ERROR_NO_PCM_FORMAT;
     }
 
-    if (!dev->codec) {
+    if (!s->codec) {
 
         switch (f) {
             case AFMT_MU_LAW:
@@ -150,10 +151,10 @@ int device_open(sa_device_t *dev) {
         
         found = 0;
 
-        if (dev->adjust_nchannels >= 0) {
+        if (s->adjust_nchannels >= 0) {
             
             /* First try more channels ... */
-            for (c = dev->pcm_attrs.nchannels; c < 8 || c == dev->pcm_attrs.nchannels; c ++) {
+            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)
                     return SA_ERROR_SYSTEM;
@@ -166,7 +167,7 @@ int device_open(sa_device_t *dev) {
 
             /* ... then try less channels */
             if (!found) {
-                for (c = dev->pcm_attrs.nchannels - 1; c > 0; c --) {
+                for (c = s->pcm_attrs.nchannels - 1; c > 0; c --) {
                     arg = c;
                     if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0)
                         return SA_ERROR_SYSTEM;
@@ -180,7 +181,7 @@ int device_open(sa_device_t *dev) {
         } else {
             
             /* First try less channels ... */
-            for (c = dev->pcm_attrs.nchannels; c > 0; c --) {
+            for (c = s->pcm_attrs.nchannels; c > 0; c --) {
                 arg = c;
                 if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0)
                     return SA_ERROR_SYSTEM;
@@ -193,7 +194,7 @@ int device_open(sa_device_t *dev) {
 
             /* ... then try more channels */
             if (!found) {
-                for (c = dev->pcm_attrs.nchannels + 1; c < 8; c ++) {
+                for (c = s->pcm_attrs.nchannels + 1; c < 8; c ++) {
                     arg = c;
                     if (ioctl(oss->fd, SNDCTL_DSP_CHANNELS, &arg) < 0)
                         return SA_ERROR_SYSTEM;
@@ -238,7 +239,7 @@ int device_open(sa_device_t *dev) {
                 break;
         }
 
-        r = dev->pcm_attrs.rate;
+        r = s->pcm_attrs.rate;
 
         if (r < 8000)
             r = 8000;
@@ -260,7 +261,7 @@ int device_open(sa_device_t *dev) {
             if (arg > suggested)
                 suggested = arg;
 
-            if (dev->adjust_rate >= 0) {
+            if (s->adjust_rate >= 0) {
                 
                 if (phase == 0) {
                     /* Find the next higher sample rate to try */
@@ -277,7 +278,7 @@ int device_open(sa_device_t *dev) {
                     
                     if (i == elementsof(try_rates)) {
                         phase = 1;
-                        r = dev->pcm_attrs.rate;
+                        r = s->pcm_attrs.rate;
                     }
                 }
 
@@ -312,7 +313,7 @@ int device_open(sa_device_t *dev) {
                     
                     if (i == 0) {
                         phase = 1;
-                        r = dev->pcm_attrs.rate;
+                        r = s->pcm_attrs.rate;
                     }
                 }
 
@@ -339,27 +340,27 @@ int device_open(sa_device_t *dev) {
 
         printf("Chosen: %u channels, %uHz, format=%u\n", oss->real_pcm_attrs.nchannels, oss->real_pcm_attrs.rate, oss->real_pcm_attrs.format);
 
-        if (dev->adjust_nchannels != 0)
-            dev->pcm_attrs.nchannels = oss->real_pcm_attrs.nchannels;
-        if (dev->adjust_rate != 0)
-            dev->pcm_attrs.rate = oss->real_pcm_attrs.rate;
-        if (dev->adjust_pcm_format != 0)
-            dev->pcm_attrs.format = oss->real_pcm_attrs.format;
+        if (s->adjust_nchannels != 0)
+            s->pcm_attrs.nchannels = oss->real_pcm_attrs.nchannels;
+        if (s->adjust_rate != 0)
+            s->pcm_attrs.rate = oss->real_pcm_attrs.rate;
+        if (s->adjust_pcm_format != 0)
+            s->pcm_attrs.format = oss->real_pcm_attrs.format;
 
-        if (dev->mode & SA_MODE_RDONLY)
-            if ((r = converter_init(&oss->converter_read, &oss->real_pcm_attrs, &dev->pcm_attrs, dev->dynamic_rate_enabled)) < 0)
+        if (s->mode & SA_MODE_RDONLY)
+            if ((r = converter_init(&oss->converter_read, &oss->real_pcm_attrs, &s->pcm_attrs, s->dynamic_rate_enabled)) < 0)
                 return r;
         
-        if (dev->mode & SA_MODE_WRONLY)
-            if ((r = converter_init(&oss->converter_write, &dev->pcm_attrs, &oss->real_pcm_attrs, dev->dynamic_rate_enabled)) < 0)
+        if (s->mode & SA_MODE_WRONLY)
+            if ((r = converter_init(&oss->converter_write, &s->pcm_attrs, &oss->real_pcm_attrs, s->dynamic_rate_enabled)) < 0)
                 return r;
     }
 
     return SA_SUCCESS;
 }
 
-int device_destroy(sa_device_t *dev) {
-    oss_device_t *oss = OSS_DEVICE(dev);
+int driver_destroy(sa_stream_t *s) {
+    oss_stream_t *oss = OSS_STREAM(s);
 
     if (oss->fd >= 0)
         close(oss->fd);
@@ -371,55 +372,55 @@ int device_destroy(sa_device_t *dev) {
     return SA_SUCCESS;
 }
 
-int device_start_thread(sa_device_t *dev, sa_event_callback_t *callback) {
+int driver_start_thread(sa_stream_t *s, sa_event_callback_t *callback) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_change_input_volume(sa_device_t *dev, int vol[]) {
-    oss_device_t *oss = OSS_DEVICE(dev);
+int driver_change_input_volume(sa_stream_t *s, const int vol[]) {
+    oss_stream_t *oss = OSS_STREAM(s);
 
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_NOT_SUPPORTED);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
 
     converter_set_volume(&oss->converter_read, vol);
     
     return SA_SUCCESS;
 }
 
-int device_change_output_volume(sa_device_t *dev, int vol[]) {
-    oss_device_t *oss = OSS_DEVICE(dev);
+int driver_change_output_volume(sa_stream_t *s, const int vol[]) {
+    oss_stream_t *oss = OSS_STREAM(s);
 
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_NOT_SUPPORTED);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
 
     converter_set_volume(&oss->converter_write, vol);
     
     return SA_SUCCESS;
 }
 
-int device_change_rate(sa_device_t *dev, unsigned rate) {
-    oss_device_t *oss = OSS_DEVICE(dev);
+int driver_change_rate(sa_stream_t *s, unsigned rate) {
+    oss_stream_t *oss = OSS_STREAM(s);
 
-    if (dev->mode & SA_MODE_RDONLY)
-        converter_set_ratio(&oss->converter_read, oss->real_pcm_attrs.rate, dev->pcm_attrs.rate);
-    if (dev->mode & SA_MODE_WRONLY)
-        converter_set_ratio(&oss->converter_write, dev->pcm_attrs.rate, oss->real_pcm_attrs.rate);
+    if (s->mode & SA_MODE_RDONLY)
+        converter_set_ratio(&oss->converter_read, oss->real_pcm_attrs.rate, s->pcm_attrs.rate);
+    if (s->mode & SA_MODE_WRONLY)
+        converter_set_ratio(&oss->converter_write, s->pcm_attrs.rate, oss->real_pcm_attrs.rate);
 
     return SA_SUCCESS;
 }
 
-int device_get_state(sa_device_t *dev, sa_state_t *state) {
+int driver_get_state(sa_stream_t *s, sa_state_t *state) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_get_position(sa_device_t *dev, sa_position_t position, int64_t *pos) {
+int driver_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_pread(sa_device_t *dev, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+int driver_pread(sa_stream_t *s, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_pwrite(sa_device_t *dev, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    oss_device_t *oss = OSS_DEVICE(dev);
+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);
     void **dst;
     size_t *stride;
     int ret;
@@ -445,32 +446,32 @@ int device_pwrite(sa_device_t *dev, const void *data, size_t nbytes, int64_t off
     return SA_SUCCESS;
 }
 
-int device_pread_ni(sa_device_t *dev, unsigned channel, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+int driver_pread_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_pwrite_ni(sa_device_t *dev, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+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 device_get_read_size(sa_device_t *dev, size_t *size) {
+int driver_get_read_size(sa_stream_t *s, size_t *size) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_get_write_size(sa_device_t *dev, size_t *size)  {
+int driver_get_write_size(sa_stream_t *s, size_t *size)  {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_resume(sa_device_t *dev) {
+int driver_resume(sa_stream_t *s) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_pause(sa_device_t *dev) {
+int driver_pause(sa_stream_t *s) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_drain(sa_device_t *dev) {
-    oss_device_t *oss = OSS_DEVICE(dev);
+int driver_drain(sa_stream_t *s) {
+    oss_stream_t *oss = OSS_STREAM(s);
 
     if (ioctl(oss->fd, SNDCTL_DSP_SYNC, NULL) < 0)
         return SA_ERROR_SYSTEM;
@@ -480,10 +481,10 @@ int device_drain(sa_device_t *dev) {
 
 /* Unsupported operations */
 
-int device_change_device(sa_device_t *dev) {
+int driver_change_device(sa_stream_t *s, const char *device) {
     return SA_ERROR_NOT_SUPPORTED;
 }
 
-int device_change_meta_data(sa_device_t *dev, const char *name, const void *data, size_t size) {
+int driver_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size) {
     return SA_ERROR_NOT_SUPPORTED;
 }