bap.h

Go to the documentation of this file.

 
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_BAP_
#define ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_BAP_

 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/assigned_numbers.h>
#include <zephyr/bluetooth/audio/audio.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/data.h>
#include <zephyr/bluetooth/gap.h>
#include <zephyr/bluetooth/iso.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/net_buf.h>
#include <zephyr/sys/slist.h>
#include <zephyr/sys/util_macro.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define BT_BAP_BASS_MAX_SUBGROUPS                                                                  \
        COND_CODE_1(CONFIG_BT_AUDIO, (CONFIG_BT_BAP_BASS_MAX_SUBGROUPS), (0))

#define BT_BASE_MAX_SIZE (UINT8_MAX - 1 /* type */ - BT_UUID_SIZE_16)

#define BT_BAP_INVALID_BROADCAST_ID 0xFFFFFFFFU

#define BT_BAP_PD_UNSET 0xFFFFFFFFU

#define BT_BAP_ADV_PARAM_CONN_QUICK                                                                \
        BT_LE_ADV_PARAM(BT_LE_ADV_OPT_CONN | BT_LE_ADV_OPT_EXT_ADV, BT_GAP_MS_TO_ADV_INTERVAL(20), \
                        BT_GAP_MS_TO_ADV_INTERVAL(30), NULL)

#define BT_BAP_ADV_PARAM_CONN_REDUCED                                                              \
        BT_LE_ADV_PARAM(BT_LE_ADV_OPT_CONN | BT_LE_ADV_OPT_EXT_ADV,                                \
                        BT_GAP_MS_TO_ADV_INTERVAL(150), BT_GAP_MS_TO_ADV_INTERVAL(150), NULL)

#define BT_BAP_CONN_PARAM_SHORT_7_5                                                                \
        BT_LE_CONN_PARAM(BT_GAP_US_TO_CONN_INTERVAL(7500), BT_GAP_MS_TO_CONN_INTERVAL(30), 0,      \
                         BT_GAP_MS_TO_CONN_TIMEOUT(4000))

#define BT_BAP_CONN_PARAM_SHORT_10                                                                 \
        BT_LE_CONN_PARAM(BT_GAP_MS_TO_CONN_INTERVAL(10), BT_GAP_MS_TO_CONN_INTERVAL(30), 0,        \
                         BT_GAP_MS_TO_CONN_TIMEOUT(4000))

#define BT_BAP_CONN_PARAM_RELAXED                                                                  \
        BT_LE_CONN_PARAM(BT_GAP_MS_TO_CONN_INTERVAL(50), BT_GAP_MS_TO_CONN_INTERVAL(70), 0,        \
                         BT_GAP_MS_TO_CONN_TIMEOUT(4000))

#define BT_BAP_ADV_PARAM_BROADCAST_FAST                                                            \
        BT_LE_ADV_PARAM(BT_LE_ADV_OPT_EXT_ADV, BT_GAP_MS_TO_ADV_INTERVAL(60),                      \
                        BT_GAP_MS_TO_ADV_INTERVAL(60), NULL)

#define BT_BAP_ADV_PARAM_BROADCAST_SLOW                                                            \
        BT_LE_ADV_PARAM(BT_LE_ADV_OPT_EXT_ADV, BT_GAP_MS_TO_ADV_INTERVAL(150),                     \
                        BT_GAP_MS_TO_ADV_INTERVAL(150), NULL)

#define BT_BAP_PER_ADV_PARAM_BROADCAST_FAST                                                        \
        BT_LE_PER_ADV_PARAM(BT_GAP_MS_TO_PER_ADV_INTERVAL(60), BT_GAP_MS_TO_PER_ADV_INTERVAL(60),  \
                            BT_LE_PER_ADV_OPT_NONE)

#define BT_BAP_PER_ADV_PARAM_BROADCAST_SLOW                                                        \
        BT_LE_PER_ADV_PARAM(BT_GAP_MS_TO_PER_ADV_INTERVAL(150),                                    \
                            BT_GAP_MS_TO_PER_ADV_INTERVAL(150), BT_LE_PER_ADV_OPT_NONE)

#define BT_BAP_BASS_VALID_BIT_BITFIELD(_bis_bitfield)                                              \
        ((_bis_bitfield) == 0U || (_bis_bitfield) == BT_BAP_BIS_SYNC_NO_PREF ||                    \
         BT_ISO_VALID_BIS_BITFIELD(_bis_bitfield))

