1 /* 2 * Copyright (C) 2016 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 BLUEKITCHEN 24 * GMBH 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__ "a2dp_source_demo.c" 39 40 /* 41 * a2dp_source_demo.c 42 */ 43 44 // ***************************************************************************** 45 /* EXAMPLE_START(a2dp_source_demo): A2DP Source - Stream Audio and Control Volume 46 * 47 * @text This A2DP Source example demonstrates how to send an audio data stream 48 * to a remote A2DP Sink device and how to switch between two audio data sources. 49 * In addition, the AVRCP Target is used to answer queries on currently played media, 50 * as well as to handle remote playback control, i.e. play, stop, repeat, etc. If HAVE_BTSTACK_STDIN 51 * is set, press SPACE on the console to show the available AVDTP and AVRCP commands. 52 * 53 * @text To test with a remote device, e.g. a Bluetooth speaker, 54 * set the device_addr_string to the Bluetooth address of your 55 * remote device in the code, and use the UI to connect and start playback. 56 * 57 * @text For more info on BTstack audio, see our blog post 58 * [A2DP Sink and Source on STM32 F4 Discovery Board](http://bluekitchen-gmbh.com/a2dp-sink-and-source-on-stm32-f4-discovery-board/). 59 * 60 */ 61 // ***************************************************************************** 62 63 64 #include <stdint.h> 65 #include <stdio.h> 66 #include <inttypes.h> 67 #include <string.h> 68 69 #include "btstack.h" 70 #include "hxcmod.h" 71 #include "mods/mod.h" 72 73 // logarithmic volume reduction, samples are divided by 2^x 74 // #define VOLUME_REDUCTION 3 75 76 //#define AVRCP_BROWSING_ENABLED 77 78 #define NUM_CHANNELS 2 79 #define BYTES_PER_AUDIO_SAMPLE (2*NUM_CHANNELS) 80 #define AUDIO_TIMEOUT_MS 10 81 #define TABLE_SIZE_441HZ 100 82 83 #define SBC_STORAGE_SIZE 1030 84 85 typedef enum { 86 STREAM_SINE = 0, 87 STREAM_MOD, 88 STREAM_PTS_TEST 89 } stream_data_source_t; 90 91 typedef struct { 92 uint16_t a2dp_cid; 93 uint8_t local_seid; 94 uint8_t remote_seid; 95 uint8_t stream_opened; 96 uint16_t avrcp_cid; 97 98 uint32_t time_audio_data_sent; // ms 99 uint32_t acc_num_missed_samples; 100 uint32_t samples_ready; 101 btstack_timer_source_t audio_timer; 102 uint8_t streaming; 103 int max_media_payload_size; 104 uint32_t rtp_timestamp; 105 106 uint8_t sbc_storage[SBC_STORAGE_SIZE]; 107 uint16_t sbc_storage_count; 108 uint8_t sbc_ready_to_send; 109 110 uint8_t volume; 111 } a2dp_media_sending_context_t; 112 113 static uint8_t media_sbc_codec_capabilities[] = { 114 (AVDTP_SBC_44100 << 4) | AVDTP_SBC_STEREO, 115 0xFF,//(AVDTP_SBC_BLOCK_LENGTH_16 << 4) | (AVDTP_SBC_SUBBANDS_8 << 2) | AVDTP_SBC_ALLOCATION_METHOD_LOUDNESS, 116 2, 53 117 }; 118 119 // input signal: pre-computed int16 sine wave, 44100 Hz at 441 Hz 120 static const int16_t sine_int16_44100[] = { 121 0, 2057, 4107, 6140, 8149, 10126, 12062, 13952, 15786, 17557, 122 19260, 20886, 22431, 23886, 25247, 26509, 27666, 28714, 29648, 30466, 123 31163, 31738, 32187, 32509, 32702, 32767, 32702, 32509, 32187, 31738, 124 31163, 30466, 29648, 28714, 27666, 26509, 25247, 23886, 22431, 20886, 125 19260, 17557, 15786, 13952, 12062, 10126, 8149, 6140, 4107, 2057, 126 0, -2057, -4107, -6140, -8149, -10126, -12062, -13952, -15786, -17557, 127 -19260, -20886, -22431, -23886, -25247, -26509, -27666, -28714, -29648, -30466, 128 -31163, -31738, -32187, -32509, -32702, -32767, -32702, -32509, -32187, -31738, 129 -31163, -30466, -29648, -28714, -27666, -26509, -25247, -23886, -22431, -20886, 130 -19260, -17557, -15786, -13952, -12062, -10126, -8149, -6140, -4107, -2057, 131 }; 132 133 static const int num_samples_sine_int16_44100 = sizeof(sine_int16_44100) / 2; 134 135 // input signal: pre-computed int16 sine wave, 48000 Hz at 441 Hz 136 static const int16_t sine_int16_48000[] = { 137 0, 1905, 3804, 5690, 7557, 9398, 11207, 12978, 14706, 16383, 138 18006, 19567, 21062, 22486, 23834, 25101, 26283, 27376, 28377, 29282, 139 30087, 30791, 31390, 31884, 32269, 32545, 32712, 32767, 32712, 32545, 140 32269, 31884, 31390, 30791, 30087, 29282, 28377, 27376, 26283, 25101, 141 23834, 22486, 21062, 19567, 18006, 16383, 14706, 12978, 11207, 9398, 142 7557, 5690, 3804, 1905, 0, -1905, -3804, -5690, -7557, -9398, 143 -11207, -12978, -14706, -16384, -18006, -19567, -21062, -22486, -23834, -25101, 144 -26283, -27376, -28377, -29282, -30087, -30791, -31390, -31884, -32269, -32545, 145 -32712, -32767, -32712, -32545, -32269, -31884, -31390, -30791, -30087, -29282, 146 -28377, -27376, -26283, -25101, -23834, -22486, -21062, -19567, -18006, -16384, 147 -14706, -12978, -11207, -9398, -7557, -5690, -3804, -1905, }; 148 149 static const int num_samples_sine_int16_48000 = sizeof(sine_int16_48000) / 2; 150 151 static const int A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS = 12; 152 153 typedef struct { 154 int reconfigure; 155 156 int num_channels; 157 int sampling_frequency; 158 int block_length; 159 int subbands; 160 int min_bitpool_value; 161 int max_bitpool_value; 162 btstack_sbc_channel_mode_t channel_mode; 163 btstack_sbc_allocation_method_t allocation_method; 164 } media_codec_configuration_sbc_t; 165 166 static btstack_packet_callback_registration_t hci_event_callback_registration; 167 168 // Minijambox: 169 static const char * device_addr_string = "00:21:3C:AC:F7:38"; 170 171 static bd_addr_t device_addr; 172 static bool scan_active; 173 174 static uint8_t sdp_a2dp_source_service_buffer[150]; 175 static uint8_t sdp_avrcp_target_service_buffer[200]; 176 static uint8_t sdp_avrcp_controller_service_buffer[200]; 177 static uint8_t device_id_sdp_service_buffer[100]; 178 179 static media_codec_configuration_sbc_t sbc_configuration; 180 static btstack_sbc_encoder_state_t sbc_encoder_state; 181 182 static uint8_t media_sbc_codec_configuration[4]; 183 static a2dp_media_sending_context_t media_tracker; 184 185 static stream_data_source_t data_source; 186 187 static int sine_phase; 188 static int current_sample_rate = 44100; 189 static int new_sample_rate = 44100; 190 191 static int hxcmod_initialized; 192 static modcontext mod_context; 193 static tracker_buffer_state trkbuf; 194 195 /* AVRCP Target context START */ 196 197 typedef struct { 198 uint8_t track_id[8]; 199 uint32_t song_length_ms; 200 avrcp_playback_status_t status; 201 uint32_t song_position_ms; // 0xFFFFFFFF if not supported 202 } avrcp_play_status_info_t; 203 204 // python -c "print('a'*512)" 205 static const char title[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 206 207 avrcp_track_t tracks[] = { 208 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 1, "Sine", "Generated", "A2DP Source Demo", "monotone", 12345}, 209 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, 2, "Nao-deceased", "Decease", "A2DP Source Demo", "vivid", 12345}, 210 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, 3, (char *)title, "Decease", "A2DP Source Demo", "vivid", 12345}, 211 }; 212 int current_track_index; 213 avrcp_play_status_info_t play_info; 214 215 /* AVRCP Target context END */ 216 217 /* @section Main Application Setup 218 * 219 * @text The Listing MainConfiguration shows how to setup AD2P Source and AVRCP services. 220 * Besides calling init() method for each service, you'll also need to register several packet handlers: 221 * - hci_packet_handler - handles legacy pairing, here by using fixed '0000' pin code. 222 * - a2dp_source_packet_handler - handles events on stream connection status (established, released), the media codec configuration, and, the commands on stream itself (open, pause, stopp). 223 * - avrcp_packet_handler - receives connect/disconnect event. 224 * - avrcp_controller_packet_handler - receives answers for sent AVRCP commands. 225 * - avrcp_target_packet_handler - receives AVRCP commands, and registered notifications. 226 * - stdin_process - used to trigger AVRCP commands to the A2DP Source device, such are get now playing info, start, stop, volume control. Requires HAVE_BTSTACK_STDIN. 227 * 228 * @text To announce A2DP Source and AVRCP services, you need to create corresponding 229 * SDP records and register them with the SDP service. 230 */ 231 232 /* LISTING_START(MainConfiguration): Setup Audio Source and AVRCP Target services */ 233 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 234 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * event, uint16_t event_size); 235 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 236 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 237 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 238 #ifdef HAVE_BTSTACK_STDIN 239 static void stdin_process(char cmd); 240 #endif 241 242 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate); 243 244 static int a2dp_source_and_avrcp_services_init(void){ 245 246 // Request role change on reconnecting headset to always use them in slave mode 247 hci_set_master_slave_policy(0); 248 // enabled EIR 249 hci_set_inquiry_mode(INQUIRY_MODE_RSSI_AND_EIR); 250 251 l2cap_init(); 252 253 #ifdef ENABLE_BLE 254 // Initialize LE Security Manager. Needed for cross-transport key derivation 255 sm_init(); 256 #endif 257 258 // Initialize A2DP Source 259 a2dp_source_init(); 260 a2dp_source_register_packet_handler(&a2dp_source_packet_handler); 261 262 // Create stream endpoint 263 avdtp_stream_endpoint_t * local_stream_endpoint = a2dp_source_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration)); 264 if (!local_stream_endpoint){ 265 printf("A2DP Source: not enough memory to create local stream endpoint\n"); 266 return 1; 267 } 268 269 // Store stream enpoint's SEP ID, as it is used by A2DP API to indentify the stream endpoint 270 media_tracker.local_seid = avdtp_local_seid(local_stream_endpoint); 271 avdtp_source_register_delay_reporting_category(media_tracker.local_seid); 272 273 // Initialize AVRCP Service 274 avrcp_init(); 275 avrcp_register_packet_handler(&avrcp_packet_handler); 276 // Initialize AVRCP Target 277 avrcp_target_init(); 278 avrcp_target_register_packet_handler(&avrcp_target_packet_handler); 279 280 // Initialize AVRCP Controller 281 avrcp_controller_init(); 282 avrcp_controller_register_packet_handler(&avrcp_controller_packet_handler); 283 284 // Initialize SDP, 285 sdp_init(); 286 287 // Create A2DP Source service record and register it with SDP 288 memset(sdp_a2dp_source_service_buffer, 0, sizeof(sdp_a2dp_source_service_buffer)); 289 a2dp_source_create_sdp_record(sdp_a2dp_source_service_buffer, 0x10001, AVDTP_SOURCE_FEATURE_MASK_PLAYER, NULL, NULL); 290 sdp_register_service(sdp_a2dp_source_service_buffer); 291 292 // Create AVRCP Target service record and register it with SDP. We receive Category 1 commands from the headphone, e.g. play/pause 293 memset(sdp_avrcp_target_service_buffer, 0, sizeof(sdp_avrcp_target_service_buffer)); 294 uint16_t supported_features = AVRCP_FEATURE_MASK_CATEGORY_PLAYER_OR_RECORDER; 295 #ifdef AVRCP_BROWSING_ENABLED 296 supported_features |= AVRCP_FEATURE_MASK_BROWSING; 297 #endif 298 avrcp_target_create_sdp_record(sdp_avrcp_target_service_buffer, 0x10002, supported_features, NULL, NULL); 299 sdp_register_service(sdp_avrcp_target_service_buffer); 300 301 // Create AVRCP Controller service record and register it with SDP. We send Category 2 commands to the headphone, e.g. volume up/down 302 memset(sdp_avrcp_controller_service_buffer, 0, sizeof(sdp_avrcp_controller_service_buffer)); 303 uint16_t controller_supported_features = AVRCP_FEATURE_MASK_CATEGORY_MONITOR_OR_AMPLIFIER; 304 avrcp_controller_create_sdp_record(sdp_avrcp_controller_service_buffer, 0x10003, controller_supported_features, NULL, NULL); 305 sdp_register_service(sdp_avrcp_controller_service_buffer); 306 307 // Register Device ID (PnP) service SDP record 308 memset(device_id_sdp_service_buffer, 0, sizeof(device_id_sdp_service_buffer)); 309 device_id_create_sdp_record(device_id_sdp_service_buffer, 0x10004, DEVICE_ID_VENDOR_ID_SOURCE_BLUETOOTH, BLUETOOTH_COMPANY_ID_BLUEKITCHEN_GMBH, 1, 1); 310 sdp_register_service(device_id_sdp_service_buffer); 311 312 // Set local name with a template Bluetooth address, that will be automatically 313 // replaced with a actual address once it is available, i.e. when BTstack boots 314 // up and starts talking to a Bluetooth module. 315 gap_set_local_name("A2DP Source 00:00:00:00:00:00"); 316 gap_discoverable_control(1); 317 gap_set_class_of_device(0x200408); 318 319 // Register for HCI events. 320 hci_event_callback_registration.callback = &hci_packet_handler; 321 hci_add_event_handler(&hci_event_callback_registration); 322 323 a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate); 324 data_source = STREAM_MOD; 325 326 // Parse human readable Bluetooth address. 327 sscanf_bd_addr(device_addr_string, device_addr); 328 329 #ifdef HAVE_BTSTACK_STDIN 330 btstack_stdin_setup(stdin_process); 331 #endif 332 return 0; 333 } 334 /* LISTING_END */ 335 336 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate){ 337 if (!hxcmod_initialized){ 338 hxcmod_initialized = hxcmod_init(&mod_context); 339 if (!hxcmod_initialized) { 340 printf("could not initialize hxcmod\n"); 341 return; 342 } 343 } 344 current_sample_rate = sample_rate; 345 media_tracker.sbc_storage_count = 0; 346 media_tracker.samples_ready = 0; 347 hxcmod_unload(&mod_context); 348 hxcmod_setcfg(&mod_context, current_sample_rate, 16, 1, 1, 1); 349 hxcmod_load(&mod_context, (void *) &mod_data, mod_len); 350 } 351 352 static void a2dp_demo_send_media_packet(void){ 353 int num_bytes_in_frame = btstack_sbc_encoder_sbc_buffer_length(); 354 int bytes_in_storage = media_tracker.sbc_storage_count; 355 uint8_t num_sbc_frames = bytes_in_storage / num_bytes_in_frame; 356 // Prepend SBC Header 357 media_tracker.sbc_storage[0] = num_sbc_frames; // (fragmentation << 7) | (starting_packet << 6) | (last_packet << 5) | num_frames; 358 a2dp_source_stream_send_media_payload_rtp(media_tracker.a2dp_cid, media_tracker.local_seid, 0, 359 media_tracker.rtp_timestamp, 360 media_tracker.sbc_storage, bytes_in_storage + 1); 361 362 // update rtp_timestamp 363 unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames(); 364 media_tracker.rtp_timestamp += num_sbc_frames * num_audio_samples_per_sbc_buffer; 365 366 media_tracker.sbc_storage_count = 0; 367 media_tracker.sbc_ready_to_send = 0; 368 } 369 370 static void produce_sine_audio(int16_t * pcm_buffer, int num_samples_to_write){ 371 int count; 372 for (count = 0; count < num_samples_to_write ; count++){ 373 switch (current_sample_rate){ 374 case 44100: 375 pcm_buffer[count * 2] = sine_int16_44100[sine_phase]; 376 pcm_buffer[count * 2 + 1] = sine_int16_44100[sine_phase]; 377 sine_phase++; 378 if (sine_phase >= num_samples_sine_int16_44100){ 379 sine_phase -= num_samples_sine_int16_44100; 380 } 381 break; 382 case 48000: 383 pcm_buffer[count * 2] = sine_int16_48000[sine_phase]; 384 pcm_buffer[count * 2 + 1] = sine_int16_48000[sine_phase]; 385 sine_phase++; 386 if (sine_phase >= num_samples_sine_int16_48000){ 387 sine_phase -= num_samples_sine_int16_48000; 388 } 389 break; 390 default: 391 break; 392 } 393 } 394 } 395 396 static void produce_mod_audio(int16_t * pcm_buffer, int num_samples_to_write){ 397 hxcmod_fillbuffer(&mod_context, (unsigned short *) &pcm_buffer[0], num_samples_to_write, &trkbuf); 398 } 399 400 static void produce_audio(int16_t * pcm_buffer, int num_samples){ 401 switch (data_source){ 402 case STREAM_SINE: 403 produce_sine_audio(pcm_buffer, num_samples); 404 break; 405 case STREAM_MOD: 406 produce_mod_audio(pcm_buffer, num_samples); 407 break; 408 default: 409 break; 410 } 411 #ifdef VOLUME_REDUCTION 412 int i; 413 for (i=0;i<num_samples*2;i++){ 414 if (pcm_buffer[i] > 0){ 415 pcm_buffer[i] = pcm_buffer[i] >> VOLUME_REDUCTION; 416 } else { 417 pcm_buffer[i] = -((-pcm_buffer[i]) >> VOLUME_REDUCTION); 418 } 419 } 420 #endif 421 } 422 423 static int a2dp_demo_fill_sbc_audio_buffer(a2dp_media_sending_context_t * context){ 424 // perform sbc encoding 425 int total_num_bytes_read = 0; 426 unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames(); 427 while (context->samples_ready >= num_audio_samples_per_sbc_buffer 428 && (context->max_media_payload_size - context->sbc_storage_count) >= btstack_sbc_encoder_sbc_buffer_length()){ 429 430 int16_t pcm_frame[256*NUM_CHANNELS]; 431 432 produce_audio(pcm_frame, num_audio_samples_per_sbc_buffer); 433 btstack_sbc_encoder_process_data(pcm_frame); 434 435 uint16_t sbc_frame_size = btstack_sbc_encoder_sbc_buffer_length(); 436 uint8_t * sbc_frame = btstack_sbc_encoder_sbc_buffer(); 437 438 total_num_bytes_read += num_audio_samples_per_sbc_buffer; 439 // first byte in sbc storage contains sbc media header 440 memcpy(&context->sbc_storage[1 + context->sbc_storage_count], sbc_frame, sbc_frame_size); 441 context->sbc_storage_count += sbc_frame_size; 442 context->samples_ready -= num_audio_samples_per_sbc_buffer; 443 } 444 return total_num_bytes_read; 445 } 446 447 static void a2dp_demo_audio_timeout_handler(btstack_timer_source_t * timer){ 448 a2dp_media_sending_context_t * context = (a2dp_media_sending_context_t *) btstack_run_loop_get_timer_context(timer); 449 btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS); 450 btstack_run_loop_add_timer(&context->audio_timer); 451 uint32_t now = btstack_run_loop_get_time_ms(); 452 453 uint32_t update_period_ms = AUDIO_TIMEOUT_MS; 454 if (context->time_audio_data_sent > 0){ 455 update_period_ms = now - context->time_audio_data_sent; 456 } 457 458 uint32_t num_samples = (update_period_ms * current_sample_rate) / 1000; 459 context->acc_num_missed_samples += (update_period_ms * current_sample_rate) % 1000; 460 461 while (context->acc_num_missed_samples >= 1000){ 462 num_samples++; 463 context->acc_num_missed_samples -= 1000; 464 } 465 context->time_audio_data_sent = now; 466 context->samples_ready += num_samples; 467 468 if (context->sbc_ready_to_send) return; 469 470 a2dp_demo_fill_sbc_audio_buffer(context); 471 472 if ((context->sbc_storage_count + btstack_sbc_encoder_sbc_buffer_length()) > context->max_media_payload_size){ 473 // schedule sending 474 context->sbc_ready_to_send = 1; 475 a2dp_source_stream_endpoint_request_can_send_now(context->a2dp_cid, context->local_seid); 476 } 477 } 478 479 static void a2dp_demo_timer_start(a2dp_media_sending_context_t * context){ 480 context->max_media_payload_size = btstack_min(a2dp_max_media_payload_size(context->a2dp_cid, context->local_seid), SBC_STORAGE_SIZE); 481 context->sbc_storage_count = 0; 482 context->sbc_ready_to_send = 0; 483 context->streaming = 1; 484 btstack_run_loop_remove_timer(&context->audio_timer); 485 btstack_run_loop_set_timer_handler(&context->audio_timer, a2dp_demo_audio_timeout_handler); 486 btstack_run_loop_set_timer_context(&context->audio_timer, context); 487 btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS); 488 btstack_run_loop_add_timer(&context->audio_timer); 489 } 490 491 static void a2dp_demo_timer_stop(a2dp_media_sending_context_t * context){ 492 context->time_audio_data_sent = 0; 493 context->acc_num_missed_samples = 0; 494 context->samples_ready = 0; 495 context->streaming = 1; 496 context->sbc_storage_count = 0; 497 context->sbc_ready_to_send = 0; 498 btstack_run_loop_remove_timer(&context->audio_timer); 499 } 500 501 static void dump_sbc_configuration(media_codec_configuration_sbc_t * configuration){ 502 printf("Received media codec configuration:\n"); 503 printf(" - num_channels: %d\n", configuration->num_channels); 504 printf(" - sampling_frequency: %d\n", configuration->sampling_frequency); 505 printf(" - channel_mode: %d\n", configuration->channel_mode); 506 printf(" - block_length: %d\n", configuration->block_length); 507 printf(" - subbands: %d\n", configuration->subbands); 508 printf(" - allocation_method: %d\n", configuration->allocation_method); 509 printf(" - bitpool_value [%d, %d] \n", configuration->min_bitpool_value, configuration->max_bitpool_value); 510 } 511 512 static void a2dp_source_demo_start_scanning(void){ 513 printf("Start scanning...\n"); 514 gap_inquiry_start(A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS); 515 scan_active = true; 516 } 517 518 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 519 UNUSED(channel); 520 UNUSED(size); 521 if (packet_type != HCI_EVENT_PACKET) return; 522 uint8_t status; 523 UNUSED(status); 524 525 bd_addr_t address; 526 uint32_t cod; 527 528 // Service Class: Rendering | Audio, Major Device Class: Audio 529 const uint32_t bluetooth_speaker_cod = 0x200000 | 0x040000 | 0x000400; 530 531 switch (hci_event_packet_get_type(packet)){ 532 #ifndef HAVE_BTSTACK_STDIN 533 case BTSTACK_EVENT_STATE: 534 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) return; 535 a2dp_source_demo_start_scanning(); 536 break; 537 #endif 538 case HCI_EVENT_PIN_CODE_REQUEST: 539 printf("Pin code request - using '0000'\n"); 540 hci_event_pin_code_request_get_bd_addr(packet, address); 541 gap_pin_code_response(address, "0000"); 542 break; 543 case GAP_EVENT_INQUIRY_RESULT: 544 gap_event_inquiry_result_get_bd_addr(packet, address); 545 // print info 546 printf("Device found: %s ", bd_addr_to_str(address)); 547 cod = gap_event_inquiry_result_get_class_of_device(packet); 548 printf("with COD: %06" PRIx32, cod); 549 if (gap_event_inquiry_result_get_rssi_available(packet)){ 550 printf(", rssi %d dBm", (int8_t) gap_event_inquiry_result_get_rssi(packet)); 551 } 552 if (gap_event_inquiry_result_get_name_available(packet)){ 553 char name_buffer[240]; 554 int name_len = gap_event_inquiry_result_get_name_len(packet); 555 memcpy(name_buffer, gap_event_inquiry_result_get_name(packet), name_len); 556 name_buffer[name_len] = 0; 557 printf(", name '%s'", name_buffer); 558 } 559 printf("\n"); 560 if ((cod & bluetooth_speaker_cod) == bluetooth_speaker_cod){ 561 memcpy(device_addr, address, 6); 562 printf("Bluetooth speaker detected, trying to connect to %s...\n", bd_addr_to_str(device_addr)); 563 scan_active = false; 564 gap_inquiry_stop(); 565 a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid); 566 } 567 break; 568 case GAP_EVENT_INQUIRY_COMPLETE: 569 if (scan_active){ 570 printf("No Bluetooth speakers found, scanning again...\n"); 571 gap_inquiry_start(A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS); 572 } 573 break; 574 default: 575 break; 576 } 577 } 578 579 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 580 UNUSED(channel); 581 UNUSED(size); 582 uint8_t status; 583 uint8_t local_seid; 584 bd_addr_t address; 585 uint16_t cid; 586 587 avdtp_channel_mode_t channel_mode; 588 uint8_t allocation_method; 589 590 if (packet_type != HCI_EVENT_PACKET) return; 591 if (hci_event_packet_get_type(packet) != HCI_EVENT_A2DP_META) return; 592 593 switch (hci_event_a2dp_meta_get_subevent_code(packet)){ 594 case A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED: 595 a2dp_subevent_signaling_connection_established_get_bd_addr(packet, address); 596 cid = a2dp_subevent_signaling_connection_established_get_a2dp_cid(packet); 597 status = a2dp_subevent_signaling_connection_established_get_status(packet); 598 599 if (status != ERROR_CODE_SUCCESS){ 600 printf("A2DP Source: Connection failed, status 0x%02x, cid 0x%02x, a2dp_cid 0x%02x \n", status, cid, media_tracker.a2dp_cid); 601 media_tracker.a2dp_cid = 0; 602 break; 603 } 604 media_tracker.a2dp_cid = cid; 605 media_tracker.volume = 32; 606 607 printf("A2DP Source: Connected to address %s, a2dp cid 0x%02x, local seid 0x%02x.\n", bd_addr_to_str(address), media_tracker.a2dp_cid, media_tracker.local_seid); 608 break; 609 610 case A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION:{ 611 cid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(packet); 612 if (cid != media_tracker.a2dp_cid) return; 613 614 media_tracker.remote_seid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet); 615 616 sbc_configuration.reconfigure = a2dp_subevent_signaling_media_codec_sbc_configuration_get_reconfigure(packet); 617 sbc_configuration.num_channels = a2dp_subevent_signaling_media_codec_sbc_configuration_get_num_channels(packet); 618 sbc_configuration.sampling_frequency = a2dp_subevent_signaling_media_codec_sbc_configuration_get_sampling_frequency(packet); 619 sbc_configuration.block_length = a2dp_subevent_signaling_media_codec_sbc_configuration_get_block_length(packet); 620 sbc_configuration.subbands = a2dp_subevent_signaling_media_codec_sbc_configuration_get_subbands(packet); 621 sbc_configuration.min_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_min_bitpool_value(packet); 622 sbc_configuration.max_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_max_bitpool_value(packet); 623 624 channel_mode = (avdtp_channel_mode_t) a2dp_subevent_signaling_media_codec_sbc_configuration_get_channel_mode(packet); 625 allocation_method = a2dp_subevent_signaling_media_codec_sbc_configuration_get_allocation_method(packet); 626 627 printf("A2DP Source: Received SBC codec configuration, sampling frequency %u, a2dp_cid 0x%02x, local seid 0x%02x, remote seid 0x%02x.\n", 628 sbc_configuration.sampling_frequency, cid, 629 a2dp_subevent_signaling_media_codec_sbc_configuration_get_local_seid(packet), 630 a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet)); 631 632 // Adapt Bluetooth spec definition to SBC Encoder expected input 633 sbc_configuration.allocation_method = (btstack_sbc_allocation_method_t)(allocation_method - 1); 634 switch (channel_mode){ 635 case AVDTP_CHANNEL_MODE_JOINT_STEREO: 636 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO; 637 break; 638 case AVDTP_CHANNEL_MODE_STEREO: 639 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_STEREO; 640 break; 641 case AVDTP_CHANNEL_MODE_DUAL_CHANNEL: 642 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL; 643 break; 644 case AVDTP_CHANNEL_MODE_MONO: 645 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_MONO; 646 break; 647 default: 648 btstack_assert(false); 649 break; 650 } 651 dump_sbc_configuration(&sbc_configuration); 652 653 btstack_sbc_encoder_init(&sbc_encoder_state, SBC_MODE_STANDARD, 654 sbc_configuration.block_length, sbc_configuration.subbands, 655 sbc_configuration.allocation_method, sbc_configuration.sampling_frequency, 656 sbc_configuration.max_bitpool_value, 657 sbc_configuration.channel_mode); 658 break; 659 } 660 661 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY: 662 printf("A2DP Source: remote supports delay report, remote seid %d\n", 663 avdtp_subevent_signaling_delay_reporting_capability_get_remote_seid(packet)); 664 break; 665 case A2DP_SUBEVENT_SIGNALING_CAPABILITIES_DONE: 666 printf("A2DP Source: All capabilities reported, remote seid %d\n", 667 avdtp_subevent_signaling_capabilities_done_get_remote_seid(packet)); 668 break; 669 670 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORT: 671 printf("A2DP Source: Received delay report of %d.%0d ms, local seid %d\n", 672 avdtp_subevent_signaling_delay_report_get_delay_100us(packet)/10, avdtp_subevent_signaling_delay_report_get_delay_100us(packet)%10, 673 avdtp_subevent_signaling_delay_report_get_local_seid(packet)); 674 break; 675 676 case A2DP_SUBEVENT_STREAM_ESTABLISHED: 677 a2dp_subevent_stream_established_get_bd_addr(packet, address); 678 status = a2dp_subevent_stream_established_get_status(packet); 679 if (status != ERROR_CODE_SUCCESS){ 680 printf("A2DP Source: Stream failed, status 0x%02x.\n", status); 681 break; 682 } 683 684 local_seid = a2dp_subevent_stream_established_get_local_seid(packet); 685 cid = a2dp_subevent_stream_established_get_a2dp_cid(packet); 686 687 printf("A2DP Source: Stream established a2dp_cid 0x%02x, local_seid 0x%02x, remote_seid 0x%02x\n", cid, local_seid, a2dp_subevent_stream_established_get_remote_seid(packet)); 688 689 a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate); 690 media_tracker.stream_opened = 1; 691 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 692 break; 693 694 case A2DP_SUBEVENT_STREAM_RECONFIGURED: 695 status = a2dp_subevent_stream_reconfigured_get_status(packet); 696 local_seid = a2dp_subevent_stream_reconfigured_get_local_seid(packet); 697 cid = a2dp_subevent_stream_reconfigured_get_a2dp_cid(packet); 698 699 if (status != ERROR_CODE_SUCCESS){ 700 printf("A2DP Source: Stream reconfiguration failed, status 0x%02x\n", status); 701 break; 702 } 703 704 printf("A2DP Source: Stream reconfigured a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 705 a2dp_demo_hexcmod_configure_sample_rate(new_sample_rate); 706 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 707 break; 708 709 case A2DP_SUBEVENT_STREAM_STARTED: 710 local_seid = a2dp_subevent_stream_started_get_local_seid(packet); 711 cid = a2dp_subevent_stream_started_get_a2dp_cid(packet); 712 713 play_info.status = AVRCP_PLAYBACK_STATUS_PLAYING; 714 if (media_tracker.avrcp_cid){ 715 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 716 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PLAYING); 717 } 718 a2dp_demo_timer_start(&media_tracker); 719 printf("A2DP Source: Stream started, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 720 break; 721 722 case A2DP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW: 723 local_seid = a2dp_subevent_streaming_can_send_media_packet_now_get_local_seid(packet); 724 cid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_a2dp_cid(packet); 725 a2dp_demo_send_media_packet(); 726 break; 727 728 case A2DP_SUBEVENT_STREAM_SUSPENDED: 729 local_seid = a2dp_subevent_stream_suspended_get_local_seid(packet); 730 cid = a2dp_subevent_stream_suspended_get_a2dp_cid(packet); 731 732 play_info.status = AVRCP_PLAYBACK_STATUS_PAUSED; 733 if (media_tracker.avrcp_cid){ 734 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PAUSED); 735 } 736 printf("A2DP Source: Stream paused, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 737 738 a2dp_demo_timer_stop(&media_tracker); 739 break; 740 741 case A2DP_SUBEVENT_STREAM_RELEASED: 742 play_info.status = AVRCP_PLAYBACK_STATUS_STOPPED; 743 cid = a2dp_subevent_stream_released_get_a2dp_cid(packet); 744 local_seid = a2dp_subevent_stream_released_get_local_seid(packet); 745 746 printf("A2DP Source: Stream released, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 747 748 if (cid == media_tracker.a2dp_cid) { 749 media_tracker.stream_opened = 0; 750 printf("A2DP Source: Stream released.\n"); 751 } 752 if (media_tracker.avrcp_cid){ 753 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 754 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_STOPPED); 755 } 756 a2dp_demo_timer_stop(&media_tracker); 757 break; 758 case A2DP_SUBEVENT_SIGNALING_CONNECTION_RELEASED: 759 cid = a2dp_subevent_signaling_connection_released_get_a2dp_cid(packet); 760 if (cid == media_tracker.a2dp_cid) { 761 media_tracker.avrcp_cid = 0; 762 media_tracker.a2dp_cid = 0; 763 printf("A2DP Source: Signaling released.\n\n"); 764 } 765 break; 766 default: 767 break; 768 } 769 } 770 771 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 772 UNUSED(channel); 773 UNUSED(size); 774 bd_addr_t event_addr; 775 uint16_t local_cid; 776 uint8_t status = ERROR_CODE_SUCCESS; 777 778 if (packet_type != HCI_EVENT_PACKET) return; 779 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 780 781 switch (packet[2]){ 782 case AVRCP_SUBEVENT_CONNECTION_ESTABLISHED: 783 local_cid = avrcp_subevent_connection_established_get_avrcp_cid(packet); 784 status = avrcp_subevent_connection_established_get_status(packet); 785 if (status != ERROR_CODE_SUCCESS){ 786 printf("AVRCP: Connection failed, local cid 0x%02x, status 0x%02x\n", local_cid, status); 787 return; 788 } 789 media_tracker.avrcp_cid = local_cid; 790 avrcp_subevent_connection_established_get_bd_addr(packet, event_addr); 791 792 printf("AVRCP: Channel to %s successfully opened, avrcp_cid 0x%02x\n", bd_addr_to_str(event_addr), media_tracker.avrcp_cid); 793 794 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED); 795 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED); 796 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED); 797 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 798 799 printf("Enable Volume Change notification\n"); 800 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED); 801 printf("Enable Battery Status Change notification\n"); 802 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED); 803 return; 804 805 case AVRCP_SUBEVENT_CONNECTION_RELEASED: 806 printf("AVRCP Target: Disconnected, avrcp_cid 0x%02x\n", avrcp_subevent_connection_released_get_avrcp_cid(packet)); 807 media_tracker.avrcp_cid = 0; 808 return; 809 default: 810 break; 811 } 812 813 if (status != ERROR_CODE_SUCCESS){ 814 printf("Responding to event 0x%02x failed, status 0x%02x\n", packet[2], status); 815 } 816 } 817 818 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 819 UNUSED(channel); 820 UNUSED(size); 821 uint8_t status = ERROR_CODE_SUCCESS; 822 823 if (packet_type != HCI_EVENT_PACKET) return; 824 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 825 826 bool button_pressed; 827 char const * button_state; 828 avrcp_operation_id_t operation_id; 829 830 switch (packet[2]){ 831 case AVRCP_SUBEVENT_PLAY_STATUS_QUERY: 832 status = avrcp_target_play_status(media_tracker.avrcp_cid, play_info.song_length_ms, play_info.song_position_ms, play_info.status); 833 break; 834 // case AVRCP_SUBEVENT_NOW_PLAYING_INFO_QUERY: 835 // status = avrcp_target_now_playing_info(avrcp_cid); 836 // break; 837 case AVRCP_SUBEVENT_OPERATION: 838 operation_id = avrcp_subevent_operation_get_operation_id(packet); 839 button_pressed = avrcp_subevent_operation_get_button_pressed(packet) > 0; 840 button_state = button_pressed ? "PRESS" : "RELEASE"; 841 842 printf("AVRCP Target: operation %s (%s)\n", avrcp_operation2str(operation_id), button_state); 843 844 if (!button_pressed){ 845 break; 846 } 847 switch (operation_id) { 848 case AVRCP_OPERATION_ID_PLAY: 849 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 850 break; 851 case AVRCP_OPERATION_ID_PAUSE: 852 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 853 break; 854 case AVRCP_OPERATION_ID_STOP: 855 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 856 break; 857 default: 858 break; 859 } 860 break; 861 default: 862 break; 863 } 864 865 if (status != ERROR_CODE_SUCCESS){ 866 printf("Responding to event 0x%02x failed, status 0x%02x\n", packet[2], status); 867 } 868 } 869 870 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 871 UNUSED(channel); 872 UNUSED(size); 873 874 if (packet_type != HCI_EVENT_PACKET) return; 875 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 876 if (!media_tracker.avrcp_cid) return; 877 878 switch (packet[2]){ 879 case AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED: 880 printf("AVRCP Controller: Notification Absolute Volume %d %%\n", avrcp_subevent_notification_volume_changed_get_absolute_volume(packet) * 100 / 127); 881 break; 882 case AVRCP_SUBEVENT_NOTIFICATION_EVENT_BATT_STATUS_CHANGED: 883 // see avrcp_battery_status_t 884 printf("AVRCP Controller: Notification Battery Status 0x%02x\n", avrcp_subevent_notification_event_batt_status_changed_get_battery_status(packet)); 885 break; 886 case AVRCP_SUBEVENT_NOTIFICATION_STATE: 887 printf("AVRCP Controller: Notification %s - %s\n", 888 avrcp_event2str(avrcp_subevent_notification_state_get_event_id(packet)), 889 avrcp_subevent_notification_state_get_enabled(packet) != 0 ? "enabled" : "disabled"); 890 break; 891 default: 892 break; 893 } 894 } 895 896 #ifdef HAVE_BTSTACK_STDIN 897 static void show_usage(void){ 898 bd_addr_t iut_address; 899 gap_local_bd_addr(iut_address); 900 printf("\n--- Bluetooth A2DP Source/AVRCP Demo %s ---\n", bd_addr_to_str(iut_address)); 901 printf("a - Scan for Bluetooth speaker and connect\n"); 902 printf("b - A2DP Source create connection to addr %s\n", device_addr_string); 903 printf("B - A2DP Source disconnect\n"); 904 printf("c - AVRCP create connection to addr %s\n", device_addr_string); 905 printf("C - AVRCP disconnect\n"); 906 printf("D - delete all link keys\n"); 907 908 printf("x - start streaming sine\n"); 909 if (hxcmod_initialized){ 910 printf("z - start streaming '%s'\n", mod_name); 911 } 912 printf("p - pause streaming\n"); 913 printf("w - reconfigure stream for 44100 Hz\n"); 914 printf("e - reconfigure stream for 48000 Hz\n"); 915 printf("t - volume up\n"); 916 printf("T - volume down\n"); 917 printf("v - volume up (via set absolute volume)\n"); 918 printf("V - volume down (via set absolute volume)\n"); 919 920 printf("---\n"); 921 } 922 923 static void stdin_process(char cmd){ 924 uint8_t status = ERROR_CODE_SUCCESS; 925 switch (cmd){ 926 case 'a': 927 a2dp_source_demo_start_scanning(); 928 break; 929 case 'b': 930 status = a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid); 931 printf("%c - Create A2DP Source connection to addr %s, cid 0x%02x.\n", cmd, bd_addr_to_str(device_addr), media_tracker.a2dp_cid); 932 break; 933 case 'B': 934 printf("%c - A2DP Source Disconnect from cid 0x%2x\n", cmd, media_tracker.a2dp_cid); 935 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 936 break; 937 case 'c': 938 printf("%c - Create AVRCP connection to addr %s.\n", cmd, bd_addr_to_str(device_addr)); 939 status = avrcp_connect(device_addr, &media_tracker.avrcp_cid); 940 break; 941 case 'C': 942 printf("%c - AVRCP disconnect\n", cmd); 943 status = avrcp_disconnect(media_tracker.avrcp_cid); 944 break; 945 case 'D': 946 printf("Deleting all link keys\n"); 947 gap_delete_all_link_keys(); 948 break; 949 case '\n': 950 case '\r': 951 break; 952 953 case 't': 954 printf(" - volume up\n"); 955 status = avrcp_controller_volume_up(media_tracker.avrcp_cid); 956 break; 957 case 'T': 958 printf(" - volume down\n"); 959 status = avrcp_controller_volume_down(media_tracker.avrcp_cid); 960 break; 961 962 case 'v': 963 if (media_tracker.volume > 117){ 964 media_tracker.volume = 127; 965 } else { 966 media_tracker.volume += 10; 967 } 968 printf(" - volume up (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 100 / 127, media_tracker.volume); 969 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 970 break; 971 case 'V': 972 if (media_tracker.volume < 10){ 973 media_tracker.volume = 0; 974 } else { 975 media_tracker.volume -= 10; 976 } 977 printf(" - volume down (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 100 / 127, media_tracker.volume); 978 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 979 break; 980 981 case 'x': 982 if (media_tracker.avrcp_cid){ 983 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 984 } 985 printf("%c - Play sine.\n", cmd); 986 data_source = STREAM_SINE; 987 if (!media_tracker.stream_opened) break; 988 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 989 break; 990 case 'z': 991 if (media_tracker.avrcp_cid){ 992 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 993 } 994 printf("%c - Play mod.\n", cmd); 995 data_source = STREAM_MOD; 996 if (!media_tracker.stream_opened) break; 997 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 998 break; 999 1000 case 'p': 1001 if (!media_tracker.stream_opened) break; 1002 printf("%c - Pause stream.\n", cmd); 1003 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 1004 break; 1005 1006 case 'w': 1007 if (!media_tracker.stream_opened) break; 1008 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 1009 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 1010 break; 1011 } 1012 new_sample_rate = 44100; 1013 if (current_sample_rate == new_sample_rate){ 1014 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate); 1015 } else { 1016 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate); 1017 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate); 1018 } 1019 break; 1020 1021 case 'e': 1022 if (!media_tracker.stream_opened) break; 1023 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 1024 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 1025 break; 1026 } 1027 new_sample_rate = 48000; 1028 if (current_sample_rate == new_sample_rate){ 1029 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate); 1030 } else { 1031 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate); 1032 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate); 1033 } 1034 break; 1035 1036 default: 1037 show_usage(); 1038 return; 1039 } 1040 if (status != ERROR_CODE_SUCCESS){ 1041 printf("Could not perform command \'%c\', status 0x%02x\n", cmd, status); 1042 } 1043 } 1044 #endif 1045 1046 1047 int btstack_main(int argc, const char * argv[]); 1048 int btstack_main(int argc, const char * argv[]){ 1049 (void)argc; 1050 (void)argv; 1051 1052 int err = a2dp_source_and_avrcp_services_init(); 1053 if (err) return err; 1054 // turn on! 1055 hci_power_control(HCI_POWER_ON); 1056 return 0; 1057 } 1058 /* EXAMPLE_END */ 1059