PipeWire  0.3.36
SPA POD

Data Structures

struct  spa_pod_builder_state
 
struct  spa_pod_builder_callbacks
 
struct  spa_pod_builder
 
struct  spa_command_body
 
struct  spa_command
 
struct  spa_event_body
 
struct  spa_event
 
struct  spa_pod_frame
 
struct  spa_pod_parser_state
 
struct  spa_pod_parser
 
struct  spa_pod
 
struct  spa_pod_bool
 
struct  spa_pod_id
 
struct  spa_pod_int
 
struct  spa_pod_long
 
struct  spa_pod_float
 
struct  spa_pod_double
 
struct  spa_pod_string
 
struct  spa_pod_bytes
 
struct  spa_pod_rectangle
 
struct  spa_pod_fraction
 
struct  spa_pod_bitmap
 
struct  spa_pod_array_body
 
struct  spa_pod_array
 
struct  spa_pod_choice_body
 
struct  spa_pod_choice
 
struct  spa_pod_struct
 
struct  spa_pod_object_body
 
struct  spa_pod_object
 
struct  spa_pod_pointer_body
 
struct  spa_pod_pointer
 
struct  spa_pod_fd
 
struct  spa_pod_prop
 
struct  spa_pod_control
 
struct  spa_pod_sequence_body
 
struct  spa_pod_sequence
 a sequence of timed controls More...
 

Macros

#define SPA_POD_BUILDER_INIT(buffer, size)   (struct spa_pod_builder){ buffer, size, 0, {}, {} }
 
#define SPA_POD_INIT(size, type)   (struct spa_pod) { size, type }
 
#define SPA_POD_INIT_None()   SPA_POD_INIT(0, SPA_TYPE_None)
 
#define SPA_POD_INIT_Bool(val)   (struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, val ? 1 : 0, 0 }
 
#define SPA_POD_INIT_Id(val)   (struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (uint32_t)val, 0 }
 
#define SPA_POD_INIT_Int(val)   (struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (int32_t)val, 0 }
 
#define SPA_POD_INIT_Long(val)   (struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (int64_t)val }
 
#define SPA_POD_INIT_Float(val)   (struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, val, 0 }
 
#define SPA_POD_INIT_Double(val)   (struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, val }
 
#define SPA_POD_INIT_String(len)   (struct spa_pod_string){ { len, SPA_TYPE_String } }
 
#define SPA_POD_INIT_Bytes(len)   (struct spa_pod_bytes){ { len, SPA_TYPE_Bytes } }
 
#define SPA_POD_INIT_Pointer(type, value)   (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { type, 0, value } }
 
#define SPA_POD_INIT_Fd(fd)   (struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, fd }
 
#define SPA_POD_INIT_Rectangle(val)   (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, val }
 
#define SPA_POD_INIT_Fraction(val)   (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, val }
 
#define SPA_POD_INIT_CHOICE_BODY(type, flags, child_size, child_type)    (struct spa_pod_choice_body) { type, flags, { child_size, child_type }}
 
#define SPA_POD_INIT_Choice(type, ctype, child_type, n_vals, ...)
 
#define SPA_POD_INIT_Struct(size)   (struct spa_pod_struct){ { size, SPA_TYPE_Struct } }
 
#define SPA_POD_INIT_Object(size, type, id, ...)   (struct spa_pod_object){ { size, SPA_TYPE_Object }, { type, id }, ##__VA_ARGS__ }
 
#define SPA_POD_INIT_Prop(key, flags, size, type)    (struct spa_pod_prop){ key, flags, { size, type } }
 
#define SPA_POD_INIT_Sequence(size, unit)    (struct spa_pod_sequence){ { size, SPA_TYPE_Sequence}, {unit, 0 } }
 
#define SPA_POD_BUILDER_COLLECT(builder, type, args)
 
#define spa_pod_builder_add_object(b, type, id, ...)
 
#define spa_pod_builder_add_struct(b, ...)
 
#define spa_pod_builder_add_sequence(b, unit, ...)
 
#define SPA_COMMAND_TYPE(cmd)   ((cmd)->body.body.type)
 
#define SPA_COMMAND_ID(cmd, type)
 
#define SPA_COMMAND_INIT_FULL(t, size, type, id, ...)
 
#define SPA_COMMAND_INIT(type, id)
 
#define SPA_EVENT_TYPE(ev)   ((ev)->body.body.type)
 
#define SPA_EVENT_ID(ev, type)
 
#define SPA_EVENT_INIT_FULL(t, size, type, id, ...)
 
#define SPA_EVENT_INIT(type, id)
 
#define SPA_POD_ARRAY_BODY_FOREACH(body, _size, iter)
 
#define SPA_POD_ARRAY_FOREACH(obj, iter)    SPA_POD_ARRAY_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
 
#define SPA_POD_CHOICE_BODY_FOREACH(body, _size, iter)
 
#define SPA_POD_CHOICE_FOREACH(obj, iter)    SPA_POD_CHOICE_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
 
#define SPA_POD_FOREACH(pod, size, iter)
 
#define SPA_POD_STRUCT_FOREACH(obj, iter)    SPA_POD_FOREACH(SPA_POD_BODY(obj), SPA_POD_BODY_SIZE(obj), iter)
 
#define SPA_POD_OBJECT_BODY_FOREACH(body, size, iter)
 
#define SPA_POD_OBJECT_FOREACH(obj, iter)    SPA_POD_OBJECT_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)
 
#define SPA_POD_SEQUENCE_BODY_FOREACH(body, size, iter)
 
#define SPA_POD_SEQUENCE_FOREACH(seq, iter)    SPA_POD_SEQUENCE_BODY_FOREACH(&(seq)->body, SPA_POD_BODY_SIZE(seq), iter)
 
#define SPA_POD_PARSER_INIT(buffer, size)   (struct spa_pod_parser){ buffer, size, 0, {} }
 
#define SPA_POD_PARSER_COLLECT(pod, _type, args)
 
#define SPA_POD_PARSER_SKIP(_type, args)
 
#define SPA_POD_OPT_Bool(val)   "?" SPA_POD_Bool(val)
 
#define SPA_POD_OPT_Id(val)   "?" SPA_POD_Id(val)
 
#define SPA_POD_OPT_Int(val)   "?" SPA_POD_Int(val)
 
#define SPA_POD_OPT_Long(val)   "?" SPA_POD_Long(val)
 
#define SPA_POD_OPT_Float(val)   "?" SPA_POD_Float(val)
 
#define SPA_POD_OPT_Double(val)   "?" SPA_POD_Double(val)
 
#define SPA_POD_OPT_String(val)   "?" SPA_POD_String(val)
 
#define SPA_POD_OPT_Stringn(val, len)   "?" SPA_POD_Stringn(val,len)
 
#define SPA_POD_OPT_Bytes(val, len)   "?" SPA_POD_Bytes(val,len)
 
#define SPA_POD_OPT_Rectangle(val)   "?" SPA_POD_Rectangle(val)
 
#define SPA_POD_OPT_Fraction(val)   "?" SPA_POD_Fraction(val)
 
#define SPA_POD_OPT_Array(csize, ctype, n_vals, vals)   "?" SPA_POD_Array(csize,ctype,n_vals,vals)
 
#define SPA_POD_OPT_Pointer(type, val)   "?" SPA_POD_Pointer(type,val)
 
#define SPA_POD_OPT_Fd(val)   "?" SPA_POD_Fd(val)
 
#define SPA_POD_OPT_Pod(val)   "?" SPA_POD_Pod(val)
 
#define SPA_POD_OPT_PodObject(val)   "?" SPA_POD_PodObject(val)
 
#define SPA_POD_OPT_PodStruct(val)   "?" SPA_POD_PodStruct(val)
 
#define SPA_POD_OPT_PodChoice(val)   "?" SPA_POD_PodChoice(val)
 
#define spa_pod_parser_get_object(p, type, id, ...)
 
#define spa_pod_parser_get_struct(p, ...)
 
#define spa_pod_parse_object(pod, type, id, ...)
 
#define spa_pod_parse_struct(pod, ...)
 
#define SPA_POD_BODY_SIZE(pod)   (((struct spa_pod*)(pod))->size)
 
#define SPA_POD_TYPE(pod)   (((struct spa_pod*)(pod))->type)
 
#define SPA_POD_SIZE(pod)   (sizeof(struct spa_pod) + SPA_POD_BODY_SIZE(pod))
 
#define SPA_POD_CONTENTS_SIZE(type, pod)   (SPA_POD_SIZE(pod)-sizeof(type))
 
#define SPA_POD_CONTENTS(type, pod)   SPA_PTROFF((pod),sizeof(type),void)
 
#define SPA_POD_CONTENTS_CONST(type, pod)   SPA_PTROFF((pod),sizeof(type),const void)
 
#define SPA_POD_BODY(pod)   SPA_PTROFF((pod),sizeof(struct spa_pod),void)
 
#define SPA_POD_BODY_CONST(pod)   SPA_PTROFF((pod),sizeof(struct spa_pod),const void)
 
#define SPA_POD_VALUE(type, pod)   (((type*)pod)->value)
 
#define SPA_POD_ARRAY_CHILD(arr)   (&((struct spa_pod_array*)(arr))->body.child)
 
#define SPA_POD_ARRAY_VALUE_TYPE(arr)   (SPA_POD_TYPE(SPA_POD_ARRAY_CHILD(arr)))
 
