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_pod *	spa_pod_builder_deref (struct spa_pod_builder *builder, uint32_t offset)

struct spa_pod *	spa_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_pod *	spa_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_prop *	spa_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_prop *	spa_pod_prop_next (const struct spa_pod_prop *iter)

struct spa_pod_control *	spa_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_control *	spa_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_pod *	spa_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_prop *	spa_pod_object_find_prop (const struct spa_pod_object pod, const struct spa_pod_prop start, uint32_t key)

const struct spa_pod_prop *	spa_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_pod *	spa_pod_parser_deref (struct spa_pod_parser *parser, uint32_t offset, uint32_t size)

struct spa_pod *	spa_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_pod *	spa_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_pod *	spa_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)

◆ SPA_COMMAND_INIT

#define SPA_COMMAND_INIT	(	type,
		id
	)

Value:

SPA_COMMAND_INIT_FULL(struct spa_command, \

sizeof(struct spa_command_body), type, id)

◆ SPA_COMMAND_INIT_FULL

#define SPA_COMMAND_INIT_FULL	(	t,
		size,
		type,
		id,
		...
	)

Value:

        (t)                     \
        { { size, SPA_TYPE_Object },                                    \
          { { type, id }, ##__VA_ARGS__ } }                             \

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

◆ SPA_EVENT_INIT

#define SPA_EVENT_INIT	(	type,
		id
	)

Value:

SPA_EVENT_INIT_FULL(struct spa_event, \

sizeof(struct spa_event_body), type, id)

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

◆ 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);                                            \
})

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

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

◆ 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_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))

◆ 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__);   \
})

◆ 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;                                                                   \
})

◆ 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;                                                   \
})

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

◆ 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

enum 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

References SPA_CHOICE_Enum, SPA_CHOICE_Flags, SPA_CHOICE_None, SPA_CHOICE_Range, and SPA_CHOICE_Step.

Referenced by spa_pod_builder_addv().

◆ spa_pod_builder_add()

int spa_pod_builder_add	(	struct spa_pod_builder *	builder,
			...
	)

inline

References spa_pod_builder_addv().

Referenced by spa_format_audio_dsp_build(), spa_format_audio_raw_build(), spa_format_video_dsp_build(), and spa_format_video_raw_build().

◆ spa_pod_builder_addv()

int spa_pod_builder_addv	(	struct spa_pod_builder *	builder,
		va_list	args
	)

inline

References spa_pod_builder_state::frame, spa_pod_frame::offset, spa_pod_frame::pod, spa_choice_from_id(), SPA_FALLTHROUGH, SPA_POD_BUILDER_COLLECT, spa_pod_builder_control(), spa_pod_builder_pop(), spa_pod_builder_prop(), spa_pod_builder_push_choice(), SPA_TYPE_None, SPA_TYPE_Object, SPA_TYPE_Sequence, spa_pod_builder::state, and type.

Referenced by spa_pod_builder_add().

◆ 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

References spa_pod_builder_raw(), spa_pod_builder_raw_padded(), and SPA_TYPE_Array.

◆ spa_pod_builder_bool()

int spa_pod_builder_bool	(	struct spa_pod_builder *	builder,
		bool	val
	)

inline

References spa_pod_bool::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Bool.

◆ spa_pod_builder_bytes()

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

inline

References spa_pod_builder_raw(), spa_pod_builder_raw_padded(), and SPA_POD_INIT_Bytes.

Referenced by spa_pod_builder_reserve_bytes().

◆ spa_pod_builder_child()

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

inline

References spa_pod_builder_state::flags, size, SPA_FLAG_CLEAR, SPA_POD_BUILDER_FLAG_FIRST, spa_pod_builder_raw(), SPA_POD_INIT, spa_pod_builder::state, and type.

◆ 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

References spa_pod_builder::data, spa_pod_builder::size, size, SPA_POD_SIZE, and SPA_PTROFF.

Referenced by spa_pod_builder_reserve_bytes(), and spa_pod_filter().

◆ spa_pod_builder_double()

int spa_pod_builder_double	(	struct spa_pod_builder *	builder,
		double	val
	)

inline

References spa_pod_double::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Double.

◆ spa_pod_builder_fd()

int spa_pod_builder_fd	(	struct spa_pod_builder *	builder,
		int64_t	fd
	)

inline

References spa_pod_fd::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Fd.

◆ spa_pod_builder_float()

int spa_pod_builder_float	(	struct spa_pod_builder *	builder,
		float	val
	)

inline

References spa_pod_float::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Float.

◆ spa_pod_builder_fraction()

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

inline

References spa_pod_fraction::pod, SPA_FRACTION, spa_pod_builder_primitive(), and SPA_POD_INIT_Fraction.

◆ spa_pod_builder_frame()

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

inline

References spa_pod_builder::data, spa_pod_frame::offset, spa_pod_frame::pod, spa_pod_builder::size, SPA_POD_SIZE, and SPA_PTROFF.

