From 17e086aaa4960e3b4d779ad02d816e9452c0d458 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Sun, 13 May 2007 01:24:01 +0000 Subject: add missing accessors git-svn-id: file:///home/lennart/svn/public/libsydney/trunk@8 9ba3c220-e4d3-45a2-8aa3-73fcc9aff6ce --- common.c | 193 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- format.c | 17 +++--- sydney.h | 150 ++++++++++++++++++++++++++----------------------- 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 #include -#include #include @@ -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); -- cgit