#define SPA_POD_ARRAY_VALUE_SIZE(arr)   (SPA_POD_BODY_SIZE(SPA_POD_ARRAY_CHILD(arr)))
 
#define SPA_POD_ARRAY_N_VALUES(arr)   (SPA_POD_ARRAY_VALUE_SIZE(arr) ? ((SPA_POD_BODY_SIZE(arr) - sizeof(struct spa_pod_array_body)) / SPA_POD_ARRAY_VALUE_SIZE(arr)) : 0)
 
#define SPA_POD_ARRAY_VALUES(arr)   SPA_POD_CONTENTS(struct spa_pod_array, arr)
 
#define SPA_POD_CHOICE_CHILD(choice)   (&((struct spa_pod_choice*)(choice))->body.child)
 
#define SPA_POD_CHOICE_TYPE(choice)   (((struct spa_pod_choice*)(choice))->body.type)
 
#define SPA_POD_CHOICE_FLAGS(choice)   (((struct spa_pod_choice*)(choice))->body.flags)
 
#define SPA_POD_CHOICE_VALUE_TYPE(choice)   (SPA_POD_TYPE(SPA_POD_CHOICE_CHILD(choice)))
 
#define SPA_POD_CHOICE_VALUE_SIZE(choice)   (SPA_POD_BODY_SIZE(SPA_POD_CHOICE_CHILD(choice)))
 
#define SPA_POD_CHOICE_N_VALUES(choice)   (SPA_POD_CHOICE_VALUE_SIZE(choice) ? ((SPA_POD_BODY_SIZE(choice) - sizeof(struct spa_pod_choice_body)) / SPA_POD_CHOICE_VALUE_SIZE(choice)) : 0)
 
#define SPA_POD_CHOICE_VALUES(choice)   (SPA_POD_CONTENTS(struct spa_pod_choice, choice))
 
#define SPA_POD_OBJECT_TYPE(obj)   (((struct spa_pod_object*)(obj))->body.type)
 
#define SPA_POD_OBJECT_ID(obj)   (((struct spa_pod_object*)(obj))->body.id)
 
#define SPA_POD_PROP_SIZE(prop)   (sizeof(struct spa_pod_prop) + (prop)->value.size)
 
#define SPA_POD_CONTROL_SIZE(ev)   (sizeof(struct spa_pod_control) + (ev)->value.size)
 
#define SPA_POD_Prop(key, ...)    key, ##__VA_ARGS__
 
#define SPA_POD_Control(offset, type, ...)    offset, type, ##__VA_ARGS__
 
#define SPA_CHOICE_RANGE(def, min, max)   3,(def),(min),(max)
 
#define SPA_CHOICE_STEP(def, min, max, step)   4,(def),(min),(max),(step)
 
#define SPA_CHOICE_ENUM(n_vals, ...)   (n_vals),##__VA_ARGS__
 
#define SPA_CHOICE_FLAGS(flags)   1, (flags)
 
#define SPA_CHOICE_BOOL(def)   3,(def),(def),!(def)
 
#define SPA_POD_Bool(val)   "b", val
 
#define SPA_POD_CHOICE_Bool(def)   "?eb", SPA_CHOICE_BOOL(def)
 
#define SPA_POD_Id(val)   "I", val
 
#define SPA_POD_CHOICE_ENUM_Id(n_vals, ...)   "?eI", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_Int(val)   "i", val
 
#define SPA_POD_CHOICE_ENUM_Int(n_vals, ...)   "?ei", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_CHOICE_RANGE_Int(def, min, max)   "?ri", SPA_CHOICE_RANGE(def, min, max)
 
#define SPA_POD_CHOICE_STEP_Int(def, min, max, step)   "?si", SPA_CHOICE_STEP(def, min, max, step)
 
#define SPA_POD_CHOICE_FLAGS_Int(flags)   "?fi", SPA_CHOICE_FLAGS(flags)
 
#define SPA_POD_Long(val)   "l", val
 
#define SPA_POD_CHOICE_ENUM_Long(n_vals, ...)   "?el", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_CHOICE_RANGE_Long(def, min, max)   "?rl", SPA_CHOICE_RANGE(def, min, max)
 
#define SPA_POD_CHOICE_STEP_Long(def, min, max, step)   "?sl", SPA_CHOICE_STEP(def, min, max, step)
 
#define SPA_POD_CHOICE_FLAGS_Long(flags)   "?fl", SPA_CHOICE_FLAGS(flags)
 
#define SPA_POD_Float(val)   "f", val
 
#define SPA_POD_CHOICE_ENUM_Float(n_vals, ...)   "?ef", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_CHOICE_RANGE_Float(def, min, max)   "?rf", SPA_CHOICE_RANGE(def, min, max)
 
#define SPA_POD_CHOICE_STEP_Float(def, min, max, step)   "?sf", SPA_CHOICE_STEP(def, min, max, step)
 
#define SPA_POD_Double(val)   "d", val
 
#define SPA_POD_CHOICE_ENUM_Double(n_vals, ...)   "?ed", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_CHOICE_RANGE_Double(def, min, max)   "?rd", SPA_CHOICE_RANGE(def, min, max)
 
#define SPA_POD_CHOICE_STEP_Double(def, min, max, step)   "?sd", SPA_CHOICE_STEP(def, min, max, step)
 
#define SPA_POD_String(val)   "s",val
 
#define SPA_POD_Stringn(val, len)   "S",val,len
 
#define SPA_POD_Bytes(val, len)   "y",val,len
 
#define SPA_POD_Rectangle(val)   "R",val
 
#define SPA_POD_CHOICE_ENUM_Rectangle(n_vals, ...)   "?eR", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_CHOICE_RANGE_Rectangle(def, min, max)   "?rR", SPA_CHOICE_RANGE((def),(min),(max))
 
#define SPA_POD_CHOICE_STEP_Rectangle(def, min, max, step)   "?sR", SPA_CHOICE_STEP((def),(min),(max),(step))
 
#define SPA_POD_Fraction(val)   "F",val
 
#define SPA_POD_CHOICE_ENUM_Fraction(n_vals, ...)   "?eF", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)
 
#define SPA_POD_CHOICE_RANGE_Fraction(def, min, max)   "?rF", SPA_CHOICE_RANGE((def),(min),(max))
 
#define SPA_POD_CHOICE_STEP_Fraction(def, min, max, step)   "?sF", SPA_CHOICE_STEP(def, min, max, step)
 
#define SPA_POD_Array(csize, ctype, n_vals, vals)   "a", csize,ctype,n_vals,vals
 
#define SPA_POD_Pointer(type, val)   "p", type,val
 
#define SPA_POD_Fd(val)   "h", val
 
#define SPA_POD_None()   "P", NULL
 
#define SPA_POD_Pod(val)   "P", val
 
#define SPA_POD_PodObject(val)   "O", val
 
#define SPA_POD_PodStruct(val)   "T", val
 
#define SPA_POD_PodChoice(val)   "V", val
 

Enumerations

enum  spa_choice_type {
  SPA_CHOICE_None , SPA_CHOICE_Range , SPA_CHOICE_Step , SPA_CHOICE_Enum ,
  SPA_CHOICE_Flags
}
 

Functions