Referenced by spa_pod_builder_pop(), and spa_pod_filter_prop().

◆ 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

References spa_pod_id::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Id.

◆ spa_pod_builder_init()

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

inline

References SPA_POD_BUILDER_INIT.

Referenced by pw_context_debug_port_params(), pw_context_find_format(), and pw_impl_port_recalc_latency().

◆ spa_pod_builder_int()

int spa_pod_builder_int	(	struct spa_pod_builder *	builder,
		int32_t	val
	)

inline

References spa_pod_int::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Int.

Referenced by spa_pod_filter_flags_value().

◆ spa_pod_builder_long()

int spa_pod_builder_long	(	struct spa_pod_builder *	builder,
		int64_t	val
	)

inline

References spa_pod_long::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Long.

Referenced by spa_pod_filter_flags_value().

◆ spa_pod_builder_none()

int spa_pod_builder_none ( struct spa_pod_builder * builder )

inline

References spa_pod_builder_primitive(), and SPA_POD_INIT_None.

◆ spa_pod_builder_pad()

int spa_pod_builder_pad	(	struct spa_pod_builder *	builder,
		uint32_t	size
	)

inline

References spa_pod_builder_raw(), and SPA_ROUND_UP_N.

Referenced by spa_pod_builder_pop(), spa_pod_builder_primitive(), spa_pod_builder_raw_padded(), and spa_pod_builder_write_string().

◆ spa_pod_builder_pointer()

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

inline

References spa_pod_pointer::pod, spa_pod_builder_primitive(), and SPA_POD_INIT_Pointer.

◆ spa_pod_builder_pop()

void* spa_pod_builder_pop	(	struct spa_pod_builder *	builder,
		struct spa_pod_frame *	frame
	)

inline

◆ spa_pod_builder_primitive()

int spa_pod_builder_primitive	(	struct spa_pod_builder *	builder,
		const struct spa_pod *	p
	)

inline

◆ spa_pod_builder_prop()

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

inline

References spa_pod_builder_raw().

Referenced by spa_pod_builder_addv(), and spa_pod_filter_prop().

◆ spa_pod_builder_push()

void spa_pod_builder_push	(	struct spa_pod_builder *	builder,
		struct spa_pod_frame *	frame,
		const struct spa_pod *	pod,
		uint32_t	offset
	)

inline

References spa_pod_builder_state::flags, spa_pod_frame::flags, spa_pod_builder_state::frame, spa_pod_frame::offset, spa_pod_frame::parent, spa_pod_frame::pod, SPA_POD_BUILDER_FLAG_BODY, SPA_POD_BUILDER_FLAG_FIRST, SPA_TYPE_Array, SPA_TYPE_Choice, spa_pod_builder::state, and type.

Referenced by spa_pod_builder_push_array(), spa_pod_builder_push_choice(), spa_pod_builder_push_object(), spa_pod_builder_push_sequence(), and spa_pod_builder_push_struct().

◆ spa_pod_builder_push_array()

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

inline

References spa_pod_builder_state::offset, spa_pod_array::pod, spa_pod_builder_push(), spa_pod_builder_raw(), SPA_TYPE_Array, and spa_pod_builder::state.

◆ 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

References spa_pod_choice_body::flags, spa_pod_builder_state::offset, spa_pod_choice::pod, spa_pod_builder_push(), spa_pod_builder_raw(), SPA_TYPE_Choice, spa_pod_builder::state, and spa_pod_choice_body::type.

Referenced by spa_pod_builder_addv(), and spa_pod_filter_prop().

◆ spa_pod_builder_push_object()

int spa_pod_builder_push_object	(	struct spa_pod_builder *	builder,
		struct spa_pod_frame *	frame,
		uint32_t	type,
		uint32_t	id
	)

inline

References spa_pod_builder_state::offset, spa_pod_object::pod, spa_pod_builder_push(), spa_pod_builder_raw(), SPA_POD_INIT_Object, and spa_pod_builder::state.

Referenced by pw_stream_set_control(), spa_format_audio_dsp_build(), spa_format_audio_raw_build(), spa_format_video_dsp_build(), spa_format_video_raw_build(), and spa_pod_filter_part().

◆ 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

References spa_pod_builder_state::offset, spa_pod_sequence::pod, spa_pod_builder_push(), spa_pod_builder_raw(), SPA_POD_INIT_Sequence, and spa_pod_builder::state.

◆ spa_pod_builder_push_struct()

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

inline

References spa_pod_builder_state::offset, spa_pod_struct::pod, spa_pod_builder_push(), spa_pod_builder_raw(), SPA_POD_INIT_Struct, and spa_pod_builder::state.

Referenced by spa_pod_filter_part().

◆ spa_pod_builder_raw()

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

inline

◆ spa_pod_builder_raw_padded()

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

inline

References spa_pod_builder_pad(), and spa_pod_builder_raw().

