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