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

pod-builder: make more generic builder

Browse source 
Make a vararg based builder that produces much smaller code.
Catch demarshal errors.
Simplify array handling
This commit is contained in:
Wim Taymans 2017-03-07 17:23:35 +01:00
parent f92b68c3c3
commit 78a3cd61b8
9 changed files with 862 additions and 637 deletions
Download patch file Download diff file Expand all files Collapse all files

7
pinos/client/context.c
View file

@ -402,9 +402,10 @@ on_context_data (SpaSource *source,
pinos_log_debug ("context %p: object demarshal %u, %u", this, id, opcode);
demarshal = proxy->demarshal;
if (demarshal[opcode])
demarshal[opcode] (proxy, message, size);
else
if (demarshal[opcode]) {
if (!demarshal[opcode] (proxy, message, size))
pinos_log_error ("context %p: invalid message received", this);
} else
pinos_log_error ("context %p: function %d not implemented", this, opcode);
}

569
pinos/client/protocol-native.c
View file

@ -47,7 +47,7 @@ write_pod (SpaPODBuilder *b, uint32_t ref, const void *data, uint32_t size)
static void
core_marshal_client_update (void *object,
const SpaDict *props)
const SpaDict *props)
{
PinosProxy *proxy = object;
PinosConnection *connection = proxy->context->protocol_private;
@ -55,78 +55,93 @@ core_marshal_client_update (void *object,
SpaPODFrame f;
int i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
n_items = props ? props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, props->items[i].key);
spa_pod_builder_string (&b.b, props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, props->items[i].key,
SPA_POD_TYPE_STRING, props->items[i].value,
0);
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, proxy->id, 0, b.b.offset);
}
static void
core_marshal_sync (void *object,
uint32_t seq)
uint32_t seq)
{
PinosProxy *proxy = object;
PinosConnection *connection = proxy->context->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
-SPA_POD_TYPE_STRUCT, &f,
0);
pinos_connection_end_write (connection, proxy->id, 1, b.b.offset);
}
static void
core_marshal_get_registry (void *object,
uint32_t seq,
uint32_t new_id)
uint32_t seq,
uint32_t new_id)
{
PinosProxy *proxy = object;
PinosConnection *connection = proxy->context->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, new_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, new_id,
-SPA_POD_TYPE_STRUCT, &f,
0);
pinos_connection_end_write (connection, proxy->id, 2, b.b.offset);
}
static void
core_marshal_create_node (void *object,
uint32_t seq,
const char *factory_name,
const char *name,
const SpaDict *props,
uint32_t new_id)
uint32_t seq,
const char *factory_name,
const char *name,
const SpaDict *props,
uint32_t new_id)
{
PinosProxy *proxy = object;
PinosConnection *connection = proxy->context->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, n_items;
uint32_t i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_string (&b.b, factory_name);
spa_pod_builder_string (&b.b, name);
n_items = props ? props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_STRING, factory_name,
SPA_POD_TYPE_STRING, name,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, props->items[i].key);
spa_pod_builder_string (&b.b, props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, props->items[i].key,
SPA_POD_TYPE_STRING, props->items[i].value,
0);
}
spa_pod_builder_int (&b.b, new_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, new_id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, proxy->id, 3, b.b.offset);
}
@ -142,24 +157,30 @@ core_marshal_create_client_node (void *object,
PinosConnection *connection = proxy->context->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, n_items;
uint32_t i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_string (&b.b, name);
n_items = props ? props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_STRING, name,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, props->items[i].key);
spa_pod_builder_string (&b.b, props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, props->items[i].key,
SPA_POD_TYPE_STRING, props->items[i].value,
0);
}
spa_pod_builder_int (&b.b, new_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, new_id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, proxy->id, 4, b.b.offset);
}
static void
static bool
core_demarshal_info (void *object,
void *data,
size_t size)
@ -181,7 +202,7 @@ core_demarshal_info (void *object,
SPA_POD_TYPE_INT, &info.cookie,
SPA_POD_TYPE_INT, &props.n_items,
0))
return;
return false;
info.props = &props;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
@ -190,12 +211,13 @@ core_demarshal_info (void *object,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return;
return false;
}
pinos_core_notify_info (proxy, &info);
return true;
}
static void
static bool
core_demarshal_done (void *object,
void *data,
size_t size)
@ -208,12 +230,13 @@ core_demarshal_done (void *object,
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
0))
return;
return false;
pinos_core_notify_done (proxy, seq);
return true;
}
static void
static bool
core_demarshal_error (void *object,
void *data,
size_t size)
@ -229,12 +252,13 @@ core_demarshal_error (void *object,
SPA_POD_TYPE_INT, &res,
SPA_POD_TYPE_STRING, &error,
0))
return;
return false;
pinos_core_notify_error (proxy, id, res, error);
return true;
}
static void
static bool
core_demarshal_remove_id (void *object,
void *data,
size_t size)
@ -247,12 +271,13 @@ core_demarshal_remove_id (void *object,
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &id,
0))
return;
return false;
pinos_core_notify_remove_id (proxy, id);
return true;
}
static void
static bool
module_demarshal_info (void *object,
void *data,
size_t size)
@ -272,7 +297,7 @@ module_demarshal_info (void *object,
SPA_POD_TYPE_STRING, &info.args,
SPA_POD_TYPE_INT, &props.n_items,
0))
return;
return false;
info.props = &props;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
@ -281,12 +306,13 @@ module_demarshal_info (void *object,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return;
return false;
}
pinos_module_notify_info (proxy, &info);
return true;
}
static void
static bool
node_demarshal_done (void *object,
void *data,
size_t size)
@ -299,12 +325,13 @@ node_demarshal_done (void *object,
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
0))
return;
return false;
pinos_node_notify_done (proxy, seq);
return true;
}
static void
static bool
node_demarshal_info (void *object,
void *data,
size_t size)
@ -324,30 +351,31 @@ node_demarshal_info (void *object,
SPA_POD_TYPE_INT, &info.n_inputs,
SPA_POD_TYPE_INT, &info.n_input_formats,
0))
return;
return false;
info.input_formats = alloca (info.n_input_formats * sizeof (SpaFormat*));
for (i = 0; i < info.n_input_formats; i++)
spa_pod_iter_get (&it,
SPA_POD_TYPE_OBJECT, &info.input_formats[i], 0);
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &info.input_formats[i], 0))
return false;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &info.max_outputs,
SPA_POD_TYPE_INT, &info.n_outputs,
SPA_POD_TYPE_INT, &info.n_output_formats,
0))
return;
return false;
info.output_formats = alloca (info.n_output_formats * sizeof (SpaFormat*));
for (i = 0; i < info.n_output_formats; i++)
spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &info.output_formats[i], 0);
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &info.output_formats[i], 0))
return false;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &info.state,
SPA_POD_TYPE_STRING, &info.error,
SPA_POD_TYPE_INT, &props.n_items,
0))
return;
return false;
info.props = &props;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
@ -356,9 +384,10 @@ node_demarshal_info (void *object,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return;
return false;
}
pinos_node_notify_info (proxy, &info);
return true;
}
static void
@ -373,14 +402,17 @@ client_node_marshal_update (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, change_mask);
spa_pod_builder_int (&b.b, max_input_ports);
spa_pod_builder_int (&b.b, max_output_ports);
spa_pod_builder_int (&b.b, props ? 1 : 0);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, change_mask,
SPA_POD_TYPE_INT, max_input_ports,
SPA_POD_TYPE_INT, max_output_ports,
SPA_POD_TYPE_INT, props ? 1 : 0,
0);
if (props)
spa_pod_builder_raw (&b.b, props, SPA_POD_SIZE (props), true);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, props, 0);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, proxy->id, 0, b.b.offset);
}
@ -402,37 +434,46 @@ client_node_marshal_port_update (void *object,
SpaPODFrame f;
int i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, direction);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_int (&b.b, change_mask);
spa_pod_builder_int (&b.b, n_possible_formats);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id,
SPA_POD_TYPE_INT, change_mask,
SPA_POD_TYPE_INT, n_possible_formats,
0);
for (i = 0; i < n_possible_formats; i++)
spa_pod_builder_raw (&b.b, possible_formats[i], SPA_POD_SIZE (possible_formats[i]), true);
spa_pod_builder_int (&b.b, format ? 1 : 0);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, possible_formats[i], 0);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, format ? 1 : 0, 0);
if (format)
spa_pod_builder_raw (&b.b, format, SPA_POD_SIZE (format), true);
spa_pod_builder_int (&b.b, props ? 1 : 0);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, format, 0);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, props ? 1 : 0, 0);
if (props)
spa_pod_builder_raw (&b.b, props, SPA_POD_SIZE (props), true);
spa_pod_builder_int (&b.b, info ? 1 : 0);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, props, 0);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, info ? 1 : 0, 0);
if (info) {
spa_pod_builder_int (&b.b, info->flags);
spa_pod_builder_long (&b.b, info->maxbuffering);
spa_pod_builder_long (&b.b, info->latency);
spa_pod_builder_int (&b.b, info->n_params);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, info->flags,
SPA_POD_TYPE_LONG, info->maxbuffering,
SPA_POD_TYPE_LONG, info->latency,
SPA_POD_TYPE_INT, info->n_params,
0);
for (i = 0; i < info->n_params; i++) {
SpaAllocParam *p = info->params[i];
spa_pod_builder_bytes (&b.b, p, p->size);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_BYTES, p, p->size, 0);
}
n_items = info->extra ? info->extra->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, info->extra->items[i].key);
spa_pod_builder_string (&b.b, info->extra->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, info->extra->items[i].key,
SPA_POD_TYPE_STRING, info->extra->items[i].value,
0);
}
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, proxy->id, 1, b.b.offset);
}
@ -446,9 +487,11 @@ client_node_marshal_state_change (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, state);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, state,
-SPA_POD_TYPE_STRUCT, &f,
0);
pinos_connection_end_write (connection, proxy->id, 2, b.b.offset);
}
@ -462,9 +505,11 @@ client_node_marshal_event (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_bytes (&b.b, event, event->size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_BYTES, event, event->size,
-SPA_POD_TYPE_STRUCT, &f,
0);
pinos_connection_end_write (connection, proxy->id, 3, b.b.offset);
}
@ -478,14 +523,16 @@ client_node_marshal_destroy (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
-SPA_POD_TYPE_STRUCT, &f,
0);
pinos_connection_end_write (connection, proxy->id, 4, b.b.offset);
}
static void
static bool
client_node_demarshal_done (void *object,
void *data,
size_t size)
@ -501,13 +548,14 @@ client_node_demarshal_done (void *object,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &idx,
0))
return;
return false;
fd = pinos_connection_get_fd (connection, idx);
pinos_client_node_notify_done (proxy, seq, fd);
return true;
}
static void
static bool
client_node_demarshal_event (void *object,
void *data,
size_t size)
@ -521,12 +569,13 @@ client_node_demarshal_event (void *object,
!spa_pod_iter_get (&it,
SPA_POD_TYPE_BYTES, &event, &s,
0))
return;
return false;
pinos_client_node_notify_event (proxy, event);
return true;
}
static void
static bool
client_node_demarshal_add_port (void *object,
void *data,
size_t size)
@ -541,15 +590,16 @@ client_node_demarshal_add_port (void *object,
SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id,
0))
return;
return false;
pinos_client_node_notify_add_port (proxy, seq, direction, port_id);
return true;
}
static void
static bool
client_node_demarshal_remove_port (void *object,
void *data,
size_t size)
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
@ -561,15 +611,16 @@ client_node_demarshal_remove_port (void *object,
SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id,
0))
return;
return false;
pinos_client_node_notify_remove_port (proxy, seq, direction, port_id);
return true;
}
static void
static bool
client_node_demarshal_set_format (void *object,
void *data,
size_t size)
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
@ -584,16 +635,17 @@ client_node_demarshal_set_format (void *object,
SPA_POD_TYPE_INT, &flags,
SPA_POD_TYPE_INT, &have_format,
0))
return;
return false;
if (have_format && !spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &format, 0))
return;
return false;
pinos_client_node_notify_set_format (proxy, seq, direction, port_id,
flags, format);
return true;
}
static void
static bool
client_node_demarshal_set_property (void *object,
void *data,
size_t size)
@ -610,12 +662,13 @@ client_node_demarshal_set_property (void *object,
SPA_POD_TYPE_INT, &id,
SPA_POD_TYPE_BYTES, &value, &s,
0))
return;
return false;
pinos_client_node_notify_set_property (proxy, seq, id, s, value);
return true;
}
static void
static bool
client_node_demarshal_add_mem (void *object,
void *data,
size_t size)
@ -637,7 +690,7 @@ client_node_demarshal_add_mem (void *object,
SPA_POD_TYPE_INT, &offset,
SPA_POD_TYPE_INT, &sz,
0))
return;
return false;
memfd = pinos_connection_get_fd (connection, memfd_idx);
@ -650,12 +703,13 @@ client_node_demarshal_add_mem (void *object,
flags,
offset,
sz);
return true;
}
static void
static bool
client_node_demarshal_use_buffers (void *object,
void *data,
size_t size)
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
@ -670,7 +724,7 @@ client_node_demarshal_use_buffers (void *object,
SPA_POD_TYPE_INT, &port_id,
SPA_POD_TYPE_INT, &n_buffers,
0))
return;
return false;
buffers = alloca (sizeof (PinosClientNodeBuffer) * n_buffers);
for (i = 0; i < n_buffers; i++) {
@ -682,7 +736,7 @@ client_node_demarshal_use_buffers (void *object,
SPA_POD_TYPE_INT, &buffers[i].size,
SPA_POD_TYPE_INT, &buf->id,
SPA_POD_TYPE_INT, &buf->n_metas, 0))
return;
return false;
buf->metas = alloca (sizeof (SpaMeta) * buf->n_metas);
for (j = 0; j < buf->n_metas; j++) {
@ -691,12 +745,12 @@ client_node_demarshal_use_buffers (void *object,
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &m->type,
SPA_POD_TYPE_INT, &size, 0))
return;
return false;
m->size = size;
}
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &buf->n_datas, 0))
return;
return false;
buf->datas = alloca (sizeof (SpaData) * buf->n_datas);
for (j = 0; j < buf->n_datas; j++) {
@ -709,7 +763,7 @@ client_node_demarshal_use_buffers (void *object,
SPA_POD_TYPE_INT, &d->mapoffset,
SPA_POD_TYPE_INT, &d->maxsize,
0))
return;
return false;
d->data = SPA_UINT32_TO_PTR (data_id);
}
@ -720,153 +774,169 @@ client_node_demarshal_use_buffers (void *object,
port_id,
n_buffers,
buffers);
return true;
}
static void
static bool
client_node_demarshal_node_command (void *object,
void *data,
size_t size)
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
const SpaNodeCommand *command;
int32_t i1;
uint32_t s;
uint32_t seq, s;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_bytes (&p, (const void**)&command, &s))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_BYTES, &command, &s,
0))
return false;
pinos_client_node_notify_node_command (proxy, i1, command);
pinos_client_node_notify_node_command (proxy, seq, command);
return true;
}
static void
static bool
client_node_demarshal_port_command (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
const SpaNodeCommand *command;
int32_t i1;
uint32_t s;
uint32_t port_id, s;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_bytes (&p, (const void**)&command, &s))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &port_id,
SPA_POD_TYPE_BYTES, &command, &s,
0))
return false;
pinos_client_node_notify_port_command (proxy, i1, command);
pinos_client_node_notify_port_command (proxy, port_id, command);
return true;
}
static void
static bool
client_node_demarshal_transport (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
PinosConnection *connection = proxy->context->protocol_private;
int32_t memfd, offset, sz;
if (!spa_pod_get_int (&p, &memfd) ||
!spa_pod_get_int (&p, &offset) ||
!spa_pod_get_int (&p, &sz))
return;
memfd = pinos_connection_get_fd (connection, memfd);
pinos_client_node_notify_transport (proxy, memfd, offset, sz);
}
static void
client_demarshal_info (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaDict props;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
PinosClientInfo info;
int32_t i1, i2;
int64_t l1;
int i;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_long (&p, &l1) ||
!spa_pod_get_int (&p, &i2))
return;
info.id = i1;
info.change_mask = l1;
info.props = &props;
props.n_items = i2;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
for (i = 0; i < props.n_items; i++) {
if (!spa_pod_get_string (&p, &props.items[i].key) ||
!spa_pod_get_string (&p, &props.items[i].value))
return;
}
pinos_client_notify_info (proxy, &info);
}
static void
link_demarshal_info (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
PinosLinkInfo info;
int32_t i1, i2, i3, i4, i5;
int64_t l1;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_long (&p, &l1) ||
!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_int (&p, &i3) ||
!spa_pod_get_int (&p, &i4) ||
!spa_pod_get_int (&p, &i5))
return;
info.id = i1;
info.change_mask = l1;
info.output_node_id = i2;
info.output_port_id = i3;
info.input_node_id = i4;
info.input_port_id = i5;
pinos_link_notify_info (proxy, &info);
}
static void
registry_demarshal_global (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1;
const char *type;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_string (&p, &type))
return;
pinos_registry_notify_global (proxy, i1, type);
}
static void
registry_demarshal_global_remove (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1;
SpaPODIter it;
PinosConnection *connection = proxy->context->protocol_private;
uint32_t memfd_idx, offset, sz;
int memfd;
if (!spa_pod_get_int (&p, &i1))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &memfd_idx,
SPA_POD_TYPE_INT, &offset,
SPA_POD_TYPE_INT, &sz,
0))
return false;
pinos_registry_notify_global_remove (proxy, i1);
memfd = pinos_connection_get_fd (connection, memfd_idx);
pinos_client_node_notify_transport (proxy, memfd, offset, sz);
return true;
}
static bool
client_demarshal_info (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
SpaDict props;
PinosClientInfo info;
uint32_t i;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &info.id,
SPA_POD_TYPE_LONG, &info.change_mask,
SPA_POD_TYPE_INT, &props.n_items,
0))
return false;
info.props = &props;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
for (i = 0; i < props.n_items; i++) {
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return false;
}
pinos_client_notify_info (proxy, &info);
return true;
}
static bool
link_demarshal_info (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
PinosLinkInfo info;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &info.id,
SPA_POD_TYPE_LONG, &info.change_mask,
SPA_POD_TYPE_INT, &info.output_node_id,
SPA_POD_TYPE_INT, &info.output_port_id,
SPA_POD_TYPE_INT, &info.input_node_id,
SPA_POD_TYPE_INT, &info.input_port_id,
0))
return false;
pinos_link_notify_info (proxy, &info);
return true;
}
static bool
registry_demarshal_global (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
uint32_t id;
const char *type;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &id,
SPA_POD_TYPE_STRING, &type,
0))
return false;
pinos_registry_notify_global (proxy, id, type);
return true;
}
static bool
registry_demarshal_global_remove (void *object,
void *data,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
uint32_t id;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &id,
0))
return false;
pinos_registry_notify_global_remove (proxy, id);
return true;
}
static void
@ -879,10 +949,11 @@ registry_marshal_bind (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, id);
spa_pod_builder_int (&b.b, new_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, id,
SPA_POD_TYPE_INT, new_id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, proxy->id, 0, b.b.offset);
}

