a2dp.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2015-2016 Intel Corporation
 * Copyright 2024 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_CLASSIC_A2DP_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_CLASSIC_A2DP_H_

 
#include <stdint.h>
 
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/l2cap.h>
#include <zephyr/bluetooth/classic/avdtp.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define BT_A2DP_SBC_IE_LENGTH      (4U)
#define BT_A2DP_MPEG_1_2_IE_LENGTH (4U)
#define BT_A2DP_MPEG_2_4_IE_LENGTH (6U)
#define BT_A2DP_MAX_IE_LENGTH      (8U)

#define BT_A2DP_EP_INIT(_role, _codec, _capability, _delay_report)                                 \
        {                                                                                          \
                .codec_type = _codec,                                                              \
                .sep = {.sep_info = {.media_type = BT_AVDTP_AUDIO, .tsep = _role}},                \
                .codec_cap = _capability, .stream = NULL,                                          \
                .delay_report = _delay_report,                                                     \
        }

#define BT_A2DP_SINK_EP_INIT(_codec, _capability, _delay_report)                                   \
        BT_A2DP_EP_INIT(BT_AVDTP_SINK, _codec, _capability, _delay_report)

#define BT_A2DP_SOURCE_EP_INIT(_codec, _capability, _delay_report)                                 \
        BT_A2DP_EP_INIT(BT_AVDTP_SOURCE, _codec, _capability, _delay_report)

#define BT_A2DP_SBC_SINK_EP(_name, _freq, _ch_mode, _blk_len, _subband, _alloc_mthd, _min_bitpool, \
                            _max_bitpool, _delay_report)                                           \
        static struct bt_a2dp_codec_ie bt_a2dp_ep_cap_ie##_name = {                                \
                .len = BT_A2DP_SBC_IE_LENGTH,                                                      \
                .codec_ie = {_freq | _ch_mode, _blk_len | _subband | _alloc_mthd, _min_bitpool,    \
                             _max_bitpool}};                                                       \
        static struct bt_a2dp_ep _name =                                                           \
                BT_A2DP_SINK_EP_INIT(BT_A2DP_SBC, (&bt_a2dp_ep_cap_ie##_name), _delay_report)

#define BT_A2DP_SBC_SOURCE_EP(_name, _freq, _ch_mode, _blk_len, _subband, _alloc_mthd,             \
                              _min_bitpool, _max_bitpool, _delay_report)                           \
        static struct bt_a2dp_codec_ie bt_a2dp_ep_cap_ie##_name = {                                \
                .len = BT_A2DP_SBC_IE_LENGTH,                                                      \
                .codec_ie = {_freq | _ch_mode, _blk_len | _subband | _alloc_mthd, _min_bitpool,    \
                             _max_bitpool}};                                                       \
        static struct bt_a2dp_ep _name =                                                           \
                BT_A2DP_SOURCE_EP_INIT(BT_A2DP_SBC, &bt_a2dp_ep_cap_ie##_name, _delay_report)

#define BT_A2DP_SBC_SINK_EP_DEFAULT(_name)                                                         \
        static struct bt_a2dp_codec_ie bt_a2dp_ep_cap_ie##_name = {                                \
                .len = BT_A2DP_SBC_IE_LENGTH,                                                      \
                .codec_ie = {A2DP_SBC_SAMP_FREQ_44100 | A2DP_SBC_SAMP_FREQ_48000 |                 \
                                     A2DP_SBC_CH_MODE_MONO | A2DP_SBC_CH_MODE_STEREO |             \
                                     A2DP_SBC_CH_MODE_JOINT,                                       \
                             A2DP_SBC_BLK_LEN_16 | A2DP_SBC_SUBBAND_8 |                            \
                                     A2DP_SBC_ALLOC_MTHD_LOUDNESS,                                 \
                             18U, 35U}};                                                           \
        static struct bt_a2dp_ep _name =                                                           \
                BT_A2DP_SINK_EP_INIT(BT_A2DP_SBC, &bt_a2dp_ep_cap_ie##_name, true)

#define BT_A2DP_SBC_SOURCE_EP_DEFAULT(_name)                                                       \
        static struct bt_a2dp_codec_ie bt_a2dp_ep_cap_ie##_name = {                                \
                .len = BT_A2DP_SBC_IE_LENGTH,                                                      \
                .codec_ie = {A2DP_SBC_SAMP_FREQ_44100 | A2DP_SBC_SAMP_FREQ_48000 |                 \
                                     A2DP_SBC_CH_MODE_MONO | A2DP_SBC_CH_MODE_STEREO |             \
                                     A2DP_SBC_CH_MODE_JOINT,                                       \
                             A2DP_SBC_BLK_LEN_16 | A2DP_SBC_SUBBAND_8 |                            \
                                     A2DP_SBC_ALLOC_MTHD_LOUDNESS,                                 \
                             18U, 35U},                                                            \
        };                                                                                         \
        static struct bt_a2dp_ep _name =                                                           \
                BT_A2DP_SOURCE_EP_INIT(BT_A2DP_SBC, &bt_a2dp_ep_cap_ie##_name, false)

#define BT_A2DP_SBC_EP_CFG(_name, _freq_cfg, _ch_mode_cfg, _blk_len_cfg, _subband_cfg,             \
                           _alloc_mthd_cfg, _min_bitpool_cfg, _max_bitpool_cfg)                    \
        static struct bt_a2dp_codec_ie bt_a2dp_codec_ie##_name = {                                 \
                .len = BT_A2DP_SBC_IE_LENGTH,                                                      \
                .codec_ie = {_freq_cfg | _ch_mode_cfg,                                             \
                             _blk_len_cfg | _subband_cfg | _alloc_mthd_cfg, _min_bitpool_cfg,      \
                             _max_bitpool_cfg},                                                    \
        };                                                                                         \
        struct bt_a2dp_codec_cfg _name = {                                                         \
                .codec_config = &bt_a2dp_codec_ie##_name,                                          \
        }

