From 18301dfca56ba8545549e80f84423d83a46c6b64 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Tue, 2 Oct 2007 20:26:08 +0000 Subject: a lot of minor cleanups git-svn-id: file:///home/lennart/svn/public/libsydney/trunk@36 9ba3c220-e4d3-45a2-8aa3-73fcc9aff6ce --- src/Makefile.am | 9 +- src/add.c | 4 + src/asyncq.c | 18 ++-- src/asyncq.h | 6 +- src/bbuffer.c | 14 +-- src/bswap.c | 74 ++++++++++++++++ src/bswap.h | 12 +++ src/bufferq.c | 44 +++++----- src/byteswap.c | 57 ------------- src/byteswap.h | 12 --- src/common.c | 108 ++++++++++++------------ src/common.h | 10 +-- src/continued-fraction.c | 5 +- src/converter.c | 158 +++++++++++++++++----------------- src/converter.h | 8 +- src/driver.h | 4 +- src/format.c | 54 ++++++------ src/interleave.c | 11 ++- src/interleave.h | 4 +- src/macro.h | 8 +- src/malloc.c | 7 ++ src/malloc.h | 4 +- src/mutex-posix.c | 107 +++++++++++++++++++++++ src/mutex.c | 97 --------------------- src/mutex.h | 23 ++--- src/oss.c | 201 +++++++++++++++++++++++--------------------- src/resample.c | 8 +- src/test-asyncq.c | 14 +-- src/test-bufferq.c | 8 +- src/test-llist.c | 8 +- src/test-pull.c | 14 +-- src/test-sine.c | 13 +-- src/thread-posix.c | 215 +++++++++++++++++++++++++++++++++++++++++++++++ src/thread.c | 214 ---------------------------------------------- src/thread.h | 31 ++++--- src/volscale.c | 29 ++++--- src/zero.c | 10 ++- 37 files changed, 868 insertions(+), 755 deletions(-) create mode 100644 src/bswap.c create mode 100644 src/bswap.h delete mode 100644 src/byteswap.c delete mode 100644 src/byteswap.h create mode 100644 src/mutex-posix.c delete mode 100644 src/mutex.c create mode 100644 src/thread-posix.c delete mode 100644 src/thread.c (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am index b6b57ea..ad13181 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -40,7 +40,7 @@ libsydney_la_SOURCES = \ bbuffer.c bbuffer.h \ format.c fomat.h \ volscale.c volscale.h \ - byteswap.c byteswap.h \ + bswap.c bswap.h \ continued-fraction.c continued-fraction.h \ zero.c zero.h \ add.c add.h \ @@ -49,9 +49,8 @@ libsydney_la_SOURCES = \ interleave.c interleave.h \ converter.c converter.h \ g711.c g711.h \ - mutex.c mutex.h \ - once.c once.h \ - thread.c thread.h \ + mutex-posix.c mutex.h \ + thread-posix.c thread.h \ bufferq.c buffer.h \ meta-name-table.h # asyncq.c asyncq.h @@ -97,7 +96,7 @@ BUILT_SOURCES = \ meta-name-table.h meta-name-table.h: meta-name-table.gperf Makefile - gperf -t -N sa_lookup_meta_name -H sa_hash_meta_name -p -C < $< | sed -e 's/{""}/{"", 0}/g' > $@ + gperf -L ANSI-C -t -N sa_lookup_meta_name -H sa_hash_meta_name -p -C < $< | sed -e 's/{""}/{"", 0}/g' > $@ fixme: find -name '*.c' -exec fgrep -H -A 3 -B 3 -i FIXME \{\} \; diff --git a/src/add.c b/src/add.c index b7714f4..74eef31 100644 --- a/src/add.c +++ b/src/add.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "macro.h" diff --git a/src/asyncq.c b/src/asyncq.c index 54d7d5b..ad5b795 100644 --- a/src/asyncq.c +++ b/src/asyncq.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include "sydney.h" #include "asyncq.h" #include "malloc.h" @@ -10,7 +14,7 @@ int sa_asyncq_init(sa_asyncq_t *a, size_t item_size) { a->last = NULL; a->item_size = item_size; - + if (!(a->mutex = sa_mutex_new(0))) return SA_ERROR_OOM; @@ -19,7 +23,7 @@ int sa_asyncq_init(sa_asyncq_t *a, size_t item_size) { sa_asyncq_item_t *sa_asyncq_get(sa_asyncq_t *a) { sa_assert(a); - + sa_mutex_lock(a->mutex); if ((i = a->unused)) @@ -53,7 +57,7 @@ void sa_asyncq_push(sa_asyncq_t *a, sa_asyncq_item_t *i) { SA_LLIST_INSERT_AFTER(sa_asyncq_item_t, items, a->items, a->last, i); else SA_LLIST_PREPEND(sa_asyncq_item_t, items, a->items, i); - + a->last = i; sa_mutex_unlock(a->mutex); @@ -63,7 +67,7 @@ void sa_asyncq_push(sa_asyncq_t *a, sa_asyncq_item_t *i) { sa_asyncq_item_t sa_asyncq_pop(sa_asyncq_t *a, int wait) { sa_asyncq_item_t *i; - + sa_assert(a); if (wait) @@ -75,10 +79,10 @@ sa_asyncq_item_t sa_asyncq_pop(sa_asyncq_t *a, int wait) { if ((i = a->items)) { if (i == a->last) a->last = NULL; - + SA_LLIST_REMOVE(sa_asyncq_item_t, items, a->items, i); } - + sa_mutex_unlock(a->mutex); return i; @@ -91,7 +95,7 @@ void sa_asyncq_done(sa_asyncq_t *a) { /* The caller *must* pop all items from the queue before * destructing us! */ sa_assert(!a->items); - + if (a->mutex) sa_mutex_free(a->mutex); diff --git a/src/asyncq.h b/src/asyncq.h index 2e60c23..5d26283 100644 --- a/src/asyncq.h +++ b/src/asyncq.h @@ -1,5 +1,5 @@ -#ifndef foosydneyhasynchfoo -#define foosydneyhasynchfoo +#ifndef foosydneyasynchfoo +#define foosydneyasynchfoo #include "llist.h" #include "mutex.h" @@ -11,7 +11,7 @@ struct sa_asyncq_item { SA_LLIST_ITEM(sa_asyncq_item_t, items); }; -#define SA_ASYNCQ_ITEM_DATA(x) ((void*) ((uint8_t*) (x) + ALIGN(sizeof(sa_asyncq_item_t)))) +#define SA_ASYNCQ_ITEM_DATA(x) ((void*) ((uint8_t*) (x) + SA_ALIGN(sizeof(sa_asyncq_item_t)))) struct sa_asyncq { sa_mutex_t *mutex; diff --git a/src/bbuffer.c b/src/bbuffer.c index c8cbaa0..86bc5ee 100644 --- a/src/bbuffer.c +++ b/src/bbuffer.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "bbuffer.h" @@ -12,7 +16,7 @@ int sa_bbuffer_init(sa_bbuffer_t *b, unsigned nchannels, size_t sample_size) { b->nchannels = nchannels; b->sample_size = sample_size; - + if (!(b->data = sa_new0(void *, nchannels))) { b->size = NULL; return SA_ERROR_OOM; @@ -23,7 +27,7 @@ int sa_bbuffer_init(sa_bbuffer_t *b, unsigned nchannels, size_t sample_size) { b->data = NULL; return SA_ERROR_OOM; } - + return SA_SUCCESS; } @@ -34,7 +38,7 @@ void sa_bbuffer_done(sa_bbuffer_t *b) { if (b->data) { for (i = 0; i < b->nchannels; i++) sa_free(b->data[i]); - + sa_free(b->data); } @@ -50,7 +54,7 @@ void* sa_bbuffer_get(sa_bbuffer_t *b, unsigned channel, size_t size, int interle sa_assert(size > 0); if (interleave) { - + if (!b->data[0] || size * b->nchannels > b->size[0]) { sa_free(b->data[0]); b->size[0] = size * b->nchannels; @@ -60,7 +64,7 @@ void* sa_bbuffer_get(sa_bbuffer_t *b, unsigned channel, size_t size, int interle } return (uint8_t*) b->data[0] + (b->sample_size * channel); - + } else { if (!b->data[channel] || size > b->size[channel]) { diff --git a/src/bswap.c b/src/bswap.c new file mode 100644 index 0000000..501f98a --- /dev/null +++ b/src/bswap.c @@ -0,0 +1,74 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + +#ifdef HAVE_BYTESWAP_H +#include +#endif + +#include + +#include "macro.h" +#include "bswap.h" + +static void byteswap16(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) { + uint16_t *dst = _dst; + const uint16_t *src = _src; + unsigned n = bytes / sizeof(uint16_t); + + for (; n > 0; n--) { + +#ifdef HAVE_BYTESWAP_H + *dst = bswap_16(*src); +#else + *dst = (*src >> 8) | (*src << 8); +#endif + + src += sstr / sizeof(uint16_t); + dst += dstr / sizeof(uint16_t); + } +} + +static void byteswap24(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) { + uint8_t *dst = _dst; + const uint8_t *src = _src; + unsigned n = bytes / (sizeof(uint8_t)*3); + + for (; n > 0; n--) { + dst[0] = src[2]; + dst[2] = src[0]; + + src += sstr / (sizeof(uint8_t)*3); + dst += dstr / (sizeof(uint8_t)*3); + } +} + +static void byteswap32(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) { + uint32_t *dst = _dst; + const uint32_t *src = _src; + unsigned n = bytes / sizeof(uint32_t); + + for (; n > 0; n--) { +#ifdef HAVE_BYTESWAP_H + *dst = bswap_32(*src); +#else + *dst = (*src << 24) | ((*src & 0xFF00) << 8) | ((*src >> 8) & 0xFF00) | (*src >> 24); +#endif + src += sstr / sizeof(uint32_t); + dst += dstr / sizeof(uint32_t); + } +} + +sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f) { + + static const sa_byteswap_func_t funcs[_SA_PCM_FORMAT_MAX] = { + [SA_PCM_FORMAT_S16_RE] = byteswap16, + [SA_PCM_FORMAT_S24_RE] = byteswap24, + [SA_PCM_FORMAT_S32_RE] = byteswap32, + [SA_PCM_FORMAT_FLOAT32_BE] = byteswap32, + }; + + sa_assert(f < _SA_PCM_FORMAT_MAX); + + return funcs[f]; +} diff --git a/src/bswap.h b/src/bswap.h new file mode 100644 index 0000000..4eeb24f --- /dev/null +++ b/src/bswap.h @@ -0,0 +1,12 @@ +#ifndef foosydneybswaphfoo +#define foosydneybswaphfoo + +#include + +#include "sydney.h" + +typedef void (*sa_byteswap_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); + +sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f); + +#endif diff --git a/src/bufferq.c b/src/bufferq.c index 1965dda..bafcaa1 100644 --- a/src/bufferq.c +++ b/src/bufferq.c @@ -1,10 +1,14 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "malloc.h" #include "macro.h" #include "bufferq.h" -#define SA_BUFFERQ_ITEM_CONCAT_DATA(x) ((void*) (uint8_t*) (x) + SA_ALIGN(sizeof(sa_bufferq_item_t))) +#define SA_BUFFERQ_ITEM_CONCAT_DATA(x) ((void*) ((uint8_t*) (x) + SA_ALIGN(sizeof(sa_bufferq_item_t)))) int sa_bufferq_init(sa_bufferq_t *q, unsigned nchannels, size_t sample_size) { sa_assert(q); @@ -23,7 +27,7 @@ int sa_bufferq_init(sa_bufferq_t *q, unsigned nchannels, size_t sample_size) { q->items = NULL; return SA_ERROR_OOM; } - + return SA_SUCCESS; } @@ -33,7 +37,7 @@ void sa_bufferq_done(sa_bufferq_t *q) { for (u = 0; u < q->nchannels; u++) { sa_bufferq_item_t *i; - + while ((i = q->items[u])) { SA_LLIST_REMOVE(sa_bufferq_item_t, bufferq, q->items[u], i); sa_free(i); @@ -62,7 +66,7 @@ static sa_bufferq_item_t* bufferq_item_new(const void *d, int64_t idx, size_t si if (!(i = sa_new(sa_bufferq_item_t, 1))) return NULL; - + i->data = (void*) d; } @@ -77,7 +81,7 @@ static sa_bufferq_item_t* bufferq_item_new(const void *d, int64_t idx, size_t si static sa_bufferq_item_t* bufferq_item_make_writable(sa_bufferq_item_t *i) { void *d; sa_assert(i); - + if (i->type == SA_BUFFERQ_ITEM_CONCATENATED || i->type == SA_BUFFERQ_ITEM_DYNAMIC) return i; @@ -91,7 +95,7 @@ static sa_bufferq_item_t* bufferq_item_make_writable(sa_bufferq_item_t *i) { static void bufferq_item_free(sa_bufferq_item_t *i) { sa_assert(i); - + if (i->type == SA_BUFFERQ_ITEM_DYNAMIC) sa_free(i->data); sa_free(i); @@ -100,7 +104,7 @@ static void bufferq_item_free(sa_bufferq_item_t *i) { int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence, sa_bufferq_item_type_t type) { int64_t idx; sa_bufferq_item_t *i, *j, *n; - + sa_assert(q); switch (whence) { @@ -122,11 +126,11 @@ int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t if (l > nbytes) l = nbytes; - + idx += l; - data += l; + data = (const uint8_t*) data + l; nbytes -= l; - + } /* Allocate the new entry */ @@ -142,7 +146,7 @@ int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t i->size = idx - i->idx; i = i->bufferq_next; } - + /* Insert the entry */ if (i) SA_LLIST_INSERT_BEFORE(sa_bufferq_item_t, bufferq, q->items[channel], i, j); @@ -154,14 +158,14 @@ int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t q->last[channel] = j; } - + /* Now kick all the entries that overlap entirely with our new entry */ for (i = j->bufferq_next; i && i->idx + i->size < j->idx + j->size ; i = n) { n = i->bufferq_next; SA_LLIST_REMOVE(sa_bufferq_item_t, bufferq, q->items[channel], i); bufferq_item_free(i); } - + q->write_index = idx + nbytes; if (q->write_index > q->end_index) @@ -176,7 +180,7 @@ void sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) { sa_assert(q); *bytes = 0; - + for (u = 0; u < q->nchannels; u++) { if (q->items[u]) { @@ -198,14 +202,14 @@ void sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) { i[u] = (uint8_t*) q->items[u]->data + q->read_index - q->items[u]->idx; l = q->items[u]->size - (q->read_index - q->items[u]->idx); - + if (first) { *bytes = l; first = 0; } else *bytes = l < *bytes ? l : *bytes; } - + } else i[u] = NULL; } @@ -214,16 +218,16 @@ void sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) { void sa_bufferq_drop(sa_bufferq_t *q, int64_t bytes) { unsigned u; - + sa_assert(q); q->read_index += bytes; for (u = 0; u < q->nchannels; u++) { sa_bufferq_item_t *i; - + i = q->items[u]; - + while (i && q->read_index >= i->idx + i->size) { sa_bufferq_item_t *n = i->bufferq_next; @@ -258,7 +262,7 @@ int sa_bufferq_realloc(sa_bufferq_t *q) { * return without doing anything, hence let's at least * drop the reference to the statically allocated * data */ - + i->size = 0; i->data = SA_BUFFERQ_ITEM_CONCAT_DATA(i); i->type = SA_BUFFERQ_ITEM_CONCATENATED; diff --git a/src/byteswap.c b/src/byteswap.c deleted file mode 100644 index 8ae0b7a..0000000 --- a/src/byteswap.c +++ /dev/null @@ -1,57 +0,0 @@ -#include - -#include "macro.h" -#include "byteswap.h" - -static void byteswap16(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) { - uint16_t *dst = _dst; - const uint16_t *src = _src; - unsigned n = bytes / sizeof(uint16_t); - - for (; n > 0; n--) { - *dst = (*src >> 8) | (*src << 8); - src += sstr / sizeof(uint16_t); - dst += dstr / sizeof(uint16_t); - } -} - -static void byteswap24(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) { - uint8_t *dst = _dst; - const uint8_t *src = _src; - unsigned n = bytes / (sizeof(uint8_t)*3); - - for (; n > 0; n--) { - dst[0] = src[2]; - dst[2] = src[0]; - - src += sstr / (sizeof(uint8_t)*3); - dst += dstr / (sizeof(uint8_t)*3); - } -} - -static void byteswap32(void *_dst, size_t dstr, const void *_src, size_t sstr, size_t bytes) { - uint32_t *dst = _dst; - const uint32_t *src = _src; - unsigned n = bytes / sizeof(uint32_t); - - for (; n > 0; n--) { - *dst = (*src << 24) | ((*src & 0xFF00) << 8) | ((*src >> 8) & 0xFF00) | (*src >> 24); - src += sstr / sizeof(uint32_t); - dst += dstr / sizeof(uint32_t); - } -} - -sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f) { - - static const sa_byteswap_func_t funcs[_SA_PCM_FORMAT_MAX] = { - [SA_PCM_FORMAT_S16_RE] = byteswap16, - [SA_PCM_FORMAT_S24_RE] = byteswap24, - [SA_PCM_FORMAT_S32_RE] = byteswap32, - [SA_PCM_FORMAT_FLOAT32_BE] = byteswap32, - }; - - sa_assert(f < _SA_PCM_FORMAT_MAX); - - return funcs[f]; -} - diff --git a/src/byteswap.h b/src/byteswap.h deleted file mode 100644 index 4116677..0000000 --- a/src/byteswap.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef foosydneyhbyteswaphfoo -#define foosydneyhbyteswaphfoo - -#include - -#include "sydney.h" - -typedef void (*sa_byteswap_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); - -sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f); - -#endif diff --git a/src/common.c b/src/common.c index 5a81d02..c8017e8 100644 --- a/src/common.c +++ b/src/common.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include @@ -21,11 +25,11 @@ 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(0))) { + if (!(d->mutex = sa_mutex_new(FALSE, FALSE))) { sa_free(d); return NULL; } - + return d; } @@ -34,7 +38,7 @@ int sa_stream_create_opaque( const char *client_name, sa_mode_t mode, const char *codec) { - + int error; sa_return_val_if_fail(s, SA_ERROR_INVALID); @@ -74,7 +78,7 @@ int sa_stream_create_pcm( int ret; size_t lwm; - + 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); @@ -100,12 +104,12 @@ int sa_stream_create_pcm( if ((ret = sa_stream_change_rate(*s, rate))) goto fail; - + lwm = ((*s)->pcm_frame_size * (*s)->pcm_attrs.rate) / 20; /* 50 ms */ if (lwm <= 0) lwm = (*s)->pcm_frame_size * (*s)->pcm_attrs.rate; /* 1s */ - + if (mode & SA_MODE_RDONLY) { if ((ret = sa_stream_set_read_lower_watermark(*s, lwm))) @@ -113,7 +117,7 @@ int sa_stream_create_pcm( if ((ret = sa_stream_set_read_upper_watermark(*s, lwm*2))) goto fail; - } + } if (mode & SA_MODE_WRONLY) { @@ -123,24 +127,24 @@ int sa_stream_create_pcm( if ((ret = sa_stream_set_write_upper_watermark(*s, lwm*2))) goto fail; } - + oil_init(); if (client_name) if ((ret = sa_stream_change_meta_data(*s, SA_META_CLIENT_NAME, client_name, strlen(client_name))) < 0) goto fail; - + return SA_SUCCESS; fail: - + sa_stream_destroy(*s); return ret; } int sa_stream_open(sa_stream_t *s) { int ret; - + 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); @@ -161,7 +165,7 @@ int sa_stream_open(sa_stream_t *s) { int sa_stream_destroy(sa_stream_t *s) { int ret; unsigned u; - + sa_return_val_if_fail_mutex(s->mutex, s, SA_ERROR_INVALID); ret = driver_destroy(s); @@ -241,7 +245,7 @@ int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size) { int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map, unsigned n) { const sa_channel_t *c; sa_channel_t *m; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(map, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -254,7 +258,7 @@ int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t *map, unsigned sa_mutex_unlock(s->mutex); return SA_ERROR_INVALID; } - + if (!(m = sa_memdup(map, sizeof(sa_channel_t) * s->pcm_attrs.nchannels))) { sa_mutex_unlock(s->mutex); return SA_ERROR_OOM; @@ -305,7 +309,7 @@ int sa_stream_set_dynamic_rate(sa_stream_t *s, int enable) { int sa_stream_set_driver(sa_stream_t *s, const char *driver) { char *d; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(driver, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -315,17 +319,17 @@ int sa_stream_set_driver(sa_stream_t *s, const char *driver) { sa_mutex_unlock(s->mutex); return SA_ERROR_OOM; } - + sa_free(s->driver); s->driver = d; - + sa_mutex_unlock(s->mutex); return SA_SUCCESS; } int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t callback) { int r; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(callback, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -336,14 +340,14 @@ int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t callback) { if (r == SA_SUCCESS) s->callback = callback; - + sa_mutex_unlock(s->mutex); return r; } int sa_stream_stop_thread(sa_stream_t *s) { int r; - + 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_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE); @@ -353,7 +357,7 @@ int sa_stream_stop_thread(sa_stream_t *s) { if (r == SA_SUCCESS) s->callback = NULL; - + sa_mutex_unlock(s->mutex); return r; } @@ -361,7 +365,7 @@ int sa_stream_stop_thread(sa_stream_t *s) { int sa_stream_change_device(sa_stream_t *s, const char *device_name) { char *d; int ret; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(device_name, SA_ERROR_INVALID); @@ -379,7 +383,7 @@ int sa_stream_change_device(sa_stream_t *s, const char *device_name) { sa_free(d); sa_mutex_unlock(s->mutex); - + return ret; } @@ -404,11 +408,11 @@ int sa_stream_change_read_volume(sa_stream_t *s, const int32_t vol[], unsigned n sa_mutex_unlock(s->mutex); return SA_ERROR_OOM; } - + for (i = 0; i < s->pcm_attrs.nchannels; i++) v[i] = vol[0]; } - + ret = s->state == SA_STATE_INIT ? SA_SUCCESS : driver_change_read_volume(s, v); if (ret == SA_SUCCESS) { @@ -442,7 +446,7 @@ int sa_stream_change_write_volume(sa_stream_t *s, const int32_t vol[], unsigned sa_mutex_unlock(s->mutex); return SA_ERROR_OOM; } - + for (i = 0; i < s->pcm_attrs.nchannels; i++) v[i] = vol[0]; } @@ -461,7 +465,7 @@ int sa_stream_change_write_volume(sa_stream_t *s, const int32_t vol[], unsigned int sa_stream_change_rate(sa_stream_t *s, unsigned rate) { int ret; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(rate > 0, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -480,9 +484,9 @@ int sa_stream_change_rate(sa_stream_t *s, unsigned rate) { int sa_stream_change_user_data(sa_stream_t *s, const void *value) { sa_return_val_if_fail(s->mutex, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); - + s->user_data = (void*) value; - + sa_mutex_unlock(s->mutex); return SA_SUCCESS; } @@ -597,7 +601,7 @@ int sa_stream_get_mode(sa_stream_t *s, sa_mode_t *access_mode) { int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size) { size_t n; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(size && (*size == 0 || codec), SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -612,7 +616,7 @@ int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size) { if (codec) strcpy(codec, s->codec); *size = n; - + sa_mutex_unlock(s->mutex); return SA_SUCCESS; } @@ -719,7 +723,7 @@ int sa_stream_get_dynamic_rate(sa_stream_t *s, int *enabled) { int sa_stream_get_driver(sa_stream_t *s, char *driver, size_t *size) { size_t n; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(size && (*size == 0 || driver), SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -734,7 +738,7 @@ int sa_stream_get_driver(sa_stream_t *s, char *driver, size_t *size) { if (driver) strcpy(driver, s->driver); *size = n; - + sa_mutex_unlock(s->mutex); return SA_SUCCESS; } @@ -885,7 +889,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) { int ret; - + 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); @@ -930,7 +934,7 @@ int sa_stream_read_ni(sa_stream_t *s, unsigned channel, void *data, size_t nbyte sa_return_val_if_fail_mutex(s->mutex, s->state == SA_STATE_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE); ret = driver_read_ni(s, channel, data, nbytes); - + sa_mutex_unlock(s->mutex); return ret; } @@ -945,7 +949,7 @@ int sa_stream_write_ni(sa_stream_t *s, unsigned channel, const void *data, size_ int sa_stream_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { int ret; - + 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); @@ -1002,7 +1006,7 @@ int sa_stream_get_read_size(sa_stream_t *s, size_t *size) { int sa_stream_get_write_size(sa_stream_t *s, size_t *size) { int ret; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(size, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -1017,7 +1021,7 @@ int sa_stream_get_write_size(sa_stream_t *s, size_t *size) { int sa_stream_resume(sa_stream_t *s) { int ret; - + 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_RUNNING || s->state == SA_STATE_STOPPED, SA_ERROR_STATE); @@ -1043,7 +1047,7 @@ int sa_stream_pause(sa_stream_t *s) { int sa_stream_drain(sa_stream_t *s) { int ret; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); sa_return_val_if_fail_mutex(s->mutex, s->mode & SA_MODE_WRONLY, SA_ERROR_STATE); @@ -1056,7 +1060,7 @@ int sa_stream_drain(sa_stream_t *s) { } size_t sa_get_pcm_sample_size(sa_pcm_format_t f) { - + switch (f) { case SA_PCM_FORMAT_U8: case SA_PCM_FORMAT_ULAW: @@ -1069,7 +1073,7 @@ size_t sa_get_pcm_sample_size(sa_pcm_format_t f) { case SA_PCM_FORMAT_S24_LE: case SA_PCM_FORMAT_S24_BE: return 3; - + case SA_PCM_FORMAT_S32_LE: case SA_PCM_FORMAT_S32_BE: case SA_PCM_FORMAT_FLOAT32_LE: @@ -1089,13 +1093,13 @@ static int meta_check_png(const void *data, size_t size) { if (size < sizeof(png_signature)) return 0; - + return memcmp(data, png_signature, 8) == 0; } static int meta_check_utf8(const void *data, size_t size) { int32_t idx; - + oil_utf8_validate(&idx, data, size); return (size_t) idx == size; @@ -1110,14 +1114,14 @@ static int meta_check_pid(const void *data, size_t size) { if (memchr(data, 0, size)) return 0; - + if (!(t = sa_strndup(data, size))) return 0; - + errno = 0; pid = strtol(t, NULL, 10); sa_free(t); - + if (errno != 0) return 0; @@ -1135,7 +1139,7 @@ static int meta_check_icon_name(const void *data, size_t size) { if (memchr(data, 0, size)) return 0; - + if (size == 1 && t[0] == '.') return 0; @@ -1144,7 +1148,7 @@ static int meta_check_icon_name(const void *data, size_t size) { if (memchr(t, '/', size)) return 0; - + return 1; } @@ -1154,7 +1158,7 @@ static int meta_check_word(const void *data, size_t size) { for (; size > 0; size --, t++) if (*t <= 32 || *t >= 127) return 0; - + return 1; } @@ -1175,7 +1179,7 @@ int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *dat meta_check_word, /* FIXME */ meta_check_word, /* FIXME */ }; - + sa_return_val_if_fail(s, SA_ERROR_INVALID); sa_return_val_if_fail(name, SA_ERROR_INVALID); sa_mutex_lock(s->mutex); @@ -1205,7 +1209,7 @@ int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *dat s->meta_data_size[m->idx] = size; } else sa_free(d); - + sa_mutex_unlock(s->mutex); return ret; } @@ -1217,7 +1221,7 @@ int sa_stream_get_meta_data(sa_stream_t *s, const char *name, void *data, size_t sa_return_val_if_fail(name, SA_ERROR_INVALID); sa_return_val_if_fail(size && (*size == 0 || data), SA_ERROR_INVALID); sa_mutex_lock(s->mutex); - + if (!(m = sa_lookup_meta_name(name, strlen(name)))) { sa_mutex_unlock(s->mutex); return SA_ERROR_NO_META; diff --git a/src/common.h b/src/common.h index b5f316c..dbf03b0 100644 --- a/src/common.h +++ b/src/common.h @@ -1,5 +1,5 @@ -#ifndef foocommonh -#define foocommonh +#ifndef foosydneycommonh +#define foosydneycommonh #include "sydney.h" #include "mutex.h" @@ -30,12 +30,12 @@ struct sa_stream { sa_xrun_mode_t xrun_mode; int ni_enabled; int dynamic_rate_enabled; - + sa_event_callback_t event_callback; char *device; char *driver; - + int32_t *read_volume; int32_t *write_volume; @@ -57,7 +57,7 @@ struct sa_stream { void *meta_data[_META_NAMES_MAX]; size_t meta_data_size[_META_NAMES_MAX]; - sa_mutex_t *mutex; + sa_mutex *mutex; sa_event_callback_t callback; }; diff --git a/src/continued-fraction.c b/src/continued-fraction.c index 6cbf8a5..5aa7a4f 100644 --- a/src/continued-fraction.c +++ b/src/continued-fraction.c @@ -1,6 +1,9 @@ +#ifdef HAVE_CONFIG_H +#include +#endif /* * Stolen from gnumeric - * + * * Original code from Morten Welinder */ diff --git a/src/converter.c b/src/converter.c index 3b146ce..c5283f6 100644 --- a/src/converter.c +++ b/src/converter.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include @@ -9,7 +13,7 @@ #include "common.h" #include "format.h" #include "volscale.h" -#include "byteswap.h" +#include "bswap.h" #include "zero.h" #include "add.h" #include "bbuffer.h" @@ -36,21 +40,21 @@ static int native_pcm_format_resample(sa_pcm_format_t f) { } static sa_pcm_format_t byteswap_fix(sa_pcm_format_t f) { - + switch (f) { case SA_PCM_FORMAT_U8: case SA_PCM_FORMAT_ULAW: case SA_PCM_FORMAT_ALAW: return f; - + case SA_PCM_FORMAT_S16_NE: case SA_PCM_FORMAT_S16_RE: return SA_PCM_FORMAT_S16_NE; - + case SA_PCM_FORMAT_S24_NE: case SA_PCM_FORMAT_S24_RE: return SA_PCM_FORMAT_S24_NE; - + case SA_PCM_FORMAT_S32_NE: case SA_PCM_FORMAT_S32_RE: return SA_PCM_FORMAT_S32_NE; @@ -67,12 +71,12 @@ static sa_pcm_format_t byteswap_fix(sa_pcm_format_t f) { } static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { - + switch (a) { case SA_PCM_FORMAT_U8: case SA_PCM_FORMAT_ULAW: case SA_PCM_FORMAT_ALAW: - + switch (b) { case SA_PCM_FORMAT_U8: return SA_PCM_FORMAT_U8; @@ -88,7 +92,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { case SA_PCM_FORMAT_S32_LE: case SA_PCM_FORMAT_S32_BE: return SA_PCM_FORMAT_S32_NE; - + case SA_PCM_FORMAT_FLOAT32_LE: case SA_PCM_FORMAT_FLOAT32_BE: return SA_PCM_FORMAT_FLOAT32_NE; @@ -98,7 +102,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { } break; - + case SA_PCM_FORMAT_S16_LE: case SA_PCM_FORMAT_S16_BE: @@ -115,7 +119,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { case SA_PCM_FORMAT_S32_LE: case SA_PCM_FORMAT_S32_BE: return SA_PCM_FORMAT_S32_NE; - + case SA_PCM_FORMAT_FLOAT32_LE: case SA_PCM_FORMAT_FLOAT32_BE: return SA_PCM_FORMAT_FLOAT32_NE; @@ -124,7 +128,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { ; } break; - + case SA_PCM_FORMAT_S24_LE: case SA_PCM_FORMAT_S24_BE: case SA_PCM_FORMAT_S32_LE: @@ -141,7 +145,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { case SA_PCM_FORMAT_S32_LE: case SA_PCM_FORMAT_S32_BE: return SA_PCM_FORMAT_S32_NE; - + case SA_PCM_FORMAT_FLOAT32_LE: case SA_PCM_FORMAT_FLOAT32_BE: return SA_PCM_FORMAT_FLOAT32_NE; @@ -150,7 +154,7 @@ static sa_pcm_format_t get_work_format(sa_pcm_format_t a, sa_pcm_format_t b) { ; } break; - + case SA_PCM_FORMAT_FLOAT32_LE: case SA_PCM_FORMAT_FLOAT32_BE: return SA_PCM_FORMAT_FLOAT32_NE; @@ -169,12 +173,12 @@ static sa_pcm_format_t fix_work_format_for_resample(sa_pcm_format_t f) { case SA_PCM_FORMAT_S16_NE: return SA_PCM_FORMAT_S16_NE; break; - + case SA_PCM_FORMAT_S32_NE: case SA_PCM_FORMAT_FLOAT32_NE: return SA_PCM_FORMAT_FLOAT32_NE; break; - + default: ; } @@ -190,7 +194,7 @@ int sa_converter_init( unsigned u, t; int resample_required; - + sa_assert(c); sa_assert(from); sa_assert(to); @@ -211,26 +215,26 @@ int sa_converter_init( for (u = 0; u < to->nchannels; u++) { unsigned k = 0; - + for (t = 0; t < from->nchannels; t++) { if (from->channel_map[u] == to->channel_map[t]) { if (u != t) c->remap_required = 1; - + c->channel_map_table[u * (from->nchannels+1) + k++] += t; } } if (k > 1) c->sum_required = 1; - + c->channel_map_table[k] = (unsigned) -1; } if (c->from_nchannels != c->to_nchannels) - c->remap_required = 1; - + c->remap_required = 1; + resample_required = from->rate != to->rate || dynamic_rate_enabled; @@ -238,7 +242,7 @@ int sa_converter_init( c->work_pcm_format = get_work_format(from->format, to->format); if (resample_required) c->work_pcm_format = fix_work_format_for_resample(c->work_pcm_format); - + sa_assert(native_pcm_format_process(c->work_pcm_format)); sa_assert(!resample_required || native_pcm_format_resample(c->work_pcm_format)); @@ -253,31 +257,31 @@ int sa_converter_init( c->pre_format_func = sa_get_format_func(byteswap_fix(from->format), c->work_pcm_format); sa_assert(c->pre_format_func); } - + c->volscale_func = sa_get_volscale_func(c->work_pcm_format); sa_assert(c->volscale_func); - + c->zero_func = sa_get_zero_func(c->work_pcm_format); sa_assert(c->zero_func); - + c->add_func = sa_get_add_func(c->work_pcm_format); sa_assert(c->add_func); if (resample_required) { c->resample_func = sa_get_resample_func(c->work_pcm_format); sa_assert(c->resample_func); - } + } if (c->work_pcm_format != byteswap_fix(to->format)) { c->post_format_func = sa_get_format_func(c->work_pcm_format, byteswap_fix(to->format)); sa_assert(c->post_format_func); } - + c->post_byteswap_func = sa_get_byteswap_func(to->format); c->interleave_func = sa_get_interleave_func(to->format); sa_assert(c->interleave_func); - + /* Initialize resampler */ if (resample_required) { @@ -309,7 +313,7 @@ int sa_converter_init( c->no_volume = 1; /* Initialize bounce buffers */ - + if (sa_bbuffer_init(&c->bb_pre_byteswap, c->from_nchannels, c->from_sample_size) < 0) goto fail; if (sa_bbuffer_init(&c->bb_pre_format, c->from_nchannels, c->work_sample_size) < 0) @@ -328,7 +332,7 @@ int sa_converter_init( goto fail; if (sa_bbuffer_init(&c->bb_tmp, 1, 1) < 0) goto fail; - + return 0; fail: @@ -341,7 +345,7 @@ void sa_converter_done(sa_converter_t *c) { sa_assert(c); sa_free(c->channel_map_table); - + sa_free(c->from_process_data); sa_free(c->to_process_data); sa_free(c->from_stride); @@ -369,7 +373,7 @@ void sa_converter_done(sa_converter_t *c) { void* sa_converter_get_zero_buffer(sa_converter_t *c, size_t size) { void *b; - + sa_assert(c); sa_assert(size > 0); @@ -382,7 +386,7 @@ void* sa_converter_get_zero_buffer(sa_converter_t *c, size_t size) { return NULL; c->zero_func(b, c->work_sample_size, size); - return c->zero_func; + return c->zero_buffer; } int sa_converter_go( @@ -390,13 +394,13 @@ int sa_converter_go( const void *const src[], const size_t sstr[], int sinterleave, void **dst[], size_t *dstr[], int dinterleave, size_t *size) { - + size_t* stride; void** process_data; int is_bounce; int interleave; unsigned i; - + sa_assert(c); is_bounce = 0; @@ -404,7 +408,7 @@ int sa_converter_go( process_data = (void**) src; interleave = !!sinterleave; dinterleave = !!dinterleave; - + if (c->no_volume && !c->remap_required && !c->resample_func && @@ -414,18 +418,18 @@ int sa_converter_go( goto do_interleave; } - + if (c->pre_byteswap_func) { size_t k; - + k = dinterleave ? c->from_sample_size*c->from_nchannels : c->from_sample_size; - + for (i = 0; i < c->from_nchannels; i++) { void *b; if (!(b = sa_bbuffer_get(&c->bb_pre_byteswap, i, *size, dinterleave))) return SA_ERROR_OOM; - + c->pre_byteswap_func(b, k, process_data[i], stride[i], *size); c->from_process_data[i] = b; c->from_stride[i] = k; @@ -436,7 +440,7 @@ int sa_converter_go( interleave = dinterleave; is_bounce = 1; } - + if (c->pre_format_func) { if (is_bounce && c->from_sample_size == c->to_sample_size) { @@ -446,24 +450,24 @@ int sa_converter_go( for (i = 0; i < c->from_nchannels; i++) c->pre_format_func(&c->bb_tmp, process_data[i], stride[i], process_data[i], stride[i], *size); - + } else { size_t k, new_size; - + new_size = *size / c->from_sample_size * c->work_sample_size; k = dinterleave ? c->work_sample_size*c->from_nchannels : c->work_sample_size; - + for (i = 0; i < c->from_nchannels; i++) { void *b; - + if (!(b = sa_bbuffer_get(&c->bb_pre_format, i, new_size, dinterleave))) return SA_ERROR_OOM; - + c->pre_format_func(&c->bb_tmp, b, k, process_data[i], stride[i], *size); c->from_process_data[i] = b; c->from_stride[i] = k; } - + process_data = c->from_process_data; stride = c->from_stride; *size = new_size; @@ -480,7 +484,7 @@ int sa_converter_go( /* The data to process is already in a bounce buffer, we * can do this in-place */ - + for (i = 0; i < c->from_nchannels; i++); c->volscale_func(process_data[i], stride[i], process_data[i], stride[i], c->volume_factor[i], c->volume_divisor[i], *size); @@ -491,15 +495,15 @@ int sa_converter_go( for (i = 0; i < c->from_nchannels; i++) { void *b; - + if (!(b = sa_bbuffer_get(&c->bb_volscale, i, *size, dinterleave))) return SA_ERROR_OOM; - + c->volscale_func(b, k, process_data[i], stride[i], c->volume_factor[i], c->volume_divisor[i], *size); c->from_process_data[i] = b; c->from_stride[i] = k; } - + process_data = c->from_process_data; stride = c->from_stride; interleave = dinterleave; @@ -516,7 +520,7 @@ int sa_converter_go( for (i = 0; i < c->to_nchannels; i++) { void *b; int *p = &c->channel_map_table[i * (c->from_nchannels+1)]; - + if (p[0] == -1) { /* We have to write silence to this channel */ @@ -536,8 +540,8 @@ int sa_converter_go( need_proper_interleave = 1; } else { int j; - - /* We have to mix two or more channels */ + + /* We have to mix two or more channels */ if (!(b = sa_bbuffer_get(&c->bb_remap, i, *size, dinterleave))) return SA_ERROR_OOM; @@ -546,7 +550,7 @@ int sa_converter_go( for (j = 2; p[j] != -1; j++) c->add_func(b, k, b, k, process_data[p[j]], stride[p[j]], *size); - + c->to_process_data[i] = b; c->to_stride[i] = k; } @@ -565,7 +569,7 @@ int sa_converter_go( k = dinterleave ? c->work_sample_size*c->to_nchannels : c->work_sample_size; new_size = (size_t) (((((uint64_t) *size+c->work_sample_size-1)/c->work_sample_size)*c->to_rate)/c->from_rate+1)*c->work_sample_size; /* FIXME */ - + for (i = 0; i < c->to_nchannels; i++) { void *b; @@ -590,7 +594,7 @@ int sa_converter_go( /* The data to process is already in a bounce buffer, we * can do this in-place */ - + for (i = 0; i < c->to_nchannels; i++) c->post_format_func(&c->bb_tmp, process_data[i], stride[i], process_data[i], stride[i], *size); @@ -599,18 +603,18 @@ int sa_converter_go( k = dinterleave ? c->to_sample_size*c->to_nchannels : c->to_sample_size; new_size = *size / c->work_sample_size * c->to_sample_size; - + for (i = 0; i < c->to_nchannels; i++) { void *b; - + if (!(b = sa_bbuffer_get(&c->bb_post_format, i, new_size, dinterleave))) return SA_ERROR_OOM; - + c->post_format_func(&c->bb_tmp, b, k, process_data[i], stride[i], *size); c->to_process_data[i] = b; c->to_stride[i] = k; } - + process_data = c->to_process_data; stride = c->to_stride; *size = new_size; @@ -618,14 +622,14 @@ int sa_converter_go( is_bounce = 1; } } - + if (c->post_byteswap_func) { if (is_bounce) { /* The data to process is already in a bounce buffer, we * can do this in-place */ - + for (i = 0; i < c->to_nchannels; i++) c->post_byteswap_func(process_data[i], stride[i], process_data[i], stride[i], *size); @@ -633,15 +637,15 @@ int sa_converter_go( size_t k; k = dinterleave ? c->to_sample_size*c->to_nchannels : c->to_sample_size; - + for (i = 0; i < c->to_nchannels; i++) { void *b; - + if (!(b = sa_bbuffer_get(&c->bb_post_byteswap, i, *size, dinterleave))) return SA_ERROR_OOM; - + c->post_byteswap_func(b, k, process_data[i], stride[i], *size); - + c->to_process_data[i] = b; c->to_stride[i] = k; } @@ -654,7 +658,7 @@ int sa_converter_go( } do_interleave: - + if (interleave != dinterleave) { size_t k; @@ -662,16 +666,16 @@ do_interleave: for (i = 0; i < c->to_nchannels; i++) { void *b; - + if (!(b = sa_bbuffer_get(&c->bb_interleave, i, *size, dinterleave))) return SA_ERROR_OOM; - + c->interleave_func(b, k, process_data[i], stride[i], *size); - + c->to_process_data[i] = b; c->to_stride[i] = k; } - + process_data = c->to_process_data; stride = c->to_stride; interleave = dinterleave; @@ -687,7 +691,7 @@ do_interleave: void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) { unsigned i; int no_volume = 1; - + sa_assert(c); for (i = 0; i < c->from_nchannels; i++) { @@ -702,12 +706,12 @@ void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) { no_volume = 0; } else { float f = powf(10.0, (float) vol[i] / 2000); - + sa_continued_fraction(f, 0x7FFF, &num, &denom); - + if (num != 1 || denom != 1) no_volume = 0; - + c->volume_factor[i] = (int32_t) num; c->volume_divisor[i] = (int32_t) denom; } @@ -718,7 +722,7 @@ void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) { int sa_converter_go_interleaved( sa_converter_t *c, - const void *const data, + const void *const data, void **dst[], size_t *dstr[], int dinterleave, size_t *size) { diff --git a/src/converter.h b/src/converter.h index 8112231..30453df 100644 --- a/src/converter.h +++ b/src/converter.h @@ -3,7 +3,7 @@ #include "sydney.h" #include "volscale.h" -#include "byteswap.h" +#include "bswap.h" #include "zero.h" #include "add.h" #include "bbuffer.h" @@ -21,9 +21,9 @@ struct sa_converter { int sum_required; int remap_required; - + sa_pcm_format_t work_pcm_format; - + size_t from_sample_size, work_sample_size, to_sample_size; sa_byteswap_func_t pre_byteswap_func, post_byteswap_func; @@ -69,7 +69,7 @@ int sa_converter_go( int sa_converter_go_interleaved( sa_converter_t *c, - const void *const data, + const void *const data, void **dst[], size_t *dstr[], int dinterleave, size_t *size); diff --git a/src/driver.h b/src/driver.h index be5d4b8..15d690e 100644 --- a/src/driver.h +++ b/src/driver.h @@ -1,5 +1,5 @@ -#ifndef foodriverhfoo -#define foodriverhfoo +#ifndef foosydneydriverhfoo +#define foosydneydriverhfoo #include "sydney.h" diff --git a/src/format.c b/src/format.c index f7a8755..adac878 100644 --- a/src/format.c +++ b/src/format.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include @@ -11,7 +15,7 @@ static int format_u8_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int16_t d = -0x80, f = 0x100; - + oil_conv_s16_u8(dst, dstr, src, sstr, bytes); oil_scalaradd_s16(dst, dstr, dst, dstr, &d, bytes); oil_scalarmult_s16(dst, dstr, dst, dstr, &f, bytes); @@ -21,7 +25,7 @@ static int format_u8_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void static int format_u8_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int32_t d = -0x80, f = 0x1000000; - + oil_conv_s16_u8(dst, dstr, src, sstr, bytes); oil_scalaradd_s32(dst, dstr, dst, dstr, &d, bytes); oil_scalarmult_s32(dst, dstr, dst, dstr, &f, bytes); @@ -34,7 +38,7 @@ static int format_u8_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void oil_conv_f32_u8(dst, dstr, src, sstr, bytes); oil_scalaradd_f32(dst, dstr, dst, dstr, &d, bytes); - oil_scalarmult_f32(dst, dstr, dst, dstr, &f, bytes); + oil_scalarmult_f32(dst, dstr, dst, dstr, &f, bytes); return SA_SUCCESS; } @@ -112,7 +116,7 @@ static int format_s16_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void for (; n > 0; n--, d += dstr, s += sstr/sizeof(int16_t)) *d = (uint8_t) (*s / 0x100 + 0x80); - + return SA_SUCCESS; } @@ -143,7 +147,7 @@ static int format_s16_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void unsigned n = bytes/sizeof(int16_t); oil_conv_s32_s16(dst, dstr, src, sstr, n); - oil_scalarmult_s32(dst, dstr, dst, dstr, &f, n); + oil_scalarmult_s32(dst, dstr, dst, dstr, &f, n); return SA_SUCCESS; } @@ -151,9 +155,9 @@ static int format_s16_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void static int format_s16_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { float f = 1.0/0x7ffff; unsigned n = bytes/sizeof(int16_t); - + oil_conv_f32_s16(dst, dstr, src, sstr, n); - oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n); + oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n); return SA_SUCCESS; } @@ -173,7 +177,7 @@ static int format_s24_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void #else #error "Unknown byte order" #endif - + return SA_SUCCESS; } @@ -190,7 +194,7 @@ static int format_s24_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void #else #error "Unknown byte order" #endif - + return SA_SUCCESS; } @@ -203,7 +207,7 @@ static int format_s32_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void for (; n > 0; n--, d += dstr, s += sstr/sizeof(int32_t)) *d = (uint8_t) (*s / 0x1000000 + 0x80); - + return SA_SUCCESS; } @@ -236,7 +240,7 @@ static int format_s32_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void for (; n > 0; n--, d += dstr/sizeof(int16_t), s += sstr/sizeof(int32_t)) *d = (int16_t) (*s / 0x10000); - + return SA_SUCCESS; } @@ -247,7 +251,7 @@ static int format_s32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void for (; n > 0; n--, d += dstr/3, s += sstr/sizeof(int32_t)) { uint32_t j = (uint32_t) (*s) >> 8; - + #if defined(SA_LITTLE_ENDIAN) d[0] = j & 0xFF; d[1] = (j >> 8) & 0xFF; @@ -260,16 +264,16 @@ static int format_s32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void #error "Unknown byte order" #endif } - + return SA_SUCCESS; } static int format_s32_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { float f = 1.0/0x7fffffff; unsigned n = bytes/sizeof(int32_t); - + oil_conv_f32_s32(dst, dstr, src, sstr, n); - oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n); + oil_scalarmult_f32(dst, dstr, dst, dstr, &f, n); return SA_SUCCESS; } @@ -312,7 +316,7 @@ static int format_f32_to_alaw(sa_bbuffer_t *b, void *dst, size_t dstr, const voi uint8_t *d = dst; const float *s = src; unsigned n = bytes/sizeof(float); - + for (; n > 0; n --, d += dstr, s += sstr/sizeof(float)) { float v = *s * 0x7FFF; if (v < -0x8000) v = -0x8000; @@ -333,7 +337,7 @@ static int format_f32_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void if (!(buf = sa_bbuffer_get(b, 0, bytes, 1))) return SA_ERROR_OOM; - oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); + oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); oil_clipconv_s16_f32(d, dstr, buf, sizeof(float), n); return SA_SUCCESS; @@ -352,7 +356,7 @@ static int format_f32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void if (f < -0x800000) f = -0x800000; j = (uint32_t) ((int32_t) f); - + #if defined(SA_LITTLE_ENDIAN) d[0] = j & 0xFF; d[1] = (j >> 8) & 0xFF; @@ -365,7 +369,7 @@ static int format_f32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void #error "Unknown byte order" #endif } - + return SA_SUCCESS; } @@ -379,7 +383,7 @@ static int format_f32_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void if (!(buf = sa_bbuffer_get(b, 0, bytes, 1))) return SA_ERROR_OOM; - oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); + oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); oil_clipconv_s32_f32(d, dstr, buf, sizeof(float), n); return SA_SUCCESS; @@ -393,7 +397,7 @@ sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) { * 2. from all work formats to all "lower" formats * 3. only for NE types */ - + static const sa_format_func_t funcs[_SA_PCM_FORMAT_MAX * _SA_PCM_FORMAT_MAX] = { [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_U8 + SA_PCM_FORMAT_S16_NE ] = format_u8_to_s16, /* done */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_U8 + SA_PCM_FORMAT_S32_NE ] = format_u8_to_s32, /* done */ @@ -412,17 +416,17 @@ sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) { [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S16_NE + SA_PCM_FORMAT_ALAW ] = format_s16_to_alaw, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S16_NE + SA_PCM_FORMAT_S32_NE ] = format_s16_to_s32, /* done */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S16_NE + SA_PCM_FORMAT_FLOAT32_NE] = format_s16_to_f32, /* done */ - + [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S24_NE + SA_PCM_FORMAT_S32_NE ] = format_s24_to_s32, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S24_NE + SA_PCM_FORMAT_FLOAT32_NE] = format_s24_to_f32, /* done, no liboil */ - + [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE + SA_PCM_FORMAT_U8 ] = format_s32_to_u8, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE + SA_PCM_FORMAT_ULAW ] = format_s32_to_ulaw, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE + SA_PCM_FORMAT_ALAW ] = format_s32_to_alaw, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE + SA_PCM_FORMAT_S16_NE ] = format_s32_to_s16, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE + SA_PCM_FORMAT_S24_NE ] = format_s32_to_s24, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_S32_NE + SA_PCM_FORMAT_FLOAT32_NE] = format_s32_to_f32, /* done, but suboptimal */ - + [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_FLOAT32_NE + SA_PCM_FORMAT_U8 ] = format_f32_to_u8, /* done */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_FLOAT32_NE + SA_PCM_FORMAT_ULAW ] = format_f32_to_ulaw, /* done, no liboil */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_FLOAT32_NE + SA_PCM_FORMAT_ALAW ] = format_f32_to_alaw, /* done, no liboil */ @@ -433,6 +437,6 @@ sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) { sa_assert(from < _SA_PCM_FORMAT_MAX); sa_assert(to < _SA_PCM_FORMAT_MAX); - + return funcs[from * _SA_PCM_FORMAT_MAX + to]; } diff --git a/src/interleave.c b/src/interleave.c index d0470f7..31d1a6b 100644 --- a/src/interleave.c +++ b/src/interleave.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "macro.h" @@ -42,7 +46,7 @@ static void interleave32(void *_dst, size_t dstr, const void *_src, size_t sstr, } sa_interleave_func_t sa_get_interleave_func(sa_pcm_format_t f) { - + static const sa_interleave_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = interleave8, [SA_PCM_FORMAT_ULAW] = interleave8, @@ -56,9 +60,8 @@ sa_interleave_func_t sa_get_interleave_func(sa_pcm_format_t f) { [SA_PCM_FORMAT_FLOAT32_LE] = interleave32, [SA_PCM_FORMAT_FLOAT32_BE] = interleave32, }; - - sa_assert(f < _SA_PCM_FORMAT_MAX); + + sa_assert(f < _SA_PCM_FORMAT_MAX); return funcs[f]; } - diff --git a/src/interleave.h b/src/interleave.h index ed4a527..add447f 100644 --- a/src/interleave.h +++ b/src/interleave.h @@ -1,5 +1,5 @@ -#ifndef foosydneyhinterleavehfoo -#define foosydneyhinterleavehfoo +#ifndef foosydneyinterleavehfoo +#define foosydneyinterleavehfoo #include diff --git a/src/macro.h b/src/macro.h index d664c3e..4f2d018 100644 --- a/src/macro.h +++ b/src/macro.h @@ -1,5 +1,5 @@ -#ifndef foomacrohfoo -#define foomacrohfoo +#ifndef foosydneymacrohfoo +#define foosydneymacrohfoo #include #include @@ -101,4 +101,8 @@ static inline size_t sa_align(size_t l) { #define SA_ALIGN(x) (sa_align(x)) +typedef void (*sa_free_cb_t)(void *); + +typedef int sa_bool_t; + #endif diff --git a/src/malloc.c b/src/malloc.c index 6a89554..a5171fa 100644 --- a/src/malloc.c +++ b/src/malloc.c @@ -1,10 +1,17 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include +#include "macro.h" #include "malloc.h" void* sa_memdup(const void* p, size_t size) { void *r; + sa_assert(p); + if (!(r = sa_malloc(size))) return NULL; diff --git a/src/malloc.h b/src/malloc.h index bcaf53e..b969988 100644 --- a/src/malloc.h +++ b/src/malloc.h @@ -1,5 +1,5 @@ -#ifndef foomallochfoo -#define foomallochfoo +#ifndef foosydneymallochfoo +#define foosydneymallochfoo #include #include diff --git a/src/mutex-posix.c b/src/mutex-posix.c new file mode 100644 index 0000000..436696c --- /dev/null +++ b/src/mutex-posix.c @@ -0,0 +1,107 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include "malloc.h" +#include "macro.h" +#include "mutex.h" + +struct sa_mutex { + pthread_mutex_t mutex; +}; + +struct sa_cond { + pthread_cond_t cond; +}; + +sa_mutex* sa_mutex_new(sa_bool_t recursive, sa_bool_t inherit_priority) { + sa_mutex *m; + pthread_mutexattr_t attr; + int r; + + sa_assert_se(pthread_mutexattr_init(&attr) == 0); + + if (recursive) + sa_assert_se(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0); + +#ifdef HAVE_PTHREAD_PRIO_INHERIT + if (inherit_priority) + sa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) == 0); +#endif + + if (!(m = sa_new(sa_mutex, 1))) + return NULL; + +#ifndef HAVE_PTHREAD_PRIO_INHERIT + sa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0); + +#else + if ((r = pthread_mutex_init(&m->mutex, &attr))) { + + /* If this failed, then this was probably due to non-available + * priority inheritance. In which case we fall back to normal + * mutexes. */ + sa_assert(r == ENOTSUP && inherit_priority); + + sa_assert_se(pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_NONE) == 0); + sa_assert_se(pthread_mutex_init(&m->mutex, &attr) == 0); + } +#endif + + return m; +} + +void sa_mutex_free(sa_mutex *m) { + sa_assert(m); + + sa_assert_se(pthread_mutex_destroy(&m->mutex) == 0); + sa_free(m); +} + +void sa_mutex_lock(sa_mutex *m) { + sa_assert(m); + + sa_assert_se(pthread_mutex_lock(&m->mutex) == 0); +} + +void sa_mutex_unlock(sa_mutex *m) { + sa_assert(m); + + sa_assert_se(pthread_mutex_unlock(&m->mutex) == 0); +} + +sa_cond *sa_cond_new(void) { + sa_cond *c; + + if (!(c = sa_new(sa_cond, 1))) + return NULL; + + sa_assert_se(pthread_cond_init(&c->cond, NULL) == 0); + return c; +} + +void sa_cond_free(sa_cond *c) { + sa_assert(c); + + sa_assert_se(pthread_cond_destroy(&c->cond) == 0); + sa_free(c); +} + +void sa_cond_signal(sa_cond *c, int broadcast) { + sa_assert(c); + + if (broadcast) + sa_assert_se(pthread_cond_broadcast(&c->cond) == 0); + else + sa_assert_se(pthread_cond_signal(&c->cond) == 0); +} + +int sa_cond_wait(sa_cond *c, sa_mutex *m) { + sa_assert(c); + sa_assert(m); + + return pthread_cond_wait(&c->cond, &m->mutex); +} diff --git a/src/mutex.c b/src/mutex.c deleted file mode 100644 index 12a4f4a..0000000 --- a/src/mutex.c +++ /dev/null @@ -1,97 +0,0 @@ -#ifdef HAVE_CONFIG_H -#include -#endif - -#include -#include - -#include "macro.h" -#include "malloc.h" -#include "mutex.h" - -struct sa_mutex { - pthread_mutex_t mutex; -}; - -struct sa_cond { - pthread_cond_t cond; -}; - -sa_mutex_t* sa_mutex_new(int recursive) { - sa_mutex_t *m; - pthread_mutexattr_t attr; - - pthread_mutexattr_init(&attr); - - if (recursive) - sa_assert_success(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)); - - if (!(m = sa_new(sa_mutex_t, 1))) - return NULL; - - sa_assert_success(pthread_mutex_init(&m->mutex, &attr)); - return m; -} - -void sa_mutex_free(sa_mutex_t *m) { - sa_assert(m); - - sa_assert_success(pthread_mutex_destroy(&m->mutex)); - sa_free(m); -} - -void sa_mutex_lock(sa_mutex_t *m) { - sa_assert(m); - - sa_assert_success(pthread_mutex_lock(&m->mutex)); -} - -int sa_mutex_try_lock(sa_mutex_t *m) { - int e; - sa_assert(m); - - if ((e = pthread_mutex_trylock(&m->mutex)) == 0) - return 1; - - sa_assert(e == EBUSY); - return 0; -} - -void sa_mutex_unlock(sa_mutex_t *m) { - sa_assert(m); - - sa_assert_success(pthread_mutex_unlock(&m->mutex)); -} - -sa_cond_t *sa_cond_new(void) { - sa_cond_t *c; - - if (!(c = sa_new(sa_cond_t, 1))) - return NULL; - - sa_assert_success(pthread_cond_init(&c->cond, NULL)); - return c; -} - -void sa_cond_free(sa_cond_t *c) { - sa_assert(c); - - sa_assert_success(pthread_cond_destroy(&c->cond)); - sa_free(c); -} - -void sa_cond_signal(sa_cond_t *c, int broadcast) { - sa_assert(c); - - if (broadcast) - sa_assert_success(pthread_cond_broadcast(&c->cond)); - else - sa_assert_success(pthread_cond_signal(&c->cond)); -} - -int sa_cond_wait(sa_cond_t *c, sa_mutex_t *m) { - sa_assert(c); - sa_assert(m); - - return pthread_cond_wait(&c->cond, &m->mutex); -} diff --git a/src/mutex.h b/src/mutex.h index e83feb8..c24acb6 100644 --- a/src/mutex.h +++ b/src/mutex.h @@ -1,19 +1,20 @@ #ifndef foosydneymutexhfoo #define foosydneymutexhfoo -typedef struct sa_mutex sa_mutex_t; +#include "macro.h" -sa_mutex_t* sa_mutex_new(int recursive); -void sa_mutex_free(sa_mutex_t *m); -void sa_mutex_lock(sa_mutex_t *m); -void sa_mutex_unlock(sa_mutex_t *m); -int sa_mutex_try_lock(sa_mutex_t *m); +typedef struct sa_mutex sa_mutex; -typedef struct sa_cond sa_cond_t; +sa_mutex* sa_mutex_new(sa_bool_t recursive, sa_bool_t inherit_priority); +void sa_mutex_free(sa_mutex *m); +void sa_mutex_lock(sa_mutex *m); +void sa_mutex_unlock(sa_mutex *m); -sa_cond_t *sa_cond_new(void); -void sa_cond_free(sa_cond_t *c); -void sa_cond_signal(sa_cond_t *c, int broadcast); -int sa_cond_wait(sa_cond_t *c, sa_mutex_t *m); +typedef struct sa_cond sa_cond; + +sa_cond *sa_cond_new(void); +void sa_cond_free(sa_cond *c); +void sa_cond_signal(sa_cond *c, int broadcast); +int sa_cond_wait(sa_cond *c, sa_mutex *m); #endif diff --git a/src/oss.c b/src/oss.c index d09f8aa..3ad1a9d 100644 --- a/src/oss.c +++ b/src/oss.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include @@ -31,7 +35,7 @@ struct oss_stream { sa_converter_t converter_read, converter_write; size_t read_fragment_size, write_fragment_size; unsigned read_nfragments, write_nfragments; - sa_thread_t *thread; + sa_thread *thread; int socket_fds[2]; sa_bufferq_t bufferq; }; @@ -47,6 +51,9 @@ static int simple_log2(int v) { return k; } +#ifdef HAVE_CONFIG_H +#include +#endif static size_t fixup_bps(size_t s, size_t bps1, size_t bps2) { return (s*bps2)/bps1; @@ -54,12 +61,12 @@ 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; - char *n; + const char *n; int f, arg, bs, r, phase, i, found, suggested, fs, l, m; unsigned c; size_t real_bps = 0, bps; int loops = 0; - + static const int format_map[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = AFMT_U8, [SA_PCM_FORMAT_ULAW] = AFMT_MU_LAW, @@ -98,23 +105,23 @@ int driver_open(sa_stream_t *s) { * device again. */ if ((oss->fd = open(n, s->mode == SA_MODE_RDONLY ? O_RDONLY : (s->mode == SA_MODE_WRONLY ? O_WRONLY : O_RDWR) | O_NOCTTY | O_NONBLOCK)) < 0) { - + if (errno == ENODEV || errno == ENOENT) r = SA_ERROR_NO_DEVICE; else r = SA_ERROR_SYSTEM; - + goto fail; } - + fcntl(oss->fd, F_SETFL, fcntl(oss->fd, F_GETFL) & ~O_NONBLOCK); /* FIXME*/ - + if (!s->device) { if (!(n = sa_strdup(n))) { r = SA_ERROR_OOM; goto fail; } - + s->device = n; } @@ -122,12 +129,12 @@ int driver_open(sa_stream_t *s) { if (s->mode & SA_MODE_WRONLY) { bs = s->write_lower_watermark; } - + if (s->mode & SA_MODE_RDONLY) { int rbs; - + rbs = s->read_upper_watermark; - + if (s->mode & SA_MODE_WRONLY) bs = bs > rbs ? bs : rbs; else @@ -145,14 +152,14 @@ int driver_open(sa_stream_t *s) { if (m > 0x7FFF) m = 0x7FFF; printf("Asking OSS for: %u fragments, %u fragsize\n", m, 1 << l); - + arg = (m << 16) | l; - + ioctl(oss->fd, SNDCTL_DSP_SETFRAGMENT, &arg); /* We ignore errors on this call, since it's merely a hint anyway */ - + if (s->codec) { - + if (strcmp(s->codec, SA_CODEC_AC3) == 0) f = AFMT_AC3; else if (strcmp(s->codec, SA_CODEC_MPEG) == 0) @@ -161,27 +168,27 @@ int driver_open(sa_stream_t *s) { r = SA_ERROR_NO_CODEC; goto fail; } - + } else f = format_map[s->pcm_attrs.format]; - + bs = 0; - + for (;;) { arg = f; - + if (ioctl(oss->fd, SNDCTL_DSP_SETFMT, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } - + if (arg == f) break; - + /* Hmm, the device doesn't support what we're looking for, * let's try our luck */ - - if (f == AFMT_S16_LE && !bs) { + + if (f == AFMT_S16_LE && !bs) { f = AFMT_S16_BE; bs = 1; } else if (f == AFMT_S16_BE && !bs) { @@ -206,39 +213,39 @@ int driver_open(sa_stream_t *s) { goto fail; } } - + if (!s->codec) { - + switch (f) { case AFMT_MU_LAW: oss->real_pcm_attrs.format = SA_PCM_FORMAT_ULAW; break; - + case AFMT_A_LAW: oss->real_pcm_attrs.format = SA_PCM_FORMAT_ALAW; break; - + case AFMT_U8: oss->real_pcm_attrs.format = SA_PCM_FORMAT_U8; break; - + case AFMT_S16_LE: oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_LE; break; - + case AFMT_S16_BE: oss->real_pcm_attrs.format = SA_PCM_FORMAT_S16_BE; break; - + default: sa_assert_not_reached(); } - - + + found = 0; - + if (s->adjust_nchannels >= 0) { - + /* First try more channels ... */ for (c = s->pcm_attrs.nchannels; c < 8 || c == s->pcm_attrs.nchannels; c ++) { arg = c; @@ -246,13 +253,13 @@ int driver_open(sa_stream_t *s) { r = SA_ERROR_SYSTEM; goto fail; } - + if (arg == (int) c) { found = 1; break; } } - + /* ... then try less channels */ if (!found) { for (c = s->pcm_attrs.nchannels - 1; c > 0; c --) { @@ -261,7 +268,7 @@ int driver_open(sa_stream_t *s) { r = SA_ERROR_SYSTEM; goto fail; } - + if (arg == (int) c) { found = 1; break; @@ -269,7 +276,7 @@ int driver_open(sa_stream_t *s) { } } } else { - + /* First try less channels ... */ for (c = s->pcm_attrs.nchannels; c > 0; c --) { arg = c; @@ -277,13 +284,13 @@ int driver_open(sa_stream_t *s) { r = SA_ERROR_SYSTEM; goto fail; } - + if (arg == (int) c) { found = 1; break; } } - + /* ... then try more channels */ if (!found) { for (c = s->pcm_attrs.nchannels + 1; c < 8; c ++) { @@ -292,28 +299,28 @@ int driver_open(sa_stream_t *s) { r = SA_ERROR_SYSTEM; goto fail; } - + if (arg == (int) c) { found = 1; break; } } - } + } } - + if (!found) { errno = EIO; r = SA_ERROR_SYSTEM; goto fail; } - + oss->real_pcm_attrs.nchannels = c; - + if (!(oss->real_pcm_attrs.channel_map = sa_new(sa_channel_t, c))) { r = SA_ERROR_OOM; goto fail; } - + switch (c) { case 8: oss->real_pcm_attrs.channel_map[7] = SA_CHANNEL_REAR_RIGHT; @@ -335,25 +342,25 @@ int driver_open(sa_stream_t *s) { oss->real_pcm_attrs.channel_map[0] = SA_CHANNEL_MONO; break; } - + r = s->pcm_attrs.rate; - + if (r < 8000) r = 8000; - + suggested = 0; phase = 0; - + for (;;) { arg = r; - + if (ioctl(oss->fd, SNDCTL_DSP_SPEED, &arg) < 0) { r = SA_ERROR_SYSTEM; goto fail; } sa_assert(arg > 0); - + if (arg >= r*0.95 || arg <= r *1.05) break; @@ -361,20 +368,20 @@ int driver_open(sa_stream_t *s) { suggested = arg; if (s->adjust_rate >= 0) { - + if (phase == 0) { /* Find the next higher sample rate to try */ - + for (i = 0; i < (int) SA_ELEMENTSOF(try_rates); i++) { /* Yes, we could optimize a little here */ - + if (try_rates[i] > r) { r = try_rates[i]; - break; + break; } } - - + + if (i == SA_ELEMENTSOF(try_rates)) { phase = 1; r = s->pcm_attrs.rate; @@ -393,23 +400,23 @@ int driver_open(sa_stream_t *s) { break; } } - + sa_assert(i > 0); } - + } else { if (phase == 0) { /* Find the next lower sample rate to try */ for (i = SA_ELEMENTSOF(try_rates); i > 0; i--) { - + if (try_rates[i-1] < r) { r = try_rates[i-1]; - break; + break; } } - + if (i == 0) { phase = 1; r = s->pcm_attrs.rate; @@ -428,7 +435,7 @@ int driver_open(sa_stream_t *s) { break; } } - + sa_assert(i < (int) SA_ELEMENTSOF(try_rates)); } } @@ -463,38 +470,38 @@ int driver_open(sa_stream_t *s) { oss->read_fragment_size = arg; oss->read_nfragments = 2; } - + if (s->mode & SA_MODE_WRONLY) { oss->write_fragment_size = arg; oss->write_nfragments = 2; } } - + /* Now, let's use GETxSPACE */ if (s->mode & SA_MODE_RDONLY) { audio_buf_info info; - + if (ioctl(oss->fd, SNDCTL_DSP_GETISPACE, &info) >= 0) { oss->read_fragment_size = info.fragsize; oss->read_nfragments = info.fragstotal; } } - + if (s->mode & SA_MODE_WRONLY) { audio_buf_info info; - + if (ioctl(oss->fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) { oss->write_fragment_size = info.fragsize; oss->write_nfragments = info.fragstotal; } } - + if (s->mode & SA_MODE_WRONLY && (oss->write_fragment_size <= 0 || oss->write_nfragments <= 1)) { errno = EIO; r = SA_ERROR_SYSTEM; goto fail; } - + if (s->mode & SA_MODE_RDONLY && (oss->read_fragment_size <= 0 || oss->read_nfragments <= 1)) { errno = EIO; r = SA_ERROR_SYSTEM; @@ -502,7 +509,7 @@ int driver_open(sa_stream_t *s) { } if (!s->codec) { - + if (s->adjust_nchannels != 0) { sa_channel_t *cm; @@ -524,7 +531,7 @@ int driver_open(sa_stream_t *s) { if (s->mode & SA_MODE_RDONLY) if ((r = sa_converter_init(&oss->converter_read, &oss->real_pcm_attrs, &s->pcm_attrs, s->dynamic_rate_enabled)) < 0) goto fail; - + if (s->mode & SA_MODE_WRONLY) if ((r = sa_converter_init(&oss->converter_write, &s->pcm_attrs, &oss->real_pcm_attrs, s->dynamic_rate_enabled)) < 0) goto fail; @@ -542,7 +549,7 @@ int driver_open(sa_stream_t *s) { s->write_upper_watermark = oss->write_fragment_size * oss->write_nfragments; } } - + if (s->mode & SA_MODE_RDONLY) printf("Chosen for read: %u fragments, %u fragsize\n", oss->read_nfragments, oss->read_fragment_size); @@ -551,7 +558,7 @@ int driver_open(sa_stream_t *s) { if (sa_bufferq_init(&oss->bufferq, s->pcm_attrs.nchannels, s->pcm_sample_size) < 0) goto fail; - + return SA_SUCCESS; fail: @@ -566,19 +573,19 @@ int driver_destroy(sa_stream_t *s) { if (oss->thread) driver_stop_thread(s); - + if (oss->fd >= 0) close(oss->fd); - + sa_bufferq_done(&oss->bufferq); - + sa_free(oss->real_pcm_attrs.channel_map); sa_converter_done(&oss->converter_read); sa_converter_done(&oss->converter_write); sa_free(oss); } - + return SA_SUCCESS; } @@ -586,7 +593,7 @@ static int feed(sa_stream_t *s) { oss_stream_t *oss = OSS_STREAM(s); size_t w; int ret; - + sa_assert(s); for (;;) { @@ -612,10 +619,10 @@ static int feed(sa_stream_t *s) { drop = 1; s->state = SA_STATE_RUNNING; - + } else { nbytes = w > oss->write_fragment_size ? oss->write_fragment_size : w; - + if (!(d = sa_converter_get_zero_buffer(&oss->converter_write, nbytes))) return SA_ERROR_OOM; @@ -627,17 +634,17 @@ static int feed(sa_stream_t *s) { while (nbytes > 0) { ssize_t l; - + if ((l = write(oss->fd, d, nbytes)) < 0) return SA_ERROR_SYSTEM; - + sa_assert(l > 0); - + nbytes -= l; d += l; w -= 1; - + if (drop) sa_bufferq_drop(&oss->bufferq, l); } @@ -667,15 +674,15 @@ static void thread_func(void *data) { if (s->callback(s, SA_EVENT_INIT_THREAD) < 0) return; } - + memset(pollfds, 0, sizeof(pollfds)); pollfds[POLLFD_SOCKET_FD].fd = oss->socket_fds[0]; pollfds[POLLFD_SOCKET_FD].events = POLLIN; - + pollfds[POLLFD_OSS_FD].fd = oss->fd; pollfds[POLLFD_OSS_FD].events = ((s->mode & SA_MODE_RDONLY) ? POLLIN : 0) | ((s->mode & SA_MODE_WRONLY) ? POLLOUT : 0); - + for (;;) { int ret; if (poll(pollfds, POLLFD_MAX, -1) < 0) { @@ -732,7 +739,7 @@ int driver_start_thread(sa_stream_t *s, sa_event_callback_t callback) { if (!(oss->thread = sa_thread_new(thread_func, s))) return SA_ERROR_OOM; - + return SA_SUCCESS; } @@ -743,13 +750,13 @@ int driver_stop_thread(sa_stream_t *s) { if (oss->socket_fds[0] >= 0) close(oss->socket_fds[0]); - + if (oss->socket_fds[1] >= 0) close(oss->socket_fds[1]); - + if (oss->thread) sa_thread_free(oss->thread); - + oss->thread = NULL; oss->socket_fds[0] = oss->socket_fds[1] = -1; @@ -762,7 +769,7 @@ int driver_change_read_volume(sa_stream_t *s, const int32_t vol[]) { sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED); sa_converter_set_volume(&oss->converter_read, vol); - + return SA_SUCCESS; } @@ -772,7 +779,7 @@ int driver_change_write_volume(sa_stream_t *s, const int32_t vol[]) { sa_return_val_if_fail(!s->codec, SA_ERROR_NOT_SUPPORTED); sa_converter_set_volume(&oss->converter_write, vol); - + return SA_SUCCESS; } @@ -806,7 +813,7 @@ int driver_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offse if ((ret = sa_bufferq_push(&oss->bufferq, 0, data, nbytes, offset, whence, SA_BUFFERQ_ITEM_STATIC))) return ret; - + ret = feed(s); ret2 = sa_bufferq_realloc(&oss->bufferq); @@ -843,7 +850,7 @@ int driver_drain(sa_stream_t *s) { if (ioctl(oss->fd, SNDCTL_DSP_SYNC, NULL) < 0) return SA_ERROR_SYSTEM; - + return SA_SUCCESS; } diff --git a/src/resample.c b/src/resample.c index 23c63a5..7babe05 100644 --- a/src/resample.c +++ b/src/resample.c @@ -1,10 +1,14 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include "macro.h" #include "resample.h" static void resample_s16(SpeexResamplerState *speex, unsigned channel, void *dst, size_t dstr, const void *src, size_t sstr, size_t in_bytes, size_t *out_bytes) { spx_uint32_t in_samples = in_bytes/sizeof(int16_t), out_samples = *out_bytes/sizeof(int16_t); - + speex_resampler_set_input_stride(speex, sstr/sizeof(int16_t)); speex_resampler_set_input_stride(speex, dstr/sizeof(int16_t)); @@ -18,7 +22,7 @@ static void resample_s16(SpeexResamplerState *speex, unsigned channel, void *dst static void resample_f32(SpeexResamplerState *speex, unsigned channel, void *dst, size_t dstr, const void *src, size_t sstr, size_t in_bytes, size_t *out_bytes) { spx_uint32_t in_samples = in_bytes/sizeof(float), out_samples = *out_bytes/sizeof(float); - + speex_resampler_set_input_stride(speex, sstr/sizeof(float)); speex_resampler_set_input_stride(speex, dstr/sizeof(float)); diff --git a/src/test-asyncq.c b/src/test-asyncq.c index 26dbc55..e32c5c9 100644 --- a/src/test-asyncq.c +++ b/src/test-asyncq.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "asyncq.h" @@ -9,7 +13,7 @@ static void thread(void *userdata) { sa_asyncq_t *q = userdata; int i; - + for (i = 0; i < ITERATIONS_MAX; i++) { sa_asyncq_item_t *i; @@ -30,12 +34,12 @@ int main(int argc, char *argv[]) { sa_asyncq_item_t *i; sa_assert_success(sa_asyncq_init(&q)); - + t = sa_thread_new(thread, &q); sa_assert(t); for (j = 0; j < ITERATIONS_MAX; j++) { - + do { i = sa_asyncq_pop(&q, 0); printf("%s ", i ? "gotcha" : "miss"); @@ -49,14 +53,14 @@ int main(int argc, char *argv[]) { } printf("\n"); - + sa_thread_free(t); while (sa_asyncq_pop(&q, 1)) ; sa_asyncq_done(&q); - + return 0; } diff --git a/src/test-bufferq.c b/src/test-bufferq.c index 45d65eb..79cd618 100644 --- a/src/test-bufferq.c +++ b/src/test-bufferq.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include "bufferq.h" #include "malloc.h" @@ -19,7 +23,7 @@ int main(int argc, char *argv[]) { for (;;) { void *b[1]; size_t size; - + sa_bufferq_get(&q, b, &size); if (size == 0) @@ -35,7 +39,7 @@ int main(int argc, char *argv[]) { sa_bufferq_drop(&q, size); } - + sa_bufferq_done(&q); return 0; diff --git a/src/test-llist.c b/src/test-llist.c index 2059ef8..814690e 100644 --- a/src/test-llist.c +++ b/src/test-llist.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include "llist.h" struct foobar { @@ -11,7 +15,7 @@ int main(int argc, char *argv[]) { struct foobar a, b, c; SA_LLIST_HEAD_INIT(struct foobar, list); - + SA_LLIST_ITEM_INIT(struct foobar, list, &a); SA_LLIST_ITEM_INIT(struct foobar, list, &b); SA_LLIST_ITEM_INIT(struct foobar, list, &c); @@ -29,6 +33,6 @@ int main(int argc, char *argv[]) { SA_LLIST_REMOVE(struct foobar, list, list, &c); sa_assert(!list); - + return 0; } diff --git a/src/test-pull.c b/src/test-pull.c index 7f93906..993b7a3 100644 --- a/src/test-pull.c +++ b/src/test-pull.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include @@ -29,9 +33,9 @@ static int callback(sa_stream_t *s, sa_event_t e) { return 0; case SA_EVENT_ERROR: { - int e; - ASSERT_SUCCESS(sa_stream_get_event_error(s, &e)); - printf("Error: %s\n", sa_strerror(e)); + int err; + ASSERT_SUCCESS(sa_stream_get_event_error(s, &err)); + printf("Error: %s\n", sa_strerror(err)); return -1; } @@ -62,12 +66,12 @@ int main(int argc, char *argv[]) { ASSERT_SUCCESS(sa_stream_start_thread(s, callback)); sleep(20); - + ASSERT_SUCCESS(sa_stream_stop_thread(s)); ASSERT_SUCCESS(sa_stream_drain(s)); ASSERT_SUCCESS(sa_stream_destroy(s)); - + return 0; } diff --git a/src/test-sine.c b/src/test-sine.c index 07f3868..633fabb 100644 --- a/src/test-sine.c +++ b/src/test-sine.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include @@ -26,7 +30,6 @@ int main(int argc, char *argv[]) { ASSERT_SUCCESS(sa_stream_create_pcm(&s, "Sine Test", SA_MODE_WRONLY, SA_PCM_FORMAT_FLOAT32_NE, FREQ * 4, 1)); ASSERT_SUCCESS(sa_stream_change_device(s, "/dev/dsp1")); - ASSERT_SUCCESS(sa_stream_set_dynamic_rate(s, 1)); sa_stream_change_meta_data(s, SA_META_CLIENT_NAME, argv[0], strlen(argv[0])); ASSERT_SUCCESS(sa_stream_open(s)); @@ -34,18 +37,18 @@ int main(int argc, char *argv[]) { int v; v = -j*500; - + /* ASSERT_SUCCESS(sa_stream_change_rate(dev, FREQ*4+100*j)); */ ASSERT_SUCCESS(sa_stream_change_write_volume(s, &v, 1)); - + for (i = 0; i < FREQ; i++) ASSERT_SUCCESS(sa_stream_write(s, data, sizeof(data))); } - + ASSERT_SUCCESS(sa_stream_drain(s)); ASSERT_SUCCESS(sa_stream_destroy(s)); - + return 0; } diff --git a/src/thread-posix.c b/src/thread-posix.c new file mode 100644 index 0000000..d76e8d5 --- /dev/null +++ b/src/thread-posix.c @@ -0,0 +1,215 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#include "malloc.h" +#include "mutex.h" +#include "macro.h" +#include "thread.h" + +struct sa_thread { + pthread_t id; + sa_thread_func_t thread_func; + void *userdata; + int running; + sa_mutex *mutex; +}; + +struct sa_tls { + pthread_key_t key; +}; + +static pthread_once_t tid_once = PTHREAD_ONCE_INIT; +static sa_tls *tid_tls = NULL; + +static void tid_free_cb(void *p) { + sa_thread *t = p; + + sa_assert(t); + + if (!t->thread_func) { + /* This is a foreign thread, we need to free the struct */ + sa_mutex_free(t->mutex); + sa_free(t); + } +} + +static void tid_init(void) { + tid_tls = sa_tls_new(tid_free_cb); +} + +static void* internal_thread_func(void *userdata) { + sa_thread *t = userdata; + sa_assert(t); + + t->id = pthread_self(); + sa_tls_set(tid_tls, t); + + sa_mutex_lock(t->mutex); + t->running++; + sa_mutex_unlock(t->mutex); + + t->thread_func(t->userdata); + + sa_mutex_lock(t->mutex); + t->running -= 2; + sa_mutex_unlock(t->mutex); + + return NULL; +} + +sa_thread* sa_thread_new(sa_thread_func_t thread_func, void *userdata) { + sa_thread *t; + + sa_assert(thread_func); + + pthread_once(&tid_once, tid_init); + + if (!tid_tls) + return NULL; + + if (!(t = sa_new(sa_thread, 1))) + return NULL; + + t->thread_func = thread_func; + t->userdata = userdata; + t->running = 1; + + if (!(t->mutex = sa_mutex_new(FALSE, FALSE))) { + sa_free(t); + return NULL; + } + + if (pthread_create(&t->id, NULL, internal_thread_func, t) < 0) { + sa_mutex_free(t->mutex); + sa_free(t); + return NULL; + } + + return t; +} + +sa_bool_t sa_thread_is_running(sa_thread *t) { + sa_bool_t b; + sa_assert(t); + + /* Unfortunately there is no way to tell whether a "foreign" + * thread is still running. See + * http://udrepper.livejournal.com/16844.html for more + * information */ + sa_assert(t->thread_func); + + sa_mutex_lock(t->mutex); + b = t->running > 0; + sa_mutex_unlock(t->mutex); + + return b; +} + +void sa_thread_free(sa_thread *t) { + sa_assert(t); + + /* Only allowed when this is not a foreign thread */ + sa_assert(t->thread_func); + + sa_thread_join(t); + sa_mutex_free(t->mutex); + sa_free(t); +} + +int sa_thread_join(sa_thread *t) { + sa_assert(t); + + /* Only allowed when this is not a foreign thread */ + sa_assert(t->thread_func); + + return pthread_join(t->id, NULL); +} + +sa_thread* sa_thread_self(void) { + sa_thread *t; + + pthread_once(&tid_once, tid_init); + + if (!tid_tls) + return NULL; + + if ((t = sa_tls_get(tid_tls))) + return t; + + /* This is a foreign thread, let's create a pthread structure to + * make sure that we can always return a sensible pointer */ + + if (!(t = sa_new(sa_thread, 1))) + return NULL; + + t->id = pthread_self(); + t->thread_func = NULL; + t->userdata = NULL; + t->running = 2; + t->mutex = sa_mutex_new(FALSE, FALSE); + + sa_tls_set(tid_tls, t); + + return t; +} + +void* sa_thread_get_data(sa_thread *t) { + sa_assert(t); + + return t->userdata; +} + +void sa_thread_set_data(sa_thread *t, void *userdata) { + sa_assert(t); + + t->userdata = userdata; +} + +void sa_thread_yield(void) { +#ifdef HAVE_PTHREAD_YIELD + pthread_yield(); +#else + sa_assert_se(sched_yield() == 0); +#endif +} + +sa_tls* sa_tls_new(sa_free_cb_t free_cb) { + sa_tls *t; + + if (!(t = sa_new(sa_tls, 1))) + return NULL; + + if (pthread_key_create(&t->key, free_cb) < 0) { + sa_free(t); + return NULL; + } + + return t; +} + +void sa_tls_free(sa_tls *t) { + sa_assert(t); + + sa_assert_se(pthread_key_delete(t->key) == 0); + sa_free(t); +} + +void *sa_tls_get(sa_tls *t) { + sa_assert(t); + + return pthread_getspecific(t->key); +} + +void *sa_tls_set(sa_tls *t, void *userdata) { + void *r; + + sa_assert(t); + r = pthread_getspecific(t->key); + sa_assert_se(pthread_setspecific(t->key, userdata) == 0); + return r; +} diff --git a/src/thread.c b/src/thread.c deleted file mode 100644 index 26deccb..0000000 --- a/src/thread.c +++ /dev/null @@ -1,214 +0,0 @@ -#ifdef HAVE_CONFIG_H -#include -#endif - -#include -#include -#include - -#include "thread.h" -#include "malloc.h" -#include "once.h" -#include "macro.h" - -struct sa_thread { - pthread_t id; - sa_thread_func_t thread_func; - void *userdata; - int running; - pthread_mutex_t running_mutex; -}; - -struct sa_tls { - pthread_key_t key; -}; - -static sa_tls_t *thread_tls; -static sa_once_t thread_tls_once = SA_ONCE_INIT; - -static void tls_free_cb(void *p) { - sa_thread_t *t = p; - - sa_assert(t); - - if (!t->thread_func) - /* This is a foreign thread, we need to free the struct */ - sa_free(t); -} - -static void thread_tls_once_func(void) { - thread_tls = sa_tls_new(tls_free_cb); -} - -static void* internal_thread_func(void *userdata) { - sa_thread_t *t = userdata; - sa_assert(t); - - t->id = pthread_self(); - sa_tls_set(thread_tls, t); - - t->thread_func(t->userdata); - - sa_assert_success(pthread_mutex_lock(&t->running_mutex)); - t->running = 0; - sa_assert_success(pthread_mutex_unlock(&t->running_mutex)); - - return NULL; -} - -sa_thread_t* sa_thread_new(sa_thread_func_t thread_func, void *userdata) { - sa_thread_t *t; - - sa_assert(thread_func); - - if (sa_once(&thread_tls_once, thread_tls_once_func) < 0 || !thread_tls) - return NULL; - - if (!(t = sa_new(sa_thread_t, 1))) - return NULL; - - t->thread_func = thread_func; - t->userdata = userdata; - - sa_assert_success(pthread_mutex_init(&t->running_mutex, NULL)); - t->running = 1; - - if (pthread_create(&t->id, NULL, internal_thread_func, t) < 0) { - sa_assert_success(pthread_mutex_destroy(&t->running_mutex)); - sa_free(t); - return NULL; - } - - return t; -} - -int sa_thread_is_running(sa_thread_t *t) { - int b; - sa_assert(t); - - if (!t->thread_func) { - /* Mhmm, this is a foreign thread, t->running is not - * necessarily valid. We misuse pthread_getschedparam() to - * check if the thread is valid. This might not be portable. */ - - int policy; - struct sched_param param; - - return pthread_getschedparam(t->id, &policy, ¶m) >= 0 || errno != ESRCH; - } - - sa_assert_success(pthread_mutex_lock(&t->running_mutex)); - b = t->running; - sa_assert_success(pthread_mutex_unlock(&t->running_mutex)); - - return !!b; -} - -void sa_thread_free(sa_thread_t *t) { - sa_assert(t); - - sa_thread_join(t); - sa_assert_success(pthread_mutex_destroy(&t->running_mutex)); - sa_free(t); -} - -int sa_thread_join(sa_thread_t *t) { - sa_assert(t); - - return pthread_join(t->id, NULL); -} - -sa_thread_t* sa_thread_self(void) { - sa_thread_t *t; - - if (sa_once(&thread_tls_once, thread_tls_once_func) < 0 || !thread_tls) - return NULL; - - if ((t = sa_tls_get(thread_tls))) - return t; - - /* This is a foreign thread, let's create a pthread structure to - * make sure that we can always return a sensible pointer */ - - if (!(t = sa_new(sa_thread_t, 1))) - return NULL; - - t->id = pthread_self(); - t->thread_func = NULL; - t->userdata = NULL; - t->running = 1; - - sa_tls_set(thread_tls, t); - - return t; -} - -int sa_thread_is_self(sa_thread_t *t) { - sa_thread_t *c; - sa_assert(t); - - if (sa_once(&thread_tls_once, thread_tls_once_func) < 0 || !thread_tls) - return 0; - - if ((c = sa_tls_get(thread_tls))) - return c == t; - - return 0; -} - - -void* sa_thread_get_data(sa_thread_t *t) { - sa_assert(t); - - return t->userdata; -} - -void sa_thread_set_data(sa_thread_t *t, void *userdata) { - sa_assert(t); - - t->userdata = userdata; -} - -void sa_thread_yield(void) { -#ifdef HAVE_PTHREAD_YIELD - pthread_yield(); -#else - sa_assert_success(sched_yield()); -#endif -} - -sa_tls_t* sa_tls_new(sa_free_func_t free_cb) { - sa_tls_t *t; - - if (!(t = sa_new(sa_tls_t, 1))) - return NULL; - - if (pthread_key_create(&t->key, free_cb) < 0) { - sa_free(t); - return NULL; - } - - return t; -} - -void sa_tls_free(sa_tls_t *t) { - sa_assert(t); - - sa_assert_success(pthread_key_delete(t->key)); - sa_free(t); -} - -void *sa_tls_get(sa_tls_t *t) { - sa_assert(t); - - return pthread_getspecific(t->key); -} - -void *sa_tls_set(sa_tls_t *t, void *userdata) { - void *r; - - r = pthread_getspecific(t->key); - sa_assert_success(pthread_setspecific(t->key, userdata)); - return r; -} - diff --git a/src/thread.h b/src/thread.h index ddd2604..66071e1 100644 --- a/src/thread.h +++ b/src/thread.h @@ -1,28 +1,27 @@ #ifndef foosydneythreadhfoo #define foosydneythreadhfoo -typedef struct sa_thread sa_thread_t; +#include "macro.h" + +typedef struct sa_thread sa_thread; typedef void (*sa_thread_func_t) (void *userdata); -sa_thread_t* sa_thread_new(sa_thread_func_t sa_thread_func, void *userdata); -void sa_thread_free(sa_thread_t *t); -int sa_thread_join(sa_thread_t *t); -int sa_thread_is_running(sa_thread_t *t); -sa_thread_t *sa_thread_self(void); +sa_thread* sa_thread_new(sa_thread_func_t thread_func, void *userdata); +void sa_thread_free(sa_thread *t); +int sa_thread_join(sa_thread *t); +sa_bool_t sa_thread_is_running(sa_thread *t); +sa_thread *sa_thread_self(void); void sa_thread_yield(void); -int sa_thread_is_self(sa_thread_t *t); - -void* sa_thread_get_data(sa_thread_t *t); -void sa_thread_set_data(sa_thread_t *t, void *userdata); -typedef struct sa_tls sa_tls_t; +void* sa_thread_get_data(sa_thread *t); +void sa_thread_set_data(sa_thread *t, void *userdata); -typedef void (*sa_free_func_t) (void *data); +typedef struct sa_tls sa_tls; -sa_tls_t* sa_tls_new(sa_free_func_t f); -void sa_tls_free(sa_tls_t *t); -void * sa_tls_get(sa_tls_t *t); -void *sa_tls_set(sa_tls_t *t, void *userdata); +sa_tls* sa_tls_new(sa_free_cb_t free_cb); +void sa_tls_free(sa_tls *t); +void * sa_tls_get(sa_tls *t); +void *sa_tls_set(sa_tls *t, void *userdata); #endif diff --git a/src/volscale.c b/src/volscale.c index 2075b90..f29cb0e 100644 --- a/src/volscale.c +++ b/src/volscale.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "macro.h" @@ -6,11 +10,12 @@ static void volscale_u8(void *_dst, size_t dstr, const void *_src, size_t sstr, int32_t factor, int32_t divisor, size_t bytes) { uint8_t *dst = _dst; const uint8_t *src = _src; - + for (; bytes > 0; bytes --) { int32_t t = (((int32_t) *src - 0x80) * factor) / divisor; - *dst = t < -0x80 ? 0 : (t > 0x7F ? 0xFF : (int8_t) (t+0x80)); - + t = CLAMP(t, -0x80, 0x7F); + *dst = (int8_t) (t+0x80); + src += sstr; dst += dstr; } @@ -20,11 +25,12 @@ static void volscale_s16(void *_dst, size_t dstr, const void *_src, size_t sstr, int16_t *dst = _dst; const int16_t *src = _src; unsigned n = bytes / sizeof(int16_t); - + for (; n > 0; n--) { int32_t t = ((int32_t) *src * factor) / divisor; - *dst = t < -0x8000 ? 0x8000 : (t > 0x7FFF ? 0x7FFF : (int16_t) t); - + t = CLAMP(t, -0x8000, 0x7FFF); + *dst = (int16_t) t; + src += sstr / sizeof(int16_t); dst += dstr / sizeof(int16_t); } @@ -34,11 +40,12 @@ static void volscale_s32(void *_dst, size_t dstr, const void *_src, size_t sstr, int32_t *dst = _dst; const int32_t *src = _src; unsigned n = bytes / sizeof(int32_t); - + for (; n > 0; n--) { int64_t t = ((int64_t) *src * factor) / divisor; - *dst = t < -0x80000000L ? (int32_t) 0x80000000L : (t > 0x7fffffffL ? (int32_t) 0x7fffffffL : (int32_t) t); - + t = CLAMP(t, -0x80000000L, 0x7FFFFFFFL); + *dst = (int32_t) t; + src += sstr / sizeof(int32_t); dst += dstr / sizeof(int32_t); } @@ -48,12 +55,12 @@ static void volscale_f32(void *_dst, size_t dstr, const void *_src, size_t sstr, float *dst = _dst; const float *src = _src; float f = (float) factor / (float) divisor; - + oil_scalarmult_f32(dst, dstr, src, sstr, &f, size / sizeof(float)); } sa_volscale_func_t sa_get_volscale_func(sa_pcm_format_t f) { - + static const sa_volscale_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = volscale_u8, [SA_PCM_FORMAT_S16_NE] = volscale_s16, diff --git a/src/zero.c b/src/zero.c index 4f477dc..9d4c054 100644 --- a/src/zero.c +++ b/src/zero.c @@ -1,3 +1,7 @@ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include "macro.h" @@ -11,7 +15,7 @@ static void zero_u8(void *dst, size_t dstr, size_t bytes) { else { for (; bytes > 0; bytes --, d += dstr) *d = 0x80; - } + } } static void zero_16(void *dst, size_t dstr, size_t bytes) { @@ -23,7 +27,7 @@ static void zero_16(void *dst, size_t dstr, size_t bytes) { else { for (; n > 0; n --, d += dstr/sizeof(uint16_t)) *d = 0; - } + } } static void zero_32(void *dst, size_t dstr, size_t bytes) { @@ -35,7 +39,7 @@ static void zero_32(void *dst, size_t dstr, size_t bytes) { else { for (; n > 0; n --, d += dstr/sizeof(uint32_t)) *d = 0; - } + } } sa_zero_func_t sa_get_zero_func(sa_pcm_format_t f) { -- cgit