#define BT_BAP_QOS_CFG(_interval, _framing, _phy, _sdu, _rtn, _latency, _pd)                       \
        ((struct bt_bap_qos_cfg){                                                                  \
                .interval = _interval,                                                             \
                .framing = _framing,                                                               \
                .phy = _phy,                                                                       \
                .sdu = _sdu,                                                                       \
                .rtn = _rtn,                                                                       \
                IF_ENABLED(UTIL_OR(IS_ENABLED(CONFIG_BT_BAP_BROADCAST_SOURCE),                     \
                                   IS_ENABLED(CONFIG_BT_BAP_UNICAST)),                             \
                           (.latency = _latency,))                                                 \
                .pd = _pd,                                                                         \
        })

enum bt_bap_qos_cfg_framing {
        BT_BAP_QOS_CFG_FRAMING_UNFRAMED = 0x00,
        BT_BAP_QOS_CFG_FRAMING_FRAMED = 0x01,
};

enum {
        BT_BAP_QOS_CFG_1M = BIT(0),
        BT_BAP_QOS_CFG_2M = BIT(1),
        BT_BAP_QOS_CFG_CODED = BIT(2),
};

#define BT_BAP_QOS_CFG_UNFRAMED(_interval, _sdu, _rtn, _latency, _pd)                              \
        BT_BAP_QOS_CFG(_interval, BT_BAP_QOS_CFG_FRAMING_UNFRAMED, BT_BAP_QOS_CFG_2M, _sdu, _rtn,  \
                       _latency, _pd)

#define BT_BAP_QOS_CFG_FRAMED(_interval, _sdu, _rtn, _latency, _pd)                                \
        BT_BAP_QOS_CFG(_interval, BT_BAP_QOS_CFG_FRAMING_FRAMED, BT_BAP_QOS_CFG_2M, _sdu, _rtn,    \
                       _latency, _pd)

struct bt_bap_qos_cfg {
        uint32_t pd;

        struct {
                enum bt_bap_qos_cfg_framing framing;

                uint8_t phy;

                uint8_t rtn;

                uint16_t sdu;
 
#if defined(CONFIG_BT_BAP_BROADCAST_SOURCE) || defined(CONFIG_BT_BAP_UNICAST) ||                   \
        defined(__DOXYGEN__)
                uint16_t latency;
#endif /*  CONFIG_BT_BAP_BROADCAST_SOURCE || CONFIG_BT_BAP_UNICAST */

                uint32_t interval;
 
#if defined(CONFIG_BT_ISO_TEST_PARAMS) || defined(__DOXYGEN__)
                uint16_t max_pdu;

                uint8_t burst_number;

                uint8_t num_subevents;
#endif /* CONFIG_BT_ISO_TEST_PARAMS */
        };
};

#define BT_BAP_QOS_CFG_PREF(_unframed_supported, _phy, _rtn, _latency, _pd_min, _pd_max,           \
                            _pref_pd_min, _pref_pd_max)                                            \
        {                                                                                          \
                .unframed_supported = _unframed_supported, .phy = _phy, .rtn = _rtn,               \
                .latency = _latency, .pd_min = _pd_min, .pd_max = _pd_max,                         \
                .pref_pd_min = _pref_pd_min, .pref_pd_max = _pref_pd_max,                          \
        }

struct bt_bap_qos_cfg_pref {
        bool unframed_supported;

        uint8_t phy;

        uint8_t rtn;

        uint16_t latency;

        uint32_t pd_min;

        uint32_t pd_max;

        uint32_t pref_pd_min;

        uint32_t pref_pd_max;
};

enum bt_bap_pa_state {
        BT_BAP_PA_STATE_NOT_SYNCED = 0x00,

        BT_BAP_PA_STATE_INFO_REQ = 0x01,

        BT_BAP_PA_STATE_SYNCED = 0x02,

        BT_BAP_PA_STATE_FAILED = 0x03,

        BT_BAP_PA_STATE_NO_PAST = 0x04,
};

enum bt_bap_big_enc_state {
        BT_BAP_BIG_ENC_STATE_NO_ENC = 0x00,

        BT_BAP_BIG_ENC_STATE_BCODE_REQ = 0x01,

        BT_BAP_BIG_ENC_STATE_DEC = 0x02,

        BT_BAP_BIG_ENC_STATE_BAD_CODE = 0x03,
};

enum bt_bap_bass_att_err {
        BT_BAP_BASS_ERR_OPCODE_NOT_SUPPORTED = 0x80,

