cap.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2022-2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_CAP_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_CAP_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/bluetooth/audio/audio.h>
#include <zephyr/bluetooth/audio/bap.h>
#include <zephyr/bluetooth/audio/csip.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/iso.h>
#include <zephyr/net_buf.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct bt_cap_broadcast_source;
 
int bt_cap_acceptor_register(const struct bt_csip_set_member_register_param *param,
                             struct bt_csip_set_member_svc_inst **svc_inst);
 
struct bt_cap_initiator_cb {
#if defined(CONFIG_BT_BAP_UNICAST_CLIENT) || defined(__DOXYGEN__)
        void (*unicast_discovery_complete)(
                struct bt_conn *conn, int err,
                const struct bt_csip_set_coordinator_set_member *member,
                const struct bt_csip_set_coordinator_csis_inst *csis_inst);
 
        void (*unicast_start_complete)(int err, struct bt_conn *conn);
 
        void (*unicast_update_complete)(int err, struct bt_conn *conn);
 
        void (*unicast_stop_complete)(int err, struct bt_conn *conn);
#endif /* CONFIG_BT_BAP_UNICAST_CLIENT */
#if defined(CONFIG_BT_BAP_BROADCAST_SOURCE)
        void (*broadcast_started)(struct bt_cap_broadcast_source *source);
 
        void (*broadcast_stopped)(struct bt_cap_broadcast_source *source, uint8_t reason);
#endif /* CONFIG_BT_BAP_BROADCAST_SOURCE */
};
 
int bt_cap_initiator_unicast_discover(struct bt_conn *conn);
 
enum bt_cap_set_type {
        BT_CAP_SET_TYPE_AD_HOC,
        BT_CAP_SET_TYPE_CSIP,
};
 
union bt_cap_set_member {
        struct bt_conn *member;
 
        struct bt_csip_set_coordinator_csis_inst *csip;
};
 
struct bt_cap_stream {
        struct bt_bap_stream bap_stream;
 
        struct bt_bap_stream_ops *ops;
};
 
void bt_cap_stream_ops_register(struct bt_cap_stream *stream, struct bt_bap_stream_ops *ops);
 
int bt_cap_stream_send(struct bt_cap_stream *stream, struct net_buf *buf, uint16_t seq_num);
 
int bt_cap_stream_send_ts(struct bt_cap_stream *stream, struct net_buf *buf, uint16_t seq_num,
                          uint32_t ts);
 
int bt_cap_stream_get_tx_sync(struct bt_cap_stream *stream, struct bt_iso_tx_info *info);
 
struct bt_cap_unicast_audio_start_stream_param {
        union bt_cap_set_member member;
 
        struct bt_cap_stream *stream;
 
        struct bt_bap_ep *ep;
 
        struct bt_audio_codec_cfg *codec_cfg;
};
 
struct bt_cap_unicast_audio_start_param {
        enum bt_cap_set_type type;
 
        size_t count;
 
        struct bt_cap_unicast_audio_start_stream_param *stream_params;
};
 
struct bt_cap_unicast_audio_update_stream_param {
        struct bt_cap_stream *stream;
 
        size_t meta_len;
 
        uint8_t *meta;
};
 
struct bt_cap_unicast_audio_update_param {
        enum bt_cap_set_type type;
 
        size_t count;
 
        struct bt_cap_unicast_audio_update_stream_param *stream_params;
};
 
struct bt_cap_unicast_audio_stop_param {
        enum bt_cap_set_type type;
 
        size_t count;
 
        struct bt_cap_stream **streams;
 
        bool release;
};
 
int bt_cap_initiator_register_cb(const struct bt_cap_initiator_cb *cb);
 
int bt_cap_initiator_unregister_cb(const struct bt_cap_initiator_cb *cb);
 
int bt_cap_initiator_unicast_audio_start(const struct bt_cap_unicast_audio_start_param *param);
 
int bt_cap_initiator_unicast_audio_update(const struct bt_cap_unicast_audio_update_param *param);
 
int bt_cap_initiator_unicast_audio_stop(const struct bt_cap_unicast_audio_stop_param *param);
 
int bt_cap_initiator_unicast_audio_cancel(void);
 
struct bt_cap_initiator_broadcast_stream_param {
        struct bt_cap_stream *stream;
 
        size_t data_len;
 
