core.h

Go to the documentation of this file.

/* PipeWire */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */
 
#ifndef PIPEWIRE_CORE_H
#define PIPEWIRE_CORE_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdarg.h>
#include <errno.h>
 
#include <spa/utils/hook.h>
 
#define PW_TYPE_INTERFACE_Core          PW_TYPE_INFO_INTERFACE_BASE "Core"
#define PW_TYPE_INTERFACE_Registry      PW_TYPE_INFO_INTERFACE_BASE "Registry"
 
#define PW_CORE_PERM_MASK               PW_PERM_R|PW_PERM_X|PW_PERM_M
 
#define PW_VERSION_CORE         4
struct pw_core;
#define PW_VERSION_REGISTRY     3
struct pw_registry;
 
#define PW_DEFAULT_REMOTE       "pipewire-0"
 
#define PW_ID_CORE              0
 
/* invalid ID that matches any object when used for permissions */
#define PW_ID_ANY               (uint32_t)(0xffffffff)
 
struct pw_core_info {
        uint32_t id;                    
        uint32_t cookie;                
        const char *user_name;          
        const char *host_name;          
        const char *version;            
        const char *name;               
#define PW_CORE_CHANGE_MASK_PROPS      (1 << 0)
#define PW_CORE_CHANGE_MASK_ALL        ((1 << 1)-1)
        uint64_t change_mask;           
        struct spa_dict *props;         
};
 
#include <pipewire/context.h>
#include <pipewire/properties.h>
#include <pipewire/proxy.h>
 
struct pw_core_info *
pw_core_info_update(struct pw_core_info *info,
                const struct pw_core_info *update);
struct pw_core_info *
pw_core_info_merge(struct pw_core_info *info,
                const struct pw_core_info *update, bool reset);
void pw_core_info_free(struct pw_core_info *info);
 
#define PW_CORE_EVENT_INFO              0
#define PW_CORE_EVENT_DONE              1
#define PW_CORE_EVENT_PING              2
#define PW_CORE_EVENT_ERROR             3
#define PW_CORE_EVENT_REMOVE_ID         4
#define PW_CORE_EVENT_BOUND_ID          5
#define PW_CORE_EVENT_ADD_MEM           6
#define PW_CORE_EVENT_REMOVE_MEM        7
#define PW_CORE_EVENT_BOUND_PROPS       8
#define PW_CORE_EVENT_NUM               9
 
struct pw_core_events {
#define PW_VERSION_CORE_EVENTS  1
        uint32_t version;
 
        void (*info) (void *data, const struct pw_core_info *info);
        void (*done) (void *data, uint32_t id, int seq);
 
        void (*ping) (void *data, uint32_t id, int seq);
 
        void (*error) (void *data, uint32_t id, int seq, int res, const char *message);
        void (*remove_id) (void *data, uint32_t id);
 
        void (*bound_id) (void *data, uint32_t id, uint32_t global_id);
 
        void (*add_mem) (void *data, uint32_t id, uint32_t type, int fd, uint32_t flags);
 
        void (*remove_mem) (void *data, uint32_t id);
 
        void (*bound_props) (void *data, uint32_t id, uint32_t global_id, const struct spa_dict *props);
};
 
#define PW_CORE_METHOD_ADD_LISTENER     0
#define PW_CORE_METHOD_HELLO            1
#define PW_CORE_METHOD_SYNC             2
#define PW_CORE_METHOD_PONG             3
#define PW_CORE_METHOD_ERROR            4
#define PW_CORE_METHOD_GET_REGISTRY     5
#define PW_CORE_METHOD_CREATE_OBJECT    6
#define PW_CORE_METHOD_DESTROY          7
#define PW_CORE_METHOD_NUM              8
 
struct pw_core_methods {
#define PW_VERSION_CORE_METHODS 0
        uint32_t version;
 
        int (*add_listener) (void *object,
                        struct spa_hook *listener,
                        const struct pw_core_events *events,
                        void *data);
        int (*hello) (void *object, uint32_t version);
        int (*sync) (void *object, uint32_t id, int seq);
        int (*pong) (void *object, uint32_t id, int seq);
        int (*error) (void *object, uint32_t id, int seq, int res, const char *message);
        struct pw_registry * (*get_registry) (void *object, uint32_t version,
                        size_t user_data_size);
 
        void * (*create_object) (void *object,
                               const char *factory_name,
                               const char *type,
                               uint32_t version,
                               const struct spa_dict *props,
                               size_t user_data_size);
        int (*destroy) (void *object, void *proxy);
};
 
