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 <inttypes.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 uint32_t rtp_timestamp; 105 106 uint8_t sbc_storage[SBC_STORAGE_SIZE]; 107 uint16_t sbc_storage_count; 108 uint8_t sbc_ready_to_send; 109 110 uint8_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 static const int A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS = 12; 152 153 typedef struct { 154 int reconfigure; 155 156 int num_channels; 157 int sampling_frequency; 158 int block_length; 159 int subbands; 160 int min_bitpool_value; 161 int max_bitpool_value; 162 btstack_sbc_channel_mode_t channel_mode; 163 btstack_sbc_allocation_method_t allocation_method; 164 } media_codec_configuration_sbc_t; 165 166 static btstack_packet_callback_registration_t hci_event_callback_registration; 167 168 // Minijambox: 169 static const char * device_addr_string = "00:21:3C:AC:F7:38"; 170 171 static bd_addr_t device_addr; 172 static bool scan_active; 173 174 static uint8_t sdp_a2dp_source_service_buffer[150]; 175 static uint8_t sdp_avrcp_target_service_buffer[200]; 176 static uint8_t sdp_avrcp_controller_service_buffer[200]; 177 static uint8_t device_id_sdp_service_buffer[100]; 178 179 static media_codec_configuration_sbc_t sbc_configuration; 180 static btstack_sbc_encoder_state_t sbc_encoder_state; 181 182 static uint8_t media_sbc_codec_configuration[4]; 183 static a2dp_media_sending_context_t media_tracker; 184 185 static stream_data_source_t data_source; 186 187 static int sine_phase; 188 static int current_sample_rate = 44100; 189 static int new_sample_rate = 44100; 190 191 static int hxcmod_initialized; 192 static modcontext mod_context; 193 static tracker_buffer_state trkbuf; 194 195 /* AVRCP Target context START */ 196 197 typedef struct { 198 uint8_t track_id[8]; 199 uint32_t song_length_ms; 200 avrcp_playback_status_t status; 201 uint32_t song_position_ms; // 0xFFFFFFFF if not supported 202 } avrcp_play_status_info_t; 203 204 // python -c "print('a'*512)" 205 static const char title[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; 206 207 avrcp_track_t tracks[] = { 208 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 1, "Sine", "Generated", "A2DP Source Demo", "monotone", 12345}, 209 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}, 2, "Nao-deceased", "Decease", "A2DP Source Demo", "vivid", 12345}, 210 {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}, 3, (char *)title, "Decease", "A2DP Source Demo", "vivid", 12345}, 211 }; 212 int current_track_index; 213 avrcp_play_status_info_t play_info; 214 215 /* AVRCP Target context END */ 216 217 /* @section Main Application Setup 218 * 219 * @text The Listing MainConfiguration shows how to setup AD2P Source and AVRCP services. 220 * Besides calling init() method for each service, you'll also need to register several packet handlers: 221 * - hci_packet_handler - handles legacy pairing, here by using fixed '0000' pin code. 222 * - 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). 223 * - avrcp_packet_handler - receives connect/disconnect event. 224 * - avrcp_controller_packet_handler - receives answers for sent AVRCP commands. 225 * - avrcp_target_packet_handler - receives AVRCP commands, and registered notifications. 226 * - 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. 227 * 228 * @text To announce A2DP Source and AVRCP services, you need to create corresponding 229 * SDP records and register them with the SDP service. 230 */ 231 232 /* LISTING_START(MainConfiguration): Setup Audio Source and AVRCP Target services */ 233 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 234 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t * event, uint16_t event_size); 235 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 236 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 237 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); 238 #ifdef HAVE_BTSTACK_STDIN 239 static void stdin_process(char cmd); 240 #endif 241 242 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate); 243 244 static int a2dp_source_and_avrcp_services_init(void){ 245 246 // Request role change on reconnecting headset to always use them in slave mode 247 hci_set_master_slave_policy(0); 248 // enabled EIR 249 hci_set_inquiry_mode(INQUIRY_MODE_RSSI_AND_EIR); 250 251 l2cap_init(); 252 253 #ifdef ENABLE_BLE 254 // Initialize LE Security Manager. Needed for cross-transport key derivation 255 sm_init(); 256 #endif 257 258 // Initialize A2DP Source 259 a2dp_source_init(); 260 a2dp_source_register_packet_handler(&a2dp_source_packet_handler); 261 262 // Create stream endpoint 263 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)); 264 if (!local_stream_endpoint){ 265 printf("A2DP Source: not enough memory to create local stream endpoint\n"); 266 return 1; 267 } 268 269 // Store stream enpoint's SEP ID, as it is used by A2DP API to indentify the stream endpoint 270 media_tracker.local_seid = avdtp_local_seid(local_stream_endpoint); 271 avdtp_source_register_delay_reporting_category(media_tracker.local_seid); 272 273 // Initialize AVRCP Service 274 avrcp_init(); 275 avrcp_register_packet_handler(&avrcp_packet_handler); 276 // Initialize AVRCP Target 277 avrcp_target_init(); 278 avrcp_target_register_packet_handler(&avrcp_target_packet_handler); 279 280 // Initialize AVRCP Controller 281 avrcp_controller_init(); 282 avrcp_controller_register_packet_handler(&avrcp_controller_packet_handler); 283 284 // Initialize SDP, 285 sdp_init(); 286 287 // Create A2DP Source service record and register it with SDP 288 memset(sdp_a2dp_source_service_buffer, 0, sizeof(sdp_a2dp_source_service_buffer)); 289 a2dp_source_create_sdp_record(sdp_a2dp_source_service_buffer, sdp_create_service_record_handle(), AVDTP_SOURCE_FEATURE_MASK_PLAYER, NULL, NULL); 290 btstack_assert(de_get_len( sdp_a2dp_source_service_buffer) <= sizeof(sdp_a2dp_source_service_buffer)); 291 sdp_register_service(sdp_a2dp_source_service_buffer); 292 293 // Create AVRCP Target service record and register it with SDP. We receive Category 1 commands from the headphone, e.g. play/pause 294 memset(sdp_avrcp_target_service_buffer, 0, sizeof(sdp_avrcp_target_service_buffer)); 295 uint16_t supported_features = AVRCP_FEATURE_MASK_CATEGORY_PLAYER_OR_RECORDER; 296 #ifdef AVRCP_BROWSING_ENABLED 297 supported_features |= AVRCP_FEATURE_MASK_BROWSING; 298 #endif 299 avrcp_target_create_sdp_record(sdp_avrcp_target_service_buffer, sdp_create_service_record_handle(), supported_features, NULL, NULL); 300 btstack_assert(de_get_len( sdp_avrcp_target_service_buffer) <= sizeof(sdp_avrcp_target_service_buffer)); 301 sdp_register_service(sdp_avrcp_target_service_buffer); 302 303 // Create AVRCP Controller service record and register it with SDP. We send Category 2 commands to the headphone, e.g. volume up/down 304 memset(sdp_avrcp_controller_service_buffer, 0, sizeof(sdp_avrcp_controller_service_buffer)); 305 uint16_t controller_supported_features = AVRCP_FEATURE_MASK_CATEGORY_MONITOR_OR_AMPLIFIER; 306 avrcp_controller_create_sdp_record(sdp_avrcp_controller_service_buffer, sdp_create_service_record_handle(), controller_supported_features, NULL, NULL); 307 btstack_assert(de_get_len( sdp_avrcp_controller_service_buffer) <= sizeof(sdp_avrcp_controller_service_buffer)); 308 sdp_register_service(sdp_avrcp_controller_service_buffer); 309 310 // Register Device ID (PnP) service SDP record 311 memset(device_id_sdp_service_buffer, 0, sizeof(device_id_sdp_service_buffer)); 312 device_id_create_sdp_record(device_id_sdp_service_buffer, sdp_create_service_record_handle(), DEVICE_ID_VENDOR_ID_SOURCE_BLUETOOTH, BLUETOOTH_COMPANY_ID_BLUEKITCHEN_GMBH, 1, 1); 313 btstack_assert(de_get_len( device_id_sdp_service_buffer) <= sizeof(device_id_sdp_service_buffer)); 314 sdp_register_service(device_id_sdp_service_buffer); 315 316 // Set local name with a template Bluetooth address, that will be automatically 317 // replaced with a actual address once it is available, i.e. when BTstack boots 318 // up and starts talking to a Bluetooth module. 319 gap_set_local_name("A2DP Source 00:00:00:00:00:00"); 320 gap_discoverable_control(1); 321 gap_set_class_of_device(0x200408); 322 323 // Register for HCI events. 324 hci_event_callback_registration.callback = &hci_packet_handler; 325 hci_add_event_handler(&hci_event_callback_registration); 326 327 a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate); 328 data_source = STREAM_MOD; 329 330 // Parse human readable Bluetooth address. 331 sscanf_bd_addr(device_addr_string, device_addr); 332 333 #ifdef HAVE_BTSTACK_STDIN 334 btstack_stdin_setup(stdin_process); 335 #endif 336 return 0; 337 } 338 /* LISTING_END */ 339 340 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate){ 341 if (!hxcmod_initialized){ 342 hxcmod_initialized = hxcmod_init(&mod_context); 343 if (!hxcmod_initialized) { 344 printf("could not initialize hxcmod\n"); 345 return; 346 } 347 } 348 current_sample_rate = sample_rate; 349 media_tracker.sbc_storage_count = 0; 350 media_tracker.samples_ready = 0; 351 hxcmod_unload(&mod_context); 352 hxcmod_setcfg(&mod_context, current_sample_rate, 16, 1, 1, 1); 353 hxcmod_load(&mod_context, (void *) &mod_data, mod_len); 354 } 355 356 static void a2dp_demo_send_media_packet(void){ 357 int num_bytes_in_frame = btstack_sbc_encoder_sbc_buffer_length(); 358 int bytes_in_storage = media_tracker.sbc_storage_count; 359 uint8_t num_sbc_frames = bytes_in_storage / num_bytes_in_frame; 360 // Prepend SBC Header 361 media_tracker.sbc_storage[0] = num_sbc_frames; // (fragmentation << 7) | (starting_packet << 6) | (last_packet << 5) | num_frames; 362 a2dp_source_stream_send_media_payload_rtp(media_tracker.a2dp_cid, media_tracker.local_seid, 0, 363 media_tracker.rtp_timestamp, 364 media_tracker.sbc_storage, bytes_in_storage + 1); 365 366 // update rtp_timestamp 367 unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames(); 368 media_tracker.rtp_timestamp += num_sbc_frames * num_audio_samples_per_sbc_buffer; 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 a2dp_source_demo_start_scanning(void){ 517 printf("Start scanning...\n"); 518 gap_inquiry_start(A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS); 519 scan_active = true; 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 uint8_t status; 527 UNUSED(status); 528 529 bd_addr_t address; 530 uint32_t cod; 531 532 // Service Class: Rendering | Audio, Major Device Class: Audio 533 const uint32_t bluetooth_speaker_cod = 0x200000 | 0x040000 | 0x000400; 534 535 switch (hci_event_packet_get_type(packet)){ 536 #ifndef HAVE_BTSTACK_STDIN 537 case BTSTACK_EVENT_STATE: 538 if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) return; 539 a2dp_source_demo_start_scanning(); 540 break; 541 #endif 542 case HCI_EVENT_PIN_CODE_REQUEST: 543 printf("Pin code request - using '0000'\n"); 544 hci_event_pin_code_request_get_bd_addr(packet, address); 545 gap_pin_code_response(address, "0000"); 546 break; 547 case GAP_EVENT_INQUIRY_RESULT: 548 gap_event_inquiry_result_get_bd_addr(packet, address); 549 // print info 550 printf("Device found: %s ", bd_addr_to_str(address)); 551 cod = gap_event_inquiry_result_get_class_of_device(packet); 552 printf("with COD: %06" PRIx32, cod); 553 if (gap_event_inquiry_result_get_rssi_available(packet)){ 554 printf(", rssi %d dBm", (int8_t) gap_event_inquiry_result_get_rssi(packet)); 555 } 556 if (gap_event_inquiry_result_get_name_available(packet)){ 557 char name_buffer[240]; 558 int name_len = gap_event_inquiry_result_get_name_len(packet); 559 memcpy(name_buffer, gap_event_inquiry_result_get_name(packet), name_len); 560 name_buffer[name_len] = 0; 561 printf(", name '%s'", name_buffer); 562 } 563 printf("\n"); 564 if ((cod & bluetooth_speaker_cod) == bluetooth_speaker_cod){ 565 memcpy(device_addr, address, 6); 566 printf("Bluetooth speaker detected, trying to connect to %s...\n", bd_addr_to_str(device_addr)); 567 scan_active = false; 568 gap_inquiry_stop(); 569 a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid); 570 } 571 break; 572 case GAP_EVENT_INQUIRY_COMPLETE: 573 if (scan_active){ 574 printf("No Bluetooth speakers found, scanning again...\n"); 575 gap_inquiry_start(A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS); 576 } 577 break; 578 default: 579 break; 580 } 581 } 582 583 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 584 UNUSED(channel); 585 UNUSED(size); 586 uint8_t status; 587 uint8_t local_seid; 588 bd_addr_t address; 589 uint16_t cid; 590 591 avdtp_channel_mode_t channel_mode; 592 uint8_t allocation_method; 593 594 if (packet_type != HCI_EVENT_PACKET) return; 595 if (hci_event_packet_get_type(packet) != HCI_EVENT_A2DP_META) return; 596 597 switch (hci_event_a2dp_meta_get_subevent_code(packet)){ 598 case A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED: 599 a2dp_subevent_signaling_connection_established_get_bd_addr(packet, address); 600 cid = a2dp_subevent_signaling_connection_established_get_a2dp_cid(packet); 601 status = a2dp_subevent_signaling_connection_established_get_status(packet); 602 603 if (status != ERROR_CODE_SUCCESS){ 604 printf("A2DP Source: Connection failed, status 0x%02x, cid 0x%02x, a2dp_cid 0x%02x \n", status, cid, media_tracker.a2dp_cid); 605 media_tracker.a2dp_cid = 0; 606 break; 607 } 608 media_tracker.a2dp_cid = cid; 609 media_tracker.volume = 32; 610 611 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); 612 break; 613 614 case A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION:{ 615 cid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(packet); 616 if (cid != media_tracker.a2dp_cid) return; 617 618 media_tracker.remote_seid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet); 619 620 sbc_configuration.reconfigure = a2dp_subevent_signaling_media_codec_sbc_configuration_get_reconfigure(packet); 621 sbc_configuration.num_channels = a2dp_subevent_signaling_media_codec_sbc_configuration_get_num_channels(packet); 622 sbc_configuration.sampling_frequency = a2dp_subevent_signaling_media_codec_sbc_configuration_get_sampling_frequency(packet); 623 sbc_configuration.block_length = a2dp_subevent_signaling_media_codec_sbc_configuration_get_block_length(packet); 624 sbc_configuration.subbands = a2dp_subevent_signaling_media_codec_sbc_configuration_get_subbands(packet); 625 sbc_configuration.min_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_min_bitpool_value(packet); 626 sbc_configuration.max_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_max_bitpool_value(packet); 627 628 channel_mode = (avdtp_channel_mode_t) a2dp_subevent_signaling_media_codec_sbc_configuration_get_channel_mode(packet); 629 allocation_method = a2dp_subevent_signaling_media_codec_sbc_configuration_get_allocation_method(packet); 630 631 printf("A2DP Source: Received SBC codec configuration, sampling frequency %u, a2dp_cid 0x%02x, local seid 0x%02x, remote seid 0x%02x.\n", 632 sbc_configuration.sampling_frequency, cid, 633 a2dp_subevent_signaling_media_codec_sbc_configuration_get_local_seid(packet), 634 a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet)); 635 636 // Adapt Bluetooth spec definition to SBC Encoder expected input 637 sbc_configuration.allocation_method = (btstack_sbc_allocation_method_t)(allocation_method - 1); 638 switch (channel_mode){ 639 case AVDTP_CHANNEL_MODE_JOINT_STEREO: 640 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO; 641 break; 642 case AVDTP_CHANNEL_MODE_STEREO: 643 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_STEREO; 644 break; 645 case AVDTP_CHANNEL_MODE_DUAL_CHANNEL: 646 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL; 647 break; 648 case AVDTP_CHANNEL_MODE_MONO: 649 sbc_configuration.channel_mode = SBC_CHANNEL_MODE_MONO; 650 break; 651 default: 652 btstack_assert(false); 653 break; 654 } 655 dump_sbc_configuration(&sbc_configuration); 656 657 btstack_sbc_encoder_init(&sbc_encoder_state, SBC_MODE_STANDARD, 658 sbc_configuration.block_length, sbc_configuration.subbands, 659 sbc_configuration.allocation_method, sbc_configuration.sampling_frequency, 660 sbc_configuration.max_bitpool_value, 661 sbc_configuration.channel_mode); 662 break; 663 } 664 665 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY: 666 printf("A2DP Source: remote supports delay report, remote seid %d\n", 667 avdtp_subevent_signaling_delay_reporting_capability_get_remote_seid(packet)); 668 break; 669 case A2DP_SUBEVENT_SIGNALING_CAPABILITIES_DONE: 670 printf("A2DP Source: All capabilities reported, remote seid %d\n", 671 avdtp_subevent_signaling_capabilities_done_get_remote_seid(packet)); 672 break; 673 674 case A2DP_SUBEVENT_SIGNALING_DELAY_REPORT: 675 printf("A2DP Source: Received delay report of %d.%0d ms, local seid %d\n", 676 avdtp_subevent_signaling_delay_report_get_delay_100us(packet)/10, avdtp_subevent_signaling_delay_report_get_delay_100us(packet)%10, 677 avdtp_subevent_signaling_delay_report_get_local_seid(packet)); 678 break; 679 680 case A2DP_SUBEVENT_STREAM_ESTABLISHED: 681 a2dp_subevent_stream_established_get_bd_addr(packet, address); 682 status = a2dp_subevent_stream_established_get_status(packet); 683 if (status != ERROR_CODE_SUCCESS){ 684 printf("A2DP Source: Stream failed, status 0x%02x.\n", status); 685 break; 686 } 687 688 local_seid = a2dp_subevent_stream_established_get_local_seid(packet); 689 cid = a2dp_subevent_stream_established_get_a2dp_cid(packet); 690 691 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)); 692 693 a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate); 694 media_tracker.stream_opened = 1; 695 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 696 break; 697 698 case A2DP_SUBEVENT_STREAM_RECONFIGURED: 699 status = a2dp_subevent_stream_reconfigured_get_status(packet); 700 local_seid = a2dp_subevent_stream_reconfigured_get_local_seid(packet); 701 cid = a2dp_subevent_stream_reconfigured_get_a2dp_cid(packet); 702 703 if (status != ERROR_CODE_SUCCESS){ 704 printf("A2DP Source: Stream reconfiguration failed, status 0x%02x\n", status); 705 break; 706 } 707 708 printf("A2DP Source: Stream reconfigured a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 709 a2dp_demo_hexcmod_configure_sample_rate(new_sample_rate); 710 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 711 break; 712 713 case A2DP_SUBEVENT_STREAM_STARTED: 714 local_seid = a2dp_subevent_stream_started_get_local_seid(packet); 715 cid = a2dp_subevent_stream_started_get_a2dp_cid(packet); 716 717 play_info.status = AVRCP_PLAYBACK_STATUS_PLAYING; 718 if (media_tracker.avrcp_cid){ 719 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 720 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PLAYING); 721 } 722 a2dp_demo_timer_start(&media_tracker); 723 printf("A2DP Source: Stream started, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 724 break; 725 726 case A2DP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW: 727 local_seid = a2dp_subevent_streaming_can_send_media_packet_now_get_local_seid(packet); 728 cid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_a2dp_cid(packet); 729 a2dp_demo_send_media_packet(); 730 break; 731 732 case A2DP_SUBEVENT_STREAM_SUSPENDED: 733 local_seid = a2dp_subevent_stream_suspended_get_local_seid(packet); 734 cid = a2dp_subevent_stream_suspended_get_a2dp_cid(packet); 735 736 play_info.status = AVRCP_PLAYBACK_STATUS_PAUSED; 737 if (media_tracker.avrcp_cid){ 738 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PAUSED); 739 } 740 printf("A2DP Source: Stream paused, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 741 742 a2dp_demo_timer_stop(&media_tracker); 743 break; 744 745 case A2DP_SUBEVENT_STREAM_RELEASED: 746 play_info.status = AVRCP_PLAYBACK_STATUS_STOPPED; 747 cid = a2dp_subevent_stream_released_get_a2dp_cid(packet); 748 local_seid = a2dp_subevent_stream_released_get_local_seid(packet); 749 750 printf("A2DP Source: Stream released, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid); 751 752 if (cid == media_tracker.a2dp_cid) { 753 media_tracker.stream_opened = 0; 754 printf("A2DP Source: Stream released.\n"); 755 } 756 if (media_tracker.avrcp_cid){ 757 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 758 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_STOPPED); 759 } 760 a2dp_demo_timer_stop(&media_tracker); 761 break; 762 case A2DP_SUBEVENT_SIGNALING_CONNECTION_RELEASED: 763 cid = a2dp_subevent_signaling_connection_released_get_a2dp_cid(packet); 764 if (cid == media_tracker.a2dp_cid) { 765 media_tracker.avrcp_cid = 0; 766 media_tracker.a2dp_cid = 0; 767 printf("A2DP Source: Signaling released.\n\n"); 768 } 769 break; 770 default: 771 break; 772 } 773 } 774 775 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 776 UNUSED(channel); 777 UNUSED(size); 778 bd_addr_t event_addr; 779 uint16_t local_cid; 780 uint8_t status = ERROR_CODE_SUCCESS; 781 782 if (packet_type != HCI_EVENT_PACKET) return; 783 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 784 785 switch (packet[2]){ 786 case AVRCP_SUBEVENT_CONNECTION_ESTABLISHED: 787 local_cid = avrcp_subevent_connection_established_get_avrcp_cid(packet); 788 status = avrcp_subevent_connection_established_get_status(packet); 789 if (status != ERROR_CODE_SUCCESS){ 790 printf("AVRCP: Connection failed, local cid 0x%02x, status 0x%02x\n", local_cid, status); 791 return; 792 } 793 media_tracker.avrcp_cid = local_cid; 794 avrcp_subevent_connection_established_get_bd_addr(packet, event_addr); 795 796 printf("AVRCP: Channel to %s successfully opened, avrcp_cid 0x%02x\n", bd_addr_to_str(event_addr), media_tracker.avrcp_cid); 797 798 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED); 799 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED); 800 avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED); 801 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t)); 802 803 printf("Enable Volume Change notification\n"); 804 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED); 805 printf("Enable Battery Status Change notification\n"); 806 avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED); 807 return; 808 809 case AVRCP_SUBEVENT_CONNECTION_RELEASED: 810 printf("AVRCP Target: Disconnected, avrcp_cid 0x%02x\n", avrcp_subevent_connection_released_get_avrcp_cid(packet)); 811 media_tracker.avrcp_cid = 0; 812 return; 813 default: 814 break; 815 } 816 817 if (status != ERROR_CODE_SUCCESS){ 818 printf("Responding to event 0x%02x failed, status 0x%02x\n", packet[2], status); 819 } 820 } 821 822 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 823 UNUSED(channel); 824 UNUSED(size); 825 uint8_t status = ERROR_CODE_SUCCESS; 826 827 if (packet_type != HCI_EVENT_PACKET) return; 828 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 829 830 bool button_pressed; 831 char const * button_state; 832 avrcp_operation_id_t operation_id; 833 834 switch (packet[2]){ 835 case AVRCP_SUBEVENT_PLAY_STATUS_QUERY: 836 status = avrcp_target_play_status(media_tracker.avrcp_cid, play_info.song_length_ms, play_info.song_position_ms, play_info.status); 837 break; 838 // case AVRCP_SUBEVENT_NOW_PLAYING_INFO_QUERY: 839 // status = avrcp_target_now_playing_info(avrcp_cid); 840 // break; 841 case AVRCP_SUBEVENT_OPERATION: 842 operation_id = avrcp_subevent_operation_get_operation_id(packet); 843 button_pressed = avrcp_subevent_operation_get_button_pressed(packet) > 0; 844 button_state = button_pressed ? "PRESS" : "RELEASE"; 845 846 printf("AVRCP Target: operation %s (%s)\n", avrcp_operation2str(operation_id), button_state); 847 848 if (!button_pressed){ 849 break; 850 } 851 switch (operation_id) { 852 case AVRCP_OPERATION_ID_PLAY: 853 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 854 break; 855 case AVRCP_OPERATION_ID_PAUSE: 856 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 857 break; 858 case AVRCP_OPERATION_ID_STOP: 859 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 860 break; 861 default: 862 break; 863 } 864 break; 865 default: 866 break; 867 } 868 869 if (status != ERROR_CODE_SUCCESS){ 870 printf("Responding to event 0x%02x failed, status 0x%02x\n", packet[2], status); 871 } 872 } 873 874 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){ 875 UNUSED(channel); 876 UNUSED(size); 877 878 if (packet_type != HCI_EVENT_PACKET) return; 879 if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return; 880 if (!media_tracker.avrcp_cid) return; 881 882 switch (packet[2]){ 883 case AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED: 884 printf("AVRCP Controller: Notification Absolute Volume %d %%\n", avrcp_subevent_notification_volume_changed_get_absolute_volume(packet) * 100 / 127); 885 break; 886 case AVRCP_SUBEVENT_NOTIFICATION_EVENT_BATT_STATUS_CHANGED: 887 // see avrcp_battery_status_t 888 printf("AVRCP Controller: Notification Battery Status 0x%02x\n", avrcp_subevent_notification_event_batt_status_changed_get_battery_status(packet)); 889 break; 890 case AVRCP_SUBEVENT_NOTIFICATION_STATE: 891 printf("AVRCP Controller: Notification %s - %s\n", 892 avrcp_event2str(avrcp_subevent_notification_state_get_event_id(packet)), 893 avrcp_subevent_notification_state_get_enabled(packet) != 0 ? "enabled" : "disabled"); 894 break; 895 default: 896 break; 897 } 898 } 899 900 #ifdef HAVE_BTSTACK_STDIN 901 static void show_usage(void){ 902 bd_addr_t iut_address; 903 gap_local_bd_addr(iut_address); 904 printf("\n--- Bluetooth A2DP Source/AVRCP Demo %s ---\n", bd_addr_to_str(iut_address)); 905 printf("a - Scan for Bluetooth speaker and connect\n"); 906 printf("b - A2DP Source create connection to addr %s\n", device_addr_string); 907 printf("B - A2DP Source disconnect\n"); 908 printf("c - AVRCP create connection to addr %s\n", device_addr_string); 909 printf("C - AVRCP disconnect\n"); 910 printf("D - delete all link keys\n"); 911 912 printf("x - start streaming sine\n"); 913 if (hxcmod_initialized){ 914 printf("z - start streaming '%s'\n", mod_name); 915 } 916 printf("p - pause streaming\n"); 917 printf("w - reconfigure stream for 44100 Hz\n"); 918 printf("e - reconfigure stream for 48000 Hz\n"); 919 printf("t - volume up\n"); 920 printf("T - volume down\n"); 921 printf("v - volume up (via set absolute volume)\n"); 922 printf("V - volume down (via set absolute volume)\n"); 923 924 printf("---\n"); 925 } 926 927 static void stdin_process(char cmd){ 928 uint8_t status = ERROR_CODE_SUCCESS; 929 switch (cmd){ 930 case 'a': 931 a2dp_source_demo_start_scanning(); 932 break; 933 case 'b': 934 status = a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid); 935 printf("%c - Create A2DP Source connection to addr %s, cid 0x%02x.\n", cmd, bd_addr_to_str(device_addr), media_tracker.a2dp_cid); 936 break; 937 case 'B': 938 printf("%c - A2DP Source Disconnect from cid 0x%2x\n", cmd, media_tracker.a2dp_cid); 939 status = a2dp_source_disconnect(media_tracker.a2dp_cid); 940 break; 941 case 'c': 942 printf("%c - Create AVRCP connection to addr %s.\n", cmd, bd_addr_to_str(device_addr)); 943 status = avrcp_connect(device_addr, &media_tracker.avrcp_cid); 944 break; 945 case 'C': 946 printf("%c - AVRCP disconnect\n", cmd); 947 status = avrcp_disconnect(media_tracker.avrcp_cid); 948 break; 949 case 'D': 950 printf("Deleting all link keys\n"); 951 gap_delete_all_link_keys(); 952 break; 953 case '\n': 954 case '\r': 955 break; 956 957 case 't': 958 printf(" - volume up\n"); 959 status = avrcp_controller_volume_up(media_tracker.avrcp_cid); 960 break; 961 case 'T': 962 printf(" - volume down\n"); 963 status = avrcp_controller_volume_down(media_tracker.avrcp_cid); 964 break; 965 966 case 'v': 967 if (media_tracker.volume > 117){ 968 media_tracker.volume = 127; 969 } else { 970 media_tracker.volume += 10; 971 } 972 printf(" - volume up (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 100 / 127, media_tracker.volume); 973 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 974 break; 975 case 'V': 976 if (media_tracker.volume < 10){ 977 media_tracker.volume = 0; 978 } else { 979 media_tracker.volume -= 10; 980 } 981 printf(" - volume down (via set absolute volume) %d%% (%d)\n", media_tracker.volume * 100 / 127, media_tracker.volume); 982 status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume); 983 break; 984 985 case 'x': 986 if (media_tracker.avrcp_cid){ 987 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 988 } 989 printf("%c - Play sine.\n", cmd); 990 data_source = STREAM_SINE; 991 if (!media_tracker.stream_opened) break; 992 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 993 break; 994 case 'z': 995 if (media_tracker.avrcp_cid){ 996 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t)); 997 } 998 printf("%c - Play mod.\n", cmd); 999 data_source = STREAM_MOD; 1000 if (!media_tracker.stream_opened) break; 1001 status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 1002 break; 1003 1004 case 'p': 1005 if (!media_tracker.stream_opened) break; 1006 printf("%c - Pause stream.\n", cmd); 1007 status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid); 1008 break; 1009 1010 case 'w': 1011 if (!media_tracker.stream_opened) break; 1012 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 1013 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 1014 break; 1015 } 1016 new_sample_rate = 44100; 1017 if (current_sample_rate == new_sample_rate){ 1018 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate); 1019 } else { 1020 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate); 1021 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate); 1022 } 1023 break; 1024 1025 case 'e': 1026 if (!media_tracker.stream_opened) break; 1027 if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){ 1028 printf("Stream cannot be reconfigured while playing, please pause stream first\n"); 1029 break; 1030 } 1031 new_sample_rate = 48000; 1032 if (current_sample_rate == new_sample_rate){ 1033 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate); 1034 } else { 1035 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate); 1036 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate); 1037 } 1038 break; 1039 1040 default: 1041 show_usage(); 1042 return; 1043 } 1044 if (status != ERROR_CODE_SUCCESS){ 1045 printf("Could not perform command \'%c\', status 0x%02x\n", cmd, status); 1046 } 1047 } 1048 #endif 1049 1050 1051 int btstack_main(int argc, const char * argv[]); 1052 int btstack_main(int argc, const char * argv[]){ 1053 (void)argc; 1054 (void)argv; 1055 1056 int err = a2dp_source_and_avrcp_services_init(); 1057 if (err) return err; 1058 // turn on! 1059 hci_power_control(HCI_POWER_ON); 1060 return 0; 1061 } 1062 /* EXAMPLE_END */ 1063