        uint8_t *data;
};
 
struct bt_cap_initiator_broadcast_subgroup_param {
        size_t stream_count;
 
        struct bt_cap_initiator_broadcast_stream_param *stream_params;
 
        struct bt_audio_codec_cfg *codec_cfg;
};
 
struct bt_cap_initiator_broadcast_create_param {
        size_t subgroup_count;
 
        struct bt_cap_initiator_broadcast_subgroup_param *subgroup_params;
 
        struct bt_bap_qos_cfg *qos;
 
        uint8_t packing;
 
        bool encryption;
 
        uint8_t broadcast_code[BT_ISO_BROADCAST_CODE_SIZE];
 
#if defined(CONFIG_BT_ISO_TEST_PARAMS) || defined(__DOXYGEN__)
        uint8_t irc;
 
        uint8_t pto;
 
        uint16_t iso_interval;
#endif /* CONFIG_BT_ISO_TEST_PARAMS */
};
 
int bt_cap_initiator_broadcast_audio_create(
        const struct bt_cap_initiator_broadcast_create_param *param,
        struct bt_cap_broadcast_source **broadcast_source);
 
int bt_cap_initiator_broadcast_audio_start(struct bt_cap_broadcast_source *broadcast_source,
                                           struct bt_le_ext_adv *adv);
int bt_cap_initiator_broadcast_audio_update(struct bt_cap_broadcast_source *broadcast_source,
                                            const uint8_t meta[], size_t meta_len);
 
int bt_cap_initiator_broadcast_audio_stop(struct bt_cap_broadcast_source *broadcast_source);
 
int bt_cap_initiator_broadcast_audio_delete(struct bt_cap_broadcast_source *broadcast_source);
 
int bt_cap_initiator_broadcast_get_base(struct bt_cap_broadcast_source *broadcast_source,
                                        struct net_buf_simple *base_buf);
 
struct bt_cap_unicast_to_broadcast_param {
        struct bt_bap_unicast_group *unicast_group;
 
        bool encrypt;
 
        uint8_t broadcast_code[BT_ISO_BROADCAST_CODE_SIZE];
};
 
int bt_cap_initiator_unicast_to_broadcast(const struct bt_cap_unicast_to_broadcast_param *param,
                                          struct bt_cap_broadcast_source **source);
 
struct bt_cap_broadcast_to_unicast_param {
        struct bt_cap_broadcast_source *broadcast_source;
 
        enum bt_cap_set_type type;
 
        size_t count;
 
        union bt_cap_set_member **members;
};
 
int bt_cap_initiator_broadcast_to_unicast(const struct bt_cap_broadcast_to_unicast_param *param,
                                          struct bt_bap_unicast_group **unicast_group);
 
struct bt_cap_commander_cb {
        void (*discovery_complete)(struct bt_conn *conn, int err,
                                   const struct bt_csip_set_coordinator_set_member *member,
                                   const struct bt_csip_set_coordinator_csis_inst *csis_inst);
 
#if defined(CONFIG_BT_VCP_VOL_CTLR) || defined(__DOXYGEN__)
        void (*volume_changed)(struct bt_conn *conn, int err);
 
        void (*volume_mute_changed)(struct bt_conn *conn, int err);
 
#if defined(CONFIG_BT_VCP_VOL_CTLR_VOCS) || defined(__DOXYGEN__)
        void (*volume_offset_changed)(struct bt_conn *conn, int err);
#endif /* CONFIG_BT_VCP_VOL_CTLR_VOCS */
#endif /* CONFIG_BT_VCP_VOL_CTLR */
#if defined(CONFIG_BT_MICP_MIC_CTLR) || defined(__DOXYGEN__)
        void (*microphone_mute_changed)(struct bt_conn *conn, int err);
#if defined(CONFIG_BT_MICP_MIC_CTLR_AICS) || defined(__DOXYGEN__)
        void (*microphone_gain_changed)(struct bt_conn *conn, int err);
#endif /* CONFIG_BT_MICP_MIC_CTLR_AICS */
#endif /* CONFIG_BT_MICP_MIC_CTLR */
 
#if defined(CONFIG_BT_BAP_BROADCAST_ASSISTANT) || defined(__DOXYGEN__)
        void (*broadcast_reception_start)(struct bt_conn *conn, int err);
        void (*broadcast_reception_stop)(struct bt_conn *conn, int err);
        void (*distribute_broadcast_code)(struct bt_conn *conn, int err);
#endif /* CONFIG_BT_BAP_BROADCAST_ASSISTANT */
};
 
