PipeWire  1.4.5
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
9 extern "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 
35 struct spa_pod_builder_state {
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 };
42 
44 
46 #define SPA_VERSION_POD_BUILDER_CALLBACKS 0
47  uint32_t version;
48 
49  int (*overflow) (void *data, uint32_t size);
50 };
51 
52 struct 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 
64 {
65  *state = builder->state;
66 }
67 
70  const struct spa_pod_builder_callbacks *callbacks, void *data)
71 {
72  builder->callbacks = SPA_CALLBACKS_INIT(callbacks, data);
73 }
74 
76 spa_pod_builder_reset(struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
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 
85 SPA_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);
88 }
89 
91 spa_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 
103 spa_pod_builder_frame(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
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 
111 spa_pod_builder_push(struct spa_pod_builder *builder,
112  struct spa_pod_frame *frame,
113  const struct spa_pod *pod,
114  uint32_t offset)
115 {
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 
126 SPA_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  size_t data_offset = -1;
132 
133  if (offset + size > builder->size) {
134  /* data could be inside the data we will realloc */
135  if (spa_ptrinside(builder->data, builder->size, data, size, NULL))
136  data_offset = SPA_PTRDIFF(data, builder->data);
137 
138  res = -ENOSPC;
139  if (offset <= builder->size)
142  overflow, 0, offset + size);
143  }
144  if (res == 0 && data) {
145  if (data_offset != (size_t) -1)
146  data = SPA_PTROFF(builder->data, data_offset, const void);
147 
148  memcpy(SPA_PTROFF(builder->data, offset, void), data, size);
149  }
150 
151  builder->state.offset += size;
152 
153  for (f = builder->state.frame; f ; f = f->parent)
154  f->pod.size += size;
155 
156  return res;
157 }
158 
159 SPA_API_POD_BUILDER int spa_pod_builder_pad(struct spa_pod_builder *builder, uint32_t size)
160 {
161  uint64_t zeroes = 0;
162  size = SPA_ROUND_UP_N(size, 8) - size;
163  return size ? spa_pod_builder_raw(builder, &zeroes, size) : 0;
164 }
165 
167 spa_pod_builder_raw_padded(struct spa_pod_builder *builder, const void *data, uint32_t size)
168 {
169  int r, res = spa_pod_builder_raw(builder, data, size);
170  if ((r = spa_pod_builder_pad(builder, size)) < 0)
171  res = r;
172  return res;
173 }
174 
175 SPA_API_POD_BUILDER void *spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
176 {
177  struct spa_pod *pod;
178 
180  const struct spa_pod p = { 0, SPA_TYPE_None };
181  spa_pod_builder_raw(builder, &p, sizeof(p));
182  }
183  if ((pod = (struct spa_pod*)spa_pod_builder_frame(builder, frame)) != NULL)
184  *pod = frame->pod;
185 
186  builder->state.frame = frame->parent;
187  builder->state.flags = frame->flags;
188  spa_pod_builder_pad(builder, builder->state.offset);
189  return pod;
190 }
191 
193 spa_pod_builder_primitive(struct spa_pod_builder *builder, const struct spa_pod *p)
194 {
195  const void *data;
196  uint32_t size;
197  int r, res;
198 
199  if (builder->state.flags == SPA_POD_BUILDER_FLAG_BODY) {
200  data = SPA_POD_BODY_CONST(p);
201  size = SPA_POD_BODY_SIZE(p);
202  } else {
203  data = p;
204  size = SPA_POD_SIZE(p);
206  }
207  res = spa_pod_builder_raw(builder, data, size);
208  if (builder->state.flags != SPA_POD_BUILDER_FLAG_BODY)
209  if ((r = spa_pod_builder_pad(builder, size)) < 0)
210  res = r;
211  return res;
212 }
213 
214 #define SPA_POD_INIT(size,type) ((struct spa_pod) { (size), (type) })
215 
216 #define SPA_POD_INIT_None() SPA_POD_INIT(0, SPA_TYPE_None)
217 
219 {
220  const struct spa_pod p = SPA_POD_INIT_None();
221  return spa_pod_builder_primitive(builder, &p);
222 }
223 
224 SPA_API_POD_BUILDER int spa_pod_builder_child(struct spa_pod_builder *builder, uint32_t size, uint32_t type)
225 {
226  const struct spa_pod p = SPA_POD_INIT(size,type);
228  return spa_pod_builder_raw(builder, &p, sizeof(p));
229 }
230 
231 #define SPA_POD_INIT_Bool(val) ((struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, (val) ? 1 : 0, 0 })
232 
233 SPA_API_POD_BUILDER int spa_pod_builder_bool(struct spa_pod_builder *builder, bool val)
234 {
235  const struct spa_pod_bool p = SPA_POD_INIT_Bool(val);
236  return spa_pod_builder_primitive(builder, &p.pod);
237 }
238 
239 #define SPA_POD_INIT_Id(val) ((struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (val), 0 })
240 
241 SPA_API_POD_BUILDER int spa_pod_builder_id(struct spa_pod_builder *builder, uint32_t val)
242 {
243  const struct spa_pod_id p = SPA_POD_INIT_Id(val);
244  return spa_pod_builder_primitive(builder, &p.pod);
245 }
246 
247 #define SPA_POD_INIT_Int(val) ((struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (val), 0 })
248 
249 SPA_API_POD_BUILDER int spa_pod_builder_int(struct spa_pod_builder *builder, int32_t val)
250 {
251  const struct spa_pod_int p = SPA_POD_INIT_Int(val);
252  return spa_pod_builder_primitive(builder, &p.pod);
253 }
254 
255 #define SPA_POD_INIT_Long(val) ((struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (val) })
256 
258 {
259  const struct spa_pod_long p = SPA_POD_INIT_Long(val);
260  return spa_pod_builder_primitive(builder, &p.pod);
261 }
262 
263 #define SPA_POD_INIT_Float(val) ((struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, (val), 0 })
264 
265 SPA_API_POD_BUILDER int spa_pod_builder_float(struct spa_pod_builder *builder, float val)
266 {
267  const struct spa_pod_float p = SPA_POD_INIT_Float(val);
268  return spa_pod_builder_primitive(builder, &p.pod);
269 }
270 
271 #define SPA_POD_INIT_Double(val) ((struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, (val) })
272 
274 {
275  const struct spa_pod_double p = SPA_POD_INIT_Double(val);
276  return spa_pod_builder_primitive(builder, &p.pod);
277 }
278 
279 #define SPA_POD_INIT_String(len) ((struct spa_pod_string){ { (len), SPA_TYPE_String } })
280 
282 spa_pod_builder_write_string(struct spa_pod_builder *builder, const char *str, uint32_t len)
283 {
284  int r, res;
285  res = spa_pod_builder_raw(builder, str, len);
286  if ((r = spa_pod_builder_raw(builder, "", 1)) < 0)
287  res = r;
288  if ((r = spa_pod_builder_pad(builder, builder->state.offset)) < 0)
289  res = r;
290  return res;
291 }
292 
294 spa_pod_builder_string_len(struct spa_pod_builder *builder, const char *str, uint32_t len)
295 {
296  const struct spa_pod_string p = SPA_POD_INIT_String(len+1);
297  int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
298  if ((r = spa_pod_builder_write_string(builder, str, len)) < 0)
299  res = r;
300  return res;
301 }
302 
303 SPA_API_POD_BUILDER int spa_pod_builder_string(struct spa_pod_builder *builder, const char *str)
304 {
305  uint32_t len = str ? strlen(str) : 0;
306  return spa_pod_builder_string_len(builder, str ? str : "", len);
307 }
308 
309 #define SPA_POD_INIT_Bytes(len) ((struct spa_pod_bytes){ { (len), SPA_TYPE_Bytes } })
310 
312 spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
313 {
314  const struct spa_pod_bytes p = SPA_POD_INIT_Bytes(len);
315  int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
316  if ((r = spa_pod_builder_raw_padded(builder, bytes, len)) < 0)
317  res = r;
318  return res;
319 }
320 SPA_API_POD_BUILDER void *
321 spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
322 {
323  uint32_t offset = builder->state.offset;
324  if (spa_pod_builder_bytes(builder, NULL, len) < 0)
325  return NULL;
326  return SPA_POD_BODY(spa_pod_builder_deref(builder, offset));
327 }
328 
329 SPA_API_POD_BUILDER uint32_t
331 {
332  uint32_t offset = builder->state.offset;
333  const struct spa_pod_bytes p = SPA_POD_INIT_Bytes(0);
334  spa_pod_builder_raw(builder, &p, sizeof(p));
335  return offset;
336 }
338 spa_pod_builder_bytes_append(struct spa_pod_builder *builder, uint32_t offset,
339  const void *data, uint32_t size)
340 {
341  int res = spa_pod_builder_raw(builder, data, size);
342  struct spa_pod *pod = spa_pod_builder_deref(builder, offset);
343  if (pod)
344  pod->size += size;
345  return res;
346 }
347 
349 spa_pod_builder_bytes_end(struct spa_pod_builder *builder, uint32_t offset SPA_UNUSED)
350 {
351  return spa_pod_builder_pad(builder, builder->state.offset);
352 }
353 
354 #define SPA_POD_INIT_Pointer(type,value) ((struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { (type), 0, (value) } })
355 
357 spa_pod_builder_pointer(struct spa_pod_builder *builder, uint32_t type, const void *val)
358 {
359  const struct spa_pod_pointer p = SPA_POD_INIT_Pointer(type, val);
360  return spa_pod_builder_primitive(builder, &p.pod);
361 }
362 
363 #define SPA_POD_INIT_Fd(fd) ((struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, (fd) })
364 
365 SPA_API_POD_BUILDER int spa_pod_builder_fd(struct spa_pod_builder *builder, int64_t fd)
366 {
367  const struct spa_pod_fd p = SPA_POD_INIT_Fd(fd);
368  return spa_pod_builder_primitive(builder, &p.pod);
369 }
370 
371 #define SPA_POD_INIT_Rectangle(val) ((struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, (val) })
372 
374 spa_pod_builder_rectangle(struct spa_pod_builder *builder, uint32_t width, uint32_t height)
375 {
376  const struct spa_pod_rectangle p = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(width, height));
377  return spa_pod_builder_primitive(builder, &p.pod);
378 }
379 
380 #define SPA_POD_INIT_Fraction(val) ((struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, (val) })
381 
383 spa_pod_builder_fraction(struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
384 {
385  const struct spa_pod_fraction p = SPA_POD_INIT_Fraction(SPA_FRACTION(num, denom));
386  return spa_pod_builder_primitive(builder, &p.pod);
387 }
388 
390 spa_pod_builder_push_array(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
391 {
392  const struct spa_pod_array p =
393  { {sizeof(struct spa_pod_array_body) - sizeof(struct spa_pod), SPA_TYPE_Array},
394  {{0, 0}} };
395  uint32_t offset = builder->state.offset;
396  int res = spa_pod_builder_raw(builder, &p, sizeof(p) - sizeof(struct spa_pod));
397  spa_pod_builder_push(builder, frame, &p.pod, offset);
398  return res;
399 }
400 
402 spa_pod_builder_array(struct spa_pod_builder *builder,
403  uint32_t child_size, uint32_t child_type, uint32_t n_elems, const void *elems)
404 {
405  const struct spa_pod_array p = {
406  {(uint32_t)(sizeof(struct spa_pod_array_body) + n_elems * child_size), SPA_TYPE_Array},
407  {{child_size, child_type}}
408  };
409  int r, res = spa_pod_builder_raw(builder, &p, sizeof(p));
410  if ((r = spa_pod_builder_raw_padded(builder, elems, child_size * n_elems)) < 0)
411  res = r;
412  return res;
413 }
414 
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) }})
417 
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__ } })
422 
424 spa_pod_builder_push_choice(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
425  uint32_t type, uint32_t flags)
426 {
427  const struct spa_pod_choice p =
428  { {sizeof(struct spa_pod_choice_body) - sizeof(struct spa_pod), SPA_TYPE_Choice},
429  { type, flags, {0, 0}} };
430  uint32_t offset = builder->state.offset;
431  int res = spa_pod_builder_raw(builder, &p, sizeof(p) - sizeof(struct spa_pod));
432  spa_pod_builder_push(builder, frame, &p.pod, offset);
433  return res;
434 }
435 
436 #define SPA_POD_INIT_Struct(size) ((struct spa_pod_struct){ { (size), SPA_TYPE_Struct } })
437 
439 spa_pod_builder_push_struct(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
440 {
441  const struct spa_pod_struct p = SPA_POD_INIT_Struct(0);
442  uint32_t offset = builder->state.offset;
443  int res = spa_pod_builder_raw(builder, &p, sizeof(p));
444  spa_pod_builder_push(builder, frame, &p.pod, offset);
445  return res;
446 }
447 
448 #define SPA_POD_INIT_Object(size,type,id,...) ((struct spa_pod_object){ { (size), SPA_TYPE_Object }, { (type), (id) }, ##__VA_ARGS__ })
449 
451 spa_pod_builder_push_object(struct spa_pod_builder *builder, struct spa_pod_frame *frame,
452  uint32_t type, uint32_t id)
453 {
454  const struct spa_pod_object p =
455  SPA_POD_INIT_Object(sizeof(struct spa_pod_object_body), type, id);
456  uint32_t offset = builder->state.offset;
457  int res = spa_pod_builder_raw(builder, &p, sizeof(p));
458  spa_pod_builder_push(builder, frame, &p.pod, offset);
459  return res;
460 }
461 
462 #define SPA_POD_INIT_Prop(key,flags,size,type) \
463  ((struct spa_pod_prop){ (key), (flags), { (size), (type) } })
464 
466 spa_pod_builder_prop(struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
467 {
468  const struct { uint32_t key; uint32_t flags; } p = { key, flags };
469  return spa_pod_builder_raw(builder, &p, sizeof(p));
470 }
471 
472 #define SPA_POD_INIT_Sequence(size,unit) \
473  ((struct spa_pod_sequence){ { (size), SPA_TYPE_Sequence}, {(unit), 0 } })
474 
476 spa_pod_builder_push_sequence(struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t unit)
477 {
478  const struct spa_pod_sequence p =
480  uint32_t offset = builder->state.offset;
481  int res = spa_pod_builder_raw(builder, &p, sizeof(p));
482  spa_pod_builder_push(builder, frame, &p.pod, offset);
483  return res;
484 }
485 
487 spa_pod_builder_control(struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
488 {
489  const struct { uint32_t offset; uint32_t type; } p = { offset, type };
490  return spa_pod_builder_raw(builder, &p, sizeof(p));
491 }
492 
493 SPA_API_POD_BUILDER uint32_t spa_choice_from_id(char id)
494 {
495  switch (id) {
496  case 'r':
497  return SPA_CHOICE_Range;
498  case 's':
499  return SPA_CHOICE_Step;
500  case 'e':
501  return SPA_CHOICE_Enum;
502  case 'f':
503  return SPA_CHOICE_Flags;
504  case 'n':
505  default:
506  return SPA_CHOICE_None;
507  }
508 }
509 
510 #define SPA_POD_BUILDER_COLLECT(builder,type,args) \
511 do { \
512  switch (type) { \
513  case 'b': \
514  spa_pod_builder_bool(builder, !!va_arg(args, int)); \
515  break; \
516  case 'I': \
517  spa_pod_builder_id(builder, va_arg(args, uint32_t)); \
518  break; \
519  case 'i': \
520  spa_pod_builder_int(builder, va_arg(args, int)); \
521  break; \
522  case 'l': \
523  spa_pod_builder_long(builder, va_arg(args, int64_t)); \
524  break; \
525  case 'f': \
526  spa_pod_builder_float(builder, (float)va_arg(args, double)); \
527  break; \
528  case 'd': \
529  spa_pod_builder_double(builder, va_arg(args, double)); \
530  break; \
531  case 's': \
532  { \
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); \
537  } \
538  else \
539  spa_pod_builder_none(builder); \
540  break; \
541  } \
542  case 'S': \
543  { \
544  char *strval = va_arg(args, char *); \
545  size_t len = va_arg(args, int); \
546  spa_pod_builder_string_len(builder, strval, len); \
547  break; \
548  } \
549  case 'y': \
550  { \
551  void *ptr = va_arg(args, void *); \
552  int len = va_arg(args, int); \
553  spa_pod_builder_bytes(builder, ptr, len); \
554  break; \
555  } \
556  case 'R': \
557  { \
558  struct spa_rectangle *rectval = \
559  va_arg(args, struct spa_rectangle *); \
560  spa_pod_builder_rectangle(builder, \
561  rectval->width, rectval->height); \
562  break; \
563  } \
564  case 'F': \
565  { \
566  struct spa_fraction *fracval = \
567  va_arg(args, struct spa_fraction *); \
568  spa_pod_builder_fraction(builder, fracval->num, fracval->denom);\
569  break; \
570  } \
571  case 'a': \
572  { \
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); \
579  break; \
580  } \
581  case 'p': \
582  { \
583  int t = va_arg(args, uint32_t); \
584  spa_pod_builder_pointer(builder, t, va_arg(args, void *)); \
585  break; \
586  } \
587  case 'h': \
588  spa_pod_builder_fd(builder, va_arg(args, int)); \
589  break; \
590  case 'P': \
591  case 'O': \
592  case 'T': \
593  case 'V': \
594  { \
595  struct spa_pod *pod = va_arg(args, struct spa_pod *); \
596  if (pod == NULL) \
597  spa_pod_builder_none(builder); \
598  else \
599  spa_pod_builder_primitive(builder, pod); \
600  break; \
601  } \
602  } \
603 } while(false)
604 
606 spa_pod_builder_addv(struct spa_pod_builder *builder, va_list args)
607 {
608  int res = 0;
609  struct spa_pod_frame *frame = builder->state.frame;
610  uint32_t ftype = frame ? frame->pod.type : (uint32_t)SPA_TYPE_None;
611 
612  do {
613  const char *format;
614  int n_values = 1;
615  struct spa_pod_frame f;
616  bool choice;
617 
618  switch (ftype) {
619  case SPA_TYPE_Object:
620  {
621  uint32_t key = va_arg(args, uint32_t);
622  if (key == 0)
623  goto exit;
624  spa_pod_builder_prop(builder, key, 0);
625  break;
626  }
627  case SPA_TYPE_Sequence:
628  {
629  uint32_t offset = va_arg(args, uint32_t);
630  uint32_t type = va_arg(args, uint32_t);
631  if (type == 0)
632  goto exit;
633  spa_pod_builder_control(builder, offset, type);
635  }
636  default:
637  break;
638  }
639  if ((format = va_arg(args, const char *)) == NULL)
640  break;
641 
642  choice = *format == '?';
643  if (choice) {
644  uint32_t type = spa_choice_from_id(*++format);
645  if (*format != '\0')
646  format++;
647 
648  spa_pod_builder_push_choice(builder, &f, type, 0);
649 
650  n_values = va_arg(args, int);
651  }
652  while (n_values-- > 0)
653  SPA_POD_BUILDER_COLLECT(builder, *format, args);
654 
655  if (choice)
656  spa_pod_builder_pop(builder, &f);
657  } while (true);
658 
659  exit:
660  return res;
661 }
662 
664 {
665  int res;
666  va_list args;
667 
668  va_start(args, builder);
669  res = spa_pod_builder_addv(builder, args);
670  va_end(args);
671 
672  return res;
673 }
674 
675 #define spa_pod_builder_add_object(b,type,id,...) \
676 ({ \
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); \
682 })
683 
684 #define spa_pod_builder_add_struct(b,...) \
685 ({ \
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); \
691 })
692 
693 #define spa_pod_builder_add_sequence(b,unit,...) \
694 ({ \
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); \
700 })
701 
704 spa_pod_copy(const struct spa_pod *pod)
705 {
706  size_t size;
707  struct spa_pod *c;
708 
709  size = SPA_POD_SIZE(pod);
710  if ((c = (struct spa_pod *) malloc(size)) == NULL)
711  return NULL;
712  return (struct spa_pod *) memcpy(c, pod, size);
713 }
714 
719 #ifdef __cplusplus
720 } /* extern "C" */
721 #endif
722 
723 #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:445
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:291
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
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(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
#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 int spa_pod_builder_bytes(struct spa_pod_builder *builder, const void *bytes, uint32_t len)
Definition: builder.h:334
SPA_API_POD_BUILDER void * spa_pod_builder_reserve_bytes(struct spa_pod_builder *builder, uint32_t len)
Definition: builder.h:343
#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
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
#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 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
SPA_API_POD_BUILDER void * spa_pod_builder_pop(struct spa_pod_builder *builder, struct spa_pod_frame *frame)
Definition: builder.h:187
#define SPA_POD_BUILDER_FLAG_FIRST
Definition: builder.h:47
#define SPA_POD_SIZE(pod)
Definition: pod.h:30
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 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
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
void * data
Definition: hook.h:128
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