michaelh/zephyr
1
0
Fork 0
Code Releases Activity

Bluetooth: Audio: Remove LC3 from the assigned numbers defines

Browse source 
The defines from the Bluetooth Audio assigned numbers are not
specific for LC3. This commit removes the LC3 infix and
the reference to LC3 in the documentation for them.

It also cleans up some of the documentation and
names of the enums.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
This commit is contained in:
Emil Gydesen 2023-12-27 13:44:50 +01:00 • committed by David Leach
commit cbc81b2a0f
29 changed files with 453 additions and 524 deletions
Download patch file Download diff file Expand all files Collapse all files

30
include/zephyr/bluetooth/audio/audio.h
View file

@ -615,7 +615,7 @@ struct bt_audio_codec_qos_pref {
* @retval -EINVAL if arguments are invalid.
* @retval The converted frequency value in Hz.
*/
int bt_audio_codec_cfg_freq_to_freq_hz(enum bt_audio_codec_config_freq freq);
int bt_audio_codec_cfg_freq_to_freq_hz(enum bt_audio_codec_cfg_freq freq);
/**
* @brief Convert frequency value to assigned numbers frequency.
@ -623,7 +623,7 @@ int bt_audio_codec_cfg_freq_to_freq_hz(enum bt_audio_codec_config_freq freq);
* @param freq_hz The frequency value to convert.
*
* @retval -EINVAL if arguments are invalid.
* @retval The assigned numbers frequency (@ref bt_audio_codec_config_freq).
* @retval The assigned numbers frequency (@ref bt_audio_codec_cfg_freq).
*/
int bt_audio_codec_cfg_freq_hz_to_freq(uint32_t freq_hz);
@ -631,7 +631,7 @@ int bt_audio_codec_cfg_freq_hz_to_freq(uint32_t freq_hz);
*
* @param codec_cfg The codec configuration to extract data from.
*
* @retval A @ref bt_audio_codec_config_freq value
* @retval A @ref bt_audio_codec_cfg_freq value
* @retval -EINVAL if arguments are invalid
* @retval -ENODATA if not found
* @retval -EBADMSG if found value has invalid size or value
@ -649,7 +649,7 @@ int bt_audio_codec_cfg_get_freq(const struct bt_audio_codec_cfg *codec_cfg);
* @retval -ENOMEM if the new value could not set or added due to memory
*/
int bt_audio_codec_cfg_set_freq(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_freq freq);
enum bt_audio_codec_cfg_freq freq);
/**
* @brief Convert assigned numbers frame duration to duration in microseconds.
@ -659,7 +659,7 @@ int bt_audio_codec_cfg_set_freq(struct bt_audio_codec_cfg *codec_cfg,
* @retval -EINVAL if arguments are invalid.
* @retval The converted frame duration value in microseconds.
*/
int bt_audio_codec_cfg_frame_dur_to_frame_dur_us(enum bt_audio_codec_config_frame_dur frame_dur);
int bt_audio_codec_cfg_frame_dur_to_frame_dur_us(enum bt_audio_codec_cfg_frame_dur frame_dur);
/**
* @brief Convert frame duration in microseconds to assigned numbers frame duration.
@ -667,7 +667,7 @@ int bt_audio_codec_cfg_frame_dur_to_frame_dur_us(enum bt_audio_codec_config_fram
* @param frame_dur_us The frame duration in microseconds to convert.
*
* @retval -EINVAL if arguments are invalid.
* @retval The assigned numbers frame duration (@ref bt_audio_codec_config_frame_dur).
* @retval The assigned numbers frame duration (@ref bt_audio_codec_cfg_frame_dur).
*/
int bt_audio_codec_cfg_frame_dur_us_to_frame_dur(uint32_t frame_dur_us);
@ -675,7 +675,7 @@ int bt_audio_codec_cfg_frame_dur_us_to_frame_dur(uint32_t frame_dur_us);
*
* @param codec_cfg The codec configuration to extract data from.
*
* @retval A @ref bt_audio_codec_config_frame_dur value
* @retval A @ref bt_audio_codec_cfg_frame_dur value
* @retval -EINVAL if arguments are invalid
* @retval -ENODATA if not found
* @retval -EBADMSG if found value has invalid size or value
@ -693,7 +693,7 @@ int bt_audio_codec_cfg_get_frame_dur(const struct bt_audio_codec_cfg *codec_cfg)
* @retval -ENOMEM if the new value could not set or added due to memory
*/
int bt_audio_codec_cfg_set_frame_dur(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_frame_dur frame_dur);
enum bt_audio_codec_cfg_frame_dur frame_dur);
/** @brief Extract channel allocation from BT codec config
*
@ -701,7 +701,7 @@ int bt_audio_codec_cfg_set_frame_dur(struct bt_audio_codec_cfg *codec_cfg,
* specified by @ref bt_audio_location
* Shall match one or more of the bits set in BT_PAC_SNK_LOC/BT_PAC_SRC_LOC.
*
* Up to the configured @ref BT_AUDIO_CODEC_LC3_CHAN_COUNT number of channels can be present.
* Up to the configured @ref BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT number of channels can be present.
*
* @param codec_cfg The codec configuration to extract data from.
* @param chan_allocation Pointer to the variable to store the extracted value in.
@ -808,7 +808,7 @@ int bt_audio_codec_cfg_set_frame_blocks_per_sdu(struct bt_audio_codec_cfg *codec
* @retval -ENODATA if not found
*/
int bt_audio_codec_cfg_get_val(const struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_type type, const uint8_t **data);
enum bt_audio_codec_cfg_type type, const uint8_t **data);
/**
* @brief Set or add a specific codec configuration value
@ -823,7 +823,7 @@ int bt_audio_codec_cfg_get_val(const struct bt_audio_codec_cfg *codec_cfg,
* @retval -ENOMEM if the new value could not set or added due to memory
*/
int bt_audio_codec_cfg_set_val(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_type type, const uint8_t *data,
enum bt_audio_codec_cfg_type type, const uint8_t *data,
size_t data_len);
/**
@ -838,7 +838,7 @@ int bt_audio_codec_cfg_set_val(struct bt_audio_codec_cfg *codec_cfg,
* @retval -EINVAL if arguments are invalid
*/
int bt_audio_codec_cfg_unset_val(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_type type);
enum bt_audio_codec_cfg_type type);
/** @brief Lookup a specific metadata value based on type
*
@ -1202,7 +1202,7 @@ int bt_audio_codec_cfg_meta_set_vendor(struct bt_audio_codec_cfg *codec_cfg,
* @retval -ENODATA if not found
*/
int bt_audio_codec_cap_get_val(const struct bt_audio_codec_cap *codec_cap,
enum bt_audio_codec_capability_type type, const uint8_t **data);
enum bt_audio_codec_cap_type type, const uint8_t **data);
/**
* @brief Set or add a specific codec capability value
@ -1217,7 +1217,7 @@ int bt_audio_codec_cap_get_val(const struct bt_audio_codec_cap *codec_cap,
* @retval -ENOMEM if the new value could not set or added due to memory
*/
int bt_audio_codec_cap_set_val(struct bt_audio_codec_cap *codec_cap,
enum bt_audio_codec_capability_type type, const uint8_t *data,
enum bt_audio_codec_cap_type type, const uint8_t *data,
size_t data_len);
/**
@ -1232,7 +1232,7 @@ int bt_audio_codec_cap_set_val(struct bt_audio_codec_cap *codec_cap,
* @retval -EINVAL if arguments are invalid
*/
int bt_audio_codec_cap_unset_val(struct bt_audio_codec_cap *codec_cap,
enum bt_audio_codec_capability_type type);
enum bt_audio_codec_cap_type type);
/**
* @brief Extract the frequency from a codec capability.

473
include/zephyr/bluetooth/audio/lc3.h
View file

@ -27,191 +27,160 @@ extern "C" {
#endif
/**
* @brief Codec capability type id's
* @brief Codec capability types
*
* Used to build and parse codec capabilities as specified in the PAC specification.
* Source is assigned numbers for Generic Audio, bluetooth.com.
*
* Even though they are in-fixed with LC3 they can be used for other codec types as well.
*/
enum bt_audio_codec_capability_type {
enum bt_audio_codec_cap_type {
/** Supported sampling frequencies */
BT_AUDIO_CODEC_CAP_TYPE_FREQ = 0x01,
/**
* @brief LC3 sample frequency capability type
*/
BT_AUDIO_CODEC_LC3_FREQ = 0x01,
/** Supported frame durations */
BT_AUDIO_CODEC_CAP_TYPE_DURATION = 0x02,
/**
* @brief LC3 frame duration capability type
*/
BT_AUDIO_CODEC_LC3_DURATION = 0x02,
/** Supported audio channel counts */
BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT = 0x03,
/**
* @brief LC3 channel count capability type
*/
BT_AUDIO_CODEC_LC3_CHAN_COUNT = 0x03,
/** Supported octets per codec frame */
BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN = 0x04,
/**
* @brief LC3 frame length capability type
*/
BT_AUDIO_CODEC_LC3_FRAME_LEN = 0x04,
/**
* @brief Max codec frame count per SDU capability type
*/
BT_AUDIO_CODEC_LC3_FRAME_COUNT = 0x05,
/** Supported maximum codec frames per SDU */
BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT = 0x05,
};
/** @brief Supported frequencies bitfield */
enum bt_audio_codec_cap_freq {
/**
* @brief LC3 8 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_8KHZ = BIT(0),
/**
* @brief LC3 11.025 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_11KHZ = BIT(1),
/**
* @brief LC3 16 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_16KHZ = BIT(2),
/**
* @brief LC3 22.05 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_22KHZ = BIT(3),
/**
* @brief LC3 24 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_24KHZ = BIT(4),
/**
* @brief LC3 32 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_32KHZ = BIT(5),
/**
* @brief LC3 44.1 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_44KHZ = BIT(6),
/**
* @brief LC3 48 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_48KHZ = BIT(7),
/**
* @brief LC3 88.2 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_88KHZ = BIT(8),
/**
* @brief LC3 96 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_96KHZ = BIT(9),
/**
* @brief LC3 176.4 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_176KHZ = BIT(10),
/**
* @brief LC3 192 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_192KHZ = BIT(11),
/**
* @brief LC3 384 Khz frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_384KHZ = BIT(12),
/**
* @brief LC3 any frequency capability
*/
BT_AUDIO_CODEC_LC3_FREQ_ANY =
(BT_AUDIO_CODEC_LC3_FREQ_8KHZ | BT_AUDIO_CODEC_LC3_FREQ_11KHZ |
BT_AUDIO_CODEC_LC3_FREQ_16KHZ | BT_AUDIO_CODEC_LC3_FREQ_22KHZ |
BT_AUDIO_CODEC_LC3_FREQ_24KHZ | BT_AUDIO_CODEC_LC3_FREQ_32KHZ |
BT_AUDIO_CODEC_LC3_FREQ_44KHZ | BT_AUDIO_CODEC_LC3_FREQ_48KHZ |
BT_AUDIO_CODEC_LC3_FREQ_88KHZ | BT_AUDIO_CODEC_LC3_FREQ_96KHZ |
BT_AUDIO_CODEC_LC3_FREQ_176KHZ | BT_AUDIO_CODEC_LC3_FREQ_192KHZ |
BT_AUDIO_CODEC_LC3_FREQ_384KHZ),
/** 8 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_8KHZ = BIT(0),
/** 11.025 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_11KHZ = BIT(1),
/** 16 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_16KHZ = BIT(2),
/** 22.05 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_22KHZ = BIT(3),
/** 24 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_24KHZ = BIT(4),
/** 32 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_32KHZ = BIT(5),
/** 44.1 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_44KHZ = BIT(6),
/** 48 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_48KHZ = BIT(7),
/** 88.2 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_88KHZ = BIT(8),
/** 96 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_96KHZ = BIT(9),
/** 176.4 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_176KHZ = BIT(10),
/** 192 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_192KHZ = BIT(11),
/** 384 Khz sampling frequency */
BT_AUDIO_CODEC_CAP_FREQ_384KHZ = BIT(12),
/** Any frequency capability */
BT_AUDIO_CODEC_CAP_FREQ_ANY =
(BT_AUDIO_CODEC_CAP_FREQ_8KHZ | BT_AUDIO_CODEC_CAP_FREQ_11KHZ |
BT_AUDIO_CODEC_CAP_FREQ_16KHZ | BT_AUDIO_CODEC_CAP_FREQ_22KHZ |
BT_AUDIO_CODEC_CAP_FREQ_24KHZ | BT_AUDIO_CODEC_CAP_FREQ_32KHZ |
BT_AUDIO_CODEC_CAP_FREQ_44KHZ | BT_AUDIO_CODEC_CAP_FREQ_48KHZ |
BT_AUDIO_CODEC_CAP_FREQ_88KHZ | BT_AUDIO_CODEC_CAP_FREQ_96KHZ |
BT_AUDIO_CODEC_CAP_FREQ_176KHZ | BT_AUDIO_CODEC_CAP_FREQ_192KHZ |
BT_AUDIO_CODEC_CAP_FREQ_384KHZ),
};
/** @brief Supported frame durations bitfield */
enum bt_audio_codec_cap_frame_dur {
/**
* @brief LC3 7.5 msec frame duration capability
*/
BT_AUDIO_CODEC_LC3_DURATION_7_5 = BIT(0),
/**
* @brief LC3 10 msec frame duration capability
*/
BT_AUDIO_CODEC_LC3_DURATION_10 = BIT(1),
/**
* @brief LC3 any frame duration capability
*/
BT_AUDIO_CODEC_LC3_DURATION_ANY =
(BT_AUDIO_CODEC_LC3_DURATION_7_5 | BT_AUDIO_CODEC_LC3_DURATION_10),
/** 7.5 msec frame duration capability */
BT_AUDIO_CODEC_CAP_DURATION_7_5 = BIT(0),
/** 10 msec frame duration capability */
BT_AUDIO_CODEC_CAP_DURATION_10 = BIT(1),
/** Any frame duration capability */
BT_AUDIO_CODEC_CAP_DURATION_ANY =
(BT_AUDIO_CODEC_CAP_DURATION_7_5 | BT_AUDIO_CODEC_CAP_DURATION_10),
/**
* @brief LC3 7.5 msec preferred frame duration capability.
* @brief 7.5 msec preferred frame duration capability.
*
* This shall only be set if @ref BT_AUDIO_CODEC_LC3_DURATION_7_5 is also set, and if @ref
* BT_AUDIO_CODEC_LC3_DURATION_PREFER_10 is not set.
* This shall only be set if @ref BT_AUDIO_CODEC_CAP_DURATION_7_5 is also set, and if @ref
* BT_AUDIO_CODEC_CAP_DURATION_PREFER_10 is not set.
*/
BT_AUDIO_CODEC_LC3_DURATION_PREFER_7_5 = BIT(4),
BT_AUDIO_CODEC_CAP_DURATION_PREFER_7_5 = BIT(4),
/**
* @brief LC3 10 msec preferred frame duration capability
* @brief 10 msec preferred frame duration capability
*
* This shall only be set if @ref BT_AUDIO_CODEC_LC3_DURATION_10 is also set, and if @ref
* BT_AUDIO_CODEC_LC3_DURATION_PREFER_7_5 is not set.
* This shall only be set if @ref BT_AUDIO_CODEC_CAP_DURATION_10 is also set, and if @ref
* BT_AUDIO_CODEC_CAP_DURATION_PREFER_7_5 is not set.
*/
BT_AUDIO_CODEC_LC3_DURATION_PREFER_10 = BIT(5),
BT_AUDIO_CODEC_CAP_DURATION_PREFER_10 = BIT(5),
};
enum bt_audio_codec_cap_chan_count {
/** Supporting 1 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_1 = BIT(0),
/** Supporting 2 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_2 = BIT(1),
/** Supporting 3 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_3 = BIT(2),
/** Supporting 4 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_4 = BIT(3),
/** Supporting 5 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_5 = BIT(4),
/** Supporting 6 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_6 = BIT(5),
/** Supporting 7 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_7 = BIT(6),
/** Supporting 8 channel */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_8 = BIT(7),
/** Supporting all channels */
BT_AUDIO_CODEC_CAP_CHAN_COUNT_ALL =
BT_AUDIO_CODEC_CAP_CHAN_COUNT_ANY =
(BT_AUDIO_CODEC_CAP_CHAN_COUNT_1 | BT_AUDIO_CODEC_CAP_CHAN_COUNT_2 |
BT_AUDIO_CODEC_CAP_CHAN_COUNT_3 | BT_AUDIO_CODEC_CAP_CHAN_COUNT_4 |
BT_AUDIO_CODEC_CAP_CHAN_COUNT_5 | BT_AUDIO_CODEC_CAP_CHAN_COUNT_6 |
BT_AUDIO_CODEC_CAP_CHAN_COUNT_7 | BT_AUDIO_CODEC_CAP_CHAN_COUNT_8),
};
/** Minimum supported channel counts */
#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_MIN 1
/** Maximum supported channel counts */
#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_MAX 8
/**
* @brief LC3 minimum supported channel counts
*/
#define BT_AUDIO_CODEC_LC3_CHAN_COUNT_MIN 1
/**
* @brief LC3 maximum supported channel counts
*/
#define BT_AUDIO_CODEC_LC3_CHAN_COUNT_MAX 8
/**
* @brief LC3 channel count support capability
* @brief Channel count support capability
*
* Macro accepts variable number of channel counts.
* The allowed channel counts are defined by specification and have to be in range from
* @ref BT_AUDIO_CODEC_LC3_CHAN_COUNT_MIN to @ref BT_AUDIO_CODEC_LC3_CHAN_COUNT_MAX inclusive.
* @ref BT_AUDIO_CODEC_CAP_CHAN_COUNT_MIN to @ref BT_AUDIO_CODEC_CAP_CHAN_COUNT_MAX inclusive.
*
* Example to support 1 and 3 channels:
* BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 3)
* BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 3)
*/
#define BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(...) \
#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(...) \
((enum bt_audio_codec_cap_chan_count)((FOR_EACH(BIT, (|), __VA_ARGS__)) >> 1))
struct BT_AUDIO_CODEC_LC3_frame_len {
uint16_t min;
uint16_t max;
};
struct bt_audio_codec_octets_per_codec_frame {
/** Minimum number of octets supported per codec frame */
uint16_t min;
@ -220,95 +189,75 @@ struct bt_audio_codec_octets_per_codec_frame {
};
/**
* @brief Codec configuration type IDs
* @brief Codec configuration types
*
* Used to build and parse codec configurations as specified in the ASCS and BAP specifications.
* Source is assigned numbers for Generic Audio, bluetooth.com.
*
* Even though they are in-fixed with LC3 they can be used for other codec types as well.
*/
enum bt_audio_codec_config_type {
enum bt_audio_codec_cfg_type {
/** Sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ = 0x01,
/** @brief LC3 Sample Frequency configuration type. */
BT_AUDIO_CODEC_CONFIG_LC3_FREQ = 0x01,
/** Frame duration */
BT_AUDIO_CODEC_CFG_DURATION = 0x02,
/** @brief LC3 Frame Duration configuration type. */
BT_AUDIO_CODEC_CONFIG_LC3_DURATION = 0x02,
/** Audio channel allocation */
BT_AUDIO_CODEC_CFG_CHAN_ALLOC = 0x03,
/** @brief LC3 channel Allocation configuration type. */
BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC = 0x03,
/** Octets per codec frame */
BT_AUDIO_CODEC_CFG_FRAME_LEN = 0x04,
/** @brief LC3 Frame Length configuration type. */
BT_AUDIO_CODEC_CONFIG_LC3_FRAME_LEN = 0x04,
/** @brief Codec frame blocks, per SDU configuration type. */
BT_AUDIO_CODEC_CONFIG_LC3_FRAME_BLKS_PER_SDU = 0x05,
/** Codec frame blocks per SDU */
BT_AUDIO_CODEC_CFG_FRAME_BLKS_PER_SDU = 0x05,
};
enum bt_audio_codec_config_freq {
/**
* @brief 8 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_8KHZ = 0x01,
/**
* @brief 11.025 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_11KHZ = 0x02,
/**
* @brief 16 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ = 0x03,
/**
* @brief 22.05 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_22KHZ = 0x04,
/**
* @brief 24 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_24KHZ = 0x05,
/**
* @brief 32 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ = 0x06,
/**
* @brief 44.1 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_44KHZ = 0x07,
/**
* @brief 48 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ = 0x08,
/**
* @brief 88.2 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_88KHZ = 0x09,
/**
* @brief 96 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_96KHZ = 0x0a,
/**
* @brief 176.4 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_176KHZ = 0x0b,
/**
* @brief 192 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_192KHZ = 0x0c,
/**
* @brief 384 Khz codec Sample Frequency configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_384KHZ = 0x0d,
enum bt_audio_codec_cfg_freq {
/** 8 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_8KHZ = 0x01,
/** 11.025 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_11KHZ = 0x02,
/** 16 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_16KHZ = 0x03,
/** 22.05 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_22KHZ = 0x04,
/** 24 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_24KHZ = 0x05,
/** 32 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_32KHZ = 0x06,
/** 44.1 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_44KHZ = 0x07,
/** 48 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_48KHZ = 0x08,
/** 88.2 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_88KHZ = 0x09,
/** 96 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_96KHZ = 0x0a,
/** 176.4 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_176KHZ = 0x0b,
/** 192 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_192KHZ = 0x0c,
/** 384 Khz codec sampling frequency */
BT_AUDIO_CODEC_CFG_FREQ_384KHZ = 0x0d,
};
enum bt_audio_codec_config_frame_dur {
/**
* @brief LC3 7.5 msec Frame Duration configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5 = 0x00,
/**
* @brief LC3 10 msec Frame Duration configuration
*/
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10 = 0x01,
enum bt_audio_codec_cfg_frame_dur {
/** 7.5 msec Frame Duration configuration */
BT_AUDIO_CODEC_CFG_DURATION_7_5 = 0x00,
/** 10 msec Frame Duration configuration */
BT_AUDIO_CODEC_CFG_DURATION_10 = 0x01,
};
/**
@ -326,14 +275,14 @@ enum bt_audio_codec_config_frame_dur {
#define BT_AUDIO_CODEC_CAP_LC3_DATA(_freq, _duration, _chan_count, _len_min, _len_max, \
_max_frames_per_sdu) \
{ \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_FREQ, BT_BYTES_LIST_LE16(_freq)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_DURATION, (_duration)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_CHAN_COUNT, (_chan_count)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_FRAME_LEN, \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_FREQ, BT_BYTES_LIST_LE16(_freq)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_DURATION, (_duration)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT, (_chan_count)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN, \
BT_BYTES_LIST_LE16(_len_min), \
BT_BYTES_LIST_LE16(_len_max)), \
COND_CODE_1(_max_frames_per_sdu, (), \
(BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_FRAME_COUNT, \
(BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT, \
(_max_frames_per_sdu)))) \
}
@ -349,9 +298,9 @@ enum bt_audio_codec_config_frame_dur {
/**
* @brief Helper to declare LC3 codec
*
* @param _freq Supported Sampling Frequencies bitfield (see ``BT_AUDIO_CODEC_LC3_FREQ_*``)
* @param _duration Supported Frame Durations bitfield (see ``BT_AUDIO_CODEC_LC3_DURATION_*``)
* @param _chan_count Supported channels (see @ref BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT)
* @param _freq Supported Sampling Frequencies bitfield (see ``BT_AUDIO_CODEC_CAP_FREQ_*``)
* @param _duration Supported Frame Durations bitfield (see ``BT_AUDIO_CODEC_CAP_DURATION_*``)
* @param _chan_count Supported channels (see @ref BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT)
* @param _len_min Minimum number of octets supported per codec frame
* @param _len_max Maximum number of octets supported per codec frame
* @param _max_frames_per_sdu Supported maximum codec frames per SDU
@ -368,8 +317,8 @@ enum bt_audio_codec_config_frame_dur {
/**
* @brief Helper to declare LC3 codec data configuration
*
* @param _freq Sampling frequency (``BT_AUDIO_CODEC_CONFIG_LC3_FREQ_*``)
* @param _duration Frame duration (``BT_AUDIO_CODEC_CONFIG_LC3_DURATION_*``)
* @param _freq Sampling frequency (``BT_AUDIO_CODEC_CFG_FREQ_*``)
* @param _duration Frame duration (``BT_AUDIO_CODEC_CFG_DURATION_*``)
* @param _loc Audio channel location bitfield (@ref bt_audio_location)
* @param _len Octets per frame (16-bit integer)
* @param _frames_per_sdu Frames per SDU (8-bit integer). This value is optional and will be
@ -377,14 +326,12 @@ enum bt_audio_codec_config_frame_dur {
*/
#define BT_AUDIO_CODEC_CFG_LC3_DATA(_freq, _duration, _loc, _len, _frames_per_sdu) \
{ \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ, (_freq)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_DURATION, (_duration)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC, \
BT_BYTES_LIST_LE32(_loc)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FRAME_LEN, \
BT_BYTES_LIST_LE16(_len)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ, (_freq)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_DURATION, (_duration)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC, BT_BYTES_LIST_LE32(_loc)), \
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FRAME_LEN, BT_BYTES_LIST_LE16(_len)), \
COND_CODE_1(_frames_per_sdu, (), \
(BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FRAME_BLKS_PER_SDU, \
(BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FRAME_BLKS_PER_SDU, \
(_frames_per_sdu)))) \
}
@ -400,8 +347,8 @@ enum bt_audio_codec_config_frame_dur {
/**
* @brief Helper to declare LC3 codec configuration.
*
* @param _freq Sampling frequency (``BT_AUDIO_CODEC_CONFIG_LC3_FREQ_*``)
* @param _duration Frame duration (``BT_AUDIO_CODEC_CONFIG_LC3_DURATION_*``)
* @param _freq Sampling frequency (``BT_AUDIO_CODEC_CFG_FREQ_*``)
* @param _duration Frame duration (``BT_AUDIO_CODEC_CFG_DURATION_*``)
* @param _loc Audio channel location bitfield (@ref bt_audio_location)
* @param _len Octets per frame (16-bit integer)
* @param _frames_per_sdu Frames per SDU (8-bit integer)
@ -420,9 +367,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_8_1(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_8KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 26u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_8KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 26u, 1, _stream_context)
/**
* @brief Helper to declare LC3 8.2 codec configuration
*
@ -430,9 +376,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_8_2(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_8KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 30u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_8KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 30u, 1, _stream_context)
/**
* @brief Helper to declare LC3 16.1 codec configuration
*
@ -440,9 +385,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_16_1(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 30u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_16KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 30u, 1, _stream_context)
/**
* @brief Helper to declare LC3 16.2 codec configuration
*
@ -450,9 +394,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_16_2(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 40u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_16KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 40u, 1, _stream_context)
/**
* @brief Helper to declare LC3 24.1 codec configuration
@ -461,9 +404,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_24_1(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_24KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 45u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_24KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 45u, 1, _stream_context)
/**
* @brief Helper to declare LC3 24.2 codec configuration
*
@ -471,9 +413,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_24_2(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_24KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 60u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_24KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 60u, 1, _stream_context)
/**
* @brief Helper to declare LC3 32.1 codec configuration
*
@ -481,9 +422,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_32_1(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 60u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_32KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 60u, 1, _stream_context)
/**
* @brief Helper to declare LC3 32.2 codec configuration
*
@ -491,9 +431,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_32_2(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 80u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_32KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 80u, 1, _stream_context)
/**
* @brief Helper to declare LC3 441.1 codec configuration
*
@ -501,9 +440,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_441_1(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_44KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 98u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_44KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 98u, 1, _stream_context)
/**
* @brief Helper to declare LC3 441.2 codec configuration
*
@ -511,9 +449,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_441_2(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_44KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 130u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_44KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 130u, 1, _stream_context)
/**
* @brief Helper to declare LC3 48.1 codec configuration
*
@ -521,9 +458,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_48_1(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 75u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_48KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 75u, 1, _stream_context)
/**
* @brief Helper to declare LC3 48.2 codec configuration
*
@ -531,9 +467,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_48_2(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 100u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_48KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 100u, 1, _stream_context)
/**
* @brief Helper to declare LC3 48.3 codec configuration
*
@ -541,9 +476,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_48_3(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 90u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_48KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 90u, 1, _stream_context)
/**
* @brief Helper to declare LC3 48.4 codec configuration
*
@ -551,9 +485,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_48_4(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 120u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_48KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 120u, 1, _stream_context)
/**
* @brief Helper to declare LC3 48.5 codec configuration
*
@ -561,9 +494,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_48_5(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, _loc, 117u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_48KHZ, BT_AUDIO_CODEC_CFG_DURATION_7_5, \
_loc, 117u, 1, _stream_context)
/**
* @brief Helper to declare LC3 48.6 codec configuration
*
@ -571,9 +503,8 @@ enum bt_audio_codec_config_frame_dur {
* @param _stream_context Stream context (``BT_AUDIO_CONTEXT_*``)
*/
#define BT_AUDIO_CODEC_LC3_CONFIG_48_6(_loc, _stream_context) \
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, \
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, _loc, 155u, 1, \
_stream_context)
BT_AUDIO_CODEC_LC3_CONFIG(BT_AUDIO_CODEC_CFG_FREQ_48KHZ, BT_AUDIO_CODEC_CFG_DURATION_10, \
_loc, 155u, 1, _stream_context)
/**
* @brief Helper to declare LC3 codec QoS for 7.5ms interval
*/

4
samples/bluetooth/broadcast_audio_sink/src/main.c
View file

@ -108,8 +108,8 @@ static struct bt_conn *broadcast_assistant_conn;
static struct bt_le_ext_adv *ext_adv;
static const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ | BT_AUDIO_CODEC_LC3_FREQ_24KHZ,
BT_AUDIO_CODEC_LC3_DURATION_10, BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ | BT_AUDIO_CODEC_CAP_FREQ_24KHZ,
BT_AUDIO_CODEC_CAP_DURATION_10, BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
/* Create a mask for the maximum BIS we can sync to using the number of streams

4
samples/bluetooth/broadcast_audio_source/src/main.c
View file

@ -384,9 +384,9 @@ static int setup_broadcast_source(struct bt_bap_broadcast_source **source)
subgroup_param[CONFIG_BT_BAP_BROADCAST_SRC_SUBGROUP_COUNT];
struct bt_bap_broadcast_source_param create_param;
const size_t streams_per_subgroup = ARRAY_SIZE(stream_params) / ARRAY_SIZE(subgroup_param);
uint8_t left[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t left[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_BYTES_LIST_LE32(BT_AUDIO_LOCATION_FRONT_LEFT))};
uint8_t right[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t right[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_BYTES_LIST_LE32(BT_AUDIO_LOCATION_FRONT_RIGHT))};
int err;

4
samples/bluetooth/hap_ha/src/bap_unicast_sr.c
View file

@ -22,8 +22,8 @@ NET_BUF_POOL_FIXED_DEFINE(tx_pool, CONFIG_BT_ASCS_ASE_SRC_COUNT,
CONFIG_BT_CONN_TX_USER_DATA_SIZE, NULL);
static const struct bt_audio_codec_cap lc3_codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ | BT_AUDIO_CODEC_LC3_FREQ_24KHZ,
BT_AUDIO_CODEC_LC3_DURATION_10, BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ | BT_AUDIO_CODEC_CAP_FREQ_24KHZ,
BT_AUDIO_CODEC_CAP_DURATION_10, BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
static struct bt_conn *default_conn;

4
samples/bluetooth/public_broadcast_sink/src/main.c
View file

@ -69,8 +69,8 @@ static struct bt_bap_stream streams[CONFIG_BT_BAP_BROADCAST_SNK_STREAM_COUNT];
struct bt_bap_stream *streams_p[ARRAY_SIZE(streams)];
static const struct bt_audio_codec_cap codec = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_48KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u, (BT_AUDIO_CONTEXT_TYPE_MEDIA));
BT_AUDIO_CODEC_CAP_FREQ_48KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u, (BT_AUDIO_CONTEXT_TYPE_MEDIA));
/* Create a mask for the maximum BIS we can sync to using the number of streams
* we have. We add an additional 1 since the bis indexes start from 1 and not

3
samples/bluetooth/public_broadcast_source/src/main.c
View file

@ -33,8 +33,7 @@ static struct bt_cap_stream broadcast_source_stream;
static struct bt_cap_stream *broadcast_stream;
static uint8_t bis_codec_data[] = {BT_AUDIO_CODEC_DATA(
BT_AUDIO_CODEC_CONFIG_LC3_FREQ, BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ))};
BT_AUDIO_CODEC_CFG_FREQ, BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_48KHZ))};
const uint8_t pba_metadata[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_METADATA_TYPE_PROGRAM_INFO, PBS_DEMO)

4
samples/bluetooth/tmap_bmr/src/bap_broadcast_sink.c
View file

@ -56,8 +56,8 @@ static struct bt_bap_stream streams[CONFIG_BT_BAP_BROADCAST_SNK_STREAM_COUNT];
struct bt_bap_stream *streams_p[ARRAY_SIZE(streams)];
static const struct bt_audio_codec_cap codec = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_48KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u, (BT_AUDIO_CONTEXT_TYPE_MEDIA));
BT_AUDIO_CODEC_CAP_FREQ_48KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u, (BT_AUDIO_CONTEXT_TYPE_MEDIA));
/* Create a mask for the maximum BIS we can sync to using the number of streams
* we have. We add an additional 1 since the bis indexes start from 1 and not

2
samples/bluetooth/tmap_bms/src/cap_initiator.c
View file

@ -28,7 +28,7 @@ static struct bt_cap_stream broadcast_source_stream;
static struct bt_cap_stream *broadcast_stream;
static uint8_t bis_codec_data[] = {BT_AUDIO_CODEC_DATA(
BT_AUDIO_CODEC_CONFIG_LC3_FREQ, BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ))};
BT_AUDIO_CODEC_CFG_FREQ, BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_48KHZ))};
static const uint8_t new_metadata[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_METADATA_TYPE_STREAM_CONTEXT,

8
samples/bluetooth/tmap_peripheral/src/bap_unicast_sr.c
View file

@ -23,10 +23,10 @@
#include "tmap_peripheral.h"
static const struct bt_audio_codec_cap lc3_codec_cap =
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_LC3_FREQ_16KHZ | BT_AUDIO_CODEC_LC3_FREQ_32KHZ |
BT_AUDIO_CODEC_LC3_FREQ_48KHZ,
BT_AUDIO_CODEC_LC3_DURATION_7_5 | BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(2), 30, 155u, 1u,
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_CAP_FREQ_16KHZ | BT_AUDIO_CODEC_CAP_FREQ_32KHZ |
BT_AUDIO_CODEC_CAP_FREQ_48KHZ,
BT_AUDIO_CODEC_CAP_DURATION_7_5 | BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(2), 30, 155u, 1u,
(AVAILABLE_SINK_CONTEXT | AVAILABLE_SOURCE_CONTEXT));
static struct bt_conn *default_conn;

4
samples/bluetooth/unicast_audio_server/src/main.c
View file

@ -34,8 +34,8 @@ NET_BUF_POOL_FIXED_DEFINE(tx_pool, CONFIG_BT_ASCS_ASE_SRC_COUNT,
CONFIG_BT_CONN_TX_USER_DATA_SIZE, NULL);
static const struct bt_audio_codec_cap lc3_codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 120u, 1u,
BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 120u, 1u,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
static struct bt_conn *default_conn;

149
subsys/bluetooth/audio/codec.c
View file

@ -20,34 +20,34 @@
LOG_MODULE_REGISTER(bt_audio_codec, CONFIG_BT_AUDIO_CODEC_LOG_LEVEL);
int bt_audio_codec_cfg_freq_to_freq_hz(enum bt_audio_codec_config_freq freq)
int bt_audio_codec_cfg_freq_to_freq_hz(enum bt_audio_codec_cfg_freq freq)
{
switch (freq) {
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_8KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_8KHZ:
return 8000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_11KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_11KHZ:
return 11025;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_16KHZ:
return 16000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_22KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_22KHZ:
return 22050;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_24KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_24KHZ:
return 24000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_32KHZ:
return 32000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_44KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_44KHZ:
return 44100;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_48KHZ:
return 48000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_88KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_88KHZ:
return 88200;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_96KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_96KHZ:
return 96000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_176KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_176KHZ:
return 176400;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_192KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_192KHZ:
return 192000;
case BT_AUDIO_CODEC_CONFIG_LC3_FREQ_384KHZ:
case BT_AUDIO_CODEC_CFG_FREQ_384KHZ:
return 384000;
default:
return -EINVAL;
@ -58,42 +58,42 @@ int bt_audio_codec_cfg_freq_hz_to_freq(uint32_t freq_hz)
{
switch (freq_hz) {
case 8000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_8KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_8KHZ;
case 11025U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_11KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_11KHZ;
case 16000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
case 22050U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_22KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_22KHZ;
case 24000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_24KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_24KHZ;
case 32000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_32KHZ;
case 44100U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_44KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_44KHZ;
case 48000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_48KHZ;
case 88200U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_88KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_88KHZ;
case 96000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_96KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_96KHZ;
case 176400U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_176KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_176KHZ;
case 192000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_192KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_192KHZ;
case 384000U:
return BT_AUDIO_CODEC_CONFIG_LC3_FREQ_384KHZ;
return BT_AUDIO_CODEC_CFG_FREQ_384KHZ;
default:
return -EINVAL;
}
}
int bt_audio_codec_cfg_frame_dur_to_frame_dur_us(enum bt_audio_codec_config_frame_dur frame_dur)
int bt_audio_codec_cfg_frame_dur_to_frame_dur_us(enum bt_audio_codec_cfg_frame_dur frame_dur)
{
switch (frame_dur) {
case BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5:
case BT_AUDIO_CODEC_CFG_DURATION_7_5:
return 7500;
case BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10:
case BT_AUDIO_CODEC_CFG_DURATION_10:
return 10000;
default:
return -EINVAL;
@ -104,9 +104,9 @@ int bt_audio_codec_cfg_frame_dur_us_to_frame_dur(uint32_t frame_dur_us)
{
switch (frame_dur_us) {
case 7500U:
return BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5;
return BT_AUDIO_CODEC_CFG_DURATION_7_5;
case 10000U:
return BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10;
return BT_AUDIO_CODEC_CFG_DURATION_10;
default:
return -EINVAL;
}
@ -280,7 +280,7 @@ static void init_net_buf_simple_from_codec_cfg(struct net_buf_simple *buf,
}
int bt_audio_codec_cfg_get_val(const struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_type type, const uint8_t **data)
enum bt_audio_codec_cfg_type type, const uint8_t **data)
{
struct search_type_param param = {
.found = false,
@ -317,7 +317,7 @@ int bt_audio_codec_cfg_get_val(const struct bt_audio_codec_cfg *codec_cfg,
}
int bt_audio_codec_cfg_set_val(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_type type, const uint8_t *data,
enum bt_audio_codec_cfg_type type, const uint8_t *data,
size_t data_len)
{
struct net_buf_simple buf;
@ -349,7 +349,7 @@ int bt_audio_codec_cfg_set_val(struct bt_audio_codec_cfg *codec_cfg,
}
int bt_audio_codec_cfg_unset_val(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_type type)
enum bt_audio_codec_cfg_type type)
{
struct net_buf_simple buf;
int ret;
@ -371,7 +371,7 @@ int bt_audio_codec_cfg_unset_val(struct bt_audio_codec_cfg *codec_cfg,
int bt_audio_codec_cfg_get_freq(const struct bt_audio_codec_cfg *codec_cfg)
{
enum bt_audio_codec_config_freq freq;
enum bt_audio_codec_cfg_freq freq;
const uint8_t *data;
uint8_t data_len;
@ -380,7 +380,7 @@ int bt_audio_codec_cfg_get_freq(const struct bt_audio_codec_cfg *codec_cfg)
return -EINVAL;
}
data_len = bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
data_len = bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
if (data == NULL) {
return -ENODATA;
}
@ -399,7 +399,7 @@ int bt_audio_codec_cfg_get_freq(const struct bt_audio_codec_cfg *codec_cfg)
}
int bt_audio_codec_cfg_set_freq(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_freq freq)
enum bt_audio_codec_cfg_freq freq)
{
uint8_t freq_u8;
@ -410,13 +410,13 @@ int bt_audio_codec_cfg_set_freq(struct bt_audio_codec_cfg *codec_cfg,
freq_u8 = (uint8_t)freq;
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &freq_u8,
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &freq_u8,
sizeof(freq_u8));
}
int bt_audio_codec_cfg_get_frame_dur(const struct bt_audio_codec_cfg *codec_cfg)
{
enum bt_audio_codec_config_frame_dur frame_dur;
enum bt_audio_codec_cfg_frame_dur frame_dur;
const uint8_t *data;
uint8_t data_len;
@ -425,7 +425,7 @@ int bt_audio_codec_cfg_get_frame_dur(const struct bt_audio_codec_cfg *codec_cfg)
return -EINVAL;
}
data_len = bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_DURATION, &data);
data_len = bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_DURATION, &data);
if (data == NULL) {
return -ENODATA;
}
@ -444,7 +444,7 @@ int bt_audio_codec_cfg_get_frame_dur(const struct bt_audio_codec_cfg *codec_cfg)
}
int bt_audio_codec_cfg_set_frame_dur(struct bt_audio_codec_cfg *codec_cfg,
enum bt_audio_codec_config_frame_dur frame_dur)
enum bt_audio_codec_cfg_frame_dur frame_dur)
{
uint8_t frame_dur_u8;
@ -455,7 +455,7 @@ int bt_audio_codec_cfg_set_frame_dur(struct bt_audio_codec_cfg *codec_cfg,
frame_dur_u8 = (uint8_t)frame_dur;
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_DURATION,
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CFG_DURATION,
&frame_dur_u8, sizeof(frame_dur_u8));
}
@ -477,7 +477,7 @@ int bt_audio_codec_cfg_get_chan_allocation(const struct bt_audio_codec_cfg *code
}
data_len =
bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC, &data);
bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_CHAN_ALLOC, &data);
if (data == NULL) {
return -ENODATA;
}
@ -503,7 +503,7 @@ int bt_audio_codec_cfg_set_chan_allocation(struct bt_audio_codec_cfg *codec_cfg,
chan_allocation_u32 = sys_cpu_to_le32((uint32_t)chan_allocation);
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
(const uint8_t *)&chan_allocation_u32,
sizeof(chan_allocation_u32));
}
@ -519,7 +519,7 @@ int bt_audio_codec_cfg_get_octets_per_frame(const struct bt_audio_codec_cfg *cod
}
data_len =
bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FRAME_LEN, &data);
bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_FRAME_LEN, &data);
if (data == NULL) {
return -ENODATA;
}
@ -538,7 +538,7 @@ int bt_audio_codec_cfg_set_octets_per_frame(struct bt_audio_codec_cfg *codec_cfg
octets_per_frame_le16 = sys_cpu_to_le16(octets_per_frame);
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FRAME_LEN,
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CFG_FRAME_LEN,
(uint8_t *)&octets_per_frame_le16,
sizeof(octets_per_frame_le16));
}
@ -555,7 +555,7 @@ int bt_audio_codec_cfg_get_frame_blocks_per_sdu(const struct bt_audio_codec_cfg
}
data_len = bt_audio_codec_cfg_get_val(codec_cfg,
BT_AUDIO_CODEC_CONFIG_LC3_FRAME_BLKS_PER_SDU, &data);
BT_AUDIO_CODEC_CFG_FRAME_BLKS_PER_SDU, &data);
if (data == NULL) {
if (fallback_to_default) {
return 1;
@ -574,7 +574,7 @@ int bt_audio_codec_cfg_get_frame_blocks_per_sdu(const struct bt_audio_codec_cfg
int bt_audio_codec_cfg_set_frame_blocks_per_sdu(struct bt_audio_codec_cfg *codec_cfg,
uint8_t frame_blocks)
{
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FRAME_BLKS_PER_SDU,
return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CFG_FRAME_BLKS_PER_SDU,
&frame_blocks, sizeof(frame_blocks));
}
#endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 */
@ -1794,7 +1794,7 @@ static void init_net_buf_simple_from_codec_cap(struct net_buf_simple *buf,
}
int bt_audio_codec_cap_get_val(const struct bt_audio_codec_cap *codec_cap,
enum bt_audio_codec_capability_type type, const uint8_t **data)
enum bt_audio_codec_cap_type type, const uint8_t **data)
{
struct search_type_param param = {
.found = false,
@ -1831,7 +1831,7 @@ int bt_audio_codec_cap_get_val(const struct bt_audio_codec_cap *codec_cap,
}
int bt_audio_codec_cap_set_val(struct bt_audio_codec_cap *codec_cap,
enum bt_audio_codec_capability_type type, const uint8_t *data,
enum bt_audio_codec_cap_type type, const uint8_t *data,
size_t data_len)
{
struct net_buf_simple buf;
@ -1863,7 +1863,7 @@ int bt_audio_codec_cap_set_val(struct bt_audio_codec_cap *codec_cap,
}
int bt_audio_codec_cap_unset_val(struct bt_audio_codec_cap *codec_cap,
enum bt_audio_codec_capability_type type)
enum bt_audio_codec_cap_type type)
{
struct net_buf_simple buf;
int ret;
@ -1893,7 +1893,7 @@ int bt_audio_codec_cap_get_freq(const struct bt_audio_codec_cap *codec_cap)
return -EINVAL;
}
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_FREQ, &data);
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FREQ, &data);
if (data == NULL) {
return -ENODATA;
}
@ -1915,15 +1915,15 @@ int bt_audio_codec_cap_set_freq(struct bt_audio_codec_cap *codec_cap,
return -EINVAL;
}
if ((freq & BT_AUDIO_CODEC_LC3_FREQ_ANY) != freq) {
if ((freq & BT_AUDIO_CODEC_CAP_FREQ_ANY) != freq) {
LOG_DBG("Invalid freq value: %d", freq);
return -EINVAL;
}
freq_le16 = sys_cpu_to_le16((uint16_t)freq);
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_LC3_FREQ, (uint8_t *)&freq_le16,
sizeof(freq_le16));
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FREQ,
(uint8_t *)&freq_le16, sizeof(freq_le16));
}
int bt_audio_codec_cap_get_frame_dur(const struct bt_audio_codec_cap *codec_cap)
@ -1936,7 +1936,7 @@ int bt_audio_codec_cap_get_frame_dur(const struct bt_audio_codec_cap *codec_cap)
return -EINVAL;
}
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_DURATION, &data);
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_DURATION, &data);
if (data == NULL) {
return -ENODATA;
}
@ -1958,33 +1958,33 @@ int bt_audio_codec_cap_set_frame_dur(struct bt_audio_codec_cap *codec_cap,
return -EINVAL;
}
if ((frame_dur & BT_AUDIO_CODEC_LC3_DURATION_ANY) == 0) {
if ((frame_dur & BT_AUDIO_CODEC_CAP_DURATION_ANY) == 0) {
LOG_DBG("Invalid frame_dur value: %d", frame_dur);
return -EINVAL;
}
if ((frame_dur & BT_AUDIO_CODEC_LC3_DURATION_PREFER_7_5) != 0) {
if ((frame_dur & BT_AUDIO_CODEC_LC3_DURATION_PREFER_10) != 0) {
if ((frame_dur & BT_AUDIO_CODEC_CAP_DURATION_PREFER_7_5) != 0) {
if ((frame_dur & BT_AUDIO_CODEC_CAP_DURATION_PREFER_10) != 0) {
LOG_DBG("Cannot prefer both 7.5 and 10ms: %d", frame_dur);
return -EINVAL;
}
if ((frame_dur & BT_AUDIO_CODEC_LC3_DURATION_7_5) == 0) {
if ((frame_dur & BT_AUDIO_CODEC_CAP_DURATION_7_5) == 0) {
LOG_DBG("Cannot prefer 7.5ms when not supported: %d", frame_dur);
return -EINVAL;
}
}
if ((frame_dur & BT_AUDIO_CODEC_LC3_DURATION_PREFER_10) != 0 &&
(frame_dur & BT_AUDIO_CODEC_LC3_DURATION_10) == 0) {
if ((frame_dur & BT_AUDIO_CODEC_CAP_DURATION_PREFER_10) != 0 &&
(frame_dur & BT_AUDIO_CODEC_CAP_DURATION_10) == 0) {
LOG_DBG("Cannot prefer 10ms when not supported: %d", frame_dur);
return -EINVAL;
}
frame_dur_u8 = (uint8_t)frame_dur;
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_LC3_DURATION, &frame_dur_u8,
sizeof(frame_dur_u8));
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_DURATION,
&frame_dur_u8, sizeof(frame_dur_u8));
}
int bt_audio_codec_cap_get_supported_audio_chan_counts(const struct bt_audio_codec_cap *codec_cap)
@ -1997,7 +1997,7 @@ int bt_audio_codec_cap_get_supported_audio_chan_counts(const struct bt_audio_cod
return -EINVAL;
}
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_CHAN_COUNT, &data);
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT, &data);
if (data == NULL) {
return -ENODATA;
}
@ -2019,15 +2019,15 @@ int bt_audio_codec_cap_set_supported_audio_chan_counts(
return -EINVAL;
}
if ((chan_count & BT_AUDIO_CODEC_CAP_CHAN_COUNT_ALL) != chan_count) {
if ((chan_count & BT_AUDIO_CODEC_CAP_CHAN_COUNT_ANY) != chan_count) {
LOG_DBG("Invalid chan_count value: %d", chan_count);
return -EINVAL;
}
chan_count_u8 = (uint8_t)chan_count;
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_LC3_CHAN_COUNT, &chan_count_u8,
sizeof(chan_count_u8));
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT,
&chan_count_u8, sizeof(chan_count_u8));
}
int bt_audio_codec_cap_get_octets_per_frame(
@ -2047,7 +2047,7 @@ int bt_audio_codec_cap_get_octets_per_frame(
return -EINVAL;
}
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_FRAME_LEN, &data);
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN, &data);
if (data == NULL) {
return -ENODATA;
}
@ -2086,8 +2086,8 @@ int bt_audio_codec_cap_set_octets_per_frame(
sys_put_le16(codec_frame->min, codec_frame_le32);
sys_put_le16(codec_frame->max, codec_frame_le32 + 2);
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_LC3_FRAME_LEN, codec_frame_le32,
sizeof(codec_frame_le32));
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN,
codec_frame_le32, sizeof(codec_frame_le32));
}
int bt_audio_codec_cap_get_max_codec_frames_per_sdu(const struct bt_audio_codec_cap *codec_cap)
@ -2100,7 +2100,8 @@ int bt_audio_codec_cap_get_max_codec_frames_per_sdu(const struct bt_audio_codec_
return -EINVAL;
}
data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_FRAME_COUNT, &data);
data_len =
bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT, &data);
if (data == NULL) {
return -ENODATA;
}
@ -2120,7 +2121,7 @@ int bt_audio_codec_cap_set_max_codec_frames_per_sdu(struct bt_audio_codec_cap *c
return -EINVAL;
}
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_LC3_FRAME_COUNT,
return bt_audio_codec_cap_set_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT,
&codec_frames_per_sdu, sizeof(codec_frames_per_sdu));
}

