blob: cb3a521d268a22ec020b9e332b4699f5d98b52b8 [file] [log] [blame]
/* bap_base.c - BAP BASE handling */
/*
* Copyright (c) 2023 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <errno.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/audio/audio.h>
#include <zephyr/bluetooth/audio/bap.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/gap.h>
#include <zephyr/bluetooth/iso.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/logging/log.h>
#include <zephyr/net/buf.h>
#include <zephyr/sys/check.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/util_macro.h>
LOG_MODULE_REGISTER(bt_bap_base, CONFIG_BT_BAP_BASE_LOG_LEVEL);
/* The BASE and the following defines are defined by BAP v1.0.1, section 3.7.2.2 Basic Audio
* Announcements
*/
#define BASE_MAX_SIZE (UINT8_MAX - 1 /* type */ - BT_UUID_SIZE_16)
#define BASE_CODEC_ID_SIZE (1 /* id */ + 2 /* cid */ + 2 /* vid */)
#define BASE_PD_SIZE 3
#define BASE_SUBGROUP_COUNT_SIZE 1
#define BASE_NUM_BIS_SIZE 1
#define BASE_CC_LEN_SIZE 1
#define BASE_META_LEN_SIZE 1
#define BASE_BIS_INDEX_SIZE 1
#define BASE_BIS_CC_LEN_SIZE 1
#define BASE_SUBGROUP_MAX_SIZE (BASE_MAX_SIZE - BASE_PD_SIZE - BASE_SUBGROUP_COUNT_SIZE)
#define BASE_SUBGROUP_MIN_SIZE \
(BASE_NUM_BIS_SIZE + BASE_CODEC_ID_SIZE + BASE_CC_LEN_SIZE + BASE_META_LEN_SIZE + \
BASE_BIS_INDEX_SIZE + BASE_BIS_CC_LEN_SIZE)
#define BASE_MIN_SIZE \
(BT_UUID_SIZE_16 + BASE_PD_SIZE + BASE_SUBGROUP_COUNT_SIZE + BASE_SUBGROUP_MIN_SIZE)
#define BASE_SUBGROUP_MAX_COUNT \
((BASE_MAX_SIZE - BASE_PD_SIZE - BASE_SUBGROUP_COUNT_SIZE) / BASE_SUBGROUP_MIN_SIZE)
static uint32_t base_pull_pd(struct net_buf_simple *net_buf)
{
return net_buf_simple_pull_le24(net_buf);
}
static uint8_t base_pull_bis_count(struct net_buf_simple *net_buf)
{
return net_buf_simple_pull_u8(net_buf);
}
static void base_pull_codec_id(struct net_buf_simple *net_buf,
struct bt_bap_base_codec_id *codec_id)
{
struct bt_bap_base_codec_id codec;
codec.id = net_buf_simple_pull_u8(net_buf); /* coding format */
codec.cid = net_buf_simple_pull_le16(net_buf); /* company id */
codec.vid = net_buf_simple_pull_le16(net_buf); /* VS codec id */
if (codec_id != NULL) {
*codec_id = codec;
}
}
static uint8_t base_pull_ltv(struct net_buf_simple *net_buf, uint8_t **data)
{
const uint8_t len = net_buf_simple_pull_u8(net_buf);
if (data == NULL) {
net_buf_simple_pull_mem(net_buf, len);
} else {
*data = net_buf_simple_pull_mem(net_buf, len);
}
return len;
}
static bool check_pull_ltv(struct net_buf_simple *net_buf)
{
uint8_t ltv_len;
if (net_buf->len < sizeof(ltv_len)) {
return false;
}
ltv_len = net_buf_simple_pull_u8(net_buf);
if (net_buf->len < ltv_len) {
return false;
}
net_buf_simple_pull_mem(net_buf, ltv_len);
return true;
}
const struct bt_bap_base *bt_bap_base_get_base_from_ad(const struct bt_data *ad)
{
struct bt_uuid_16 broadcast_uuid;
const struct bt_bap_base *base;
struct net_buf_simple net_buf;
uint8_t subgroup_count;
void *uuid;
CHECKIF(ad == NULL) {
LOG_DBG("data is NULL");
return NULL;
}
if (ad->type != BT_DATA_SVC_DATA16) {
LOG_DBG("Invalid type: %u", ad->type);
return NULL;
}
if (ad->data_len < BASE_MIN_SIZE) {
LOG_DBG("Invalid len: %u", ad->data_len);
return NULL;
}
net_buf_simple_init_with_data(&net_buf, (void *)ad->data, ad->data_len);
uuid = net_buf_simple_pull_mem(&net_buf, BT_UUID_SIZE_16);
if (!bt_uuid_create(&broadcast_uuid.uuid, uuid, BT_UUID_SIZE_16)) {
LOG_ERR("bt_uuid_create failed");
return NULL;
}
if (bt_uuid_cmp(&broadcast_uuid.uuid, BT_UUID_BASIC_AUDIO) != 0) {
LOG_DBG("Invalid UUID");
return NULL;
}
/* Store the start of the BASE */
base = (const struct bt_bap_base *)net_buf.data;
/* Pull all data to verify that the result BASE is valid */
base_pull_pd(&net_buf);
subgroup_count = net_buf_simple_pull_u8(&net_buf);
if (subgroup_count == 0 || subgroup_count > BASE_SUBGROUP_MAX_COUNT) {
LOG_DBG("Invalid subgroup count: %u", subgroup_count);
return NULL;
}
for (uint8_t i = 0U; i < subgroup_count; i++) {
uint8_t bis_count;
if (net_buf.len < sizeof(bis_count)) {
LOG_DBG("Invalid BASE length: %u", ad->data_len);
return NULL;
}
bis_count = base_pull_bis_count(&net_buf);
if (bis_count == 0 || bis_count > BT_ISO_MAX_GROUP_ISO_COUNT) {
LOG_DBG("Subgroup[%u]: Invalid BIS count: %u", i, bis_count);
return NULL;
}
if (net_buf.len < BASE_CODEC_ID_SIZE) {
LOG_DBG("Invalid BASE length: %u", ad->data_len);
return NULL;
}
base_pull_codec_id(&net_buf, NULL);
/* Pull CC */
if (!check_pull_ltv(&net_buf)) {
LOG_DBG("Invalid BASE length: %u", ad->data_len);
return NULL;
}
/* Pull meta */
if (!check_pull_ltv(&net_buf)) {
LOG_DBG("Invalid BASE length: %u", ad->data_len);
return NULL;
}
for (uint8_t j = 0U; j < bis_count; j++) {
uint8_t bis_index;
if (net_buf.len < sizeof(bis_index)) {
LOG_DBG("Invalid BASE length: %u", ad->data_len);
return NULL;
}
bis_index = net_buf_simple_pull_u8(&net_buf);
if (bis_index == 0 || bis_index > BT_ISO_BIS_INDEX_MAX) {
LOG_DBG("Subgroup[%u]: Invalid BIS index: %u", i, bis_index);
return NULL;
}
/* Pull BIS CC data */
if (!check_pull_ltv(&net_buf)) {
LOG_DBG("Invalid BASE length: %u", ad->data_len);
return NULL;
}
}
}
return base;
}
int bt_bap_base_get_size(const struct bt_bap_base *base)
{
struct net_buf_simple net_buf;
uint8_t subgroup_count;
size_t size = 0;
CHECKIF(base == NULL) {
LOG_DBG("base is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)base, BASE_MAX_SIZE);
base_pull_pd(&net_buf);
size += BASE_PD_SIZE;
subgroup_count = net_buf_simple_pull_u8(&net_buf);
size += BASE_SUBGROUP_COUNT_SIZE;
/* Parse subgroup data */
for (uint8_t i = 0U; i < subgroup_count; i++) {
uint8_t bis_count;
uint8_t len;
bis_count = base_pull_bis_count(&net_buf);
size += BASE_NUM_BIS_SIZE;
base_pull_codec_id(&net_buf, NULL);
size += BASE_CODEC_ID_SIZE;
/* Codec config */
len = base_pull_ltv(&net_buf, NULL);
size += len + BASE_CC_LEN_SIZE;
/* meta */
len = base_pull_ltv(&net_buf, NULL);
size += len + BASE_META_LEN_SIZE;
/* Parse BIS data */
for (uint8_t j = 0U; j < bis_count; j++) {
/* BIS index */
net_buf_simple_pull_u8(&net_buf);
size += BASE_BIS_INDEX_SIZE;
/* Codec config */
len = base_pull_ltv(&net_buf, NULL);
size += len + BASE_BIS_CC_LEN_SIZE;
}
}
return (int)size;
}
int bt_bap_base_get_pres_delay(const struct bt_bap_base *base)
{
struct net_buf_simple net_buf;
uint32_t pd;
CHECKIF(base == NULL) {
LOG_DBG("base is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)base, sizeof(pd));
pd = base_pull_pd(&net_buf);
return (int)pd; /* PD is 24-bit so it fits in an int */
}
int bt_bap_base_get_subgroup_count(const struct bt_bap_base *base)
{
struct net_buf_simple net_buf;
uint8_t subgroup_count;
CHECKIF(base == NULL) {
LOG_DBG("base is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)base, BASE_MAX_SIZE);
base_pull_pd(&net_buf);
subgroup_count = net_buf_simple_pull_u8(&net_buf);
return (int)subgroup_count; /* subgroup_count is 8-bit so it fits in an int */
}
int bt_bap_base_foreach_subgroup(const struct bt_bap_base *base,
bool (*func)(const struct bt_bap_base_subgroup *data,
void *user_data),
void *user_data)
{
struct bt_bap_base_subgroup *subgroup;
struct net_buf_simple net_buf;
uint8_t subgroup_count;
CHECKIF(base == NULL) {
LOG_DBG("base is NULL");
return -EINVAL;
}
CHECKIF(func == NULL) {
LOG_DBG("func is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)base, BASE_MAX_SIZE);
base_pull_pd(&net_buf);
subgroup_count = net_buf_simple_pull_u8(&net_buf);
for (uint8_t i = 0U; i < subgroup_count; i++) {
subgroup = (struct bt_bap_base_subgroup *)net_buf.data;
if (!func(subgroup, user_data)) {
LOG_DBG("user stopped parsing");
return -ECANCELED;
}
/* Parse subgroup data to get next subgroup pointer */
if (subgroup_count > 1) { /* Only parse data if it isn't the last one */
uint8_t bis_count;
bis_count = base_pull_bis_count(&net_buf);
base_pull_codec_id(&net_buf, NULL);
/* Codec config */
base_pull_ltv(&net_buf, NULL);
/* meta */
base_pull_ltv(&net_buf, NULL);
for (uint8_t j = 0U; j < bis_count; j++) {
net_buf_simple_pull_u8(&net_buf); /* index */
/* Codec config */
base_pull_ltv(&net_buf, NULL);
}
}
}
return 0;
}
int bt_bap_base_get_subgroup_codec_id(const struct bt_bap_base_subgroup *subgroup,
struct bt_bap_base_codec_id *codec_id)
{
struct net_buf_simple net_buf;
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
CHECKIF(codec_id == NULL) {
LOG_DBG("codec_id is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)subgroup, BASE_SUBGROUP_MAX_SIZE);
base_pull_bis_count(&net_buf);
base_pull_codec_id(&net_buf, codec_id);
return 0;
}
int bt_bap_base_get_subgroup_codec_data(const struct bt_bap_base_subgroup *subgroup, uint8_t **data)
{
struct net_buf_simple net_buf;
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
CHECKIF(data == NULL) {
LOG_DBG("data is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)subgroup, BASE_SUBGROUP_MAX_SIZE);
base_pull_bis_count(&net_buf);
base_pull_codec_id(&net_buf, NULL);
/* Codec config */
return base_pull_ltv(&net_buf, data);
}
int bt_bap_base_get_subgroup_codec_meta(const struct bt_bap_base_subgroup *subgroup, uint8_t **meta)
{
struct net_buf_simple net_buf;
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
CHECKIF(meta == NULL) {
LOG_DBG("meta is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)subgroup, BASE_SUBGROUP_MAX_SIZE);
base_pull_bis_count(&net_buf);
base_pull_codec_id(&net_buf, NULL);
/* Codec config */
base_pull_ltv(&net_buf, NULL);
/* meta */
return base_pull_ltv(&net_buf, meta);
}
int bt_bap_base_subgroup_codec_to_codec_cfg(const struct bt_bap_base_subgroup *subgroup,
struct bt_audio_codec_cfg *codec_cfg)
{
struct bt_bap_base_codec_id codec_id;
struct net_buf_simple net_buf;
uint8_t *ltv_data;
uint8_t ltv_len;
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
CHECKIF(codec_cfg == NULL) {
LOG_DBG("codec_cfg is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)subgroup, BASE_SUBGROUP_MAX_SIZE);
base_pull_bis_count(&net_buf);
base_pull_codec_id(&net_buf, &codec_id);
codec_cfg->id = codec_id.id;
codec_cfg->cid = codec_id.cid;
codec_cfg->vid = codec_id.vid;
/* Codec config */
ltv_len = base_pull_ltv(&net_buf, &ltv_data);
if (ltv_len > ARRAY_SIZE(codec_cfg->data)) {
LOG_DBG("Cannot fit %u octets of codec data (max %zu)", ltv_len,
ARRAY_SIZE(codec_cfg->data));
return -ENOMEM;
}
codec_cfg->data_len = ltv_len;
memcpy(codec_cfg->data, ltv_data, ltv_len);
/* Meta */
ltv_len = base_pull_ltv(&net_buf, &ltv_data);
if (ltv_len > ARRAY_SIZE(codec_cfg->meta)) {
LOG_DBG("Cannot fit %u octets of codec meta (max %zu)", ltv_len,
ARRAY_SIZE(codec_cfg->meta));
return -ENOMEM;
}
codec_cfg->meta_len = ltv_len;
memcpy(codec_cfg->meta, ltv_data, ltv_len);
return 0;
}
int bt_bap_base_get_subgroup_bis_count(const struct bt_bap_base_subgroup *subgroup)
{
struct net_buf_simple net_buf;
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)subgroup, BASE_SUBGROUP_MAX_SIZE);
return base_pull_bis_count(&net_buf);
}
int bt_bap_base_subgroup_foreach_bis(const struct bt_bap_base_subgroup *subgroup,
bool (*func)(const struct bt_bap_base_subgroup_bis *subgroup,
void *user_data),
void *user_data)
{
struct net_buf_simple net_buf;
uint8_t bis_count;
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
CHECKIF(func == NULL) {
LOG_DBG("func is NULL");
return -EINVAL;
}
net_buf_simple_init_with_data(&net_buf, (void *)subgroup, BASE_SUBGROUP_MAX_SIZE);
bis_count = base_pull_bis_count(&net_buf);
base_pull_codec_id(&net_buf, NULL);
/* Codec config */
base_pull_ltv(&net_buf, NULL);
/* meta */
base_pull_ltv(&net_buf, NULL);
for (uint8_t i = 0U; i < bis_count; i++) {
struct bt_bap_base_subgroup_bis bis;
bis.index = net_buf_simple_pull_u8(&net_buf); /* index */
/* Codec config */
bis.data_len = base_pull_ltv(&net_buf, &bis.data);
if (!func(&bis, user_data)) {
LOG_DBG("user stopped parsing");
return -ECANCELED;
}
}
return 0;
}
int bt_bap_base_subgroup_bis_codec_to_codec_cfg(const struct bt_bap_base_subgroup_bis *bis,
struct bt_audio_codec_cfg *codec_cfg)
{
CHECKIF(bis == NULL) {
LOG_DBG("bis is NULL");
return -EINVAL;
}
CHECKIF(codec_cfg == NULL) {
LOG_DBG("codec_cfg is NULL");
return -EINVAL;
}
if (bis->data_len > ARRAY_SIZE(codec_cfg->data)) {
LOG_DBG("Cannot fit %u octets of codec data (max %zu)", bis->data_len,
ARRAY_SIZE(codec_cfg->data));
return -ENOMEM;
}
codec_cfg->data_len = bis->data_len;
memcpy(codec_cfg->data, bis->data, bis->data_len);
return 0;
}
static bool base_subgroup_bis_cb(const struct bt_bap_base_subgroup_bis *bis, void *user_data)
{
uint32_t *base_bis_index_bitfield = user_data;
*base_bis_index_bitfield |= BIT(bis->index);
return true;
}
static bool base_subgroup_cb(const struct bt_bap_base_subgroup *subgroup, void *user_data)
{
const int err = bt_bap_base_subgroup_foreach_bis(subgroup, base_subgroup_bis_cb, user_data);
if (err != 0) {
LOG_DBG("Failed to parse all BIS: %d", err);
return false;
}
return true;
}
int bt_bap_base_subgroup_get_bis_indexes(const struct bt_bap_base_subgroup *subgroup,
uint32_t *bis_indexes)
{
CHECKIF(subgroup == NULL) {
LOG_DBG("subgroup is NULL");
return -EINVAL;
}
CHECKIF(bis_indexes == NULL) {
LOG_DBG("bis_indexes is NULL");
return -EINVAL;
}
*bis_indexes = 0U;
return bt_bap_base_subgroup_foreach_bis(subgroup, base_subgroup_bis_cb, bis_indexes);
}
int bt_bap_base_get_bis_indexes(const struct bt_bap_base *base, uint32_t *bis_indexes)
{
CHECKIF(base == NULL) {
LOG_DBG("base is NULL");
return -EINVAL;
}
CHECKIF(bis_indexes == NULL) {
LOG_DBG("bis_indexes is NULL");
return -EINVAL;
}
*bis_indexes = 0U;
return bt_bap_base_foreach_subgroup(base, base_subgroup_cb, bis_indexes);
}