Referenced by spa_pod_builder_array(), spa_pod_builder_bytes(), spa_pod_filter(), spa_pod_filter_part(), spa_result_func_device_params(), and spa_result_func_node_params().

◆ spa_pod_builder_rectangle()

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

inline

References spa_pod_rectangle::pod, spa_pod_builder_primitive(), SPA_POD_INIT_Rectangle, and SPA_RECTANGLE.

◆ spa_pod_builder_reserve_bytes()

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

inline

References spa_pod_builder_state::offset, SPA_POD_BODY, spa_pod_builder_bytes(), spa_pod_builder_deref(), and spa_pod_builder::state.

◆ spa_pod_builder_reset()

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

inline

References spa_pod_builder_state::frame, spa_pod_builder_state::offset, spa_pod_frame::parent, spa_pod_frame::pod, size, and spa_pod_builder::state.

Referenced by spa_pod_filter().

◆ 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

References spa_pod_builder::callbacks, and SPA_CALLBACKS_INIT.

◆ spa_pod_builder_string()

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

inline

References spa_pod_builder_string_len().

◆ spa_pod_builder_string_len()

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

inline

References spa_pod_builder_raw(), spa_pod_builder_write_string(), and SPA_POD_INIT_String.

Referenced by spa_pod_builder_string().

◆ spa_pod_builder_write_string()

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

inline

References spa_pod_builder_state::offset, spa_pod_builder_pad(), spa_pod_builder_raw(), and spa_pod_builder::state.

Referenced by spa_pod_builder_string_len().

◆ spa_pod_choice_fix_default()

int spa_pod_choice_fix_default ( struct spa_pod_choice * choice )

inline

References spa_pod_choice::body, pw_buffer::size, SPA_CHOICE_Enum, SPA_CHOICE_Flags, SPA_CHOICE_None, SPA_CHOICE_Range, SPA_CHOICE_Step, SPA_POD_CHOICE_N_VALUES, SPA_POD_CHOICE_VALUE_SIZE, SPA_POD_CHOICE_VALUE_TYPE, SPA_POD_CHOICE_VALUES, spa_pod_compare_value(), SPA_PTROFF, and spa_pod_choice_body::type.

Referenced by spa_pod_filter_prop().

◆ spa_pod_compare()

int spa_pod_compare	(	const struct spa_pod *	pod1,
		const struct spa_pod *	pod2
	)

inline

References spa_pod_prop::key, SPA_POD_BODY, SPA_POD_BODY_CONST, SPA_POD_BODY_SIZE, spa_pod_compare_value(), spa_pod_get_values(), spa_pod_is_inside(), spa_pod_next(), spa_pod_object_find_prop(), SPA_POD_OBJECT_FOREACH, SPA_POD_TYPE, spa_return_val_if_fail, SPA_TYPE_Array, SPA_TYPE_Object, SPA_TYPE_Struct, and spa_pod_prop::value.

◆ spa_pod_compare_value()

int spa_pod_compare_value	(	uint32_t	type,
		const void *	r1,
		const void *	r2,
		uint32_t	size
	)

inline

References spa_fraction::denom, spa_rectangle::height, spa_fraction::num, SPA_TYPE_Bool, SPA_TYPE_Bytes, SPA_TYPE_Double, SPA_TYPE_Float, SPA_TYPE_Fraction, SPA_TYPE_Id, SPA_TYPE_Int, SPA_TYPE_Long, SPA_TYPE_None, SPA_TYPE_Rectangle, SPA_TYPE_String, and spa_rectangle::width.

Referenced by spa_pod_choice_fix_default(), spa_pod_compare(), and spa_pod_filter_prop().

◆ 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

References SPA_POD_CONTENTS, SPA_POD_CONTROL_SIZE, and SPA_PTROFF.

◆ spa_pod_control_next()

struct spa_pod_control* spa_pod_control_next ( const struct spa_pod_control * iter )

inline

References SPA_POD_CONTROL_SIZE, SPA_PTROFF, and SPA_ROUND_UP_N.

◆ 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_update().

◆ 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

References spa_pod_pointer::pod, SPA_MIN, SPA_POD_ARRAY_VALUE_SIZE, SPA_POD_ARRAY_VALUE_TYPE, and spa_pod_get_array().

Referenced by spa_format_audio_raw_parse().

◆ spa_pod_copy_string()

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

inline

References SPA_POD_CONTENTS, and spa_pod_is_string().

◆ 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

References spa_pod_builder_state::offset, spa_pod_builder_deref(), spa_pod_builder_get_state(), spa_pod_builder_raw_padded(), spa_pod_builder_reset(), spa_pod_filter_part(), SPA_POD_SIZE, and spa_return_val_if_fail.

◆ 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

References spa_pod_builder_int(), spa_pod_builder_long(), SPA_TYPE_Int, and SPA_TYPE_Long.

Referenced by spa_pod_filter_prop().

◆ spa_pod_filter_part()

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
	)