6
subsys/bluetooth/audio/shell/bap.c
View file

@ -590,8 +590,8 @@ static int lc3_release(struct bt_bap_stream *stream, struct bt_bap_ascs_rsp *rsp
}
static const struct bt_audio_codec_cap lc3_codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_ANY,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2, CONTEXT);
BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_ANY,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2, CONTEXT);
static const struct bt_bap_unicast_server_cb unicast_server_cb = {
.config = lc3_config,
@ -1124,7 +1124,7 @@ static int cmd_config(const struct shell *sh, size_t argc, char *argv[])
type = codec_cfg->data[i++];
value = &codec_cfg->data[i];
if (type == BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC) {
if (type == BT_AUDIO_CODEC_CFG_CHAN_ALLOC) {
const uint32_t loc_32 = location;
sys_put_le32(loc_32, value);

6
subsys/bluetooth/audio/shell/cap_initiator.c
View file

@ -1092,11 +1092,11 @@ int cap_ac_broadcast(const struct shell *sh, size_t argc, char **argv,
/* TODO: Use CAP API when the CAP shell has broadcast support */
struct bt_bap_broadcast_source_stream_param stream_params[BAP_UNICAST_AC_MAX_SRC] = {0};
uint8_t stereo_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_RIGHT | BT_AUDIO_LOCATION_FRONT_LEFT)};
uint8_t right_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t right_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_RIGHT)};
uint8_t left_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t left_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_LEFT)};
struct bt_bap_broadcast_source_subgroup_param subgroup_param = {0};
struct bt_bap_broadcast_source_param create_param = {0};

