PipeWire 0.3.38
parser.h
Go to the documentation of this file.
1/* Spa
2 *
3 * Copyright © 2018 Wim Taymans
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24
25#ifndef SPA_POD_PARSER_H
26#define SPA_POD_PARSER_H
27
28#ifdef __cplusplus
29extern "C" {
30#endif
31
32#include <errno.h>
33#include <stdarg.h>
34
35#include <spa/pod/iter.h>
36#include <spa/pod/vararg.h>
37
44 uint32_t offset;
45 uint32_t flags;
47};
48
50 const void *data;
51 uint32_t size;
52 uint32_t _padding;
54};
55
56#define SPA_POD_PARSER_INIT(buffer,size) (struct spa_pod_parser){ buffer, size, 0, {} }
57
58/* static */ inline void spa_pod_parser_init(struct spa_pod_parser *parser,
59 const void *data, uint32_t size)
60{
61 *parser = SPA_POD_PARSER_INIT(data, size);
62}
63
64/* static */ inline void spa_pod_parser_pod(struct spa_pod_parser *parser,
65 const struct spa_pod *pod)
66{
67 spa_pod_parser_init(parser, pod, SPA_POD_SIZE(pod));
68}
69
70/* static */ inline void
72{
73 *state = parser->state;
74}
75
76/* static */ inline void
78{
79 parser->state = *state;
80}
81
82/* static */ inline struct spa_pod *
83spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
84{
85 if (offset + 8 <= size) {
86 struct spa_pod *pod = SPA_PTROFF(parser->data, offset, struct spa_pod);
87 if (offset + SPA_POD_SIZE(pod) <= size)
88 return pod;
89 }
90 return NULL;
91}
92
93/* static */ inline struct spa_pod *spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
94{
95 return SPA_PTROFF(parser->data, frame->offset, struct spa_pod);
96}
97
98/* static */ inline void spa_pod_parser_push(struct spa_pod_parser *parser,
99 struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
100{
101 frame->pod = *pod;
102 frame->offset = offset;
103 frame->parent = parser->state.frame;
104 frame->flags = parser->state.flags;
105 parser->state.frame = frame;
106}
107
108/* static */ inline struct spa_pod *spa_pod_parser_current(struct spa_pod_parser *parser)
109{
110 struct spa_pod_frame *f = parser->state.frame;
111 uint32_t size = f ? f->offset + SPA_POD_SIZE(&f->pod) : parser->size;
112 return spa_pod_parser_deref(parser, parser->state.offset, size);
113}
114
115/* static */ inline void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
116{
118}
119
120/* static */ inline struct spa_pod *spa_pod_parser_next(struct spa_pod_parser *parser)
121{
122 struct spa_pod *pod = spa_pod_parser_current(parser);
123 if (pod)
124 spa_pod_parser_advance(parser, pod);
125 return pod;
126}
127
128/* static */ inline int spa_pod_parser_pop(struct spa_pod_parser *parser,
129 struct spa_pod_frame *frame)
130{
131 parser->state.frame = frame->parent;
132 parser->state.offset = frame->offset + SPA_ROUND_UP_N(SPA_POD_SIZE(&frame->pod), 8);
133 return 0;
134}
135
136/* static */ inline int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
137{
138 int res = -EPIPE;
139 const struct spa_pod *pod = spa_pod_parser_current(parser);
140 if (pod != NULL && (res = spa_pod_get_bool(pod, value)) >= 0)
141 spa_pod_parser_advance(parser, pod);
142 return res;
143}
144
145/* static */ inline int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
146{
147 int res = -EPIPE;
148 const struct spa_pod *pod = spa_pod_parser_current(parser);
149 if (pod != NULL && (res = spa_pod_get_id(pod, value)) >= 0)
150 spa_pod_parser_advance(parser, pod);
151 return res;
152}
153
154/* static */ inline int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
155{
156 int res = -EPIPE;
157 const struct spa_pod *pod = spa_pod_parser_current(parser);
158 if (pod != NULL && (res = spa_pod_get_int(pod, value)) >= 0)
159 spa_pod_parser_advance(parser, pod);
160 return res;
161}
162
163/* static */ inline int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
164{
165 int res = -EPIPE;
166 const struct spa_pod *pod = spa_pod_parser_current(parser);
167 if (pod != NULL && (res = spa_pod_get_long(pod, value)) >= 0)
168 spa_pod_parser_advance(parser, pod);
169 return res;
170}
171
172/* static */ inline int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
173{
174 int res = -EPIPE;
175 const struct spa_pod *pod = spa_pod_parser_current(parser);
176 if (pod != NULL && (res = spa_pod_get_float(pod, value)) >= 0)
177 spa_pod_parser_advance(parser, pod);
178 return res;
179}
180
181/* static */ inline int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
182{
183 int res = -EPIPE;
184 const struct spa_pod *pod = spa_pod_parser_current(parser);
185 if (pod != NULL && (res = spa_pod_get_double(pod, value)) >= 0)
186 spa_pod_parser_advance(parser, pod);
187 return res;
188}
189
190/* static */ inline int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
191{
192 int res = -EPIPE;
193 const struct spa_pod *pod = spa_pod_parser_current(parser);
194 if (pod != NULL && (res = spa_pod_get_string(pod, value)) >= 0)
195 spa_pod_parser_advance(parser, pod);
196 return res;
197}
198
199/* static */ inline int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
200{
201 int res = -EPIPE;
202 const struct spa_pod *pod = spa_pod_parser_current(parser);
203 if (pod != NULL && (res = spa_pod_get_bytes(pod, value, len)) >= 0)
204 spa_pod_parser_advance(parser, pod);
205 return res;
206}
207
208/* static */ inline int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
209{
210 int res = -EPIPE;
211 const struct spa_pod *pod = spa_pod_parser_current(parser);
212 if (pod != NULL && (res = spa_pod_get_pointer(pod, type, value)) >= 0)
213 spa_pod_parser_advance(parser, pod);
214 return res;
215}
216
217/* static */ inline int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
218{
219 int res = -EPIPE;
220 const struct spa_pod *pod = spa_pod_parser_current(parser);
221 if (pod != NULL && (res = spa_pod_get_fd(pod, value)) >= 0)
222 spa_pod_parser_advance(parser, pod);
223 return res;
224}
225
226/* static */ inline int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
227{
228 int res = -EPIPE;
229 const struct spa_pod *pod = spa_pod_parser_current(parser);
230 if (pod != NULL && (res = spa_pod_get_rectangle(pod, value)) >= 0)
231 spa_pod_parser_advance(parser, pod);
232 return res;
233}
234
235/* static */ inline int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
236{
237 int res = -EPIPE;
238 const struct spa_pod *pod = spa_pod_parser_current(parser);
239 if (pod != NULL && (res = spa_pod_get_fraction(pod, value)) >= 0)
240 spa_pod_parser_advance(parser, pod);
241 return res;
242}
243
244/* static */ inline int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
245{
246 struct spa_pod *pod = spa_pod_parser_current(parser);
247 if (pod == NULL)
248 return -EPIPE;
249 *value = pod;
250 spa_pod_parser_advance(parser, pod);
251 return 0;
252}
253/* static */ inline int spa_pod_parser_push_struct(struct spa_pod_parser *parser,
254 struct spa_pod_frame *frame)
255{
256 const struct spa_pod *pod = spa_pod_parser_current(parser);
257 if (pod == NULL)
258 return -EPIPE;
259 if (!spa_pod_is_struct(pod))
260 return -EINVAL;
261 spa_pod_parser_push(parser, frame, pod, parser->state.offset);
262 parser->state.offset += sizeof(struct spa_pod_struct);
263 return 0;
264}
265
266/* static */ inline int spa_pod_parser_push_object(struct spa_pod_parser *parser,
267 struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
268{
269 const struct spa_pod *pod = spa_pod_parser_current(parser);
270 if (pod == NULL)
271 return -EPIPE;
272 if (!spa_pod_is_object(pod))
273 return -EINVAL;
274 if (type != SPA_POD_OBJECT_TYPE(pod))
275 return -EPROTO;
276 if (id != NULL)
277 *id = SPA_POD_OBJECT_ID(pod);
278 spa_pod_parser_push(parser, frame, pod, parser->state.offset);
279 parser->state.offset = parser->size;
280 return 0;
281}
282
283/* static */ inline bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
284{
285 if (pod == NULL)
286 return false;
287
288 if (spa_pod_is_choice(pod) &&
291 return true;
292
293 switch (type) {
294 case 'P':
295 return true;
296 case 'b':
297 return spa_pod_is_bool(pod);
298 case 'I':
299 return spa_pod_is_id(pod);
300 case 'i':
301 return spa_pod_is_int(pod);
302 case 'l':
303 return spa_pod_is_long(pod);
304 case 'f':
305 return spa_pod_is_float(pod);
306 case 'd':
307 return spa_pod_is_double(pod);
308 case 's':
309 return spa_pod_is_string(pod) || spa_pod_is_none(pod);
310 case 'S':
311 return spa_pod_is_string(pod);
312 case 'y':
313 return spa_pod_is_bytes(pod);
314 case 'R':
315 return spa_pod_is_rectangle(pod);
316 case 'F':
317 return spa_pod_is_fraction(pod);
318 case 'B':
319 return spa_pod_is_bitmap(pod);
320 case 'a':
321 return spa_pod_is_array(pod);
322 case 'p':
323 return spa_pod_is_pointer(pod);
324 case 'h':
325 return spa_pod_is_fd(pod);
326 case 'T':
327 return spa_pod_is_struct(pod) || spa_pod_is_none(pod);
328 case 'O':
329 return spa_pod_is_object(pod) || spa_pod_is_none(pod);
330 case 'V':
331 return spa_pod_is_choice(pod);
332 default:
333 return false;
334 }
335}
336
337#define SPA_POD_PARSER_COLLECT(pod,_type,args) \
338do { \
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 break; \
368 } \
369 case 'y': \
370 *(va_arg(args, void **)) = SPA_POD_CONTENTS(struct spa_pod_bytes, pod); \
371 *(va_arg(args, uint32_t *)) = SPA_POD_BODY_SIZE(pod); \
372 break; \
373 case 'R': \
374 *va_arg(args, struct spa_rectangle*) = \
375 SPA_POD_VALUE(struct spa_pod_rectangle, pod); \
376 break; \
377 case 'F': \
378 *va_arg(args, struct spa_fraction*) = \
379 SPA_POD_VALUE(struct spa_pod_fraction, pod); \
380 break; \
381 case 'B': \
382 *va_arg(args, uint32_t **) = \
383 (uint32_t *) SPA_POD_CONTENTS(struct spa_pod_bitmap, pod); \
384 break; \
385 case 'a': \
386 *va_arg(args, uint32_t*) = SPA_POD_ARRAY_VALUE_SIZE(pod); \
387 *va_arg(args, uint32_t*) = SPA_POD_ARRAY_VALUE_TYPE(pod); \
388 *va_arg(args, uint32_t*) = SPA_POD_ARRAY_N_VALUES(pod); \
389 *va_arg(args, void**) = SPA_POD_ARRAY_VALUES(pod); \
390 break; \
391 case 'p': \
392 { \
393 struct spa_pod_pointer_body *b = \
394 (struct spa_pod_pointer_body *) SPA_POD_BODY(pod); \
395 *(va_arg(args, uint32_t *)) = b->type; \
396 *(va_arg(args, const void **)) = b->value; \
397 break; \
398 } \
399 case 'h': \
400 *va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_fd, pod); \
401 break; \
402 case 'P': \
403 case 'T': \
404 case 'O': \
405 case 'V': \
406 { \
407 const struct spa_pod **d = va_arg(args, const struct spa_pod**); \
408 if (d) \
409 *d = (pod == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None) \
410 ? NULL : pod); \
411 break; \
412 } \
413 default: \
414 break; \
415 } \
416} while(false)
417
418#define SPA_POD_PARSER_SKIP(_type,args) \
419do { \
420 switch (_type) { \
421 case 'S': \
422 va_arg(args, char*); \
423 va_arg(args, uint32_t); \
424 break; \
425 case 'a': \
426 va_arg(args, void*); \
427 va_arg(args, void*); \
428 SPA_FALLTHROUGH \
429 case 'p': \
430 case 'y': \
431 va_arg(args, void*); \
432 SPA_FALLTHROUGH \
433 case 'b': \
434 case 'I': \
435 case 'i': \
436 case 'l': \
437 case 'f': \
438 case 'd': \
439 case 's': \
440 case 'R': \
441 case 'F': \
442 case 'B': \
443 case 'h': \
444 case 'V': \
445 case 'P': \
446 case 'T': \
447 case 'O': \
448 va_arg(args, void*); \
449 break; \
450 } \
451} while(false)
452
453/* static */ inline int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
454{
455 struct spa_pod_frame *f = parser->state.frame;
456 uint32_t ftype = f ? f->pod.type : (uint32_t)SPA_TYPE_Struct;
457 const struct spa_pod_prop *prop = NULL;
458 int count = 0;
459
460 do {
461 bool optional;
462 const struct spa_pod *pod = NULL;
463 const char *format;
464
465 if (ftype == SPA_TYPE_Object) {
466 uint32_t key = va_arg(args, uint32_t);
467 const struct spa_pod_object *object;
468
469 if (key == 0)
470 break;
471
472 object = (const struct spa_pod_object *)spa_pod_parser_frame(parser, f);
473 prop = spa_pod_object_find_prop(object, prop, key);
474 pod = prop ? &prop->value : NULL;
475 }
476
477 if ((format = va_arg(args, char *)) == NULL)
478 break;
479
480 if (ftype == SPA_TYPE_Struct)
481 pod = spa_pod_parser_next(parser);
482
483 if ((optional = (*format == '?')))
484 format++;
485
486 if (!spa_pod_parser_can_collect(pod, *format)) {
487 if (!optional) {
488 if (pod == NULL)
489 return -ESRCH;
490 else
491 return -EPROTO;
492 }
493 SPA_POD_PARSER_SKIP(*format, args);
494 } else {
495 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
507/* static */ inline int spa_pod_parser_get(struct spa_pod_parser *parser, ...)
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 */
int spa_pod_parser_get_fraction(struct spa_pod_parser *parser, struct spa_fraction *value)
Definition: parser.h:235
int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type, const void **value)
Definition: iter.h:275
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:98
void spa_pod_parser_pod(struct spa_pod_parser *parser, const struct spa_pod *pod)
Definition: parser.h:64
int spa_pod_is_none(const struct spa_pod *pod)
Definition: iter.h:146
int spa_pod_is_bool(const struct spa_pod *pod)
Definition: iter.h:151
int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
Definition: iter.h:169
int spa_pod_is_rectangle(const struct spa_pod *pod)
Definition: iter.h:298
int spa_pod_is_long(const struct spa_pod *pod)
Definition: iter.h:190
void spa_pod_parser_init(struct spa_pod_parser *parser, const void *data, uint32_t size)
Definition: parser.h:58
int spa_pod_parser_get_pointer(struct spa_pod_parser *parser, uint32_t *type, const void **value)
Definition: parser.h:208
int spa_pod_is_int(const struct spa_pod *pod)
Definition: iter.h:177
struct spa_pod * spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:93
int spa_pod_parser_get(struct spa_pod_parser *parser,...)
Definition: parser.h:507
int spa_pod_parser_pop(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:128
int spa_pod_parser_get_bytes(struct spa_pod_parser *parser, const void **value, uint32_t *len)
Definition: parser.h:199
int spa_pod_is_string(const struct spa_pod *pod)
Definition: iter.h:229
int spa_pod_parser_get_float(struct spa_pod_parser *parser, float *value)
Definition: parser.h:172
int spa_pod_is_double(const struct spa_pod *pod)
Definition: iter.h:216
int spa_pod_is_choice(const struct spa_pod *pod)
Definition: iter.h:356
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:403
int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
Definition: iter.h:290
struct spa_pod * spa_pod_parser_deref(struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
Definition: parser.h:83
int spa_pod_is_id(const struct spa_pod *pod)
Definition: iter.h:164
void spa_pod_parser_get_state(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
Definition: parser.h:71
struct spa_pod * spa_pod_parser_current(struct spa_pod_parser *parser)
Definition: parser.h:108
int spa_pod_parser_get_double(struct spa_pod_parser *parser, double *value)
Definition: parser.h:181
int spa_pod_parser_get_bool(struct spa_pod_parser *parser, bool *value)
Definition: parser.h:136
int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
Definition: iter.h:156
int spa_pod_get_fraction(const struct spa_pod *pod, struct spa_fraction *value)
Definition: iter.h:318
#define SPA_POD_PARSER_COLLECT(pod, _type, args)
Definition: parser.h:337
int spa_pod_parser_get_pod(struct spa_pod_parser *parser, struct spa_pod **value)
Definition: parser.h:244
struct spa_pod * spa_pod_parser_next(struct spa_pod_parser *parser)
Definition: parser.h:120
int spa_pod_get_double(const struct spa_pod *pod, double *value)
Definition: iter.h:221
#define SPA_POD_PARSER_SKIP(_type, args)
Definition: parser.h:418
int spa_pod_get_float(const struct spa_pod *pod, float *value)
Definition: iter.h:208
int spa_pod_is_bitmap(const struct spa_pod *pod)
Definition: iter.h:325
int spa_pod_parser_get_long(struct spa_pod_parser *parser, int64_t *value)
Definition: parser.h:163
int spa_pod_is_fd(const struct spa_pod *pod)
Definition: iter.h:284
int spa_pod_parser_get_int(struct spa_pod_parser *parser, int32_t *value)
Definition: parser.h:154
int spa_pod_get_bytes(const struct spa_pod *pod, const void **value, uint32_t *len)
Definition: iter.h:260
#define SPA_POD_PARSER_INIT(buffer, size)
Definition: parser.h:56
int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rectangle *value)
Definition: iter.h:304
int spa_pod_is_struct(const struct spa_pod *pod)
Definition: iter.h:376
bool spa_pod_parser_can_collect(const struct spa_pod *pod, char type)
Definition: parser.h:283
#define SPA_POD_OBJECT_TYPE(obj)
Definition: pod/pod.h:166
#define SPA_POD_OBJECT_ID(obj)
Definition: pod/pod.h:167
int spa_pod_is_fraction(const struct spa_pod *pod)
Definition: iter.h:312
int spa_pod_parser_get_fd(struct spa_pod_parser *parser, int64_t *value)
Definition: parser.h:217
int spa_pod_parser_get_rectangle(struct spa_pod_parser *parser, struct spa_rectangle *value)
Definition: parser.h:226
int spa_pod_parser_get_id(struct spa_pod_parser *parser, uint32_t *value)
Definition: parser.h:145
void spa_pod_parser_advance(struct spa_pod_parser *parser, const struct spa_pod *pod)
Definition: parser.h:115
int spa_pod_is_float(const struct spa_pod *pod)
Definition: iter.h:203
int spa_pod_is_object(const struct spa_pod *pod)
Definition: iter.h:381
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:266
int spa_pod_is_pointer(const struct spa_pod *pod)
Definition: iter.h:269
int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
Definition: iter.h:195
int spa_pod_get_string(const struct spa_pod *pod, const char **value)
Definition: iter.h:237
int spa_pod_is_array(const struct spa_pod *pod)
Definition: iter.h:331
#define SPA_POD_SIZE(pod)
Definition: pod/pod.h:42
int spa_pod_parser_get_string(struct spa_pod_parser *parser, const char **value)
Definition: parser.h:190
#define SPA_POD_CHOICE_CHILD(choice)
Definition: pod/pod.h:132
int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
Definition: iter.h:182
int spa_pod_is_bytes(const struct spa_pod *pod)
Definition: iter.h:255
#define SPA_POD_CHOICE_TYPE(choice)
Definition: pod/pod.h:133
int spa_pod_parser_push_struct(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:253
void spa_pod_parser_reset(struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
Definition: parser.h:77
int spa_pod_parser_getv(struct spa_pod_parser *parser, va_list args)
Definition: parser.h:453
@ SPA_CHOICE_None
no choice, first value is current
Definition: pod/pod.h:141
@ SPA_TYPE_Object
Definition: redhat-linux-build/doc/spa/utils/type.h:59
@ SPA_TYPE_Choice
Definition: redhat-linux-build/doc/spa/utils/type.h:63
@ SPA_TYPE_Struct
Definition: redhat-linux-build/doc/spa/utils/type.h:58
#define SPA_ROUND_UP_N(num, align)
Definition: defs.h:230
#define SPA_PTROFF(ptr_, offset_, type_)
Return the address (buffer + offset) as pointer of type.
Definition: defs.h:164
user data to add to an object
Definition: media-session.c:113
Definition: defs.h:104
Definition: iter.h:42
struct spa_pod pod
Definition: iter.h:43
uint32_t offset
Definition: iter.h:45
struct spa_pod_frame * parent
Definition: iter.h:44
uint32_t flags
Definition: iter.h:46
Definition: pod/pod.h:175
struct spa_pod pod
Definition: pod/pod.h:176
Definition: parser.h:43
uint32_t offset
Definition: parser.h:44
uint32_t flags
Definition: parser.h:45
struct spa_pod_frame * frame
Definition: parser.h:46
Definition: parser.h:49
uint32_t size
Definition: parser.h:51
struct spa_pod_parser_state state
Definition: parser.h:53
const void * data
Definition: parser.h:50
uint32_t _padding
Definition: parser.h:52
Definition: pod/pod.h:199
struct spa_pod value
Definition: pod/pod.h:212
Definition: pod/pod.h:161
Definition: pod/pod.h:50
uint32_t type
Definition: pod/pod.h:52
uint32_t size
Definition: pod/pod.h:51
Definition: defs.h:86