audio.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2020 Intel Corporation
 * Copyright (c) 2020-2024 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_AUDIO_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_AUDIO_H_

 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/audio/lc3.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/buf.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/iso.h>
#include <zephyr/sys/atomic.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/util_macro.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define BT_AUDIO_BROADCAST_ID_SIZE               3
#define BT_AUDIO_BROADCAST_ID_MAX                0xFFFFFFU
#define BT_AUDIO_PD_PREF_NONE                    0x000000U
#define BT_AUDIO_PD_MAX                          0xFFFFFFU
#define BT_AUDIO_RTN_PREF_NONE                   0xFFU
#define BT_AUDIO_BROADCAST_NAME_LEN_MIN          4
#define BT_AUDIO_BROADCAST_NAME_LEN_MAX          128

#define BT_AUDIO_LANG_SIZE 3

enum bt_audio_codec_cap_type {
        BT_AUDIO_CODEC_CAP_TYPE_FREQ = 0x01,

        BT_AUDIO_CODEC_CAP_TYPE_DURATION = 0x02,

        BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT = 0x03,

        BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN = 0x04,

        BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT = 0x05,
};
enum bt_audio_codec_cap_type {…};

enum bt_audio_codec_cap_freq {
        BT_AUDIO_CODEC_CAP_FREQ_8KHZ = BIT(0),

        BT_AUDIO_CODEC_CAP_FREQ_11KHZ = BIT(1),

        BT_AUDIO_CODEC_CAP_FREQ_16KHZ = BIT(2),

        BT_AUDIO_CODEC_CAP_FREQ_22KHZ = BIT(3),

        BT_AUDIO_CODEC_CAP_FREQ_24KHZ = BIT(4),

        BT_AUDIO_CODEC_CAP_FREQ_32KHZ = BIT(5),

        BT_AUDIO_CODEC_CAP_FREQ_44KHZ = BIT(6),

        BT_AUDIO_CODEC_CAP_FREQ_48KHZ = BIT(7),

        BT_AUDIO_CODEC_CAP_FREQ_88KHZ = BIT(8),

        BT_AUDIO_CODEC_CAP_FREQ_96KHZ = BIT(9),

        BT_AUDIO_CODEC_CAP_FREQ_176KHZ = BIT(10),

        BT_AUDIO_CODEC_CAP_FREQ_192KHZ = BIT(11),

        BT_AUDIO_CODEC_CAP_FREQ_384KHZ = BIT(12),

        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),
};
enum bt_audio_codec_cap_freq {…};

enum bt_audio_codec_cap_frame_dur {
        BT_AUDIO_CODEC_CAP_DURATION_7_5 = BIT(0),

        BT_AUDIO_CODEC_CAP_DURATION_10 = BIT(1),

        BT_AUDIO_CODEC_CAP_DURATION_ANY =
                (BT_AUDIO_CODEC_CAP_DURATION_7_5 | BT_AUDIO_CODEC_CAP_DURATION_10),

        BT_AUDIO_CODEC_CAP_DURATION_PREFER_7_5 = BIT(4),

        BT_AUDIO_CODEC_CAP_DURATION_PREFER_10 = BIT(5),
};
enum bt_audio_codec_cap_frame_dur {…};

enum bt_audio_codec_cap_chan_count {
        BT_AUDIO_CODEC_CAP_CHAN_COUNT_1 = BIT(0),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_2 = BIT(1),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_3 = BIT(2),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_4 = BIT(3),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_5 = BIT(4),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_6 = BIT(5),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_7 = BIT(6),

        BT_AUDIO_CODEC_CAP_CHAN_COUNT_8 = BIT(7),

        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),
};
enum bt_audio_codec_cap_chan_count {…};

#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_MIN 1
#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_MAX 8

#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(...)                                                 \
        ((enum bt_audio_codec_cap_chan_count)((FOR_EACH(BIT, (|), __VA_ARGS__)) >> 1))
#define BT_AUDIO_CODEC_CAP_CHAN_COUNT_SUPPORT(...)                                                 \ …

struct bt_audio_codec_octets_per_codec_frame {
        uint16_t min;
        uint16_t max;
};
struct bt_audio_codec_octets_per_codec_frame {…};

enum bt_audio_codec_cfg_type {
        BT_AUDIO_CODEC_CFG_FREQ = 0x01,

        BT_AUDIO_CODEC_CFG_DURATION = 0x02,

        BT_AUDIO_CODEC_CFG_CHAN_ALLOC = 0x03,

        BT_AUDIO_CODEC_CFG_FRAME_LEN = 0x04,

        BT_AUDIO_CODEC_CFG_FRAME_BLKS_PER_SDU = 0x05,
};
enum bt_audio_codec_cfg_type {…};

enum bt_audio_codec_cfg_freq {
        BT_AUDIO_CODEC_CFG_FREQ_8KHZ = 0x01,

        BT_AUDIO_CODEC_CFG_FREQ_11KHZ = 0x02,

        BT_AUDIO_CODEC_CFG_FREQ_16KHZ = 0x03,

        BT_AUDIO_CODEC_CFG_FREQ_22KHZ = 0x04,

        BT_AUDIO_CODEC_CFG_FREQ_24KHZ = 0x05,

        BT_AUDIO_CODEC_CFG_FREQ_32KHZ = 0x06,

        BT_AUDIO_CODEC_CFG_FREQ_44KHZ = 0x07,

        BT_AUDIO_CODEC_CFG_FREQ_48KHZ = 0x08,

        BT_AUDIO_CODEC_CFG_FREQ_88KHZ = 0x09,