2
tests/bluetooth/audio/bap_broadcast_source/src/main.c
View file

@ -43,7 +43,7 @@ static void bap_broadcast_source_test_suite_fixture_init(
struct bap_broadcast_source_test_suite_fixture *fixture)
{
const uint8_t bis_cfg_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_LEFT | BT_AUDIO_LOCATION_FRONT_RIGHT),
};
const size_t streams_per_subgroup = CONFIG_BT_BAP_BROADCAST_SRC_STREAM_COUNT /

168
tests/bluetooth/audio/codec/src/main.c
View file

@ -19,14 +19,14 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_get_val)
{
struct bt_audio_codec_cfg codec_cfg =
BT_AUDIO_CODEC_CFG(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000,
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)},
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_AUDIO_CODEC_CFG_FREQ_16KHZ)},
{});
const uint8_t expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], expected_data, "Unexpected return value %d", ret);
}
@ -35,23 +35,23 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_set_val)
{
struct bt_audio_codec_cfg codec_cfg =
BT_AUDIO_CODEC_CFG(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000,
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)},
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_AUDIO_CODEC_CFG_FREQ_16KHZ)},
{});
const uint8_t new_expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
const uint8_t new_expected_data = BT_AUDIO_CODEC_CFG_FREQ_48KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], expected_data, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_set_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
ret = bt_audio_codec_cfg_set_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ,
&new_expected_data, sizeof(new_expected_data));
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(new_expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], new_expected_data, "Unexpected data value %u", data[0]);
}
@ -60,18 +60,18 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_set_val_new_value)
{
struct bt_audio_codec_cfg codec_cfg =
BT_AUDIO_CODEC_CFG(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000, {}, {});
const uint8_t new_expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ;
const uint8_t new_expected_data = BT_AUDIO_CODEC_CFG_FREQ_48KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, -ENODATA, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_set_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
ret = bt_audio_codec_cfg_set_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ,
&new_expected_data, sizeof(new_expected_data));
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(new_expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], new_expected_data, "Unexpected return value %d", ret);
}
@ -80,43 +80,43 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_unset_val)
{
struct bt_audio_codec_cfg codec_cfg =
BT_AUDIO_CODEC_CFG(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000,
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)},
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_AUDIO_CODEC_CFG_FREQ_16KHZ)},
{});
const uint8_t expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], expected_data, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_unset_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ);
ret = bt_audio_codec_cfg_unset_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ);
zassert_true(ret >= 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cfg_get_val(&codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, -ENODATA, "Unexpected return value %d", ret);
}
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_freq_to_freq_hz)
{
const struct freq_test_input {
enum bt_audio_codec_config_freq freq;
enum bt_audio_codec_cfg_freq freq;
uint32_t freq_hz;
} freq_test_inputs[] = {
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_8KHZ, .freq_hz = 8000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_11KHZ, .freq_hz = 11025U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ, .freq_hz = 16000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_22KHZ, .freq_hz = 22050U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_24KHZ, .freq_hz = 24000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ, .freq_hz = 32000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_44KHZ, .freq_hz = 44100U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ, .freq_hz = 48000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_88KHZ, .freq_hz = 88200U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_96KHZ, .freq_hz = 96000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_176KHZ, .freq_hz = 176400U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_192KHZ, .freq_hz = 192000U},
{.freq = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_384KHZ, .freq_hz = 384000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_8KHZ, .freq_hz = 8000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_11KHZ, .freq_hz = 11025U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_16KHZ, .freq_hz = 16000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_22KHZ, .freq_hz = 22050U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_24KHZ, .freq_hz = 24000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_32KHZ, .freq_hz = 32000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_44KHZ, .freq_hz = 44100U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_48KHZ, .freq_hz = 48000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_88KHZ, .freq_hz = 88200U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_96KHZ, .freq_hz = 96000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_176KHZ, .freq_hz = 176400U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_192KHZ, .freq_hz = 192000U},
{.freq = BT_AUDIO_CODEC_CFG_FREQ_384KHZ, .freq_hz = 384000U},
};
for (size_t i = 0U; i < ARRAY_SIZE(freq_test_inputs); i++) {
@ -169,7 +169,7 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_set_freq)
ret = bt_audio_codec_cfg_get_freq(&preset.codec_cfg);
zassert_equal(ret, 0x03, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_set_freq(&preset.codec_cfg, BT_AUDIO_CODEC_CONFIG_LC3_FREQ_32KHZ);
ret = bt_audio_codec_cfg_set_freq(&preset.codec_cfg, BT_AUDIO_CODEC_CFG_FREQ_32KHZ);
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_get_freq(&preset.codec_cfg);
@ -179,11 +179,11 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_set_freq)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_frame_dur_to_frame_dur_us)
{
const struct frame_dur_test_input {
enum bt_audio_codec_config_frame_dur frame_dur;
enum bt_audio_codec_cfg_frame_dur frame_dur;
uint32_t frame_dur_us;
} frame_dur_test_inputs[] = {
{.frame_dur = BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5, .frame_dur_us = 7500U},
{.frame_dur = BT_AUDIO_CODEC_CONFIG_LC3_DURATION_10, .frame_dur_us = 10000U},
{.frame_dur = BT_AUDIO_CODEC_CFG_DURATION_7_5, .frame_dur_us = 7500U},
{.frame_dur = BT_AUDIO_CODEC_CFG_DURATION_10, .frame_dur_us = 10000U},
};
for (size_t i = 0U; i < ARRAY_SIZE(frame_dur_test_inputs); i++) {
@ -219,7 +219,7 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cfg_set_frame_dur)
zassert_equal(ret, 0x01, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_set_frame_dur(&preset.codec_cfg,
BT_AUDIO_CODEC_CONFIG_LC3_DURATION_7_5);
BT_AUDIO_CODEC_CFG_DURATION_7_5);
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cfg_get_frame_dur(&preset.codec_cfg);
@ -879,14 +879,14 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_val)
{
struct bt_audio_codec_cap codec_cap =
BT_AUDIO_CODEC_CAP(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000,
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)},
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_AUDIO_CODEC_CFG_FREQ_16KHZ)},
{});
const uint8_t expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], expected_data, "Unexpected return value %d", ret);
}
@ -895,23 +895,23 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_val)
{
struct bt_audio_codec_cap codec_cap =
BT_AUDIO_CODEC_CAP(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000,
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)},
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_AUDIO_CODEC_CFG_FREQ_16KHZ)},
{});
const uint8_t new_expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
const uint8_t new_expected_data = BT_AUDIO_CODEC_CFG_FREQ_48KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], expected_data, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_set_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
ret = bt_audio_codec_cap_set_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ,
&new_expected_data, sizeof(new_expected_data));
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(new_expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], new_expected_data, "Unexpected data value %u", data[0]);
}
@ -920,18 +920,18 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_val_new)
{
struct bt_audio_codec_cap codec_cap =
BT_AUDIO_CODEC_CAP(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000, {}, {});
const uint8_t new_expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ;
const uint8_t new_expected_data = BT_AUDIO_CODEC_CFG_FREQ_48KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, -ENODATA, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_set_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
ret = bt_audio_codec_cap_set_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ,
&new_expected_data, sizeof(new_expected_data));
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(new_expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], new_expected_data, "Unexpected return value %d", ret);
}
@ -940,29 +940,29 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_unset_val)
{
struct bt_audio_codec_cap codec_cap =
BT_AUDIO_CODEC_CAP(BT_HCI_CODING_FORMAT_LC3, 0x0000, 0x0000,
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)},
{BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_AUDIO_CODEC_CFG_FREQ_16KHZ)},
{});
const uint8_t expected_data = BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ;
const uint8_t expected_data = BT_AUDIO_CODEC_CFG_FREQ_16KHZ;
const uint8_t *data;
int ret;
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, sizeof(expected_data), "Unexpected return value %d", ret);
zassert_equal(data[0], expected_data, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_unset_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ);
ret = bt_audio_codec_cap_unset_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ);
zassert_true(ret >= 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CONFIG_LC3_FREQ, &data);
ret = bt_audio_codec_cap_get_val(&codec_cap, BT_AUDIO_CODEC_CFG_FREQ, &data);
zassert_equal(ret, -ENODATA, "Unexpected return value %d", ret);
}
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_freq)
{
const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -974,8 +974,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_freq)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_freq)
{
struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -983,7 +983,7 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_freq)
ret = bt_audio_codec_cap_get_freq(&codec_cap);
zassert_equal(ret, 4, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_set_freq(&codec_cap, BT_AUDIO_CODEC_LC3_FREQ_22KHZ);
ret = bt_audio_codec_cap_set_freq(&codec_cap, BT_AUDIO_CODEC_CAP_FREQ_22KHZ);
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_get_freq(&codec_cap);
@ -993,8 +993,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_freq)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_frame_dur)
{
const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -1006,8 +1006,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_frame_dur)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_frame_dur)
{
struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -1015,7 +1015,7 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_frame_dur)
ret = bt_audio_codec_cap_get_frame_dur(&codec_cap);
zassert_equal(ret, 2, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_set_frame_dur(&codec_cap, BT_AUDIO_CODEC_LC3_DURATION_7_5);
ret = bt_audio_codec_cap_set_frame_dur(&codec_cap, BT_AUDIO_CODEC_CAP_DURATION_7_5);
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_get_frame_dur(&codec_cap);
@ -1025,8 +1025,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_frame_dur)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_supported_audio_chan_counts)
{
const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(2), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(2), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -1038,8 +1038,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_supported_audio_chan_c
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_supported_audio_chan_counts)
{
struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -1048,7 +1048,7 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_supported_audio_chan_c
zassert_equal(ret, 1, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_set_frame_dur(&codec_cap,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(2));
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(2));
zassert_true(ret > 0, "Unexpected return value %d", ret);
ret = bt_audio_codec_cap_get_frame_dur(&codec_cap);
@ -1062,8 +1062,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_octets_per_frame)
.max = 120U,
};
const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
struct bt_audio_codec_octets_per_codec_frame codec_frame;
@ -1080,8 +1080,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_octets_per_frame)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_octets_per_frame)
{
struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
struct bt_audio_codec_octets_per_codec_frame codec_frame;
int ret;
@ -1105,8 +1105,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_octets_per_frame)
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_max_codec_frames_per_sdu)
{
const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;
@ -1118,8 +1118,8 @@ ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_get_max_codec_frames_per_s
ZTEST(audio_codec_test_suite, test_bt_audio_codec_cap_set_max_codec_frames_per_sdu)
{
struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_16KHZ, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
BT_AUDIO_CODEC_CAP_FREQ_16KHZ, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40U, 120U, 2U,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
int ret;

4
tests/bluetooth/audio/mocks/src/pacs.c
View file

@ -15,8 +15,8 @@
FAKE(bt_pacs_get_available_contexts_for_conn) \
static const struct bt_audio_codec_cap lc3_codec = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 120u, 1u,
BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 120u, 1u,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
DEFINE_FAKE_VOID_FUNC(bt_pacs_cap_foreach, enum bt_audio_dir, bt_pacs_cap_foreach_func_t, void *);

10
tests/bluetooth/tester/src/btp_bap.c
View file

@ -33,14 +33,14 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_BTTESTER_LOG_LEVEL);
#define AVAILABLE_SOURCE_CONTEXT SUPPORTED_SOURCE_CONTEXT
static const struct bt_audio_codec_cap default_codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_7_5 |
BT_AUDIO_CODEC_LC3_DURATION_10, BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 2), 26u, 155u, 1u,
BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_7_5 |
BT_AUDIO_CODEC_CAP_DURATION_10, BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 26u, 155u, 1u,
BT_AUDIO_CONTEXT_TYPE_ANY);
static const struct bt_audio_codec_cap vendor_codec_cap = BT_AUDIO_CODEC_CAP(
0xff, 0xffff, 0xffff, BT_AUDIO_CODEC_CAP_LC3_DATA(BT_AUDIO_CODEC_LC3_FREQ_ANY,
BT_AUDIO_CODEC_LC3_DURATION_7_5 | BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 2), 26u, 155, 1u),
0xff, 0xffff, 0xffff, BT_AUDIO_CODEC_CAP_LC3_DATA(BT_AUDIO_CODEC_CAP_FREQ_ANY,
BT_AUDIO_CODEC_CAP_DURATION_7_5 | BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 26u, 155, 1u),
BT_AUDIO_CODEC_CAP_LC3_META(BT_AUDIO_CONTEXT_TYPE_ANY));
static struct bt_pacs_cap cap_sink = {

8
tests/bluetooth/tester/src/btp_bap_unicast.c
View file

@ -233,19 +233,19 @@ static void btp_send_pac_codec_found_ev(struct bt_conn *conn,
ev.dir = dir;
ev.coding_format = codec_cap->id;
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_FREQ, &data)) {
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FREQ, &data)) {
memcpy(&ev.frequencies, data, sizeof(ev.frequencies));
}
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_DURATION, &data)) {
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_DURATION, &data)) {
memcpy(&ev.frame_durations, data, sizeof(ev.frame_durations));
}
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_FRAME_LEN, &data)) {
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN, &data)) {
memcpy(&ev.octets_per_frame, data, sizeof(ev.octets_per_frame));
}
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_LC3_CHAN_COUNT, &data)) {
if (codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT, &data)) {
memcpy(&ev.channel_counts, data, sizeof(ev.channel_counts));
}