void spa_pod_builder_get_state (struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
 
void spa_pod_builder_set_callbacks (struct spa_pod_builder *builder, const struct spa_pod_builder_callbacks *callbacks, void *data)
 
void spa_pod_builder_reset (struct spa_pod_builder *builder, struct spa_pod_builder_state *state)
 
void spa_pod_builder_init (struct spa_pod_builder *builder, void *data, uint32_t size)
 
struct spa_podspa_pod_builder_deref (struct spa_pod_builder *builder, uint32_t offset)
 
struct spa_podspa_pod_builder_frame (struct spa_pod_builder *builder, struct spa_pod_frame *frame)
 
void spa_pod_builder_push (struct spa_pod_builder *builder, struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
 
int spa_pod_builder_raw (struct spa_pod_builder *builder, const void *data, uint32_t size)
 
int spa_pod_builder_pad (struct spa_pod_builder *builder, uint32_t size)
 
int spa_pod_builder_raw_padded (struct spa_pod_builder *builder, const void *data, uint32_t size)
 
void * spa_pod_builder_pop (struct spa_pod_builder *builder, struct spa_pod_frame *frame)
 
int spa_pod_builder_primitive (struct spa_pod_builder *builder, const struct spa_pod *p)
 
int spa_pod_builder_none (struct spa_pod_builder *builder)
 
int spa_pod_builder_child (struct spa_pod_builder *builder, uint32_t size, uint32_t type)
 
int spa_pod_builder_bool (struct spa_pod_builder *builder, bool val)
 
int spa_pod_builder_id (struct spa_pod_builder *builder, uint32_t val)
 
int spa_pod_builder_int (struct spa_pod_builder *builder, int32_t val)
 
int spa_pod_builder_long (struct spa_pod_builder *builder, int64_t val)
 
int spa_pod_builder_float (struct spa_pod_builder *builder, float val)
 
int spa_pod_builder_double (struct spa_pod_builder *builder, double val)
 
int spa_pod_builder_write_string (struct spa_pod_builder *builder, const char *str, uint32_t len)
 
int spa_pod_builder_string_len (struct spa_pod_builder *builder, const char *str, uint32_t len)
 
int spa_pod_builder_string (struct spa_pod_builder *builder, const char *str)
 
int spa_pod_builder_bytes (struct spa_pod_builder *builder, const void *bytes, uint32_t len)
 
void * spa_pod_builder_reserve_bytes (struct spa_pod_builder *builder, uint32_t len)
 
int spa_pod_builder_pointer (struct spa_pod_builder *builder, uint32_t type, const void *val)
 
int spa_pod_builder_fd (struct spa_pod_builder *builder, int64_t fd)
 
int spa_pod_builder_rectangle (struct spa_pod_builder *builder, uint32_t width, uint32_t height)
 
int spa_pod_builder_fraction (struct spa_pod_builder *builder, uint32_t num, uint32_t denom)
 
int spa_pod_builder_push_array (struct spa_pod_builder *builder, struct spa_pod_frame *frame)
 
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)
 
int spa_pod_builder_push_choice (struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t type, uint32_t flags)
 
int spa_pod_builder_push_struct (struct spa_pod_builder *builder, struct spa_pod_frame *frame)
 
int spa_pod_builder_push_object (struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t type, uint32_t id)
 
int spa_pod_builder_prop (struct spa_pod_builder *builder, uint32_t key, uint32_t flags)
 
int spa_pod_builder_push_sequence (struct spa_pod_builder *builder, struct spa_pod_frame *frame, uint32_t unit)
 
uint32_t spa_pod_builder_control (struct spa_pod_builder *builder, uint32_t offset, uint32_t type)
 
uint32_t spa_choice_from_id (char id)
 
int spa_pod_builder_addv (struct spa_pod_builder *builder, va_list args)
 
int spa_pod_builder_add (struct spa_pod_builder *builder,...)
 
struct spa_podspa_pod_copy (const struct spa_pod *pod)
 Copy a pod structure. More...
 
int spa_pod_compare_value (uint32_t type, const void *r1, const void *r2, uint32_t size)
 
int spa_pod_compare (const struct spa_pod *pod1, const struct spa_pod *pod2)
 
int spa_pod_choice_fix_default (struct spa_pod_choice *choice)
 
int spa_pod_filter_flags_value (struct spa_pod_builder *b, uint32_t type, const void *r1, const void *r2, uint32_t size)
 
int spa_pod_filter_prop (struct spa_pod_builder *b, const struct spa_pod_prop *p1, const struct spa_pod_prop *p2)
 
int spa_pod_filter_part (struct spa_pod_builder *b, const struct spa_pod *pod, uint32_t pod_size, const struct spa_pod *filter, uint32_t filter_size)
 
int spa_pod_filter (struct spa_pod_builder *b, struct spa_pod **result, const struct spa_pod *pod, const struct spa_pod *filter)
 
bool spa_pod_is_inside (const void *pod, uint32_t size, const void *iter)
 
void * spa_pod_next (const void *iter)
 
struct spa_pod_propspa_pod_prop_first (const struct spa_pod_object_body *body)
 
bool spa_pod_prop_is_inside (const struct spa_pod_object_body *body, uint32_t size, const struct spa_pod_prop *iter)
 
struct spa_pod_propspa_pod_prop_next (const struct spa_pod_prop *iter)
 
struct spa_pod_controlspa_pod_control_first (const struct spa_pod_sequence_body *body)
 
bool spa_pod_control_is_inside (const struct spa_pod_sequence_body *body, uint32_t size, const struct spa_pod_control *iter)
 
struct spa_pod_controlspa_pod_control_next (const struct spa_pod_control *iter)
 
void * spa_pod_from_data (void *data, size_t maxsize, off_t offset, size_t size)
 
int spa_pod_is_none (const struct spa_pod *pod)
 
int spa_pod_is_bool (const struct spa_pod *pod)
 
int spa_pod_get_bool (const struct spa_pod *pod, bool *value)
 
int spa_pod_is_id (const struct spa_pod *pod)
 
int spa_pod_get_id (const struct spa_pod *pod, uint32_t *value)
 
int spa_pod_is_int (const struct spa_pod *pod)
 
int spa_pod_get_int (const struct spa_pod *pod, int32_t *value)
 
int spa_pod_is_long (const struct spa_pod *pod)
 
int spa_pod_get_long (const struct spa_pod *pod, int64_t *value)
 
int spa_pod_is_float (const struct spa_pod *pod)
 
int spa_pod_get_float (const struct spa_pod *pod, float *value)
 
int spa_pod_is_double (const struct spa_pod *pod)
 
int spa_pod_get_double (const struct spa_pod *pod, double *value)
 
int spa_pod_is_string (const struct spa_pod *pod)
 
int spa_pod_get_string (const struct spa_pod *pod, const char **value)
 
int spa_pod_copy_string (const struct spa_pod *pod, size_t maxlen, char *dest)
 
int spa_pod_is_bytes (const struct spa_pod *pod)
 
int spa_pod_get_bytes (const struct spa_pod *pod, const void **value, uint32_t *len)
 
int spa_pod_is_pointer (const struct spa_pod *pod)
 
int spa_pod_get_pointer (const struct spa_pod *pod, uint32_t *type, const void **value)
 
int spa_pod_is_fd (const struct spa_pod *pod)
 
int spa_pod_get_fd (const struct spa_pod *pod, int64_t *value)
 
int spa_pod_is_rectangle (const struct spa_pod *pod)
 
int spa_pod_get_rectangle (const struct spa_pod *pod, struct spa_rectangle *value)
 
int spa_pod_is_fraction (const struct spa_pod *pod)
 
int spa_pod_get_fraction (const struct spa_pod *pod, struct spa_fraction *value)
 
int spa_pod_is_bitmap (const struct spa_pod *pod)
 
int spa_pod_is_array (const struct spa_pod *pod)
 
void * spa_pod_get_array (const struct spa_pod *pod, uint32_t *n_values)
 
uint32_t spa_pod_copy_array (const struct spa_pod *pod, uint32_t type, void *values, uint32_t max_values)
 
int spa_pod_is_choice (const struct spa_pod *pod)
 
struct spa_podspa_pod_get_values (const struct spa_pod *pod, uint32_t *n_vals, uint32_t *choice)
 
int spa_pod_is_struct (const struct spa_pod *pod)
 
int spa_pod_is_object (const struct spa_pod *pod)
 
bool spa_pod_is_object_type (const struct spa_pod *pod, uint32_t type)
 
bool spa_pod_is_object_id (const struct spa_pod *pod, uint32_t id)
 
int spa_pod_is_sequence (const struct spa_pod *pod)
 
const struct spa_pod_propspa_pod_object_find_prop (const struct spa_pod_object *pod, const struct spa_pod_prop *start, uint32_t key)
 
const struct spa_pod_propspa_pod_find_prop (const struct spa_pod *pod, const struct spa_pod_prop *start, uint32_t key)
 
int spa_pod_object_fixate (struct spa_pod_object *pod)
 
int spa_pod_fixate (struct spa_pod *pod)
 
void spa_pod_parser_init (struct spa_pod_parser *parser, const void *data, uint32_t size)
 
void spa_pod_parser_pod (struct spa_pod_parser *parser, const struct spa_pod *pod)
 
void spa_pod_parser_get_state (struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
 
void spa_pod_parser_reset (struct spa_pod_parser *parser, struct spa_pod_parser_state *state)
 
struct spa_podspa_pod_parser_deref (struct spa_pod_parser *parser, uint32_t offset, uint32_t size)
 
struct spa_podspa_pod_parser_frame (struct spa_pod_parser *parser, struct spa_pod_frame *frame)
 
void spa_pod_parser_push (struct spa_pod_parser *parser, struct spa_pod_frame *frame, const struct spa_pod *pod, uint32_t offset)
 
struct spa_podspa_pod_parser_current (struct spa_pod_parser *parser)
 
void spa_pod_parser_advance (struct spa_pod_parser *parser, const struct spa_pod *pod)
 
struct spa_podspa_pod_parser_next (struct spa_pod_parser *parser)
 
int spa_pod_parser_pop (struct spa_pod_parser *parser, struct spa_pod_frame *frame)
 
int spa_pod_parser_get_bool (struct spa_pod_parser *parser, bool *value)
 
int spa_pod_parser_get_id (struct spa_pod_parser *parser, uint32_t *value)
 
int spa_pod_parser_get_int (struct spa_pod_parser *parser, int32_t *value)
 
int spa_pod_parser_get_long (struct spa_pod_parser *parser, int64_t *value)
 
int spa_pod_parser_get_float (struct spa_pod_parser *parser, float *value)
 
int spa_pod_parser_get_double (struct spa_pod_parser *parser, double *value)
 
int spa_pod_parser_get_string (struct spa_pod_parser *parser, const char **value)
 
int spa_pod_parser_get_bytes (struct spa_pod_parser *parser, const void **value, uint32_t *len)
 
int spa_pod_parser_get_pointer (struct spa_pod_parser *parser, uint32_t *type, const void **value)
 
int spa_pod_parser_get_fd (struct spa_pod_parser *parser, int64_t *value)
 
int spa_pod_parser_get_rectangle (struct spa_pod_parser *parser, struct spa_rectangle *value)
 
int spa_pod_parser_get_fraction (struct spa_pod_parser *parser, struct spa_fraction *value)
 
int spa_pod_parser_get_pod (struct spa_pod_parser *parser, struct spa_pod **value)
 
int spa_pod_parser_push_struct (struct spa_pod_parser *parser, struct spa_pod_frame *frame)
 
int spa_pod_parser_push_object (struct spa_pod_parser *parser, struct spa_pod_frame *frame, uint32_t type, uint32_t *id)
 
bool spa_pod_parser_can_collect (const struct spa_pod *pod, char type)
 
int spa_pod_parser_getv (struct spa_pod_parser *parser, va_list args)
 
int spa_pod_parser_get (struct spa_pod_parser *parser,...)
 

Detailed Description

Macro Definition Documentation

◆ SPA_CHOICE_BOOL

#define SPA_CHOICE_BOOL (   def)    3,(def),(def),!(def)

◆ SPA_CHOICE_ENUM

#define SPA_CHOICE_ENUM (   n_vals,
  ... 
)    (n_vals),##__VA_ARGS__

◆ SPA_CHOICE_FLAGS

#define SPA_CHOICE_FLAGS (   flags)    1, (flags)

◆ SPA_CHOICE_RANGE

#define SPA_CHOICE_RANGE (   def,
  min,
  max 
)    3,(def),(min),(max)

