PipeWire 1.3.83
Loading...
Searching...
No Matches
builder.h
Go to the documentation of this file.
1/* Simple Plugin API */
2/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
3/* SPDX-License-Identifier: MIT */
4
5#ifndef SPA_POD_BUILDER_H
6#define SPA_POD_BUILDER_H
7
8#ifdef __cplusplus
9extern "C" {
10#endif
11
21#include <stdarg.h>
22
23#include <spa/utils/hook.h>
24#include <spa/pod/iter.h>
25#include <spa/pod/vararg.h>
26
27#ifndef SPA_API_POD_BUILDER
28 #ifdef SPA_API_IMPL
29 #define SPA_API_POD_BUILDER SPA_API_IMPL
30 #else
31 #define SPA_API_POD_BUILDER static inline
32 #endif
33#endif
34
36 uint32_t offset;
37#define SPA_POD_BUILDER_FLAG_BODY (1<<0)
38#define SPA_POD_BUILDER_FLAG_FIRST (1<<1)
39 uint32_t flags;
40 struct spa_pod_frame *frame;
41};
44
46#define SPA_VERSION_POD_BUILDER_CALLBACKS 0
47 uint32_t version;
49 int (*overflow) (void *data, uint32_t size);
50};
51
52struct spa_pod_builder {
53 void *data;
54 uint32_t size;
55 uint32_t _padding;
58};
59
60#define SPA_POD_BUILDER_INIT(buffer,size) ((struct spa_pod_builder){ (buffer), (size), 0, {0,0,NULL},{NULL,NULL}})
61
70 const struct spa_pod_builder_callbacks *callbacks, void *data)
71{
72 builder->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
73}
74
77{
78 struct spa_pod_frame *f;
79 uint32_t size = builder->state.offset - state->offset;
80 builder->state = *state;
81 for (f = builder->state.frame; f ; f = f->parent)
82 f->pod.size -= size;
83}
84
85SPA_API_POD_BUILDER void spa_pod_builder_init(struct spa_pod_builder *builder, void *data, uint32_t size)
86{
87 *builder = SPA_POD_BUILDER_INIT(data, size);
89
91spa_pod_builder_deref(struct spa_pod_builder *builder, uint32_t offset)
92{
93 uint32_t size = builder->size;
94 if (offset + 8 <= size) {
95 struct spa_pod *pod = SPA_PTROFF(builder->data, offset, struct spa_pod);
96 if (offset + SPA_POD_SIZE(pod) <= size)
97 return pod;
98 }
99 return NULL;
100}
101
104{
105 if (frame->offset + SPA_POD_SIZE(&frame->pod) <= builder->size)
106 return SPA_PTROFF(builder->data, frame->offset, struct spa_pod);
107 return NULL;
108}
109
112 struct spa_pod_frame *frame,
113 const struct spa_pod *pod,
114 uint32_t offset)
116 frame->pod = *pod;
117 frame->offset = offset;
118 frame->parent = builder->state.frame;
119 frame->flags = builder->state.flags;
120 builder->state.frame = frame;
121
122 if (frame->pod.type == SPA_TYPE_Array || frame->pod.type == SPA_TYPE_Choice)
124}
125
126SPA_API_POD_BUILDER int spa_pod_builder_raw(struct spa_pod_builder *builder, const void *data, uint32_t size)
127{
128 int res = 0;
129 struct spa_pod_frame *f;
130 uint32_t offset = builder->state.offset;
131
132 if (offset + size > builder->size) {
133 res = -ENOSPC;
134 if (offset <= builder->size)
137 overflow, 0, offset + size);
139 if (res == 0 && data)
140 memcpy(SPA_PTROFF(builder->data, offset, void), data, size);
141
142 builder->state.offset += size;
143
144 for (f = builder->state.frame; f ; f = f->parent)
145 f->pod.size += size;
146
147 return res;
148}
149
150SPA_API_POD_BUILDER int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
151{
152 uint64_t zeroes = 0;
153 size = SPA_ROUND_UP_N(size, 8) - size;
154 return size ? spa_pod_builder_raw(builder, &zeroes, size) : 0;
155}
156
158spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
159{
160 int r, res = spa_pod_builder_raw(builder, data, size);
161 if ((r = spa_pod_builder_pad(builder, size)) < 0)
163 return res;
164}
165
166SPA_API_POD_BUILDER void *spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
167{
168 struct spa_pod *pod;
169
171 const struct spa_pod p = { 0, SPA_TYPE_None };
172 spa_pod_builder_raw(builder, &p, sizeof(p));
173 }
174 if ((pod = (struct spa_pod*)spa_pod_builder_frame(builder, frame)) != NULL)
175 *pod = frame->pod;
176
177 builder->state.frame = frame->parent;
178 builder->state.flags = frame->flags;
179 spa_pod_builder_pad(builder, builder->state.offset);
180 return pod;
181}
182
184spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
185{
186 const void *data;
188 int r, res;
189
190 if (builder->state.flags == SPA_POD_BUILDER_FLAG_BODY) {
191 data = SPA_POD_BODY_CONST(p);
193 } else {
194 data = p;
197 }
198 res = spa_pod_builder_raw(builder, data, size);
199 if (builder->state.flags != SPA_POD_BUILDER_FLAG_BODY)
200 if ((r = spa_pod_builder_pad(builder, size)) < 0)
201 res = r;
202 return res;
203}
204
205#define SPA_POD_INIT(size,type) ((struct spa_pod) { (size), (type) })
206
207#define SPA_POD_INIT_None() SPA_POD_INIT(0, SPA_TYPE_None)
208
210{
211 const struct spa_pod p = SPA_POD_INIT_None();
212 return spa_pod_builder_primitive(builder, &p);
213}
214
216{
217 const struct spa_pod p = SPA_POD_INIT(size,type);
219 return spa_pod_builder_raw(builder, &p, sizeof(p));
220}
222#define SPA_POD_INIT_Bool(val) ((struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, (val) ? 1 : 0, 0 })
225{
226 const struct spa_pod_bool p = SPA_POD_INIT_Bool(val);
227 return spa_pod_builder_primitive(builder, &p.pod);
228}
230#define SPA_POD_INIT_Id(val) ((struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (val), 0 })
231
232SPA_API_POD_BUILDER int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
233{
234 const struct spa_pod_id p = SPA_POD_INIT_Id(val);
235 return spa_pod_builder_primitive(builder, &p.pod);
236}
238#define SPA_POD_INIT_Int(val) ((struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (val), 0 })
240SPA_API_POD_BUILDER int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
241{
242 const struct spa_pod_int p = SPA_POD_INIT_Int(val);
243 return spa_pod_builder_primitive(builder, &p.pod);
244}
245
246#define SPA_POD_INIT_Long(val) ((struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (val) })
247
249{
250 const struct spa_pod_long p = SPA_POD_INIT_Long(val);
251 return spa_pod_builder_primitive(builder, &p.pod);
252}
253
254#define SPA_POD_INIT_Float(val) ((struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, (val), 0 })
256SPA_API_POD_BUILDER int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
258 const struct spa_pod_float p = SPA_POD_INIT_Float(val);
259 return spa_pod_builder_primitive(builder, &p.pod);
260}
261
262#define SPA_POD_INIT_Double(val) ((struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, (val) })
263
265{
266 const struct spa_pod_double p = SPA_POD_INIT_Double(val);
267 return spa_pod_builder_primitive(builder, &p.pod);
268}
269
270#define SPA_POD_INIT_String(len) ((struct spa_pod_string){ { (len), SPA_TYPE_String } })
271
273spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
274{
275 int r, res;
276 res = spa_pod_builder_raw(builder, str, len);
277 if ((r = spa_pod_builder_raw(builder, "", 1)) < 0)
278 res = r;
279 if ((r = spa_pod_builder_pad(builder, builder->state.offset)) < 0)
280 res = r;
281 return res;
283
285spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
286{
287 const struct spa_pod_string p = SPA_POD_INIT_String(len+1);
288 int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
289 if ((r = spa_pod_builder_write_string(builder, str, len)) < 0)
290 res = r;
291 return res;
292}
293
294SPA_API_POD_BUILDER int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
295{
296 uint32_t len = str ? strlen(str) : 0;
297 return spa_pod_builder_string_len(builder, str ? str : "", len);
298}
299
300#define SPA_POD_INIT_Bytes(len) ((struct spa_pod_bytes){ { (len), SPA_TYPE_Bytes } })
301
303spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
304{
305 const struct spa_pod_bytes p = SPA_POD_INIT_Bytes(len);
306 int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
307 if ((r = spa_pod_builder_raw_padded(builder, bytes, len)) < 0)
308 res = r;
309 return res;
310}
312spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
313{
314 uint32_t offset = builder->state.offset;
315 if (spa_pod_builder_bytes(builder, NULL, len) < 0)
316 return NULL;
317 return SPA_POD_BODY(spa_pod_builder_deref(builder, offset));
318}
319
320#define SPA_POD_INIT_Pointer(type,value) ((struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { (type), 0, (value) } })
321
323spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const void *val)
324{
325 const struct spa_pod_pointer p = SPA_POD_INIT_Pointer(type, val);
326 return spa_pod_builder_primitive(builder, &p.pod);
327}
328
329#define SPA_POD_INIT_Fd(fd) ((struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, (fd) })
330
331SPA_API_POD_BUILDER int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
332{
333 const struct spa_pod_fd p = SPA_POD_INIT_Fd(fd);
334 return spa_pod_builder_primitive(builder, &p.pod);
335}
336
337#define SPA_POD_INIT_Rectangle(val) ((struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, (val) })
338
340spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
341{
342 const struct spa_pod_rectangle p = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(width, height));
343 return spa_pod_builder_primitive(builder, &p.pod);
344}
345
346#define SPA_POD_INIT_Fraction(val) ((struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, (val) })
347
349spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
350{
351 const struct spa_pod_fraction p = SPA_POD_INIT_Fraction(SPA_FRACTION(num, denom));
352 return spa_pod_builder_primitive(builder, &p.pod);
354
356spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
357{
358 const struct spa_pod_array p =
359 { {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_TYPE_Array},
360 {{0, 0}} };
361 uint32_t offset = builder->state.offset;
362 int res = spa_pod_builder_raw(builder, &p, sizeof(p) - sizeof(struct spa_pod));
363 spa_pod_builder_push(builder, frame, &p.pod, offset);
364 return res;
366
369 uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
370{
371 const struct spa_pod_array p = {
372 {(uint32_t)(sizeof(struct spa_pod_array_body) + n_elems * child_size), SPA_TYPE_Array},
373 {{child_size, child_type}}
374 };
375 int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
376 if ((r = spa_pod_builder_raw_padded(builder, elems, child_size * n_elems)) < 0)
377 res = r;
378 return res;
379}
380
381#define SPA_POD_INIT_CHOICE_BODY(type, flags, child_size, child_type) \
382 ((struct spa_pod_choice_body) { (type), (flags), { (child_size), (child_type) }})
383
384#define SPA_POD_INIT_Choice(type, ctype, child_type, n_vals, ...) \
385 ((struct { struct spa_pod_choice choice; ctype vals[(n_vals)];}) \
386 { { { (n_vals) * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice }, \
387 { (type), 0, { sizeof(ctype), (child_type) } } }, { __VA_ARGS__ } })
388
390spa_pod_builder_push_choice(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
391 uint32_t type, uint32_t flags)
392{
393 const struct spa_pod_choice p =
395 { type, flags, {0, 0}} };
396 uint32_t offset = builder->state.offset;
397 int res = spa_pod_builder_raw(builder, &p, sizeof(p) - sizeof(struct spa_pod));
398 spa_pod_builder_push(builder, frame, &p.pod, offset);
399 return res;
400}
401
402#define SPA_POD_INIT_Struct(size) ((struct spa_pod_struct){ { (size), SPA_TYPE_Struct } })
403
405spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
406{
408 uint32_t offset = builder->state.offset;
409 int res = spa_pod_builder_raw(builder, &p, sizeof(p));
410 spa_pod_builder_push(builder, frame, &p.pod, offset);
411 return res;
412}
413
414#define SPA_POD_INIT_Object(size,type,id,...) ((struct spa_pod_object){ { (size), SPA_TYPE_Object }, { (type), (id) }, ##__VA_ARGS__ })
415
417spa_pod_builder_push_object(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
418 uint32_t type, uint32_t id)
419{
420 const struct spa_pod_object p =
421 SPA_POD_INIT_Object(sizeof(struct spa_pod_object_body), type, id);
422 uint32_t offset = builder->state.offset;
423 int res = spa_pod_builder_raw(builder, &p, sizeof(p));
424 spa_pod_builder_push(builder, frame, &p.pod, offset);
425 return res;
426}
427
428#define SPA_POD_INIT_Prop(key,flags,size,type) \
429 ((struct spa_pod_prop){ (key), (flags), { (size), (type) } })
430
432spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
433{
434 const struct { uint32_t key; uint32_t flags; } p = { key, flags };
435 return spa_pod_builder_raw(builder, &p, sizeof(p));
436}
437
438#define SPA_POD_INIT_Sequence(size,unit) \
439 ((struct spa_pod_sequence){ { (size), SPA_TYPE_Sequence}, {(unit), 0 } })
440
442spa_pod_builder_push_sequence(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t unit)
443{
444 const struct spa_pod_sequence p =
446 uint32_t offset = builder->state.offset;
447 int res = spa_pod_builder_raw(builder, &p, sizeof(p));
448 spa_pod_builder_push(builder, frame, &p.pod, offset);
449 return res;
450}
451
453spa_pod_builder_control(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
454{
455 const struct { uint32_t offset; uint32_t type; } p = { offset, type };
456 return spa_pod_builder_raw(builder, &p, sizeof(p));
457}
458
461 switch (id) {
462 case 'r':
463 return SPA_CHOICE_Range;
464 case 's':
465 return SPA_CHOICE_Step;
466 case 'e':
467 return SPA_CHOICE_Enum;
468 case 'f':
469 return SPA_CHOICE_Flags;
470 case 'n':
471 default:
472 return SPA_CHOICE_None;
473 }
474}
475
476#define SPA_POD_BUILDER_COLLECT(builder,type,args) \
477do { \
478 switch (type) { \
479 case 'b': \
480 spa_pod_builder_bool(builder, !!va_arg(args, int)); \
481 break; \
482 case 'I': \
483 spa_pod_builder_id(builder, va_arg(args, uint32_t)); \
484 break; \
485 case 'i': \
486 spa_pod_builder_int(builder, va_arg(args, int)); \
487 break; \
488 case 'l': \
489 spa_pod_builder_long(builder, va_arg(args, int64_t)); \
490 break; \
491 case 'f': \
492 spa_pod_builder_float(builder, (float)va_arg(args, double)); \
493 break; \
494 case 'd': \
495 spa_pod_builder_double(builder, va_arg(args, double)); \
496 break; \
497 case 's': \
498 { \
499 char *strval = va_arg(args, char *); \
500 if (strval != NULL) { \
501 size_t len = strlen(strval); \
502 spa_pod_builder_string_len(builder, strval, len); \
503 } \
504 else \
505 spa_pod_builder_none(builder); \
506 break; \
507 } \
508 case 'S': \
509 { \
510 char *strval = va_arg(args, char *); \
511 size_t len = va_arg(args, int); \
512 spa_pod_builder_string_len(builder, strval, len); \
513 break; \
514 } \
515 case 'y': \
516 { \
517 void *ptr = va_arg(args, void *); \
518 int len = va_arg(args, int); \
519 spa_pod_builder_bytes(builder, ptr, len); \
520 break; \
521 } \
522 case 'R': \
523 { \
524 struct spa_rectangle *rectval = \
525 va_arg(args, struct spa_rectangle *); \
526 spa_pod_builder_rectangle(builder, \
527 rectval->width, rectval->height); \
528 break; \
529 } \
530 case 'F': \
531 { \
532 struct spa_fraction *fracval = \
533 va_arg(args, struct spa_fraction *); \
534 spa_pod_builder_fraction(builder, fracval->num, fracval->denom);\
535 break; \
536 } \
537 case 'a': \
538 { \
539 int child_size = va_arg(args, int); \
540 int child_type = va_arg(args, int); \
541 int n_elems = va_arg(args, int); \
542 void *elems = va_arg(args, void *); \
543 spa_pod_builder_array(builder, child_size, \
544 child_type, n_elems, elems); \
545 break; \
546 } \
547 case 'p': \
548 { \
549 int t = va_arg(args, uint32_t); \
550 spa_pod_builder_pointer(builder, t, va_arg(args, void *)); \
551 break; \
552 } \
553 case 'h': \
554 spa_pod_builder_fd(builder, va_arg(args, int)); \
555 break; \
556 case 'P': \
557 case 'O': \
558 case 'T': \
559 case 'V': \
560 { \
561 struct spa_pod *pod = va_arg(args, struct spa_pod *); \
562 if (pod == NULL) \
563 spa_pod_builder_none(builder); \
564 else \
565 spa_pod_builder_primitive(builder, pod); \
566 break; \
567 } \
568 } \
569} while(false)
570
572spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
573{
574 int res = 0;
575 struct spa_pod_frame *frame = builder->state.frame;
576 uint32_t ftype = frame ? frame->pod.type : (uint32_t)SPA_TYPE_None;
577
578 do {
579 const char *format;
580 int n_values = 1;
581 struct spa_pod_frame f;
582 bool choice;
583
584 switch (ftype) {
585 case SPA_TYPE_Object:
586 {
587 uint32_t key = va_arg(args, uint32_t);
588 if (key == 0)
589 goto exit;
590 spa_pod_builder_prop(builder, key, 0);
591 break;
592 }
594 {
595 uint32_t offset = va_arg(args, uint32_t);
596 uint32_t type = va_arg(args, uint32_t);
597 if (type == 0)
598 goto exit;
599 spa_pod_builder_control(builder, offset, type);
601 }
602 default:
603 break;
604 }
605 if ((format = va_arg(args, const char *)) == NULL)
606 break;
607
608 choice = *format == '?';
609 if (choice) {
610 uint32_t type = spa_choice_from_id(*++format);
611 if (*format != '\0')
612 format++;
613
614 spa_pod_builder_push_choice(builder, &f, type, 0);
615
616 n_values = va_arg(args, int);
617 }
618 while (n_values-- > 0)
619 SPA_POD_BUILDER_COLLECT(builder, *format, args);
620
621 if (choice)
622 spa_pod_builder_pop(builder, &f);
623 } while (true);
624
625 exit:
626 return res;
627}
628
630{
631 int res;
632 va_list args;
633
634 va_start(args, builder);
635 res = spa_pod_builder_addv(builder, args);
636 va_end(args);
637
638 return res;
639}
640
641#define spa_pod_builder_add_object(b,type,id,...) \
642({ \
643 struct spa_pod_builder *_b = (b); \
644 struct spa_pod_frame _f; \
645 spa_pod_builder_push_object(_b, &_f, type, id); \
646 spa_pod_builder_add(_b, ##__VA_ARGS__, 0); \
647 spa_pod_builder_pop(_b, &_f); \
648})
649
650#define spa_pod_builder_add_struct(b,...) \
651({ \
652 struct spa_pod_builder *_b = (b); \
653 struct spa_pod_frame _f; \
654 spa_pod_builder_push_struct(_b, &_f); \
655 spa_pod_builder_add(_b, ##__VA_ARGS__, NULL); \
656 spa_pod_builder_pop(_b, &_f); \
658
659#define spa_pod_builder_add_sequence(b,unit,...) \
660({ \
661 struct spa_pod_builder *_b = (b); \
662 struct spa_pod_frame _f; \
663 spa_pod_builder_push_sequence(_b, &_f, unit); \
664 spa_pod_builder_add(_b, ##__VA_ARGS__, 0, 0); \
665 spa_pod_builder_pop(_b, &_f); \
666})
667
670spa_pod_copy(const struct spa_pod *pod)
671{
672 size_t size;
673 struct spa_pod *c;
674
675 size = SPA_POD_SIZE(pod);
676 if ((c = (struct spa_pod *) malloc(size)) == NULL)
677 return NULL;
678 return (struct spa_pod *) memcpy(c, pod, size);
679}
680
685#ifdef __cplusplus
686} /* extern "C" */
687#endif
688
689#endif /* SPA_POD_BUILDER_H */
uint32_t int int const char va_list args
Definition core.h:434
va_end(args)
uint32_t int int const char int r
Definition core.h:447
uint32_t int int res
Definition core.h:433
va_start(args, message)
#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:282
SPA_API_POD_BUILDER void * spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:178
SPA_API_POD_BUILDER int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
Definition builder.h:257
SPA_API_POD_BUILDER int spa_pod_builder_long(struct spa_pod_builder *builder, int64_t val)
Definition builder.h:266
#define SPA_POD_INIT_None()
Definition builder.h:221
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:416
SPA_API_POD_BUILDER int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
Definition builder.h:162
#define SPA_POD_INIT(size, type)
Definition builder.h:218
SPA_API_POD_BUILDER int spa_pod_builder_none(struct spa_pod_builder *builder)
Definition builder.h:223
SPA_API_POD_BUILDER int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
Definition builder.h:315
SPA_API_POD_BUILDER int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
Definition builder.h:248
#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:229
#define SPA_POD_INIT_Object(size, type, id,...)
Definition builder.h:442
SPA_API_POD_BUILDER int spa_pod_builder_double(struct spa_pod_builder *builder, double val)
Definition builder.h:284
SPA_API_POD_BUILDER int spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
Definition builder.h:375
#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:355
SPA_API_POD_BUILDER int spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const void *val)
Definition builder.h:346
#define SPA_POD_INIT_Sequence(size, unit)
Definition builder.h:466
#define SPA_POD_INIT_Rectangle(val)
Definition builder.h:362
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:237
#define SPA_POD_INIT_String(len)
Definition builder.h:291
#define SPA_POD_BODY(pod)
Definition pod.h:39
SPA_API_POD_BUILDER int spa_pod_builder_control(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
Definition builder.h:481
#define SPA_POD_INIT_Id(val)
Definition builder.h:246
SPA_API_POD_BUILDER int spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:432
SPA_API_POD_BUILDER int spa_pod_builder_add(struct spa_pod_builder *builder,...)
Definition builder.h:657
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:239
SPA_API_POD_BUILDER int spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
Definition builder.h:365
#define SPA_POD_INIT_Struct(size)
Definition builder.h:429
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:445
SPA_API_POD_BUILDER int spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
Definition builder.h:600
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:306
SPA_API_POD_BUILDER struct spa_pod * spa_pod_copy(const struct spa_pod *pod)
Copy a pod structure.
Definition builder.h:698
SPA_API_POD_BUILDER int spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
Definition builder.h:325
#define SPA_POD_BUILDER_COLLECT(builder, type, args)
Definition builder.h:504
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:487
SPA_API_POD_BUILDER int spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
Definition builder.h:294
SPA_API_POD_BUILDER int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
Definition builder.h:275
SPA_API_POD_BUILDER int spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition builder.h:382
#define SPA_POD_INIT_Int(val)
Definition builder.h:255
#define SPA_POD_INIT_Float(val)
Definition builder.h:273
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:322
#define SPA_POD_INIT_Fd(fd)
Definition builder.h:353
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:470
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:334
SPA_API_POD_BUILDER int spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
Definition builder.h:196
SPA_API_POD_BUILDER int spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
Definition builder.h:170
#define SPA_POD_INIT_Long(val)
Definition builder.h:264
#define SPA_POD_INIT_Pointer(type, value)
Definition builder.h:343
#define SPA_API_POD_BUILDER
Definition builder.h:38
#define SPA_POD_INIT_Fraction(val)
Definition builder.h:372
#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:460
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:394
@ 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_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
#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_RECTANGLE(width, height)
Definition defs.h:115
spa/utils/hook.h
spa/pod/iter.h
Callbacks, contains the structure with functions and the data passed to the functions.
Definition hook.h:126
Definition pod.h:121
Definition pod.h:126
struct spa_pod pod
Definition pod.h:127
Definition pod.h:51
struct spa_pod pod
Definition pod.h:52
Definition builder.h:55
int(* overflow)(void *data, uint32_t size)
Definition builder.h:60
uint32_t version
Definition builder.h:58
Definition builder.h:42
uint32_t flags
Definition builder.h:48
uint32_t offset
Definition builder.h:43
struct spa_pod_frame * frame
Definition builder.h:49
Definition builder.h:63
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
Definition pod.h:90
Definition pod.h:154
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
Definition pod.h:162
struct spa_pod pod
Definition pod.h:163
Definition pod.h:80
struct spa_pod pod
Definition pod.h:81
Definition pod.h:199
struct spa_pod pod
Definition pod.h:200
Definition pod.h:74
struct spa_pod pod
Definition pod.h:75
Definition pod.h:100
struct spa_pod pod
Definition pod.h:101
Definition iter.h:37
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
Definition pod.h:57
struct spa_pod pod
Definition pod.h:58
Definition pod.h:63
struct spa_pod pod
Definition pod.h:64
Definition pod.h:69
struct spa_pod pod
Definition pod.h:70
Definition pod.h:177
Definition pod.h:183
struct spa_pod pod
Definition pod.h:184
Definition pod.h:194
struct spa_pod pod
Definition pod.h:195
Definition pod.h:95
struct spa_pod pod
Definition pod.h:96
Definition pod.h:241
a sequence of timed controls
Definition pod.h:248
struct spa_pod pod
Definition pod.h:249
Definition pod.h:85
Definition pod.h:167
struct spa_pod pod
Definition pod.h:168
Definition pod.h:43
uint32_t type
Definition pod.h:45
uint32_t size
Definition pod.h:44
spa/pod/vararg.h