mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-12-16 08:56:45 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

implement set_format

Browse source 
Serialize the formats
Use SpaMemoryRef where we can
Add more debug
This commit is contained in:
Wim Taymans 2016-08-04 17:33:49 +02:00
parent 98679cbd53
commit 8f9222bf9e
19 changed files with 611 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -28,6 +28,7 @@ typedef struct _SpaBuffer SpaBuffer;
typedef struct _SpaBufferGroup SpaBufferGroup;
#include <spa/defs.h>
#include <spa/memory.h>
/**
* SpaMetaType:
@ -89,7 +90,7 @@ typedef struct {
/**
* SpaMeta:
* @type: metadata type
* @offset: offset of metadata
* @offset: offset of metadata in the buffer structure
* @size: size of metadata
*/
typedef struct {
@ -100,13 +101,13 @@ typedef struct {
/**
* SpaData:
* @mem_id: the memory id to use
* @offset: offset of memory
* @mem: reference to the memory to use
* @offset: ofset in memory
* @size: size of memory
* @stride: stride of memory if applicable
*/
typedef struct {
uint32_t mem_id;
SpaMemoryRef mem;
off_t offset;
size_t size;
size_t stride;
@ -115,9 +116,9 @@ typedef struct {
/**
* SpaBuffer:
* @id: buffer id
* @mem_id: memory id of the buffer
* @offset: offset into the memory
* @size: total size of the buffer structure
* @mem: reference to the memory for this buffer
* @offset: offset inside memory
* @size: of of memory
* @n_metas: number of metadata
* @metas: offset of array of @n_metas metadata
* @n_datas: number of data pointers
@ -125,7 +126,7 @@ typedef struct {
*/
struct _SpaBuffer {
uint32_t id;
uint32_t mem_id;
SpaMemoryRef mem;
off_t offset;
size_t size;
unsigned int n_metas;

30
spa/include/spa/control.h
View file

@ -144,8 +144,8 @@ typedef struct {
/* SPA_CONTROL_CMD_SET_FORMAT */
typedef struct {
uint32_t port_id;
const SpaFormat *format;
uint32_t port_id;
SpaFormat *format;
} SpaControlCmdSetFormat;
/* SPA_CONTROL_CMD_SET_PROPERTY */
@ -161,27 +161,27 @@ typedef struct {
/* SPA_CONTROL_CMD_ADD_MEM */
typedef struct {
uint32_t port_id;
uint32_t mem_id;
uint32_t mem_type;
uint32_t fd_index;
uint32_t flags;
uint64_t size;
uint32_t port_id;
SpaMemoryRef mem;
uint32_t mem_type;
uint32_t fd_index;
uint32_t flags;
uint64_t size;
} SpaControlCmdAddMem;
/* SPA_CONTROL_CMD_REMOVE_MEM */
typedef struct {
uint32_t port_id;
uint32_t mem_id;
SpaMemoryRef mem;
} SpaControlCmdRemoveMem;
/* SPA_CONTROL_CMD_ADD_BUFFER */
typedef struct {
uint32_t port_id;
uint32_t buffer_id;
uint32_t mem_id;
uint64_t offset;
uint64_t size;
uint32_t port_id;
uint32_t buffer_id;
SpaMemoryRef mem;
off_t offset;
size_t size;
} SpaControlCmdAddBuffer;
/* SPA_CONTROL_CMD_REMOVE_BUFFER */
@ -207,8 +207,6 @@ typedef struct {
} SpaControlCmdReuseBuffer;
struct _SpaControlIter {
/*< private >*/
size_t x[16];

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

@ -27,10 +27,14 @@ extern "C" {
#include <spa/defs.h>
#include <spa/port.h>
#include <spa/buffer.h>
#include <spa/props.h>
#include <spa/format.h>
SpaResult spa_debug_port_info (const SpaPortInfo *info);
SpaResult spa_debug_buffer (const SpaBuffer *buffer);
SpaResult spa_debug_dump_mem (void *data, size_t size);
SpaResult spa_debug_props (const SpaProps *props, bool print_ranges);
SpaResult spa_debug_format (const SpaFormat *format);
SpaResult spa_debug_dump_mem (const void *data, size_t size);
#ifdef __cplusplus
} /* extern "C" */

1
spa/include/spa/defs.h
View file

@ -73,6 +73,7 @@ typedef void (*SpaNotify) (void *data);
#define SPA_MAX(a,b) ((a)>(b) ? (a) : (b))
#define SPA_MEMBER(b,o,t) ((t*)((uint8_t*)(b) + (o)))
#define SPA_PTRDIFF(p1,p2) ((uint8_t*)(p1) - (uint8_t*)(p2))
#define SPA_PTR_TO_INT(p) ((int) ((intptr_t) (p)))
#define SPA_INT_TO_PTR(u) ((void*) ((intptr_t) (u)))

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

@ -25,6 +25,7 @@ extern "C" {
#endif
typedef struct _SpaMemory SpaMemory;
typedef struct _SpaMemoryRef SpaMemoryRef;
typedef struct _SpaMemoryPool SpaMemoryPool;
#include <spa/defs.h>
@ -43,6 +44,16 @@ typedef enum {
#define SPA_MEMORY_FLAG_READWRITE (SPA_MEMORY_FLAG_READABLE|SPA_MEMORY_FLAG_WRITABLE)
/**
* SpaMemoryRef:
* @pool_id: the pool id
* @id: mem_id
*/
struct _SpaMemoryRef {
uint32_t pool_id;
uint32_t id;
};
/**
* SpaMemory:
* @refcount: a refcount
@ -58,8 +69,7 @@ typedef enum {
struct _SpaMemory {
int refcount;
SpaNotify notify;
uint32_t pool_id;
uint32_t id;
SpaMemoryRef mem;
SpaMemoryFlags flags;
const char *type;
int fd;
@ -75,10 +85,10 @@ void spa_memory_pool_free (uint32_t);
SpaMemory * spa_memory_alloc (uint32_t pool_id);
SpaMemory * spa_memory_alloc_with_fd (uint32_t pool_id, void *data, size_t size);
SpaResult spa_memory_free (uint32_t pool_id, uint32_t id);
SpaMemory * spa_memory_import (uint32_t pool_id, uint32_t id);
SpaMemory * spa_memory_find (uint32_t pool_id, uint32_t id);
SpaResult spa_memory_free (SpaMemoryRef *ref);
SpaMemory * spa_memory_import (SpaMemoryRef *ref);
SpaMemory * spa_memory_find (SpaMemoryRef *ref);
void * spa_memory_ensure_ptr (SpaMemory *mem);

227
spa/lib/control.c
View file

@ -26,6 +26,7 @@
#include <sys/socket.h>
#include <spa/control.h>
#include <spa/debug.h>
#if 0
#define SPA_DEBUG_CONTROL(format,args...) fprintf(stderr,format,##args)
@ -339,6 +340,50 @@ spa_control_iter_get_data (SpaControlIter *iter, size_t *size)
return si->data;
}
static void
iter_parse_set_format (struct stack_iter *si, SpaControlCmdSetFormat *cmd)
{
uint32_t *p = si->data;
SpaProps *tp;
unsigned int i, j;
SpaPropInfo *pi;
SpaPropRangeInfo *ri;
cmd->port_id = *p++;
cmd->format = malloc (si->size - 4);
memcpy (cmd->format, p, si->size - 4);
tp = (SpaProps *) &cmd->format->props;
tp->prop_info = SPA_MEMBER (tp, SPA_PTR_TO_INT (tp->prop_info), SpaPropInfo);
tp->set_prop = spa_props_generic_set_prop;
tp->get_prop = spa_props_generic_get_prop;
tp->priv = NULL;
/* now fix all the pointers */
for (i = 0; i < tp->n_prop_info; i++) {
pi = (SpaPropInfo *) &tp->prop_info[i];
if (pi->name)
pi->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->name), char);
if (pi->description)
pi->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->description), char);
if (pi->default_value)
pi->default_value = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->default_value), void);
if (pi->range_values)
pi->range_values = SPA_MEMBER (tp, SPA_PTR_TO_INT (pi->range_values), SpaPropRangeInfo);
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *) &pi->range_values[j];
if (ri->name)
ri->name = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->name), char);
if (ri->description)
ri->description = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->description), char);
if (ri->value)
ri->value = SPA_MEMBER (tp, SPA_PTR_TO_INT (ri->value), void);
}
}
}
SpaResult
spa_control_iter_parse_cmd (SpaControlIter *iter,
void *command)
@ -399,12 +444,7 @@ spa_control_iter_parse_cmd (SpaControlIter *iter,
case SPA_CONTROL_CMD_SET_FORMAT:
{
SpaControlCmdSetFormat *cmd;
uint32_t *p = si->data;
cmd = command;
cmd->port_id = *p++;
cmd->format = (const SpaFormat *)p;
iter_parse_set_format (si, command);
break;
}
@ -507,7 +547,7 @@ spa_control_builder_init_full (SpaControlBuilder *builder,
sb->control.max_size = sizeof (SpaStackHeader) + 128;
sb->control.data = malloc (sb->control.max_size);
sb->control.free_data = sb->control.data;
fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n",
fprintf (stderr, "builder %p: alloc control memory %zd -> %zd\n",
builder, max_data, sb->control.max_size);
} else {
sb->control.max_size = max_data;
@ -620,7 +660,12 @@ spa_control_builder_add_fd (SpaControlBuilder *builder,
fprintf (stderr, "builder %p: realloc control fds %d -> %d\n",
builder, sb->control.max_fds, new_size);
sb->control.max_fds = new_size;
sb->control.free_fds = realloc (sb->control.free_fds, new_size * sizeof (int));
if (sb->control.free_fds == NULL) {
sb->control.free_fds = malloc (new_size * sizeof (int));
memcpy (sb->control.free_fds, sb->control.fds, sb->control.n_fds * sizeof (int));
} else {
sb->control.free_fds = realloc (sb->control.free_fds, new_size * sizeof (int));
}
sb->control.fds = sb->control.free_fds;
}
index = sb->control.n_fds;
@ -639,7 +684,12 @@ builder_ensure_size (struct stack_builder *sb, size_t size)
fprintf (stderr, "builder %p: realloc control memory %zd -> %zd\n",
sb, sb->control.max_size, new_size);
sb->control.max_size = new_size;
sb->control.free_data = realloc (sb->control.free_data, new_size);
if (sb->control.free_data == NULL) {
sb->control.free_data = malloc (new_size);
memcpy (sb->control.free_data, sb->control.data, sb->control.size);
} else {
sb->control.free_data = realloc (sb->control.free_data, new_size);
}
sb->sh = sb->control.data = sb->control.free_data;
}
return (uint8_t *) sb->control.data + sb->control.size;
@ -671,6 +721,143 @@ builder_add_cmd (struct stack_builder *sb, SpaControlCmd cmd, size_t size)
return p;
}
static void
builder_add_set_format (struct stack_builder *sb, SpaControlCmdSetFormat *sf)
{
size_t len, slen;
unsigned int i, j;
void *p, *base;
SpaFormat *tf;
SpaProps *tp;
const SpaProps *sp;
SpaPropInfo *pi, *bpi;
SpaPropRangeInfo *ri, *bri;
sp = &sf->format->props;
/* calculate length */
/* port_id + format + mask */
len = sizeof (uint32_t) + sizeof (SpaFormat) + sizeof (uint32_t);
for (i = 0; i < sp->n_prop_info; i++) {
pi = (SpaPropInfo *) &sp->prop_info[i];
len += sizeof (SpaPropInfo);
len += pi->name ? strlen (pi->name) + 1 : 0;
len += pi->description ? strlen (pi->description) + 1 : 0;
/* for the value and the default value */
len += pi->maxsize + pi->default_size;
for (j = 0; j < pi->n_range_values; j++) {
ri = (SpaPropRangeInfo *)&pi->range_values[j];
len += sizeof (SpaPropRangeInfo);
len += ri->name ? strlen (ri->name) + 1 : 0;
len += ri->description ? strlen (ri->description) + 1 : 0;
/* the size of the range value */
len += ri->size;
}
}
base = builder_add_cmd (sb, SPA_CONTROL_CMD_SET_FORMAT, len);
memcpy (base, &sf->port_id, sizeof (uint32_t));
tf = SPA_MEMBER (base, sizeof (uint32_t), SpaFormat);
tf->media_type = sf->format->media_type;
tf->media_subtype = sf->format->media_subtype;
tp = SPA_MEMBER (tf, offsetof (SpaFormat, props), SpaProps);
tp->n_prop_info = sp->n_prop_info;
tp->prop_info = SPA_INT_TO_PTR (sizeof (SpaFormat) + sizeof (uint32_t));
tp->set_prop = NULL;
tp->get_prop = NULL;
tp->priv = NULL;
/* write propinfo array, adjust offset of mask */
bpi = pi = (SpaPropInfo *) ((uint8_t *)tp + sizeof (SpaFormat) + sizeof (uint32_t));
for (i = 0; i < tp->n_prop_info; i++) {
memcpy (pi, &sp->prop_info[i], sizeof (SpaPropInfo));
pi->mask_offset = sizeof (SpaFormat);
pi->priv = NULL;
pi++;
}
bri = ri = (SpaPropRangeInfo *) pi;
pi = bpi;
/* write range info arrays, adjust offset to it */
for (i = 0; i < tp->n_prop_info; i++) {
pi->range_values = SPA_INT_TO_PTR (SPA_PTRDIFF (ri, tf));
for (j = 0; j < pi->n_range_values; j++) {
memcpy (ri, &sp->prop_info[i].range_values[j], sizeof (SpaPropRangeInfo));
ri++;
}
pi++;
}
p = ri;
pi = bpi;
ri = bri;
/* strings and default values from props and ranges */
for (i = 0; i < tp->n_prop_info; i++) {
if (pi->name) {
slen = strlen (pi->name) + 1;
memcpy (p, pi->name, slen);
pi->name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
pi->name = 0;
}
if (pi->description) {
slen = strlen (pi->description) + 1;
memcpy (p, pi->description, slen);
pi->description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
pi->description = 0;
}
if (pi->default_value) {
memcpy (p, pi->default_value, pi->default_size);
pi->default_value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += pi->default_size;
} else {
pi->default_value = 0;
}
for (j = 0; j < pi->n_range_values; j++) {
if (ri->name) {
slen = strlen (ri->name) + 1;
memcpy (p, ri->name, slen);
ri->name = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
ri->name = 0;
}
if (ri->description) {
slen = strlen (ri->description) + 1;
memcpy (p, ri->description, slen);
ri->description = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += slen;
} else {
ri->description = 0;
}
if (ri->size) {
memcpy (p, ri->value, ri->size);
ri->value = SPA_INT_TO_PTR (SPA_PTRDIFF (p, tf));
p += ri->size;
} else {
ri->value = 0;
}
ri++;
}
pi++;
}
/* and the actual values */
pi = bpi;
for (i = 0; i < tp->n_prop_info; i++) {
if (pi->offset) {
memcpy (p, SPA_MEMBER (sp, pi->offset, void), pi->maxsize);
pi->offset = SPA_PTRDIFF (p, tf);
p += pi->maxsize;
} else {
pi->offset = 0;
}
pi++;
}
}
/**
* spa_control_builder_add_cmd:
* @builder: a #SpaControlBuilder
@ -736,20 +923,8 @@ spa_control_builder_add_cmd (SpaControlBuilder *builder,
break;
case SPA_CONTROL_CMD_SET_FORMAT:
{
size_t len, slen;
SpaControlCmdSetFormat *sf = command;
uint32_t *p;
slen = strlen ("")+1;
/* port + string */
len = 4 + slen;
p = builder_add_cmd (sb, cmd, len);
*p++ = sf->port_id;
memcpy ((char*)p, sf->format, slen);
builder_add_set_format (sb, command);
break;
}
case SPA_CONTROL_CMD_SET_PROPERTY:
fprintf (stderr, "implement builder of %d\n", cmd);
@ -854,7 +1029,13 @@ spa_control_read (SpaControl *control,
if (sc->max_size < need) {
fprintf (stderr, "control: realloc receive memory %zd -> %zd\n", sc->max_size, need);
sc->max_size = need;
hdr = sc->data = sc->free_data = realloc (sc->free_data, need);
if (sc->free_data == NULL) {
sc->free_data = malloc (need);
memcpy (sc->free_data, sc->data, len);
} else {
sc->free_data = realloc (sc->free_data, need);
}
hdr = sc->data = sc->free_data;
}
sc->size = need;

299
spa/lib/debug.c
View file

@ -21,6 +21,8 @@
#include "spa/debug.h"
#include "spa/memory.h"
#include "spa/props.h"
#include "spa/format.h"
SpaResult
spa_debug_port_info (const SpaPortInfo *info)
@ -90,7 +92,8 @@ spa_debug_buffer (const SpaBuffer *buffer)
fprintf (stderr, "SpaBuffer %p:\n", buffer);
fprintf (stderr, " id: %08X\n", buffer->id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem_id);
fprintf (stderr, " pool_id: %08X\n", buffer->mem.pool_id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem.id);
fprintf (stderr, " offset: %zd\n", buffer->offset);
fprintf (stderr, " size: %zd\n", buffer->size);
fprintf (stderr, " n_metas: %u (offset %zd)\n", buffer->n_metas, buffer->metas);
@ -126,11 +129,11 @@ spa_debug_buffer (const SpaBuffer *buffer)
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
SpaMemory *mem;
mem = spa_memory_find (0, d->mem_id);
mem = spa_memory_find (&d->mem);
fprintf (stderr, " data %d: (memory %p)\n", i, mem);
if (mem) {
fprintf (stderr, " pool_id: %u\n", mem->pool_id);
fprintf (stderr, " id: %u\n", mem->id);
fprintf (stderr, " pool_id: %u\n", mem->mem.pool_id);
fprintf (stderr, " id: %u\n", mem->mem.id);
fprintf (stderr, " flags: %08x\n", mem->flags);
fprintf (stderr, " type: %s\n", mem->type ? mem->type : "*unknown*");
fprintf (stderr, " fd: %d\n", mem->fd);
@ -147,9 +150,9 @@ spa_debug_buffer (const SpaBuffer *buffer)
}
SpaResult
spa_debug_dump_mem (void *mem, size_t size)
spa_debug_dump_mem (const void *mem, size_t size)
{
uint8_t *t = mem;
const uint8_t *t = mem;
int i;
if (mem == NULL)
@ -162,3 +165,287 @@ spa_debug_dump_mem (void *mem, size_t size)
}
return SPA_RESULT_OK;
}
struct media_type_name {
const char *name;
} media_type_names[] = {
{ "unknown" },
{ "audio" },
{ "video" },
};
struct media_subtype_name {
const char *name;
} media_subtype_names[] = {
{ "unknown" },
{ "raw" },
{ "h264" },
{ "mjpg" },
};
struct prop_type_name {
const char *name;
const char *CCName;
} prop_type_names[] = {
{ "invalid", "*Invalid*" },
{ "bool", "Boolean" },
{ "int8", "Int8" },
{ "uint8", "UInt8" },
{ "int16", "Int16" },
{ "uint16", "UInt16" },
{ "int32", "Int32" },
{ "uint32", "UInt32" },
{ "int64", "Int64" },
{ "uint64", "UInt64" },
{ "int", "Int" },
{ "uint", "UInt" },
{ "float", "Float" },
{ "double", "Double" },
{ "string", "String" },
{ "rectangle", "Rectangle" },
{ "fraction", "Fraction" },
{ "bitmask", "Bitmask" },
{ "pointer", "Pointer" },
};
static void
print_value (const SpaPropInfo *info, int size, const void *value)
{
SpaPropType type = info->type;
bool enum_string = false;
if (info->range_type == SPA_PROP_RANGE_TYPE_ENUM) {
int i;
for (i = 0; i < info->n_range_values; i++) {
if (memcmp (info->range_values[i].value, value, size) == 0) {
if (info->range_values[i].name) {
type = SPA_PROP_TYPE_STRING;
value = info->range_values[i].name;
enum_string = true;
}
}
}
}
switch (type) {
case SPA_PROP_TYPE_INVALID:
fprintf (stderr, "invalid");
break;
case SPA_PROP_TYPE_BOOL:
fprintf (stderr, "%s", *(bool *)value ? "true" : "false");
break;
case SPA_PROP_TYPE_INT8:
fprintf (stderr, "%" PRIi8, *(int8_t *)value);
break;
case SPA_PROP_TYPE_UINT8:
fprintf (stderr, "%" PRIu8, *(uint8_t *)value);
break;
case SPA_PROP_TYPE_INT16:
fprintf (stderr, "%" PRIi16, *(int16_t *)value);
break;
case SPA_PROP_TYPE_UINT16:
fprintf (stderr, "%" PRIu16, *(uint16_t *)value);
break;
case SPA_PROP_TYPE_INT32:
fprintf (stderr, stderr, "%" PRIi32, *(int32_t *)value);
break;
case SPA_PROP_TYPE_UINT32:
fprintf (stderr, "%" PRIu32, *(uint32_t *)value);
break;
case SPA_PROP_TYPE_INT64:
fprintf (stderr, "%" PRIi64 "\n", *(int64_t *)value);
break;
case SPA_PROP_TYPE_UINT64:
fprintf (stderr, "%" PRIu64 "\n", *(uint64_t *)value);
break;
case SPA_PROP_TYPE_INT:
fprintf (stderr, "%d", *(int *)value);
break;
case SPA_PROP_TYPE_UINT:
fprintf (stderr, "%u", *(unsigned int *)value);
break;
case SPA_PROP_TYPE_FLOAT:
fprintf (stderr, "%f", *(float *)value);
break;
case SPA_PROP_TYPE_DOUBLE:
fprintf (stderr, "%g", *(double *)value);
break;
case SPA_PROP_TYPE_STRING:
if (enum_string)
fprintf (stderr, "%s", (char *)value);
else
fprintf (stderr, "\"%s\"", (char *)value);
break;
case SPA_PROP_TYPE_RECTANGLE:
{
const SpaRectangle *r = value;
fprintf (stderr, "%"PRIu32"x%"PRIu32, r->width, r->height);
break;
}
case SPA_PROP_TYPE_FRACTION:
{
const SpaFraction *f = value;
fprintf (stderr, "%"PRIu32"/%"PRIu32, f->num, f->denom);
break;
}
case SPA_PROP_TYPE_BITMASK:
break;
case SPA_PROP_TYPE_POINTER:
fprintf (stderr, "%p", value);
break;
default:
break;
}
}
SpaResult
spa_debug_props (const SpaProps *props, bool print_ranges)
{
SpaResult res;
const SpaPropInfo *info;
int i, j;
if (props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
fprintf (stderr, "Properties (%d items):\n", props->n_prop_info);
for (i = 0; i < props->n_prop_info; i++) {
SpaPropValue value;
info = &props->prop_info[i];
fprintf (stderr, " %-20s: %s\n", info->name, info->description);
fprintf (stderr, "%-23.23s flags: ", "");
if (info->flags & SPA_PROP_FLAG_READABLE)
fprintf (stderr, "readable ");
if (info->flags & SPA_PROP_FLAG_WRITABLE)
fprintf (stderr, "writable ");
if (info->flags & SPA_PROP_FLAG_OPTIONAL)
fprintf (stderr, "optional ");
if (info->flags & SPA_PROP_FLAG_DEPRECATED)
fprintf (stderr, "deprecated ");
fprintf (stderr, "\n");
fprintf (stderr, "%-23.23s %s. ", "", prop_type_names[info->type].CCName);
fprintf (stderr, "Default: ");
if (info->default_value)
print_value (info, info->default_size, info->default_value);
else
fprintf (stderr, "None");
res = props->get_prop (props, i, &value);
fprintf (stderr, ". Current: ");
if (res == SPA_RESULT_OK)
print_value (info, value.size, value.value);
else if (res == SPA_RESULT_PROPERTY_UNSET)
fprintf (stderr, "Unset");
else
fprintf (stderr, "Error %d", res);
fprintf (stderr, ".\n");
if (!print_ranges)
continue;
if (info->range_type != SPA_PROP_RANGE_TYPE_NONE) {
fprintf (stderr, "%-23.23s ", "");
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
fprintf (stderr, "Range");
break;
case SPA_PROP_RANGE_TYPE_STEP:
fprintf (stderr, "Step");
break;
case SPA_PROP_RANGE_TYPE_ENUM:
fprintf (stderr, "Enum");
break;
case SPA_PROP_RANGE_TYPE_FLAGS:
fprintf (stderr, "Flags");
break;
default:
fprintf (stderr, "Unknown");
break;
}
fprintf (stderr, ".\n");
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
fprintf (stderr, "%-23.23s ", "");
print_value (info, rinfo->size, rinfo->value);
fprintf (stderr, "\t: %-12s - %s \n", rinfo->name, rinfo->description);
}
}
if (info->tags) {
fprintf (stderr, "Tags: ");
for (j = 0; info->tags[j]; j++) {
fprintf (stderr, "\"%s\" ", info->tags[j]);
}
fprintf (stderr, "\n");
}
}
return SPA_RESULT_OK;
}
SpaResult
spa_debug_format (const SpaFormat *format)
{
const SpaProps *props;
int i;
if (format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
props = &format->props;
fprintf (stderr, "%-6s %s/%s\n", "", media_type_names[format->media_type].name,
media_subtype_names[format->media_subtype].name);
for (i = 0; i < props->n_prop_info; i++) {
const SpaPropInfo *info = &props->prop_info[i];
SpaPropValue value;
SpaResult res;
res = props->get_prop (props, i, &value);
if (res == SPA_RESULT_PROPERTY_UNSET && info->flags & SPA_PROP_FLAG_OPTIONAL)
continue;
fprintf (stderr, " %20s : (%s) ", info->name, prop_type_names[info->type].name);
if (res == SPA_RESULT_OK) {
print_value (info, value.size, value.value);
} else if (res == SPA_RESULT_PROPERTY_UNSET) {
int j;
const char *ssep, *esep, *sep;
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
case SPA_PROP_RANGE_TYPE_STEP:
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
case SPA_PROP_RANGE_TYPE_ENUM:
case SPA_PROP_RANGE_TYPE_FLAGS:
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
fprintf (stderr, ssep);
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
print_value (info, rinfo->size, rinfo->value);
fprintf (stderr, "%s", j + 1 < info->n_range_values ? sep : "");
}
fprintf (stderr, esep);
} else {
fprintf (stderr, "*Error*");
}
fprintf (stderr, "\n");
}
return SPA_RESULT_OK;
}