4
tests/bsim/bluetooth/audio/src/bap_broadcast_sink_test.c
View file

@ -38,8 +38,8 @@ static struct bt_le_ext_adv *ext_adv;
static const struct bt_bap_scan_delegator_recv_state *req_recv_state;
static const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_ANY,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2,
BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_ANY,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
static K_SEM_DEFINE(sem_started, 0U, ARRAY_SIZE(streams));

8
tests/bsim/bluetooth/audio/src/bap_broadcast_source_test.c
View file

@ -97,8 +97,8 @@ static struct bt_bap_stream_ops stream_ops = {
static int setup_broadcast_source(struct bt_bap_broadcast_source **source)
{
uint8_t bis_codec_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_16KHZ)),
};
struct bt_bap_broadcast_source_stream_param
stream_params[ARRAY_SIZE(broadcast_source_streams)];
@ -248,8 +248,8 @@ static int setup_extended_adv(struct bt_bap_broadcast_source *source, struct bt_
static void test_broadcast_source_reconfig(struct bt_bap_broadcast_source *source)
{
uint8_t bis_codec_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_16KHZ)),
};
struct bt_bap_broadcast_source_stream_param
stream_params[ARRAY_SIZE(broadcast_source_streams)];

16
tests/bsim/bluetooth/audio/src/bap_unicast_server_test.c
View file

