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