#define BT_A2DP_SBC_EP_CFG_DEFAULT(_name, _freq_cfg)                                               \
        static struct bt_a2dp_codec_ie bt_a2dp_codec_ie##_name = {                                 \
                .len = BT_A2DP_SBC_IE_LENGTH,                                                      \
                .codec_ie = {_freq_cfg | A2DP_SBC_CH_MODE_JOINT,                                   \
                             A2DP_SBC_BLK_LEN_16 | A2DP_SBC_SUBBAND_8 |                            \
                                     A2DP_SBC_ALLOC_MTHD_LOUDNESS,                                 \
                             18U, 35U},                                                            \
        };                                                                                         \
        struct bt_a2dp_codec_cfg _name = {                                                         \
                .codec_config = &bt_a2dp_codec_ie##_name,                                          \
        }

enum bt_a2dp_err_code {
        BT_A2DP_INVALID_CODEC_TYPE = 0xC1,
        BT_A2DP_NOT_SUPPORTED_CODEC_TYPE = 0xC2,
        BT_A2DP_INVALID_SAMPLING_FREQUENCY = 0xC3,
        BT_A2DP_NOT_SUPPORTED_SAMPLING_FREQUENCY = 0xC4,
        BT_A2DP_INVALID_CHANNEL_MODE = 0xC5,
        BT_A2DP_NOT_SUPPORTED_CHANNEL_MODE = 0xC6,
        BT_A2DP_INVALID_SUBBANDS = 0xC7,
        BT_A2DP_NOT_SUPPORTED_SUBBANDS = 0xC8,
        BT_A2DP_INVALID_ALLOCATION_METHOD = 0xC9,
        BT_A2DP_NOT_SUPPORTED_ALLOCATION_METHOD = 0xCA,
        BT_A2DP_INVALID_MINIMUM_BITPOOL_VALUE = 0xCB,
        BT_A2DP_NOT_SUPPORTED_MINIMUM_BITPOOL_VALUE = 0xCC,
        BT_A2DP_INVALID_MAXIMUM_BITPOOL_VALUE = 0xCD,
        BT_A2DP_NOT_SUPPORTED_MAXIMUM_BITPOOL_VALUE = 0xCE,
        BT_A2DP_INVALID_LAYER = 0xCF,
        BT_A2DP_NOT_SUPPORTED_LAYER = 0xD0,
        BT_A2DP_NOT_SUPPORTED_CRC = 0xD1,
        BT_A2DP_NOT_SUPPORTED_MPF = 0xD2,
        BT_A2DP_NOT_SUPPORTED_VBR = 0xD3,
        BT_A2DP_INVALID_BIT_RATE = 0xD4,
        BT_A2DP_NOT_SUPPORTED_BIT_RATE = 0xD5,
        BT_A2DP_INVALID_OBJECT_TYPE = 0xD6,
        BT_A2DP_NOT_SUPPORTED_OBJECT_TYPE = 0xD7,
        BT_A2DP_INVALID_CHANNELS = 0xD8,
        BT_A2DP_NOT_SUPPORTED_CHANNELS = 0xD9,
        BT_A2DP_INVALID_VERSION = 0xDA,
        BT_A2DP_NOT_SUPPORTED_VERSION = 0xDB,
        BT_A2DP_NOT_SUPPORTED_MAXIMUM_SUL = 0xDC,
        BT_A2DP_INVALID_BLOCK_LENGTH = 0xDD,
        BT_A2DP_INVALID_CP_TYPE = 0xE0,
        BT_A2DP_INVALID_CP_FORMAT = 0xE1,
        BT_A2DP_INVALID_CODEC_PARAMETER = 0xE2,
        BT_A2DP_NOT_SUPPORTED_CODEC_PARAMETER = 0xE3,
        BT_A2DP_INVALID_DRC = 0xE4,
        BT_A2DP_NOT_SUPPORTED_DRC = 0xE5,
};