@ -31,14 +31,14 @@ static const struct bt_audio_codec_cap lc3_codec_cap = {
.vid = 0x0000U,
.data_len = (3 + 1) + (2 + 1) + (2 + 1) + (5 + 1) + (2 + 1),
.data = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_LC3_FREQ_16KHZ)),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_DURATION,
BT_AUDIO_CODEC_LC3_DURATION_10),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_CHAN_COUNT, CHANNEL_COUNT_1),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_FRAME_LEN, BT_BYTES_LIST_LE16(40U),
BT_BYTES_LIST_LE16(40U)),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_LC3_FRAME_COUNT, 1U),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CAP_FREQ_16KHZ)),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_DURATION,
BT_AUDIO_CODEC_CAP_DURATION_10),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT, CHANNEL_COUNT_1),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN,
BT_BYTES_LIST_LE16(40U), BT_BYTES_LIST_LE16(40U)),
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT, 1U),
},
.meta_len = (5 + 1) + (LONG_META_LEN + 1U),
.meta = {

4
tests/bsim/bluetooth/audio/src/cap_acceptor_test.c
View file

@ -37,8 +37,8 @@ static uint32_t broadcaster_broadcast_id;
static struct audio_test_stream broadcast_sink_streams[CONFIG_BT_BAP_BROADCAST_SNK_STREAM_COUNT];
static const struct bt_audio_codec_cap codec_cap = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_ANY,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2,
BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_ANY,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2,
(BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | BT_AUDIO_CONTEXT_TYPE_MEDIA));
static const struct bt_audio_codec_qos_pref unicast_qos_pref =

