add missing accessors

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

3 files changed, 273 insertions, 87 deletions

diff --git a/common.c b/common.c
index 7219ae5..89779bb 100644
--- a/common.c
+++ b/common.c
@@ -137,6 +137,7 @@ int sa_stream_set_write_lower_watermark(sa_stream_t *s, size_t size) {
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
     sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
 
     s->write_lower_watermark = size;
     return SA_SUCCESS;
@@ -147,6 +148,7 @@ int sa_stream_set_read_lower_watermark(sa_stream_t *s, size_t size) {
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
     sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
 
     s->read_lower_watermark = size;
     return SA_SUCCESS;
@@ -157,6 +159,7 @@ int sa_stream_set_write_upper_watermark(sa_stream_t *s, size_t size) {
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
     sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
 
     s->write_upper_watermark = size;
     return SA_SUCCESS;
@@ -167,6 +170,7 @@ int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size) {
     sa_return_val_if_fail(s, SA_ERROR_INVALID);
     sa_return_val_if_fail(size > 0, SA_ERROR_INVALID);
     sa_return_val_if_fail(s->state == SA_STATE_INIT, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
 
     s->read_upper_watermark = size;
     return SA_SUCCESS;
@@ -183,7 +187,7 @@ int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map) {
     sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
 
     for (c = map, n = s->pcm_attrs.nchannels; n > 0; c++, n--)
-        if (*c >= SA_CHANNEL_MAX)
+        if (*c >= _SA_CHANNEL_MAX)
             return SA_ERROR_INVALID;
     
     if (!(m = sa_memdup(map, sizeof(sa_channel_t) * s->pcm_attrs.nchannels)))
@@ -335,7 +339,7 @@ int sa_stream_change_user_data(sa_stream_t *s, void *value) {
     return SA_SUCCESS;
 }
 
-int sa_stream_adjust_rate(sa_stream_t *s, sa_adjust_t direction) {
+int sa_stream_set_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);
@@ -344,7 +348,7 @@ int sa_stream_adjust_rate(sa_stream_t *s, sa_adjust_t direction) {
     return SA_SUCCESS;
 }
 
-int sa_stream_adjust_nchannels(sa_stream_t *s, sa_adjust_t direction) {
+int sa_stream_set_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);
@@ -353,7 +357,7 @@ int sa_stream_adjust_nchannels(sa_stream_t *s, sa_adjust_t direction) {
     return SA_SUCCESS;
 }
 
-int sa_stream_adjust_pcm_format(sa_stream_t *s, sa_adjust_t direction) {
+int sa_stream_set_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);
@@ -396,6 +400,157 @@ int sa_stream_get_pcm_format(sa_stream_t *s, sa_pcm_format_t *pcm_format) {
     return SA_SUCCESS;
 }
 
+int sa_stream_get_mode(sa_stream_t *s, sa_mode_t *access_mode) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(access_mode, SA_ERROR_INVALID);
+
+    *access_mode = s->mode;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_codec(sa_stream_t *s, const char **codec) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(codec, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->codec, SA_ERROR_STATE);
+
+    *codec = s->codec;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_write_lower_watermark(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(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+
+    *size = s->write_lower_watermark;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_read_lower_watermark(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(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+
+    *size = s->read_lower_watermark;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_write_upper_watermark(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(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+
+    *size = s->write_upper_watermark;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_read_upper_watermark(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(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+
+    *size = s->read_upper_watermark;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_channel_map(sa_stream_t *s, const sa_channel_t *map[]) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(map, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+
+    *map = s->pcm_attrs.channel_map;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_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_ERROR_INVALID);
+
+    *mode = s->xrun_mode;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_ni(sa_stream_t *s, int *enabled) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(enabled, SA_ERROR_INVALID);
+
+    *enabled = s->ni_enabled;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_dynamic_rate(sa_stream_t *s, int *enabled) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(enabled, SA_ERROR_INVALID);
+
+    *enabled = s->ni_enabled;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_driver(sa_stream_t *s, const char **driver) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(driver, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->driver, SA_ERROR_STATE);
+
+    *driver = s->driver;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_device(sa_stream_t *s, const char **device_name) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(device_name, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->device, SA_ERROR_STATE);
+
+    *device_name = s->device;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_input_volume(sa_stream_t *s, const int *vol[]) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(vol, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_RDONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->input_volume, SA_ERROR_STATE);
+
+    *vol = s->input_volume;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_output_volume(sa_stream_t *s, const int *vol[]) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(vol, SA_ERROR_INVALID);
+    sa_return_val_if_fail(s->mode & SA_MODE_WRONLY, SA_ERROR_STATE);
+    sa_return_val_if_fail(s->output_volume, SA_ERROR_STATE);
+
+    *vol = s->output_volume;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_adjust_rate(sa_stream_t *s, sa_adjust_t *direction) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(direction, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+
+    *direction = s->adjust_rate;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_adjust_nchannels(sa_stream_t *s, sa_adjust_t *direction) {
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(direction, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+
+    *direction = s->adjust_nchannels;
+    return SA_SUCCESS;
+}
+
+int sa_stream_get_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(direction, SA_ERROR_INVALID);
+    sa_return_val_if_fail(!s->codec, SA_ERROR_STATE);
+
+    *direction = s->adjust_pcm_format;
+    return SA_SUCCESS;
+}
+
 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);
@@ -425,7 +580,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) {
     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(position < _SA_POSITION_MAX, SA_ERROR_INVALID);
     sa_return_val_if_fail(s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE);
 
     return driver_get_position(s, position, pos);
@@ -693,9 +848,28 @@ int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *dat
     return ret;
 }
 
+int sa_stream_get_meta_data(sa_stream_t *s, const char *name, const void **data, size_t *size) {
+    const struct meta_name *m;
+
+    sa_return_val_if_fail(s, SA_ERROR_INVALID);
+    sa_return_val_if_fail(name, SA_ERROR_INVALID);
+    sa_return_val_if_fail(data, SA_ERROR_INVALID);
+    sa_return_val_if_fail(size, SA_ERROR_INVALID);
+    
+    if (!(m = lookup_meta_name(name, strlen(name))))
+        return SA_ERROR_NO_META;
+
+    if (!s->meta_data[m->idx])
+        return SA_ERROR_NO_DATA;
+
+    *data = s->meta_data[m->idx];
+    *size = s->meta_data_size[m->idx];
+
+    return SA_SUCCESS;
+}
 
 const char *sa_strerror(int code) {
-    const char * const error_table[-SA_ERROR_MAX] = {
+    const char * const error_table[-_SA_ERROR_MAX] = {
         [-SA_SUCCESS] = "Success",
         [-SA_ERROR_NOT_SUPPORTED] = "Operation not supported",
         [-SA_ERROR_INVALID] = "Invalid argument",
@@ -707,11 +881,12 @@ const char *sa_strerror(int code) {
         [-SA_ERROR_NO_PCM_FORMAT] = "No such PCM format",
         [-SA_ERROR_SYSTEM] = "System error",
         [-SA_ERROR_NO_INIT] = "Not initialized",
-        [-SA_ERROR_NO_META] ="No such meta name"
+        [-SA_ERROR_NO_META] = "No such meta name",
+        [-SA_ERROR_NO_DATA] = "No such data"
     };
 
-    sa_assert(code <= 0);
-    sa_assert(code > SA_ERROR_MAX);
+    sa_return_val_if_fail(code <= 0, NULL);
+    sa_return_val_if_fail(code > _SA_ERROR_MAX, NULL);
 
     return error_table[-code];
 }
diff --git a/format.c b/format.c
index 7051fcb..91b7464 100644
--- a/format.c
+++ b/format.c
@@ -1,6 +1,5 @@
 #include <inttypes.h>
 #include <sys/types.h>
-#include <sys/param.h>
 
 #include <liboil/liboil.h>
 
@@ -167,9 +166,9 @@ static int format_s24_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *s
     unsigned n = bytes/3;
 
     for (; n > 0; n--, d += dstr/sizeof(int32_t), s += sstr/3)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
+#if defined(SA_LITTLE_ENDIAN)
         *d = (int32_t) ((int8_t) s[2]) * 0x1000000 + s[1] * 0x10000 + s[0] * 0x100;
-#elif __BYTE_ORDER == __BIG_ENDIAN
+#elif defined(SA_BIG_ENDIAN)
         *d = (int32_t) ((int8_t) s[0]) * 0x1000000 + s[1] * 0x10000 + s[2] * 0x100;
 #else
 #error "Unknown byte order"
@@ -184,9 +183,9 @@ static int format_s24_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *s
     unsigned n = bytes/3;
 
     for (; n > 0; n--, d += dstr/sizeof(float), s += sstr/3)
-#if __BYTE_ORDER == __LITTLE_ENDIAN
+#if defined(SA_LITTLE_ENDIAN)
         *d = ((float) ((int8_t) s[2]) * 0x10000 + s[1] * 0x100 + s[0]) / 0x7fffff;
-#elif __BYTE_ORDER == __BIG_ENDIAN
+#elif defined(SA_BIG_ENDIAN)
         *d = ((float) ((int8_t) s[0]) * 0x10000 + s[1] * 0x100 + s[2]) / 0x7fffff;
 #else
 #error "Unknown byte order"
@@ -249,11 +248,11 @@ static int format_s32_to_s24(bbuffer_t *b, void *dst, size_t dstr, const void *s
     for (; n > 0; n--, d += dstr/3, s += sstr/sizeof(int32_t)) {
         uint32_t j = (uint32_t) (*s) >> 8;
         
-#if __BYTE_ORDER == __LITTLE_ENDIAN
+#if defined(SA_LITTLE_ENDIAN)
         d[0] = j & 0xFF;
         d[1] = (j >> 8) & 0xFF;
         d[2] = (j >> 16);
-#elif __BYTE_ORDER == __BIG_ENDIAN
+#elif defined(SA_BIG_ENDIAN)
         d[2] = j & 0xFF;
         d[1] = (j >> 8) & 0xFF;
         d[0] = (j >> 16);
@@ -354,11 +353,11 @@ static int format_f32_to_s24(bbuffer_t *b, void *dst, size_t dstr, const void *s
 
         j = (uint32_t) ((int32_t) f);
         
-#if __BYTE_ORDER == __LITTLE_ENDIAN
+#if defined(SA_LITTLE_ENDIAN)
         d[0] = j & 0xFF;
         d[1] = (j >> 8) & 0xFF;
         d[2] = (j >> 16);
-#elif __BYTE_ORDER == __BIG_ENDIAN
+#elif defined(SA_BIG_ENDIAN)
         d[2] = j & 0xFF;
         d[1] = (j >> 8) & 0xFF;
         d[0] = (j >> 16);
diff --git a/sydney.h b/sydney.h
index 7c67f86..5b3f009 100644
--- a/sydney.h
+++ b/sydney.h
@@ -18,11 +18,11 @@ async-signal safe.
 
 /* Detect byte order, based on sys/param.h */
 #if (defined(__BYTE_ORDER) && (__BYTE_ORDER == __LITTLE_ENDIAN)) || defined(WIN32)
-#    define SA_LITTLE_ENDIAN
+#    define SA_LITTLE_ENDIAN 1
 #    undef SA_BIG_ENDIAN
 #elif (defined(__BYTE_ORDER) && (__BYTE_ORDER == __BIG_ENDIAN))
 #    undef SA_LITTLE_ENDIAN
-#    define SA_BIG_ENDIAN
+#    define SA_BIG_ENDIAN 1
 #else
 #    error "Cannot determine byte order!"
 #endif
@@ -84,9 +84,10 @@ typedef enum {
 
 /** Device opening modes */
 typedef enum {
-    SA_MODE_RDONLY = 1,
-    SA_MODE_WRONLY = 2,
-    SA_MODE_RDWR   = 3
+    SA_MODE_WRONLY = 1,
+    SA_MODE_RDONLY = 2,
+    SA_MODE_RDWR   = 3,
+    _SA_MODE_MAX   = 4,
 } sa_mode_t;
 
 /** Error codes */
@@ -103,7 +104,8 @@ typedef enum {
     SA_ERROR_SYSTEM = -8,
     SA_ERROR_NO_INIT = -9,
     SA_ERROR_NO_META = -10,
-    SA_ERROR_MAX = -11
+    SA_ERROR_NO_DATA = -11,
+    _SA_ERROR_MAX = -12
 } sa_error_t;
 
 /** Possible events for notifications */
@@ -112,7 +114,8 @@ typedef enum {
     SA_NOTIFY_REQUEST_START,
     SA_NOTIFY_VOLUME_CHANGED_IN,
     SA_NOTIFY_VOLUME_CHANGED_OUT,
-    SA_NOTIFY_DEVICE_CHANGED
+    SA_NOTIFY_DEVICE_CHANGED,
+    _SA_NOTIFY_MAX
 } sa_notify_t;
 
 /** Classes of events */
@@ -120,7 +123,8 @@ typedef enum {
     SA_EVENT_REQUEST_IO,
     SA_EVENT_INIT_THREAD,
     SA_EVENT_NOTIFY,
-    SA_EVENT_ERROR
+    SA_EVENT_ERROR,
+    _SA_EVENT_MAX
 } sa_event_t;
 
 /** List of sample position queries */
@@ -132,7 +136,7 @@ typedef enum {
     SA_POSITION_READ_HARDWARE,
     SA_POSITION_READ_SOFTWARE,
     SA_POSITION_DUPLEX_DELAY,
-    SA_POSITION_MAX
+    _SA_POSITION_MAX
 } sa_position_t;
 
 /* Channel positions */
@@ -191,7 +195,7 @@ typedef enum {
     SA_CHANNEL_AUX29,
     SA_CHANNEL_AUX30,
     SA_CHANNEL_AUX31,
-    SA_CHANNEL_MAX
+    _SA_CHANNEL_MAX
 } sa_channel_t;
 
 typedef enum {
@@ -199,11 +203,13 @@ typedef enum {
     SA_STATE_RUNNING,
     SA_STATE_STOPPED,
     /* put more stuff */
+    _SA_STATE_MAX,
 } sa_state_t;
 
 typedef enum {
     SA_XRUN_MODE_STOP,
-    SA_XRUN_MODE_SPIN
+    SA_XRUN_MODE_SPIN,
+    _SA_XRUN_MODE_MAX
 } sa_xrun_mode_t;
 
 typedef enum {
@@ -225,138 +231,144 @@ typedef enum {
 #define SA_META_XID "sydney.xid"                     /* X11 window id */
 
 /** Main callback function */
-typedef int (*sa_event_callback_t)(sa_stream_t *dev, sa_event_t event);
+typedef int (*sa_event_callback_t)(sa_stream_t *s, sa_event_t event);
 
 /** Create an opaque (e.g. AC3) codec stream */
-int sa_stream_create_opaque(sa_stream_t **dev, sa_mode_t mode, const char *codec);
+int sa_stream_create_opaque(sa_stream_t **s, sa_mode_t mode, const char *codec);
 
 /** Normal way to open a PCM device */
-int sa_stream_create_pcm(sa_stream_t **dev, sa_mode_t mode, sa_pcm_format_t format, unsigned rate, unsigned nchannels);
+int sa_stream_create_pcm(sa_stream_t **s, sa_mode_t mode, sa_pcm_format_t format, unsigned rate, unsigned nchannels);
 
 /** Initialise the device */
-int sa_stream_open(sa_stream_t *dev);
+int sa_stream_open(sa_stream_t *s);
 
 /** Close/destroy everything */
-int sa_stream_destroy(sa_stream_t *dev);
+int sa_stream_destroy(sa_stream_t *s);
 
 /* "Soft" params */
-int sa_stream_set_write_lower_watermark(sa_stream_t *dev, size_t size);
-int sa_stream_set_read_lower_watermark(sa_stream_t *dev, size_t size);
-
-int sa_stream_set_write_upper_watermark(sa_stream_t *dev, size_t size);
-int sa_stream_set_read_upper_watermark(sa_stream_t *dev, size_t size);
+int sa_stream_set_write_lower_watermark(sa_stream_t *s, size_t size);
+int sa_stream_set_read_lower_watermark(sa_stream_t *s, size_t size);
+int sa_stream_set_write_upper_watermark(sa_stream_t *s, size_t size);
+int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size);
 
 /** Set the mapping between channels and the loudspeakers */
-int sa_stream_set_channel_map(sa_stream_t *dev, const sa_channel_t map[]);
+int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t map[]);
 
 /** Whether xruns cause the card to reset */
-int sa_stream_set_xrun_mode(sa_stream_t *dev, sa_xrun_mode_t mode);
+int sa_stream_set_xrun_mode(sa_stream_t *s, sa_xrun_mode_t mode);
 
 /** Set the device to non-interleaved mode */
-int sa_stream_set_ni(sa_stream_t *dev, int enable);
+int sa_stream_set_ni(sa_stream_t *s, int enable);
 
 /** Require dynamic sample rate */
-int sa_stream_set_dynamic_rate(sa_stream_t *dev, int enable);
+int sa_stream_set_dynamic_rate(sa_stream_t *s, int enable);
 
 /** Select driver */
-int sa_stream_set_driver(sa_stream_t *dev, const char *driver);
+int sa_stream_set_driver(sa_stream_t *s, const char *driver);
 
 /** Start callback */
-int sa_stream_start_thread(sa_stream_t *dev, sa_event_callback_t *callback);
+int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t *callback);
 
 /** Change the device connected to the stream */
-int sa_stream_change_device(sa_stream_t *dev, const char *device_name);
+int sa_stream_change_device(sa_stream_t *s, const char *device_name);
 
 /** volume in hundreths of dB*/
-int sa_stream_change_input_volume(sa_stream_t *dev, const int vol[]);
+int sa_stream_change_input_volume(sa_stream_t *s, const int vol[]);
 
 /** volume in hundreths of dB*/
-int sa_stream_change_output_volume(sa_stream_t *dev, const int vol[]);
+int sa_stream_change_output_volume(sa_stream_t *s, const int vol[]);
 
 /** Change the sampling rate */
-int sa_stream_change_rate(sa_stream_t *dev, unsigned rate);
+int sa_stream_change_rate(sa_stream_t *s, unsigned rate);
 
 /** Change some meta data that is attached to the stream */
-int sa_stream_change_meta_data(sa_stream_t *dev, const char *name, const void *data, size_t len);
+int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size);
 
 /** Associate opaque user data */
-int sa_stream_change_user_data(sa_stream_t *dev, void *value);
+int sa_stream_change_user_data(sa_stream_t *s, void *value);
 
 /* Hardware-related. This is implementation-specific and hardware specific. */
-int sa_stream_adjust_rate(sa_stream_t *dev, sa_adjust_t direction);
-
-int sa_stream_adjust_nchannels(sa_stream_t *dev, sa_adjust_t direction);
-
-int sa_stream_adjust_pcm_format(sa_stream_t *dev, sa_adjust_t direction);
+int sa_stream_set_adjust_rate(sa_stream_t *s, sa_adjust_t direction);
+int sa_stream_set_adjust_nchannels(sa_stream_t *s, sa_adjust_t direction);
+int sa_stream_set_adjust_pcm_format(sa_stream_t *s, sa_adjust_t direction);
 
 /* Query functions */
 
-/** Get current state of the audio device */
-int sa_stream_get_state(sa_stream_t *dev, sa_state_t *state);
-
-/** Get current sampling rate */
-int sa_stream_get_rate(sa_stream_t *dev, unsigned *rate);
+int sa_stream_get_mode(sa_stream_t *s, sa_mode_t *access_mode);
+int sa_stream_get_codec(sa_stream_t *s, const char **codec);
+int sa_stream_get_pcm_format(sa_stream_t *s, sa_pcm_format_t *format);
+int sa_stream_get_rate(sa_stream_t *s, unsigned *rate);
+int sa_stream_get_nchannels(sa_stream_t *s, int *nchannels);
+int sa_stream_get_user_data(sa_stream_t *s, void **value);
+int sa_stream_get_write_lower_watermark(sa_stream_t *s, size_t *size);
+int sa_stream_get_read_lower_watermark(sa_stream_t *s, size_t *size);
+int sa_stream_get_write_upper_watermark(sa_stream_t *s, size_t *size);
+int sa_stream_get_read_upper_watermark(sa_stream_t *s, size_t *size);
+int sa_stream_get_channel_map(sa_stream_t *s, const sa_channel_t *map[]);
+int sa_stream_get_xrun_mode(sa_stream_t *s, sa_xrun_mode_t *mode);
+int sa_stream_get_ni(sa_stream_t *s, int *enabled);
+int sa_stream_get_dynamic_rate(sa_stream_t *s, int *enabled);
+int sa_stream_get_driver(sa_stream_t *s, const char **driver);
+int sa_stream_get_device(sa_stream_t *s, const char **device_name);
+int sa_stream_get_input_volume(sa_stream_t *s, const int *vol[]);
+int sa_stream_get_output_volume(sa_stream_t *s, const int *vol[]);
+int sa_stream_get_meta_data(sa_stream_t *s, const char *name, const void **data, size_t *size);
+int sa_stream_get_adjust_rate(sa_stream_t *s, sa_adjust_t *direction);
+int sa_stream_get_adjust_nchannels(sa_stream_t *s, sa_adjust_t *direction);
+int sa_stream_get_adjust_pcm_format(sa_stream_t *s, sa_adjust_t *direction);
 
-/** Get number of channels */
-int sa_stream_get_nchannels(sa_stream_t *dev, int *nchannels);
-
-/** Get format being used */
-int sa_stream_get_pcm_format(sa_stream_t *dev, sa_pcm_format_t *format);
-
-/** Get opaque pointer associated to the device */
-int sa_stream_get_user_data(sa_stream_t *dev, void **value);
+/** Get current state of the audio device */
+int sa_stream_get_state(sa_stream_t *s, sa_state_t *state);
 
 /** Obtain the error code */
-int sa_stream_get_event_error(sa_stream_t *dev, sa_error_t *error);
+int sa_stream_get_event_error(sa_stream_t *s, sa_error_t *error);
 
 /** Obtain the notification code */
-int sa_stream_get_event_notify(sa_stream_t *dev, sa_notify_t *notify);
+int sa_stream_get_event_notify(sa_stream_t *s, sa_notify_t *notify);
 
 /** sync/timing */
-int sa_stream_get_position(sa_stream_t *dev, sa_position_t position, int64_t *pos);
-
-
+int sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos);
 
 
 /* Blocking IO calls */
 
 /** Interleaved capture function */
-int sa_stream_read(sa_stream_t *dev, void *data, size_t nbytes);
+int sa_stream_read(sa_stream_t *s, void *data, size_t nbytes);
 /** Interleaved playback function */
-int sa_stream_write(sa_stream_t *dev, const void *data, size_t nbytes);
+int sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes);
 
 /** Non-interleaved capture function */
-int sa_stream_read_ni(sa_stream_t *dev, unsigned channel, void *data, size_t nbytes);
+int sa_stream_read_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes);
 /** Non-interleaved playback function */
-int sa_stream_write_ni(sa_stream_t *dev, unsigned channel, const void *data, size_t nbytes);
+int sa_stream_write_ni(sa_stream_t *s, unsigned channel, const void *data, size_t nbytes);
 
 /** Interleaved capture function with seek offset */
-int sa_stream_pread(sa_stream_t *dev, void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
+int sa_stream_pread(sa_stream_t *s, void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
 /** Interleaved playback function with seek offset */
-int sa_stream_pwrite(sa_stream_t *dev, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
+int sa_stream_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
 
 /** Non-interleaved capture function with seek offset */
-int sa_stream_pread_ni(sa_stream_t *dev, unsigned channel, void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
+int sa_stream_pread_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
 /** Non-interleaved playback function with seek offset */
-int sa_stream_pwrite_ni(sa_stream_t *dev, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
+int sa_stream_pwrite_ni(sa_stream_t *s, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence);
 
 
 /** Query how much can be read without blocking */
-int sa_stream_get_read_size(sa_stream_t *dev, size_t *size);
+int sa_stream_get_read_size(sa_stream_t *s, size_t *size);
 /** Query how much can be written without blocking */
-int sa_stream_get_write_size(sa_stream_t *dev, size_t *size);
+int sa_stream_get_write_size(sa_stream_t *s, size_t *size);
 
 
 /* Control/xrun */
 
 /** Resume playing after a pause */
-int sa_stream_resume(sa_stream_t *dev);
+int sa_stream_resume(sa_stream_t *s);
 
 /** Pause audio playback (do not empty the buffer) */
-int sa_stream_pause(sa_stream_t *dev);
+int sa_stream_pause(sa_stream_t *s);
 
 /** Block until all audio has been played */
-int sa_stream_drain(sa_stream_t *dev);
+int sa_stream_drain(sa_stream_t *s);
 
 /** Return a human readable error */
 const char *sa_strerror(int code);