body.h

Go to the documentation of this file.

/* Simple Plugin API */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */
 
#ifndef SPA_POD_BODY_H
#define SPA_POD_BODY_H
 
#include <errno.h>
#include <sys/types.h>
 
#include <spa/pod/pod.h>
#include <spa/utils/atomic.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef SPA_API_POD_BODY
 #ifdef SPA_API_IMPL
  #define SPA_API_POD_BODY SPA_API_IMPL
 #else
  #define SPA_API_POD_BODY static inline
 #endif
#endif

 
struct spa_pod_frame {
        struct spa_pod pod;
        struct spa_pod_frame *parent;
        uint32_t offset;
        uint32_t flags;
};
 
SPA_API_POD_BODY uint32_t spa_pod_type_size(uint32_t type)
{
        switch (type) {
        case SPA_TYPE_None:
        case SPA_TYPE_Bytes:
        case SPA_TYPE_Struct:
        case SPA_TYPE_Pod:
                return 0;
        case SPA_TYPE_String:
                return 1;
        case SPA_TYPE_Bool:
        case SPA_TYPE_Int:
                return sizeof(int32_t);
        case SPA_TYPE_Id:
                return sizeof(uint32_t);
        case SPA_TYPE_Long:
                return sizeof(int64_t);
        case SPA_TYPE_Float:
                return sizeof(float);
        case SPA_TYPE_Double:
                return sizeof(double);
        case SPA_TYPE_Rectangle:
                return sizeof(struct spa_rectangle);
        case SPA_TYPE_Fraction:
                return sizeof(struct spa_fraction);
        case SPA_TYPE_Bitmap:
                return sizeof(uint8_t);
        case SPA_TYPE_Array:
                return sizeof(struct spa_pod_array_body);
        case SPA_TYPE_Object:
                return sizeof(struct spa_pod_object_body);
        case SPA_TYPE_Sequence:
                return sizeof(struct spa_pod_sequence_body);
        case SPA_TYPE_Pointer:
                return sizeof(struct spa_pod_pointer_body);
        case SPA_TYPE_Fd:
                return sizeof(int64_t);
        case SPA_TYPE_Choice:
                return sizeof(struct spa_pod_choice_body);
        }
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_choice_n_values(uint32_t choice_type, uint32_t *min, uint32_t *max)
{
        switch (choice_type) {
        case SPA_CHOICE_Enum:
                *min = 2;
                *max = UINT32_MAX;
                break;
        case SPA_CHOICE_Range:
                *min = *max = 3;
                break;
        case SPA_CHOICE_Step:
                *min = *max = 4;
                break;
        case SPA_CHOICE_None:
        case SPA_CHOICE_Flags:
                *min = *max = 1;
                break;
        default:
                /*
                 * This must always return at least 1, because callers
                 * assume that n_vals >= spa_pod_choice_n_values()
                 * mean that n_vals is at least 1.
                 */
                *min = 1;
                *max = UINT32_MAX;
                return 0;
        }
        return 1;
}
 
SPA_API_POD_BODY int spa_pod_body_from_data(void *data, size_t maxsize, off_t offset, size_t size,
                struct spa_pod *pod, const void **body)
{
        if (offset < 0)
                return -EINVAL;
        /* On 32-bit platforms, off_t is a signed 32-bit type (since it tracks pointer
         * width), and consequently can never exceed UINT32_MAX. Skip the upper-bound
         * check on 32-bit platforms to avoid a compiler warning. */
#if __SIZEOF_POINTER__ > 4
        if (offset > (int64_t)UINT32_MAX)
                return -EINVAL;
#endif
        if (size < sizeof(struct spa_pod) ||
            size > maxsize ||
            maxsize - size < (uint32_t)offset)
                return -EINVAL;
        memcpy(pod, SPA_PTROFF(data, offset, void), sizeof(struct spa_pod));
        if (!SPA_POD_IS_VALID(pod))
                return -EINVAL;
        if (pod->size > size - sizeof(struct spa_pod))
                return -EINVAL;
        *body = SPA_PTROFF(data, offset + sizeof(struct spa_pod), void);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_none(const struct spa_pod *pod)
{
        return SPA_POD_CHECK_TYPE(pod, SPA_TYPE_None);
}
 
SPA_API_POD_BODY int spa_pod_is_bool(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Bool, sizeof(int32_t));
}
 
#define SPA_POD_BODY_LOAD_ONCE(a, b) (*(a) = SPA_LOAD_ONCE((__typeof__(a))(b)))
#define SPA_POD_BODY_LOAD_FIELD_ONCE(a, b, field) ((a)->field = SPA_LOAD_ONCE(&((__typeof__(a))(b))->field))
 
SPA_API_POD_BODY int spa_pod_body_get_bool(const struct spa_pod *pod, const void *body, bool *value)
{
        if (!spa_pod_is_bool(pod))
                return -EINVAL;
        *value = !!__atomic_load_n((const int32_t *)body, __ATOMIC_RELAXED);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_id(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Id, sizeof(uint32_t));
}
 
SPA_API_POD_BODY int spa_pod_body_get_id(const struct spa_pod *pod, const void *body, uint32_t *value)
{
        if (!spa_pod_is_id(pod))
                return -EINVAL;
        SPA_POD_BODY_LOAD_ONCE(value, body);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_int(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Int, sizeof(int32_t));
}
 
SPA_API_POD_BODY int spa_pod_body_get_int(const struct spa_pod *pod, const void *body, int32_t *value)
{
        if (!spa_pod_is_int(pod))
                return -EINVAL;
        SPA_POD_BODY_LOAD_ONCE(value, body);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_long(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Long, sizeof(int64_t));
}
 
SPA_API_POD_BODY int spa_pod_body_get_long(const struct spa_pod *pod, const void *body, int64_t *value)
{
        if (!spa_pod_is_long(pod))
                return -EINVAL;
        /* TODO this is wrong per C standard, but if it breaks so does the Linux kernel. */
        SPA_BARRIER;
        memcpy(value, body, sizeof *value);
        SPA_BARRIER;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_float(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Float, sizeof(float));
}
 
SPA_API_POD_BODY int spa_pod_body_get_float(const struct spa_pod *pod, const void *body, float *value)
{
        if (!spa_pod_is_float(pod))
                return -EINVAL;
        SPA_BARRIER;
        memcpy(value, body, sizeof *value);
        SPA_BARRIER;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_double(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Double, sizeof(double));
}
 
SPA_API_POD_BODY int spa_pod_body_get_double(const struct spa_pod *pod, const void *body, double *value)
{
        if (!spa_pod_is_double(pod))
                return -EINVAL;
        SPA_BARRIER;
        memcpy(value, body, sizeof *value);
        SPA_BARRIER;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_string(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_String, 1);
}
 
SPA_API_POD_BODY int spa_pod_body_get_string(const struct spa_pod *pod,
                const void *body, const char **value)
{
        const char *s;
        if (!spa_pod_is_string(pod))
                return -EINVAL;
        s = (const char *)body;
        if (((const volatile char *)s)[pod->size-1] != '\0')
                return -EINVAL;
        *value = s;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_body_copy_string(const struct spa_pod *pod, const void *body,
                char *dest, size_t maxlen)
{
        const char *s;
        if (spa_pod_body_get_string(pod, body, &s) < 0 || maxlen < 1)
                return -EINVAL;
        SPA_BARRIER;
        strncpy(dest, s, maxlen-1);
        SPA_BARRIER;
        dest[maxlen-1]= '\0';
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_bytes(const struct spa_pod *pod)
{
        return SPA_POD_CHECK_TYPE(pod, SPA_TYPE_Bytes);
}
 
SPA_API_POD_BODY int spa_pod_body_get_bytes(const struct spa_pod *pod, const void *body,
                const void **value, uint32_t *len)
{
        if (!spa_pod_is_bytes(pod))
                return -EINVAL;
        *value = (const void *)body;
        *len = pod->size;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_pointer(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Pointer, sizeof(struct spa_pod_pointer_body));
}
 
SPA_API_POD_BODY int spa_pod_body_get_pointer(const struct spa_pod *pod, const void *body,
                uint32_t *type, const void **value)
{
        struct spa_pod_pointer_body b;
        if (!spa_pod_is_pointer(pod))
                return -EINVAL;
        SPA_POD_BODY_LOAD_FIELD_ONCE(&b, body, type);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&b, body, value);
        *type = b.type;
        *value = b.value;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_fd(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Fd, sizeof(int64_t));
}
 
SPA_API_POD_BODY int spa_pod_body_get_fd(const struct spa_pod *pod, const void *body,
                int64_t *value)
{
        if (!spa_pod_is_fd(pod))
                return -EINVAL;
        SPA_BARRIER;
        memcpy(value, body, sizeof *value);
        SPA_BARRIER;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_rectangle(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Rectangle, sizeof(struct spa_rectangle));
}
 
SPA_API_POD_BODY int spa_pod_body_get_rectangle(const struct spa_pod *pod, const void *body,
                struct spa_rectangle *value)
{
        if (!spa_pod_is_rectangle(pod))
                return -EINVAL;
        SPA_POD_BODY_LOAD_FIELD_ONCE(value, body, width);
        SPA_POD_BODY_LOAD_FIELD_ONCE(value, body, height);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_fraction(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Fraction, sizeof(struct spa_fraction));
}
SPA_API_POD_BODY int spa_pod_body_get_fraction(const struct spa_pod *pod, const void *body,
                struct spa_fraction *value)
{
        if (!spa_pod_is_fraction(pod))
                return -EINVAL;
        SPA_POD_BODY_LOAD_FIELD_ONCE(value, body, num);
        SPA_POD_BODY_LOAD_FIELD_ONCE(value, body, denom);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_bitmap(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Bitmap, sizeof(uint8_t));
}
SPA_API_POD_BODY int spa_pod_body_get_bitmap(const struct spa_pod *pod, const void *body,
                const uint8_t **value)
{
        if (!spa_pod_is_bitmap(pod))
                return -EINVAL;
        *value = (const uint8_t *)body;
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_array(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Array, sizeof(struct spa_pod_array_body));
}
SPA_API_POD_BODY int spa_pod_body_get_array(const struct spa_pod *pod, const void *body,
                struct spa_pod_array *arr, const void **arr_body)
{
        if (!spa_pod_is_array(pod))
                return -EINVAL;
        arr->pod = *pod;
        SPA_POD_BODY_LOAD_FIELD_ONCE(&arr->body.child, body, type);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&arr->body.child, body, size);
        *arr_body = SPA_PTROFF(body, sizeof(struct spa_pod_array_body), void);
        return 0;
}
SPA_API_POD_BODY const void *spa_pod_array_body_get_values(const struct spa_pod_array *arr,
                const void *body, uint32_t *n_values, uint32_t *val_size, uint32_t *val_type)
{
        uint32_t child_size = arr->body.child.size;
        *n_values = child_size ? (arr->pod.size - sizeof(arr->body)) / child_size : 0;
        *val_size = child_size;
        *val_type = arr->body.child.type;
        if (*val_size < spa_pod_type_size(*val_type))
                *n_values = 0;
        return body;
}
 
SPA_API_POD_BODY const void *spa_pod_body_get_array_values(const struct spa_pod *pod,
                const void *body, uint32_t *n_values, uint32_t *val_size, uint32_t *val_type)
{
        struct spa_pod_array arr;
        if (spa_pod_body_get_array(pod, body, &arr, &body) < 0)
                return NULL;
        return spa_pod_array_body_get_values(&arr, body, n_values, val_size, val_type);
}
 
SPA_API_POD_BODY int spa_pod_is_choice(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Choice, sizeof(struct spa_pod_choice_body));
}
SPA_API_POD_BODY int spa_pod_body_get_choice(const struct spa_pod *pod, const void *body,
                struct spa_pod_choice *choice, const void **choice_body)
{
        if (!spa_pod_is_choice(pod))
                return -EINVAL;
        choice->pod = *pod;
        SPA_POD_BODY_LOAD_FIELD_ONCE(&choice->body, body, type);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&choice->body, body, flags);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&choice->body, body, child.size);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&choice->body, body, child.type);
        *choice_body = SPA_PTROFF(body, sizeof(struct spa_pod_choice_body), void);
        return 0;
}
SPA_API_POD_BODY const void *spa_pod_choice_body_get_values(const struct spa_pod_choice *pod,
                const void *body, uint32_t *n_values, uint32_t *choice,
                uint32_t *val_size, uint32_t *val_type)
{
        uint32_t child_size = pod->body.child.size, min, max;
        *val_size = child_size;
        *val_type = pod->body.child.type;
        *n_values = child_size ? (pod->pod.size - sizeof(pod->body)) / child_size : 0;
        *choice = pod->body.type;
        spa_pod_choice_n_values(*choice, &min, &max);
        if (*n_values < min || *val_size < spa_pod_type_size(*val_type))
                *n_values = 0;
        else if (*n_values > max)
                *n_values = max;
        return body;
}
 