enum bt_a2dp_codec_type {
        BT_A2DP_SBC = 0x00,
        BT_A2DP_MPEG1 = 0x01,
        BT_A2DP_MPEG2 = 0x02,
        BT_A2DP_MPEGD = 0x03,
        BT_A2DP_ATRAC = 0x04,
        BT_A2DP_VENDOR = 0xff
};

struct bt_a2dp;
 
/* Internal to pass build */
struct bt_a2dp_stream;

struct bt_a2dp_codec_ie {
        uint8_t len;
        uint8_t codec_ie[BT_A2DP_MAX_IE_LENGTH];
};

struct bt_a2dp_codec_cfg {
        bool delay_report;
        struct bt_a2dp_codec_ie *codec_config;
};

struct bt_a2dp_ep {
        uint8_t codec_type;
        bool delay_report;
        struct bt_a2dp_codec_ie *codec_cap;
        struct bt_avdtp_sep sep;
        /* Internally used stream object pointer */
        struct bt_a2dp_stream *stream;
};
 
struct bt_a2dp_ep_info {
        uint8_t codec_type;
        bool delay_report;
        struct bt_a2dp_codec_ie codec_cap;
        struct bt_avdtp_sep_info *sep_info;
};

enum {
        BT_A2DP_DISCOVER_EP_STOP = 0,
        BT_A2DP_DISCOVER_EP_CONTINUE,
};

typedef uint8_t (*bt_a2dp_discover_ep_cb)(struct bt_a2dp *a2dp, struct bt_a2dp_ep_info *info,
                                          struct bt_a2dp_ep **ep);
 
struct bt_a2dp_discover_param {
        bt_a2dp_discover_ep_cb cb;
        struct bt_a2dp_ep_info info;
        struct bt_avdtp_sep_info *seps_info;
        uint16_t avdtp_version;
        uint8_t sep_count;
};