        BT_AUDIO_CODEC_CFG_FREQ_96KHZ = 0x0a,

        BT_AUDIO_CODEC_CFG_FREQ_176KHZ = 0x0b,

        BT_AUDIO_CODEC_CFG_FREQ_192KHZ = 0x0c,

        BT_AUDIO_CODEC_CFG_FREQ_384KHZ = 0x0d,
};
enum bt_audio_codec_cfg_freq {…};

enum bt_audio_codec_cfg_frame_dur {
        BT_AUDIO_CODEC_CFG_DURATION_7_5 = 0x00,

        BT_AUDIO_CODEC_CFG_DURATION_10 = 0x01,
};
enum bt_audio_codec_cfg_frame_dur {…};

enum bt_audio_context {
        BT_AUDIO_CONTEXT_TYPE_NONE = 0,
        BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED = BIT(0),
        BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL = BIT(1),
        BT_AUDIO_CONTEXT_TYPE_MEDIA = BIT(2),
        BT_AUDIO_CONTEXT_TYPE_GAME = BIT(3),
        BT_AUDIO_CONTEXT_TYPE_INSTRUCTIONAL = BIT(4),
        BT_AUDIO_CONTEXT_TYPE_VOICE_ASSISTANTS = BIT(5),
        BT_AUDIO_CONTEXT_TYPE_LIVE = BIT(6),
        BT_AUDIO_CONTEXT_TYPE_SOUND_EFFECTS = BIT(7),
        BT_AUDIO_CONTEXT_TYPE_NOTIFICATIONS = BIT(8),
        BT_AUDIO_CONTEXT_TYPE_RINGTONE = BIT(9),
        BT_AUDIO_CONTEXT_TYPE_ALERTS = BIT(10),
        BT_AUDIO_CONTEXT_TYPE_EMERGENCY_ALARM = BIT(11),
};
enum bt_audio_context {…};

#define BT_AUDIO_CONTEXT_TYPE_ANY        (BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED | \
                                          BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL | \
                                          BT_AUDIO_CONTEXT_TYPE_MEDIA | \
                                          BT_AUDIO_CONTEXT_TYPE_GAME | \
                                          BT_AUDIO_CONTEXT_TYPE_INSTRUCTIONAL | \
                                          BT_AUDIO_CONTEXT_TYPE_VOICE_ASSISTANTS | \
                                          BT_AUDIO_CONTEXT_TYPE_LIVE | \
                                          BT_AUDIO_CONTEXT_TYPE_SOUND_EFFECTS | \
                                          BT_AUDIO_CONTEXT_TYPE_NOTIFICATIONS | \
                                          BT_AUDIO_CONTEXT_TYPE_RINGTONE | \
                                          BT_AUDIO_CONTEXT_TYPE_ALERTS | \
                                          BT_AUDIO_CONTEXT_TYPE_EMERGENCY_ALARM)
#define BT_AUDIO_CONTEXT_TYPE_ANY        (BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED | \ …

enum bt_audio_parental_rating {
        BT_AUDIO_PARENTAL_RATING_NO_RATING        = 0x00,
        BT_AUDIO_PARENTAL_RATING_AGE_ANY          = 0x01,
        BT_AUDIO_PARENTAL_RATING_AGE_5_OR_ABOVE   = 0x02,
        BT_AUDIO_PARENTAL_RATING_AGE_6_OR_ABOVE   = 0x03,
        BT_AUDIO_PARENTAL_RATING_AGE_7_OR_ABOVE   = 0x04,
        BT_AUDIO_PARENTAL_RATING_AGE_8_OR_ABOVE   = 0x05,
        BT_AUDIO_PARENTAL_RATING_AGE_9_OR_ABOVE   = 0x06,
        BT_AUDIO_PARENTAL_RATING_AGE_10_OR_ABOVE  = 0x07,
        BT_AUDIO_PARENTAL_RATING_AGE_11_OR_ABOVE  = 0x08,
        BT_AUDIO_PARENTAL_RATING_AGE_12_OR_ABOVE  = 0x09,
        BT_AUDIO_PARENTAL_RATING_AGE_13_OR_ABOVE  = 0x0A,
        BT_AUDIO_PARENTAL_RATING_AGE_14_OR_ABOVE  = 0x0B,
        BT_AUDIO_PARENTAL_RATING_AGE_15_OR_ABOVE  = 0x0C,
        BT_AUDIO_PARENTAL_RATING_AGE_16_OR_ABOVE  = 0x0D,
        BT_AUDIO_PARENTAL_RATING_AGE_17_OR_ABOVE  = 0x0E,
        BT_AUDIO_PARENTAL_RATING_AGE_18_OR_ABOVE  = 0x0F
};
enum bt_audio_parental_rating {…};

enum bt_audio_active_state {
        BT_AUDIO_ACTIVE_STATE_DISABLED       = 0x00,
        BT_AUDIO_ACTIVE_STATE_ENABLED        = 0x01,
};
enum bt_audio_active_state {…};

enum bt_audio_assisted_listening_stream {
        BT_AUDIO_ASSISTED_LISTENING_STREAM_UNSPECIFIED = 0x00,
};
enum bt_audio_assisted_listening_stream {…};

enum bt_audio_metadata_type {
        BT_AUDIO_METADATA_TYPE_PREF_CONTEXT = 0x01,

        BT_AUDIO_METADATA_TYPE_STREAM_CONTEXT = 0x02,

        BT_AUDIO_METADATA_TYPE_PROGRAM_INFO = 0x03,

