/* Simple Plugin API */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */

#ifndef SPA_BUFFER_H
#define SPA_BUFFER_H

#ifdef __cplusplus
extern "C" {
#endif

#include <spa/utils/defs.h>
#include <spa/buffer/meta.h>

#ifndef SPA_API_BUFFER
 #ifdef SPA_API_IMPL
  #define SPA_API_BUFFER SPA_API_IMPL
 #else
  #define SPA_API_BUFFER static inline
 #endif
#endif

/** \defgroup spa_buffer Buffers
 *
 * Buffers describe the data and metadata that is exchanged between
 * ports of a node.
 */

/**
 * \addtogroup spa_buffer
 * \{
 */

enum spa_data_type {
    SPA_DATA_Invalid,
    SPA_DATA_MemPtr,        /**< pointer to memory, the data field in
                      *  struct spa_data is set. */
    SPA_DATA_MemFd,            /**< memfd, mmap to get to memory. */
    SPA_DATA_DmaBuf,        /**< fd to dmabuf memory. This might not be readily
                      *  mappable (unless the MAPPABLE flag is set) and should
                      *  normally be handled with DMABUF apis. */
    SPA_DATA_MemId,            /**< memory is identified with an id. The actual memory
                      *  can be obtained in some other way and can be identified
                      *  with this id. */
    SPA_DATA_SyncObj,        /**< a syncobj, usually requires a spa_meta_sync_timeline metadata
                      *  with timeline points. */

    _SPA_DATA_LAST,            /**< not part of ABI */
};

/** Chunk of memory, can change for each buffer */
struct spa_chunk {
    uint32_t offset;        /**< offset of valid data. Should be taken
                      *  modulo the data maxsize to get the offset
                      *  in the data memory. */
    uint32_t size;            /**< size of valid data. Should be clamped to
                      *  maxsize. */
    int32_t stride;            /**< stride of valid data */
#define SPA_CHUNK_FLAG_NONE        0
#define SPA_CHUNK_FLAG_CORRUPTED    (1u<<0)    /**< chunk data is corrupted in some way */
#define SPA_CHUNK_FLAG_EMPTY        (1u<<1)    /**< chunk data is empty with media specific
                          *  neutral data such as silence or black. This
                          *  could be used to optimize processing. */
    int32_t flags;            /**< chunk flags */
};

/** Data for a buffer this stays constant for a buffer */
struct spa_data {
    uint32_t type;            /**< memory type, one of enum spa_data_type, when
                      *  allocating memory, the type contains a bitmask
                      *  of allowed types. SPA_ID_INVALID is a special
                      *  value for the allocator to indicate that the
                      *  other side did not explicitly specify any
                      *  supported data types. It should probably use
                      *  a memory type that does not require special
                      *  handling in addition to simple mmap/munmap. */
#define SPA_DATA_FLAG_NONE     0
#define SPA_DATA_FLAG_READABLE    (1u<<0)    /**< data is readable */
#define SPA_DATA_FLAG_WRITABLE    (1u<<1)    /**< data is writable */
#define SPA_DATA_FLAG_DYNAMIC    (1u<<2)    /**< data pointer can be changed */
#define SPA_DATA_FLAG_READWRITE    (SPA_DATA_FLAG_READABLE|SPA_DATA_FLAG_WRITABLE)
#define SPA_DATA_FLAG_MAPPABLE    (1u<<3)    /**< data is mappable with simple mmap/munmap. Some memory
                      *  types are not simply mappable (DmaBuf) unless explicitly
                      *  specified with this flag. */
    uint32_t flags;            /**< data flags */
    int64_t fd;            /**< optional fd for data */
    uint32_t mapoffset;        /**< offset to map fd at, this is page aligned */
    uint32_t maxsize;        /**< max size of data */
    void *data;            /**< optional data pointer */
    struct spa_chunk *chunk;    /**< valid chunk of memory */
};

/** A Buffer */
struct spa_buffer {
    uint32_t n_metas;        /**< number of metadata */
    uint32_t n_datas;        /**< number of data members */
    struct spa_meta *metas;        /**< array of metadata */
    struct spa_data *datas;        /**< array of data members */
};

/** Find metadata in a buffer */
SPA_API_BUFFER struct spa_meta *spa_buffer_find_meta(const struct spa_buffer *b, uint32_t type)
{
    uint32_t i;

    for (i = 0; i < b->n_metas; i++)
        if (b->metas[i].type == type)
            return &b->metas[i];

    return NULL;
}

SPA_API_BUFFER void *spa_buffer_find_meta_data(const struct spa_buffer *b, uint32_t type, size_t size)
{
    struct spa_meta *m;
    if ((m = spa_buffer_find_meta(b, type)) && m->size >= size)
        return m->data;
    return NULL;
}

/**
 * \}
 */

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

#endif /* SPA_BUFFER_H */