mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/spa/lib/debug.c

452 lines
14 KiB
C
Raw Normal View History

More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
/* 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 "spa/debug.h"
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
#include "spa/memory.h"
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
#include "spa/props.h"
#include "spa/format.h"
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
SpaResult
spa_debug_port_info (const SpaPortInfo *info)
{
int i;
if (info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
fprintf (stderr, "SpaPortInfo %p:\n", info);
fprintf (stderr, " flags: \t%08x\n", info->flags);
Work on node creation Implements the basics of the PORT_UPDATE control message Add the ports to the proxy node with whe PORT_UPDATE control message. Let the proxy node check the events and create dbus objects based on added/removed ports.
2016-08-05 19:46:37 +02:00
fprintf (stderr, " maxbuffering: \t%"PRIu64"\n", info->maxbuffering);
More hacking Add spa based v4l2 pinos module Add allocation params to port_alloc_buffers Let the app do allocation for handles.
2016-07-13 18:29:55 +02:00
fprintf (stderr, " latency: \t%" PRIu64 "\n", info->latency);
fprintf (stderr, " n_params: \t%d\n", info->n_params);
for (i = 0; i < info->n_params; i++) {
SpaAllocParam *param = info->params[i];
fprintf (stderr, " param %d, type %d, size %zd:\n", i, param->type, param->size);
switch (param->type) {
case SPA_ALLOC_PARAM_TYPE_INVALID:
fprintf (stderr, " INVALID\n");
break;
case SPA_ALLOC_PARAM_TYPE_BUFFERS:
{
SpaAllocParamBuffers *p = (SpaAllocParamBuffers *)param;
fprintf (stderr, " SpaAllocParamBuffers:\n");
fprintf (stderr, " minsize: \t\t%zd\n", p->minsize);
fprintf (stderr, " stride: \t\t%zd\n", p->stride);
fprintf (stderr, " min_buffers: \t%d\n", p->min_buffers);
fprintf (stderr, " max_buffers: \t%d\n", p->max_buffers);
fprintf (stderr, " align: \t\t%d\n", p->align);
break;
}
case SPA_ALLOC_PARAM_TYPE_META_ENABLE:
{
SpaAllocParamMetaEnable *p = (SpaAllocParamMetaEnable *)param;
fprintf (stderr, " SpaAllocParamMetaEnable:\n");
fprintf (stderr, " type: \t%d\n", p->type);
break;
}
case SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING:
{
SpaAllocParamVideoPadding *p = (SpaAllocParamVideoPadding *)param;
fprintf (stderr, " SpaAllocParamVideoPadding:\n");
fprintf (stderr, " padding_top: \t%d\n", p->padding_top);
fprintf (stderr, " padding_bottom: \t%d\n", p->padding_bottom);
fprintf (stderr, " padding_left: \t%d\n", p->padding_left);
fprintf (stderr, " padding_right: \t%d\n", p->padding_right);
fprintf (stderr, " stide_align: \t[%d, %d, %d, %d]\n",
p->stride_align[0], p->stride_align[1], p->stride_align[2], p->stride_align[3]);
break;
}
default:
fprintf (stderr, " UNKNOWN\n");
break;
}
}
return SPA_RESULT_OK;
}
Rework transport protocol Remove the old PinosBuffer object and replace it with SpaControl, this communication protocol is designed to make it possible to implement remote nodes and so it is moved to Spa. Move SpaBuffer into to API Work on easier API to make formats, implement enumeration and support for all formats in v4l2. Improve format output in -inspect
2016-07-28 21:19:20 +02:00
Make buffer structure sharable Use stucture offsets instead of pointers so that we can share the buffer structure between client and server. We can then pass an fd wrapping the memory of the buffer to the client. Add beginnings of a memory pool
2016-08-03 15:59:17 +02:00
SpaResult
spa_debug_buffer (const SpaBuffer *buffer)
{
int i;
if (buffer == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
fprintf (stderr, "SpaBuffer %p:\n", buffer);
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
fprintf (stderr, " id: %08X\n", buffer->id);
Work on negotiation Add helpers to convert between pinos and gstreamer formats. Use pinos formats in the API. Work on removing some hardcoded stuff and instead use the real format from the pinos server. Use memfd and sealing.
2016-08-05 16:39:26 +02:00
fprintf (stderr, " pool_id: %08X\n", buffer->mem.mem.pool_id);
fprintf (stderr, " mem_id: %08X\n", buffer->mem.mem.id);
fprintf (stderr, " offset: %zd\n", buffer->mem.offset);
fprintf (stderr, " size: %zd\n", buffer->mem.size);
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
fprintf (stderr, " n_metas: %u (offset %zd)\n", buffer->n_metas, buffer->metas);
Make buffer structure sharable Use stucture offsets instead of pointers so that we can share the buffer structure between client and server. We can then pass an fd wrapping the memory of the buffer to the client. Add beginnings of a memory pool
2016-08-03 15:59:17 +02:00
for (i = 0; i < buffer->n_metas; i++) {
SpaMeta *m = &SPA_BUFFER_METAS (buffer)[i];
fprintf (stderr, " meta %d: type %d, offset %zd, size %zd:\n", i, m->type, m->offset, m->size);
switch (m->type) {
case SPA_META_TYPE_HEADER:
{
SpaMetaHeader *h = SPA_MEMBER (buffer, m->offset, SpaMetaHeader);
fprintf (stderr, " SpaMetaHeader:\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);
break;
}
case SPA_META_TYPE_POINTER:
fprintf (stderr, " SpaMetaPointer:\n");
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
break;
case SPA_META_TYPE_VIDEO_CROP:
fprintf (stderr, " SpaMetaVideoCrop:\n");
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
break;
default:
spa_debug_dump_mem (SPA_MEMBER (buffer, m->offset, void), m->size);
break;
}
}
fprintf (stderr, " n_datas: \t%u (offset %zd)\n", buffer->n_datas, buffer->datas);
for (i = 0; i < buffer->n_datas; i++) {
SpaData *d = &SPA_BUFFER_DATAS (buffer)[i];
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
SpaMemory *mem;
Work on negotiation Add helpers to convert between pinos and gstreamer formats. Use pinos formats in the API. Work on removing some hardcoded stuff and instead use the real format from the pinos server. Use memfd and sealing.
2016-08-05 16:39:26 +02:00
mem = spa_memory_find (&d->mem.mem);
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
fprintf (stderr, " data %d: (memory %p)\n", i, mem);
if (mem) {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
fprintf (stderr, " pool_id: %u\n", mem->mem.pool_id);
fprintf (stderr, " id: %u\n", mem->mem.id);
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
fprintf (stderr, " flags: %08x\n", mem->flags);
fprintf (stderr, " type: %s\n", mem->type ? mem->type : "*unknown*");
fprintf (stderr, " fd: %d\n", mem->fd);
fprintf (stderr, " ptr: %p\n", mem->ptr);
fprintf (stderr, " size: %zd\n", mem->size);
} else {
fprintf (stderr, " invalid memory reference\n");
Make buffer structure sharable Use stucture offsets instead of pointers so that we can share the buffer structure between client and server. We can then pass an fd wrapping the memory of the buffer to the client. Add beginnings of a memory pool
2016-08-03 15:59:17 +02:00
}
Work on negotiation Add helpers to convert between pinos and gstreamer formats. Use pinos formats in the API. Work on removing some hardcoded stuff and instead use the real format from the pinos server. Use memfd and sealing.
2016-08-05 16:39:26 +02:00
fprintf (stderr, " offset: %zd\n", d->mem.offset);
fprintf (stderr, " size: %zd\n", d->mem.size);
Make buffer data point to memory blocks Make buffer data point to a registered memory block by its mem_id. Add some more helpers to allocate memfd backed memory. Allocate buffers in memfd so that we easily share them between client and server. Update pts and seq in v4l2 now that this change will actually be visible at the client.
2016-08-03 21:33:57 +02:00
fprintf (stderr, " stride: %zd\n", d->stride);
Make buffer structure sharable Use stucture offsets instead of pointers so that we can share the buffer structure between client and server. We can then pass an fd wrapping the memory of the buffer to the client. Add beginnings of a memory pool
2016-08-03 15:59:17 +02:00
}
return SPA_RESULT_OK;
}
Rework transport protocol Remove the old PinosBuffer object and replace it with SpaControl, this communication protocol is designed to make it possible to implement remote nodes and so it is moved to Spa. Move SpaBuffer into to API Work on easier API to make formats, implement enumeration and support for all formats in v4l2. Improve format output in -inspect
2016-07-28 21:19:20 +02:00
SpaResult
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
spa_debug_dump_mem (const void *mem, size_t size)
Rework transport protocol Remove the old PinosBuffer object and replace it with SpaControl, this communication protocol is designed to make it possible to implement remote nodes and so it is moved to Spa. Move SpaBuffer into to API Work on easier API to make formats, implement enumeration and support for all formats in v4l2. Improve format output in -inspect
2016-07-28 21:19:20 +02:00
{
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
const uint8_t *t = mem;
Rework transport protocol Remove the old PinosBuffer object and replace it with SpaControl, this communication protocol is designed to make it possible to implement remote nodes and so it is moved to Spa. Move SpaBuffer into to API Work on easier API to make formats, implement enumeration and support for all formats in v4l2. Improve format output in -inspect
2016-07-28 21:19:20 +02:00
int i;
if (mem == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < size; i++) {
printf ("%02x ", t[i]);
Make buffer structure sharable Use stucture offsets instead of pointers so that we can share the buffer structure between client and server. We can then pass an fd wrapping the memory of the buffer to the client. Add beginnings of a memory pool
2016-08-03 15:59:17 +02:00
if (i % 16 == 15 || i == size - 1)
Rework transport protocol Remove the old PinosBuffer object and replace it with SpaControl, this communication protocol is designed to make it possible to implement remote nodes and so it is moved to Spa. Move SpaBuffer into to API Work on easier API to make formats, implement enumeration and support for all formats in v4l2. Improve format output in -inspect
2016-07-28 21:19:20 +02:00
printf ("\n");
}
return SPA_RESULT_OK;
}
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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:
work on port-update control message Serialize format and properties. Simplify the properties by moving the unset-mask inside the property structure. We can then also just use the index of the property as the bit in the mask. Work on stopping on disconnect
2016-08-08 22:10:57 +02:00
fprintf (stderr, "%" PRIi32, *(int32_t *)value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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");
work on memory references Add a memory reference helper struct that we can use to track the memory in buffers and formats. Remove custom property get and set, the default ones will work fine. Custom ones are problematic when we want to serialize properties in formats etc. Deserialized Formats are now tracked in the memory pool and can be freed if needed.
2016-08-04 19:24:16 +02:00
res = spa_props_get_prop (props, i, &value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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;
work on memory references Add a memory reference helper struct that we can use to track the memory in buffers and formats. Remove custom property get and set, the default ones will work fine. Custom ones are problematic when we want to serialize properties in formats etc. Deserialized Formats are now tracked in the memory pool and can be freed if needed.
2016-08-04 19:24:16 +02:00
res = spa_props_get_prop (props, i, &value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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;
}
Reference in a new issue Copy permalink