        BT_BAP_BASS_ERR_INVALID_SRC_ID = 0x81,
};

#define BT_BAP_PA_INTERVAL_UNKNOWN             0xFFFF

#define BT_BAP_BIS_SYNC_NO_PREF 0xFFFFFFFF
#define BT_BAP_BIS_SYNC_FAILED  0xFFFFFFFF

enum bt_bap_ep_state {
        BT_BAP_EP_STATE_IDLE = 0x00,

        BT_BAP_EP_STATE_CODEC_CONFIGURED = 0x01,

        BT_BAP_EP_STATE_QOS_CONFIGURED = 0x02,

        BT_BAP_EP_STATE_ENABLING = 0x03,

        BT_BAP_EP_STATE_STREAMING = 0x04,

        BT_BAP_EP_STATE_DISABLING = 0x05,

        BT_BAP_EP_STATE_RELEASING = 0x06,
};

enum bt_bap_ascs_rsp_code {
        BT_BAP_ASCS_RSP_CODE_SUCCESS = 0x00,
        BT_BAP_ASCS_RSP_CODE_NOT_SUPPORTED = 0x01,
        BT_BAP_ASCS_RSP_CODE_INVALID_LENGTH = 0x02,
        BT_BAP_ASCS_RSP_CODE_INVALID_ASE = 0x03,
        BT_BAP_ASCS_RSP_CODE_INVALID_ASE_STATE = 0x04,
        BT_BAP_ASCS_RSP_CODE_INVALID_DIR = 0x05,
        BT_BAP_ASCS_RSP_CODE_CAP_UNSUPPORTED = 0x06,
        BT_BAP_ASCS_RSP_CODE_CONF_UNSUPPORTED = 0x07,
        BT_BAP_ASCS_RSP_CODE_CONF_REJECTED = 0x08,
        BT_BAP_ASCS_RSP_CODE_CONF_INVALID = 0x09,
        BT_BAP_ASCS_RSP_CODE_METADATA_UNSUPPORTED = 0x0a,
        BT_BAP_ASCS_RSP_CODE_METADATA_REJECTED = 0x0b,
        BT_BAP_ASCS_RSP_CODE_METADATA_INVALID = 0x0c,
        BT_BAP_ASCS_RSP_CODE_NO_MEM = 0x0d,
        BT_BAP_ASCS_RSP_CODE_UNSPECIFIED = 0x0e,
};

enum bt_bap_ascs_reason {
        BT_BAP_ASCS_REASON_NONE = 0x00,
        BT_BAP_ASCS_REASON_CODEC = 0x01,
        BT_BAP_ASCS_REASON_CODEC_DATA = 0x02,
        BT_BAP_ASCS_REASON_INTERVAL = 0x03,
        BT_BAP_ASCS_REASON_FRAMING = 0x04,
        BT_BAP_ASCS_REASON_PHY = 0x05,
        BT_BAP_ASCS_REASON_SDU = 0x06,
        BT_BAP_ASCS_REASON_RTN = 0x07,
        BT_BAP_ASCS_REASON_LATENCY = 0x08,
        BT_BAP_ASCS_REASON_PD = 0x09,
        BT_BAP_ASCS_REASON_CIS = 0x0a,
};

struct bt_bap_ascs_rsp {
        enum bt_bap_ascs_rsp_code code;

        union {
                enum bt_bap_ascs_reason reason;

                enum bt_audio_metadata_type metadata_type;
        };
};

#define BT_BAP_ASCS_RSP(c, r) (struct bt_bap_ascs_rsp) { .code = c, .reason = r }

struct bt_bap_broadcast_source;

struct bt_bap_broadcast_sink;

struct bt_bap_unicast_group;

struct bt_bap_ep;

struct bt_bap_bass_subgroup {
        uint32_t bis_sync;

        uint8_t metadata_len;
 
#if defined(CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE) || defined(__DOXYGEN__)
        uint8_t metadata[CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE];
#endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE */
};

struct bt_bap_scan_delegator_recv_state {
        uint8_t src_id;

        bt_addr_le_t addr;

        uint8_t adv_sid;

        enum bt_bap_pa_state pa_sync_state;

        enum bt_bap_big_enc_state encrypt_state;

        uint32_t broadcast_id;

        uint8_t bad_code[BT_ISO_BROADCAST_CODE_SIZE];

        uint8_t num_subgroups;

