spa/include/spa/node/node.h

Go to the documentation of this file.

/* Simple Plugin API */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */
 
#ifndef SPA_NODE_H
#define SPA_NODE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <errno.h>
#include <spa/utils/defs.h>
#include <spa/utils/type.h>
#include <spa/utils/hook.h>
#include <spa/buffer/buffer.h>
#include <spa/node/event.h>
#include <spa/node/command.h>
 
 
#define SPA_TYPE_INTERFACE_Node         SPA_TYPE_INFO_INTERFACE_BASE "Node"
 
#define SPA_VERSION_NODE                0
struct spa_node { struct spa_interface iface; };
 
struct spa_node_info {
        uint32_t max_input_ports;
        uint32_t max_output_ports;
#define SPA_NODE_CHANGE_MASK_FLAGS              (1u<<0)
#define SPA_NODE_CHANGE_MASK_PROPS              (1u<<1)
#define SPA_NODE_CHANGE_MASK_PARAMS             (1u<<2)
        uint64_t change_mask;
 
#define SPA_NODE_FLAG_RT                        (1u<<0) 
#define SPA_NODE_FLAG_IN_DYNAMIC_PORTS          (1u<<1) 
#define SPA_NODE_FLAG_OUT_DYNAMIC_PORTS         (1u<<2) 
#define SPA_NODE_FLAG_IN_PORT_CONFIG            (1u<<3) 
#define SPA_NODE_FLAG_OUT_PORT_CONFIG           (1u<<4) 
#define SPA_NODE_FLAG_NEED_CONFIGURE            (1u<<5) 
#define SPA_NODE_FLAG_ASYNC                     (1u<<6) 
        uint64_t flags;
        struct spa_dict *props;                 
        struct spa_param_info *params;          
        uint32_t n_params;                      
};
 
#define SPA_NODE_INFO_INIT()    ((struct spa_node_info) { 0, })
 
struct spa_port_info {
#define SPA_PORT_CHANGE_MASK_FLAGS              (1u<<0)
#define SPA_PORT_CHANGE_MASK_RATE               (1u<<1)
#define SPA_PORT_CHANGE_MASK_PROPS              (1u<<2)
#define SPA_PORT_CHANGE_MASK_PARAMS             (1u<<3)
        uint64_t change_mask;
 
#define SPA_PORT_FLAG_REMOVABLE                 (1u<<0) 
#define SPA_PORT_FLAG_OPTIONAL                  (1u<<1) 
#define SPA_PORT_FLAG_CAN_ALLOC_BUFFERS         (1u<<2) 
#define SPA_PORT_FLAG_IN_PLACE                  (1u<<3) 
#define SPA_PORT_FLAG_NO_REF                    (1u<<4) 
#define SPA_PORT_FLAG_LIVE                      (1u<<5) 
#define SPA_PORT_FLAG_PHYSICAL                  (1u<<6) 
#define SPA_PORT_FLAG_TERMINAL                  (1u<<7) 
#define SPA_PORT_FLAG_DYNAMIC_DATA              (1u<<8) 
        uint64_t flags;                         
        struct spa_fraction rate;               
        const struct spa_dict *props;           
        struct spa_param_info *params;          
        uint32_t n_params;                      
};
 
#define SPA_PORT_INFO_INIT()    ((struct spa_port_info) { 0, })
 
#define SPA_RESULT_TYPE_NODE_ERROR      1
#define SPA_RESULT_TYPE_NODE_PARAMS     2
 
struct spa_result_node_error {
        const char *message;
};
 
struct spa_result_node_params {
        uint32_t id;            
        uint32_t index;         
        uint32_t next;          
        struct spa_pod *param;  
};
 
#define SPA_NODE_EVENT_INFO             0
#define SPA_NODE_EVENT_PORT_INFO        1
#define SPA_NODE_EVENT_RESULT           2
#define SPA_NODE_EVENT_EVENT            3
#define SPA_NODE_EVENT_NUM              4
 
struct spa_node_events {
#define SPA_VERSION_NODE_EVENTS 0
        uint32_t version;       
        void (*info) (void *data, const struct spa_node_info *info);
 
        void (*port_info) (void *data,
                        enum spa_direction direction, uint32_t port,
                        const struct spa_port_info *info);
 
        void (*result) (void *data, int seq, int res,
                        uint32_t type, const void *result);
 
        void (*event) (void *data, const struct spa_event *event);
};
 
#define SPA_NODE_CALLBACK_READY         0
#define SPA_NODE_CALLBACK_REUSE_BUFFER  1
#define SPA_NODE_CALLBACK_XRUN          2
#define SPA_NODE_CALLBACK_NUM           3
 
struct spa_node_callbacks {
#define SPA_VERSION_NODE_CALLBACKS      0
        uint32_t version;
        int (*ready) (void *data, int state);
 
        int (*reuse_buffer) (void *data,
                             uint32_t port_id,
                             uint32_t buffer_id);
 
