1 /*
2 * Copyright (C) 2022 BlueKitchen GmbH
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holders nor the names of
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * 4. Any redistribution, use, or modification is done solely for
17 * personal benefit and not for any commercial purpose or for
18 * monetary gain.
19 *
20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
24 * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Please inquire about commercial licensing options at
34 * [email protected]
35 *
36 */
37
38 #define BTSTACK_FILE__ "le_audio_broadcast_sink.c"
39
40 /*
41 * LE Audio Broadcast Sink
42 */
43
44
45 #include "btstack_config.h"
46
47 #include <stdint.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <inttypes.h>
52
53 #include "ad_parser.h"
54 #include "ble/att_server.h"
55 #include "ble/sm.h"
56 #include "bluetooth_data_types.h"
57 #include "bluetooth_gatt.h"
58 #include "btstack_debug.h"
59 #include "btstack_audio.h"
60 #include "btstack_event.h"
61 #include "btstack_run_loop.h"
62 #include "btstack_ring_buffer.h"
63 #include "btstack_stdin.h"
64 #include "btstack_util.h"
65 #include "gap.h"
66 #include "hci.h"
67 #include "hci_cmd.h"
68 #include "btstack_lc3.h"
69 #include "btstack_lc3_google.h"
70 #include "btstack_lc3plus_fraunhofer.h"
71 #include "l2cap.h"
72 #include "le-audio/le_audio_util.h"
73 #include "le-audio/le_audio_base_parser.h"
74 #include "le-audio/gatt-service/broadcast_audio_scan_service_server.h"
75
76 #include "le_audio_broadcast_sink.h"
77 #include "le_audio_demo_util_sink.h"
78
79 // max config
80 #define MAX_NUM_BIS 2
81 #define MAX_SAMPLES_PER_FRAME 480
82
83 // playback
84 #define MAX_NUM_LC3_FRAMES 5
85 #define MAX_BYTES_PER_SAMPLE 4
86 #define PLAYBACK_BUFFER_SIZE (MAX_NUM_LC3_FRAMES * MAX_SAMPLES_PER_FRAME * MAX_BYTES_PER_SAMPLE)
87
88 static void show_usage(void);
89
90 static enum {
91 APP_W4_WORKING,
92 APP_W4_BROADCAST_ADV,
93 APP_W4_PA_AND_BIG_INFO,
94 APP_W4_BROADCAST_CODE,
95 APP_W4_BIG_SYNC_ESTABLISHED,
96 APP_STREAMING,
97 APP_IDLE
98 } app_state = APP_W4_WORKING;
99
100 static const uint8_t adv_sid = 0;
101 static le_advertising_set_t le_advertising_set;
102 static uint8_t adv_handle = 0;
103
104 static le_extended_advertising_parameters_t extended_params = {
105 .advertising_event_properties = 1, // connectable
106 .primary_advertising_interval_min = 0x4b0, // 750 ms
107 .primary_advertising_interval_max = 0x4b0, // 750 ms
108 .primary_advertising_channel_map = 7,
109 .own_address_type = BD_ADDR_TYPE_LE_PUBLIC,
110 .peer_address_type = 0,
111 .peer_address = { 0 },
112 .advertising_filter_policy = 0,
113 .advertising_tx_power = 10, // 10 dBm
114 .primary_advertising_phy = 1, // LE 1M PHY
115 .secondary_advertising_max_skip = 0,
116 .secondary_advertising_phy = 1, // LE 1M PHY
117 .advertising_sid = adv_sid,
118 .scan_request_notification_enable = 0,
119 };
120
121 static const uint8_t extended_adv_data[] = {
122 // 16 bit service data, ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE,
123 3, BLUETOOTH_DATA_TYPE_SERVICE_DATA_16_BIT_UUID,
124 ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE & 0xff, ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE >> 8,
125 // name
126 5, BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME, 'S', 'i', 'n', 'k'
127 };
128
129 #define BASS_NUM_CLIENTS 1
130 #define BASS_NUM_SOURCES 1
131 static bass_source_data_t bass_source_new;
132 static bass_server_source_t bass_sources[BASS_NUM_SOURCES];
133 static bass_server_connection_t bass_clients[BASS_NUM_CLIENTS];
134
135 //
136 static btstack_packet_callback_registration_t hci_event_callback_registration;
137 static btstack_packet_callback_registration_t sm_event_callback_registration;
138
139 static bool have_base;
140 static bool have_big_info;
141 static bool have_broadcast_code;
142 static bool standalone_mode;
143 static uint32_t bis_sync_mask;
144
145 uint16_t samples_received;
146 uint16_t samples_dropped;
147
148 // remote info
149 static char remote_name[20];
150 static bd_addr_t remote;
151 static bd_addr_type_t remote_type;
152 static uint8_t remote_sid;
153 static bool count_mode;
154 static bool pts_mode;
155 static bool nrf5340_audio_demo;
156
157 // broadcast assistant
158 static hci_con_handle_t commander_acl_handle;
159 static bd_addr_t commander_address;
160 static bd_addr_type_t commander_type;
161
162 // broadcast info
163 static const uint8_t big_handle = 1;
164 static hci_con_handle_t sync_handle;
165 static hci_con_handle_t bis_con_handles[MAX_NUM_BIS];
166 static uint8_t encryption;
167 static uint8_t broadcast_code[16];
168
169 static btstack_timer_source_t broadcast_sink_pa_sync_timer;
170
171 // BIG Sync
172 static le_audio_big_sync_t big_sync_storage;
173 static le_audio_big_sync_params_t big_sync_params;
174
175 // lc3 codec config
176 static uint16_t sampling_frequency_hz;
177 static btstack_lc3_frame_duration_t frame_duration;
178 static uint16_t octets_per_frame;
179 static uint8_t num_bis;
180
handle_periodic_advertisement(const uint8_t * packet,uint16_t size)181 static void handle_periodic_advertisement(const uint8_t * packet, uint16_t size){
182 // nRF534_audio quirk - no BASE in periodic advertisement
183 if (nrf5340_audio_demo){
184 // hard coded config LC3
185 // default: mono bitrate 96000, 10 ms with USB audio source, 120 octets per frame
186 count_mode = 0;
187 pts_mode = 0;
188 num_bis = 1;
189 sampling_frequency_hz = 48000;
190 frame_duration = BTSTACK_LC3_FRAME_DURATION_10000US;
191 octets_per_frame = 120;
192 have_base = true;
193 return;
194 }
195
196 // periodic advertisement contains the BASE
197 // TODO: BASE might be split across multiple advertisements
198 const uint8_t * adv_data = hci_subevent_le_periodic_advertising_report_get_data(packet);
199 uint16_t adv_size = hci_subevent_le_periodic_advertising_report_get_data_length(packet);
200 uint8_t adv_status = hci_subevent_le_periodic_advertising_report_get_data_status(packet);
201
202 if (adv_status != 0) {
203 printf("Periodic Advertisement (status %u): ", adv_status);
204 printf_hexdump(adv_data, adv_size);
205 return;
206 }
207
208 le_audio_base_parser_t parser;
209 bool ok = le_audio_base_parser_init(&parser, adv_data, adv_size);
210 if (ok == false){
211 return;
212 }
213 have_base = true;
214
215 printf("BASE:\n");
216 uint32_t presentation_delay = le_audio_base_parser_get_presentation_delay(&parser);
217 printf("- presentation delay: %"PRIu32" us\n", presentation_delay);
218 uint8_t num_subgroups = le_audio_base_parser_get_num_subgroups(&parser);
219 // Cache in new source struct
220 bass_source_new.subgroups_num = num_subgroups;
221 printf("- num subgroups: %u\n", num_subgroups);
222 uint8_t i;
223 for (i=0;i<num_subgroups;i++){
224 // Level 2: Subgroup Level
225 printf(" - Subgroup %u\n", i);
226 num_bis = le_audio_base_parser_subgroup_get_num_bis(&parser);
227 printf(" - num bis[%u]: %u\n", i, num_bis);
228 uint8_t codec_specific_configuration_length = le_audio_base_parser_subgroup_get_codec_specific_configuration_length(&parser);
229 const uint8_t * codec_specific_configuration = le_audio_base_parser_subgroup_get_codec_specific_configuration(&parser);
230 printf(" - codec specific config[%u]: ", i);
231 printf_hexdump(codec_specific_configuration, codec_specific_configuration_length);
232 // parse config to get sampling frequency and frame duration
233 uint8_t codec_offset = 0;
234 while ((codec_offset + 1) < codec_specific_configuration_length){
235 uint8_t ltv_len = codec_specific_configuration[codec_offset++];
236 uint8_t ltv_type = codec_specific_configuration[codec_offset];
237 const uint32_t sampling_frequency_map[] = { 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, 176400, 192000, 384000 };
238 uint8_t sampling_frequency_index;
239 uint8_t frame_duration_index;
240 switch (ltv_type){
241 case 0x01: // sampling frequency
242 sampling_frequency_index = codec_specific_configuration[codec_offset+1];
243 // TODO: check range
244 sampling_frequency_hz = sampling_frequency_map[sampling_frequency_index - 1];
245 printf(" - sampling frequency[%u]: %u\n", i, sampling_frequency_hz);
246 break;
247 case 0x02: // 0 = 7.5, 1 = 10 ms
248 frame_duration_index = codec_specific_configuration[codec_offset+1];
249 frame_duration = le_audio_util_get_btstack_lc3_frame_duration(frame_duration_index);
250 printf(" - frame duration[%u]: %u us\n", i, le_audio_get_frame_duration_us(frame_duration_index));
251 break;
252 case 0x04: // octets per coding frame
253 octets_per_frame = little_endian_read_16(codec_specific_configuration, codec_offset+1);
254 printf(" - octets per codec frame[%u]: %u\n", i, octets_per_frame);
255 break;
256 default:
257 break;
258 }
259 codec_offset += ltv_len;
260 }
261 uint8_t metadata_length = le_audio_base_parser_subgroup_get_metadata_length(&parser);
262 const uint8_t * meta_data = le_audio_base_subgroup_parser_get_metadata(&parser);
263 printf(" - meta data[%u]: ", i);
264 printf_hexdump(meta_data, metadata_length);
265 uint8_t k;
266 for (k=0;k<num_bis;k++){
267 printf(" - BIS %u\n", k);
268 // Level 3: BIS Level
269 uint8_t bis_index = le_audio_base_parser_bis_get_index(&parser);
270 if ((bis_index == 0) || (bis_index > 30)){
271 continue;
272 }
273
274 // collect bis sync mask
275 bis_sync_mask |= 1 << (bis_index - 1);
276
277 bass_source_new.subgroups[i].metadata_length = 0;
278 memset(&bass_source_new.subgroups[i].metadata, 0, sizeof(le_audio_metadata_t));
279
280 printf(" - bis index[%u][%u]: %u\n", i, k, bis_index);
281 codec_specific_configuration_length = le_audio_base_parser_bis_get_codec_specific_configuration_length(&parser);
282 codec_specific_configuration = le_audio_base_bis_parser_get_codec_specific_configuration(&parser);
283 printf(" - codec specific config[%u][%u]: ", i, k);
284 printf_hexdump(codec_specific_configuration, codec_specific_configuration_length);
285 // parse next BIS
286 le_audio_base_parser_bis_next(&parser);
287 }
288
289 // parse next subgroup
290 le_audio_base_parser_subgroup_next(&parser);
291 }
292 }
293
handle_big_info(const uint8_t * packet,uint16_t size)294 static void handle_big_info(const uint8_t * packet, uint16_t size){
295 printf("BIG Info advertising report\n");
296 sync_handle = hci_subevent_le_biginfo_advertising_report_get_sync_handle(packet);
297 encryption = hci_subevent_le_biginfo_advertising_report_get_encryption(packet);
298 if (encryption) {
299 printf("Stream is encrypted\n");
300 }
301 have_big_info = true;
302 }
303
enter_create_big_sync(void)304 static void enter_create_big_sync(void){
305 // stop scanning
306 gap_stop_scan();
307
308 // init sink
309 uint16_t iso_interval_1250us = frame_duration == BTSTACK_LC3_FRAME_DURATION_7500US ? 6 : 8;
310 uint8_t pre_transmission_offset = 1;
311 le_audio_demo_util_sink_configure_broadcast(num_bis, 1, sampling_frequency_hz, frame_duration, octets_per_frame,
312 iso_interval_1250us, pre_transmission_offset);
313
314 big_sync_params.big_handle = big_handle;
315 big_sync_params.sync_handle = sync_handle;
316 big_sync_params.encryption = encryption;
317 if (encryption) {
318 memcpy(big_sync_params.broadcast_code, &broadcast_code[0], 16);
319 } else {
320 memset(big_sync_params.broadcast_code, 0, 16);
321 }
322 big_sync_params.mse = 0;
323 big_sync_params.big_sync_timeout_10ms = 100;
324 big_sync_params.num_bis = num_bis;
325 uint8_t i;
326 printf("BIG Create Sync for BIS: ");
327 for (i=0;i<num_bis;i++){
328 big_sync_params.bis_indices[i] = i + 1;
329 printf("%u ", big_sync_params.bis_indices[i]);
330 }
331 printf("\n");
332 app_state = APP_W4_BIG_SYNC_ESTABLISHED;
333 gap_big_sync_create(&big_sync_storage, &big_sync_params);
334 }
335
start_scanning()336 static void start_scanning() {
337 app_state = APP_W4_BROADCAST_ADV;
338 have_base = false;
339 have_big_info = false;
340 gap_set_scan_params(1, 0x30, 0x30, 0);
341 gap_start_scan();
342 printf("Start scan..\n");
343 }
344
start_advertising(void)345 static void start_advertising(void) {
346 gap_extended_advertising_start(adv_handle, 0, 0);
347 }
348
setup_advertising(void)349 static void setup_advertising(void) {
350 bd_addr_t local_addr;
351 gap_local_bd_addr(local_addr);
352 bool local_address_invalid = btstack_is_null_bd_addr( local_addr );
353 if( local_address_invalid ) {
354 extended_params.own_address_type = BD_ADDR_TYPE_LE_RANDOM;
355 }
356 gap_extended_advertising_setup(&le_advertising_set, &extended_params, &adv_handle);
357 if( local_address_invalid ) {
358 bd_addr_t random_address = { 0xC1, 0x01, 0x01, 0x01, 0x01, 0x01 };
359 gap_extended_advertising_set_random_address( adv_handle, random_address );
360 }
361 gap_extended_advertising_set_adv_data(adv_handle, sizeof(extended_adv_data), extended_adv_data);
362 start_advertising();
363 }
364
got_base_and_big_info()365 static void got_base_and_big_info() {
366 // add source
367 if (standalone_mode) {
368 printf("BASS: add Broadcast Source\n");
369 // add source
370 uint8_t source_index = 0;
371 broadcast_audio_scan_service_server_add_source(&bass_source_new, &source_index);
372 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA);
373 }
374
375 // update num subgroups from BASE
376 bass_sources[0].data.subgroups_num = bass_source_new.subgroups_num;
377
378 if ((encryption == false) || have_broadcast_code){
379 enter_create_big_sync();
380 } else {
381 printf("BASS: request Broadcast Code\n");
382 bass_sources[0].big_encryption = LE_AUDIO_BIG_ENCRYPTION_BROADCAST_CODE_REQUIRED;
383 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA);
384 app_state = APP_W4_BROADCAST_CODE;
385 }
386 }
387
start_pa_sync(bd_addr_type_t source_type,bd_addr_t source_addr)388 static void start_pa_sync(bd_addr_type_t source_type, bd_addr_t source_addr) {
389 // ignore other advertisements
390 gap_whitelist_add(source_type, source_addr);
391 gap_set_scan_params(1, 0x30, 0x30, 1);
392 // sync to PA
393 gap_periodic_advertiser_list_clear();
394 gap_periodic_advertiser_list_add(source_type, source_addr, remote_sid);
395 app_state = APP_W4_PA_AND_BIG_INFO;
396 printf("Start Periodic Advertising Sync\n");
397 gap_periodic_advertising_create_sync(0x01, remote_sid, source_type, source_addr, 0, 1000, 0);
398 gap_start_scan();
399 }
400
pa_sync_established()401 static void pa_sync_established() {
402 have_base = false;
403 have_big_info = false;
404 app_state = APP_W4_PA_AND_BIG_INFO;
405 }
406
stop_pa_sync(void)407 static void stop_pa_sync(void) {
408 app_state = APP_IDLE;
409 le_audio_demo_util_sink_close();
410 printf("Terminate BIG SYNC\n");
411 gap_big_sync_terminate(big_handle);
412 int i;
413 for (i=0;i<num_bis;i++){
414 if (bis_con_handles[i] != HCI_CON_HANDLE_INVALID) {
415 gap_disconnect(bis_con_handles[i]);
416 }
417 }
418
419 }
420
packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)421 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
422 UNUSED(channel);
423 if (packet_type != HCI_EVENT_PACKET) return;
424 switch (packet[0]) {
425 case BTSTACK_EVENT_STATE:
426 switch(btstack_event_state_get_state(packet)) {
427 case HCI_STATE_WORKING:
428 app_state = APP_IDLE;
429 // setup advertising and allow to receive periodic advertising sync transfers
430 setup_advertising();
431 gap_periodic_advertising_sync_transfer_set_default_parameters(2, 0, 0x2000, 0);
432
433 #ifdef ENABLE_DEMO_MODE
434 start_scanning();
435 #else
436 show_usage();
437 #endif
438 break;
439 case HCI_STATE_OFF:
440 printf("Goodbye\n");
441 exit(0);
442 break;
443 default:
444 break;
445 }
446 break;
447 case GAP_EVENT_EXTENDED_ADVERTISING_REPORT:
448 {
449 if (app_state != APP_W4_BROADCAST_ADV) break;
450
451 gap_event_extended_advertising_report_get_address(packet, remote);
452 uint8_t adv_size = gap_event_extended_advertising_report_get_data_length(packet);
453 const uint8_t * adv_data = gap_event_extended_advertising_report_get_data(packet);
454
455 ad_context_t context;
456 bool found = false;
457 remote_name[0] = '\0';
458 uint16_t uuid;
459 uint32_t broadcast_id;
460 for (ad_iterator_init(&context, adv_size, adv_data) ; ad_iterator_has_more(&context) ; ad_iterator_next(&context)) {
461 const uint8_t data_type = ad_iterator_get_data_type(&context);
462 uint8_t data_size = ad_iterator_get_data_len(&context);
463 const uint8_t *data = ad_iterator_get_data(&context);
464 switch (data_type){
465 case BLUETOOTH_DATA_TYPE_SERVICE_DATA_16_BIT_UUID:
466 uuid = little_endian_read_16(data, 0);
467 if (uuid == ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE){
468 broadcast_id = little_endian_read_24(data, 2);
469 found = true;
470 }
471 break;
472 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME:
473 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME:
474 data_size = btstack_min(sizeof(remote_name) - 1, data_size);
475 memcpy(remote_name, data, data_size);
476 remote_name[data_size] = 0;
477 // support for nRF5340 Audio DK
478 if (strncmp("NRF5340", remote_name, 7) == 0){
479 nrf5340_audio_demo = true;
480 found = true;
481 }
482 break;
483 default:
484 break;
485 }
486 }
487 if (!found) break;
488 remote_type = gap_event_extended_advertising_report_get_address_type(packet);
489 remote_sid = gap_event_extended_advertising_report_get_advertising_sid(packet);
490 pts_mode = strncmp("PTS-", remote_name, 4) == 0;
491 count_mode = strncmp("COUNT", remote_name, 5) == 0;
492 printf("Broadcast sink found, addr %s, name: '%s' (pts-mode: %u, count: %u), Broadcast_ID 0%06x\n", bd_addr_to_str(remote), remote_name, pts_mode, count_mode, broadcast_id);
493
494 // setup bass source info
495 bass_source_new.address_type = remote_type;
496 memcpy(bass_source_new.address, remote, 6);
497 bass_source_new.adv_sid = remote_sid;
498 bass_source_new.broadcast_id = broadcast_id;
499 bass_source_new.pa_sync = LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE;
500 bass_source_new.pa_interval = gap_event_extended_advertising_report_get_periodic_advertising_interval(packet);
501
502 // start pa sync
503 start_pa_sync(remote_type, remote);
504 break;
505 }
506
507 case HCI_EVENT_DISCONNECTION_COMPLETE:
508 // restart advertisements on disconnect
509 if (hci_event_disconnection_complete_get_connection_handle(packet) == commander_acl_handle) {
510 printf("Broadcast Assistant disconnected\n");
511 commander_acl_handle = HCI_CON_HANDLE_INVALID;
512 start_advertising();
513 }
514 break;
515 case HCI_EVENT_LE_META:
516 switch(hci_event_le_meta_get_subevent_code(packet)) {
517 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED:
518 // PAST implies broadcast source has been added by client
519 sync_handle = hci_subevent_le_periodic_advertising_sync_transfer_received_get_sync_handle(packet);
520 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA);
521 btstack_run_loop_remove_timer(&broadcast_sink_pa_sync_timer);
522 printf("Periodic advertising sync transfer with handle 0x%04x received\n", sync_handle);
523 pa_sync_established();
524 break;
525 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHMENT:
526 sync_handle = hci_subevent_le_periodic_advertising_sync_establishment_get_sync_handle(packet);
527 printf("Periodic advertising sync with handle 0x%04x established\n", sync_handle);
528 pa_sync_established();
529 break;
530 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_REPORT:
531 if (app_state != APP_W4_PA_AND_BIG_INFO) break;
532 if (have_base) break;
533 handle_periodic_advertisement(packet, size);
534 if (have_base && have_big_info){
535 got_base_and_big_info();
536 }
537 break;
538 case HCI_SUBEVENT_LE_BIGINFO_ADVERTISING_REPORT:
539 if (app_state != APP_W4_PA_AND_BIG_INFO) break;
540 if (have_big_info) break;
541 handle_big_info(packet, size);
542 if (have_base && have_big_info){
543 got_base_and_big_info();
544 }
545 break;
546 case HCI_SUBEVENT_LE_BIG_SYNC_LOST:
547 printf("BIG Sync Lost\n");
548 {
549 const btstack_audio_sink_t * sink = btstack_audio_sink_get_instance();
550 if (sink != NULL) {
551 sink->stop_stream();
552 sink->close();
553 }
554 }
555 // start over
556 if (!standalone_mode) break;
557 start_scanning();
558 break;
559 default:
560 break;
561 }
562 break;
563 case HCI_EVENT_META_GAP:
564 switch (hci_event_gap_meta_get_subevent_code(packet)){
565 case GAP_SUBEVENT_LE_CONNECTION_COMPLETE:
566 commander_acl_handle = gap_subevent_le_connection_complete_get_connection_handle(packet);
567 commander_type = gap_subevent_le_connection_complete_get_peer_address_type(packet);
568 gap_subevent_le_connection_complete_get_peer_address(packet, commander_address);
569 printf("Broadcast Assistant connected, handle 0x%04x - %s type %u\n", commander_acl_handle, bd_addr_to_str(commander_address), commander_type);
570 break;
571 case GAP_SUBEVENT_BIG_SYNC_CREATED: {
572 printf("BIG Sync created with BIS Connection handles: ");
573 uint8_t i;
574 for (i=0;i<num_bis;i++){
575 bis_con_handles[i] = gap_subevent_big_sync_created_get_bis_con_handles(packet, i);
576 printf("0x%04x ", bis_con_handles[i]);
577 }
578 printf("\n");
579 app_state = APP_STREAMING;
580 printf("Start receiving\n");
581
582 printf("Terminate PA Sync\n");
583 gap_periodic_advertising_terminate_sync(sync_handle);
584
585 // update BIS Sync state
586 bass_sources[0].data.subgroups[0].bis_sync_state = bis_sync_mask;
587 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA);
588 break;
589 }
590 case GAP_SUBEVENT_BIG_SYNC_STOPPED:
591 printf("BIG Sync stopped, big_handle 0x%02x\n", gap_subevent_big_sync_stopped_get_big_handle(packet));
592 break;
593 default:
594 break;
595 }
596 break;
597 case SM_EVENT_JUST_WORKS_REQUEST:
598 printf("Just Works requested\n");
599 sm_just_works_confirm(sm_event_just_works_request_get_handle(packet));
600 break;
601 default:
602 break;
603 }
604 }
605
show_usage(void)606 static void show_usage(void){
607 printf("\n--- LE Audio Broadcast Sink Test Console ---\n");
608 printf("s - start scanning\n");
609 #ifdef HAVE_LC3PLUS
610 printf("q - use LC3plus decoder if 10 ms ISO interval is used\n");
611 #endif
612 printf("e - set broadcast code to 0x11111111111111111111111111111111\n");
613 printf("t - terminate BIS streams\n");
614 printf("---\n");
615 }
616
stdin_process(char c)617 static void stdin_process(char c){
618 switch (c){
619 case 's':
620 if (app_state != APP_IDLE) break;
621 standalone_mode = true;
622 start_scanning();
623 break;
624 case 'e':
625 printf("Set broadcast code to 0x11111111111111111111111111111111\n");
626 memset(broadcast_code, 0x11, 16);
627 have_broadcast_code = true;
628 break;
629 #ifdef HAVE_LC3PLUS
630 case 'q':
631 printf("Use LC3plus decoder for 10 ms ISO interval...\n");
632 le_audio_demo_util_sink_enable_lc3plus(true);
633 break;
634 #endif
635 case 't':
636 switch (app_state){
637 case APP_STREAMING:
638 case APP_W4_BIG_SYNC_ESTABLISHED:
639 stop_pa_sync();
640 break;
641 default:
642 break;
643 }
644 break;
645 case '\n':
646 case '\r':
647 break;
648 default:
649 show_usage();
650 break;
651
652 }
653 }
654
iso_packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)655 static void iso_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) {
656 void (*packet_receive)(uint8_t stream_index, uint8_t *packet, uint16_t size) = le_audio_demo_util_sink_receive;
657
658 // get stream_index from con_handle
659 uint16_t header = little_endian_read_16(packet, 0);
660 hci_con_handle_t con_handle = header & 0x0fff;
661 uint8_t i;
662
663 if (count_mode){
664 packet_receive = le_audio_demo_util_sink_count;
665 }
666
667 for (i=0;i<num_bis;i++){
668 if (bis_con_handles[i] == con_handle) {
669 packet_receive(i, packet, size);
670 }
671 }
672 }
673
broadcast_sync_pa_sync_timeout_handler(btstack_timer_source_t * ts)674 static void broadcast_sync_pa_sync_timeout_handler(btstack_timer_source_t * ts){
675 UNUSED(ts);
676 printf("PAST Timeout -> LE_AUDIO_PA_SYNC_STATE_NO_PAST\n");
677 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_NO_PAST);
678 }
679
handle_new_pa_sync(uint8_t source_id,le_audio_pa_sync_t pa_sync)680 static void handle_new_pa_sync(uint8_t source_id, le_audio_pa_sync_t pa_sync) {
681 switch (pa_sync){
682 case LE_AUDIO_PA_SYNC_DO_NOT_SYNCHRONIZE_TO_PA:
683 printf("Stop PA Sync\n");
684 stop_pa_sync();
685 bass_sources[0].data.subgroups[0].bis_sync_state = 0;
686 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_NOT_SYNCHRONIZED_TO_PA);
687 break;
688 case LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE:
689 printf("LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE -> Request SyncInfo\n");
690 broadcast_audio_scan_service_server_set_pa_sync_state(source_id, LE_AUDIO_PA_SYNC_STATE_SYNCINFO_REQUEST);
691 // start timeout
692 btstack_run_loop_set_timer_handler(&broadcast_sink_pa_sync_timer, broadcast_sync_pa_sync_timeout_handler);
693 btstack_run_loop_set_timer(&broadcast_sink_pa_sync_timer, 10000); // 10 seconds
694 btstack_run_loop_add_timer(&broadcast_sink_pa_sync_timer);
695 break;
696 case LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_NOT_AVAILABLE:
697 printf("LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE -> Start Periodic Advertising Sync\n");
698 start_pa_sync(bass_sources[source_id].data.address_type, bass_sources[source_id].data.address);
699 break;
700 default:
701 break;
702 }
703 }
704
bass_packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)705 static void bass_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
706 UNUSED(packet_type);
707 UNUSED(channel);
708 btstack_assert (packet_type == HCI_EVENT_PACKET);
709 btstack_assert(hci_event_packet_get_type(packet) == HCI_EVENT_LEAUDIO_META);
710 uint8_t source_id;
711 printf("BASS Event 0x%02x: ", hci_event_leaudio_meta_get_subevent_code(packet));
712 printf_hexdump(packet, size);
713 uint8_t pa_sync;
714 switch (hci_event_leaudio_meta_get_subevent_code(packet)){
715 case LEAUDIO_SUBEVENT_BASS_SERVER_SOURCE_ADDED:
716 pa_sync = leaudio_subevent_bass_server_source_added_get_pa_sync(packet);
717 source_id = leaudio_subevent_bass_server_source_added_get_source_id(packet);
718 printf("LEAUDIO_SUBEVENT_BASS_SOURCE_ADDED, source_id 0x%04x, pa_sync %u\n", source_id, pa_sync);
719 handle_new_pa_sync(source_id, pa_sync);
720 break;
721 case LEAUDIO_SUBEVENT_BASS_SERVER_SOURCE_MODIFIED:
722 pa_sync = leaudio_subevent_bass_server_source_added_get_pa_sync(packet);
723 source_id = leaudio_subevent_bass_server_source_added_get_source_id(packet);
724 printf("LEAUDIO_SUBEVENT_BASS_SOURCE_MODIFIED, source_id 0x%04x, pa_sync %u\n", source_id, pa_sync);
725 handle_new_pa_sync(source_id, pa_sync);
726 break;
727 case LEAUDIO_SUBEVENT_BASS_SERVER_SOURCE_DELETED:
728 printf("LEAUDIO_SUBEVENT_BASS_SERVER_SOURCE_DELETED, source_id 0x%04x\n",
729 leaudio_subevent_bass_server_source_deleted_get_source_id(packet));
730 break;
731 case LEAUDIO_SUBEVENT_BASS_SERVER_BROADCAST_CODE:
732 leaudio_subevent_bass_server_broadcast_code_get_broadcast_code(packet, broadcast_code);
733 printf("LEAUDIO_SUBEVENT_BASS_BROADCAST_CODE received: ");
734 printf_hexdump(broadcast_code, 16);
735 bass_sources[0].big_encryption = LE_AUDIO_BIG_ENCRYPTION_DECRYPTING;
736 if (have_base && have_big_info){
737 enter_create_big_sync();
738 }
739 break;
740 default:
741 break;
742 }
743 }
744
745 int btstack_main(int argc, const char * argv[]);
btstack_main(int argc,const char * argv[])746 int btstack_main(int argc, const char * argv[]){
747 (void) argv;
748 (void) argc;
749
750 l2cap_init();
751 sm_init();
752
753 // setup ATT server
754 att_server_init(profile_data, NULL, NULL);
755
756 // register for HCI events
757 hci_event_callback_registration.callback = &packet_handler;
758 hci_add_event_handler(&hci_event_callback_registration);
759
760 // register for ISO Packet
761 hci_register_iso_packet_handler(&iso_packet_handler);
762
763 // register for SM events
764 sm_event_callback_registration.callback = &packet_handler;
765 sm_add_event_handler(&sm_event_callback_registration);
766
767 // setup BASS Server
768 broadcast_audio_scan_service_server_init(BASS_NUM_SOURCES, bass_sources, BASS_NUM_CLIENTS, bass_clients);
769 broadcast_audio_scan_service_server_register_packet_handler(&bass_packet_handler);
770
771 // setup audio processing
772 le_audio_demo_util_sink_init("le_audio_broadcast_sink.wav");
773
774 // turn on!
775 hci_power_control(HCI_POWER_ON);
776
777 btstack_stdin_setup(stdin_process);
778 return 0;
779 }
780