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

540 lines
16 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"
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
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
struct meta_type_name {
const char *name;
} meta_type_names[] = {
{ "invalid" },
{ "SpaMetaHeader" },
{ "SpaMetaPointer" },
{ "SpaMetaVideoCrop" },
{ "SpaMetaRingbuffer" },
{ "invalid" },
};
#define META_TYPE_NAME(t) meta_type_names[SPA_CLAMP(t,0,SPA_N_ELEMENTS(meta_type_names)-1)].name
struct data_type_name {
const char *name;
} data_type_names[] = {
{ "invalid" },
{ "memptr" },
{ "memfd" },
{ "dmabuf" },
{ "ID" },
{ "invalid" },
};
#define DATA_TYPE_NAME(t) data_type_names[SPA_CLAMP(t,0,SPA_N_ELEMENTS(data_type_names)-1)].name
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");
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
fprintf (stderr, " type: \t%d (%s)\n", p->type, META_TYPE_NAME(p->type));
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
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);
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
fprintf (stderr, " n_metas: %u (at %p)\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++) {
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
SpaMeta *m = &buffer->metas[i];
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
fprintf (stderr, " meta %d: type %d (%s), data %p, size %zd:\n", i, m->type, META_TYPE_NAME (m->type), m->data, m->size);
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
switch (m->type) {
case SPA_META_TYPE_HEADER:
{
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
SpaMetaHeader *h = m->data;
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
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:
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
{
SpaMetaPointer *h = m->data;
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
fprintf (stderr, " SpaMetaPointer:\n");
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
fprintf (stderr, " ptr_type: %s\n", h->ptr_type);
fprintf (stderr, " ptr: %p\n", h->ptr);
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
spa_debug_dump_mem (m->data, m->size);
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
break;
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +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
case SPA_META_TYPE_VIDEO_CROP:
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
{
SpaMetaVideoCrop *h = m->data;
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
fprintf (stderr, " SpaMetaVideoCrop:\n");
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
fprintf (stderr, " x: %d\n", h->x);
fprintf (stderr, " y: %d\n", h->y);
fprintf (stderr, " width: %d\n", h->width);
fprintf (stderr, " height: %d\n", h->height);
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
break;
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
}
case SPA_META_TYPE_RINGBUFFER:
{
SpaMetaRingbuffer *h = m->data;
fprintf (stderr, " SpaMetaRingbuffer:\n");
fprintf (stderr, " readindex: %d\n", h->readindex);
fprintf (stderr, " writeindex: %d\n", h->writeindex);
fprintf (stderr, " size: %d\n", h->size);
fprintf (stderr, " size_mask: %d\n", h->size_mask);
break;
}
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
default:
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
spa_debug_dump_mem (m->data, m->size);
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
break;
}
}
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
fprintf (stderr, " n_datas: \t%u (at %p)\n", buffer->n_datas, buffer->datas);
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_datas; i++) {
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
SpaData *d = &buffer->datas[i];
More work on memory Add explicit DMABUF memory because we can't use it like an fd in v4l2. mmap random fd memory and use userptr in v4l2 to use it. Allocate buffer data memory in memfd when no node can allocate. Improve debug some more
2016-10-04 15:56:33 +02:00
fprintf (stderr, " type: %d (%s)\n", d->type, DATA_TYPE_NAME (d->type));
Add fd to the data Add the fd to the SpaData so that we can noth use the fd and the mmapped memory when we want instead of needing to mmap again in the plugin. various cleanups
2016-10-04 19:37:44 +02:00
fprintf (stderr, " flags: %d\n", d->flags);
Plug some leaks Add maxsize to bufferdata in case the memory size can be variable such as with encoded formats. Copy new size in the proxy.
2016-09-30 19:56:41 +02:00
fprintf (stderr, " data: %p\n", d->data);
Add fd to the data Add the fd to the SpaData so that we can noth use the fd and the mmapped memory when we want instead of needing to mmap again in the plugin. various cleanups
2016-10-04 19:37:44 +02:00
fprintf (stderr, " fd: %d\n", d->fd);
fprintf (stderr, " maxsize: %zd\n", d->maxsize);
Plug some leaks Add maxsize to bufferdata in case the memory size can be variable such as with encoded formats. Copy new size in the proxy.
2016-09-30 19:56:41 +02:00
fprintf (stderr, " offset: %zd\n", d->offset);
fprintf (stderr, " size: %zd\n", d->size);
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++) {
Remove port Remove the port object. We don't use it as a dbus object and we don't need it, we can use the link and node object directy. Move poll code and event handler to the node.
2016-09-02 19:51:23 +02:00
if (i % 16 == 0)
printf ("%p: ", &t[i]);
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 ("%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;
improve format support
2016-08-26 20:26:34 +02:00
unsigned int first;
unsigned int last;
unsigned int idx;
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
} media_type_names[] = {
improve format support
2016-08-26 20:26:34 +02:00
{ "invalid", 0, 0, 0 },
{ "audio", SPA_MEDIA_SUBTYPE_AUDIO_FIRST, SPA_MEDIA_SUBTYPE_AUDIO_LAST, 16 },
{ "video", SPA_MEDIA_SUBTYPE_VIDEO_FIRST, SPA_MEDIA_SUBTYPE_VIDEO_LAST, 2 },
{ "image", 0, 0 },
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
};
struct media_subtype_name {
const char *name;
} media_subtype_names[] = {
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
{ "invalid" },
improve format support
2016-08-26 20:26:34 +02:00
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{ "raw" },
improve format support
2016-08-26 20:26:34 +02:00
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{ "h264" },
{ "mjpg" },
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
{ "dv" },
{ "mpegts" },
{ "h263" },
{ "mpeg1" },
{ "mpeg2" },
{ "mpeg4" },
{ "xvid" },
{ "vc1" },
{ "vp8" },
{ "vp9" },
{ "jpeg" },
{ "bayer" },
improve format support
2016-08-26 20:26:34 +02:00
Fix up audio formats as well
2016-08-26 19:22:50 +02:00
{ "mp3" },
{ "aac" },
improve format support
2016-08-26 20:26:34 +02:00
{ "vorbis" },
{ "wma" },
{ "ra" },
{ "sbc" },
{ "adpcm" },
{ "g723" },
{ "g726" },
{ "g729" },
{ "amr" },
{ "gsm" },
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
};
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
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
print_value (const SpaPropInfo *info, const SpaPropValue *val)
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{
SpaPropType type = info->type;
bool enum_string = false;
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
const void *enum_value;
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
if (info->range_type == SPA_PROP_RANGE_TYPE_ENUM) {
int i;
for (i = 0; i < info->n_range_values; i++) {
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
if (memcmp (info->range_values[i].val.value, val->value, val->size) == 0) {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
if (info->range_values[i].name) {
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
enum_value = info->range_values[i].name;
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
enum_string = true;
}
}
}
}
switch (type) {
case SPA_PROP_TYPE_INVALID:
fprintf (stderr, "invalid");
break;
case SPA_PROP_TYPE_BOOL:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%s", *(bool *)val->value ? "true" : "false");
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_INT8:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIi8, *(int8_t *)val->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_UINT8:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIu8, *(uint8_t *)val->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_INT16:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIi16, *(int16_t *)val->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_UINT16:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIu16, *(uint16_t *)val->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_INT32:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIi32, *(int32_t *)val->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:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIu32, *(uint32_t *)val->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_INT64:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIi64 "\n", *(int64_t *)val->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_UINT64:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%" PRIu64 "\n", *(uint64_t *)val->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_INT:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%d", *(int *)val->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_UINT:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%u", *(unsigned int *)val->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_FLOAT:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%f", *(float *)val->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_DOUBLE:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%g", *(double *)val->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_STRING:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "\"%s\"", (char *)val->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_RECTANGLE:
{
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
const SpaRectangle *r = val->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, "%"PRIu32"x%"PRIu32, r->width, r->height);
break;
}
case SPA_PROP_TYPE_FRACTION:
{
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
const SpaFraction *f = val->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, "%"PRIu32"/%"PRIu32, f->num, f->denom);
break;
}
case SPA_PROP_TYPE_BITMASK:
break;
case SPA_PROP_TYPE_POINTER:
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
fprintf (stderr, "%p", val->value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
default:
break;
}
Work on sink Remove _remove from properties, we can do the same with set of a NULL value. Add signals to the stream API to manage the buffers. Wrap those buffers in a GstBuffer in the pinossrc and pinossink elements and pool them in a bufferpool. Remove SPA_EVENT_TYPE_PULL_INPUT, we can do the same with NEED_INPUT and by using a ringbuffer. Do more complete allocation of buffers in the link. Use the buffer allocator if none of the nodes can allocate. Follow the node state to trigger negotiation and allocation. Remove offset and size when refering to buffers, we want to always deal with the complete buffer and use a ringbuffer for ranges or change the offset/size in the buffer data when needed. Serialize port_info structures as part of the port_update Print both the enum number and the name when debuging properties or formats.
2016-08-24 16:26:58 +02:00
if (enum_string)
fprintf (stderr, " (%s)", (char *)enum_value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
}
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];
use a dict for extra property info A dictionary is probably more extensible
2016-10-14 10:32:11 +02:00
fprintf (stderr, " %-20s flags: ", info->name);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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);
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
res = spa_props_get_value (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
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
fprintf (stderr, "Current: ");
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_OK)
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
print_value (info, &value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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 ", "");
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
print_value (info, &rinfo->val);
Remove description Documentation should go somewhere else
2016-10-13 19:25:49 +02:00
fprintf (stderr, "\t: %-12s\n", rinfo->name);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
}
}
use dictionary for extra port info
2016-10-14 10:42:02 +02:00
if (info->extra) {
fprintf (stderr, "Extra info: \n");
spa_debug_dict (info->extra);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
}
}
return SPA_RESULT_OK;
}
SpaResult
spa_debug_format (const SpaFormat *format)
{
const SpaProps *props;
improve format support
2016-08-26 20:26:34 +02:00
int i, first, last, idx;
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
const char *media_type;
const char *media_subtype;
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
if (format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
props = &format->props;
improve format support
2016-08-26 20:26:34 +02:00
if (format->media_type > 0 && format->media_type < SPA_N_ELEMENTS (media_type_names)) {
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
media_type = media_type_names[format->media_type].name;
improve format support
2016-08-26 20:26:34 +02:00
first = media_type_names[format->media_type].first;
last = media_type_names[format->media_type].last;
idx = media_type_names[format->media_type].idx;
}
else {
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
media_type = "unknown";
improve format support
2016-08-26 20:26:34 +02:00
idx = first = last = -1;
}
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
improve format support
2016-08-26 20:26:34 +02:00
if (format->media_subtype >= SPA_MEDIA_SUBTYPE_ANY_FIRST &&
format->media_subtype <= SPA_MEDIA_SUBTYPE_ANY_LAST) {
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
media_subtype = media_subtype_names[format->media_subtype].name;
improve format support
2016-08-26 20:26:34 +02:00
} else if (format->media_subtype >= first && format->media_subtype <= last)
media_subtype = media_subtype_names[format->media_subtype - first + idx].name;
Make new USE_BUFFERS command Make a new USE_BUFFERS command to atomically send a buffer array to the remote client. We can use this to then clean up an old array and go to the PAUSED state if possible. Work on formats. Make one structure that can hold all video formats. Work on pipeline suspend and resume. Add jpeg support to v4l2. Work on enum_formats with a filter in v4l2.
2016-08-26 17:43:48 +02:00
else
media_subtype = "unknown";
fprintf (stderr, "%-6s %s/%s\n", "", media_type, media_subtype);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
for (i = 0; i < props->n_prop_info; i++) {
const SpaPropInfo *info = &props->prop_info[i];
SpaPropValue value;
SpaResult res;
mem: remove memory stuff Remove the memory stuff from the spa API, we can do thing more simple and efficiently if we always allocate buffers outside of the plugins and only implement an alloc function on the node when it can do something clever. Move serialize code to the props/format/buffer code Make it possible to copy a format and properties.
2016-09-29 18:18:59 +02:00
res = spa_props_get_value (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
Cleanup audio format
2016-09-08 12:32:30 +02:00
if (info->flags & SPA_PROP_FLAG_INFO)
continue;
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) {
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
print_value (info, &value);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
} 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];
Add h264 format Improve format support Remove the type from the value because we can find that from the property info.
2016-09-07 16:25:31 +02:00
print_value (info, &rinfo->val);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
fprintf (stderr, "%s", j + 1 < info->n_range_values ? sep : "");
}
fprintf (stderr, esep);
} else {
fprintf (stderr, "*Error*");
}
fprintf (stderr, "\n");
}
return SPA_RESULT_OK;
}
Add monitor interface Add an interface to monitor devices and helper program Add v4l2 monitor Add simple dictionary with key/value pairs
2016-09-15 11:49:34 +02:00
SpaResult
spa_debug_dict (const SpaDict *dict)
{
unsigned int i;
if (dict == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < dict->n_items; i++)
fprintf (stderr, " %s = \"%s\"\n", dict->items[i].key, dict->items[i].value);
return SPA_RESULT_OK;
}
Reference in a new issue Copy permalink