◆ SPA_CHOICE_STEP

#define SPA_CHOICE_STEP (   def,
  min,
  max,
  step 
)    4,(def),(min),(max),(step)

◆ SPA_COMMAND_ID

#define SPA_COMMAND_ID (   cmd,
  type 
)
Value:
(SPA_COMMAND_TYPE(cmd) == type ? \
(cmd)->body.body.id : SPA_ID_INVALID)
#define SPA_COMMAND_TYPE(cmd)
Definition: pod/command.h:49
#define SPA_ID_INVALID
Definition: defs.h:187

◆ SPA_COMMAND_INIT

#define SPA_COMMAND_INIT (   type,
  id 
)
Value:
sizeof(struct spa_command_body), type, id)
#define SPA_COMMAND_INIT_FULL(t, size, type, id,...)
Definition: pod/command.h:53
Definition: pod/command.h:40
Definition: pod/command.h:44

◆ SPA_COMMAND_INIT_FULL

#define SPA_COMMAND_INIT_FULL (   t,
  size,
  type,
  id,
  ... 
)
Value:
(t) \
{ { size, SPA_TYPE_Object }, \
{ { type, id }, ##__VA_ARGS__ } } \
@ SPA_TYPE_Object
Definition: build-13876487/doc/spa/utils/type.h:59

◆ SPA_COMMAND_TYPE

#define SPA_COMMAND_TYPE (   cmd)    ((cmd)->body.body.type)

◆ SPA_EVENT_ID

#define SPA_EVENT_ID (   ev,
  type 
)
Value:
(SPA_EVENT_TYPE(ev) == type ? \
(ev)->body.body.id : SPA_ID_INVALID)
#define SPA_EVENT_TYPE(ev)
Definition: pod/event.h:48

◆ SPA_EVENT_INIT

#define SPA_EVENT_INIT (   type,
  id 
)
Value:
sizeof(struct spa_event_body), type, id)
#define SPA_EVENT_INIT_FULL(t, size, type, id,...)
Definition: pod/event.h:52
Definition: pod/event.h:39
Definition: pod/event.h:43

◆ SPA_EVENT_INIT_FULL

#define SPA_EVENT_INIT_FULL (   t,
  size,
  type,
  id,
  ... 
)
Value:
(t) \
{ { size, SPA_TYPE_OBJECT }, \
{ { type, id }, ##__VA_ARGS__ } } \

◆ SPA_EVENT_TYPE

#define SPA_EVENT_TYPE (   ev)    ((ev)->body.body.type)

◆ SPA_POD_Array

#define SPA_POD_Array (   csize,
  ctype,
  n_vals,
  vals 
)    "a", csize,ctype,n_vals,vals

◆ SPA_POD_ARRAY_BODY_FOREACH

#define SPA_POD_ARRAY_BODY_FOREACH (   body,
  _size,
  iter 
)
Value:
for ((iter) = (__typeof__(iter))SPA_PTROFF((body), sizeof(struct spa_pod_array_body), void); \
(iter) < (__typeof__(iter))SPA_PTROFF((body), (_size), void); \
(iter) = (__typeof__(iter))SPA_PTROFF((iter), (body)->child.size, void))
#define SPA_PTROFF(ptr_, offset_, type_)
Return the address (buffer + offset) as pointer of type.
Definition: defs.h:164
Definition: pod/pod.h:122

◆ SPA_POD_ARRAY_CHILD

#define SPA_POD_ARRAY_CHILD (   arr)    (&((struct spa_pod_array*)(arr))->body.child)

◆ SPA_POD_ARRAY_FOREACH

#define SPA_POD_ARRAY_FOREACH (   obj,
  iter 
)     SPA_POD_ARRAY_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)

◆ SPA_POD_ARRAY_N_VALUES

#define SPA_POD_ARRAY_N_VALUES (   arr)    (SPA_POD_ARRAY_VALUE_SIZE(arr) ? ((SPA_POD_BODY_SIZE(arr) - sizeof(struct spa_pod_array_body)) / SPA_POD_ARRAY_VALUE_SIZE(arr)) : 0)

◆ SPA_POD_ARRAY_VALUE_SIZE

#define SPA_POD_ARRAY_VALUE_SIZE (   arr)    (SPA_POD_BODY_SIZE(SPA_POD_ARRAY_CHILD(arr)))

◆ SPA_POD_ARRAY_VALUE_TYPE

#define SPA_POD_ARRAY_VALUE_TYPE (   arr)    (SPA_POD_TYPE(SPA_POD_ARRAY_CHILD(arr)))

◆ SPA_POD_ARRAY_VALUES

#define SPA_POD_ARRAY_VALUES (   arr)    SPA_POD_CONTENTS(struct spa_pod_array, arr)

◆ SPA_POD_BODY

#define SPA_POD_BODY (   pod)    SPA_PTROFF((pod),sizeof(struct spa_pod),void)

◆ SPA_POD_BODY_CONST

#define SPA_POD_BODY_CONST (   pod)    SPA_PTROFF((pod),sizeof(struct spa_pod),const void)

◆ SPA_POD_BODY_SIZE

#define SPA_POD_BODY_SIZE (   pod)    (((struct spa_pod*)(pod))->size)

◆ SPA_POD_Bool

#define SPA_POD_Bool (   val)    "b", val

◆ spa_pod_builder_add_object

#define spa_pod_builder_add_object (   b,
  type,
  id,
  ... 
)
Value:
({ \
struct spa_pod_frame _f; \
spa_pod_builder_push_object(b, &_f, type, id); \
spa_pod_builder_add(b, ##__VA_ARGS__, 0); \
spa_pod_builder_pop(b, &_f); \
})
Definition: iter.h:42

◆ spa_pod_builder_add_sequence

#define spa_pod_builder_add_sequence (   b,
  unit,
  ... 
)
Value:
({ \
struct spa_pod_frame _f; \
spa_pod_builder_push_sequence(b, &_f, unit); \
spa_pod_builder_add(b, ##__VA_ARGS__, 0, 0); \
spa_pod_builder_pop(b, &_f); \
})

◆ spa_pod_builder_add_struct

#define spa_pod_builder_add_struct (   b,
  ... 
)
Value:
({ \
struct spa_pod_frame _f; \
spa_pod_builder_push_struct(b, &_f); \
spa_pod_builder_add(b, ##__VA_ARGS__, NULL); \
spa_pod_builder_pop(b, &_f); \
})

◆ SPA_POD_BUILDER_COLLECT

#define SPA_POD_BUILDER_COLLECT (   builder,
  type,
  args 
)

◆ SPA_POD_BUILDER_INIT

#define SPA_POD_BUILDER_INIT (   buffer,
  size 
)    (struct spa_pod_builder){ buffer, size, 0, {}, {} }

◆ SPA_POD_Bytes

#define SPA_POD_Bytes (   val,
  len 
)    "y",val,len

◆ SPA_POD_CHOICE_BODY_FOREACH

#define SPA_POD_CHOICE_BODY_FOREACH (   body,
  _size,
  iter 
)
Value:
for ((iter) = (__typeof__(iter))SPA_PTROFF((body), sizeof(struct spa_pod_choice_body), void); \
(iter) < (__typeof__(iter))SPA_PTROFF((body), (_size), void); \
(iter) = (__typeof__(iter))SPA_PTROFF((iter), (body)->child.size, void))
Definition: pod/pod.h:148

◆ SPA_POD_CHOICE_Bool

#define SPA_POD_CHOICE_Bool (   def)    "?eb", SPA_CHOICE_BOOL(def)

◆ SPA_POD_CHOICE_CHILD

#define SPA_POD_CHOICE_CHILD (   choice)    (&((struct spa_pod_choice*)(choice))->body.child)

◆ SPA_POD_CHOICE_ENUM_Double

#define SPA_POD_CHOICE_ENUM_Double (   n_vals,
  ... 
)    "?ed", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_ENUM_Float

#define SPA_POD_CHOICE_ENUM_Float (   n_vals,
  ... 
)    "?ef", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_ENUM_Fraction

#define SPA_POD_CHOICE_ENUM_Fraction (   n_vals,
  ... 
)    "?eF", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_ENUM_Id

#define SPA_POD_CHOICE_ENUM_Id (   n_vals,
  ... 
)    "?eI", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_ENUM_Int

#define SPA_POD_CHOICE_ENUM_Int (   n_vals,
  ... 
)    "?ei", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_ENUM_Long

