system/pipewire
system/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire synced 2024-07-21 02:05:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

remove spalib

Browse source
This commit is contained in:
Wim Taymans 2018-08-14 12:33:53 +02:00
parent f532fd8681
commit a6ad8f747f
69 changed files with 612 additions and 1250 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
pkgconfig/libspa.pc.in
View file

@ -1,10 +1,7 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@/
Name: libspa
Description: Simple Plugin API
Version: @VERSION@
Libs: -L${libdir} -lspa-lib
Cflags: -I${includedir} -D_REENTRANT

91
spa/include/spa/debug/buffer.h Normal file
View file

@ -0,0 +1,91 @@
/* Simple Plugin API
* Copyright (C) 2018 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_DEBUG_BUFFER_H__
#define __SPA_DEBUG_BUFFER_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/support/type-map.h>
#include <spa/debug/debug-mem.h>
#ifndef spa_debug
#define spa_debug(...) ({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
#endif
static inline int spa_debug_buffer(int indent,
struct spa_type_map *map, const struct spa_buffer *buffer)
{
int i;
spa_debug("%*s" "struct spa_buffer %p:", indent, "", buffer);
spa_debug("%*s" " id: %08X", indent, "", buffer->id);
spa_debug("%*s" " n_metas: %u (at %p)", indent, "", buffer->n_metas, buffer->metas);
for (i = 0; i < buffer->n_metas; i++) {
struct spa_meta *m = &buffer->metas[i];
const char *type_name;
type_name = spa_type_map_get_type(map, m->type);
spa_debug("%*s" " meta %d: type %d (%s), data %p, size %d:", indent, "", i, m->type,
type_name, m->data, m->size);
if (!strcmp(type_name, SPA_TYPE_META__Header)) {
struct spa_meta_header *h = m->data;
spa_debug("%*s" " struct spa_meta_header:", indent, "");
spa_debug("%*s" " flags: %08x", indent, "", h->flags);
spa_debug("%*s" " seq: %u", indent, "", h->seq);
spa_debug("%*s" " pts: %" PRIi64, indent, "", h->pts);
spa_debug("%*s" " dts_offset: %" PRIi64, indent, "", h->dts_offset);
} else if (!strcmp(type_name, SPA_TYPE_META__VideoCrop)) {
struct spa_meta_video_crop *h = m->data;
spa_debug("%*s" " struct spa_meta_video_crop:", indent, "");
spa_debug("%*s" " x: %d", indent, "", h->x);
spa_debug("%*s" " y: %d", indent, "", h->y);
spa_debug("%*s" " width: %d", indent, "", h->width);
spa_debug("%*s" " height: %d", indent, "", h->height);
} else {
spa_debug("%*s" " Unknown:", indent, "");
spa_debug_mem(5, m->data, m->size);
}
}
spa_debug("%*s" " n_datas: \t%u (at %p)", indent, "", buffer->n_datas, buffer->datas);
for (i = 0; i < buffer->n_datas; i++) {
struct spa_data *d = &buffer->datas[i];
spa_debug("%*s" " type: %d (%s)", indent, "", d->type,
spa_type_map_get_type(map, d->type));
spa_debug("%*s" " flags: %d", indent, "", d->flags);
spa_debug("%*s" " data: %p", indent, "", d->data);
spa_debug("%*s" " fd: %d", indent, "", d->fd);
spa_debug("%*s" " offset: %d", indent, "", d->mapoffset);
spa_debug("%*s" " maxsize: %u", indent, "", d->maxsize);
spa_debug("%*s" " chunk: %p", indent, "", d->chunk);
spa_debug("%*s" " offset: %d", indent, "", d->chunk->offset);
spa_debug("%*s" " size: %u", indent, "", d->chunk->size);
spa_debug("%*s" " stride: %d", indent, "", d->chunk->stride);
}
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_DEBUG_BUFFER_H__ */

36
spa/lib/pod.h → spa/include/spa/debug/dict.h
View file

@ -1,5 +1,5 @@
/* Simple Plugin API
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
* Copyright (C) 2018 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
@ -17,26 +17,30 @@
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_LIBPOD_H__
#define __SPA_LIBPOD_H__
#ifndef __SPA_DEBUG_DICT_H__
#define __SPA_DEBUG_DICT_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/props.h>
#include <spa/pod/builder.h>
#include <spa/utils/dict.h>
int spa_pod_filter(struct spa_pod_builder *b,
struct spa_pod **result,
const struct spa_pod *pod,
const struct spa_pod *filter);
int spa_pod_compare(const struct spa_pod *pod1,
const struct spa_pod *pod2);
#ifdef __cplusplus
} /* extern "C" */
#ifndef spa_debug
#define spa_debug(...) ({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
#endif
#endif /* __SPA_LIBPOD_H__ */
static inline int spa_debug_dict(int indent, const struct spa_dict *dict)
{
const struct spa_dict_item *item;
spa_dict_for_each(item, dict) {
spa_debug("%*s%s = \"%s\"", indent, "", item->key, item->value);
}
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_DEBUG_DICT_H__ */

34
spa/lib/debug.h → spa/include/spa/debug/format.h
View file

@ -1,5 +1,5 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
* Copyright (C) 2018 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
@ -17,26 +17,32 @@
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_LIBDEBUG_H__
#define __SPA_LIBDEBUG_H__
#ifndef __SPA_DEBUG_FORMAT_H__
#define __SPA_DEBUG_FORMAT_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/node/node.h>
#include <spa/pod/pod.h>
#include <spa/support/type-map.h>
#include <spa/debug/mem.h>
#include <spa/debug/pod.h>
void spa_debug_set_type_map(const struct spa_type_map *map);
#ifndef spa_debug
#define spa_debug(...) ({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
#endif
int spa_debug_port_info(const struct spa_port_info *info);
int spa_debug_buffer(const struct spa_buffer *buffer);
#define SPA_DEBUG_FLAG_FORMAT (1 << 0)
int spa_debug_pod(const struct spa_pod *pod, uint32_t flags);
int spa_debug_dump_mem(const void *data, size_t size);
int spa_debug_dict(const struct spa_dict *dict);
static inline int spa_debug_format(int indent,
struct spa_type_map *map, const struct spa_pod *pod)
{
return spa_debug_pod_value(indent, map,
SPA_POD_TYPE(pod),
SPA_POD_BODY(pod),
SPA_POD_BODY_SIZE(pod));
}
#ifdef __cplusplus
} /* extern "C" */
} /* extern "C" */
#endif
#endif /* __SPA_LIBDEBUG_H__ */
#endif /* __SPA_DEBUG_FORMAT_H__ */

54
spa/include/spa/debug/mem.h Normal file
View file

@ -0,0 +1,54 @@
/* Simple Plugin API
* Copyright (C) 2018 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_DEBUG_MEM_H__
#define __SPA_DEBUG_MEM_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/dict.h>
#ifndef spa_debug
#define spa_debug(...) ({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
#endif
static inline int spa_debug_mem(int indent, const void *data, size_t size)
{
const uint8_t *t = data;
char buffer[512];
int i, pos = 0;
for (i = 0; i < size; i++) {
if (i % 16 == 0)
pos = sprintf(buffer, "%p: ", &t[i]);
pos += sprintf(buffer + pos, "%02x ", t[i]);
if (i % 16 == 15 || i == size - 1) {
spa_debug("%*s" "%s", indent, "", buffer);
}
}
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_DEBUG_MEM_H__ */

52
spa/include/spa/debug/node.h Normal file
View file

@ -0,0 +1,52 @@
/* Simple Plugin API
* Copyright (C) 2018 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_DEBUG_NODE_H__
#define __SPA_DEBUG_NODE_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/node/node.h>
#include <spa/debug/dict.h>
#ifndef spa_debug
#define spa_debug(...) ({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
#endif
int spa_debug_port_info(int indent, const struct spa_port_info *info)
{
spa_debug("%*s" "struct spa_port_info %p:", indent, "", info);
spa_debug("%*s" " flags: \t%08x", indent, "", info->flags);
spa_debug("%*s" " rate: \t%u", indent, "", info->rate);
spa_debug("%*s" " props:", indent, "");
if (info->props)
spa_debug_dict(indent + 2, info->props);
else
spa_debug("%*s" " none", indent, "");
return 0;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_DEBUG_NODE_H__ */

206
spa/include/spa/debug/pod.h Normal file
View file

@ -0,0 +1,206 @@
/* Simple Plugin API
* Copyright (C) 2018 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_DEBUG_POD_H__
#define __SPA_DEBUG_POD_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/support/type-map.h>
#include <spa/debug/mem.h>
#include <spa/pod/pod.h>
#include <spa/pod/iter.h>
#ifndef spa_debug
#define spa_debug(...) ({ fprintf(stderr, __VA_ARGS__);fputc('\n', stderr); })
#endif
static inline int
spa_debug_pod_value(int indent, struct spa_type_map *map,
uint32_t type, void *body, uint32_t size)
{
switch (type) {
case SPA_POD_TYPE_BOOL:
spa_debug("%*s" "Bool %d", indent, "", *(int32_t *) body);
break;
case SPA_POD_TYPE_ID:
spa_debug("%*s" "Id %d %s", indent, "", *(int32_t *) body,
spa_type_map_get_type(map, *(int32_t *) body));
break;
case SPA_POD_TYPE_INT:
spa_debug("%*s" "Int %d", indent, "", *(int32_t *) body);
break;
case SPA_POD_TYPE_LONG:
spa_debug("%*s" "Long %" PRIi64 "", indent, "", *(int64_t *) body);
break;
case SPA_POD_TYPE_FLOAT:
spa_debug("%*s" "Float %f", indent, "", *(float *) body);
break;
case SPA_POD_TYPE_DOUBLE:
spa_debug("%*s" "Double %f", indent, "", *(double *) body);
break;
case SPA_POD_TYPE_STRING:
spa_debug("%*s" "String \"%s\"", indent, "", (char *) body);
break;
case SPA_POD_TYPE_FD:
spa_debug("%*s" "Fd %d", indent, "", *(int *) body);
break;
case SPA_POD_TYPE_POINTER:
{
struct spa_pod_pointer_body *b = body;
spa_debug("%*s" "Pointer %s %p", indent, "",
map ? spa_type_map_get_type(map, b->type) : "*no map*", b->value);
break;
}
case SPA_POD_TYPE_RECTANGLE:
{
struct spa_rectangle *r = body;
spa_debug("%*s" "Rectangle %dx%d", indent, "", r->width, r->height);
break;
}
case SPA_POD_TYPE_FRACTION:
{
struct spa_fraction *f = body;
spa_debug("%*s" "Fraction %d/%d", indent, "", f->num, f->denom);
break;
}
case SPA_POD_TYPE_BITMAP:
spa_debug("%*s" "Bitmap", indent, "");
break;
case SPA_POD_TYPE_ARRAY:
{
struct spa_pod_array_body *b = body;
void *p;
spa_debug("%*s" "Array: child.size %d, child.type %d", indent, "",
b->child.size, b->child.type);
SPA_POD_ARRAY_BODY_FOREACH(b, size, p)
spa_debug_pod_value(indent + 2, map, b->child.type, p, b->child.size);
break;
}
case SPA_POD_TYPE_STRUCT:
{
struct spa_pod *b = body, *p;
spa_debug("%*s" "Struct: size %d", indent, "", size);
SPA_POD_FOREACH(b, size, p)
spa_debug_pod_value(indent + 2, map, p->type, SPA_POD_BODY(p), p->size);
break;
}
case SPA_POD_TYPE_OBJECT:
{
struct spa_pod_object_body *b = body;
struct spa_pod *p;
spa_debug("%*s" "Object: size %d, id %s, type %s", indent, "", size,
map ? spa_type_map_get_type(map, b->id) : "*no map*",
map ? spa_type_map_get_type(map, b->type) : "*no map*");
SPA_POD_OBJECT_BODY_FOREACH(b, size, p)
spa_debug_pod_value(indent + 2, map, p->type, SPA_POD_BODY(p), p->size);
break;
}
case SPA_POD_TYPE_PROP:
{
struct spa_pod_prop_body *b = body;
void *alt;
int i;
spa_debug("%*s" "Prop: key %s, flags %d", indent, "",
map ? spa_type_map_get_type(map, b->key) : "*no map*", b->flags);
if (b->flags & SPA_POD_PROP_FLAG_UNSET)
spa_debug("%*s" "Unset (Default):", indent + 2, "");
else
spa_debug("%*s" "Value: size %u", indent + 2, "", b->value.size);
spa_debug_pod_value(indent + 4, map, b->value.type, SPA_POD_BODY(&b->value),
b->value.size);
i = 0;
switch (b->flags & SPA_POD_PROP_RANGE_MASK) {
case SPA_POD_PROP_RANGE_NONE:
break;
case SPA_POD_PROP_RANGE_MIN_MAX:
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt) {
if (i == 0)
spa_debug("%*s" "Min: ", indent + 2, "");
else if (i == 1)
spa_debug("%*s" "Max: ", indent + 2, "");
else
break;
spa_debug_pod_value(indent + 4, map, b->value.type, alt, b->value.size);
i++;
}
break;
case SPA_POD_PROP_RANGE_STEP:
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt) {
if (i == 0)
spa_debug("%*s" "Min: ", indent + 2, "");
else if (i == 1)
spa_debug("%*s" "Max: ", indent + 2, "");
else if (i == 2)
spa_debug("%*s" "Step: ", indent + 2, "");
else
break;
spa_debug_pod_value(indent + 4, map, b->value.type, alt, b->value.size);
i++;
}
break;
case SPA_POD_PROP_RANGE_ENUM:
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt) {
if (i == 0) {
spa_debug("%*s" "Enum:", indent + 2, "");
}
spa_debug_pod_value(indent + 4, map, b->value.type, alt, b->value.size);
i++;
}
break;
case SPA_POD_PROP_RANGE_FLAGS:
break;
}
break;
}
case SPA_POD_TYPE_BYTES:
spa_debug("%*s" "Bytes", indent, "");
spa_debug_mem(indent + 2, body, size);
break;
case SPA_POD_TYPE_NONE:
spa_debug("%*s" "None", indent, "");
spa_debug_mem(indent + 2, body, size);
break;
default:
spa_debug("%*s" "unhandled POD type %d", indent, "", type);
break;
}
return 0;
}
static inline int spa_debug_pod(int indent,
struct spa_type_map *map, const struct spa_pod *pod)
{
return spa_debug_pod_value(indent, map,
SPA_POD_TYPE(pod),
SPA_POD_BODY(pod),
SPA_POD_BODY_SIZE(pod));
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_DEBUG_POD_H__ */

