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