#define SPA_POD_CHOICE_ENUM_Long (   n_vals,
  ... 
)    "?el", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_ENUM_Rectangle

#define SPA_POD_CHOICE_ENUM_Rectangle (   n_vals,
  ... 
)    "?eR", SPA_CHOICE_ENUM(n_vals, __VA_ARGS__)

◆ SPA_POD_CHOICE_FLAGS

#define SPA_POD_CHOICE_FLAGS (   choice)    (((struct spa_pod_choice*)(choice))->body.flags)

◆ SPA_POD_CHOICE_FLAGS_Int

#define SPA_POD_CHOICE_FLAGS_Int (   flags)    "?fi", SPA_CHOICE_FLAGS(flags)

◆ SPA_POD_CHOICE_FLAGS_Long

#define SPA_POD_CHOICE_FLAGS_Long (   flags)    "?fl", SPA_CHOICE_FLAGS(flags)

◆ SPA_POD_CHOICE_FOREACH

#define SPA_POD_CHOICE_FOREACH (   obj,
  iter 
)     SPA_POD_CHOICE_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)

◆ SPA_POD_CHOICE_N_VALUES

#define SPA_POD_CHOICE_N_VALUES (   choice)    (SPA_POD_CHOICE_VALUE_SIZE(choice) ? ((SPA_POD_BODY_SIZE(choice) - sizeof(struct spa_pod_choice_body)) / SPA_POD_CHOICE_VALUE_SIZE(choice)) : 0)

◆ SPA_POD_CHOICE_RANGE_Double

#define SPA_POD_CHOICE_RANGE_Double (   def,
  min,
  max 
)    "?rd", SPA_CHOICE_RANGE(def, min, max)

◆ SPA_POD_CHOICE_RANGE_Float

#define SPA_POD_CHOICE_RANGE_Float (   def,
  min,
  max 
)    "?rf", SPA_CHOICE_RANGE(def, min, max)

◆ SPA_POD_CHOICE_RANGE_Fraction

#define SPA_POD_CHOICE_RANGE_Fraction (   def,
  min,
  max 
)    "?rF", SPA_CHOICE_RANGE((def),(min),(max))

◆ SPA_POD_CHOICE_RANGE_Int

#define SPA_POD_CHOICE_RANGE_Int (   def,
  min,
  max 
)    "?ri", SPA_CHOICE_RANGE(def, min, max)

◆ SPA_POD_CHOICE_RANGE_Long

#define SPA_POD_CHOICE_RANGE_Long (   def,
  min,
  max 
)    "?rl", SPA_CHOICE_RANGE(def, min, max)

◆ SPA_POD_CHOICE_RANGE_Rectangle

#define SPA_POD_CHOICE_RANGE_Rectangle (   def,
  min,
  max 
)    "?rR", SPA_CHOICE_RANGE((def),(min),(max))

◆ SPA_POD_CHOICE_STEP_Double

#define SPA_POD_CHOICE_STEP_Double (   def,
  min,
  max,
  step 
)    "?sd", SPA_CHOICE_STEP(def, min, max, step)

◆ SPA_POD_CHOICE_STEP_Float

#define SPA_POD_CHOICE_STEP_Float (   def,
  min,
  max,
  step 
)    "?sf", SPA_CHOICE_STEP(def, min, max, step)

◆ SPA_POD_CHOICE_STEP_Fraction

#define SPA_POD_CHOICE_STEP_Fraction (   def,
  min,
  max,
  step 
)    "?sF", SPA_CHOICE_STEP(def, min, max, step)

◆ SPA_POD_CHOICE_STEP_Int

#define SPA_POD_CHOICE_STEP_Int (   def,
  min,
  max,
  step 
)    "?si", SPA_CHOICE_STEP(def, min, max, step)

◆ SPA_POD_CHOICE_STEP_Long

#define SPA_POD_CHOICE_STEP_Long (   def,
  min,
  max,
  step 
)    "?sl", SPA_CHOICE_STEP(def, min, max, step)

◆ SPA_POD_CHOICE_STEP_Rectangle

#define SPA_POD_CHOICE_STEP_Rectangle (   def,
  min,
  max,
  step 
)    "?sR", SPA_CHOICE_STEP((def),(min),(max),(step))

◆ SPA_POD_CHOICE_TYPE

#define SPA_POD_CHOICE_TYPE (   choice)    (((struct spa_pod_choice*)(choice))->body.type)

◆ SPA_POD_CHOICE_VALUE_SIZE

#define SPA_POD_CHOICE_VALUE_SIZE (   choice)    (SPA_POD_BODY_SIZE(SPA_POD_CHOICE_CHILD(choice)))

◆ SPA_POD_CHOICE_VALUE_TYPE

#define SPA_POD_CHOICE_VALUE_TYPE (   choice)    (SPA_POD_TYPE(SPA_POD_CHOICE_CHILD(choice)))

◆ SPA_POD_CHOICE_VALUES

#define SPA_POD_CHOICE_VALUES (   choice)    (SPA_POD_CONTENTS(struct spa_pod_choice, choice))

◆ SPA_POD_CONTENTS

#define SPA_POD_CONTENTS (   type,
  pod 
)    SPA_PTROFF((pod),sizeof(type),void)

◆ SPA_POD_CONTENTS_CONST

#define SPA_POD_CONTENTS_CONST (   type,
  pod 
)    SPA_PTROFF((pod),sizeof(type),const void)

◆ SPA_POD_CONTENTS_SIZE

#define SPA_POD_CONTENTS_SIZE (   type,
  pod 
)    (SPA_POD_SIZE(pod)-sizeof(type))

◆ SPA_POD_Control

#define SPA_POD_Control (   offset,
  type,
  ... 
)     offset, type, ##__VA_ARGS__

◆ SPA_POD_CONTROL_SIZE

#define SPA_POD_CONTROL_SIZE (   ev)    (sizeof(struct spa_pod_control) + (ev)->value.size)

◆ SPA_POD_Double

#define SPA_POD_Double (   val)    "d", val

◆ SPA_POD_Fd

#define SPA_POD_Fd (   val)    "h", val

◆ SPA_POD_Float

#define SPA_POD_Float (   val)    "f", val

◆ SPA_POD_FOREACH

#define SPA_POD_FOREACH (   pod,
  size,
  iter 
)
Value:
for ((iter) = (pod); \
spa_pod_is_inside(pod, size, iter); \
(iter) = (__typeof__(iter))spa_pod_next(iter))
void * spa_pod_next(const void *iter)
Definition: iter.h:55

◆ SPA_POD_Fraction

#define SPA_POD_Fraction (   val)    "F",val

◆ SPA_POD_Id

#define SPA_POD_Id (   val)    "I", val

◆ SPA_POD_INIT

#define SPA_POD_INIT (   size,
  type 
)    (struct spa_pod) { size, type }

◆ SPA_POD_INIT_Bool

#define SPA_POD_INIT_Bool (   val)    (struct spa_pod_bool){ { sizeof(uint32_t), SPA_TYPE_Bool }, val ? 1 : 0, 0 }

◆ SPA_POD_INIT_Bytes

#define SPA_POD_INIT_Bytes (   len)    (struct spa_pod_bytes){ { len, SPA_TYPE_Bytes } }

◆ SPA_POD_INIT_Choice

#define SPA_POD_INIT_Choice (   type,
  ctype,
  child_type,
  n_vals,
  ... 
)
Value:
(struct { struct spa_pod_choice choice; ctype vals[n_vals];}) \
{ { { n_vals * sizeof(ctype) + sizeof(struct spa_pod_choice_body), SPA_TYPE_Choice }, \
{ type, 0, { sizeof(ctype), child_type } } }, { __VA_ARGS__ } }
@ SPA_TYPE_Choice
Definition: build-13876487/doc/spa/utils/type.h:63
Definition: pod/pod.h:156

◆ SPA_POD_INIT_CHOICE_BODY

#define SPA_POD_INIT_CHOICE_BODY (   type,
  flags,
  child_size,
  child_type 
)     (struct spa_pod_choice_body) { type, flags, { child_size, child_type }}

◆ SPA_POD_INIT_Double

#define SPA_POD_INIT_Double (   val)    (struct spa_pod_double){ { sizeof(double), SPA_TYPE_Double }, val }

◆ SPA_POD_INIT_Fd

#define SPA_POD_INIT_Fd (   fd)    (struct spa_pod_fd){ { sizeof(int64_t), SPA_TYPE_Fd }, fd }

◆ SPA_POD_INIT_Float

#define SPA_POD_INIT_Float (   val)    (struct spa_pod_float){ { sizeof(float), SPA_TYPE_Float }, val, 0 }

◆ SPA_POD_INIT_Fraction

#define SPA_POD_INIT_Fraction (   val)    (struct spa_pod_fraction){ { sizeof(struct spa_fraction), SPA_TYPE_Fraction }, val }

◆ SPA_POD_INIT_Id

#define SPA_POD_INIT_Id (   val)    (struct spa_pod_id){ { sizeof(uint32_t), SPA_TYPE_Id }, (uint32_t)val, 0 }

◆ SPA_POD_INIT_Int

#define SPA_POD_INIT_Int (   val)    (struct spa_pod_int){ { sizeof(int32_t), SPA_TYPE_Int }, (int32_t)val, 0 }

◆ SPA_POD_INIT_Long