        int (*xrun) (void *data, uint64_t trigger, uint64_t delay,
                        struct spa_pod *info);
};
 
 
#define SPA_NODE_PARAM_FLAG_TEST_ONLY   (1 << 0)        
#define SPA_NODE_PARAM_FLAG_FIXATE      (1 << 1)        
#define SPA_NODE_PARAM_FLAG_NEAREST     (1 << 2)        
#define SPA_NODE_BUFFERS_FLAG_ALLOC     (1 << 0)        
#define SPA_NODE_METHOD_ADD_LISTENER            0
#define SPA_NODE_METHOD_SET_CALLBACKS           1
#define SPA_NODE_METHOD_SYNC                    2
#define SPA_NODE_METHOD_ENUM_PARAMS             3
#define SPA_NODE_METHOD_SET_PARAM               4
#define SPA_NODE_METHOD_SET_IO                  5
#define SPA_NODE_METHOD_SEND_COMMAND            6
#define SPA_NODE_METHOD_ADD_PORT                7
#define SPA_NODE_METHOD_REMOVE_PORT             8
#define SPA_NODE_METHOD_PORT_ENUM_PARAMS        9
#define SPA_NODE_METHOD_PORT_SET_PARAM          10
#define SPA_NODE_METHOD_PORT_USE_BUFFERS        11
#define SPA_NODE_METHOD_PORT_SET_IO             12
#define SPA_NODE_METHOD_PORT_REUSE_BUFFER       13
#define SPA_NODE_METHOD_PROCESS                 14
#define SPA_NODE_METHOD_NUM                     15
 
struct spa_node_methods {
        /* the version of the node methods. This can be used to expand this
         * structure in the future */
#define SPA_VERSION_NODE_METHODS        0
        uint32_t version;
 
        int (*add_listener) (void *object,
                        struct spa_hook *listener,
                        const struct spa_node_events *events,
                        void *data);
        int (*set_callbacks) (void *object,
                              const struct spa_node_callbacks *callbacks,
                              void *data);
        int (*sync) (void *object, int seq);
 
        int (*enum_params) (void *object, int seq,
                            uint32_t id, uint32_t start, uint32_t max,
                            const struct spa_pod *filter);
 
        int (*set_param) (void *object,
                          uint32_t id, uint32_t flags,
                          const struct spa_pod *param);
 
        int (*set_io) (void *object,
                       uint32_t id, void *data, size_t size);
 
        int (*send_command) (void *object, const struct spa_command *command);
 
        int (*add_port) (void *object,
                        enum spa_direction direction, uint32_t port_id,
                        const struct spa_dict *props);
 
        int (*remove_port) (void *object,
                        enum spa_direction direction, uint32_t port_id);
 
        int (*port_enum_params) (void *object, int seq,
                                 enum spa_direction direction, uint32_t port_id,
                                 uint32_t id, uint32_t start, uint32_t max,
                                 const struct spa_pod *filter);
        int (*port_set_param) (void *object,
                               enum spa_direction direction,
                               uint32_t port_id,
                               uint32_t id, uint32_t flags,
                               const struct spa_pod *param);
 
        int (*port_use_buffers) (void *object,
                                 enum spa_direction direction,
                                 uint32_t port_id,
                                 uint32_t flags,
                                 struct spa_buffer **buffers,
                                 uint32_t n_buffers);
 
        int (*port_set_io) (void *object,
                            enum spa_direction direction,
                            uint32_t port_id,
                            uint32_t id,
                            void *data, size_t size);
 
        int (*port_reuse_buffer) (void *object, uint32_t port_id, uint32_t buffer_id);
 
        int (*process) (void *object);
};
 
#define spa_node_method(o,method,version,...)                           \
({                                                                      \
        int _res = -ENOTSUP;                                            \
        struct spa_node *_n = o;                                        \
        spa_interface_call_res(&_n->iface,                              \
                        struct spa_node_methods, _res,                  \
                        method, version, ##__VA_ARGS__);                \
        _res;                                                           \
})
 
#define spa_node_method_fast(o,method,version,...)                      \
({                                                                      \
        int _res;                                                       \
        struct spa_node *_n = o;                                        \
        spa_interface_call_fast_res(&_n->iface,                         \
                        struct spa_node_methods, _res,                  \
                        method, version, ##__VA_ARGS__);                \
        _res;                                                           \
})
 
#define spa_node_add_listener(n,...)            spa_node_method(n, add_listener, 0, __VA_ARGS__)
#define spa_node_set_callbacks(n,...)           spa_node_method(n, set_callbacks, 0, __VA_ARGS__)
#define spa_node_sync(n,...)                    spa_node_method(n, sync, 0, __VA_ARGS__)
#define spa_node_enum_params(n,...)             spa_node_method(n, enum_params, 0, __VA_ARGS__)
#define spa_node_set_param(n,...)               spa_node_method(n, set_param, 0, __VA_ARGS__)
#define spa_node_set_io(n,...)                  spa_node_method(n, set_io, 0, __VA_ARGS__)
#define spa_node_send_command(n,...)            spa_node_method(n, send_command, 0, __VA_ARGS__)
#define spa_node_add_port(n,...)                spa_node_method(n, add_port, 0, __VA_ARGS__)
#define spa_node_remove_port(n,...)             spa_node_method(n, remove_port, 0, __VA_ARGS__)
#define spa_node_port_enum_params(n,...)        spa_node_method(n, port_enum_params, 0, __VA_ARGS__)
#define spa_node_port_set_param(n,...)          spa_node_method(n, port_set_param, 0, __VA_ARGS__)
#define spa_node_port_use_buffers(n,...)        spa_node_method(n, port_use_buffers, 0, __VA_ARGS__)
#define spa_node_port_set_io(n,...)             spa_node_method(n, port_set_io, 0, __VA_ARGS__)
 
#define spa_node_port_reuse_buffer(n,...)       spa_node_method(n, port_reuse_buffer, 0, __VA_ARGS__)
#define spa_node_port_reuse_buffer_fast(n,...)  spa_node_method_fast(n, port_reuse_buffer, 0, __VA_ARGS__)
#define spa_node_process(n)                     spa_node_method(n, process, 0)
#define spa_node_process_fast(n)                spa_node_method_fast(n, process, 0)
 
#ifdef __cplusplus
}  /* extern "C" */
#endif
 
#endif /* SPA_NODE_H */