From b0c5e0bdea90d5d045039724977f673505829756 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Tue, 2 Oct 2007 21:02:45 +0000 Subject: comment watermark stuff for now git-svn-id: file:///home/lennart/svn/public/libsydney/trunk@39 9ba3c220-e4d3-45a2-8aa3-73fcc9aff6ce --- src/common.c | 219 ++++++++++++++++++++++++++++---------------------------- src/common.h | 5 +- src/converter.c | 2 +- src/oss.c | 4 +- src/sydney.h | 29 ++++---- 5 files changed, 132 insertions(+), 127 deletions(-) diff --git a/src/common.c b/src/common.c index c8017e8..b366563 100644 --- a/src/common.c +++ b/src/common.c @@ -25,7 +25,7 @@ static sa_stream_t *stream_alloc(void) { /* All fields a carefully chosen in a way that initializing them * NUL bytes is sufficient */ - if (!(d->mutex = sa_mutex_new(FALSE, FALSE))) { + if (!(d->mutex = sa_mutex_new(FALSE, TRUE))) { sa_free(d); return NULL; } @@ -110,23 +110,23 @@ int sa_stream_create_pcm( if (lwm <= 0) lwm = (*s)->pcm_frame_size * (*s)->pcm_attrs.rate; /* 1s */ - if (mode & SA_MODE_RDONLY) { +/* if (mode & SA_MODE_RDONLY) { */ - if ((ret = sa_stream_set_read_lower_watermark(*s, lwm))) - goto fail; +/* if ((ret = sa_stream_set_read_lower_watermark(*s, lwm))) */ +/* goto fail; */ - if ((ret = sa_stream_set_read_upper_watermark(*s, lwm*2))) - goto fail; - } +/* if ((ret = sa_stream_set_read_upper_watermark(*s, lwm*2))) */ +/* goto fail; */ +/* } */ - if (mode & SA_MODE_WRONLY) { +/* if (mode & SA_MODE_WRONLY) { */ - if ((ret = sa_stream_set_write_lower_watermark(*s, lwm))) - goto fail; +/* if ((ret = sa_stream_set_write_lower_watermark(*s, lwm))) */ +/* goto fail; */ - if ((ret = sa_stream_set_write_upper_watermark(*s, lwm*2))) - goto fail; - } +/* if ((ret = sa_stream_set_write_upper_watermark(*s, lwm*2))) */ +/* goto fail; */ +/* } */ oil_init(); @@ -149,10 +149,10 @@ int sa_stream_open(sa_stream_t *s) { sa_mutex_lock(s->mutex); sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); sa_return_val_if_fail_mutex(s->mutex, s->codec || s->pcm_attrs.channel_map, SA_ERROR_NO_INIT); - sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_RDONLY) || (s->read_lower_watermark <= s->read_upper_watermark), SA_ERROR_INVALID); - sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_WRONLY) || (s->write_lower_watermark <= s->write_upper_watermark), SA_ERROR_INVALID); - sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_RDONLY) || !s->codec || (s->read_lower_watermark > 0 && s->read_upper_watermark > 0), SA_ERROR_NO_INIT); - sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_WRONLY) || !s->codec || (s->write_lower_watermark > 0 && s->write_upper_watermark > 0), SA_ERROR_NO_INIT); +/* sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_RDONLY) || (s->read_lower_watermark <= s->read_upper_watermark), SA_ERROR_INVALID); */ +/* sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_WRONLY) || (s->write_lower_watermark <= s->write_upper_watermark), SA_ERROR_INVALID); */ +/* sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_RDONLY) || !s->codec || (s->read_lower_watermark > 0 && s->read_upper_watermark > 0), SA_ERROR_NO_INIT); */ +/* sa_return_val_if_fail_mutex(s->mutex, !(s->mode & SA_MODE_WRONLY) || !s->codec || (s->write_lower_watermark > 0 && s->write_upper_watermark > 0), SA_ERROR_NO_INIT); */ if ((ret = driver_open(s)) == 0) s->state = SA_STATE_STOPPED; @@ -185,62 +185,62 @@ int sa_stream_destroy(sa_stream_t *s) { return ret; } -int sa_stream_set_write_lower_watermark(sa_stream_t *s, size_t size) { +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); +/* sa_return_val_if_fail(s, SA_ERROR_INVALID); */ +/* sa_return_val_if_fail(size > 0, SA_ERROR_INVALID); */ +/* sa_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); */ - s->write_lower_watermark = size; +/* s->write_lower_watermark = size; */ - sa_mutex_unlock(s->mutex); +/* sa_mutex_unlock(s->mutex); */ - return SA_SUCCESS; -} +/* return SA_SUCCESS; */ +/* } */ -int sa_stream_set_read_lower_watermark(sa_stream_t *s, size_t size) { +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); +/* sa_return_val_if_fail(s, SA_ERROR_INVALID); */ +/* sa_return_val_if_fail(size > 0, SA_ERROR_INVALID); */ +/* sa_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); */ - s->read_lower_watermark = size; +/* s->read_lower_watermark = size; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* return SA_SUCCESS; */ +/* } */ -int sa_stream_set_write_upper_watermark(sa_stream_t *s, size_t size) { +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); +/* sa_return_val_if_fail(s, SA_ERROR_INVALID); */ +/* sa_return_val_if_fail(size > 0, SA_ERROR_INVALID); */ +/* sa_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); */ - s->write_upper_watermark = size; +/* s->write_upper_watermark = size; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* return SA_SUCCESS; */ +/* } */ -int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size) { +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); +/* sa_return_val_if_fail(s, SA_ERROR_INVALID); */ +/* sa_return_val_if_fail(size > 0, SA_ERROR_INVALID); */ +/* sa_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); */ - s->read_upper_watermark = size; +/* s->read_upper_watermark = size; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* return SA_SUCCESS; */ +/* } */ int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map, unsigned n) { const sa_channel_t *c; @@ -527,16 +527,16 @@ int sa_stream_set_adjust_pcm_format(sa_stream_t *s, sa_adjust_t direction) { return SA_SUCCESS; } -int sa_stream_set_adjust_watermarks(sa_stream_t *s, sa_adjust_t direction) { - sa_return_val_if_fail(s, SA_ERROR_INVALID); - sa_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); +/* int sa_stream_set_adjust_watermarks(sa_stream_t *s, sa_adjust_t direction) { */ +/* sa_return_val_if_fail(s, SA_ERROR_INVALID); */ +/* sa_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_INIT, SA_ERROR_STATE); */ - s->adjust_watermarks = direction; +/* s->adjust_watermarks = direction; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* return SA_SUCCESS; */ +/* } */ int sa_stream_get_state(sa_stream_t *s, sa_state_t *state) { int ret; @@ -621,53 +621,53 @@ int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size) { 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); +/* 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_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); */ - *size = s->write_lower_watermark; +/* *size = s->write_lower_watermark; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); +/* 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_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); */ - *size = s->read_lower_watermark; +/* *size = s->read_lower_watermark; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); +/* 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_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); */ - *size = s->write_upper_watermark; +/* *size = s->write_upper_watermark; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* 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_mutex_lock(s->mutex); - sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); +/* 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_mutex_lock(s->mutex); */ +/* sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_RDONLY, SA_ERROR_STATE); */ - *size = s->read_upper_watermark; +/* *size = s->read_upper_watermark; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* return SA_SUCCESS; */ +/* } */ int sa_stream_get_channel_map(sa_stream_t *s, sa_channel_t *map, unsigned *n) { sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -841,16 +841,16 @@ int sa_stream_get_adjust_pcm_format(sa_stream_t *s, sa_adjust_t *direction) { return SA_SUCCESS; } -int sa_stream_get_adjust_watermarks(sa_stream_t *s, sa_adjust_t *direction) { - sa_return_val_if_fail_mutex(s->mutex, s, SA_ERROR_INVALID); - sa_return_val_if_fail_mutex(s->mutex, direction, SA_ERROR_INVALID); - sa_mutex_lock(s->mutex); +/* int sa_stream_get_adjust_watermarks(sa_stream_t *s, sa_adjust_t *direction) { */ +/* sa_return_val_if_fail_mutex(s->mutex, s, SA_ERROR_INVALID); */ +/* sa_return_val_if_fail_mutex(s->mutex, direction, SA_ERROR_INVALID); */ +/* sa_mutex_lock(s->mutex); */ - *direction = s->adjust_watermarks; +/* *direction = s->adjust_watermarks; */ - sa_mutex_unlock(s->mutex); - return SA_SUCCESS; -} +/* sa_mutex_unlock(s->mutex); */ +/* return SA_SUCCESS; */ +/* } */ int sa_stream_get_user_data(sa_stream_t *s, void **value) { sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -1070,6 +1070,7 @@ size_t sa_get_pcm_sample_size(sa_pcm_format_t f) { case SA_PCM_FORMAT_S16_LE: case SA_PCM_FORMAT_S16_BE: return 2; + case SA_PCM_FORMAT_S24_LE: case SA_PCM_FORMAT_S24_BE: return 3; diff --git a/src/common.h b/src/common.h index dbf03b0..698dbf6 100644 --- a/src/common.h +++ b/src/common.h @@ -3,6 +3,7 @@ #include "sydney.h" #include "mutex.h" +#include "macro.h" #define _META_NAMES_MAX 9 @@ -28,8 +29,8 @@ struct sa_stream { size_t write_upper_watermark; sa_xrun_mode_t xrun_mode; - int ni_enabled; - int dynamic_rate_enabled; + sa_bool_t ni_enabled; + sa_bool_t dynamic_rate_enabled; sa_event_callback_t event_callback; diff --git a/src/converter.c b/src/converter.c index ad19f82..d895d83 100644 --- a/src/converter.c +++ b/src/converter.c @@ -190,7 +190,7 @@ int sa_converter_init( sa_converter_t *c, const pcm_attrs_t *from, const pcm_attrs_t *to, - int dynamic_rate_enabled) { + sa_bool_t dynamic_rate_enabled) { unsigned u, t; int resample_required; diff --git a/src/oss.c b/src/oss.c index 3ad1a9d..fa71436 100644 --- a/src/oss.c +++ b/src/oss.c @@ -61,7 +61,7 @@ static size_t fixup_bps(size_t s, size_t bps1, size_t bps2) { int driver_open(sa_stream_t *s) { oss_stream_t *oss; - const char *n; + char *n; int f, arg, bs, r, phase, i, found, suggested, fs, l, m; unsigned c; size_t real_bps = 0, bps; @@ -91,7 +91,7 @@ int driver_open(sa_stream_t *s) { oss->parent = s; oss->socket_fds[0] = oss->socket_fds[1] = -1; - n = s->device ? s->device : DEFAULT_DEVICE; + n = s->device ? s->device : (char*) DEFAULT_DEVICE; if (!s->codec) bps = s->pcm_frame_size * s->pcm_attrs.rate; diff --git a/src/sydney.h b/src/sydney.h index 8733260..00887f9 100644 --- a/src/sydney.h +++ b/src/sydney.h @@ -8,7 +8,7 @@ of zeros to be issued to that one can do "while (1); {read(); write()} - All functions are thread-safe and can be called in any thread context. None of the functions is async-signal safe. - + - It is assumed that duplex streams have a single clock (synchronised) */ @@ -221,12 +221,12 @@ typedef enum { } sa_adjust_t; /* Some kind of meta information. */ -#define SA_META_CLIENT_NAME "sydney.client-name" /* utf-8 */ +#define SA_META_CLIENT_NAME "sydney.client-name" /* utf-8 */ #define SA_META_PROCESS_ID "sydney.process-id" /* getpid() */ #define SA_META_LANGUAGE "sydney.language" /* de_DE and similar */ /* Some kind of meta information. Not filled in */ -#define SA_META_STREAM_NAME "sydney.stream-name" /* utf-8 */ +#define SA_META_STREAM_NAME "sydney.stream-name" /* utf-8 */ #define SA_META_ICON_NAME "sydney.icon-name" /* file name (no slashes) */ #define SA_META_ICON_PNG "sydney.icon-png" /* PNG blob */ #define SA_META_ROLE "sydney.role" /* one of: "music", "phone", "game", "event" */ @@ -249,10 +249,10 @@ int sa_stream_open(sa_stream_t *s); int sa_stream_destroy(sa_stream_t *s); /* "Soft" params */ -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_user_size(sa_stream_t *s, size_t size); -int sa_stream_set_read_user_size(sa_stream_t *s, 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_user_size(sa_stream_t *s, size_t size); */ +/* int sa_stream_set_read_user_size(sa_stream_t *s, size_t size); */ /** Set the mapping between channels and the loudspeakers */ int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t map[], unsigned n); @@ -263,6 +263,9 @@ 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_non_interleaved(sa_stream_t *s, int enable); +/** Allow that the sample rate may be changed during runtime */ +int sa_stream_set_dynamic_rate(sa_stream_t *s, int enabled); + /** Select driver */ int sa_stream_set_driver(sa_stream_t *s, const char *driver); @@ -294,7 +297,7 @@ int sa_stream_change_user_data(sa_stream_t *s, const void *value); 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); -int sa_stream_set_adjust_watermarks(sa_stream_t *s, sa_adjust_t direction); +/* int sa_stream_set_adjust_watermarks(sa_stream_t *s, sa_adjust_t direction); */ /* Query functions */ @@ -304,10 +307,10 @@ 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_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, sa_channel_t map[], unsigned *n); int sa_stream_get_xrun_mode(sa_stream_t *s, sa_xrun_mode_t *mode); int sa_stream_get_non_interleaved(sa_stream_t *s, int *enabled); @@ -320,7 +323,7 @@ int sa_stream_get_meta_data(sa_stream_t *s, const char *name, void*data, size_t 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); -int sa_stream_get_adjust_watermarks(sa_stream_t *s, sa_adjust_t *direction); +/* int sa_stream_get_adjust_watermarks(sa_stream_t *s, sa_adjust_t *direction); */ /** Get current state of the audio device */ int sa_stream_get_state(sa_stream_t *s, sa_state_t *state); -- cgit