#define SPA_POD_INIT_Long (   val)    (struct spa_pod_long){ { sizeof(int64_t), SPA_TYPE_Long }, (int64_t)val }

◆ SPA_POD_INIT_None

#define SPA_POD_INIT_None ( )    SPA_POD_INIT(0, SPA_TYPE_None)

◆ SPA_POD_INIT_Object

#define SPA_POD_INIT_Object (   size,
  type,
  id,
  ... 
)    (struct spa_pod_object){ { size, SPA_TYPE_Object }, { type, id }, ##__VA_ARGS__ }

◆ SPA_POD_INIT_Pointer

#define SPA_POD_INIT_Pointer (   type,
  value 
)    (struct spa_pod_pointer){ { sizeof(struct spa_pod_pointer_body), SPA_TYPE_Pointer }, { type, 0, value } }

◆ SPA_POD_INIT_Prop

#define SPA_POD_INIT_Prop (   key,
  flags,
  size,
  type 
)     (struct spa_pod_prop){ key, flags, { size, type } }

◆ SPA_POD_INIT_Rectangle

#define SPA_POD_INIT_Rectangle (   val)    (struct spa_pod_rectangle){ { sizeof(struct spa_rectangle), SPA_TYPE_Rectangle }, val }

◆ SPA_POD_INIT_Sequence

#define SPA_POD_INIT_Sequence (   size,
  unit 
)     (struct spa_pod_sequence){ { size, SPA_TYPE_Sequence}, {unit, 0 } }

◆ SPA_POD_INIT_String

#define SPA_POD_INIT_String (   len)    (struct spa_pod_string){ { len, SPA_TYPE_String } }

◆ SPA_POD_INIT_Struct

#define SPA_POD_INIT_Struct (   size)    (struct spa_pod_struct){ { size, SPA_TYPE_Struct } }

◆ SPA_POD_Int

#define SPA_POD_Int (   val)    "i", val

◆ SPA_POD_Long

#define SPA_POD_Long (   val)    "l", val

◆ SPA_POD_None

#define SPA_POD_None ( )    "P", NULL

◆ SPA_POD_OBJECT_BODY_FOREACH

#define SPA_POD_OBJECT_BODY_FOREACH (   body,
  size,
  iter 
)
Value:
for ((iter) = spa_pod_prop_first(body); \
spa_pod_prop_is_inside(body, size, iter); \
(iter) = spa_pod_prop_next(iter))
struct spa_pod_prop * spa_pod_prop_next(const struct spa_pod_prop *iter)
Definition: iter.h:72
struct spa_pod_prop * spa_pod_prop_first(const struct spa_pod_object_body *body)
Definition: iter.h:60

◆ SPA_POD_OBJECT_FOREACH

#define SPA_POD_OBJECT_FOREACH (   obj,
  iter 
)     SPA_POD_OBJECT_BODY_FOREACH(&(obj)->body, SPA_POD_BODY_SIZE(obj), iter)

◆ SPA_POD_OBJECT_ID

#define SPA_POD_OBJECT_ID (   obj)    (((struct spa_pod_object*)(obj))->body.id)

◆ SPA_POD_OBJECT_TYPE

#define SPA_POD_OBJECT_TYPE (   obj)    (((struct spa_pod_object*)(obj))->body.type)

◆ SPA_POD_OPT_Array

#define SPA_POD_OPT_Array (   csize,
  ctype,
  n_vals,
  vals 
)    "?" SPA_POD_Array(csize,ctype,n_vals,vals)

◆ SPA_POD_OPT_Bool

#define SPA_POD_OPT_Bool (   val)    "?" SPA_POD_Bool(val)

◆ SPA_POD_OPT_Bytes

#define SPA_POD_OPT_Bytes (   val,
  len 
)    "?" SPA_POD_Bytes(val,len)

◆ SPA_POD_OPT_Double

#define SPA_POD_OPT_Double (   val)    "?" SPA_POD_Double(val)

◆ SPA_POD_OPT_Fd

#define SPA_POD_OPT_Fd (   val)    "?" SPA_POD_Fd(val)

◆ SPA_POD_OPT_Float

#define SPA_POD_OPT_Float (   val)    "?" SPA_POD_Float(val)

◆ SPA_POD_OPT_Fraction

#define SPA_POD_OPT_Fraction (   val)    "?" SPA_POD_Fraction(val)

◆ SPA_POD_OPT_Id

#define SPA_POD_OPT_Id (   val)    "?" SPA_POD_Id(val)

◆ SPA_POD_OPT_Int

#define SPA_POD_OPT_Int (   val)    "?" SPA_POD_Int(val)

◆ SPA_POD_OPT_Long

#define SPA_POD_OPT_Long (   val)    "?" SPA_POD_Long(val)

◆ SPA_POD_OPT_Pod

#define SPA_POD_OPT_Pod (   val)    "?" SPA_POD_Pod(val)

◆ SPA_POD_OPT_PodChoice

#define SPA_POD_OPT_PodChoice (   val)    "?" SPA_POD_PodChoice(val)

◆ SPA_POD_OPT_PodObject

#define SPA_POD_OPT_PodObject (   val)    "?" SPA_POD_PodObject(val)

◆ SPA_POD_OPT_PodStruct

#define SPA_POD_OPT_PodStruct (   val)    "?" SPA_POD_PodStruct(val)

◆ SPA_POD_OPT_Pointer

#define SPA_POD_OPT_Pointer (   type,
  val 
)    "?" SPA_POD_Pointer(type,val)

◆ SPA_POD_OPT_Rectangle

#define SPA_POD_OPT_Rectangle (   val)    "?" SPA_POD_Rectangle(val)

◆ SPA_POD_OPT_String

#define SPA_POD_OPT_String (   val)    "?" SPA_POD_String(val)

◆ SPA_POD_OPT_Stringn

#define SPA_POD_OPT_Stringn (   val,
  len 
)    "?" SPA_POD_Stringn(val,len)

◆ spa_pod_parse_object

#define spa_pod_parse_object (   pod,
  type,
  id,
  ... 
)
Value:
({ \
struct spa_pod_parser _p; \
spa_pod_parser_pod(&_p, pod); \
spa_pod_parser_get_object(&_p,type,id,##__VA_ARGS__); \
})
Definition: parser.h:49

◆ spa_pod_parse_struct

#define spa_pod_parse_struct (   pod,
  ... 
)
Value:
({ \
struct spa_pod_parser _p; \
spa_pod_parser_pod(&_p, pod); \
spa_pod_parser_get_struct(&_p,##__VA_ARGS__); \
})

◆ SPA_POD_PARSER_COLLECT

#define SPA_POD_PARSER_COLLECT (   pod,
  _type,
  args 
)

◆ spa_pod_parser_get_object

#define spa_pod_parser_get_object (   p,
  type,
  id,
  ... 
)
Value:
({ \
struct spa_pod_frame _f; \
int _res; \
if ((_res = spa_pod_parser_push_object(p, &_f, type, id)) == 0) { \
_res = spa_pod_parser_get(p,##__VA_ARGS__, 0); \
spa_pod_parser_pop(p, &_f); \
} \
_res; \
})
int spa_pod_parser_get(struct spa_pod_parser *parser,...)
Definition: parser.h:507
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

◆ spa_pod_parser_get_struct

#define spa_pod_parser_get_struct (   p,
  ... 
)
Value:
({ \
struct spa_pod_frame _f; \
int _res; \
if ((_res = spa_pod_parser_push_struct(p, &_f)) == 0) { \
_res = spa_pod_parser_get(p,##__VA_ARGS__, NULL); \
spa_pod_parser_pop(p, &_f); \
} \
_res; \
})
int spa_pod_parser_push_struct(struct spa_pod_parser *parser, struct spa_pod_frame *frame)
Definition: parser.h:253

◆ SPA_POD_PARSER_INIT

#define SPA_POD_PARSER_INIT (   buffer,
  size 
)    (struct spa_pod_parser){ buffer, size, 0, {} }

◆ SPA_POD_PARSER_SKIP

#define SPA_POD_PARSER_SKIP (   _type,
  args 
)

◆ SPA_POD_Pod

#define SPA_POD_Pod (   val)    "P", val

◆ SPA_POD_PodChoice

#define SPA_POD_PodChoice (   val)    "V", val

◆ SPA_POD_PodObject

#define SPA_POD_PodObject (   val)    "O", val

◆ SPA_POD_PodStruct

#define SPA_POD_PodStruct (   val)    "T", val

◆ SPA_POD_Pointer

#define SPA_POD_Pointer (   type,
  val 
)    "p", type,val

◆ SPA_POD_Prop

#define SPA_POD_Prop (   key,
  ... 
)     key, ##__VA_ARGS__

◆ SPA_POD_PROP_SIZE

#define SPA_POD_PROP_SIZE (   prop)    (sizeof(struct spa_pod_prop) + (prop)->value.size)

◆ SPA_POD_Rectangle

#define SPA_POD_Rectangle (   val)    "R",val

◆ SPA_POD_SEQUENCE_BODY_FOREACH

#define SPA_POD_SEQUENCE_BODY_FOREACH (   body,
  size,
  iter 
)
Value:
for ((iter) = spa_pod_control_first(body); \
spa_pod_control_is_inside(body, size, iter); \
(iter) = spa_pod_control_next(iter))
struct spa_pod_control * spa_pod_control_next(const struct spa_pod_control *iter)
Definition: iter.h:89
struct spa_pod_control * spa_pod_control_first(const struct spa_pod_sequence_body *body)
Definition: iter.h:77

