1 /* Simple Plugin API
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_ITER_H
26 #define SPA_POD_ITER_H
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 #include <errno.h>
33 #include <sys/types.h>
34
35 #include <spa/pod/pod.h>
36
37 /**
38 * \addtogroup spa_pod
39 * \{
40 */
41
42 struct spa_pod_frame {
43 struct spa_pod pod;
44 struct spa_pod_frame *parent;
45 uint32_t offset;
46 uint32_t flags;
47 };
48
spa_pod_is_inside(const void * pod,uint32_t size,const void * iter)49 static inline bool spa_pod_is_inside(const void *pod, uint32_t size, const void *iter)
50 {
51 return SPA_POD_BODY(iter) <= SPA_PTROFF(pod, size, void) &&
52 SPA_PTROFF(iter, SPA_POD_SIZE(iter), void) <= SPA_PTROFF(pod, size, void);
53 }
54
spa_pod_next(const void * iter)55 static inline void *spa_pod_next(const void *iter)
56 {
57 return SPA_PTROFF(iter, SPA_ROUND_UP_N(SPA_POD_SIZE(iter), 8), void);
58 }
59
spa_pod_prop_first(const struct spa_pod_object_body * body)60 static inline struct spa_pod_prop *spa_pod_prop_first(const struct spa_pod_object_body *body)
61 {
62 return SPA_PTROFF(body, sizeof(struct spa_pod_object_body), struct spa_pod_prop);
63 }
64
spa_pod_prop_is_inside(const struct spa_pod_object_body * body,uint32_t size,const struct spa_pod_prop * iter)65 static inline bool spa_pod_prop_is_inside(const struct spa_pod_object_body *body,
66 uint32_t size, const struct spa_pod_prop *iter)
67 {
68 return SPA_POD_CONTENTS(struct spa_pod_prop, iter) <= SPA_PTROFF(body, size, void) &&
69 SPA_PTROFF(iter, SPA_POD_PROP_SIZE(iter), void) <= SPA_PTROFF(body, size, void);
70 }
71
spa_pod_prop_next(const struct spa_pod_prop * iter)72 static inline struct spa_pod_prop *spa_pod_prop_next(const struct spa_pod_prop *iter)
73 {
74 return SPA_PTROFF(iter, SPA_ROUND_UP_N(SPA_POD_PROP_SIZE(iter), 8), struct spa_pod_prop);
75 }
76
spa_pod_control_first(const struct spa_pod_sequence_body * body)77 static inline struct spa_pod_control *spa_pod_control_first(const struct spa_pod_sequence_body *body)
78 {
79 return SPA_PTROFF(body, sizeof(struct spa_pod_sequence_body), struct spa_pod_control);
80 }
81
spa_pod_control_is_inside(const struct spa_pod_sequence_body * body,uint32_t size,const struct spa_pod_control * iter)82 static inline bool spa_pod_control_is_inside(const struct spa_pod_sequence_body *body,
83 uint32_t size, const struct spa_pod_control *iter)
84 {
85 return SPA_POD_CONTENTS(struct spa_pod_control, iter) <= SPA_PTROFF(body, size, void) &&
86 SPA_PTROFF(iter, SPA_POD_CONTROL_SIZE(iter), void) <= SPA_PTROFF(body, size, void);
87 }
88
spa_pod_control_next(const struct spa_pod_control * iter)89 static inline struct spa_pod_control *spa_pod_control_next(const struct spa_pod_control *iter)
90 {
91 return SPA_PTROFF(iter, SPA_ROUND_UP_N(SPA_POD_CONTROL_SIZE(iter), 8), struct spa_pod_control);
92 }
93
94 #define SPA_POD_ARRAY_BODY_FOREACH(body, _size, iter) \
95 for ((iter) = (__typeof__(iter))SPA_PTROFF((body), sizeof(struct spa_pod_array_body), void); \
96 (iter) < (__typeof__(iter))SPA_PTROFF((body), (_size), void); \
97 (iter) = (__typeof__(iter))SPA_PTROFF((iter), (body)->child.size, void))
98
99 #define SPA_POD_ARRAY_FOREACH(obj, iter) \
100 SPA_POD_ARRAY_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
101
102 #define SPA_POD_CHOICE_BODY_FOREACH(body, _size, iter) \
103 for ((iter) = (__typeof__(iter))SPA_PTROFF((body), sizeof(struct spa_pod_choice_body), void); \
104 (iter) < (__typeof__(iter))SPA_PTROFF((body), (_size), void); \
105 (iter) = (__typeof__(iter))SPA_PTROFF((iter), (body)->child.size, void))
106
107 #define SPA_POD_CHOICE_FOREACH(obj, iter) \
108 SPA_POD_CHOICE_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
109
110 #define SPA_POD_FOREACH(pod, size, iter) \
111 for ((iter) = (pod); \
112 spa_pod_is_inside(pod, size, iter); \
113 (iter) = (__typeof__(iter))spa_pod_next(iter))
114
115 #define SPA_POD_STRUCT_FOREACH(obj, iter) \
116 SPA_POD_FOREACH(SPA_POD_BODY(obj), SPA_POD_BODY_SIZE(obj), iter)
117
118 #define SPA_POD_OBJECT_BODY_FOREACH(body, size, iter) \
119 for ((iter) = spa_pod_prop_first(body); \
120 spa_pod_prop_is_inside(body, size, iter); \
121 (iter) = spa_pod_prop_next(iter))
122
123 #define SPA_POD_OBJECT_FOREACH(obj, iter) \
124 SPA_POD_OBJECT_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
125
126 #define SPA_POD_SEQUENCE_BODY_FOREACH(body, size, iter) \
127 for ((iter) = spa_pod_control_first(body); \
128 spa_pod_control_is_inside(body, size, iter); \
129 (iter) = spa_pod_control_next(iter))
130
131 #define SPA_POD_SEQUENCE_FOREACH(seq, iter) \
132 SPA_POD_SEQUENCE_BODY_FOREACH(&(seq)->body, SPA_POD_BODY_SIZE(seq), iter)
133
134
spa_pod_from_data(void * data,size_t maxsize,off_t offset,size_t size)135 static inline void *spa_pod_from_data(void *data, size_t maxsize, off_t offset, size_t size)
136 {
137 void *pod;
138 if (size < sizeof(struct spa_pod) || offset + size > maxsize)
139 return NULL;
140 pod = SPA_PTROFF(data, offset, void);
141 if (SPA_POD_SIZE(pod) > size)
142 return NULL;
143 return pod;
144 }
145
spa_pod_is_none(const struct spa_pod * pod)146 static inline int spa_pod_is_none(const struct spa_pod *pod)
147 {
148 return (SPA_POD_TYPE(pod) == SPA_TYPE_None);
149 }
150
spa_pod_is_bool(const struct spa_pod * pod)151 static inline int spa_pod_is_bool(const struct spa_pod *pod)
152 {
153 return (SPA_POD_TYPE(pod) == SPA_TYPE_Bool && SPA_POD_BODY_SIZE(pod) >= sizeof(int32_t));
154 }
155
spa_pod_get_bool(const struct spa_pod * pod,bool * value)156 static inline int spa_pod_get_bool(const struct spa_pod *pod, bool *value)
157 {
158 if (!spa_pod_is_bool(pod))
159 return -EINVAL;
160 *value = !!SPA_POD_VALUE(struct spa_pod_bool, pod);
161 return 0;
162 }
163
spa_pod_is_id(const struct spa_pod * pod)164 static inline int spa_pod_is_id(const struct spa_pod *pod)
165 {
166 return (SPA_POD_TYPE(pod) == SPA_TYPE_Id && SPA_POD_BODY_SIZE(pod) >= sizeof(uint32_t));
167 }
168
spa_pod_get_id(const struct spa_pod * pod,uint32_t * value)169 static inline int spa_pod_get_id(const struct spa_pod *pod, uint32_t *value)
170 {
171 if (!spa_pod_is_id(pod))
172 return -EINVAL;
173 *value = SPA_POD_VALUE(struct spa_pod_id, pod);
174 return 0;
175 }
176
spa_pod_is_int(const struct spa_pod * pod)177 static inline int spa_pod_is_int(const struct spa_pod *pod)
178 {
179 return (SPA_POD_TYPE(pod) == SPA_TYPE_Int && SPA_POD_BODY_SIZE(pod) >= sizeof(int32_t));
180 }
181
spa_pod_get_int(const struct spa_pod * pod,int32_t * value)182 static inline int spa_pod_get_int(const struct spa_pod *pod, int32_t *value)
183 {
184 if (!spa_pod_is_int(pod))
185 return -EINVAL;
186 *value = SPA_POD_VALUE(struct spa_pod_int, pod);
187 return 0;
188 }
189
spa_pod_is_long(const struct spa_pod * pod)190 static inline int spa_pod_is_long(const struct spa_pod *pod)
191 {
192 return (SPA_POD_TYPE(pod) == SPA_TYPE_Long && SPA_POD_BODY_SIZE(pod) >= sizeof(int64_t));
193 }
194
spa_pod_get_long(const struct spa_pod * pod,int64_t * value)195 static inline int spa_pod_get_long(const struct spa_pod *pod, int64_t *value)
196 {
197 if (!spa_pod_is_long(pod))
198 return -EINVAL;
199 *value = SPA_POD_VALUE(struct spa_pod_long, pod);
200 return 0;
201 }
202
spa_pod_is_float(const struct spa_pod * pod)203 static inline int spa_pod_is_float(const struct spa_pod *pod)
204 {
205 return (SPA_POD_TYPE(pod) == SPA_TYPE_Float && SPA_POD_BODY_SIZE(pod) >= sizeof(float));
206 }
207
spa_pod_get_float(const struct spa_pod * pod,float * value)208 static inline int spa_pod_get_float(const struct spa_pod *pod, float *value)
209 {
210 if (!spa_pod_is_float(pod))
211 return -EINVAL;
212 *value = SPA_POD_VALUE(struct spa_pod_float, pod);
213 return 0;
214 }
215
spa_pod_is_double(const struct spa_pod * pod)216 static inline int spa_pod_is_double(const struct spa_pod *pod)
217 {
218 return (SPA_POD_TYPE(pod) == SPA_TYPE_Double && SPA_POD_BODY_SIZE(pod) >= sizeof(double));
219 }
220
spa_pod_get_double(const struct spa_pod * pod,double * value)221 static inline int spa_pod_get_double(const struct spa_pod *pod, double *value)
222 {
223 if (!spa_pod_is_double(pod))
224 return -EINVAL;
225 *value = SPA_POD_VALUE(struct spa_pod_double, pod);
226 return 0;
227 }
228
spa_pod_is_string(const struct spa_pod * pod)229 static inline int spa_pod_is_string(const struct spa_pod *pod)
230 {
231 const char *s = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
232 return (SPA_POD_TYPE(pod) == SPA_TYPE_String &&
233 SPA_POD_BODY_SIZE(pod) > 0 &&
234 s[SPA_POD_BODY_SIZE(pod)-1] == '\0');
235 }
236
spa_pod_get_string(const struct spa_pod * pod,const char ** value)237 static inline int spa_pod_get_string(const struct spa_pod *pod, const char **value)
238 {
239 if (!spa_pod_is_string(pod))
240 return -EINVAL;
241 *value = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
242 return 0;
243 }
244
spa_pod_copy_string(const struct spa_pod * pod,size_t maxlen,char * dest)245 static inline int spa_pod_copy_string(const struct spa_pod *pod, size_t maxlen, char *dest)
246 {
247 const char *s = (const char *)SPA_POD_CONTENTS(struct spa_pod_string, pod);
248 if (!spa_pod_is_string(pod) || maxlen < 1)
249 return -EINVAL;
250 strncpy(dest, s, maxlen-1);
251 dest[maxlen-1]= '\0';
252 return 0;
253 }
254
spa_pod_is_bytes(const struct spa_pod * pod)255 static inline int spa_pod_is_bytes(const struct spa_pod *pod)
256 {
257 return SPA_POD_TYPE(pod) == SPA_TYPE_Bytes;
258 }
259
spa_pod_get_bytes(const struct spa_pod * pod,const void ** value,uint32_t * len)260 static inline int spa_pod_get_bytes(const struct spa_pod *pod, const void **value, uint32_t *len)
261 {
262 if (!spa_pod_is_bytes(pod))
263 return -EINVAL;
264 *value = (const void *)SPA_POD_CONTENTS(struct spa_pod_bytes, pod);
265 *len = SPA_POD_BODY_SIZE(pod);
266 return 0;
267 }
268
spa_pod_is_pointer(const struct spa_pod * pod)269 static inline int spa_pod_is_pointer(const struct spa_pod *pod)
270 {
271 return (SPA_POD_TYPE(pod) == SPA_TYPE_Pointer &&
272 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_pointer_body));
273 }
274
spa_pod_get_pointer(const struct spa_pod * pod,uint32_t * type,const void ** value)275 static inline int spa_pod_get_pointer(const struct spa_pod *pod, uint32_t *type, const void **value)
276 {
277 if (!spa_pod_is_pointer(pod))
278 return -EINVAL;
279 *type = ((struct spa_pod_pointer*)pod)->body.type;
280 *value = ((struct spa_pod_pointer*)pod)->body.value;
281 return 0;
282 }
283
spa_pod_is_fd(const struct spa_pod * pod)284 static inline int spa_pod_is_fd(const struct spa_pod *pod)
285 {
286 return (SPA_POD_TYPE(pod) == SPA_TYPE_Fd &&
287 SPA_POD_BODY_SIZE(pod) >= sizeof(int64_t));
288 }
289
spa_pod_get_fd(const struct spa_pod * pod,int64_t * value)290 static inline int spa_pod_get_fd(const struct spa_pod *pod, int64_t *value)
291 {
292 if (!spa_pod_is_fd(pod))
293 return -EINVAL;
294 *value = SPA_POD_VALUE(struct spa_pod_fd, pod);
295 return 0;
296 }
297
spa_pod_is_rectangle(const struct spa_pod * pod)298 static inline int spa_pod_is_rectangle(const struct spa_pod *pod)
299 {
300 return (SPA_POD_TYPE(pod) == SPA_TYPE_Rectangle &&
301 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_rectangle));
302 }
303
spa_pod_get_rectangle(const struct spa_pod * pod,struct spa_rectangle * value)304 static inline int spa_pod_get_rectangle(const struct spa_pod *pod, struct spa_rectangle *value)
305 {
306 if (!spa_pod_is_rectangle(pod))
307 return -EINVAL;
308 *value = SPA_POD_VALUE(struct spa_pod_rectangle, pod);
309 return 0;
310 }
311
spa_pod_is_fraction(const struct spa_pod * pod)312 static inline int spa_pod_is_fraction(const struct spa_pod *pod)
313 {
314 return (SPA_POD_TYPE(pod) == SPA_TYPE_Fraction &&
315 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_fraction));
316 }
317
spa_pod_get_fraction(const struct spa_pod * pod,struct spa_fraction * value)318 static inline int spa_pod_get_fraction(const struct spa_pod *pod, struct spa_fraction *value)
319 {
320 spa_return_val_if_fail(spa_pod_is_fraction(pod), -EINVAL);
321 *value = SPA_POD_VALUE(struct spa_pod_fraction, pod);
322 return 0;
323 }
324
spa_pod_is_bitmap(const struct spa_pod * pod)325 static inline int spa_pod_is_bitmap(const struct spa_pod *pod)
326 {
327 return (SPA_POD_TYPE(pod) == SPA_TYPE_Bitmap &&
328 SPA_POD_BODY_SIZE(pod) >= sizeof(uint8_t));
329 }
330
spa_pod_is_array(const struct spa_pod * pod)331 static inline int spa_pod_is_array(const struct spa_pod *pod)
332 {
333 return (SPA_POD_TYPE(pod) == SPA_TYPE_Array &&
334 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_array_body));
335 }
336
spa_pod_get_array(const struct spa_pod * pod,uint32_t * n_values)337 static inline void *spa_pod_get_array(const struct spa_pod *pod, uint32_t *n_values)
338 {
339 spa_return_val_if_fail(spa_pod_is_array(pod), NULL);
340 *n_values = SPA_POD_ARRAY_N_VALUES(pod);
341 return SPA_POD_ARRAY_VALUES(pod);
342 }
343
spa_pod_copy_array(const struct spa_pod * pod,uint32_t type,void * values,uint32_t max_values)344 static inline uint32_t spa_pod_copy_array(const struct spa_pod *pod, uint32_t type,
345 void *values, uint32_t max_values)
346 {
347 uint32_t n_values;
348 void *v = spa_pod_get_array(pod, &n_values);
349 if (v == NULL || max_values == 0 || SPA_POD_ARRAY_VALUE_TYPE(pod) != type)
350 return 0;
351 n_values = SPA_MIN(n_values, max_values);
352 memcpy(values, v, SPA_POD_ARRAY_VALUE_SIZE(pod) * n_values);
353 return n_values;
354 }
355
spa_pod_is_choice(const struct spa_pod * pod)356 static inline int spa_pod_is_choice(const struct spa_pod *pod)
357 {
358 return (SPA_POD_TYPE(pod) == SPA_TYPE_Choice &&
359 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_choice_body));
360 }
361
spa_pod_get_values(const struct spa_pod * pod,uint32_t * n_vals,uint32_t * choice)362 static inline struct spa_pod *spa_pod_get_values(const struct spa_pod *pod, uint32_t *n_vals, uint32_t *choice)
363 {
364 if (pod->type == SPA_TYPE_Choice) {
365 *n_vals = SPA_POD_CHOICE_N_VALUES(pod);
366 if ((*choice = SPA_POD_CHOICE_TYPE(pod)) == SPA_CHOICE_None)
367 *n_vals = SPA_MIN(1u, SPA_POD_CHOICE_N_VALUES(pod));
368 return (struct spa_pod*)SPA_POD_CHOICE_CHILD(pod);
369 } else {
370 *n_vals = 1;
371 *choice = SPA_CHOICE_None;
372 return (struct spa_pod*)pod;
373 }
374 }
375
spa_pod_is_struct(const struct spa_pod * pod)376 static inline int spa_pod_is_struct(const struct spa_pod *pod)
377 {
378 return (SPA_POD_TYPE(pod) == SPA_TYPE_Struct);
379 }
380
spa_pod_is_object(const struct spa_pod * pod)381 static inline int spa_pod_is_object(const struct spa_pod *pod)
382 {
383 return (SPA_POD_TYPE(pod) == SPA_TYPE_Object &&
384 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_object_body));
385 }
386
spa_pod_is_object_type(const struct spa_pod * pod,uint32_t type)387 static inline bool spa_pod_is_object_type(const struct spa_pod *pod, uint32_t type)
388 {
389 return (pod && spa_pod_is_object(pod) && SPA_POD_OBJECT_TYPE(pod) == type);
390 }
391
spa_pod_is_object_id(const struct spa_pod * pod,uint32_t id)392 static inline bool spa_pod_is_object_id(const struct spa_pod *pod, uint32_t id)
393 {
394 return (pod && spa_pod_is_object(pod) && SPA_POD_OBJECT_ID(pod) == id);
395 }
396
spa_pod_is_sequence(const struct spa_pod * pod)397 static inline int spa_pod_is_sequence(const struct spa_pod *pod)
398 {
399 return (SPA_POD_TYPE(pod) == SPA_TYPE_Sequence &&
400 SPA_POD_BODY_SIZE(pod) >= sizeof(struct spa_pod_sequence_body));
401 }
402
spa_pod_object_find_prop(const struct spa_pod_object * pod,const struct spa_pod_prop * start,uint32_t key)403 static inline const struct spa_pod_prop *spa_pod_object_find_prop(const struct spa_pod_object *pod,
404 const struct spa_pod_prop *start, uint32_t key)
405 {
406 const struct spa_pod_prop *first, *res;
407
408 first = spa_pod_prop_first(&pod->body);
409 start = start ? spa_pod_prop_next(start) : first;
410
411 for (res = start; spa_pod_prop_is_inside(&pod->body, pod->pod.size, res);
412 res = spa_pod_prop_next(res)) {
413 if (res->key == key)
414 return res;
415 }
416 for (res = first; res != start; res = spa_pod_prop_next(res)) {
417 if (res->key == key)
418 return res;
419 }
420 return NULL;
421 }
422
spa_pod_find_prop(const struct spa_pod * pod,const struct spa_pod_prop * start,uint32_t key)423 static inline const struct spa_pod_prop *spa_pod_find_prop(const struct spa_pod *pod,
424 const struct spa_pod_prop *start, uint32_t key)
425 {
426 if (!spa_pod_is_object(pod))
427 return NULL;
428 return spa_pod_object_find_prop((const struct spa_pod_object *)pod, start, key);
429 }
430
spa_pod_object_fixate(struct spa_pod_object * pod)431 static inline int spa_pod_object_fixate(struct spa_pod_object *pod)
432 {
433 struct spa_pod_prop *res;
434 SPA_POD_OBJECT_FOREACH(pod, res) {
435 if (res->value.type == SPA_TYPE_Choice &&
436 !SPA_FLAG_IS_SET(res->flags, SPA_POD_PROP_FLAG_DONT_FIXATE))
437 ((struct spa_pod_choice*)&res->value)->body.type = SPA_CHOICE_None;
438 }
439 return 0;
440 }
441
spa_pod_fixate(struct spa_pod * pod)442 static inline int spa_pod_fixate(struct spa_pod *pod)
443 {
444 if (!spa_pod_is_object(pod))
445 return -EINVAL;
446 return spa_pod_object_fixate((struct spa_pod_object *)pod);
447 }
448
spa_pod_object_is_fixated(const struct spa_pod_object * pod)449 static inline int spa_pod_object_is_fixated(const struct spa_pod_object *pod)
450 {
451 struct spa_pod_prop *res;
452 SPA_POD_OBJECT_FOREACH(pod, res) {
453 if (res->value.type == SPA_TYPE_Choice &&
454 ((struct spa_pod_choice*)&res->value)->body.type != SPA_CHOICE_None)
455 return 0;
456 }
457 return 1;
458 }
459
spa_pod_is_fixated(const struct spa_pod * pod)460 static inline int spa_pod_is_fixated(const struct spa_pod *pod)
461 {
462 if (!spa_pod_is_object(pod))
463 return -EINVAL;
464 return spa_pod_object_is_fixated((const struct spa_pod_object *)pod);
465 }
466
467 /**
468 * \}
469 */
470
471 #ifdef __cplusplus
472 } /* extern "C" */
473 #endif
474
475 #endif /* SPA_POD_H */
476