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