5#ifndef SPA_POD_BUILDER_H 
    6#define SPA_POD_BUILDER_H 
   27#ifndef SPA_API_POD_BUILDER 
   29  #define SPA_API_POD_BUILDER SPA_API_IMPL 
   31  #define SPA_API_POD_BUILDER static inline 
   37#define SPA_POD_BUILDER_FLAG_BODY       (1<<0) 
   38#define SPA_POD_BUILDER_FLAG_FIRST      (1<<1) 
   46#define SPA_VERSION_POD_BUILDER_CALLBACKS 0 
 
   60#define SPA_POD_BUILDER_INIT(buffer,size)  ((struct spa_pod_builder){ (buffer), (size), 0, {0,0,NULL},{NULL,NULL}}) 
 
   80        builder->
state = *state;
 
   94        if (offset + 8 <= 
size) {
 
 
  131        size_t data_offset = -1;
 
 
  142                                        overflow, 0, 
offset + size);
 
  144        if (
res == 0 && data) {
 
  145                if (data_offset != (
size_t) -1)
 
 
  214#define SPA_POD_INIT(size,type) ((struct spa_pod) { (size), (type) }) 
  216#define SPA_POD_INIT_None() SPA_POD_INIT(0, SPA_TYPE_None) 
 
  231#define SPA_POD_INIT_Bool(val) ((struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, (val) ? 1 : 0, 0 }) 
  239#define SPA_POD_INIT_Id(val) ((struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (val), 0 }) 
 
  247#define SPA_POD_INIT_Int(val) ((struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (val), 0 }) 
  255#define SPA_POD_INIT_Long(val) ((struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (val) }) 
  263#define SPA_POD_INIT_Float(val) ((struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, (val), 0 }) 
  271#define SPA_POD_INIT_Double(val) ((struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, (val) }) 
  279#define SPA_POD_INIT_String(len) ((struct spa_pod_string){ { (len), SPA_TYPE_String } }) 
 
  305        uint32_t len = str ? strlen(str) : 0;
 
  309#define SPA_POD_INIT_Bytes(len) ((struct spa_pod_bytes){ { (len), SPA_TYPE_Bytes } }) 
 
  339                const void *data, uint32_t size)
 
 
  354#define SPA_POD_INIT_Pointer(type,value) ((struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { (type), 0, (value) } }) 
 
  363#define SPA_POD_INIT_Fd(fd) ((struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, (fd) }) 
 
  371#define SPA_POD_INIT_Rectangle(val) ((struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, (val) }) 
 
  380#define SPA_POD_INIT_Fraction(val) ((struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, (val) }) 
 
  403                      uint32_t child_size, uint32_t child_type, uint32_t n_elems, 
const void *elems)
 
 
  407                {{child_size, child_type}}
 
  415#define SPA_POD_INIT_CHOICE_BODY(type, flags, child_size, child_type)                           \ 
  416        ((struct spa_pod_choice_body) { (type), (flags), { (child_size), (child_type) }}) 
  418#define SPA_POD_INIT_Choice(type, ctype, child_type, n_vals, ...)                               \ 
  419        ((struct { struct spa_pod_choice choice; ctype vals[(n_vals)];})                        \ 
  420        { { { (n_vals) * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice }, \ 
  421                { (type), 0, { sizeof(ctype), (child_type) } } }, { __VA_ARGS__ } }) 
  425                uint32_t type, uint32_t flags)
 
 
  436#define SPA_POD_INIT_Struct(size) ((struct spa_pod_struct){ { (size), SPA_TYPE_Struct } }) 
 
  448#define SPA_POD_INIT_Object(size,type,id,...)   ((struct spa_pod_object){ { (size), SPA_TYPE_Object }, { (type), (id) }, ##__VA_ARGS__ }) 
  452                uint32_t type, uint32_t 
