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