device.h

Go to the documentation of this file.

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

#ifndef SPA_DEVICE_H
#define SPA_DEVICE_H

#ifdef __cplusplus
extern "C" {
#endif

#include <spa/utils/defs.h>
#include <spa/utils/hook.h>
#include <spa/utils/dict.h>
#include <spa/pod/event.h>

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

#define SPA_TYPE_INTERFACE_Device       SPA_TYPE_INFO_INTERFACE_BASE "Device"

#define SPA_VERSION_DEVICE              0
struct spa_device { struct spa_interface iface; };

struct spa_device_info {
#define SPA_VERSION_DEVICE_INFO 0
        uint32_t version;

#define SPA_DEVICE_CHANGE_MASK_FLAGS            (1u<<0)
#define SPA_DEVICE_CHANGE_MASK_PROPS            (1u<<1)
#define SPA_DEVICE_CHANGE_MASK_PARAMS           (1u<<2)
        uint64_t change_mask;
        uint64_t flags;
        const struct spa_dict *props;           
        struct spa_param_info *params;          
        uint32_t n_params;                      
};

#define SPA_DEVICE_INFO_INIT()  ((struct spa_device_info){ SPA_VERSION_DEVICE_INFO, })

struct spa_device_object_info {
#define SPA_VERSION_DEVICE_OBJECT_INFO 0
        uint32_t version;

        const char *type;                       
        const char *factory_name;               
#define SPA_DEVICE_OBJECT_CHANGE_MASK_FLAGS     (1u<<0)
#define SPA_DEVICE_OBJECT_CHANGE_MASK_PROPS     (1u<<1)
        uint64_t change_mask;
        uint64_t flags;
        const struct spa_dict *props;           
};

#define SPA_DEVICE_OBJECT_INFO_INIT()   ((struct spa_device_object_info){ SPA_VERSION_DEVICE_OBJECT_INFO, })

#define SPA_RESULT_TYPE_DEVICE_PARAMS   1
struct spa_result_device_params {
        uint32_t id;
        uint32_t index;
        uint32_t next;
        struct spa_pod *param;
};

#define SPA_DEVICE_EVENT_INFO           0
#define SPA_DEVICE_EVENT_RESULT         1
#define SPA_DEVICE_EVENT_EVENT          2
#define SPA_DEVICE_EVENT_OBJECT_INFO    3
#define SPA_DEVICE_EVENT_NUM            4

struct spa_device_events {
#define SPA_VERSION_DEVICE_EVENTS       0
        uint32_t version;

        void (*info) (void *data, const struct spa_device_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);

        void (*object_info) (void *data, uint32_t id,
                const struct spa_device_object_info *info);
};

#define SPA_DEVICE_METHOD_ADD_LISTENER  0
#define SPA_DEVICE_METHOD_SYNC          1
#define SPA_DEVICE_METHOD_ENUM_PARAMS   2
#define SPA_DEVICE_METHOD_SET_PARAM     3
#define SPA_DEVICE_METHOD_NUM           4

struct spa_device_methods {
        /* the version of the methods. This can be used to expand this
         * structure in the future */
#define SPA_VERSION_DEVICE_METHODS      0
        uint32_t version;

        int (*add_listener) (void *object,
                        struct spa_hook *listener,
                        const struct spa_device_events *events,
                        void *data);
        int (*sync) (void *object, int seq);

        int (*enum_params) (void *object, int seq,
                            uint32_t id, uint32_t index, uint32_t max,
                            const struct spa_pod *filter);

        int (*set_param) (void *object,
                          uint32_t id, uint32_t flags,
                          const struct spa_pod *param);
};

SPA_API_DEVICE int spa_device_add_listener(struct spa_device *object,
                        struct spa_hook *listener,
                        const struct spa_device_events *events,
                        void *data)
{
        return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, add_listener, 0,
                        listener, events, data);

}
SPA_API_DEVICE int spa_device_sync(struct spa_device *object, int seq)
{
        return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, sync, 0,
                        seq);
}
SPA_API_DEVICE int spa_device_enum_params(struct spa_device *object, int seq,
                            uint32_t id, uint32_t index, uint32_t max,
                            const struct spa_pod *filter)
{
        return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, enum_params, 0,
                        seq, id, index, max, filter);
}
SPA_API_DEVICE int spa_device_set_param(struct spa_device *object,
                          uint32_t id, uint32_t flags,
                          const struct spa_pod *param)
{
        return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, set_param, 0,
                        id, flags, param);
}

#define SPA_KEY_DEVICE_ENUM_API         "device.enum.api"       
#define SPA_KEY_DEVICE_API              "device.api"            
#define SPA_KEY_DEVICE_NAME             "device.name"           
#define SPA_KEY_DEVICE_ALIAS            "device.alias"          
#define SPA_KEY_DEVICE_NICK             "device.nick"           
#define SPA_KEY_DEVICE_DESCRIPTION      "device.description"    
#define SPA_KEY_DEVICE_ICON             "device.icon"           
#define SPA_KEY_DEVICE_ICON_NAME        "device.icon-name"      
#define SPA_KEY_DEVICE_PLUGGED_USEC     "device.plugged.usec"   
#define SPA_KEY_DEVICE_BUS_ID           "device.bus-id"         
#define SPA_KEY_DEVICE_BUS_PATH         "device.bus-path"       
#define SPA_KEY_DEVICE_BUS              "device.bus"            
#define SPA_KEY_DEVICE_SUBSYSTEM        "device.subsystem"      
#define SPA_KEY_DEVICE_SYSFS_PATH       "device.sysfs.path"     
#define SPA_KEY_DEVICE_VENDOR_ID        "device.vendor.id"      
#define SPA_KEY_DEVICE_VENDOR_NAME      "device.vendor.name"    
#define SPA_KEY_DEVICE_PRODUCT_ID       "device.product.id"     
#define SPA_KEY_DEVICE_PRODUCT_NAME     "device.product.name"   
#define SPA_KEY_DEVICE_SERIAL           "device.serial"         
#define SPA_KEY_DEVICE_CLASS            "device.class"          
#define SPA_KEY_DEVICE_CAPABILITIES     "device.capabilities"   
#define SPA_KEY_DEVICE_FORM_FACTOR      "device.form-factor"    
#define SPA_KEY_DEVICE_PROFILE          "device.profile"        
#define SPA_KEY_DEVICE_PROFILE_SET      "device.profile-set"    
#define SPA_KEY_DEVICE_STRING           "device.string"         
#define SPA_KEY_DEVICE_DEVIDS           "device.devids"         
#ifdef __cplusplus
}  /* extern "C" */
#endif

#endif /* SPA_DEVICE_H */