#define pw_core_method(o,method,version,...)                    \
({                                                                      \
        int _res = -ENOTSUP;                                            \
        spa_interface_call_res((struct spa_interface*)o,                \
                        struct pw_core_methods, _res,           \
                        method, version, ##__VA_ARGS__);                \
        _res;                                                           \
})
 
#define pw_core_add_listener(c,...)     pw_core_method(c,add_listener,0,__VA_ARGS__)
#define pw_core_hello(c,...)            pw_core_method(c,hello,0,__VA_ARGS__)
#define pw_core_sync(c,...)             pw_core_method(c,sync,0,__VA_ARGS__)
#define pw_core_pong(c,...)             pw_core_method(c,pong,0,__VA_ARGS__)
#define pw_core_error(c,...)            pw_core_method(c,error,0,__VA_ARGS__)
 
 
static inline
SPA_PRINTF_FUNC(5, 0) int
pw_core_errorv(struct pw_core *core, uint32_t id, int seq,
                int res, const char *message, va_list args)
{
        char buffer[1024];
        vsnprintf(buffer, sizeof(buffer), message, args);
        buffer[1023] = '\0';
        return pw_core_error(core, id, seq, res, buffer);
}
 
static inline
SPA_PRINTF_FUNC(5, 6) int
pw_core_errorf(struct pw_core *core, uint32_t id, int seq,
                int res, const char *message, ...)
{
        va_list args;
        int r;
        va_start(args, message);
        r = pw_core_errorv(core, id, seq, res, message, args);
        va_end(args);
        return r;
}
 
static inline struct pw_registry *
pw_core_get_registry(struct pw_core *core, uint32_t version, size_t user_data_size)
{
        struct pw_registry *res = NULL;
        spa_interface_call_res((struct spa_interface*)core,
                        struct pw_core_methods, res,
                        get_registry, 0, version, user_data_size);
        return res;
}
 
static inline void *
pw_core_create_object(struct pw_core *core,
                            const char *factory_name,
                            const char *type,
                            uint32_t version,
                            const struct spa_dict *props,
                            size_t user_data_size)
{
        void *res = NULL;
        spa_interface_call_res((struct spa_interface*)core,
                        struct pw_core_methods, res,
                        create_object, 0, factory_name,
                        type, version, props, user_data_size);
        return res;
}
 
#define pw_core_destroy(c,...)          pw_core_method(c,destroy,0,__VA_ARGS__)
 
#define PW_REGISTRY_EVENT_GLOBAL             0
#define PW_REGISTRY_EVENT_GLOBAL_REMOVE      1
#define PW_REGISTRY_EVENT_NUM                2
 
struct pw_registry_events {
#define PW_VERSION_REGISTRY_EVENTS      0
        uint32_t version;
        void (*global) (void *data, uint32_t id,
                       uint32_t permissions, const char *type, uint32_t version,
                       const struct spa_dict *props);
        void (*global_remove) (void *data, uint32_t id);
};
 
#define PW_REGISTRY_METHOD_ADD_LISTENER 0
#define PW_REGISTRY_METHOD_BIND         1
#define PW_REGISTRY_METHOD_DESTROY      2
#define PW_REGISTRY_METHOD_NUM          3
 
struct pw_registry_methods {
#define PW_VERSION_REGISTRY_METHODS     0
        uint32_t version;
 
        int (*add_listener) (void *object,
                        struct spa_hook *listener,
                        const struct pw_registry_events *events,
                        void *data);
        void * (*bind) (void *object, uint32_t id, const char *type, uint32_t version,
                        size_t use_data_size);
 
        int (*destroy) (void *object, uint32_t id);
};
 
#define pw_registry_method(o,method,version,...)                        \
({                                                                      \
        int _res = -ENOTSUP;                                            \
        spa_interface_call_res((struct spa_interface*)o,                \
                        struct pw_registry_methods, _res,               \
                        method, version, ##__VA_ARGS__);                \
        _res;                                                           \
})
 
#define pw_registry_add_listener(p,...) pw_registry_method(p,add_listener,0,__VA_ARGS__)
 
static inline void *
pw_registry_bind(struct pw_registry *registry,
                       uint32_t id, const char *type, uint32_t version,
                       size_t user_data_size)
{
        void *res = NULL;
        spa_interface_call_res((struct spa_interface*)registry,
                        struct pw_registry_methods, res,
                        bind, 0, id, type, version, user_data_size);
        return res;
}
 
#define pw_registry_destroy(p,...)      pw_registry_method(p,destroy,0,__VA_ARGS__)
 
struct pw_core *
pw_context_connect(struct pw_context *context,
              struct pw_properties *properties,
              size_t user_data_size);
 
struct pw_core *
pw_context_connect_fd(struct pw_context *context,
              int fd,
              struct pw_properties *properties,
              size_t user_data_size);
 
struct pw_core *
pw_context_connect_self(struct pw_context *context,
              struct pw_properties *properties,
              size_t user_data_size);
 
int pw_core_steal_fd(struct pw_core *core);
 
int pw_core_set_paused(struct pw_core *core, bool paused);
 
int pw_core_disconnect(struct pw_core *core);
 
void *pw_core_get_user_data(struct pw_core *core);
 
struct pw_client * pw_core_get_client(struct pw_core *core);
 
struct pw_context * pw_core_get_context(struct pw_core *core);
 
const struct pw_properties *pw_core_get_properties(struct pw_core *core);
 
int pw_core_update_properties(struct pw_core *core, const struct spa_dict *dict);
 
struct pw_mempool * pw_core_get_mempool(struct pw_core *core);
 
struct pw_proxy *pw_core_find_proxy(struct pw_core *core, uint32_t id);
 
struct pw_proxy *pw_core_export(struct pw_core *core,                   
                                  const char *type,                     
                                  const struct spa_dict *props,         
                                  void *object,                         
                                  size_t user_data_size                 );
 
#ifdef __cplusplus
}
#endif
 
#endif /* PIPEWIRE_CORE_H */