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>
 
#include <pipewire/type.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;
 
#ifndef PW_API_CORE_IMPL
#define PW_API_CORE_IMPL static inline
#endif
#ifndef PW_API_REGISTRY_IMPL
#define PW_API_REGISTRY_IMPL static inline
#endif
 
#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);
};
 
 
PW_API_CORE_IMPL int pw_core_add_listener(struct pw_core *object,
                        struct spa_hook *listener,
                        const struct pw_core_events *events,
                        void *data)
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_core, (struct spa_interface*)object, add_listener, 0,
                        listener, events, data);
}
PW_API_CORE_IMPL int pw_core_hello(struct pw_core *object, uint32_t version)
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_core, (struct spa_interface*)object, hello, 0,
                        version);
}
PW_API_CORE_IMPL int pw_core_sync(struct pw_core *object, uint32_t id, int seq)
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_core, (struct spa_interface*)object, sync, 0,
                        id, seq);
}
PW_API_CORE_IMPL int pw_core_pong(struct pw_core *object, uint32_t id, int seq)
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_core, (struct spa_interface*)object, pong, 0,
                        id, seq);
}
PW_API_CORE_IMPL int pw_core_error(struct pw_core *object, uint32_t id, int seq, int res, const char *message)
        int (*pong) (void *object, uint32_t id, int seq); {…};
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_core, (struct spa_interface*)object, error, 0,
                        id, seq, res, message);
}
PW_API_CORE_IMPL
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);
}
 
PW_API_CORE_IMPL
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;
}
 
        va_start(args, message); {…}
PW_API_CORE_IMPL struct pw_registry *
pw_core_get_registry(struct pw_core *core, uint32_t version, size_t user_data_size)
{
        return spa_api_method_r(struct pw_registry*, NULL,
                        pw_core, (struct spa_interface*)core, get_registry, 0,
                        version, user_data_size);
PW_API_CORE_IMPL struct pw_registry * {…}
}
PW_API_CORE_IMPL 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)
{
        return spa_api_method_r(void*, NULL,
                        pw_core, (struct spa_interface*)core, create_object, 0,
                        factory_name, type, version, props, user_data_size);
}
PW_API_CORE_IMPL void
pw_core_destroy(struct pw_core *core, void *proxy)
{
        spa_api_method_v(pw_core, (struct spa_interface*)core, destroy, 0,
                        proxy);
}
 
#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);
};
 
 
                        void *data); {…};
PW_API_REGISTRY_IMPL int pw_registry_add_listener(struct pw_registry *registry,
                        struct spa_hook *listener,
                        const struct pw_registry_events *events,
                        void *data)
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_registry, (struct spa_interface*)registry, add_listener, 0,
                        listener, events, data);
}
PW_API_REGISTRY_IMPL void *
pw_registry_bind(struct pw_registry *registry,
                       uint32_t id, const char *type, uint32_t version,
                       size_t user_data_size)
{
        return spa_api_method_r(void*, NULL,
                        pw_registry, (struct spa_interface*)registry, bind, 0,
                        id, type, version, user_data_size);
}
PW_API_REGISTRY_IMPL int
pw_registry_destroy(struct pw_registry *registry, uint32_t id)
{
        return spa_api_method_r(int, -ENOTSUP,
                        pw_registry, (struct spa_interface*)registry, destroy, 0, id);
}
 
struct pw_core *
pw_context_connect(struct pw_context *context,
              struct pw_properties *properties,
              size_t user_data_size);
 
pw_context_connect(struct pw_context *context, {…}
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 */