audio.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2020 Intel Corporation
 * Copyright (c) 2020-2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_AUDIO_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_AUDIO_H_
 
#include <zephyr/sys/atomic.h>
#include <zephyr/bluetooth/buf.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/iso.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/audio/lc3.h>
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define BT_AUDIO_BROADCAST_ID_SIZE               3 /* octets */
#define BT_AUDIO_BROADCAST_ID_MAX                0xFFFFFFU
#define BT_AUDIO_PD_PREF_NONE                    0x000000U
#define BT_AUDIO_PD_MAX                          0xFFFFFFU
 
#define BT_AUDIO_BROADCAST_CODE_SIZE             16
 
enum bt_audio_context {
        BT_AUDIO_CONTEXT_TYPE_PROHIBITED = 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),
};
 
#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)
 
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_active_state {
        BT_AUDIO_ACTIVE_STATE_DISABLED       = 0x00,
        BT_AUDIO_ACTIVE_STATE_ENABLED        = 0x01,
};
 
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_STREAM_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_EXTENDED            = 0xFE,
 
        BT_AUDIO_METADATA_TYPE_VENDOR              = 0xFF,
};
 
/* Unicast Announcement Type, Generic Audio */
#define BT_AUDIO_UNICAST_ANNOUNCEMENT_GENERAL    0x00
#define BT_AUDIO_UNICAST_ANNOUNCEMENT_TARGETED   0x01
 
struct bt_codec_data {
        struct bt_data data;
        uint8_t value[CONFIG_BT_CODEC_MAX_DATA_LEN];
};
 
#define BT_CODEC_DATA(_type, _bytes...) \
        { \
                .data = BT_DATA(_type, ((uint8_t []) { _bytes }), \
                                sizeof((uint8_t []) { _bytes })) \
        }
 
#define BT_CODEC(_id, _cid, _vid, _data, _meta) \
        { \
                /* Use HCI data path as default, can be overwritten by application */ \
                .path_id = BT_ISO_DATA_PATH_HCI, \
                .id = _id, \
                .cid = _cid, \
                .vid = _vid, \
                .data_count = ARRAY_SIZE(((struct bt_codec_data[]) _data)), \
                .data = _data, \
                .meta_count = ARRAY_SIZE(((struct bt_codec_data[]) _meta)), \
                .meta = _meta, \
        }
 
enum bt_audio_location {
        BT_AUDIO_LOCATION_PROHIBITED = 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),
};
 
#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)
 
struct bt_codec {
        uint8_t path_id;
        uint8_t  id;
        uint16_t cid;
        uint16_t vid;
#if defined(CONFIG_BT_CODEC_MAX_DATA_COUNT)
        size_t   data_count;
        struct bt_codec_data data[CONFIG_BT_CODEC_MAX_DATA_COUNT];
#endif /* CONFIG_BT_CODEC_MAX_DATA_COUNT */
#if defined(CONFIG_BT_CODEC_MAX_METADATA_COUNT)
        size_t   meta_count;
        struct bt_codec_data meta[CONFIG_BT_CODEC_MAX_METADATA_COUNT];
#endif /* CONFIG_BT_CODEC_MAX_METADATA_COUNT */
};
 
enum bt_audio_dir {
        BT_AUDIO_DIR_SINK = 0x01,
        BT_AUDIO_DIR_SOURCE = 0x02,
};
 
#define BT_CODEC_QOS(_interval, _framing, _phy, _sdu, _rtn, _latency, \
                     _pd) \
        { \
                .interval = _interval, \
                .framing = _framing, \
                .phy = _phy, \
                .sdu = _sdu, \
                .rtn = _rtn, \
                .latency = _latency, \
                .pd = _pd, \
        }
 
enum {
        BT_CODEC_QOS_UNFRAMED = 0x00,
        BT_CODEC_QOS_FRAMED = 0x01,
};
 
enum {
        BT_CODEC_QOS_1M = BIT(0),
        BT_CODEC_QOS_2M = BIT(1),
        BT_CODEC_QOS_CODED = BIT(2),
};
 
#define BT_CODEC_QOS_UNFRAMED(_interval, _sdu, _rtn, _latency, _pd) \
        BT_CODEC_QOS(_interval, BT_CODEC_QOS_UNFRAMED, BT_CODEC_QOS_2M, _sdu, \
                     _rtn, _latency, _pd)
 
#define BT_CODEC_QOS_FRAMED(_interval, _sdu, _rtn, _latency, _pd) \
        BT_CODEC_QOS(_interval, BT_CODEC_QOS_FRAMED, BT_CODEC_QOS_2M, _sdu, \
                     _rtn, _latency, _pd)
 
struct bt_codec_qos {
        uint8_t  phy;
 
        uint8_t  framing;
 
        uint8_t rtn;
 
        uint16_t sdu;
 
#if defined(CONFIG_BT_BAP_BROADCAST_SOURCE) || defined(CONFIG_BT_BAP_UNICAST)
        uint16_t latency;
#endif /*  CONFIG_BT_BAP_BROADCAST_SOURCE || CONFIG_BT_BAP_UNICAST */
 
        uint32_t interval;
 
        uint32_t pd;
};
 
#define BT_CODEC_QOS_PREF(_unframed_supported, _phy, _rtn, _latency, _pd_min, \
                          _pd_max, _pref_pd_min, _pref_pd_max) \
        { \
                .unframed_supported = _unframed_supported, \
                .phy = _phy, \
                .rtn = _rtn, \
                .latency = _latency, \
                .pd_min = _pd_min, \
                .pd_max = _pd_max, \
                .pref_pd_min = _pref_pd_min, \
                .pref_pd_max = _pref_pd_max, \
        }
 
struct bt_codec_qos_pref {
        bool unframed_supported;
 
        uint8_t phy;
 
        uint8_t rtn;
 
        uint16_t latency;
 
        uint32_t pd_min;
 
        uint32_t pd_max;
 
        uint32_t pref_pd_min;
 
        uint32_t pref_pd_max;
};
 
ssize_t bt_audio_codec_data_to_buf(const struct bt_codec_data *codec_data, size_t count,
                                   uint8_t *buf, size_t buf_size);
 
enum bt_audio_codec_parse_err {
 
        BT_AUDIO_CODEC_PARSE_ERR_SUCCESS               = 0,
 
        BT_AUDIO_CODEC_PARSE_ERR_TYPE_NOT_FOUND        = -1,
 
        BT_AUDIO_CODEC_PARSE_ERR_INVALID_VALUE_FOUND   = -2,
 
        BT_AUDIO_CODEC_PARSE_ERR_INVALID_PARAM         = -3,
};
 
int bt_codec_cfg_get_freq(const struct bt_codec *codec);
 
int bt_codec_cfg_get_frame_duration_us(const struct bt_codec *codec);
 
int bt_codec_cfg_get_chan_allocation_val(const struct bt_codec *codec,
                                         enum bt_audio_location *chan_allocation);
 
int bt_codec_cfg_get_octets_per_frame(const struct bt_codec *codec);
 
int bt_codec_cfg_get_frame_blocks_per_sdu(const struct bt_codec *codec, bool fallback_to_default);
 
bool bt_codec_get_val(const struct bt_codec *codec,
                      uint8_t type,
                      const struct bt_codec_data **data);
 /* End of bt_audio_codec_cfg */
 
#ifdef __cplusplus
}
#endif
 /* end of bt_audio */
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_AUDIO_H_ */