SPA_API_POD_BODY int spa_pod_is_struct(const struct spa_pod *pod)
{
        return SPA_POD_CHECK_TYPE(pod, SPA_TYPE_Struct);
}
 
SPA_API_POD_BODY int spa_pod_is_object(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Object, sizeof(struct spa_pod_object_body));
}
SPA_API_POD_BODY int spa_pod_body_get_object(const struct spa_pod *pod, const void *body,
                struct spa_pod_object *object, const void **object_body)
{
        if (!spa_pod_is_object(pod))
                return -EINVAL;
        object->pod = *pod;
        SPA_POD_BODY_LOAD_FIELD_ONCE(&object->body, body, type);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&object->body, body, id);
        *object_body = SPA_PTROFF(body, sizeof(struct spa_pod_object_body), void);
        return 0;
}
 
SPA_API_POD_BODY int spa_pod_is_sequence(const struct spa_pod *pod)
{
        return SPA_POD_CHECK(pod, SPA_TYPE_Sequence, sizeof(struct spa_pod_sequence_body));
}
SPA_API_POD_BODY int spa_pod_body_get_sequence(const struct spa_pod *pod, const void *body,
                struct spa_pod_sequence *seq, const void **seq_body)
{
        if (!spa_pod_is_sequence(pod))
                return -EINVAL;
        seq->pod = *pod;
        SPA_POD_BODY_LOAD_FIELD_ONCE(&seq->body, body, unit);
        SPA_POD_BODY_LOAD_FIELD_ONCE(&seq->body, body, pad);
        *seq_body = SPA_PTROFF(body, sizeof(struct spa_pod_sequence_body), void);
        return 0;
}

 
#ifdef __cplusplus
}  /* extern "C" */
#endif
 
#endif /* SPA_POD_BODY_H */