From 08ee90ea2e6ea839846c5670afa9d1a19c20ba78 Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Sun, 13 May 2007 00:49:21 +0000
Subject: s/device/stream

git-svn-id: file:///home/lennart/svn/public/libsydney/trunk@7 9ba3c220-e4d3-45a2-8aa3-73fcc9aff6ce
---
 common.c | 468 +++++++++++++++++++++++++++++++--------------------------------
 1 file changed, 234 insertions(+), 234 deletions(-)

(limited to 'common.c')

diff --git a/common.c b/common.c
index ea9858c..7219ae5 100644
--- a/common.c
+++ b/common.c
@@ -11,10 +11,10 @@
 /* contains code */
 #include "meta-name-table.h"
 
-static sa_device_t *device_alloc(void) {
-    sa_device_t *d;
+static sa_stream_t *stream_alloc(void) {
+    sa_stream_t *d;
 
-    if (!(d = sa_new0(sa_device_t, 1)))
+    if (!(d = sa_new0(sa_stream_t, 1)))
         return NULL;
 
     /* All fields a carefully chosen in a way that initializing them
@@ -23,23 +23,23 @@ static sa_device_t *device_alloc(void) {
     return d;
 }
 
-int sa_device_create_opaque(
-        sa_device_t **dev,
+int sa_stream_create_opaque(
+        sa_stream_t **s,
         sa_mode_t mode,
         const char *codec) {
     
     int error;
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    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(codec, SA_ERROR_INVALID);
 
-    if (!(*dev = device_alloc()))
+    if (!(*s = stream_alloc()))
         return SA_ERROR_OOM;
 
-    (*dev)->mode = mode;
+    (*s)->mode = mode;
 
-    if (!((*dev)->codec = sa_strdup(codec))) {
+    if (!((*s)->codec = sa_strdup(codec))) {
         error = SA_ERROR_OOM;
         goto fail;
     }
@@ -49,12 +49,12 @@ int sa_device_create_opaque(
     return SA_SUCCESS;
 
 fail:
-    sa_device_destroy(*dev);
+    sa_stream_destroy(*s);
     return error;
 }
 
-int sa_device_create_pcm(
-        sa_device_t **dev,
+int sa_stream_create_pcm(
+        sa_stream_t **s,
         sa_mode_t mode,
         sa_pcm_format_t format,
         unsigned rate,
@@ -62,30 +62,30 @@ int sa_device_create_pcm(
 
     int ret;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    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);
     sa_return_val_if_fail(rate > 0, SA_ERROR_INVALID);
     sa_return_val_if_fail(nchannels > 0, SA_ERROR_INVALID);
 
-    if (!(*dev = device_alloc()))
+    if (!(*s = stream_alloc()))
         return SA_ERROR_OOM;
 
-    (*dev)->mode = mode;
-    (*dev)->pcm_attrs.format = format;
-    (*dev)->pcm_attrs.nchannels = nchannels;
-    (*dev)->pcm_sample_size = get_pcm_sample_size(format);
-    (*dev)->pcm_frame_size = (*dev)->pcm_sample_size * nchannels;
+    (*s)->mode = mode;
+    (*s)->pcm_attrs.format = format;
+    (*s)->pcm_attrs.nchannels = nchannels;
+    (*s)->pcm_sample_size = get_pcm_sample_size(format);
+    (*s)->pcm_frame_size = (*s)->pcm_sample_size * nchannels;
 
     if (nchannels <= 2) {
         static const sa_channel_t map_stereo[2] = { SA_CHANNEL_LEFT, SA_CHANNEL_RIGHT };
         static const sa_channel_t map_mono[1] = { SA_CHANNEL_MONO };
 
-        if ((ret = sa_device_set_channel_map(*dev, nchannels == 2 ? map_stereo : map_mono)))
+        if ((ret = sa_stream_set_channel_map(*s, nchannels == 2 ? map_stereo : map_mono)))
             goto fail;
     }
 
-    if ((ret = sa_device_change_rate(*dev, rate)))
+    if ((ret = sa_stream_change_rate(*s, rate)))
         goto fail;
 
     oil_init();
@@ -94,457 +94,457 @@ int sa_device_create_pcm(
 
 fail:
     
-    sa_device_destroy(*dev);
+    sa_stream_destroy(*s);
     return ret;
 }
 
-int sa_device_open(sa_device_t *dev) {
+int sa_stream_open(sa_stream_t *s) {
     int ret;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    if ((ret = device_open(dev)) == 0)
-        dev->state = SA_STATE_STOPPED;
+    if ((ret = driver_open(s)) == 0)
+        s->state = SA_STATE_STOPPED;
 
     return ret;
 }
 
-int sa_device_destroy(sa_device_t *dev) {
+int sa_stream_destroy(sa_stream_t *s) {
     int ret;
     unsigned u;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
 
-    ret = device_destroy(dev);
+    ret = driver_destroy(s);
 
-    sa_free(dev->codec);
-    sa_free(dev->driver);
-    sa_free(dev->device);
-    sa_free(dev->pcm_attrs.channel_map);
-    sa_free(dev->input_volume);
-    sa_free(dev->output_volume);
+    sa_free(s->codec);
+    sa_free(s->driver);
+    sa_free(s->device);
+    sa_free(s->pcm_attrs.channel_map);
+    sa_free(s->input_volume);
+    sa_free(s->output_volume);
 
     for (u = 0; u < META_NAMES_MAX; u++)
-        sa_free(dev->meta_data[u]);
+        sa_free(s->meta_data[u]);
 
-    sa_free(dev);
+    sa_free(s);
     return ret;
 }
 
-int sa_device_set_write_lower_watermark(sa_device_t *dev, size_t size) {
+int sa_stream_set_write_lower_watermark(sa_stream_t *s, size_t size) {
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->write_lower_watermark = size;
+    s->write_lower_watermark = size;
     return SA_SUCCESS;
 }
 
-int sa_device_set_read_lower_watermark(sa_device_t *dev, size_t size) {
+int sa_stream_set_read_lower_watermark(sa_stream_t *s, size_t size) {
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->read_lower_watermark = size;
+    s->read_lower_watermark = size;
     return SA_SUCCESS;
 }
 
-int sa_device_set_write_upper_watermark(sa_device_t *dev, size_t size) {
+int sa_stream_set_write_upper_watermark(sa_stream_t *s, size_t size) {
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->write_upper_watermark = size;
+    s->write_upper_watermark = size;
     return SA_SUCCESS;
 }
 
-int sa_device_set_read_upper_watermark(sa_device_t *dev, size_t size) {
+int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size) {
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->read_upper_watermark = size;
+    s->read_upper_watermark = size;
     return SA_SUCCESS;
 }
 
-int sa_device_set_channel_map(sa_device_t *dev, const sa_channel_t *map) {
+int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map) {
     const sa_channel_t *c;
     sa_channel_t *m;
     unsigned n;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(map, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
-    for (c = map, n = dev->pcm_attrs.nchannels; n > 0; c++, n--)
+    for (c = map, n = s->pcm_attrs.nchannels; n > 0; c++, n--)
         if (*c >= SA_CHANNEL_MAX)
             return SA_ERROR_INVALID;
     
-    if (!(m = sa_memdup(map, sizeof(sa_channel_t) * dev->pcm_attrs.nchannels)))
+    if (!(m = sa_memdup(map, sizeof(sa_channel_t) * s->pcm_attrs.nchannels)))
         return SA_ERROR_OOM;
 
-    sa_free(dev->pcm_attrs.channel_map);
-    dev->pcm_attrs.channel_map = m;
+    sa_free(s->pcm_attrs.channel_map);
+    s->pcm_attrs.channel_map = m;
 
     return SA_SUCCESS;
 }
 
-int sa_device_set_xrun_mode(sa_device_t *dev, sa_xrun_mode_t mode) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_set_xrun_mode(sa_stream_t *s, sa_xrun_mode_t mode) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(mode == SA_XRUN_MODE_STOP || mode == SA_XRUN_MODE_SPIN, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->xrun_mode = mode;
+    s->xrun_mode = mode;
     return SA_SUCCESS;
 }
 
-int sa_device_set_ni(sa_device_t *dev, int enable) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+int sa_stream_set_ni(sa_stream_t *s, int enable) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
-    dev->ni_enabled = !!enable;
+    s->ni_enabled = !!enable;
     return SA_SUCCESS;
 }
 
-int sa_device_set_dynamic_rate(sa_device_t *dev, int enable) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+int sa_stream_set_dynamic_rate(sa_stream_t *s, int enable) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
-    dev->dynamic_rate_enabled = !!enable;
+    s->dynamic_rate_enabled = !!enable;
     return SA_SUCCESS;
 }
 
-int sa_device_set_driver(sa_device_t *dev, const char *driver) {
+int sa_stream_set_driver(sa_stream_t *s, const char *driver) {
     char *d;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(driver, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
     if (!(d = sa_strdup(driver)))
         return SA_ERROR_OOM;
     
-    sa_free(dev->driver);
-    dev->driver = d;
+    sa_free(s->driver);
+    s->driver = d;
     
     return SA_SUCCESS;
 }
 
-int sa_device_start_thread(sa_device_t *dev, sa_event_callback_t *callback) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t *callback) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(callback, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->codec || dev->pcm_attrs.channel_map, SA_ERROR_NO_INIT);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->codec || s->pcm_attrs.channel_map, SA_ERROR_NO_INIT);
 
-    return device_start_thread(dev, callback);
+    return driver_start_thread(s, callback);
 }
 
-int sa_device_change_device(sa_device_t *dev, const char *device_name) {
+int sa_stream_change_device(sa_stream_t *s, const char *device_name) {
     char *d;
     int ret;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(device_name, SA_ERROR_INVALID);
 
     if (!(d = sa_strdup(device_name)))
         return SA_ERROR_OOM;
 
-    ret = dev->state == SA_STATE_INIT ? SA_SUCCESS : device_change_device(dev, device_name);
+    ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_device(s, device_name);
 
     if (ret == SA_SUCCESS) {
-        sa_free(dev->device);
-        dev->device = d;
+        sa_free(s->device);
+        s->device = d;
     } else
         sa_free(d);
 
     return ret;
 }
 
-int sa_device_change_input_volume(sa_device_t *dev, const int vol[]) {
+int sa_stream_change_input_volume(sa_stream_t *s, const int vol[]) {
     int *v, ret;
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(vol, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_NOT_SUPPORTED);
-    sa_return_val_if_fail(dev->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
 
-    if (!(v = sa_newdup(vol, int, dev->pcm_attrs.nchannels)))
+    if (!(v = sa_newdup(vol, int, s->pcm_attrs.nchannels)))
         return SA_ERROR_OOM;
     
-    ret = dev->state == SA_STATE_INIT ? SA_SUCCESS : device_change_input_volume(dev, v);
+    ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_input_volume(s, v);
 
     if (ret == SA_SUCCESS) {
-        sa_free(dev->input_volume);
-        dev->input_volume = v;
+        sa_free(s->input_volume);
+        s->input_volume = v;
     } else
         sa_free(v);
 
     return ret;
 }
 
-int sa_device_change_output_volume(sa_device_t *dev, const int vol[]) {
+int sa_stream_change_output_volume(sa_stream_t *s, const int vol[]) {
     int *v, ret;
 
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(vol, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_NOT_SUPPORTED);
-    sa_return_val_if_fail(dev->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
 
-    if (!(v = sa_newdup(vol, int, dev->pcm_attrs.nchannels)))
+    if (!(v = sa_newdup(vol, int, s->pcm_attrs.nchannels)))
         return SA_ERROR_OOM;
 
-    ret = dev->state == SA_STATE_INIT ? SA_SUCCESS : device_change_output_volume(dev, v);
+    ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_output_volume(s, v);
 
     if (ret == SA_SUCCESS) {
-        sa_free(dev->output_volume);
-        dev->output_volume = v;
+        sa_free(s->output_volume);
+        s->output_volume = v;
     } else
         sa_free(v);
 
     return ret;
 }
 
-int sa_device_change_rate(sa_device_t *dev, unsigned rate) {
+int sa_stream_change_rate(sa_stream_t *s, unsigned rate) {
     int ret;
     
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(rate > 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->dynamic_rate_enabled || dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->dynamic_rate_enabled || s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    ret = dev->state == SA_STATE_INIT ? SA_SUCCESS : device_change_rate(dev, rate);
+    ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_rate(s, rate);
 
     if (ret == SA_SUCCESS)
-        dev->pcm_attrs.rate = rate;
+        s->pcm_attrs.rate = rate;
 
     return ret;
 }
 
-int sa_device_change_user_data(sa_device_t *dev, void *value) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_change_user_data(sa_stream_t *s, void *value) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
 
-    dev->user_data = value;
+    s->user_data = value;
     return SA_SUCCESS;
 }
 
-int sa_device_adjust_rate(sa_device_t *dev, sa_adjust_t direction) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+int sa_stream_adjust_rate(sa_stream_t *s, sa_adjust_t direction) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->adjust_rate = direction;
+    s->adjust_rate = direction;
     return SA_SUCCESS;
 }
 
-int sa_device_adjust_nchannels(sa_device_t *dev, sa_adjust_t direction) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+int sa_stream_adjust_nchannels(sa_stream_t *s, sa_adjust_t direction) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->adjust_rate = direction;
+    s->adjust_rate = direction;
     return SA_SUCCESS;
 }
 
-int sa_device_adjust_pcm_format(sa_device_t *dev, sa_adjust_t direction) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_INIT, SA_ERROR_STATE);
+int sa_stream_adjust_pcm_format(sa_stream_t *s, sa_adjust_t direction) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
 
-    dev->adjust_pcm_format = direction;
+    s->adjust_pcm_format = direction;
     return SA_SUCCESS;
 }
 
-int sa_device_get_state(sa_device_t *dev, sa_state_t *state) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_state(sa_stream_t *s, sa_state_t *state) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(state, SA_ERROR_INVALID);
 
-    return device_get_state(dev, state);
+    return driver_get_state(s, state);
 }
 
-int sa_device_get_rate(sa_device_t *dev, unsigned *rate) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_rate(sa_stream_t *s, unsigned *rate) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(rate, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
-    *rate = dev->pcm_attrs.rate;
+    *rate = s->pcm_attrs.rate;
     return SA_SUCCESS;
 }
 
-int sa_device_get_nchannels(sa_device_t *dev, int *nchannels) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_nchannels(sa_stream_t *s, int *nchannels) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(nchannels, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
-    *nchannels = dev->pcm_attrs.nchannels;
+    *nchannels = s->pcm_attrs.nchannels;
     return SA_SUCCESS;
 }
 
-int sa_device_get_pcm_format(sa_device_t *dev, sa_pcm_format_t *pcm_format) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_pcm_format(sa_stream_t *s, sa_pcm_format_t *pcm_format) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(pcm_format, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
-    *pcm_format = dev->pcm_attrs.format;
+    *pcm_format = s->pcm_attrs.format;
     return SA_SUCCESS;
 }
 
-int sa_device_get_user_data(sa_device_t *dev, void **value) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_user_data(sa_stream_t *s, void **value) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(value, SA_ERROR_INVALID);
 
-    *value = dev->user_data;
+    *value = s->user_data;
     return SA_SUCCESS;
 }
 
-int sa_device_get_event_error(sa_device_t *dev, sa_error_t *error) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_event_error(sa_stream_t *s, sa_error_t *error) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(error, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->event == SA_EVENT_ERROR, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->event == SA_EVENT_ERROR, SA_ERROR_STATE);
 
-    *error = dev->error;
+    *error = s->error;
     return SA_SUCCESS;
 }
 
-int sa_device_get_event_notify(sa_device_t *dev, sa_notify_t *notify) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_event_notify(sa_stream_t *s, sa_notify_t *notify) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(notify, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->event == SA_EVENT_NOTIFY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->event == SA_EVENT_NOTIFY, SA_ERROR_STATE);
 
-    *notify = dev->notify;
+    *notify = s->notify;
     return SA_SUCCESS;
 }
 
-int sa_device_get_position(sa_device_t *dev, sa_position_t position, int64_t *pos) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
+    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);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_get_position(dev, position, pos);
+    return driver_get_position(s, position, pos);
 }
 
-int sa_device_read(sa_device_t *dev, void *data, size_t nbytes) {
-    return sa_device_pread(dev, data, nbytes, 0, SA_SEEK_RELATIVE);
+int sa_stream_read(sa_stream_t *s, void *data, size_t nbytes) {
+    return sa_stream_pread(s, data, nbytes, 0, SA_SEEK_RELATIVE);
 }
 
-int sa_device_write(sa_device_t *dev, const void *data, size_t nbytes) {
-    return sa_device_pwrite(dev, data, nbytes, 0, SA_SEEK_RELATIVE);
+int sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes) {
+    return sa_stream_pwrite(s, data, nbytes, 0, SA_SEEK_RELATIVE);
 }
 
-int sa_device_read_ni(sa_device_t *dev, unsigned channel, void *data, size_t nbytes) {
-    return sa_device_pread_ni(dev, channel, data, nbytes, 0, SA_SEEK_RELATIVE);
+int sa_stream_read_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes) {
+    return sa_stream_pread_ni(s, channel, data, nbytes, 0, SA_SEEK_RELATIVE);
 }
 
-int sa_device_write_ni(sa_device_t *dev, unsigned channel, const void *data, size_t nbytes) {
-    return sa_device_pwrite_ni(dev, channel, data, nbytes, 0, SA_SEEK_RELATIVE);
+int sa_stream_write_ni(sa_stream_t *s, unsigned channel, const void *data, size_t nbytes) {
+    return sa_stream_pwrite_ni(s, channel, data, nbytes, 0, SA_SEEK_RELATIVE);
 }
 
-int sa_device_pread(sa_device_t *dev, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_pread(sa_stream_t *s, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+    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);
     sa_return_val_if_fail(whence == SA_SEEK_RELATIVE || whence == SA_SEEK_ABSOLUTE || whence == SA_SEEK_RELATIVE_END, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->ni_enabled, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->codec || (nbytes % dev->pcm_frame_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->codec || (offset % dev->pcm_frame_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->ni_enabled, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->codec || (nbytes % s->pcm_frame_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->codec || (offset % s->pcm_frame_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_pread(dev, data, nbytes, offset, whence);
+    return driver_pread(s, data, nbytes, offset, whence);
 }
 
-int sa_device_pwrite(sa_device_t *dev, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+    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);
     sa_return_val_if_fail(whence == SA_SEEK_RELATIVE || whence == SA_SEEK_ABSOLUTE || whence == SA_SEEK_RELATIVE_END, SA_ERROR_INVALID);
-    sa_return_val_if_fail(!dev->ni_enabled, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->codec || (nbytes % dev->pcm_frame_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->codec || (offset % dev->pcm_frame_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->ni_enabled, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->codec || (nbytes % s->pcm_frame_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->codec || (offset % s->pcm_frame_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_pwrite(dev, data, nbytes, offset, whence);
+    return driver_pwrite(s, data, nbytes, offset, whence);
 }
 
-int sa_device_pread_ni(sa_device_t *dev, unsigned channel, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_pread_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+    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);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
     sa_return_val_if_fail(whence == SA_SEEK_RELATIVE || whence == SA_SEEK_ABSOLUTE || whence == SA_SEEK_RELATIVE_END, SA_ERROR_INVALID);
-    sa_return_val_if_fail(channel < dev->pcm_attrs.nchannels, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->ni_enabled, SA_ERROR_STATE);
-    sa_return_val_if_fail((nbytes % dev->pcm_sample_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail((offset % dev->pcm_sample_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(channel < s->pcm_attrs.nchannels, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->ni_enabled, SA_ERROR_STATE);
+    sa_return_val_if_fail((nbytes % s->pcm_sample_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail((offset % s->pcm_sample_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_pread_ni(dev, channel, data, nbytes, offset, whence);
+    return driver_pread_ni(s, channel, data, nbytes, offset, whence);
 }
 
-int sa_device_pwrite_ni(sa_device_t *dev, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_pwrite_ni(sa_stream_t *s, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) {
+    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);
-    sa_return_val_if_fail(!dev->codec, SA_ERROR_STATE);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
     sa_return_val_if_fail(whence == SA_SEEK_RELATIVE || whence == SA_SEEK_ABSOLUTE || whence == SA_SEEK_RELATIVE_END, SA_ERROR_INVALID);
-    sa_return_val_if_fail(channel < dev->pcm_attrs.nchannels, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->ni_enabled, SA_ERROR_STATE);
-    sa_return_val_if_fail((nbytes % dev->pcm_sample_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail((offset % dev->pcm_sample_size) == 0, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(channel < s->pcm_attrs.nchannels, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->ni_enabled, SA_ERROR_STATE);
+    sa_return_val_if_fail((nbytes % s->pcm_sample_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail((offset % s->pcm_sample_size) == 0, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_pwrite_ni(dev, channel, data, nbytes, offset, whence);
+    return driver_pwrite_ni(s, channel, data, nbytes, offset, whence);
 }
 
-int sa_device_get_read_size(sa_device_t *dev, size_t *size) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_read_size(sa_stream_t *s, size_t *size) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_get_read_size(dev, size);
+    return driver_get_read_size(s, size);
 }
 
-int sa_device_get_write_size(sa_device_t *dev, size_t *size) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+int sa_stream_get_write_size(sa_stream_t *s, size_t *size) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_get_write_size(dev, size);
+    return driver_get_write_size(s, size);
 }
 
-int sa_device_resume(sa_device_t *dev) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+int sa_stream_resume(sa_stream_t *s) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_resume(dev);
+    return driver_resume(s);
 }
 
-int sa_device_pause(sa_device_t *dev) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+int sa_stream_pause(sa_stream_t *s) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_pause(dev);
+    return driver_pause(s);
 }
 
-int sa_device_drain(sa_device_t *dev) {
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
-    sa_return_val_if_fail(dev->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
-    sa_return_val_if_fail(dev->state == SA_STATE_RUNNING || dev->state == SA_STATE_STOPPED, SA_ERROR_STATE);
+int sa_stream_drain(sa_stream_t *s) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
-    return device_drain(dev);
+    return driver_drain(s);
 }
 
 size_t get_pcm_sample_size(sa_pcm_format_t f) {
@@ -652,7 +652,7 @@ static int meta_check_word(const void *data, size_t size) {
 
 typedef int (*meta_check_func_t)(const void *data, size_t size);
 
-int sa_device_change_meta_data(sa_device_t *dev, const char *name, const void *data, size_t size) {
+int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size) {
     void *d = NULL;
     const struct meta_name *m;
     int ret;
@@ -668,7 +668,7 @@ int sa_device_change_meta_data(sa_device_t *dev, const char *name, const void *d
         meta_check_word, /* FIXME */
     };
         
-    sa_return_val_if_fail(dev, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(name, SA_ERROR_INVALID);
     sa_return_val_if_fail(data || size == 0, SA_ERROR_INVALID);
 
@@ -682,12 +682,12 @@ int sa_device_change_meta_data(sa_device_t *dev, const char *name, const void *d
         if (!(d = sa_memdup(data, size)))
             return SA_ERROR_OOM;
 
-    ret = dev->state == SA_STATE_INIT ? SA_SUCCESS : device_change_meta_data(dev, name, data, size);
+    ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_meta_data(s, name, data, size);
 
     if (ret == SA_SUCCESS) {
-        sa_free(dev->meta_data[m->idx]);
-        dev->meta_data[m->idx] = d;
-        dev->meta_data_size[m->idx] = size;
+        sa_free(s->meta_data[m->idx]);
+        s->meta_data[m->idx] = d;
+        s->meta_data_size[m->idx] = size;
     }
     
     return ret;
-- 
cgit