        BT_AUDIO_METADATA_TYPE_LANG = 0x04,

        BT_AUDIO_METADATA_TYPE_CCID_LIST = 0x05,

        BT_AUDIO_METADATA_TYPE_PARENTAL_RATING = 0x06,

        BT_AUDIO_METADATA_TYPE_PROGRAM_INFO_URI = 0x07,

        BT_AUDIO_METADATA_TYPE_AUDIO_STATE = 0x08,

        BT_AUDIO_METADATA_TYPE_BROADCAST_IMMEDIATE = 0x09,

        BT_AUDIO_METADATA_TYPE_ASSISTED_LISTENING_STREAM = 0x0A,

        BT_AUDIO_METADATA_TYPE_BROADCAST_NAME = 0x0B,

        BT_AUDIO_METADATA_TYPE_EXTENDED = 0xFE,

        BT_AUDIO_METADATA_TYPE_VENDOR = 0xFF,
};
enum bt_audio_metadata_type {…};

#define BT_AUDIO_METADATA_TYPE_IS_KNOWN(_type)                                                     \
        (IN_RANGE((_type), BT_AUDIO_METADATA_TYPE_PREF_CONTEXT,                                    \
                  BT_AUDIO_METADATA_TYPE_BROADCAST_IMMEDIATE) ||                                   \
         (_type) == BT_AUDIO_METADATA_TYPE_EXTENDED || (_type) == BT_AUDIO_METADATA_TYPE_VENDOR)
#define BT_AUDIO_METADATA_TYPE_IS_KNOWN(_type)                                                     \ …

#define BT_AUDIO_UNICAST_ANNOUNCEMENT_GENERAL    0x00
#define BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED   0x01

#define BT_AUDIO_CODEC_DATA(_type, _bytes...)                                                      \
        (sizeof((uint8_t)_type) + sizeof((uint8_t[]){_bytes})), (_type), _bytes
#define BT_AUDIO_CODEC_DATA(_type, _bytes...)                                                      \ …

#define BT_AUDIO_CODEC_CFG(_id, _cid, _vid, _data, _meta)                                          \
        ((struct bt_audio_codec_cfg){                                                              \
                /* Use HCI data path as default, can be overwritten by application */              \
                .path_id = BT_ISO_DATA_PATH_HCI,                                                   \
                .ctlr_transcode = false,                                                           \
                COND_CODE_1(IS_ENABLED(CONFIG_BT_BAP_UNICAST),                                     \
                            (.target_latency = BT_AUDIO_CODEC_CFG_TARGET_LATENCY_BALANCED,         \
                             .target_phy = BT_AUDIO_CODEC_CFG_TARGET_PHY_2M,),                     \
                            ())                                                                    \
                .id = _id,                                                                         \
                .cid = _cid,                                                                       \
                .vid = _vid,                                                                       \
                .data_len = sizeof((uint8_t[])_data),                                              \
                .data = _data,                                                                     \
                .meta_len = sizeof((uint8_t[])_meta),                                              \
                .meta = _meta,                                                                     \
        })
#define BT_AUDIO_CODEC_CFG(_id, _cid, _vid, _data, _meta)                                          \ …

#define BT_AUDIO_CODEC_CAP(_id, _cid, _vid, _data, _meta)                                          \
        ((struct bt_audio_codec_cap){                                                              \
                /* Use HCI data path as default, can be overwritten by application */              \
                .path_id = BT_ISO_DATA_PATH_HCI,                                                   \
                .ctlr_transcode = false,                                                           \
                .id = (_id),                                                                       \
                .cid = (_cid),                                                                     \
                .vid = (_vid),                                                                     \
                .data_len = sizeof((uint8_t[])_data),                                              \
                .data = _data,                                                                     \
                .meta_len = sizeof((uint8_t[])_meta),                                              \
                .meta = _meta,                                                                     \
        })
#define BT_AUDIO_CODEC_CAP(_id, _cid, _vid, _data, _meta)                                          \ …

enum bt_audio_location {
        BT_AUDIO_LOCATION_MONO_AUDIO = 0,
        BT_AUDIO_LOCATION_FRONT_LEFT = BIT(0),
        BT_AUDIO_LOCATION_FRONT_RIGHT = BIT(1),
        BT_AUDIO_LOCATION_FRONT_CENTER = BIT(2),
        BT_AUDIO_LOCATION_LOW_FREQ_EFFECTS_1 = BIT(3),
        BT_AUDIO_LOCATION_BACK_LEFT = BIT(4),
        BT_AUDIO_LOCATION_BACK_RIGHT = BIT(5),
        BT_AUDIO_LOCATION_FRONT_LEFT_OF_CENTER = BIT(6),
        BT_AUDIO_LOCATION_FRONT_RIGHT_OF_CENTER = BIT(7),
        BT_AUDIO_LOCATION_BACK_CENTER = BIT(8),
        BT_AUDIO_LOCATION_LOW_FREQ_EFFECTS_2 = BIT(9),
        BT_AUDIO_LOCATION_SIDE_LEFT = BIT(10),
        BT_AUDIO_LOCATION_SIDE_RIGHT = BIT(11),
        BT_AUDIO_LOCATION_TOP_FRONT_LEFT = BIT(12),
        BT_AUDIO_LOCATION_TOP_FRONT_RIGHT = BIT(13),
        BT_AUDIO_LOCATION_TOP_FRONT_CENTER = BIT(14),
        BT_AUDIO_LOCATION_TOP_CENTER = BIT(15),
        BT_AUDIO_LOCATION_TOP_BACK_LEFT = BIT(16),
        BT_AUDIO_LOCATION_TOP_BACK_RIGHT = BIT(17),
        BT_AUDIO_LOCATION_TOP_SIDE_LEFT = BIT(18),
        BT_AUDIO_LOCATION_TOP_SIDE_RIGHT = BIT(19),
        BT_AUDIO_LOCATION_TOP_BACK_CENTER = BIT(20),
        BT_AUDIO_LOCATION_BOTTOM_FRONT_CENTER = BIT(21),
        BT_AUDIO_LOCATION_BOTTOM_FRONT_LEFT = BIT(22),
        BT_AUDIO_LOCATION_BOTTOM_FRONT_RIGHT = BIT(23),
        BT_AUDIO_LOCATION_FRONT_LEFT_WIDE = BIT(24),
        BT_AUDIO_LOCATION_FRONT_RIGHT_WIDE = BIT(25),
        BT_AUDIO_LOCATION_LEFT_SURROUND = BIT(26),
        BT_AUDIO_LOCATION_RIGHT_SURROUND = BIT(27),
};
enum bt_audio_location {…};