14
tests/bsim/bluetooth/audio/src/cap_initiator_broadcast_test.c
View file

@ -291,8 +291,8 @@ static void stop_and_delete_extended_adv(struct bt_le_ext_adv *adv)
static void test_broadcast_audio_create_inval(void)
{
uint8_t bis_codec_data[] = {3, BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)};
uint8_t bis_codec_data[] = {3, BT_AUDIO_CODEC_CFG_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_16KHZ)};
struct bt_cap_initiator_broadcast_stream_param
stream_params[ARRAY_SIZE(broadcast_source_streams)];
struct bt_cap_initiator_broadcast_subgroup_param subgroup_param;
@ -350,8 +350,8 @@ static void test_broadcast_audio_create_inval(void)
static void test_broadcast_audio_create(struct bt_cap_broadcast_source **broadcast_source)
{
uint8_t bis_codec_data[] = {3, BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_16KHZ)};
uint8_t bis_codec_data[] = {3, BT_AUDIO_CODEC_CFG_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_16KHZ)};
struct bt_cap_initiator_broadcast_stream_param
stream_params[ARRAY_SIZE(broadcast_source_streams)];
struct bt_cap_initiator_broadcast_subgroup_param subgroup_param;
@ -677,11 +677,11 @@ static int test_cap_initiator_ac(const struct cap_initiator_ac_param *param)
{
struct bt_cap_initiator_broadcast_stream_param stream_params[CAP_AC_MAX_STREAM] = {0};
uint8_t stereo_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_RIGHT | BT_AUDIO_LOCATION_FRONT_LEFT)};
uint8_t right_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t right_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_RIGHT)};
uint8_t left_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t left_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_LEFT)};
struct bt_cap_initiator_broadcast_subgroup_param subgroup_param = {0};
struct bt_cap_initiator_broadcast_create_param create_param = {0};

