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

Improve padding

Browse source 
Write out 0 while padding to make sure all memory is initialized
Remove the fd from the loop before destroying the node.
This commit is contained in:
Wim Taymans 2017-03-09 09:48:41 +01:00
parent a1dad30fd1
commit 905743dac6
8 changed files with 81 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

2
spa/include/spa/format-builder.h
View file

@ -40,7 +40,7 @@ spa_pod_builder_push_format (SpaPODBuilder *builder,
{ { sizeof (uint32_t), SPA_POD_TYPE_INT }, media_type }, 0,
{ { sizeof (uint32_t), SPA_POD_TYPE_INT }, media_subtype }, 0 } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
spa_pod_builder_raw (builder, &p, sizeof(p)));
}
static inline uint32_t

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

@ -71,19 +71,44 @@ spa_pod_builder_push (SpaPODBuilder *builder,
return ref;
}
static inline void
spa_pod_builder_advance (SpaPODBuilder *builder, uint32_t size, bool pad)
static inline uint32_t
spa_pod_builder_raw (SpaPODBuilder *builder, const void *data, uint32_t size)
{
if (pad)
size = SPA_ROUND_UP_N (size, 8);
uint32_t ref;
SpaPODFrame *f;
if (size > 0) {
SpaPODFrame *f;
builder->offset += size;
for (f = builder->stack; f; f = f->parent)
f->pod.size += size;
if (builder->write) {
ref = builder->write (builder, -1, data, size);
} else {
ref = builder->offset;
if (ref + size > builder->size)
ref = -1;
else
memcpy (builder->data + ref, data, size);
}
builder->offset += size;
for (f = builder->stack; f; f = f->parent)
f->pod.size += size;
return ref;
}
static void
spa_pod_builder_pad (SpaPODBuilder *builder, uint32_t size)
{
uint64_t zeroes = 0;
size = SPA_ROUND_UP_N (size, 8) - size;
if (size)
spa_pod_builder_raw (builder, &zeroes, size);
}
static inline uint32_t
spa_pod_builder_raw_padded (SpaPODBuilder *builder, const void *data, uint32_t size)
{
uint32_t ref = spa_pod_builder_raw (builder, data, size);
spa_pod_builder_pad (builder, size);
return ref;
}
static inline void
@ -99,44 +124,14 @@ spa_pod_builder_pop (SpaPODBuilder *builder,
builder->stack = frame->parent;
builder->in_array = (builder->stack && (builder->stack->pod.type == SPA_POD_TYPE_ARRAY ||
builder->stack->pod.type == SPA_POD_TYPE_PROP));
spa_pod_builder_advance (builder, SPA_ROUND_UP_N(builder->offset, 8) - builder->offset, false);
}
static inline uint32_t
spa_pod_builder_raw (SpaPODBuilder *builder, const void *data, uint32_t size, bool pad)
{
uint32_t ref;
if (builder->write) {
ref = builder->write (builder, -1, data, size);
} else {
ref = builder->offset;
if (ref + size > builder->size)
ref = -1;
else
memcpy (builder->data + ref, data, size);
}
spa_pod_builder_advance (builder, size, pad);
return ref;
}
static inline uint32_t
spa_pod_builder_string_body (SpaPODBuilder *builder,
const char *str,
uint32_t len)
{
uint32_t out = spa_pod_builder_raw (builder, str, len, true);
if (out != -1)
*SPA_MEMBER (builder->data, out + len-1, char) = '\0';
return out;
spa_pod_builder_pad (builder, builder->offset);
}
static inline uint32_t
spa_pod_builder_primitive (SpaPODBuilder *builder, const SpaPOD *p)
{
const void *data;
uint32_t size;
uint32_t size, ref;
if (builder->in_array && !builder->first) {
data = SPA_POD_BODY_CONST (p);
@ -146,7 +141,10 @@ spa_pod_builder_primitive (SpaPODBuilder *builder, const SpaPOD *p)
size = SPA_POD_SIZE (p);
builder->first = false;
}
return spa_pod_builder_raw (builder, data, size, !builder->in_array);
ref = spa_pod_builder_raw (builder, data, size);
if (!builder->in_array)
spa_pod_builder_pad (builder, size);
return ref;
}
static inline uint32_t
@ -195,10 +193,10 @@ static inline uint32_t
spa_pod_builder_string_len (SpaPODBuilder *builder, const char *str, uint32_t len)
{
const SpaPODString p = { { len, SPA_POD_TYPE_STRING } };
uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
if (spa_pod_builder_string_body (builder, str, len) == -1)
out = -1;
return out;
uint32_t ref = spa_pod_builder_raw (builder, &p, sizeof (p));
if (spa_pod_builder_raw_padded (builder, str, len) == -1)
ref = -1;
return ref;
}
static inline uint32_t
@ -212,10 +210,10 @@ static inline uint32_t
spa_pod_builder_bytes (SpaPODBuilder *builder, const void *bytes, uint32_t len)
{
const SpaPODBytes p = { { len, SPA_POD_TYPE_BYTES } };
uint32_t out = spa_pod_builder_raw (builder, &p, sizeof (p) , false);
if (spa_pod_builder_raw (builder, bytes, len, true) == -1)
out = -1;
return out;
uint32_t ref = spa_pod_builder_raw (builder, &p, sizeof (p));
if (spa_pod_builder_raw_padded (builder, bytes, len) == -1)
ref = -1;
return ref;
}
static inline uint32_t
@ -238,7 +236,7 @@ spa_pod_builder_push_array (SpaPODBuilder *builder,
{
const SpaPODArray p = { { sizeof (SpaPODArrayBody) - sizeof (SpaPOD), SPA_POD_TYPE_ARRAY }, { { 0, 0 } } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD), false));
spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD)));
}
static inline uint32_t
@ -252,10 +250,10 @@ spa_pod_builder_array (SpaPODBuilder *builder,
{ (uint32_t)(sizeof (SpaPODArrayBody) + n_elems * child_size), SPA_POD_TYPE_ARRAY },
{ { child_size, child_type } }
};
uint32_t out = spa_pod_builder_raw (builder, &p, sizeof(p), true);
if (spa_pod_builder_raw (builder, elems, child_size * n_elems, true) == -1)
out = -1;
return out;
uint32_t ref = spa_pod_builder_raw_padded (builder, &p, sizeof(p));
if (spa_pod_builder_raw_padded (builder, elems, child_size * n_elems) == -1)
ref = -1;
return ref;
}
static inline uint32_t
@ -264,7 +262,7 @@ spa_pod_builder_push_struct (SpaPODBuilder *builder,
{
const SpaPODStruct p = { { 0, SPA_POD_TYPE_STRUCT } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
spa_pod_builder_raw (builder, &p, sizeof(p)));
}
static inline uint32_t
@ -275,7 +273,7 @@ spa_pod_builder_push_object (SpaPODBuilder *builder,
{
const SpaPODObject p = { { sizeof (SpaPODObjectBody), SPA_POD_TYPE_OBJECT }, { id, type } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p), false));
spa_pod_builder_raw (builder, &p, sizeof(p)));
}
static inline uint32_t
@ -287,7 +285,7 @@ spa_pod_builder_push_prop (SpaPODBuilder *builder,
const SpaPODProp p = { { sizeof (SpaPODPropBody) - sizeof(SpaPOD), SPA_POD_TYPE_PROP},
{ key, flags | SPA_POD_PROP_RANGE_NONE, { 0, 0 } } };
return spa_pod_builder_push (builder, frame, &p.pod,
spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD), false));
spa_pod_builder_raw (builder, &p, sizeof(p) - sizeof(SpaPOD)));
}
static inline void
@ -393,7 +391,7 @@ spa_pod_builder_addv (SpaPODBuilder *builder,
case SPA_POD_TYPE_POD:
{
SpaPOD *value = va_arg (args, SpaPOD *);
spa_pod_builder_raw (builder, value, SPA_POD_SIZE (value), true);
spa_pod_builder_raw_padded (builder, value, SPA_POD_SIZE (value));
break;
}
}