4
spa/include/spa/support/log.h
View file

@ -102,8 +102,10 @@ struct spa_log {
(defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
#define spa_log_log(l,lev,...) \
({ \
if (SPA_UNLIKELY (spa_log_level_enabled (l, lev))) \
(l)->log((l),lev,__VA_ARGS__)
(l)->log((l),lev,__VA_ARGS__); \
})
#define spa_log_error(l,...) spa_log_log(l,SPA_LOG_LEVEL_ERROR,__FILE__,__LINE__,__func__,__VA_ARGS__)
#define spa_log_warn(l,...) spa_log_log(l,SPA_LOG_LEVEL_WARN,__FILE__,__LINE__,__func__,__VA_ARGS__)

469
spa/lib/debug.c
View file

@ -1,469 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/eventfd.h>
#include <spa/support/loop.h>
#include <spa/pod/parser.h>
#include "debug.h"
static const struct spa_type_map *map;
void spa_debug_set_type_map(const struct spa_type_map *m)
{
map = m;
}
int spa_debug_port_info(const struct spa_port_info *info)
{
if (info == NULL)
return -EINVAL;
fprintf(stderr, "struct spa_port_info %p:\n", info);
fprintf(stderr, " flags: \t%08x\n", info->flags);
return 0;
}
int spa_debug_buffer(const struct spa_buffer *buffer)
{
int i;
if (buffer == NULL)
return -EINVAL;
fprintf(stderr, "spa_buffer %p:\n", buffer);
fprintf(stderr, " id: %08X\n", buffer->id);
fprintf(stderr, " n_metas: %u (at %p)\n", buffer->n_metas, buffer->metas);
for (i = 0; i < buffer->n_metas; i++) {
struct spa_meta *m = &buffer->metas[i];
const char *type_name;
type_name = spa_type_map_get_type(map, m->type);
fprintf(stderr, " meta %d: type %d (%s), data %p, size %d:\n", i, m->type,
type_name, m->data, m->size);
if (!strcmp(type_name, SPA_TYPE_META__Header)) {
struct spa_meta_header *h = m->data;
fprintf(stderr, " struct spa_meta_header:\n");
fprintf(stderr, " flags: %08x\n", h->flags);
fprintf(stderr, " seq: %u\n", h->seq);
fprintf(stderr, " pts: %" PRIi64 "\n", h->pts);
fprintf(stderr, " dts_offset: %" PRIi64 "\n", h->dts_offset);
} else if (strstr(type_name, SPA_TYPE_META_REGION_BASE) == type_name) {
struct spa_meta_region *h = m->data;
fprintf(stderr, " struct spa_meta_region:\n");
fprintf(stderr, " x: %d\n", h->region.position.x);
fprintf(stderr, " y: %d\n", h->region.position.y);
fprintf(stderr, " width: %d\n", h->region.size.width);
fprintf(stderr, " height: %d\n", h->region.size.height);
} else if (strstr(type_name, SPA_TYPE_META_REGION_ARRAY_BASE) == type_name) {
struct spa_meta_region *p;
fprintf(stderr, " struct spa_meta_region_array:\n");
spa_meta_region_for_each(p, m) {
fprintf(stderr, " x: %d\n", p->region.position.x);
fprintf(stderr, " y: %d\n", p->region.position.y);
fprintf(stderr, " width: %d\n", p->region.size.width);
fprintf(stderr, " height: %d\n", p->region.size.height);
}
} else {
fprintf(stderr, " Unknown:\n");
spa_debug_dump_mem(m->data, m->size);
}
}
fprintf(stderr, " n_datas: \t%u (at %p)\n", buffer->n_datas, buffer->datas);
for (i = 0; i < buffer->n_datas; i++) {
struct spa_data *d = &buffer->datas[i];
fprintf(stderr, " type: %d (%s)\n", d->type,
spa_type_map_get_type(map, d->type));
fprintf(stderr, " flags: %d\n", d->flags);
fprintf(stderr, " data: %p\n", d->data);
fprintf(stderr, " fd: %d\n", d->fd);
fprintf(stderr, " offset: %d\n", d->mapoffset);
fprintf(stderr, " maxsize: %u\n", d->maxsize);
fprintf(stderr, " chunk: %p\n", d->chunk);
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 0;
}
int spa_debug_dump_mem(const void *mem, size_t size)
{
const uint8_t *t = mem;
int i;
if (mem == NULL)
return -EINVAL;
for (i = 0; i < size; i++) {
if (i % 16 == 0)
fprintf(stderr,"%p: ", &t[i]);
fprintf(stderr,"%02x ", t[i]);
if (i % 16 == 15 || i == size - 1)
fprintf(stderr,"\n");
}
return 0;
}
static const char *pod_type_names[] = {
[SPA_POD_TYPE_INVALID] = "invalid",
[SPA_POD_TYPE_NONE] = "none",
[SPA_POD_TYPE_BOOL] = "bool",
[SPA_POD_TYPE_ID] = "id",
[SPA_POD_TYPE_INT] = "int",
[SPA_POD_TYPE_LONG] = "long",
[SPA_POD_TYPE_FLOAT] = "float",
[SPA_POD_TYPE_DOUBLE] = "double",
[SPA_POD_TYPE_STRING] = "string",
[SPA_POD_TYPE_BYTES] = "bytes",
[SPA_POD_TYPE_RECTANGLE] = "rectangle",
[SPA_POD_TYPE_FRACTION] = "fraction",
[SPA_POD_TYPE_BITMAP] = "bitmap",
[SPA_POD_TYPE_ARRAY] = "array",
[SPA_POD_TYPE_STRUCT] = "struct",
[SPA_POD_TYPE_OBJECT] = "object",
[SPA_POD_TYPE_POINTER] = "pointer",
[SPA_POD_TYPE_FD] = "fd",
[SPA_POD_TYPE_PROP] = "prop",
[SPA_POD_TYPE_POD] = "pod"
};
static void
print_pod_value(uint32_t size, uint32_t type, void *body, int prefix)
{
switch (type) {
case SPA_POD_TYPE_BOOL:
fprintf(stderr,"%-*sBool %d\n", prefix, "", *(int32_t *) body);
break;
case SPA_POD_TYPE_ID:
fprintf(stderr,"%-*sId %d %s\n", prefix, "", *(int32_t *) body,
spa_type_map_get_type(map, *(int32_t *) body));
break;
case SPA_POD_TYPE_INT:
fprintf(stderr,"%-*sInt %d\n", prefix, "", *(int32_t *) body);
break;
case SPA_POD_TYPE_LONG:
fprintf(stderr,"%-*sLong %" PRIi64 "\n", prefix, "", *(int64_t *) body);
break;
case SPA_POD_TYPE_FLOAT:
fprintf(stderr,"%-*sFloat %f\n", prefix, "", *(float *) body);
break;
case SPA_POD_TYPE_DOUBLE:
fprintf(stderr,"%-*sDouble %f\n", prefix, "", *(double *) body);
break;
case SPA_POD_TYPE_STRING:
fprintf(stderr,"%-*sString \"%s\"\n", prefix, "", (char *) body);
break;
case SPA_POD_TYPE_FD:
fprintf(stderr,"%-*sFd %d\n", prefix, "", *(int *) body);
break;
case SPA_POD_TYPE_POINTER:
{
struct spa_pod_pointer_body *b = body;
fprintf(stderr,"%-*sPointer %s %p\n", prefix, "",
map ? spa_type_map_get_type(map, b->type) : "*no map*", b->value);
break;
}
case SPA_POD_TYPE_RECTANGLE:
{
struct spa_rectangle *r = body;
fprintf(stderr,"%-*sRectangle %dx%d\n", prefix, "", r->width, r->height);
break;
}
case SPA_POD_TYPE_FRACTION:
{
struct spa_fraction *f = body;
fprintf(stderr,"%-*sFraction %d/%d\n", prefix, "", f->num, f->denom);
break;
}
case SPA_POD_TYPE_BITMAP:
fprintf(stderr,"%-*sBitmap\n", prefix, "");
break;
case SPA_POD_TYPE_ARRAY:
{
struct spa_pod_array_body *b = body;
void *p;
fprintf(stderr,"%-*sArray: child.size %d, child.type %d\n", prefix, "",
b->child.size, b->child.type);
SPA_POD_ARRAY_BODY_FOREACH(b, size, p)
print_pod_value(b->child.size, b->child.type, p, prefix + 2);
break;
}
case SPA_POD_TYPE_STRUCT:
{
struct spa_pod *b = body, *p;
fprintf(stderr,"%-*sStruct: size %d\n", prefix, "", size);
SPA_POD_FOREACH(b, size, p)
print_pod_value(p->size, p->type, SPA_POD_BODY(p), prefix + 2);
break;
}
case SPA_POD_TYPE_OBJECT:
{
struct spa_pod_object_body *b = body;
struct spa_pod *p;
fprintf(stderr,"%-*sObject: size %d, id %s, type %s\n", prefix, "", size,
map ? spa_type_map_get_type(map, b->id) : "*no map*",
map ? spa_type_map_get_type(map, b->type) : "*no map*");
SPA_POD_OBJECT_BODY_FOREACH(b, size, p)
print_pod_value(p->size, p->type, SPA_POD_BODY(p), prefix + 2);
break;
}
case SPA_POD_TYPE_PROP:
{
struct spa_pod_prop_body *b = body;
void *alt;
int i;
fprintf(stderr,"%-*sProp: key %s, flags %d\n", prefix, "",
map ? spa_type_map_get_type(map, b->key) : "*no map*", b->flags);
if (b->flags & SPA_POD_PROP_FLAG_UNSET)
fprintf(stderr,"%-*sUnset (Default):\n", prefix + 2, "");
else
fprintf(stderr,"%-*sValue: size %u\n", prefix + 2, "", b->value.size);
print_pod_value(b->value.size, b->value.type, SPA_POD_BODY(&b->value),
prefix + 4);
i = 0;
switch (b->flags & SPA_POD_PROP_RANGE_MASK) {
case SPA_POD_PROP_RANGE_NONE:
break;
case SPA_POD_PROP_RANGE_MIN_MAX:
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt) {
if (i == 0)
fprintf(stderr,"%-*sMin: ", prefix + 2, "");
else if (i == 1)
fprintf(stderr,"%-*sMax: ", prefix + 2, "");
else
break;
print_pod_value(b->value.size, b->value.type, alt, 0);
i++;
}
break;
case SPA_POD_PROP_RANGE_STEP:
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt) {
if (i == 0)
fprintf(stderr,"%-*sMin: ", prefix + 2, "");
else if (i == 1)
fprintf(stderr,"%-*sMax: ", prefix + 2, "");
else if (i == 2)
fprintf(stderr,"%-*sStep: ", prefix + 2, "");
else
break;
print_pod_value(b->value.size, b->value.type, alt, 0);
i++;
}
break;
case SPA_POD_PROP_RANGE_ENUM:
SPA_POD_PROP_ALTERNATIVE_FOREACH(b, size, alt) {
if (i == 0)
fprintf(stderr,"%-*sEnum:\n", prefix + 2, "");
print_pod_value(b->value.size, b->value.type, alt, prefix + 4);
i++;
}
break;
case SPA_POD_PROP_RANGE_FLAGS:
break;
}
break;
}
case SPA_POD_TYPE_BYTES:
fprintf(stderr,"%-*sBytes\n", prefix, "");
spa_debug_dump_mem(body, size);
break;
case SPA_POD_TYPE_NONE:
fprintf(stderr,"%-*sNone\n", prefix, "");
spa_debug_dump_mem(body, size);
break;
default:
fprintf(stderr,"unhandled POD type %d\n", type);
break;
}
}
static void
print_format_value(uint32_t size, uint32_t type, void *body)
{
switch (type) {
case SPA_POD_TYPE_BOOL:
fprintf(stderr, "%s", *(int32_t *) body ? "true" : "false");
break;
case SPA_POD_TYPE_ID:
{
const char *str = map ? spa_type_map_get_type(map, *(int32_t *) body) : NULL;
if (str) {
const char *h = rindex(str, ':');
if (h)
str = h + 1;
} else {
str = "unknown";
}
fprintf(stderr, "%s", str);
break;
}
case SPA_POD_TYPE_INT:
fprintf(stderr, "%" PRIi32, *(int32_t *) body);
break;
case SPA_POD_TYPE_LONG:
fprintf(stderr, "%" PRIi64, *(int64_t *) body);
break;
case SPA_POD_TYPE_FLOAT:
fprintf(stderr, "%f", *(float *) body);
break;
case SPA_POD_TYPE_DOUBLE:
fprintf(stderr, "%g", *(double *) body);
break;
case SPA_POD_TYPE_STRING:
fprintf(stderr, "%s", (char *) body);
break;
case SPA_POD_TYPE_RECTANGLE:
{
struct spa_rectangle *r = body;
fprintf(stderr, "%" PRIu32 "x%" PRIu32, r->width, r->height);
break;
}
case SPA_POD_TYPE_FRACTION:
{
struct spa_fraction *f = body;
fprintf(stderr, "%" PRIu32 "/%" PRIu32, f->num, f->denom);
break;
}
case SPA_POD_TYPE_BITMAP:
fprintf(stderr, "Bitmap");
break;
case SPA_POD_TYPE_BYTES:
fprintf(stderr, "Bytes");
break;
default:
break;
}
}
static int spa_debug_format(const struct spa_pod *format)
{
int i;
const char *media_type;
const char *media_subtype;
struct spa_pod *pod;
uint32_t mtype, mstype;
if (format == NULL || SPA_POD_TYPE(format) != SPA_POD_TYPE_OBJECT)
return -EINVAL;
if (spa_pod_object_parse(format, "I", &mtype,
"I", &mstype) < 0)
return -EINVAL;
media_type = spa_type_map_get_type(map, mtype);
media_subtype = spa_type_map_get_type(map, mstype);
fprintf(stderr, "%-6s %s/%s\n", "", rindex(media_type, ':') + 1,
rindex(media_subtype, ':') + 1);
SPA_POD_OBJECT_FOREACH((struct spa_pod_object*)format, pod) {
struct spa_pod_prop *prop;
const char *key;
if (pod->type != SPA_POD_TYPE_PROP)
continue;
prop = (struct spa_pod_prop *)pod;
if ((prop->body.flags & SPA_POD_PROP_FLAG_UNSET) &&
(prop->body.flags & SPA_POD_PROP_FLAG_OPTIONAL))
continue;
key = spa_type_map_get_type(map, prop->body.key);
fprintf(stderr, " %20s : (%s) ", rindex(key, ':') + 1,
pod_type_names[prop->body.value.type]);
if (!(prop->body.flags & SPA_POD_PROP_FLAG_UNSET)) {
print_format_value(prop->body.value.size,
prop->body.value.type, SPA_POD_BODY(&prop->body.value));
} else {
const char *ssep, *esep, *sep;
void *alt;
switch (prop->body.flags & SPA_POD_PROP_RANGE_MASK) {
case SPA_POD_PROP_RANGE_MIN_MAX:
case SPA_POD_PROP_RANGE_STEP:
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
case SPA_POD_PROP_RANGE_ENUM:
case SPA_POD_PROP_RANGE_FLAGS:
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
fprintf(stderr, "%s", ssep);
i = 0;
SPA_POD_PROP_ALTERNATIVE_FOREACH(&prop->body, prop->pod.size, alt) {
if (i > 0)
fprintf(stderr, "%s", sep);
print_format_value(prop->body.value.size,
prop->body.value.type, alt);
i++;
}
fprintf(stderr, "%s", esep);
}
fprintf(stderr, "\n");
}
return 0;
}
int spa_debug_pod(const struct spa_pod *pod, uint32_t flags)
{
int res = 0;
if (flags & SPA_DEBUG_FLAG_FORMAT)
res = spa_debug_format(pod);
else
print_pod_value(pod->size, pod->type, SPA_POD_BODY(pod), 0);
return res;
}
int spa_debug_dict(const struct spa_dict *dict)
{
unsigned int i;
if (dict == NULL)
return -EINVAL;
for (i = 0; i < dict->n_items; i++)
fprintf(stderr, " %s = \"%s\"\n", dict->items[i].key,
dict->items[i].value);
return 0;
}

18
spa/lib/meson.build
View file

@ -1,18 +0,0 @@
spalib_headers = [
'debug.h',
]
install_headers(spalib_headers, subdir : 'spa/lib')
spalib_sources = ['debug.c' ]
spalib = shared_library('spa-lib-@0@'.format(spaversion),
spalib_sources,
version : libversion,
soversion : soversion,
include_directories : [ spa_inc, spa_libinc ],
install : true)
spalib_dep = declare_dependency(link_with : spalib,
include_directories : spa_inc,
)

491
spa/lib/pod.c
View file

@ -1,491 +0,0 @@
/* Simple Plugin API
* Copyright (C) 2016 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.
*/
#include <errno.h>
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <spa/param/props.h>
#include <spa/pod/iter.h>
#include <spa/pod/builder.h>
static int compare_value(enum spa_pod_type type, const void *r1, const void *r2)
{
switch (type) {
case SPA_POD_TYPE_INVALID:
return 0;
case SPA_POD_TYPE_BOOL:
case SPA_POD_TYPE_ID:
return *(int32_t *) r1 == *(uint32_t *) r2 ? 0 : 1;
case SPA_POD_TYPE_INT:
return *(int32_t *) r1 - *(int32_t *) r2;
case SPA_POD_TYPE_LONG:
return *(int64_t *) r1 - *(int64_t *) r2;
case SPA_POD_TYPE_FLOAT:
return *(float *) r1 - *(float *) r2;
case SPA_POD_TYPE_DOUBLE:
return *(double *) r1 - *(double *) r2;
case SPA_POD_TYPE_STRING:
return strcmp(r1, r2);
case SPA_POD_TYPE_RECTANGLE:
{
const struct spa_rectangle *rec1 = (struct spa_rectangle *) r1,
*rec2 = (struct spa_rectangle *) r2;
if (rec1->width == rec2->width && rec1->height == rec2->height)
return 0;
else if (rec1->width < rec2->width || rec1->height < rec2->height)
return -1;
else
return 1;
}
case SPA_POD_TYPE_FRACTION:
{
const struct spa_fraction *f1 = (struct spa_fraction *) r1,
*f2 = (struct spa_fraction *) r2;
int64_t n1, n2;
n1 = ((int64_t) f1->num) * f2->denom;
n2 = ((int64_t) f2->num) * f1->denom;
if (n1 < n2)
return -1;
else if (n1 > n2)
return 1;
else
return 0;
}
default:
break;
}
return 0;
}
static void fix_default(struct spa_pod_prop *prop)
{
void *val = SPA_MEMBER(prop, sizeof(struct spa_pod_prop), void),
*alt = SPA_MEMBER(val, prop->body.value.size, void);
int i, nalt = SPA_POD_PROP_N_VALUES(prop) - 1;
switch (prop->body.flags & SPA_POD_PROP_RANGE_MASK) {
case SPA_POD_PROP_RANGE_NONE:
break;
case SPA_POD_PROP_RANGE_MIN_MAX:
case SPA_POD_PROP_RANGE_STEP:
if (compare_value(prop->body.value.type, val, alt) < 0)
memcpy(val, alt, prop->body.value.size);
alt = SPA_MEMBER(alt, prop->body.value.size, void);
if (compare_value(prop->body.value.type, val, alt) > 0)
memcpy(val, alt, prop->body.value.size);
break;
case SPA_POD_PROP_RANGE_ENUM:
{
void *best = NULL;
for (i = 0; i < nalt; i++) {
if (compare_value(prop->body.value.type, val, alt) == 0) {
best = alt;
break;
}
if (best == NULL)
best = alt;
alt = SPA_MEMBER(alt, prop->body.value.size, void);
}
if (best)
memcpy(val, best, prop->body.value.size);
if (nalt <= 1) {
prop->body.flags &= ~SPA_POD_PROP_FLAG_UNSET;
prop->body.flags &= ~SPA_POD_PROP_RANGE_MASK;
prop->body.flags |= SPA_POD_PROP_RANGE_NONE;
}
break;
}
case SPA_POD_PROP_RANGE_FLAGS:
break;
}
}
static inline struct spa_pod_prop *find_prop(const struct spa_pod *pod, uint32_t size, uint32_t key)
{
const struct spa_pod *res;
SPA_POD_FOREACH(pod, size, res) {
if (res->type == SPA_POD_TYPE_PROP
&& ((struct spa_pod_prop *) res)->body.key == key)
return (struct spa_pod_prop *) res;
}
return NULL;
}
static inline int
filter_prop(struct spa_pod_builder *b,
const struct spa_pod_prop *p1,
const struct spa_pod_prop *p2)
{
struct spa_pod_prop *np;
int nalt1, nalt2;
void *alt1, *alt2, *a1, *a2;
uint32_t rt1, rt2;
int j, k;
/* incompatible property types */
if (p1->body.value.type != p2->body.value.type)
return -EINVAL;
rt1 = p1->body.flags & SPA_POD_PROP_RANGE_MASK;
rt2 = p2->body.flags & SPA_POD_PROP_RANGE_MASK;
alt1 = SPA_MEMBER(p1, sizeof(struct spa_pod_prop), void);
nalt1 = SPA_POD_PROP_N_VALUES(p1);
alt2 = SPA_MEMBER(p2, sizeof(struct spa_pod_prop), void);
nalt2 = SPA_POD_PROP_N_VALUES(p2);
if (p1->body.flags & SPA_POD_PROP_FLAG_UNSET) {
alt1 = SPA_MEMBER(alt1, p1->body.value.size, void);
nalt1--;
} else {
nalt1 = 1;
rt1 = SPA_POD_PROP_RANGE_NONE;
}
if (p2->body.flags & SPA_POD_PROP_FLAG_UNSET) {
alt2 = SPA_MEMBER(alt2, p2->body.value.size, void);
nalt2--;
} else {
nalt2 = 1;
rt2 = SPA_POD_PROP_RANGE_NONE;
}
/* start with copying the property */
np = spa_pod_builder_deref(b, spa_pod_builder_push_prop(b, p1->body.key, 0));
/* default value */
spa_pod_builder_raw(b, &p1->body.value, sizeof(p1->body.value) + p1->body.value.size);
if ((rt1 == SPA_POD_PROP_RANGE_NONE && rt2 == SPA_POD_PROP_RANGE_NONE) ||
(rt1 == SPA_POD_PROP_RANGE_NONE && rt2 == SPA_POD_PROP_RANGE_ENUM) ||
(rt1 == SPA_POD_PROP_RANGE_ENUM && rt2 == SPA_POD_PROP_RANGE_NONE) ||
(rt1 == SPA_POD_PROP_RANGE_ENUM && rt2 == SPA_POD_PROP_RANGE_ENUM)) {
int n_copied = 0;
/* copy all equal values but don't copy the default value again */
for (j = 0, a1 = alt1; j < nalt1; j++, a1 += p1->body.value.size) {
for (k = 0, a2 = alt2; k < nalt2; k++, a2 += p2->body.value.size) {
if (compare_value(p1->body.value.type, a1, a2) == 0) {
if (rt1 == SPA_POD_PROP_RANGE_ENUM || j > 0)
spa_pod_builder_raw(b, a1, p1->body.value.size);
n_copied++;
}
}
}
if (n_copied == 0)
return -EINVAL;
np->body.flags |= SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET;
}
if ((rt1 == SPA_POD_PROP_RANGE_NONE && rt2 == SPA_POD_PROP_RANGE_MIN_MAX) ||
(rt1 == SPA_POD_PROP_RANGE_ENUM && rt2 == SPA_POD_PROP_RANGE_MIN_MAX)) {
int n_copied = 0;
/* copy all values inside the range */
for (j = 0, a1 = alt1, a2 = alt2; j < nalt1; j++, a1 += p1->body.value.size) {
if (compare_value(p1->body.value.type, a1, a2) < 0)
continue;
if (compare_value(p1->body.value.type, a1, a2 + p2->body.value.size) > 0)
continue;
spa_pod_builder_raw(b, a1, p1->body.value.size);
n_copied++;
}
if (n_copied == 0)
return -EINVAL;
np->body.flags |= SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET;
}
if ((rt1 == SPA_POD_PROP_RANGE_NONE && rt2 == SPA_POD_PROP_RANGE_STEP) ||
(rt1 == SPA_POD_PROP_RANGE_ENUM && rt2 == SPA_POD_PROP_RANGE_STEP)) {
return -ENOTSUP;
}
if ((rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_NONE) ||
(rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_ENUM)) {
int n_copied = 0;
/* copy all values inside the range */
for (k = 0, a1 = alt1, a2 = alt2; k < nalt2; k++, a2 += p2->body.value.size) {
if (compare_value(p1->body.value.type, a2, a1) < 0)
continue;
if (compare_value(p1->body.value.type, a2, a1 + p1->body.value.size) > 0)
continue;
spa_pod_builder_raw(b, a2, p2->body.value.size);
n_copied++;
}
if (n_copied == 0)
return -EINVAL;
np->body.flags |= SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET;
}
if (rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_MIN_MAX) {
if (compare_value(p1->body.value.type, alt1, alt2) < 0)
spa_pod_builder_raw(b, alt2, p2->body.value.size);
else
spa_pod_builder_raw(b, alt1, p1->body.value.size);
alt1 += p1->body.value.size;
alt2 += p2->body.value.size;
if (compare_value(p1->body.value.type, alt1, alt2) < 0)
spa_pod_builder_raw(b, alt1, p1->body.value.size);
else
spa_pod_builder_raw(b, alt2, p2->body.value.size);
np->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
}
if (rt1 == SPA_POD_PROP_RANGE_NONE && rt2 == SPA_POD_PROP_RANGE_FLAGS)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_STEP)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_FLAGS)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_ENUM && rt2 == SPA_POD_PROP_RANGE_FLAGS)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_STEP && rt2 == SPA_POD_PROP_RANGE_NONE)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_STEP && rt2 == SPA_POD_PROP_RANGE_MIN_MAX)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_STEP && rt2 == SPA_POD_PROP_RANGE_STEP)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_STEP && rt2 == SPA_POD_PROP_RANGE_ENUM)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_STEP && rt2 == SPA_POD_PROP_RANGE_FLAGS)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_FLAGS && rt2 == SPA_POD_PROP_RANGE_NONE)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_FLAGS && rt2 == SPA_POD_PROP_RANGE_MIN_MAX)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_FLAGS && rt2 == SPA_POD_PROP_RANGE_STEP)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_FLAGS && rt2 == SPA_POD_PROP_RANGE_ENUM)
return -ENOTSUP;
if (rt1 == SPA_POD_PROP_RANGE_FLAGS && rt2 == SPA_POD_PROP_RANGE_FLAGS)
return -ENOTSUP;
spa_pod_builder_pop(b);
fix_default(np);
return 0;
}
int pod_filter(struct spa_pod_builder *b,
const struct spa_pod *pod, uint32_t pod_size,
const struct spa_pod *filter, uint32_t filter_size)
{
const struct spa_pod *pp, *pf;
int res = 0;
pf = filter;
SPA_POD_FOREACH(pod, pod_size, pp) {
bool do_copy = false, do_advance = false;
uint32_t filter_offset = 0;
switch (SPA_POD_TYPE(pp)) {
case SPA_POD_TYPE_STRUCT:
case SPA_POD_TYPE_OBJECT:
if (pf != NULL) {
if (SPA_POD_TYPE(pf) != SPA_POD_TYPE(pp))
return -EINVAL;
if (SPA_POD_TYPE(pp) == SPA_POD_TYPE_STRUCT) {
filter_offset = sizeof(struct spa_pod_struct);
spa_pod_builder_push_struct(b);
} else {
struct spa_pod_object *p1 = (struct spa_pod_object *) pp;
filter_offset = sizeof(struct spa_pod_object);
spa_pod_builder_push_object(b, p1->body.id, p1->body.type);
}
do_advance = true;
}
else
do_copy = true;
break;
case SPA_POD_TYPE_PROP:
{
struct spa_pod_prop *p1, *p2;
p1 = (struct spa_pod_prop *) pp;
p2 = find_prop(filter, filter_size, p1->body.key);
if (p2 != NULL)
res = filter_prop(b, p1, p2);
else
do_copy = true;
break;
}
default:
if (pf != NULL) {
if (SPA_POD_SIZE(pp) != SPA_POD_SIZE(pf))
return -EINVAL;
if (memcmp(pp, pf, SPA_POD_SIZE(pp)) != 0)
return -EINVAL;
do_advance = true;
}
do_copy = true;
break;
}
if (do_copy)
spa_pod_builder_raw_padded(b, pp, SPA_POD_SIZE(pp));
else if (filter_offset) {
res = pod_filter(b,
SPA_MEMBER(pp,filter_offset,void),
SPA_POD_SIZE(pp) - filter_offset,
SPA_MEMBER(pf,filter_offset,void),
SPA_POD_SIZE(pf) - filter_offset);
spa_pod_builder_pop(b);
}
if (do_advance) {
pf = spa_pod_next(pf);
if (!spa_pod_is_inside(filter, filter_size, pf))
pf = NULL;
}
if (res < 0)
break;
}
return res;
}
int
spa_pod_filter(struct spa_pod_builder *b,
struct spa_pod **result,
const struct spa_pod *pod,
const struct spa_pod *filter)
{
int res;
struct spa_pod_builder_state state;
spa_return_val_if_fail(pod != NULL, -EINVAL);
spa_return_val_if_fail(b != NULL, -EINVAL);
if (filter == NULL) {
*result = spa_pod_builder_deref(b,
spa_pod_builder_raw_padded(b, pod, SPA_POD_SIZE(pod)));
return 0;
}
spa_pod_builder_get_state(b, &state);
if ((res = pod_filter(b, pod, SPA_POD_SIZE(pod), filter, SPA_POD_SIZE(filter))) < 0)
spa_pod_builder_reset(b, &state);
else
*result = spa_pod_builder_deref(b, state.offset);
return res;
}
int pod_compare(const struct spa_pod *pod1, uint32_t pod1_size,
const struct spa_pod *pod2, uint32_t pod2_size)
{
const struct spa_pod *p1, *p2;
int res;
p2 = pod2;
SPA_POD_FOREACH(pod1, pod1_size, p1) {
bool do_advance = true;
uint32_t recurse_offset = 0;
if (p2 == NULL)
return -EINVAL;
switch (SPA_POD_TYPE(p1)) {
case SPA_POD_TYPE_STRUCT:
case SPA_POD_TYPE_OBJECT:
if (SPA_POD_TYPE(p2) != SPA_POD_TYPE(p1))
return -EINVAL;
if (SPA_POD_TYPE(p1) == SPA_POD_TYPE_STRUCT)
recurse_offset = sizeof(struct spa_pod_struct);
else
recurse_offset = sizeof(struct spa_pod_object);
do_advance = true;
break;
case SPA_POD_TYPE_PROP:
{
struct spa_pod_prop *pr1, *pr2;
void *a1, *a2;
pr1 = (struct spa_pod_prop *) p1;
pr2 = find_prop(pod2, pod2_size, pr1->body.key);
if (pr2 == NULL)
return -EINVAL;
/* incompatible property types */
if (pr1->body.value.type != pr2->body.value.type)
return -EINVAL;
if (pr1->body.flags & SPA_POD_PROP_FLAG_UNSET ||
pr2->body.flags & SPA_POD_PROP_FLAG_UNSET)
return -EINVAL;
a1 = SPA_MEMBER(pr1, sizeof(struct spa_pod_prop), void);
a2 = SPA_MEMBER(pr2, sizeof(struct spa_pod_prop), void);
res = compare_value(pr1->body.value.type, a1, a2);
break;
}
default:
if (SPA_POD_TYPE(p1) != SPA_POD_TYPE(p2))
return -EINVAL;
res = compare_value(SPA_POD_TYPE(p1), SPA_POD_BODY(p1), SPA_POD_BODY(p2));
do_advance = true;
break;
}
if (recurse_offset) {
res = pod_compare(SPA_MEMBER(p1,recurse_offset,void),
SPA_POD_SIZE(p1) - recurse_offset,
SPA_MEMBER(p2,recurse_offset,void),
SPA_POD_SIZE(p2) - recurse_offset);
}
if (do_advance) {
p2 = spa_pod_next(p2);
if (!spa_pod_is_inside(pod2, pod2_size, p2))
p2 = NULL;
}
if (res != 0)
return res;
}
if (p2 != NULL)
return -EINVAL;
return 0;
}
int spa_pod_compare(const struct spa_pod *pod1,
const struct spa_pod *pod2)
{
spa_return_val_if_fail(pod1 != NULL, -EINVAL);
spa_return_val_if_fail(pod2 != NULL, -EINVAL);
return pod_compare(pod1, SPA_POD_SIZE(pod1), pod2, SPA_POD_SIZE(pod2));
}

