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_assistant.c" 39 40 /* 41 * LE Audio Broadcast Assistant 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/sm.h" 55 #include "bluetooth_data_types.h" 56 #include "bluetooth_gatt.h" 57 #include "btstack_audio.h" 58 #include "btstack_debug.h" 59 #include "btstack_event.h" 60 #include "btstack_lc3.h" 61 #include "btstack_run_loop.h" 62 #include "btstack_stdin.h" 63 #include "btstack_util.h" 64 #include "gap.h" 65 #include "hci.h" 66 #include "l2cap.h" 67 #include "le-audio/gatt-service/broadcast_audio_scan_service_client.h" 68 #include "le-audio/le_audio_util.h" 69 #include "le-audio/le_audio_base_parser.h" 70 71 static void show_usage(void); 72 73 static enum { 74 APP_W4_WORKING, 75 APP_IDLE, 76 APP_W4_SCAN_DELEGATOR_CONNECTION, 77 APP_CONNECTED, 78 APP_W4_SCAN_BROADCAST_SOURCES, 79 APP_W4_PA_AND_BIG_INFO, 80 APP_W4_BIG_SYNC_ESTABLISHED, 81 } app_state = APP_W4_WORKING; 82 83 // 84 static btstack_packet_callback_registration_t hci_event_callback_registration; 85 static btstack_packet_callback_registration_t sm_event_callback_registration; 86 87 static bool have_scan_delegator; 88 static bool have_broadcast_source; 89 static bool have_base; 90 static bool have_big_info; 91 static bool scan_for_scan_delegator; 92 static bool scan_for_broadcast_source; 93 static uint16_t broadcast_source_scan_duration_s = 10; 94 95 // broadcast sink info 96 #define NUM_BROADCAST_SOURCES 5 97 #define BROADCAST_SOURCE_NAME_LEN 20 98 struct { 99 char name[BROADCAST_SOURCE_NAME_LEN]; 100 bd_addr_t addr; 101 bd_addr_type_t addr_type; 102 uint8_t sid; 103 uint32_t broadcast_id; 104 uint16_t pa_interval; 105 } broadcast_sources[NUM_BROADCAST_SOURCES]; 106 static uint8_t broadcast_source_current; 107 static bool broadcast_source_selected; 108 static uint8_t broadcast_source_count = 0; 109 static btstack_timer_source_t broadcast_source_scan_timer; 110 static bool broadcast_source_synced; 111 112 // broadcast info 113 static hci_con_handle_t sync_handle = HCI_CON_HANDLE_INVALID; 114 static uint8_t encryption; 115 static uint8_t broadcast_code [] = {0x01, 0x02, 0x68, 0x05, 0x53, 0xF1, 0x41, 0x5A, 0xA2, 0x65, 0xBB, 0xAF, 0xC6, 0xEA, 0x03, 0xB8, }; 116 static uint8_t num_bis; 117 static uint32_t bis_sync_mask; 118 static uint32_t sampling_frequency_hz; 119 static btstack_lc3_frame_duration_t frame_duration; 120 static uint16_t octets_per_frame; 121 122 // scan delegator info 123 static char scan_delegator_name[20]; 124 static bd_addr_t scan_delegator; 125 static bd_addr_type_t scan_delegator_type; 126 static hci_con_handle_t scan_delegator_handle; 127 128 // BASS 129 #define BASS_CLIENT_NUM_SOURCES 1 130 static bass_client_connection_t bass_connection; 131 static bass_client_source_t bass_sources[BASS_CLIENT_NUM_SOURCES]; 132 static bass_source_data_t bass_source_data; 133 static uint16_t bass_cid; 134 static uint8_t bass_source_id; 135 136 // test device name 137 static const char test_device_name[] = "OnePlus Buds Pro 2"; 138 139 /* Scanning */ 140 141 static void start_scanning() { 142 have_base = false; 143 have_big_info = false; 144 gap_set_scan_params(1, 0x30, 0x30, 0); 145 gap_start_scan(); 146 printf("Start scan..\n"); 147 } 148 149 static void stop_scanning() { 150 gap_stop_scan(); 151 app_state = APP_CONNECTED; 152 } 153 154 static void broadcast_source_scan_timeout_handler(btstack_timer_source_t * ts) { 155 stop_scanning(); 156 printf("Scanning done, found %u Broadcast Sources\n", broadcast_source_count); 157 show_usage(); 158 } 159 160 /* Scan Delegator */ 161 162 static void connect_to_scan_delegator(void) { 163 printf("Connect to Scan Delegator %s type %u - %s\n", bd_addr_to_str(scan_delegator), scan_delegator_type, scan_delegator_name); 164 app_state = APP_W4_SCAN_DELEGATOR_CONNECTION; 165 gap_connect(scan_delegator, scan_delegator_type); 166 } 167 168 static void 169 le_audio_broadcast_assistant_found_scan_delegator(bd_addr_type_t *addr_type, const uint8_t *addr, 170 const char *adv_name) { 171 memcpy(scan_delegator, addr, 6); 172 scan_delegator_type = (*addr_type); 173 btstack_strcpy(scan_delegator_name, sizeof(scan_delegator_name), (const char *) adv_name); 174 printf("Broadcast sink found, addr %s, name: '%s'\n", bd_addr_to_str(scan_delegator), scan_delegator_name); 175 gap_whitelist_add(scan_delegator_type, scan_delegator); 176 177 stop_scanning(); 178 connect_to_scan_delegator(); 179 } 180 181 /* Broadcast Sources */ 182 183 static void le_audio_broadcast_assistant_start_periodic_sync() { 184 printf("Start Periodic Advertising Sync\n"); 185 186 have_base = false; 187 have_big_info = false; 188 189 // ignore other advertisements 190 gap_set_scan_params(1, 0x30, 0x30, 1); 191 // sync to PA 192 gap_periodic_advertiser_list_clear(); 193 gap_periodic_advertiser_list_add(broadcast_sources[broadcast_source_current].addr_type, broadcast_sources[broadcast_source_current].addr, broadcast_sources[broadcast_source_current].sid); 194 app_state = APP_W4_PA_AND_BIG_INFO; 195 gap_periodic_advertising_create_sync(0x01, broadcast_sources[broadcast_source_current].sid, broadcast_sources[broadcast_source_current].addr_type, broadcast_sources[broadcast_source_current].addr, 0, 1000, 0); 196 gap_start_scan(); 197 } 198 199 static void handle_periodic_advertisement(const uint8_t * packet, uint16_t size){ 200 201 // periodic advertisement contains the BASE 202 // TODO: BASE might be split across multiple advertisements 203 const uint8_t * adv_data = hci_subevent_le_periodic_advertising_report_get_data(packet); 204 uint16_t adv_size = hci_subevent_le_periodic_advertising_report_get_data_length(packet); 205 uint8_t adv_status = hci_subevent_le_periodic_advertising_report_get_data_status(packet); 206 207 if (adv_status != 0) { 208 printf("Periodic Advertisement (status %u): ", adv_status); 209 printf_hexdump(adv_data, adv_size); 210 return; 211 } 212 213 le_audio_base_parser_t parser; 214 bool ok = le_audio_base_parser_init(&parser, adv_data, adv_size); 215 if (ok == false){ 216 return; 217 } 218 have_base = true; 219 220 printf("BASE:\n"); 221 uint32_t presentation_delay = le_audio_base_parser_get_presentation_delay(&parser); 222 printf("- presentation delay: %"PRIu32" us\n", presentation_delay); 223 uint8_t num_subgroups = le_audio_base_parser_get_num_subgroups(&parser); 224 // Cache in new source struct 225 bass_source_data.subgroups_num = num_subgroups; 226 printf("- num subgroups: %u\n", num_subgroups); 227 uint8_t i; 228 for (i=0;i<num_subgroups;i++){ 229 230 // Cache in new source struct 231 bass_source_data.subgroups[i].bis_sync = 0; 232 233 // Level 2: Subgroup Level 234 num_bis = le_audio_base_parser_subgroup_get_num_bis(&parser); 235 printf(" - num bis[%u]: %u\n", i, num_bis); 236 uint8_t codec_specific_configuration_length = le_audio_base_parser_bis_get_codec_specific_configuration_length(&parser); 237 const uint8_t * codec_specific_configuration = le_audio_base_parser_subgroup_get_codec_specific_configuration(&parser); 238 printf(" - codec specific config[%u]: ", i); 239 printf_hexdump(codec_specific_configuration, codec_specific_configuration_length); 240 // parse config to get sampling frequency and frame duration 241 uint8_t codec_offset = 0; 242 while ((codec_offset + 1) < codec_specific_configuration_length){ 243 uint8_t ltv_len = codec_specific_configuration[codec_offset++]; 244 uint8_t ltv_type = codec_specific_configuration[codec_offset]; 245 const uint32_t sampling_frequency_map[] = { 8000, 11025, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000, 176400, 192000, 384000 }; 246 uint8_t sampling_frequency_index; 247 uint8_t frame_duration_index; 248 switch (ltv_type){ 249 case 0x01: // sampling frequency 250 sampling_frequency_index = codec_specific_configuration[codec_offset+1]; 251 // TODO: check range 252 sampling_frequency_hz = sampling_frequency_map[sampling_frequency_index - 1]; 253 printf(" - sampling frequency[%u]: %u\n", i, sampling_frequency_hz); 254 break; 255 case 0x02: // 0 = 7.5, 1 = 10 ms 256 frame_duration_index = codec_specific_configuration[codec_offset+1]; 257 frame_duration = le_audio_util_get_btstack_lc3_frame_duration(frame_duration_index); 258 printf(" - frame duration[%u]: %u us\n", i, le_audio_get_frame_duration_us(frame_duration_index)); 259 break; 260 case 0x04: // octets per coding frame 261 octets_per_frame = little_endian_read_16(codec_specific_configuration, codec_offset+1); 262 printf(" - octets per codec frame[%u]: %u\n", i, octets_per_frame); 263 break; 264 default: 265 break; 266 } 267 codec_offset += ltv_len; 268 } 269 uint8_t metadata_length = le_audio_base_parser_subgroup_get_metadata_length(&parser); 270 const uint8_t * meta_data = le_audio_base_subgroup_parser_get_metadata(&parser); 271 printf(" - meta data[%u]: ", i); 272 printf_hexdump(meta_data, metadata_length); 273 uint8_t k; 274 for (k=0;k<num_bis;k++){ 275 // Level 3: BIS Level 276 uint8_t bis_index = le_audio_base_parser_bis_get_index(&parser); 277 278 // check value 279 // double check message 280 281 // Cache in new source struct 282 bis_sync_mask |= 1 << (bis_index-1); 283 284 bass_source_data.subgroups[i].metadata_length = 0; 285 memset(&bass_source_data.subgroups[i].metadata, 0, sizeof(le_audio_metadata_t)); 286 287 printf(" - bis index[%u][%u]: %u\n", i, k, bis_index); 288 codec_specific_configuration_length = le_audio_base_parser_bis_get_codec_specific_configuration_length(&parser); 289 codec_specific_configuration = le_audio_base_bis_parser_get_codec_specific_configuration(&parser); 290 printf(" - codec specific config[%u][%u]: ", i, k); 291 printf_hexdump(codec_specific_configuration, codec_specific_configuration_length); 292 293 // parse next BIS 294 le_audio_base_parser_bis_next(&parser); 295 } 296 297 // parse next subgroup 298 le_audio_base_parser_subgroup_next(&parser); 299 } 300 } 301 302 static void have_base_and_big_info(void){ 303 stop_scanning(); 304 broadcast_source_synced = true; 305 show_usage(); 306 } 307 308 static void handle_big_info(const uint8_t * packet, uint16_t size){ 309 printf("BIG Info advertising report\n"); 310 sync_handle = hci_subevent_le_biginfo_advertising_report_get_sync_handle(packet); 311 encryption = hci_subevent_le_biginfo_advertising_report_get_encryption(packet); 312 if (encryption) { 313 printf("Stream is encrypted\n"); 314 } 315 have_big_info = true; 316 } 317 318 static void add_source() { 319 // setup bass source info 320 printf("BASS Client: add source with BIS Sync 0x%04x\n", bass_source_data.subgroups[0].bis_sync_state); 321 bass_source_data.address_type = broadcast_sources[broadcast_source_current].addr_type; 322 memcpy(bass_source_data.address, broadcast_sources[broadcast_source_current].addr, 6); 323 bass_source_data.adv_sid = broadcast_sources[broadcast_source_current].sid; 324 bass_source_data.broadcast_id = broadcast_sources[broadcast_source_current].broadcast_id; 325 bass_source_data.pa_sync = broadcast_source_synced ? LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE : LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_NOT_AVAILABLE; 326 bass_source_data.pa_interval = broadcast_sources[broadcast_source_current].pa_interval; 327 // bass_source_new.subgroups_num set in BASE parser 328 // bass_source_new.subgroup[i].* set in BASE parser 329 330 // add bass source 331 broadcast_audio_scan_service_client_add_source(bass_cid, &bass_source_data); 332 } 333 334 /* Packet Handlers */ 335 336 static void bass_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 337 UNUSED(channel); 338 UNUSED(size); 339 340 if (packet_type != HCI_EVENT_PACKET) return; 341 if (hci_event_packet_get_type(packet) != HCI_EVENT_GATTSERVICE_META) return; 342 343 const bass_source_data_t * source_data; 344 345 switch (hci_event_gattservice_meta_get_subevent_code(packet)) { 346 case GATTSERVICE_SUBEVENT_BASS_CLIENT_CONNECTED: 347 if (gattservice_subevent_bass_client_connected_get_status(packet) != ERROR_CODE_SUCCESS){ 348 printf("BASS client connection failed, cid 0x%02x, con_handle 0x%02x, status 0x%02x\n", 349 bass_cid, scan_delegator_handle, 350 gattservice_subevent_bass_client_connected_get_status(packet)); 351 return; 352 } 353 printf("BASS client connected, cid 0x%02x\n", bass_cid); 354 app_state = APP_CONNECTED; 355 break; 356 case GATTSERVICE_SUBEVENT_BASS_CLIENT_SOURCE_OPERATION_COMPLETE: 357 if (gattservice_subevent_bass_client_source_operation_complete_get_status(packet) != ERROR_CODE_SUCCESS){ 358 printf("BASS client source operation failed, status 0x%02x\n", gattservice_subevent_bass_client_source_operation_complete_get_status(packet)); 359 break; 360 } 361 362 if ( gattservice_subevent_bass_client_source_operation_complete_get_opcode(packet) == (uint8_t)BASS_OPCODE_ADD_SOURCE ){ 363 // TODO: set state to 'wait for source_id" 364 printf("BASS client add source operation completed, wait for source_id\n"); 365 } 366 break; 367 case GATTSERVICE_SUBEVENT_BASS_CLIENT_NOTIFICATION_COMPLETE: 368 // store source_id 369 bass_source_id = gattservice_subevent_bass_client_notification_complete_get_source_id(packet); 370 printf("BASS client notification, source_id = 0x%02x\n", bass_source_id); 371 source_data = broadcast_audio_scan_service_client_get_source_data(bass_cid, bass_source_id); 372 btstack_assert(source_data != NULL); 373 374 switch (source_data->pa_sync_state){ 375 case LE_AUDIO_PA_SYNC_STATE_SYNCINFO_REQUEST: 376 // start pa sync transfer 377 printf("LE_AUDIO_PA_SYNC_STATE_SYNCINFO_REQUEST -> Start PAST\n"); 378 // TODO: unclear why this needs to be shifted for PAST with TS to get test green 379 uint16_t service_data = bass_source_id << 8; 380 gap_periodic_advertising_sync_transfer_send(scan_delegator_handle, service_data, sync_handle); 381 break; 382 default: 383 break; 384 } 385 break; 386 case GATTSERVICE_SUBEVENT_BASS_CLIENT_DISCONNECTED: 387 break; 388 default: 389 break; 390 } 391 } 392 393 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 394 UNUSED(channel); 395 if (packet_type != HCI_EVENT_PACKET) return; 396 uint8_t adv_size; 397 const uint8_t * adv_data; 398 bool found_scan_delegator = false; 399 bool found_broadcast_source = false; 400 bool add_broadcast_source = false; 401 char adv_name[31]; 402 uint16_t uuid; 403 ad_context_t context; 404 405 switch (packet[0]) { 406 case BTSTACK_EVENT_STATE: 407 switch (btstack_event_state_get_state(packet)) { 408 case HCI_STATE_WORKING: 409 app_state = APP_IDLE; 410 #ifdef ENABLE_DEMO_MODE 411 start_scanning(); 412 #else 413 show_usage(); 414 #endif 415 break; 416 case HCI_STATE_OFF: 417 printf("Goodbye\n"); 418 exit(0); 419 break; 420 default: 421 break; 422 } 423 break; 424 425 case GAP_EVENT_ADVERTISING_REPORT: 426 // TODO: contains partial copy of GAP_EVENT_EXTENDED_ADVERTISING_REPORT below 427 adv_size = gap_event_advertising_report_get_data_length(packet); 428 adv_data = gap_event_advertising_report_get_data(packet); 429 adv_name[0] = 0; 430 431 for (ad_iterator_init(&context, adv_size, adv_data) ; ad_iterator_has_more(&context) ; ad_iterator_next(&context)) { 432 uint8_t data_type = ad_iterator_get_data_type(&context); 433 uint8_t size = ad_iterator_get_data_len(&context); 434 const uint8_t *data = ad_iterator_get_data(&context); 435 switch (data_type){ 436 case BLUETOOTH_DATA_TYPE_SERVICE_DATA_16_BIT_UUID: 437 uuid = little_endian_read_16(data, 0); 438 switch (uuid){ 439 case ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE: 440 if (scan_for_broadcast_source) { 441 broadcast_sources[broadcast_source_count].broadcast_id = little_endian_read_24(data, 2); 442 found_broadcast_source = true; 443 } 444 break; 445 case ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE: 446 if (scan_for_scan_delegator) { 447 found_scan_delegator = true; 448 } 449 break; 450 default: 451 break; 452 } 453 break; 454 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME: 455 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME: 456 size = btstack_min(sizeof(adv_name) - 1, size); 457 memcpy(adv_name, data, size); 458 adv_name[size] = 0; 459 break; 460 default: 461 break; 462 } 463 } 464 465 if ((have_scan_delegator == false) && found_scan_delegator){ 466 have_scan_delegator = true; 467 bd_addr_t addr; 468 gap_event_extended_advertising_report_get_address(packet, addr); 469 bd_addr_type_t addr_type = (bd_addr_type_t) gap_event_extended_advertising_report_get_address_type(packet); 470 le_audio_broadcast_assistant_found_scan_delegator(&addr_type, addr, adv_name); 471 } 472 break; 473 474 case GAP_EVENT_EXTENDED_ADVERTISING_REPORT: 475 adv_size = gap_event_extended_advertising_report_get_data_length(packet); 476 adv_data = gap_event_extended_advertising_report_get_data(packet); 477 adv_name[0] = 0; 478 479 for (ad_iterator_init(&context, adv_size, adv_data) ; ad_iterator_has_more(&context) ; ad_iterator_next(&context)) { 480 uint8_t data_type = ad_iterator_get_data_type(&context); 481 uint8_t size = ad_iterator_get_data_len(&context); 482 const uint8_t *data = ad_iterator_get_data(&context); 483 switch (data_type){ 484 case BLUETOOTH_DATA_TYPE_SERVICE_DATA_16_BIT_UUID: 485 uuid = little_endian_read_16(data, 0); 486 switch (uuid){ 487 case ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE: 488 if (scan_for_broadcast_source) { 489 broadcast_sources[broadcast_source_count].broadcast_id = little_endian_read_24(data, 2); 490 found_broadcast_source = true; 491 } 492 break; 493 case ORG_BLUETOOTH_SERVICE_BROADCAST_AUDIO_SCAN_SERVICE: 494 if (scan_for_scan_delegator) { 495 found_scan_delegator = true; 496 } 497 break; 498 default: 499 break; 500 } 501 break; 502 case BLUETOOTH_DATA_TYPE_SHORTENED_LOCAL_NAME: 503 case BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME: 504 size = btstack_min(sizeof(adv_name) - 1, size); 505 memcpy(adv_name, data, size); 506 adv_name[size] = 0; 507 break; 508 default: 509 break; 510 } 511 } 512 513 if ((have_scan_delegator == false) && found_scan_delegator){ 514 have_scan_delegator = true; 515 bd_addr_t addr; 516 gap_event_extended_advertising_report_get_address(packet, addr); 517 bd_addr_type_t addr_type = (bd_addr_type_t) gap_event_extended_advertising_report_get_address_type(packet); 518 le_audio_broadcast_assistant_found_scan_delegator(&addr_type, addr, adv_name); 519 } 520 if (found_broadcast_source){ 521 have_broadcast_source = true; 522 bd_addr_t addr; 523 gap_event_extended_advertising_report_get_address(packet, addr); 524 bd_addr_type_t type = gap_event_extended_advertising_report_get_address_type(packet); 525 uint8_t i; 526 add_broadcast_source = true; 527 for (i=0;i<broadcast_source_count;i++) { 528 if (memcmp(addr, broadcast_sources[i].addr, 6) != 0) continue; 529 if (type != broadcast_sources[i].addr_type) continue; 530 add_broadcast_source = false; 531 } 532 } 533 if (add_broadcast_source && (broadcast_source_count < NUM_BROADCAST_SOURCES)) { 534 gap_event_extended_advertising_report_get_address(packet, broadcast_sources[broadcast_source_count].addr); 535 broadcast_sources[broadcast_source_count].addr_type = gap_event_extended_advertising_report_get_address_type(packet); 536 broadcast_sources[broadcast_source_count].sid = gap_event_extended_advertising_report_get_advertising_sid(packet); 537 btstack_strcpy(broadcast_sources[broadcast_source_count].name, BROADCAST_SOURCE_NAME_LEN, (const char *) adv_name); 538 printf("Broadcast source found, addr %s, name: '%s'\n", bd_addr_to_str(broadcast_sources[broadcast_source_count].addr), broadcast_sources[broadcast_source_count].name); 539 gap_whitelist_add(broadcast_sources[broadcast_source_count].addr_type, broadcast_sources[broadcast_source_count].addr); 540 broadcast_source_count++; 541 } 542 break; 543 544 case HCI_EVENT_LE_META: 545 switch(hci_event_le_meta_get_subevent_code(packet)) { 546 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_SYNC_ESTABLISHMENT: 547 sync_handle = hci_subevent_le_periodic_advertising_sync_establishment_get_sync_handle(packet); 548 broadcast_sources[broadcast_source_current].pa_interval = hci_subevent_le_periodic_advertising_sync_establishment_get_periodic_advertising_interval(packet); 549 printf("Periodic advertising sync with handle 0x%04x established\n", sync_handle); 550 break; 551 case HCI_SUBEVENT_LE_PERIODIC_ADVERTISING_REPORT: 552 if (have_base) break; 553 handle_periodic_advertisement(packet, size); 554 if (have_base & have_big_info){ 555 have_base_and_big_info(); 556 } 557 break; 558 case HCI_SUBEVENT_LE_BIGINFO_ADVERTISING_REPORT: 559 if (have_big_info) break; 560 handle_big_info(packet, size); 561 if (have_base & have_big_info){ 562 have_base_and_big_info(); 563 } 564 break; 565 case HCI_SUBEVENT_LE_BIG_SYNC_LOST: 566 printf("BIG Sync Lost\n"); 567 { 568 const btstack_audio_sink_t * sink = btstack_audio_sink_get_instance(); 569 if (sink != NULL) { 570 sink->stop_stream(); 571 sink->close(); 572 } 573 } 574 // start over 575 start_scanning(); 576 break; 577 default: 578 break; 579 } 580 break; 581 case HCI_EVENT_META_GAP: 582 switch (hci_event_gap_meta_get_subevent_code(packet)){ 583 case GAP_SUBEVENT_LE_CONNECTION_COMPLETE: 584 if (gap_subevent_le_connection_complete_get_status(packet) != ERROR_CODE_SUCCESS) break; 585 scan_delegator_handle = gap_subevent_le_connection_complete_get_connection_handle(packet); 586 printf("Connection complete, handle 0x%04x\n", scan_delegator_handle); 587 broadcast_audio_scan_service_client_connect(&bass_connection, 588 bass_sources, 589 BASS_CLIENT_NUM_SOURCES, 590 scan_delegator_handle, 591 &bass_cid); 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 606 /* UI */ 607 608 static void show_usage(void){ 609 printf("\n--- LE Audio Broadcast Assistant Test Console ---\n"); 610 switch (app_state) { 611 case APP_IDLE: 612 // printf("s - setup LE Broadcast Sink with Broadcast Source via Scan Delegator\n"); 613 printf("c - scan and connect to Scan Delegator\n"); 614 break; 615 case APP_CONNECTED: 616 if (broadcast_source_selected) { 617 printf("Selected Broadcast source: addr %s, type %u, name: %s, synced %u\n", 618 bd_addr_to_str(broadcast_sources[broadcast_source_current].addr), 619 broadcast_sources[broadcast_source_current].addr_type, 620 broadcast_sources[broadcast_source_current].name, 621 broadcast_source_synced); 622 } 623 printf("d - scan for Broadcast sources (%u s)\n", broadcast_source_scan_duration_s); 624 if (broadcast_source_count > 0) { 625 printf("1..%u select one of the Broadcast Sources:\n", broadcast_source_count); 626 uint8_t i; 627 for (i=0;i<broadcast_source_count;i++) { 628 printf("%u. addr %s, type %u, name: %s\n", i+1, 629 bd_addr_to_str(broadcast_sources[broadcast_source_current].addr), 630 broadcast_sources[broadcast_source_current].addr_type, 631 broadcast_sources[broadcast_source_current].name); 632 } 633 if (broadcast_source_synced) { 634 printf("a - add source with BIS Sync 0x%08x\n", bis_sync_mask); 635 printf("A - add source with BIS Sync 0x00000000 (do not sync)\n"); 636 printf("m - modify source to PA Sync = 0, bis sync = 0x00000000\n"); 637 printf("M - modify source to PA Sync = 2, bis sync = 0x%08x\n", bis_sync_mask); 638 printf("b - send Broadcast Code: "); 639 printf_hexdump(broadcast_code, sizeof(broadcast_code)); 640 printf("r - remove source\n"); 641 } 642 } 643 break; 644 default: 645 printf("[LE Audio Broadcast Assistant busy]\n"); 646 break; 647 } 648 printf("---\n"); 649 } 650 651 static void stdin_process(char c){ 652 switch (app_state) { 653 case APP_IDLE: 654 switch (c) { 655 case 'c': 656 scan_for_scan_delegator = true; 657 scan_for_broadcast_source = false; 658 start_scanning(); 659 app_state = APP_W4_SCAN_DELEGATOR_CONNECTION; 660 break; 661 default: 662 break; 663 } 664 break; 665 case APP_CONNECTED: 666 if ((c >= '1') && (c <= '9')){ 667 uint8_t digit = c - '0'; 668 if (digit <= broadcast_source_count) { 669 if (sync_handle != HCI_CON_HANDLE_INVALID) { 670 gap_periodic_advertising_terminate_sync(sync_handle); 671 } 672 broadcast_source_synced = false; 673 broadcast_source_selected = true; 674 broadcast_source_current = digit-1; 675 printf("Selected addr %s, type %u, name: %s\n", 676 bd_addr_to_str(broadcast_sources[broadcast_source_current].addr), 677 broadcast_sources[broadcast_source_current].addr_type, 678 broadcast_sources[broadcast_source_current].name); 679 le_audio_broadcast_assistant_start_periodic_sync(); 680 } 681 break; 682 } 683 switch (c) { 684 case 'd': 685 scan_for_scan_delegator = false; 686 scan_for_broadcast_source = true; 687 start_scanning(); 688 btstack_run_loop_set_timer(&broadcast_source_scan_timer, broadcast_source_scan_duration_s * 1000); 689 btstack_run_loop_set_timer_handler(&broadcast_source_scan_timer, broadcast_source_scan_timeout_handler); 690 btstack_run_loop_add_timer(&broadcast_source_scan_timer); 691 break; 692 default: 693 break; 694 } 695 break; 696 default: 697 break; 698 } 699 700 switch (c){ 701 case 'a': 702 bass_source_data.subgroups[0].bis_sync = bis_sync_mask; 703 add_source(); 704 break; 705 case 'A': 706 bass_source_data.subgroups[0].bis_sync = 0; 707 add_source(); 708 break; 709 case 'm': 710 bass_source_data.pa_sync = LE_AUDIO_PA_SYNC_DO_NOT_SYNCHRONIZE_TO_PA; 711 bass_source_data.subgroups[0].bis_sync_state = 0; 712 broadcast_audio_scan_service_client_modify_source(bass_cid, bass_source_id, &bass_source_data); 713 break; 714 case 'M': 715 bass_source_data.pa_sync = LE_AUDIO_PA_SYNC_SYNCHRONIZE_TO_PA_PAST_AVAILABLE; 716 bass_source_data.subgroups[0].bis_sync_state = bis_sync_mask; 717 broadcast_audio_scan_service_client_modify_source(bass_cid, bass_source_id, &bass_source_data); 718 break; 719 case 'r': 720 broadcast_audio_scan_service_client_remove_source(bass_cid, bass_source_id); 721 break; 722 case 'b': 723 broadcast_audio_scan_service_client_set_broadcast_code(bass_cid, bass_source_id, broadcast_code); 724 break; 725 case '\n': 726 case '\r': 727 break; 728 default: 729 show_usage(); 730 break; 731 732 } 733 } 734 735 int btstack_main(int argc, const char * argv[]); 736 int btstack_main(int argc, const char * argv[]){ 737 (void) argv; 738 (void) argc; 739 740 l2cap_init(); 741 sm_init(); 742 gatt_client_init(); 743 744 // register for HCI events 745 hci_event_callback_registration.callback = &packet_handler; 746 hci_add_event_handler(&hci_event_callback_registration); 747 748 // register for SM events 749 sm_event_callback_registration.callback = &packet_handler; 750 sm_add_event_handler(&sm_event_callback_registration); 751 752 broadcast_audio_scan_service_client_init(&bass_packet_handler); 753 754 // turn on! 755 hci_power_control(HCI_POWER_ON); 756 757 btstack_stdin_setup(stdin_process); 758 return 0; 759 } 760