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 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__ "a2dp_source_demo.c" 39 40 /* 41 * a2dp_source_demo.c 42 */ 43 44 // ***************************************************************************** 45 /* EXAMPLE_START(a2dp_source_demo): Serve audio stream and handle remote playback control and queries. 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 <stdlib.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 // #undef HAVE_BTSTACK_STDIN 76 77 //#define AVRCP_BROWSING_ENABLED 78 79 #define NUM_CHANNELS 2 80 #define BYTES_PER_AUDIO_SAMPLE (2*NUM_CHANNELS) 81 #define AUDIO_TIMEOUT_MS 10 82 #define TABLE_SIZE_441HZ 100 83 84 #define SBC_STORAGE_SIZE 1030 85 86 typedef enum { 87 STREAM_SINE = 0, 88 STREAM_MOD, 89 STREAM_PTS_TEST 90 } stream_data_source_t; 91 92 typedef struct { 93 uint16_t a2dp_cid; 94 uint8_t local_seid; 95 uint8_t remote_seid; 96 uint8_t stream_opened; 97 uint16_t avrcp_cid; 98 99 uint32_t time_audio_data_sent; // ms 100 uint32_t acc_num_missed_samples; 101 uint32_t samples_ready; 102 btstack_timer_source_t audio_timer; 103 uint8_t streaming; 104 int max_media_payload_size; 105 106 uint8_t sbc_storage[SBC_STORAGE_SIZE]; 107 uint16_t sbc_storage_count; 108 uint8_t sbc_ready_to_send; 109 110 uint16_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 typedef struct { 152 int reconfigure; 153 int num_channels; 154 int sampling_frequency; 155 int channel_mode; 156 int block_length; 157 int subbands; 158 int allocation_method; 159 int min_bitpool_value; 160 int max_bitpool_value; 161 int frames_per_buffer; 162 } avdtp_media_codec_configuration_sbc_t; 163 164 static btstack_packet_callback_registration_t hci_event_callback_registration; 165 166 // pts: static const char * device_addr_string = "00:1B:DC:08:0A:A5"; 167 // pts: static const char * device_addr_string = "00:1B:DC:08:E2:72"; 168 // mac 2013: static const char * device_addr_string = "84:38:35:65:d1:15"; 169 // phone 2013: static const char * device_addr_string = "D8:BB:2C:DF:F0:F2"; 170 // Minijambox: 171 static const char * device_addr_string = "00:21:3C:AC:F7:38"; 172 // Philips SHB9100: static const char * device_addr_string = "00:22:37:05:FD:E8"; 173 // RT-B6: static const char * device_addr_string = "00:75:58:FF:C9:7D"; 174 // BT dongle: static const char * device_addr_string = "00:1A:7D:DA:71:0A"; 175 // Sony MDR-ZX330BT static const char * device_addr_string = "00:18:09:28:50:18"; 176 // Panda (BM6) static const char * device_addr_string = "4F:3F:66:52:8B:E0"; 177 // BeatsX: static const char * device_addr_string = "DC:D3:A2:89:57:FB"; 178 static bd_addr_t device_addr; 179 180 static uint8_t sdp_a2dp_source_service_buffer[150]; 181 static uint8_t sdp_avrcp_target_service_buffer[200]; 182 static uint8_t sdp_avrcp_controller_service_buffer[200]; 183 184 static avdtp_media_codec_configuration_sbc_t sbc_configuration; 185 static btstack_sbc_encoder_state_t sbc_encoder_state; 186 187 static uint8_t media_sbc_codec_configuration[4]; 188 static a2dp_media_sending_context_t media_tracker; 189 190 static stream_data_source_t data_source; 191 192 static int sine_phase; 193 static int sample_rate = 44100; 194 195 static int hxcmod_initialized; 196 static modcontext mod_context; 197 static tracker_buffer_state trkbuf; 198 199 /* AVRCP Target context START */ 200 static const uint8_t subunit_info[] = { 201 0,0,0,0, 202 1,1,1,1, 203 2,2,2,2, 204 3,3,3,3, 205 4,4,4,4, 206 5,5,5,5, 207 6,6,6,6, 208 7,7,7,7 209 }; 210 211 static uint32_t company_id = 0x112233; 212 static uint8_t companies_num = 1; 213 static uint8_t companies[] = { 214 0x00, 0x19, 0x58 //BT SIG registered CompanyID 215 }; 216 217 static uint8_t events_num = 6; 218 static uint8_t events[] = { 219 AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED, 220 AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED, 221 AVRCP_NOTIFICATION_EVENT_PLAYER_APPLICATION_SETTING_CHANGED, 222 AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED, 223 AVRCP_NOTIFICATION_EVENT_AVAILABLE_PLAYERS_CHANGED, 224 AVRCP_NOTIFICATION_EVENT_ADDRESSED_PLAYER_CHANGED 225 }; 226 227 typedef struct { 228 uint8_t track_id[8]; 229 uint32_t song_length_ms; 230 avrcp_playback_status_t status; 231 uint32_t song_position_ms; // 0xFFFFFFFF if not supported 232 } avrcp_play_status_info_t; 233 234 // python -c "print('a'*512)" 235 static const char title[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 236 237 avrcp_track_t tracks[] = { 238 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 1, "Sine", "Generated", "A2DP Source Demo", "monotone", 12345}, 239 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, 2, "Nao-deceased", "Decease", "A2DP Source Demo", "vivid", 12345}, 240 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, 3, (char *)title, "Decease", "A2DP Source Demo", "vivid", 12345}, 241 }; 242 int current_track_index; 243 avrcp_play_status_info_t play_info; 244 245 /* AVRCP Target context END */ 246 247 /* @section Main Application Setup 248 * 249 * @text The Listing MainConfiguration shows how to setup AD2P Source and AVRCP services. 250 * Besides calling init() method for each service, you'll also need to register several packet handlers: 251 * - hci_packet_handler - handles legacy pairing, here by using fixed '0000' pin code. 252 * - 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). 253 * - avrcp_packet_handler - receives connect/disconnect event. 254 * - avrcp_controller_packet_handler - receives answers for sent AVRCP commands. 255 * - avrcp_target_packet_handler - receives AVRCP commands, and registered notifications. 256 * - 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. 257 * 258 * @text To announce A2DP Source and AVRCP services, you need to create corresponding 259 * SDP records and register them with the SDP service. 260 */ 261 262 /* LISTING_START(MainConfiguration): Setup Audio Source and AVRCP Target services */ 263 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 264 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * event, uint16_t event_size); 265 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 266 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 267 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 268 #ifdef HAVE_BTSTACK_STDIN 269 static void stdin_process(char cmd); 270 #endif 271 272 static void a2dp_demo_reconfigure_sample_rate(int new_sample_rate); 273 274 static int a2dp_source_and_avrcp_services_init(void){ 275 // request role change on reconnecting headset to always use them in slave mode 276 hci_set_master_slave_policy(0); 277 278 l2cap_init(); 279 // Initialize A2DP Source. 280 a2dp_source_init(); 281 a2dp_source_register_packet_handler(&a2dp_source_packet_handler); 282 283 // Create stream endpoint. 284 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)); 285 if (!local_stream_endpoint){ 286 printf("A2DP Source: not enough memory to create local stream endpoint\n"); 287 return 1; 288 } 289 media_tracker.local_seid = avdtp_local_seid(local_stream_endpoint); 290 avdtp_source_register_delay_reporting_category(media_tracker.local_seid); 291 292 // Initialize AVRCP Service. 293 avrcp_init(); 294 avrcp_register_packet_handler(&avrcp_packet_handler); 295 // Initialize AVRCP Target. 296 avrcp_target_init(); 297 avrcp_target_register_packet_handler(&avrcp_target_packet_handler); 298 // Initialize AVRCP Controller 299 avrcp_controller_init(); 300 avrcp_controller_register_packet_handler(&avrcp_controller_packet_handler); 301 302 // Initialize SDP, 303 sdp_init(); 304 305 // Create A2DP Source service record and register it with SDP. 306 memset(sdp_a2dp_source_service_buffer, 0, sizeof(sdp_a2dp_source_service_buffer)); 307 a2dp_source_create_sdp_record(sdp_a2dp_source_service_buffer, 0x10001, AVDTP_SOURCE_FEATURE_MASK_PLAYER, NULL, NULL); 308 sdp_register_service(sdp_a2dp_source_service_buffer); 309 310 // Create AVRCP target service record and register it with SDP. 311 memset(sdp_avrcp_target_service_buffer, 0, sizeof(sdp_avrcp_target_service_buffer)); 312 uint16_t supported_features = AVRCP_FEATURE_MASK_CATEGORY_PLAYER_OR_RECORDER; 313 #ifdef AVRCP_BROWSING_ENABLED 314 supported_features |= AVRCP_FEATURE_MASK_BROWSING; 315 #endif 316 avrcp_target_create_sdp_record(sdp_avrcp_target_service_buffer, 0x10002, supported_features, NULL, NULL); 317 sdp_register_service(sdp_avrcp_target_service_buffer); 318 319 // setup AVRCP Controller 320 memset(sdp_avrcp_controller_service_buffer, 0, sizeof(sdp_avrcp_controller_service_buffer)); 321 uint16_t controller_supported_features = AVRCP_FEATURE_MASK_CATEGORY_PLAYER_OR_RECORDER; 322 avrcp_controller_create_sdp_record(sdp_avrcp_controller_service_buffer, 0x10003, controller_supported_features, NULL, NULL); 323 sdp_register_service(sdp_avrcp_controller_service_buffer); 324 325 // Set local name with a template Bluetooth address, that will be automatically 326 // replaced with a actual address once it is available, i.e. when BTstack boots 327 // up and starts talking to a Bluetooth module. 328 gap_set_local_name("A2DP Source 00:00:00:00:00:00"); 329 gap_discoverable_control(1); 330 gap_set_class_of_device(0x200408); 331 332 // Register for HCI events. 333 hci_event_callback_registration.callback = &hci_packet_handler; 334 hci_add_event_handler(&hci_event_callback_registration); 335 336 a2dp_demo_reconfigure_sample_rate(sample_rate); 337 338 #ifdef HAVE_BTSTACK_STDIN 339 // Parse human readable Bluetooth address. 340 sscanf_bd_addr(device_addr_string, device_addr); 341 btstack_stdin_setup(stdin_process); 342 #endif 343 return 0; 344 } 345 /* LISTING_END */ 346 347 static void a2dp_demo_reconfigure_sample_rate(int new_sample_rate){ 348 if (!hxcmod_initialized){ 349 hxcmod_initialized = hxcmod_init(&mod_context); 350 if (!hxcmod_initialized) { 351 printf("could not initialize hxcmod\n"); 352 return; 353 } 354 } 355 sample_rate = new_sample_rate; 356 media_tracker.sbc_storage_count = 0; 357 media_tracker.samples_ready = 0; 358 hxcmod_unload(&mod_context); 359 hxcmod_setcfg(&mod_context, sample_rate, 16, 1, 1, 1); 360 hxcmod_load(&mod_context, (void *) &mod_data, mod_len); 361 } 362 363 static void a2dp_demo_send_media_packet(void){ 364 int num_bytes_in_frame = btstack_sbc_encoder_sbc_buffer_length(); 365 int bytes_in_storage = media_tracker.sbc_storage_count; 366 uint8_t num_frames = bytes_in_storage / num_bytes_in_frame; 367 a2dp_source_stream_send_media_payload(media_tracker.a2dp_cid, media_tracker.local_seid, media_tracker.sbc_storage, bytes_in_storage, num_frames, 0); 368 media_tracker.sbc_storage_count = 0; 369 media_tracker.sbc_ready_to_send = 0; 370 } 371 372 static void produce_sine_audio(int16_t * pcm_buffer, int num_samples_to_write){ 373 int count; 374 for (count = 0; count < num_samples_to_write ; count++){ 375 switch (sample_rate){ 376 case 44100: 377 pcm_buffer[count * 2] = sine_int16_44100[sine_phase]; 378 pcm_buffer[count * 2 + 1] = sine_int16_44100[sine_phase]; 379 sine_phase++; 380 if (sine_phase >= num_samples_sine_int16_44100){ 381 sine_phase -= num_samples_sine_int16_44100; 382 } 383 break; 384 case 48000: 385 pcm_buffer[count * 2] = sine_int16_48000[sine_phase]; 386 pcm_buffer[count * 2 + 1] = sine_int16_48000[sine_phase]; 387 sine_phase++; 388 if (sine_phase >= num_samples_sine_int16_48000){ 389 sine_phase -= num_samples_sine_int16_48000; 390 } 391 break; 392 default: 393 break; 394 } 395 396 397 } 398 } 399 400 static void produce_mod_audio(int16_t * pcm_buffer, int num_samples_to_write){ 401 hxcmod_fillbuffer(&mod_context, (unsigned short *) &pcm_buffer[0], num_samples_to_write, &trkbuf); 402 } 403 404 static void produce_audio(int16_t * pcm_buffer, int num_samples){ 405 switch (data_source){ 406 case STREAM_SINE: 407 produce_sine_audio(pcm_buffer, num_samples); 408 break; 409 case STREAM_MOD: 410 produce_mod_audio(pcm_buffer, num_samples); 411 break; 412 default: 413 break; 414 } 415 #ifdef VOLUME_REDUCTION 416 int i; 417 for (i=0;i<num_samples*2;i++){ 418 if (pcm_buffer[i] > 0){ 419 pcm_buffer[i] = pcm_buffer[i] >> VOLUME_REDUCTION; 420 } else { 421 pcm_buffer[i] = -((-pcm_buffer[i]) >> VOLUME_REDUCTION); 422 } 423 } 424 #endif 425 } 426 427 static int a2dp_demo_fill_sbc_audio_buffer(a2dp_media_sending_context_t * context){ 428 // perform sbc encodin 429 int total_num_bytes_read = 0; 430 unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames(); 431 while (context->samples_ready >= num_audio_samples_per_sbc_buffer 432 && (context->max_media_payload_size - context->sbc_storage_count) >= btstack_sbc_encoder_sbc_buffer_length()){ 433 434 int16_t pcm_frame[256*NUM_CHANNELS]; 435 436 produce_audio(pcm_frame, num_audio_samples_per_sbc_buffer); 437 btstack_sbc_encoder_process_data(pcm_frame); 438 439 uint16_t sbc_frame_size = btstack_sbc_encoder_sbc_buffer_length(); 440 uint8_t * sbc_frame = btstack_sbc_encoder_sbc_buffer(); 441 442 total_num_bytes_read += num_audio_samples_per_sbc_buffer; 443 memcpy(&context->sbc_storage[context->sbc_storage_count], sbc_frame, sbc_frame_size); 444 context->sbc_storage_count += sbc_frame_size; 445 context->samples_ready -= num_audio_samples_per_sbc_buffer; 446 } 447 return total_num_bytes_read; 448 } 449 450 static void a2dp_demo_audio_timeout_handler(btstack_timer_source_t * timer){ 451 a2dp_media_sending_context_t * context = (a2dp_media_sending_context_t *) btstack_run_loop_get_timer_context(timer); 452 btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS); 453 btstack_run_loop_add_timer(&context->audio_timer); 454 uint32_t now = btstack_run_loop_get_time_ms(); 455 456 uint32_t update_period_ms = AUDIO_TIMEOUT_MS; 457 if (context->time_audio_data_sent > 0){ 458 update_period_ms = now - context->time_audio_data_sent; 459 } 460 461 uint32_t num_samples = (update_period_ms * sample_rate) / 1000; 462 context->acc_num_missed_samples += (update_period_ms * sample_rate) % 1000; 463 464 while (context->acc_num_missed_samples >= 1000){ 465 num_samples++; 466 context->acc_num_missed_samples -= 1000; 467 } 468 context->time_audio_data_sent = now; 469 context->samples_ready += num_samples; 470 471 if (context->sbc_ready_to_send) return; 472 473 a2dp_demo_fill_sbc_audio_buffer(context); 474 475 if ((context->sbc_storage_count + btstack_sbc_encoder_sbc_buffer_length()) > context->max_media_payload_size){ 476 // schedule sending 477 context->sbc_ready_to_send = 1; 478 a2dp_source_stream_endpoint_request_can_send_now(context->a2dp_cid, context->local_seid); 479 } 480 } 481 482 static void a2dp_demo_timer_start(a2dp_media_sending_context_t * context){ 483 context->max_media_payload_size = btstack_min(a2dp_max_media_payload_size(context->a2dp_cid, context->local_seid), SBC_STORAGE_SIZE); 484 context->sbc_storage_count = 0; 485 context->sbc_ready_to_send = 0; 486 context->streaming = 1; 487 btstack_run_loop_remove_timer(&context->audio_timer); 488 btstack_run_loop_set_timer_handler(&context->audio_timer, a2dp_demo_audio_timeout_handler); 489 btstack_run_loop_set_timer_context(&context->audio_timer, context); 490 btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS); 491 btstack_run_loop_add_timer(&context->audio_timer); 492 } 493 494 static void a2dp_demo_timer_stop(a2dp_media_sending_context_t * context){ 495 context->time_audio_data_sent = 0; 496 context->acc_num_missed_samples = 0; 497 context->samples_ready = 0; 498 context->streaming = 1; 499 context->sbc_storage_count = 0; 500 context->sbc_ready_to_send = 0; 501 btstack_run_loop_remove_timer(&context->audio_timer); 502 } 503 504 static void dump_sbc_configuration(avdtp_media_codec_configuration_sbc_t * configuration){ 505 printf("Received media codec configuration:\n"); 506 printf(" - num_channels: %d\n", configuration->num_channels); 507 printf(" - sampling_frequency: %d\n", configuration->sampling_frequency); 508 printf(" - channel_mode: %d\n", configuration->channel_mode); 509 printf(" - block_length: %d\n", configuration->block_length); 510 printf(" - subbands: %d\n", configuration->subbands); 511 printf(" - allocation_method: %d\n", configuration->allocation_method); 512 printf(" - bitpool_value [%d, %d] \n", configuration->min_bitpool_value, configuration->max_bitpool_value); 513 } 514 515 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 516 UNUSED(channel); 517 UNUSED(size); 518 if (packet_type != HCI_EVENT_PACKET) return; 519 520 #ifndef HAVE_BTSTACK_STDIN 521 if (hci_event_packet_get_type(packet) == BTSTACK_EVENT_STATE){ 522 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) return; 523 printf("Create A2DP Source connection to addr %s.\n", bd_addr_to_str(device_addr)); 524 uint8_t status = a2dp_source_establish_stream(device_addr, media_tracker.local_seid, &media_tracker.a2dp_cid); 525 if (status != ERROR_CODE_SUCCESS){ 526 printf("Could not perform command, status 0x%2x\n", status); 527 } 528 return; 529 } 530 #endif 531 532 if (hci_event_packet_get_type(packet) == HCI_EVENT_PIN_CODE_REQUEST) { 533 bd_addr_t address; 534 printf("Pin code request - using '0000'\n"); 535 hci_event_pin_code_request_get_bd_addr(packet, address); 536 gap_pin_code_response(address, "0000"); 537 } 538 } 539 540 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 541 UNUSED(channel); 542 UNUSED(size); 543 uint8_t status; 544 uint8_t local_seid; 545 bd_addr_t address; 546 uint16_t cid; 547 548 if (packet_type != HCI_EVENT_PACKET) return; 549 if (hci_event_packet_get_type(packet) != HCI_EVENT_A2DP_META) return; 550 551 switch (hci_event_a2dp_meta_get_subevent_code(packet)){ 552 case A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED: 553 a2dp_subevent_signaling_connection_established_get_bd_addr(packet, address); 554 cid = a2dp_subevent_signaling_connection_established_get_a2dp_cid(packet); 555 status = a2dp_subevent_signaling_connection_established_get_status(packet); 556 557 if (status != ERROR_CODE_SUCCESS){ 558 printf("A2DP Source: Connection failed, status 0x%02x, cid 0x%02x, a2dp_cid 0x%02x \n", status, cid, media_tracker.a2dp_cid); 559 media_tracker.a2dp_cid = 0; 560 break; 561 } 562 media_tracker.a2dp_cid = cid; 563 media_tracker.volume = 64; 564 565 printf("A2DP Source: Connected to address %s, a2dp cid 0x%02x, local seid %d.\n", bd_addr_to_str(address), media_tracker.a2dp_cid, media_tracker.local_seid); 566 break; 567 568 case A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION:{ 569 cid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(packet); 570 if (cid != media_tracker.a2dp_cid) return; 571 media_tracker.remote_seid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_acp_seid(packet); 572 573 sbc_configuration.reconfigure = a2dp_subevent_signaling_media_codec_sbc_configuration_get_reconfigure(packet); 574 sbc_configuration.num_channels = a2dp_subevent_signaling_media_codec_sbc_configuration_get_num_channels(packet); 575 sbc_configuration.sampling_frequency = a2dp_subevent_signaling_media_codec_sbc_configuration_get_sampling_frequency(packet); 576 sbc_configuration.channel_mode = a2dp_subevent_signaling_media_codec_sbc_configuration_get_channel_mode(packet); 577 sbc_configuration.block_length = a2dp_subevent_signaling_media_codec_sbc_configuration_get_block_length(packet); 578 sbc_configuration.subbands = a2dp_subevent_signaling_media_codec_sbc_configuration_get_subbands(packet); 579 sbc_configuration.allocation_method = a2dp_subevent_signaling_media_codec_sbc_configuration_get_allocation_method(packet); 580 sbc_configuration.min_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_min_bitpool_value(packet); 581 sbc_configuration.max_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_max_bitpool_value(packet); 582 sbc_configuration.frames_per_buffer = sbc_configuration.subbands * sbc_configuration.block_length; 583 printf("A2DP Source: Received SBC codec configuration, sampling frequency %u, a2dp_cid 0x%02x, local seid %d (expected %d), remote seid %d .\n", 584 sbc_configuration.sampling_frequency, cid, 585 a2dp_subevent_signaling_media_codec_sbc_configuration_get_int_seid(packet), 586 media_tracker.local_seid, 587 media_tracker.remote_seid); 588 589 // Adapt Bluetooth spec definition to SBC Encoder expected input 590 sbc_configuration.allocation_method -= 1; 591 sbc_configuration.num_channels = 2; 592 switch (sbc_configuration.channel_mode){ 593 case AVDTP_SBC_JOINT_STEREO: 594 sbc_configuration.channel_mode = 3; 595 break; 596 case AVDTP_SBC_STEREO: 597 sbc_configuration.channel_mode = 2; 598 break; 599 case AVDTP_SBC_DUAL_CHANNEL: 600 sbc_configuration.channel_mode = 1; 601 break; 602 case AVDTP_SBC_MONO: 603 sbc_configuration.channel_mode = 0; 604 sbc_configuration.num_channels = 1; 605 break; 606 } 607 dump_sbc_configuration(&sbc_configuration); 608 609 btstack_sbc_encoder_init(&sbc_encoder_state, SBC_MODE_STANDARD, 610 sbc_configuration.block_length, sbc_configuration.subbands, 611 sbc_configuration.allocation_method, sbc_configuration.sampling_frequency, 612 sbc_configuration.max_bitpool_value, 613 sbc_configuration.channel_mode); 614 break; 615 } 616 617 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY: 618 printf("A2DP Source: remote supports delay report, remote seid %d\n", 619 avdtp_subevent_signaling_delay_reporting_capability_get_remote_seid(packet)); 620 break; 621 case A2DP_SUBEVENT_SIGNALING_CAPABILITIES_DONE: 622 printf("A2DP Source: All capabilities reported, remote seid %d\n", 623 avdtp_subevent_signaling_capabilities_done_get_remote_seid(packet)); 624 break; 625 626 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORT: 627 printf("A2DP Source: Received delay report of %d.%0d ms, local seid %d\n", 628 avdtp_subevent_signaling_delay_report_get_delay_100us(packet)/10, avdtp_subevent_signaling_delay_report_get_delay_100us(packet)%10, 629 avdtp_subevent_signaling_delay_report_get_local_seid(packet)); 630 break; 631 632 case A2DP_SUBEVENT_STREAM_ESTABLISHED: 633 a2dp_subevent_stream_established_get_bd_addr(packet, address); 634 status = a2dp_subevent_stream_established_get_status(packet); 635 if (status){ 636 printf("A2DP Source: Stream failed, status 0x%02x.\n", status); 637 break; 638 } 639 640 local_seid = a2dp_subevent_stream_established_get_local_seid(packet); 641 cid = a2dp_subevent_stream_established_get_a2dp_cid(packet); 642 printf("A2DP_SUBEVENT_STREAM_ESTABLISHED: a2dp_cid [expected 0x%02x, received 0x%02x], local_seid %d (expected %d), remote_seid %d (expected %d)\n", 643 media_tracker.a2dp_cid, cid, 644 local_seid, media_tracker.local_seid, 645 a2dp_subevent_stream_established_get_remote_seid(packet), media_tracker.remote_seid); 646 647 if (local_seid != media_tracker.local_seid){ 648 printf("A2DP Source: Stream failed, wrong local seid %d, expected %d.\n", local_seid, media_tracker.local_seid); 649 break; 650 } 651 printf("A2DP Source: Stream established, address %s, a2dp cid 0x%02x, local seid %d, remote seid %d.\n", bd_addr_to_str(address), 652 media_tracker.a2dp_cid, media_tracker.local_seid, a2dp_subevent_stream_established_get_remote_seid(packet)); 653 media_tracker.stream_opened = 1; 654 data_source = STREAM_MOD; 655 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 656 break; 657 658 case A2DP_SUBEVENT_STREAM_RECONFIGURED: 659 status = a2dp_subevent_stream_reconfigured_get_status(packet); 660 local_seid = a2dp_subevent_stream_reconfigured_get_local_seid(packet); 661 cid = a2dp_subevent_stream_reconfigured_get_a2dp_cid(packet); 662 663 printf("A2DP Source: Reconfigured: a2dp_cid [expected 0x%02x, received 0x%02x], local_seid [expected %d, received %d]\n", media_tracker.a2dp_cid, cid, media_tracker.local_seid, local_seid); 664 printf("Status 0x%02x\n", status); 665 break; 666 667 case A2DP_SUBEVENT_STREAM_STARTED: 668 local_seid = a2dp_subevent_stream_started_get_local_seid(packet); 669 cid = a2dp_subevent_stream_started_get_a2dp_cid(packet); 670 671 play_info.status = AVRCP_PLAYBACK_STATUS_PLAYING; 672 if (media_tracker.avrcp_cid){ 673 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 674 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PLAYING); 675 } 676 a2dp_demo_timer_start(&media_tracker); 677 printf("A2DP Source: Stream started: a2dp_cid [expected 0x%02x, received 0x%02x], local_seid [expected %d, received %d]\n", media_tracker.a2dp_cid, cid, media_tracker.local_seid, local_seid); 678 break; 679 680 case A2DP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW: 681 local_seid = a2dp_subevent_streaming_can_send_media_packet_now_get_local_seid(packet); 682 cid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_a2dp_cid(packet); 683 // printf("A2DP Source: can send media packet: a2dp_cid [expected 0x%02x, received 0x%02x], local_seid [expected %d, received %d]\n", media_tracker.a2dp_cid, cid, media_tracker.local_seid, local_seid); 684 a2dp_demo_send_media_packet(); 685 break; 686 687 case A2DP_SUBEVENT_STREAM_SUSPENDED: 688 local_seid = a2dp_subevent_stream_suspended_get_local_seid(packet); 689 cid = a2dp_subevent_stream_suspended_get_a2dp_cid(packet); 690 691 play_info.status = AVRCP_PLAYBACK_STATUS_PAUSED; 692 if (media_tracker.avrcp_cid){ 693 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PAUSED); 694 } 695 printf("A2DP Source: Stream paused: a2dp_cid [expected 0x%02x, received 0x%02x], local_seid [expected %d, received %d]\n", media_tracker.a2dp_cid, cid, media_tracker.local_seid, local_seid); 696 697 a2dp_demo_timer_stop(&media_tracker); 698 break; 699 700 case A2DP_SUBEVENT_STREAM_RELEASED: 701 play_info.status = AVRCP_PLAYBACK_STATUS_STOPPED; 702 cid = a2dp_subevent_stream_released_get_a2dp_cid(packet); 703 local_seid = a2dp_subevent_stream_released_get_local_seid(packet); 704 705 printf("A2DP Source: Stream released: a2dp_cid [expected 0x%02x, received 0x%02x], local_seid [expected %d, received %d]\n", media_tracker.a2dp_cid, cid, media_tracker.local_seid, local_seid); 706 707 if (cid == media_tracker.a2dp_cid) { 708 media_tracker.stream_opened = 0; 709 printf("A2DP Source: Stream released.\n"); 710 } 711 if (media_tracker.avrcp_cid){ 712 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 713 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_STOPPED); 714 } 715 716 a2dp_demo_timer_stop(&media_tracker); 717 break; 718 case A2DP_SUBEVENT_SIGNALING_CONNECTION_RELEASED: 719 cid = a2dp_subevent_signaling_connection_released_get_a2dp_cid(packet); 720 if (cid == media_tracker.a2dp_cid) { 721 media_tracker.avrcp_cid = 0; 722 media_tracker.a2dp_cid = 0; 723 printf("A2DP Source: Signaling released.\n\n"); 724 } 725 break; 726 default: 727 break; 728 } 729 } 730 731 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 732 UNUSED(channel); 733 UNUSED(size); 734 bd_addr_t event_addr; 735 uint16_t local_cid; 736 uint8_t status = ERROR_CODE_SUCCESS; 737 738 if (packet_type != HCI_EVENT_PACKET) return; 739 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 740 741 switch (packet[2]){ 742 case AVRCP_SUBEVENT_CONNECTION_ESTABLISHED: 743 local_cid = avrcp_subevent_connection_established_get_avrcp_cid(packet); 744 status = avrcp_subevent_connection_established_get_status(packet); 745 if (status != ERROR_CODE_SUCCESS){ 746 printf("AVRCP: Connection failed, local cid 0x%02x, status 0x%02x\n", local_cid, status); 747 return; 748 } 749 media_tracker.avrcp_cid = local_cid; 750 avrcp_subevent_connection_established_get_bd_addr(packet, event_addr); 751 752 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 753 avrcp_target_set_unit_info(media_tracker.avrcp_cid, AVRCP_SUBUNIT_TYPE_AUDIO, company_id); 754 avrcp_target_set_subunit_info(media_tracker.avrcp_cid, AVRCP_SUBUNIT_TYPE_AUDIO, (uint8_t *)subunit_info, sizeof(subunit_info)); 755 756 avrcp_controller_get_supported_events(media_tracker.avrcp_cid); 757 758 printf("AVRCP: Channel successfully opened: media_tracker.avrcp_cid 0x%02x\n", media_tracker.avrcp_cid); 759 return; 760 761 case AVRCP_SUBEVENT_CONNECTION_RELEASED: 762 printf("AVRCP Target: Disconnected, avrcp_cid 0x%02x\n", avrcp_subevent_connection_released_get_avrcp_cid(packet)); 763 media_tracker.avrcp_cid = 0; 764 return; 765 default: 766 break; 767 } 768 769 if (status != ERROR_CODE_SUCCESS){ 770 printf("Responding to event 0x%02x failed with status 0x%02x\n", packet[2], status); 771 } 772 } 773 774 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 775 UNUSED(channel); 776 UNUSED(size); 777 uint8_t status = ERROR_CODE_SUCCESS; 778 779 if (packet_type != HCI_EVENT_PACKET) return; 780 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 781 782 switch (packet[2]){ 783 case AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED: 784 media_tracker.volume = avrcp_subevent_notification_volume_changed_get_absolute_volume(packet); 785 printf("AVRCP Target: Volume set to %d%% (%d)\n", media_tracker.volume * 127/100, media_tracker.volume); 786 break; 787 case AVRCP_SUBEVENT_EVENT_IDS_QUERY: 788 status = avrcp_target_supported_events(media_tracker.avrcp_cid, events_num, events, sizeof(events)); 789 break; 790 case AVRCP_SUBEVENT_COMPANY_IDS_QUERY: 791 status = avrcp_target_supported_companies(media_tracker.avrcp_cid, companies_num, companies, sizeof(companies)); 792 break; 793 case AVRCP_SUBEVENT_PLAY_STATUS_QUERY: 794 status = avrcp_target_play_status(media_tracker.avrcp_cid, play_info.song_length_ms, play_info.song_position_ms, play_info.status); 795 break; 796 // case AVRCP_SUBEVENT_NOW_PLAYING_INFO_QUERY: 797 // status = avrcp_target_now_playing_info(avrcp_cid); 798 // break; 799 case AVRCP_SUBEVENT_OPERATION:{ 800 avrcp_operation_id_t operation_id = avrcp_subevent_operation_get_operation_id(packet); 801 switch (operation_id){ 802 case AVRCP_OPERATION_ID_PLAY: 803 printf("AVRCP Target: PLAY\n"); 804 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 805 break; 806 case AVRCP_OPERATION_ID_PAUSE: 807 printf("AVRCP Target: PAUSE\n"); 808 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 809 break; 810 case AVRCP_OPERATION_ID_STOP: 811 printf("AVRCP Target: STOP\n"); 812 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 813 break; 814 default: 815 printf("AVRCP Target: operation 0x%2x is not handled\n", operation_id); 816 return; 817 } 818 break; 819 } 820 821 default: 822 break; 823 } 824 825 if (status != ERROR_CODE_SUCCESS){ 826 printf("Responding to event 0x%02x failed with status 0x%02x\n", packet[2], status); 827 } 828 } 829 830 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 831 UNUSED(channel); 832 UNUSED(size); 833 uint8_t status = 0xFF; 834 835 if (packet_type != HCI_EVENT_PACKET) return; 836 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 837 838 status = packet[5]; 839 if (!media_tracker.avrcp_cid) return; 840 841 // ignore INTERIM status 842 if (status == AVRCP_CTYPE_RESPONSE_INTERIM) return; 843 844 switch (packet[2]){ 845 case AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED: 846 printf("AVRCP Controller: notification absolute volume changed %d %%\n", avrcp_subevent_notification_volume_changed_get_absolute_volume(packet) * 100 / 127); 847 break; 848 case AVRCP_SUBEVENT_GET_CAPABILITY_EVENT_ID: 849 printf("Remote supports EVENT_ID 0x%02x\n", avrcp_subevent_get_capability_event_id_get_event_id(packet)); 850 break; 851 case AVRCP_SUBEVENT_GET_CAPABILITY_EVENT_ID_DONE: 852 printf("automatically enable notifications\n"); 853 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED); 854 break; 855 default: 856 break; 857 } 858 } 859 860 #ifdef HAVE_BTSTACK_STDIN 861 static void show_usage(void){ 862 bd_addr_t iut_address; 863 gap_local_bd_addr(iut_address); 864 printf("\n--- Bluetooth A2DP Source/AVRCP Demo %s ---\n", bd_addr_to_str(iut_address)); 865 printf("b - A2DP Source create connection to addr %s\n", device_addr_string); 866 printf("B - A2DP Source disconnect\n"); 867 printf("c - AVRCP create connection to addr %s\n", device_addr_string); 868 printf("C - AVRCP disconnect\n"); 869 870 printf("x - start streaming sine\n"); 871 if (hxcmod_initialized){ 872 printf("z - start streaming '%s'\n", mod_name); 873 } 874 printf("p - pause streaming\n"); 875 printf("w - reconfigure stream for 44100 Hz\n"); 876 printf("e - reconfigure stream for 48000 Hz\n"); 877 printf("t - volume up\n"); 878 printf("T - volume down\n"); 879 printf("v - volume up (via set absolute volume)\n"); 880 printf("V - volume down (via set absolute volume)\n"); 881 882 printf("---\n"); 883 } 884 885 static void stdin_process(char cmd){ 886 uint8_t status = ERROR_CODE_SUCCESS; 887 switch (cmd){ 888 case 'b': 889 status = a2dp_source_establish_stream(device_addr, media_tracker.local_seid, &media_tracker.a2dp_cid); 890 printf("%c - Create A2DP Source connection to addr %s, cid 0x%02x.\n", cmd, bd_addr_to_str(device_addr), media_tracker.a2dp_cid); 891 break; 892 case 'B': 893 printf("%c - A2DP Source Disconnect from cid 0x%2x\n", cmd, media_tracker.a2dp_cid); 894 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 895 break; 896 case 'c': 897 printf("%c - Create AVRCP connection to addr %s.\n", cmd, bd_addr_to_str(device_addr)); 898 status = avrcp_connect(device_addr, &media_tracker.avrcp_cid); 899 break; 900 case 'C': 901 printf("%c - AVRCP disconnect\n", cmd); 902 status = avrcp_disconnect(media_tracker.avrcp_cid); 903 break; 904 905 case '\n': 906 case '\r': 907 break; 908 909 case 't': 910 printf(" - volume up\n"); 911 status = avrcp_controller_volume_up(media_tracker.avrcp_cid); 912 break; 913 case 'T': 914 printf(" - volume down\n"); 915 status = avrcp_controller_volume_down(media_tracker.avrcp_cid); 916 break; 917 918 case 'v': 919 if (media_tracker.volume > 117){ 920 media_tracker.volume = 127; 921 } else { 922 media_tracker.volume += 10; 923 } 924 printf(" - volume up (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 127/100, media_tracker.volume); 925 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 926 break; 927 case 'V': 928 if (media_tracker.volume < 10){ 929 media_tracker.volume = 0; 930 } else { 931 media_tracker.volume -= 10; 932 } 933 printf(" - volume down (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 127/100, media_tracker.volume); 934 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 935 break; 936 937 case 'x': 938 if (media_tracker.avrcp_cid){ 939 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 940 } 941 printf("%c - Play sine.\n", cmd); 942 data_source = STREAM_SINE; 943 if (!media_tracker.stream_opened) break; 944 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 945 break; 946 case 'z': 947 if (media_tracker.avrcp_cid){ 948 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 949 } 950 printf("%c - Play mod.\n", cmd); 951 data_source = STREAM_MOD; 952 if (!media_tracker.stream_opened) break; 953 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 954 if (status == ERROR_CODE_SUCCESS){ 955 a2dp_demo_reconfigure_sample_rate(sample_rate); 956 } 957 break; 958 959 case 'p': 960 if (!media_tracker.stream_opened) break; 961 printf("%c - Pause stream.\n", cmd); 962 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 963 break; 964 965 case 'w': 966 if (!media_tracker.stream_opened) break; 967 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 968 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 969 break; 970 } 971 printf("%c - Reconfigure for %d Hz.\n", cmd, sample_rate); 972 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, 44100); 973 if (status == ERROR_CODE_SUCCESS){ 974 a2dp_demo_reconfigure_sample_rate(44100); 975 } 976 break; 977 978 case 'e': 979 if (!media_tracker.stream_opened) break; 980 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 981 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 982 break; 983 } 984 printf("%c - Reconfigure for %d Hz.\n", cmd, sample_rate); 985 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, 48000); 986 if (status == ERROR_CODE_SUCCESS){ 987 a2dp_demo_reconfigure_sample_rate(48000); 988 } 989 break; 990 991 default: 992 show_usage(); 993 return; 994 } 995 if (status != ERROR_CODE_SUCCESS){ 996 printf("Could not perform command \'%c\', status 0x%02x\n", cmd, status); 997 } 998 } 999 #endif 1000 1001 1002 int btstack_main(int argc, const char * argv[]); 1003 int btstack_main(int argc, const char * argv[]){ 1004 (void)argc; 1005 (void)argv; 1006 1007 int err = a2dp_source_and_avrcp_services_init(); 1008 if (err) return err; 1009 // turn on! 1010 hci_power_control(HCI_POWER_ON); 1011 return 0; 1012 } 1013 /* EXAMPLE_END */ 1014