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_A2DP_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_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_STREAM_BUF_RESERVE (12u + BT_L2CAP_BUF_SIZE(0))
 
#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 A2DP_MAX_IE_LENGTH (8U)
 
#define BT_A2DP_EP_INIT(_role, _codec, _capability)\
{\
        .codec_type = _codec,\
        .sep = {.sep_info = {.media_type = BT_AVDTP_AUDIO, .tsep = _role}},\
        .codec_cap = _capability,\
        .stream = NULL,\
}
 
#define BT_A2DP_SINK_EP_INIT(_codec, _capability)\
BT_A2DP_EP_INIT(BT_AVDTP_SINK, _codec, _capability)
 
#define BT_A2DP_SOURCE_EP_INIT(_codec, _capability)\
BT_A2DP_EP_INIT(BT_AVDTP_SOURCE, _codec, _capability)
 
#define BT_A2DP_SBC_SINK_EP(_name, _freq, _ch_mode, _blk_len, _subband,\
_alloc_mthd, _min_bitpool, _max_bitpool)\
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))
 
#define BT_A2DP_SBC_SOURCE_EP(_name, _freq, _ch_mode, _blk_len, _subband,\
_alloc_mthd, _min_bitpool, _max_bitpool)\
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)
 
#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_STREO |\
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)
 
#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_STREO | \
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)
 
#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_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[A2DP_MAX_IE_LENGTH];
};
 
struct bt_a2dp_codec_cfg {
        struct bt_a2dp_codec_ie *codec_config;
};
 
struct bt_a2dp_ep {
        uint8_t codec_type;
        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;
        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;
        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);
        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 (*reconfig_req)(struct bt_a2dp_stream *stream, uint8_t *rsp_err_code);
        void (*reconfig_rsp)(struct bt_a2dp_stream *stream, uint8_t rsp_err_code);
};
 
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 role);
 
int bt_a2dp_register_cb(struct bt_a2dp_cb *cb);
 
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;
        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);
        void (*reconfigured)(struct bt_a2dp_stream *stream);
#if defined(CONFIG_BT_A2DP_SINK)
        void (*recv)(struct bt_a2dp_stream *stream,
                struct net_buf *buf, uint16_t seq_num, uint32_t ts);
#endif
#if defined(CONFIG_BT_A2DP_SOURCE)
        void (*sent)(struct bt_a2dp_stream *stream);
#endif
};
 
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_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);
 
uint32_t bt_a2dp_get_mtu(struct bt_a2dp_stream *stream);
 
#if defined(CONFIG_BT_A2DP_SOURCE)
int bt_a2dp_stream_send(struct bt_a2dp_stream *stream,  struct net_buf *buf,
                        uint16_t seq_num, uint32_t ts);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_A2DP_H_ */