cap.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2022-2025 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;

struct bt_cap_unicast_group;

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_group_stream_param {
        struct bt_cap_stream *stream;

        struct bt_bap_qos_cfg *qos_cfg;
};

struct bt_cap_unicast_group_stream_pair_param {
        struct bt_cap_unicast_group_stream_param *rx_param;

        struct bt_cap_unicast_group_stream_param *tx_param;
};

struct bt_cap_unicast_group_param {
        size_t params_count;

        struct bt_cap_unicast_group_stream_pair_param *params;

        uint8_t packing;
 
#if defined(CONFIG_BT_ISO_TEST_PARAMS) || defined(__DOXYGEN__)
        uint8_t c_to_p_ft;

        uint8_t p_to_c_ft;

        uint16_t iso_interval;
#endif /* CONFIG_BT_ISO_TEST_PARAMS */
};

int bt_cap_unicast_group_create(const struct bt_cap_unicast_group_param *param,
                                struct bt_cap_unicast_group **unicast_group);

int bt_cap_unicast_group_reconfig(struct bt_cap_unicast_group *unicast_group,
                                  const struct bt_cap_unicast_group_param *param);

int bt_cap_unicast_group_add_streams(struct bt_cap_unicast_group *unicast_group,
                                     const struct bt_cap_unicast_group_stream_pair_param params[],
                                     size_t num_param);

int bt_cap_unicast_group_delete(struct bt_cap_unicast_group *unicast_group);

typedef bool (*bt_cap_unicast_group_foreach_stream_func_t)(struct bt_cap_stream *stream,
                                                           void *user_data);

int bt_cap_unicast_group_foreach_stream(struct bt_cap_unicast_group *unicast_group,
                                        bt_cap_unicast_group_foreach_stream_func_t func,
                                        void *user_data);

struct bt_cap_unicast_group_info {
        const struct bt_bap_unicast_group *unicast_group;
};

int bt_cap_unicast_group_get_info(const struct bt_cap_unicast_group *unicast_group,
                                  struct bt_cap_unicast_group_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);

typedef bool (*bt_cap_initiator_broadcast_foreach_stream_func_t)(struct bt_cap_stream *stream,
                                                                 void *user_data);

int bt_cap_initiator_broadcast_foreach_stream(struct bt_cap_broadcast_source *broadcast_source,
                                              bt_cap_initiator_broadcast_foreach_stream_func_t func,
                                              void *user_data);

struct bt_cap_handover_unicast_to_broadcast_param {
        enum bt_cap_set_type type;

        struct bt_cap_unicast_group *unicast_group;

        struct bt_le_ext_adv *ext_adv;

        uint16_t pa_interval;

        uint32_t broadcast_id;

        struct bt_cap_initiator_broadcast_create_param *broadcast_create_param;
};

struct bt_cap_handover_cb {
        void (*unicast_to_broadcast_created)(struct bt_cap_broadcast_source *broadcast_source);

        void (*unicast_to_broadcast_complete)(int err, struct bt_conn *conn,
                                              struct bt_cap_unicast_group *unicast_group,
                                              struct bt_cap_broadcast_source *broadcast_source);

        void (*broadcast_to_unicast_complete)(int err, struct bt_conn *conn,
                                              struct bt_cap_broadcast_source *broadcast_source,
                                              struct bt_cap_unicast_group *unicast_group);
};

int bt_cap_handover_register_cb(const struct bt_cap_handover_cb *cb);

int bt_cap_handover_unregister_cb(const struct bt_cap_handover_cb *cb);

int bt_cap_handover_unicast_to_broadcast(
        const struct bt_cap_handover_unicast_to_broadcast_param *param);

struct bt_cap_handover_broadcast_to_unicast_param {
        struct bt_cap_commander_broadcast_reception_stop_param *reception_stop_param;

        uint32_t broadcast_id;

        uint8_t adv_sid;

        uint8_t adv_type;

        struct bt_cap_broadcast_source *broadcast_source;
 
        /* Parameters for the unicast group to be created */
        struct bt_cap_unicast_group_param *unicast_group_param;
 
        /* Parameters for starting the unicast audio */
        struct bt_cap_unicast_audio_start_param *unicast_start_param;
};

int bt_cap_handover_broadcast_to_unicast(
        const struct bt_cap_handover_broadcast_to_unicast_param *param);

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_ */