id)
 
 
  462#define SPA_POD_INIT_Prop(key,flags,size,type)  \ 
  463        ((struct spa_pod_prop){ (key), (flags), { (size), (type) } }) 
  468        const struct { uint32_t key; uint32_t flags; } p = { key, flags };
 
  472#define SPA_POD_INIT_Sequence(size,unit)        \ 
  473        ((struct spa_pod_sequence){ { (size), SPA_TYPE_Sequence}, {(unit), 0 } }) 
 
  489        const struct { uint32_t offset; uint32_t type; } p = { offset, type };
 
  510#define SPA_POD_BUILDER_COLLECT(builder,type,args)                              \ 
 
  514                spa_pod_builder_bool(builder, !!va_arg(args, int));             \ 
  517                spa_pod_builder_id(builder, va_arg(args, uint32_t));            \ 
 
  520                spa_pod_builder_int(builder, va_arg(args, int));                \ 
  523                spa_pod_builder_long(builder, va_arg(args, int64_t));           \ 
  526                spa_pod_builder_float(builder, (float)va_arg(args, double));    \ 
  529                spa_pod_builder_double(builder, va_arg(args, double));          \ 
  533                char *strval = va_arg(args, char *);                            \ 
  534                if (strval != NULL) {                                           \ 
  535                        size_t len = strlen(strval);                            \ 
  536                        spa_pod_builder_string_len(builder, strval, len);       \ 
 
  539                        spa_pod_builder_none(builder);                          \ 
  544                char *strval = va_arg(args, char *);                            \ 
  545                size_t len = va_arg(args, int);                                 \ 
  546                spa_pod_builder_string_len(builder, strval, len);               \ 
  551                void *ptr  = va_arg(args, void *);                              \ 
  552                int len = va_arg(args, int);                                    \ 
  553                spa_pod_builder_bytes(builder, ptr, len);                       \ 
  558                struct spa_rectangle *rectval =                                 \ 
  559                        va_arg(args, struct spa_rectangle *);                   \ 
  560                spa_pod_builder_rectangle(builder,                              \ 
  561                                rectval->width, rectval->height);               \ 
  566                struct spa_fraction *fracval =                                  \ 
  567                        va_arg(args, struct spa_fraction *);                    \ 
  568                spa_pod_builder_fraction(builder, fracval->num, fracval->denom);\ 
  573                int child_size = va_arg(args, int);                             \ 
  574                int child_type = va_arg(args, int);                             \ 
  575                int n_elems = va_arg(args, int);                                \ 
  576                void *elems = va_arg(args, void *);                             \ 
  577                spa_pod_builder_array(builder, child_size,                      \ 
  578                                child_type, n_elems, elems);                    \ 
  583                int t = va_arg(args, uint32_t);                                 \ 
  584                spa_pod_builder_pointer(builder, t, va_arg(args, void *));      \ 
  588                spa_pod_builder_fd(builder, va_arg(args, int));                 \ 
  595                struct spa_pod *pod = va_arg(args, struct spa_pod *);           \ 
  597                        spa_pod_builder_none(builder);                          \ 
  599                        spa_pod_builder_primitive(builder, pod);                \ 
  621                        uint32_t key = va_arg(
args, uint32_t);
 
  630                        uint32_t type = va_arg(
args, uint32_t);
 
 
  639                if ((format = va_arg(
args, 
const char *)) == NULL)
 
  642                choice = *format == 
'?';
 
  650                        n_values = va_arg(
args, 
int);
 
  652                while (n_values-- > 0)
 
  675#define spa_pod_builder_add_object(b,type,id,...)                               \ 
  677        struct spa_pod_builder *_b = (b);                                       \ 
  678        struct spa_pod_frame _f;                                                \ 
  679        spa_pod_builder_push_object(_b, &_f, type, id);                         \ 
  680        spa_pod_builder_add(_b, ##__VA_ARGS__, 0);                              \ 
  681        spa_pod_builder_pop(_b, &_f);                                           \ 
  684#define spa_pod_builder_add_struct(b,...)                                       \ 
  686        struct spa_pod_builder *_b = (b);                                       \ 
  687        struct spa_pod_frame _f;                                                \ 
  688        spa_pod_builder_push_struct(_b, &_f);                                   \ 
  689        spa_pod_builder_add(_b, ##__VA_ARGS__, NULL);                           \ 
 
  690        spa_pod_builder_pop(_b, &_f);                                           \ 
  693#define spa_pod_builder_add_sequence(b,unit,...)                                \ 
  695        struct spa_pod_builder *_b = (b);                                       \ 
  696        struct spa_pod_frame _f;                                                \ 
  697        spa_pod_builder_push_sequence(_b, &_f, unit);                           \ 
  698        spa_pod_builder_add(_b, ##__VA_ARGS__, 0, 0);                           \ 
  699        spa_pod_builder_pop(_b, &_f);                                           \ 
 
uint32_t int int const char va_list args
Definition core.h:434
uint32_t int int const char int r
Definition core.h:447
uint32_t int int res
Definition core.h:433
#define SPA_CALLBACKS_INIT(_funcs, _data)
Initialize the set of functions funcs as a spa_callbacks, together with _data.
Definition hook.h:144
#define spa_callbacks_call_res(callbacks, type, res, method, vers,...)
Invoke method named method in the callbacks.
Definition hook.h:217
#define SPA_POD_INIT_Double(val)
Definition builder.h:291
SPA_API_POD_BUILDER void * spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:187
SPA_API_POD_BUILDER int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
Definition builder.h:266
SPA_API_POD_BUILDER int spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
Definition builder.h:275
#define SPA_POD_INIT_None()
Definition builder.h:230
SPA_API_POD_BUILDER int spa_pod_builder_push_choice(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t type, uint32_t flags)
Definition builder.h:450
SPA_API_POD_BUILDER int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
Definition builder.h:171
#define SPA_POD_INIT(size, type)
Definition builder.h:227
SPA_API_POD_BUILDER int spa_pod_builder_none(struct spa_pod_builder *builder)
Definition builder.h:232
SPA_API_POD_BUILDER int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
Definition builder.h:324
SPA_API_POD_BUILDER int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
Definition builder.h:257
#define SPA_POD_BODY_CONST(pod)
Definition pod.h:41
SPA_API_POD_BUILDER int spa_pod_builder_child(struct spa_pod_builder *builder, uint32_t size, uint32_t type)
Definition builder.h:238
#define SPA_POD_INIT_Object(size, type, id,...)
Definition builder.h:476
SPA_API_POD_BUILDER int spa_pod_builder_double(struct spa_pod_builder *builder, double val)
Definition builder.h:293
SPA_API_POD_BUILDER int spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
Definition builder.h:409
#define SPA_POD_BUILDER_FLAG_BODY
Definition builder.h:45
SPA_API_POD_BUILDER int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
Definition builder.h:389
SPA_API_POD_BUILDER int spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const void *val)
Definition builder.h:380
#define SPA_POD_INIT_Sequence(size, unit)
Definition builder.h:500
#define SPA_POD_INIT_Rectangle(val)
Definition builder.h:396
SPA_API_POD_BUILDER void spa_pod_builder_get_state(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
Definition builder.h:75
#define SPA_POD_INIT_Bool(val)
Definition builder.h:246
SPA_API_POD_BUILDER int spa_pod_builder_bytes_append(struct spa_pod_builder *builder, uint32_t offset, const void *data, uint32_t size)
Definition builder.h:360
#define SPA_POD_INIT_String(len)
Definition builder.h:300
#define SPA_POD_BODY(pod)
Definition pod.h:39
SPA_API_POD_BUILDER int spa_pod_builder_bytes_end(struct spa_pod_builder *builder, uint32_t offset 1)
Definition builder.h:371
SPA_API_POD_BUILDER int spa_pod_builder_control(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
Definition builder.h:515
#define SPA_POD_INIT_Id(val)
Definition builder.h:255
SPA_API_POD_BUILDER int spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:466
SPA_API_POD_BUILDER int spa_pod_builder_add(struct spa_pod_builder *builder,...)
Definition builder.h:691
SPA_API_POD_BUILDER struct spa_pod * spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t offset)
Definition builder.h:103
#define SPA_POD_BODY_SIZE(pod)
Definition pod.h:26
#define SPA_POD_BUILDER_INIT(buffer, size)
Definition builder.h:72
SPA_API_POD_BUILDER int spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
Definition builder.h:248
SPA_API_POD_BUILDER int spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
Definition builder.h:399
#define SPA_POD_INIT_Struct(size)
Definition builder.h:463
SPA_API_POD_BUILDER int spa_pod_builder_push_object(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t type, uint32_t id)
Definition builder.h:479
SPA_API_POD_BUILDER int spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
Definition builder.h:634
SPA_API_POD_BUILDER void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
Definition builder.h:97
SPA_API_POD_BUILDER void spa_pod_builder_reset(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
Definition builder.h:88
SPA_API_POD_BUILDER int spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
Definition builder.h:315
SPA_API_POD_BUILDER struct spa_pod * spa_pod_copy(const struct spa_pod *pod)
Copy a pod structure.
Definition builder.h:732
SPA_API_POD_BUILDER int spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
Definition builder.h:334
#define SPA_POD_BUILDER_COLLECT(builder, type, args)
Definition builder.h:538
SPA_API_POD_BUILDER void spa_pod_builder_push(struct spa_pod_builder *builder, struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
Definition builder.h:123
SPA_API_POD_BUILDER uint32_t spa_choice_from_id(char id)
Definition builder.h:521
SPA_API_POD_BUILDER uint32_t spa_pod_builder_bytes_start(struct spa_pod_builder *builder)
Definition builder.h:352
SPA_API_POD_BUILDER int spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
Definition builder.h:303
SPA_API_POD_BUILDER int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
Definition builder.h:284
SPA_API_POD_BUILDER int spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:416
#define SPA_POD_INIT_Int(val)
Definition builder.h:264
#define SPA_POD_INIT_Float(val)
Definition builder.h:282
SPA_API_POD_BUILDER int spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
Definition builder.h:138
#define SPA_POD_INIT_Bytes(len)
Definition builder.h:331
#define SPA_POD_INIT_Fd(fd)
Definition builder.h:387
SPA_API_POD_BUILDER int spa_pod_builder_push_sequence(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t unit)
Definition builder.h:504
SPA_API_POD_BUILDER struct spa_pod * spa_pod_builder_frame(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:115
SPA_API_POD_BUILDER void * spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
Definition builder.h:343
SPA_API_POD_BUILDER int spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
Definition builder.h:205
SPA_API_POD_BUILDER int spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
Definition builder.h:179
#define SPA_POD_INIT_Long(val)
Definition builder.h:273
#define SPA_POD_INIT_Pointer(type, value)
Definition builder.h:377
#define SPA_API_POD_BUILDER
Definition builder.h:38
#define SPA_POD_INIT_Fraction(val)
Definition builder.h:406
#define SPA_POD_BUILDER_FLAG_FIRST
Definition builder.h:47
#define SPA_POD_SIZE(pod)
Definition pod.h:30
SPA_API_POD_BUILDER void spa_pod_builder_set_callbacks(struct spa_pod_builder *builder, const struct spa_pod_builder_callbacks *callbacks, void *data)
Definition builder.h:81
SPA_API_POD_BUILDER int spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
Definition builder.h:494
SPA_API_POD_BUILDER int spa_pod_builder_array(struct spa_pod_builder *builder, uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
Definition builder.h:428
@ SPA_CHOICE_Step
range with step: default, min, max, step
Definition pod.h:149
@ SPA_CHOICE_None
no choice, first value is current
Definition pod.h:147
@ SPA_CHOICE_Flags
flags: default, possible flags,...
Definition pod.h:151
@ SPA_CHOICE_Range
range: default, min, max
Definition pod.h:148
@ SPA_CHOICE_Enum
list: default, alternative,...
Definition pod.h:150
@ SPA_TYPE_Object
Definition type.h:56
@ SPA_TYPE_None
Definition type.h:42
@ SPA_TYPE_Sequence
Definition type.h:57
@ SPA_TYPE_Choice
Definition type.h:60
@ SPA_TYPE_Array
Definition type.h:54
#define SPA_UNUSED
Definition defs.h:307
#define SPA_ROUND_UP_N(num, align)
Definition defs.h:360
#define SPA_FRACTION(num, denom)
Definition defs.h:136
#define SPA_FLAG_IS_SET(field, flag)
Definition defs.h:90
SPA_API_UTILS_DEFS bool spa_ptrinside(const void *p1, size_t s1, const void *p2, size_t s2, size_t *remaining)
Definition defs.h:398
#define SPA_FALLTHROUGH
SPA_FALLTHROUGH is an annotation to suppress compiler warnings about switch cases that fall through w...
Definition defs.h:84
#define SPA_FLAG_CLEAR(field, flag)
Definition defs.h:94
#define SPA_PTROFF(ptr_, offset_, type_)
Return the address (buffer + offset) as pointer of type.
Definition defs.h:222
#define SPA_PTRDIFF(p1, p2)
Definition defs.h:238
#define SPA_RECTANGLE(width, height)
Definition defs.h:115
Callbacks, contains the structure with functions and the data passed to the functions.
Definition hook.h:126
struct spa_pod pod
Definition pod.h:127
struct spa_pod pod
Definition pod.h:52
int(* overflow)(void *data, uint32_t size)
Definition builder.h:60
uint32_t version
Definition builder.h:58
uint32_t flags
Definition builder.h:48
uint32_t offset
Definition builder.h:43
struct spa_pod_frame * frame
Definition builder.h:49
uint32_t _padding
Definition builder.h:66
struct spa_callbacks callbacks
Definition builder.h:68
void * data
Definition builder.h:64
struct spa_pod_builder_state state
Definition builder.h:67
uint32_t size
Definition builder.h:65
uint32_t type
type of choice, one of enum spa_choice_type
Definition pod.h:155
uint32_t flags
extra flags
Definition pod.h:156
struct spa_pod pod
Definition pod.h:163
struct spa_pod pod
Definition pod.h:81
struct spa_pod pod
Definition pod.h:200
struct spa_pod pod
Definition pod.h:75
struct spa_pod pod
Definition pod.h:101
struct spa_pod pod
Definition iter.h:38
uint32_t offset
Definition iter.h:40
struct spa_pod_frame * parent
Definition iter.h:39
uint32_t flags
Definition iter.h:41
struct spa_pod pod
Definition pod.h:58
struct spa_pod pod
Definition pod.h:64
struct spa_pod pod
Definition pod.h:70
struct spa_pod pod
Definition pod.h:184
struct spa_pod pod
Definition pod.h:195
struct spa_pod pod
Definition pod.h:96
a sequence of timed controls
Definition pod.h:248
struct spa_pod pod
Definition pod.h:249
struct spa_pod pod
Definition pod.h:168
uint32_t type
Definition pod.h:45
uint32_t size
Definition pod.h:44