| /* |
| * Copyright (c) 2022 Bose Corporation |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| /** @file |
| * @brief Bluetooth LE-Audio codec LTV parsing |
| * |
| * Helper functions to parse codec config data as specified in the Bluetooth assigned numbers for |
| * Generic Audio. |
| */ |
| |
| #include <stdlib.h> |
| |
| #include <zephyr/bluetooth/audio/audio.h> |
| #include <zephyr/sys/byteorder.h> |
| #include <zephyr/sys/check.h> |
| |
| #include <zephyr/logging/log.h> |
| |
| 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_cfg_freq freq) |
| { |
| switch (freq) { |
| case BT_AUDIO_CODEC_CFG_FREQ_8KHZ: |
| return 8000; |
| case BT_AUDIO_CODEC_CFG_FREQ_11KHZ: |
| return 11025; |
| case BT_AUDIO_CODEC_CFG_FREQ_16KHZ: |
| return 16000; |
| case BT_AUDIO_CODEC_CFG_FREQ_22KHZ: |
| return 22050; |
| case BT_AUDIO_CODEC_CFG_FREQ_24KHZ: |
| return 24000; |
| case BT_AUDIO_CODEC_CFG_FREQ_32KHZ: |
| return 32000; |
| case BT_AUDIO_CODEC_CFG_FREQ_44KHZ: |
| return 44100; |
| case BT_AUDIO_CODEC_CFG_FREQ_48KHZ: |
| return 48000; |
| case BT_AUDIO_CODEC_CFG_FREQ_88KHZ: |
| return 88200; |
| case BT_AUDIO_CODEC_CFG_FREQ_96KHZ: |
| return 96000; |
| case BT_AUDIO_CODEC_CFG_FREQ_176KHZ: |
| return 176400; |
| case BT_AUDIO_CODEC_CFG_FREQ_192KHZ: |
| return 192000; |
| case BT_AUDIO_CODEC_CFG_FREQ_384KHZ: |
| return 384000; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| int bt_audio_codec_cfg_freq_hz_to_freq(uint32_t freq_hz) |
| { |
| switch (freq_hz) { |
| case 8000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_8KHZ; |
| case 11025U: |
| return BT_AUDIO_CODEC_CFG_FREQ_11KHZ; |
| case 16000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_16KHZ; |
| case 22050U: |
| return BT_AUDIO_CODEC_CFG_FREQ_22KHZ; |
| case 24000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_24KHZ; |
| case 32000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_32KHZ; |
| case 44100U: |
| return BT_AUDIO_CODEC_CFG_FREQ_44KHZ; |
| case 48000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_48KHZ; |
| case 88200U: |
| return BT_AUDIO_CODEC_CFG_FREQ_88KHZ; |
| case 96000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_96KHZ; |
| case 176400U: |
| return BT_AUDIO_CODEC_CFG_FREQ_176KHZ; |
| case 192000U: |
| return BT_AUDIO_CODEC_CFG_FREQ_192KHZ; |
| case 384000U: |
| 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_cfg_frame_dur frame_dur) |
| { |
| switch (frame_dur) { |
| case BT_AUDIO_CODEC_CFG_DURATION_7_5: |
| return 7500; |
| case BT_AUDIO_CODEC_CFG_DURATION_10: |
| return 10000; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| 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_CFG_DURATION_7_5; |
| case 10000U: |
| return BT_AUDIO_CODEC_CFG_DURATION_10; |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| #if CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 || \ |
| CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 || \ |
| CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE > 0 || \ |
| CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE > 0 |
| |
| struct search_type_param { |
| bool found; |
| uint8_t type; |
| uint8_t data_len; |
| const uint8_t **data; |
| }; |
| |
| static bool parse_cb(struct bt_data *data, void *user_data) |
| { |
| struct search_type_param *param = (struct search_type_param *)user_data; |
| |
| if (param->type == data->type) { |
| param->found = true; |
| param->data_len = data->data_len; |
| *param->data = data->data; |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static int ltv_set_val(struct net_buf_simple *buf, uint8_t type, const uint8_t *data, |
| size_t data_len) |
| { |
| size_t new_buf_len; |
| |
| for (uint16_t i = 0U; i < buf->len;) { |
| uint8_t *len = &buf->data[i++]; |
| const uint8_t data_type = buf->data[i++]; |
| const uint8_t value_len = *len - sizeof(data_type); |
| |
| if (data_type == type) { |
| uint8_t *value = &buf->data[i]; |
| |
| if (data_len == value_len) { |
| memcpy(value, data, data_len); |
| } else { |
| const int16_t diff = data_len - value_len; |
| uint8_t *old_next_data_start; |
| uint8_t *new_next_data_start; |
| uint8_t data_len_to_move; |
| |
| /* Check if this is the last value in the buffer */ |
| if (value + value_len == buf->data + buf->len) { |
| data_len_to_move = 0U; |
| } else { |
| old_next_data_start = value + value_len; |
| new_next_data_start = value + data_len; |
| data_len_to_move = |
| buf->len - (old_next_data_start - buf->data); |
| } |
| |
| if (diff < 0) { |
| /* In this case we need to move memory around after the copy |
| * to fit the new shorter data |
| */ |
| |
| memcpy(value, data, data_len); |
| if (data_len_to_move > 0U) { |
| memmove(new_next_data_start, old_next_data_start, |
| data_len_to_move); |
| } |
| } else { |
| /* In this case we need to move memory around before |
| * the copy to fit the new longer data |
| */ |
| if ((buf->len + diff) > buf->size) { |
| LOG_DBG("Cannot fit data_len %zu in buf with len " |
| "%u and size %u", |
| data_len, buf->len, buf->size); |
| return -ENOMEM; |
| } |
| |
| if (data_len_to_move > 0) { |
| memmove(new_next_data_start, old_next_data_start, |
| data_len_to_move); |
| } |
| memcpy(value, data, data_len); |
| } |
| |
| buf->len += diff; |
| *len += diff; |
| } |
| |
| return buf->len; |
| } |
| |
| i += value_len; |
| } |
| |
| /* If we reach here, we did not find the data in the buffer, so we simply add it */ |
| new_buf_len = buf->len + 1 /* len */ + sizeof(type) + data_len; |
| if (new_buf_len <= buf->size) { |
| net_buf_simple_add_u8(buf, data_len + sizeof(type)); /* len */ |
| net_buf_simple_add_u8(buf, type); /* type */ |
| if (data_len > 0) { |
| net_buf_simple_add_mem(buf, data, data_len); /* value */ |
| } |
| } else { |
| LOG_DBG("Cannot fit data_len %zu in codec_cfg with len %u and size %u", data_len, |
| buf->len, buf->size); |
| return -ENOMEM; |
| } |
| |
| return buf->len; |
| } |
| |
| static int ltv_unset_val(struct net_buf_simple *buf, uint8_t type) |
| { |
| for (uint16_t i = 0U; i < buf->len;) { |
| uint8_t *ltv_start = &buf->data[i]; |
| const uint8_t len = buf->data[i++]; |
| const uint8_t data_type = buf->data[i++]; |
| const uint8_t value_len = len - sizeof(data_type); |
| |
| if (data_type == type) { |
| const uint8_t ltv_size = value_len + sizeof(data_type) + sizeof(len); |
| uint8_t *value = &buf->data[i]; |
| |
| /* Check if this is not the last value in the buffer */ |
| if (value + value_len != buf->data + buf->len) { |
| uint8_t *next_data_start; |
| uint8_t data_len_to_move; |
| |
| next_data_start = value + value_len; |
| data_len_to_move = buf->len - (next_data_start - buf->data); |
| memmove(ltv_start, next_data_start, data_len_to_move); |
| |
| LOG_ERR("buf->data %p, ltv_start %p, value_len %u next_data_start " |
| "%p data_len_to_move %u", |
| buf->data, ltv_start, value_len, next_data_start, |
| data_len_to_move); |
| } /* else just reduce the length of the buffer */ |
| |
| buf->len -= ltv_size; |
| |
| return buf->len; |
| } |
| |
| i += value_len; |
| } |
| |
| return buf->len; |
| } |
| #endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 || \ |
| * CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 || \ |
| * CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE > 0 || \ |
| * CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE > 0 \ |
| */ |
| |
| #if CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 |
| |
| static void init_net_buf_simple_from_codec_cfg(struct net_buf_simple *buf, |
| struct bt_audio_codec_cfg *codec_cfg) |
| { |
| buf->__buf = codec_cfg->data; |
| buf->data = codec_cfg->data; |
| buf->size = sizeof(codec_cfg->data); |
| buf->len = codec_cfg->data_len; |
| } |
| |
| 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) |
| { |
| struct search_type_param param = { |
| .found = false, |
| .type = (uint8_t)type, |
| .data_len = 0, |
| .data = data, |
| }; |
| int err; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data == NULL) { |
| LOG_DBG("data is NULL"); |
| return -EINVAL; |
| } |
| |
| *data = NULL; |
| |
| err = bt_audio_data_parse(codec_cfg->data, codec_cfg->data_len, parse_cb, ¶m); |
| if (err != 0 && err != -ECANCELED) { |
| LOG_DBG("Could not parse the data: %d", err); |
| return err; |
| } |
| |
| if (!param.found) { |
| LOG_DBG("Could not find the type %u", type); |
| return -ENODATA; |
| } |
| |
| return param.data_len; |
| } |
| |
| 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) |
| { |
| struct net_buf_simple buf; |
| int ret; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data == NULL) { |
| LOG_DBG("data is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data_len == 0U || data_len > UINT8_MAX) { |
| LOG_DBG("Invalid data_len %zu", data_len); |
| return -EINVAL; |
| } |
| |
| init_net_buf_simple_from_codec_cfg(&buf, codec_cfg); |
| |
| ret = ltv_set_val(&buf, type, data, data_len); |
| if (ret >= 0) { |
| codec_cfg->data_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_unset_val(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_codec_cfg_type type) |
| { |
| struct net_buf_simple buf; |
| int ret; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| init_net_buf_simple_from_codec_cfg(&buf, codec_cfg); |
| |
| ret = ltv_unset_val(&buf, type); |
| if (ret >= 0) { |
| codec_cfg->data_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_get_freq(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| enum bt_audio_codec_cfg_freq freq; |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_FREQ, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| freq = data[0]; |
| if (bt_audio_codec_cfg_freq_to_freq_hz(freq) < 0) { |
| LOG_DBG("Invalid freq value: 0x%02X", freq); |
| return -EBADMSG; |
| } |
| |
| return freq; |
| } |
| |
| int bt_audio_codec_cfg_set_freq(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_codec_cfg_freq freq) |
| { |
| uint8_t freq_u8; |
| |
| if (bt_audio_codec_cfg_freq_to_freq_hz(freq) < 0) { |
| LOG_DBG("Invalid freq value: %d", freq); |
| return -EINVAL; |
| } |
| |
| freq_u8 = (uint8_t)freq; |
| |
| 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_cfg_frame_dur frame_dur; |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_DURATION, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| frame_dur = data[0]; |
| if (bt_audio_codec_cfg_frame_dur_to_frame_dur_us(frame_dur) < 0) { |
| LOG_DBG("Invalid frame_dur value: 0x%02X", frame_dur); |
| return -EBADMSG; |
| } |
| |
| return frame_dur; |
| } |
| |
| int bt_audio_codec_cfg_set_frame_dur(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_codec_cfg_frame_dur frame_dur) |
| { |
| uint8_t frame_dur_u8; |
| |
| if (bt_audio_codec_cfg_frame_dur_to_frame_dur_us(frame_dur) < 0) { |
| LOG_DBG("Invalid freq value: %d", frame_dur); |
| return -EINVAL; |
| } |
| |
| frame_dur_u8 = (uint8_t)frame_dur; |
| |
| return bt_audio_codec_cfg_set_val(codec_cfg, BT_AUDIO_CODEC_CFG_DURATION, |
| &frame_dur_u8, sizeof(frame_dur_u8)); |
| } |
| |
| int bt_audio_codec_cfg_get_chan_allocation(const struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_location *chan_allocation) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| *chan_allocation = 0; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(chan_allocation == NULL) { |
| return -EINVAL; |
| } |
| |
| data_len = |
| bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_CHAN_ALLOC, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint32_t)) { |
| return -EBADMSG; |
| } |
| |
| *chan_allocation = sys_get_le32(data); |
| |
| return 0; |
| } |
| |
| int bt_audio_codec_cfg_set_chan_allocation(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_location chan_allocation) |
| { |
| uint32_t chan_allocation_u32; |
| |
| if ((chan_allocation & BT_AUDIO_LOCATION_ANY) != chan_allocation) { |
| LOG_DBG("Invalid chan_allocation value: 0x%08X", chan_allocation); |
| return -EINVAL; |
| } |
| |
| chan_allocation_u32 = sys_cpu_to_le32((uint32_t)chan_allocation); |
| |
| 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)); |
| } |
| |
| int bt_audio_codec_cfg_get_octets_per_frame(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = |
| bt_audio_codec_cfg_get_val(codec_cfg, BT_AUDIO_CODEC_CFG_FRAME_LEN, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint16_t)) { |
| return -EBADMSG; |
| } |
| |
| return sys_get_le16(data); |
| } |
| |
| int bt_audio_codec_cfg_set_octets_per_frame(struct bt_audio_codec_cfg *codec_cfg, |
| uint16_t octets_per_frame) |
| { |
| uint16_t octets_per_frame_le16; |
| |
| octets_per_frame_le16 = sys_cpu_to_le16(octets_per_frame); |
| |
| 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)); |
| } |
| |
| int bt_audio_codec_cfg_get_frame_blocks_per_sdu(const struct bt_audio_codec_cfg *codec_cfg, |
| bool fallback_to_default) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cfg_get_val(codec_cfg, |
| BT_AUDIO_CODEC_CFG_FRAME_BLKS_PER_SDU, &data); |
| if (data == NULL) { |
| if (fallback_to_default) { |
| return 1; |
| } |
| |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| return data[0]; |
| } |
| |
| 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_CFG_FRAME_BLKS_PER_SDU, |
| &frame_blocks, sizeof(frame_blocks)); |
| } |
| #endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_DATA_SIZE > 0 */ |
| |
| #if CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 || \ |
| CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE > 0 |
| |
| static void init_net_buf_simple_from_meta(struct net_buf_simple *buf, uint8_t meta[], |
| size_t meta_len, size_t meta_size) |
| { |
| buf->__buf = meta; |
| buf->data = meta; |
| buf->size = meta_size; |
| buf->len = meta_len; |
| } |
| |
| static int codec_meta_get_val(const uint8_t meta[], size_t meta_len, |
| enum bt_audio_metadata_type type, const uint8_t **data) |
| { |
| struct search_type_param param = { |
| .found = false, |
| .type = (uint8_t)type, |
| .data_len = 0, |
| .data = data, |
| }; |
| int err; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data == NULL) { |
| LOG_DBG("data is NULL"); |
| return -EINVAL; |
| } |
| |
| *data = NULL; |
| |
| err = bt_audio_data_parse(meta, meta_len, parse_cb, ¶m); |
| if (err != 0 && err != -ECANCELED) { |
| LOG_DBG("Could not parse the meta data: %d", err); |
| return err; |
| } |
| |
| if (!param.found) { |
| LOG_DBG("Could not find the type %u", type); |
| return -ENODATA; |
| } |
| |
| return param.data_len; |
| } |
| |
| static int codec_meta_set_val(uint8_t meta[], size_t meta_len, size_t meta_size, |
| enum bt_audio_metadata_type type, const uint8_t *data, |
| size_t data_len) |
| { |
| struct net_buf_simple buf; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data == NULL && data_len != 0) { |
| LOG_DBG("data is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data_len > UINT8_MAX) { |
| LOG_DBG("Invalid data_len %zu", data_len); |
| return -EINVAL; |
| } |
| |
| init_net_buf_simple_from_meta(&buf, meta, meta_len, meta_size); |
| |
| return ltv_set_val(&buf, (uint8_t)type, data, data_len); |
| } |
| |
| static int codec_meta_unset_val(uint8_t meta[], size_t meta_len, size_t meta_size, |
| enum bt_audio_metadata_type type) |
| { |
| struct net_buf_simple buf; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| init_net_buf_simple_from_meta(&buf, meta, meta_len, meta_size); |
| |
| return ltv_unset_val(&buf, type); |
| } |
| |
| static int codec_meta_get_pref_context(const uint8_t meta[], size_t meta_len) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_PREF_CONTEXT, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (ret != sizeof(uint16_t)) { |
| return -EBADMSG; |
| } |
| |
| return sys_get_le16(data); |
| } |
| |
| static int codec_meta_set_pref_context(uint8_t meta[], size_t meta_len, size_t meta_size, |
| enum bt_audio_context ctx) |
| { |
| uint16_t ctx_le16; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| if ((ctx & BT_AUDIO_CONTEXT_TYPE_ANY) != ctx) { |
| LOG_DBG("Invalid ctx value: %d", ctx); |
| return -EINVAL; |
| } |
| |
| ctx_le16 = sys_cpu_to_le16((uint16_t)ctx); |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_PREF_CONTEXT, |
| (const uint8_t *)&ctx_le16, sizeof(ctx_le16)); |
| } |
| |
| static int codec_meta_get_stream_context(const uint8_t meta[], size_t meta_len) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_STREAM_CONTEXT, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (ret != sizeof(uint16_t)) { |
| return -EBADMSG; |
| } |
| |
| return sys_get_le16(data); |
| } |
| |
| static int codec_meta_set_stream_context(uint8_t meta[], size_t meta_len, size_t meta_size, |
| enum bt_audio_context ctx) |
| { |
| uint16_t ctx_le16; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| if ((ctx & BT_AUDIO_CONTEXT_TYPE_ANY) != ctx) { |
| LOG_DBG("Invalid ctx value: %d", ctx); |
| return -EINVAL; |
| } |
| |
| ctx_le16 = sys_cpu_to_le16((uint16_t)ctx); |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_STREAM_CONTEXT, |
| (const uint8_t *)&ctx_le16, sizeof(ctx_le16)); |
| } |
| |
| static int codec_meta_get_program_info(const uint8_t meta[], size_t meta_len, |
| const uint8_t **program_info) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(program_info == NULL) { |
| LOG_DBG("program_info is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_PROGRAM_INFO, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| *program_info = data; |
| |
| return ret; |
| } |
| |
| static int codec_meta_set_program_info(uint8_t meta[], size_t meta_len, size_t meta_size, |
| const uint8_t *program_info, size_t program_info_len) |
| { |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(program_info == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_PROGRAM_INFO, |
| program_info, program_info_len); |
| } |
| |
| static int codec_meta_get_stream_lang(const uint8_t meta[], size_t meta_len) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_STREAM_LANG, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (ret != 3) { /* Stream language is 3 octets */ |
| return -EBADMSG; |
| } |
| |
| return sys_get_le24(data); |
| } |
| |
| static int codec_meta_set_stream_lang(uint8_t meta[], size_t meta_len, size_t meta_size, |
| uint32_t stream_lang) |
| { |
| uint8_t stream_lang_le[3]; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| if ((stream_lang & 0xFFFFFFU) != stream_lang) { |
| LOG_DBG("Invalid stream_lang value: %d", stream_lang); |
| return -EINVAL; |
| } |
| |
| sys_put_le24(stream_lang, stream_lang_le); |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_STREAM_LANG, |
| stream_lang_le, sizeof(stream_lang_le)); |
| } |
| |
| static int codec_meta_get_ccid_list(const uint8_t meta[], size_t meta_len, |
| const uint8_t **ccid_list) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(ccid_list == NULL) { |
| LOG_DBG("ccid_list is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_CCID_LIST, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| *ccid_list = data; |
| |
| return ret; |
| } |
| |
| static int codec_meta_set_ccid_list(uint8_t meta[], size_t meta_len, size_t meta_size, |
| const uint8_t *ccid_list, size_t ccid_list_len) |
| { |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(ccid_list == NULL) { |
| LOG_DBG("ccid_list is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_CCID_LIST, |
| ccid_list, ccid_list_len); |
| } |
| |
| static int codec_meta_get_parental_rating(const uint8_t meta[], size_t meta_len) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_PARENTAL_RATING, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (ret != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| return data[0]; |
| } |
| |
| static int codec_meta_set_parental_rating(uint8_t meta[], size_t meta_len, size_t meta_size, |
| enum bt_audio_parental_rating parental_rating) |
| { |
| uint8_t parental_rating_u8; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| if (parental_rating > BT_AUDIO_PARENTAL_RATING_AGE_18_OR_ABOVE) { |
| LOG_DBG("Invalid parental_rating value: %d", parental_rating); |
| return -EINVAL; |
| } |
| |
| parental_rating_u8 = (uint8_t)parental_rating; |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_PARENTAL_RATING, |
| &parental_rating_u8, sizeof(parental_rating_u8)); |
| } |
| |
| static int codec_meta_get_program_info_uri(const uint8_t meta[], size_t meta_len, |
| const uint8_t **program_info_uri) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(program_info_uri == NULL) { |
| LOG_DBG("program_info_uri is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_PROGRAM_INFO_URI, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| *program_info_uri = data; |
| |
| return ret; |
| } |
| |
| static int codec_meta_set_program_info_uri(uint8_t meta[], size_t meta_len, size_t meta_size, |
| const uint8_t *program_info_uri, |
| size_t program_info_uri_len) |
| { |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(program_info_uri == NULL) { |
| LOG_DBG("program_info_uri is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, |
| BT_AUDIO_METADATA_TYPE_PROGRAM_INFO_URI, program_info_uri, |
| program_info_uri_len); |
| } |
| |
| static int codec_meta_get_audio_active_state(const uint8_t meta[], size_t meta_len) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_AUDIO_STATE, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (ret != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| return data[0]; |
| } |
| |
| static int codec_meta_set_audio_active_state(uint8_t meta[], size_t meta_len, size_t meta_size, |
| enum bt_audio_active_state state) |
| { |
| uint8_t state_u8; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| if (state != BT_AUDIO_ACTIVE_STATE_DISABLED && state != BT_AUDIO_ACTIVE_STATE_ENABLED) { |
| LOG_DBG("Invalid state value: %d", state); |
| return -EINVAL; |
| } |
| |
| state_u8 = (uint8_t)state; |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_AUDIO_STATE, |
| &state_u8, sizeof(state_u8)); |
| } |
| |
| static int codec_meta_get_bcast_audio_immediate_rend_flag(const uint8_t meta[], size_t meta_len) |
| { |
| const uint8_t *data; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_BROADCAST_IMMEDIATE, |
| &data); |
| } |
| |
| static int codec_meta_set_bcast_audio_immediate_rend_flag(uint8_t meta[], size_t meta_len, |
| size_t meta_size) |
| { |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, |
| BT_AUDIO_METADATA_TYPE_BROADCAST_IMMEDIATE, NULL, 0); |
| } |
| |
| static int codec_meta_get_extended(const uint8_t meta[], size_t meta_len, |
| const uint8_t **extended_meta) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(extended_meta == NULL) { |
| LOG_DBG("extended_meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_EXTENDED, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| *extended_meta = data; |
| |
| return ret; |
| } |
| |
| static int codec_meta_set_extended(uint8_t meta[], size_t meta_len, size_t meta_size, |
| const uint8_t *extended, size_t extended_len) |
| { |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(extended == NULL) { |
| LOG_DBG("extended is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_EXTENDED, |
| extended, extended_len); |
| } |
| |
| static int codec_meta_get_vendor(const uint8_t meta[], size_t meta_len, const uint8_t **vendor_meta) |
| { |
| const uint8_t *data; |
| int ret; |
| |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(vendor_meta == NULL) { |
| LOG_DBG("vendor_meta is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_get_val(meta, meta_len, BT_AUDIO_METADATA_TYPE_VENDOR, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| *vendor_meta = data; |
| |
| return ret; |
| } |
| |
| static int codec_meta_set_vendor(uint8_t meta[], size_t meta_len, size_t meta_size, |
| const uint8_t *vendor, size_t vendor_len) |
| { |
| CHECKIF(meta == NULL) { |
| LOG_DBG("meta is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(vendor == NULL) { |
| LOG_DBG("vendor is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_set_val(meta, meta_len, meta_size, BT_AUDIO_METADATA_TYPE_VENDOR, vendor, |
| vendor_len); |
| } |
| |
| #if CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 |
| int bt_audio_codec_cfg_meta_get_val(const struct bt_audio_codec_cfg *codec_cfg, uint8_t type, |
| const uint8_t **data) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_val(codec_cfg->meta, codec_cfg->meta_len, type, 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 ret; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_set_val(codec_cfg->meta, codec_cfg->meta_len, ARRAY_SIZE(codec_cfg->meta), |
| type, data, data_len); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_unset_val(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_metadata_type type) |
| { |
| int ret; |
| |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_unset_val(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), type); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_pref_context(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_pref_context(codec_cfg->meta, codec_cfg->meta_len); |
| } |
| |
| int bt_audio_codec_cfg_meta_set_pref_context(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_context ctx) |
| { |
| int ret; |
| |
| ret = codec_meta_set_pref_context(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), ctx); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_stream_context(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_stream_context(codec_cfg->meta, codec_cfg->meta_len); |
| } |
| |
| int bt_audio_codec_cfg_meta_set_stream_context(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_context ctx) |
| { |
| int ret; |
| |
| ret = codec_meta_set_stream_context(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), ctx); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_program_info(const struct bt_audio_codec_cfg *codec_cfg, |
| const uint8_t **program_info) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_program_info(codec_cfg->meta, codec_cfg->meta_len, 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 ret; |
| |
| ret = codec_meta_set_program_info(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), program_info, |
| program_info_len); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_stream_lang(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_stream_lang(codec_cfg->meta, codec_cfg->meta_len); |
| } |
| |
| int bt_audio_codec_cfg_meta_set_stream_lang(struct bt_audio_codec_cfg *codec_cfg, |
| uint32_t stream_lang) |
| { |
| int ret; |
| |
| ret = codec_meta_set_stream_lang(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), stream_lang); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_ccid_list(const struct bt_audio_codec_cfg *codec_cfg, |
| const uint8_t **ccid_list) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_ccid_list(codec_cfg->meta, codec_cfg->meta_len, 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 ret; |
| |
| ret = codec_meta_set_ccid_list(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), ccid_list, ccid_list_len); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_parental_rating(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_parental_rating(codec_cfg->meta, codec_cfg->meta_len); |
| } |
| |
| int bt_audio_codec_cfg_meta_set_parental_rating(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_parental_rating parental_rating) |
| { |
| int ret; |
| |
| ret = codec_meta_set_parental_rating(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), parental_rating); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_program_info_uri(const struct bt_audio_codec_cfg *codec_cfg, |
| const uint8_t **program_info_uri) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_program_info_uri(codec_cfg->meta, codec_cfg->meta_len, |
| 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 ret; |
| |
| ret = codec_meta_set_program_info_uri(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), program_info_uri, |
| program_info_uri_len); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_audio_active_state(const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_audio_active_state(codec_cfg->meta, codec_cfg->meta_len); |
| } |
| |
| int bt_audio_codec_cfg_meta_set_audio_active_state(struct bt_audio_codec_cfg *codec_cfg, |
| enum bt_audio_active_state state) |
| { |
| int ret; |
| |
| ret = codec_meta_set_audio_active_state(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), state); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_bcast_audio_immediate_rend_flag( |
| const struct bt_audio_codec_cfg *codec_cfg) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_bcast_audio_immediate_rend_flag(codec_cfg->meta, codec_cfg->meta_len); |
| } |
| |
| int bt_audio_codec_cfg_meta_set_bcast_audio_immediate_rend_flag( |
| struct bt_audio_codec_cfg *codec_cfg) |
| { |
| int ret; |
| |
| ret = codec_meta_set_bcast_audio_immediate_rend_flag(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta)); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_extended(const struct bt_audio_codec_cfg *codec_cfg, |
| const uint8_t **extended_meta) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_extended(codec_cfg->meta, codec_cfg->meta_len, 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 ret; |
| |
| ret = codec_meta_set_extended(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), extended_meta, |
| extended_meta_len); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cfg_meta_get_vendor(const struct bt_audio_codec_cfg *codec_cfg, |
| const uint8_t **vendor_meta) |
| { |
| CHECKIF(codec_cfg == NULL) { |
| LOG_DBG("codec_cfg is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_vendor(codec_cfg->meta, codec_cfg->meta_len, 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) |
| { |
| int ret; |
| |
| ret = codec_meta_set_vendor(codec_cfg->meta, codec_cfg->meta_len, |
| ARRAY_SIZE(codec_cfg->meta), vendor_meta, vendor_meta_len); |
| if (ret >= 0) { |
| codec_cfg->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| #endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 */ |
| |
| #if CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE > 0 |
| int bt_audio_codec_cap_meta_get_val(const struct bt_audio_codec_cap *codec_cap, uint8_t type, |
| const uint8_t **data) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_val(codec_cap->meta, codec_cap->meta_len, type, 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 ret; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_set_val(codec_cap->meta, codec_cap->meta_len, ARRAY_SIZE(codec_cap->meta), |
| type, data, data_len); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_unset_val(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_metadata_type type) |
| { |
| int ret; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| ret = codec_meta_unset_val(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), type); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_pref_context(const struct bt_audio_codec_cap *codec_cap) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_pref_context(codec_cap->meta, codec_cap->meta_len); |
| } |
| |
| int bt_audio_codec_cap_meta_set_pref_context(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_context ctx) |
| { |
| int ret; |
| |
| ret = codec_meta_set_pref_context(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), ctx); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_stream_context(const struct bt_audio_codec_cap *codec_cap) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_stream_context(codec_cap->meta, codec_cap->meta_len); |
| } |
| |
| int bt_audio_codec_cap_meta_set_stream_context(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_context ctx) |
| { |
| int ret; |
| |
| ret = codec_meta_set_stream_context(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), ctx); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_program_info(const struct bt_audio_codec_cap *codec_cap, |
| const uint8_t **program_info) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_program_info(codec_cap->meta, codec_cap->meta_len, 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 ret; |
| |
| ret = codec_meta_set_program_info(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), program_info, |
| program_info_len); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_stream_lang(const struct bt_audio_codec_cap *codec_cap) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_stream_lang(codec_cap->meta, codec_cap->meta_len); |
| } |
| |
| int bt_audio_codec_cap_meta_set_stream_lang(struct bt_audio_codec_cap *codec_cap, |
| uint32_t stream_lang) |
| { |
| int ret; |
| |
| ret = codec_meta_set_stream_lang(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), stream_lang); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_ccid_list(const struct bt_audio_codec_cap *codec_cap, |
| const uint8_t **ccid_list) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_ccid_list(codec_cap->meta, codec_cap->meta_len, 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 ret; |
| |
| ret = codec_meta_set_ccid_list(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), ccid_list, ccid_list_len); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_parental_rating(const struct bt_audio_codec_cap *codec_cap) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_parental_rating(codec_cap->meta, codec_cap->meta_len); |
| } |
| |
| int bt_audio_codec_cap_meta_set_parental_rating(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_parental_rating parental_rating) |
| { |
| int ret; |
| |
| ret = codec_meta_set_parental_rating(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), parental_rating); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_program_info_uri(const struct bt_audio_codec_cap *codec_cap, |
| const uint8_t **program_info_uri) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_program_info_uri(codec_cap->meta, codec_cap->meta_len, |
| 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 ret; |
| |
| ret = codec_meta_set_program_info_uri(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), program_info_uri, |
| program_info_uri_len); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_audio_active_state(const struct bt_audio_codec_cap *codec_cap) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_audio_active_state(codec_cap->meta, codec_cap->meta_len); |
| } |
| |
| int bt_audio_codec_cap_meta_set_audio_active_state(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_active_state state) |
| { |
| int ret; |
| |
| ret = codec_meta_set_audio_active_state(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), state); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_bcast_audio_immediate_rend_flag( |
| const struct bt_audio_codec_cap *codec_cap) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_bcast_audio_immediate_rend_flag(codec_cap->meta, codec_cap->meta_len); |
| } |
| |
| int bt_audio_codec_cap_meta_set_bcast_audio_immediate_rend_flag( |
| struct bt_audio_codec_cap *codec_cap) |
| { |
| int ret; |
| |
| ret = codec_meta_set_bcast_audio_immediate_rend_flag(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta)); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_extended(const struct bt_audio_codec_cap *codec_cap, |
| const uint8_t **extended_meta) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_extended(codec_cap->meta, codec_cap->meta_len, 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 ret; |
| |
| ret = codec_meta_set_extended(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), extended_meta, |
| extended_meta_len); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_meta_get_vendor(const struct bt_audio_codec_cap *codec_cap, |
| const uint8_t **vendor_meta) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| return codec_meta_get_vendor(codec_cap->meta, codec_cap->meta_len, 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) |
| { |
| int ret; |
| |
| ret = codec_meta_set_vendor(codec_cap->meta, codec_cap->meta_len, |
| ARRAY_SIZE(codec_cap->meta), vendor_meta, vendor_meta_len); |
| if (ret >= 0) { |
| codec_cap->meta_len = ret; |
| } |
| |
| return ret; |
| } |
| #endif /* CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE > 0 */ |
| #endif /* CONFIG_BT_AUDIO_CODEC_CFG_MAX_METADATA_SIZE > 0 || \ |
| * CONFIG_BT_AUDIO_CODEC_CAP_MAX_METADATA_SIZE > 0 \ |
| */ |
| |
| #if CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE > 0 |
| |
| static void init_net_buf_simple_from_codec_cap(struct net_buf_simple *buf, |
| struct bt_audio_codec_cap *codec_cap) |
| { |
| buf->__buf = codec_cap->data; |
| buf->data = codec_cap->data; |
| buf->size = sizeof(codec_cap->data); |
| buf->len = codec_cap->data_len; |
| } |
| |
| 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) |
| { |
| struct search_type_param param = { |
| .found = false, |
| .type = (uint8_t)type, |
| .data_len = 0, |
| .data = data, |
| }; |
| int err; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data == NULL) { |
| LOG_DBG("data is NULL"); |
| return -EINVAL; |
| } |
| |
| *data = NULL; |
| |
| err = bt_audio_data_parse(codec_cap->data, codec_cap->data_len, parse_cb, ¶m); |
| if (err != 0 && err != -ECANCELED) { |
| LOG_DBG("Could not parse the data: %d", err); |
| return err; |
| } |
| |
| if (!param.found) { |
| LOG_DBG("Could not find the type %u", type); |
| return -ENODATA; |
| } |
| |
| return param.data_len; |
| } |
| |
| 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) |
| { |
| struct net_buf_simple buf; |
| int ret; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data == NULL) { |
| LOG_DBG("data is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(data_len == 0U || data_len > UINT8_MAX) { |
| LOG_DBG("Invalid data_len %zu", data_len); |
| return -EINVAL; |
| } |
| |
| init_net_buf_simple_from_codec_cap(&buf, codec_cap); |
| |
| ret = ltv_set_val(&buf, type, data, data_len); |
| if (ret >= 0) { |
| codec_cap->data_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_unset_val(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_codec_cap_type type) |
| { |
| struct net_buf_simple buf; |
| int ret; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| init_net_buf_simple_from_codec_cap(&buf, codec_cap); |
| |
| ret = ltv_unset_val(&buf, type); |
| if (ret >= 0) { |
| codec_cap->data_len = ret; |
| } |
| |
| return ret; |
| } |
| |
| int bt_audio_codec_cap_get_freq(const struct bt_audio_codec_cap *codec_cap) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FREQ, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint16_t)) { |
| return -EBADMSG; |
| } |
| |
| return sys_get_le16(data); |
| } |
| |
| int bt_audio_codec_cap_set_freq(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_codec_cap_freq freq) |
| { |
| uint16_t freq_le16; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| 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_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) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_DURATION, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| return data[0]; |
| } |
| |
| int bt_audio_codec_cap_set_frame_dur(struct bt_audio_codec_cap *codec_cap, |
| enum bt_audio_codec_cap_frame_dur frame_dur) |
| { |
| uint8_t frame_dur_u8; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| 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_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_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_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_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) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_CHAN_COUNT, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| return data[0]; |
| } |
| |
| 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) |
| { |
| uint8_t chan_count_u8; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| 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_CAP_TYPE_CHAN_COUNT, |
| &chan_count_u8, sizeof(chan_count_u8)); |
| } |
| |
| 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) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(codec_frame == NULL) { |
| LOG_DBG("codec_frame is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_LEN, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint32_t)) { |
| return -EBADMSG; |
| } |
| |
| codec_frame->min = sys_get_le16(data); |
| codec_frame->max = sys_get_le16(data + sizeof(codec_frame->min)); |
| |
| return 0; |
| } |
| |
| 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) |
| { |
| uint8_t codec_frame_le32[4]; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| CHECKIF(codec_frame == NULL) { |
| LOG_DBG("codec_frame is NULL"); |
| return -EINVAL; |
| } |
| |
| if (codec_frame->min > codec_frame->max) { |
| LOG_DBG("Invalid codec_frame values: %u/%u", codec_frame->min, codec_frame->max); |
| return -EINVAL; |
| } |
| |
| 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_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) |
| { |
| const uint8_t *data; |
| uint8_t data_len; |
| |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| data_len = |
| bt_audio_codec_cap_get_val(codec_cap, BT_AUDIO_CODEC_CAP_TYPE_FRAME_COUNT, &data); |
| if (data == NULL) { |
| return -ENODATA; |
| } |
| |
| if (data_len != sizeof(uint8_t)) { |
| return -EBADMSG; |
| } |
| |
| return data[0]; |
| } |
| |
| int bt_audio_codec_cap_set_max_codec_frames_per_sdu(struct bt_audio_codec_cap *codec_cap, |
| uint8_t codec_frames_per_sdu) |
| { |
| CHECKIF(codec_cap == NULL) { |
| LOG_DBG("codec_cap is NULL"); |
| return -EINVAL; |
| } |
| |
| 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)); |
| } |
| |
| #endif /* CONFIG_BT_AUDIO_CODEC_CAP_MAX_DATA_SIZE > 0 */ |