mainloop-api.c mainloop-api.h \
util.c util.h \
hashset.c hashset.h \
- namereg.c namereg.h
-
-polypaudio_CFLAGS = $(AM_CFLAGS)
-
+ namereg.c namereg.h \
+ sconv.c sconv.h \
+ resampler.c resampler.h \
+ endianmacros.h
+polypaudio_CFLAGS = $(AM_CFLAGS) $(LIBSAMPLERATE_CFLAGS)
polypaudio_INCLUDES = $(INCLTDL)
-polypaudio_LDADD = $(LIBLTDL)
+polypaudio_LDADD = $(LIBLTDL) $(LIBSAMPLERATE_LIBS)
polypaudio_LDFLAGS=-export-dynamic
libprotocol_simple_la_SOURCES = protocol-simple.c protocol-simple.h
--- /dev/null
+#ifndef fooendianmacroshfoo
+#define fooendianmacroshfoo
+
+#include <inttypes.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define INT16_SWAP(x) ((int16_t)(((int16_t) x >> 8) | ((int16_t) x << 8)))
+#define UINT16_SWAP(x) ((uint16_t)(((uint16_t) x >> 8) | ((uint16_t) x << 8)))
+#define INT32_SWAP(x) ((int32_t)(((int32_t) x >> 24) | ((int32_t) x << 24) | (((int32_t) x & 0xFF00) << 16) | (((int32_t) x) >> 16) & 0xFF00))
+#define UINT32_SWAP(x) ((uint32_t)(((uint32_t) x >> 24) | ((uint32_t) x << 24) | (((uint32_t) x & 0xFF00) << 16) | (((uint32_t) x) >> 16) & 0xFF00))
+
+#ifdef WORDS_BIGENDIAN
+ #define INT16_FROM_LE(x) INT16_SWAP(x)
+ #define INT16_FROM_BE(x) ((int16_t)(x))
+ #define INT16_TO_LE(x) INT16_SWAP(x)
+ #define INT16_TO_BE(x) ((int16_t)(x))
+
+ #define UINT16_FROM_LE(x) UINT16_SWAP(x)
+ #define UINT16_FROM_BE(x) ((uint16_t)(x))
+ #define INT32_FROM_LE(x) INT32_SWAP(x)
+ #define INT32_FROM_BE(x) ((int32_t)(x))
+ #define UINT32_FROM_LE(x) UINT32_SWAP(x)
+ #define UINT32_FROM_BE(x) ((uint32_t)(x))
+#else
+ #define INT16_FROM_LE(x) ((int16_t)(x))
+ #define INT16_FROM_BE(x) INT16_SWAP(x)
+ #define INT16_TO_LE(x) ((int16_t)(x))
+ #define INT16_TO_BE(x) INT16_SWAP(x)
+
+ #define UINT16_FROM_LE(x) ((uint16_t)(x))
+ #define UINT16_FROM_BE(x) UINT16_SWAP(x)
+ #define INT32_FROM_LE(x) ((int32_t)(x))
+ #define INT32_FROM_BE(x) INT32_SWAP(x)
+ #define UINT32_FROM_LE(x) ((uint32_t)(x))
+ #define UINT32_FROM_BE(x) UINT32_SWAP(x)
+#endif
+
+#endif
+#include <stdlib.h>
#include <assert.h>
#include <fcntl.h>
-#include <stdlib.h>
#include <unistd.h>
#include "iochannel.h"
--- /dev/null
+#include <stdlib.h>
+#include <assert.h>
+
+#include <samplerate.h>
+
+#include "resampler.h"
+#include "sconv.h"
+
+struct resampler {
+ struct pa_sample_spec i_ss, o_ss;
+ float* i_buf, *o_buf;
+ unsigned i_alloc, o_alloc;
+ size_t i_sz, o_sz;
+
+ int channels;
+
+ convert_to_float32_func_t to_float32_func;
+ convert_from_float32_func_t from_float32_func;
+ SRC_STATE *src_state;
+};
+
+struct resampler* resampler_new(const struct pa_sample_spec *a, const struct pa_sample_spec *b) {
+ struct resampler *r;
+ int err;
+ assert(a && b && pa_sample_spec_valid(a) && pa_sample_spec_valid(b));
+
+ if (a->channels != b->channels && a->channels != 1 && b->channels != 1)
+ goto fail;
+
+ if (a->format == PA_SAMPLE_ALAW || a->format == PA_SAMPLE_ULAW || b->format == PA_SAMPLE_ALAW || b->format == PA_SAMPLE_ULAW)
+ goto fail;
+
+ r->channels = a->channels;
+ if (b->channels < r->channels)
+ r->channels = b->channels;
+
+ r = malloc(sizeof(struct resampler));
+ assert(r);
+ r->i_buf = r->o_buf = NULL;
+ r->i_alloc = r->o_alloc = 0;
+
+ if (a->rate != b->rate) {
+ r->src_state = src_new(SRC_SINC_FASTEST, r->channels, &err);
+ if (err != 0 || !r->src_state)
+ goto fail;
+ } else
+ r->src_state = NULL;
+
+ r->i_ss = *a;
+ r->o_ss = *b;
+
+ r->i_sz = pa_sample_size(a);
+ r->o_sz = pa_sample_size(b);
+
+ r->to_float32_func = get_convert_to_float32_function(a->format);
+ r->from_float32_func = get_convert_from_float32_function(b->format);
+
+ assert(r->to_float32_func && r->from_float32_func);
+
+ return r;
+
+fail:
+ if (r)
+ free(r);
+
+ return NULL;
+}
+
+void resampler_free(struct resampler *r) {
+ assert(r);
+ if (r->src_state)
+ src_delete(r->src_state);
+ free(r->i_buf);
+ free(r->o_buf);
+ free(r);
+}
+
+size_t resampler_request(struct resampler *r, size_t out_length) {
+ assert(r && (out_length % r->o_sz) == 0);
+
+ return (((out_length / r->o_sz)*r->i_ss.rate)/r->o_ss.rate) * r->i_sz;
+}
+
+
+int resampler_run(struct resampler *r, struct memchunk *in, struct memchunk *out) {
+ unsigned i_nchannels, o_nchannels, ins, ons, eff_ins, eff_ons;
+ float *cbuf;
+ size_t in_bytes_used = 0;
+ assert(r && in && out && in->length && in->memblock);
+
+ /* How many input samples? */
+ ins = in->length/r->i_sz;
+
+ /* How much space for output samples? */
+ if (r->src_state)
+ ons = (ins*r->o_ss.rate/r->i_ss.rate)+1024;
+ else
+ ons = ins;
+
+ /* How many channels? */
+ if (r->i_ss.channels == r->o_ss.channels) {
+ i_nchannels = o_nchannels = 1;
+ eff_ins = ins*r->i_ss.channels; /* effective samples */
+ eff_ons = ons*r->o_ss.channels;
+ } else {
+ i_nchannels = r->i_ss.channels;
+ o_nchannels = r->o_ss.channels;
+ eff_ins = ins;
+ eff_ons = ons;
+ }
+
+ out->memblock = memblock_new(out->length = (ons*r->o_sz));
+ out->index = 0;
+ assert(out->memblock);
+
+ if (r->i_alloc < eff_ins)
+ r->i_buf = realloc(r->i_buf, sizeof(float) * (r->i_alloc = eff_ins));
+ assert(r->i_buf);
+
+ r->to_float32_func(eff_ins, in->memblock->data+in->index, i_nchannels, r->i_buf);
+
+ if (r->src_state) {
+ int ret;
+ SRC_DATA data;
+
+ if (r->o_alloc < eff_ons)
+ r->o_buf = realloc(r->o_buf, sizeof(float) * (r->o_alloc = eff_ons));
+ assert(r->o_buf);
+
+ data.data_in = r->i_buf;
+ data.input_frames = ins;
+
+ data.data_out = r->o_buf;
+ data.output_frames = ons;
+
+ data.src_ratio = (double) r->o_ss.rate / r->i_ss.rate;
+ data.end_of_input = 0;
+
+ ret = src_process(r->src_state, &data);
+ assert(ret == 0);
+
+ in_bytes_used = data.input_frames_used*r->i_sz;
+ cbuf = r->o_buf;
+ ons = data.output_frames_gen;
+
+ if (r->i_ss.channels == r->o_ss.channels)
+ eff_ons = ons*r->o_ss.channels;
+ else
+ eff_ons = ons;
+ } else {
+ in_bytes_used = ins*r->i_sz;
+ cbuf = r->i_buf;
+ }
+
+ assert(in_bytes_used < in->length);
+ in->index += in_bytes_used;
+ in->length -= in_bytes_used;
+
+ r->from_float32_func(eff_ons, cbuf, out->memblock->data+out->index, o_nchannels);
+ out->length = ons*r->o_sz;
+ return 0;
+}
--- /dev/null
+#ifndef fooresamplerhfoo
+#define fooresamplerhfoo
+
+#include "sample.h"
+#include "memblock.h"
+
+struct resampler;
+
+struct resampler* resampler_new(const struct pa_sample_spec *a, const struct pa_sample_spec *b);
+void resampler_free(struct resampler *r);
+
+size_t resampler_request(struct resampler *r, size_t out_length);
+int resampler_run(struct resampler *r, struct memchunk *in, struct memchunk *out);
+
+#endif
#include "sample.h"
-size_t pa_sample_size(struct pa_sample_spec *spec) {
+size_t pa_sample_size(const struct pa_sample_spec *spec) {
assert(spec);
size_t b = 1;
return b * spec->channels;
}
-size_t pa_bytes_per_second(struct pa_sample_spec *spec) {
+size_t pa_bytes_per_second(const struct pa_sample_spec *spec) {
assert(spec);
return spec->rate*pa_sample_size(spec);
}
-uint32_t pa_samples_usec(size_t length, struct pa_sample_spec *spec) {
+uint32_t pa_samples_usec(size_t length, const struct pa_sample_spec *spec) {
assert(spec);
return (uint32_t) (((double) length /pa_sample_size(spec))/spec->rate*1000000);
}
-int pa_sample_spec_valid(struct pa_sample_spec *spec) {
+int pa_sample_spec_valid(const struct pa_sample_spec *spec) {
assert(spec);
if (!spec->rate || !spec->channels)
PA_SAMPLE_MAX
};
+#ifdef WORDS_BIGENDIAN
+#define PA_SAMPLE_S16NE PA_SAMPLE_S16BE
+#else
#define PA_SAMPLE_S16NE PA_SAMPLE_S16LE
+#endif
struct pa_sample_spec {
enum pa_sample_format format;
uint8_t channels;
};
-size_t pa_bytes_per_second(struct pa_sample_spec *spec);
-size_t pa_sample_size(struct pa_sample_spec *spec);
-uint32_t pa_samples_usec(size_t length, struct pa_sample_spec *spec);
+size_t pa_bytes_per_second(const struct pa_sample_spec *spec);
+size_t pa_sample_size(const struct pa_sample_spec *spec);
+uint32_t pa_samples_usec(size_t length, const struct pa_sample_spec *spec);
-int pa_sample_spec_valid(struct pa_sample_spec *spec);
+int pa_sample_spec_valid(const struct pa_sample_spec *spec);
#endif
--- /dev/null
+#include <stdlib.h>
+#include <assert.h>
+#include "endianmacros.h"
+#include "sconv.h"
+
+static void s16le_to_float32(unsigned n, const void *a, unsigned an, float *b) {
+ const int16_t *ca = a;
+ assert(n && a && an && b);
+
+ for (; n > 0; n--) {
+ unsigned i;
+ float sum = 0;
+
+ for (i = 0; i < an; i++) {
+ int16_t s = *(ca++);
+ sum += ((float) INT16_FROM_LE(s))/0x7FFF;
+ }
+
+ if (sum > 1)
+ sum = 1;
+ if (sum < -1)
+ sum = -1;
+
+ *(b++) = sum;
+ }
+}
+
+static void s16le_from_float32(unsigned n, const float *a, void *b, unsigned bn) {
+ int16_t *cb = b;
+ assert(n && a && b && bn);
+
+ for (; n > 0; n--) {
+ unsigned i;
+ int16_t s;
+ float v = *(a++);
+
+ if (v > 1)
+ v = 1;
+ if (v < -1)
+ v = -1;
+
+ s = (int16_t) (v * 0x7FFF);
+
+ for (i = 0; i < bn; i++)
+ *(cb++) = INT16_TO_LE(v);
+ }
+}
+
+static void float32_to_float32(unsigned n, const void *a, unsigned an, float *b) {
+ unsigned i;
+ const float *ca = a;
+ assert(n && a && an && b);
+ for (; n > 0; n--) {
+ float sum = 0;
+
+ for (i = 0; i < an; i++)
+ sum += *(ca++);
+
+ if (sum > 1)
+ sum = 1;
+ if (sum < -1)
+ sum = -1;
+
+ *(b++) = sum;
+ }
+}
+
+static void float32_from_float32(unsigned n, const float *a, void *b, unsigned bn) {
+ unsigned i;
+ float *cb = b;
+ assert(n && a && b && bn);
+ for (; n > 0; n--) {
+ float v = *(a++);
+ for (i = 0; i < bn; i++)
+ *(cb++) = v;
+ }
+}
+
+convert_to_float32_func_t get_convert_to_float32_function(enum pa_sample_format f) {
+ switch(f) {
+ case PA_SAMPLE_S16LE:
+ return s16le_to_float32;
+ case PA_SAMPLE_FLOAT32:
+ return float32_to_float32;
+ default:
+ return NULL;
+ }
+}
+
+convert_from_float32_func_t get_convert_from_float32_function(enum pa_sample_format f) {
+ switch(f) {
+ case PA_SAMPLE_S16LE:
+ return s16le_from_float32;
+ case PA_SAMPLE_FLOAT32:
+ return float32_from_float32;
+ default:
+ return NULL;
+ }
+}
--- /dev/null
+#ifndef foosconvhfoo
+#define foosconvhfoo
+
+#include "sample.h"
+
+typedef void (*convert_to_float32_func_t)(unsigned n, const void *a, unsigned an, float *b);
+typedef void (*convert_from_float32_func_t)(unsigned n, const float *a, void *b, unsigned bn);
+
+convert_to_float32_func_t get_convert_to_float32_function(enum pa_sample_format f);
+convert_from_float32_func_t get_convert_from_float32_function(enum pa_sample_format f);
+
+
+
+#endif
uint32_t sink_input_get_latency(struct sink_input *i);
char *sink_input_list_to_string(struct core *c);
+
+
+
#endif
more functions
- esound protocol:
recording
-- split oss-dma?
+- move more stuff from module-oss[-dma] to liboss-util
- simple library
- simple control protocol:
kill client/input/output
+- kill() routines in all modules
- resampling
- config parser/cmdline
- record testing
- mixing/volume
-- kill() routines in all modules
-- 0.1
- future cancellation
- client-ui
- clip cache
+- autoloading/autounloading
drivers:
- libao