mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use types with known sizes where we can, easier to serialize

Browse source 
Add iterator for POD and use it to implement some demarshalling.
This commit is contained in:
Wim Taymans 2017-03-07 11:56:43 +01:00
parent 23d09d5b60
commit f92b68c3c3
77 changed files with 839 additions and 695 deletions
Download patch file Download diff file Expand all files Collapse all files

14
pinos/client/connection.c
View file

@ -36,7 +36,7 @@ typedef struct {
size_t buffer_size;
size_t buffer_maxsize;
int fds[MAX_FDS];
unsigned int n_fds;
uint32_t n_fds;
off_t offset;
void *data;
@ -52,7 +52,7 @@ struct _PinosConnection {
int
pinos_connection_get_fd (PinosConnection *conn,
int index)
uint32_t index)
{
if (index < 0 || index >= conn->in.n_fds)
return -1;
@ -60,11 +60,11 @@ pinos_connection_get_fd (PinosConnection *conn,
return conn->in.fds[index];
}
int
uint32_t
pinos_connection_add_fd (PinosConnection *conn,
int fd)
{
int index, i;
uint32_t index, i;
for (i = 0; i < conn->out.n_fds; i++) {
if (conn->out.fds[i] == fd)
@ -202,7 +202,7 @@ pinos_connection_get_next (PinosConnection *conn,
uint8_t *opcode,
uint32_t *dest_id,
void **dt,
size_t *sz)
uint32_t *sz)
{
size_t len, size;
uint8_t *data;
@ -265,7 +265,7 @@ again:
void *
pinos_connection_begin_write (PinosConnection *conn,
size_t size)
uint32_t size)
{
uint32_t *p;
ConnectionBuffer *buf = &conn->out;
@ -278,7 +278,7 @@ void
pinos_connection_end_write (PinosConnection *conn,
uint32_t dest_id,
uint8_t opcode,
size_t size)
uint32_t size)
{
uint32_t *p;
ConnectionBuffer *buf = &conn->out;

10
pinos/client/connection.h
View file

@ -31,23 +31,23 @@ typedef struct _PinosConnection PinosConnection;
PinosConnection * pinos_connection_new (int fd);
void pinos_connection_destroy (PinosConnection *conn);
int pinos_connection_add_fd (PinosConnection *conn,
uint32_t pinos_connection_add_fd (PinosConnection *conn,
int fd);
int pinos_connection_get_fd (PinosConnection *conn,
int index);
uint32_t index);
bool pinos_connection_get_next (PinosConnection *conn,
uint8_t *opcode,
uint32_t *dest_id,
void **data,
size_t *size);
uint32_t *size);
void * pinos_connection_begin_write (PinosConnection *conn,
size_t size);
uint32_t size);
void pinos_connection_end_write (PinosConnection *conn,
uint32_t dest_id,
uint8_t opcode,
size_t size);
uint32_t size);
bool pinos_connection_flush (PinosConnection *conn);
bool pinos_connection_clear (PinosConnection *conn);

2
pinos/client/context.c
View file

@ -387,7 +387,7 @@ on_context_data (SpaSource *source,
PinosConnection *conn = impl->connection;
uint8_t opcode;
uint32_t id;
size_t size;
uint32_t size;
void *message;
while (pinos_connection_get_next (conn, &opcode, &id, &message, &size)) {

22
pinos/client/interfaces.h
View file

@ -117,8 +117,8 @@ typedef struct {
struct _PinosClientNodeBuffer {
uint32_t mem_id;
off_t offset;
size_t size;
uint32_t offset;
uint32_t size;
SpaBuffer *buffer;
};
@ -128,8 +128,8 @@ typedef struct {
#define PINOS_MESSAGE_NODE_UPDATE_MAX_OUTPUTS (1 << 1)
#define PINOS_MESSAGE_NODE_UPDATE_PROPS (1 << 2)
uint32_t change_mask,
unsigned int max_input_ports,
unsigned int max_output_ports,
uint32_t max_input_ports,
uint32_t max_output_ports,
const SpaProps *props);
void (*port_update) (void *object,
@ -140,7 +140,7 @@ typedef struct {
#define PINOS_MESSAGE_PORT_UPDATE_PROPS (1 << 2)
#define PINOS_MESSAGE_PORT_UPDATE_INFO (1 << 3)
uint32_t change_mask,
unsigned int n_possible_formats,
uint32_t n_possible_formats,
const SpaFormat **possible_formats,
const SpaFormat *format,
const SpaProps *props,
@ -182,7 +182,7 @@ typedef struct {
void (*set_property) (void *object,
uint32_t seq,
uint32_t id,
size_t size,
uint32_t size,
const void *value);
void (*add_mem) (void *object,
SpaDirection direction,
@ -191,13 +191,13 @@ typedef struct {
SpaDataType type,
int memfd,
uint32_t flags,
off_t offset,
size_t size);
uint32_t offset,
uint32_t size);
void (*use_buffers) (void *object,
uint32_t seq,
SpaDirection direction,
uint32_t port_id,
unsigned int n_buffers,
uint32_t n_buffers,
PinosClientNodeBuffer *buffers);
void (*node_command) (void *object,
uint32_t seq,
@ -207,8 +207,8 @@ typedef struct {
const SpaNodeCommand *command);
void (*transport) (void *object,
int memfd,
off_t offset,
size_t size);
uint32_t offset,
uint32_t size);
} PinosClientNodeEvent;
#define pinos_client_node_notify_done(r,...) ((PinosClientNodeEvent*)r->event)->done(r,__VA_ARGS__)

2
pinos/client/introspect.c
View file

@ -119,7 +119,7 @@ static SpaDict *
pinos_spa_dict_copy (SpaDict *dict)
{
SpaDict *copy;
unsigned int i;
uint32_t i;
if (dict == NULL)
return NULL;

12
pinos/client/introspect.h
View file

@ -256,13 +256,13 @@ struct _PinosNodeInfo {
uint32_t id;
uint64_t change_mask;
const char *name;
unsigned int max_inputs;
unsigned int n_inputs;
unsigned int n_input_formats;
uint32_t max_inputs;
uint32_t n_inputs;
uint32_t n_input_formats;
SpaFormat **input_formats;
unsigned int max_outputs;
unsigned int n_outputs;
unsigned int n_output_formats;
uint32_t max_outputs;
uint32_t n_outputs;
uint32_t n_output_formats;
SpaFormat **output_formats;
PinosNodeState state;
const char *error;

2
pinos/client/loop.c
View file

@ -225,7 +225,7 @@ event_func (SpaSource *source,
void *data)
{
PinosLoopImpl *impl = data;
size_t offset;
uint32_t offset;
while (spa_ringbuffer_get_read_offset (&impl->buffer, &offset) > 0) {
InvokeItem *item = SPA_MEMBER (impl->buffer_data, offset, InvokeItem);

4
pinos/client/properties.c
View file

@ -105,7 +105,7 @@ pinos_properties_new (const char *key, ...)
PinosProperties *
pinos_properties_new_dict (const SpaDict *dict)
{
unsigned int i;
uint32_t i;
PinosPropertiesImpl *impl;
impl = calloc (1, sizeof (PinosPropertiesImpl));
@ -307,7 +307,7 @@ pinos_properties_iterate (PinosProperties *properties,
void **state)
{
PinosPropertiesImpl *impl = SPA_CONTAINER_OF (properties, PinosPropertiesImpl, this);
unsigned int index;
uint32_t index;
if (*state == NULL)
index = 0;

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

@ -19,6 +19,7 @@
#include <errno.h>
#include "spa/pod-iter.h"
#include "pinos/client/pinos.h"
#include "pinos/client/protocol-native.h"
@ -30,8 +31,8 @@ typedef struct {
PinosConnection *connection;
} Builder;
static off_t
write_pod (SpaPODBuilder *b, off_t ref, const void *data, size_t size)
static uint32_t
write_pod (SpaPODBuilder *b, uint32_t ref, const void *data, uint32_t size)
{
if (ref == -1)
ref = b->offset;
@ -165,31 +166,30 @@ core_demarshal_info (void *object,
{
PinosProxy *proxy = object;
SpaDict props;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
PinosCoreInfo info;
int32_t i1, i2, i3;
int64_t l1;
SpaPODIter it;
int i;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_long (&p, &l1) ||
!spa_pod_get_string (&p, &info.user_name) ||
!spa_pod_get_string (&p, &info.host_name) ||
!spa_pod_get_string (&p, &info.version) ||
!spa_pod_get_string (&p, &info.name) ||
!spa_pod_get_int (&p, &i3) ||
!spa_pod_get_int (&p, &i2))
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_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, &props.n_items,
0))
return;
info.id = i1;
info.change_mask = l1;
info.cookie = i3;
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))
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return;
}
pinos_core_notify_info (proxy, &info);
@ -201,13 +201,16 @@ core_demarshal_done (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i32;
SpaPODIter it;
uint32_t seq;
if (!spa_pod_get_int (&p, &i32))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
0))
return;
pinos_core_notify_done (proxy, i32);
pinos_core_notify_done (proxy, seq);
}
static void
@ -216,16 +219,19 @@ core_demarshal_error (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1, i2;
SpaPODIter it;
uint32_t id, res;
const char *error;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_string (&p, &error))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &id,
SPA_POD_TYPE_INT, &res,
SPA_POD_TYPE_STRING, &error,
0))
return;
pinos_core_notify_error (proxy, i1, i2, error);
pinos_core_notify_error (proxy, id, res, error);
}
static void
@ -234,13 +240,16 @@ core_demarshal_remove_id (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1;
SpaPODIter it;
uint32_t id;
if (!spa_pod_get_int (&p, &i1))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &id,
0))
return;
pinos_core_notify_remove_id (proxy, i1);
pinos_core_notify_remove_id (proxy, id);
}
static void
@ -249,29 +258,29 @@ module_demarshal_info (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
SpaDict props;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
PinosModuleInfo 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_string (&p, &info.name) ||
!spa_pod_get_string (&p, &info.filename) ||
!spa_pod_get_string (&p, &info.args) ||
!spa_pod_get_int (&p, &i2))
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_STRING, &info.name,
SPA_POD_TYPE_STRING, &info.filename,
SPA_POD_TYPE_STRING, &info.args,
SPA_POD_TYPE_INT, &props.n_items,
0))
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))
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return;
}
pinos_module_notify_info (proxy, &info);
@ -283,13 +292,16 @@ node_demarshal_done (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1;
SpaPODIter it;
uint32_t seq;
if (!spa_pod_get_int (&p, &i1))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
0))
return;
pinos_node_notify_done (proxy, i1);
pinos_node_notify_done (proxy, seq);
}
static void
@ -298,54 +310,52 @@ node_demarshal_info (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPODIter it;
SpaDict props;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
PinosNodeInfo info;
int32_t i1, i2, i3, i4;
int64_t l1;
int i;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_long (&p, &l1) ||
!spa_pod_get_string (&p, &info.name) ||
!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_int (&p, &i3) ||
!spa_pod_get_int (&p, &i4))
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_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))
return;
info.id = i1;
info.change_mask = l1;
info.max_inputs = i2;
info.n_inputs = i3;
info.n_input_formats = i4;
info.input_formats = alloca (info.n_input_formats * sizeof (SpaFormat*));
for (i = 0; i < info.n_input_formats; i++)
spa_pod_get_object (&p, (const SpaPOD**)&info.input_formats[i]);
spa_pod_iter_get (&it,
SPA_POD_TYPE_OBJECT, &info.input_formats[i], 0);
if (!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_int (&p, &i3) ||
!spa_pod_get_int (&p, &i4))
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;
info.max_outputs = i2;
info.n_outputs = i3;
info.n_output_formats = i4;
info.output_formats = alloca (info.n_output_formats * sizeof (SpaFormat*));
for (i = 0; i < info.n_output_formats; i++)
spa_pod_get_object (&p, (const SpaPOD**)&info.output_formats[i]);
spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &info.output_formats[i], 0);
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_string (&p, &info.error) ||
!spa_pod_get_int (&p, &i2))
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;
info.state = i1;
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))
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_STRING, &props.items[i].key,
SPA_POD_TYPE_STRING, &props.items[i].value,
0))
return;
}
pinos_node_notify_info (proxy, &info);
@ -354,8 +364,8 @@ node_demarshal_info (void *object,
static void
client_node_marshal_update (void *object,
uint32_t change_mask,
unsigned int max_input_ports,
unsigned int max_output_ports,
uint32_t max_input_ports,
uint32_t max_output_ports,
const SpaProps *props)
{
PinosProxy *proxy = object;
@ -380,7 +390,7 @@ client_node_marshal_port_update (void *object,
SpaDirection direction,
uint32_t port_id,
uint32_t change_mask,
unsigned int n_possible_formats,
uint32_t n_possible_formats,
const SpaFormat **possible_formats,
const SpaFormat *format,
const SpaProps *props,
@ -481,17 +491,20 @@ client_node_demarshal_done (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
PinosConnection *connection = proxy->context->protocol_private;
int32_t i1, i2;
int32_t seq, idx;
int fd;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &idx,
0))
return;
fd = pinos_connection_get_fd (connection, i2);
pinos_client_node_notify_done (proxy, i1, fd);
fd = pinos_connection_get_fd (connection, idx);
pinos_client_node_notify_done (proxy, seq, fd);
}
static void
@ -500,11 +513,14 @@ client_node_demarshal_event (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
const SpaNodeEvent *event;
uint32_t s;
if (!spa_pod_get_bytes (&p, (const void**)&event, &s))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_BYTES, &event, &s,
0))
return;
pinos_client_node_notify_event (proxy, event);
@ -516,15 +532,18 @@ client_node_demarshal_add_port (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1, i2, i3;
SpaPODIter it;
int32_t seq, direction, port_id;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_int (&p, &i3))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id,
0))
return;
pinos_client_node_notify_add_port (proxy, i1, i2, i3);
pinos_client_node_notify_add_port (proxy, seq, direction, port_id);
}
static void
@ -533,15 +552,18 @@ client_node_demarshal_remove_port (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t i1, i2, i3;
SpaPODIter it;
int32_t seq, direction, port_id;
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2) ||
!spa_pod_get_int (&p, &i3))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id,
0))
return;
pinos_client_node_notify_remove_port (proxy, i1, i2, i3);
pinos_client_node_notify_remove_port (proxy, seq, direction, port_id);
}
static void
@ -550,18 +572,21 @@ client_node_demarshal_set_format (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq, direction, port_id, flags, have_format;
SpaPODIter it;
uint32_t seq, direction, port_id, flags, have_format;
const SpaFormat *format = NULL;
if (!spa_pod_get_int (&p, &seq) ||
!spa_pod_get_int (&p, &direction) ||
!spa_pod_get_int (&p, &port_id) ||
!spa_pod_get_int (&p, &flags) ||
!spa_pod_get_int (&p, &have_format))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
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, &have_format,
0))
return;
if (have_format && !spa_pod_get_object (&p, (const SpaPOD**)&format))
if (have_format && !spa_pod_iter_get (&it, SPA_POD_TYPE_OBJECT, &format, 0))
return;
pinos_client_node_notify_set_format (proxy, seq, direction, port_id,
@ -574,14 +599,17 @@ client_node_demarshal_set_property (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq, id;
SpaPODIter it;
uint32_t seq, id;
const void *value;
uint32_t s;
if (!spa_pod_get_int (&p, &seq) ||
!spa_pod_get_int (&p, &id) ||
!spa_pod_get_bytes (&p, &value, &s))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &id,
SPA_POD_TYPE_BYTES, &value, &s,
0))
return;
pinos_client_node_notify_set_property (proxy, seq, id, s, value);
@ -593,21 +621,25 @@ client_node_demarshal_add_mem (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
SpaPODIter it;
PinosConnection *connection = proxy->context->protocol_private;
int32_t direction, port_id, mem_id, type, memfd, flags, offset, sz;
uint32_t direction, port_id, mem_id, type, memfd_idx, flags, offset, sz;
int memfd;
if (!spa_pod_get_int (&p, &direction) ||
!spa_pod_get_int (&p, &port_id) ||
!spa_pod_get_int (&p, &mem_id) ||
!spa_pod_get_int (&p, &type) ||
!spa_pod_get_int (&p, &memfd) ||
!spa_pod_get_int (&p, &flags) ||
!spa_pod_get_int (&p, &offset) ||
!spa_pod_get_int (&p, &sz))
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, &mem_id,
SPA_POD_TYPE_INT, &type,
SPA_POD_TYPE_INT, &memfd_idx,
SPA_POD_TYPE_INT, &flags,
SPA_POD_TYPE_INT, &offset,
SPA_POD_TYPE_INT, &sz,
0))
return;
memfd = pinos_connection_get_fd (connection, memfd);
memfd = pinos_connection_get_fd (connection, memfd_idx);
pinos_client_node_notify_add_mem (proxy,
direction,
@ -626,66 +658,60 @@ client_node_demarshal_use_buffers (void *object,
size_t size)
{
PinosProxy *proxy = object;
SpaPOD *p = SPA_POD_CONTENTS (SpaPODStruct, data);
int32_t seq, direction, port_id, n_buffers;
SpaPODIter it;
uint32_t seq, direction, port_id, n_buffers, data_id;
PinosClientNodeBuffer *buffers;
int i, j;
if (!spa_pod_get_int (&p, &seq) ||
!spa_pod_get_int (&p, &direction) ||
!spa_pod_get_int (&p, &port_id) ||
!spa_pod_get_int (&p, &n_buffers))
if (!spa_pod_iter_struct (&it, data, size) ||
!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &seq,
SPA_POD_TYPE_INT, &direction,
SPA_POD_TYPE_INT, &port_id,
SPA_POD_TYPE_INT, &n_buffers,
0))
return;
buffers = alloca (sizeof (PinosClientNodeBuffer) * n_buffers);
for (i = 0; i < n_buffers; i++) {
SpaBuffer *buf = buffers[i].buffer = alloca (sizeof (SpaBuffer));
int32_t i1, i2, i3, i4, i5;
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) ||
!spa_pod_get_int (&p, &i5))
if (!spa_pod_iter_get (&it,
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))
return;
buffers[i].mem_id = i1;
buffers[i].offset = i2;
buffers[i].size = i3;
buf->id = i4;
buf->n_metas = i5;
buf->metas = alloca (sizeof (SpaMeta) * buf->n_metas);
for (j = 0; j < buf->n_metas; j++) {
SpaMeta *m = &buf->metas[j];
if (!spa_pod_get_int (&p, &i1) ||
!spa_pod_get_int (&p, &i2))
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &m->type,
SPA_POD_TYPE_INT, &size, 0))
return;
m->type = i1;
m->size = i2;
m->size = size;
}
if (!spa_pod_get_int (&p, &i1))
if (!spa_pod_iter_get (&it, SPA_POD_TYPE_INT, &buf->n_datas, 0))
return;
buf->n_datas = i1;
buf->datas = alloca (sizeof (SpaData) * buf->n_datas);
for (j = 0; j < buf->n_datas; j++) {
SpaData *d = &buf->datas[j];
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) ||
!spa_pod_get_int (&p, &i5))
if (!spa_pod_iter_get (&it,
SPA_POD_TYPE_INT, &d->type,
SPA_POD_TYPE_INT, &data_id,
SPA_POD_TYPE_INT, &d->flags,
SPA_POD_TYPE_INT, &d->mapoffset,
SPA_POD_TYPE_INT, &d->maxsize,
0))
return;
d->type = i1;
d->data = SPA_UINT32_TO_PTR (i2);
d->flags = i3;
d->mapoffset = i4;
d->maxsize = i5;
d->data = SPA_UINT32_TO_PTR (data_id);
}
}
pinos_client_node_notify_use_buffers (proxy,

34
pinos/client/stream.c
View file

@ -47,8 +47,8 @@ typedef struct {
int fd;
uint32_t flags;
void *ptr;
off_t offset;
size_t size;
uint32_t offset;
uint32_t size;
} MemId;
typedef struct {
@ -66,7 +66,7 @@ typedef struct
uint32_t seq;
unsigned int n_possible_formats;
uint32_t n_possible_formats;
SpaFormat **possible_formats;
SpaFormat *format;
@ -310,7 +310,7 @@ static void
add_node_update (PinosStream *stream, uint32_t change_mask, bool flush)
{
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
unsigned int max_input_ports = 0, max_output_ports = 0;
uint32_t max_input_ports = 0, max_output_ports = 0;
if (change_mask & PINOS_MESSAGE_NODE_UPDATE_MAX_INPUTS)
max_input_ports = impl->direction == SPA_DIRECTION_INPUT ? 1 : 0;
@ -724,7 +724,7 @@ static void
client_node_set_property (void *object,
uint32_t seq,
uint32_t id,
size_t size,
uint32_t size,
const void *value)
{
pinos_log_warn ("set property not implemented");
@ -738,8 +738,8 @@ client_node_add_mem (void *object,
SpaDataType type,
int memfd,
uint32_t flags,
off_t offset,
size_t size)
uint32_t offset,
uint32_t size)
{
PinosProxy *proxy = object;
PinosStream *stream = proxy->user_data;
@ -748,12 +748,12 @@ client_node_add_mem (void *object,
m = find_mem (stream, mem_id);
if (m) {
pinos_log_debug ("update mem %u, fd %d, flags %d, off %zd, size %zd",
pinos_log_debug ("update mem %u, fd %d, flags %d, off %d, size %d",
mem_id, memfd, flags, offset, size);
clear_memid (m);
} else {
m = pinos_array_add (&impl->mem_ids, sizeof (MemId));
pinos_log_debug ("add mem %u, fd %d, flags %d, off %zd, size %zd",
pinos_log_debug ("add mem %u, fd %d, flags %d, off %d, size %d",
mem_id, memfd, flags, offset, size);
}
m->id = mem_id;
@ -769,14 +769,14 @@ client_node_use_buffers (void *object,
uint32_t seq,
SpaDirection direction,
uint32_t port_id,
unsigned int n_buffers,
uint32_t n_buffers,
PinosClientNodeBuffer *buffers)
{
PinosProxy *proxy = object;
PinosStream *stream = proxy->user_data;
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
BufferId *bid;
unsigned int i, j, len;
uint32_t i, j, len;
SpaBuffer *b;
/* clear previous buffers */
@ -795,7 +795,7 @@ client_node_use_buffers (void *object,
mid->ptr = mmap (NULL, mid->size + mid->offset, PROT_READ | PROT_WRITE, MAP_SHARED, mid->fd, 0);
if (mid->ptr == MAP_FAILED) {
mid->ptr = NULL;
pinos_log_warn ("Failed to mmap memory %zd %p: %s", mid->size, mid, strerror (errno));
pinos_log_warn ("Failed to mmap memory %d %p: %s", mid->size, mid, strerror (errno));
continue;
}
mid->ptr = SPA_MEMBER (mid->ptr, mid->offset, void);
@ -820,7 +820,7 @@ client_node_use_buffers (void *object,
pinos_log_warn ("unexpected id %u found, expected %u", bid->id, len);
impl->in_order = false;
}
pinos_log_debug ("add buffer %d %d %zd", mid->id, bid->id, buffers[i].offset);
pinos_log_debug ("add buffer %d %d %u", mid->id, bid->id, buffers[i].offset);
for (j = 0; j < b->n_metas; j++) {
SpaMeta *m = &b->metas[j];
@ -893,8 +893,8 @@ client_node_port_command (void *object,
static void
client_node_transport (void *object,
int memfd,
off_t offset,
size_t size)
uint32_t offset,
uint32_t size)
{
PinosProxy *proxy = object;
PinosStream *stream = proxy->user_data;
@ -964,7 +964,7 @@ pinos_stream_connect (PinosStream *stream,
PinosStreamMode mode,
const char *port_path,
PinosStreamFlags flags,
unsigned int n_possible_formats,
uint32_t n_possible_formats,
SpaFormat **possible_formats)
{
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);
@ -1030,7 +1030,7 @@ bool
pinos_stream_finish_format (PinosStream *stream,
SpaResult res,
SpaAllocParam **params,
unsigned int n_params)
uint32_t n_params)
{
PinosStreamImpl *impl = SPA_CONTAINER_OF (stream, PinosStreamImpl, this);

4
pinos/client/stream.h
View file

@ -105,14 +105,14 @@ bool pinos_stream_connect (PinosStream *stream,
PinosStreamMode mode,
const char *port_path,
PinosStreamFlags flags,
unsigned int n_possible_formats,
uint32_t n_possible_formats,
SpaFormat **possible_formats);
bool pinos_stream_disconnect (PinosStream *stream);
bool pinos_stream_finish_format (PinosStream *stream,
SpaResult res,
SpaAllocParam **params,
unsigned int n_params);
uint32_t n_params);

4
pinos/client/transport.c
View file

@ -99,8 +99,8 @@ transport_setup_area (void *p, PinosTransport *trans)
}
PinosTransport *
pinos_transport_new (unsigned int max_inputs,
unsigned int max_outputs)
pinos_transport_new (uint32_t max_inputs,
uint32_t max_outputs)
{
PinosTransportImpl *impl;
PinosTransport *trans;

18
pinos/client/transport.h
View file

@ -37,9 +37,9 @@ typedef struct _PinosTransportArea PinosTransportArea;
#include <pinos/client/sig.h>
typedef struct {
int memfd;
off_t offset;
size_t size;
int memfd;
uint32_t offset;
uint32_t size;
} PinosTransportInfo;
/**
@ -48,10 +48,10 @@ typedef struct {
* Shared structure between client and server
*/
struct _PinosTransportArea {
unsigned int max_inputs;
unsigned int n_inputs;
unsigned int max_outputs;
unsigned int n_outputs;
uint32_t max_inputs;
uint32_t n_inputs;
uint32_t max_outputs;
uint32_t n_outputs;
};
struct _PinosTransport {
@ -67,8 +67,8 @@ struct _PinosTransport {
SpaRingbuffer *output_buffer;
};
PinosTransport * pinos_transport_new (unsigned int max_inputs,
unsigned int max_outputs);
PinosTransport * pinos_transport_new (uint32_t max_inputs,
uint32_t max_outputs);
PinosTransport * pinos_transport_new_from_info (PinosTransportInfo *info);
void pinos_transport_destroy (PinosTransport *trans);

4
pinos/gst/gstpinosformat.c
View file

@ -353,8 +353,8 @@ handle_audio_fields (ConvertData *d)
return TRUE;
}
static off_t
write_pod (SpaPODBuilder *b, off_t ref, const void *data, size_t size)
static uint32_t
write_pod (SpaPODBuilder *b, uint32_t ref, const void *data, uint32_t size)
{
if (ref == -1)
ref = b->offset;

2
pinos/gst/gstpinossink.c
View file

@ -369,7 +369,7 @@ on_add_buffer (PinosListener *listener,
GstPinosSink *pinossink = SPA_CONTAINER_OF (listener, GstPinosSink, stream_add_buffer);
SpaBuffer *b;
GstBuffer *buf;
unsigned int i;
uint32_t i;
ProcessMemData data;
GST_LOG_OBJECT (pinossink, "add buffer");

2
pinos/gst/gstpinossrc.c
View file

@ -386,7 +386,7 @@ on_add_buffer (PinosListener *listener,
GstPinosSrc *pinossrc = SPA_CONTAINER_OF (listener, GstPinosSrc, stream_add_buffer);
SpaBuffer *b;
GstBuffer *buf;
unsigned int i;
uint32_t i;
ProcessMemData data;
GST_LOG_OBJECT (pinossrc, "add buffer");

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

@ -141,7 +141,7 @@ connection_data (SpaSource *source,
PinosConnection *conn = client->connection;
uint8_t opcode;
uint32_t id;
size_t size;
uint32_t size;
PinosClient *c = client->client;
void *message;

4
pinos/modules/spa/spa-monitor.c
View file

@ -84,7 +84,7 @@ add_item (PinosSpaMonitor *this, SpaMonitorItem *item)
props = pinos_properties_new (NULL, NULL);
if (item->info) {
unsigned int i;
uint32_t i;
for (i = 0; i < item->info->n_items; i++) {
pinos_properties_set (props,
@ -203,7 +203,7 @@ pinos_spa_monitor_load (PinosCore *core,
SpaResult res;
void *iface;
void *hnd;
unsigned int index;
uint32_t index;
SpaEnumHandleFactoryFunc enum_func;
const SpaHandleFactory *factory;

2
pinos/modules/spa/spa-node.c
View file

@ -47,7 +47,7 @@ pinos_spa_node_load (PinosCore *core,
SpaResult res;
SpaHandle *handle;
void *hnd;
unsigned int index;
uint32_t index;
SpaEnumHandleFactoryFunc enum_func;
const SpaHandleFactory *factory;
void *iface;

44
pinos/server/client-node.c
View file

@ -72,11 +72,11 @@ typedef struct {
bool valid;
SpaPortInfo *info;
SpaFormat *format;
unsigned int n_formats;
uint32_t n_formats;
SpaFormat **formats;
void *io;
unsigned int n_buffers;
uint32_t n_buffers;
ProxyBuffer buffers[MAX_BUFFERS];
uint32_t buffer_mem_id;
@ -101,10 +101,10 @@ struct _SpaProxy
SpaSource data_source;
unsigned int max_inputs;
unsigned int n_inputs;
unsigned int max_outputs;
unsigned int n_outputs;
uint32_t max_inputs;
uint32_t n_inputs;
uint32_t max_outputs;
uint32_t n_outputs;
SpaProxyPort in_ports[MAX_INPUTS];
SpaProxyPort out_ports[MAX_OUTPUTS];
@ -254,10 +254,10 @@ spa_proxy_node_set_event_callback (SpaNode *node,
static SpaResult
spa_proxy_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
SpaProxy *this;
@ -280,9 +280,9 @@ spa_proxy_node_get_n_ports (SpaNode *node,
static SpaResult
spa_proxy_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
SpaProxy *this;
@ -313,14 +313,14 @@ do_update_port (SpaProxy *this,
SpaDirection direction,
uint32_t port_id,
uint32_t change_mask,
unsigned int n_possible_formats,
uint32_t n_possible_formats,
const SpaFormat **possible_formats,
const SpaFormat *format,
const SpaProps *props,
const SpaPortInfo *info)
{
SpaProxyPort *port;
unsigned int i;
uint32_t i;
size_t size;
if (direction == SPA_DIRECTION_INPUT) {
@ -459,7 +459,7 @@ spa_proxy_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaProxy *this;
SpaProxyPort *port;
@ -630,7 +630,7 @@ spa_proxy_node_port_use_buffers (SpaNode *node,
{
SpaProxy *this;
SpaProxyPort *port;
unsigned int i, j;
uint32_t i, j;
size_t n_mem;
PinosClientNodeBuffer *mb;
SpaMetaShared *msh;
@ -886,8 +886,8 @@ handle_node_event (SpaProxy *this,
static void
client_node_update (void *object,
uint32_t change_mask,
unsigned int max_input_ports,
unsigned int max_output_ports,
uint32_t max_input_ports,
uint32_t max_output_ports,
const SpaProps *props)
{
PinosResource *resource = object;
@ -909,7 +909,7 @@ client_node_port_update (void *object,
SpaDirection direction,
uint32_t port_id,
uint32_t change_mask,
unsigned int n_possible_formats,
uint32_t n_possible_formats,
const SpaFormat **possible_formats,
const SpaFormat *format,
const SpaProps *props,
@ -1044,9 +1044,9 @@ static SpaResult
proxy_init (SpaProxy *this,
SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
unsigned int i;
uint32_t i;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_LOG_URI) == 0)
@ -1114,7 +1114,7 @@ on_global_added (PinosListener *listener,
static SpaResult
proxy_clear (SpaProxy *this)
{
unsigned int i;
uint32_t i;
for (i = 0; i < MAX_INPUTS; i++) {
if (this->in_ports[i].valid)

2
pinos/server/client.c
View file

@ -171,7 +171,7 @@ pinos_client_update_properties (PinosClient *client,
if (dict)
client->properties = pinos_properties_new_dict (dict);
} else {
unsigned int i;
uint32_t i;
for (i = 0; i < dict->n_items; i++)
pinos_properties_set (client->properties,

8
pinos/server/core.c
View file

@ -435,7 +435,7 @@ pinos_core_update_properties (PinosCore *core,
if (dict)
core->properties = pinos_properties_new_dict (dict);
} else if (dict != &core->properties->dict) {
unsigned int i;
uint32_t i;
for (i = 0; i < dict->n_items; i++)
pinos_properties_set (core->properties,
@ -456,7 +456,7 @@ pinos_core_find_port (PinosCore *core,
PinosPort *other_port,
uint32_t id,
PinosProperties *props,
unsigned int n_format_filters,
uint32_t n_format_filters,
SpaFormat **format_filters,
char **error)
{
@ -520,14 +520,14 @@ pinos_core_find_format (PinosCore *core,
PinosPort *output,
PinosPort *input,
PinosProperties *props,
unsigned int n_format_filters,
uint32_t n_format_filters,
SpaFormat **format_filterss,
char **error)
{
SpaNodeState out_state, in_state;
SpaResult res;
SpaFormat *filter = NULL, *format;
unsigned int iidx = 0, oidx = 0;
uint32_t iidx = 0, oidx = 0;
out_state = output->node->node->state;
in_state = input->node->node->state;

6
pinos/server/core.h
View file

@ -85,7 +85,7 @@ struct _PinosCore {
PinosDataLoop *data_loop;
SpaSupport *support;
unsigned int n_support;
uint32_t n_support;
PINOS_SIGNAL (destroy_signal, (PinosListener *listener,
PinosCore *core));
@ -122,7 +122,7 @@ SpaFormat * pinos_core_find_format (PinosCore *core,
PinosPort *output,
PinosPort *input,
PinosProperties *props,
unsigned int n_format_filters,
uint32_t n_format_filters,
SpaFormat **format_filters,
char **error);
@ -130,7 +130,7 @@ PinosPort * pinos_core_find_port (PinosCore *core,
PinosPort *other_port,
uint32_t id,
PinosProperties *props,
unsigned int n_format_filters,
uint32_t n_format_filters,
SpaFormat **format_filters,
char **error);

18
pinos/server/link.c
View file

@ -49,7 +49,7 @@ typedef struct
bool allocated;
PinosMemblock buffer_mem;
SpaBuffer **buffers;
unsigned int n_buffers;
uint32_t n_buffers;
} PinosLinkImpl;
static void
@ -142,7 +142,7 @@ error:
static void *
find_param (const SpaPortInfo *info, SpaAllocParamType type)
{
unsigned int i;
uint32_t i;
for (i = 0; i < info->n_params; i++) {
if (info->params[i]->type == type)
@ -154,7 +154,7 @@ find_param (const SpaPortInfo *info, SpaAllocParamType type)
static void *
find_meta_enable (const SpaPortInfo *info, SpaMetaType type)
{
unsigned int i;
uint32_t i;
for (i = 0; i < info->n_params; i++) {
if (info->params[i]->type == SPA_ALLOC_PARAM_TYPE_META_ENABLE &&
@ -167,20 +167,20 @@ find_meta_enable (const SpaPortInfo *info, SpaMetaType type)
static SpaBuffer **
alloc_buffers (PinosLink *this,
unsigned int n_buffers,
unsigned int n_params,
uint32_t n_buffers,
uint32_t n_params,
SpaAllocParam **params,
unsigned int n_datas,
uint32_t n_datas,
size_t *data_sizes,
ssize_t *data_strides,
PinosMemblock *mem)
{
SpaBuffer **buffers, *bp;
unsigned int i;
uint32_t i;
size_t skel_size, data_size, meta_size;
SpaChunk *cdp;
void *ddp;
unsigned int n_metas;
uint32_t n_metas;
SpaMeta *metas;
n_metas = data_size = meta_size = 0;
@ -382,7 +382,7 @@ do_allocation (PinosLink *this, SpaNodeState in_state, SpaNodeState out_state)
if (impl->buffers == NULL) {
SpaAllocParamBuffers *in_alloc, *out_alloc;
SpaAllocParamMetaEnableRingbuffer *in_me, *out_me;
unsigned int max_buffers;
uint32_t max_buffers;
size_t minsize, stride, blocks;
in_me = find_meta_enable (iinfo, SPA_META_TYPE_RINGBUFFER);

2
pinos/server/link.h
View file

@ -69,7 +69,7 @@ struct _PinosLink {
PinosPort *port));
struct {
unsigned int in_ready;
uint32_t in_ready;
PinosPort *input;
PinosPort *output;
SpaList input_link;

8
pinos/server/node.c
View file

@ -45,8 +45,8 @@ update_port_ids (PinosNode *node, bool create)
{
PinosNodeImpl *impl = SPA_CONTAINER_OF (node, PinosNodeImpl, this);
uint32_t *input_port_ids, *output_port_ids;
unsigned int n_input_ports, n_output_ports, max_input_ports, max_output_ports;
unsigned int i;
uint32_t n_input_ports, n_output_ports, max_input_ports, max_output_ports;
uint32_t i;
SpaList *ports;
if (node->node == NULL)
@ -524,7 +524,7 @@ pinos_node_new (PinosCore *core,
spa_list_init (&this->output_ports);
if (this->node->info) {
unsigned int i;
uint32_t i;
if (this->properties == NULL)
this->properties = pinos_properties_new (NULL, NULL);
@ -681,7 +681,7 @@ PinosPort *
pinos_node_get_free_port (PinosNode *node,
PinosDirection direction)
{
unsigned int n_ports, max_ports;
uint32_t n_ports, max_ports;
SpaList *ports;
PinosPort *port = NULL, *p;

4
pinos/server/node.h
View file

@ -81,8 +81,8 @@ struct _PinosNode {
PinosPort **input_port_map;
PinosPort **output_port_map;
unsigned int n_used_output_links;
unsigned int n_used_input_links;
uint32_t n_used_output_links;
uint32_t n_used_input_links;
PinosTransport *transport;
PINOS_SIGNAL (transport_changed, (PinosListener *listener,

2
pinos/server/port.h
View file

@ -49,7 +49,7 @@ struct _PinosPort {
bool allocated;
PinosMemblock buffer_mem;
SpaBuffer **buffers;
unsigned int n_buffers;
uint32_t n_buffers;
SpaList links;

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

@ -27,8 +27,8 @@ typedef struct {
PinosConnection *connection;
} Builder;
static off_t
write_pod (SpaPODBuilder *b, off_t ref, const void *data, size_t size)
static uint32_t
write_pod (SpaPODBuilder *b, uint32_t ref, const void *data, uint32_t size)
{
if (ref == -1)
ref = b->offset;
@ -512,7 +512,7 @@ static void
client_node_marshal_set_property (void *object,
uint32_t seq,
uint32_t id,
size_t size,
uint32_t size,
const void *value)
{
PinosResource *resource = object;
@ -537,8 +537,8 @@ client_node_marshal_add_mem (void *object,
SpaDataType type,
int memfd,
uint32_t flags,
off_t offset,
size_t size)
uint32_t offset,
uint32_t size)
{
PinosResource *resource = object;
PinosConnection *connection = resource->client->protocol_private;
@ -564,7 +564,7 @@ client_node_marshal_use_buffers (void *object,
uint32_t seq,
SpaDirection direction,
uint32_t port_id,
unsigned int n_buffers,
uint32_t n_buffers,
PinosClientNodeBuffer *buffers)
{
PinosResource *resource = object;
@ -645,8 +645,8 @@ client_node_marshal_port_command (void *object,
static void
client_node_marshal_transport (void *object,
int memfd,
off_t offset,
size_t size)
uint32_t offset,
uint32_t size)
{
PinosResource *resource = object;
PinosConnection *connection = resource->client->protocol_private;

39
spa/include/spa/buffer.h
View file

@ -109,8 +109,8 @@ typedef struct {
* @height
*/
typedef struct {
int x, y;
int width, height;
int32_t x, y;
int32_t width, height;
} SpaMetaVideoCrop;
/**
@ -130,10 +130,10 @@ typedef struct {
*/
typedef struct {
SpaDataType type;
int flags;
int32_t flags;
int fd;
off_t offset;
size_t size;
int32_t offset;
uint32_t size;
} SpaMetaShared;
/**
@ -145,7 +145,7 @@ typedef struct {
typedef struct {
SpaMetaType type;
void *data;
size_t size;
uint32_t size;
} SpaMeta;
/**
@ -155,9 +155,9 @@ typedef struct {
* @stride: stride of data if applicable
*/
typedef struct {
off_t offset;
size_t size;
ssize_t stride;
uint32_t offset;
uint32_t size;
int32_t stride;
} SpaChunk;
/**
@ -172,10 +172,10 @@ typedef struct {
*/
typedef struct {
SpaDataType type;
int flags;
uint32_t flags;
int fd;
off_t mapoffset;
size_t maxsize;
uint32_t mapoffset;
uint32_t maxsize;
void *data;
SpaChunk *chunk;
} SpaData;
@ -190,22 +190,17 @@ typedef struct {
*/
struct _SpaBuffer {
uint32_t id;
unsigned int n_metas;
uint32_t n_metas;
SpaMeta *metas;
unsigned int n_datas;
uint32_t n_datas;
SpaData *datas;
};
typedef struct {
unsigned int n_buffers;
SpaBuffer **buffers;
} SpaBufferArray;
static inline void *
spa_buffer_find_meta (SpaBuffer *b, SpaMetaType type)
{
unsigned int i;
uint32_t i;
for (i = 0; i < b->n_metas; i++)
if (b->metas[i].type == type)
@ -213,10 +208,10 @@ spa_buffer_find_meta (SpaBuffer *b, SpaMetaType type)
return NULL;
}
static inline size_t
static inline uint32_t
spa_meta_type_get_size (SpaMetaType type)
{
static const size_t header_sizes[] = {
static const uint32_t header_sizes[] = {
0,
sizeof (SpaMetaHeader),
sizeof (SpaMetaPointer),

2
spa/include/spa/dict.h
View file

@ -36,7 +36,7 @@ typedef struct {
} SpaDictItem;
struct _SpaDict {
unsigned int n_items;
uint32_t n_items;
SpaDictItem *items;
};

6
spa/include/spa/format-builder.h
View file

@ -29,7 +29,7 @@ extern "C" {
#include <spa/format.h>
#include <spa/pod-builder.h>
static inline off_t
static inline uint32_t
spa_pod_builder_push_format (SpaPODBuilder *builder,
SpaPODFrame *frame,
uint32_t media_type,
@ -43,7 +43,7 @@ spa_pod_builder_push_format (SpaPODBuilder *builder,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
}
static inline off_t
static inline uint32_t
spa_pod_builder_format (SpaPODBuilder *builder,
uint32_t media_type,
uint32_t media_subtype,
@ -51,7 +51,7 @@ spa_pod_builder_format (SpaPODBuilder *builder,
{
SpaPODFrame f;
va_list args;
off_t off;
uint32_t off;
off = spa_pod_builder_push_format (builder, &f, media_type, media_subtype);

2
spa/include/spa/id-map.h
View file

@ -39,7 +39,7 @@ typedef struct _SpaIDMap SpaIDMap;
struct _SpaIDMap {
/* the total size of this structure. This can be used to expand this
* structure in the future */
size_t size;
const size_t size;
/**
* SpaIDMap::info
*

4
spa/include/spa/monitor.h
View file

@ -49,7 +49,7 @@ typedef enum {
typedef struct {
SpaMonitorEventType type;
size_t size;
uint32_t size;
} SpaMonitorEvent;
typedef enum {
@ -126,7 +126,7 @@ struct _SpaMonitor {
SpaResult (*enum_items) (SpaMonitor *monitor,
SpaMonitorItem **item,
unsigned int index);
uint32_t index);
};

2
spa/include/spa/node-command.h
View file

@ -51,7 +51,7 @@ typedef enum {
struct _SpaNodeCommand {
SpaNodeCommandType type;
size_t size;
uint32_t size;
};
/**

2
spa/include/spa/node-event.h
View file

@ -67,7 +67,7 @@ typedef enum {
struct _SpaNodeEvent {
SpaNodeEventType type;
size_t size;
uint32_t size;
};
typedef struct {

20
spa/include/spa/node.h
View file

@ -270,10 +270,10 @@ struct _SpaNode {
* #SPA_RESULT_INVALID_ARGUMENTS when node is %NULL
*/
SpaResult (*get_n_ports) (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports);
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports);
/**
* SpaNode::get_port_ids:
* @node: a #SpaNode
@ -290,9 +290,9 @@ struct _SpaNode {
* #SPA_RESULT_INVALID_ARGUMENTS when node is %NULL
*/
SpaResult (*get_port_ids) (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids);
/**
@ -350,7 +350,7 @@ struct _SpaNode {
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index);
uint32_t index);
/**
* SpaNode::port_set_format:
* @node: a #SpaNode
@ -459,7 +459,7 @@ struct _SpaNode {
SpaDirection direction,
uint32_t port_id,
SpaBuffer **buffers,
unsigned int n_buffers);
uint32_t n_buffers);
/**
* SpaNode::port_alloc_buffers:
* @node: a #SpaNode
@ -499,9 +499,9 @@ struct _SpaNode {
SpaDirection direction,
uint32_t port_id,
SpaAllocParam **params,
unsigned int n_params,
uint32_t n_params,
SpaBuffer **buffers,
unsigned int *n_buffers);
uint32_t *n_buffers);
/**
* SpaNode::port_set_input:

8
spa/include/spa/plugin.h
View file

@ -130,7 +130,7 @@ struct _SpaHandleFactory {
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support);
uint32_t n_support);
/**
* SpaHandle::enum_interface_info:
@ -147,7 +147,7 @@ struct _SpaHandleFactory {
*/
SpaResult (*enum_interface_info) (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index);
uint32_t index);
};
#define spa_handle_factory_init(h,...) (h)->init((h),__VA_ARGS__)
@ -165,7 +165,7 @@ struct _SpaHandleFactory {
* #SPA_RESULT_ENUM_END when there are no more factories
*/
typedef SpaResult (*SpaEnumHandleFactoryFunc) (const SpaHandleFactory **factory,
unsigned int index);
uint32_t index);
/**
* spa_enum_handle_factory:
@ -179,7 +179,7 @@ typedef SpaResult (*SpaEnumHandleFactoryFunc) (const SpaHandleFactory **factory,
* #SPA_RESULT_ENUM_END when there are no more factories
*/
SpaResult spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index);
uint32_t index);
#ifdef __cplusplus
} /* extern "C" */

70
spa/include/spa/pod-builder.h
View file

@ -30,15 +30,15 @@ extern "C" {
typedef struct _SpaPODFrame {
struct _SpaPODFrame *parent;
SpaPOD pod;
off_t ref;
uint32_t ref;
} SpaPODFrame;
typedef struct _SpaPODBuilder {
void *data;
size_t size;
off_t offset;
uint32_t size;
uint32_t offset;
SpaPODFrame *stack;
off_t (*write) (struct _SpaPODBuilder *builder, off_t ref, const void *data, size_t size);
uint32_t (*write) (struct _SpaPODBuilder *builder, uint32_t ref, const void *data, uint32_t size);
} SpaPODBuilder;
#define SPA_POD_BUILDER_DEREF(b,ref,type) SPA_MEMBER ((b)->data, (ref), type)
@ -46,7 +46,7 @@ typedef struct _SpaPODBuilder {
static inline void
spa_pod_builder_init (SpaPODBuilder *builder,
void *data,
size_t size)
uint32_t size)
{
builder->data = data;
builder->size = size;
@ -71,11 +71,11 @@ spa_pod_builder_in_array (SpaPODBuilder *builder, bool *first)
return false;
}
static inline off_t
static inline uint32_t
spa_pod_builder_push (SpaPODBuilder *builder,
SpaPODFrame *frame,
const SpaPOD *pod,
off_t ref)
uint32_t ref)
{
frame->parent = builder->stack;
frame->pod = *pod;
@ -113,10 +113,10 @@ spa_pod_builder_pop (SpaPODBuilder *builder,
spa_pod_builder_advance (builder, SPA_ROUND_UP_N(builder->offset, 8) - builder->offset, false);
}
static inline off_t
static inline uint32_t
spa_pod_builder_raw (SpaPODBuilder *builder, const void *data, uint32_t size, bool pad)
{
off_t ref;
uint32_t ref;
if (builder->write) {
ref = builder->write (builder, -1, data, size);
@ -132,29 +132,29 @@ spa_pod_builder_raw (SpaPODBuilder *builder, const void *data, uint32_t size, bo
return ref;
}
static inline off_t
static inline uint32_t
spa_pod_builder_string_body (SpaPODBuilder *builder,
const char *str,
uint32_t len)
{
off_t out = spa_pod_builder_raw (builder, str, len + 1 , true);
uint32_t out = spa_pod_builder_raw (builder, str, len + 1 , true);
if (out != -1)
*SPA_MEMBER (builder->data, out + len, char) = '\0';
return out;
}
static inline off_t
static inline uint32_t
spa_pod_builder_pod (SpaPODBuilder *builder, uint32_t size, uint32_t type)
{
const SpaPOD p = { size, type };
return spa_pod_builder_raw (builder, &p, sizeof (p), false);
}
static inline off_t
static inline uint32_t
spa_pod_builder_primitive (SpaPODBuilder *builder, const SpaPOD *p)
{
const void *data;
size_t size;
uint32_t size;
bool in_array, first = false;
in_array = spa_pod_builder_in_array (builder, &first);
@ -168,90 +168,90 @@ spa_pod_builder_primitive (SpaPODBuilder *builder, const SpaPOD *p)
return spa_pod_builder_raw (builder, data, size, !in_array);
}
static inline off_t
static inline uint32_t
spa_pod_builder_bool (SpaPODBuilder *builder, bool val)
{
const SpaPODBool p = { { sizeof (uint32_t), SPA_POD_TYPE_BOOL }, val ? 1 : 0 };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_uri (SpaPODBuilder *builder, uint32_t val)
{
const SpaPODURI p = { { sizeof (uint32_t), SPA_POD_TYPE_URI }, val };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_int (SpaPODBuilder *builder, int32_t val)
{
const SpaPODInt p = { { sizeof (uint32_t), SPA_POD_TYPE_INT }, val };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_long (SpaPODBuilder *builder, int64_t val)
{
const SpaPODLong p = { { sizeof (val), SPA_POD_TYPE_LONG }, val };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_float (SpaPODBuilder *builder, float val)
{
const SpaPODFloat p = { { sizeof (val), SPA_POD_TYPE_FLOAT }, val };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_double (SpaPODBuilder *builder, double val)
{
const SpaPODDouble p = { { sizeof (val), SPA_POD_TYPE_DOUBLE }, val };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_string_len (SpaPODBuilder *builder, const char *str, uint32_t len)
{
const SpaPODString p = { { len + 1, SPA_POD_TYPE_STRING } };
off_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
if (spa_pod_builder_string_body (builder, str, len) == -1)
out = -1;
return out;
}
static inline off_t
static inline uint32_t
spa_pod_builder_string (SpaPODBuilder *builder, const char *str)
{
uint32_t len = str ? strlen (str) : 0;
return spa_pod_builder_string_len (builder, str ? str : "", len);
}
static inline off_t
static inline uint32_t
spa_pod_builder_bytes (SpaPODBuilder *builder, const void *bytes, uint32_t len)
{
const SpaPODBytes p = { { len, SPA_POD_TYPE_BYTES } };
off_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
if (spa_pod_builder_raw (builder, bytes, len, true) == -1)
out = -1;
return out;
}
static inline off_t
static inline uint32_t
spa_pod_builder_rectangle (SpaPODBuilder *builder, uint32_t width, uint32_t height)
{
const SpaPODRectangle p = { { sizeof (SpaRectangle), SPA_POD_TYPE_RECTANGLE }, { width, height } };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_fraction (SpaPODBuilder *builder, uint32_t num, uint32_t denom)
{
const SpaPODFraction p = { { sizeof (SpaFraction), SPA_POD_TYPE_FRACTION }, { num, denom } };
return spa_pod_builder_primitive (builder, &p.pod);
}
static inline off_t
static inline uint32_t
spa_pod_builder_push_array (SpaPODBuilder *builder,
SpaPODFrame *frame)
{
@ -260,7 +260,7 @@ spa_pod_builder_push_array (SpaPODBuilder *builder,
spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD), false));
}
static inline off_t
static inline uint32_t
spa_pod_builder_array (SpaPODBuilder *builder,
uint32_t child_size,
uint32_t child_type,
@ -271,13 +271,13 @@ spa_pod_builder_array (SpaPODBuilder *builder,
{ (uint32_t)(sizeof (SpaPODArrayBody) + n_elems * child_size), SPA_POD_TYPE_ARRAY },
{ { child_size, child_type } }
};
off_t out = spa_pod_builder_raw (builder, &p, sizeof(p), true);
uint32_t out = spa_pod_builder_raw (builder, &p, sizeof(p), true);
if (spa_pod_builder_raw (builder, elems, child_size * n_elems, true) == -1)
out = -1;
return out;
}
static inline off_t
static inline uint32_t
spa_pod_builder_push_struct (SpaPODBuilder *builder,
SpaPODFrame *frame)
{
@ -286,7 +286,7 @@ spa_pod_builder_push_struct (SpaPODBuilder *builder,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
}
static inline off_t
static inline uint32_t
spa_pod_builder_push_object (SpaPODBuilder *builder,
SpaPODFrame *frame,
uint32_t id,
@ -297,7 +297,7 @@ spa_pod_builder_push_object (SpaPODBuilder *builder,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
}
static inline off_t
static inline uint32_t
spa_pod_builder_push_prop (SpaPODBuilder *builder,
SpaPODFrame *frame,
uint32_t key,
@ -315,10 +315,10 @@ spa_pod_builder_propv (SpaPODBuilder *builder,
va_list args)
{
while (propid != 0) {
int type, n_alternatives = -1;
uint32_t type, n_alternatives = -1;
SpaPODProp *prop = NULL;
SpaPODFrame f;
off_t off;
uint32_t off;
if ((off = spa_pod_builder_push_prop (builder, &f, propid, SPA_POD_PROP_FLAG_READWRITE)) != -1)
prop = SPA_MEMBER (builder->data, off, SpaPODProp);

177
spa/include/spa/pod-iter.h Normal file
View file

@ -0,0 +1,177 @@
/* Simple Plugin API
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_POD_ITER_H__
#define __SPA_POD_ITER_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <stdarg.h>
#include <spa/defs.h>
#include <spa/pod.h>
typedef struct {
const void *data;
uint32_t size;
uint32_t offset;
} SpaPODIter;
static inline void
spa_pod_iter_contents (SpaPODIter *iter, const void *data, uint32_t size)
{
iter->data = data;
iter->size = size;
iter->offset = 0;
}
static inline bool
spa_pod_iter_struct (SpaPODIter *iter, const void *data, uint32_t size)
{
if (data == NULL || size < 8 || SPA_POD_SIZE (data) > size || SPA_POD_TYPE (data) != SPA_POD_TYPE_STRUCT)
return false;
spa_pod_iter_contents (iter, SPA_POD_CONTENTS (SpaPODStruct, data),
SPA_POD_CONTENTS_SIZE (SpaPODStruct, data));
return true;
}
static inline bool
spa_pod_iter_object (SpaPODIter *iter, const void *data, uint32_t size)
{
if (data == NULL || SPA_POD_SIZE (data) > size || SPA_POD_TYPE (data) != SPA_POD_TYPE_OBJECT)
return false;
spa_pod_iter_contents (iter, SPA_POD_CONTENTS (SpaPODObject, data),
SPA_POD_CONTENTS_SIZE (SpaPODObject, data));
return true;
}
static inline bool
spa_pod_iter_pod (SpaPODIter *iter, SpaPOD *pod)
{
void *data;
uint32_t size;
switch (SPA_POD_TYPE (pod)) {
case SPA_POD_TYPE_STRUCT:
data = SPA_POD_CONTENTS (SpaPODStruct, pod);
size = SPA_POD_CONTENTS_SIZE (SpaPODStruct, pod);
break;
case SPA_POD_TYPE_OBJECT:
data = SPA_POD_CONTENTS (SpaPODObject, pod);
size = SPA_POD_CONTENTS_SIZE (SpaPODObject, pod);
break;
default:
return false;
}
spa_pod_iter_contents (iter, data, size);
return true;
}
static inline bool
spa_pod_iter_has_next (SpaPODIter *iter)
{
return (iter->offset + 8 <= iter->size &&
SPA_POD_SIZE (SPA_MEMBER (iter->data, iter->offset, SpaPOD)) <= iter->size);
}
static inline SpaPOD *
spa_pod_iter_next (SpaPODIter *iter)
{
SpaPOD *res = SPA_MEMBER (iter->data, iter->offset, SpaPOD);
iter->offset += SPA_ROUND_UP_N (SPA_POD_SIZE (res), 8);
return res;
}
static inline bool
spa_pod_iter_getv (SpaPODIter *iter,
uint32_t type,
va_list args)
{
while (type && spa_pod_iter_has_next (iter)) {
SpaPOD *pod = spa_pod_iter_next (iter);
if (pod->type != type)
return false;
switch (type) {
case SPA_POD_TYPE_BOOL:
case SPA_POD_TYPE_URI:
case SPA_POD_TYPE_INT:
*(va_arg (args, int32_t*)) = ((SpaPODInt *)(pod))->value;
break;
case SPA_POD_TYPE_LONG:
*(va_arg (args, int64_t*)) = ((SpaPODLong *)(pod))->value;
break;
case SPA_POD_TYPE_FLOAT:
*(va_arg (args, float*)) = ((SpaPODFloat *)(pod))->value;
break;
case SPA_POD_TYPE_DOUBLE:
*(va_arg (args, double*)) = ((SpaPODDouble *)(pod))->value;
break;
case SPA_POD_TYPE_STRING:
*(va_arg (args, char **)) = SPA_POD_CONTENTS (SpaPODString, pod);
break;
case SPA_POD_TYPE_RECTANGLE:
*(va_arg (args, SpaRectangle *)) = ((SpaPODRectangle *)(pod))->value;
break;
case SPA_POD_TYPE_FRACTION:
*(va_arg (args, SpaFraction *)) = ((SpaPODFraction *)(pod))->value;
break;
case SPA_POD_TYPE_BITMASK:
*(va_arg (args, uint32_t **)) = SPA_POD_CONTENTS (SpaPOD, pod);
break;
case SPA_POD_TYPE_ARRAY:
case SPA_POD_TYPE_STRUCT:
case SPA_POD_TYPE_OBJECT:
case SPA_POD_TYPE_PROP:
*(va_arg (args, SpaPOD **)) = pod;
break;
case SPA_POD_TYPE_BYTES:
*(va_arg (args, void **)) = SPA_POD_CONTENTS (SpaPODBytes, pod);
*(va_arg (args, uint32_t *)) = SPA_POD_BODY_SIZE (pod);
break;
default:
case SPA_POD_TYPE_INVALID:
return false;
}
type = va_arg (args, uint32_t);
}
return true;
}
static inline bool
spa_pod_iter_get (SpaPODIter *iter, uint32_t type, ...)
{
va_list args;
bool res;
va_start (args, type);
res = spa_pod_iter_getv (iter, type, args);
va_end (args);
return res;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_POD_H__ */

11
spa/include/spa/pod.h
View file

@ -57,6 +57,7 @@ typedef struct {
} SpaPOD;
#define SPA_POD_BODY_SIZE(pod) (((SpaPOD*)(pod))->size)
#define SPA_POD_TYPE(pod) (((SpaPOD*)(pod))->type)
#define SPA_POD_SIZE(pod) (sizeof(SpaPOD) + SPA_POD_BODY_SIZE(pod))
#define SPA_POD_CONTENTS_SIZE(type,pod) (SPA_POD_SIZE(pod)-sizeof(type))
@ -228,10 +229,10 @@ spa_pod_get_bytes (SpaPOD **pod, const void **val, uint32_t *size)
}
#define SPA_POD_ARRAY_BODY_FOREACH(body, size, iter) \
for ((iter) = SPA_MEMBER (body, sizeof(SpaPODArrayBody), __typeof__(*iter)); \
(iter) < SPA_MEMBER (body, (size), __typeof__(*iter)); \
(iter) = SPA_MEMBER ((iter), (body)->child.size, __typeof__(*iter)))
#define SPA_POD_ARRAY_BODY_FOREACH(body, _size, iter) \
for ((iter) = SPA_MEMBER ((body), sizeof(SpaPODArrayBody), __typeof__(*(iter))); \
(iter) < SPA_MEMBER ((body), (_size), __typeof__(*(iter))); \
(iter) = SPA_MEMBER ((iter), (body)->child.size, __typeof__(*(iter))))
#define SPA_POD_FOREACH(pod, size, iter) \
for ((iter) = (pod); \
@ -255,7 +256,7 @@ spa_pod_get_bytes (SpaPOD **pod, const void **val, uint32_t *size)
(iter) = SPA_MEMBER ((iter), (body)->value.size, __typeof__(*iter)))
static inline SpaPODProp *
spa_pod_contents_find_prop (const SpaPOD *pod, off_t offset, uint32_t key)
spa_pod_contents_find_prop (const SpaPOD *pod, uint32_t offset, uint32_t key)
{
SpaPOD *res;
SPA_POD_CONTENTS_FOREACH (pod, offset, res) {

24
spa/include/spa/port.h
View file

@ -53,13 +53,13 @@ typedef enum {
struct _SpaAllocParam {
uint32_t type;
size_t size;
uint32_t size;
};
typedef struct {
SpaAllocParam param;
size_t minsize;
size_t stride;
uint32_t minsize;
int32_t stride;
uint32_t min_buffers;
uint32_t max_buffers;
uint32_t align;
@ -73,19 +73,19 @@ typedef struct {
typedef struct {
SpaAllocParam param;
SpaMetaType type;
size_t minsize;
size_t stride;
size_t blocks;
uint32_t minsize;
int32_t stride;
uint32_t blocks;
uint32_t align;
} SpaAllocParamMetaEnableRingbuffer;
typedef struct {
SpaAllocParam param;
unsigned int padding_top;
unsigned int padding_bottom;
unsigned int padding_left;
unsigned int padding_right;
unsigned int stride_align[4];
uint32_t padding_top;
uint32_t padding_bottom;
uint32_t padding_left;
uint32_t padding_right;
uint32_t stride_align[4];
} SpaAllocParamVideoPadding;
/**
@ -128,7 +128,7 @@ typedef struct {
uint64_t maxbuffering;
uint64_t latency;
SpaAllocParam **params;
unsigned int n_params;
uint32_t n_params;
SpaDict *extra;
} SpaPortInfo;

6
spa/include/spa/props.h
View file

@ -33,20 +33,20 @@ typedef SpaPODObject SpaProps;
#define SPA_PROPS_PREFIX SPA_PROPS_URI "#"
static inline off_t
static inline uint32_t
spa_pod_builder_push_props (SpaPODBuilder *builder,
SpaPODFrame *frame)
{
return spa_pod_builder_push_object (builder, frame, 0, 0);
}
static inline off_t
static inline uint32_t
spa_pod_builder_props (SpaPODBuilder *builder,
uint32_t propid, ...)
{
SpaPODFrame f;
va_list args;
off_t off;
uint32_t off;
off = spa_pod_builder_push_props (builder, &f);

44
spa/include/spa/ringbuffer.h
View file

@ -35,8 +35,8 @@ typedef struct _SpaRingbuffer SpaRingbuffer;
#include <spa/barrier.h>
typedef struct {
off_t offset;
size_t len;
uint32_t offset;
uint32_t len;
} SpaRingbufferArea;
/**
@ -47,11 +47,11 @@ typedef struct {
* @size_mask: mask if @size is power of 2
*/
struct _SpaRingbuffer {
volatile size_t readindex;
volatile size_t writeindex;
size_t size;
size_t mask;
size_t mask2;
volatile uint32_t readindex;
volatile uint32_t writeindex;
uint32_t size;
uint32_t mask;
uint32_t mask2;
};
/**
@ -67,7 +67,7 @@ struct _SpaRingbuffer {
*/
static inline SpaResult
spa_ringbuffer_init (SpaRingbuffer *rbuf,
size_t size)
uint32_t size)
{
if (SPA_UNLIKELY ((size & (size - 1)) != 0))
return SPA_RESULT_ERROR;
@ -94,11 +94,11 @@ spa_ringbuffer_clear (SpaRingbuffer *rbuf)
rbuf->writeindex = 0;
}
static inline size_t
static inline uint32_t
spa_ringbuffer_get_read_offset (SpaRingbuffer *rbuf,
size_t *offset)
uint32_t *offset)
{
size_t avail, r;
uint32_t avail, r;
r = rbuf->readindex;
*offset = r & rbuf->mask;
@ -117,11 +117,11 @@ spa_ringbuffer_get_read_offset (SpaRingbuffer *rbuf,
* Fill @areas with pointers to read from. The total amount of
* bytes that can be read can be obtained by summing the areas len fields.
*/
static inline size_t
static inline uint32_t
spa_ringbuffer_get_read_areas (SpaRingbuffer *rbuf,
SpaRingbufferArea areas[2])
{
size_t avail, end, r;
uint32_t avail, end, r;
avail = spa_ringbuffer_get_read_offset (rbuf, &r);
end = r + avail;
@ -144,7 +144,7 @@ spa_ringbuffer_read_data (SpaRingbuffer *rbuf,
void *buffer,
SpaRingbufferArea areas[2],
void *data,
size_t size)
uint32_t size)
{
if (SPA_LIKELY (size < areas[0].len))
memcpy (data, buffer + areas[0].offset, size);
@ -163,17 +163,17 @@ spa_ringbuffer_read_data (SpaRingbuffer *rbuf,
*/
static inline void
spa_ringbuffer_read_advance (SpaRingbuffer *rbuf,
ssize_t len)
int32_t len)
{
spa_barrier_full();
rbuf->readindex = (rbuf->readindex + len) & rbuf->mask2;
}
static inline size_t
static inline uint32_t
spa_ringbuffer_get_write_offset (SpaRingbuffer *rbuf,
size_t *offset)
uint32_t *offset)
{
size_t avail, w;
uint32_t avail, w;
w = rbuf->writeindex;
*offset = w & rbuf->mask;
@ -191,11 +191,11 @@ spa_ringbuffer_get_write_offset (SpaRingbuffer *rbuf,
* Fill @areas with pointers to write to. The total amount of
* bytes that can be written can be obtained by summing the areas len fields.
*/
static inline size_t
static inline uint32_t
spa_ringbuffer_get_write_areas (SpaRingbuffer *rbuf,
SpaRingbufferArea areas[2])
{
size_t avail, end, w;
uint32_t avail, end, w;
avail = spa_ringbuffer_get_write_offset (rbuf, &w);
end = w + avail;
@ -218,7 +218,7 @@ spa_ringbuffer_write_data (SpaRingbuffer *rbuf,
void *buffer,
SpaRingbufferArea areas[2],
void *data,
size_t size)
uint32_t size)
{
if (SPA_LIKELY (size < areas[0].len))
memcpy (buffer + areas[0].offset, data, size);
@ -238,7 +238,7 @@ spa_ringbuffer_write_data (SpaRingbuffer *rbuf,
*/
static inline void
spa_ringbuffer_write_advance (SpaRingbuffer *rbuf,
ssize_t len)
int32_t len)
{
spa_barrier_write();
rbuf->writeindex = (rbuf->writeindex + len) & rbuf->mask2;

2
spa/include/spa/video/raw.h
View file

@ -171,7 +171,7 @@ struct _SpaVideoInfoRaw {
SpaRectangle size;
SpaFraction framerate;
SpaFraction max_framerate;
unsigned int views;
uint32_t views;
SpaVideoInterlaceMode interlace_mode;
SpaFraction pixel_aspect_ratio;
SpaVideoMultiviewMode multiview_mode;

38
spa/lib/debug.c
View file

@ -61,7 +61,7 @@ spa_debug_port_info (const SpaPortInfo *info)
fprintf (stderr, " n_params: \t%d\n", info->n_params);
for (i = 0; i < info->n_params; i++) {
SpaAllocParam *param = info->params[i];
fprintf (stderr, " param %d, type %d, size %zd:\n", i, param->type, param->size);
fprintf (stderr, " param %d, type %d, size %u:\n", i, param->type, param->size);
switch (param->type) {
case SPA_ALLOC_PARAM_TYPE_INVALID:
fprintf (stderr, " INVALID\n");
@ -70,8 +70,8 @@ spa_debug_port_info (const SpaPortInfo *info)
{
SpaAllocParamBuffers *p = (SpaAllocParamBuffers *)param;
fprintf (stderr, " SpaAllocParamBuffers:\n");
fprintf (stderr, " minsize: \t\t%zd\n", p->minsize);
fprintf (stderr, " stride: \t\t%zd\n", p->stride);
fprintf (stderr, " minsize: \t\t%d\n", p->minsize);
fprintf (stderr, " stride: \t\t%d\n", p->stride);
fprintf (stderr, " min_buffers: \t%d\n", p->min_buffers);
fprintf (stderr, " max_buffers: \t%d\n", p->max_buffers);
fprintf (stderr, " align: \t\t%d\n", p->align);
@ -86,9 +86,9 @@ spa_debug_port_info (const SpaPortInfo *info)
case SPA_META_TYPE_RINGBUFFER:
{
SpaAllocParamMetaEnableRingbuffer *rb = (SpaAllocParamMetaEnableRingbuffer *)p;
fprintf (stderr, " minsize: \t\t%zd\n", rb->minsize);
fprintf (stderr, " stride: \t\t%zd\n", rb->stride);
fprintf (stderr, " blocks: \t\t%zd\n", rb->blocks);
fprintf (stderr, " minsize: \t\t%d\n", rb->minsize);
fprintf (stderr, " stride: \t\t%d\n", rb->stride);
fprintf (stderr, " blocks: \t\t%d\n", rb->blocks);
fprintf (stderr, " align: \t\t%d\n", rb->align);
break;
}
@ -130,7 +130,7 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, " n_metas: %u (at %p)\n", buffer->n_metas, buffer->metas);
for (i = 0; i < buffer->n_metas; i++) {
SpaMeta *m = &buffer->metas[i];
fprintf (stderr, " meta %d: type %d (%s), data %p, size %zd:\n", i, m->type, META_TYPE_NAME (m->type), m->data, m->size);
fprintf (stderr, " meta %d: type %d (%s), data %p, size %d:\n", i, m->type, META_TYPE_NAME (m->type), m->data, m->size);
switch (m->type) {
case SPA_META_TYPE_HEADER:
{
@ -165,11 +165,11 @@ spa_debug_buffer (const SpaBuffer *buffer)
{
SpaMetaRingbuffer *h = m->data;
fprintf (stderr, " SpaMetaRingbuffer:\n");
fprintf (stderr, " readindex: %zd\n", h->ringbuffer.readindex);
fprintf (stderr, " writeindex: %zd\n", h->ringbuffer.writeindex);
fprintf (stderr, " size: %zd\n", h->ringbuffer.size);
fprintf (stderr, " mask: %zd\n", h->ringbuffer.mask);
fprintf (stderr, " mask2: %zd\n", h->ringbuffer.mask2);
fprintf (stderr, " readindex: %d\n", h->ringbuffer.readindex);
fprintf (stderr, " writeindex: %d\n", h->ringbuffer.writeindex);
fprintf (stderr, " size: %d\n", h->ringbuffer.size);
fprintf (stderr, " mask: %d\n", h->ringbuffer.mask);
fprintf (stderr, " mask2: %d\n", h->ringbuffer.mask2);
break;
}
case SPA_META_TYPE_SHARED:
@ -179,8 +179,8 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, " type: %d\n", h->type);
fprintf (stderr, " flags: %d\n", h->flags);
fprintf (stderr, " fd: %d\n", h->fd);
fprintf (stderr, " offset: %zd\n", h->offset);
fprintf (stderr, " size: %zd\n", h->size);
fprintf (stderr, " offset: %d\n", h->offset);
fprintf (stderr, " size: %d\n", h->size);
break;
}
default:
@ -195,12 +195,12 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, " flags: %d\n", d->flags);
fprintf (stderr, " data: %p\n", d->data);
fprintf (stderr, " fd: %d\n", d->fd);
fprintf (stderr, " offset: %zd\n", d->mapoffset);
fprintf (stderr, " maxsize: %zu\n", d->maxsize);
fprintf (stderr, " offset: %d\n", d->mapoffset);
fprintf (stderr, " maxsize: %u\n", d->maxsize);
fprintf (stderr, " chunk: %p\n", d->chunk);
fprintf (stderr, " offset: %zd\n", d->chunk->offset);
fprintf (stderr, " size: %zu\n", d->chunk->size);
fprintf (stderr, " stride: %zd\n", d->chunk->stride);
fprintf (stderr, " offset: %d\n", d->chunk->offset);
fprintf (stderr, " size: %u\n", d->chunk->size);
fprintf (stderr, " stride: %d\n", d->chunk->stride);
}
return SPA_RESULT_OK;
}

83
spa/lib/props.c
View file

@ -24,89 +24,6 @@
#include <spa/props.h>
#if 0
SpaResult
spa_props_set_value (SpaProps *props,
unsigned int index,
const SpaPropValue *value)
{
const SpaPropInfo *info;
if (props == NULL || value == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (index >= props->n_prop_info)
return SPA_RESULT_INVALID_PROPERTY_INDEX;
info = &props->prop_info[index];
if ((info->flags & SPA_PROP_FLAG_WRITABLE) == 0)
return SPA_RESULT_INVALID_PROPERTY_ACCESS;
if (info->maxsize < value->size)
return SPA_RESULT_WRONG_PROPERTY_SIZE;
memcpy (SPA_MEMBER (props, info->offset, void), value->value, value->size);
SPA_PROPS_INDEX_SET (props, index);
return SPA_RESULT_OK;
}
SpaResult
spa_props_get_value (const SpaProps *props,
unsigned int index,
SpaPropValue *value)
{
const SpaPropInfo *info;
if (props == NULL || value == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (index >= props->n_prop_info)
return SPA_RESULT_INVALID_PROPERTY_INDEX;
info = &props->prop_info[index];
if ((info->flags & SPA_PROP_FLAG_READABLE) == 0)
return SPA_RESULT_INVALID_PROPERTY_ACCESS;
if (SPA_PROPS_INDEX_IS_UNSET (props, index))
return SPA_RESULT_PROPERTY_UNSET;
value->size = info->maxsize;
value->value = SPA_MEMBER (props, info->offset, void);
return SPA_RESULT_OK;
}
SpaResult
spa_props_copy_values (const SpaProps *src,
SpaProps *dest)
{
int i;
if (src == dest)
return SPA_RESULT_OK;
for (i = 0; i < dest->n_prop_info; i++) {
const SpaPropInfo *dinfo = &dest->prop_info[i];
const SpaPropInfo *sinfo;
unsigned int idx;
if (!(dinfo->flags & SPA_PROP_FLAG_WRITABLE))
continue;
if ((idx = spa_props_index_for_id (src, dinfo->id)) == SPA_IDX_INVALID)
continue;
sinfo = &src->prop_info[idx];
if (sinfo->maxsize > dinfo->maxsize)
return SPA_RESULT_WRONG_PROPERTY_SIZE;
memcpy (SPA_MEMBER (dest, dinfo->offset, void), SPA_MEMBER (src, sinfo->offset, void), sinfo->maxsize);
if (!SPA_PROPS_INDEX_IS_UNSET (src, idx))
SPA_PROPS_INDEX_SET (dest, i);
}
return SPA_RESULT_OK;
}
#endif
static int
compare_value (SpaPODType type, const void *r1, const void *r2)
{

12
spa/plugins/alsa/alsa-monitor.c
View file

@ -64,7 +64,7 @@ struct _SpaALSAMonitor {
struct udev* udev;
struct udev_monitor *umonitor;
struct udev_enumerate *enumerate;
unsigned int index;
uint32_t index;
struct udev_list_entry *devices;
ALSAItem uitem;
@ -107,7 +107,7 @@ static int
fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice)
{
int err;
unsigned int i;
uint32_t i;
const char *str;
snd_pcm_t *hndl;
char device[64];
@ -319,7 +319,7 @@ spa_alsa_monitor_set_event_callback (SpaMonitor *monitor,
static SpaResult
spa_alsa_monitor_enum_items (SpaMonitor *monitor,
SpaMonitorItem **item,
unsigned int index)
uint32_t index)
{
SpaResult res;
SpaALSAMonitor *this;
@ -407,10 +407,10 @@ alsa_monitor_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaALSAMonitor *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -451,7 +451,7 @@ static const SpaInterfaceInfo alsa_monitor_interfaces[] =
static SpaResult
alsa_monitor_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

20
spa/plugins/alsa/alsa-sink.c
View file

@ -263,10 +263,10 @@ spa_alsa_sink_node_set_event_callback (SpaNode *node,
static SpaResult
spa_alsa_sink_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -285,9 +285,9 @@ spa_alsa_sink_node_get_n_ports (SpaNode *node,
static SpaResult
spa_alsa_sink_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -322,7 +322,7 @@ spa_alsa_sink_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaALSASink *this;
SpaResult res;
@ -795,10 +795,10 @@ alsa_sink_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaALSASink *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -849,7 +849,7 @@ static const SpaInterfaceInfo alsa_sink_interfaces[] =
static SpaResult
alsa_sink_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

20
spa/plugins/alsa/alsa-source.c
View file

@ -298,10 +298,10 @@ spa_alsa_source_node_set_event_callback (SpaNode *node,
static SpaResult
spa_alsa_source_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -320,9 +320,9 @@ spa_alsa_source_node_get_n_ports (SpaNode *node,
static SpaResult
spa_alsa_source_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -357,7 +357,7 @@ spa_alsa_source_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaALSASource *this;
SpaResult res;
@ -859,10 +859,10 @@ alsa_source_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaALSASource *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -917,7 +917,7 @@ static const SpaInterfaceInfo alsa_source_interfaces[] =
static SpaResult
alsa_source_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/plugins/alsa/alsa-utils.c
View file

@ -339,7 +339,7 @@ pull_frames_ringbuffer (SpaALSAState *state,
avail = spa_ringbuffer_get_read_areas (&b->rb->ringbuffer, areas);
size = SPA_MIN (avail, frames * state->frame_size);
spa_log_debug (state->log, "%zd %zd %zd %zd %zd %zd",
spa_log_debug (state->log, "%u %u %u %u %zd %zd",
areas[0].offset, areas[0].len,
areas[1].offset, areas[1].len, offset, size);

2
spa/plugins/alsa/alsa.c
View file

@ -26,7 +26,7 @@ extern const SpaHandleFactory spa_alsa_monitor_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

24
spa/plugins/audiomixer/audiomixer.c
View file

@ -51,7 +51,7 @@ typedef struct {
MixerBuffer mix;
SpaBuffer **buffers;
unsigned int n_buffers;
uint32_t n_buffers;
SpaBuffer *buffer;
void *io;
} SpaAudioMixerPort;
@ -158,10 +158,10 @@ spa_audiomixer_node_set_event_callback (SpaNode *node,
static SpaResult
spa_audiomixer_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -180,9 +180,9 @@ spa_audiomixer_node_get_n_ports (SpaNode *node,
static SpaResult
spa_audiomixer_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
SpaAudioMixer *this;
@ -264,7 +264,7 @@ spa_audiomixer_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaAudioMixer *this;
@ -472,7 +472,7 @@ static SpaResult
spa_audiomixer_node_process_input (SpaNode *node)
{
SpaAudioMixer *this;
unsigned int i;
uint32_t i;
bool have_error = false;
SpaPortOutput *output;
@ -679,10 +679,10 @@ spa_audiomixer_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaAudioMixer *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -721,7 +721,7 @@ static const SpaInterfaceInfo audiomixer_interfaces[] =
static SpaResult
audiomixer_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/plugins/audiomixer/plugin.c
View file

@ -24,7 +24,7 @@ extern const SpaHandleFactory spa_audiomixer_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

24
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -94,7 +94,7 @@ struct _SpaAudioTestSrc {
size_t bpf;
ATSBuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
uint32_t n_buffers;
bool started;
uint64_t start_time;
@ -397,10 +397,10 @@ spa_audiotestsrc_node_set_event_callback (SpaNode *node,
static SpaResult
spa_audiotestsrc_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -419,9 +419,9 @@ spa_audiotestsrc_node_get_n_ports (SpaNode *node,
static SpaResult
spa_audiotestsrc_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -455,7 +455,7 @@ spa_audiotestsrc_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaAudioTestSrc *this;
SpaResult res;
@ -664,7 +664,7 @@ spa_audiotestsrc_node_port_use_buffers (SpaNode *node,
uint32_t n_buffers)
{
SpaAudioTestSrc *this;
unsigned int i;
uint32_t i;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -943,10 +943,10 @@ audiotestsrc_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaAudioTestSrc *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -1010,7 +1010,7 @@ static const SpaInterfaceInfo audiotestsrc_interfaces[] =
static SpaResult
audiotestsrc_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/plugins/audiotestsrc/plugin.c
View file

@ -24,7 +24,7 @@ extern const SpaHandleFactory spa_audiotestsrc_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

21
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -147,10 +147,10 @@ spa_ffmpeg_dec_node_set_event_callback (SpaNode *node,
static SpaResult
spa_ffmpeg_dec_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -169,9 +169,9 @@ spa_ffmpeg_dec_node_get_n_ports (SpaNode *node,
static SpaResult
spa_ffmpeg_dec_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -208,10 +208,9 @@ spa_ffmpeg_dec_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaFFMpegDec *this;
SpaFFMpegPort *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -221,8 +220,6 @@ spa_ffmpeg_dec_node_port_enum_formats (SpaNode *node,
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
switch (index) {
case 0:
break;
@ -516,10 +513,10 @@ SpaResult
spa_ffmpeg_dec_init (SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaFFMpegDec *this;
unsigned int i;
uint32_t i;
handle->get_interface = spa_ffmpeg_dec_get_interface;

18
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -152,10 +152,10 @@ spa_ffmpeg_enc_node_set_event_callback (SpaNode *node,
static SpaResult
spa_ffmpeg_enc_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -174,9 +174,9 @@ spa_ffmpeg_enc_node_get_n_ports (SpaNode *node,
static SpaResult
spa_ffmpeg_enc_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -213,7 +213,7 @@ spa_ffmpeg_enc_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaFFMpegEnc *this;
SpaFFMpegPort *port;
@ -524,10 +524,10 @@ SpaResult
spa_ffmpeg_enc_init (SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaFFMpegEnc *this;
unsigned int i;
uint32_t i;
handle->get_interface = spa_ffmpeg_enc_get_interface;

12
spa/plugins/ffmpeg/ffmpeg.c
View file

@ -25,15 +25,15 @@
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
SpaResult spa_ffmpeg_dec_init (SpaHandle *handle, const SpaDict *info, const SpaSupport *support, unsigned int n_support);
SpaResult spa_ffmpeg_enc_init (SpaHandle *handle, const SpaDict *info, const SpaSupport *support, unsigned int n_support);
SpaResult spa_ffmpeg_dec_init (SpaHandle *handle, const SpaDict *info, const SpaSupport *support, uint32_t n_support);
SpaResult spa_ffmpeg_enc_init (SpaHandle *handle, const SpaDict *info, const SpaSupport *support, uint32_t n_support);
static SpaResult
ffmpeg_dec_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -46,7 +46,7 @@ ffmpeg_enc_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -63,7 +63,7 @@ static const SpaInterfaceInfo ffmpeg_interfaces[] =
static SpaResult
ffmpeg_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -78,7 +78,7 @@ ffmpeg_enum_interface_info (const SpaHandleFactory *factory,
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
static const AVCodec *c = NULL;
static int ci = 0;

20
spa/plugins/libva/libva-dec.c
View file

@ -189,10 +189,10 @@ spa_libva_dec_node_set_event_callback (SpaHandle *handle,
static SpaResult
spa_libva_dec_node_get_n_ports (SpaHandle *handle,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -211,9 +211,9 @@ spa_libva_dec_node_get_n_ports (SpaHandle *handle,
static SpaResult
spa_libva_dec_node_get_port_ids (SpaHandle *handle,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (handle == NULL)
@ -246,7 +246,7 @@ spa_libva_dec_node_remove_port (SpaHandle *handle,
static SpaResult
spa_libva_dec_node_port_enum_formats (SpaHandle *handle,
uint32_t port_id,
unsigned int index,
uint32_t index,
SpaFormat **format)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
@ -423,7 +423,7 @@ spa_libva_dec_node_port_alloc_buffers (SpaHandle *handle,
static SpaResult
spa_libva_dec_node_port_push_input (SpaHandle *handle,
unsigned int n_info,
uint32_t n_info,
SpaInputInfo *info)
{
return SPA_RESULT_INVALID_PORT;
@ -431,12 +431,12 @@ spa_libva_dec_node_port_push_input (SpaHandle *handle,
static SpaResult
spa_libva_dec_node_port_pull_output (SpaHandle *handle,
unsigned int n_info,
uint32_t n_info,
SpaOutputInfo *info)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
SpaLibvaState *state;
unsigned int i;
uint32_t i;
bool have_error = false;
if (handle == NULL || n_info == 0 || info == NULL)

20
spa/plugins/libva/libva-enc.c
View file

@ -189,10 +189,10 @@ spa_libva_enc_node_set_event_callback (SpaHandle *handle,
static SpaResult
spa_libva_enc_node_get_n_ports (SpaHandle *handle,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -211,9 +211,9 @@ spa_libva_enc_node_get_n_ports (SpaHandle *handle,
static SpaResult
spa_libva_enc_node_get_port_ids (SpaHandle *handle,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (handle == NULL)
@ -246,7 +246,7 @@ spa_libva_enc_node_remove_port (SpaHandle *handle,
static SpaResult
spa_libva_enc_node_port_enum_formats (SpaHandle *handle,
uint32_t port_id,
unsigned int index,
uint32_t index,
SpaFormat **format)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
@ -423,7 +423,7 @@ spa_libva_enc_node_port_alloc_buffers (SpaHandle *handle,
static SpaResult
spa_libva_enc_node_port_push_input (SpaHandle *handle,
unsigned int n_info,
uint32_t n_info,
SpaInputInfo *info)
{
return SPA_RESULT_INVALID_PORT;
@ -431,12 +431,12 @@ spa_libva_enc_node_port_push_input (SpaHandle *handle,
static SpaResult
spa_libva_enc_node_port_pull_output (SpaHandle *handle,
unsigned int n_info,
uint32_t n_info,
SpaOutputInfo *info)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
SpaLibvaState *state;
unsigned int i;
uint32_t i;
bool have_error = false;
if (handle == NULL || n_info == 0 || info == NULL)

4
spa/plugins/libva/libva.c
View file

@ -58,7 +58,7 @@ static const SpaInterfaceInfo libva_interfaces[] =
static SpaResult
libva_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
uint32_t index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
@ -84,7 +84,7 @@ static const SpaHandleFactory factories[] =
};
SpaResult
spa_enum_handle_factory (unsigned int index,
spa_enum_handle_factory (uint32_t index,
const SpaHandleFactory **factory)
{
if (index >= 2)

12
spa/plugins/v4l2/v4l2-monitor.c
View file

@ -61,7 +61,7 @@ struct _SpaV4l2Monitor {
struct udev* udev;
struct udev_monitor *umonitor;
struct udev_enumerate *enumerate;
unsigned int index;
uint32_t index;
struct udev_list_entry *devices;
V4l2Item uitem;
@ -83,7 +83,7 @@ v4l2_udev_open (SpaV4l2Monitor *this)
static void
fill_item (V4l2Item *item, struct udev_device *udevice)
{
unsigned int i;
uint32_t i;
const char *str;
if (item->udevice)
@ -253,7 +253,7 @@ spa_v4l2_monitor_set_event_callback (SpaMonitor *monitor,
static SpaResult
spa_v4l2_monitor_enum_items (SpaMonitor *monitor,
SpaMonitorItem **item,
unsigned int index)
uint32_t index)
{
SpaResult res;
SpaV4l2Monitor *this;
@ -340,10 +340,10 @@ v4l2_monitor_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaV4l2Monitor *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -384,7 +384,7 @@ static const SpaInterfaceInfo v4l2_monitor_interfaces[] =
static SpaResult
v4l2_monitor_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

26
spa/plugins/v4l2/v4l2-source.c
View file

@ -93,7 +93,7 @@ typedef struct {
enum v4l2_memory memtype;
V4l2Buffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
uint32_t n_buffers;
bool source_enabled;
SpaSource source;
@ -415,10 +415,10 @@ spa_v4l2_source_node_set_event_callback (SpaNode *node,
static SpaResult
spa_v4l2_source_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -437,9 +437,9 @@ spa_v4l2_source_node_get_n_ports (SpaNode *node,
static SpaResult
spa_v4l2_source_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -474,7 +474,7 @@ spa_v4l2_source_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaV4l2Source *this;
SpaResult res;
@ -726,9 +726,9 @@ spa_v4l2_source_node_port_alloc_buffers (SpaNode *node,
SpaDirection direction,
uint32_t port_id,
SpaAllocParam **params,
unsigned int n_params,
uint32_t n_params,
SpaBuffer **buffers,
unsigned int *n_buffers)
uint32_t *n_buffers)
{
SpaV4l2Source *this;
SpaV4l2State *state;
@ -965,10 +965,10 @@ v4l2_source_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaV4l2Source *this;
unsigned int i;
uint32_t i;
const char *str;
if (factory == NULL || handle == NULL)
@ -1032,7 +1032,7 @@ static const SpaInterfaceInfo v4l2_source_interfaces[] =
static SpaResult
v4l2_source_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

18
spa/plugins/v4l2/v4l2-utils.c
View file

@ -322,7 +322,7 @@ find_format_info_by_media_type (SpaMediaType type,
}
static SpaVideoFormat
enum_filter_format (const SpaFormat *filter, unsigned int index)
enum_filter_format (const SpaFormat *filter, uint32_t index)
{
SpaVideoFormat video_format = SPA_VIDEO_FORMAT_UNKNOWN;
@ -330,7 +330,7 @@ enum_filter_format (const SpaFormat *filter, unsigned int index)
filter->body.media_type.value == SPA_MEDIA_TYPE_IMAGE)) {
if (filter->body.media_subtype.value == SPA_MEDIA_SUBTYPE_RAW) {
SpaPODProp *p;
unsigned int n_values;
uint32_t n_values;
const uint32_t *values;
if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_FORMAT)))
@ -449,7 +449,7 @@ static SpaResult
spa_v4l2_enum_format (SpaV4l2Source *this,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaV4l2State *state = &this->state[0];
int res, n_fractions;
@ -547,7 +547,7 @@ do_frmsize:
SpaPODProp *p;
const SpaRectangle step = { 1, 1 }, *values;
uint32_t range;
unsigned int i, n_values;
uint32_t i, n_values;
/* check if we have a fixed frame size */
if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_SIZE)))
@ -650,7 +650,7 @@ have_size:
if (filter) {
SpaPODProp *p;
uint32_t range;
unsigned int i, n_values;
uint32_t i, n_values;
const SpaFraction step = { 1, 1 }, *values;
if (!(p = spa_format_find_prop (filter, SPA_PROP_ID_VIDEO_FRAMERATE)))
@ -1024,9 +1024,9 @@ spa_v4l2_use_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_buffe
static SpaResult
mmap_init (SpaV4l2Source *this,
SpaAllocParam **params,
unsigned int n_params,
uint32_t n_params,
SpaBuffer **buffers,
unsigned int *n_buffers)
uint32_t *n_buffers)
{
SpaV4l2State *state = &this->state[0];
struct v4l2_requestbuffers reqbuf;
@ -1136,9 +1136,9 @@ read_init (SpaV4l2Source *this)
static SpaResult
spa_v4l2_alloc_buffers (SpaV4l2Source *this,
SpaAllocParam **params,
unsigned int n_params,
uint32_t n_params,
SpaBuffer **buffers,
unsigned int *n_buffers)
uint32_t *n_buffers)
{
SpaResult res;
SpaV4l2State *state = &this->state[0];

2
spa/plugins/v4l2/v4l2.c
View file

@ -25,7 +25,7 @@ extern const SpaHandleFactory spa_v4l2_monitor_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/plugins/videotestsrc/plugin.c
View file

@ -24,7 +24,7 @@ extern const SpaHandleFactory spa_videotestsrc_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

24
spa/plugins/videotestsrc/videotestsrc.c
View file

@ -92,7 +92,7 @@ struct _SpaVideoTestSrc {
size_t bpp;
VTSBuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
uint32_t n_buffers;
bool started;
uint64_t start_time;
@ -366,10 +366,10 @@ spa_videotestsrc_node_set_event_callback (SpaNode *node,
static SpaResult
spa_videotestsrc_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -388,9 +388,9 @@ spa_videotestsrc_node_get_n_ports (SpaNode *node,
static SpaResult
spa_videotestsrc_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -424,7 +424,7 @@ spa_videotestsrc_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaVideoTestSrc *this;
SpaResult res;
@ -648,7 +648,7 @@ spa_videotestsrc_node_port_use_buffers (SpaNode *node,
uint32_t n_buffers)
{
SpaVideoTestSrc *this;
unsigned int i;
uint32_t i;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -927,10 +927,10 @@ videotestsrc_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaVideoTestSrc *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -994,7 +994,7 @@ static const SpaInterfaceInfo videotestsrc_interfaces[] =
static SpaResult
videotestsrc_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/plugins/volume/plugin.c
View file

@ -24,7 +24,7 @@ extern const SpaHandleFactory spa_volume_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

26
spa/plugins/volume/volume.c
View file

@ -55,7 +55,7 @@ typedef struct {
SpaAllocParamMetaEnable param_meta;
SpaVolumeBuffer buffers[MAX_BUFFERS];
unsigned int n_buffers;
uint32_t n_buffers;
void *io;
@ -225,10 +225,10 @@ spa_volume_node_set_event_callback (SpaNode *node,
static SpaResult
spa_volume_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -247,9 +247,9 @@ spa_volume_node_get_n_ports (SpaNode *node,
static SpaResult
spa_volume_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -286,7 +286,7 @@ spa_volume_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaVolume *this;
SpaResult res;
@ -487,7 +487,7 @@ spa_volume_node_port_use_buffers (SpaNode *node,
{
SpaVolume *this;
SpaVolumePort *port;
unsigned int i;
uint32_t i;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -665,7 +665,7 @@ release_buffer (SpaVolume *this, SpaBuffer *buffer)
static void
do_volume (SpaVolume *this, SpaBuffer *dbuf, SpaBuffer *sbuf)
{
unsigned int si, di, i, n_samples, n_bytes, soff, doff ;
uint32_t si, di, i, n_samples, n_bytes, soff, doff ;
SpaData *sd, *dd;
uint16_t *src, *dst;
double volume;
@ -825,10 +825,10 @@ volume_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaVolume *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -872,7 +872,7 @@ static const SpaInterfaceInfo volume_interfaces[] =
static SpaResult
volume_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

20
spa/plugins/xv/xv-sink.c
View file

@ -231,10 +231,10 @@ spa_xv_sink_node_set_event_callback (SpaNode *node,
static SpaResult
spa_xv_sink_node_get_n_ports (SpaNode *node,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -253,9 +253,9 @@ spa_xv_sink_node_get_n_ports (SpaNode *node,
static SpaResult
spa_xv_sink_node_get_port_ids (SpaNode *node,
unsigned int n_input_ports,
uint32_t n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
@ -290,7 +290,7 @@ spa_xv_sink_node_port_enum_formats (SpaNode *node,
uint32_t port_id,
SpaFormat **format,
const SpaFormat *filter,
unsigned int index)
uint32_t index)
{
SpaXvSink *this;
@ -558,10 +558,10 @@ xv_sink_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const SpaDict *info,
const SpaSupport *support,
unsigned int n_support)
uint32_t n_support)
{
SpaXvSink *this;
unsigned int i;
uint32_t i;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -599,7 +599,7 @@ static const SpaInterfaceInfo xv_sink_interfaces[] =
static SpaResult
xv_sink_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
unsigned int index)
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/plugins/xv/xv.c
View file

@ -24,7 +24,7 @@ extern const SpaHandleFactory spa_xv_sink_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
unsigned int index)
uint32_t index)
{
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

2
spa/tests/test-mixer.c
View file

@ -50,7 +50,7 @@ typedef struct {
SpaPollItem poll;
SpaSupport support[2];
unsigned int n_support;
uint32_t n_support;
SpaIDMap *map;
SpaLog *log;
SpaPoll data_loop;

33
spa/tests/test-props2.c
View file

@ -26,6 +26,7 @@
#include <spa/pod.h>
#include <spa/pod-builder.h>
#include <spa/pod-iter.h>
#include <spa/id-map.h>
#include <spa/log.h>
@ -40,11 +41,12 @@ main (int argc, char *argv[])
SpaPODFrame frame[4];
uint8_t buffer[1024];
SpaPOD *obj;
SpaPODIter i;
b.data = buffer;
b.size = 1024;
obj = SPA_MEMBER (buffer, spa_pod_builder_push_object (&b, &frame[0], 0, 0), SpaPOD);
spa_pod_builder_push_object (&b, &frame[0], 0, 0);
uint32_t formats[] = { 1, 2 };
spa_pod_builder_push_prop (&b, &frame[1],
@ -84,11 +86,40 @@ main (int argc, char *argv[])
spa_pod_builder_pop (&b, &frame[1]);
spa_pod_builder_pop (&b, &frame[0]);
obj = SPA_POD_BUILDER_DEREF (&b, frame[0].ref, SpaPOD);
spa_debug_pod (obj);
SpaPODProp *p = spa_pod_object_find_prop ((SpaPODObject *)obj, 4);
printf ("%d %d\n", p->body.key, p->body.flags);
spa_debug_pod (&p->body.value);
obj = SPA_POD_BUILDER_DEREF (&b, frame[2].ref, SpaPOD);
int32_t vi, *pi;
int64_t vl;
float vf;
double vd;
char *vs;
SpaRectangle vr;
SpaFraction vfr;
SpaPODArray *va;
spa_pod_iter_pod (&i, obj);
spa_pod_iter_get (&i, SPA_POD_TYPE_INT, &vi,
SPA_POD_TYPE_LONG, &vl,
SPA_POD_TYPE_FLOAT, &vf,
SPA_POD_TYPE_DOUBLE, &vd,
SPA_POD_TYPE_STRING, &vs,
SPA_POD_TYPE_RECTANGLE, &vr,
SPA_POD_TYPE_FRACTION, &vfr,
SPA_POD_TYPE_ARRAY, &va,
0);
printf ("%u %lu %f %g %s %ux%u %u/%u\n", vi, vl, vf, vd, vs, vr.width, vr.height, vfr.num, vfr.denom);
SPA_POD_ARRAY_BODY_FOREACH (&va->body, SPA_POD_BODY_SIZE (va), pi) {
printf ("%d\n", *pi);
}
return 0;
}

2
spa/tests/test-v4l2.c
View file

@ -71,7 +71,7 @@ typedef struct {
unsigned int n_buffers;
SpaSupport support[2];
unsigned int n_support;
uint32_t n_support;
SpaIDMap *map;
SpaLog *log;
SpaPoll data_loop;

10
spa/tools/spa-inspect.c
View file

@ -39,7 +39,7 @@ typedef struct {
URI uri;
SpaSupport support[4];
unsigned int n_support;
uint32_t n_support;
SpaIDMap *map;
SpaLog *log;
SpaLoop loop;
@ -50,7 +50,7 @@ inspect_port (SpaNode *node, SpaDirection direction, uint32_t port_id)
{
SpaResult res;
SpaFormat *format;
unsigned int index = 0;
uint32_t index = 0;
SpaProps *props;
while (true) {
@ -73,7 +73,7 @@ static void
inspect_node (SpaNode *node)
{
SpaResult res;
unsigned int i, n_input, max_input, n_output, max_output;
uint32_t i, n_input, max_input, n_output, max_output;
uint32_t *in_ports, *out_ports;
SpaProps *props;
@ -114,7 +114,7 @@ inspect_factory (AppData *data, const SpaHandleFactory *factory)
SpaResult res;
SpaHandle *handle;
void *interface;
unsigned int index = 0;
uint32_t index = 0;
printf ("factory name:\t\t'%s'\n", factory->name);
printf ("factory info:\n");
@ -181,7 +181,7 @@ main (int argc, char *argv[])
SpaResult res;
void *handle;
SpaEnumHandleFactoryFunc enum_func;
unsigned int index = 0;
uint32_t index = 0;
if (argc < 2) {
printf ("usage: %s <plugin.so>\n", argv[0]);

8
spa/tools/spa-monitor.c
View file

@ -44,7 +44,7 @@ typedef struct {
SpaLoop main_loop;
SpaSupport support[3];
unsigned int n_support;
uint32_t n_support;
unsigned int n_sources;
SpaSource sources[16];
@ -123,7 +123,7 @@ static void
handle_monitor (AppData *data, SpaMonitor *monitor)
{
SpaResult res;
unsigned int index;
uint32_t index;
if (monitor->info)
spa_debug_dict (monitor->info);
@ -181,7 +181,7 @@ main (int argc, char *argv[])
SpaResult res;
void *handle;
SpaEnumHandleFactoryFunc enum_func;
unsigned int fidx;
uint32_t fidx;
data.map = spa_id_map_get_default ();
data.log = NULL;
@ -216,7 +216,7 @@ main (int argc, char *argv[])
for (fidx = 0;; fidx++) {
const SpaHandleFactory *factory;
unsigned int iidx;
uint32_t iidx;
if ((res = enum_func (&factory, fidx)) < 0) {
if (res != SPA_RESULT_ENUM_END)