1 /* 2 * Copyright (C) 2016 BlueKitchen GmbH 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the copyright holders nor the names of 14 * contributors may be used to endorse or promote products derived 15 * from this software without specific prior written permission. 16 * 4. Any redistribution, use, or modification is done solely for 17 * personal benefit and not for any commercial purpose or for 18 * monetary gain. 19 * 20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN 24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * Please inquire about commercial licensing options at 34 * [email protected] 35 * 36 */ 37 38 #define BTSTACK_FILE__ "a2dp_source_demo.c" 39 40 /* 41 * a2dp_source_demo.c 42 */ 43 44 // ***************************************************************************** 45 /* EXAMPLE_START(a2dp_source_demo): A2DP Source - Stream Audio and Control Volume 46 * 47 * @text This A2DP Source example demonstrates how to send an audio data stream 48 * to a remote A2DP Sink device and how to switch between two audio data sources. 49 * In addition, the AVRCP Target is used to answer queries on currently played media, 50 * as well as to handle remote playback control, i.e. play, stop, repeat, etc. If HAVE_BTSTACK_STDIN 51 * is set, press SPACE on the console to show the available AVDTP and AVRCP commands. 52 * 53 * @text To test with a remote device, e.g. a Bluetooth speaker, 54 * set the device_addr_string to the Bluetooth address of your 55 * remote device in the code, and use the UI to connect and start playback. 56 * 57 * @text For more info on BTstack audio, see our blog post 58 * [A2DP Sink and Source on STM32 F4 Discovery Board](http://bluekitchen-gmbh.com/a2dp-sink-and-source-on-stm32-f4-discovery-board/). 59 * 60 */ 61 // ***************************************************************************** 62 63 64 #include <stdint.h> 65 #include <stdio.h> 66 #include <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 76 //#define AVRCP_BROWSING_ENABLED 77 78 #define NUM_CHANNELS 2 79 #define BYTES_PER_AUDIO_SAMPLE (2*NUM_CHANNELS) 80 #define AUDIO_TIMEOUT_MS 10 81 #define TABLE_SIZE_441HZ 100 82 83 #define SBC_STORAGE_SIZE 1030 84 85 typedef enum { 86 STREAM_SINE = 0, 87 STREAM_MOD, 88 STREAM_PTS_TEST 89 } stream_data_source_t; 90 91 typedef struct { 92 uint16_t a2dp_cid; 93 uint8_t local_seid; 94 uint8_t remote_seid; 95 uint8_t stream_opened; 96 uint16_t avrcp_cid; 97 98 uint32_t time_audio_data_sent; // ms 99 uint32_t acc_num_missed_samples; 100 uint32_t samples_ready; 101 btstack_timer_source_t audio_timer; 102 uint8_t streaming; 103 int max_media_payload_size; 104 105 uint8_t sbc_storage[SBC_STORAGE_SIZE]; 106 uint16_t sbc_storage_count; 107 uint8_t sbc_ready_to_send; 108 109 uint16_t volume; 110 } a2dp_media_sending_context_t; 111 112 static uint8_t media_sbc_codec_capabilities[] = { 113 (AVDTP_SBC_44100 << 4) | AVDTP_SBC_STEREO, 114 0xFF,//(AVDTP_SBC_BLOCK_LENGTH_16 << 4) | (AVDTP_SBC_SUBBANDS_8 << 2) | AVDTP_SBC_ALLOCATION_METHOD_LOUDNESS, 115 2, 53 116 }; 117 118 // input signal: pre-computed int16 sine wave, 44100 Hz at 441 Hz 119 static const int16_t sine_int16_44100[] = { 120 0, 2057, 4107, 6140, 8149, 10126, 12062, 13952, 15786, 17557, 121 19260, 20886, 22431, 23886, 25247, 26509, 27666, 28714, 29648, 30466, 122 31163, 31738, 32187, 32509, 32702, 32767, 32702, 32509, 32187, 31738, 123 31163, 30466, 29648, 28714, 27666, 26509, 25247, 23886, 22431, 20886, 124 19260, 17557, 15786, 13952, 12062, 10126, 8149, 6140, 4107, 2057, 125 0, -2057, -4107, -6140, -8149, -10126, -12062, -13952, -15786, -17557, 126 -19260, -20886, -22431, -23886, -25247, -26509, -27666, -28714, -29648, -30466, 127 -31163, -31738, -32187, -32509, -32702, -32767, -32702, -32509, -32187, -31738, 128 -31163, -30466, -29648, -28714, -27666, -26509, -25247, -23886, -22431, -20886, 129 -19260, -17557, -15786, -13952, -12062, -10126, -8149, -6140, -4107, -2057, 130 }; 131 132 static const int num_samples_sine_int16_44100 = sizeof(sine_int16_44100) / 2; 133 134 // input signal: pre-computed int16 sine wave, 48000 Hz at 441 Hz 135 static const int16_t sine_int16_48000[] = { 136 0, 1905, 3804, 5690, 7557, 9398, 11207, 12978, 14706, 16383, 137 18006, 19567, 21062, 22486, 23834, 25101, 26283, 27376, 28377, 29282, 138 30087, 30791, 31390, 31884, 32269, 32545, 32712, 32767, 32712, 32545, 139 32269, 31884, 31390, 30791, 30087, 29282, 28377, 27376, 26283, 25101, 140 23834, 22486, 21062, 19567, 18006, 16383, 14706, 12978, 11207, 9398, 141 7557, 5690, 3804, 1905, 0, -1905, -3804, -5690, -7557, -9398, 142 -11207, -12978, -14706, -16384, -18006, -19567, -21062, -22486, -23834, -25101, 143 -26283, -27376, -28377, -29282, -30087, -30791, -31390, -31884, -32269, -32545, 144 -32712, -32767, -32712, -32545, -32269, -31884, -31390, -30791, -30087, -29282, 145 -28377, -27376, -26283, -25101, -23834, -22486, -21062, -19567, -18006, -16384, 146 -14706, -12978, -11207, -9398, -7557, -5690, -3804, -1905, }; 147 148 static const int num_samples_sine_int16_48000 = sizeof(sine_int16_48000) / 2; 149 150 typedef struct { 151 int reconfigure; 152 153 int num_channels; 154 int sampling_frequency; 155 int block_length; 156 int subbands; 157 int min_bitpool_value; 158 int max_bitpool_value; 159 btstack_sbc_channel_mode_t channel_mode; 160 btstack_sbc_allocation_method_t allocation_method; 161 } media_codec_configuration_sbc_t; 162 163 static btstack_packet_callback_registration_t hci_event_callback_registration; 164 165 // pts: static const char * device_addr_string = "00:1B:DC:08:0A:A5"; 166 // pts: static const char * device_addr_string = "00:1B:DC:08:E2:72"; 167 // mac 2013: static const char * device_addr_string = "84:38:35:65:d1:15"; 168 // phone 2013: static const char * device_addr_string = "D8:BB:2C:DF:F0:F2"; 169 // Minijambox: 170 static const char * device_addr_string = "00:21:3C:AC:F7:38"; 171 // Philips SHB9100: static const char * device_addr_string = "00:22:37:05:FD:E8"; 172 // RT-B6: static const char * device_addr_string = "00:75:58:FF:C9:7D"; 173 // BT dongle: static const char * device_addr_string = "00:1A:7D:DA:71:0A"; 174 // Sony MDR-ZX330BT static const char * device_addr_string = "00:18:09:28:50:18"; 175 // Panda (BM6) static const char * device_addr_string = "4F:3F:66:52:8B:E0"; 176 // BeatsX: static const char * device_addr_string = "DC:D3:A2:89:57:FB"; 177 // Green mushroom: static const char * device_addr_string = "41:42:2A:ED:D6:F3"; 178 179 static bd_addr_t device_addr; 180 181 static uint8_t sdp_a2dp_source_service_buffer[150]; 182 static uint8_t sdp_avrcp_target_service_buffer[200]; 183 static uint8_t sdp_avrcp_controller_service_buffer[200]; 184 static uint8_t device_id_sdp_service_buffer[100]; 185 186 static media_codec_configuration_sbc_t sbc_configuration; 187 static btstack_sbc_encoder_state_t sbc_encoder_state; 188 189 static uint8_t media_sbc_codec_configuration[4]; 190 static a2dp_media_sending_context_t media_tracker; 191 192 static stream_data_source_t data_source; 193 194 static int sine_phase; 195 static int current_sample_rate = 44100; 196 static int new_sample_rate = 44100; 197 198 static int hxcmod_initialized; 199 static modcontext mod_context; 200 static tracker_buffer_state trkbuf; 201 202 /* AVRCP Target context START */ 203 204 typedef struct { 205 uint8_t track_id[8]; 206 uint32_t song_length_ms; 207 avrcp_playback_status_t status; 208 uint32_t song_position_ms; // 0xFFFFFFFF if not supported 209 } avrcp_play_status_info_t; 210 211 // python -c "print('a'*512)" 212 static const char title[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 213 214 avrcp_track_t tracks[] = { 215 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 1, "Sine", "Generated", "A2DP Source Demo", "monotone", 12345}, 216 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, 2, "Nao-deceased", "Decease", "A2DP Source Demo", "vivid", 12345}, 217 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, 3, (char *)title, "Decease", "A2DP Source Demo", "vivid", 12345}, 218 }; 219 int current_track_index; 220 avrcp_play_status_info_t play_info; 221 222 /* AVRCP Target context END */ 223 224 /* @section Main Application Setup 225 * 226 * @text The Listing MainConfiguration shows how to setup AD2P Source and AVRCP services. 227 * Besides calling init() method for each service, you'll also need to register several packet handlers: 228 * - hci_packet_handler - handles legacy pairing, here by using fixed '0000' pin code. 229 * - 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). 230 * - avrcp_packet_handler - receives connect/disconnect event. 231 * - avrcp_controller_packet_handler - receives answers for sent AVRCP commands. 232 * - avrcp_target_packet_handler - receives AVRCP commands, and registered notifications. 233 * - 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. 234 * 235 * @text To announce A2DP Source and AVRCP services, you need to create corresponding 236 * SDP records and register them with the SDP service. 237 */ 238 239 /* LISTING_START(MainConfiguration): Setup Audio Source and AVRCP Target services */ 240 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 241 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * event, uint16_t event_size); 242 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 243 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 244 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 245 #ifdef HAVE_BTSTACK_STDIN 246 static void stdin_process(char cmd); 247 #endif 248 249 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate); 250 251 static int a2dp_source_and_avrcp_services_init(void){ 252 // Request role change on reconnecting headset to always use them in slave mode 253 hci_set_master_slave_policy(0); 254 255 l2cap_init(); 256 // Initialize A2DP Source 257 a2dp_source_init(); 258 a2dp_source_register_packet_handler(&a2dp_source_packet_handler); 259 260 // Create stream endpoint 261 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)); 262 if (!local_stream_endpoint){ 263 printf("A2DP Source: not enough memory to create local stream endpoint\n"); 264 return 1; 265 } 266 267 // Store stream enpoint's SEP ID, as it is used by A2DP API to indentify the stream endpoint 268 media_tracker.local_seid = avdtp_local_seid(local_stream_endpoint); 269 avdtp_source_register_delay_reporting_category(media_tracker.local_seid); 270 271 // Initialize AVRCP Service 272 avrcp_init(); 273 avrcp_register_packet_handler(&avrcp_packet_handler); 274 // Initialize AVRCP Target 275 avrcp_target_init(); 276 avrcp_target_register_packet_handler(&avrcp_target_packet_handler); 277 278 // Initialize AVRCP Controller 279 avrcp_controller_init(); 280 avrcp_controller_register_packet_handler(&avrcp_controller_packet_handler); 281 282 // Initialize SDP, 283 sdp_init(); 284 285 // Create A2DP Source service record and register it with SDP 286 memset(sdp_a2dp_source_service_buffer, 0, sizeof(sdp_a2dp_source_service_buffer)); 287 a2dp_source_create_sdp_record(sdp_a2dp_source_service_buffer, 0x10001, AVDTP_SOURCE_FEATURE_MASK_PLAYER, NULL, NULL); 288 sdp_register_service(sdp_a2dp_source_service_buffer); 289 290 // Create AVRCP Target service record and register it with SDP. We receive Category 1 commands from the headphone, e.g. play/pause 291 memset(sdp_avrcp_target_service_buffer, 0, sizeof(sdp_avrcp_target_service_buffer)); 292 uint16_t supported_features = AVRCP_FEATURE_MASK_CATEGORY_PLAYER_OR_RECORDER; 293 #ifdef AVRCP_BROWSING_ENABLED 294 supported_features |= AVRCP_FEATURE_MASK_BROWSING; 295 #endif 296 avrcp_target_create_sdp_record(sdp_avrcp_target_service_buffer, 0x10002, supported_features, NULL, NULL); 297 sdp_register_service(sdp_avrcp_target_service_buffer); 298 299 // Create AVRCP Controller service record and register it with SDP. We send Category 2 commands to the headphone, e.g. volume up/down 300 memset(sdp_avrcp_controller_service_buffer, 0, sizeof(sdp_avrcp_controller_service_buffer)); 301 uint16_t controller_supported_features = AVRCP_FEATURE_MASK_CATEGORY_MONITOR_OR_AMPLIFIER; 302 avrcp_controller_create_sdp_record(sdp_avrcp_controller_service_buffer, 0x10003, controller_supported_features, NULL, NULL); 303 sdp_register_service(sdp_avrcp_controller_service_buffer); 304 305 // Register Device ID (PnP) service SDP record 306 memset(device_id_sdp_service_buffer, 0, sizeof(device_id_sdp_service_buffer)); 307 device_id_create_sdp_record(device_id_sdp_service_buffer, 0x10004, DEVICE_ID_VENDOR_ID_SOURCE_BLUETOOTH, BLUETOOTH_COMPANY_ID_BLUEKITCHEN_GMBH, 1, 1); 308 sdp_register_service(device_id_sdp_service_buffer); 309 310 // Set local name with a template Bluetooth address, that will be automatically 311 // replaced with a actual address once it is available, i.e. when BTstack boots 312 // up and starts talking to a Bluetooth module. 313 gap_set_local_name("A2DP Source 00:00:00:00:00:00"); 314 gap_discoverable_control(1); 315 gap_set_class_of_device(0x200408); 316 317 // Register for HCI events. 318 hci_event_callback_registration.callback = &hci_packet_handler; 319 hci_add_event_handler(&hci_event_callback_registration); 320 321 a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate); 322 323 // Parse human readable Bluetooth address. 324 sscanf_bd_addr(device_addr_string, device_addr); 325 326 #ifdef HAVE_BTSTACK_STDIN 327 btstack_stdin_setup(stdin_process); 328 #endif 329 return 0; 330 } 331 /* LISTING_END */ 332 333 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate){ 334 if (!hxcmod_initialized){ 335 hxcmod_initialized = hxcmod_init(&mod_context); 336 if (!hxcmod_initialized) { 337 printf("could not initialize hxcmod\n"); 338 return; 339 } 340 } 341 current_sample_rate = sample_rate; 342 media_tracker.sbc_storage_count = 0; 343 media_tracker.samples_ready = 0; 344 hxcmod_unload(&mod_context); 345 hxcmod_setcfg(&mod_context, current_sample_rate, 16, 1, 1, 1); 346 hxcmod_load(&mod_context, (void *) &mod_data, mod_len); 347 } 348 349 static void a2dp_demo_send_media_packet(void){ 350 int num_bytes_in_frame = btstack_sbc_encoder_sbc_buffer_length(); 351 int bytes_in_storage = media_tracker.sbc_storage_count; 352 uint8_t num_frames = bytes_in_storage / num_bytes_in_frame; 353 // Prepend SBC Header 354 media_tracker.sbc_storage[0] = num_frames; // (fragmentation << 7) | (starting_packet << 6) | (last_packet << 5) | num_frames; 355 avdtp_source_stream_send_media_payload_rtp(media_tracker.a2dp_cid, media_tracker.local_seid, 0, media_tracker.sbc_storage, bytes_in_storage + 1); 356 357 media_tracker.sbc_storage_count = 0; 358 media_tracker.sbc_ready_to_send = 0; 359 } 360 361 static void produce_sine_audio(int16_t * pcm_buffer, int num_samples_to_write){ 362 int count; 363 for (count = 0; count < num_samples_to_write ; count++){ 364 switch (current_sample_rate){ 365 case 44100: 366 pcm_buffer[count * 2] = sine_int16_44100[sine_phase]; 367 pcm_buffer[count * 2 + 1] = sine_int16_44100[sine_phase]; 368 sine_phase++; 369 if (sine_phase >= num_samples_sine_int16_44100){ 370 sine_phase -= num_samples_sine_int16_44100; 371 } 372 break; 373 case 48000: 374 pcm_buffer[count * 2] = sine_int16_48000[sine_phase]; 375 pcm_buffer[count * 2 + 1] = sine_int16_48000[sine_phase]; 376 sine_phase++; 377 if (sine_phase >= num_samples_sine_int16_48000){ 378 sine_phase -= num_samples_sine_int16_48000; 379 } 380 break; 381 default: 382 break; 383 } 384 } 385 } 386 387 static void produce_mod_audio(int16_t * pcm_buffer, int num_samples_to_write){ 388 hxcmod_fillbuffer(&mod_context, (unsigned short *) &pcm_buffer[0], num_samples_to_write, &trkbuf); 389 } 390 391 static void produce_audio(int16_t * pcm_buffer, int num_samples){ 392 switch (data_source){ 393 case STREAM_SINE: 394 produce_sine_audio(pcm_buffer, num_samples); 395 break; 396 case STREAM_MOD: 397 produce_mod_audio(pcm_buffer, num_samples); 398 break; 399 default: 400 break; 401 } 402 #ifdef VOLUME_REDUCTION 403 int i; 404 for (i=0;i<num_samples*2;i++){ 405 if (pcm_buffer[i] > 0){ 406 pcm_buffer[i] = pcm_buffer[i] >> VOLUME_REDUCTION; 407 } else { 408 pcm_buffer[i] = -((-pcm_buffer[i]) >> VOLUME_REDUCTION); 409 } 410 } 411 #endif 412 } 413 414 static int a2dp_demo_fill_sbc_audio_buffer(a2dp_media_sending_context_t * context){ 415 // perform sbc encoding 416 int total_num_bytes_read = 0; 417 unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames(); 418 while (context->samples_ready >= num_audio_samples_per_sbc_buffer 419 && (context->max_media_payload_size - context->sbc_storage_count) >= btstack_sbc_encoder_sbc_buffer_length()){ 420 421 int16_t pcm_frame[256*NUM_CHANNELS]; 422 423 produce_audio(pcm_frame, num_audio_samples_per_sbc_buffer); 424 btstack_sbc_encoder_process_data(pcm_frame); 425 426 uint16_t sbc_frame_size = btstack_sbc_encoder_sbc_buffer_length(); 427 uint8_t * sbc_frame = btstack_sbc_encoder_sbc_buffer(); 428 429 total_num_bytes_read += num_audio_samples_per_sbc_buffer; 430 // first byte in sbc storage contains sbc media header 431 memcpy(&context->sbc_storage[1 + context->sbc_storage_count], sbc_frame, sbc_frame_size); 432 context->sbc_storage_count += sbc_frame_size; 433 context->samples_ready -= num_audio_samples_per_sbc_buffer; 434 } 435 return total_num_bytes_read; 436 } 437 438 static void a2dp_demo_audio_timeout_handler(btstack_timer_source_t * timer){ 439 a2dp_media_sending_context_t * context = (a2dp_media_sending_context_t *) btstack_run_loop_get_timer_context(timer); 440 btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS); 441 btstack_run_loop_add_timer(&context->audio_timer); 442 uint32_t now = btstack_run_loop_get_time_ms(); 443 444 uint32_t update_period_ms = AUDIO_TIMEOUT_MS; 445 if (context->time_audio_data_sent > 0){ 446 update_period_ms = now - context->time_audio_data_sent; 447 } 448 449 uint32_t num_samples = (update_period_ms * current_sample_rate) / 1000; 450 context->acc_num_missed_samples += (update_period_ms * current_sample_rate) % 1000; 451 452 while (context->acc_num_missed_samples >= 1000){ 453 num_samples++; 454 context->acc_num_missed_samples -= 1000; 455 } 456 context->time_audio_data_sent = now; 457 context->samples_ready += num_samples; 458 459 if (context->sbc_ready_to_send) return; 460 461 a2dp_demo_fill_sbc_audio_buffer(context); 462 463 if ((context->sbc_storage_count + btstack_sbc_encoder_sbc_buffer_length()) > context->max_media_payload_size){ 464 // schedule sending 465 context->sbc_ready_to_send = 1; 466 a2dp_source_stream_endpoint_request_can_send_now(context->a2dp_cid, context->local_seid); 467 } 468 } 469 470 static void a2dp_demo_timer_start(a2dp_media_sending_context_t * context){ 471 context->max_media_payload_size = btstack_min(a2dp_max_media_payload_size(context->a2dp_cid, context->local_seid), SBC_STORAGE_SIZE); 472 context->sbc_storage_count = 0; 473 context->sbc_ready_to_send = 0; 474 context->streaming = 1; 475 btstack_run_loop_remove_timer(&context->audio_timer); 476 btstack_run_loop_set_timer_handler(&context->audio_timer, a2dp_demo_audio_timeout_handler); 477 btstack_run_loop_set_timer_context(&context->audio_timer, context); 478 btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS); 479 btstack_run_loop_add_timer(&context->audio_timer); 480 } 481 482 static void a2dp_demo_timer_stop(a2dp_media_sending_context_t * context){ 483 context->time_audio_data_sent = 0; 484 context->acc_num_missed_samples = 0; 485 context->samples_ready = 0; 486 context->streaming = 1; 487 context->sbc_storage_count = 0; 488 context->sbc_ready_to_send = 0; 489 btstack_run_loop_remove_timer(&context->audio_timer); 490 } 491 492 static void dump_sbc_configuration(media_codec_configuration_sbc_t * configuration){ 493 printf("Received media codec configuration:\n"); 494 printf(" - num_channels: %d\n", configuration->num_channels); 495 printf(" - sampling_frequency: %d\n", configuration->sampling_frequency); 496 printf(" - channel_mode: %d\n", configuration->channel_mode); 497 printf(" - block_length: %d\n", configuration->block_length); 498 printf(" - subbands: %d\n", configuration->subbands); 499 printf(" - allocation_method: %d\n", configuration->allocation_method); 500 printf(" - bitpool_value [%d, %d] \n", configuration->min_bitpool_value, configuration->max_bitpool_value); 501 } 502 503 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 504 UNUSED(channel); 505 UNUSED(size); 506 if (packet_type != HCI_EVENT_PACKET) return; 507 508 #ifndef HAVE_BTSTACK_STDIN 509 if (hci_event_packet_get_type(packet) == BTSTACK_EVENT_STATE){ 510 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) return; 511 printf("Create A2DP Source connection to addr %s.\n", bd_addr_to_str(device_addr)); 512 uint8_t status = a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid); 513 if (status != ERROR_CODE_SUCCESS){ 514 printf("Could not perform command, status 0x%2x\n", status); 515 } 516 return; 517 } 518 #endif 519 520 if (hci_event_packet_get_type(packet) == HCI_EVENT_PIN_CODE_REQUEST) { 521 bd_addr_t address; 522 printf("Pin code request - using '0000'\n"); 523 hci_event_pin_code_request_get_bd_addr(packet, address); 524 gap_pin_code_response(address, "0000"); 525 } 526 } 527 528 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 529 UNUSED(channel); 530 UNUSED(size); 531 uint8_t status; 532 uint8_t local_seid; 533 bd_addr_t address; 534 uint16_t cid; 535 536 avdtp_channel_mode_t channel_mode; 537 uint8_t allocation_method; 538 539 if (packet_type != HCI_EVENT_PACKET) return; 540 if (hci_event_packet_get_type(packet) != HCI_EVENT_A2DP_META) return; 541 542 switch (hci_event_a2dp_meta_get_subevent_code(packet)){ 543 case A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED: 544 a2dp_subevent_signaling_connection_established_get_bd_addr(packet, address); 545 cid = a2dp_subevent_signaling_connection_established_get_a2dp_cid(packet); 546 status = a2dp_subevent_signaling_connection_established_get_status(packet); 547 548 if (status != ERROR_CODE_SUCCESS){ 549 printf("A2DP Source: Connection failed, status 0x%02x, cid 0x%02x, a2dp_cid 0x%02x \n", status, cid, media_tracker.a2dp_cid); 550 media_tracker.a2dp_cid = 0; 551 break; 552 } 553 media_tracker.a2dp_cid = cid; 554 media_tracker.volume = 32; 555 556 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); 557 break; 558 559 case A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION:{ 560 cid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(packet); 561 if (cid != media_tracker.a2dp_cid) return; 562 563 media_tracker.remote_seid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet); 564 565 sbc_configuration.reconfigure = a2dp_subevent_signaling_media_codec_sbc_configuration_get_reconfigure(packet); 566 sbc_configuration.num_channels = a2dp_subevent_signaling_media_codec_sbc_configuration_get_num_channels(packet); 567 sbc_configuration.sampling_frequency = a2dp_subevent_signaling_media_codec_sbc_configuration_get_sampling_frequency(packet); 568 sbc_configuration.block_length = a2dp_subevent_signaling_media_codec_sbc_configuration_get_block_length(packet); 569 sbc_configuration.subbands = a2dp_subevent_signaling_media_codec_sbc_configuration_get_subbands(packet); 570 sbc_configuration.min_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_min_bitpool_value(packet); 571 sbc_configuration.max_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_max_bitpool_value(packet); 572 573 channel_mode = (avdtp_channel_mode_t) a2dp_subevent_signaling_media_codec_sbc_configuration_get_channel_mode(packet); 574 allocation_method = a2dp_subevent_signaling_media_codec_sbc_configuration_get_allocation_method(packet); 575 576 printf("A2DP Source: Received SBC codec configuration, sampling frequency %u, a2dp_cid 0x%02x, local seid 0x%02x, remote seid 0x%02x.\n", 577 sbc_configuration.sampling_frequency, cid, 578 a2dp_subevent_signaling_media_codec_sbc_configuration_get_local_seid(packet), 579 a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet)); 580 581 // Adapt Bluetooth spec definition to SBC Encoder expected input 582 sbc_configuration.allocation_method = (btstack_sbc_allocation_method_t)(allocation_method - 1); 583 switch (channel_mode){ 584 case AVDTP_CHANNEL_MODE_JOINT_STEREO: 585 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO; 586 break; 587 case AVDTP_CHANNEL_MODE_STEREO: 588 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_STEREO; 589 break; 590 case AVDTP_CHANNEL_MODE_DUAL_CHANNEL: 591 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL; 592 break; 593 case AVDTP_CHANNEL_MODE_MONO: 594 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_MONO; 595 break; 596 default: 597 btstack_assert(false); 598 break; 599 } 600 dump_sbc_configuration(&sbc_configuration); 601 602 btstack_sbc_encoder_init(&sbc_encoder_state, SBC_MODE_STANDARD, 603 sbc_configuration.block_length, sbc_configuration.subbands, 604 sbc_configuration.allocation_method, sbc_configuration.sampling_frequency, 605 sbc_configuration.max_bitpool_value, 606 sbc_configuration.channel_mode); 607 break; 608 } 609 610 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY: 611 printf("A2DP Source: remote supports delay report, remote seid %d\n", 612 avdtp_subevent_signaling_delay_reporting_capability_get_remote_seid(packet)); 613 break; 614 case A2DP_SUBEVENT_SIGNALING_CAPABILITIES_DONE: 615 printf("A2DP Source: All capabilities reported, remote seid %d\n", 616 avdtp_subevent_signaling_capabilities_done_get_remote_seid(packet)); 617 break; 618 619 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORT: 620 printf("A2DP Source: Received delay report of %d.%0d ms, local seid %d\n", 621 avdtp_subevent_signaling_delay_report_get_delay_100us(packet)/10, avdtp_subevent_signaling_delay_report_get_delay_100us(packet)%10, 622 avdtp_subevent_signaling_delay_report_get_local_seid(packet)); 623 break; 624 625 case A2DP_SUBEVENT_STREAM_ESTABLISHED: 626 a2dp_subevent_stream_established_get_bd_addr(packet, address); 627 status = a2dp_subevent_stream_established_get_status(packet); 628 if (status != ERROR_CODE_SUCCESS){ 629 printf("A2DP Source: Stream failed, status 0x%02x.\n", status); 630 break; 631 } 632 633 local_seid = a2dp_subevent_stream_established_get_local_seid(packet); 634 cid = a2dp_subevent_stream_established_get_a2dp_cid(packet); 635 636 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)); 637 638 a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate); 639 media_tracker.stream_opened = 1; 640 data_source = STREAM_MOD; 641 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 642 break; 643 644 case A2DP_SUBEVENT_STREAM_RECONFIGURED: 645 status = a2dp_subevent_stream_reconfigured_get_status(packet); 646 local_seid = a2dp_subevent_stream_reconfigured_get_local_seid(packet); 647 cid = a2dp_subevent_stream_reconfigured_get_a2dp_cid(packet); 648 649 if (status != ERROR_CODE_SUCCESS){ 650 printf("A2DP Source: Stream reconfiguration failed with status 0x%02x\n", status); 651 break; 652 } 653 654 printf("A2DP Source: Stream reconfigured a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 655 a2dp_demo_hexcmod_configure_sample_rate(new_sample_rate); 656 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 657 break; 658 659 case A2DP_SUBEVENT_STREAM_STARTED: 660 local_seid = a2dp_subevent_stream_started_get_local_seid(packet); 661 cid = a2dp_subevent_stream_started_get_a2dp_cid(packet); 662 663 play_info.status = AVRCP_PLAYBACK_STATUS_PLAYING; 664 if (media_tracker.avrcp_cid){ 665 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 666 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PLAYING); 667 } 668 a2dp_demo_timer_start(&media_tracker); 669 printf("A2DP Source: Stream started, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 670 break; 671 672 case A2DP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW: 673 local_seid = a2dp_subevent_streaming_can_send_media_packet_now_get_local_seid(packet); 674 cid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_a2dp_cid(packet); 675 a2dp_demo_send_media_packet(); 676 break; 677 678 case A2DP_SUBEVENT_STREAM_SUSPENDED: 679 local_seid = a2dp_subevent_stream_suspended_get_local_seid(packet); 680 cid = a2dp_subevent_stream_suspended_get_a2dp_cid(packet); 681 682 play_info.status = AVRCP_PLAYBACK_STATUS_PAUSED; 683 if (media_tracker.avrcp_cid){ 684 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PAUSED); 685 } 686 printf("A2DP Source: Stream paused, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 687 688 a2dp_demo_timer_stop(&media_tracker); 689 break; 690 691 case A2DP_SUBEVENT_STREAM_RELEASED: 692 play_info.status = AVRCP_PLAYBACK_STATUS_STOPPED; 693 cid = a2dp_subevent_stream_released_get_a2dp_cid(packet); 694 local_seid = a2dp_subevent_stream_released_get_local_seid(packet); 695 696 printf("A2DP Source: Stream released, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 697 698 if (cid == media_tracker.a2dp_cid) { 699 media_tracker.stream_opened = 0; 700 printf("A2DP Source: Stream released.\n"); 701 } 702 if (media_tracker.avrcp_cid){ 703 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 704 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_STOPPED); 705 } 706 a2dp_demo_timer_stop(&media_tracker); 707 break; 708 case A2DP_SUBEVENT_SIGNALING_CONNECTION_RELEASED: 709 cid = a2dp_subevent_signaling_connection_released_get_a2dp_cid(packet); 710 if (cid == media_tracker.a2dp_cid) { 711 media_tracker.avrcp_cid = 0; 712 media_tracker.a2dp_cid = 0; 713 printf("A2DP Source: Signaling released.\n\n"); 714 } 715 break; 716 default: 717 break; 718 } 719 } 720 721 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 722 UNUSED(channel); 723 UNUSED(size); 724 bd_addr_t event_addr; 725 uint16_t local_cid; 726 uint8_t status = ERROR_CODE_SUCCESS; 727 728 if (packet_type != HCI_EVENT_PACKET) return; 729 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 730 731 switch (packet[2]){ 732 case AVRCP_SUBEVENT_CONNECTION_ESTABLISHED: 733 local_cid = avrcp_subevent_connection_established_get_avrcp_cid(packet); 734 status = avrcp_subevent_connection_established_get_status(packet); 735 if (status != ERROR_CODE_SUCCESS){ 736 printf("AVRCP: Connection failed, local cid 0x%02x, status 0x%02x\n", local_cid, status); 737 return; 738 } 739 media_tracker.avrcp_cid = local_cid; 740 avrcp_subevent_connection_established_get_bd_addr(packet, event_addr); 741 742 printf("AVRCP: Channel to %s successfully opened, avrcp_cid 0x%02x\n", bd_addr_to_str(event_addr), media_tracker.avrcp_cid); 743 744 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED); 745 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED); 746 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED); 747 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 748 749 printf("Enable Volume Change notification\n"); 750 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED); 751 printf("Enable Battery Status Change notification\n"); 752 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED); 753 return; 754 755 case AVRCP_SUBEVENT_CONNECTION_RELEASED: 756 printf("AVRCP Target: Disconnected, avrcp_cid 0x%02x\n", avrcp_subevent_connection_released_get_avrcp_cid(packet)); 757 media_tracker.avrcp_cid = 0; 758 return; 759 default: 760 break; 761 } 762 763 if (status != ERROR_CODE_SUCCESS){ 764 printf("Responding to event 0x%02x failed with status 0x%02x\n", packet[2], status); 765 } 766 } 767 768 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 769 UNUSED(channel); 770 UNUSED(size); 771 uint8_t status = ERROR_CODE_SUCCESS; 772 773 if (packet_type != HCI_EVENT_PACKET) return; 774 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 775 776 bool button_pressed; 777 char const * button_state; 778 avrcp_operation_id_t operation_id; 779 780 switch (packet[2]){ 781 case AVRCP_SUBEVENT_PLAY_STATUS_QUERY: 782 status = avrcp_target_play_status(media_tracker.avrcp_cid, play_info.song_length_ms, play_info.song_position_ms, play_info.status); 783 break; 784 // case AVRCP_SUBEVENT_NOW_PLAYING_INFO_QUERY: 785 // status = avrcp_target_now_playing_info(avrcp_cid); 786 // break; 787 case AVRCP_SUBEVENT_OPERATION: 788 operation_id = avrcp_subevent_operation_get_operation_id(packet); 789 button_pressed = avrcp_subevent_operation_get_button_pressed(packet) > 0; 790 button_state = button_pressed ? "PRESS" : "RELEASE"; 791 792 printf("AVRCP Target: operation %s (%s)\n", avrcp_operation2str(operation_id), button_state); 793 794 if (!button_pressed){ 795 break; 796 } 797 switch (operation_id) { 798 case AVRCP_OPERATION_ID_PLAY: 799 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 800 break; 801 case AVRCP_OPERATION_ID_PAUSE: 802 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 803 break; 804 case AVRCP_OPERATION_ID_STOP: 805 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 806 break; 807 default: 808 break; 809 } 810 break; 811 default: 812 break; 813 } 814 815 if (status != ERROR_CODE_SUCCESS){ 816 printf("Responding to event 0x%02x failed with status 0x%02x\n", packet[2], status); 817 } 818 } 819 820 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 821 UNUSED(channel); 822 UNUSED(size); 823 824 if (packet_type != HCI_EVENT_PACKET) return; 825 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 826 if (!media_tracker.avrcp_cid) return; 827 828 switch (packet[2]){ 829 case AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED: 830 printf("AVRCP Controller: Notification Absolute Volume %d %%\n", avrcp_subevent_notification_volume_changed_get_absolute_volume(packet) * 100 / 127); 831 break; 832 case AVRCP_SUBEVENT_NOTIFICATION_EVENT_BATT_STATUS_CHANGED: 833 // see avrcp_battery_status_t 834 printf("AVRCP Controller: Notification Battery Status %d\n", avrcp_subevent_notification_event_batt_status_changed_get_battery_status(packet)); 835 break; 836 case AVRCP_SUBEVENT_NOTIFICATION_STATE: 837 printf("AVRCP Controller: Notification %s - %s\n", 838 avrcp_event2str(avrcp_subevent_notification_state_get_event_id(packet)), 839 avrcp_subevent_notification_state_get_enabled(packet) != 0 ? "enabled" : "disabled"); 840 break; 841 default: 842 break; 843 } 844 } 845 846 #ifdef HAVE_BTSTACK_STDIN 847 static void show_usage(void){ 848 bd_addr_t iut_address; 849 gap_local_bd_addr(iut_address); 850 printf("\n--- Bluetooth A2DP Source/AVRCP Demo %s ---\n", bd_addr_to_str(iut_address)); 851 printf("b - A2DP Source create connection to addr %s\n", device_addr_string); 852 printf("B - A2DP Source disconnect\n"); 853 printf("c - AVRCP create connection to addr %s\n", device_addr_string); 854 printf("C - AVRCP disconnect\n"); 855 printf("D - delete all link keys\n"); 856 857 printf("x - start streaming sine\n"); 858 if (hxcmod_initialized){ 859 printf("z - start streaming '%s'\n", mod_name); 860 } 861 printf("p - pause streaming\n"); 862 printf("w - reconfigure stream for 44100 Hz\n"); 863 printf("e - reconfigure stream for 48000 Hz\n"); 864 printf("t - volume up\n"); 865 printf("T - volume down\n"); 866 printf("v - volume up (via set absolute volume)\n"); 867 printf("V - volume down (via set absolute volume)\n"); 868 869 printf("---\n"); 870 } 871 872 static void stdin_process(char cmd){ 873 uint8_t status = ERROR_CODE_SUCCESS; 874 switch (cmd){ 875 case 'b': 876 status = a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid); 877 printf("%c - Create A2DP Source connection to addr %s, cid 0x%02x.\n", cmd, bd_addr_to_str(device_addr), media_tracker.a2dp_cid); 878 break; 879 case 'B': 880 printf("%c - A2DP Source Disconnect from cid 0x%2x\n", cmd, media_tracker.a2dp_cid); 881 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 882 break; 883 case 'c': 884 printf("%c - Create AVRCP connection to addr %s.\n", cmd, bd_addr_to_str(device_addr)); 885 status = avrcp_connect(device_addr, &media_tracker.avrcp_cid); 886 break; 887 case 'C': 888 printf("%c - AVRCP disconnect\n", cmd); 889 status = avrcp_disconnect(media_tracker.avrcp_cid); 890 break; 891 case 'D': 892 printf("Deleting all link keys\n"); 893 gap_delete_all_link_keys(); 894 break; 895 case '\n': 896 case '\r': 897 break; 898 899 case 't': 900 printf(" - volume up\n"); 901 status = avrcp_controller_volume_up(media_tracker.avrcp_cid); 902 break; 903 case 'T': 904 printf(" - volume down\n"); 905 status = avrcp_controller_volume_down(media_tracker.avrcp_cid); 906 break; 907 908 case 'v': 909 if (media_tracker.volume > 117){ 910 media_tracker.volume = 127; 911 } else { 912 media_tracker.volume += 10; 913 } 914 printf(" - volume up (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 100 / 127, media_tracker.volume); 915 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 916 break; 917 case 'V': 918 if (media_tracker.volume < 10){ 919 media_tracker.volume = 0; 920 } else { 921 media_tracker.volume -= 10; 922 } 923 printf(" - volume down (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 100 / 127, media_tracker.volume); 924 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 925 break; 926 927 case 'x': 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 sine.\n", cmd); 932 data_source = STREAM_SINE; 933 if (!media_tracker.stream_opened) break; 934 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 935 break; 936 case 'z': 937 if (media_tracker.avrcp_cid){ 938 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 939 } 940 printf("%c - Play mod.\n", cmd); 941 data_source = STREAM_MOD; 942 if (!media_tracker.stream_opened) break; 943 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 944 break; 945 946 case 'p': 947 if (!media_tracker.stream_opened) break; 948 printf("%c - Pause stream.\n", cmd); 949 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 950 break; 951 952 case 'w': 953 if (!media_tracker.stream_opened) break; 954 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 955 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 956 break; 957 } 958 new_sample_rate = 44100; 959 if (current_sample_rate == new_sample_rate){ 960 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate); 961 } else { 962 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate); 963 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate); 964 } 965 break; 966 967 case 'e': 968 if (!media_tracker.stream_opened) break; 969 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 970 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 971 break; 972 } 973 new_sample_rate = 48000; 974 if (current_sample_rate == new_sample_rate){ 975 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate); 976 } else { 977 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate); 978 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate); 979 } 980 break; 981 982 default: 983 show_usage(); 984 return; 985 } 986 if (status != ERROR_CODE_SUCCESS){ 987 printf("Could not perform command \'%c\', status 0x%02x\n", cmd, status); 988 } 989 } 990 #endif 991 992 993 int btstack_main(int argc, const char * argv[]); 994 int btstack_main(int argc, const char * argv[]){ 995 (void)argc; 996 (void)argv; 997 998 int err = a2dp_source_and_avrcp_services_init(); 999 if (err) return err; 1000 // turn on! 1001 hci_power_control(HCI_POWER_ON); 1002 return 0; 1003 } 1004 /* EXAMPLE_END */ 1005