#define BT_AUDIO_LOCATION_ANY (BT_AUDIO_LOCATION_FRONT_LEFT | \
                               BT_AUDIO_LOCATION_FRONT_RIGHT | \
                               BT_AUDIO_LOCATION_FRONT_CENTER | \
                               BT_AUDIO_LOCATION_LOW_FREQ_EFFECTS_1 | \
                               BT_AUDIO_LOCATION_BACK_LEFT | \
                               BT_AUDIO_LOCATION_BACK_RIGHT | \
                               BT_AUDIO_LOCATION_FRONT_LEFT_OF_CENTER | \
                               BT_AUDIO_LOCATION_FRONT_RIGHT_OF_CENTER | \
                               BT_AUDIO_LOCATION_BACK_CENTER | \
                               BT_AUDIO_LOCATION_LOW_FREQ_EFFECTS_2 | \
                               BT_AUDIO_LOCATION_SIDE_LEFT | \
                               BT_AUDIO_LOCATION_SIDE_RIGHT | \
                               BT_AUDIO_LOCATION_TOP_FRONT_LEFT | \
                               BT_AUDIO_LOCATION_TOP_FRONT_RIGHT | \
                               BT_AUDIO_LOCATION_TOP_FRONT_CENTER | \
                               BT_AUDIO_LOCATION_TOP_CENTER | \
                               BT_AUDIO_LOCATION_TOP_BACK_LEFT | \
                               BT_AUDIO_LOCATION_TOP_BACK_RIGHT | \
                               BT_AUDIO_LOCATION_TOP_SIDE_LEFT | \
                               BT_AUDIO_LOCATION_TOP_SIDE_RIGHT | \
                               BT_AUDIO_LOCATION_TOP_BACK_CENTER | \
                               BT_AUDIO_LOCATION_BOTTOM_FRONT_CENTER | \
                               BT_AUDIO_LOCATION_BOTTOM_FRONT_LEFT | \
                               BT_AUDIO_LOCATION_BOTTOM_FRONT_RIGHT | \
                               BT_AUDIO_LOCATION_FRONT_LEFT_WIDE | \
                               BT_AUDIO_LOCATION_FRONT_RIGHT_WIDE | \
                               BT_AUDIO_LOCATION_LEFT_SURROUND | \
                               BT_AUDIO_LOCATION_RIGHT_SURROUND)
#define BT_AUDIO_LOCATION_ANY (BT_AUDIO_LOCATION_FRONT_LEFT | \ …

struct bt_audio_codec_cap {
        uint8_t path_id;
        bool ctlr_transcode;
        uint8_t id;
        uint16_t cid;
        uint16_t vid;
#if CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE > 0 || defined(__DOXYGEN__)
        size_t data_len;
        uint8_t data[CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE];
#endif /* CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE > 0 */
#if defined(CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE) || defined(__DOXYGEN__)
        size_t meta_len;
        uint8_t meta[CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE];
#endif /* CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE */
};
struct bt_audio_codec_cap {…};

enum bt_audio_codec_cfg_target_latency {
        BT_AUDIO_CODEC_CFG_TARGET_LATENCY_LOW = 0x01,

        BT_AUDIO_CODEC_CFG_TARGET_LATENCY_BALANCED = 0x02,

        BT_AUDIO_CODEC_CFG_TARGET_LATENCY_HIGH = 0x03,
};
enum bt_audio_codec_cfg_target_latency {…};

enum bt_audio_codec_cfg_target_phy {
        BT_AUDIO_CODEC_CFG_TARGET_PHY_1M = 0x01,

        BT_AUDIO_CODEC_CFG_TARGET_PHY_2M = 0x02,

        BT_AUDIO_CODEC_CFG_TARGET_PHY_CODED = 0x03,
};
enum bt_audio_codec_cfg_target_phy {…};

struct bt_audio_codec_cfg {
        uint8_t path_id;
        bool ctlr_transcode;
#if defined(CONFIG_BT_BAP_UNICAST)
        enum bt_audio_codec_cfg_target_latency target_latency;
        enum bt_audio_codec_cfg_target_phy target_phy;
#endif /* CONFIG_BT_BAP_UNICAST */
        uint8_t  id;
        uint16_t cid;
        uint16_t vid;
#if CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 || defined(__DOXYGEN__)
        size_t data_len;
        uint8_t data[CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE];
#endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 */
#if CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 || defined(__DOXYGEN__)
        size_t meta_len;
        uint8_t meta[CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE];
#endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 */
};
struct bt_audio_codec_cfg {…};

