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