5#ifndef SPA_POD_PARSER_H 
    6#define SPA_POD_PARSER_H 
   18#ifndef SPA_API_POD_PARSER 
   20  #define SPA_API_POD_PARSER SPA_API_IMPL 
   22  #define SPA_API_POD_PARSER static inline 
   44#define SPA_POD_PARSER_INIT(buffer,size)  ((struct spa_pod_parser){ (buffer), (size), 0, {0,0,NULL}}) 
 
   61        *state = parser->
state;
 
 
   74        const uint64_t long_offset = (uint64_t)offset + 8;
 
   75        if (long_offset <= 
size && (offset & 7) == 0) {
 
 
  337#define SPA_POD_PARSER_COLLECT(pod,_type,args)                                          \ 
  341                *va_arg(args, bool*) = SPA_POD_VALUE(struct spa_pod_bool, pod);         \ 
 
  345                *va_arg(args, int32_t*) = SPA_POD_VALUE(struct spa_pod_int, pod);       \ 
  348                *va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_long, pod);      \ 
  351                *va_arg(args, float*) = SPA_POD_VALUE(struct spa_pod_float, pod);       \ 
  354                *va_arg(args, double*) = SPA_POD_VALUE(struct spa_pod_double, pod);     \ 
  357                *va_arg(args, char**) =                                                 \ 
  358                        ((pod) == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None)          \ 
  360                                : (char *)SPA_POD_CONTENTS(struct spa_pod_string, pod));        \ 
  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';                                                  \ 
  371                *(va_arg(args, void **)) = SPA_POD_CONTENTS(struct spa_pod_bytes, pod); \ 
  372                *(va_arg(args, uint32_t *)) = SPA_POD_BODY_SIZE(pod);                   \ 
  375                *va_arg(args, struct spa_rectangle*) =                                  \ 
  376                                SPA_POD_VALUE(struct spa_pod_rectangle, pod);           \ 
  379                *va_arg(args, struct spa_fraction*) =                                   \ 
  380                                SPA_POD_VALUE(struct spa_pod_fraction, pod);            \ 
  383                *va_arg(args, uint32_t **) =                                            \ 
  384                        (uint32_t *) SPA_POD_CONTENTS(struct spa_pod_bitmap, pod);      \ 
  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);                      \ 
  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;                              \ 
  401                *va_arg(args, int64_t*) = SPA_POD_VALUE(struct spa_pod_fd, pod);        \ 
  408                const struct spa_pod **d = va_arg(args, const struct spa_pod**);        \ 
  410                        *d = ((pod) == NULL || (SPA_POD_TYPE(pod) == SPA_TYPE_None)     \ 
  419#define SPA_POD_PARSER_SKIP(_type,args)                                                 \ 
  423                va_arg(args, char*);                                                    \ 
  424                va_arg(args, uint32_t);                                                 \ 
 
  427                va_arg(args, void*);                                                    \ 
  428                va_arg(args, void*);                                                    \ 
  432                va_arg(args, void*);                                                    \ 
  449                va_arg(args, void*);                                                    \ 
 
  463                const struct spa_pod *pod = NULL;
 
  467                        uint32_t key = va_arg(
args, uint32_t);
 
  478                if ((format = va_arg(
args, 
char *)) == NULL)
 
  484                if ((optional = (*format == 
'?')))
 
 
  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) 
  538#define spa_pod_parser_get_object(p,type,id,...)                                \ 
  540        struct spa_pod_frame _f;                                                \ 
  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);                                     \ 
  549#define spa_pod_parser_get_struct(p,...)                                \ 
  551        struct spa_pod_frame _f;                                        \ 
  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);                             \ 
  560#define spa_pod_parse_object(pod,type,id,...)                   \ 
  562        struct spa_pod_parser _p;                               \ 
  563        spa_pod_parser_pod(&_p, pod);                           \ 
  564        spa_pod_parser_get_object(&_p,type,id,##__VA_ARGS__);   \ 
  567#define spa_pod_parse_struct(pod,...)                           \ 
  569        struct spa_pod_parser _p;                               \ 
  570        spa_pod_parser_pod(&_p, pod);                           \ 
  571        spa_pod_parser_get_struct(&_p,##__VA_ARGS__);           \ 
 
uint32_t int int const char va_list args
Definition core.h:434
uint32_t int int res
Definition core.h:433
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 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_PARSER void spa_pod_parser_pod(struct spa_pod_parser *parser, const struct spa_pod *pod)
Definition parser.h:60
SPA_API_POD_PARSER struct spa_pod * spa_pod_parser_next(struct spa_pod_parser *parser)
Definition parser.h:124
SPA_API_POD_PARSER struct spa_pod * spa_pod_parser_current(struct spa_pod_parser *parser)
Definition parser.h:112
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 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_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_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 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
#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_PARSER struct spa_pod * spa_pod_parser_frame(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition parser.h:97
SPA_API_POD_ITER int spa_pod_is_fd(const struct spa_pod *pod)
Definition iter.h:285
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_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
#define SPA_API_POD_PARSER
Definition parser.h:29
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
struct spa_pod pod
Definition pod.h:184
uint32_t offset
Definition parser.h:39
uint32_t flags
Definition parser.h:40
struct spa_pod_frame * frame
Definition parser.h:41
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
struct spa_pod value
Definition pod.h:226
uint32_t type
Definition pod.h:45
uint32_t size
Definition pod.h:44