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 const char * filename_wav = "le_audio_broadcast_sink.wav"; 91 92 static enum { 93 APP_W4_WORKING, 94 APP_W4_BROADCAST_ADV, 95 APP_W4_PA_AND_BIG_INFO, 96 APP_W4_BROADCAST_CODE, 97 APP_W4_BIG_SYNC_ESTABLISHED, 98 APP_STREAMING, 99 APP_IDLE 100 } app_state = APP_W4_WORKING; 101 102 static const uint8_t adv_sid = 0; 103 static le_advertising_set_t le_advertising_set; 104 static uint8_t adv_handle = 0; 105 106 static le_extended_advertising_parameters_t extended_params = { 107 .advertising_event_properties = 1, // connectable 108 .primary_advertising_interval_min = 0x4b0, // 750 ms 109 .primary_advertising_interval_max = 0x4b0, // 750 ms 110 .primary_advertising_channel_map = 7, 111 .own_address_type = BD_ADDR_TYPE_LE_PUBLIC, 112 .peer_address_type = 0, 113 .peer_address = { 0 }, 114 .advertising_filter_policy = 0, 115 .advertising_tx_power = 10, // 10 dBm 116 .primary_advertising_phy = 1, // LE 1M PHY 117 .secondary_advertising_max_skip = 0, 118 .secondary_advertising_phy = 1, // LE 1M PHY 119 .advertising_sid = adv_sid, 120 .scan_request_notification_enable = 0, 121 }; 122 123 static const uint8_t extended_adv_data[] = { 124 // 16 bit service data, ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE, 125 3, BLUETOOTH_DATA_TYPE_SERVICE_DATA_16_BIT_UUID, 126 ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE & 0xff, ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE >> 8, 127 // name 128 5, BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME, 'S', 'i', 'n', 'k' 129 }; 130 131 #define BASS_NUM_CLIENTS 1 132 #define BASS_NUM_SOURCES 1 133 static bass_source_data_t bass_source_new; 134 static bass_server_source_t bass_sources[BASS_NUM_SOURCES]; 135 static bass_server_connection_t bass_clients[BASS_NUM_CLIENTS]; 136 137 // 138 static btstack_packet_callback_registration_t hci_event_callback_registration; 139 static btstack_packet_callback_registration_t sm_event_callback_registration; 140 141 static bool have_base; 142 static bool have_big_info; 143 static bool have_broadcast_code; 144 static bool standalone_mode; 145 static uint32_t bis_sync_mask; 146 147 uint16_t samples_received; 148 uint16_t samples_dropped; 149 150 // remote info 151 static char remote_name[20]; 152 static bd_addr_t remote; 153 static bd_addr_type_t remote_type; 154 static uint8_t remote_sid; 155 static bool count_mode; 156 static bool pts_mode; 157 static bool nrf5340_audio_demo; 158 159 // broadcast assistant 160 static hci_con_handle_t commander_acl_handle; 161 static bd_addr_t commander_address; 162 static bd_addr_type_t commander_type; 163 164 // broadcast info 165 static const uint8_t big_handle = 1; 166 static hci_con_handle_t sync_handle; 167 static hci_con_handle_t bis_con_handles[MAX_NUM_BIS]; 168 static uint8_t encryption; 169 static uint8_t broadcast_code[16]; 170 171 static btstack_timer_source_t broadcast_sink_pa_sync_timer; 172 173 // BIG Sync 174 static le_audio_big_sync_t big_sync_storage; 175 static le_audio_big_sync_params_t big_sync_params; 176 177 // lc3 codec config 178 static uint16_t sampling_frequency_hz; 179 static btstack_lc3_frame_duration_t frame_duration; 180 static uint16_t number_samples_per_frame; 181 static uint16_t octets_per_frame; 182 static uint8_t num_bis; 183 184 static void handle_periodic_advertisement(const uint8_t * packet, uint16_t size){ 185 // nRF534_audio quirk - no BASE in periodic advertisement 186 if (nrf5340_audio_demo){ 187 // hard coded config LC3 188 // default: mono bitrate 96000, 10 ms with USB audio source, 120 octets per frame 189 count_mode = 0; 190 pts_mode = 0; 191 num_bis = 1; 192 sampling_frequency_hz = 48000; 193 frame_duration = BTSTACK_LC3_FRAME_DURATION_10000US; 194 octets_per_frame = 120; 195 have_base = true; 196 return; 197 } 198 199 // periodic advertisement contains the BASE 200 // TODO: BASE might be split across multiple advertisements 201 const uint8_t * adv_data = hci_subevent_le_periodic_advertising_report_get_data(packet); 202 uint16_t adv_size = hci_subevent_le_periodic_advertising_report_get_data_length(packet); 203 uint8_t adv_status = hci_subevent_le_periodic_advertising_report_get_data_status(packet); 204 205 if (adv_status != 0) { 206 printf("Periodic Advertisement (status %u): ", adv_status); 207 printf_hexdump(adv_data, adv_size); 208 return; 209 } 210 211 le_audio_base_parser_t parser; 212 bool ok = le_audio_base_parser_init(&parser, adv_data, adv_size); 213 if (ok == false){ 214 return; 215 } 216 have_base = true; 217 218 printf("BASE:\n"); 219 uint32_t presentation_delay = le_audio_base_parser_get_presentation_delay(&parser); 220 printf("- presentation delay: %"PRIu32" us\n", presentation_delay); 221 uint8_t num_subgroups = le_audio_base_parser_get_num_subgroups(&parser); 222 // Cache in new source struct 223 bass_source_new.subgroups_num = num_subgroups; 224 printf("- num subgroups: %u\n", num_subgroups); 225 uint8_t i; 226 for (i=0;i<num_subgroups;i++){ 227 // Level 2: Subgroup Level 228 printf(" - Subgroup %u\n", i); 229 num_bis = le_audio_base_parser_subgroup_get_num_bis(&parser); 230 printf(" - num bis[%u]: %u\n", i, num_bis); 231 uint8_t codec_specific_configuration_length = le_audio_base_parser_subgroup_get_codec_specific_configuration_length(&parser); 232 const uint8_t * codec_specific_configuration = le_audio_base_parser_subgroup_get_codec_specific_configuration(&parser); 233 printf(" - codec specific config[%u]: ", i); 234 printf_hexdump(codec_specific_configuration, codec_specific_configuration_length); 235 // parse config to get sampling frequency and frame duration 236 uint8_t codec_offset = 0; 237 while ((codec_offset + 1) < codec_specific_configuration_length){ 238 uint8_t ltv_len = codec_specific_configuration[codec_offset++]; 239 uint8_t ltv_type = codec_specific_configuration[codec_offset]; 240 const uint32_t sampling_frequency_map[] = { 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, 176400, 192000, 384000 }; 241 uint8_t sampling_frequency_index; 242 uint8_t frame_duration_index; 243 switch (ltv_type){ 244 case 0x01: // sampling frequency 245 sampling_frequency_index = codec_specific_configuration[codec_offset+1]; 246 // TODO: check range 247 sampling_frequency_hz = sampling_frequency_map[sampling_frequency_index - 1]; 248 printf(" - sampling frequency[%u]: %u\n", i, sampling_frequency_hz); 249 break; 250 case 0x02: // 0 = 7.5, 1 = 10 ms 251 frame_duration_index = codec_specific_configuration[codec_offset+1]; 252 frame_duration = le_audio_util_get_btstack_lc3_frame_duration(frame_duration_index); 253 printf(" - frame duration[%u]: %u us\n", i, le_audio_get_frame_duration_us(frame_duration_index)); 254 break; 255 case 0x04: // octets per coding frame 256 octets_per_frame = little_endian_read_16(codec_specific_configuration, codec_offset+1); 257 printf(" - octets per codec frame[%u]: %u\n", i, octets_per_frame); 258 break; 259 default: 260 break; 261 } 262 codec_offset += ltv_len; 263 } 264 uint8_t metadata_length = le_audio_base_parser_subgroup_get_metadata_length(&parser); 265 const uint8_t * meta_data = le_audio_base_subgroup_parser_get_metadata(&parser); 266 printf(" - meta data[%u]: ", i); 267 printf_hexdump(meta_data, metadata_length); 268 uint8_t k; 269 for (k=0;k<num_bis;k++){ 270 printf(" - BIS %u\n", k); 271 // Level 3: BIS Level 272 uint8_t bis_index = le_audio_base_parser_bis_get_index(&parser); 273 if ((bis_index == 0) || (bis_index > 30)){ 274 continue; 275 } 276 277 // collect bis sync mask 278 bis_sync_mask |= 1 << (bis_index - 1); 279 280 bass_source_new.subgroups[i].metadata_length = 0; 281 memset(&bass_source_new.subgroups[i].metadata, 0, sizeof(le_audio_metadata_t)); 282 283 printf(" - bis index[%u][%u]: %u\n", i, k, bis_index); 284 codec_specific_configuration_length = le_audio_base_parser_bis_get_codec_specific_configuration_length(&parser); 285 codec_specific_configuration = le_audio_base_bis_parser_get_codec_specific_configuration(&parser); 286 printf(" - codec specific config[%u][%u]: ", i, k); 287 printf_hexdump(codec_specific_configuration, codec_specific_configuration_length); 288 // parse next BIS 289 le_audio_base_parser_bis_next(&parser); 290 } 291 292 // parse next subgroup 293 le_audio_base_parser_subgroup_next(&parser); 294 } 295 } 296 297 static void handle_big_info(const uint8_t * packet, uint16_t size){ 298 printf("BIG Info advertising report\n"); 299 sync_handle = hci_subevent_le_biginfo_advertising_report_get_sync_handle(packet); 300 encryption = hci_subevent_le_biginfo_advertising_report_get_encryption(packet); 301 if (encryption) { 302 printf("Stream is encrypted\n"); 303 } 304 have_big_info = true; 305 } 306 307 static void enter_create_big_sync(void){ 308 // stop scanning 309 gap_stop_scan(); 310 311 // init sink 312 uint16_t iso_interval_1250us = frame_duration == BTSTACK_LC3_FRAME_DURATION_7500US ? 6 : 8; 313 uint8_t pre_transmission_offset = 1; 314 le_audio_demo_util_sink_configure_broadcast(num_bis, 1, sampling_frequency_hz, frame_duration, octets_per_frame, 315 iso_interval_1250us, pre_transmission_offset); 316 317 big_sync_params.big_handle = big_handle; 318 big_sync_params.sync_handle = sync_handle; 319 big_sync_params.encryption = encryption; 320 if (encryption) { 321 memcpy(big_sync_params.broadcast_code, &broadcast_code[0], 16); 322 } else { 323 memset(big_sync_params.broadcast_code, 0, 16); 324 } 325 big_sync_params.mse = 0; 326 big_sync_params.big_sync_timeout_10ms = 100; 327 big_sync_params.num_bis = num_bis; 328 uint8_t i; 329 printf("BIG Create Sync for BIS: "); 330 for (i=0;i<num_bis;i++){ 331 big_sync_params.bis_indices[i] = i + 1; 332 printf("%u ", big_sync_params.bis_indices[i]); 333 } 334 printf("\n"); 335 app_state = APP_W4_BIG_SYNC_ESTABLISHED; 336 gap_big_sync_create(&big_sync_storage, &big_sync_params); 337 } 338 339 static void start_scanning() { 340 app_state = APP_W4_BROADCAST_ADV; 341 have_base = false; 342 have_big_info = false; 343 gap_set_scan_params(1, 0x30, 0x30, 0); 344 gap_start_scan(); 345 printf("Start scan..\n"); 346 } 347 348 static void start_advertising(void) { 349 gap_extended_advertising_start(adv_handle, 0, 0); 350 } 351 352 static void setup_advertising(void) { 353 bd_addr_t local_addr; 354 gap_local_bd_addr(local_addr); 355 bool local_address_invalid = btstack_is_null_bd_addr( local_addr ); 356 if( local_address_invalid ) { 357 extended_params.own_address_type = BD_ADDR_TYPE_LE_RANDOM; 358 } 359 gap_extended_advertising_setup(&le_advertising_set, &extended_params, &adv_handle); 360 if( local_address_invalid ) { 361 bd_addr_t random_address = { 0xC1, 0x01, 0x01, 0x01, 0x01, 0x01 }; 362 gap_extended_advertising_set_random_address( adv_handle, random_address ); 363 } 364 gap_extended_advertising_set_adv_data(adv_handle, sizeof(extended_adv_data), extended_adv_data); 365 start_advertising(); 366 } 367 368 static void got_base_and_big_info() { 369 // add source 370 if (standalone_mode) { 371 printf("BASS: add Broadcast Source\n"); 372 // add source 373 uint8_t source_index = 0; 374 broadcast_audio_scan_service_server_add_source(&bass_source_new, &source_index); 375 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA); 376 } 377 378 // update num subgroups from BASE 379 bass_sources[0].data.subgroups_num = bass_source_new.subgroups_num; 380 381 if ((encryption == false) || have_broadcast_code){ 382 enter_create_big_sync(); 383 } else { 384 printf("BASS: request Broadcast Code\n"); 385 bass_sources[0].big_encryption = LE_AUDIO_BIG_ENCRYPTION_BROADCAST_CODE_REQUIRED; 386 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA); 387 app_state = APP_W4_BROADCAST_CODE; 388 } 389 } 390 391 static void start_pa_sync(bd_addr_type_t source_type, bd_addr_t source_addr) { 392 // ignore other advertisements 393 gap_whitelist_add(source_type, source_addr); 394 gap_set_scan_params(1, 0x30, 0x30, 1); 395 // sync to PA 396 gap_periodic_advertiser_list_clear(); 397 gap_periodic_advertiser_list_add(source_type, source_addr, remote_sid); 398 app_state = APP_W4_PA_AND_BIG_INFO; 399 printf("Start Periodic Advertising Sync\n"); 400 gap_periodic_advertising_create_sync(0x01, remote_sid, source_type, source_addr, 0, 1000, 0); 401 gap_start_scan(); 402 } 403 404 static void pa_sync_established() { 405 have_base = false; 406 have_big_info = false; 407 app_state = APP_W4_PA_AND_BIG_INFO; 408 } 409 410 static void stop_pa_sync(void) { 411 app_state = APP_IDLE; 412 le_audio_demo_util_sink_close(); 413 printf("Terminate BIG SYNC\n"); 414 gap_big_sync_terminate(big_handle); 415 int i; 416 for (i=0;i<num_bis;i++){ 417 if (bis_con_handles[i] != HCI_CON_HANDLE_INVALID) { 418 gap_disconnect(bis_con_handles[i]); 419 } 420 } 421 422 } 423 424 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 425 UNUSED(channel); 426 if (packet_type != HCI_EVENT_PACKET) return; 427 switch (packet[0]) { 428 case BTSTACK_EVENT_STATE: 429 switch(btstack_event_state_get_state(packet)) { 430 case HCI_STATE_WORKING: 431 app_state = APP_IDLE; 432 // setup advertising and allow to receive periodic advertising sync transfers 433 setup_advertising(); 434 gap_periodic_advertising_sync_transfer_set_default_parameters(2, 0, 0x2000, 0); 435 436 #ifdef ENABLE_DEMO_MODE 437 start_scanning(); 438 #else 439 show_usage(); 440 #endif 441 break; 442 case HCI_STATE_OFF: 443 printf("Goodbye\n"); 444 exit(0); 445 break; 446 default: 447 break; 448 } 449 break; 450 case GAP_EVENT_EXTENDED_ADVERTISING_REPORT: 451 { 452 if (app_state != APP_W4_BROADCAST_ADV) break; 453 454 gap_event_extended_advertising_report_get_address(packet, remote); 455 uint8_t adv_size = gap_event_extended_advertising_report_get_data_length(packet); 456 const uint8_t * adv_data = gap_event_extended_advertising_report_get_data(packet); 457 458 ad_context_t context; 459 bool found = false; 460 remote_name[0] = '\0'; 461 uint16_t uuid; 462 uint32_t broadcast_id; 463 for (ad_iterator_init(&context, adv_size, adv_data) ; ad_iterator_has_more(&context) ; ad_iterator_next(&context)) { 464 const uint8_t data_type = ad_iterator_get_data_type(&context); 465 uint8_t data_size = ad_iterator_get_data_len(&context); 466 const uint8_t *data = ad_iterator_get_data(&context); 467 switch (data_type){ 468 case BLUETOOTH_DATA_TYPE_SERVICE_DATA_16_BIT_UUID: 469 uuid = little_endian_read_16(data, 0); 470 if (uuid == ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE){ 471 broadcast_id = little_endian_read_24(data, 2); 472 found = true; 473 } 474 break; 475 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME: 476 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME: 477 data_size = btstack_min(sizeof(remote_name) - 1, data_size); 478 memcpy(remote_name, data, data_size); 479 remote_name[data_size] = 0; 480 // support for nRF5340 Audio DK 481 if (strncmp("NRF5340", remote_name, 7) == 0){ 482 nrf5340_audio_demo = true; 483 found = true; 484 } 485 break; 486 default: 487 break; 488 } 489 } 490 if (!found) break; 491 remote_type = gap_event_extended_advertising_report_get_address_type(packet); 492 remote_sid = gap_event_extended_advertising_report_get_advertising_sid(packet); 493 pts_mode = strncmp("PTS-", remote_name, 4) == 0; 494 count_mode = strncmp("COUNT", remote_name, 5) == 0; 495 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); 496 497 // setup bass source info 498 bass_source_new.address_type = remote_type; 499 memcpy(bass_source_new.address, remote, 6); 500 bass_source_new.adv_sid = remote_sid; 501 bass_source_new.broadcast_id = broadcast_id; 502 bass_source_new.pa_sync = LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE; 503 bass_source_new.pa_interval = gap_event_extended_advertising_report_get_periodic_advertising_interval(packet); 504 505 // start pa sync 506 start_pa_sync(remote_type, remote); 507 break; 508 } 509 510 case HCI_EVENT_DISCONNECTION_COMPLETE: 511 // restart advertisements on disconnect 512 if (hci_event_disconnection_complete_get_connection_handle(packet) == commander_acl_handle) { 513 printf("Broadcast Assistant disconnected\n"); 514 commander_acl_handle = HCI_CON_HANDLE_INVALID; 515 start_advertising(); 516 } 517 break; 518 case HCI_EVENT_LE_META: 519 switch(hci_event_le_meta_get_subevent_code(packet)) { 520 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECEIVED: 521 // PAST implies broadcast source has been added by client 522 sync_handle = hci_subevent_le_periodic_advertising_sync_transfer_received_get_sync_handle(packet); 523 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA); 524 btstack_run_loop_remove_timer(&broadcast_sink_pa_sync_timer); 525 printf("Periodic advertising sync transfer with handle 0x%04x received\n", sync_handle); 526 pa_sync_established(); 527 break; 528 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHMENT: 529 sync_handle = hci_subevent_le_periodic_advertising_sync_establishment_get_sync_handle(packet); 530 printf("Periodic advertising sync with handle 0x%04x established\n", sync_handle); 531 pa_sync_established(); 532 break; 533 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_REPORT: 534 if (app_state != APP_W4_PA_AND_BIG_INFO) break; 535 if (have_base) break; 536 handle_periodic_advertisement(packet, size); 537 if (have_base && have_big_info){ 538 got_base_and_big_info(); 539 } 540 break; 541 case HCI_SUBEVENT_LE_BIGINFO_ADVERTISING_REPORT: 542 if (app_state != APP_W4_PA_AND_BIG_INFO) break; 543 if (have_big_info) break; 544 handle_big_info(packet, size); 545 if (have_base && have_big_info){ 546 got_base_and_big_info(); 547 } 548 break; 549 case HCI_SUBEVENT_LE_BIG_SYNC_LOST: 550 printf("BIG Sync Lost\n"); 551 { 552 const btstack_audio_sink_t * sink = btstack_audio_sink_get_instance(); 553 if (sink != NULL) { 554 sink->stop_stream(); 555 sink->close(); 556 } 557 } 558 // start over 559 if (!standalone_mode) break; 560 start_scanning(); 561 break; 562 default: 563 break; 564 } 565 break; 566 case HCI_EVENT_META_GAP: 567 switch (hci_event_gap_meta_get_subevent_code(packet)){ 568 case GAP_SUBEVENT_LE_CONNECTION_COMPLETE: 569 commander_acl_handle = gap_subevent_le_connection_complete_get_connection_handle(packet); 570 commander_type = gap_subevent_le_connection_complete_get_peer_address_type(packet); 571 gap_subevent_le_connection_complete_get_peer_address(packet, commander_address); 572 printf("Broadcast Assistant connected, handle 0x%04x - %s type %u\n", commander_acl_handle, bd_addr_to_str(commander_address), commander_type); 573 break; 574 case GAP_SUBEVENT_BIG_SYNC_CREATED: { 575 printf("BIG Sync created with BIS Connection handles: "); 576 uint8_t i; 577 for (i=0;i<num_bis;i++){ 578 bis_con_handles[i] = gap_subevent_big_sync_created_get_bis_con_handles(packet, i); 579 printf("0x%04x ", bis_con_handles[i]); 580 } 581 printf("\n"); 582 app_state = APP_STREAMING; 583 printf("Start receiving\n"); 584 585 printf("Terminate PA Sync\n"); 586 gap_periodic_advertising_terminate_sync(sync_handle); 587 588 // update BIS Sync state 589 bass_sources[0].data.subgroups[0].bis_sync_state = bis_sync_mask; 590 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_SYNCHRONIZED_TO_PA); 591 break; 592 } 593 case GAP_SUBEVENT_BIG_SYNC_STOPPED: 594 printf("BIG Sync stopped, big_handle 0x%02x\n", gap_subevent_big_sync_stopped_get_big_handle(packet)); 595 break; 596 default: 597 break; 598 } 599 break; 600 case SM_EVENT_JUST_WORKS_REQUEST: 601 printf("Just Works requested\n"); 602 sm_just_works_confirm(sm_event_just_works_request_get_handle(packet)); 603 break; 604 default: 605 break; 606 } 607 } 608 609 static void show_usage(void){ 610 printf("\n--- LE Audio Broadcast Sink Test Console ---\n"); 611 printf("s - start scanning\n"); 612 #ifdef HAVE_LC3PLUS 613 printf("q - use LC3plus decoder if 10 ms ISO interval is used\n"); 614 #endif 615 printf("e - set broadcast code to 0x11111111111111111111111111111111\n"); 616 printf("t - terminate BIS streams\n"); 617 printf("---\n"); 618 } 619 620 static void stdin_process(char c){ 621 switch (c){ 622 case 's': 623 if (app_state != APP_IDLE) break; 624 standalone_mode = true; 625 start_scanning(); 626 break; 627 case 'e': 628 printf("Set broadcast code to 0x11111111111111111111111111111111\n"); 629 memset(broadcast_code, 0x11, 16); 630 have_broadcast_code = true; 631 break; 632 #ifdef HAVE_LC3PLUS 633 case 'q': 634 printf("Use LC3plus decoder for 10 ms ISO interval...\n"); 635 le_audio_demo_util_sink_enable_lc3plus(true); 636 break; 637 #endif 638 case 't': 639 switch (app_state){ 640 case APP_STREAMING: 641 case APP_W4_BIG_SYNC_ESTABLISHED: 642 stop_pa_sync(); 643 break; 644 default: 645 break; 646 } 647 break; 648 case '\n': 649 case '\r': 650 break; 651 default: 652 show_usage(); 653 break; 654 655 } 656 } 657 658 static void iso_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size) { 659 // get stream_index from con_handle 660 uint16_t header = little_endian_read_16(packet, 0); 661 hci_con_handle_t con_handle = header & 0x0fff; 662 uint8_t i; 663 for (i=0;i<num_bis;i++){ 664 if (bis_con_handles[i] == con_handle) { 665 le_audio_demo_util_sink_receive(i, packet, size); 666 } 667 } 668 } 669 670 static void broadcast_sync_pa_sync_timeout_handler(btstack_timer_source_t * ts){ 671 UNUSED(ts); 672 printf("PAST Timeout -> LE_AUDIO_PA_SYNC_STATE_NO_PAST\n"); 673 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_NO_PAST); 674 } 675 676 static void handle_new_pa_sync(uint8_t source_id, le_audio_pa_sync_t pa_sync) { 677 switch (pa_sync){ 678 case LE_AUDIO_PA_SYNC_DO_NOT_SYNCHRONIZE_TO_PA: 679 printf("Stop PA Sync\n"); 680 stop_pa_sync(); 681 bass_sources[0].data.subgroups[0].bis_sync_state = 0; 682 broadcast_audio_scan_service_server_set_pa_sync_state(0, LE_AUDIO_PA_SYNC_STATE_NOT_SYNCHRONIZED_TO_PA); 683 break; 684 case LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE: 685 printf("LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE -> Request SyncInfo\n"); 686 broadcast_audio_scan_service_server_set_pa_sync_state(source_id, LE_AUDIO_PA_SYNC_STATE_SYNCINFO_REQUEST); 687 // start timeout 688 btstack_run_loop_set_timer_handler(&broadcast_sink_pa_sync_timer, broadcast_sync_pa_sync_timeout_handler); 689 btstack_run_loop_set_timer(&broadcast_sink_pa_sync_timer, 10000); // 10 seconds 690 btstack_run_loop_add_timer(&broadcast_sink_pa_sync_timer); 691 break; 692 case LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_NOT_AVAILABLE: 693 printf("LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE -> Start Periodic Advertising Sync\n"); 694 start_pa_sync(bass_sources[source_id].data.address_type, bass_sources[source_id].data.address); 695 break; 696 default: 697 break; 698 } 699 } 700 701 static void bass_packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 702 UNUSED(packet_type); 703 UNUSED(channel); 704 btstack_assert (packet_type == HCI_EVENT_PACKET); 705 btstack_assert(hci_event_packet_get_type(packet) == HCI_EVENT_GATTSERVICE_META); 706 uint8_t source_id; 707 printf("BASS Event 0x%02x: ", hci_event_gattservice_meta_get_subevent_code(packet)); 708 printf_hexdump(packet, size); 709 uint8_t pa_sync; 710 switch (hci_event_gattservice_meta_get_subevent_code(packet)){ 711 case GATTSERVICE_SUBEVENT_BASS_SERVER_SOURCE_ADDED: 712 pa_sync = gattservice_subevent_bass_server_source_added_get_pa_sync(packet); 713 source_id = gattservice_subevent_bass_server_source_added_get_source_id(packet); 714 printf("GATTSERVICE_SUBEVENT_BASS_SOURCE_ADDED, source_id 0x%04x, pa_sync %u\n", source_id, pa_sync); 715 handle_new_pa_sync(source_id, pa_sync); 716 break; 717 case GATTSERVICE_SUBEVENT_BASS_SERVER_SOURCE_MODIFIED: 718 pa_sync = gattservice_subevent_bass_server_source_added_get_pa_sync(packet); 719 source_id = gattservice_subevent_bass_server_source_added_get_source_id(packet); 720 printf("GATTSERVICE_SUBEVENT_BASS_SOURCE_MODIFIED, source_id 0x%04x, pa_sync %u\n", source_id, pa_sync); 721 handle_new_pa_sync(source_id, pa_sync); 722 break; 723 case GATTSERVICE_SUBEVENT_BASS_SERVER_SOURCE_DELETED: 724 printf("GATTSERVICE_SUBEVENT_BASS_SERVER_SOURCE_DELETED, source_id 0x%04x\n", 725 gattservice_subevent_bass_server_source_deleted_get_source_id(packet)); 726 break; 727 case GATTSERVICE_SUBEVENT_BASS_SERVER_BROADCAST_CODE: 728 gattservice_subevent_bass_server_broadcast_code_get_broadcast_code(packet, broadcast_code); 729 printf("GATTSERVICE_SUBEVENT_BASS_BROADCAST_CODE received: "); 730 printf_hexdump(broadcast_code, 16); 731 bass_sources[0].big_encryption = LE_AUDIO_BIG_ENCRYPTION_DECRYPTING; 732 if (have_base && have_big_info){ 733 enter_create_big_sync(); 734 } 735 break; 736 default: 737 break; 738 } 739 } 740 741 int btstack_main(int argc, const char * argv[]); 742 int btstack_main(int argc, const char * argv[]){ 743 (void) argv; 744 (void) argc; 745 746 l2cap_init(); 747 sm_init(); 748 749 // setup ATT server 750 att_server_init(profile_data, NULL, NULL); 751 752 // register for HCI events 753 hci_event_callback_registration.callback = &packet_handler; 754 hci_add_event_handler(&hci_event_callback_registration); 755 756 // register for ISO Packet 757 hci_register_iso_packet_handler(&iso_packet_handler); 758 759 // register for SM events 760 sm_event_callback_registration.callback = &packet_handler; 761 sm_add_event_handler(&sm_event_callback_registration); 762 763 // setup BASS Server 764 broadcast_audio_scan_service_server_init(BASS_NUM_SOURCES, bass_sources, BASS_NUM_CLIENTS, bass_clients); 765 broadcast_audio_scan_service_server_register_packet_handler(&bass_packet_handler); 766 767 // setup advertising and allow to receive periodic advertising sync trasnfers 768 setup_advertising(); 769 gap_periodic_advertising_sync_transfer_set_default_parameters(2, 0, 0x2000, 0); 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