1 /*
2 * Copyright (c) 2022-2024 Nordic Semiconductor ASA
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <errno.h>
8 #include <stddef.h>
9 #include <stdint.h>
10 #include <string.h>
11
12 #include <zephyr/autoconf.h>
13 #include <zephyr/bluetooth/audio/audio.h>
14 #include <zephyr/bluetooth/audio/bap.h>
15 #include <zephyr/bluetooth/audio/bap_lc3_preset.h>
16 #include <zephyr/bluetooth/bluetooth.h>
17 #include <zephyr/bluetooth/byteorder.h>
18 #include <zephyr/bluetooth/crypto.h>
19 #include <zephyr/bluetooth/gap.h>
20 #include <zephyr/bluetooth/iso.h>
21 #include <zephyr/bluetooth/uuid.h>
22 #include <zephyr/device.h>
23 #include <zephyr/devicetree.h>
24 #include <zephyr/drivers/usb/udc_buf.h>
25 #include <zephyr/kernel.h>
26 #include <zephyr/net_buf.h>
27 #include <zephyr/sys/__assert.h>
28 #include <zephyr/sys/printk.h>
29 #include <zephyr/sys/util.h>
30 #include <zephyr/sys_clock.h>
31 #include <zephyr/toolchain.h>
32 #include <zephyr/usb/class/usbd_uac2.h>
33 #include <zephyr/usb/usbd.h>
34
35 BUILD_ASSERT(strlen(CONFIG_BROADCAST_CODE) <= BT_ISO_BROADCAST_CODE_SIZE, "Invalid broadcast code");
36 BUILD_ASSERT(IN_RANGE(strlen(CONFIG_BROADCAST_NAME), BT_AUDIO_BROADCAST_NAME_LEN_MIN,
37 BT_AUDIO_BROADCAST_NAME_LEN_MAX),
38 "Invalid broadcast name");
39
40 /* When BROADCAST_ENQUEUE_COUNT > 1 we can enqueue enough buffers to ensure that
41 * the controller is never idle
42 */
43 #define BROADCAST_ENQUEUE_COUNT 3U
44 #define TOTAL_BUF_NEEDED (BROADCAST_ENQUEUE_COUNT * CONFIG_BT_BAP_BROADCAST_SRC_STREAM_COUNT)
45
46 BUILD_ASSERT(CONFIG_BT_ISO_TX_BUF_COUNT >= TOTAL_BUF_NEEDED,
47 "CONFIG_BT_ISO_TX_BUF_COUNT should be at least "
48 "BROADCAST_ENQUEUE_COUNT * CONFIG_BT_BAP_BROADCAST_SRC_STREAM_COUNT");
49
50 #if defined(CONFIG_BAP_BROADCAST_16_2_1)
51
52 static struct bt_bap_lc3_preset preset_active = BT_BAP_LC3_BROADCAST_PRESET_16_2_1(
53 BT_AUDIO_LOCATION_FRONT_LEFT | BT_AUDIO_LOCATION_FRONT_RIGHT,
54 BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED);
55
56 #define BROADCAST_SAMPLE_RATE 16000
57
58 #elif defined(CONFIG_BAP_BROADCAST_24_2_1)
59
60 static struct bt_bap_lc3_preset preset_active = BT_BAP_LC3_BROADCAST_PRESET_24_2_1(
61 BT_AUDIO_LOCATION_FRONT_LEFT | BT_AUDIO_LOCATION_FRONT_RIGHT,
62 BT_AUDIO_CONTEXT_TYPE_UNSPECIFIED);
63
64 #define BROADCAST_SAMPLE_RATE 24000
65
66 #endif
67
68 #if defined(CONFIG_BAP_BROADCAST_16_2_1)
69 #define MAX_SAMPLE_RATE 16000
70 #elif defined(CONFIG_BAP_BROADCAST_24_2_1)
71 #define MAX_SAMPLE_RATE 24000
72 #endif
73 #define MAX_FRAME_DURATION_US 10000
74 #define MAX_NUM_SAMPLES ((MAX_FRAME_DURATION_US * MAX_SAMPLE_RATE) / USEC_PER_SEC)
75
76 #if defined(CONFIG_LIBLC3)
77 #include "lc3.h"
78
79 #if defined(CONFIG_USE_USB_AUDIO_INPUT)
80 #include <zephyr/usb/usb_device.h>
81 #include <zephyr/usb/class/usb_audio.h>
82 #include <zephyr/sys/ring_buffer.h>
83
84 #include <sample_usbd.h>
85
86 /* USB Audio Data is downsampled from 48kHz to match broadcast preset when receiving data */
87 #define USB_SAMPLE_RATE 48000
88 #define USB_DOWNSAMPLE_RATE BROADCAST_SAMPLE_RATE
89 #define USB_FRAME_DURATION_US 1000
90 #define USB_SAMPLE_CNT ((USB_FRAME_DURATION_US * USB_SAMPLE_RATE) / USEC_PER_SEC)
91 #define USB_DOWNSSAMPLE_CNT ((USB_FRAME_DURATION_US * USB_DOWNSAMPLE_RATE) / USEC_PER_SEC)
92 #define USB_BYTES_PER_SAMPLE 2
93 #define USB_CHANNELS 2
94 #define USB_MONO_FRAME_SIZE (USB_SAMPLE_CNT * USB_BYTES_PER_SAMPLE)
95 /* The number of samples received may be USB_SAMPLE_CNT -+ 1 */
96 #define USB_MAX_MONO_FRAME_SIZE ((USB_SAMPLE_CNT + 1) * USB_BYTES_PER_SAMPLE)
97 #define USB_STEREO_FRAME_SIZE (USB_MONO_FRAME_SIZE * USB_CHANNELS)
98 #define USB_MAX_STEREO_FRAME_SIZE (USB_MAX_MONO_FRAME_SIZE * USB_CHANNELS)
99 #define USB_ENQUEUE_COUNT 30U /* 30 times 1ms frames => 30ms */
100
101 #define RING_BUF_USB_FRAMES 20
102 #define AUDIO_RING_BUF_BYTES (USB_DOWNSSAMPLE_CNT * USB_BYTES_PER_SAMPLE * RING_BUF_USB_FRAMES)
103 #else /* !defined(CONFIG_USE_USB_AUDIO_INPUT) */
104
105 #include <math.h>
106
107 #define AUDIO_VOLUME (INT16_MAX - 3000) /* codec does clipping above INT16_MAX - 3000 */
108 #define AUDIO_TONE_FREQUENCY_HZ 400
109
110 /**
111 * Use the math lib to generate a sine-wave using 16 bit samples into a buffer.
112 *
113 * @param buf Destination buffer
114 * @param length_us Length of the buffer in microseconds
115 * @param frequency_hz frequency in Hz
116 * @param sample_rate_hz sample-rate in Hz.
117 */
fill_audio_buf_sin(int16_t * buf,int length_us,int frequency_hz,int sample_rate_hz)118 static void fill_audio_buf_sin(int16_t *buf, int length_us, int frequency_hz, int sample_rate_hz)
119 {
120 const int sine_period_samples = sample_rate_hz / frequency_hz;
121 const unsigned int num_samples = (length_us * sample_rate_hz) / USEC_PER_SEC;
122 const float step = 2 * 3.1415f / sine_period_samples;
123
124 for (unsigned int i = 0; i < num_samples; i++) {
125 const float sample = sinf(i * step);
126
127 buf[i] = (int16_t)(AUDIO_VOLUME * sample);
128 }
129 }
130 #endif /* defined(CONFIG_USE_USB_AUDIO_INPUT) */
131 #endif /* defined(CONFIG_LIBLC3) */
132
133 static struct broadcast_source_stream {
134 struct bt_bap_stream stream;
135 uint16_t seq_num;
136 size_t sent_cnt;
137 #if defined(CONFIG_LIBLC3)
138 lc3_encoder_t lc3_encoder;
139 #if defined(CONFIG_BAP_BROADCAST_16_2_1)
140 lc3_encoder_mem_16k_t lc3_encoder_mem;
141 #elif defined(CONFIG_BAP_BROADCAST_24_2_1)
142 lc3_encoder_mem_48k_t lc3_encoder_mem;
143 #endif
144 #if defined(CONFIG_USE_USB_AUDIO_INPUT)
145 struct ring_buf audio_ring_buf;
146 uint8_t _ring_buffer_memory[AUDIO_RING_BUF_BYTES];
147 #endif /* defined(CONFIG_USE_USB_AUDIO_INPUT) */
148 #endif /* defined(CONFIG_LIBLC3) */
149 } streams[CONFIG_BT_BAP_BROADCAST_SRC_STREAM_COUNT];
150 static struct bt_bap_broadcast_source *broadcast_source;
151
152 NET_BUF_POOL_FIXED_DEFINE(tx_pool, TOTAL_BUF_NEEDED, BT_ISO_SDU_BUF_SIZE(CONFIG_BT_ISO_TX_MTU),
153 CONFIG_BT_CONN_TX_USER_DATA_SIZE, NULL);
154
155 static int16_t send_pcm_data[MAX_NUM_SAMPLES];
156 static uint16_t seq_num;
157 static bool stopping;
158
159 static K_SEM_DEFINE(sem_started, 0U, 1U);
160 static K_SEM_DEFINE(sem_stopped, 0U, 1U);
161
162 #define BROADCAST_SOURCE_LIFETIME 120U /* seconds */
163
164 #if defined(CONFIG_LIBLC3)
165 static int freq_hz;
166 static int frame_duration_us;
167 static int frames_per_sdu;
168 static int octets_per_frame;
169
170 static K_SEM_DEFINE(lc3_encoder_sem, 0U, TOTAL_BUF_NEEDED);
171 #endif
172
send_data(struct broadcast_source_stream * source_stream)173 static void send_data(struct broadcast_source_stream *source_stream)
174 {
175 struct bt_bap_stream *stream = &source_stream->stream;
176 struct net_buf *buf;
177 int ret;
178
179 if (stopping) {
180 return;
181 }
182
183 buf = net_buf_alloc(&tx_pool, K_FOREVER);
184 if (buf == NULL) {
185 printk("Could not allocate buffer when sending on %p\n", stream);
186 return;
187 }
188
189 net_buf_reserve(buf, BT_ISO_CHAN_SEND_RESERVE);
190 #if defined(CONFIG_LIBLC3)
191 uint8_t lc3_encoded_buffer[preset_active.qos.sdu];
192
193 if (source_stream->lc3_encoder == NULL) {
194 printk("LC3 encoder not setup, cannot encode data.\n");
195 net_buf_unref(buf);
196 return;
197 }
198
199 #if defined(CONFIG_USE_USB_AUDIO_INPUT)
200 uint32_t size = ring_buf_get(&source_stream->audio_ring_buf, (uint8_t *)send_pcm_data,
201 sizeof(send_pcm_data));
202
203 if (size < sizeof(send_pcm_data)) {
204 const size_t padding_size = sizeof(send_pcm_data) - size;
205
206 printk("Not enough bytes ready, padding %d!\n", padding_size);
207 memset(&((uint8_t *)send_pcm_data)[size], 0, padding_size);
208 }
209 #endif
210
211 ret = lc3_encode(source_stream->lc3_encoder, LC3_PCM_FORMAT_S16, send_pcm_data, 1,
212 octets_per_frame, lc3_encoded_buffer);
213 if (ret == -1) {
214 printk("LC3 encoder failed - wrong parameters?: %d", ret);
215 net_buf_unref(buf);
216 return;
217 }
218
219 net_buf_add_mem(buf, lc3_encoded_buffer, preset_active.qos.sdu);
220 #else
221 net_buf_add_mem(buf, send_pcm_data, preset_active.qos.sdu);
222 #endif /* defined(CONFIG_LIBLC3) */
223
224 ret = bt_bap_stream_send(stream, buf, source_stream->seq_num++);
225 if (ret < 0) {
226 /* This will end broadcasting on this stream. */
227 printk("Unable to broadcast data on %p: %d\n", stream, ret);
228 net_buf_unref(buf);
229 return;
230 }
231
232 source_stream->sent_cnt++;
233 if ((source_stream->sent_cnt % 1000U) == 0U) {
234 printk("Stream %p: Sent %u total ISO packets\n", stream, source_stream->sent_cnt);
235 }
236 }
237
238 #if defined(CONFIG_LIBLC3)
init_lc3_thread(void * arg1,void * arg2,void * arg3)239 static void init_lc3_thread(void *arg1, void *arg2, void *arg3)
240 {
241 const struct bt_audio_codec_cfg *codec_cfg = &preset_active.codec_cfg;
242 int ret;
243
244 ret = bt_audio_codec_cfg_get_freq(codec_cfg);
245 if (ret > 0) {
246 freq_hz = bt_audio_codec_cfg_freq_to_freq_hz(ret);
247 } else {
248 return;
249 }
250
251 ret = bt_audio_codec_cfg_get_frame_dur(codec_cfg);
252 if (ret > 0) {
253 frame_duration_us = bt_audio_codec_cfg_frame_dur_to_frame_dur_us(ret);
254 } else {
255 printk("Error: Frame duration not set, cannot start codec.");
256 return;
257 }
258
259 octets_per_frame = bt_audio_codec_cfg_get_octets_per_frame(codec_cfg);
260 frames_per_sdu = bt_audio_codec_cfg_get_frame_blocks_per_sdu(codec_cfg, true);
261
262 if (freq_hz < 0) {
263 printk("Error: Codec frequency not set, cannot start codec.");
264 return;
265 }
266
267 if (frame_duration_us < 0) {
268 printk("Error: Frame duration not set, cannot start codec.");
269 return;
270 }
271
272 if (octets_per_frame < 0) {
273 printk("Error: Octets per frame not set, cannot start codec.");
274 return;
275 }
276
277 #if !defined(CONFIG_USE_USB_AUDIO_INPUT)
278 /* If USB is not used as a sound source, generate a sine wave */
279 fill_audio_buf_sin(send_pcm_data, frame_duration_us, AUDIO_TONE_FREQUENCY_HZ, freq_hz);
280 #endif
281
282 /* Create the encoder instance. This shall complete before stream_started() is called. */
283 for (size_t i = 0U; i < ARRAY_SIZE(streams); i++) {
284 printk("Initializing lc3 encoder for stream %zu\n", i);
285 streams[i].lc3_encoder = lc3_setup_encoder(frame_duration_us, freq_hz, 0,
286 &streams[i].lc3_encoder_mem);
287
288 if (streams[i].lc3_encoder == NULL) {
289 printk("ERROR: Failed to setup LC3 encoder - wrong parameters?\n");
290 }
291 }
292
293 while (true) {
294 for (size_t i = 0U; i < ARRAY_SIZE(streams); i++) {
295 k_sem_take(&lc3_encoder_sem, K_FOREVER);
296 }
297 for (size_t i = 0U; i < ARRAY_SIZE(streams); i++) {
298 send_data(&streams[i]);
299 }
300 }
301 }
302
303 #define LC3_ENCODER_STACK_SIZE 4 * 4096
304 #define LC3_ENCODER_PRIORITY 5
305
306 K_THREAD_DEFINE(encoder, LC3_ENCODER_STACK_SIZE, init_lc3_thread, NULL, NULL, NULL,
307 LC3_ENCODER_PRIORITY, 0, -1);
308
309 #if defined(CONFIG_USE_USB_AUDIO_INPUT)
310 /* Allocate 3: 1 for USB to receive data to and 2 additional buffers to prevent out of memory
311 * errors when USB host decides to perform rapid terminal enable/disable cycles.
312 */
313 K_MEM_SLAB_DEFINE_STATIC(usb_out_buf_pool, USB_MAX_STEREO_FRAME_SIZE, 3, UDC_BUF_ALIGN);
314 static bool terminal_enabled;
315
terminal_update_cb(const struct device * dev,uint8_t terminal,bool enabled,bool microframes,void * user_data)316 static void terminal_update_cb(const struct device *dev, uint8_t terminal, bool enabled,
317 bool microframes, void *user_data)
318 {
319 terminal_enabled = enabled;
320 }
321
uac2_sof_cb(const struct device * dev,void * user_data)322 static void uac2_sof_cb(const struct device *dev, void *user_data)
323 {
324 /* no-op, but has to be registered */
325 }
326
get_recv_buf_cb(const struct device * dev,uint8_t terminal,uint16_t size,void * user_data)327 static void *get_recv_buf_cb(const struct device *dev, uint8_t terminal, uint16_t size,
328 void *user_data)
329 {
330 void *buf = NULL;
331 int ret;
332
333 if (!terminal_enabled) {
334 return NULL;
335 }
336
337 __ASSERT(size <= USB_MAX_STEREO_FRAME_SIZE, "%u was not <= %d", size,
338 USB_MAX_STEREO_FRAME_SIZE);
339
340 ret = k_mem_slab_alloc(&usb_out_buf_pool, &buf, K_NO_WAIT);
341 if (ret != 0) {
342 printk("Failed to allocate buffer: %d\n", ret);
343 }
344
345 return buf;
346 }
347
data_recv_cb(const struct device * dev,uint8_t terminal,void * buf,uint16_t size,void * user_data)348 static void data_recv_cb(const struct device *dev, uint8_t terminal, void *buf, uint16_t size,
349 void *user_data)
350 {
351 int16_t usb_pcm_data[USB_CHANNELS][USB_DOWNSSAMPLE_CNT];
352 int nsamples, ratio;
353 static int count;
354 int16_t *pcm;
355
356 if (!terminal_enabled || buf == NULL || size == 0U) {
357 k_mem_slab_free(&usb_out_buf_pool, buf);
358 return;
359 }
360
361 pcm = (int16_t *)buf;
362
363 /* 'size' is in bytes, containing 1ms, 48kHz, stereo, 2 bytes per sample.
364 * Do a simple downsample to 16kHz/24Khz matching the broadcast preset.
365 */
366
367 ratio = USB_SAMPLE_RATE / USB_DOWNSAMPLE_RATE;
368 nsamples = size / (sizeof(int16_t) * USB_CHANNELS * ratio);
369 for (size_t i = 0, j = 0; i < nsamples; i++, j += USB_CHANNELS * ratio) {
370 usb_pcm_data[0][i] = pcm[j];
371 usb_pcm_data[1][i] = pcm[j + 1];
372 }
373
374 for (size_t i = 0U; i < MIN(ARRAY_SIZE(streams), 2); i++) {
375 const uint32_t size_put =
376 ring_buf_put(&(streams[i].audio_ring_buf), (uint8_t *)(usb_pcm_data[i]),
377 nsamples * USB_BYTES_PER_SAMPLE);
378 if (size_put < nsamples * USB_BYTES_PER_SAMPLE) {
379 printk("Not enough room for samples in %s buffer: %u < %u, total capacity: "
380 "%u\n",
381 i == 0 ? "left" : "right", size_put, nsamples * USB_BYTES_PER_SAMPLE,
382 ring_buf_capacity_get(&(streams[i].audio_ring_buf)));
383 }
384 }
385
386 count++;
387 if ((count % 10000) == 0) {
388 printk("USB Data received (count = %d)\n", count);
389 }
390
391 k_mem_slab_free(&usb_out_buf_pool, buf);
392 }
393 #endif /* defined(CONFIG_USE_USB_AUDIO_INPUT) */
394 #endif /* defined(CONFIG_LIBLC3) */
395
stream_started_cb(struct bt_bap_stream * stream)396 static void stream_started_cb(struct bt_bap_stream *stream)
397 {
398 struct broadcast_source_stream *source_stream =
399 CONTAINER_OF(stream, struct broadcast_source_stream, stream);
400 struct bt_iso_info info;
401 int err;
402
403 err = bt_iso_chan_get_info(stream->iso, &info);
404 __ASSERT(err == 0, "Failed to get ISO chan info: %d", err);
405
406 printk("Stream %p started with BIG_Handle %u and BIS_Number %u\n", stream,
407 info.broadcaster.big_handle, info.broadcaster.bis_number);
408
409 source_stream->seq_num = 0U;
410 source_stream->sent_cnt = 0U;
411 }
412
stream_sent_cb(struct bt_bap_stream * stream)413 static void stream_sent_cb(struct bt_bap_stream *stream)
414 {
415 #if defined(CONFIG_LIBLC3)
416 k_sem_give(&lc3_encoder_sem);
417 #else
418 /* If no LC3 encoder is used, just send mock data directly */
419 struct broadcast_source_stream *source_stream =
420 CONTAINER_OF(stream, struct broadcast_source_stream, stream);
421
422 send_data(source_stream);
423 #endif
424 }
425
426 static struct bt_bap_stream_ops stream_ops = {
427 .started = stream_started_cb,
428 .sent = stream_sent_cb,
429 };
430
setup_broadcast_source(struct bt_bap_broadcast_source ** source)431 static int setup_broadcast_source(struct bt_bap_broadcast_source **source)
432 {
433 struct bt_bap_broadcast_source_stream_param
434 stream_params[CONFIG_BT_BAP_BROADCAST_SRC_STREAM_COUNT];
435 struct bt_bap_broadcast_source_subgroup_param
436 subgroup_param[CONFIG_BT_BAP_BROADCAST_SRC_SUBGROUP_COUNT];
437 struct bt_bap_broadcast_source_param create_param = {0};
438 const size_t streams_per_subgroup = ARRAY_SIZE(stream_params) / ARRAY_SIZE(subgroup_param);
439 uint8_t left[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
440 BT_BYTES_LIST_LE32(BT_AUDIO_LOCATION_FRONT_LEFT))};
441 uint8_t right[] = {BT_AUDIO_CODEC_DATA(BT_AUDIO_CODEC_CFG_CHAN_ALLOC,
442 BT_BYTES_LIST_LE32(BT_AUDIO_LOCATION_FRONT_RIGHT))};
443 int err;
444
445 for (size_t i = 0U; i < ARRAY_SIZE(subgroup_param); i++) {
446 subgroup_param[i].params_count = streams_per_subgroup;
447 subgroup_param[i].params = stream_params + i * streams_per_subgroup;
448 subgroup_param[i].codec_cfg = &preset_active.codec_cfg;
449 }
450
451 for (size_t j = 0U; j < ARRAY_SIZE(stream_params); j++) {
452 stream_params[j].stream = &streams[j].stream;
453 stream_params[j].data = j == 0 ? left : right;
454 stream_params[j].data_len = j == 0 ? sizeof(left) : sizeof(right);
455 bt_bap_stream_cb_register(stream_params[j].stream, &stream_ops);
456 }
457
458 create_param.params_count = ARRAY_SIZE(subgroup_param);
459 create_param.params = subgroup_param;
460 create_param.qos = &preset_active.qos;
461 create_param.encryption = strlen(CONFIG_BROADCAST_CODE) > 0;
462 create_param.packing = (IS_ENABLED(CONFIG_ISO_PACKING_INTERLEAVED) ?
463 BT_ISO_PACKING_INTERLEAVED :
464 BT_ISO_PACKING_SEQUENTIAL);
465
466 if (create_param.encryption) {
467 memcpy(create_param.broadcast_code, CONFIG_BROADCAST_CODE,
468 strlen(CONFIG_BROADCAST_CODE));
469 }
470
471 printk("Creating broadcast source with %zu subgroups with %zu streams\n",
472 ARRAY_SIZE(subgroup_param), ARRAY_SIZE(subgroup_param) * streams_per_subgroup);
473
474 err = bt_bap_broadcast_source_create(&create_param, source);
475 if (err != 0) {
476 printk("Unable to create broadcast source: %d\n", err);
477 return err;
478 }
479
480 return 0;
481 }
482
source_started_cb(struct bt_bap_broadcast_source * source)483 static void source_started_cb(struct bt_bap_broadcast_source *source)
484 {
485 printk("Broadcast source %p started\n", source);
486 k_sem_give(&sem_started);
487 }
488
source_stopped_cb(struct bt_bap_broadcast_source * source,uint8_t reason)489 static void source_stopped_cb(struct bt_bap_broadcast_source *source, uint8_t reason)
490 {
491 printk("Broadcast source %p stopped with reason 0x%02X\n", source, reason);
492 k_sem_give(&sem_stopped);
493 }
494
main(void)495 int main(void)
496 {
497 static struct bt_bap_broadcast_source_cb broadcast_source_cb = {
498 .started = source_started_cb,
499 .stopped = source_stopped_cb,
500 };
501 struct bt_le_ext_adv *adv;
502 int err;
503
504 err = bt_enable(NULL);
505 if (err) {
506 printk("Bluetooth init failed (err %d)\n", err);
507 return 0;
508 }
509 printk("Bluetooth initialized\n");
510
511 err = bt_bap_broadcast_source_register_cb(&broadcast_source_cb);
512 if (err != 0) {
513 printk("Failed to register broadcast source callbacks (err %d)\n", err);
514 return 0;
515 }
516
517 for (size_t i = 0U; i < ARRAY_SIZE(send_pcm_data); i++) {
518 /* Initialize mock data */
519 send_pcm_data[i] = i;
520 }
521
522 #if defined(CONFIG_LIBLC3)
523 #if defined(CONFIG_USE_USB_AUDIO_INPUT)
524 const struct device *broadcaster_dev = DEVICE_DT_GET(DT_NODELABEL(uac2_broadcaster));
525 static struct uac2_ops usb_audio_ops = {
526 .terminal_update_cb = terminal_update_cb,
527 .get_recv_buf = get_recv_buf_cb,
528 .data_recv_cb = data_recv_cb,
529 .sof_cb = uac2_sof_cb,
530 };
531 struct usbd_context *sample_usbd;
532
533 if (!device_is_ready(broadcaster_dev)) {
534 printk("Cannot get USB Broadcaster Device\n");
535 return -EIO;
536 }
537
538 printk("Found USB Headset Device\n");
539
540 (void)memset(streams, 0, sizeof(streams));
541
542 for (size_t i = 0U; i < ARRAY_SIZE(streams); i++) {
543 ring_buf_init(&(streams[i].audio_ring_buf), sizeof(streams[i]._ring_buffer_memory),
544 streams[i]._ring_buffer_memory);
545 printk("Initialized ring buf %zu: capacity: %u\n", i,
546 ring_buf_capacity_get(&(streams[i].audio_ring_buf)));
547 }
548
549 usbd_uac2_set_ops(broadcaster_dev, &usb_audio_ops, NULL);
550
551 sample_usbd = sample_usbd_init_device(NULL);
552 if (sample_usbd == NULL) {
553 printk("Failed to init USBD device: %d\n", err);
554 return -ENODEV;
555 }
556
557 err = usbd_enable(sample_usbd);
558 if (err != 0) {
559 printk("Failed to enable USBD: %d\n", err);
560 return err;
561 }
562
563 printk("USB initialized\n");
564
565 #endif /* defined(CONFIG_USE_USB_AUDIO_INPUT) */
566 k_thread_start(encoder);
567 #endif /* defined(CONFIG_LIBLC3) */
568
569 while (true) {
570 /* Broadcast Audio Streaming Endpoint advertising data */
571 NET_BUF_SIMPLE_DEFINE(ad_buf, BT_UUID_SIZE_16 + BT_AUDIO_BROADCAST_ID_SIZE);
572 NET_BUF_SIMPLE_DEFINE(base_buf, 128);
573 struct bt_data ext_ad[3];
574 struct bt_data per_ad;
575 uint32_t broadcast_id;
576
577 /* Create a connectable advertising set */
578 err = bt_le_ext_adv_create(BT_BAP_ADV_PARAM_BROADCAST_FAST, NULL, &adv);
579 if (err != 0) {
580 printk("Unable to create extended advertising set: %d\n", err);
581 return 0;
582 }
583
584 /* Set periodic advertising parameters */
585 err = bt_le_per_adv_set_param(adv, BT_BAP_PER_ADV_PARAM_BROADCAST_FAST);
586 if (err) {
587 printk("Failed to set periodic advertising parameters (err %d)\n", err);
588 return 0;
589 }
590
591 printk("Creating broadcast source\n");
592 err = setup_broadcast_source(&broadcast_source);
593 if (err != 0) {
594 printk("Unable to setup broadcast source: %d\n", err);
595 return 0;
596 }
597
598 #if defined(CONFIG_STATIC_BROADCAST_ID)
599 broadcast_id = CONFIG_BROADCAST_ID;
600 #else
601 err = bt_rand(&broadcast_id, BT_AUDIO_BROADCAST_ID_SIZE);
602 if (err) {
603 printk("Unable to generate broadcast ID: %d\n", err);
604 return err;
605 }
606 #endif /* CONFIG_STATIC_BROADCAST_ID */
607
608 /* Setup extended advertising data */
609 net_buf_simple_add_le16(&ad_buf, BT_UUID_BROADCAST_AUDIO_VAL);
610 net_buf_simple_add_le24(&ad_buf, broadcast_id);
611 ext_ad[0].type = BT_DATA_SVC_DATA16;
612 ext_ad[0].data_len = ad_buf.len;
613 ext_ad[0].data = ad_buf.data;
614 ext_ad[1] = (struct bt_data)BT_DATA(BT_DATA_NAME_COMPLETE, CONFIG_BT_DEVICE_NAME,
615 sizeof(CONFIG_BT_DEVICE_NAME) - 1);
616 /* Broadcast name used for scanning device that displays information on the */
617 /* available broadcast sources. */
618 ext_ad[2] = (struct bt_data)BT_DATA(BT_DATA_BROADCAST_NAME, CONFIG_BROADCAST_NAME,
619 sizeof(CONFIG_BROADCAST_NAME) - 1);
620 err = bt_le_ext_adv_set_data(adv, ext_ad, 3, NULL, 0);
621 if (err != 0) {
622 printk("Failed to set extended advertising data: %d\n", err);
623 return 0;
624 }
625
626 /* Setup periodic advertising data */
627 err = bt_bap_broadcast_source_get_base(broadcast_source, &base_buf);
628 if (err != 0) {
629 printk("Failed to get encoded BASE: %d\n", err);
630 return 0;
631 }
632
633 per_ad.type = BT_DATA_SVC_DATA16;
634 per_ad.data_len = base_buf.len;
635 per_ad.data = base_buf.data;
636 err = bt_le_per_adv_set_data(adv, &per_ad, 1);
637 if (err != 0) {
638 printk("Failed to set periodic advertising data: %d\n", err);
639 return 0;
640 }
641
642 /* Start extended advertising */
643 err = bt_le_ext_adv_start(adv, BT_LE_EXT_ADV_START_DEFAULT);
644 if (err) {
645 printk("Failed to start extended advertising: %d\n", err);
646 return 0;
647 }
648
649 /* Enable Periodic Advertising */
650 err = bt_le_per_adv_start(adv);
651 if (err) {
652 printk("Failed to enable periodic advertising: %d\n", err);
653 return 0;
654 }
655
656 printk("Starting broadcast source\n");
657 stopping = false;
658 err = bt_bap_broadcast_source_start(broadcast_source, adv);
659 if (err != 0) {
660 printk("Unable to start broadcast source: %d\n", err);
661 return 0;
662 }
663
664 /* Wait for broadcast source to be started */
665 k_sem_take(&sem_started, K_FOREVER);
666 printk("Broadcast source started\n");
667
668 /* Initialize sending */
669 for (size_t i = 0U; i < ARRAY_SIZE(streams); i++) {
670 for (unsigned int j = 0U; j < BROADCAST_ENQUEUE_COUNT; j++) {
671 stream_sent_cb(&streams[i].stream);
672 }
673 }
674
675 #if defined(CONFIG_LIBLC3) && defined(CONFIG_USE_USB_AUDIO_INPUT)
676 /* Never stop streaming when using USB Audio as input */
677 k_sleep(K_FOREVER);
678 #endif /* defined(CONFIG_LIBLC3) && defined(CONFIG_USE_USB_AUDIO_INPUT) */
679 printk("Waiting %u seconds before stopped\n", BROADCAST_SOURCE_LIFETIME);
680 k_sleep(K_SECONDS(BROADCAST_SOURCE_LIFETIME));
681 printk("Stopping broadcast source\n");
682 stopping = true;
683 err = bt_bap_broadcast_source_stop(broadcast_source);
684 if (err != 0) {
685 printk("Unable to stop broadcast source: %d\n", err);
686 return 0;
687 }
688
689 /* Wait for broadcast source to be stopped */
690 k_sem_take(&sem_stopped, K_FOREVER);
691 printk("Broadcast source stopped\n");
692
693 printk("Deleting broadcast source\n");
694 err = bt_bap_broadcast_source_delete(broadcast_source);
695 if (err != 0) {
696 printk("Unable to delete broadcast source: %d\n", err);
697 return 0;
698 }
699 printk("Broadcast source deleted\n");
700 broadcast_source = NULL;
701 seq_num = 0;
702
703 err = bt_le_per_adv_stop(adv);
704 if (err) {
705 printk("Failed to stop periodic advertising (err %d)\n", err);
706 return 0;
707 }
708
709 err = bt_le_ext_adv_stop(adv);
710 if (err) {
711 printk("Failed to stop extended advertising (err %d)\n", err);
712 return 0;
713 }
714
715 err = bt_le_ext_adv_delete(adv);
716 if (err) {
717 printk("Failed to delete extended advertising (err %d)\n", err);
718 return 0;
719 }
720 }
721 return 0;
722 }
723
