PipeWire  1.4.5
parser.h
Go to the documentation of this file.
1 /* Spa */
2 /* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
3 /* SPDX-License-Identifier: MIT */
4 
5 #ifndef SPA_POD_PARSER_H
6 #define SPA_POD_PARSER_H
7 
8 #ifdef __cplusplus
9 extern "C" {
10 #endif
11 
12 #include <errno.h>
13 #include <stdarg.h>
14 
15 #include <spa/pod/iter.h>
16 #include <spa/pod/vararg.h>
17 
18 #ifndef SPA_API_POD_PARSER
19  #ifdef SPA_API_IMPL
20  #define SPA_API_POD_PARSER SPA_API_IMPL
21  #else
22  #define SPA_API_POD_PARSER static inline
23  #endif
24 #endif
25 
31 struct spa_pod_parser_state {
32  uint32_t offset;
33  uint32_t flags;
34  struct spa_pod_frame *frame;
35 };
36 
37 struct spa_pod_parser {
38  const void *data;
39  uint32_t size;
40  uint32_t _padding;
42 };
43 
44 #define SPA_POD_PARSER_INIT(buffer,size) ((struct spa_pod_parser){ (buffer), (size), 0, {0,0,NULL}})
45 
47  const void *data, uint32_t size)
48 {
49  *parser = SPA_POD_PARSER_INIT(data, size);
50 }
51 
53  const struct spa_pod *pod)
54 {
55  spa_pod_parser_init(parser, pod, SPA_POD_SIZE(pod));
56 }
57 
60 {
61  *state = parser->state;
62 }
63 
65 spa_pod_parser_reset(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
66 {
67  parser->state = *state;
68 }
69 
71 spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
72 {
73  /* Cast to uint64_t to avoid wraparound. Add 8 for the pod itself. */
74  const uint64_t long_offset = (uint64_t)offset + 8;
75  if (long_offset <= size && (offset & 7) == 0) {
76  /* Use void* because creating a misaligned pointer is undefined. */
77  void *pod = SPA_PTROFF(parser->data, offset, void);
78  /*
79  * Check that the pointer is aligned and that the size (rounded
80  * to the next multiple of 8) is in bounds.
81  */
82  if (SPA_IS_ALIGNED(pod, __alignof__(struct spa_pod)) &&
83  long_offset + SPA_ROUND_UP_N((uint64_t)SPA_POD_BODY_SIZE(pod), 8) <= size)
84  return (struct spa_pod *)pod;
85  }
86  return NULL;
87 }
88 
89 SPA_API_POD_PARSER struct spa_pod *spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
90 {
91  return SPA_PTROFF(parser->data, frame->offset, struct spa_pod);
92 }
93 
95  struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
96 {
97  frame->pod = *pod;
98  frame->offset = offset;
99  frame->parent = parser->state.frame;
100  frame->flags = parser->state.flags;
101  parser->state.frame = frame;
102 }
103 
105 {
106  struct spa_pod_frame *f = parser->state.frame;
107  uint32_t size = f ? f->offset + SPA_POD_SIZE(&f->pod) : parser->size;
108  return spa_pod_parser_deref(parser, parser->state.offset, size);
109 }
110 
111 SPA_API_POD_PARSER void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
112 {
113  parser->state.offset += SPA_ROUND_UP_N(SPA_POD_SIZE(pod), 8);
114 }
115 
117 {
118  struct spa_pod *pod = spa_pod_parser_current(parser);
119  if (pod)
120  spa_pod_parser_advance(parser, pod);
121  return pod;
122 }
123 
125  struct spa_pod_frame *frame)
126 {
127  parser->state.frame = frame->parent;
128  parser->state.offset = frame->offset + SPA_ROUND_UP_N(SPA_POD_SIZE(&frame->pod), 8);
129  return 0;
130 }
131 
133 {
134  int res = -EPIPE;
135  const struct spa_pod *pod = spa_pod_parser_current(parser);
136  if (pod != NULL && (res = spa_pod_get_bool(pod, value)) >= 0)
137  spa_pod_parser_advance(parser, pod);
138  return res;
139 }
140 
141 SPA_API_POD_PARSER int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
142 {
143  int res = -EPIPE;
144  const struct spa_pod *pod = spa_pod_parser_current(parser);
145  if (pod != NULL && (res = spa_pod_get_id(pod, value)) >= 0)
146  spa_pod_parser_advance(parser, pod);
147  return res;
148 }
149 
150 SPA_API_POD_PARSER int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
151 {
152  int res = -EPIPE;
153  const struct spa_pod *pod = spa_pod_parser_current(parser);
154  if (pod != NULL && (res = spa_pod_get_int(pod, value)) >= 0)
155  spa_pod_parser_advance(parser, pod);
156  return res;
157 }
158 
159 SPA_API_POD_PARSER int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
160 {
161  int res = -EPIPE;
162  const struct spa_pod *pod = spa_pod_parser_current(parser);
163  if (pod != NULL && (res = spa_pod_get_long(pod, value)) >= 0)
164  spa_pod_parser_advance(parser, pod);
165  return res;
166 }
167 
168 SPA_API_POD_PARSER int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
169 {
170  int res = -EPIPE;
171  const struct spa_pod *pod = spa_pod_parser_current(parser);
172  if (pod != NULL && (res = spa_pod_get_float(pod, value)) >= 0)
173  spa_pod_parser_advance(parser, pod);
174  return res;
175 }
176 
177 SPA_API_POD_PARSER int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
178 {
179  int res = -EPIPE;
180  const struct spa_pod *pod = spa_pod_parser_current(parser);
181  if (pod != NULL && (res = spa_pod_get_double(pod, value)) >= 0)
182  spa_pod_parser_advance(parser, pod);
183  return res;
184 }
185 
186 SPA_API_POD_PARSER int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
187 {
188  int res = -EPIPE;
189  const struct spa_pod *pod = spa_pod_parser_current(parser);
190  if (pod != NULL && (res = spa_pod_get_string(pod, value)) >= 0)
191  spa_pod_parser_advance(parser, pod);
192  return res;
193 }
194 
195 SPA_API_POD_PARSER int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
196 {
197  int res = -EPIPE;
198  const struct spa_pod *pod = spa_pod_parser_current(parser);
199  if (pod != NULL && (res = spa_pod_get_bytes(pod, value, len)) >= 0)
200  spa_pod_parser_advance(parser, pod);
201  return res;
202 }
203 
204 SPA_API_POD_PARSER int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
205 {
206  int res = -EPIPE;
207  const struct spa_pod *pod = spa_pod_parser_current(parser);
208  if (pod != NULL && (res = spa_pod_get_pointer(pod, type, value)) >= 0)
209  spa_pod_parser_advance(parser, pod);
210  return res;
211 }
212 
213 SPA_API_POD_PARSER int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
214 {
215  int res = -EPIPE;
216  const struct spa_pod *pod = spa_pod_parser_current(parser);
217  if (pod != NULL && (res = spa_pod_get_fd(pod, value)) >= 0)
218  spa_pod_parser_advance(parser, pod);
219  return res;
220 }
221 
223 {
224  int res = -EPIPE;
225  const struct spa_pod *pod = spa_pod_parser_current(parser);
226  if (pod != NULL && (res = spa_pod_get_rectangle(pod, value)) >= 0)
227  spa_pod_parser_advance(parser, pod);
228  return res;
229 }
230 
232 {
233  int res = -EPIPE;
234  const struct spa_pod *pod = spa_pod_parser_current(parser);
235  if (pod != NULL && (res = spa_pod_get_fraction(pod, value)) >= 0)
236  spa_pod_parser_advance(parser, pod);
237  return res;
238 }
239 
240 SPA_API_POD_PARSER int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
241 {
242  struct spa_pod *pod = spa_pod_parser_current(parser);
243  if (pod == NULL)
244  return -EPIPE;
245  *value = pod;
246  spa_pod_parser_advance(parser, pod);
247  return 0;
248 }
250  struct spa_pod_frame *frame)
251 {
252  const struct spa_pod *pod = spa_pod_parser_current(parser);
253  if (pod == NULL)
254  return -EPIPE;
255  if (!spa_pod_is_struct(pod))
256  return -EINVAL;
257  spa_pod_parser_push(parser, frame, pod, parser->state.offset);
258  parser->state.offset += sizeof(struct spa_pod_struct);
259  return 0;
260 }
261 
263  struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
264 {
265  const struct spa_pod *pod = spa_pod_parser_current(parser);
266  if (pod == NULL)
267  return -EPIPE;
268  if (!spa_pod_is_object(pod))
269  return -EINVAL;
271  return -EPROTO;
272  if (id != NULL)
273  *id = SPA_POD_OBJECT_ID(pod);
274  spa_pod_parser_push(parser, frame, pod, parser->state.offset);
275  parser->state.offset = parser->size;
276  return 0;
277 }
278 
279 SPA_API_POD_PARSER bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
280 {
281  if (pod == NULL)
282  return false;
283 
284  if (SPA_POD_TYPE(pod) == SPA_TYPE_Choice) {
285  if (!spa_pod_is_choice(pod))
286  return false;
287  if (type == 'V')
288  return true;
290  return false;
291  pod = SPA_POD_CHOICE_CHILD(pod);
292  }
293 
294  switch (type) {
295  case 'P':
296  return true;
297  case 'b':
298  return spa_pod_is_bool(pod);
299  case 'I':
300  return spa_pod_is_id(pod);
301  case 'i':
302  return spa_pod_is_int(pod);
303  case 'l':
304  return spa_pod_is_long(pod);
305  case 'f':
306  return spa_pod_is_float(pod);
307  case 'd':
308  return spa_pod_is_double(pod);
309  case 's':
310  return spa_pod_is_string(pod) || spa_pod_is_none(pod);
311  case 'S':
312  return spa_pod_is_string(pod);
313  case 'y':
314  return spa_pod_is_bytes(pod);
315  case 'R':
316  return spa_pod_is_rectangle(pod);
317  case 'F':
318  return spa_pod_is_fraction(pod);
319  case 'B':
320  return spa_pod_is_bitmap(pod);
321  case 'a':
322  return spa_pod_is_array(pod);
323  case 'p':
324  return spa_pod_is_pointer(pod);
325  case 'h':
326  return spa_pod_is_fd(pod);
327  case 'T':
328  return spa_pod_is_struct(pod) || spa_pod_is_none(pod);
329  case 'O':
330  return spa_pod_is_object(pod) || spa_pod_is_none(pod);
331  case 'V':
332  default:
333  return false;
334  }
335 }
336 
337 #define SPA_POD_PARSER_COLLECT(pod,_type,args) \
338 do { \
339  switch (_type) { \
340  case 'b': \
341  *va_arg(args, bool*) = SPA_POD_VALUE(struct spa_pod_bool, pod); \
342  break; \
343  case 'I': \
344  case 'i': \
345  *va_arg(args, int32_t*) = SPA_POD_VALUE(struct spa_pod_int, pod); \
346  break; \
347  case 'l': \
348  *va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_long, pod); \
349  break; \
350  case 'f': \
351  *va_arg(args, float*) = SPA_POD_VALUE(struct spa_pod_float, pod); \
352  break; \
353  case 'd': \
354  *va_arg(args, double*) = SPA_POD_VALUE(struct spa_pod_double, pod); \
355  break; \
356  case 's': \
357  *va_arg(args, char**) = \
358  ((pod) == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None) \
359  ? NULL \
360  : (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod)); \
361  break; \
362  case 'S': \
363  { \
364  char *dest = va_arg(args, char*); \
365  uint32_t maxlen = va_arg(args, uint32_t); \
366  strncpy(dest, (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod), maxlen-1); \
367  dest[maxlen-1] = '\0'; \
368  break; \
369  } \
370  case 'y': \
371  *(va_arg(args, void **)) = SPA_POD_CONTENTS(struct spa_pod_bytes, pod); \
372  *(va_arg(args, uint32_t *)) = SPA_POD_BODY_SIZE(pod); \
373  break; \
374  case 'R': \
375  *va_arg(args, struct spa_rectangle*) = \
376  SPA_POD_VALUE(struct spa_pod_rectangle, pod); \
377  break; \
378  case 'F': \
379  *va_arg(args, struct spa_fraction*) = \
380  SPA_POD_VALUE(struct spa_pod_fraction, pod); \
381  break; \
382  case 'B': \
383  *va_arg(args, uint32_t **) = \
384  (uint32_t *) SPA_POD_CONTENTS(struct spa_pod_bitmap, pod); \
385  break; \
386  case 'a': \
387  *va_arg(args, uint32_t*) = SPA_POD_ARRAY_VALUE_SIZE(pod); \
388  *va_arg(args, uint32_t*) = SPA_POD_ARRAY_VALUE_TYPE(pod); \
389  *va_arg(args, uint32_t*) = SPA_POD_ARRAY_N_VALUES(pod); \
390  *va_arg(args, void**) = SPA_POD_ARRAY_VALUES(pod); \
391  break; \
392  case 'p': \
393  { \
394  struct spa_pod_pointer_body *b = \
395  (struct spa_pod_pointer_body *) SPA_POD_BODY(pod); \
396  *(va_arg(args, uint32_t *)) = b->type; \
397  *(va_arg(args, const void **)) = b->value; \
398  break; \
399  } \
400  case 'h': \
401  *va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_fd, pod); \
402  break; \
403  case 'P': \
404  case 'T': \
405  case 'O': \
406  case 'V': \
407  { \
408  const struct spa_pod **d = va_arg(args, const struct spa_pod**); \
409  if (d) \
410  *d = ((pod) == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None) \
411  ? NULL : (pod)); \
412  break; \
413  } \
414  default: \
415  break; \
416  } \
417 } while(false)
418 
419 #define SPA_POD_PARSER_SKIP(_type,args) \
420 do { \
421  switch (_type) { \
422  case 'S': \
423  va_arg(args, char*); \
424  va_arg(args, uint32_t); \
425  break; \
426  case 'a': \
427  va_arg(args, void*); \
428  va_arg(args, void*); \
429  SPA_FALLTHROUGH \
430  case 'p': \
431  case 'y': \
432  va_arg(args, void*); \
433  SPA_FALLTHROUGH \
434  case 'b': \
435  case 'I': \
436  case 'i': \
437  case 'l': \
438  case 'f': \
439  case 'd': \
440  case 's': \
441  case 'R': \
442  case 'F': \
443  case 'B': \
444  case 'h': \
445  case 'V': \
446  case 'P': \
447  case 'T': \
448  case 'O': \
449  va_arg(args, void*); \
450  break; \
451  } \
452 } while(false)
453 
454 SPA_API_POD_PARSER int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
455 {
456  struct spa_pod_frame *f = parser->state.frame;
457  uint32_t ftype = f ? f->pod.type : (uint32_t)SPA_TYPE_Struct;
458  const struct spa_pod_prop *prop = NULL;
459  int count = 0;
460 
461  do {
462  bool optional;
463  const struct spa_pod *pod = NULL;
464  const char *format;
465 
466  if (f && ftype == SPA_TYPE_Object) {
467  uint32_t key = va_arg(args, uint32_t);
468  const struct spa_pod_object *object;
469 
470  if (key == 0)
471  break;
472 
473  object = (const struct spa_pod_object *)spa_pod_parser_frame(parser, f);
474  prop = spa_pod_object_find_prop(object, prop, key);
475  pod = prop ? &prop->value : NULL;
476  }
477 
478  if ((format = va_arg(args, char *)) == NULL)
479  break;
480 
481  if (ftype == SPA_TYPE_Struct)
482  pod = spa_pod_parser_next(parser);
483 
484  if ((optional = (*format == '?')))
485  format++;
486 
487  if (!spa_pod_parser_can_collect(pod, *format)) {
488  if (!optional) {
489  if (pod == NULL)
490  return -ESRCH;
491  else
492  return -EPROTO;
493  }
494  SPA_POD_PARSER_SKIP(*format, args);
495  } else {
496  if (pod->type == SPA_TYPE_Choice && *format != 'V')
498 
499  SPA_POD_PARSER_COLLECT(pod, *format, args);
500  count++;
501  }
502  } while (true);
503 
504  return count;
505 }
506 
508 {
509  int res;
510  va_list args;
511 
512  va_start(args, parser);
513  res = spa_pod_parser_getv(parser, args);
514  va_end(args);
515 
516  return res;
517 }
518 
519 #define SPA_POD_OPT_Bool(val) "?" SPA_POD_Bool(val)
520 #define SPA_POD_OPT_Id(val) "?" SPA_POD_Id(val)
521 #define SPA_POD_OPT_Int(val) "?" SPA_POD_Int(val)
522 #define SPA_POD_OPT_Long(val) "?" SPA_POD_Long(val)
523 #define SPA_POD_OPT_Float(val) "?" SPA_POD_Float(val)
524 #define SPA_POD_OPT_Double(val) "?" SPA_POD_Double(val)
525 #define SPA_POD_OPT_String(val) "?" SPA_POD_String(val)
526 #define SPA_POD_OPT_Stringn(val,len) "?" SPA_POD_Stringn(val,len)
527 #define SPA_POD_OPT_Bytes(val,len) "?" SPA_POD_Bytes(val,len)
528 #define SPA_POD_OPT_Rectangle(val) "?" SPA_POD_Rectangle(val)
529 #define SPA_POD_OPT_Fraction(val) "?" SPA_POD_Fraction(val)
530 #define SPA_POD_OPT_Array(csize,ctype,n_vals,vals) "?" SPA_POD_Array(csize,ctype,n_vals,vals)
531 #define SPA_POD_OPT_Pointer(type,val) "?" SPA_POD_Pointer(type,val)
532 #define SPA_POD_OPT_Fd(val) "?" SPA_POD_Fd(val)
533 #define SPA_POD_OPT_Pod(val) "?" SPA_POD_Pod(val)
534 #define SPA_POD_OPT_PodObject(val) "?" SPA_POD_PodObject(val)
535 #define SPA_POD_OPT_PodStruct(val) "?" SPA_POD_PodStruct(val)
536 #define SPA_POD_OPT_PodChoice(val) "?" SPA_POD_PodChoice(val)
537 
538 #define spa_pod_parser_get_object(p,type,id,...) \
539 ({ \
540  struct spa_pod_frame _f; \
541  int _res; \
542  if ((_res = spa_pod_parser_push_object(p, &_f, type, id)) == 0) { \
543  _res = spa_pod_parser_get(p,##__VA_ARGS__, 0); \
544  spa_pod_parser_pop(p, &_f); \
545  } \
546  _res; \
547 })
548 
549 #define spa_pod_parser_get_struct(p,...) \
550 ({ \
551  struct spa_pod_frame _f; \
552  int _res; \
553  if ((_res = spa_pod_parser_push_struct(p, &_f)) == 0) { \
554  _res = spa_pod_parser_get(p,##__VA_ARGS__, NULL); \
555  spa_pod_parser_pop(p, &_f); \
556  } \
557  _res; \
558 })
559 
560 #define spa_pod_parse_object(pod,type,id,...) \
561 ({ \
562  struct spa_pod_parser _p; \
563  spa_pod_parser_pod(&_p, pod); \
564  spa_pod_parser_get_object(&_p,type,id,##__VA_ARGS__); \
565 })
566 
567 #define spa_pod_parse_struct(pod,...) \
568 ({ \
569  struct spa_pod_parser _p; \
570  spa_pod_parser_pod(&_p, pod); \
571  spa_pod_parser_get_struct(&_p,##__VA_ARGS__); \
572 })
573 
578 #ifdef __cplusplus
579 } /* extern "C" */
580 #endif
581 
582 #endif /* SPA_POD_PARSER_H */
uint32_t int int const char va_list args
Definition: core.h:434
va_end(args)
uint32_t int int res
Definition: core.h:433
va_start(args, message)
SPA_API_POD_PARSER void spa_pod_parser_push(struct spa_pod_parser *parser, struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
Definition: parser.h:102
SPA_API_POD_PARSER int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
Definition: parser.h:167
SPA_API_POD_ITER int spa_pod_is_long(const struct spa_pod *pod)
Definition: iter.h:191
SPA_API_POD_ITER int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
Definition: iter.h:183
SPA_API_POD_PARSER int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
Definition: parser.h:158
SPA_API_POD_PARSER int spa_pod_parser_pop(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:132
SPA_API_POD_ITER int spa_pod_is_int(const struct spa_pod *pod)
Definition: iter.h:178
SPA_API_POD_ITER int spa_pod_is_fraction(const struct spa_pod *pod)
Definition: iter.h:313
SPA_API_POD_PARSER void spa_pod_parser_pod(struct spa_pod_parser *parser, const struct spa_pod *pod)
Definition: parser.h:60
SPA_API_POD_PARSER int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
Definition: parser.h:212
SPA_API_POD_PARSER int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
Definition: parser.h:239
SPA_API_POD_ITER int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type, const void **value)
Definition: iter.h:276
SPA_API_POD_ITER int spa_pod_is_choice(const struct spa_pod *pod)
Definition: iter.h:357
SPA_API_POD_ITER int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
Definition: iter.h:170
SPA_API_POD_PARSER struct spa_pod * spa_pod_parser_current(struct spa_pod_parser *parser)
Definition: parser.h:112
SPA_API_POD_PARSER void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
Definition: parser.h:119
SPA_API_POD_ITER int spa_pod_get_bytes(const struct spa_pod *pod, const void **value, uint32_t *len)
Definition: iter.h:261
SPA_API_POD_ITER int spa_pod_is_float(const struct spa_pod *pod)
Definition: iter.h:204
SPA_API_POD_ITER int spa_pod_is_id(const struct spa_pod *pod)
Definition: iter.h:165
SPA_API_POD_PARSER int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
Definition: parser.h:203
SPA_API_POD_PARSER void spa_pod_parser_reset(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
Definition: parser.h:73
#define SPA_POD_TYPE(pod)
Definition: pod.h:28
SPA_API_POD_PARSER int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
Definition: parser.h:462
SPA_API_POD_ITER int spa_pod_is_pointer(const struct spa_pod *pod)
Definition: iter.h:270
SPA_API_POD_PARSER int spa_pod_parser_push_object(struct spa_pod_parser *parser, struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
Definition: parser.h:270
SPA_API_POD_PARSER int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
Definition: parser.h:185
SPA_API_POD_ITER const struct spa_pod_prop * spa_pod_object_find_prop(const struct spa_pod_object *pod, const struct spa_pod_prop *start, uint32_t key)
Definition: iter.h:404
SPA_API_POD_ITER int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
Definition: iter.h:291
SPA_API_POD_ITER int spa_pod_is_none(const struct spa_pod *pod)
Definition: iter.h:147
SPA_API_POD_PARSER struct spa_pod * spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:97
#define SPA_POD_BODY_SIZE(pod)
Definition: pod.h:26
SPA_API_POD_ITER int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
Definition: iter.h:196
SPA_API_POD_ITER int spa_pod_get_float(const struct spa_pod *pod, float *value)
Definition: iter.h:209
SPA_API_POD_PARSER bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
Definition: parser.h:287
SPA_API_POD_PARSER int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
Definition: parser.h:221
SPA_API_POD_ITER int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
Definition: iter.h:157
#define SPA_POD_PARSER_COLLECT(pod, _type, args)
Definition: parser.h:345
SPA_API_POD_PARSER int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
Definition: parser.h:140
SPA_API_POD_ITER int spa_pod_is_object(const struct spa_pod *pod)
Definition: iter.h:382
SPA_API_POD_PARSER int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
Definition: parser.h:248
SPA_API_POD_PARSER int spa_pod_parser_push_struct(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:257
SPA_API_POD_ITER int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rectangle *value)
Definition: iter.h:305
SPA_API_POD_ITER int spa_pod_get_double(const struct spa_pod *pod, double *value)
Definition: iter.h:222
#define SPA_POD_PARSER_SKIP(_type, args)
Definition: parser.h:427
SPA_API_POD_PARSER int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
Definition: parser.h:176
SPA_API_POD_ITER int spa_pod_is_struct(const struct spa_pod *pod)
Definition: iter.h:377
SPA_API_POD_ITER int spa_pod_is_fd(const struct spa_pod *pod)
Definition: iter.h:285
SPA_API_POD_PARSER struct spa_pod * spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
Definition: parser.h:79
SPA_API_POD_ITER int spa_pod_is_string(const struct spa_pod *pod)
Definition: iter.h:230
SPA_API_POD_PARSER void spa_pod_parser_get_state(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
Definition: parser.h:67
SPA_API_POD_PARSER int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
Definition: parser.h:194
#define SPA_POD_PARSER_INIT(buffer, size)
Definition: parser.h:52
SPA_API_POD_ITER int spa_pod_is_bool(const struct spa_pod *pod)
Definition: iter.h:152
SPA_API_POD_ITER int spa_pod_is_bitmap(const struct spa_pod *pod)
Definition: iter.h:326
SPA_API_POD_PARSER int spa_pod_parser_get(struct spa_pod_parser *parser,...)
Definition: parser.h:515
#define SPA_POD_OBJECT_TYPE(obj)
Definition: pod.h:173
#define SPA_POD_OBJECT_ID(obj)
Definition: pod.h:175
SPA_API_POD_PARSER void spa_pod_parser_init(struct spa_pod_parser *parser, const void *data, uint32_t size)
Definition: parser.h:54
SPA_API_POD_ITER int spa_pod_get_string(const struct spa_pod *pod, const char **value)
Definition: iter.h:238
SPA_API_POD_PARSER int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
Definition: parser.h:230
SPA_API_POD_PARSER struct spa_pod * spa_pod_parser_next(struct spa_pod_parser *parser)
Definition: parser.h:124
SPA_API_POD_ITER int spa_pod_is_bytes(const struct spa_pod *pod)
Definition: iter.h:256
#define SPA_POD_SIZE(pod)
Definition: pod.h:30
SPA_API_POD_ITER int spa_pod_is_double(const struct spa_pod *pod)
Definition: iter.h:217
SPA_API_POD_PARSER int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
Definition: parser.h:149
#define SPA_POD_CHOICE_CHILD(choice)
Definition: pod.h:132
SPA_API_POD_ITER int spa_pod_get_fraction(const struct spa_pod *pod, struct spa_fraction *value)
Definition: iter.h:319
#define SPA_POD_CHOICE_TYPE(choice)
Definition: pod.h:134
SPA_API_POD_ITER int spa_pod_is_array(const struct spa_pod *pod)
Definition: iter.h:332
SPA_API_POD_ITER int spa_pod_is_rectangle(const struct spa_pod *pod)
Definition: iter.h:299
@ SPA_CHOICE_None
no choice, first value is current
Definition: pod.h:147
@ SPA_TYPE_Object
Definition: type.h:56
@ SPA_TYPE_Choice
Definition: type.h:60
@ SPA_TYPE_Struct
Definition: type.h:55
#define SPA_ROUND_UP_N(num, align)
Definition: defs.h:360
#define SPA_IS_ALIGNED(p, align)
Definition: defs.h:380
#define SPA_PTROFF(ptr_, offset_, type_)
Return the address (buffer + offset) as pointer of type.
Definition: defs.h:222
spa/pod/iter.h
#define SPA_API_POD_PARSER
Definition: parser.h:29
Definition: defs.h:137
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:183
struct spa_pod pod
Definition: pod.h:184
Definition: parser.h:38
uint32_t offset
Definition: parser.h:39
uint32_t flags
Definition: parser.h:40
struct spa_pod_frame * frame
Definition: parser.h:41
Definition: parser.h:44
uint32_t size
Definition: parser.h:46
struct spa_pod_parser_state state
Definition: parser.h:48
const void * data
Definition: parser.h:45
uint32_t _padding
Definition: parser.h:47
Definition: pod.h:208
struct spa_pod value
Definition: pod.h:226
Definition: pod.h:167
Definition: pod.h:43
uint32_t type
Definition: pod.h:45
uint32_t size
Definition: pod.h:44
Definition: defs.h:116
spa/pod/vararg.h