◆ SPA_POD_SEQUENCE_FOREACH

#define SPA_POD_SEQUENCE_FOREACH (   seq,
  iter 
)     SPA_POD_SEQUENCE_BODY_FOREACH(&(seq)->body, SPA_POD_BODY_SIZE(seq), iter)

◆ SPA_POD_SIZE

#define SPA_POD_SIZE (   pod)    (sizeof(struct spa_pod) + SPA_POD_BODY_SIZE(pod))

◆ SPA_POD_String

#define SPA_POD_String (   val)    "s",val

◆ SPA_POD_Stringn

#define SPA_POD_Stringn (   val,
  len 
)    "S",val,len

◆ SPA_POD_STRUCT_FOREACH

#define SPA_POD_STRUCT_FOREACH (   obj,
  iter 
)     SPA_POD_FOREACH(SPA_POD_BODY(obj), SPA_POD_BODY_SIZE(obj), iter)

◆ SPA_POD_TYPE

#define SPA_POD_TYPE (   pod)    (((struct spa_pod*)(pod))->type)

◆ SPA_POD_VALUE

#define SPA_POD_VALUE (   type,
  pod 
)    (((type*)pod)->value)

Enumeration Type Documentation

◆ spa_choice_type

Enumerator
SPA_CHOICE_None 

no choice, first value is current

SPA_CHOICE_Range 

range: default, min, max

SPA_CHOICE_Step 

range with step: default, min, max, step

SPA_CHOICE_Enum 

list: default, alternative,...


SPA_CHOICE_Flags 

flags: default, possible flags,...

Function Documentation

◆ spa_choice_from_id()

uint32_t spa_choice_from_id ( char  id)
inline

◆ spa_pod_builder_add()

◆ spa_pod_builder_addv()

◆ spa_pod_builder_array()

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 
)
inline

◆ spa_pod_builder_bool()

int spa_pod_builder_bool ( struct spa_pod_builder builder,
bool  val 
)
inline

◆ spa_pod_builder_bytes()

int spa_pod_builder_bytes ( struct spa_pod_builder builder,
const void *  bytes,
uint32_t  len 
)
inline

◆ spa_pod_builder_child()

int spa_pod_builder_child ( struct spa_pod_builder builder,
uint32_t  size,
uint32_t  type 
)
inline

◆ spa_pod_builder_control()

uint32_t spa_pod_builder_control ( struct spa_pod_builder builder,
uint32_t  offset,
uint32_t  type 
)
inline

References spa_pod_builder_raw().

Referenced by spa_pod_builder_addv().

◆ spa_pod_builder_deref()

struct spa_pod* spa_pod_builder_deref ( struct spa_pod_builder builder,
uint32_t  offset 
)
inline

◆ spa_pod_builder_double()

int spa_pod_builder_double ( struct spa_pod_builder builder,
double  val 
)
inline

◆ spa_pod_builder_fd()

int spa_pod_builder_fd ( struct spa_pod_builder builder,
int64_t  fd 
)
inline

◆ spa_pod_builder_float()

int spa_pod_builder_float ( struct spa_pod_builder builder,
float  val 
)
inline

◆ spa_pod_builder_fraction()

int spa_pod_builder_fraction ( struct spa_pod_builder builder,
uint32_t  num,
uint32_t  denom 
)
inline

◆ spa_pod_builder_frame()

struct spa_pod* spa_pod_builder_frame ( struct spa_pod_builder builder,
struct spa_pod_frame frame 
)
inline

◆ spa_pod_builder_get_state()

void spa_pod_builder_get_state ( struct spa_pod_builder builder,
struct spa_pod_builder_state state 
)
inline

References spa_pod_builder::state.

Referenced by spa_pod_filter().

◆ spa_pod_builder_id()

int spa_pod_builder_id ( struct spa_pod_builder builder,
uint32_t  val 
)
inline

◆ spa_pod_builder_init()

void spa_pod_builder_init ( struct spa_pod_builder builder,
void *  data,
uint32_t  size 
)
inline

◆ spa_pod_builder_int()

int spa_pod_builder_int ( struct spa_pod_builder builder,
int32_t  val 
)
inline

◆ spa_pod_builder_long()

int spa_pod_builder_long ( struct spa_pod_builder builder,
int64_t  val 
)
inline

◆ spa_pod_builder_none()

int spa_pod_builder_none ( struct spa_pod_builder builder)
inline

◆ spa_pod_builder_pad()

int spa_pod_builder_pad ( struct spa_pod_builder builder,
uint32_t  size 
)
inline

◆ spa_pod_builder_pointer()

int spa_pod_builder_pointer ( struct spa_pod_builder builder,
uint32_t  type,
const void *  val 
)
inline

◆ spa_pod_builder_pop()

◆ spa_pod_builder_primitive()

◆ spa_pod_builder_prop()

int spa_pod_builder_prop ( struct spa_pod_builder builder,
uint32_t  key,
uint32_t  flags 
)
inline

◆ spa_pod_builder_push()

◆ spa_pod_builder_push_array()

int spa_pod_builder_push_array ( struct spa_pod_builder builder,
struct spa_pod_frame frame 
)
inline

◆ spa_pod_builder_push_choice()

int spa_pod_builder_push_choice ( struct spa_pod_builder builder,
struct spa_pod_frame frame,
uint32_t  type,
uint32_t  flags 
)
inline

◆ spa_pod_builder_push_object()

◆ spa_pod_builder_push_sequence()

int spa_pod_builder_push_sequence ( struct spa_pod_builder builder,
struct spa_pod_frame frame,
uint32_t  unit 
)
inline

◆ spa_pod_builder_push_struct()

int spa_pod_builder_push_struct ( struct spa_pod_builder builder,
struct spa_pod_frame frame 
)
inline

◆ spa_pod_builder_raw()

◆ spa_pod_builder_raw_padded()

int spa_pod_builder_raw_padded ( struct spa_pod_builder builder,
const void *  data,
uint32_t  size 
)
inline

◆ spa_pod_builder_rectangle()

int spa_pod_builder_rectangle ( struct spa_pod_builder builder,
uint32_t  width,
uint32_t  height 
)
inline

◆ spa_pod_builder_reserve_bytes()

void* spa_pod_builder_reserve_bytes ( struct spa_pod_builder builder,
uint32_t  len 
)
inline

◆ spa_pod_builder_reset()

void spa_pod_builder_reset ( struct spa_pod_builder builder,
struct spa_pod_builder_state state 
)
inline

◆ spa_pod_builder_set_callbacks()

void spa_pod_builder_set_callbacks ( struct spa_pod_builder builder,
const struct spa_pod_builder_callbacks callbacks,
void *  data 
)
inline

◆ spa_pod_builder_string()

int spa_pod_builder_string ( struct spa_pod_builder builder,
const char *  str 
)
inline

◆ spa_pod_builder_string_len()

int spa_pod_builder_string_len ( struct spa_pod_builder builder,
const char *  str,
uint32_t  len 
)
inline

◆ spa_pod_builder_write_string()

int spa_pod_builder_write_string ( struct spa_pod_builder builder,
const char *  str,
uint32_t  len 
)
inline

◆ spa_pod_choice_fix_default()

◆ spa_pod_compare()

◆ spa_pod_compare_value()

◆ spa_pod_control_first()

struct spa_pod_control* spa_pod_control_first ( const struct spa_pod_sequence_body body)
inline

References SPA_PTROFF.

◆ spa_pod_control_is_inside()

bool spa_pod_control_is_inside ( const struct spa_pod_sequence_body body,
uint32_t  size,
const struct spa_pod_control iter 
)
inline

◆ spa_pod_control_next()

struct spa_pod_control* spa_pod_control_next ( const struct spa_pod_control iter)
inline

◆ spa_pod_copy()

struct spa_pod* spa_pod_copy ( const struct spa_pod pod)
inline

Copy a pod structure.

References size, and SPA_POD_SIZE.

Referenced by pw_link_info_merge().

◆ spa_pod_copy_array()

uint32_t spa_pod_copy_array ( const struct spa_pod pod,
uint32_t  type,
void *  values,
uint32_t  max_values 
)
inline

◆ spa_pod_copy_string()

int spa_pod_copy_string ( const struct spa_pod pod,
size_t  maxlen,
char *  dest 
)
inline

◆ spa_pod_filter()

int spa_pod_filter ( struct spa_pod_builder b,
struct spa_pod **  result,
const struct spa_pod pod,
const struct spa_pod filter 
)
inline

◆ spa_pod_filter_flags_value()

int spa_pod_filter_flags_value ( struct spa_pod_builder b,
uint32_t  type,
const void *  r1,
const void *  r2,
uint32_t  size 
)
inline

◆ spa_pod_filter_part()

◆ spa_pod_filter_prop()

◆ spa_pod_find_prop()

const struct spa_pod_prop* spa_pod_find_prop ( const struct spa_pod pod,
const struct spa_pod_prop start,
uint32_t  key 
)
inline

◆ spa_pod_fixate()

int spa_pod_fixate ( struct spa_pod pod)
inline

◆ spa_pod_from_data()

void* spa_pod_from_data ( void *  data,
size_t  maxsize,
off_t  offset,
size_t  size 
)
inline

◆ spa_pod_get_array()

