pkglib_LTLIBRARIES=libprotocol-simple.la module-simple-protocol-tcp.la \
libsocket-server.la module-pipe-sink.la libpstream.la libiochannel.la \
- libpacket.la module-oss.la
+ libpacket.la module-oss.la module-oss-mmap.la liboss.la
polypaudio_SOURCES = idxset.c queue.c strbuf.c mainloop.c \
memblock.c sample.c memblockq.c client.c \
libpacket_la_SOURCES = packet.c
libpacket_la_LDFLAGS = -avoid-version
+liboss_la_SOURCES = oss.c
+liboss_la_LDFLAGS = -avoid-version
+
module_simple_protocol_tcp_la_SOURCES = module-simple-protocol-tcp.c
module_simple_protocol_tcp_la_LDFLAGS = -module -avoid-version
module_simple_protocol_tcp_la_LIBADD = libprotocol-simple.la libiochannel.la
module_oss_la_SOURCES = module-oss.c
module_oss_la_LDFLAGS = -module -avoid-version
-module_oss_la_LIBADD = libiochannel.la
+module_oss_la_LIBADD = libiochannel.la liboss.la
+
+module_oss_mmap_la_SOURCES = module-oss-mmap.c
+module_oss_mmap_la_LDFLAGS = -module -avoid-version
+module_oss_mmap_la_LIBADD = libiochannel.la liboss.la
mainloop_source_new_signal(m, SIGINT, signal_callback, NULL);
signal(SIGPIPE, SIG_IGN);
- module_load(c, "module-oss", "/dev/dsp1");
+ module_load(c, "module-oss-mmap", "/dev/dsp1");
module_load(c, "module-pipe-sink", NULL);
module_load(c, "module-simple-protocol-tcp", NULL);
-
fprintf(stderr, "main: mainloop entry.\n");
while (mainloop_iterate(m, 1) == 0);
/* fprintf(stderr, "main: %u blocks\n", n_blocks);*/
#include <stdlib.h>
#include <assert.h>
#include <string.h>
-#include <sys/time.h>
-#include <time.h>
#include "memblock.h"
b->length = length;
b->data = b+1;
n_blocks++;
- timerclear(&b->stamp);
return b;
}
b->length = length;
b->data = d;
n_blocks++;
- timerclear(&b->stamp);
return b;
}
b->length = length;
b->data = d;
n_blocks++;
- timerclear(&b->stamp);
return b;
}
b->type = MEMBLOCK_DYNAMIC;
}
-void memblock_stamp(struct memblock*b) {
- assert(b);
- gettimeofday(&b->stamp, NULL);
-}
-
-uint32_t memblock_age(struct memblock*b) {
- assert(b);
- struct timeval tv;
- uint32_t r;
-
- if (b->stamp.tv_sec == 0)
- return (suseconds_t) -1;
-
- gettimeofday(&tv, NULL);
-
- /*fprintf(stderr, "memblock: (%lu,%lu) -- (%lu,%lu)\r", b->stamp.tv_sec, b->stamp.tv_usec, tv.tv_sec, tv.tv_usec);*/
-
- r = (tv.tv_sec-b->stamp.tv_sec) * 1000000;
-
- if (tv.tv_usec >= b->stamp.tv_usec)
- r += tv.tv_usec - b->stamp.tv_usec;
- else
- r -= b->stamp.tv_usec - tv.tv_usec;
-
- return r;
-}
unsigned ref;
size_t length;
void *data;
- struct timeval stamp;
};
struct memchunk {
void memblock_unref_fixed(struct memblock*b);
-void memblock_stamp(struct memblock*b);
-uint32_t memblock_age(struct memblock*b);
-
#define memblock_assert_exclusive(b) assert((b)->ref == 1)
extern unsigned n_blocks;
+#include <sys/time.h>
+#include <time.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
struct memblock_list {
struct memblock_list *next;
struct memchunk chunk;
+ struct timeval stamp;
};
struct memblockq {
struct memblock_list *blocks, *blocks_tail;
unsigned n_blocks;
- size_t total_length;
- size_t maxlength;
- size_t base;
- size_t prebuf;
+ size_t total_length, maxlength, base, prebuf;
+ int measure_latency;
+ uint32_t latency;
};
-
struct memblockq* memblockq_new(size_t maxlength, size_t base, size_t prebuf) {
struct memblockq* bq;
assert(maxlength && base);
assert(bq->maxlength >= base);
+ bq->measure_latency = 1;
+ bq->latency = 0;
+
return bq;
}
q = malloc(sizeof(struct memblock_list));
assert(q);
+ if (bq->measure_latency)
+ gettimeofday(&q->stamp, NULL);
+ else
+ timerclear(&q->stamp);
+
q->chunk = *chunk;
memblock_ref(q->chunk.memblock);
assert(q->chunk.index+q->chunk.length <= q->chunk.memblock->length);
return 0;
}
+static uint32_t age(struct timeval *tv) {
+ assert(tv);
+ struct timeval now;
+ uint32_t r;
+
+ if (tv->tv_sec == 0)
+ return 0;
+
+ gettimeofday(&now, NULL);
+
+ r = (now.tv_sec-tv->tv_sec) * 1000000;
+
+ if (now.tv_usec >= tv->tv_usec)
+ r += now.tv_usec - tv->tv_usec;
+ else
+ r -= tv->tv_usec - now.tv_usec;
+
+ return r;
+}
+
void memblockq_drop(struct memblockq *bq, size_t length) {
assert(bq);
if (l > bq->blocks->chunk.length)
l = bq->blocks->chunk.length;
-
+
+ if (bq->measure_latency)
+ bq->latency = age(&bq->blocks->stamp);
+
bq->blocks->chunk.index += l;
bq->blocks->chunk.length -= l;
bq->total_length -= l;
assert(length <= bq->maxlength);
return bq->total_length + length <= bq->maxlength;
}
+
+uint32_t memblockq_get_latency(struct memblockq *bq) {
+ return bq->latency;
+}
int memblockq_is_readable(struct memblockq *bq);
int memblockq_is_writable(struct memblockq *bq, size_t length);
+uint32_t memblockq_get_latency(struct memblockq *bq);
#endif
--- /dev/null
+#include <sys/soundcard.h>
+#include <sys/ioctl.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/mman.h>
+
+#include "iochannel.h"
+#include "sink.h"
+#include "source.h"
+#include "module.h"
+#include "oss.h"
+
+struct userdata {
+ struct sink *sink;
+ struct source *source;
+ struct core *core;
+ struct sample_spec sample_spec;
+
+ size_t in_fragment_size, out_fragment_size, in_fragments, out_fragments, sample_size, out_fill;
+ uint32_t sample_usec;
+
+ int fd;
+
+ void *in_mmap, *out_mmap;
+ size_t in_mmap_length, out_mmap_length;
+
+ struct mainloop_source *mainloop_source;
+
+ struct memblock **in_memblocks, **out_memblocks;
+ unsigned out_current, in_current;
+};
+
+void module_done(struct core *c, struct module*m);
+
+static void out_clear_memblocks(struct userdata*u, unsigned n) {
+ unsigned i = u->out_current;
+ assert(u && u->out_memblocks);
+
+ if (n > u->out_fragments)
+ n = u->out_fragments;
+
+ while (n > 0) {
+ if (u->out_memblocks[i]) {
+ memblock_unref_fixed(u->out_memblocks[i]);
+ u->out_memblocks[i] = NULL;
+ }
+
+ i++;
+ while (i >= u->out_fragments)
+ i -= u->out_fragments;
+
+ n--;
+ }
+}
+
+static void out_fill_memblocks(struct userdata *u, unsigned n) {
+ assert(u && u->out_memblocks);
+
+ while (n > 0) {
+ struct memchunk chunk;
+
+ if (!u->out_memblocks[u->out_current]) {
+
+ u->out_memblocks[u->out_current] = chunk.memblock = memblock_new_fixed(u->out_mmap+u->out_fragment_size*u->out_current, u->out_fragment_size);
+ chunk.length = chunk.memblock->length;
+ chunk.index = 0;
+
+ sink_render_into_full(u->sink, &chunk);
+ }
+
+ u->out_current++;
+ while (u->out_current >= u->out_fragments)
+ u->out_current -= u->out_fragments;
+
+ n--;
+ }
+}
+
+static void do_write(struct userdata *u) {
+ struct count_info info;
+ assert(u && u->sink);
+
+ if (ioctl(u->fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_GETOPTR: %s\n", strerror(errno));
+ return;
+ }
+
+ u->out_fill = (u->out_fragment_size * u->out_fragments) - (info.ptr % u->out_fragment_size);
+
+ if (!info.blocks)
+ return;
+
+ out_clear_memblocks(u, info.blocks);
+ out_fill_memblocks(u, info.blocks);
+
+}
+
+static void in_post_memblocks(struct userdata *u, unsigned n) {
+ assert(u && u->in_memblocks);
+
+ while (n > 0) {
+ struct memchunk chunk;
+
+ if (!u->in_memblocks[u->in_current]) {
+ u->in_memblocks[u->in_current] = chunk.memblock = memblock_new_fixed(u->in_mmap+u->in_fragment_size*u->in_current, u->in_fragment_size);
+ chunk.length = chunk.memblock->length;
+ chunk.index = 0;
+
+ source_post(u->source, &chunk);
+ }
+
+ u->in_current++;
+ while (u->in_current >= u->in_fragments)
+ u->in_current -= u->in_fragments;
+
+ n--;
+ }
+}
+
+static void in_clear_memblocks(struct userdata*u, unsigned n) {
+ unsigned i = u->in_current;
+ assert(u && u->in_memblocks);
+
+ if (n > u->in_fragments)
+ n = u->in_fragments;
+
+ while (n > 0) {
+ if (u->in_memblocks[i]) {
+ memblock_unref_fixed(u->in_memblocks[i]);
+ u->in_memblocks[i] = NULL;
+ }
+
+ i++;
+ while (i >= u->in_fragments)
+ i -= u->in_fragments;
+
+ n--;
+ }
+}
+
+static void do_read(struct userdata *u) {
+ struct count_info info;
+ assert(u && u->source);
+
+ if (ioctl(u->fd, SNDCTL_DSP_GETIPTR, &info) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_GETIPTR: %s\n", strerror(errno));
+ return;
+ }
+
+ if (!info.blocks)
+ return;
+
+ in_post_memblocks(u, info.blocks);
+ in_clear_memblocks(u, u->in_fragments/2);
+};
+
+static void io_callback(struct mainloop_source*s, int fd, enum mainloop_io_event event, void *userdata) {
+ struct userdata *u = userdata;
+
+ if (event & MAINLOOP_IO_EVENT_IN)
+ do_read(u);
+ if (event & MAINLOOP_IO_EVENT_OUT)
+ do_write(u);
+}
+
+static uint32_t sink_get_latency_cb(struct sink *s) {
+ struct userdata *u = s->userdata;
+ assert(s && u);
+
+ do_write(u);
+ return u->out_fill/u->sample_size*u->sample_usec;
+}
+
+int module_init(struct core *c, struct module*m) {
+ struct audio_buf_info info;
+ struct userdata *u = NULL;
+ char *p;
+ int frag_size;
+ int mode, caps, caps_read = 0;
+ int enable_bits = 0, zero = 0;
+ assert(c && m);
+
+ m->userdata = u = malloc(sizeof(struct userdata));
+ assert(u);
+ memset(u, 0, sizeof(struct userdata));
+ u->fd = -1;
+ u->core = c;
+
+ p = m->argument ? m->argument : "/dev/dsp";
+ if ((u->fd = open(p, (mode = O_RDWR)|O_NDELAY)) >= 0) {
+ ioctl(u->fd, SNDCTL_DSP_SETDUPLEX, 0);
+
+ if (ioctl(u->fd, SNDCTL_DSP_GETCAPS, &caps) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_GETCAPS: %s\n", strerror(errno));
+ goto fail;
+ }
+
+ if (!(caps & DSP_CAP_DUPLEX)) {
+ close(u->fd);
+ u->fd = -1;
+ } else
+ caps_read = 1;
+ }
+
+ if (u->fd < 0) {
+ if ((u->fd = open(p, (mode = O_WRONLY)|O_NDELAY)) < 0) {
+ if ((u->fd = open(p, (mode = O_RDONLY)|O_NDELAY)) < 0) {
+ fprintf(stderr, "open('%s'): %s\n", p, strerror(errno));
+ goto fail;
+ }
+ }
+ }
+
+ if (!caps_read) {
+ if (ioctl(u->fd, SNDCTL_DSP_GETCAPS, &caps) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_GETCAPS: %s\n", strerror(errno));
+ goto fail;
+ }
+ }
+
+ if (!(caps & DSP_CAP_MMAP) || !(caps & DSP_CAP_REALTIME) || !(caps & DSP_CAP_TRIGGER)) {
+ fprintf(stderr, "OSS device not mmap capable.\n");
+ goto fail;
+ }
+
+ fprintf(stderr, "module-oss: device opened in %s mode.\n", mode == O_WRONLY ? "O_WRONLY" : (mode == O_RDONLY ? "O_RDONLY" : "O_RDWR"));
+
+ frag_size = ((int) 12 << 16) | 10; /* nfrags = 12; frag_size = 2^10 */
+ if (ioctl(u->fd, SNDCTL_DSP_SETFRAGMENT, &frag_size) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_SETFRAGMENT: %s\n", strerror(errno));
+ goto fail;
+ }
+
+ if (oss_auto_format(u->fd, &u->sample_spec) < 0)
+ goto fail;
+
+ if (mode != O_WRONLY) {
+ if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_GETISPACE: %s\n", strerror(errno));
+ goto fail;
+ }
+
+ fprintf(stderr, "module-oss-mmap: input -- %u fragments of size %u.\n", info.fragstotal, info.fragsize);
+ u->in_mmap_length = (u->in_fragment_size = info.fragsize) * (u->in_fragments = info.fragstotal);
+
+ if ((u->in_mmap = mmap(NULL, u->in_mmap_length, PROT_READ, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
+ if (mode == O_RDWR) {
+ fprintf(stderr, "module-oss-mmap: mmap failed for input. Changing to O_WRONLY mode.\n");
+ mode = O_WRONLY;
+ } else {
+ fprintf(stderr, "modeule-oss-mmap: mmap(): %s\n", strerror(errno));
+ goto fail;
+ }
+ } else {
+
+ u->source = source_new(c, "dsp", &u->sample_spec);
+ assert(u->source);
+ u->source->userdata = u;
+
+ u->in_memblocks = malloc(sizeof(struct memblock *)*u->in_fragments);
+ memset(u->in_memblocks, 0, sizeof(struct memblock *)*u->in_fragments);
+
+ enable_bits |= PCM_ENABLE_INPUT;
+ }
+ }
+
+ if (m != O_RDONLY) {
+ if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_GETOSPACE: %s\n", strerror(errno));
+ goto fail;
+ }
+
+ fprintf(stderr, "module-oss: output -- %u fragments of size %u.\n", info.fragstotal, info.fragsize);
+ u->out_mmap_length = (u->out_fragment_size = info.fragsize) * (u->out_fragments = info.fragstotal);
+
+ if ((u->out_mmap = mmap(NULL, u->out_mmap_length, PROT_WRITE, MAP_SHARED, u->fd, 0)) == MAP_FAILED) {
+ if (mode == O_RDWR) {
+ fprintf(stderr, "module-oss-mmap: mmap filed for output. Changing to O_RDONLY mode.\n");
+ mode = O_RDONLY;
+ } else {
+ fprintf(stderr, "modeule-oss-mmap: mmap(): %s\n", strerror(errno));
+ goto fail;
+ }
+ } else {
+ silence_memory(u->out_mmap, u->out_mmap_length, &u->sample_spec);
+
+ u->sink = sink_new(c, "dsp", &u->sample_spec);
+ assert(u->sink);
+ u->sink->get_latency = sink_get_latency_cb;
+ u->sink->userdata = u;
+
+ u->out_memblocks = malloc(sizeof(struct memblock *)*u->out_fragments);
+ memset(u->out_memblocks, 0, sizeof(struct memblock *)*u->out_fragments);
+
+ enable_bits |= PCM_ENABLE_OUTPUT;
+ }
+ }
+
+ zero = 0;
+ if (ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &zero) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_SETTRIGGER: %s\n", strerror(errno));
+ goto fail;
+ }
+
+ if (ioctl(u->fd, SNDCTL_DSP_SETTRIGGER, &enable_bits) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_SETTRIGGER: %s\n", strerror(errno));
+ goto fail;
+ }
+
+ assert(u->source || u->sink);
+
+ u->sample_size = sample_size(&u->sample_spec);
+ u->sample_usec = 1000000/u->sample_spec.rate;
+
+ u->mainloop_source = mainloop_source_new_io(c->mainloop, u->fd, (u->source ? MAINLOOP_IO_EVENT_IN : 0) | (u->sink ? MAINLOOP_IO_EVENT_OUT : 0), io_callback, u);
+ assert(u->mainloop_source);
+
+ return 0;
+
+fail:
+ module_done(c, m);
+
+ return -1;
+}
+
+void module_done(struct core *c, struct module*m) {
+ struct userdata *u;
+ assert(c && m);
+
+ u = m->userdata;
+ assert(u);
+
+ if (u->out_memblocks) {
+ out_clear_memblocks(u, u->out_fragments);
+ free(u->out_memblocks);
+ }
+
+ if (u->in_memblocks) {
+ in_clear_memblocks(u, u->in_fragments);
+ free(u->in_memblocks);
+ }
+
+ if (u->in_mmap && u->in_mmap != MAP_FAILED)
+ munmap(u->in_mmap, u->in_mmap_length);
+
+ if (u->out_mmap && u->out_mmap != MAP_FAILED)
+ munmap(u->out_mmap, u->out_mmap_length);
+
+ if (u->sink)
+ sink_free(u->sink);
+
+ if (u->source)
+ source_free(u->source);
+
+ if (u->mainloop_source)
+ mainloop_source_free(u->mainloop_source);
+
+ if (u->fd >= 0)
+ close(u->fd);
+
+ free(u);
+}
#include "sink.h"
#include "source.h"
#include "module.h"
+#include "oss.h"
+#include "sample.h"
struct userdata {
struct sink *sink;
struct memchunk memchunk, silence;
- uint32_t in_fragment_size, out_fragment_size, sample_size;
+ uint32_t in_fragment_size, out_fragment_size, sample_size, sample_usec;
+
+ int fd;
};
static void do_write(struct userdata *u) {
do_read(u);
}
+static uint32_t sink_get_latency_cb(struct sink *s) {
+ int arg;
+ struct userdata *u = s->userdata;
+ assert(s && u);
+
+ if (ioctl(u->fd, SNDCTL_DSP_GETODELAY, &arg) < 0) {
+ fprintf(stderr, "module-oss: device doesn't support SNDCTL_DSP_GETODELAY.\n");
+ s->get_latency = NULL;
+ return 0;
+ }
+
+ return arg/u->sample_size*u->sample_usec;
+}
+
int module_init(struct core *c, struct module*m) {
struct audio_buf_info info;
struct userdata *u = NULL;
char *p;
int fd = -1;
- int format, channels, speed, frag_size, in_frag_size, out_frag_size;
+ int frag_size, in_frag_size, out_frag_size;
int mode;
struct sample_spec ss;
assert(c && m);
goto fail;
}
- format = AFMT_S16_NE;
- if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) < 0 || format != AFMT_S16_NE) {
- int f = AFMT_S16_NE == AFMT_S16_LE ? AFMT_S16_BE : AFMT_S16_LE;
- format = f;
- if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) < 0 || format != f) {
- format = AFMT_U8;
- if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) < 0 || format != AFMT_U8) {
- fprintf(stderr, "SNDCTL_DSP_SETFMT: %s\n", format != AFMT_U8 ? "No supported sample format" : strerror(errno));
- goto fail;
- } else
- ss.format = SAMPLE_U8;
- } else
- ss.format = f == AFMT_S16_LE ? SAMPLE_S16LE : SAMPLE_S16BE;
- } else
- ss.format = SAMPLE_S16NE;
-
- channels = 2;
- if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) < 0) {
- fprintf(stderr, "SNDCTL_DSP_CHANNELS: %s\n", strerror(errno));
- goto fail;
- }
- assert(channels);
- ss.channels = channels;
-
- speed = 44100;
- if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) < 0) {
- fprintf(stderr, "SNDCTL_DSP_SPEED: %s\n", strerror(errno));
+ if (oss_auto_format(fd, &ss) < 0)
goto fail;
- }
- assert(speed);
- ss.rate = speed;
if (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &frag_size) < 0) {
fprintf(stderr, "SNDCTL_DSP_GETBLKSIZE: %s\n", strerror(errno));
if (mode != O_RDONLY) {
u->sink = sink_new(c, "dsp", &ss);
assert(u->sink);
+ u->sink->get_latency = sink_get_latency_cb;
+ u->sink->userdata = u;
} else
u->sink = NULL;
if (mode != O_WRONLY) {
u->source = source_new(c, "dsp", &ss);
assert(u->source);
+ u->source->userdata = u;
} else
u->source = NULL;
u->io = iochannel_new(c->mainloop, u->source ? fd : -1, u->sink ? fd : 0);
assert(u->io);
iochannel_set_callback(u->io, io_callback, u);
+ u->fd = fd;
u->memchunk.memblock = NULL;
u->memchunk.length = 0;
u->sample_size = sample_size(&ss);
+ u->sample_usec = 1000000/ss.rate;
u->out_fragment_size = out_frag_size;
u->in_fragment_size = in_frag_size;
u->silence.memblock = memblock_new(u->silence.length = u->out_fragment_size);
assert(u->silence.memblock);
- silence(u->silence.memblock, &ss);
+ silence_memblock(u->silence.memblock, &ss);
u->silence.index = 0;
m->userdata = u;
--- /dev/null
+#include <assert.h>
+#include <sys/soundcard.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include "oss.h"
+
+int oss_auto_format(int fd, struct sample_spec *ss) {
+ int format, channels, speed;
+
+ assert(fd >= 0 && ss);
+
+ format = AFMT_S16_NE;
+ if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) < 0 || format != AFMT_S16_NE) {
+ int f = AFMT_S16_NE == AFMT_S16_LE ? AFMT_S16_BE : AFMT_S16_LE;
+ format = f;
+ if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) < 0 || format != f) {
+ format = AFMT_U8;
+ if (ioctl(fd, SNDCTL_DSP_SETFMT, &format) < 0 || format != AFMT_U8) {
+ fprintf(stderr, "SNDCTL_DSP_SETFMT: %s\n", format != AFMT_U8 ? "No supported sample format" : strerror(errno));
+ return -1;
+ } else
+ ss->format = SAMPLE_U8;
+ } else
+ ss->format = f == AFMT_S16_LE ? SAMPLE_S16LE : SAMPLE_S16BE;
+ } else
+ ss->format = SAMPLE_S16NE;
+
+ channels = 2;
+ if (ioctl(fd, SNDCTL_DSP_CHANNELS, &channels) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_CHANNELS: %s\n", strerror(errno));
+ return -1;
+ }
+ assert(channels);
+ ss->channels = channels;
+
+ speed = 44100;
+ if (ioctl(fd, SNDCTL_DSP_SPEED, &speed) < 0) {
+ fprintf(stderr, "SNDCTL_DSP_SPEED: %s\n", strerror(errno));
+ return -1;
+ }
+ assert(speed);
+ ss->rate = speed;
+
+ return 0;
+}
--- /dev/null
+#ifndef fooosshfoo
+#define fooosshfoo
+
+#include "sample.h"
+
+int oss_auto_format(int fd, struct sample_spec *ss);
+
+#endif
static int do_read(struct connection *c) {
struct memchunk chunk;
ssize_t r;
+ uint32_t u1, u2;
if (!iochannel_is_readable(c->io))
return 0;
chunk.memblock = memblock_new(BUFSIZE);
assert(chunk.memblock);
- memblock_stamp(chunk.memblock);
-
if ((r = iochannel_read(c->io, chunk.memblock->data, BUFSIZE)) <= 0) {
fprintf(stderr, "read(): %s\n", r == 0 ? "EOF" : strerror(errno));
memblock_unref(chunk.memblock);
memblockq_push(c->input_memblockq, &chunk, 0);
memblock_unref(chunk.memblock);
sink_notify(c->sink_input->sink);
+
+
+ u1 = memblockq_get_latency(c->input_memblockq);
+ u2 = sink_get_latency(c->sink_input->sink);
+
+ fprintf(stderr, "latency: %u+%u=%u\r", u1, u2, u1+u2);
+
return 0;
}
return 0;
assert(c->output_memblockq);
- memblockq_peek(c->output_memblockq, &chunk);
+ if (memblockq_peek(c->output_memblockq, &chunk) < 0)
+ return 0;
+
assert(chunk.memblock && chunk.length);
if ((r = iochannel_write(c->io, chunk.memblock->data+chunk.index, chunk.length)) < 0) {
assert(o && c && chunk);
memblockq_push(c->output_memblockq, chunk, 0);
+
+ if (do_write(c) < 0)
+ destroy_connection(c);
}
static void source_output_kill_cb(struct source_output *o) {
c->source_output->kill = source_output_kill_cb;
c->source_output->userdata = c;
- l = 5*bytes_per_second(&DEFAULT_SAMPLE_SPEC);
+ l = 5*bytes_per_second(&DEFAULT_SAMPLE_SPEC); /* 5s */
c->output_memblockq = memblockq_new(l, sample_size(&DEFAULT_SAMPLE_SPEC), l/2);
}
c->sink_input->kill = sink_input_kill_cb;
c->sink_input->userdata = c;
- l = 5*bytes_per_second(&DEFAULT_SAMPLE_SPEC);
+ l = bytes_per_second(&DEFAULT_SAMPLE_SPEC)/2; /* half a second */
c->input_memblockq = memblockq_new(l, sample_size(&DEFAULT_SAMPLE_SPEC), l/2);
}
.channels = 2
};
-struct memblock *silence(struct memblock* b, struct sample_spec *spec) {
- char c = 0;
- assert(b && spec);
+struct memblock *silence_memblock(struct memblock* b, struct sample_spec *spec) {
+ assert(b && b->data && spec);
memblock_assert_exclusive(b);
+ silence_memory(b->data, b->length, spec);
+ return b;
+}
+
+void silence_memchunk(struct memchunk *c, struct sample_spec *spec) {
+ assert(c && c->memblock && c->memblock->data && spec && c->length);
+ memblock_assert_exclusive(c->memblock);
+ silence_memory(c->memblock->data+c->index, c->length, spec);
+}
+
+void silence_memory(void *p, size_t length, struct sample_spec *spec) {
+ char c = 0;
+ assert(p && length && spec);
switch (spec->format) {
case SAMPLE_U8:
break;
}
- memset(b->data, c, b->length);
- return b;
+ memset(p, c, length);
}
size_t sample_size(struct sample_spec *spec) {
extern struct sample_spec default_sample_spec;
-struct memblock *silence(struct memblock* b, struct sample_spec *spec);
-
+struct memblock *silence_memblock(struct memblock* b, struct sample_spec *spec);
+void silence_memchunk(struct memchunk *c, struct sample_spec *spec);
+void silence_memory(void *p, size_t length, struct sample_spec *spec);
struct mix_info {
struct memchunk chunk;
s->volume = 0xFF;
s->notify = NULL;
+ s->get_latency = NULL;
s->userdata = NULL;
r = idxset_put(core->sinks, s, &s->index);
}
inputs_drop(s, info, n, l);
+
+ assert(s->monitor_source);
+ source_post(s->monitor_source, result);
+
return 0;
}
-int sink_render_into(struct sink*s, struct memblock *target, struct memchunk *result) {
+int sink_render_into(struct sink*s, struct memchunk *target) {
struct mix_info info[MAX_MIX_CHANNELS];
unsigned n;
size_t l;
- assert(s && target && target->length && target->data && result);
+ assert(s && target && target->length && target->memblock && target->memblock->data);
n = fill_mix_info(s, info, MAX_MIX_CHANNELS);
if (l > info[0].chunk.length)
l = info[0].chunk.length;
- result->memblock = target;
- memcpy(target->data, info[0].chunk.memblock->data + info[0].chunk.index, l);
- result->length = target->length = l;
- result->index = 0;
- } else {
+ memcpy(target->memblock->data+target->index, info[0].chunk.memblock->data + info[0].chunk.index, l);
+ target->length = l;
+ } else
+ target->length = l = mix_chunks(info, n, target->memblock->data+target->index, target->length, &s->sample_spec, s->volume);
+
+ assert(l);
+ inputs_drop(s, info, n, l);
- result->memblock = target;
- result->length = l = mix_chunks(info, n, target->data, target->length, &s->sample_spec, s->volume);
- result->index = 0;
- assert(l);
- }
+ assert(s->monitor_source);
+ source_post(s->monitor_source, target);
- inputs_drop(s, info, n, l);
return 0;
}
+
+void sink_render_into_full(struct sink *s, struct memchunk *target) {
+ struct memchunk chunk;
+ size_t l, d;
+ assert(s && target && target->memblock && target->length && target->memblock->data);
+
+ l = target->length;
+ d = 0;
+ while (l > 0) {
+ chunk = *target;
+ chunk.index += d;
+ chunk.length -= d;
+
+ if (sink_render_into(s, &chunk) < 0)
+ break;
+
+ d += chunk.length;
+ l -= chunk.length;
+ }
+
+ if (l > 0) {
+ chunk = *target;
+ chunk.index += d;
+ chunk.length -= d;
+ silence_memchunk(&chunk, &s->sample_spec);
+ }
+}
+
+uint32_t sink_get_latency(struct sink *s) {
+ assert(s);
+
+ if (!s->get_latency)
+ return 0;
+
+ return s->get_latency(s);
+}
uint8_t volume;
void (*notify)(struct sink*sink);
+ uint32_t (*get_latency)(struct sink *s);
void *userdata;
};
void sink_free(struct sink* s);
int sink_render(struct sink*s, size_t length, struct memchunk *result);
-int sink_render_into(struct sink*s, struct memblock *target, struct memchunk *result);
+int sink_render_into(struct sink*s, struct memchunk *target);
+void sink_render_into_full(struct sink *s, struct memchunk *target);
+
+uint32_t sink_get_latency(struct sink *s);
void sink_notify(struct sink*s);
static int do_post(void *p, uint32_t index, int *del, void*userdata) {
struct memchunk *chunk = userdata;
struct source_output *o = p;
- assert(o && o->push && index && del && chunk);
+ assert(o && o->push && del && chunk);
o->push(o, chunk);
return 0;
-- mixing
-- latenzoptimierung
-- optimierung von rebuild_pollfds()
-- resampling
+- simple control protocol
- native protocol/library
-- oss/mmap
-- esound prodocol
+- resampling
+- esound protocol
- config-parser
+- record-testing
-- 0.1
+- optimierung von rebuild_pollfds()
- future cancellation
- client-ui
- portaudio
- mplayer
- python
+
+modules:
+- alsa?