6
tests/bsim/bluetooth/audio/src/gmap_ugg_test.c
View file

@ -1168,11 +1168,11 @@ static void broadcast_audio_delete(struct bt_cap_broadcast_source *broadcast_sou
static int test_gmap_ugg_broadcast_ac(const struct gmap_broadcast_ac_param *param)
{
uint8_t stereo_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_RIGHT | BT_AUDIO_LOCATION_FRONT_LEFT)};
uint8_t right_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t right_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_RIGHT)};
uint8_t left_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_CHAN_ALLOC,
uint8_t left_data[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
BT_AUDIO_LOCATION_FRONT_LEFT)};
struct bt_cap_initiator_broadcast_subgroup_param subgroup_param = {0};
struct bt_cap_initiator_broadcast_create_param create_param = {0};

4
tests/bsim/bluetooth/audio/src/gmap_ugt_test.c
View file

@ -22,8 +22,8 @@ extern enum bst_result_t bst_result;
static uint8_t csis_rank = 1;
static struct bt_audio_codec_cap codec_cap =
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_LC3_FREQ_ANY, BT_AUDIO_CODEC_LC3_DURATION_ANY,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2, CONTEXT);
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_CAP_FREQ_ANY, BT_AUDIO_CODEC_CAP_DURATION_ANY,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1, 2), 30, 240, 2, CONTEXT);
static const struct bt_audio_codec_qos_pref unicast_qos_pref =
BT_AUDIO_CODEC_QOS_PREF(true, BT_GAP_LE_PHY_2M, 0U, 60U, 10000U, 60000U, 10000U, 60000U);