2
spa/meson.build
View file

@ -20,10 +20,8 @@ speexdsp_dep = dependency('speexdsp')
#mathlib = cc.find_library('m', required : false)
spa_inc = include_directories('include')
spa_libinc = include_directories('.')
subdir('include')
subdir('lib')
subdir('plugins')
subdir('tools')
subdir('tests')

2
spa/plugins/alsa/meson.build
View file

@ -6,7 +6,7 @@ spa_alsa_sources = ['alsa.c',
spa_alsa = shared_library('spa-alsa',
spa_alsa_sources,
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
dependencies : [ alsa_dep, libudev_dep ],
install : true,
install_dir : '@0@/spa/alsa'.format(get_option('libdir')))

20
spa/plugins/audioconvert/audioconvert.c
View file

@ -32,8 +32,7 @@
#include <spa/param/meta.h>
#include <spa/param/io.h>
#include <spa/pod/filter.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
#define NAME "audioconvert"
@ -204,18 +203,13 @@ static void clean_link(struct impl *this, struct link *link)
static int debug_params(struct impl *this, struct spa_node *node,
enum spa_direction direction, uint32_t port_id, uint32_t id, struct spa_pod *filter)
{
struct type *t = &this->type;
struct spa_pod_builder b = { 0 };
uint8_t buffer[4096];
uint32_t state, flag;
struct spa_pod *format;
uint32_t state;
struct spa_pod *param;
int res;
flag = 0;
if (id == t->param.idEnumFormat)
flag |= SPA_DEBUG_FLAG_FORMAT;
spa_log_error(this->log, "formats:");
spa_log_error(this->log, "params:");
state = 0;
while (true) {
@ -223,16 +217,16 @@ static int debug_params(struct impl *this, struct spa_node *node,
res = spa_node_port_enum_params(node,
direction, port_id,
id, &state,
NULL, &format, &b);
NULL, &param, &b);
if (res <= 0)
break;
spa_debug_pod(format, flag);
spa_debug_pod(2, this->map, param);
}
spa_log_error(this->log, "failed filter:");
if (filter)
spa_debug_pod(filter, flag);
spa_debug_pod(2, this->map, filter);
return 0;
}

2
spa/plugins/audioconvert/merger.c
View file

@ -33,8 +33,6 @@
#include <spa/param/io.h>
#include <spa/pod/filter.h>
#include <lib/debug.h>
#define NAME "merger"
#define DEFAULT_RATE 48000

3
spa/plugins/audioconvert/meson.build
View file

@ -8,8 +8,7 @@ audioconvert_sources = ['fmtconvert.c',
audioconvertlib = shared_library('spa-audioconvert',
audioconvert_sources,
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
dependencies : speexdsp_dep,
link_with : spalib,
install : true,
install_dir : '@0@/spa/audioconvert/'.format(get_option('libdir')))

2
spa/plugins/audioconvert/splitter.c
View file

@ -32,8 +32,6 @@
#include <spa/param/io.h>
#include <spa/pod/filter.h>
#include <lib/debug.h>
#define NAME "splitter"
#define MAX_BUFFERS 64

2
spa/plugins/audiomixer/meson.build
View file

@ -2,6 +2,6 @@ audiomixer_sources = ['audiomixer.c', 'mix-ops.c', 'plugin.c']
audiomixerlib = shared_library('spa-audiomixer',
audiomixer_sources,
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
install : true,
install_dir : '@0@/spa/audiomixer/'.format(get_option('libdir')))

2
spa/plugins/audiotestsrc/meson.build
View file

@ -2,7 +2,7 @@ audiotestsrc_sources = ['audiotestsrc.c', 'plugin.c']
audiotestsrclib = shared_library('spa-audiotestsrc',
audiotestsrc_sources,
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
dependencies : mathlib,
install : true,
install_dir : '@0@/spa/audiotestsrc'.format(get_option('libdir')))

2
spa/plugins/bluez5/meson.build
View file

@ -5,7 +5,7 @@ bluez5_sources = ['plugin.c',
bluez5lib = shared_library('spa-bluez5',
bluez5_sources,
include_directories : [ spa_inc, spa_libinc ],
include_directories : [ spa_inc ],
dependencies : [ dbus_dep, sbc_dep ],
install : true,
install_dir : '@0@/spa/bluez5'.format(get_option('libdir')))

2
spa/plugins/ffmpeg/meson.build
View file

@ -4,7 +4,7 @@ ffmpeg_sources = ['ffmpeg.c',
ffmpeglib = shared_library('spa-ffmpeg',
ffmpeg_sources,
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
dependencies : [ avcodec_dep, avformat_dep ],
install : true,
install_dir : '@0@/spa/ffmpeg'.format(get_option('libdir')))

4
spa/plugins/support/meson.build
View file

@ -5,7 +5,7 @@ spa_support_sources = ['mapper.c',
spa_support_lib = shared_library('spa-support',
spa_support_sources,
include_directories : [ spa_inc, spa_libinc],
include_directories : [ spa_inc],
dependencies : threads_dep,
install : true,
install_dir : '@0@/spa/support'.format(get_option('libdir')))
@ -14,7 +14,7 @@ spa_dbus_sources = ['dbus.c']
spa_dbus_lib = shared_library('spa-dbus',
spa_dbus_sources,
include_directories : [ spa_inc, spa_libinc],
include_directories : [ spa_inc],
dependencies : dbus_dep,
install : true,
install_dir : '@0@/spa/support'.format(get_option('libdir')))

2
spa/plugins/test/meson.build
View file

@ -2,7 +2,7 @@ test_sources = ['fakesrc.c', 'fakesink.c', 'plugin.c']
testlib = shared_library('spa-test',
test_sources,
include_directories : [ spa_inc, spa_libinc],
include_directories : [ spa_inc],
dependencies : threads_dep,
install : true,
install_dir : '@0@/spa/test'.format(get_option('libdir')))

2
spa/plugins/v4l2/meson.build
View file

@ -4,7 +4,7 @@ v4l2_sources = ['v4l2.c',
v4l2lib = shared_library('spa-v4l2',
v4l2_sources,
include_directories : [ spa_inc, spa_libinc ],
include_directories : [ spa_inc ],
dependencies : [ v4l2_dep, libudev_dep ],
install : true,
install_dir : '@0@/spa/v4l2'.format(get_option('libdir')))

2
spa/plugins/videotestsrc/meson.build
View file

@ -2,7 +2,7 @@ videotestsrc_sources = ['videotestsrc.c', 'plugin.c']
videotestsrclib = shared_library('spa-videotestsrc',
videotestsrc_sources,
include_directories : [ spa_inc, spa_libinc],
include_directories : [ spa_inc],
dependencies : threads_dep,
install : true,
install_dir : '@0@/spa/videotestsrc'.format(get_option('libdir')))

2
spa/plugins/volume/meson.build
View file

@ -2,6 +2,6 @@ volume_sources = ['volume.c', 'plugin.c']
volumelib = shared_library('spa-volume',
volume_sources,
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
install : true,
install_dir : '@0@/spa/volume'.format(get_option('libdir')))

41
spa/tests/meson.build
View file

@ -1,77 +1,62 @@
executable('test-mixer', 'test-mixer.c',
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib, mathlib],
link_with : spalib,
install : false)
executable('test-convert', 'test-convert.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib, mathlib],
link_with : spalib,
install : false)
executable('test-convert2', 'test-convert2.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib, mathlib],
link_with : spalib,
install : false)
executable('test-bluez5', 'test-bluez5.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib, mathlib, dbus_dep],
link_with : spalib,
install : false)
executable('test-ringbuffer', 'test-ringbuffer.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('test-graph', 'test-graph.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('test-graph2', 'test-graph2.c',
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('test-perf', 'test-perf.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('stress-ringbuffer', 'stress-ringbuffer.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
if sdl_dep.found()
executable('test-v4l2', 'test-v4l2.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, sdl_dep, pthread_lib],
link_with : spalib,
install : false)
endif
executable('test-props', 'test-props.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [],
link_with : spalib,
install : false)
executable('test-props2', 'test-props2.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [],
link_with : spalib,
install : false)
#executable('test-props4', 'test-props4.c',
# include_directories : [spa_inc, spa_libinc ],
# include_directories : [spa_inc ],
# dependencies : [],
# link_with : spalib,
# install : false)
executable('test-props5', 'test-props5.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [],
link_with : spalib,
install : false)
executable('test-control', 'test-control.c',
include_directories : [spa_inc, spa_libinc ],
include_directories : [spa_inc ],
dependencies : [dl_lib, pthread_lib, mathlib],
link_with : spalib,
install : false)

5
spa/tests/test-bluez5.c
View file

@ -50,7 +50,7 @@ static struct spa_log *logger;
#include <spa/graph/graph.h>
#include <spa/graph/graph-scheduler2.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
struct type {
uint32_t log;
@ -134,7 +134,7 @@ struct data {
static void inspect_item(struct data *data, struct spa_pod *item)
{
spa_debug_pod(item, 0);
spa_debug_pod(0, data->map, item);
}
static void monitor_event(void *_data, struct spa_event *event)
@ -223,7 +223,6 @@ int main(int argc, char *argv[])
data.support[0].data = data.map;
data.n_support = 1;
init_type(&data.type, data.map);
spa_debug_set_type_map(data.map);
if ((res = get_handle(&data, &handle,
"build/spa/plugins/support/libspa-support.so",

10
spa/tests/test-control.c
View file

@ -49,7 +49,7 @@ static SPA_LOG_IMPL(default_log);
#include <spa/graph/graph.h>
#include <spa/graph/graph-scheduler2.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
struct type {
uint32_t node;
@ -329,7 +329,7 @@ static int make_nodes(struct data *data, const char *device)
":", data->type.props_device, "s", device ? device : "hw:0",
":", data->type.props_min_latency, "i", MIN_LATENCY);
spa_debug_pod(props, 0);
spa_debug_pod(0, data->map, props);
if ((res = spa_node_set_param(data->sink, data->type.param.idProps, 0, props)) < 0)
printf("got set_props error %d\n", res);
@ -434,7 +434,7 @@ static int negotiate_formats(struct data *data)
":", data->type.format_audio.rate, "i", 44100,
":", data->type.format_audio.channels, "i", 2);
spa_debug_pod(filter, 0);
spa_debug_pod(0, data->map, filter);
spa_log_debug(&default_log.log, "enum_params");
if ((res = spa_node_port_enum_params(data->sink,
@ -443,7 +443,7 @@ static int negotiate_formats(struct data *data)
filter, &format, &b)) <= 0)
return -EBADF;
spa_debug_pod(format, 0);
spa_debug_pod(0, data->map, format);
spa_log_debug(&default_log.log, "sink set_param");
if ((res = spa_node_port_set_param(data->sink,
@ -577,8 +577,6 @@ int main(int argc, char *argv[])
data.data_loop.remove_source = do_remove_source;
data.data_loop.invoke = do_invoke;
spa_debug_set_type_map(data.map);
if ((str = getenv("SPA_DEBUG")))
data.log->level = atoi(str);

15
spa/tests/test-convert.c
View file

@ -35,8 +35,8 @@
#include <spa/param/props.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/format-utils.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
#include <spa/debug/mem.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);
@ -318,7 +318,7 @@ static int negotiate_buffers(struct data *data)
NULL, &param, &b)) <= 0)
return -EBADF;
spa_debug_pod(param, 0);
spa_debug_pod(0, data->map, param);
init_buffer(data, data->in_buffers, data->in_buffer, 1, BUFFER_SIZE, 1);
if ((res =
@ -335,7 +335,7 @@ static int negotiate_buffers(struct data *data)
NULL, &param, &b)) <= 0)
return -EBADF;
spa_debug_pod(param, 0);
spa_debug_pod(0, data->map, param);
init_buffer(data, data->out_buffers, data->out_buffer, 1, BUFFER_SIZE, 2);
if ((res =
@ -374,13 +374,13 @@ static void run_convert(struct data *data)
data->io_out[0].status = SPA_STATUS_NEED_BUFFER;
data->io_out[0].buffer_id = 0;
spa_debug_dump_mem(data->in_buffers[0]->datas[0].data, BUFFER_SIZE);
spa_debug_mem(0, data->in_buffers[0]->datas[0].data, BUFFER_SIZE);
res = spa_node_process(data->conv);
printf("called process %d\n", res);
spa_debug_dump_mem(data->out_buffers[0]->datas[0].data, BUFFER_SIZE);
spa_debug_dump_mem(data->out_buffers[0]->datas[1].data, BUFFER_SIZE);
spa_debug_mem(0, data->out_buffers[0]->datas[0].data, BUFFER_SIZE);
spa_debug_mem(0, data->out_buffers[0]->datas[1].data, BUFFER_SIZE);
{
struct spa_command cmd = SPA_COMMAND_INIT(data->type.command_node.Pause);
@ -408,7 +408,6 @@ int main(int argc, char *argv[])
data.n_support = 2;
init_type(&data.type, data.map);
spa_debug_set_type_map(data.map);
if ((res = make_nodes(&data, argc > 1 ? argv[1] : NULL)) < 0) {
printf("can't make nodes: %d\n", res);

14
spa/tests/test-convert2.c
View file

@ -37,8 +37,9 @@
#include <spa/param/props.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/format-utils.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
#include <spa/debug/format.h>
#include <spa/debug/mem.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);
@ -273,7 +274,7 @@ static int negotiate_link_format(struct data *data, struct link *link, struct sp
}
spa_pod_fixate(filter);
spa_debug_pod(filter, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(0, data->map, filter);
if (link->out_node != NULL) {
if ((res = spa_node_port_set_param(link->out_node->node,
@ -369,7 +370,7 @@ static int negotiate_link_buffers(struct data *data, struct link *link)
}
spa_pod_fixate(param);
spa_debug_pod(param, 0);
spa_debug_pod(0, data->map, param);
if (link->in_info)
in_alloc = SPA_FLAG_CHECK(link->in_info->flags, SPA_PORT_INFO_FLAG_CAN_ALLOC_BUFFERS);
@ -497,7 +498,7 @@ static void run_convert(struct data *data)
b = data->links[0].buffers[0];
for (i = 0; i < b->n_datas; i++)
spa_debug_dump_mem(b->datas[i].data, b->datas[i].maxsize);
spa_debug_mem(0, b->datas[i].data, b->datas[i].maxsize);
for (j = 0; j < 2; j++) {
data->links[0].io.status = SPA_STATUS_HAVE_BUFFER;
@ -510,7 +511,7 @@ static void run_convert(struct data *data)
b = data->links[3].buffers[0];
for (i = 0; i < b->n_datas; i++)
spa_debug_dump_mem(b->datas[i].data, b->datas[i].maxsize);
spa_debug_mem(0, b->datas[i].data, b->datas[i].maxsize);
{
struct spa_command cmd = SPA_COMMAND_INIT(t->command_node.Pause);
@ -540,7 +541,6 @@ int main(int argc, char *argv[])
data.n_support = 2;
init_type(&data.type, data.map);
spa_debug_set_type_map(data.map);
if ((res = make_nodes(&data, argc > 1 ? argv[1] : NULL)) < 0) {
printf("can't make nodes: %d\n", res);

10
spa/tests/test-graph.c
View file

@ -44,7 +44,7 @@ static SPA_LOG_IMPL(default_log);
#include <spa/graph/graph.h>
#include <spa/graph/graph-scheduler2.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
struct type {
uint32_t node;
@ -308,7 +308,7 @@ static int make_nodes(struct data *data, const char *device)
":", data->type.props_device, "s", device ? device : "hw:0",
":", data->type.props_min_latency, "i", MIN_LATENCY);
spa_debug_pod(props, 0);
spa_debug_pod(0, data->map, props);
if ((res = spa_node_set_param(data->sink, data->type.param.idProps, 0, props)) < 0)
printf("got set_props error %d\n", res);
@ -402,7 +402,7 @@ static int negotiate_formats(struct data *data)
":", data->type.format_audio.rate, "i", 44100,
":", data->type.format_audio.channels, "i", 2);
spa_debug_pod(filter, 0);
spa_debug_pod(0, data->map, filter);
spa_log_debug(&default_log.log, "enum_params");
if ((res = spa_node_port_enum_params(data->sink,
@ -411,7 +411,7 @@ static int negotiate_formats(struct data *data)
filter, &format, &b)) <= 0)
return -EBADF;
spa_debug_pod(format, 0);
spa_debug_pod(0, data->map, format);
spa_log_debug(&default_log.log, "sink set_param");
if ((res = spa_node_port_set_param(data->sink,
@ -569,8 +569,6 @@ int main(int argc, char *argv[])
data.data_loop.remove_source = do_remove_source;
data.data_loop.invoke = do_invoke;
spa_debug_set_type_map(data.map);
if ((str = getenv("SPA_DEBUG")))
data.log->level = atoi(str);

19
spa/tests/test-props.c
View file

@ -29,8 +29,8 @@
#include <spa/pod/builder.h>
#include <spa/pod/parser.h>
#include <spa/param/video/format-utils.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
#include <spa/debug/format.h>
#if 0
/* { video/raw,
@ -250,8 +250,8 @@ static void do_static_struct(struct spa_type_map *map)
}
};
spa_debug_pod(&test_format.fmt.pod, 0);
spa_debug_pod(&test_format.fmt.pod, SPA_DEBUG_FLAG_FORMAT);
spa_debug_pod(0, map, &test_format.fmt.pod);
spa_debug_format(0, map, &test_format.fmt.pod);
{
uint32_t format = -1;
@ -283,7 +283,6 @@ int main(int argc, char *argv[])
struct spa_type_map *map = &default_map.map;
type_init(map);
spa_debug_set_type_map(map);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
@ -317,7 +316,7 @@ int main(int argc, char *argv[])
fmt = spa_pod_builder_pop(&b);
spa_debug_pod(&fmt->pod, 0);
spa_debug_pod(0, map, &fmt->pod);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
@ -335,8 +334,8 @@ int main(int argc, char *argv[])
2, &SPA_FRACTION(0,1),
&SPA_FRACTION(INT32_MAX,1));
spa_debug_pod(&fmt->pod, 0);
spa_debug_pod(&fmt->pod, SPA_DEBUG_FLAG_FORMAT);
spa_debug_pod(0, map, &fmt->pod);
spa_debug_format(0, map, &fmt->pod);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
@ -365,8 +364,8 @@ int main(int argc, char *argv[])
&SPA_FRACTION(INT32_MAX,1),
">", NULL);
spa_debug_pod(&fmt->pod, 0);
spa_debug_pod(&fmt->pod, SPA_DEBUG_FLAG_FORMAT);
spa_debug_pod(0, map, &fmt->pod);
spa_debug_format(0, map, &fmt->pod);
do_static_struct(map);

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

@ -30,7 +30,7 @@
#include <spa/pod/parser.h>
#include <spa/param/video/format.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
@ -43,8 +43,6 @@ int main(int argc, char *argv[])
struct spa_pod_parser prs;
struct spa_type_map *map = &default_map.map;
spa_debug_set_type_map(map);
b.data = buffer;
b.size = 1024;
@ -86,11 +84,11 @@ int main(int argc, char *argv[])
spa_pod_builder_pop(&b);
obj = spa_pod_builder_pop(&b);
spa_debug_pod(obj, 0);
spa_debug_pod(0, map, obj);
struct spa_pod_prop *p = spa_pod_find_prop(obj, 4);
printf("%d %d\n", p->body.key, p->body.flags);
spa_debug_pod(&p->body.value, 0);
spa_debug_pod(0, map, &p->body.value);
obj = spa_pod_builder_deref(&b, ref);

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

@ -26,8 +26,6 @@
#include <spa/support/log.h>
#include <spa/pod/iter.h>
#include <lib/debug.h>
#if 0
/*
( "Format",

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

@ -24,8 +24,9 @@
#include <errno.h>
#include <spa/pod/parser.h>
#include <spa/pod/builder.h>
#include <lib/debug.h>
#include <spa/debug/pod.h>
int main(int argc, char *argv[])
{
@ -52,7 +53,7 @@ int main(int argc, char *argv[])
2, &SPA_FRACTION(0,1),
&SPA_FRACTION(INT32_MAX, 1),
">", NULL);
spa_debug_pod(fmt, 0);
spa_debug_pod(0, NULL, fmt);
spa_pod_parser_pod(&prs, fmt);
res = spa_pod_parser_get(&prs,
@ -67,7 +68,7 @@ int main(int argc, char *argv[])
printf("media-type:%d media-subtype:%d\n", media_type, media_subtype);
printf("framerate:\n");
if (pod)
spa_debug_pod(pod, 0);
spa_debug_pod(0, NULL, pod);
printf("format: %d\n", fmt_value);
spa_pod_builder_init(&b, buffer, sizeof(buffer));
@ -76,7 +77,7 @@ int main(int argc, char *argv[])
" P", NULL,
" [ i", 44, "i",45,"]"
">", NULL);
spa_debug_pod(pod, 0);
spa_debug_pod(0, NULL, pod);
spa_pod_parser_pod(&prs, pod);
res = spa_pod_parser_get(&prs,

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

@ -36,8 +36,6 @@
#include <spa/param/audio/format-utils.h>
#include <spa/param/format-utils.h>
#include <lib/debug.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);

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

@ -39,8 +39,6 @@
#include <spa/param/video/format-utils.h>
#include <spa/param/format-utils.h>
#include <lib/debug.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);

6
spa/tools/meson.build
View file

@ -1,11 +1,9 @@
executable('spa-inspect', 'spa-inspect.c',
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
dependencies : [dl_lib],
link_with : spalib,
install : true)
executable('spa-monitor', 'spa-monitor.c',
include_directories : [spa_inc, spa_libinc],
include_directories : [spa_inc],
dependencies : [dl_lib],
link_with : spalib,
install : true)

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

@ -31,8 +31,8 @@
#include <spa/pod/parser.h>
#include <spa/param/param.h>
#include <spa/param/format.h>
#include <lib/debug.h>
#include <spa/debug/dict.h>
#include <spa/debug/format.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);
@ -80,8 +80,6 @@ inspect_node_params(struct data *data, struct spa_node *node)
printf("enumerating: %s:\n", spa_type_map_get_type(data->map, id));
for (idx2 = 0;;) {
uint32_t flags = 0;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if ((res = spa_node_enum_params(node,
id, &idx2,
@ -90,7 +88,7 @@ inspect_node_params(struct data *data, struct spa_node *node)
error(0, -res, "enum_params %d", id);
break;
}
spa_debug_pod(param, flags);
spa_debug_pod(0, data->map, param);
}
}
}
@ -123,8 +121,6 @@ inspect_port_params(struct data *data, struct spa_node *node,
printf("enumerating: %s:\n", spa_type_map_get_type(data->map, id));
for (idx2 = 0;;) {
uint32_t flags = 0;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
if ((res = spa_node_port_enum_params(node,
direction, port_id,
@ -136,8 +132,9 @@ inspect_port_params(struct data *data, struct spa_node *node,
}
if (spa_pod_is_object_type(param, data->type.format))
flags |= SPA_DEBUG_FLAG_FORMAT;
spa_debug_pod(param, flags);
spa_debug_format(0, data->map, param);
else
spa_debug_pod(0, data->map, param);
}
}
}
@ -150,7 +147,7 @@ static void inspect_node(struct data *data, struct spa_node *node)
printf("node info:\n");
if (node->info)
spa_debug_dict(node->info);
spa_debug_dict(2, node->info);
else
printf(" none\n");
@ -193,7 +190,7 @@ static void inspect_factory(struct data *data, const struct spa_handle_factory *
printf("factory name:\t\t'%s'\n", factory->name);
printf("factory info:\n");
if (factory->info)
spa_debug_dict(factory->info);
spa_debug_dict(2, factory->info);
else
printf(" none\n");
@ -283,8 +280,6 @@ int main(int argc, char *argv[])
if ((str = getenv("SPA_DEBUG")))
data.log->level = atoi(str);
spa_debug_set_type_map(data.map);
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].type = SPA_TYPE__Log;

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

@ -28,9 +28,11 @@
#include <spa/support/log-impl.h>
#include <spa/support/type-map-impl.h>
#include <spa/support/loop.h>
#include <spa/support/plugin.h>
#include <spa/monitor/monitor.h>
#include <lib/debug.h>
#include <spa/debug/dict.h>
#include <spa/debug/pod.h>
static SPA_TYPE_MAP_IMPL(default_map, 4096);
static SPA_LOG_IMPL(default_log);
@ -60,7 +62,7 @@ struct data {
static void inspect_item(struct data *data, struct spa_pod *item)
{
spa_debug_pod(item, 0);
spa_debug_pod(0, data->map, item);
}
static void on_monitor_event(void *_data, struct spa_event *event)
@ -110,7 +112,7 @@ static void handle_monitor(struct data *data, struct spa_monitor *monitor)
uint32_t index;
if (monitor->info)
spa_debug_dict(monitor->info);
spa_debug_dict(0, monitor->info);
for (index = 0;;) {
struct spa_pod *item;
@ -174,8 +176,6 @@ int main(int argc, char *argv[])
data.main_loop.update_source = do_update_source;
data.main_loop.remove_source = do_remove_source;
spa_debug_set_type_map(data.map);
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].type = SPA_TYPE__Log;

2
src/daemon/pipewire.conf.in
View file

@ -8,6 +8,6 @@ load-module libpipewire-module-spa-monitor bluez5/libspa-bluez5 bluez5-monitor b
#load-module libpipewire-module-spa-node videotestsrc/libspa-videotestsrc videotestsrc videotestsrc Spa:POD:Object:Props:patternType=Spa:POD:Object:Props:patternType:snow
load-module libpipewire-module-client-node
load-module libpipewire-module-flatpak
#load-module libpipewire-module-media-session
load-module libpipewire-module-media-session
load-module libpipewire-module-audio-dsp
load-module libpipewire-module-link-factory

1
src/examples/audio-src.c
View file

@ -27,7 +27,6 @@
#include <spa/param/format-utils.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/props.h>
#include <spa/lib/debug.h>
#include <pipewire/pipewire.h>

6
src/examples/export-sink.c
View file

@ -28,7 +28,7 @@
#include <spa/param/video/format-utils.h>
#include <spa/param/props.h>
#include <spa/node/io.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
#include <pipewire/module.h>
@ -455,7 +455,7 @@ static int port_set_format(struct spa_node *node,
if (format == NULL)
return 0;
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(0, d->t->map, format);
spa_format_video_raw_parse(format, &d->format, &d->type.format_video);
@ -683,8 +683,6 @@ int main(int argc, char *argv[])
init_type(&data.type, data.t->map);
reset_props(&data.props);
spa_debug_set_type_map(data.t->map);
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("can't initialize SDL: %s\n", SDL_GetError());
return -1;

5
src/examples/export-source.c
View file

@ -27,7 +27,7 @@
#include <spa/param/audio/format-utils.h>
#include <spa/param/props.h>
#include <spa/node/io.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
@ -359,7 +359,7 @@ static int port_set_format(struct spa_node *node,
return 0;
}
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(0, d->t->map, format);
if (spa_format_audio_raw_parse(format, &d->format, &d->type.format_audio) < 0)
return -EINVAL;
@ -602,7 +602,6 @@ int main(int argc, char *argv[])
spa_list_init(&data.empty);
init_type(&data.type, data.t->map);
reset_props(&data.props);
spa_debug_set_type_map(data.t->map);
pw_remote_add_listener(data.remote, &data.remote_listener, &remote_events, &data);

4
src/examples/export-spa.c
View file

@ -26,8 +26,6 @@
#include <spa/param/video/format-utils.h>
#include <spa/param/props.h>
#include <spa/lib/debug.h>
#include <pipewire/pipewire.h>
#include <pipewire/factory.h>
@ -140,8 +138,6 @@ int main(int argc, char *argv[])
pw_module_load(data.core, "libpipewire-module-spa-node-factory", NULL, NULL, NULL, NULL);
spa_debug_set_type_map(data.t->map);
pw_remote_add_listener(data.remote, &data.remote_listener, &remote_events, &data);
pw_remote_connect(data.remote);

6
src/examples/local-v4l2.c
View file

@ -27,7 +27,7 @@
#include <spa/param/video/format-utils.h>
#include <spa/param/props.h>
#include <spa/node/io.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
#include <pipewire/module.h>
@ -337,7 +337,7 @@ static int port_set_format(struct spa_node *node, enum spa_direction direction,
if (format == NULL)
return 0;
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(0, d->t->map, format);
spa_format_video_raw_parse(format, &d->format, &d->type.format_video);
@ -511,8 +511,6 @@ int main(int argc, char *argv[])
init_type(&data.type, data.t->map);
spa_debug_set_type_map(data.t->map);
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("can't initialize SDL: %s\n", SDL_GetError());
return -1;

3
src/examples/media-session.c
View file

@ -29,9 +29,6 @@
#include <spa/utils/hook.h>
#include <spa/param/audio/format-utils.h>
#include <spa/lib/pod.h>
#include <spa/lib/debug.h>
#include "pipewire/core.h"
#include "pipewire/control.h"
#include "pipewire/link.h"

5
src/examples/video-play.c
View file

@ -27,7 +27,7 @@
#include <spa/param/format-utils.h>
#include <spa/param/video/format-utils.h>
#include <spa/param/props.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
@ -322,7 +322,7 @@ static int build_format(struct data *data, struct spa_pod_builder *b, const stru
params[0] = spa_pod_builder_pop(b);
printf("supported formats:\n");
spa_debug_pod(params[0], SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, data->t->map, params[0]);
return 0;
}
@ -355,7 +355,6 @@ int main(int argc, char *argv[])
data.path = argc > 1 ? argv[1] : NULL;
init_type(&data.type, data.t->map);
spa_debug_set_type_map(data.t->map);
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("can't initialize SDL: %s\n", SDL_GetError());

1
src/examples/video-src.c
View file

@ -26,7 +26,6 @@
#include <spa/param/format-utils.h>
#include <spa/param/video/format-utils.h>
#include <spa/param/props.h>
#include <spa/lib/debug.h>
#include <pipewire/pipewire.h>

2
src/modules/meson.build
View file

@ -61,7 +61,6 @@ pipewire_module_protocol_native = shared_library('pipewire-module-protocol-nativ
'module-protocol-native/connection.c' ],
c_args : pipewire_module_c_args,
include_directories : [configinc, spa_inc],
link_with : spalib,
install : true,
install_dir : modules_install_dir,
dependencies : [mathlib, dl_lib, pipewire_dep],
@ -74,7 +73,6 @@ pipewire_module_audio_dsp = shared_library('pipewire-module-audio-dsp',
'spa/spa-node.c' ],
c_args : pipewire_module_c_args,
include_directories : [configinc, spa_inc],
link_with : spalib,
install : true,
install_dir : modules_install_dir,
dependencies : [mathlib, dl_lib, rt_lib, pipewire_dep],

22
src/modules/module-client-node/client-stream.c
View file

@ -32,8 +32,8 @@
#include <spa/buffer/alloc.h>
#include <spa/pod/parser.h>
#include <spa/param/audio/format-utils.h>
#include <spa/lib/pod.h>
#include <spa/debug/pod.h>
#include <spa/debug/format.h>
#include "pipewire/core.h"
#include "pipewire/pipewire.h"
@ -45,8 +45,6 @@
#include "client-node.h"
#include "client-stream.h"
#include <spa/lib/debug.h>
/** \cond */
struct type {
@ -349,14 +347,10 @@ static int debug_params(struct impl *impl, struct spa_node *node,
struct pw_type *t = impl->t;
struct spa_pod_builder b = { 0 };
uint8_t buffer[4096];
uint32_t state, flag;
struct spa_pod *format;
uint32_t state;
struct spa_pod *param;
int res;
flag = 0;
if (id == t->param.idEnumFormat)
flag |= SPA_DEBUG_FLAG_FORMAT;
spa_log_error(this->log, "params %s:", spa_type_map_get_type(t->map, id));
state = 0;
@ -365,18 +359,18 @@ static int debug_params(struct impl *impl, struct spa_node *node,
res = spa_node_port_enum_params(node,
direction, port_id,
id, &state,
NULL, &format, &b);
NULL, &param, &b);
if (res <= 0) {
if (res < 0)
spa_log_error(this->log, " error: %s", spa_strerror(res));
break;
}
spa_debug_pod(format, flag);
spa_debug_pod(2, t->map, param);
}
spa_log_error(this->log, "failed filter:");
if (filter)
spa_debug_pod(filter, flag);
spa_debug_pod(2, t->map, filter);
return 0;
}
@ -417,7 +411,7 @@ static int negotiate_format(struct impl *impl)
}
spa_pod_fixate(format);
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(0, t->map, format);
if ((res = spa_node_port_set_param(impl->adapter_mix,
SPA_DIRECTION_REVERSE(impl->direction), 0,

6
src/modules/module-media-session.c
View file

@ -28,9 +28,7 @@
#include <spa/node/node.h>
#include <spa/utils/hook.h>
#include <spa/param/audio/format-utils.h>
#include <spa/lib/pod.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include "pipewire/core.h"
#include "pipewire/control.h"
@ -666,7 +664,7 @@ static int collect_audio_format(void *data, uint32_t id,
return 0;
spa_pod_fixate(param);
spa_debug_pod(param, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(0, impl->t->map, param);
if (spa_format_audio_raw_parse(param, &info, &impl->type.format_audio) < 0)
return 0;

3
src/modules/module-media-session/audio-dsp.c
View file

@ -29,9 +29,6 @@
#include <spa/utils/hook.h>
#include <spa/param/audio/format-utils.h>
#include <spa/lib/pod.h>
#include <spa/lib/debug.h>
#include "pipewire/core.h"
#include "pipewire/link.h"
#include "pipewire/log.h"

10
src/modules/module-protocol-native.c
View file

@ -28,7 +28,7 @@
#include <sys/file.h>
#include <spa/pod/iter.h>
#include <spa/lib/debug.h>
#include <spa/debug/pod.h>
#include "config.h"
@ -233,7 +233,7 @@ process_messages(struct client_data *data)
if (debug_messages) {
fprintf(stderr, "<<<<<<<<< in: %d %d %d\n", id, opcode, size);
spa_debug_pod((struct spa_pod *)message, 0);
spa_debug_pod(0, core->type.map, (struct spa_pod *)message);
}
if (demarshal[opcode].func(resource, message, size) < 0)
goto invalid_message;
@ -344,7 +344,7 @@ static struct pw_client *client_new(struct server *s, int fd)
if (this->source == NULL)
goto no_source;
this->connection = pw_protocol_native_connection_new(fd);
this->connection = pw_protocol_native_connection_new(protocol->core, fd);
if (this->connection == NULL)
goto no_connection;
@ -567,7 +567,7 @@ on_remote_data(void *data, int fd, enum spa_io mask)
}
if (debug_messages) {
fprintf(stderr, "<<<<<<<<< in: %d %d %d\n", id, opcode, size);
spa_debug_pod((struct spa_pod *)message, 0);
spa_debug_pod(0, core->type.map, (struct spa_pod *)message);
}
if (demarshal[opcode].func(proxy, message, size) < 0) {
pw_log_error ("protocol-native %p: invalid message received %u for %u", this,
@ -611,7 +611,7 @@ static int impl_connect_fd(struct pw_protocol_client *client, int fd)
impl->disconnecting = false;
impl->connection = pw_protocol_native_connection_new(fd);
impl->connection = pw_protocol_native_connection_new(remote->core, fd);
if (impl->connection == NULL)
goto error_close;

9
src/modules/module-protocol-native/connection.c
View file

@ -25,7 +25,7 @@
#include <unistd.h>
#include <sys/socket.h>
#include <spa/lib/debug.h>
#include <spa/debug/pod.h>
#include <pipewire/pipewire.h>
#include <pipewire/private.h>
@ -59,6 +59,8 @@ struct impl {
uint32_t dest_id;
uint8_t opcode;
struct spa_pod_builder builder;
struct pw_core *core;
};
/** \endcond */
@ -193,7 +195,7 @@ static void clear_buffer(struct buffer *buf)
*
* \memberof pw_protocol_native_connection
*/
struct pw_protocol_native_connection *pw_protocol_native_connection_new(int fd)
struct pw_protocol_native_connection *pw_protocol_native_connection_new(struct pw_core *core, int fd)
{
struct impl *impl;
struct pw_protocol_native_connection *this;
@ -216,6 +218,7 @@ struct pw_protocol_native_connection *pw_protocol_native_connection_new(int fd)
impl->in.buffer_data = malloc(MAX_BUFFER_SIZE);
impl->in.buffer_maxsize = MAX_BUFFER_SIZE;
impl->in.update = true;
impl->core = core;
if (impl->out.buffer_data == NULL || impl->in.buffer_data == NULL)
goto no_mem;
@ -432,7 +435,7 @@ pw_protocol_native_connection_end(struct pw_protocol_native_connection *conn,
if (debug_messages) {
fprintf(stderr, ">>>>>>>>> out: %d %d %d\n", impl->dest_id, impl->opcode, size);
spa_debug_pod((struct spa_pod *)p, 0);
spa_debug_pod(0, impl->core->type.map, (struct spa_pod *)p);
}
spa_hook_list_call(&conn->listener_list,
struct pw_protocol_native_connection_events, need_flush, 0);

2
src/modules/module-protocol-native/connection.h
View file

@ -61,7 +61,7 @@ pw_protocol_native_connection_add_listener(struct pw_protocol_native_connection
}
struct pw_protocol_native_connection *
pw_protocol_native_connection_new(int fd);
pw_protocol_native_connection_new(struct pw_core *core, int fd);
void
pw_protocol_native_connection_destroy(struct pw_protocol_native_connection *conn);

2
src/modules/module-protocol-native/local-socket.c
View file

@ -29,8 +29,6 @@
#include <fcntl.h>
#include <sys/file.h>
#include <spa/lib/debug.h>
#include <pipewire/pipewire.h>
#include <pipewire/private.h>

2
src/modules/module-protocol-native/portal-screencast.c
View file

@ -25,8 +25,6 @@
#include <unistd.h>
#include <sys/socket.h>
#include <spa/lib/debug.h>
#include <pipewire/pipewire.h>
#include <pipewire/private.h>

1
src/modules/spa/spa-monitor.c
View file

@ -31,7 +31,6 @@
#include <spa/node/node.h>
#include <spa/monitor/monitor.h>
#include <spa/pod/parser.h>
#include <spa/lib/debug.h>
#include <pipewire/log.h>
#include <pipewire/type.h>

14
src/pipewire/core.c
View file

@ -21,8 +21,10 @@
#include <time.h>
#include <stdio.h>
#include <spa/lib/debug.h>
#include <pipewire/log.h>
#include <spa/support/dbus.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
#include <pipewire/private.h>
@ -390,8 +392,6 @@ struct pw_core *pw_core_new(struct pw_loop *main_loop, struct pw_properties *pro
pw_type_init(&this->type);
pw_map_init(&this->globals, 128, 32);
spa_debug_set_type_map(this->type.map);
this->support[0] = SPA_SUPPORT_INIT(SPA_TYPE__TypeMap, this->type.map);
this->support[1] = SPA_SUPPORT_INIT(SPA_TYPE_LOOP__DataLoop, this->data_loop->loop);
this->support[2] = SPA_SUPPORT_INIT(SPA_TYPE_LOOP__MainLoop, this->main_loop->loop);
@ -759,7 +759,7 @@ int pw_core_find_format(struct pw_core *core,
}
pw_log_debug("Got output format:");
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(*format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, t->map, *format);
} else if (out_state >= PW_PORT_STATE_CONFIGURE && in_state > PW_PORT_STATE_CONFIGURE) {
/* only output needs format */
if ((res = spa_node_port_enum_params(input->node->node,
@ -773,7 +773,7 @@ int pw_core_find_format(struct pw_core *core,
}
pw_log_debug("Got input format:");
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(*format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, t->map, *format);
} else if (in_state == PW_PORT_STATE_CONFIGURE && out_state == PW_PORT_STATE_CONFIGURE) {
struct spa_pod_builder fb = { 0 };
uint8_t fbuf[4096];
@ -795,7 +795,7 @@ int pw_core_find_format(struct pw_core *core,
}
pw_log_debug("enum output %d with filter: %p", oidx, filter);
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(filter, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, t->map, filter);
if ((res = spa_node_port_enum_params(output->node->node,
output->direction, output->port_id,
@ -811,7 +811,7 @@ int pw_core_find_format(struct pw_core *core,
pw_log_debug("Got filtered:");
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(*format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, core->type.map, *format);
} else {
res = -EBADF;
asprintf(error, "error node state");

19
src/pipewire/link.c
View file

@ -25,14 +25,15 @@
#include <spa/pod/compare.h>
#include <spa/param/param.h>
#include <spa/lib/debug.h>
#include "pipewire.h"
#include "private.h"
#include "pipewire.h"
#include "interfaces.h"
#include "link.h"
#include "work-queue.h"
#include <spa/debug/node.h>
#include <spa/debug/format.h>
#define MAX_BUFFERS 64
/** \cond */
@ -222,7 +223,7 @@ static int do_negotiate(struct pw_link *this, uint32_t in_state, uint32_t out_st
pw_log_debug("link %p: doing set format %p", this, format);
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, t->map, format);
if (out_mix_state == PW_PORT_STATE_CONFIGURE) {
pw_log_debug("link %p: doing set format on output mix", this);
@ -499,7 +500,7 @@ param_filter(struct pw_link *this,
}
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG) && iparam != NULL)
spa_debug_pod(iparam, 0);
spa_debug_pod(2, this->core->type.map, iparam);
for (oidx = 0;;) {
pw_log_debug("oparam %d", oidx);
@ -510,7 +511,7 @@ param_filter(struct pw_link *this,
}
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(oparam, 0);
spa_debug_pod(2, this->core->type.map, oparam);
num++;
}
@ -614,8 +615,8 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
}
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG)) {
spa_debug_port_info(oinfo);
spa_debug_port_info(iinfo);
spa_debug_port_info(2, oinfo);
spa_debug_port_info(2, iinfo);
}
if (output->allocation.n_buffers) {
out_flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS;
@ -652,7 +653,7 @@ static int do_allocation(struct pw_link *this, uint32_t in_state, uint32_t out_s
spa_pod_fixate(params[i]);
pw_log_debug("fixated param %d:", i);
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(params[i], 0);
spa_debug_pod(2, this->core->type.map, params[i]);
offset += SPA_ROUND_UP_N(SPA_POD_SIZE(params[i]), 8);
}

8
src/pipewire/log.h
View file

@ -61,9 +61,11 @@ pw_log_logv(enum spa_log_level level,
/** Check if a loglevel is enabled \memberof pw_log */
#define pw_log_level_enabled(lev) (pw_log_level >= (lev))
#define pw_log(lev,...) \
if (SPA_UNLIKELY(pw_log_level_enabled (lev))) \
pw_log_log(lev,__FILE__,__LINE__,__func__,__VA_ARGS__)
#define pw_log(lev,...) \
({ \
if (SPA_UNLIKELY(pw_log_level_enabled (lev))) \
pw_log_log(lev,__FILE__,__LINE__,__func__,__VA_ARGS__); \
})
#define pw_log_error(...) pw_log(SPA_LOG_LEVEL_ERROR,__VA_ARGS__)
#define pw_log_warn(...) pw_log(SPA_LOG_LEVEL_WARN,__VA_ARGS__)

3
src/pipewire/meson.build
View file

@ -79,12 +79,11 @@ libpipewire = shared_library('pipewire-@0@'.format(apiversion), pipewire_sources
soversion : soversion,
c_args : libpipewire_c_args,
include_directories : [pipewire_inc, configinc, spa_inc],
link_with : spalib,
install : true,
dependencies : [dl_lib, mathlib, pthread_lib],
)
pipewire_dep = declare_dependency(link_with : libpipewire,
include_directories : [pipewire_inc, configinc, spa_inc],
dependencies : [pthread_lib,spalib_dep],
dependencies : [pthread_lib],
)

4
src/pipewire/node.c
View file

@ -34,6 +34,10 @@
#include "pipewire/main-loop.h"
#include "pipewire/work-queue.h"
#ifndef spa_debug
#define spa_debug pw_log_trace
#endif
#include <spa/graph/graph-scheduler2.h>
/** \cond */

2
src/pipewire/private.h
View file

@ -27,10 +27,10 @@ extern "C" {
#include <sys/socket.h>
#include <sys/types.h> /* for pthread_t */
#include "pipewire/mem.h"
#include "pipewire/pipewire.h"
#include "pipewire/introspect.h"
#include "pipewire/log.h"
#ifndef spa_debug
#define spa_debug pw_log_trace

4
src/pipewire/stream.c
View file

@ -30,7 +30,7 @@
#include <spa/node/io.h>
#include <spa/utils/ringbuffer.h>
#include <spa/pod/filter.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include "pipewire/pipewire.h"
#include "pipewire/stream.h"
@ -446,7 +446,7 @@ static int port_set_format(struct spa_node *node,
pw_log_debug("stream %p: format changed:", impl);
if (pw_log_level >= SPA_LOG_LEVEL_DEBUG)
spa_debug_pod(format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, t->map, format);
clear_params(stream, PARAM_TYPE_FORMAT);
if (spa_pod_is_object_type(format, t->spa_format)) {

16
src/tools/pipewire-cli.c
View file

@ -25,7 +25,7 @@
#include <signal.h>
#include <string.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
#include <pipewire/command.h>
@ -596,7 +596,7 @@ static void info_link(struct proxy_data *pd)
fprintf(stdout, "%c\tinput-port-id: %u\n", MARK_CHANGE(1), info->input_port_id);
fprintf(stdout, "%c\tformat:\n", MARK_CHANGE(2));
if (info->format)
spa_debug_pod(info->format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, pd->rd->data->t->map, info->format);
else
fprintf(stdout, "\t\tnone\n");
print_properties(info->props, MARK_CHANGE(3), true);
@ -666,14 +666,14 @@ static void node_event_param(void *object, uint32_t id, uint32_t index, uint32_t
struct proxy_data *data = object;
struct remote_data *rd = data->rd;
struct pw_type *t = rd->data->t;
uint32_t flags = 0;
fprintf(stdout, "remote %d node %d param %d index %d\n",
rd->id, data->global->id, id, index);
if (spa_pod_is_object_type(param, t->spa_format))
flags |= SPA_DEBUG_FLAG_FORMAT;
spa_debug_pod(param, flags);
spa_debug_format(2, t->map, param);
else
spa_debug_pod(2, t->map, param);
}
static const struct pw_node_proxy_events node_events = {
@ -704,14 +704,14 @@ static void port_event_param(void *object, uint32_t id, uint32_t index, uint32_t
struct proxy_data *data = object;
struct remote_data *rd = data->rd;
struct pw_type *t = rd->data->t;
uint32_t flags = 0;
fprintf(stdout, "remote %d port %d param %d index %d\n",
rd->id, data->global->id, id, index);
if (spa_pod_is_object_type(param, t->spa_format))
flags |= SPA_DEBUG_FLAG_FORMAT;
spa_debug_pod(param, flags);
spa_debug_format(2, t->map, param);
else
spa_debug_pod(2, t->map, param);
}
static const struct pw_port_proxy_events port_events = {

17
src/tools/pipewire-monitor.c
View file

@ -20,7 +20,7 @@
#include <stdio.h>
#include <signal.h>
#include <spa/lib/debug.h>
#include <spa/debug/format.h>
#include <pipewire/pipewire.h>
#include <pipewire/interfaces.h>
@ -216,10 +216,10 @@ static void print_node(struct proxy_data *data)
printf("%c\tname: \"%s\"\n", MARK_CHANGE(0), info->name);
printf("%c\tparams:\n", MARK_CHANGE(5));
for (i = 0; i < data->n_params; i++) {
uint32_t flags = 0;
if (spa_pod_is_object_type(data->params[i], t->spa_format))
flags |= SPA_DEBUG_FLAG_FORMAT;
spa_debug_pod(data->params[i], flags);
spa_debug_format(2, t->map, data->params[i]);
else
spa_debug_pod(2, t->map, data->params[i]);
}
printf("%c\tinput ports: %u/%u\n", MARK_CHANGE(1),
info->n_input_ports, info->max_input_ports);
@ -293,10 +293,10 @@ static void print_port(struct proxy_data *data)
printf("%c\tname: \"%s\"\n", MARK_CHANGE(0), info->name);
printf("%c\tparams:\n", MARK_CHANGE(2));
for (i = 0; i < data->n_params; i++) {
uint32_t flags = 0;
if (spa_pod_is_object_type(data->params[i], t->spa_format))
flags |= SPA_DEBUG_FLAG_FORMAT;
spa_debug_pod(data->params[i], flags);
spa_debug_format(2, t->map, data->params[i]);
else
spa_debug_pod(2, t->map, data->params[i]);
}
print_properties(info->props, MARK_CHANGE(1));
}
@ -404,6 +404,7 @@ static const struct pw_client_proxy_events client_events = {
static void link_event_info(void *object, struct pw_link_info *info)
{
struct proxy_data *data = object;
struct pw_type *t = pw_core_get_type(data->data->core);
bool print_all, print_mark;
print_all = true;
@ -431,7 +432,7 @@ static void link_event_info(void *object, struct pw_link_info *info)
printf("%c\tinput-port-id: %u\n", MARK_CHANGE(1), info->input_port_id);
printf("%c\tformat:\n", MARK_CHANGE(2));
if (info->format)
spa_debug_pod(info->format, SPA_DEBUG_FLAG_FORMAT);
spa_debug_format(2, t->map, info->format);
else
printf("\t\tnone\n");
print_properties(info->props, MARK_CHANGE(3));