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

581 lines
17 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>
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
#include "debug.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
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
static const struct meta_type_name {
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
const char *name;
} meta_type_names[] = {
{ "invalid" },
{ "SpaMetaHeader" },
{ "SpaMetaPointer" },
{ "SpaMetaVideoCrop" },
{ "SpaMetaRingbuffer" },
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
{ "SpaMetaShared" },
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
{ "invalid" },
};
#define META_TYPE_NAME(t) meta_type_names[SPA_CLAMP(t,0,SPA_N_ELEMENTS(meta_type_names)-1)].name
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
static const struct data_type_name {
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
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 Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
switch (p->type) {
case SPA_META_TYPE_RINGBUFFER:
{
SpaAllocParamMetaEnableRingbuffer *rb = (SpaAllocParamMetaEnableRingbuffer *)p;
fprintf (stderr, " minsize: \t\t%zd\n", rb->minsize);
fprintf (stderr, " stride: \t\t%zd\n", rb->stride);
fprintf (stderr, " blocks: \t\t%zd\n", rb->blocks);
fprintf (stderr, " align: \t\t%d\n", rb->align);
break;
}
default:
break;
}
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");
More hacking Move array and map to pinos Move more things to spa lib ControlCmd -> Message Make pinos log, use for plugins as well work on ringbuffer in alsa and nodes work on making registry with all objects
2016-11-03 19:41:53 +01:00
fprintf (stderr, " readindex: %zd\n", h->ringbuffer.readindex);
fprintf (stderr, " writeindex: %zd\n", h->ringbuffer.writeindex);
fprintf (stderr, " size: %zd\n", h->ringbuffer.size);
fprintf (stderr, " mask: %zd\n", h->ringbuffer.mask);
fprintf (stderr, " mask2: %zd\n", h->ringbuffer.mask2);
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
break;
}
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
case SPA_META_TYPE_SHARED:
{
SpaMetaShared *h = m->data;
fprintf (stderr, " SpaMetaShared:\n");
fprintf (stderr, " type: %d\n", h->type);
fprintf (stderr, " flags: %d\n", h->flags);
fprintf (stderr, " fd: %d\n", h->fd);
fprintf (stderr, " offset: %zd\n", h->offset);
fprintf (stderr, " size: %zd\n", h->size);
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);
Improve upload Only send a buffer when we have received a NEED_DATA message. Add a signal to pulla buffer from the sink. Restructure the sink to use a queue like the source and only push a buffer when we can. Improve SpaData. Offset and size should be between 0 and maxsize, make sure we clamp correctly when needed. node_process_output completes the processing of the output after receiving HAVE_OUTPUT for async elements. It instructs the node that it now can produce more output.
2016-12-20 16:51:57 +01:00
fprintf (stderr, " offset: %zd\n", d->mapoffset);
fprintf (stderr, " maxsize: %zu\n", d->maxsize);
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
fprintf (stderr, " chunk: %p\n", d->chunk);
fprintf (stderr, " offset: %zd\n", d->chunk->offset);
Improve upload Only send a buffer when we have received a NEED_DATA message. Add a signal to pulla buffer from the sink. Restructure the sink to use a queue like the source and only push a buffer when we can. Improve SpaData. Offset and size should be between 0 and maxsize, make sure we clamp correctly when needed. node_process_output completes the processing of the output after receiving HAVE_OUTPUT for async elements. It instructs the node that it now can produce more output.
2016-12-20 16:51:57 +01:00
fprintf (stderr, " size: %zu\n", d->chunk->size);
Rework buffer memory layout Move offset, size and stride to separate chunk structure that we can keep in shared memory. Add shared metadata type to hold the memory block holding the metadata.
2016-12-15 14:57:34 +01:00
fprintf (stderr, " stride: %zd\n", d->chunk->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
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
SpaResult
spa_debug_props (const SpaProps *props, bool print_ranges)
{
rework props with pod
2017-02-27 21:25:33 +01:00
spa_debug_pod (&props->pod);
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
return SPA_RESULT_OK;
}
static const char* media_audio_prop_names[] = {
"info",
"format",
"flags",
"layout",
"rate",
"channels",
"channel-mask",
};
static const char* media_video_prop_names[] = {
"info",
"format",
"size",
"framerate",
"max-framerate",
"views",
"interlace-mode",
"pixel-aspect-ratio",
"multiview-mode",
"multiview-flags",
"chroma-site",
"color-range",
"color-matrix",
"transfer-function",
"color-primaries",
"profile",
"stream-format",
"alignment",
};
static const struct media_type_name {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
const char *name;
improve format support
2016-08-26 20:26:34 +02:00
unsigned int first;
unsigned int last;
unsigned int idx;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
const char **prop_names;
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 },
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
{ "audio", SPA_MEDIA_SUBTYPE_AUDIO_FIRST, SPA_MEDIA_SUBTYPE_AUDIO_LAST, 16, media_audio_prop_names },
{ "video", SPA_MEDIA_SUBTYPE_VIDEO_FIRST, SPA_MEDIA_SUBTYPE_VIDEO_LAST, 2, media_video_prop_names },
improve format support
2016-08-26 20:26:34 +02:00
{ "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
};
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
static const struct media_subtype_name {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
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
};
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
struct pod_type_name {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
const char *name;
const char *CCName;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
} pod_type_names[] = {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{ "invalid", "*Invalid*" },
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
{ "bool", "Bool" },
intersection improvements Add uri type
2017-02-28 16:38:23 +01:00
{ "uri", "URI" },
Improve negotiation Fix selection of the default property value by restricting it to something in the valid range of the property. Fix audio/videotestsrc reuse Fix format enum with filters. Fix module property configuration Fix connection refill
2017-03-01 14:07:02 +01:00
{ "int", "Int" },
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
{ "long", "Long" },
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{ "float", "Float" },
{ "double", "Double" },
{ "string", "String" },
{ "rectangle", "Rectangle" },
{ "fraction", "Fraction" },
{ "bitmask", "Bitmask" },
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
{ "array", "Array" },
{ "struct", "Struct" },
{ "object", "Object" },
{ "prop", "Prop" },
{ "bytes", "Bytes" },
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
};
static void
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{
switch (type) {
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_BOOL:
printf ("%-*sBool %d\n", prefix, "", *(int32_t *) body);
break;
intersection improvements Add uri type
2017-02-28 16:38:23 +01:00
case SPA_POD_TYPE_URI:
printf ("%-*sURI %d\n", prefix, "", *(int32_t *) body);
break;
Improve negotiation Fix selection of the default property value by restricting it to something in the valid range of the property. Fix audio/videotestsrc reuse Fix format enum with filters. Fix module property configuration Fix connection refill
2017-03-01 14:07:02 +01:00
case SPA_POD_TYPE_INT:
printf ("%-*sInt %d\n", prefix, "", *(int32_t *) body);
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_LONG:
printf ("%-*sLong %"PRIi64"\n", prefix, "", *(int64_t *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_FLOAT:
printf ("%-*sFloat %f\n", prefix, "", *(float *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_DOUBLE:
printf ("%-*sDouble %g\n", prefix, "", *(double *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_STRING:
rework props with pod
2017-02-27 21:25:33 +01:00
printf ("%-*sString \"%s\"\n", prefix, "", (char *) body);
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
break;
case SPA_POD_TYPE_RECTANGLE:
{
SpaRectangle *r = body;
printf ("%-*sRectangle %dx%d\n", prefix, "", r->width, r->height);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
case SPA_POD_TYPE_FRACTION:
{
SpaFraction *f = body;
printf ("%-*sFraction %d/%d\n", prefix, "", f->num, f->denom);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
case SPA_POD_TYPE_BITMASK:
printf ("%-*sBitmask\n", prefix, "");
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_ARRAY:
{
SpaPODArrayBody *b = body;
void *p;
printf ("%-*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);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
case SPA_POD_TYPE_STRUCT:
{
SpaPOD *b = body, *p;
printf ("%-*sStruct: size %d\n", prefix, "", size);
Format: implement intersection and fixate
2017-02-28 15:09:34 +01:00
SPA_POD_FOREACH (b, size, p)
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
print_pod_value (p->size, p->type, SPA_POD_BODY (p), prefix + 2);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
case SPA_POD_TYPE_OBJECT:
{
SpaPODObjectBody *b = body;
SpaPODProp *p;
pod: make format like other PODs
2017-02-27 17:07:48 +01:00
printf ("%-*sObject: size %d\n", prefix, "", size);
SPA_POD_OBJECT_BODY_FOREACH (b, size, p)
print_pod_value (p->pod.size, p->pod.type, SPA_POD_BODY (p), prefix + 6);
break;
}
case SPA_POD_TYPE_PROP:
{
SpaPODPropBody *b = body;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
void *alt;
int i;
pod: make format like other PODs
2017-02-27 17:07:48 +01:00
printf ("%-*sProp: key %d, flags %d\n", prefix + 2, "", b->key, b->flags);
if (b->flags & SPA_POD_PROP_FLAG_UNSET)
printf ("%-*sUnset (Default):\n", prefix + 4, "");
else
printf ("%-*sValue:\n", prefix + 4, "");
print_pod_value (b->value.size, b->value.type, SPA_POD_BODY (&b->value), prefix + 6);
i = 0;
SPA_POD_PROP_ALTERNATIVE_FOREACH (b, size, alt) {
if (i == 0)
printf ("%-*sAlternatives:\n", prefix + 4, "");
print_pod_value (b->value.size, b->value.type, alt, prefix + 6);
i++;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
pod: fix padding
2017-03-01 20:00:11 +01:00
default:
printf ("unhandled prop type %d\n", type);
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
}
}
SpaResult
spa_debug_pod (const SpaPOD *pod)
{
print_pod_value (pod->size, pod->type, SPA_POD_BODY (pod), 0);
return SPA_RESULT_OK;
}
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");
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Improve negotiation Fix selection of the default property value by restricting it to something in the valid range of the property. Fix audio/videotestsrc reuse Fix format enum with filters. Fix module property configuration Fix connection refill
2017-03-01 14:07:02 +01:00
case SPA_POD_TYPE_URI:
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
fprintf (stderr, "%"PRIi32, *(int32_t *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Improve negotiation Fix selection of the default property value by restricting it to something in the valid range of the property. Fix audio/videotestsrc reuse Fix format enum with filters. Fix module property configuration Fix connection refill
2017-03-01 14:07:02 +01:00
case SPA_POD_TYPE_INT:
intersection improvements Add uri type
2017-02-28 16:38:23 +01:00
fprintf (stderr, "%"PRIi32, *(int32_t *) body);
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_LONG:
fprintf (stderr, "%"PRIi64, *(int64_t *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_FLOAT:
fprintf (stderr, "%f", *(float *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_DOUBLE:
fprintf (stderr, "%g", *(double *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_STRING:
fprintf (stderr, "%s", (char *) body);
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
break;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_RECTANGLE:
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
SpaRectangle *r = body;
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;
}
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_FRACTION:
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
{
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
SpaFraction *f = body;
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;
}
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_TYPE_BITMASK:
fprintf (stderr, "Bitmask");
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;
}
}
SpaResult
spa_debug_format (const SpaFormat *format)
{
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;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
const char **prop_names;
SpaPODProp *prop;
rework props with pod
2017-02-27 21:25:33 +01:00
uint32_t mtype, mstype;
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;
rework props with pod
2017-02-27 21:25:33 +01:00
mtype = format->body.media_type.value;
mstype = format->body.media_subtype.value;
if (mtype > 0 && mtype < SPA_N_ELEMENTS (media_type_names)) {
media_type = media_type_names[mtype].name;
first = media_type_names[mtype].first;
last = media_type_names[mtype].last;
idx = media_type_names[mtype].idx;
prop_names = media_type_names[mtype].prop_names;
improve format support
2016-08-26 20:26:34 +02:00
}
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;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
prop_names = NULL;
improve format support
2016-08-26 20:26:34 +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
rework props with pod
2017-02-27 21:25:33 +01:00
if (mstype >= SPA_MEDIA_SUBTYPE_ANY_FIRST &&
mstype <= SPA_MEDIA_SUBTYPE_ANY_LAST) {
media_subtype = media_subtype_names[mstype].name;
} else if (mstype >= first && mstype <= last)
media_subtype = media_subtype_names[mstype - 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
Format: implement intersection and fixate
2017-02-28 15:09:34 +01:00
SPA_FORMAT_FOREACH (format, prop) {
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
if ((prop->body.flags & SPA_POD_PROP_FLAG_UNSET) &&
(prop->body.flags & SPA_POD_PROP_FLAG_OPTIONAL))
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
continue;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
fprintf (stderr, " %20s : (%s) ", prop_names[prop->body.key - SPA_PROP_ID_MEDIA_CUSTOM_START], pod_type_names[prop->body.value.type].name);
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 {
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
const char *ssep, *esep, *sep;
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
void *alt;
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
switch (prop->body.flags & SPA_POD_PROP_RANGE_MASK) {
case SPA_POD_PROP_RANGE_MIN_MAX:
case SPA_POD_PROP_RANGE_STEP:
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
ssep = "[ ";
sep = ", ";
esep = " ]";
break;
default:
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
case SPA_POD_PROP_RANGE_ENUM:
case SPA_POD_PROP_RANGE_FLAGS:
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
ssep = "{ ";
sep = ", ";
esep = " }";
break;
}
fprintf (stderr, ssep);
Rework formats Use a POD for the format body. This allows us to more easily build and copy the formats. Remove obsolete code to make video and audio formats. Use SpaVideo/AudioInfo to keep track of formats. Make functions to parse the format into the structures. Update plugins
2017-02-24 09:28:18 +01:00
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++;
implement set_format Serialize the formats Use SpaMemoryRef where we can Add more debug
2016-08-04 17:33:49 +02:00
}
fprintf (stderr, esep);
}
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