        struct bt_bap_bass_subgroup subgroups[BT_BAP_BASS_MAX_SUBGROUPS];
};

struct bt_bap_scan_delegator_cb {
        void (*recv_state_updated)(struct bt_conn *conn,
                                   const struct bt_bap_scan_delegator_recv_state *recv_state);

        int (*pa_sync_req)(struct bt_conn *conn,
                           const struct bt_bap_scan_delegator_recv_state *recv_state,
                           bool past_avail, uint16_t pa_interval);

        int (*pa_sync_term_req)(struct bt_conn *conn,
                                const struct bt_bap_scan_delegator_recv_state *recv_state);

        void (*broadcast_code)(struct bt_conn *conn,
                               const struct bt_bap_scan_delegator_recv_state *recv_state,
                               const uint8_t broadcast_code[BT_ISO_BROADCAST_CODE_SIZE]);
        int (*bis_sync_req)(struct bt_conn *conn,
                            const struct bt_bap_scan_delegator_recv_state *recv_state,
                            const uint32_t bis_sync_req[BT_BAP_BASS_MAX_SUBGROUPS]);
        void (*scanning_state)(struct bt_conn *conn, bool is_scanning);
        int (*add_source)(struct bt_conn *conn,
                          const struct bt_bap_scan_delegator_recv_state *recv_state);

        int (*modify_source)(struct bt_conn *conn,
                             const struct bt_bap_scan_delegator_recv_state *recv_state);

        int (*remove_source)(struct bt_conn *conn, uint8_t src_id);
};

struct bt_bap_ep_info {
        uint8_t id;

        enum bt_bap_ep_state state;

        enum bt_audio_dir dir;

        struct bt_iso_chan *iso_chan;

        bool can_send;

        bool can_recv;

        struct bt_bap_ep *paired_ep;

        const struct bt_bap_qos_cfg_pref *qos_pref;
};

int bt_bap_ep_get_info(const struct bt_bap_ep *ep, struct bt_bap_ep_info *info);

struct bt_conn *bt_bap_ep_get_conn(const struct bt_bap_ep *ep);

struct bt_bap_stream {
        struct bt_conn *conn;

        struct bt_bap_ep *ep;

        const struct bt_audio_codec_cfg *codec_cfg;

        const struct bt_bap_qos_cfg *qos;

        struct bt_bap_stream_ops *ops;

        void *user_data;

        struct bt_iso_chan *iso;

        void *group;
 
#if defined(CONFIG_BT_BAP_DEBUG_STREAM_SEQ_NUM) || defined(__DOXYGEN__)
        uint16_t _prev_seq_num;
#endif /* CONFIG_BT_BAP_DEBUG_STREAM_SEQ_NUM */

        sys_snode_t _node;
};

struct bt_bap_stream_ops {
#if defined(CONFIG_BT_BAP_UNICAST) || defined(__DOXYGEN__)
        void (*configured)(struct bt_bap_stream *stream, const struct bt_bap_qos_cfg_pref *pref);

        void (*qos_set)(struct bt_bap_stream *stream);

        void (*enabled)(struct bt_bap_stream *stream);

        void (*metadata_updated)(struct bt_bap_stream *stream);

        void (*disabled)(struct bt_bap_stream *stream);

        void (*released)(struct bt_bap_stream *stream);
#endif /* CONFIG_BT_BAP_UNICAST */

        void (*started)(struct bt_bap_stream *stream);

        void (*stopped)(struct bt_bap_stream *stream, uint8_t reason);
 
#if defined(CONFIG_BT_AUDIO_RX) || defined(__DOXYGEN__)
        void (*recv)(struct bt_bap_stream *stream, const struct bt_iso_recv_info *info,
                     struct net_buf *buf);
#endif /* CONFIG_BT_AUDIO_RX */
 
#if defined(CONFIG_BT_AUDIO_TX) || defined(__DOXYGEN__)
        void (*sent)(struct bt_bap_stream *stream);
#endif /* CONFIG_BT_AUDIO_TX */

        void (*connected)(struct bt_bap_stream *stream);

        void (*disconnected)(struct bt_bap_stream *stream, uint8_t reason);
};

struct bt_bap_unicast_server_register_param {
        uint8_t snk_cnt;

        uint8_t src_cnt;
};

void bt_bap_stream_cb_register(struct bt_bap_stream *stream, struct bt_bap_stream_ops *ops);