struct bt_a2dp_cb {
        void (*connected)(struct bt_a2dp *a2dp, int err);
        void (*disconnected)(struct bt_a2dp *a2dp);
        int (*config_req)(struct bt_a2dp *a2dp, struct bt_a2dp_ep *ep,
                          struct bt_a2dp_codec_cfg *codec_cfg, struct bt_a2dp_stream **stream,
                          uint8_t *rsp_err_code);
        int (*reconfig_req)(struct bt_a2dp_stream *stream, struct bt_a2dp_codec_cfg *codec_cfg,
                            uint8_t *rsp_err_code);
        void (*config_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
        int (*establish_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*establish_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
        int (*release_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*release_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
        int (*start_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*start_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
        int (*suspend_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*suspend_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
        int (*abort_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*abort_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
        int (*get_config_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*get_config_rsp)(struct bt_a2dp_stream *stream, struct bt_a2dp_codec_cfg *codec_cfg,
                               uint8_t rsp_err_code);
#ifdef CONFIG_BT_A2DP_SOURCE
        int (*delay_report_req)(struct bt_a2dp_stream *stream, uint16_t value,
                                uint8_t *rsp_err_code);
#endif
#ifdef CONFIG_BT_A2DP_SINK
        void (*delay_report_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
#endif
};

struct bt_a2dp *bt_a2dp_connect(struct bt_conn *conn);

int bt_a2dp_disconnect(struct bt_a2dp *a2dp);

int bt_a2dp_register_ep(struct bt_a2dp_ep *ep, uint8_t media_type, uint8_t sep_type);

int bt_a2dp_register_cb(struct bt_a2dp_cb *cb);

struct bt_conn *bt_a2dp_get_conn(struct bt_a2dp *a2dp);

int bt_a2dp_discover(struct bt_a2dp *a2dp, struct bt_a2dp_discover_param *param);

struct bt_a2dp_stream {
        struct bt_a2dp_ep *local_ep;
        struct bt_a2dp_ep *remote_ep;
        uint8_t remote_ep_id;
        bool delay_report;
        struct bt_a2dp_stream_ops *ops;
        struct bt_a2dp *a2dp;
        struct bt_a2dp_codec_ie codec_config;
};

struct bt_a2dp_stream_ops {
        void (*configured)(struct bt_a2dp_stream *stream);
        void (*established)(struct bt_a2dp_stream *stream);
        void (*released)(struct bt_a2dp_stream *stream);
        void (*started)(struct bt_a2dp_stream *stream);
        void (*suspended)(struct bt_a2dp_stream *stream);
#if defined(CONFIG_BT_A2DP_SINK) || defined(__DOXYGEN__)
        void (*recv)(struct bt_a2dp_stream *stream, struct net_buf *buf, uint16_t seq_num,
                     uint32_t ts);
#endif /* CONFIG_BT_A2DP_SINK */
#if defined(CONFIG_BT_A2DP_SOURCE) || defined(__DOXYGEN__)
        void (*sent)(struct bt_a2dp_stream *stream);
        void (*delay_report)(struct bt_a2dp_stream *stream, uint16_t value);
#endif /* CONFIG_BT_A2DP_SOURCE */
};

void bt_a2dp_stream_cb_register(struct bt_a2dp_stream *stream, struct bt_a2dp_stream_ops *ops);

int bt_a2dp_stream_config(struct bt_a2dp *a2dp, struct bt_a2dp_stream *stream,
                          struct bt_a2dp_ep *local_ep, struct bt_a2dp_ep *remote_ep,
                          struct bt_a2dp_codec_cfg *config);

int bt_a2dp_stream_get_config(struct bt_a2dp_stream *stream);

int bt_a2dp_stream_establish(struct bt_a2dp_stream *stream);

int bt_a2dp_stream_release(struct bt_a2dp_stream *stream);

int bt_a2dp_stream_start(struct bt_a2dp_stream *stream);

int bt_a2dp_stream_suspend(struct bt_a2dp_stream *stream);

int bt_a2dp_stream_reconfig(struct bt_a2dp_stream *stream, struct bt_a2dp_codec_cfg *config);

int bt_a2dp_stream_abort(struct bt_a2dp_stream *stream);

uint32_t bt_a2dp_get_mtu(struct bt_a2dp_stream *stream);

int bt_a2dp_stream_send(struct bt_a2dp_stream *stream, struct net_buf *buf, uint16_t seq_num,
                        uint32_t ts);

struct net_buf *bt_a2dp_stream_create_pdu(struct net_buf_pool *pool, k_timeout_t timeout);

int bt_a2dp_stream_delay_report(struct bt_a2dp_stream *stream, uint16_t delay);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_CLASSIC_A2DP_H_ */