2
pinos/client/protocol-native.h
View file

@ -20,7 +20,7 @@
#include "pinos/client/pinos.h"
#include "pinos/client/interfaces.h"
typedef void (*PinosDemarshalFunc) (void *object, void *data, size_t size);
typedef bool (*PinosDemarshalFunc) (void *object, void *data, size_t size);
extern const PinosCoreInterface pinos_protocol_native_client_core_interface;
extern const PinosRegistryInterface pinos_protocol_native_client_registry_interface;

7
pinos/modules/module-protocol-native.c
View file

@ -163,9 +163,10 @@ connection_data (SpaSource *source,
continue;
}
demarshal = resource->demarshal;
if (demarshal[opcode])
demarshal[opcode] (resource, message, size);
else
if (demarshal[opcode]) {
if (!demarshal[opcode] (resource, message, size))
pinos_log_error ("protocol-native %p: invalid message received", client->impl);
} else
pinos_log_error ("protocol-native %p: function %d not implemented", client->impl, opcode);
}
}

639
pinos/server/protocol-native.c
View file

@ -17,6 +17,9 @@
* Boston, MA 02110-1301, USA.
*/
#include "spa/pod-iter.h"
#include "pinos/client/interfaces.h"
#include "pinos/server/resource.h"
#include "pinos/server/protocol-native.h"
@ -49,23 +52,28 @@ core_marshal_info (void *object,
PinosConnection *connection = resource->client->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, n_items;
uint32_t i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, info->id);
spa_pod_builder_long (&b.b, info->change_mask);
spa_pod_builder_string (&b.b, info->user_name);
spa_pod_builder_string (&b.b, info->host_name);
spa_pod_builder_string (&b.b, info->version);
spa_pod_builder_string (&b.b, info->name);
spa_pod_builder_int (&b.b, info->cookie);
n_items = info->props ? info->props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, info->id,
SPA_POD_TYPE_LONG, info->change_mask,
SPA_POD_TYPE_STRING, info->user_name,
SPA_POD_TYPE_STRING, info->host_name,
SPA_POD_TYPE_STRING, info->version,
SPA_POD_TYPE_STRING, info->name,
SPA_POD_TYPE_INT, info->cookie,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, info->props->items[i].key);
spa_pod_builder_string (&b.b, info->props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, info->props->items[i].key,
SPA_POD_TYPE_STRING, info->props->items[i].value,
0);
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}
@ -79,9 +87,10 @@ core_marshal_done (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 1, b.b.offset);
}
@ -104,11 +113,12 @@ core_marshal_error (void *object,
vsnprintf (buffer, sizeof (buffer), error, ap);
va_end (ap);
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, id);
spa_pod_builder_int (&b.b, res);
spa_pod_builder_string (&b.b, buffer);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, id,
SPA_POD_TYPE_INT, res,
SPA_POD_TYPE_STRING, buffer,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 2, b.b.offset);
}
@ -122,95 +132,111 @@ core_marshal_remove_id (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 3, b.b.offset);
}
static void
static bool
core_demarshal_client_update (void *object,
void *data,
size_t size)
void *data,
size_t size)
{
PinosResource *resource = object;
SpaDict props;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i32;
int i;
SpaPODIter it;
uint32_t i;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &props.n_items,
0))
return false;
if (!spa_pod_get_int (&p, &i32))
return;
props.n_items = i32;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
for (i = 0; i < props.n_items; i++) {
if (!spa_pod_get_string (&p, &props.items[i].key) ||
!spa_pod_get_string (&p, &props.items[i].value))
return;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return false;
}
pinos_core_do_client_update (resource, &props);
return true;
}
static void
static bool
core_demarshal_sync (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq;
SpaPODIter it;
uint32_t seq;
if (!spa_pod_get_int (&p, &seq))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
0))
return false;
pinos_core_do_sync (resource, seq);
return true;
}
static void
static bool
core_demarshal_get_registry (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
int32_t seq, new_id;
if (!spa_pod_get_int (&p, &seq) ||
!spa_pod_get_int (&p, &new_id))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &new_id,
0))
return false;
pinos_core_do_get_registry (resource, seq, new_id);
return true;
}
static void
static bool
core_demarshal_create_node (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq, new_id, i32;
SpaPODIter it;
uint32_t seq, new_id, i;
const char *factory_name, *name;
int i;
SpaDict props;
if (!spa_pod_get_int (&p, &seq) ||
!spa_pod_get_string (&p, &factory_name) ||
!spa_pod_get_string (&p, &name) ||
!spa_pod_get_int (&p, &i32))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_STRING, &factory_name,
SPA_POD_TYPE_STRING, &name,
SPA_POD_TYPE_INT, &props.n_items,
0))
return false;
props.n_items = i32;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
for (i = 0; i < props.n_items; i++) {
if (!spa_pod_get_string (&p, &props.items[i].key) ||
!spa_pod_get_string (&p, &props.items[i].value))
return;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return false;
}
if (!spa_pod_get_int (&p, &new_id))
return;
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &new_id, 0))
return false;
pinos_core_do_create_node (resource,
seq,
@ -218,40 +244,45 @@ core_demarshal_create_node (void *object,
name,
&props,
new_id);
return true;
}
static void
static bool
core_demarshal_create_client_node (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq, new_id, i32;
SpaPODIter it;
uint32_t seq, new_id, i;
const char *name;
int i;
SpaDict props;
if (!spa_pod_get_int (&p, &seq) ||
!spa_pod_get_string (&p, &name) ||
!spa_pod_get_int (&p, &i32))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_STRING, &name,
SPA_POD_TYPE_INT, &props.n_items,
0))
return false;
props.n_items = i32;
props.items = alloca (props.n_items * sizeof (SpaDictItem));
for (i = 0; i < props.n_items; i++) {
if (!spa_pod_get_string (&p, &props.items[i].key) ||
!spa_pod_get_string (&p, &props.items[i].value))
return;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return false;
}
if (!spa_pod_get_int (&p, &new_id))
return;
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &new_id, 0))
return false;
pinos_core_do_create_client_node (resource,
seq,
name,
&props,
new_id);
return true;
}
static void
@ -264,10 +295,11 @@ registry_marshal_global (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, id);
spa_pod_builder_string (&b.b, type);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, id,
SPA_POD_TYPE_STRING, type,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}
@ -281,27 +313,32 @@ registry_marshal_global_remove (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 1, b.b.offset);
}
static void
static bool
registry_demarshal_bind (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1, i2;
SpaPODIter it;
uint32_t id, new_id;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &id,
SPA_POD_TYPE_INT, &new_id,
0))
return false;
pinos_registry_do_bind (resource, i1, i2);
pinos_registry_do_bind (resource, id, new_id);
return true;
}
static void
@ -312,21 +349,26 @@ module_marshal_info (void *object,
PinosConnection *connection = resource->client->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, n_items;
uint32_t i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, info->id);
spa_pod_builder_long (&b.b, info->change_mask);
spa_pod_builder_string (&b.b, info->name);
spa_pod_builder_string (&b.b, info->filename);
spa_pod_builder_string (&b.b, info->args);
n_items = info->props ? info->props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, info->id,
SPA_POD_TYPE_LONG, info->change_mask,
SPA_POD_TYPE_STRING, info->name,
SPA_POD_TYPE_STRING, info->filename,
SPA_POD_TYPE_STRING, info->args,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, info->props->items[i].key);
spa_pod_builder_string (&b.b, info->props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, info->props->items[i].key,
SPA_POD_TYPE_STRING, info->props->items[i].value,
0);
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}
@ -340,9 +382,10 @@ node_marshal_done (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}
@ -355,31 +398,41 @@ node_marshal_info (void *object,
PinosConnection *connection = resource->client->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, n_items;
uint32_t i, n_items;
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, info->id,
SPA_POD_TYPE_LONG, info->change_mask,
SPA_POD_TYPE_STRING, info->name,
SPA_POD_TYPE_INT, info->max_inputs,
SPA_POD_TYPE_INT, info->n_inputs,
SPA_POD_TYPE_INT, info->n_input_formats, 0);
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, info->id);
spa_pod_builder_long (&b.b, info->change_mask);
spa_pod_builder_string (&b.b, info->name);
spa_pod_builder_int (&b.b, info->max_inputs);
spa_pod_builder_int (&b.b, info->n_inputs);
spa_pod_builder_int (&b.b, info->n_input_formats);
for (i = 0; i < info->n_input_formats; i++)
spa_pod_builder_raw (&b.b, info->input_formats[i], SPA_POD_SIZE (info->input_formats[i]), true);
spa_pod_builder_int (&b.b, info->max_outputs);
spa_pod_builder_int (&b.b, info->n_outputs);
spa_pod_builder_int (&b.b, info->n_output_formats);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, info->input_formats[i], 0);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, info->max_outputs,
SPA_POD_TYPE_INT, info->n_outputs,
SPA_POD_TYPE_INT, info->n_output_formats, 0);
for (i = 0; i < info->n_output_formats; i++)
spa_pod_builder_raw (&b.b, info->output_formats[i], SPA_POD_SIZE (info->output_formats[i]), true);
spa_pod_builder_int (&b.b, info->state);
spa_pod_builder_string (&b.b, info->error);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, info->output_formats[i], 0);
n_items = info->props ? info->props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, info->state,
SPA_POD_TYPE_STRING, info->error,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, info->props->items[i].key);
spa_pod_builder_string (&b.b, info->props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, info->props->items[i].key,
SPA_POD_TYPE_STRING, info->props->items[i].value, 0);
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 1, b.b.offset);
}
@ -392,18 +445,22 @@ client_marshal_info (void *object,
PinosConnection *connection = resource->client->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, n_items;
uint32_t i, n_items;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, info->id);
spa_pod_builder_long (&b.b, info->change_mask);
n_items = info->props ? info->props->n_items : 0;
spa_pod_builder_int (&b.b, n_items);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, info->id,
SPA_POD_TYPE_LONG, info->change_mask,
SPA_POD_TYPE_INT, n_items, 0);
for (i = 0; i < n_items; i++) {
spa_pod_builder_string (&b.b, info->props->items[i].key);
spa_pod_builder_string (&b.b, info->props->items[i].value);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRING, info->props->items[i].key,
SPA_POD_TYPE_STRING, info->props->items[i].value, 0);
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}
@ -418,10 +475,11 @@ client_node_marshal_done (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, pinos_connection_add_fd (connection, datafd));
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, pinos_connection_add_fd (connection, datafd),
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}
@ -435,9 +493,10 @@ client_node_marshal_event (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_bytes (&b.b, event, event->size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_BYTES, event, event->size,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 1, b.b.offset);
}
@ -453,11 +512,12 @@ client_node_marshal_add_port (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, direction);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 2, b.b.offset);
}
@ -473,11 +533,12 @@ client_node_marshal_remove_port (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, direction);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 3, b.b.offset);
}
@ -495,15 +556,16 @@ client_node_marshal_set_format (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, direction);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_int (&b.b, flags);
spa_pod_builder_int (&b.b, format ? 1 : 0);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id,
SPA_POD_TYPE_INT, flags,
SPA_POD_TYPE_INT, format ? 1 : 0, 0);
if (format)
spa_pod_builder_raw (&b.b, format, SPA_POD_SIZE (format), true);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_POD, format, 0);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 4, b.b.offset);
}
@ -520,11 +582,12 @@ client_node_marshal_set_property (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, id);
spa_pod_builder_bytes (&b.b, value, size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, id,
SPA_POD_TYPE_BYTES, value, size,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 5, b.b.offset);
}
@ -545,16 +608,17 @@ client_node_marshal_add_mem (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, direction);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_int (&b.b, mem_id);
spa_pod_builder_int (&b.b, type);
spa_pod_builder_int (&b.b, pinos_connection_add_fd (connection, memfd));
spa_pod_builder_int (&b.b, flags);
spa_pod_builder_int (&b.b, offset);
spa_pod_builder_int (&b.b, size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id,
SPA_POD_TYPE_INT, mem_id,
SPA_POD_TYPE_INT, type,
SPA_POD_TYPE_INT, pinos_connection_add_fd (connection, memfd),
SPA_POD_TYPE_INT, flags,
SPA_POD_TYPE_INT, offset,
SPA_POD_TYPE_INT, size,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 6, b.b.offset);
}
@ -571,37 +635,43 @@ client_node_marshal_use_buffers (void *object,
PinosConnection *connection = resource->client->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
int i, j;
uint32_t i, j;
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_INT, direction,
SPA_POD_TYPE_INT, port_id,
SPA_POD_TYPE_INT, n_buffers, 0);
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_int (&b.b, direction);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_int (&b.b, n_buffers);
for (i = 0; i < n_buffers; i++) {
SpaBuffer *buf = buffers[i].buffer;
spa_pod_builder_int (&b.b, buffers[i].mem_id);
spa_pod_builder_int (&b.b, buffers[i].offset);
spa_pod_builder_int (&b.b, buffers[i].size);
spa_pod_builder_int (&b.b, buf->id);
spa_pod_builder_int (&b.b, buf->n_metas);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, buffers[i].mem_id,
SPA_POD_TYPE_INT, buffers[i].offset,
SPA_POD_TYPE_INT, buffers[i].size,
SPA_POD_TYPE_INT, buf->id,
SPA_POD_TYPE_INT, buf->n_metas, 0);
for (j = 0; j < buf->n_metas; j++) {
SpaMeta *m = &buf->metas[j];
spa_pod_builder_int (&b.b, m->type);
spa_pod_builder_int (&b.b, m->size);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, m->type,
SPA_POD_TYPE_INT, m->size, 0);
}
spa_pod_builder_int (&b.b, buf->n_datas);
spa_pod_builder_add (&b.b, SPA_POD_TYPE_INT, buf->n_datas, 0);
for (j = 0; j < buf->n_datas; j++) {
SpaData *d = &buf->datas[j];
spa_pod_builder_int (&b.b, d->type);
spa_pod_builder_int (&b.b, SPA_PTR_TO_UINT32 (d->data));
spa_pod_builder_int (&b.b, d->flags);
spa_pod_builder_int (&b.b, d->mapoffset);
spa_pod_builder_int (&b.b, d->maxsize);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_INT, d->type,
SPA_POD_TYPE_INT, SPA_PTR_TO_UINT32 (d->data),
SPA_POD_TYPE_INT, d->flags,
SPA_POD_TYPE_INT, d->mapoffset,
SPA_POD_TYPE_INT, d->maxsize, 0);
}
}
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b, -SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 7, b.b.offset);
}
@ -616,10 +686,11 @@ client_node_marshal_node_command (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, seq);
spa_pod_builder_bytes (&b.b, command, command->size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, seq,
SPA_POD_TYPE_BYTES, command, command->size,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 8, b.b.offset);
}
@ -634,10 +705,11 @@ client_node_marshal_port_command (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, port_id);
spa_pod_builder_bytes (&b.b, command, command->size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, port_id,
SPA_POD_TYPE_BYTES, command, command->size,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 9, b.b.offset);
}
@ -653,102 +725,107 @@ client_node_marshal_transport (void *object,
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, pinos_connection_add_fd (connection, memfd));
spa_pod_builder_int (&b.b, offset);
spa_pod_builder_int (&b.b, size);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, pinos_connection_add_fd (connection, memfd),
SPA_POD_TYPE_INT, offset,
SPA_POD_TYPE_INT, size,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 10, b.b.offset);
}
static void
static bool
client_node_demarshal_update (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1, i2, i3, i4;
const SpaPOD *props = NULL;
SpaPODIter it;
uint32_t change_mask, max_input_ports, max_output_ports, have_props;
const SpaProps *props = NULL;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_int (&p, &i3) ||
!spa_pod_get_int (&p, &i4))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &change_mask,
SPA_POD_TYPE_INT, &max_input_ports,
SPA_POD_TYPE_INT, &max_output_ports,
SPA_POD_TYPE_INT, &have_props,
0))
return false;
if (i4 && !spa_pod_get_object (&p, &props))
return;
if (have_props && !spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &props, 0))
return false;
pinos_client_node_do_update (resource, i1, i2, i3, (SpaProps *)props);
pinos_client_node_do_update (resource, change_mask, max_input_ports, max_output_ports, props);
return true;
}
static void
static bool
client_node_demarshal_port_update (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1, i2, direction, port_id, change_mask, n_possible_formats;
int64_t l1, l2;
SpaPODIter it;
uint32_t i, t, direction, port_id, change_mask, n_possible_formats, sz;
const SpaProps *props = NULL;
const SpaFormat **possible_formats = NULL, *format = NULL;
SpaPortInfo info, *infop = NULL;
int i;
uint32_t sz;
if (!spa_pod_get_int (&p, &direction) ||
!spa_pod_get_int (&p, &port_id) ||
!spa_pod_get_int (&p, &change_mask) ||
!spa_pod_get_int (&p, &n_possible_formats))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id,
SPA_POD_TYPE_INT, &change_mask,
SPA_POD_TYPE_INT, &n_possible_formats,
0))
return false;
possible_formats = alloca (n_possible_formats * sizeof (SpaFormat*));
for (i = 0; i < n_possible_formats; i++)
spa_pod_get_object (&p, (const SpaPOD**)&possible_formats[i]);
if (!spa_pod_iter_get (&it,SPA_POD_TYPE_OBJECT, &possible_formats[i], 0))
return false;
if (!spa_pod_get_int (&p, &i1) ||
(i1 && !spa_pod_get_object (&p, (const SpaPOD**)&format)))
return;
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &t, 0) ||
(t && !spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &format, 0)))
return false;
if (!spa_pod_get_int (&p, &i1) ||
(i1 && !spa_pod_get_object (&p, (const SpaPOD**)&props)))
return;
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &t, 0) ||
(t && !spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &props, 0)))
return false;
if (!spa_pod_get_int (&p, &i1))
return;
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &t, 0))
return false;
if (i1) {
if (t) {
SpaDict dict;
infop = &info;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_long (&p, &l1) ||
!spa_pod_get_long (&p, &l2) ||
!spa_pod_get_int (&p, &i2))
return;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &info.flags,
SPA_POD_TYPE_LONG, &info.maxbuffering,
SPA_POD_TYPE_LONG, &info.latency,
SPA_POD_TYPE_INT, &info.n_params,
0))
return false;
info.flags = i1;
info.maxbuffering = l1;
info.latency = l2;
info.n_params = i2;
info.params = alloca (info.n_params * sizeof (SpaAllocParam *));
for (i = 0; i < info.n_params; i++)
spa_pod_get_bytes (&p, (const void **)&info.params[i], &sz);
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_BYTES, &info.params[i], &sz, 0))
return false;
if (!spa_pod_get_int (&p, &i1))
return;
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &dict.n_items, 0))
return false;
info.extra = &dict;
dict.n_items = i1;
dict.items = alloca (dict.n_items * sizeof (SpaDictItem));
for (i = 0; i < dict.n_items; i++) {
if (!spa_pod_get_string (&p, &dict.items[i].key) ||
!spa_pod_get_string (&p, &dict.items[i].value))
return;
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &dict.items[i].key,
SPA_POD_TYPE_STRING, &dict.items[i].value,
0))
return false;
}
}
@ -761,71 +838,79 @@ client_node_demarshal_port_update (void *object,
format,
props,
infop);
return true;
}
static void
static bool
client_node_demarshal_state_change (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t state;
SpaPODIter it;
uint32_t state;
if (!spa_pod_get_int (&p, &state))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &state, 0))
return false;
pinos_client_node_do_state_change (resource, state);
return true;
}
static void
static bool
client_node_demarshal_event (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
SpaNodeEvent *event;
uint32_t sz;
if (!spa_pod_get_bytes (&p, (const void **)&event, &sz))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it, SPA_POD_TYPE_BYTES, &event, &sz, 0))
return false;
pinos_client_node_do_event (resource, event);
return true;
}
static void
static bool
client_node_demarshal_destroy (void *object,
void *data,
size_t size)
{
PinosResource *resource = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq;
SpaPODIter it;
uint32_t seq;
if (!spa_pod_get_int (&p, &seq))
return;
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &seq, 0))
return false;
pinos_client_node_do_destroy (resource, seq);
return true;
}
static void
link_marshal_info (void *object,
PinosLinkInfo *info)
PinosLinkInfo *info)
{
PinosResource *resource = object;
PinosConnection *connection = resource->client->protocol_private;
Builder b = { { NULL, 0, 0, NULL, write_pod }, connection };
SpaPODFrame f;
spa_pod_builder_push_struct (&b.b, &f);
spa_pod_builder_int (&b.b, info->id);
spa_pod_builder_long (&b.b, info->change_mask);
spa_pod_builder_int (&b.b, info->output_node_id);
spa_pod_builder_int (&b.b, info->output_port_id);
spa_pod_builder_int (&b.b, info->input_node_id);
spa_pod_builder_int (&b.b, info->input_port_id);
spa_pod_builder_pop (&b.b, &f);
spa_pod_builder_add (&b.b,
SPA_POD_TYPE_STRUCT, &f,
SPA_POD_TYPE_INT, info->id,
SPA_POD_TYPE_LONG, info->change_mask,
SPA_POD_TYPE_LONG, info->output_node_id,
SPA_POD_TYPE_LONG, info->output_port_id,
SPA_POD_TYPE_LONG, info->input_node_id,
SPA_POD_TYPE_LONG, info->input_port_id,
-SPA_POD_TYPE_STRUCT, &f, 0);
pinos_connection_end_write (connection, resource->id, 0, b.b.offset);
}

2
pinos/server/protocol-native.h
View file

@ -19,7 +19,7 @@
#include "pinos/client/pinos.h"
typedef void (*PinosDemarshalFunc) (void *object, void *data, size_t size);
typedef bool (*PinosDemarshalFunc) (void *object, void *data, size_t size);
extern const PinosCoreEvent pinos_protocol_native_server_core_event;
extern const PinosRegistryEvent pinos_protocol_native_server_registry_event;