int bt_audio_data_parse(const uint8_t ltv[], size_t size,
                        bool (*func)(struct bt_data *data, void *user_data), void *user_data);

int bt_audio_data_get_val(const uint8_t ltv_data[], size_t size, uint8_t type,
                          const uint8_t **data);

uint8_t bt_audio_get_chan_count(enum bt_audio_location chan_allocation);

enum bt_audio_dir {
        BT_AUDIO_DIR_SINK = 0x01,
        BT_AUDIO_DIR_SOURCE = 0x02,
};
enum bt_audio_dir {…};


int bt_audio_codec_cfg_freq_to_freq_hz(enum bt_audio_codec_cfg_freq freq);

int bt_audio_codec_cfg_freq_hz_to_freq(uint32_t freq_hz);

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_cfg_freq freq);

int bt_audio_codec_cfg_frame_dur_to_frame_dur_us(enum bt_audio_codec_cfg_frame_dur frame_dur);

int bt_audio_codec_cfg_frame_dur_us_to_frame_dur(uint32_t frame_dur_us);

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_cfg_frame_dur frame_dur);

int bt_audio_codec_cfg_get_chan_allocation(const struct bt_audio_codec_cfg *codec_cfg,
                                           enum bt_audio_location *chan_allocation,
                                           bool fallback_to_default);

int bt_audio_codec_cfg_set_chan_allocation(struct bt_audio_codec_cfg *codec_cfg,
                                           enum bt_audio_location chan_allocation);