int bt_bap_stream_config(struct bt_conn *conn, struct bt_bap_stream *stream, struct bt_bap_ep *ep,
                         const struct bt_audio_codec_cfg *codec_cfg);

int bt_bap_stream_reconfig(struct bt_bap_stream *stream,
                           const struct bt_audio_codec_cfg *codec_cfg);

int bt_bap_stream_qos(struct bt_conn *conn, struct bt_bap_unicast_group *group);

int bt_bap_stream_enable(struct bt_bap_stream *stream, const uint8_t meta[], size_t meta_len);

int bt_bap_stream_metadata(struct bt_bap_stream *stream, const uint8_t meta[], size_t meta_len);

int bt_bap_stream_disable(struct bt_bap_stream *stream);

int bt_bap_stream_connect(struct bt_bap_stream *stream);

int bt_bap_stream_start(struct bt_bap_stream *stream);

int bt_bap_stream_stop(struct bt_bap_stream *stream);

int bt_bap_stream_release(struct bt_bap_stream *stream);

int bt_bap_stream_send(struct bt_bap_stream *stream, struct net_buf *buf, uint16_t seq_num);

int bt_bap_stream_send_ts(struct bt_bap_stream *stream, struct net_buf *buf, uint16_t seq_num,
                          uint32_t ts);

int bt_bap_stream_get_tx_sync(struct bt_bap_stream *stream, struct bt_iso_tx_info *info);


struct bt_bap_unicast_server_cb {
        int (*config)(struct bt_conn *conn, const struct bt_bap_ep *ep, enum bt_audio_dir dir,
                      const struct bt_audio_codec_cfg *codec_cfg, struct bt_bap_stream **stream,
                      struct bt_bap_qos_cfg_pref *const pref, struct bt_bap_ascs_rsp *rsp);

        int (*reconfig)(struct bt_bap_stream *stream, enum bt_audio_dir dir,
                        const struct bt_audio_codec_cfg *codec_cfg,
                        struct bt_bap_qos_cfg_pref *const pref, struct bt_bap_ascs_rsp *rsp);

        int (*qos)(struct bt_bap_stream *stream, const struct bt_bap_qos_cfg *qos,
                   struct bt_bap_ascs_rsp *rsp);

        int (*enable)(struct bt_bap_stream *stream, const uint8_t meta[], size_t meta_len,
                      struct bt_bap_ascs_rsp *rsp);

        int (*start)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);

        int (*metadata)(struct bt_bap_stream *stream, const uint8_t meta[], size_t meta_len,
                        struct bt_bap_ascs_rsp *rsp);

        int (*disable)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);

        int (*stop)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);

        int (*release)(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp);
};

int bt_bap_unicast_server_register(const struct bt_bap_unicast_server_register_param *param);

int bt_bap_unicast_server_unregister(void);

int bt_bap_unicast_server_register_cb(const struct bt_bap_unicast_server_cb *cb);

int bt_bap_unicast_server_unregister_cb(const struct bt_bap_unicast_server_cb *cb);

typedef bool (*bt_bap_ep_func_t)(struct bt_bap_ep *ep, void *user_data);

int bt_bap_unicast_server_foreach_ep(struct bt_conn *conn, bt_bap_ep_func_t func, void *user_data);

int bt_bap_unicast_server_config_ase(struct bt_conn *conn, struct bt_bap_stream *stream,
                                     const struct bt_audio_codec_cfg *codec_cfg,
                                     const struct bt_bap_qos_cfg_pref *qos_pref);
 /* End of group bt_bap_unicast_server */


struct bt_bap_unicast_group_stream_param {
        struct bt_bap_stream *stream;

        const struct bt_bap_qos_cfg *qos;
};

struct bt_bap_unicast_group_stream_pair_param {
        struct bt_bap_unicast_group_stream_param *rx_param;

        struct bt_bap_unicast_group_stream_param *tx_param;
};

struct bt_bap_unicast_group_param {
        size_t params_count;

        struct bt_bap_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_bap_unicast_group_create(struct bt_bap_unicast_group_param *param,
                                struct bt_bap_unicast_group **unicast_group);

int bt_bap_unicast_group_reconfig(struct bt_bap_unicast_group *unicast_group,
                                  const struct bt_bap_unicast_group_param *param);

int bt_bap_unicast_group_add_streams(struct bt_bap_unicast_group *unicast_group,
                                     struct bt_bap_unicast_group_stream_pair_param params[],
                                     size_t num_param);

int bt_bap_unicast_group_delete(struct bt_bap_unicast_group *unicast_group);

typedef bool (*bt_bap_unicast_group_foreach_stream_func_t)(struct bt_bap_stream *stream,
                                                           void *user_data);

int bt_bap_unicast_group_foreach_stream(struct bt_bap_unicast_group *unicast_group,
                                        bt_bap_unicast_group_foreach_stream_func_t func,
                                        void *user_data);

struct bt_bap_unicast_group_info {
        uint32_t sink_pd;

