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/include/spa/pod/builder.h

779 lines
24 KiB
C
Raw Normal View History

Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
/* Simple Plugin API
* Copyright (C) 2017 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_POD_BUILDER_H__
#define __SPA_POD_BUILDER_H__
#ifdef __cplusplus
extern "C" {
#endif
props: move prop builder to pod-builder.h
2017-02-26 19:52:21 +01:00
#include <stdarg.h>
Reorganise SPA tree Reorganise the SPA includes to make it more extensible later Simplify the naming of the buffer and meta params
2017-11-10 13:36:14 +01:00
#include <spa/pod/pod.h>
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
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
struct spa_pod_frame {
indent
2017-05-26 08:05:01 +02:00
struct spa_pod pod;
uint32_t ref;
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
};
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
struct spa_pod_builder_state {
uint32_t offset;
bool in_array;
bool first;
int depth;
};
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
struct spa_pod_builder {
indent
2017-05-26 08:05:01 +02:00
void *data;
uint32_t size;
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
uint32_t (*write) (struct spa_pod_builder *builder, const void *data, uint32_t size);
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
void * (*deref) (struct spa_pod_builder *builder, uint32_t ref, bool safe);
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
void (*reset) (struct spa_pod_builder *builder, struct spa_pod_builder_state *state);
struct spa_pod_builder_state state;
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
struct spa_pod_frame frame[SPA_POD_MAX_DEPTH];
spa: don't use typedef for struct and enum
2017-05-25 13:28:15 +02:00
};
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
Improve init functions spa_pod_id has uint32_t value
2017-11-23 12:38:37 +01:00
#define SPA_POD_BUILDER_INIT(buffer,size) (struct spa_pod_builder){ buffer, size, }
improve node io Unify input and output io areas. Add support for ranges in the io area. Automatically recycle buffers in the output areas in process_output Improve the mixer, add use_buffer support, use a queue of input buffers, fix mixing, add support for ranges. Fix mixer and v4l2 tests
2017-04-03 14:56:04 +02:00
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
static inline void
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
spa_pod_builder_get_state(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
{
*state = builder->state;
}
static inline void
spa_pod_builder_reset(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
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
{
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
if (builder->reset)
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
builder->reset(builder, state);
else
builder->state = *state;
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
}
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
static inline void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
{
Improve init functions spa_pod_id has uint32_t value
2017-11-23 12:38:37 +01:00
*builder = SPA_POD_BUILDER_INIT(data, size);
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
}
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
static inline void *
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_deref_checked(struct spa_pod_builder *builder, uint32_t ref, bool safe)
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
{
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
if (ref == SPA_ID_INVALID)
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
return NULL;
else if (builder->deref)
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return builder->deref(builder, ref, safe);
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
else if (ref + 8 <= builder->size) {
struct spa_pod *pod = SPA_MEMBER(builder->data, ref, struct spa_pod);
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
if (!safe || SPA_POD_SIZE(pod) <= builder->size)
Fix compiler issues with c++
2018-02-08 10:49:08 +01:00
return (void *) pod;
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
}
return NULL;
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
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
static inline void *
spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t ref)
{
return spa_pod_builder_deref_checked(builder, ref, false);
}
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_push(struct spa_pod_builder *builder,
const struct spa_pod *pod,
uint32_t ref)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
struct spa_pod_frame *frame = &builder->frame[builder->state.depth++];
indent
2017-05-26 08:05:01 +02:00
frame->pod = *pod;
frame->ref = ref;
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
builder->state.in_array = builder->state.first =
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
(pod->type == SPA_TYPE_Array || pod->type == SPA_TYPE_Choice);
indent
2017-05-26 08:05:01 +02:00
return ref;
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
indent
2017-05-26 08:05:01 +02:00
uint32_t ref;
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
int i;
indent
2017-05-26 08:05:01 +02:00
if (builder->write) {
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
ref = builder->write(builder, data, size);
indent
2017-05-26 08:05:01 +02:00
} else {
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
ref = builder->state.offset;
indent
2017-05-26 08:05:01 +02:00
if (ref + size > builder->size)
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
ref = SPA_ID_INVALID;
indent
2017-05-26 08:05:01 +02:00
else
Fix compiler issues with c++
2018-02-08 10:49:08 +01:00
memcpy(SPA_MEMBER(builder->data, ref, void), data, size);
indent
2017-05-26 08:05:01 +02:00
}
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
builder->state.offset += size;
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
for (i = 0; i < builder->state.depth; i++)
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
builder->frame[i].pod.size += size;
indent
2017-05-26 08:05:01 +02:00
return ref;
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
client-node: split setup of transport and fds We can initialize the transport as soon as we get async notify from the client when setup completes. Node initialization happens after that and then finaly the node is initialized and we can send the transport and fds. Small cleanups
2017-10-25 16:47:43 +02:00
static inline void spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
Improve padding Write out 0 while padding to make sure all memory is initialized Remove the fd from the loop before destroying the node.
2017-03-09 09:48:41 +01:00
{
indent
2017-05-26 08:05:01 +02:00
uint64_t zeroes = 0;
size = SPA_ROUND_UP_N(size, 8) - size;
if (size)
spa_pod_builder_raw(builder, &zeroes, size);
Improve padding Write out 0 while padding to make sure all memory is initialized Remove the fd from the loop before destroying the node.
2017-03-09 09:48:41 +01:00
}
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
uint32_t ref = size ? spa_pod_builder_raw(builder, data, size) : SPA_ID_INVALID;
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_pad(builder, size);
return ref;
Improve padding Write out 0 while padding to make sure all memory is initialized Remove the fd from the loop before destroying the node.
2017-03-09 09:48:41 +01:00
}
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
static inline void *spa_pod_builder_pop(struct spa_pod_builder *builder)
Improve padding Write out 0 while padding to make sure all memory is initialized Remove the fd from the loop before destroying the node.
2017-03-09 09:48:41 +01:00
{
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
struct spa_pod_frame *frame, *top;
struct spa_pod *pod;
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
frame = &builder->frame[--builder->state.depth];
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
if ((pod = (struct spa_pod *) spa_pod_builder_deref_checked(builder, frame->ref, true)) != NULL)
Implement param filtering Make a new pod filter function and use it in the plugins to filter in enum_params. Small tweaks to the pod_builder
2017-11-09 17:07:04 +01:00
*pod = frame->pod;
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
top = builder->state.depth > 0 ? &builder->frame[builder->state.depth-1] : NULL;
builder->state.in_array = (top &&
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
(top->pod.type == SPA_TYPE_Array || top->pod.type == SPA_TYPE_Choice));
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
spa_pod_builder_pad(builder, builder->state.offset);
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
builder: make deref safer Don't try to deref objects that did not fit into the memory. Deref now returns the object
2017-11-13 11:50:50 +01:00
return pod;
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_TYPE_Collect 0x100
struct spa_pod_collect {
struct spa_pod pod;
struct spa_pod child;
const void *value;
};
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const void *head, *body;
uint32_t head_size, body_size, ref;
bool collect = p->type == SPA_TYPE_Collect;
if (collect) {
struct spa_pod_collect *col = (struct spa_pod_collect *)p;
head = &col->child;
head_size = sizeof(struct spa_pod);
body = col->value;
} else {
head = p;
head_size = SPA_POD_SIZE(p);
body = SPA_POD_BODY_CONST(p);
}
body_size = SPA_POD_BODY_SIZE(head);
indent
2017-05-26 08:05:01 +02:00
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
if (builder->state.in_array && !builder->state.first) {
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
head = body;
head_size = body_size;
collect = false;
indent
2017-05-26 08:05:01 +02:00
} else {
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
builder->state.first = false;
indent
2017-05-26 08:05:01 +02:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
ref = spa_pod_builder_raw(builder, head, head_size);
if (ref != SPA_ID_INVALID && collect) {
ref = spa_pod_builder_raw(builder, body, body_size);
head_size += body_size;
}
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
if (!builder->state.in_array)
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_pad(builder, head_size);
indent
2017-05-26 08:05:01 +02:00
return ref;
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_INIT(size,type) (struct spa_pod) { size, type }
#define SPA_POD_None() SPA_POD_INIT(0, SPA_TYPE_None)
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
static inline uint32_t spa_pod_builder_none(struct spa_pod_builder *builder)
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod p = SPA_POD_None();
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
return spa_pod_builder_primitive(builder, &p);
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Bool(val) (struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, val ? 1 : 0, 0 }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
indent
2017-05-26 08:05:01 +02:00
static inline uint32_t spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_bool p = SPA_POD_Bool(val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Id(val) (struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, val, 0 }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
static inline uint32_t spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
intersection improvements Add uri type
2017-02-28 16:38:23 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_id p = SPA_POD_Id(val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
intersection improvements Add uri type
2017-02-28 16:38:23 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Int(val) (struct spa_pod_int){ { sizeof(uint32_t), SPA_TYPE_Int }, val, 0 }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
indent
2017-05-26 08:05:01 +02:00
static inline uint32_t spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_int p = SPA_POD_Int(val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Long(val) (struct spa_pod_long){ { sizeof(uint64_t), SPA_TYPE_Long }, val }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
indent
2017-05-26 08:05:01 +02:00
static inline uint32_t spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_long p = SPA_POD_Long(val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Float(val) (struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, val }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
indent
2017-05-26 08:05:01 +02:00
static inline uint32_t spa_pod_builder_float(struct spa_pod_builder *builder, float val)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_float p = SPA_POD_Float(val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Double(val) (struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, val }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
indent
2017-05-26 08:05:01 +02:00
static inline uint32_t spa_pod_builder_double(struct spa_pod_builder *builder, double val)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_double p = SPA_POD_Double(val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Stringv(str) \
(struct spa_pod_collect) \
{ { 0, SPA_TYPE_Collect }, { strlen(str)+1, SPA_TYPE_String }, str }
#define SPA_POD_String(str, len) \
(struct spa_pod_collect) \
{ { 0, SPA_TYPE_Collect }, { len, SPA_TYPE_String }, str }
#define SPA_POD_Stringc(str) \
(struct { struct spa_pod_string pod; char val[sizeof(str)]; }) \
{ { { sizeof(str), SPA_TYPE_String } }, { str } }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
static inline uint32_t
spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
{
uint32_t ref = 0;
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
if (spa_pod_builder_raw(builder, str, len) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
if (spa_pod_builder_raw(builder, "", 1) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
builder: make methods to save and restore state
2017-11-13 12:30:48 +01:00
spa_pod_builder_pad(builder, builder->state.offset);
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
return ref;
}
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_string p = { { len + 1, SPA_TYPE_String } };
indent
2017-05-26 08:05:01 +02:00
uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p));
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
if (spa_pod_builder_write_string(builder, str, len) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
indent
2017-05-26 08:05:01 +02:00
return ref;
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
indent
2017-05-26 08:05:01 +02:00
static inline uint32_t spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
{
indent
2017-05-26 08:05:01 +02:00
uint32_t len = str ? strlen(str) : 0;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
return spa_pod_builder_string_len(builder, str ? str : "", len);
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Bytes(len) (struct spa_pod_bytes){ { len, SPA_TYPE_Bytes } }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_bytes p = SPA_POD_Bytes(len);
indent
2017-05-26 08:05:01 +02:00
uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p));
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
if (spa_pod_builder_raw_padded(builder, bytes, len) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
indent
2017-05-26 08:05:01 +02:00
return ref;
Rework serialization Move serialization to the protocol, we now just send blocks of bytes over the connection and let the protocol deserialize them.
2017-03-06 15:48:04 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Pointer(type,value) (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { type, value } }
monitor: use dynamic types Make the monitor item a POD object and use dynamic types.
2017-03-23 08:54:04 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, void *val)
monitor: use dynamic types Make the monitor item a POD object and use dynamic types.
2017-03-23 08:54:04 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_pointer p = SPA_POD_Pointer(type, val);
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
monitor: use dynamic types Make the monitor item a POD object and use dynamic types.
2017-03-23 08:54:04 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Fd(fd) (struct spa_pod_fd){ { sizeof(int), SPA_TYPE_Fd }, fd }
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
static inline uint32_t spa_pod_builder_fd(struct spa_pod_builder *builder, int fd)
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_fd p = SPA_POD_Fd(fd);
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Rectangle(val) (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, val }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_rectangle p = SPA_POD_Rectangle(SPA_RECTANGLE(width, height));
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Fraction(val) (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, val }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_fraction p = SPA_POD_Fraction(SPA_FRACTION(num, denom));
indent
2017-05-26 08:05:01 +02:00
return spa_pod_builder_primitive(builder, &p.pod);
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
More work on multichannel Reorder channels to a more common default order. Only add channel layout when channels > 1 Don't try to link to a session that is still starting Small sse fixes.
2018-09-14 15:23:12 +02:00
#define SPA_POD_Array(ctype, child_type, n_vals, ...) \
(struct { struct spa_pod_array array; ctype vals[n_vals];}) \
{ { { n_vals * sizeof(ctype) + sizeof(struct spa_pod_array_body), SPA_TYPE_Array }, \
{ { sizeof(ctype), child_type } } }, { __VA_ARGS__ } }
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
spa_pod_builder_push_array(struct spa_pod_builder *builder)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
indent
2017-05-26 08:05:01 +02:00
const struct spa_pod_array p =
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
{ {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_TYPE_Array},
indent
2017-05-26 08:05:01 +02:00
{{0, 0}} };
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
return spa_pod_builder_push(builder, &p.pod,
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_raw(builder, &p,
sizeof(p) - sizeof(struct spa_pod)));
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_array(struct spa_pod_builder *builder,
uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
indent
2017-05-26 08:05:01 +02:00
const struct spa_pod_array p = {
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
{(uint32_t)(sizeof(struct spa_pod_array_body) + n_elems * child_size), SPA_TYPE_Array},
indent
2017-05-26 08:05:01 +02:00
{{child_size, child_type}}
};
uint32_t ref = spa_pod_builder_raw(builder, &p, sizeof(p));
fix some signed vs unsigned comparisons
2018-02-20 18:19:11 +01:00
if (spa_pod_builder_raw_padded(builder, elems, child_size * n_elems) == SPA_ID_INVALID)
ref = SPA_ID_INVALID;
indent
2017-05-26 08:05:01 +02:00
return ref;
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_CHOICE_BODY_INIT(type, flags, child_size, child_type) \
(struct spa_pod_choice_body) { type, flags, { child_size, child_type }}
#define SPA_POD_Choice(type, ctype, child_type, n_vals, ...) \
(struct { struct spa_pod_choice choice; ctype vals[n_vals];}) \
{ { { n_vals * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice }, \
{ type, 0, { sizeof(ctype), child_type } } }, { __VA_ARGS__ } }
static inline uint32_t
spa_pod_builder_push_choice(struct spa_pod_builder *builder, uint32_t type, uint32_t flags)
{
const struct spa_pod_choice p =
{ {sizeof(struct spa_pod_choice_body) - sizeof(struct spa_pod), SPA_TYPE_Choice},
{ type, flags, {0, 0}} };
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p,
sizeof(p) - sizeof(struct spa_pod)));
}
#define SPA_POD_Struct(size) (struct spa_pod_struct){ { size, SPA_TYPE_Struct } }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
spa_pod_builder_push_struct(struct spa_pod_builder *builder)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct spa_pod_struct p = SPA_POD_Struct(0);
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
return spa_pod_builder_push(builder, &p.pod,
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_raw(builder, &p, sizeof(p)));
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Object(size,type,id,...) (struct spa_pod_object){ { size, SPA_TYPE_Object }, { type, id }, ##__VA_ARGS__ }
spa: make events and commands as objects So we can serialize and introspect them more easily
2017-03-15 16:21:05 +01:00
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
spa_pod_builder_push_object(struct spa_pod_builder *builder, uint32_t type, uint32_t id)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
indent
2017-05-26 08:05:01 +02:00
const struct spa_pod_object p =
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
SPA_POD_Object(sizeof(struct spa_pod_object_body), type, id);
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
return spa_pod_builder_push(builder, &p.pod,
indent
2017-05-26 08:05:01 +02:00
spa_pod_builder_raw(builder, &p, sizeof(p)));
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Prop(key,flags,size,type) \
(struct spa_pod_prop){ key, flags, { size, type } }
improve props test
2017-05-26 20:52:04 +02:00
Use types with known sizes where we can, easier to serialize Add iterator for POD and use it to implement some demarshalling.
2017-03-07 11:56:43 +01:00
static inline uint32_t
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
const struct { uint32_t key; uint32_t flags; } p = { key, flags };
return spa_pod_builder_raw(builder, &p, sizeof(p));
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_Sequence(size,unit,...) \
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
(struct spa_pod_sequence){ { size, SPA_TYPE_Sequence}, {unit, 0 }, ##__VA_ARGS__ }
static inline uint32_t
spa_pod_builder_push_sequence(struct spa_pod_builder *builder, uint32_t unit)
{
const struct spa_pod_sequence p =
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
SPA_POD_Sequence(sizeof(struct spa_pod_sequence_body), unit);
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
return spa_pod_builder_push(builder, &p.pod,
spa_pod_builder_raw(builder, &p, sizeof(p)));
}
static inline uint32_t
spa_pod_builder_control_header(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
{
const struct { uint32_t offset; uint32_t type; } p = { offset, type };
return spa_pod_builder_raw(builder, &p, sizeof(p));
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
static inline uint32_t spa_choice_from_id(char id)
pod-builder: make more generic builder Make a vararg based builder that produces much smaller code. Catch demarshal errors. Simplify array handling
2017-03-07 17:23:35 +01:00
{
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
switch (id) {
case 'r':
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return SPA_CHOICE_Range;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
case 's':
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return SPA_CHOICE_Step;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
case 'e':
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return SPA_CHOICE_Enum;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
case 'f':
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return SPA_CHOICE_Flags;
case 'n':
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
default:
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return SPA_CHOICE_None;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
}
}
#define SPA_POD_BUILDER_COLLECT(builder,type,args) \
do { \
switch (type) { \
case 'b': \
spa_pod_builder_bool(builder, va_arg(args, int)); \
break; \
case 'I': \
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_id(builder, va_arg(args, uint32_t)); \
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
break; \
case 'i': \
spa_pod_builder_int(builder, va_arg(args, int)); \
break; \
case 'l': \
spa_pod_builder_long(builder, va_arg(args, int64_t)); \
break; \
case 'f': \
spa_pod_builder_float(builder, va_arg(args, double)); \
break; \
case 'd': \
spa_pod_builder_double(builder, va_arg(args, double)); \
break; \
case 's': \
{ \
Add support for NULL strings
2017-10-17 12:16:53 +02:00
char *strval = va_arg(args, char *); \
if (strval != NULL) { \
size_t len = strlen(strval); \
spa_pod_builder_string_len(builder, strval, len); \
} \
else \
spa_pod_builder_none(builder); \
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
break; \
} \
case 'S': \
{ \
char *strval = va_arg(args, char *); \
size_t len = va_arg(args, int); \
spa_pod_builder_string_len(builder, strval, len); \
break; \
} \
case 'z': \
{ \
void *ptr = va_arg(args, void *); \
int len = va_arg(args, int); \
spa_pod_builder_bytes(builder, ptr, len); \
break; \
} \
case 'R': \
{ \
struct spa_rectangle *rectval = \
va_arg(args, struct spa_rectangle *); \
spa_pod_builder_rectangle(builder, \
rectval->width, rectval->height); \
break; \
} \
case 'F': \
{ \
struct spa_fraction *fracval = \
va_arg(args, struct spa_fraction *); \
spa_pod_builder_fraction(builder, fracval->num, fracval->denom);\
break; \
} \
case 'a': \
{ \
int child_size = va_arg(args, int); \
int child_type = va_arg(args, int); \
int n_elems = va_arg(args, int); \
void *elems = va_arg(args, void *); \
spa_pod_builder_array(builder, child_size, \
child_type, n_elems, elems); \
break; \
} \
case 'p': \
{ \
int t = va_arg(args, uint32_t); \
spa_pod_builder_pointer(builder, t, va_arg(args, void *)); \
break; \
} \
case 'h': \
spa_pod_builder_fd(builder, va_arg(args, int)); \
break; \
case 'P': \
{ \
struct spa_pod *pod = va_arg(args, struct spa_pod *); \
if (pod == NULL) \
spa_pod_builder_none(builder); \
else \
spa_pod_builder_primitive(builder, pod); \
break; \
} \
} \
} while(false)
static inline void *
spa_pod_builder_addv(struct spa_pod_builder *builder,
Use errno for result errors Make new enumeration for data transport status and use errno style error numbers for errors.
2017-11-13 09:41:41 +01:00
const char *format, va_list args)
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
{
while (format) {
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
int n_values = 1;
bool do_pop = false;
switch (*format) {
pod: use {} as object delimited, like json Use <> for sequence
2018-08-30 09:53:29 +02:00
case '{':
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
{
uint32_t type = va_arg(args, uint32_t);
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
uint32_t id = va_arg(args, uint32_t);
spa_pod_builder_push_object(builder, type, id);
indent
2017-05-26 08:05:01 +02:00
break;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
}
case '[':
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
spa_pod_builder_push_struct(builder);
indent
2017-05-26 08:05:01 +02:00
break;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
case '(':
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
spa_pod_builder_push_array(builder);
indent
2017-05-26 08:05:01 +02:00
break;
pod: use {} as object delimited, like json Use <> for sequence
2018-08-30 09:53:29 +02:00
case '<':
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
{
uint32_t unit = va_arg(args, uint32_t);
spa_pod_builder_push_sequence(builder, unit);
break;
}
case '.':
{
uint32_t offset = va_arg(args, uint32_t);
uint32_t type = va_arg(args, uint32_t);
spa_pod_builder_control_header(builder, offset, type);
break;
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
case '?':
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
{
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
uint32_t choice, flags = 0;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
format++;
choice = spa_choice_from_id(*format);
pod: add info property flag Add an info property flag that should not be taken into account when intersecting. We use this for docs and labels. Improve builder, make it possible to make struct properties with flags. Add some docs to the property flags and ranges.
2017-12-15 16:25:46 +01:00
if (*format != '\0')
format++;
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
spa_pod_builder_push_choice(builder, choice, flags);
builder: fix format parsing We completely parse the format for props, make sure we read the next format string in the next iteration.
2017-12-04 17:27:21 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
n_values = va_arg(args, int);
do_pop = true;
goto do_collect;
}
case ':':
{
remove property flags Remove the property flags, we will add info about properties with the param interface.
2018-09-28 17:44:14 +02:00
uint32_t key;
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
key = va_arg(args, uint32_t);
remove property flags Remove the property flags, we will add info about properties with the param interface.
2018-09-28 17:44:14 +02:00
spa_pod_builder_prop(builder, key, 0);
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
break;
indent
2017-05-26 08:05:01 +02:00
}
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
case ']': case ')': case '>': case '}':
clean up pod_builder Remove the frame argument from the builder, we can use the builder allocated frames. Add deref function to builder to make it more flexible later. Add some more recursion depth checks in the parser. Improve props filter, also filter other types.
2017-11-08 15:48:31 +01:00
spa_pod_builder_pop(builder);
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
break;
case ' ': case '\n': case '\t': case '\r':
break;
case '\0':
format = va_arg(args, const char *);
continue;
default:
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
do_collect:
while (n_values-- > 0)
SPA_POD_BUILDER_COLLECT(builder, *format, args);
if (do_pop)
spa_pod_builder_pop(builder);
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
break;;
indent
2017-05-26 08:05:01 +02:00
}
pod: add info property flag Add an info property flag that should not be taken into account when intersecting. We use this for docs and labels. Improve builder, make it possible to make struct properties with flags. Add some docs to the property flags and ranges.
2017-12-15 16:25:46 +01:00
if (*format != '\0')
format++;
indent
2017-05-26 08:05:01 +02:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
return spa_pod_builder_deref_checked(builder, builder->frame[builder->state.depth].ref,true);
pod-builder: make more generic builder Make a vararg based builder that produces much smaller code. Catch demarshal errors. Simplify array handling
2017-03-07 17:23:35 +01:00
}
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
static inline void *spa_pod_builder_add(struct spa_pod_builder *builder, const char *format, ...)
pod-builder: make more generic builder Make a vararg based builder that produces much smaller code. Catch demarshal errors. Simplify array handling
2017-03-07 17:23:35 +01:00
{
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
void *res;
indent
2017-05-26 08:05:01 +02:00
va_list args;
pod-builder: make more generic builder Make a vararg based builder that produces much smaller code. Catch demarshal errors. Simplify array handling
2017-03-07 17:23:35 +01:00
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
va_start(args, format);
res = spa_pod_builder_addv(builder, format, args);
indent
2017-05-26 08:05:01 +02:00
va_end(args);
pod-builder: make more generic builder Make a vararg based builder that produces much smaller code. Catch demarshal errors. Simplify array handling
2017-03-07 17:23:35 +01:00
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
return res;
}
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
More test
2018-09-05 17:23:14 +02:00
static inline void spa_pod_builder_prop_val(struct spa_pod_builder *builder,
uint32_t key, void *pod)
{
spa_pod_builder_prop(builder, key, 0);
Fix build with c++ compilers
2018-10-30 12:37:14 +00:00
spa_pod_builder_primitive(builder,(const struct spa_pod *) pod);
More test
2018-09-05 17:23:14 +02:00
}
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
static inline void spa_pod_builder_propsv(struct spa_pod_builder *builder,
uint32_t key, va_list args)
{
while (key) {
More test
2018-09-05 17:23:14 +02:00
spa_pod_builder_prop_val(builder, key, va_arg(args, struct spa_pod *));
key = va_arg(args, uint32_t);
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
}
}
static inline void spa_pod_builder_props(struct spa_pod_builder *builder, uint32_t key, ...)
{
va_list args;
va_start(args, key);
spa_pod_builder_propsv(builder, key, args);
va_end(args);
}
static inline void *spa_pod_builder_object(struct spa_pod_builder *builder,
uint32_t type, uint32_t id, uint32_t key, ...)
{
va_list args;
spa_pod_builder_push_object(builder, type, id);
va_start(args, key);
spa_pod_builder_propsv(builder, key, args);
va_end(args);
return spa_pod_builder_pop(builder);
}
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
#define SPA_POD_OBJECT(type,id,...) \
pod: use {} as object delimited, like json Use <> for sequence
2018-08-30 09:53:29 +02:00
"{", type, id, ##__VA_ARGS__, "}"
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
#define SPA_POD_STRUCT(...) \
"[", ##__VA_ARGS__, "]"
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_POD_PROP(key,spec,value,...) \
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
":", key, spec, value, ##__VA_ARGS__
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
#define SPA_POD_SEQUENCE(unit,...) \
pod: use {} as object delimited, like json Use <> for sequence
2018-08-30 09:53:29 +02:00
"<", unit, ##__VA_ARGS__, ">"
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
#define SPA_POD_CONTROL(offset,type,...) \
".", offset, type, ##__VA_ARGS__
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define spa_pod_builder_add_object(b,type,id,...) \
More type cleanups SPA_ID_* -> SPA_TYPE_*. We use 'type' for all registered types. ID refers to either a registered type or an enum. Improve introspection of object ids. Make 0 an invalid enum and use it to look up the object id type. Move some type-info files together. Swap type and id of the object, we first specify the type and then the id because the meaning of the id depends on the object type.
2018-08-27 15:03:11 +02:00
spa_pod_builder_add(b, SPA_POD_OBJECT(type,id,##__VA_ARGS__), NULL)
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define spa_pod_builder_add_struct(b,...) \
Add new pod parser and builder Add a new pod builder and parser that is less verbose and a little more powerful.
2017-09-21 18:57:41 +02:00
spa_pod_builder_add(b, SPA_POD_STRUCT(__VA_ARGS__), NULL)
Make AllocParams into POD objects Make allocparams into pod objects. This makes it easy to serialize, copy, create and intersect them. Add convenience macros for properties Add helper function to collect object properties.
2017-03-17 11:58:09 +01:00
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define spa_pod_builder_add_sequence(b,unit,...) \
Implement control streams spa_io_control_range -> spa_io_range Add helpers for sequence and control pod objects Implement control properties in audiotestsrc, update test example.
2018-08-28 18:16:41 +02:00
spa_pod_builder_add(b, SPA_POD_SEQUENCE(unit,__VA_ARGS__), NULL)
Type changes Only allow properties inside objects, this makes it easier to iterate the object, which is needed for efficiently processing control streams. Add a choice type to mark variable properties. SPA_TYPE_Enum -> SPA_TYPE_Id to avoid confusion with choice enum Make it easier to allocate and initialize properties on the stack Make more efficient methods to make objects.
2018-09-05 16:41:07 +02:00
#define SPA_CHOICE_RANGE(def,min,max) 3,(def),(min),(max)
#define SPA_CHOICE_STEP(def,min,max,step) 4,(def),(min),(max),(step)
#define SPA_CHOICE_ENUM(n_vals,...) (n_vals),__VA_ARGS__
#define SPA_CHOICE_BOOL(def) 3,(def),(def),!(def)
#define SPA_POD_CHOICE_Bool(def) \
SPA_POD_Choice(SPA_CHOICE_Enum, int32_t, SPA_TYPE_Bool, 3, (def), (def), !(def))
#define SPA_POD_CHOICE_Int(type, n_vals, ...) \
SPA_POD_Choice(type, uint32_t, SPA_TYPE_Int, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Int(n_vals, ...) \
SPA_POD_CHOICE_Int(SPA_CHOICE_Enum, SPA_CHOICE_ENUM(n_vals, __VA_ARGS__))
#define SPA_POD_CHOICE_RANGE_Int(def, min, max) \
SPA_POD_CHOICE_Int(SPA_CHOICE_Range, SPA_CHOICE_RANGE(def, min, max))
#define SPA_POD_CHOICE_STEP_Int(def, min, max, step) \
SPA_POD_CHOICE_Int(SPA_CHOICE_Step, SPA_CHOICE_STEP(def, min, max, step))
#define SPA_POD_CHOICE_Id(type, n_vals, ...) \
SPA_POD_Choice(type, uint32_t, SPA_TYPE_Id, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Id(n_vals, ...) \
SPA_POD_CHOICE_Id(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_Float(type, n_vals, ...) \
SPA_POD_Choice(type, float, SPA_TYPE_Float, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Float(n_vals, ...) \
SPA_POD_CHOICE_Float(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Float(def, min, max) \
SPA_POD_CHOICE_Float(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Float(def, min, max, step) \
SPA_POD_CHOICE_Float(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_CHOICE_Double(type, n_vals, ...) \
SPA_POD_Choice(type, double, SPA_TYPE_Double, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Double(n_vals, ...) \
SPA_POD_CHOICE_Double(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Double(def, min, max) \
SPA_POD_CHOICE_Double(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Double(def, min, max, step) \
SPA_POD_CHOICE_Double(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_CHOICE_Rectangle(type, n_vals, ...) \
SPA_POD_Choice(type, struct spa_rectangle, SPA_TYPE_Rectangle, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Rectangle(n_vals, ...) \
SPA_POD_CHOICE_Rectangle(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Rectangle(def, min, max) \
SPA_POD_CHOICE_Rectangle(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Rectangle(def, min, max, step) \
SPA_POD_CHOICE_Rectangle(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
#define SPA_POD_CHOICE_Fraction(type, n_vals, ...) \
SPA_POD_Choice(type, struct spa_fraction, SPA_TYPE_Fraction, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_ENUM_Fraction(n_vals, ...) \
SPA_POD_CHOICE_Fraction(SPA_CHOICE_Enum, n_vals, __VA_ARGS__)
#define SPA_POD_CHOICE_RANGE_Fraction(def, min, max) \
SPA_POD_CHOICE_Fraction(SPA_CHOICE_Range, 3, (def), (min), (max))
#define SPA_POD_CHOICE_STEP_Fraction(def, min, max, step) \
SPA_POD_CHOICE_Fraction(SPA_CHOICE_Step, 4, (def), (min), (max), (step))
Add POD helper objects POD (plain old data) objects are similar to LV2 Atoms and allows storage and construction of datastructures in memory or on the stack. They can be copied with a simple memcpy. The idea is to use this to construct the network messages and to replace the structures used for describing formats and properties.
2017-02-22 13:12:32 +01:00
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_POD_BUILDER_H__ */
Reference in a new issue Copy permalink