This file is part of polypaudio.
polypaudio is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
+ it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU Lesser General Public License
along with polypaudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
#include "client.h"
#include "sample-util.h"
#include "namereg.h"
+#include "xmalloc.h"
+#include "log.h"
struct connection {
struct pa_protocol_simple *protocol;
struct pa_source_output *source_output;
struct pa_client *client;
struct pa_memblockq *input_memblockq, *output_memblockq;
- void *fixed_source;
+ struct pa_defer_event *defer_event;
struct {
struct pa_memblock *current_memblock;
DUPLEX = 3
} mode;
struct pa_sample_spec sample_spec;
- uint32_t sink_index, source_index;
+ char *source_name, *sink_name;
};
#define PLAYBACK_BUFFER_SECONDS (.5)
if (c->playback.current_memblock)
pa_memblock_unref(c->playback.current_memblock);
- if (c->sink_input)
- pa_sink_input_free(c->sink_input);
- if (c->source_output)
- pa_source_output_free(c->source_output);
+ if (c->sink_input) {
+ pa_sink_input_disconnect(c->sink_input);
+ pa_sink_input_unref(c->sink_input);
+ }
+ if (c->source_output) {
+ pa_source_output_disconnect(c->source_output);
+ pa_source_output_unref(c->source_output);
+ }
if (c->client)
pa_client_free(c->client);
if (c->io)
pa_memblockq_free(c->input_memblockq);
if (c->output_memblockq)
pa_memblockq_free(c->output_memblockq);
- if (c->fixed_source)
- c->protocol->core->mainloop->cancel_fixed(c->protocol->core->mainloop, c->fixed_source);
- free(c);
+ if (c->defer_event)
+ c->protocol->core->mainloop->defer_free(c->defer_event);
+ pa_xfree(c);
}
static int do_read(struct connection *c) {
}
if (!c->playback.current_memblock) {
- c->playback.current_memblock = pa_memblock_new(c->playback.fragment_size*2);
+ c->playback.current_memblock = pa_memblock_new(c->playback.fragment_size*2, c->protocol->core->memblock_stat);
assert(c->playback.current_memblock && c->playback.current_memblock->length >= l);
c->playback.memblock_index = 0;
}
- if ((r = pa_iochannel_read(c->io, c->playback.current_memblock->data+c->playback.memblock_index, l)) <= 0) {
- fprintf(stderr, __FILE__": read() failed: %s\n", r == 0 ? "EOF" : strerror(errno));
+ if ((r = pa_iochannel_read(c->io, (uint8_t*) c->playback.current_memblock->data+c->playback.memblock_index, l)) <= 0) {
+ pa_log(__FILE__": read() failed: %s\n", r == 0 ? "EOF" : strerror(errno));
return -1;
}
assert(chunk.memblock && chunk.length);
- if ((r = pa_iochannel_write(c->io, chunk.memblock->data+chunk.index, chunk.length)) < 0) {
+ if ((r = pa_iochannel_write(c->io, (uint8_t*) chunk.memblock->data+chunk.index, chunk.length)) < 0) {
pa_memblock_unref(chunk.memblock);
- fprintf(stderr, "write(): %s\n", strerror(errno));
+ pa_log(__FILE__": write(): %s\n", strerror(errno));
return -1;
}
- pa_memblockq_drop(c->output_memblockq, r);
+ pa_memblockq_drop(c->output_memblockq, &chunk, r);
pa_memblock_unref(chunk.memblock);
return 0;
static void do_work(struct connection *c) {
assert(c);
- assert(c->protocol && c->protocol->core && c->protocol->core->mainloop && c->protocol->core->mainloop->enable_fixed);
- c->protocol->core->mainloop->enable_fixed(c->protocol->core->mainloop, c->fixed_source, 0);
+ assert(c->protocol && c->protocol->core && c->protocol->core->mainloop && c->protocol->core->mainloop->defer_enable);
+ c->protocol->core->mainloop->defer_enable(c->defer_event, 0);
if (pa_iochannel_is_hungup(c->io))
goto fail;
return 0;
}
-static void sink_input_drop_cb(struct pa_sink_input *i, size_t length) {
+static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
struct connection*c = i->userdata;
assert(i && c && length);
- pa_memblockq_drop(c->input_memblockq, length);
+ pa_memblockq_drop(c->input_memblockq, chunk, length);
/* do something */
- assert(c->protocol && c->protocol->core && c->protocol->core->mainloop && c->protocol->core->mainloop->enable_fixed);
- c->protocol->core->mainloop->enable_fixed(c->protocol->core->mainloop, c->fixed_source, 1);
+ assert(c->protocol && c->protocol->core && c->protocol->core->mainloop && c->protocol->core->mainloop->defer_enable);
+ c->protocol->core->mainloop->defer_enable(c->defer_event, 1);
}
static void sink_input_kill_cb(struct pa_sink_input *i) {
}
-static uint32_t sink_input_get_latency_cb(struct pa_sink_input *i) {
+static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i) {
struct connection*c = i->userdata;
assert(i && c);
return pa_bytes_to_usec(pa_memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec);
pa_memblockq_push(c->output_memblockq, chunk, 0);
/* do something */
- assert(c->protocol && c->protocol->core && c->protocol->core->mainloop && c->protocol->core->mainloop->enable_fixed);
- c->protocol->core->mainloop->enable_fixed(c->protocol->core->mainloop, c->fixed_source, 1);
+ assert(c->protocol && c->protocol->core && c->protocol->core->mainloop && c->protocol->core->mainloop->defer_enable);
+ c->protocol->core->mainloop->defer_enable(c->defer_event, 1);
}
static void source_output_kill_cb(struct pa_source_output *o) {
connection_free((struct connection *) o->userdata);
}
+static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o) {
+ struct connection*c = o->userdata;
+ assert(o && c);
+ return pa_bytes_to_usec(pa_memblockq_get_length(c->output_memblockq), &c->source_output->sample_spec);
+}
+
/*** client callbacks ***/
static void client_kill_cb(struct pa_client *c) {
/*** fixed callback ***/
-static void fixed_callback(struct pa_mainloop_api*a, void *id, void *userdata) {
+static void defer_callback(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata) {
struct connection *c = userdata;
- assert(a && c && c->fixed_source == id);
+ assert(a && c && c->defer_event == e);
do_work(c);
}
char cname[256];
assert(s && io && p);
- c = malloc(sizeof(struct connection));
- assert(c);
+ c = pa_xmalloc(sizeof(struct connection));
c->io = io;
c->sink_input = NULL;
c->source_output = NULL;
- c->fixed_source = NULL;
+ c->defer_event = NULL;
c->input_memblockq = c->output_memblockq = NULL;
c->protocol = p;
c->playback.current_memblock = NULL;
struct pa_sink *sink;
size_t l;
- if (!(sink = pa_idxset_get_by_index(p->core->sinks, p->sink_index)))
- if (!(sink = pa_sink_get_default(p->core))) {
- fprintf(stderr, "Failed to get sink.\n");
- goto fail;
- }
+ if (!(sink = pa_namereg_get(p->core, p->sink_name, PA_NAMEREG_SINK, 1))) {
+ pa_log(__FILE__": Failed to get sink.\n");
+ goto fail;
+ }
- c->sink_input = pa_sink_input_new(sink, c->client->name, &p->sample_spec);
- if (!c->sink_input) {
- fprintf(stderr, "Failed to create sink input.\n");
+ if (!(c->sink_input = pa_sink_input_new(sink, c->client->name, &p->sample_spec, 0, -1))) {
+ pa_log(__FILE__": Failed to create sink input.\n");
goto fail;
}
+
c->sink_input->owner = p->module;
c->sink_input->client = c->client;
c->sink_input->userdata = c;
l = (size_t) (pa_bytes_per_second(&p->sample_spec)*PLAYBACK_BUFFER_SECONDS);
- c->input_memblockq = pa_memblockq_new(l, 0, pa_frame_size(&p->sample_spec), l/2, l/PLAYBACK_BUFFER_FRAGMENTS);
+ c->input_memblockq = pa_memblockq_new(l, 0, pa_frame_size(&p->sample_spec), l/2, l/PLAYBACK_BUFFER_FRAGMENTS, p->core->memblock_stat);
assert(c->input_memblockq);
pa_iochannel_socket_set_rcvbuf(io, l/PLAYBACK_BUFFER_FRAGMENTS*5);
c->playback.fragment_size = l/10;
struct pa_source *source;
size_t l;
- if (!(source = pa_idxset_get_by_index(p->core->sources, p->source_index)))
- if (!(source = pa_source_get_default(p->core))) {
- fprintf(stderr, "Failed to get source.\n");
- goto fail;
- }
+ if (!(source = pa_namereg_get(p->core, p->source_name, PA_NAMEREG_SOURCE, 1))) {
+ pa_log(__FILE__": Failed to get source.\n");
+ goto fail;
+ }
- c->source_output = pa_source_output_new(source, c->client->name, &p->sample_spec);
+ c->source_output = pa_source_output_new(source, c->client->name, &p->sample_spec, -1);
if (!c->source_output) {
- fprintf(stderr, "Failed to create source output.\n");
+ pa_log(__FILE__": Failed to create source output.\n");
goto fail;
}
c->source_output->owner = p->module;
c->source_output->push = source_output_push_cb;
c->source_output->kill = source_output_kill_cb;
+ c->source_output->get_latency = source_output_get_latency_cb;
c->source_output->userdata = c;
l = (size_t) (pa_bytes_per_second(&p->sample_spec)*RECORD_BUFFER_SECONDS);
- c->output_memblockq = pa_memblockq_new(l, 0, pa_frame_size(&p->sample_spec), 0, 0);
+ c->output_memblockq = pa_memblockq_new(l, 0, pa_frame_size(&p->sample_spec), 0, 0, p->core->memblock_stat);
pa_iochannel_socket_set_sndbuf(io, l/RECORD_BUFFER_FRAGMENTS*2);
}
pa_iochannel_set_callback(c->io, io_callback, c);
pa_idxset_put(p->connections, c, NULL);
- c->fixed_source = p->core->mainloop->source_fixed(p->core->mainloop, fixed_callback, c);
- assert(c->fixed_source);
- p->core->mainloop->enable_fixed(p->core->mainloop, c->fixed_source, 0);
+ c->defer_event = p->core->mainloop->defer_new(p->core->mainloop, defer_callback, c);
+ assert(c->defer_event);
+ p->core->mainloop->defer_enable(c->defer_event, 0);
return;
struct pa_protocol_simple* pa_protocol_simple_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) {
struct pa_protocol_simple* p = NULL;
- uint32_t enable;
+ int enable;
assert(core && server && ma);
- p = malloc(sizeof(struct pa_protocol_simple));
- assert(p);
- memset(p, 0, sizeof(struct pa_protocol_simple));
-
+ p = pa_xmalloc0(sizeof(struct pa_protocol_simple));
p->module = m;
p->core = core;
p->server = server;
p->sample_spec = core->default_sample_spec;
if (pa_modargs_get_sample_spec(ma, &p->sample_spec) < 0) {
- fprintf(stderr, "Failed to parse sample type specification.\n");
- goto fail;
- }
-
- if (pa_modargs_get_source_index(ma, core, &p->source_index) < 0) {
- fprintf(stderr, __FILE__": source does not exist.\n");
+ pa_log(__FILE__": Failed to parse sample type specification.\n");
goto fail;
}
- if (pa_modargs_get_sink_index(ma, core, &p->sink_index) < 0) {
- fprintf(stderr, __FILE__": sink does not exist.\n");
- goto fail;
- }
+ p->source_name = pa_xstrdup(pa_modargs_get_value(ma, "source", NULL));
+ p->sink_name = pa_xstrdup(pa_modargs_get_value(ma, "sink", NULL));
enable = 0;
- if (pa_modargs_get_value_u32(ma, "record", &enable) < 0) {
- fprintf(stderr, __FILE__": record= expects a numeric argument.\n");
+ if (pa_modargs_get_value_boolean(ma, "record", &enable) < 0) {
+ pa_log(__FILE__": record= expects a numeric argument.\n");
goto fail;
}
p->mode = enable ? RECORD : 0;
enable = 1;
- if (pa_modargs_get_value_u32(ma, "playback", &enable) < 0) {
- fprintf(stderr, __FILE__": playback= expects a numeric argument.\n");
+ if (pa_modargs_get_value_boolean(ma, "playback", &enable) < 0) {
+ pa_log(__FILE__": playback= expects a numeric argument.\n");
goto fail;
}
p->mode |= enable ? PLAYBACK : 0;
if ((p->mode & (RECORD|PLAYBACK)) == 0) {
- fprintf(stderr, __FILE__": neither playback nor recording enabled for protocol.\n");
+ pa_log(__FILE__": neither playback nor recording enabled for protocol.\n");
goto fail;
}
}
if (p->server)
- pa_socket_server_free(p->server);
- free(p);
+ pa_socket_server_unref(p->server);
+ pa_xfree(p);
}