void* spa_pod_get_array ( const struct spa_pod pod,
uint32_t *  n_values 
)
inline

◆ spa_pod_get_bool()

int spa_pod_get_bool ( const struct spa_pod pod,
bool *  value 
)
inline

◆ spa_pod_get_bytes()

int spa_pod_get_bytes ( const struct spa_pod pod,
const void **  value,
uint32_t *  len 
)
inline

◆ spa_pod_get_double()

int spa_pod_get_double ( const struct spa_pod pod,
double *  value 
)
inline

◆ spa_pod_get_fd()

int spa_pod_get_fd ( const struct spa_pod pod,
int64_t *  value 
)
inline

◆ spa_pod_get_float()

int spa_pod_get_float ( const struct spa_pod pod,
float *  value 
)
inline

◆ spa_pod_get_fraction()

int spa_pod_get_fraction ( const struct spa_pod pod,
struct spa_fraction value 
)
inline

◆ spa_pod_get_id()

int spa_pod_get_id ( const struct spa_pod pod,
uint32_t *  value 
)
inline

◆ spa_pod_get_int()

int spa_pod_get_int ( const struct spa_pod pod,
int32_t *  value 
)
inline

◆ spa_pod_get_long()

int spa_pod_get_long ( const struct spa_pod pod,
int64_t *  value 
)
inline

◆ spa_pod_get_pointer()

int spa_pod_get_pointer ( const struct spa_pod pod,
uint32_t *  type,
const void **  value 
)
inline

◆ spa_pod_get_rectangle()

int spa_pod_get_rectangle ( const struct spa_pod pod,
struct spa_rectangle value 
)
inline

◆ spa_pod_get_string()

int spa_pod_get_string ( const struct spa_pod pod,
const char **  value 
)
inline

◆ spa_pod_get_values()

struct spa_pod* spa_pod_get_values ( const struct spa_pod pod,
uint32_t *  n_vals,
uint32_t *  choice 
)
inline

◆ spa_pod_is_array()

int spa_pod_is_array ( const struct spa_pod pod)
inline

◆ spa_pod_is_bitmap()

int spa_pod_is_bitmap ( const struct spa_pod pod)
inline

◆ spa_pod_is_bool()

int spa_pod_is_bool ( const struct spa_pod pod)
inline

◆ spa_pod_is_bytes()

int spa_pod_is_bytes ( const struct spa_pod pod)
inline

◆ spa_pod_is_choice()

int spa_pod_is_choice ( const struct spa_pod pod)
inline

◆ spa_pod_is_double()

int spa_pod_is_double ( const struct spa_pod pod)
inline

◆ spa_pod_is_fd()

int spa_pod_is_fd ( const struct spa_pod pod)
inline

◆ spa_pod_is_float()

int spa_pod_is_float ( const struct spa_pod pod)
inline

◆ spa_pod_is_fraction()

int spa_pod_is_fraction ( const struct spa_pod pod)
inline

◆ spa_pod_is_id()

int spa_pod_is_id ( const struct spa_pod pod)
inline

◆ spa_pod_is_inside()

bool spa_pod_is_inside ( const void *  pod,
uint32_t  size,
const void *  iter 
)
inline

◆ spa_pod_is_int()

int spa_pod_is_int ( const struct spa_pod pod)
inline

◆ spa_pod_is_long()

int spa_pod_is_long ( const struct spa_pod pod)
inline

◆ spa_pod_is_none()

int spa_pod_is_none ( const struct spa_pod pod)
inline

References SPA_POD_TYPE, and SPA_TYPE_None.

Referenced by spa_pod_parser_can_collect().

◆ spa_pod_is_object()

◆ spa_pod_is_object_id()

bool spa_pod_is_object_id ( const struct spa_pod pod,
uint32_t  id 
)
inline

◆ spa_pod_is_object_type()

bool spa_pod_is_object_type ( const struct spa_pod pod,
uint32_t  type 
)
inline

◆ spa_pod_is_pointer()

int spa_pod_is_pointer ( const struct spa_pod pod)
inline

◆ spa_pod_is_rectangle()

int spa_pod_is_rectangle ( const struct spa_pod pod)
inline

◆ spa_pod_is_sequence()

int spa_pod_is_sequence ( const struct spa_pod pod)
inline

◆ spa_pod_is_string()

int spa_pod_is_string ( const struct spa_pod pod)
inline

◆ spa_pod_is_struct()

int spa_pod_is_struct ( const struct spa_pod pod)
inline

◆ spa_pod_next()

void* spa_pod_next ( const void *  iter)
inline

◆ spa_pod_object_find_prop()

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 
)
inline

◆ spa_pod_object_fixate()

◆ spa_pod_parser_advance()

◆ spa_pod_parser_can_collect()

◆ spa_pod_parser_current()

◆ spa_pod_parser_deref()

struct spa_pod* spa_pod_parser_deref ( struct spa_pod_parser parser,
uint32_t  offset,
uint32_t  size 
)
inline

◆ spa_pod_parser_frame()

struct spa_pod* spa_pod_parser_frame ( struct spa_pod_parser parser,
struct spa_pod_frame frame 
)
inline

◆ spa_pod_parser_get()

int spa_pod_parser_get ( struct spa_pod_parser parser,
  ... 
)
inline

References spa_pod_parser_getv().

◆ spa_pod_parser_get_bool()

int spa_pod_parser_get_bool ( struct spa_pod_parser parser,
bool *  value 
)
inline

◆ spa_pod_parser_get_bytes()

int spa_pod_parser_get_bytes ( struct spa_pod_parser parser,
const void **  value,
uint32_t *  len 
)
inline

◆ spa_pod_parser_get_double()

int spa_pod_parser_get_double ( struct spa_pod_parser parser,
double *  value 
)
inline

◆ spa_pod_parser_get_fd()

int spa_pod_parser_get_fd ( struct spa_pod_parser parser,
int64_t *  value 
)
inline

◆ spa_pod_parser_get_float()

int spa_pod_parser_get_float ( struct spa_pod_parser parser,
float *  value 
)
inline

◆ spa_pod_parser_get_fraction()

int spa_pod_parser_get_fraction ( struct spa_pod_parser parser,
struct spa_fraction value 
)
inline

◆ spa_pod_parser_get_id()

int spa_pod_parser_get_id ( struct spa_pod_parser parser,
uint32_t *  value 
)
inline

◆ spa_pod_parser_get_int()

int spa_pod_parser_get_int ( struct spa_pod_parser parser,
int32_t *  value 
)
inline

◆ spa_pod_parser_get_long()

int spa_pod_parser_get_long ( struct spa_pod_parser parser,
int64_t *  value 
)
inline

◆ spa_pod_parser_get_pod()

int spa_pod_parser_get_pod ( struct spa_pod_parser parser,
struct spa_pod **  value 
)
inline

◆ spa_pod_parser_get_pointer()

int spa_pod_parser_get_pointer ( struct spa_pod_parser parser,
uint32_t *  type,
const void **  value 
)
inline

◆ spa_pod_parser_get_rectangle()

int spa_pod_parser_get_rectangle ( struct spa_pod_parser parser,
struct spa_rectangle value 
)
inline

◆ spa_pod_parser_get_state()

void spa_pod_parser_get_state ( struct spa_pod_parser parser,
struct spa_pod_parser_state state 
)
inline

References spa_pod_parser::state.

◆ spa_pod_parser_get_string()

int spa_pod_parser_get_string ( struct spa_pod_parser parser,
const char **  value 
)
inline

◆ spa_pod_parser_getv()

◆ spa_pod_parser_init()

void spa_pod_parser_init ( struct spa_pod_parser parser,
const void *  data,
uint32_t  size 
)
inline

References SPA_POD_PARSER_INIT.

Referenced by spa_pod_parser_pod().

◆ spa_pod_parser_next()

struct spa_pod* spa_pod_parser_next ( struct spa_pod_parser parser)
inline

◆ spa_pod_parser_pod()

void spa_pod_parser_pod ( struct spa_pod_parser parser,
const struct spa_pod pod 
)
inline

◆ spa_pod_parser_pop()

◆ spa_pod_parser_push()

void spa_pod_parser_push ( struct spa_pod_parser parser,
struct spa_pod_frame frame,
const struct spa_pod pod,
uint32_t  offset 
)
inline

◆ spa_pod_parser_push_object()

int spa_pod_parser_push_object ( struct spa_pod_parser parser,
struct spa_pod_frame frame,
uint32_t  type,
uint32_t *  id 
)
inline

◆ spa_pod_parser_push_struct()

int spa_pod_parser_push_struct ( struct spa_pod_parser parser,
struct spa_pod_frame frame 
)
inline

◆ spa_pod_parser_reset()

void spa_pod_parser_reset ( struct spa_pod_parser parser,
struct spa_pod_parser_state state 
)
inline

References spa_pod_parser::state.

◆ spa_pod_prop_first()

struct spa_pod_prop* spa_pod_prop_first ( const struct spa_pod_object_body body)
inline

References SPA_PTROFF.

Referenced by spa_pod_object_find_prop().

◆ spa_pod_prop_is_inside()

bool spa_pod_prop_is_inside ( const struct spa_pod_object_body body,
uint32_t  size,
const struct spa_pod_prop iter 
)
inline

◆ spa_pod_prop_next()

struct spa_pod_prop* spa_pod_prop_next ( const struct spa_pod_prop iter)
inline