int bt_audio_codec_cfg_get_octets_per_frame(const struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_set_octets_per_frame(struct bt_audio_codec_cfg *codec_cfg,
                                            uint16_t octets_per_frame);

int bt_audio_codec_cfg_get_frame_blocks_per_sdu(const struct bt_audio_codec_cfg *codec_cfg,
                                                bool fallback_to_default);

int bt_audio_codec_cfg_set_frame_blocks_per_sdu(struct bt_audio_codec_cfg *codec_cfg,
                                                uint8_t frame_blocks);

int bt_audio_codec_cfg_get_val(const struct bt_audio_codec_cfg *codec_cfg,
                               enum bt_audio_codec_cfg_type type, const uint8_t **data);

int bt_audio_codec_cfg_set_val(struct bt_audio_codec_cfg *codec_cfg,
                               enum bt_audio_codec_cfg_type type, const uint8_t *data,
                               size_t data_len);

int bt_audio_codec_cfg_unset_val(struct bt_audio_codec_cfg *codec_cfg,
                                 enum bt_audio_codec_cfg_type type);

int bt_audio_codec_cfg_meta_get_val(const struct bt_audio_codec_cfg *codec_cfg, uint8_t type,
                                    const uint8_t **data);

int bt_audio_codec_cfg_meta_set_val(struct bt_audio_codec_cfg *codec_cfg,
                                    enum bt_audio_metadata_type type, const uint8_t *data,
                                    size_t data_len);

int bt_audio_codec_cfg_meta_unset_val(struct bt_audio_codec_cfg *codec_cfg,
                                      enum bt_audio_metadata_type type);
int bt_audio_codec_cfg_meta_get_pref_context(const struct bt_audio_codec_cfg *codec_cfg,
                                             bool fallback_to_default);

int bt_audio_codec_cfg_meta_set_pref_context(struct bt_audio_codec_cfg *codec_cfg,
                                             enum bt_audio_context ctx);

int bt_audio_codec_cfg_meta_get_stream_context(const struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_meta_set_stream_context(struct bt_audio_codec_cfg *codec_cfg,
                                               enum bt_audio_context ctx);

int bt_audio_codec_cfg_meta_get_program_info(const struct bt_audio_codec_cfg *codec_cfg,
                                             const uint8_t **program_info);

int bt_audio_codec_cfg_meta_set_program_info(struct bt_audio_codec_cfg *codec_cfg,
                                             const uint8_t *program_info, size_t program_info_len);

int bt_audio_codec_cfg_meta_get_lang(const struct bt_audio_codec_cfg *codec_cfg,
                                     const uint8_t **lang);

int bt_audio_codec_cfg_meta_set_lang(struct bt_audio_codec_cfg *codec_cfg,
                                     const uint8_t lang[BT_AUDIO_LANG_SIZE]);

int bt_audio_codec_cfg_meta_get_ccid_list(const struct bt_audio_codec_cfg *codec_cfg,
                                          const uint8_t **ccid_list);

int bt_audio_codec_cfg_meta_set_ccid_list(struct bt_audio_codec_cfg *codec_cfg,
                                          const uint8_t *ccid_list, size_t ccid_list_len);

int bt_audio_codec_cfg_meta_get_parental_rating(const struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_meta_set_parental_rating(struct bt_audio_codec_cfg *codec_cfg,
                                                enum bt_audio_parental_rating parental_rating);

int bt_audio_codec_cfg_meta_get_program_info_uri(const struct bt_audio_codec_cfg *codec_cfg,
                                                 const uint8_t **program_info_uri);

int bt_audio_codec_cfg_meta_set_program_info_uri(struct bt_audio_codec_cfg *codec_cfg,
                                                 const uint8_t *program_info_uri,
                                                 size_t program_info_uri_len);

int bt_audio_codec_cfg_meta_get_audio_active_state(const struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_meta_set_audio_active_state(struct bt_audio_codec_cfg *codec_cfg,
                                                   enum bt_audio_active_state state);

int bt_audio_codec_cfg_meta_get_bcast_audio_immediate_rend_flag(
        const struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_meta_set_bcast_audio_immediate_rend_flag(
        struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_meta_get_assisted_listening_stream(
        const struct bt_audio_codec_cfg *codec_cfg);

int bt_audio_codec_cfg_meta_set_assisted_listening_stream(
        struct bt_audio_codec_cfg *codec_cfg, enum bt_audio_assisted_listening_stream val);

int bt_audio_codec_cfg_meta_get_broadcast_name(const struct bt_audio_codec_cfg *codec_cfg,
                                               const uint8_t **broadcast_name);

int bt_audio_codec_cfg_meta_set_broadcast_name(struct bt_audio_codec_cfg *codec_cfg,
                                               const uint8_t *broadcast_name,
                                               size_t broadcast_name_len);

int bt_audio_codec_cfg_meta_get_extended(const struct bt_audio_codec_cfg *codec_cfg,
                                         const uint8_t **extended_meta);

int bt_audio_codec_cfg_meta_set_extended(struct bt_audio_codec_cfg *codec_cfg,
                                         const uint8_t *extended_meta, size_t extended_meta_len);

int bt_audio_codec_cfg_meta_get_vendor(const struct bt_audio_codec_cfg *codec_cfg,
                                       const uint8_t **vendor_meta);

int bt_audio_codec_cfg_meta_set_vendor(struct bt_audio_codec_cfg *codec_cfg,
                                       const uint8_t *vendor_meta, size_t vendor_meta_len); /* End of bt_audio_codec_cfg */


int bt_audio_codec_cap_get_val(const struct bt_audio_codec_cap *codec_cap,
                               enum bt_audio_codec_cap_type type, const uint8_t **data);

int bt_audio_codec_cap_set_val(struct bt_audio_codec_cap *codec_cap,
                               enum bt_audio_codec_cap_type type, const uint8_t *data,
                               size_t data_len);

int bt_audio_codec_cap_unset_val(struct bt_audio_codec_cap *codec_cap,
                                 enum bt_audio_codec_cap_type type);

int bt_audio_codec_cap_get_freq(const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_set_freq(struct bt_audio_codec_cap *codec_cap,
                                enum bt_audio_codec_cap_freq freq);

int bt_audio_codec_cap_get_frame_dur(const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_set_frame_dur(struct bt_audio_codec_cap *codec_cap,
                                     enum bt_audio_codec_cap_frame_dur frame_dur);

int bt_audio_codec_cap_get_supported_audio_chan_counts(const struct bt_audio_codec_cap *codec_cap,
                                                       bool fallback_to_default);

int bt_audio_codec_cap_set_supported_audio_chan_counts(
        struct bt_audio_codec_cap *codec_cap, enum bt_audio_codec_cap_chan_count chan_count);

int bt_audio_codec_cap_get_octets_per_frame(
        const struct bt_audio_codec_cap *codec_cap,
        struct bt_audio_codec_octets_per_codec_frame *codec_frame);

int bt_audio_codec_cap_set_octets_per_frame(
        struct bt_audio_codec_cap *codec_cap,
        const struct bt_audio_codec_octets_per_codec_frame *codec_frame);

int bt_audio_codec_cap_get_max_codec_frames_per_sdu(const struct bt_audio_codec_cap *codec_cap,
                                                    bool fallback_to_default);

int bt_audio_codec_cap_set_max_codec_frames_per_sdu(struct bt_audio_codec_cap *codec_cap,
                                                    uint8_t codec_frames_per_sdu);

int bt_audio_codec_cap_meta_get_val(const struct bt_audio_codec_cap *codec_cap, uint8_t type,
                                    const uint8_t **data);

int bt_audio_codec_cap_meta_set_val(struct bt_audio_codec_cap *codec_cap,
                                    enum bt_audio_metadata_type type, const uint8_t *data,
                                    size_t data_len);

int bt_audio_codec_cap_meta_unset_val(struct bt_audio_codec_cap *codec_cap,
                                      enum bt_audio_metadata_type type);

int bt_audio_codec_cap_meta_get_pref_context(const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_set_pref_context(struct bt_audio_codec_cap *codec_cap,
                                             enum bt_audio_context ctx);

int bt_audio_codec_cap_meta_get_stream_context(const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_set_stream_context(struct bt_audio_codec_cap *codec_cap,
                                               enum bt_audio_context ctx);

int bt_audio_codec_cap_meta_get_program_info(const struct bt_audio_codec_cap *codec_cap,
                                             const uint8_t **program_info);

int bt_audio_codec_cap_meta_set_program_info(struct bt_audio_codec_cap *codec_cap,
                                             const uint8_t *program_info, size_t program_info_len);

int bt_audio_codec_cap_meta_get_lang(const struct bt_audio_codec_cap *codec_cap,
                                     const uint8_t **lang);

int bt_audio_codec_cap_meta_set_lang(struct bt_audio_codec_cap *codec_cap,
                                     const uint8_t lang[BT_AUDIO_LANG_SIZE]);

int bt_audio_codec_cap_meta_get_ccid_list(const struct bt_audio_codec_cap *codec_cap,
                                          const uint8_t **ccid_list);

int bt_audio_codec_cap_meta_set_ccid_list(struct bt_audio_codec_cap *codec_cap,
                                          const uint8_t *ccid_list, size_t ccid_list_len);

int bt_audio_codec_cap_meta_get_parental_rating(const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_set_parental_rating(struct bt_audio_codec_cap *codec_cap,
                                                enum bt_audio_parental_rating parental_rating);

int bt_audio_codec_cap_meta_get_program_info_uri(const struct bt_audio_codec_cap *codec_cap,
                                                 const uint8_t **program_info_uri);

int bt_audio_codec_cap_meta_set_program_info_uri(struct bt_audio_codec_cap *codec_cap,
                                                 const uint8_t *program_info_uri,
                                                 size_t program_info_uri_len);

int bt_audio_codec_cap_meta_get_audio_active_state(const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_set_audio_active_state(struct bt_audio_codec_cap *codec_cap,
                                                   enum bt_audio_active_state state);

int bt_audio_codec_cap_meta_get_bcast_audio_immediate_rend_flag(
        const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_set_bcast_audio_immediate_rend_flag(
        struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_get_assisted_listening_stream(
        const struct bt_audio_codec_cap *codec_cap);

int bt_audio_codec_cap_meta_set_assisted_listening_stream(
        struct bt_audio_codec_cap *codec_cap, enum bt_audio_assisted_listening_stream val);

int bt_audio_codec_cap_meta_get_broadcast_name(const struct bt_audio_codec_cap *codec_cap,
                                               const uint8_t **broadcast_name);

int bt_audio_codec_cap_meta_set_broadcast_name(struct bt_audio_codec_cap *codec_cap,
                                               const uint8_t *broadcast_name,
                                               size_t broadcast_name_len);
int bt_audio_codec_cap_meta_get_extended(const struct bt_audio_codec_cap *codec_cap,
                                         const uint8_t **extended_meta);

int bt_audio_codec_cap_meta_set_extended(struct bt_audio_codec_cap *codec_cap,
                                         const uint8_t *extended_meta, size_t extended_meta_len);

int bt_audio_codec_cap_meta_get_vendor(const struct bt_audio_codec_cap *codec_cap,
                                       const uint8_t **vendor_meta);

int bt_audio_codec_cap_meta_set_vendor(struct bt_audio_codec_cap *codec_cap,
                                       const uint8_t *vendor_meta, size_t vendor_meta_len);
 /* End of bt_audio_codec_cap */


static inline char *bt_audio_context_bit_to_str(enum bt_audio_context context)
{
        switch (context) {
        case BT_AUDIO_CONTEXT_TYPE_NONE:
                return "None";
        case BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED:
                return "Unspecified";
        case BT_AUDIO_CONTEXT_TYPE_CONVERSATIONAL:
                return "Conversational";
        case BT_AUDIO_CONTEXT_TYPE_MEDIA:
                return "Media";
        case BT_AUDIO_CONTEXT_TYPE_GAME:
                return "Game";
        case BT_AUDIO_CONTEXT_TYPE_INSTRUCTIONAL:
                return "Instructional";
        case BT_AUDIO_CONTEXT_TYPE_VOICE_ASSISTANTS:
                return "Voice assistant";
        case BT_AUDIO_CONTEXT_TYPE_LIVE:
                return "Live";
        case BT_AUDIO_CONTEXT_TYPE_SOUND_EFFECTS:
                return "Sound effects";
        case BT_AUDIO_CONTEXT_TYPE_NOTIFICATIONS:
                return "Notifications";
        case BT_AUDIO_CONTEXT_TYPE_RINGTONE:
                return "Ringtone";
        case BT_AUDIO_CONTEXT_TYPE_ALERTS:
                return "Alerts";
        case BT_AUDIO_CONTEXT_TYPE_EMERGENCY_ALARM:
                return "Emergency alarm";
        default:
                return "Unknown context";
        }
}
static inline char *bt_audio_context_bit_to_str(enum bt_audio_context context) {…}

static inline char *bt_audio_parental_rating_to_str(enum bt_audio_parental_rating parental_rating)
{
        switch (parental_rating) {
        case BT_AUDIO_PARENTAL_RATING_NO_RATING:
                return "No rating";
        case BT_AUDIO_PARENTAL_RATING_AGE_ANY:
                return "Any";
        case BT_AUDIO_PARENTAL_RATING_AGE_5_OR_ABOVE:
                return "Age 5 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_6_OR_ABOVE:
                return "Age 6 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_7_OR_ABOVE:
                return "Age 7 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_8_OR_ABOVE:
                return "Age 8 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_9_OR_ABOVE:
                return "Age 9 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_10_OR_ABOVE:
                return "Age 10 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_11_OR_ABOVE:
                return "Age 11 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_12_OR_ABOVE:
                return "Age 12 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_13_OR_ABOVE:
                return "Age 13 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_14_OR_ABOVE:
                return "Age 14 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_15_OR_ABOVE:
                return "Age 15 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_16_OR_ABOVE:
                return "Age 16 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_17_OR_ABOVE:
                return "Age 17 or above";
        case BT_AUDIO_PARENTAL_RATING_AGE_18_OR_ABOVE:
                return "Age 18 or above";
        default:
                return "Unknown rating";
        }
}
static inline char *bt_audio_parental_rating_to_str(enum bt_audio_parental_rating parental_rating) {…}

static inline char *bt_audio_active_state_to_str(enum bt_audio_active_state state)
{
        switch (state) {
        case BT_AUDIO_ACTIVE_STATE_DISABLED:
                return "Disabled";
        case BT_AUDIO_ACTIVE_STATE_ENABLED:
                return "Enabled";
        default:
                return "Unknown active state";
        }
}
static inline char *bt_audio_active_state_to_str(enum bt_audio_active_state state) {…}

static inline char *bt_audio_codec_cap_freq_bit_to_str(enum bt_audio_codec_cap_freq freq)
{
        switch (freq) {
        case BT_AUDIO_CODEC_CAP_FREQ_8KHZ:
                return "8000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_11KHZ:
                return "11025 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_16KHZ:
                return "16000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_22KHZ:
                return "22050 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_24KHZ:
                return "24000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_32KHZ:
                return "32000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_44KHZ:
                return "44100 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_48KHZ:
                return "48000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_88KHZ:
                return "88200 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_96KHZ:
                return "96000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_176KHZ:
                return "176400 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_192KHZ:
                return "192000 Hz";
        case BT_AUDIO_CODEC_CAP_FREQ_384KHZ:
                return "384000 Hz";
        default:
                return "Unknown supported frequency";
        }
}
static inline char *bt_audio_codec_cap_freq_bit_to_str(enum bt_audio_codec_cap_freq freq) {…}

static inline char *
bt_audio_codec_cap_frame_dur_bit_to_str(enum bt_audio_codec_cap_frame_dur frame_dur)
{
        switch (frame_dur) {
        case BT_AUDIO_CODEC_CAP_DURATION_7_5:
                return "7.5 ms";
        case BT_AUDIO_CODEC_CAP_DURATION_10:
                return "10 ms";
        case BT_AUDIO_CODEC_CAP_DURATION_PREFER_7_5:
                return "7.5 ms preferred";
        case BT_AUDIO_CODEC_CAP_DURATION_PREFER_10:
                return "10 ms preferred";
        default:
                return "Unknown frame duration";
        }
}
bt_audio_codec_cap_frame_dur_bit_to_str(enum bt_audio_codec_cap_frame_dur frame_dur) {…}

static inline char *
bt_audio_codec_cap_chan_count_bit_to_str(enum bt_audio_codec_cap_chan_count chan_count)
{
        switch (chan_count) {
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_1:
                return "1 channel";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_2:
                return "2 channels";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_3:
                return "3 channels";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_4:
                return "4 channels";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_5:
                return "5 channels";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_6:
                return "6 channels";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_7:
                return "7 channels";
        case BT_AUDIO_CODEC_CAP_CHAN_COUNT_8:
                return "8 channels";
        default:
                return "Unknown channel count";
        }
}
bt_audio_codec_cap_chan_count_bit_to_str(enum bt_audio_codec_cap_chan_count chan_count) {…}

static inline char *bt_audio_location_bit_to_str(enum bt_audio_location location)
{
        switch (location) {
        case BT_AUDIO_LOCATION_MONO_AUDIO:
                return "Mono";
        case BT_AUDIO_LOCATION_FRONT_LEFT:
                return "Front left";
        case BT_AUDIO_LOCATION_FRONT_RIGHT:
                return "Front right";
        case BT_AUDIO_LOCATION_FRONT_CENTER:
                return "Front center";
        case BT_AUDIO_LOCATION_LOW_FREQ_EFFECTS_1:
                return "Low frequency effects 1";
        case BT_AUDIO_LOCATION_BACK_LEFT:
                return "Back left";
        case BT_AUDIO_LOCATION_BACK_RIGHT:
                return "Back right";
        case BT_AUDIO_LOCATION_FRONT_LEFT_OF_CENTER:
                return "Front left of center";
        case BT_AUDIO_LOCATION_FRONT_RIGHT_OF_CENTER:
                return "Front right of center";
        case BT_AUDIO_LOCATION_BACK_CENTER:
                return "Back center";
        case BT_AUDIO_LOCATION_LOW_FREQ_EFFECTS_2:
                return "Low frequency effects 2";
        case BT_AUDIO_LOCATION_SIDE_LEFT:
                return "Side left";
        case BT_AUDIO_LOCATION_SIDE_RIGHT:
                return "Side right";
        case BT_AUDIO_LOCATION_TOP_FRONT_LEFT:
                return "Top front left";
        case BT_AUDIO_LOCATION_TOP_FRONT_RIGHT:
                return "Top front right";
        case BT_AUDIO_LOCATION_TOP_FRONT_CENTER:
                return "Top front center";
        case BT_AUDIO_LOCATION_TOP_CENTER:
                return "Top center";
        case BT_AUDIO_LOCATION_TOP_BACK_LEFT:
                return "Top back left";
        case BT_AUDIO_LOCATION_TOP_BACK_RIGHT:
                return "Top back right";
        case BT_AUDIO_LOCATION_TOP_SIDE_LEFT:
                return "Top side left";
        case BT_AUDIO_LOCATION_TOP_SIDE_RIGHT:
                return "Top side right";
        case BT_AUDIO_LOCATION_TOP_BACK_CENTER:
                return "Top back center";
        case BT_AUDIO_LOCATION_BOTTOM_FRONT_CENTER:
                return "Bottom front center";
        case BT_AUDIO_LOCATION_BOTTOM_FRONT_LEFT:
                return "Bottom front left";
        case BT_AUDIO_LOCATION_BOTTOM_FRONT_RIGHT:
                return "Bottom front right";
        case BT_AUDIO_LOCATION_FRONT_LEFT_WIDE:
                return "Front left wide";
        case BT_AUDIO_LOCATION_FRONT_RIGHT_WIDE:
                return "Front right wde";
        case BT_AUDIO_LOCATION_LEFT_SURROUND:
                return "Left surround";
        case BT_AUDIO_LOCATION_RIGHT_SURROUND:
                return "Right surround";
        default:
                return "Unknown location";
        }
}
static inline char *bt_audio_location_bit_to_str(enum bt_audio_location location) {…}
 /* End of bt_audio_to_str */
#ifdef __cplusplus
}
#endif
 /* end of bt_audio */
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_H_ */