12
tests/bsim/bluetooth/audio/src/pacs_notify_server_test.c
View file

@ -14,14 +14,14 @@ LOG_MODULE_REGISTER(pacs_notify_server_test, LOG_LEVEL_DBG);
extern enum bst_result_t bst_result;
static struct bt_audio_codec_cap lc3_codec_1 =
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_LC3_FREQ_16KHZ | BT_AUDIO_CODEC_LC3_FREQ_24KHZ,
BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_CAP_FREQ_16KHZ | BT_AUDIO_CODEC_CAP_FREQ_24KHZ,
BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
BT_AUDIO_CONTEXT_TYPE_ANY);
static struct bt_audio_codec_cap lc3_codec_2 =
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_LC3_FREQ_16KHZ,
BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_CAP_FREQ_16KHZ,
BT_AUDIO_CODEC_CAP_DURATION_10,
BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 60u, 1u,
BT_AUDIO_CONTEXT_TYPE_ANY);
static struct bt_pacs_cap caps_1 = {
.codec_cap = &lc3_codec_1,

12
tests/bsim/bluetooth/audio/src/pbp_public_broadcast_sink_test.c
View file

@ -38,13 +38,11 @@ static struct bt_le_per_adv_sync *bcast_pa_sync;
static struct bt_bap_stream streams[CONFIG_BT_BAP_BROADCAST_SNK_STREAM_COUNT];
static struct bt_bap_stream *streams_p[ARRAY_SIZE(streams)];
static const struct bt_audio_codec_cap codec =
BT_AUDIO_CODEC_CAP_LC3(BT_AUDIO_CODEC_LC3_FREQ_16KHZ | BT_AUDIO_CODEC_LC3_FREQ_24KHZ
| BT_AUDIO_CODEC_LC3_FREQ_48KHZ,
BT_AUDIO_CODEC_LC3_DURATION_10,
BT_AUDIO_CODEC_LC3_CHAN_COUNT_SUPPORT(1), 40u, 155u, 1u,
BT_AUDIO_CONTEXT_TYPE_MEDIA
);
static const struct bt_audio_codec_cap codec = BT_AUDIO_CODEC_CAP_LC3(
BT_AUDIO_CODEC_CAP_FREQ_16KHZ | BT_AUDIO_CODEC_CAP_FREQ_24KHZ |
BT_AUDIO_CODEC_CAP_FREQ_48KHZ,
BT_AUDIO_CODEC_CAP_DURATION_10, BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(1), 40u, 155u, 1u,
BT_AUDIO_CONTEXT_TYPE_MEDIA);
/* Create a mask for the maximum BIS we can sync to using the number of streams
* we have. We add an additional 1 since the bis indexes start from 1 and not

4
tests/bsim/bluetooth/audio/src/pbp_public_broadcast_source_test.c
View file

@ -39,8 +39,8 @@ const uint8_t pba_metadata[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_METADATA_TYPE_PROGRAM_INFO, PBS_DEMO)};
static uint8_t bis_codec_data[] = {
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CONFIG_LC3_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CONFIG_LC3_FREQ_48KHZ))};
BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_FREQ,
BT_BYTES_LIST_LE16(BT_AUDIO_CODEC_CFG_FREQ_48KHZ))};
static struct bt_cap_stream broadcast_source_stream;
static struct bt_cap_stream *broadcast_stream;