atom-util.h

Go to the documentation of this file.

/*
  Copyright 2008-2015 David Robillard <http://drobilla.net>
 
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted, provided that the above
  copyright notice and this permission notice appear in all copies.
 
  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/


 
#ifndef LV2_ATOM_UTIL_H
#define LV2_ATOM_UTIL_H
 
#include <stdarg.h>
#include <stdint.h>
#include <string.h>
 
#include "atom.h"
 
#ifdef __cplusplus
extern "C" {
#else
#    include <stdbool.h>
#endif

static inline uint32_t
lv2_atom_pad_size(uint32_t size)
{
        return (size + 7U) & (~7U);
}

static inline uint32_t
lv2_atom_total_size(const LV2_Atom* atom)
{
        return (uint32_t)sizeof(LV2_Atom) + atom->size;
}

static inline bool
lv2_atom_is_null(const LV2_Atom* atom)
{
        return !atom || (atom->type == 0 && atom->size == 0);
}

static inline bool
lv2_atom_equals(const LV2_Atom* a, const LV2_Atom* b)
{
        return (a == b) || ((a->type == b->type) &&
                            (a->size == b->size) &&
                            !memcmp(a + 1, b + 1, a->size));
}


static inline const LV2_Atom_Event*
lv2_atom_sequence_begin(const LV2_Atom_Sequence_Body* body)
{
        return (const LV2_Atom_Event*)(body + 1);
}

static inline const LV2_Atom_Event*
lv2_atom_sequence_end(const LV2_Atom_Sequence_Body* body, uint32_t size)
{
        return (const LV2_Atom_Event*)((const uint8_t*)body + lv2_atom_pad_size(size));
}

static inline LV2_Atom_Event*
lv2_atom_sequence_end2(LV2_Atom_Sequence_Body* body, uint32_t size)
{
        return (LV2_Atom_Event*)((uint8_t*)body + lv2_atom_pad_size(size));
}

static inline bool
lv2_atom_sequence_is_end(const LV2_Atom_Sequence_Body* body,
                         uint32_t                      size,
                         const LV2_Atom_Event*         i)
{
        return (const uint8_t*)i >= ((const uint8_t*)body + size);
}

static inline const LV2_Atom_Event*
lv2_atom_sequence_next(const LV2_Atom_Event* i)
{
        return (const LV2_Atom_Event*)((const uint8_t*)i
                                       + sizeof(LV2_Atom_Event)
                                       + lv2_atom_pad_size(i->body.size));
}

#define LV2_ATOM_SEQUENCE_FOREACH(seq, iter) \
        for (const LV2_Atom_Event* iter = lv2_atom_sequence_begin(&(seq)->body); \
             !lv2_atom_sequence_is_end(&(seq)->body, (seq)->atom.size, (iter)); \
             iter = lv2_atom_sequence_next(iter))

#define LV2_ATOM_SEQUENCE_BODY_FOREACH(body, size, iter) \
        for (const LV2_Atom_Event* iter = lv2_atom_sequence_begin(body); \
             !lv2_atom_sequence_is_end(body, size, (iter)); \
             iter = lv2_atom_sequence_next(iter))


static inline void
lv2_atom_sequence_clear(LV2_Atom_Sequence* seq)
{
        seq->atom.size = sizeof(LV2_Atom_Sequence_Body);
}

static inline LV2_Atom_Event*
lv2_atom_sequence_append_event(LV2_Atom_Sequence*    seq,
                               uint32_t              capacity,
                               const LV2_Atom_Event* event)
{
        const uint32_t total_size = (uint32_t)sizeof(*event) + event->body.size;
        if (capacity - seq->atom.size < total_size) {
                return NULL;
        }
 
        LV2_Atom_Event* e = lv2_atom_sequence_end2(&seq->body, seq->atom.size);
        memcpy(e, event, total_size);
 
        seq->atom.size += lv2_atom_pad_size(total_size);
 
        return e;
}


static inline const LV2_Atom*
lv2_atom_tuple_begin(const LV2_Atom_Tuple* tup)
{
        return (const LV2_Atom*)(LV2_ATOM_BODY_CONST(tup));
}

static inline bool
lv2_atom_tuple_is_end(const void* body, uint32_t size, const LV2_Atom* i)
{
        return (const uint8_t*)i >= ((const uint8_t*)body + size);
}

static inline const LV2_Atom*
lv2_atom_tuple_next(const LV2_Atom* i)
{
        return (const LV2_Atom*)(
                (const uint8_t*)i + sizeof(LV2_Atom) + lv2_atom_pad_size(i->size));
}

#define LV2_ATOM_TUPLE_FOREACH(tuple, iter) \
        for (const LV2_Atom* iter = lv2_atom_tuple_begin(tuple); \
             !lv2_atom_tuple_is_end(LV2_ATOM_BODY_CONST(tuple), (tuple)->atom.size, (iter)); \
             iter = lv2_atom_tuple_next(iter))

#define LV2_ATOM_TUPLE_BODY_FOREACH(body, size, iter) \
        for (const LV2_Atom* iter = (const LV2_Atom*)body; \
             !lv2_atom_tuple_is_end(body, size, (iter)); \
             iter = lv2_atom_tuple_next(iter))


static inline const LV2_Atom_Property_Body*
lv2_atom_object_begin(const LV2_Atom_Object_Body* body)
{
        return (const LV2_Atom_Property_Body*)(body + 1);
}

static inline bool
lv2_atom_object_is_end(const LV2_Atom_Object_Body*   body,
                       uint32_t                      size,
                       const LV2_Atom_Property_Body* i)
{
        return (const uint8_t*)i >= ((const uint8_t*)body + size);
}

static inline const LV2_Atom_Property_Body*
lv2_atom_object_next(const LV2_Atom_Property_Body* i)
{
        const LV2_Atom* const value = (const LV2_Atom*)(
                (const uint8_t*)i + 2 * sizeof(uint32_t));
        return (const LV2_Atom_Property_Body*)(
                (const uint8_t*)i + lv2_atom_pad_size(
                        (uint32_t)sizeof(LV2_Atom_Property_Body) + value->size));
}

#define LV2_ATOM_OBJECT_FOREACH(obj, iter) \
        for (const LV2_Atom_Property_Body* iter = lv2_atom_object_begin(&(obj)->body); \
             !lv2_atom_object_is_end(&(obj)->body, (obj)->atom.size, (iter)); \
             iter = lv2_atom_object_next(iter))

#define LV2_ATOM_OBJECT_BODY_FOREACH(body, size, iter) \
        for (const LV2_Atom_Property_Body* iter = lv2_atom_object_begin(body); \
             !lv2_atom_object_is_end(body, size, (iter)); \
             iter = lv2_atom_object_next(iter))


typedef struct {
        uint32_t         key;    
        const LV2_Atom** value;  
} LV2_Atom_Object_Query;
 
static const LV2_Atom_Object_Query LV2_ATOM_OBJECT_QUERY_END = { 0, NULL };

static inline int
lv2_atom_object_query(const LV2_Atom_Object* object,
                      LV2_Atom_Object_Query* query)
{
        int matches   = 0;
        int n_queries = 0;
 
        /* Count number of query keys so we can short-circuit when done */
        for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
                ++n_queries;
        }
 
        LV2_ATOM_OBJECT_FOREACH(object, prop) {
                for (LV2_Atom_Object_Query* q = query; q->key; ++q) {
                        if (q->key == prop->key && !*q->value) {
                                *q->value = &prop->value;
                                if (++matches == n_queries) {
                                        return matches;
                                }
                                break;
                        }
                }
        }
        return matches;
}

