From 284516185f90412c22dfa9a28cb93fb344af591b Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 18 May 2007 00:10:02 +0000 Subject: really prefix everything with "sa_" git-svn-id: file:///home/lennart/svn/public/libsydney/trunk@28 9ba3c220-e4d3-45a2-8aa3-73fcc9aff6ce --- Makefile | 9 +++-- add.c | 4 +- add.h | 4 +- bbuffer.c | 6 +-- bbuffer.h | 10 ++--- bufferq.c | 48 ++++++++++++------------ bufferq.h | 26 ++++++------- byteswap.c | 4 +- byteswap.h | 4 +- common.c | 8 ++-- common.h | 4 +- continued-fraction.c | 6 +-- continued-fraction.h | 2 +- converter.c | 102 +++++++++++++++++++++++++-------------------------- converter.h | 36 +++++++++--------- format.c | 90 ++++++++++++++++++++++----------------------- format.h | 4 +- g711.c | 20 +++++----- g711.h | 24 ++++++------ interleave.c | 4 +- interleave.h | 4 +- oss.c | 22 +++++------ resample.c | 4 +- resample.h | 4 +- test-bufferq.c | 22 +++++------ volscale.c | 4 +- volscale.h | 4 +- zero.c | 4 +- zero.h | 4 +- 29 files changed, 245 insertions(+), 242 deletions(-) diff --git a/Makefile b/Makefile index 75e9f41..123b97d 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -CFLAGS=-Wall -O0 -g -W -Wno-unused-parameter `pkg-config --cflags liboil-0.3` -DRANDOM_PREFIX=sa -DOUTSIDE_SPEEX -D_GNU_SOURCE -pthread +CFLAGS=-Wall -O0 -g -W -Wno-unused-parameter `pkg-config --cflags liboil-0.3` -DRANDOM_PREFIX=saspeex -DOUTSIDE_SPEEX -D_GNU_SOURCE -pthread LIBS=-lm `pkg-config --libs liboil-0.3` SOURCES=common.c malloc.c oss.c bbuffer.c format.c volscale.c byteswap.c continued-fraction.c zero.c add.c speex/resample.c resample.c interleave.c converter.c g711.c mutex.c once.c thread.c @@ -25,12 +25,12 @@ indent: # astyle --indent=spaces=4 --brackets=attach --indent-switches --max-instatement-indent=40 --pad=oper --unpad=paren --convert-tabs --mode=c < oss.c clean: - rm -f *.o meta-name-table.h test-bufferq test-llist test-sine core test-pull + rm -f *.o meta-name-table.h test-bufferq test-llist test-sine core test-pull speex/*.o common.o: meta-name-table.h meta-name-table.h: meta-name-table.gperf Makefile - gperf -t -N lookup_meta_name -H hash_meta_name -p -C < $< | sed -e 's/{""}/{"", 0}/g' > $@ + gperf -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 \{\} \; @@ -39,3 +39,6 @@ update-speex: wget -O speex/speex_resampler.h http://svn.xiph.org/trunk/speex/include/speex/speex_resampler.h wget -O speex/resample.c http://svn.xiph.org/trunk/speex/libspeex/resample.c wget -O speex/arch.h http://svn.xiph.org/trunk/speex/libspeex/arch.h + +warn-export: all + nm test-bufferq test-llist test-sine test-pull | grep " T " | awk '{print $$3}' | sort | uniq diff --git a/add.c b/add.c index 42c0758..ec10131 100644 --- a/add.c +++ b/add.c @@ -40,9 +40,9 @@ static void add_f32(void *dst, size_t dstr, const void *src1, size_t sstr1, cons oil_vectoradd_f32(dst, dstr, src1, sstr1, src2, sstr2, bytes/sizeof(int32_t), &a, &b); } -add_func_t get_add_func(sa_pcm_format_t f) { +sa_add_func_t sa_get_add_func(sa_pcm_format_t f) { - static const add_func_t funcs[_SA_PCM_FORMAT_MAX] = { + static const sa_add_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = add_u8, [SA_PCM_FORMAT_S16_NE] = add_s16, [SA_PCM_FORMAT_S32_NE] = add_s32, diff --git a/add.h b/add.h index 35e6bee..6a31bc5 100644 --- a/add.h +++ b/add.h @@ -6,8 +6,8 @@ #include "sydney.h" -typedef void (*add_func_t) (void *dst, size_t dstr, const void *src1, size_t sstr1, const void *src2, size_t sstr2, size_t bytes); +typedef void (*sa_add_func_t) (void *dst, size_t dstr, const void *src1, size_t sstr1, const void *src2, size_t sstr2, size_t bytes); -add_func_t get_add_func(sa_pcm_format_t f); +sa_add_func_t sa_get_add_func(sa_pcm_format_t f); #endif diff --git a/bbuffer.c b/bbuffer.c index 63aa145..c8cbaa0 100644 --- a/bbuffer.c +++ b/bbuffer.c @@ -5,7 +5,7 @@ #include "malloc.h" #include "macro.h" -int bbuffer_init(bbuffer_t *b, unsigned nchannels, size_t sample_size) { +int sa_bbuffer_init(sa_bbuffer_t *b, unsigned nchannels, size_t sample_size) { sa_assert(b); sa_assert(nchannels > 0); sa_assert(sample_size > 0); @@ -27,7 +27,7 @@ int bbuffer_init(bbuffer_t *b, unsigned nchannels, size_t sample_size) { return SA_SUCCESS; } -void bbuffer_done(bbuffer_t *b) { +void sa_bbuffer_done(sa_bbuffer_t *b) { unsigned i; sa_assert(b); @@ -44,7 +44,7 @@ void bbuffer_done(bbuffer_t *b) { b->size = NULL; } -void* bbuffer_get(bbuffer_t *b, unsigned channel, size_t size, int interleave) { +void* sa_bbuffer_get(sa_bbuffer_t *b, unsigned channel, size_t size, int interleave) { sa_assert(b); sa_assert(channel < b->nchannels); sa_assert(size > 0); diff --git a/bbuffer.h b/bbuffer.h index 58f5055..6394a11 100644 --- a/bbuffer.h +++ b/bbuffer.h @@ -5,15 +5,15 @@ /* Simple bounce buffer management routines */ -typedef struct bbuffer { +typedef struct sa_bbuffer { void **data; size_t *size; unsigned nchannels; size_t sample_size; -} bbuffer_t; +} sa_bbuffer_t; -int bbuffer_init(bbuffer_t *b, unsigned nchannels, size_t sample_size); -void bbuffer_done(bbuffer_t *b); -void* bbuffer_get(bbuffer_t *b, unsigned channel, size_t size, int interleave); +int sa_bbuffer_init(sa_bbuffer_t *b, unsigned nchannels, size_t sample_size); +void sa_bbuffer_done(sa_bbuffer_t *b); +void* sa_bbuffer_get(sa_bbuffer_t *b, unsigned channel, size_t size, int interleave); #endif diff --git a/bufferq.c b/bufferq.c index df22ec3..c4c3ec3 100644 --- a/bufferq.c +++ b/bufferq.c @@ -4,7 +4,7 @@ #include "macro.h" #include "bufferq.h" -int bufferq_init(bufferq_t *q, unsigned nchannels, size_t sample_size) { +int sa_bufferq_init(sa_bufferq_t *q, unsigned nchannels, size_t sample_size) { sa_assert(q); sa_assert(sample_size > 0); sa_assert(nchannels > 0); @@ -13,10 +13,10 @@ int bufferq_init(bufferq_t *q, unsigned nchannels, size_t sample_size) { q->sample_size = sample_size; q->nchannels = nchannels; - if (!(q->items = sa_new0(bufferq_item_t*, nchannels))) + if (!(q->items = sa_new0(sa_bufferq_item_t*, nchannels))) return SA_ERROR_OOM; - if (!(q->last = sa_new0(bufferq_item_t*, nchannels))) { + if (!(q->last = sa_new0(sa_bufferq_item_t*, nchannels))) { sa_free(q->items); q->items = NULL; return SA_ERROR_OOM; @@ -25,15 +25,15 @@ int bufferq_init(bufferq_t *q, unsigned nchannels, size_t sample_size) { return SA_SUCCESS; } -void bufferq_done(bufferq_t *q) { +void sa_bufferq_done(sa_bufferq_t *q) { unsigned u; sa_assert(q); for (u = 0; u < q->nchannels; u++) { - bufferq_item_t *i; + sa_bufferq_item_t *i; while ((i = q->items[u])) { - SA_LLIST_REMOVE(bufferq_item_t, bufferq, q->items[u], i); + SA_LLIST_REMOVE(sa_bufferq_item_t, bufferq, q->items[u], i); sa_free(i); } } @@ -42,21 +42,21 @@ void bufferq_done(bufferq_t *q) { sa_free(q->last); } -static bufferq_item_t* bufferq_item_new(size_t size) { - bufferq_item_t *i; +static sa_bufferq_item_t* bufferq_item_new(size_t size) { + sa_bufferq_item_t *i; sa_assert(size > 0); - if (!(i = sa_malloc(ALIGN(sizeof(bufferq_item_t)) + size))) + if (!(i = sa_malloc(ALIGN(sizeof(sa_bufferq_item_t)) + size))) return i; - SA_LLIST_ITEM_INIT(bufferq_item_t, bufferq, i); + SA_LLIST_ITEM_INIT(sa_bufferq_item_t, bufferq, i); return i; } -int bufferq_push(bufferq_t *q, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { +int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence) { int64_t idx; - bufferq_item_t *i, *j; + sa_bufferq_item_t *i, *j; sa_assert(q); @@ -107,11 +107,11 @@ int bufferq_push(bufferq_t *q, unsigned channel, const void *data, size_t nbytes if (!(j = bufferq_item_new(l))) return SA_ERROR_OOM; - memcpy(BUFFERQ_ITEM_DATA(j), data, l); + memcpy(SA_BUFFERQ_ITEM_DATA(j), data, l); j->idx = idx; j->size = l; - SA_LLIST_INSERT_BEFORE(bufferq_item_t, bufferq, q->items[channel], i, j); + SA_LLIST_INSERT_BEFORE(sa_bufferq_item_t, bufferq, q->items[channel], i, j); idx += l; data += l; @@ -127,7 +127,7 @@ int bufferq_push(bufferq_t *q, unsigned channel, const void *data, size_t nbytes if (l > i->idx + i->size - idx) l = i->idx + i->size - idx; - memcpy((uint8_t*) BUFFERQ_ITEM_DATA(i) + (idx - i->idx), data, l); + memcpy((uint8_t*) SA_BUFFERQ_ITEM_DATA(i) + (idx - i->idx), data, l); idx += l; data += l; @@ -141,14 +141,14 @@ int bufferq_push(bufferq_t *q, unsigned channel, const void *data, size_t nbytes if (!(j = bufferq_item_new(nbytes))) return SA_ERROR_OOM; - memcpy(BUFFERQ_ITEM_DATA(j), data, nbytes); + memcpy(SA_BUFFERQ_ITEM_DATA(j), data, nbytes); j->idx = idx; j->size = nbytes; if (q->last[channel]) - SA_LLIST_INSERT_AFTER(bufferq_item_t, bufferq, q->items[channel], q->last[channel], j); + SA_LLIST_INSERT_AFTER(sa_bufferq_item_t, bufferq, q->items[channel], q->last[channel], j); else - SA_LLIST_PREPEND(bufferq_item_t, bufferq, q->items[channel], j); + SA_LLIST_PREPEND(sa_bufferq_item_t, bufferq, q->items[channel], j); q->last[channel] = j; } @@ -161,7 +161,7 @@ int bufferq_push(bufferq_t *q, unsigned channel, const void *data, size_t nbytes return SA_SUCCESS; } -int bufferq_get(bufferq_t *q, void *i[], size_t *bytes) { +int sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes) { int first = 1; unsigned u; sa_assert(q); @@ -186,7 +186,7 @@ int bufferq_get(bufferq_t *q, void *i[], size_t *bytes) { } else { int64_t l; - i[u] = (uint8_t*) BUFFERQ_ITEM_DATA(q->items[u]) + q->read_index - q->items[u]->idx; + i[u] = (uint8_t*) SA_BUFFERQ_ITEM_DATA(q->items[u]) + q->read_index - q->items[u]->idx; l = q->items[u]->size - (q->read_index - q->items[u]->idx); @@ -205,7 +205,7 @@ int bufferq_get(bufferq_t *q, void *i[], size_t *bytes) { } -int bufferq_drop(bufferq_t *q, int64_t bytes) { +int sa_bufferq_drop(sa_bufferq_t *q, int64_t bytes) { unsigned u; sa_assert(q); @@ -214,14 +214,14 @@ int bufferq_drop(bufferq_t *q, int64_t bytes) { for (u = 0; u < q->nchannels; u++) { - bufferq_item_t *i; + sa_bufferq_item_t *i; i = q->items[u]; while (i && q->read_index >= i->idx + i->size) { - bufferq_item_t *n = i->bufferq_next; + sa_bufferq_item_t *n = i->bufferq_next; - SA_LLIST_REMOVE(bufferq_item_t, bufferq, q->items[u], i); + SA_LLIST_REMOVE(sa_bufferq_item_t, bufferq, q->items[u], i); sa_free(i); i = n; diff --git a/bufferq.h b/bufferq.h index da4eac3..a645398 100644 --- a/bufferq.h +++ b/bufferq.h @@ -7,29 +7,29 @@ #include "llist.h" #include "sydney.h" -typedef struct bufferq_item { +typedef struct sa_bufferq_item { int64_t idx; size_t size; - SA_LLIST_ITEM(struct bufferq_item, bufferq); -} bufferq_item_t; + SA_LLIST_ITEM(struct sa_bufferq_item, bufferq); +} sa_bufferq_item_t; -#define BUFFERQ_ITEM_DATA(x) ((void*) (uint8_t*) (x) + ALIGN(sizeof(bufferq_item_t))) +#define SA_BUFFERQ_ITEM_DATA(x) ((void*) (uint8_t*) (x) + ALIGN(sizeof(sa_bufferq_item_t))) -typedef struct bufferq { - SA_LLIST_HEAD(bufferq_item_t, *items); - bufferq_item_t **last; +typedef struct sa_bufferq { + SA_LLIST_HEAD(sa_bufferq_item_t, *items); + sa_bufferq_item_t **last; int64_t read_index, write_index, end_index; size_t sample_size; unsigned nchannels; -} bufferq_t; +} sa_bufferq_t; -int bufferq_init(bufferq_t *q, unsigned nchannels, size_t sample_size); +int sa_bufferq_init(sa_bufferq_t *q, unsigned nchannels, size_t sample_size); -void bufferq_done(bufferq_t *q); +void sa_bufferq_done(sa_bufferq_t *q); -int bufferq_push(bufferq_t *q, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence); +int sa_bufferq_push(sa_bufferq_t *q, unsigned channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence); -int bufferq_get(bufferq_t *q, void *i[], size_t *bytes); -int bufferq_drop(bufferq_t *q, int64_t bytes); +int sa_bufferq_get(sa_bufferq_t *q, void *i[], size_t *bytes); +int sa_bufferq_drop(sa_bufferq_t *q, int64_t bytes); #endif diff --git a/byteswap.c b/byteswap.c index addd572..8ae0b7a 100644 --- a/byteswap.c +++ b/byteswap.c @@ -41,9 +41,9 @@ static void byteswap32(void *_dst, size_t dstr, const void *_src, size_t sstr, s } } -byteswap_func_t get_byteswap_func(sa_pcm_format_t f) { +sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f) { - static const byteswap_func_t funcs[_SA_PCM_FORMAT_MAX] = { + 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, diff --git a/byteswap.h b/byteswap.h index 6840412..4116677 100644 --- a/byteswap.h +++ b/byteswap.h @@ -5,8 +5,8 @@ #include "sydney.h" -typedef void (*byteswap_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); +typedef void (*sa_byteswap_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); -byteswap_func_t get_byteswap_func(sa_pcm_format_t f); +sa_byteswap_func_t sa_get_byteswap_func(sa_pcm_format_t f); #endif diff --git a/common.c b/common.c index 2470cca..5f3ff57 100644 --- a/common.c +++ b/common.c @@ -87,7 +87,7 @@ int sa_stream_create_pcm( (*s)->mode = mode; (*s)->pcm_attrs.format = format; (*s)->pcm_attrs.nchannels = nchannels; - (*s)->pcm_sample_size = get_pcm_sample_size(format); + (*s)->pcm_sample_size = sa_get_pcm_sample_size(format); (*s)->pcm_frame_size = (*s)->pcm_sample_size * nchannels; if (nchannels <= 2) { @@ -1064,7 +1064,7 @@ int sa_stream_drain(sa_stream_t *s) { return ret; } -size_t get_pcm_sample_size(sa_pcm_format_t f) { +size_t sa_get_pcm_sample_size(sa_pcm_format_t f) { switch (f) { case SA_PCM_FORMAT_U8: @@ -1190,7 +1190,7 @@ int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *dat sa_mutex_lock(s->mutex); sa_return_val_if_fail_mutex(s->mutex, data || size == 0, SA_ERROR_INVALID); - if (!(m = lookup_meta_name(name, strlen(name)))) { + if (!(m = sa_lookup_meta_name(name, strlen(name)))) { sa_mutex_unlock(s->mutex); return SA_ERROR_NO_META; } @@ -1227,7 +1227,7 @@ int sa_stream_get_meta_data(sa_stream_t *s, const char *name, void *data, size_t sa_return_val_if_fail(size && (*size == 0 || data), SA_ERROR_INVALID); sa_mutex_lock(s->mutex); - if (!(m = lookup_meta_name(name, strlen(name)))) { + if (!(m = sa_lookup_meta_name(name, strlen(name)))) { sa_mutex_unlock(s->mutex); return SA_ERROR_NO_META; } diff --git a/common.h b/common.h index 79439c8..b5f316c 100644 --- a/common.h +++ b/common.h @@ -6,7 +6,7 @@ #define _META_NAMES_MAX 9 -typedef struct pcm_attrs { +typedef struct sa_pcm_attrs { sa_pcm_format_t format; unsigned rate; unsigned nchannels; @@ -62,6 +62,6 @@ struct sa_stream { sa_event_callback_t callback; }; -size_t get_pcm_sample_size(sa_pcm_format_t f); +size_t sa_get_pcm_sample_size(sa_pcm_format_t f); #endif diff --git a/continued-fraction.c b/continued-fraction.c index 15253a3..6cbf8a5 100644 --- a/continued-fraction.c +++ b/continued-fraction.c @@ -9,12 +9,12 @@ #include "continued-fraction.h" -void continued_fraction(double val, int max_denom, int *res_num, int *res_denom) { +void sa_continued_fraction(double val, int max_denom, int *res_num, int *res_denom) { int n1, n2, d1, d2; double x, y; if (val < 0) { - continued_fraction (-val, max_denom, res_num, res_denom); + sa_continued_fraction (-val, max_denom, res_num, res_denom); *res_num = -*res_num; return; } @@ -59,7 +59,7 @@ int main(int argc, char*argv[]) { float value = 3.1417235; int res_num, res_denom; - continued_fraction(value, 0xFFFF, &res_num, &res_denom); + sa_continued_fraction(value, 0xFFFF, &res_num, &res_denom); printf("%g ~= %i/%i = %g\n", value, res_num, res_denom, (float) res_num / res_denom); diff --git a/continued-fraction.h b/continued-fraction.h index b19ee3c..2026b50 100644 --- a/continued-fraction.h +++ b/continued-fraction.h @@ -1,6 +1,6 @@ #ifndef foosydneycontinuedfractionhfoo #define foosydneycontinuedfractionhfoo -void continued_fraction(double val, int max_denom, int *res_num, int *res_denom); +void sa_continued_fraction(double val, int max_denom, int *res_num, int *res_denom); #endif diff --git a/converter.c b/converter.c index 4f6723d..dda8c10 100644 --- a/converter.c +++ b/converter.c @@ -182,8 +182,8 @@ static sa_pcm_format_t fix_work_format_for_resample(sa_pcm_format_t f) { sa_assert_not_reached(); } -int converter_init( - converter_t *c, +int sa_converter_init( + sa_converter_t *c, const pcm_attrs_t *from, const pcm_attrs_t *to, int dynamic_rate_enabled) { @@ -242,40 +242,40 @@ int converter_init( sa_assert(native_pcm_format_process(c->work_pcm_format)); sa_assert(!resample_required || native_pcm_format_resample(c->work_pcm_format)); - c->from_sample_size = get_pcm_sample_size(c->from_pcm_format); - c->work_sample_size = get_pcm_sample_size(c->work_pcm_format); - c->to_sample_size = get_pcm_sample_size(c->to_pcm_format); + c->from_sample_size = sa_get_pcm_sample_size(c->from_pcm_format); + c->work_sample_size = sa_get_pcm_sample_size(c->work_pcm_format); + c->to_sample_size = sa_get_pcm_sample_size(c->to_pcm_format); /* Get function pointers */ - c->pre_byteswap_func = get_byteswap_func(from->format); + c->pre_byteswap_func = sa_get_byteswap_func(from->format); if (byteswap_fix(from->format) != c->work_pcm_format) { - c->pre_format_func = get_format_func(byteswap_fix(from->format), c->work_pcm_format); + 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 = get_volscale_func(c->work_pcm_format); + c->volscale_func = sa_get_volscale_func(c->work_pcm_format); sa_assert(c->volscale_func); - c->zero_func = get_zero_func(c->work_pcm_format); + c->zero_func = sa_get_zero_func(c->work_pcm_format); sa_assert(c->zero_func); - c->add_func = get_add_func(c->work_pcm_format); + c->add_func = sa_get_add_func(c->work_pcm_format); sa_assert(c->add_func); if (resample_required) { - c->resample_func = get_resample_func(c->work_pcm_format); + 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 = get_format_func(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 = get_byteswap_func(to->format); + c->post_byteswap_func = sa_get_byteswap_func(to->format); - c->interleave_func = get_interleave_func(to->format); + c->interleave_func = sa_get_interleave_func(to->format); sa_assert(c->interleave_func); /* Initialize resampler */ @@ -310,34 +310,34 @@ int converter_init( /* Initialize bounce buffers */ - if (bbuffer_init(&c->bb_pre_byteswap, c->from_nchannels, c->from_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_pre_byteswap, c->from_nchannels, c->from_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_pre_format, c->from_nchannels, c->work_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_pre_format, c->from_nchannels, c->work_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_volscale, c->from_nchannels, c->work_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_volscale, c->from_nchannels, c->work_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_remap, c->to_nchannels, c->work_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_remap, c->to_nchannels, c->work_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_resample, c->to_nchannels, c->work_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_resample, c->to_nchannels, c->work_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_post_format, c->to_nchannels, c->to_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_post_format, c->to_nchannels, c->to_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_post_byteswap, c->to_nchannels, c->to_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_post_byteswap, c->to_nchannels, c->to_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_interleave, c->to_nchannels, c->to_sample_size) < 0) + if (sa_bbuffer_init(&c->bb_interleave, c->to_nchannels, c->to_sample_size) < 0) goto fail; - if (bbuffer_init(&c->bb_tmp, 1, 1) < 0) + if (sa_bbuffer_init(&c->bb_tmp, 1, 1) < 0) goto fail; return 0; fail: - converter_done(c); + sa_converter_done(c); return SA_ERROR_OOM; } -void converter_done(converter_t *c) { +void sa_converter_done(sa_converter_t *c) { sa_assert(c); sa_free(c->channel_map_table); @@ -347,15 +347,15 @@ void converter_done(converter_t *c) { sa_free(c->from_stride); sa_free(c->to_stride); - bbuffer_done(&c->bb_pre_byteswap); - bbuffer_done(&c->bb_pre_format); - bbuffer_done(&c->bb_volscale); - bbuffer_done(&c->bb_remap); - bbuffer_done(&c->bb_resample); - bbuffer_done(&c->bb_post_format); - bbuffer_done(&c->bb_post_byteswap); - bbuffer_done(&c->bb_interleave); - bbuffer_done(&c->bb_tmp); + sa_bbuffer_done(&c->bb_pre_byteswap); + sa_bbuffer_done(&c->bb_pre_format); + sa_bbuffer_done(&c->bb_volscale); + sa_bbuffer_done(&c->bb_remap); + sa_bbuffer_done(&c->bb_resample); + sa_bbuffer_done(&c->bb_post_format); + sa_bbuffer_done(&c->bb_post_byteswap); + sa_bbuffer_done(&c->bb_interleave); + sa_bbuffer_done(&c->bb_tmp); if (c->speex) speex_resampler_destroy(c->speex); @@ -367,7 +367,7 @@ void converter_done(converter_t *c) { memset(c, 0, sizeof(*c)); } -static void* get_zero_buffer(converter_t *c, size_t size) { +static void* get_zero_buffer(sa_converter_t *c, size_t size) { void *b; sa_assert(c); @@ -385,8 +385,8 @@ static void* get_zero_buffer(converter_t *c, size_t size) { return c->zero_func; } -int converter_go( - converter_t *c, +int sa_converter_go( + sa_converter_t *c, const void *const src[], const size_t sstr[], int sinterleave, void **dst[], size_t *dstr[], int dinterleave, size_t *size) { @@ -423,7 +423,7 @@ int converter_go( for (i = 0; i < c->from_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_pre_byteswap, i, *size, dinterleave))) + 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); @@ -456,7 +456,7 @@ int converter_go( for (i = 0; i < c->from_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_pre_format, i, new_size, dinterleave))) + 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); @@ -492,7 +492,7 @@ int converter_go( for (i = 0; i < c->from_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_volscale, i, *size, dinterleave))) + 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); @@ -539,7 +539,7 @@ int converter_go( /* We have to mix two or more channels */ - if (!(b = bbuffer_get(&c->bb_remap, i, *size, dinterleave))) + if (!(b = sa_bbuffer_get(&c->bb_remap, i, *size, dinterleave))) return SA_ERROR_OOM; c->add_func(b, k, process_data[p[0]], stride[p[0]], process_data[p[1]], stride[p[1]], *size); @@ -569,7 +569,7 @@ int converter_go( for (i = 0; i < c->to_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_resample, i, new_size, dinterleave))) + if (!(b = sa_bbuffer_get(&c->bb_resample, i, new_size, dinterleave))) return SA_ERROR_OOM; c->resample_func(c->speex, i, b, k, process_data[i], stride[i], *size, &new_size); @@ -603,7 +603,7 @@ int converter_go( for (i = 0; i < c->to_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_post_format, i, new_size, dinterleave))) + 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); @@ -637,7 +637,7 @@ int converter_go( for (i = 0; i < c->to_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_post_byteswap, i, *size, dinterleave))) + 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); @@ -663,7 +663,7 @@ do_interleave: for (i = 0; i < c->to_nchannels; i++) { void *b; - if (!(b = bbuffer_get(&c->bb_interleave, i, *size, dinterleave))) + 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); @@ -684,7 +684,7 @@ do_interleave: return SA_SUCCESS; } -void converter_set_volume(converter_t *c, const int32_t vol[]) { +void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]) { unsigned i; int no_volume = 1; @@ -703,7 +703,7 @@ void converter_set_volume(converter_t *c, const int32_t vol[]) { } else { float f = powf(10.0, (float) vol[i] / 2000); - continued_fraction(f, 0x7FFF, &num, &denom); + sa_continued_fraction(f, 0x7FFF, &num, &denom); if (num != 1 || denom != 1) no_volume = 0; @@ -716,8 +716,8 @@ void converter_set_volume(converter_t *c, const int32_t vol[]) { c->no_volume = no_volume; } -int converter_go_interleaved( - converter_t *c, +int sa_converter_go_interleaved( + sa_converter_t *c, const void *const data, void **dst[], size_t *dstr[], int dinterleave, size_t *size) { @@ -732,10 +732,10 @@ int converter_go_interleaved( c->from_stride[i] = stride; } - return converter_go(c, (const void *const*) c->from_process_data, c->from_stride, 1, dst, dstr, dinterleave, size); + return sa_converter_go(c, (const void *const*) c->from_process_data, c->from_stride, 1, dst, dstr, dinterleave, size); } -void converter_set_ratio(converter_t *c, unsigned rate1, unsigned rate2) { +void sa_converter_set_ratio(sa_converter_t *c, unsigned rate1, unsigned rate2) { assert(c); assert(c->speex); diff --git a/converter.h b/converter.h index da48d3c..3230471 100644 --- a/converter.h +++ b/converter.h @@ -12,9 +12,9 @@ #include "common.h" #include "interleave.h" -typedef struct converter converter_t; +typedef struct sa_converter sa_converter_t; -struct converter { +struct sa_converter { sa_pcm_format_t from_pcm_format, to_pcm_format; unsigned from_nchannels, to_nchannels; unsigned from_rate, to_rate; @@ -26,17 +26,17 @@ struct converter { size_t from_sample_size, work_sample_size, to_sample_size; - byteswap_func_t pre_byteswap_func, post_byteswap_func; - format_func_t pre_format_func, post_format_func; - volscale_func_t volscale_func; - zero_func_t zero_func; - add_func_t add_func; - resample_func_t resample_func; - interleave_func_t interleave_func; + sa_byteswap_func_t pre_byteswap_func, post_byteswap_func; + sa_format_func_t pre_format_func, post_format_func; + sa_volscale_func_t volscale_func; + sa_zero_func_t zero_func; + sa_add_func_t add_func; + sa_resample_func_t resample_func; + sa_interleave_func_t interleave_func; SpeexResamplerState *speex; - bbuffer_t bb_pre_byteswap, + sa_bbuffer_t bb_pre_byteswap, bb_pre_format, bb_volscale, bb_remap, @@ -58,24 +58,24 @@ struct converter { size_t zero_size; }; -int converter_init(converter_t *c, const pcm_attrs_t *from, const pcm_attrs_t *to, int dynamic_rate_enabled); -void converter_done(converter_t *c); +int sa_converter_init(sa_converter_t *c, const pcm_attrs_t *from, const pcm_attrs_t *to, int dynamic_rate_enabled); +void sa_converter_done(sa_converter_t *c); -int converter_go( - converter_t *c, +int sa_converter_go( + sa_converter_t *c, const void *const src[], const size_t sstr[], int sinterleave, void **dst[], size_t *dstr[], int dinterleave, size_t *size); -int converter_go_interleaved( - converter_t *c, +int sa_converter_go_interleaved( + sa_converter_t *c, const void *const data, void **dst[], size_t *dstr[], int dinterleave, size_t *size); -void converter_set_volume(converter_t *c, const int32_t vol[]); +void sa_converter_set_volume(sa_converter_t *c, const int32_t vol[]); -void converter_set_ratio(converter_t *c, unsigned rate1, unsigned rate2); +void sa_converter_set_ratio(sa_converter_t *c, unsigned rate1, unsigned rate2); #endif diff --git a/format.c b/format.c index 9b1f805..f7a8755 100644 --- a/format.c +++ b/format.c @@ -9,7 +9,7 @@ /* u8 --> */ -static int format_u8_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +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); @@ -19,7 +19,7 @@ static int format_u8_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *sr return SA_SUCCESS; } -static int format_u8_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +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); @@ -29,7 +29,7 @@ static int format_u8_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *sr return SA_SUCCESS; } -static int format_u8_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_u8_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { float d = -0x80, f = 1.0/0x7F; oil_conv_f32_u8(dst, dstr, src, sstr, bytes); @@ -41,71 +41,71 @@ static int format_u8_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *sr /* ulaw --> */ -static int format_ulaw_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_ulaw_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int16_t *d = dst; const uint8_t *s = src; for (; bytes > 0; bytes --, d += dstr/sizeof(int16_t), s += sstr) - *d = st_ulaw2linear16(*s); + *d = sa_ulaw2linear16(*s); return SA_SUCCESS; } -static int format_ulaw_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_ulaw_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int32_t *d = dst; const uint8_t *s = src; for (; bytes > 0; bytes --, d += dstr/sizeof(int32_t), s += sstr) - *d = (int32_t) st_ulaw2linear16(*s) * 0x10000; + *d = (int32_t) sa_ulaw2linear16(*s) * 0x10000; return SA_SUCCESS; } -static int format_ulaw_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_ulaw_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { float *d = dst; const uint8_t *s = src; for (; bytes > 0; bytes --, d += dstr/sizeof(float), s += sstr) - *d = st_ulaw2linear16(*s * 1.0F / 0x7FFF); + *d = sa_ulaw2linear16(*s * 1.0F / 0x7FFF); return SA_SUCCESS; } /* alaw --> */ -static int format_alaw_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_alaw_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int16_t *d = dst; const uint8_t *s = src; for (; bytes > 0; bytes --, d += dstr/sizeof(int16_t), s += sstr) - *d = st_alaw2linear16(*s); + *d = sa_alaw2linear16(*s); return SA_SUCCESS; } -static int format_alaw_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_alaw_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int32_t *d = dst; const uint8_t *s = src; for (; bytes > 0; bytes --, d += dstr/sizeof(int32_t), s += sstr) - *d = (int32_t) st_alaw2linear16(*(s++)) * 0x10000; + *d = (int32_t) sa_alaw2linear16(*(s++)) * 0x10000; return SA_SUCCESS; } -static int format_alaw_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_alaw_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { float *d = dst; const uint8_t *s = src; for (; bytes > 0; bytes --, d += dstr/sizeof(float), s += sstr) - *d = st_alaw2linear16(*(s++) * 1.0F / 0x7FFF); + *d = sa_alaw2linear16(*(s++) * 1.0F / 0x7FFF); return SA_SUCCESS; } /* s16 --> */ -static int format_s16_to_u8(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s16_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int16_t *s = src; unsigned n = bytes/sizeof(int16_t); @@ -116,29 +116,29 @@ static int format_s16_to_u8(bbuffer_t *b, void *dst, size_t dstr, const void *sr return SA_SUCCESS; } -static int format_s16_to_ulaw(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s16_to_ulaw(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int16_t *s = src; unsigned n = bytes/sizeof(int16_t); for (; n > 0; n --, d += dstr, s += sstr/sizeof(int16_t)) - *d = st_14linear2ulaw(*s); + *d = sa_14linear2ulaw(*s); return SA_SUCCESS; } -static int format_s16_to_alaw(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s16_to_alaw(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int16_t *s = src; unsigned n = bytes/sizeof(int16_t); for (; n > 0; n --, d += dstr, s += sstr/sizeof(int16_t)) - *d = st_13linear2alaw(*s); + *d = sa_13linear2alaw(*s); return SA_SUCCESS; } -static int format_s16_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s16_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int f = 0x10000; unsigned n = bytes/sizeof(int16_t); @@ -148,7 +148,7 @@ static int format_s16_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -static int format_s16_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +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); @@ -160,7 +160,7 @@ static int format_s16_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *s /* s24 --> */ -static int format_s24_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s24_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int32_t *d = dst; const uint8_t *s = src; unsigned n = bytes/3; @@ -177,7 +177,7 @@ static int format_s24_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -static int format_s24_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s24_to_f32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { float *d = dst; const uint8_t *s = src; unsigned n = bytes/3; @@ -196,7 +196,7 @@ static int format_s24_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *s /* s32 --> */ -static int format_s32_to_u8(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s32_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int32_t *s = src; unsigned n = bytes/sizeof(int32_t); @@ -207,29 +207,29 @@ static int format_s32_to_u8(bbuffer_t *b, void *dst, size_t dstr, const void *sr return SA_SUCCESS; } -static int format_s32_to_ulaw(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s32_to_ulaw(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int32_t *s = src; unsigned n = bytes/sizeof(int32_t); for (; n > 0; n--, d += dstr, s += sstr/sizeof(int32_t)) - *d = st_14linear2ulaw(*s / 0x10000); + *d = sa_14linear2ulaw(*s / 0x10000); return SA_SUCCESS; } -static int format_s32_to_alaw(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s32_to_alaw(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int32_t *s = src; unsigned n = bytes/sizeof(int32_t); for (; n > 0; n--, d += dstr, s += sstr/sizeof(int32_t)) - *d = st_13linear2alaw(*s / 0x10000); + *d = sa_13linear2alaw(*s / 0x10000); return SA_SUCCESS; } -static int format_s32_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s32_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int16_t *d = dst; const int32_t *s = src; unsigned n = bytes/sizeof(int32_t); @@ -240,7 +240,7 @@ static int format_s32_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -static int format_s32_to_s24(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_s32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const int32_t *s = src; unsigned n = bytes/sizeof(float); @@ -264,7 +264,7 @@ static int format_s32_to_s24(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -static int format_s32_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +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); @@ -276,14 +276,14 @@ static int format_s32_to_f32(bbuffer_t *b, void *dst, size_t dstr, const void *s /* f32 --> */ -static int format_f32_to_u8(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_f32_to_u8(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const float *s = src; float *buf; float f = 0x7F, p = 0x80; unsigned n = bytes/sizeof(float); - if (!(buf = bbuffer_get(b, 0, bytes, 1))) + if (!(buf = sa_bbuffer_get(b, 0, bytes, 1))) return SA_ERROR_OOM; oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); @@ -293,7 +293,7 @@ static int format_f32_to_u8(bbuffer_t *b, void *dst, size_t dstr, const void *sr return SA_SUCCESS; } -static int format_f32_to_ulaw(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_f32_to_ulaw(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const float *s = src; unsigned n = bytes/sizeof(float); @@ -302,13 +302,13 @@ static int format_f32_to_ulaw(bbuffer_t *b, void *dst, size_t dstr, const void * float v = *s * 0x7FFF; if (v < -0x8000) v = -0x8000; if (v > -0x7FFF) v = -0x7FFF; - *d = st_13linear2alaw((int16_t) v); + *d = sa_13linear2alaw((int16_t) v); } return SA_SUCCESS; } -static int format_f32_to_alaw(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_f32_to_alaw(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const float *s = src; unsigned n = bytes/sizeof(float); @@ -317,20 +317,20 @@ static int format_f32_to_alaw(bbuffer_t *b, void *dst, size_t dstr, const void * float v = *s * 0x7FFF; if (v < -0x8000) v = -0x8000; if (v > -0x7FFF) v = -0x7FFF; - *d = st_13linear2alaw((int16_t) v); + *d = sa_13linear2alaw((int16_t) v); } return SA_SUCCESS; } -static int format_f32_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_f32_to_s16(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int16_t *d = dst; const float *s = src; float *buf; float f = 0x7FFF; unsigned n = bytes/sizeof(float); - if (!(buf = bbuffer_get(b, 0, bytes, 1))) + if (!(buf = sa_bbuffer_get(b, 0, bytes, 1))) return SA_ERROR_OOM; oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); @@ -339,7 +339,7 @@ static int format_f32_to_s16(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -static int format_f32_to_s24(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_f32_to_s24(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { uint8_t *d = dst; const float *s = src; unsigned n = bytes/sizeof(float); @@ -369,14 +369,14 @@ static int format_f32_to_s24(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -static int format_f32_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { +static int format_f32_to_s32(sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes) { int32_t *d = dst; const float *s = src; float *buf; float f = 0x7FFFFFFF; unsigned n = bytes/sizeof(float); - if (!(buf = bbuffer_get(b, 0, bytes, 1))) + if (!(buf = sa_bbuffer_get(b, 0, bytes, 1))) return SA_ERROR_OOM; oil_scalarmult_f32(buf, sizeof(float), s, sstr, &f, n); @@ -385,7 +385,7 @@ static int format_f32_to_s32(bbuffer_t *b, void *dst, size_t dstr, const void *s return SA_SUCCESS; } -format_func_t get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) { +sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) { /* Rules: we need conversion functions: * @@ -394,7 +394,7 @@ format_func_t get_format_func(sa_pcm_format_t from, sa_pcm_format_t to) { * 3. only for NE types */ - static const format_func_t funcs[_SA_PCM_FORMAT_MAX * _SA_PCM_FORMAT_MAX] = { + 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 */ [_SA_PCM_FORMAT_MAX * SA_PCM_FORMAT_U8 + SA_PCM_FORMAT_FLOAT32_NE] = format_u8_to_f32, /* done */ diff --git a/format.h b/format.h index 2df79ca..91caf25 100644 --- a/format.h +++ b/format.h @@ -6,8 +6,8 @@ #include "sydney.h" #include "bbuffer.h" -typedef int (*format_func_t) (bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); +typedef int (*sa_format_func_t) (sa_bbuffer_t *b, void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); -format_func_t get_format_func(sa_pcm_format_t from, sa_pcm_format_t to); +sa_format_func_t sa_get_format_func(sa_pcm_format_t from, sa_pcm_format_t to); #endif diff --git a/g711.c b/g711.c index 55a8239..df76ac7 100644 --- a/g711.c +++ b/g711.c @@ -91,7 +91,7 @@ static int16_t search( * For further information see John C. Bellamy's Digital Telephony, 1982, * John Wiley & Sons, pps 98-111 and 472-476. */ -unsigned char st_13linear2alaw( +unsigned char sa_13linear2alaw( int16_t pcm_val) /* 2's complement (13-bit range) */ { int16_t mask; @@ -132,7 +132,7 @@ unsigned char st_13linear2alaw( * alaw2linear() - Convert an A-law value to 16-bit signed linear PCM * */ -int16_t st_alaw2linear16( +int16_t sa_alaw2linear16( unsigned char a_val) { int16_t t; @@ -193,7 +193,7 @@ int16_t st_alaw2linear16( * For further information see John C. Bellamy's Digital Telephony, 1982, * John Wiley & Sons, pps 98-111 and 472-476. */ -unsigned char st_14linear2ulaw( +unsigned char sa_14linear2ulaw( int16_t pcm_val) /* 2's complement (14-bit range) */ { int16_t mask; @@ -241,7 +241,7 @@ unsigned char st_14linear2ulaw( * Note that this function expects to be passed the complement of the * original code word. This is in keeping with ISDN conventions. */ -int16_t st_ulaw2linear16( +int16_t sa_ulaw2linear16( unsigned char u_val) { int16_t t; @@ -262,7 +262,7 @@ int16_t st_ulaw2linear16( #ifdef FAST_ALAW_CONVERSION -int16_t _st_alaw2linear16[256] = { +int16_t _sa_alaw2linear16[256] = { -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736, -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784, -2752, -2624, -3008, -2880, -2240, @@ -302,7 +302,7 @@ int16_t _st_alaw2linear16[256] = { 816, 784, 880, 848 }; -uint8_t _st_13linear2alaw[0x2000] = { +uint8_t _sa_13linear2alaw[0x2000] = { 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, @@ -992,7 +992,7 @@ uint8_t _st_13linear2alaw[0x2000] = { #ifdef FAST_ULAW_CONVERSION -int16_t _st_ulaw2linear16[256] = { +int16_t _sa_ulaw2linear16[256] = { -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956, -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764, -15996, -15484, -14972, -14460, -13948, @@ -1032,7 +1032,7 @@ int16_t _st_ulaw2linear16[256] = { 24, 16, 8, 0 }; -uint8_t _st_14linear2ulaw[0x4000] = { +uint8_t _sa_14linear2ulaw[0x4000] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -2512,7 +2512,7 @@ unsigned char _a2u[128] = { /* A- to u-law conversions */ 120, 121, 122, 123, 124, 125, 126, 127}; /* A-law to u-law conversion */ -unsigned char st_alaw2ulaw( +unsigned char sa_alaw2ulaw( unsigned char aval) { aval &= 0xff; @@ -2521,7 +2521,7 @@ unsigned char st_alaw2ulaw( } /* u-law to A-law conversion */ -unsigned char st_ulaw2alaw( +unsigned char sa_ulaw2alaw( unsigned char uval) { uval &= 0xff; diff --git a/g711.h b/g711.h index 9b2582d..ef43e3f 100644 --- a/g711.h +++ b/g711.h @@ -18,23 +18,23 @@ #include #ifdef FAST_ALAW_CONVERSION -extern uint8_t _st_13linear2alaw[0x2000]; -extern int16_t _st_alaw2linear16[256]; -#define st_13linear2alaw(sw) (_st_13linear2alaw[(sw + 0x1000)]) -#define st_alaw2linear16(uc) (_st_alaw2linear16[uc]) +extern uint8_t _sa_13linear2alaw[0x2000]; +extern int16_t _sa_alaw2linear16[256]; +#define sa_13linear2alaw(sw) (_sa_13linear2alaw[(sw + 0x1000)]) +#define sa_alaw2linear16(uc) (_sa_alaw2linear16[uc]) #else -unsigned char st_13linear2alaw(int16_t pcm_val); -int16_t st_alaw2linear16(unsigned char); +unsigned char sa_13linear2alaw(int16_t pcm_val); +int16_t sa_alaw2linear16(unsigned char); #endif #ifdef FAST_ULAW_CONVERSION -extern uint8_t _st_14linear2ulaw[0x4000]; -extern int16_t _st_ulaw2linear16[256]; -#define st_14linear2ulaw(sw) (_st_14linear2ulaw[(sw + 0x2000)]) -#define st_ulaw2linear16(uc) (_st_ulaw2linear16[uc]) +extern uint8_t _sa_14linear2ulaw[0x4000]; +extern int16_t _sa_ulaw2linear16[256]; +#define sa_14linear2ulaw(sw) (_sa_14linear2ulaw[(sw + 0x2000)]) +#define sa_ulaw2linear16(uc) (_sa_ulaw2linear16[uc]) #else -unsigned char st_14linear2ulaw(int16_t pcm_val); -int16_t st_ulaw2linear16(unsigned char); +unsigned char sa_14linear2ulaw(int16_t pcm_val); +int16_t sa_ulaw2linear16(unsigned char); #endif #endif diff --git a/interleave.c b/interleave.c index 499d988..d0470f7 100644 --- a/interleave.c +++ b/interleave.c @@ -41,9 +41,9 @@ static void interleave32(void *_dst, size_t dstr, const void *_src, size_t sstr, *dst = *src; } -interleave_func_t get_interleave_func(sa_pcm_format_t f) { +sa_interleave_func_t sa_get_interleave_func(sa_pcm_format_t f) { - static const interleave_func_t funcs[_SA_PCM_FORMAT_MAX] = { + static const sa_interleave_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = interleave8, [SA_PCM_FORMAT_ULAW] = interleave8, [SA_PCM_FORMAT_ALAW] = interleave8, diff --git a/interleave.h b/interleave.h index 10b6de1..ed4a527 100644 --- a/interleave.h +++ b/interleave.h @@ -5,8 +5,8 @@ #include "sydney.h" -typedef void (*interleave_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); +typedef void (*sa_interleave_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, size_t bytes); -interleave_func_t get_interleave_func(sa_pcm_format_t f); +sa_interleave_func_t sa_get_interleave_func(sa_pcm_format_t f); #endif diff --git a/oss.c b/oss.c index 838e0f4..3adce81 100644 --- a/oss.c +++ b/oss.c @@ -27,7 +27,7 @@ struct oss_stream { sa_stream_t *parent; int fd; pcm_attrs_t real_pcm_attrs; - converter_t converter_read, converter_write; + sa_converter_t converter_read, converter_write; size_t read_fragment_size, write_fragment_size; unsigned read_nfragments, write_nfragments; sa_thread_t *thread; @@ -443,7 +443,7 @@ int driver_open(sa_stream_t *s) { printf("Chosen: %u channels, %uHz, format=%u\n", oss->real_pcm_attrs.nchannels, oss->real_pcm_attrs.rate, oss->real_pcm_attrs.format); - real_bps = oss->real_pcm_attrs.nchannels * oss->real_pcm_attrs.rate * get_pcm_sample_size(oss->real_pcm_attrs.format); + real_bps = oss->real_pcm_attrs.nchannels * oss->real_pcm_attrs.rate * sa_get_pcm_sample_size(oss->real_pcm_attrs.format); if (real_bps != bps && loops < 1) { loops++; @@ -526,11 +526,11 @@ int driver_open(sa_stream_t *s) { s->pcm_attrs.format = oss->real_pcm_attrs.format; if (s->mode & SA_MODE_RDONLY) - if ((r = converter_init(&oss->converter_read, &oss->real_pcm_attrs, &s->pcm_attrs, s->dynamic_rate_enabled)) < 0) + 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 = converter_init(&oss->converter_write, &s->pcm_attrs, &oss->real_pcm_attrs, s->dynamic_rate_enabled)) < 0) + if ((r = sa_converter_init(&oss->converter_write, &s->pcm_attrs, &oss->real_pcm_attrs, s->dynamic_rate_enabled)) < 0) goto fail; } @@ -572,8 +572,8 @@ int driver_destroy(sa_stream_t *s) { close(oss->fd); sa_free(oss->real_pcm_attrs.channel_map); - converter_done(&oss->converter_read); - converter_done(&oss->converter_write); + sa_converter_done(&oss->converter_read); + sa_converter_done(&oss->converter_write); sa_free(oss); } @@ -670,7 +670,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); - converter_set_volume(&oss->converter_read, vol); + sa_converter_set_volume(&oss->converter_read, vol); return SA_SUCCESS; } @@ -680,7 +680,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); - converter_set_volume(&oss->converter_write, vol); + sa_converter_set_volume(&oss->converter_write, vol); return SA_SUCCESS; } @@ -689,9 +689,9 @@ int driver_change_rate(sa_stream_t *s, unsigned rate) { oss_stream_t *oss = OSS_STREAM(s); if (s->mode & SA_MODE_RDONLY) - converter_set_ratio(&oss->converter_read, oss->real_pcm_attrs.rate, s->pcm_attrs.rate); + sa_converter_set_ratio(&oss->converter_read, oss->real_pcm_attrs.rate, s->pcm_attrs.rate); if (s->mode & SA_MODE_WRONLY) - converter_set_ratio(&oss->converter_write, s->pcm_attrs.rate, oss->real_pcm_attrs.rate); + sa_converter_set_ratio(&oss->converter_write, s->pcm_attrs.rate, oss->real_pcm_attrs.rate); return SA_SUCCESS; } @@ -715,7 +715,7 @@ int driver_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offse int ret; uint8_t *d; - if ((ret = converter_go_interleaved(&oss->converter_write, data, &dst, &stride, 1, &nbytes))) + if ((ret = sa_converter_go_interleaved(&oss->converter_write, data, &dst, &stride, 1, &nbytes))) return ret; d = dst[0]; diff --git a/resample.c b/resample.c index 2061541..23c63a5 100644 --- a/resample.c +++ b/resample.c @@ -29,9 +29,9 @@ static void resample_f32(SpeexResamplerState *speex, unsigned channel, void *dst *out_bytes = out_samples * sizeof(float); } -resample_func_t get_resample_func(sa_pcm_format_t f) { +sa_resample_func_t sa_get_resample_func(sa_pcm_format_t f) { - static const resample_func_t funcs[_SA_PCM_FORMAT_MAX] = { + static const sa_resample_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_S16_NE] = resample_s16, [SA_PCM_FORMAT_FLOAT32_NE] = resample_f32 }; diff --git a/resample.h b/resample.h index 4e9fae3..7734f86 100644 --- a/resample.h +++ b/resample.h @@ -7,8 +7,8 @@ #include "sydney.h" #include "speex/speex_resampler.h" -typedef void (*resample_func_t) (SpeexResamplerState *speex, unsigned channel, void *dst, size_t dstr, const void *src, size_t sstr, size_t in_bytes, size_t *out_bytes); +typedef void (*sa_resample_func_t) (SpeexResamplerState *speex, unsigned channel, void *dst, size_t dstr, const void *src, size_t sstr, size_t in_bytes, size_t *out_bytes); -resample_func_t get_resample_func(sa_pcm_format_t f); +sa_resample_func_t sa_get_resample_func(sa_pcm_format_t f); #endif diff --git a/test-bufferq.c b/test-bufferq.c index d4585e2..05fc35b 100644 --- a/test-bufferq.c +++ b/test-bufferq.c @@ -2,22 +2,22 @@ int main(int argc, char *argv[]) { - bufferq_t q; + sa_bufferq_t q; - bufferq_init(&q, 1, 1); + sa_bufferq_init(&q, 1, 1); - bufferq_push(&q, 0, "{AAAAAAAA}", 10, 0, SA_SEEK_RELATIVE); - bufferq_push(&q, 0, "", 10, 5, SA_SEEK_RELATIVE); - bufferq_push(&q, 0, "[CCCC]", 6, -18, SA_SEEK_RELATIVE); - bufferq_push(&q, 0, "(DDDD)", 6, -3, SA_SEEK_ABSOLUTE); - bufferq_push(&q, 0, "XXX", 3, 10, SA_SEEK_RELATIVE_END); - bufferq_push(&q, 0, "YYYYY", 5, -4, SA_SEEK_RELATIVE); + sa_bufferq_push(&q, 0, "{AAAAAAAA}", 10, 0, SA_SEEK_RELATIVE); + sa_bufferq_push(&q, 0, "", 10, 5, SA_SEEK_RELATIVE); + sa_bufferq_push(&q, 0, "[CCCC]", 6, -18, SA_SEEK_RELATIVE); + sa_bufferq_push(&q, 0, "(DDDD)", 6, -3, SA_SEEK_ABSOLUTE); + sa_bufferq_push(&q, 0, "XXX", 3, 10, SA_SEEK_RELATIVE_END); + sa_bufferq_push(&q, 0, "YYYYY", 5, -4, SA_SEEK_RELATIVE); for (;;) { void *b[1]; size_t size; - bufferq_get(&q, b, &size); + sa_bufferq_get(&q, b, &size); if (size == 0) break; @@ -30,10 +30,10 @@ int main(int argc, char *argv[]) { printf("\n"); - bufferq_drop(&q, size); + sa_bufferq_drop(&q, size); } - bufferq_done(&q); + sa_bufferq_done(&q); return 0; } diff --git a/volscale.c b/volscale.c index fe26700..2075b90 100644 --- a/volscale.c +++ b/volscale.c @@ -52,9 +52,9 @@ static void volscale_f32(void *_dst, size_t dstr, const void *_src, size_t sstr, oil_scalarmult_f32(dst, dstr, src, sstr, &f, size / sizeof(float)); } -volscale_func_t get_volscale_func(sa_pcm_format_t f) { +sa_volscale_func_t sa_get_volscale_func(sa_pcm_format_t f) { - static const volscale_func_t funcs[_SA_PCM_FORMAT_MAX] = { + static const sa_volscale_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = volscale_u8, [SA_PCM_FORMAT_S16_NE] = volscale_s16, [SA_PCM_FORMAT_S32_NE] = volscale_s32, diff --git a/volscale.h b/volscale.h index ea812d0..fe6e037 100644 --- a/volscale.h +++ b/volscale.h @@ -6,8 +6,8 @@ #include "sydney.h" -typedef void (*volscale_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, int32_t factor, int32_t divisor, size_t bytes); +typedef void (*sa_volscale_func_t) (void *dst, size_t dstr, const void *src, size_t sstr, int32_t factor, int32_t divisor, size_t bytes); -volscale_func_t get_volscale_func(sa_pcm_format_t f); +sa_volscale_func_t sa_get_volscale_func(sa_pcm_format_t f); #endif diff --git a/zero.c b/zero.c index 9a5c9d5..4f477dc 100644 --- a/zero.c +++ b/zero.c @@ -38,9 +38,9 @@ static void zero_32(void *dst, size_t dstr, size_t bytes) { } } -zero_func_t get_zero_func(sa_pcm_format_t f) { +sa_zero_func_t sa_get_zero_func(sa_pcm_format_t f) { - static const zero_func_t funcs[_SA_PCM_FORMAT_MAX] = { + static const sa_zero_func_t funcs[_SA_PCM_FORMAT_MAX] = { [SA_PCM_FORMAT_U8] = zero_u8, [SA_PCM_FORMAT_S16_NE] = zero_16, [SA_PCM_FORMAT_S32_NE] = zero_32, diff --git a/zero.h b/zero.h index 2e76d90..6f59bdb 100644 --- a/zero.h +++ b/zero.h @@ -6,8 +6,8 @@ #include "sydney.h" -typedef void (*zero_func_t) (void *dst, size_t dstr, size_t bytes); +typedef void (*sa_zero_func_t) (void *dst, size_t dstr, size_t bytes); -zero_func_t get_zero_func(sa_pcm_format_t f); +sa_zero_func_t sa_get_zero_func(sa_pcm_format_t f); #endif -- cgit