        uint32_t source_pd;
};

int bt_bap_unicast_group_get_info(const struct bt_bap_unicast_group *unicast_group,
                                  struct bt_bap_unicast_group_info *info);

struct bt_bap_unicast_client_cb {
        void (*location)(struct bt_conn *conn, enum bt_audio_dir dir, enum bt_audio_location loc);

        void (*supported_contexts)(struct bt_conn *conn, enum bt_audio_context snk_ctx,
                                   enum bt_audio_context src_ctx);

        void (*available_contexts)(struct bt_conn *conn, enum bt_audio_context snk_ctx,
                                   enum bt_audio_context src_ctx);

        void (*config)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                       enum bt_bap_ascs_reason reason);

        void (*qos)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                    enum bt_bap_ascs_reason reason);

        void (*enable)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                       enum bt_bap_ascs_reason reason);

        void (*start)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                      enum bt_bap_ascs_reason reason);

        void (*stop)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                     enum bt_bap_ascs_reason reason);

        void (*disable)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                        enum bt_bap_ascs_reason reason);

        void (*metadata)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                         enum bt_bap_ascs_reason reason);

        void (*release)(struct bt_bap_stream *stream, enum bt_bap_ascs_rsp_code rsp_code,
                        enum bt_bap_ascs_reason reason);

        void (*pac_record)(struct bt_conn *conn, enum bt_audio_dir dir,
                           const struct bt_audio_codec_cap *codec_cap);

        void (*endpoint)(struct bt_conn *conn, enum bt_audio_dir dir, struct bt_bap_ep *ep);

        void (*discover)(struct bt_conn *conn, int err, enum bt_audio_dir dir);

        sys_snode_t _node;
};

int bt_bap_unicast_client_register_cb(struct bt_bap_unicast_client_cb *cb);

int bt_bap_unicast_client_unregister_cb(struct bt_bap_unicast_client_cb *cb);

int bt_bap_unicast_client_discover(struct bt_conn *conn, enum bt_audio_dir dir);
 /* End of group bt_bap_unicast_client */

struct bt_bap_base_subgroup;
struct bt_bap_base;

struct bt_bap_base_codec_id {
        uint8_t id;
        uint16_t cid;
        uint16_t vid;
};

struct bt_bap_base_subgroup_bis {
        uint8_t index;
        uint8_t data_len;
        uint8_t *data;
};

const struct bt_bap_base *bt_bap_base_get_base_from_ad(const struct bt_data *ad);

int bt_bap_base_get_size(const struct bt_bap_base *base);

int bt_bap_base_get_pres_delay(const struct bt_bap_base *base);

int bt_bap_base_get_subgroup_count(const struct bt_bap_base *base);

int bt_bap_base_get_bis_indexes(const struct bt_bap_base *base, uint32_t *bis_indexes);

int bt_bap_base_foreach_subgroup(const struct bt_bap_base *base,
                                 bool (*func)(const struct bt_bap_base_subgroup *subgroup,
                                              void *user_data),
                                 void *user_data);

int bt_bap_base_get_subgroup_codec_id(const struct bt_bap_base_subgroup *subgroup,
                                      struct bt_bap_base_codec_id *codec_id);

int bt_bap_base_get_subgroup_codec_data(const struct bt_bap_base_subgroup *subgroup,
                                        uint8_t **data);

int bt_bap_base_get_subgroup_codec_meta(const struct bt_bap_base_subgroup *subgroup,
                                        uint8_t **meta);

int bt_bap_base_subgroup_codec_to_codec_cfg(const struct bt_bap_base_subgroup *subgroup,
                                            struct bt_audio_codec_cfg *codec_cfg);

int bt_bap_base_get_subgroup_bis_count(const struct bt_bap_base_subgroup *subgroup);

int bt_bap_base_subgroup_get_bis_indexes(const struct bt_bap_base_subgroup *subgroup,
                                         uint32_t *bis_indexes);

