mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-02 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

pod: optimize a little

Browse source
This commit is contained in:
Wim Taymans 2017-03-20 10:10:04 +01:00
parent 1588b9df8d
commit 08194ec982
1 changed files with 161 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

240
spa/include/spa/pod-builder.h
View file

@ -107,7 +107,7 @@ spa_pod_builder_pad (SpaPODBuilder *builder, uint32_t size)
static inline uint32_t static inline uint32_t
spa_pod_builder_raw_padded (SpaPODBuilder *builder, const void *data, uint32_t size) spa_pod_builder_raw_padded (SpaPODBuilder *builder, const void *data, uint32_t size)
{ {
uint32_t ref = spa_pod_builder_raw (builder, data, size); uint32_t ref = size ? spa_pod_builder_raw (builder, data, size) : -1;
spa_pod_builder_pad (builder, size); spa_pod_builder_pad (builder, size);
return ref; return ref;
} }
@ -308,7 +308,7 @@ spa_pod_builder_push_prop (SpaPODBuilder *builder,
uint32_t flags) uint32_t flags)
{ {
const SpaPODProp p = { { sizeof (SpaPODPropBody) - sizeof(SpaPOD), SPA_POD_TYPE_PROP}, const SpaPODProp p = { { sizeof (SpaPODPropBody) - sizeof(SpaPOD), SPA_POD_TYPE_PROP},
{ key, flags | SPA_POD_PROP_RANGE_NONE, { 0, 0 } } }; { key, flags, { 0, 0 } } };
return spa_pod_builder_push (builder, frame, &p.pod, return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD))); spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD)));
} }
@ -319,117 +319,199 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
va_list args) va_list args)
{ {
uint32_t n_values = 0; uint32_t n_values = 0;
union {
SpaPOD pod;
SpaPODBool bool_pod;
SpaPODURI uri_pod;
SpaPODInt int_pod;
SpaPODLong long_pod;
SpaPODFloat float_pod;
SpaPODDouble double_pod;
SpaPODString string_pod;
SpaPODBytes bytes_pod;
SpaPODRectangle rectangle_pod;
SpaPODFraction fraction_pod;
SpaPODArray array_pod;
SpaPODStruct struct_pod;
SpaPODObject object_pod;
SpaPODProp prop_pod;
} head;
uint32_t head_size;
const void *body;
uint32_t body_size;
static const uint64_t zeroes = 0;
while (type != 0) { while (type != 0) {
SpaPODFrame *f = NULL;
const void *data[3];
uint32_t size[3], ref, i, n_sizes = 0;
switch (type) { switch (type) {
case SPA_POD_TYPE_INVALID: case SPA_POD_TYPE_INVALID:
break; break;
case SPA_POD_TYPE_BOOL: case SPA_POD_TYPE_BOOL:
spa_pod_builder_bool (builder, va_arg (args, int)); head.bool_pod.pod.type = SPA_POD_TYPE_BOOL;
break; head.bool_pod.pod.size = body_size = sizeof (uint32_t);
head.bool_pod.value = va_arg (args, int);
head_size = sizeof (SpaPOD);
body = &head.bool_pod.value;
goto primitive;
case SPA_POD_TYPE_URI: case SPA_POD_TYPE_URI:
spa_pod_builder_uri (builder, va_arg (args, int32_t)); head.uri_pod.pod.type = SPA_POD_TYPE_URI;
break; head.uri_pod.pod.size = body_size = sizeof (uint32_t);
head.uri_pod.value = va_arg (args, int);
head_size = sizeof (SpaPOD);
body = &head.uri_pod.value;
goto primitive;
case SPA_POD_TYPE_INT: case SPA_POD_TYPE_INT:
spa_pod_builder_int (builder, va_arg (args, int32_t)); head.int_pod.pod.type = SPA_POD_TYPE_INT;
break; head.int_pod.pod.size = body_size = sizeof (uint32_t);
head.int_pod.value = va_arg (args, int);
head_size = sizeof (SpaPOD);
body = &head.int_pod.value;
goto primitive;
case SPA_POD_TYPE_LONG: case SPA_POD_TYPE_LONG:
spa_pod_builder_long (builder, va_arg (args, int64_t)); head.long_pod.pod.type = SPA_POD_TYPE_LONG;
break; head.long_pod.pod.size = body_size = sizeof (uint32_t);
head.long_pod.value = va_arg (args, int64_t);
head_size = sizeof (SpaPOD);
body = &head.long_pod.value;
goto primitive;
case SPA_POD_TYPE_FLOAT: case SPA_POD_TYPE_FLOAT:
spa_pod_builder_float (builder, va_arg (args, double)); head.float_pod.pod.type = SPA_POD_TYPE_FLOAT;
break; head.float_pod.pod.size = body_size = sizeof (float);
head.float_pod.value = va_arg (args, double);
head_size = sizeof (SpaPOD);
body = &head.float_pod.value;
goto primitive;
case SPA_POD_TYPE_DOUBLE: case SPA_POD_TYPE_DOUBLE:
spa_pod_builder_double (builder, va_arg (args, double)); head.double_pod.pod.type = SPA_POD_TYPE_DOUBLE;
break; head.double_pod.pod.size = body_size = sizeof (double);
head.double_pod.value = va_arg (args, double);
head_size = sizeof (SpaPOD);
body = &head.double_pod.value;
goto primitive;
case SPA_POD_TYPE_STRING: case SPA_POD_TYPE_STRING:
spa_pod_builder_string (builder, va_arg (args, char *)); body = va_arg (args, const char *);
break; body_size = body ? strlen (body) + 1 : (body = "", 1);
head.string_pod.pod.type = SPA_POD_TYPE_STRING;
head.string_pod.pod.size = body_size;
head_size = sizeof (SpaPOD);
goto primitive;
case -SPA_POD_TYPE_STRING: case -SPA_POD_TYPE_STRING:
{ body = va_arg (args, const char *);
const char *str = va_arg (args, const char *); body_size = va_arg (args, uint32_t);
uint32_t len = va_arg (args, uint32_t); head.string_pod.pod.type = SPA_POD_TYPE_STRING;
spa_pod_builder_string_len (builder, str, len); head.string_pod.pod.size = body_size;
break; head_size = sizeof (SpaPOD);
} goto primitive;
case SPA_POD_TYPE_BYTES: case SPA_POD_TYPE_BYTES:
{ body = va_arg (args, void *);
void *value = va_arg (args, void *); body_size = va_arg (args, uint32_t);
uint32_t size = va_arg (args, uint32_t); head.bytes_pod.pod.type = SPA_POD_TYPE_BYTES;
spa_pod_builder_bytes (builder, value, size); head.bytes_pod.pod.size = body_size;
break; head_size = sizeof (SpaPOD);
} goto primitive;
case SPA_POD_TYPE_RECTANGLE: case SPA_POD_TYPE_RECTANGLE:
{ head.rectangle_pod.pod.type = SPA_POD_TYPE_RECTANGLE;
uint32_t width = va_arg (args, uint32_t), height = va_arg (args, uint32_t); head.rectangle_pod.pod.size = body_size = sizeof (SpaRectangle);
spa_pod_builder_rectangle (builder, width, height); head.rectangle_pod.value.width = va_arg (args, uint32_t);
break; head.rectangle_pod.value.height = va_arg (args, uint32_t);
} head_size = sizeof (SpaPOD);
body = &head.rectangle_pod.value;
goto primitive;
case -SPA_POD_TYPE_RECTANGLE: case -SPA_POD_TYPE_RECTANGLE:
{ head.rectangle_pod.pod.type = SPA_POD_TYPE_RECTANGLE;
const SpaRectangle *val = va_arg (args, SpaRectangle *); head.rectangle_pod.pod.size = body_size = sizeof (SpaRectangle);
spa_pod_builder_rectangle (builder, val->width, val->height); head.rectangle_pod.value = *va_arg (args, SpaRectangle *);
break; head_size = sizeof (SpaPOD);
} body = &head.rectangle_pod.value;
goto primitive;
case SPA_POD_TYPE_FRACTION: case SPA_POD_TYPE_FRACTION:
{ head.fraction_pod.pod.type = SPA_POD_TYPE_FRACTION;
uint32_t num = va_arg (args, uint32_t), denom = va_arg (args, uint32_t); head.fraction_pod.pod.size = body_size = sizeof (SpaFraction);
spa_pod_builder_fraction (builder, num, denom); head.fraction_pod.value.num = va_arg (args, uint32_t);
break; head.fraction_pod.value.denom = va_arg (args, uint32_t);
} head_size = sizeof (SpaPOD);
body = &head.fraction_pod.value;
goto primitive;
case -SPA_POD_TYPE_FRACTION: case -SPA_POD_TYPE_FRACTION:
{ head.fraction_pod.pod.type = SPA_POD_TYPE_FRACTION;
const SpaFraction *val = va_arg (args, SpaFraction *); head.fraction_pod.pod.size = body_size = sizeof (SpaFraction);
spa_pod_builder_fraction (builder, val->num, val->denom); head.fraction_pod.value = *va_arg (args, SpaFraction *);
break; head_size = sizeof (SpaPOD);
} body = &head.fraction_pod.value;
goto primitive;
case SPA_POD_TYPE_BITMASK: case SPA_POD_TYPE_BITMASK:
break; break;
case SPA_POD_TYPE_ARRAY: case SPA_POD_TYPE_ARRAY:
{ f = va_arg (args, SpaPODFrame *);
SpaPODFrame *f = va_arg (args, SpaPODFrame *);
type = va_arg (args, uint32_t); type = va_arg (args, uint32_t);
n_values = va_arg (args, uint32_t); n_values = va_arg (args, uint32_t);
spa_pod_builder_push_array (builder, f); head.array_pod.pod.type = SPA_POD_TYPE_ARRAY;
break; head.array_pod.pod.size = 0;
} head_size = sizeof(SpaPOD);
body = NULL;
goto primitive;
case SPA_POD_TYPE_STRUCT: case SPA_POD_TYPE_STRUCT:
{ f = va_arg (args, SpaPODFrame *);
SpaPODFrame *f = va_arg (args, SpaPODFrame *); head.struct_pod.pod.type = SPA_POD_TYPE_STRUCT;
spa_pod_builder_push_struct (builder, f); head.struct_pod.pod.size = 0;
break; head_size = sizeof(SpaPOD);
} body = NULL;
goto primitive;
case SPA_POD_TYPE_OBJECT: case SPA_POD_TYPE_OBJECT:
{ f = va_arg (args, SpaPODFrame *);
SpaPODFrame *f = va_arg (args, SpaPODFrame *); head.object_pod.pod.type = SPA_POD_TYPE_OBJECT;
uint32_t id = va_arg (args, uint32_t); head.object_pod.pod.size = sizeof (SpaPODObjectBody);
uint32_t type = va_arg (args, uint32_t); head.object_pod.body.id = va_arg (args, uint32_t);
spa_pod_builder_push_object (builder, f, id, type); head.object_pod.body.type = va_arg (args, uint32_t);
break; head_size = sizeof(SpaPODObject);
} body = NULL;
goto primitive;
case SPA_POD_TYPE_PROP: case SPA_POD_TYPE_PROP:
{ f = va_arg (args, SpaPODFrame *);
SpaPODFrame *f = va_arg (args, SpaPODFrame *); head.prop_pod.pod.type = SPA_POD_TYPE_PROP;
uint32_t key = va_arg (args, uint32_t); head.prop_pod.pod.size = sizeof (SpaPODPropBody) - sizeof(SpaPOD);
uint32_t flags = va_arg (args, uint32_t); head.prop_pod.body.key = va_arg (args, uint32_t);
head.prop_pod.body.flags = va_arg (args, uint32_t);
head_size = sizeof (SpaPODProp) - sizeof(SpaPOD);
body = NULL;
type = va_arg (args, uint32_t); type = va_arg (args, uint32_t);
n_values = va_arg (args, uint32_t); n_values = va_arg (args, uint32_t);
spa_pod_builder_push_prop (builder, f, key, flags); goto primitive;
break;
}
case -SPA_POD_TYPE_ARRAY: case -SPA_POD_TYPE_ARRAY:
case -SPA_POD_TYPE_STRUCT: case -SPA_POD_TYPE_STRUCT:
case -SPA_POD_TYPE_OBJECT: case -SPA_POD_TYPE_OBJECT:
case -SPA_POD_TYPE_PROP: case -SPA_POD_TYPE_PROP:
{ f = va_arg (args, SpaPODFrame *);
SpaPODFrame *f = va_arg (args, SpaPODFrame *);
spa_pod_builder_pop (builder, f); spa_pod_builder_pop (builder, f);
break; break;
}
case SPA_POD_TYPE_POD: case SPA_POD_TYPE_POD:
{ body = va_arg (args, void *);
const SpaPOD *value = va_arg (args, SpaPOD *); body_size = SPA_POD_SIZE (body);
spa_pod_builder_raw_padded (builder, value, SPA_POD_SIZE (value)); goto extra;
break; }
if (0) {
primitive:
if (!builder->in_array || builder->first) {
data[n_sizes] = &head;
size[n_sizes++] = head_size;
builder->first = false;
}
if (body) {
extra:
data[n_sizes] = body;
size[n_sizes++] = body_size;
if (!builder->in_array) {
data[n_sizes] = &zeroes;
size[n_sizes++] = SPA_ROUND_UP_N (body_size, 8) - body_size;
}
}
for (i = 0; i < n_sizes; i++) {
ref = spa_pod_builder_raw (builder, data[i], size[i]);
if (f && i == 0)
spa_pod_builder_push (builder, f, data[i], ref);
} }
} }
if (n_values > 0) if (n_values > 0)