static inline int
lv2_atom_object_body_get(uint32_t size, const LV2_Atom_Object_Body* body, ...)
{
        int matches   = 0;
        int n_queries = 0;
 
        /* Count number of keys so we can short-circuit when done */
        va_list args;
        va_start(args, body);
        for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
                if (!va_arg(args, const LV2_Atom**)) {
                        va_end(args);
                        return -1;
                }
        }
        va_end(args);
 
        LV2_ATOM_OBJECT_BODY_FOREACH(body, size, prop) {
                va_start(args, body);
                for (int i = 0; i < n_queries; ++i) {
                        uint32_t         qkey = va_arg(args, uint32_t);
                        const LV2_Atom** qval = va_arg(args, const LV2_Atom**);
                        if (qkey == prop->key && !*qval) {
                                *qval = &prop->value;
                                if (++matches == n_queries) {
                                        va_end(args);
                                        return matches;
                                }
                                break;
                        }
                }
                va_end(args);
        }
        return matches;
}

static inline int
lv2_atom_object_get(const LV2_Atom_Object* object, ...)
{
        int matches   = 0;
        int n_queries = 0;
 
        /* Count number of keys so we can short-circuit when done */
        va_list args;
        va_start(args, object);
        for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
                if (!va_arg(args, const LV2_Atom**)) {
                        return -1;
                }
        }
        va_end(args);
 
        LV2_ATOM_OBJECT_FOREACH(object, prop) {
                va_start(args, object);
                for (int i = 0; i < n_queries; ++i) {
                        uint32_t         qkey = va_arg(args, uint32_t);
                        const LV2_Atom** qval = va_arg(args, const LV2_Atom**);
                        if (qkey == prop->key && !*qval) {
                                *qval = &prop->value;
                                if (++matches == n_queries) {
                                        return matches;
                                }
                                break;
                        }
                }
                va_end(args);
        }
        return matches;
}

static inline int
lv2_atom_object_get_typed(const LV2_Atom_Object* object, ...)
{
        int matches   = 0;
        int n_queries = 0;
 
        /* Count number of keys so we can short-circuit when done */
        va_list args;
        va_start(args, object);
        for (n_queries = 0; va_arg(args, uint32_t); ++n_queries) {
                if (!va_arg(args, const LV2_Atom**) ||
                    !va_arg(args, uint32_t)) {
                        return -1;
                }
        }
        va_end(args);
 
        LV2_ATOM_OBJECT_FOREACH(object, prop) {
                va_start(args, object);
                for (int i = 0; i < n_queries; ++i) {
                        const uint32_t   qkey  = va_arg(args, uint32_t);
                        const LV2_Atom** qval  = va_arg(args, const LV2_Atom**);
                        const uint32_t   qtype = va_arg(args, uint32_t);
                        if (!*qval && qkey == prop->key && qtype == prop->value.type) {
                                *qval = &prop->value;
                                if (++matches == n_queries) {
                                        return matches;
                                }
                                break;
                        }
                }
                va_end(args);
        }
        return matches;
}

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