int bt_bap_base_subgroup_foreach_bis(const struct bt_bap_base_subgroup *subgroup,
                                     bool (*func)(const struct bt_bap_base_subgroup_bis *bis,
                                                  void *user_data),
                                     void *user_data);

int bt_bap_base_subgroup_bis_codec_to_codec_cfg(const struct bt_bap_base_subgroup_bis *bis,
                                                struct bt_audio_codec_cfg *codec_cfg);
 /* End of group bt_bap_broadcast */


struct bt_bap_broadcast_source_cb {
        void (*started)(struct bt_bap_broadcast_source *source);

        void (*stopped)(struct bt_bap_broadcast_source *source, uint8_t reason);

        sys_snode_t _node;
};

int bt_bap_broadcast_source_register_cb(struct bt_bap_broadcast_source_cb *cb);

int bt_bap_broadcast_source_unregister_cb(struct bt_bap_broadcast_source_cb *cb);

struct bt_bap_broadcast_source_stream_param {
        struct bt_bap_stream *stream;
 
#if CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 || defined(__DOXYGEN__)
        size_t data_len;

        const uint8_t *data;
#endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 */
};

struct bt_bap_broadcast_source_subgroup_param {
        size_t params_count;

        struct bt_bap_broadcast_source_stream_param *params;

        const struct bt_audio_codec_cfg *codec_cfg;
};

struct bt_bap_broadcast_source_param {
        size_t params_count;

        struct bt_bap_broadcast_source_subgroup_param *params;

        const 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_bap_broadcast_source_create(struct bt_bap_broadcast_source_param *param,
                                   struct bt_bap_broadcast_source **source);

int bt_bap_broadcast_source_reconfig(struct bt_bap_broadcast_source *source,
                                     struct bt_bap_broadcast_source_param *param);

int bt_bap_broadcast_source_update_metadata(struct bt_bap_broadcast_source *source,
                                            const uint8_t meta[], size_t meta_len);

int bt_bap_broadcast_source_start(struct bt_bap_broadcast_source *source,
                                  struct bt_le_ext_adv *adv);

int bt_bap_broadcast_source_stop(struct bt_bap_broadcast_source *source);

int bt_bap_broadcast_source_delete(struct bt_bap_broadcast_source *source);

int bt_bap_broadcast_source_get_base(struct bt_bap_broadcast_source *source,
                                     struct net_buf_simple *base_buf);

typedef bool (*bt_bap_broadcast_source_foreach_stream_func_t)(struct bt_bap_stream *stream,
                                                              void *user_data);

int bt_bap_broadcast_source_foreach_stream(struct bt_bap_broadcast_source *source,
                                           bt_bap_broadcast_source_foreach_stream_func_t func,
                                           void *user_data); /* End of bt_bap_broadcast_source */


struct bt_bap_broadcast_sink_cb {
        void (*base_recv)(struct bt_bap_broadcast_sink *sink, const struct bt_bap_base *base,
                          size_t base_size);

        void (*syncable)(struct bt_bap_broadcast_sink *sink, const struct bt_iso_biginfo *biginfo);

        void (*started)(struct bt_bap_broadcast_sink *sink);

        void (*stopped)(struct bt_bap_broadcast_sink *sink, uint8_t reason);

        sys_snode_t _node;
};

int bt_bap_broadcast_sink_register_cb(struct bt_bap_broadcast_sink_cb *cb);

int bt_bap_broadcast_sink_create(struct bt_le_per_adv_sync *pa_sync, uint32_t broadcast_id,
                                 struct bt_bap_broadcast_sink **sink);

int bt_bap_broadcast_sink_sync(struct bt_bap_broadcast_sink *sink, uint32_t indexes_bitfield,
                               struct bt_bap_stream *streams[],
                               const uint8_t broadcast_code[BT_ISO_BROADCAST_CODE_SIZE]);

int bt_bap_broadcast_sink_stop(struct bt_bap_broadcast_sink *sink);

int bt_bap_broadcast_sink_delete(struct bt_bap_broadcast_sink *sink);
 /* End of group bt_bap_broadcast_sink */

int bt_bap_scan_delegator_register(struct bt_bap_scan_delegator_cb *cb);

int bt_bap_scan_delegator_unregister(void);

int bt_bap_scan_delegator_set_pa_state(uint8_t src_id,
                                       enum bt_bap_pa_state pa_state);

int bt_bap_scan_delegator_set_bis_sync_state(uint8_t src_id,
                                             uint32_t bis_synced[BT_BAP_BASS_MAX_SUBGROUPS]);

struct bt_bap_scan_delegator_add_src_param {
        bt_addr_le_t addr;