18
spa/lib/props.c
View file

@ -154,7 +154,7 @@ spa_props_filter (SpaPODBuilder *b,
if (filter == NULL || (p2 = find_prop (filter, filter_size, p1->body.key)) == NULL) {
/* no filter, copy the complete property */
spa_pod_builder_raw (b, p1, SPA_POD_SIZE (p1), true);
spa_pod_builder_raw_padded (b, p1, SPA_POD_SIZE (p1));
continue;
}
@ -170,7 +170,7 @@ spa_props_filter (SpaPODBuilder *b,
spa_pod_builder_push_prop (b, &f, p1->body.key, SPA_POD_PROP_FLAG_READWRITE),
SpaPODProp);
/* default value */
spa_pod_builder_raw (b, &p1->body.value, sizeof (p1->body.value) + p1->body.value.size, false);
spa_pod_builder_raw (b, &p1->body.value, sizeof (p1->body.value) + p1->body.value.size);
alt1 = SPA_MEMBER (p1, sizeof (SpaPODProp), void);
nalt1 = SPA_POD_PROP_N_VALUES (p1);
@ -200,7 +200,7 @@ spa_props_filter (SpaPODBuilder *b,
for (j = 0, a1 = alt1; j < nalt1; j++, a1 += p1->body.value.size) {
for (k = 0, a2 = alt2; k < nalt2; k++, a2 += p2->body.value.size) {
if (compare_value (p1->body.value.type, a1, a2) == 0) {
spa_pod_builder_raw (b, a1, p1->body.value.size, false);
spa_pod_builder_raw (b, a1, p1->body.value.size);
n_copied++;
}
}
@ -219,7 +219,7 @@ spa_props_filter (SpaPODBuilder *b,
continue;
if (compare_value (p1->body.value.type, a1, a2 + p2->body.value.size) > 0)
continue;
spa_pod_builder_raw (b, a1, p1->body.value.size, false);
spa_pod_builder_raw (b, a1, p1->body.value.size);
n_copied++;
}
if (n_copied == 0)
@ -241,7 +241,7 @@ spa_props_filter (SpaPODBuilder *b,
continue;
if (compare_value (p1->body.value.type, a2, a1 + p1->body.value.size) > 0)
continue;
spa_pod_builder_raw (b, a2, p2->body.value.size, false);
spa_pod_builder_raw (b, a2, p2->body.value.size);
n_copied++;
}
if (n_copied == 0)
@ -251,17 +251,17 @@ spa_props_filter (SpaPODBuilder *b,
if (rt1 == SPA_POD_PROP_RANGE_MIN_MAX && rt2 == SPA_POD_PROP_RANGE_MIN_MAX) {
if (compare_value (p1->body.value.type, alt1, alt2) < 0)
spa_pod_builder_raw (b, alt2, p2->body.value.size, false);
spa_pod_builder_raw (b, alt2, p2->body.value.size);
else
spa_pod_builder_raw (b, alt1, p1->body.value.size, false);
spa_pod_builder_raw (b, alt1, p1->body.value.size);
alt1 += p1->body.value.size;
alt2 += p2->body.value.size;
if (compare_value (p1->body.value.type, alt1, alt2) < 0)
spa_pod_builder_raw (b, alt1, p1->body.value.size, false);
spa_pod_builder_raw (b, alt1, p1->body.value.size);
else
spa_pod_builder_raw (b, alt2, p2->body.value.size, false);
spa_pod_builder_raw (b, alt2, p2->body.value.size);
np->body.flags |= SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET;
}

2
spa/lib/video-raw.c
View file

@ -142,7 +142,7 @@ spa_format_filter (const SpaFormat *format,
return SPA_RESULT_INVALID_ARGUMENTS;
if (filter == NULL) {
spa_pod_builder_raw (result, format, SPA_POD_SIZE (format), true);
spa_pod_builder_raw_padded (result, format, SPA_POD_SIZE (format));
return SPA_RESULT_OK;
}

4
spa/tests/test-props.c
View file

@ -143,7 +143,7 @@ main (int argc, char *argv[])
SPA_PROP_ID_VIDEO_SIZE,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_rectangle (&b, 320, 240);
spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max), false);
spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max));
spa_pod_builder_pop (&b, &frame[1]);
SpaFraction rate_min_max[] = { { 0, 1 }, { INT32_MAX, 1 } };
@ -151,7 +151,7 @@ main (int argc, char *argv[])
SPA_PROP_ID_VIDEO_FRAMERATE,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_fraction (&b, 25, 1);
spa_pod_builder_raw (&b, rate_min_max, sizeof(rate_min_max), false);
spa_pod_builder_raw (&b, rate_min_max, sizeof(rate_min_max));
spa_pod_builder_pop (&b, &frame[1]);
spa_pod_builder_pop (&b, &frame[0]);

2
spa/tests/test-props2.c
View file

@ -65,7 +65,7 @@ main (int argc, char *argv[])
spa_pod_builder_push_prop (&b, &frame[1],
3, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_rectangle (&b, 320, 240);
spa_pod_builder_raw (&b, sizes, sizeof (sizes), false);
spa_pod_builder_raw (&b, sizes, sizeof (sizes));
spa_pod_builder_pop (&b, &frame[1]);
spa_pod_builder_push_prop (&b, &frame[1], 4, SPA_POD_PROP_RANGE_NONE | SPA_POD_PROP_FLAG_READABLE);