33
spa/lib/memory.c
View file

@ -114,8 +114,8 @@ spa_memory_alloc (uint32_t pool_id)
mem = &pool->memories[id];
mem->refcount = 1;
mem->notify = NULL;
mem->pool_id = pool_id;
mem->id = id;
mem->mem.pool_id = pool_id;
mem->mem.id = id;
return mem;
}
@ -159,16 +159,20 @@ spa_memory_alloc_with_fd (uint32_t pool_id, void *data, size_t size)
SpaMemory *
spa_memory_import (uint32_t pool_id, uint32_t id)
spa_memory_import (SpaMemoryRef *ref)
{
SpaMemory *mem = NULL;
SpaMemoryPool *pool;
int i;
bool init = false;
uint32_t id, pool_id;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL;
id = ref->id;
pool_id = ref->pool_id;
pool = &pools[pool_id];
for (i = 0; i < pool->n_free; i++) {
@ -184,42 +188,41 @@ spa_memory_import (uint32_t pool_id, uint32_t id)
if (init) {
mem->refcount = 1;
mem->notify = NULL;
mem->pool_id = pool_id;
mem->id = id;
mem->mem = *ref;
}
return mem;
}
SpaResult
spa_memory_free (uint32_t pool_id, uint32_t id)
spa_memory_free (SpaMemoryRef *ref)
{
SpaMemoryPool *pool;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return SPA_RESULT_INVALID_ARGUMENTS;
pool = &pools[pool_id];
pool->free_mem[pool->n_free] = id;
pool = &pools[ref->pool_id];
pool->free_mem[pool->n_free] = ref->id;
pool->n_free++;
return SPA_RESULT_OK;
}
SpaMemory *
spa_memory_find (uint32_t pool_id, uint32_t id)
spa_memory_find (SpaMemoryRef *ref)
{
SpaMemoryPool *pool;
if (pool_id >= MAX_POOLS || !pools[pool_id].valid)
if (ref == NULL || ref->pool_id >= MAX_POOLS || !pools[ref->pool_id].valid)
return NULL;
pool = &pools[pool_id];
pool = &pools[ref->pool_id];
if (id >= MAX_MEMORIES || pool->memories[id].refcount <= 0)
if (ref->id >= MAX_MEMORIES || pool->memories[ref->id].refcount <= 0)
return NULL;
return &pool->memories[id];
return &pool->memories[ref->id];
}
void *

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

@ -597,12 +597,12 @@ add_port_data (SpaAudioMixer *this, SpaBuffer *out, SpaAudioMixerPort *port)
while (true) {
if (op == NULL) {
mem = spa_memory_find (0, odatas[oi].mem_id);
mem = spa_memory_find (&odatas[oi].mem);
op = (uint8_t*)mem->ptr + odatas[oi].offset;
os = odatas[oi].size;
}
if (ip == NULL) {
mem = spa_memory_find (0, idatas[port->buffer_index].mem_id);
mem = spa_memory_find (&idatas[port->buffer_index].mem);
ip = (uint8_t*)mem->ptr + odatas[oi].offset;
is = idatas[port->buffer_index].size;
ip += port->buffer_offset;

20
spa/plugins/remote/proxy.c
View file

@ -442,7 +442,7 @@ spa_proxy_node_port_set_format (SpaNode *node,
spa_control_builder_init_into (&builder, buf, sizeof (buf), NULL, 0);
sf.port_id = port_id;
sf.format = format;
sf.format = (SpaFormat *) format;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_SET_FORMAT, &sf);
spa_control_builder_end (&builder, &control);
@ -563,19 +563,19 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
spa_control_builder_init_into (&builder, buf, sizeof (buf), fds, sizeof (fds));
if (buffer->mem_id == SPA_ID_INVALID) {
if (buffer->mem.id == SPA_ID_INVALID) {
fprintf (stderr, "proxy %p: alloc buffer space\n", this);
bmem = spa_memory_alloc_with_fd (0, buffer, buffer->size);
b = spa_memory_ensure_ptr (bmem);
b->mem_id = bmem->id;
b->mem = bmem->mem;
b->offset = 0;
} else {
bmem = spa_memory_find (0, buffer->mem_id);
bmem = spa_memory_find (&buffer->mem);
b = buffer;
}
am.port_id = port_id;
am.mem_id = bmem->id;
am.mem = bmem->mem;
am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (&builder, bmem->fd, false);
am.flags = bmem->flags;
@ -586,13 +586,13 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
SpaData *d = &SPA_BUFFER_DATAS (b)[i];
SpaMemory *mem;
if (!(mem = spa_memory_find (0, d->mem_id))) {
if (!(mem = spa_memory_find (&d->mem))) {
fprintf (stderr, "proxy %p: error invalid memory\n", this);
continue;
}
am.port_id = port_id;
am.mem_id = mem->id;
am.mem = mem->mem;
am.mem_type = 0;
am.fd_index = spa_control_builder_add_fd (&builder, mem->fd, false);
am.flags = mem->flags;
@ -601,7 +601,7 @@ add_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
}
ab.port_id = port_id;
ab.buffer_id = b->id;
ab.mem_id = bmem->id;
ab.mem = bmem->mem;
ab.offset = b->offset;
ab.size = b->size;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_ADD_BUFFER, &ab);
@ -632,14 +632,14 @@ remove_buffer (SpaProxy *this, uint32_t port_id, SpaBuffer *buffer)
rb.buffer_id = buffer->id;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_BUFFER, &rb);
rm.port_id = port_id;
rm.mem_id = buffer->mem_id;
rm.mem = buffer->mem;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm);
for (i = 0; i < buffer->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
rm.port_id = port_id;
rm.mem_id = d->mem_id;
rm.mem = d->mem;
spa_control_builder_add_cmd (&builder, SPA_CONTROL_CMD_REMOVE_MEM, &rm);
}
spa_control_builder_end (&builder, &control);

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

@ -526,18 +526,18 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
state->reqbuf = reqbuf;
if (state->alloc_mem)
spa_memory_free (state->alloc_mem->pool_id, state->alloc_mem->id);
spa_memory_free (&state->alloc_mem->mem);
state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count);
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
for (i = 0; i < reqbuf.count; i++) {
V4l2Buffer *b;
uint32_t mem_id;
SpaMemoryRef *mem_ref;
SpaMemory *mem;
SpaData *d = SPA_BUFFER_DATAS (buffers[i]);
b = &state->alloc_buffers[i];
b->buffer.mem_id = state->alloc_mem->id;
b->buffer.mem = state->alloc_mem->mem;
b->buffer.offset = sizeof (V4l2Buffer) * i;
b->buffer.size = sizeof (V4l2Buffer);
b->buffer.id = SPA_ID_INVALID;
@ -546,8 +546,8 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
fprintf (stderr, "import buffer %p\n", buffers[i]);
mem_id = SPA_BUFFER_DATAS (buffers[i])[0].mem_id;
if (!(mem = spa_memory_find (0, mem_id))) {
mem_ref = &SPA_BUFFER_DATAS (buffers[i])[0].mem;
if (!(mem = spa_memory_find (mem_ref))) {
fprintf (stderr, "invalid memory on buffer %p\n", buffers[i]);
continue;
}
@ -559,8 +559,6 @@ spa_v4l2_import_buffers (SpaV4l2Source *this, SpaBuffer **buffers, uint32_t n_bu
b->v4l2_buffer.m.userptr = (unsigned long) ((uint8_t*)mem->ptr + d[0].offset);
b->v4l2_buffer.length = d[0].size;
spa_debug_buffer (b->outbuf);
spa_v4l2_buffer_recycle (this, buffers[i]->id);
}
state->have_buffers = true;
@ -604,7 +602,7 @@ mmap_init (SpaV4l2Source *this,
state->reqbuf = reqbuf;
if (state->alloc_mem)
spa_memory_free (state->alloc_mem->pool_id, state->alloc_mem->id);
spa_memory_free (&state->alloc_mem->mem);
state->alloc_mem = spa_memory_alloc_with_fd (0, NULL, sizeof (V4l2Buffer) * reqbuf.count);
state->alloc_buffers = spa_memory_ensure_ptr (state->alloc_mem);
@ -625,7 +623,7 @@ mmap_init (SpaV4l2Source *this,
b = &state->alloc_buffers[i];
b->buffer.id = i;
b->buffer.mem_id = state->alloc_mem->id;
b->buffer.mem = state->alloc_mem->mem;
b->buffer.offset = sizeof (V4l2Buffer) * i;
b->buffer.size = sizeof (V4l2Buffer);
@ -648,7 +646,7 @@ mmap_init (SpaV4l2Source *this,
mem = spa_memory_alloc (0);
mem->flags = SPA_MEMORY_FLAG_READABLE;
mem->size = buf.length;
b->datas[0].mem_id = mem->id;
b->datas[0].mem = mem->mem;
b->datas[0].offset = 0;
b->datas[0].size = buf.length;
b->datas[0].stride = state->fmt.fmt.pix.bytesperline;
@ -690,8 +688,6 @@ mmap_init (SpaV4l2Source *this,
b->v4l2_buffer.memory = state->memtype;
b->v4l2_buffer.index = i;
spa_debug_buffer (b->outbuf);
spa_v4l2_buffer_recycle (this, i);
}
state->have_buffers = true;
@ -799,13 +795,13 @@ spa_v4l2_stop (SpaV4l2Source *this)
fprintf (stderr, "queueing outstanding buffer %p\n", b);
spa_v4l2_buffer_recycle (this, i);
}
mem = spa_memory_find (0, b->datas[0].mem_id);
mem = spa_memory_find (&b->datas[0].mem);
if (state->export_buf) {
close (mem->fd);
} else {
munmap (mem->ptr, mem->size);
}
spa_memory_free (0, mem->id);
spa_memory_free (&mem->mem);
}
state->have_buffers = false;

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

@ -583,8 +583,8 @@ spa_volume_node_port_pull_output (SpaNode *node,
sd = &SPA_BUFFER_DATAS (sbuf)[si];
dd = &SPA_BUFFER_DATAS (dbuf)[di];
sm = spa_memory_find (0, sd->mem_id);
dm = spa_memory_find (0, dd->mem_id);
sm = spa_memory_find (&sd->mem);
dm = spa_memory_find (&dd->mem);
src = (uint16_t*) ((uint8_t*)sm->ptr + sd->offset + soff);
dst = (uint16_t*) ((uint8_t*)dm->ptr + dd->offset + doff);

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

@ -150,7 +150,7 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return;
}
mem = spa_memory_find (0, datas[0].mem_id);
mem = spa_memory_find (&datas[0].mem);
mem->ptr = sdata;
mem->type = "sysmem";
mem->size = sstride * 240;
@ -162,7 +162,7 @@ on_source_event (SpaNode *node, SpaEvent *event, void *user_data)
fprintf (stderr, "Couldn't lock texture: %s\n", SDL_GetError());
return;
}
mem = spa_memory_find (0, datas[0].mem_id);
mem = spa_memory_find (&datas[0].mem);
sdata = spa_memory_ensure_ptr (mem);
sstride = datas[0].stride;
@ -252,6 +252,9 @@ alloc_buffers (AppData *data)
}
b->buffer.id = i;
b->buffer.mem.pool_id = SPA_ID_INVALID;
b->buffer.mem.id = SPA_ID_INVALID;
b->buffer.offset = 0;
b->buffer.size = sizeof (SDLBuffer);
b->buffer.n_metas = 2;
b->buffer.metas = offsetof (SDLBuffer, metas);
@ -279,7 +282,7 @@ alloc_buffers (AppData *data)
mem->ptr = ptr;
mem->size = stride * 240;
b->datas[0].mem_id = mem->id;
b->datas[0].mem = mem->mem;
b->datas[0].offset = 0;
b->datas[0].size = mem->size;
b->datas[0].stride = stride;

1
spa/tools/meson.build
View file

@ -1,4 +1,5 @@
executable('spa-inspect', 'spa-inspect.c',
include_directories : inc,
dependencies : [dl_lib],
link_with : spalib,
install : true)

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

@ -24,279 +24,7 @@
#include <dlfcn.h>
#include <spa/node.h>
struct media_type_name {
const char *name;
} media_type_names[] = {
{ "unknown" },
{ "audio" },
{ "video" },
};
struct media_subtype_name {
const char *name;
} media_subtype_names[] = {
{ "unknown" },
{ "raw" },
{ "h264" },
{ "mjpg" },
};
struct prop_type_name {
const char *name;
const char *CCName;
} prop_type_names[] = {
{ "invalid", "*Invalid*" },
{ "bool", "Boolean" },
{ "int8", "Int8" },
{ "uint8", "UInt8" },
{ "int16", "Int16" },
{ "uint16", "UInt16" },
{ "int32", "Int32" },
{ "uint32", "UInt32" },
{ "int64", "Int64" },
{ "uint64", "UInt64" },
{ "int", "Int" },
{ "uint", "UInt" },
{ "double", "Double" },
{ "string", "String" },
{ "rectangle", "Rectangle" },
{ "fraction", "Fraction" },
{ "bitmask", "Bitmask" },
{ "pointer", "Pointer" },
};
static void
print_value (const SpaPropInfo *info, int size, const void *value)
{
SpaPropType type = info->type;
bool enum_string = false;
if (info->range_type == SPA_PROP_RANGE_TYPE_ENUM) {
int i;
for (i = 0; i < info->n_range_values; i++) {
if (memcmp (info->range_values[i].value, value, size) == 0) {
if (info->range_values[i].name) {
type = SPA_PROP_TYPE_STRING;
value = info->range_values[i].name;
enum_string = true;
}
}
}
}
switch (type) {
case SPA_PROP_TYPE_INVALID:
printf ("invalid");
break;
case SPA_PROP_TYPE_BOOL:
printf ("%s", *(bool *)value ? "true" : "false");
break;
case SPA_PROP_TYPE_INT8:
printf ("%" PRIi8, *(int8_t *)value);
break;
case SPA_PROP_TYPE_UINT8:
printf ("%" PRIu8, *(uint8_t *)value);
break;
case SPA_PROP_TYPE_INT16:
printf ("%" PRIi16, *(int16_t *)value);
break;
case SPA_PROP_TYPE_UINT16:
printf ("%" PRIu16, *(uint16_t *)value);
break;
case SPA_PROP_TYPE_INT32:
printf ("%" PRIi32, *(int32_t *)value);
break;
case SPA_PROP_TYPE_UINT32:
printf ("%" PRIu32, *(uint32_t *)value);
break;
case SPA_PROP_TYPE_INT64:
printf ("%" PRIi64 "\n", *(int64_t *)value);
break;
case SPA_PROP_TYPE_UINT64:
printf ("%" PRIu64 "\n", *(uint64_t *)value);
break;
case SPA_PROP_TYPE_INT:
printf ("%d", *(int *)value);
break;
case SPA_PROP_TYPE_UINT:
printf ("%u", *(unsigned int *)value);
break;
case SPA_PROP_TYPE_FLOAT:
printf ("%f", *(float *)value);
break;
case SPA_PROP_TYPE_DOUBLE:
printf ("%g", *(double *)value);
break;
case SPA_PROP_TYPE_STRING:
if (enum_string)
printf ("%s", (char *)value);
else
printf ("\"%s\"", (char *)value);
break;
case SPA_PROP_TYPE_RECTANGLE:
{
const SpaRectangle *r = value;
printf ("%"PRIu32"x%"PRIu32, r->width, r->height);
break;
}
case SPA_PROP_TYPE_FRACTION:
{
const SpaFraction *f = value;
printf ("%"PRIu32"/%"PRIu32, f->num, f->denom);
break;
}
case SPA_PROP_TYPE_BITMASK:
break;
case SPA_PROP_TYPE_POINTER:
printf ("%p", value);
break;
default:
break;
}
}
static void
print_props (const SpaProps *props, int print_ranges)
{
SpaResult res;
const SpaPropInfo *info;
int i, j;
printf ("Properties (%d items):\n", props->n_prop_info);
for (i = 0; i < props->n_prop_info; i++) {
SpaPropValue value;
info = &props->prop_info[i];
printf (" %-20s: %s\n", info->name, info->description);
printf ("%-23.23s flags: ", "");
if (info->flags & SPA_PROP_FLAG_READABLE)
printf ("readable ");
if (info->flags & SPA_PROP_FLAG_WRITABLE)
printf ("writable ");
if (info->flags & SPA_PROP_FLAG_OPTIONAL)
printf ("optional ");
if (info->flags & SPA_PROP_FLAG_DEPRECATED)
printf ("deprecated ");
printf ("\n");
printf ("%-23.23s %s. ", "", prop_type_names[info->type].CCName);
printf ("Default: ");
if (info->default_value)
print_value (info, info->default_size, info->default_value);
else
printf ("None");
res = props->get_prop (props, i, &value);
printf (". Current: ");
if (res == SPA_RESULT_OK)
print_value (info, value.size, value.value);
else if (res == SPA_RESULT_PROPERTY_UNSET)
printf ("Unset");
else
printf ("Error %d", res);
printf (".\n");
if (!print_ranges)
continue;
if (info->range_type != SPA_PROP_RANGE_TYPE_NONE) {
printf ("%-23.23s ", "");
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
printf ("Range");
break;
case SPA_PROP_RANGE_TYPE_STEP:
printf ("Step");
break;
case SPA_PROP_RANGE_TYPE_ENUM:
printf ("Enum");
break;
case SPA_PROP_RANGE_TYPE_FLAGS:
printf ("Flags");
break;
default:
printf ("Unknown");
break;
}
printf (".\n");
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
printf ("%-23.23s ", "");
print_value (info, rinfo->size, rinfo->value);
printf ("\t: %-12s - %s \n", rinfo->name, rinfo->description);
}
}
if (info->tags) {
printf ("Tags: ");
for (j = 0; info->tags[j]; j++) {
printf ("\"%s\" ", info->tags[j]);
}
printf ("\n");
}
}
}
static void
print_format (const SpaFormat *format)
{
const SpaProps *props = &format->props;
int i;
printf ("%-6s %s/%s\n", "", media_type_names[format->media_type].name,
media_subtype_names[format->media_subtype].name);
for (i = 0; i < props->n_prop_info; i++) {
const SpaPropInfo *info = &props->prop_info[i];
SpaPropValue value;
SpaResult res;
res = props->get_prop (props, i, &value);
if (res == SPA_RESULT_PROPERTY_UNSET && info->flags & SPA_PROP_FLAG_OPTIONAL)
continue;
printf (" %20s : (%s) ", info->name, prop_type_names[info->type].name);
if (res == SPA_RESULT_OK) {
print_value (info, value.size, value.value);
} else if (res == SPA_RESULT_PROPERTY_UNSET) {
int j;
const char *ssep, *esep, *sep;
switch (info->range_type) {
case SPA_PROP_RANGE_TYPE_MIN_MAX:
case SPA_PROP_RANGE_TYPE_STEP:
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
case SPA_PROP_RANGE_TYPE_ENUM:
case SPA_PROP_RANGE_TYPE_FLAGS:
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
printf (ssep);
for (j = 0; j < info->n_range_values; j++) {
const SpaPropRangeInfo *rinfo = &info->range_values[j];
print_value (info, rinfo->size, rinfo->value);
printf ("%s", j + 1 < info->n_range_values ? sep : "");
}
printf (esep);
} else {
printf ("*Error*");
}
printf ("\n");
}
}
#include <spa/debug.h>
static void
inspect_node (SpaNode *node)
@ -310,7 +38,7 @@ inspect_node (SpaNode *node)
if ((res = node->get_props (node, &props)) < 0)
printf ("can't get properties: %d\n", res);
else
print_props (props, 1);
spa_debug_props (props, true);
if ((res = node->get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0)
printf ("can't get n_ports: %d\n", res);
@ -324,12 +52,12 @@ inspect_node (SpaNode *node)
break;
}
if (format)
print_format (format);
spa_debug_format (format);
}
if ((res = node->port_get_props (node, 0, &props)) < 0)
printf ("port_get_props error: %d\n", res);
else
print_props (props, 1);
spa_debug_props (props, true);
}
static void
@ -343,7 +71,7 @@ inspect_factory (const SpaHandleFactory *factory)
printf ("factory name:\t\t'%s'\n", factory->name);
printf ("factory info:\n");
if (factory->info)
print_props (factory->info, 1);
spa_debug_props (factory->info, true);
else
printf (" none\n");