int bt_cap_commander_register_cb(const struct bt_cap_commander_cb *cb);
 
int bt_cap_commander_unregister_cb(const struct bt_cap_commander_cb *cb);
 
int bt_cap_commander_discover(struct bt_conn *conn);
 
int bt_cap_commander_cancel(void);
 
struct bt_cap_commander_broadcast_reception_start_member_param {
        union bt_cap_set_member member;
 
        bt_addr_le_t addr;
 
        uint8_t adv_sid;
 
        uint16_t pa_interval;
 
        uint32_t broadcast_id;
 
        struct bt_bap_bass_subgroup subgroups[BT_BAP_BASS_MAX_SUBGROUPS];
 
        size_t num_subgroups;
};
 
struct bt_cap_commander_broadcast_reception_start_param {
        enum bt_cap_set_type type;
 
        struct bt_cap_commander_broadcast_reception_start_member_param *param;
 
        size_t count;
};
 
int bt_cap_commander_broadcast_reception_start(
        const struct bt_cap_commander_broadcast_reception_start_param *param);
 
struct bt_cap_commander_broadcast_reception_stop_member_param {
        union bt_cap_set_member member;
 
        uint8_t src_id;
 
        size_t num_subgroups;
};
 
struct bt_cap_commander_broadcast_reception_stop_param {
        enum bt_cap_set_type type;
 
        struct bt_cap_commander_broadcast_reception_stop_member_param *param;
 
        size_t count;
};
 
int bt_cap_commander_broadcast_reception_stop(
        const struct bt_cap_commander_broadcast_reception_stop_param *param);
 
struct bt_cap_commander_distribute_broadcast_code_member_param {
        union bt_cap_set_member member;
 
        uint8_t src_id;
};
 
struct bt_cap_commander_distribute_broadcast_code_param {
        enum bt_cap_set_type type;
 
        struct bt_cap_commander_distribute_broadcast_code_member_param *param;
 
        size_t count;
 
        uint8_t broadcast_code[BT_ISO_BROADCAST_CODE_SIZE];
};
 
int bt_cap_commander_distribute_broadcast_code(
        const struct bt_cap_commander_distribute_broadcast_code_param *param);
 
struct bt_cap_commander_change_volume_param {
        enum bt_cap_set_type type;
 
        union bt_cap_set_member *members;
 
        size_t count;
 
        uint8_t volume;
};
 
int bt_cap_commander_change_volume(const struct bt_cap_commander_change_volume_param *param);
 
struct bt_cap_commander_change_volume_offset_member_param {
        union bt_cap_set_member member;
 
        int16_t offset;
};
 
struct bt_cap_commander_change_volume_offset_param {
        enum bt_cap_set_type type;
 
        struct bt_cap_commander_change_volume_offset_member_param *param;
 
        size_t count;
};
 
int bt_cap_commander_change_volume_offset(
        const struct bt_cap_commander_change_volume_offset_param *param);
 
struct bt_cap_commander_change_volume_mute_state_param {
        enum bt_cap_set_type type;
 
        union bt_cap_set_member *members;
 
        size_t count;
 
        bool mute;
};
 
int bt_cap_commander_change_volume_mute_state(
        const struct bt_cap_commander_change_volume_mute_state_param *param);
 
struct bt_cap_commander_change_microphone_mute_state_param {
        enum bt_cap_set_type type;
 
        union bt_cap_set_member *members;
 
        size_t count;
 
        bool mute;
};
 
int bt_cap_commander_change_microphone_mute_state(
        const struct bt_cap_commander_change_microphone_mute_state_param *param);
 
struct bt_cap_commander_change_microphone_gain_setting_member_param {
        union bt_cap_set_member member;
 
        int8_t gain;
};
 
struct bt_cap_commander_change_microphone_gain_setting_param {
        enum bt_cap_set_type type;
 
        struct bt_cap_commander_change_microphone_gain_setting_member_param *param;
 
        size_t count;
};
 
int bt_cap_commander_change_microphone_gain_setting(
        const struct bt_cap_commander_change_microphone_gain_setting_param *param);
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_CAP_H_ */