        uint8_t sid;

        enum bt_bap_pa_state pa_state;

        enum bt_bap_big_enc_state encrypt_state;

        uint32_t broadcast_id;

        uint8_t num_subgroups;

        struct bt_bap_bass_subgroup subgroups[BT_BAP_BASS_MAX_SUBGROUPS];
};

int bt_bap_scan_delegator_add_src(const struct bt_bap_scan_delegator_add_src_param *param);

struct bt_bap_scan_delegator_mod_src_param {
        uint8_t src_id;

        enum bt_bap_big_enc_state encrypt_state;

        uint32_t broadcast_id;

        uint8_t num_subgroups;

        struct bt_bap_bass_subgroup subgroups[BT_BAP_BASS_MAX_SUBGROUPS];
};

int bt_bap_scan_delegator_mod_src(const struct bt_bap_scan_delegator_mod_src_param *param);

int bt_bap_scan_delegator_rem_src(uint8_t src_id);

typedef bool (*bt_bap_scan_delegator_state_func_t)(
        const struct bt_bap_scan_delegator_recv_state *recv_state, void *user_data);

void bt_bap_scan_delegator_foreach_state(bt_bap_scan_delegator_state_func_t func,
                                         void *user_data);

const struct bt_bap_scan_delegator_recv_state *bt_bap_scan_delegator_find_state(
        bt_bap_scan_delegator_state_func_t func, void *user_data);
 
/******************************** CLIENT API ********************************/

typedef void (*bt_bap_broadcast_assistant_write_cb)(struct bt_conn *conn,
                                                    int err);

struct bt_bap_broadcast_assistant_cb {
        void (*discover)(struct bt_conn *conn, int err,
                         uint8_t recv_state_count);

        void (*scan)(const struct bt_le_scan_recv_info *info,
                     uint32_t broadcast_id);

        void (*recv_state)(struct bt_conn *conn, int err,
                           const struct bt_bap_scan_delegator_recv_state *state);

        void (*recv_state_removed)(struct bt_conn *conn, uint8_t src_id);

        void (*scan_start)(struct bt_conn *conn, int err);

        void (*scan_stop)(struct bt_conn *conn, int err);

        void (*add_src)(struct bt_conn *conn, int err);

        void (*mod_src)(struct bt_conn *conn, int err);

        void (*broadcast_code)(struct bt_conn *conn, int err);

        void (*rem_src)(struct bt_conn *conn, int err);

        sys_snode_t _node;
};

int bt_bap_broadcast_assistant_discover(struct bt_conn *conn);

int bt_bap_broadcast_assistant_scan_start(struct bt_conn *conn,
                                          bool start_scan);

int bt_bap_broadcast_assistant_scan_stop(struct bt_conn *conn);

int bt_bap_broadcast_assistant_register_cb(struct bt_bap_broadcast_assistant_cb *cb);

int bt_bap_broadcast_assistant_unregister_cb(struct bt_bap_broadcast_assistant_cb *cb);
 

struct bt_bap_broadcast_assistant_add_src_param {
        bt_addr_le_t addr;

        uint8_t adv_sid;

        bool pa_sync;

        uint32_t broadcast_id;

        uint16_t pa_interval;

        uint8_t num_subgroups;

        struct bt_bap_bass_subgroup *subgroups;
};

int bt_bap_broadcast_assistant_add_src(
        struct bt_conn *conn, const struct bt_bap_broadcast_assistant_add_src_param *param);

struct bt_bap_broadcast_assistant_mod_src_param {
        uint8_t src_id;

        bool pa_sync;

        uint16_t pa_interval;

        uint8_t num_subgroups;

        struct bt_bap_bass_subgroup *subgroups;
};

int bt_bap_broadcast_assistant_mod_src(
        struct bt_conn *conn, const struct bt_bap_broadcast_assistant_mod_src_param *param);

int bt_bap_broadcast_assistant_set_broadcast_code(
        struct bt_conn *conn, uint8_t src_id,
        const uint8_t broadcast_code[BT_ISO_BROADCAST_CODE_SIZE]);

int bt_bap_broadcast_assistant_rem_src(struct bt_conn *conn, uint8_t src_id);

int bt_bap_broadcast_assistant_read_recv_state(struct bt_conn *conn, uint8_t idx);
 /* end of bt_bap */
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_BAP_ */