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