mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-07 13:30:09 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

don't use generic events for real-time messages

Browse source 
Use static event enumerations for real-time messages.
This commit is contained in:
Wim Taymans 2017-08-07 18:07:38 +02:00
parent 97de0de0b7
commit b90dac7656
5 changed files with 131 additions and 146 deletions
Download patch file Download diff file Expand all files Collapse all files

44
src/modules/module-client-node/client-node.c
View file

@ -93,8 +93,6 @@ struct proxy {
struct spa_log *log;
struct spa_loop *data_loop;
struct pw_type_event_client_node type_event_client_node;
const struct spa_node_callbacks *callbacks;
void *callbacks_data;
@ -156,7 +154,7 @@ static inline void do_flush(struct proxy *this)
{
uint64_t cmd = 1;
if (write(this->writefd, &cmd, 8) != 8)
spa_log_warn(this->log, "proxy %p: error writing event: %s", this, strerror(errno));
spa_log_warn(this->log, "proxy %p: error flushing : %s", this, strerror(errno));
}
@ -721,9 +719,8 @@ spa_proxy_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32
spa_log_trace(this->log, "reuse buffer %d", buffer_id);
{
struct pw_event_client_node_reuse_buffer rb = PW_EVENT_CLIENT_NODE_REUSE_BUFFER_INIT
(this->type_event_client_node.ReuseBuffer, port_id, buffer_id);
pw_client_node_transport_add_event(impl->transport, (struct spa_event *) &rb);
struct pw_client_node_message_reuse_buffer rb = PW_CLIENT_NODE_MESSAGE_REUSE_BUFFER_INIT(port_id, buffer_id);
pw_client_node_transport_add_message(impl->transport, (struct pw_client_node_message *) &rb);
}
return SPA_RESULT_OK;
@ -768,8 +765,8 @@ static int spa_proxy_node_process_input(struct spa_node *node)
impl->transport->inputs[i] = *io;
io->status = SPA_RESULT_NEED_BUFFER;
}
pw_client_node_transport_add_event(impl->transport,
&SPA_EVENT_INIT(this->type_event_client_node.ProcessInput));
pw_client_node_transport_add_message(impl->transport,
&PW_CLIENT_NODE_MESSAGE_INIT(PW_CLIENT_NODE_MESSAGE_PROCESS_INPUT));
do_flush(this);
if (this->callbacks->need_input)
@ -802,19 +799,19 @@ static int spa_proxy_node_process_output(struct spa_node *node)
*io = tmp;
pw_log_trace("%d %d %d", io->status, io->buffer_id, io->status);
}
pw_client_node_transport_add_event(impl->transport,
&SPA_EVENT_INIT(this->type_event_client_node.ProcessOutput));
pw_client_node_transport_add_message(impl->transport,
&PW_CLIENT_NODE_MESSAGE_INIT(PW_CLIENT_NODE_MESSAGE_PROCESS_OUTPUT));
do_flush(this);
return res;
}
static int handle_node_event(struct proxy *this, struct spa_event *event)
static int handle_node_message(struct proxy *this, struct pw_client_node_message *message)
{
struct impl *impl = SPA_CONTAINER_OF(this, struct impl, proxy);
int i;
if (SPA_EVENT_TYPE(event) == this->type_event_client_node.HaveOutput) {
if (PW_CLIENT_NODE_MESSAGE_TYPE(message) == PW_CLIENT_NODE_MESSAGE_HAVE_OUTPUT) {
for (i = 0; i < MAX_OUTPUTS; i++) {
struct spa_port_io *io = this->out_ports[i].io;
@ -825,11 +822,11 @@ static int handle_node_event(struct proxy *this, struct spa_event *event)
pw_log_trace("%d %d", io->status, io->buffer_id);
}
this->callbacks->have_output(this->callbacks_data);
} else if (SPA_EVENT_TYPE(event) == this->type_event_client_node.NeedInput) {
} else if (PW_CLIENT_NODE_MESSAGE_TYPE(message) == PW_CLIENT_NODE_MESSAGE_NEED_INPUT) {
this->callbacks->need_input(this->callbacks_data);
} else if (SPA_EVENT_TYPE(event) == this->type_event_client_node.ReuseBuffer) {
struct pw_event_client_node_reuse_buffer *p =
(struct pw_event_client_node_reuse_buffer *) event;
} else if (PW_CLIENT_NODE_MESSAGE_TYPE(message) == PW_CLIENT_NODE_MESSAGE_REUSE_BUFFER) {
struct pw_client_node_message_reuse_buffer *p =
(struct pw_client_node_message_reuse_buffer *) message;
this->callbacks->reuse_buffer(this->callbacks_data, p->body.port_id.value,
p->body.buffer_id.value);
}
@ -930,18 +927,17 @@ static void proxy_on_data_fd_events(struct spa_source *source)
}
if (source->rmask & SPA_IO_IN) {
struct spa_event event;
struct pw_client_node_message message;
uint64_t cmd;
if (read(this->data_source.fd, &cmd, 8) != 8)
spa_log_warn(this->log, "proxy %p: error reading event: %s",
spa_log_warn(this->log, "proxy %p: error reading message: %s",
this, strerror(errno));
while (pw_client_node_transport_next_event(impl->transport, &event) == SPA_RESULT_OK) {
struct spa_event *ev = alloca(SPA_POD_SIZE(&event));
pw_client_node_transport_parse_event(impl->transport, ev);
pw_pod_remap(&ev->pod, &this->resource->client->types);;
handle_node_event(this, ev);
while (pw_client_node_transport_next_message(impl->transport, &message) == SPA_RESULT_OK) {
struct pw_client_node_message *msg = alloca(SPA_POD_SIZE(&message));
pw_client_node_transport_parse_message(impl->transport, msg);
handle_node_message(this, msg);
}
}
}
@ -999,8 +995,6 @@ proxy_init(struct proxy *this,
this->node = proxy_node;
pw_type_event_client_node_map(this->map, &this->type_event_client_node);
this->data_source.func = proxy_on_data_fd_events;
this->data_source.data = this;
this->data_source.fd = -1;

38
src/modules/module-client-node/transport.c
View file

@ -37,7 +37,7 @@ struct transport {
struct pw_memblock mem;
size_t offset;
struct spa_event current;
struct pw_client_node_message current;
uint32_t current_index;
};
/** \endcond */
@ -98,64 +98,64 @@ static void transport_reset_area(struct pw_client_node_transport *trans)
spa_ringbuffer_init(trans->output_buffer, OUTPUT_BUFFER_SIZE);
}
static int add_event(struct pw_client_node_transport *trans, struct spa_event *event)
static int add_message(struct pw_client_node_transport *trans, struct pw_client_node_message *message)
{
struct transport *impl = (struct transport *) trans;
int32_t filled, avail;
uint32_t size, index;
if (impl == NULL || event == NULL)
if (impl == NULL || message == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
filled = spa_ringbuffer_get_write_index(trans->output_buffer, &index);
avail = trans->output_buffer->size - filled;
size = SPA_POD_SIZE(event);
size = SPA_POD_SIZE(message);
if (avail < size)
return SPA_RESULT_ERROR;
spa_ringbuffer_write_data(trans->output_buffer,
trans->output_data,
index & trans->output_buffer->mask, event, size);
index & trans->output_buffer->mask, message, size);
spa_ringbuffer_write_update(trans->output_buffer, index + size);
return SPA_RESULT_OK;
}
static int next_event(struct pw_client_node_transport *trans, struct spa_event *event)
static int next_message(struct pw_client_node_transport *trans, struct pw_client_node_message *message)
{
struct transport *impl = (struct transport *) trans;
int32_t avail;
if (impl == NULL || event == NULL)
if (impl == NULL || message == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
avail = spa_ringbuffer_get_read_index(trans->input_buffer, &impl->current_index);
if (avail < sizeof(struct spa_event))
if (avail < sizeof(struct pw_client_node_message))
return SPA_RESULT_ENUM_END;
spa_ringbuffer_read_data(trans->input_buffer,
trans->input_data,
impl->current_index & trans->input_buffer->mask,
&impl->current, sizeof(struct spa_event));
&impl->current, sizeof(struct pw_client_node_message));
*event = impl->current;
*message = impl->current;
return SPA_RESULT_OK;
}
static int parse_event(struct pw_client_node_transport *trans, void *event)
static int parse_message(struct pw_client_node_transport *trans, void *message)
{
struct transport *impl = (struct transport *) trans;
uint32_t size;
if (impl == NULL || event == NULL)
if (impl == NULL || message == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
size = SPA_POD_SIZE(&impl->current);
spa_ringbuffer_read_data(trans->input_buffer,
trans->input_data,
impl->current_index & trans->input_buffer->mask, event, size);
impl->current_index & trans->input_buffer->mask, message, size);
spa_ringbuffer_read_update(trans->input_buffer, impl->current_index + size);
return SPA_RESULT_OK;
@ -194,9 +194,9 @@ pw_client_node_transport_new(uint32_t max_input_ports, uint32_t max_output_ports
transport_setup_area(impl->mem.ptr, trans);
transport_reset_area(trans);
trans->add_event = add_event;
trans->next_event = next_event;
trans->parse_event = parse_event;
trans->add_message = add_message;
trans->next_message = next_message;
trans->parse_message = parse_message;
return trans;
}
@ -236,9 +236,9 @@ pw_client_node_transport_new_from_info(struct pw_client_node_transport_info *inf
trans->output_data = trans->input_data;
trans->input_data = tmp;
trans->add_event = add_event;
trans->next_event = next_event;
trans->parse_event = parse_event;
trans->add_message = add_message;
trans->next_message = next_message;
trans->parse_message = parse_message;
return trans;