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
 
#include <spa/utils/defs.h>
#include <spa/utils/hook.h>
#include <spa/utils/dict.h>
#include <spa/pod/command.h>
#include <spa/pod/event.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#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 {
        /** version of the structure */
#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_SEND_COMMAND  4
#define SPA_DEVICE_METHOD_NUM           5
 
/* object id of SPA_TYPE_COMMAND_Device */
enum spa_device_commands {
        SPA_DEVICE_COMMAND_User,
};
 
#define SPA_DEVICE_COMMAND_ID(cmd)      SPA_COMMAND_ID(cmd, SPA_TYPE_COMMAND_Device)
#define SPA_DEVICE_COMMAND_INIT(id)     SPA_COMMAND_INIT(SPA_TYPE_COMMAND_Device, id)
 
 
/* properties for SPA_TYPE_COMMAND_Device */
enum spa_command_device {
        SPA_COMMAND_DEVICE_START,
 
        SPA_COMMAND_DEVICE_START_User           = 0x1000,
        SPA_COMMAND_DEVICE_extra,               
 
        SPA_COMMAND_DEVICE_START_CUSTOM         = 0x1000000,
};

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      1
        uint32_t version;

         * Setting the events will trigger the info event and an
         * object_info event for each managed object on the new
         * listener.
         *
         * \param object a \ref spa_device
         * \param listener a listener
         * \param events a struct \ref spa_device_events
         * \param data data passed as first argument in functions of \a events
         * \return 0 on success
         *         < 0 errno on error
         */
        int (*add_listener) (void *object,
                        struct spa_hook *listener,
                        const struct spa_device_events *events,
                        void *data);

         * to wait for completion of all previous method calls.
         *
         * \param seq a sequence number
         * \return 0 on success
         *         -EINVAL when node is NULL
         *         an async result
         */
        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);

        int (*send_command) (void *object, const struct spa_command *command);
 
};
 
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);
}
SPA_API_DEVICE int spa_device_send_command(struct spa_device *object,
                          const struct spa_command *command)
{
        return spa_api_method_r(int, -ENOTSUP, spa_device, &object->iface, send_command, 1,
                        command);
}
 
#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"            

                                                                   *  "bluetooth" */
#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 */