From e61c2dddb7bc392ab4073d5691870615ada82922 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Sat, 3 Jul 2004 23:35:12 +0000 Subject: add pa_ prefix to all identifiers. fix downsampling/resampling add support for U8 samples git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@49 fefdeb5f-60dc-0310-8127-8f9354f1896f --- src/protocol-simple.c | 152 +++++++++++++++++++++++++------------------------- 1 file changed, 76 insertions(+), 76 deletions(-) (limited to 'src/protocol-simple.c') diff --git a/src/protocol-simple.c b/src/protocol-simple.c index a7f3eb7e..380b1802 100644 --- a/src/protocol-simple.c +++ b/src/protocol-simple.c @@ -12,19 +12,19 @@ #include "sample-util.h" struct connection { - struct protocol_simple *protocol; - struct iochannel *io; - struct sink_input *sink_input; - struct source_output *source_output; - struct client *client; - struct memblockq *input_memblockq, *output_memblockq; + struct pa_protocol_simple *protocol; + struct pa_iochannel *io; + struct pa_sink_input *sink_input; + struct pa_source_output *source_output; + struct pa_client *client; + struct pa_memblockq *input_memblockq, *output_memblockq; }; -struct protocol_simple { - struct core *core; - struct socket_server*server; - struct idxset *connections; - enum protocol_simple_mode mode; +struct pa_protocol_simple { + struct pa_core *core; + struct pa_socket_server*server; + struct pa_idxset *connections; + enum pa_protocol_simple_mode mode; struct pa_sample_spec sample_spec; }; @@ -33,38 +33,38 @@ struct protocol_simple { static void connection_free(struct connection *c) { assert(c); - idxset_remove_by_data(c->protocol->connections, c, NULL); + pa_idxset_remove_by_data(c->protocol->connections, c, NULL); if (c->sink_input) - sink_input_free(c->sink_input); + pa_sink_input_free(c->sink_input); if (c->source_output) - source_output_free(c->source_output); + pa_source_output_free(c->source_output); if (c->client) - client_free(c->client); + pa_client_free(c->client); if (c->io) - iochannel_free(c->io); + pa_iochannel_free(c->io); if (c->input_memblockq) - memblockq_free(c->input_memblockq); + pa_memblockq_free(c->input_memblockq); if (c->output_memblockq) - memblockq_free(c->output_memblockq); + pa_memblockq_free(c->output_memblockq); free(c); } static int do_read(struct connection *c) { - struct memchunk chunk; + struct pa_memchunk chunk; ssize_t r; - if (!iochannel_is_readable(c->io)) + if (!pa_iochannel_is_readable(c->io)) return 0; - if (!c->sink_input || !memblockq_is_writable(c->input_memblockq, BUFSIZE)) + if (!c->sink_input || !pa_memblockq_is_writable(c->input_memblockq, BUFSIZE)) return 0; - chunk.memblock = memblock_new(BUFSIZE); + chunk.memblock = pa_memblock_new(BUFSIZE); assert(chunk.memblock); - if ((r = iochannel_read(c->io, chunk.memblock->data, BUFSIZE)) <= 0) { + if ((r = pa_iochannel_read(c->io, chunk.memblock->data, BUFSIZE)) <= 0) { fprintf(stderr, "read(): %s\n", r == 0 ? "EOF" : strerror(errno)); - memblock_unref(chunk.memblock); + pa_memblock_unref(chunk.memblock); return -1; } @@ -72,103 +72,103 @@ static int do_read(struct connection *c) { chunk.index = 0; assert(c->input_memblockq); - memblockq_push_align(c->input_memblockq, &chunk, 0); - memblock_unref(chunk.memblock); + pa_memblockq_push_align(c->input_memblockq, &chunk, 0); + pa_memblock_unref(chunk.memblock); assert(c->sink_input); - sink_notify(c->sink_input->sink); + pa_sink_notify(c->sink_input->sink); return 0; } static int do_write(struct connection *c) { - struct memchunk chunk; + struct pa_memchunk chunk; ssize_t r; - if (!iochannel_is_writable(c->io)) + if (!pa_iochannel_is_writable(c->io)) return 0; if (!c->source_output) return 0; assert(c->output_memblockq); - if (memblockq_peek(c->output_memblockq, &chunk) < 0) + if (pa_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) { + if ((r = pa_iochannel_write(c->io, chunk.memblock->data+chunk.index, chunk.length)) < 0) { fprintf(stderr, "write(): %s\n", strerror(errno)); - memblock_unref(chunk.memblock); + pa_memblock_unref(chunk.memblock); return -1; } - memblockq_drop(c->output_memblockq, r); - memblock_unref(chunk.memblock); + pa_memblockq_drop(c->output_memblockq, r); + pa_memblock_unref(chunk.memblock); return 0; } /*** sink_input callbacks ***/ -static int sink_input_peek_cb(struct sink_input *i, struct memchunk *chunk) { +static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk) { struct connection*c; assert(i && i->userdata && chunk); c = i->userdata; - if (memblockq_peek(c->input_memblockq, chunk) < 0) + if (pa_memblockq_peek(c->input_memblockq, chunk) < 0) return -1; return 0; } -static void sink_input_drop_cb(struct sink_input *i, size_t length) { +static void sink_input_drop_cb(struct pa_sink_input *i, size_t length) { struct connection*c = i->userdata; assert(i && c && length); - memblockq_drop(c->input_memblockq, length); + pa_memblockq_drop(c->input_memblockq, length); if (do_read(c) < 0) connection_free(c); } -static void sink_input_kill_cb(struct sink_input *i) { +static void sink_input_kill_cb(struct pa_sink_input *i) { assert(i && i->userdata); connection_free((struct connection *) i->userdata); } -static uint32_t sink_input_get_latency_cb(struct sink_input *i) { +static uint32_t sink_input_get_latency_cb(struct pa_sink_input *i) { struct connection*c = i->userdata; assert(i && c); - return pa_samples_usec(memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec); + return pa_samples_usec(pa_memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec); } /*** source_output callbacks ***/ -static void source_output_push_cb(struct source_output *o, const struct memchunk *chunk) { +static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk) { struct connection *c = o->userdata; assert(o && c && chunk); - memblockq_push(c->output_memblockq, chunk, 0); + pa_memblockq_push(c->output_memblockq, chunk, 0); if (do_write(c) < 0) connection_free(c); } -static void source_output_kill_cb(struct source_output *o) { +static void source_output_kill_cb(struct pa_source_output *o) { assert(o && o->userdata); connection_free((struct connection *) o->userdata); } /*** client callbacks ***/ -static void client_kill_cb(struct client *c) { +static void client_kill_cb(struct pa_client *c) { assert(c && c->userdata); connection_free((struct connection *) c->userdata); } -/*** iochannel callbacks ***/ +/*** pa_iochannel callbacks ***/ -static void io_callback(struct iochannel*io, void *userdata) { +static void io_callback(struct pa_iochannel*io, void *userdata) { struct connection *c = userdata; assert(io && c && c->io == io); @@ -178,8 +178,8 @@ static void io_callback(struct iochannel*io, void *userdata) { /*** socket_server callbacks */ -static void on_connection(struct socket_server*s, struct iochannel *io, void *userdata) { - struct protocol_simple *p = userdata; +static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) { + struct pa_protocol_simple *p = userdata; struct connection *c = NULL; char cname[256]; assert(s && io && p); @@ -192,41 +192,41 @@ static void on_connection(struct socket_server*s, struct iochannel *io, void *us c->input_memblockq = c->output_memblockq = NULL; c->protocol = p; - iochannel_peer_to_string(io, cname, sizeof(cname)); - c->client = client_new(p->core, "SIMPLE", cname); + pa_iochannel_peer_to_string(io, cname, sizeof(cname)); + c->client = pa_client_new(p->core, "SIMPLE", cname); assert(c->client); c->client->kill = client_kill_cb; c->client->userdata = c; - if (p->mode & PROTOCOL_SIMPLE_RECORD) { - struct source *source; + if (p->mode & PA_PROTOCOL_SIMPLE_RECORD) { + struct pa_source *source; size_t l; - if (!(source = source_get_default(p->core))) { + if (!(source = pa_source_get_default(p->core))) { fprintf(stderr, "Failed to get default source.\n"); goto fail; } - c->source_output = source_output_new(source, c->client->name, &p->sample_spec); + c->source_output = pa_source_output_new(source, c->client->name, &p->sample_spec); assert(c->source_output); c->source_output->push = source_output_push_cb; c->source_output->kill = source_output_kill_cb; c->source_output->userdata = c; - l = 5*pa_bytes_per_second(&DEFAULT_SAMPLE_SPEC); /* 5s */ - c->output_memblockq = memblockq_new(l, pa_sample_size(&p->sample_spec), l/2); + l = 5*pa_bytes_per_second(&p->sample_spec); /* 5s */ + c->output_memblockq = pa_memblockq_new(l, pa_sample_size(&p->sample_spec), l/2); } - if (p->mode & PROTOCOL_SIMPLE_PLAYBACK) { - struct sink *sink; + if (p->mode & PA_PROTOCOL_SIMPLE_PLAYBACK) { + struct pa_sink *sink; size_t l; - if (!(sink = sink_get_default(p->core))) { + if (!(sink = pa_sink_get_default(p->core))) { fprintf(stderr, "Failed to get default sink.\n"); goto fail; } - c->sink_input = sink_input_new(sink, c->client->name, &p->sample_spec); + c->sink_input = pa_sink_input_new(sink, c->client->name, &p->sample_spec); assert(c->sink_input); c->sink_input->peek = sink_input_peek_cb; c->sink_input->drop = sink_input_drop_cb; @@ -234,13 +234,13 @@ static void on_connection(struct socket_server*s, struct iochannel *io, void *us c->sink_input->get_latency = sink_input_get_latency_cb; c->sink_input->userdata = c; - l = pa_bytes_per_second(&DEFAULT_SAMPLE_SPEC)/2; /* half a second */ - c->input_memblockq = memblockq_new(l, pa_sample_size(&p->sample_spec), l/2); + l = pa_bytes_per_second(&p->sample_spec)/2; /* half a second */ + c->input_memblockq = pa_memblockq_new(l, pa_sample_size(&p->sample_spec), l/2); } - iochannel_set_callback(c->io, io_callback, c); - idxset_put(p->connections, c, NULL); + pa_iochannel_set_callback(c->io, io_callback, c); + pa_idxset_put(p->connections, c, NULL); return; fail: @@ -248,34 +248,34 @@ fail: connection_free(c); } -struct protocol_simple* protocol_simple_new(struct core *core, struct socket_server *server, enum protocol_simple_mode mode) { - struct protocol_simple* p; - assert(core && server && mode <= PROTOCOL_SIMPLE_DUPLEX && mode > 0); +struct pa_protocol_simple* pa_protocol_simple_new(struct pa_core *core, struct pa_socket_server *server, enum pa_protocol_simple_mode mode) { + struct pa_protocol_simple* p; + assert(core && server && mode <= PA_PROTOCOL_SIMPLE_DUPLEX && mode > 0); - p = malloc(sizeof(struct protocol_simple)); + p = malloc(sizeof(struct pa_protocol_simple)); assert(p); p->core = core; p->server = server; - p->connections = idxset_new(NULL, NULL); + p->connections = pa_idxset_new(NULL, NULL); p->mode = mode; - p->sample_spec = DEFAULT_SAMPLE_SPEC; + p->sample_spec = PA_DEFAULT_SAMPLE_SPEC; - socket_server_set_callback(p->server, on_connection, p); + pa_socket_server_set_callback(p->server, on_connection, p); return p; } -void protocol_simple_free(struct protocol_simple *p) { +void pa_protocol_simple_free(struct pa_protocol_simple *p) { struct connection *c; assert(p); - while((c = idxset_first(p->connections, NULL))) + while((c = pa_idxset_first(p->connections, NULL))) connection_free(c); - idxset_free(p->connections, NULL, NULL); + pa_idxset_free(p->connections, NULL, NULL); - socket_server_free(p->server); + pa_socket_server_free(p->server); free(p); } -- cgit