xref: /btstack/example/a2dp_source_demo.c (revision a878cd3191844ef890f1fa5db126956592842425)
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, 0x10001, AVDTP_SOURCE_FEATURE_MASK_PLAYER, NULL, NULL);
290     sdp_register_service(sdp_a2dp_source_service_buffer);
291 
292     // Create AVRCP Target service record and register it with SDP. We receive Category 1 commands from the headphone, e.g. play/pause
293     memset(sdp_avrcp_target_service_buffer, 0, sizeof(sdp_avrcp_target_service_buffer));
294     uint16_t supported_features = AVRCP_FEATURE_MASK_CATEGORY_PLAYER_OR_RECORDER;
295 #ifdef AVRCP_BROWSING_ENABLED
296     supported_features |= AVRCP_FEATURE_MASK_BROWSING;
297 #endif
298     avrcp_target_create_sdp_record(sdp_avrcp_target_service_buffer, 0x10002, supported_features, NULL, NULL);
299     sdp_register_service(sdp_avrcp_target_service_buffer);
300 
301     // Create AVRCP Controller service record and register it with SDP. We send Category 2 commands to the headphone, e.g. volume up/down
302     memset(sdp_avrcp_controller_service_buffer, 0, sizeof(sdp_avrcp_controller_service_buffer));
303     uint16_t controller_supported_features = AVRCP_FEATURE_MASK_CATEGORY_MONITOR_OR_AMPLIFIER;
304     avrcp_controller_create_sdp_record(sdp_avrcp_controller_service_buffer, 0x10003, controller_supported_features, NULL, NULL);
305     sdp_register_service(sdp_avrcp_controller_service_buffer);
306 
307     // Register Device ID (PnP) service SDP record
308     memset(device_id_sdp_service_buffer, 0, sizeof(device_id_sdp_service_buffer));
309     device_id_create_sdp_record(device_id_sdp_service_buffer, 0x10004, DEVICE_ID_VENDOR_ID_SOURCE_BLUETOOTH, BLUETOOTH_COMPANY_ID_BLUEKITCHEN_GMBH, 1, 1);
310     sdp_register_service(device_id_sdp_service_buffer);
311 
312     // Set local name with a template Bluetooth address, that will be automatically
313     // replaced with a actual address once it is available, i.e. when BTstack boots
314     // up and starts talking to a Bluetooth module.
315     gap_set_local_name("A2DP Source 00:00:00:00:00:00");
316     gap_discoverable_control(1);
317     gap_set_class_of_device(0x200408);
318 
319     // Register for HCI events.
320     hci_event_callback_registration.callback = &hci_packet_handler;
321     hci_add_event_handler(&hci_event_callback_registration);
322 
323     a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate);
324     data_source = STREAM_MOD;
325 
326     // Parse human readable Bluetooth address.
327     sscanf_bd_addr(device_addr_string, device_addr);
328 
329 #ifdef HAVE_BTSTACK_STDIN
330     btstack_stdin_setup(stdin_process);
331 #endif
332     return 0;
333 }
334 /* LISTING_END */
335 
336 static void a2dp_demo_hexcmod_configure_sample_rate(int sample_rate){
337     if (!hxcmod_initialized){
338         hxcmod_initialized = hxcmod_init(&mod_context);
339         if (!hxcmod_initialized) {
340             printf("could not initialize hxcmod\n");
341             return;
342         }
343     }
344     current_sample_rate = sample_rate;
345     media_tracker.sbc_storage_count = 0;
346     media_tracker.samples_ready = 0;
347     hxcmod_unload(&mod_context);
348     hxcmod_setcfg(&mod_context, current_sample_rate, 16, 1, 1, 1);
349     hxcmod_load(&mod_context, (void *) &mod_data, mod_len);
350 }
351 
352 static void a2dp_demo_send_media_packet(void){
353     int num_bytes_in_frame = btstack_sbc_encoder_sbc_buffer_length();
354     int bytes_in_storage = media_tracker.sbc_storage_count;
355     uint8_t num_sbc_frames = bytes_in_storage / num_bytes_in_frame;
356     // Prepend SBC Header
357     media_tracker.sbc_storage[0] = num_sbc_frames;  // (fragmentation << 7) | (starting_packet << 6) | (last_packet << 5) | num_frames;
358     a2dp_source_stream_send_media_payload_rtp(media_tracker.a2dp_cid, media_tracker.local_seid, 0,
359                                                media_tracker.rtp_timestamp,
360                                                media_tracker.sbc_storage, bytes_in_storage + 1);
361 
362     // update rtp_timestamp
363     unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames();
364     media_tracker.rtp_timestamp += num_sbc_frames * num_audio_samples_per_sbc_buffer;
365 
366     media_tracker.sbc_storage_count = 0;
367     media_tracker.sbc_ready_to_send = 0;
368 }
369 
370 static void produce_sine_audio(int16_t * pcm_buffer, int num_samples_to_write){
371     int count;
372     for (count = 0; count < num_samples_to_write ; count++){
373         switch (current_sample_rate){
374             case 44100:
375                 pcm_buffer[count * 2]     = sine_int16_44100[sine_phase];
376                 pcm_buffer[count * 2 + 1] = sine_int16_44100[sine_phase];
377                 sine_phase++;
378                 if (sine_phase >= num_samples_sine_int16_44100){
379                     sine_phase -= num_samples_sine_int16_44100;
380                 }
381                 break;
382             case 48000:
383                 pcm_buffer[count * 2]     = sine_int16_48000[sine_phase];
384                 pcm_buffer[count * 2 + 1] = sine_int16_48000[sine_phase];
385                 sine_phase++;
386                 if (sine_phase >= num_samples_sine_int16_48000){
387                     sine_phase -= num_samples_sine_int16_48000;
388                 }
389                 break;
390             default:
391                 break;
392         }
393     }
394 }
395 
396 static void produce_mod_audio(int16_t * pcm_buffer, int num_samples_to_write){
397     hxcmod_fillbuffer(&mod_context, (unsigned short *) &pcm_buffer[0], num_samples_to_write, &trkbuf);
398 }
399 
400 static void produce_audio(int16_t * pcm_buffer, int num_samples){
401     switch (data_source){
402         case STREAM_SINE:
403             produce_sine_audio(pcm_buffer, num_samples);
404             break;
405         case STREAM_MOD:
406             produce_mod_audio(pcm_buffer, num_samples);
407             break;
408         default:
409             break;
410     }
411 #ifdef VOLUME_REDUCTION
412     int i;
413     for (i=0;i<num_samples*2;i++){
414         if (pcm_buffer[i] > 0){
415             pcm_buffer[i] =     pcm_buffer[i]  >> VOLUME_REDUCTION;
416         } else {
417             pcm_buffer[i] = -((-pcm_buffer[i]) >> VOLUME_REDUCTION);
418         }
419     }
420 #endif
421 }
422 
423 static int a2dp_demo_fill_sbc_audio_buffer(a2dp_media_sending_context_t * context){
424     // perform sbc encoding
425     int total_num_bytes_read = 0;
426     unsigned int num_audio_samples_per_sbc_buffer = btstack_sbc_encoder_num_audio_frames();
427     while (context->samples_ready >= num_audio_samples_per_sbc_buffer
428         && (context->max_media_payload_size - context->sbc_storage_count) >= btstack_sbc_encoder_sbc_buffer_length()){
429 
430         int16_t pcm_frame[256*NUM_CHANNELS];
431 
432         produce_audio(pcm_frame, num_audio_samples_per_sbc_buffer);
433         btstack_sbc_encoder_process_data(pcm_frame);
434 
435         uint16_t sbc_frame_size = btstack_sbc_encoder_sbc_buffer_length();
436         uint8_t * sbc_frame = btstack_sbc_encoder_sbc_buffer();
437 
438         total_num_bytes_read += num_audio_samples_per_sbc_buffer;
439         // first byte in sbc storage contains sbc media header
440         memcpy(&context->sbc_storage[1 + context->sbc_storage_count], sbc_frame, sbc_frame_size);
441         context->sbc_storage_count += sbc_frame_size;
442         context->samples_ready -= num_audio_samples_per_sbc_buffer;
443     }
444     return total_num_bytes_read;
445 }
446 
447 static void a2dp_demo_audio_timeout_handler(btstack_timer_source_t * timer){
448     a2dp_media_sending_context_t * context = (a2dp_media_sending_context_t *) btstack_run_loop_get_timer_context(timer);
449     btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS);
450     btstack_run_loop_add_timer(&context->audio_timer);
451     uint32_t now = btstack_run_loop_get_time_ms();
452 
453     uint32_t update_period_ms = AUDIO_TIMEOUT_MS;
454     if (context->time_audio_data_sent > 0){
455         update_period_ms = now - context->time_audio_data_sent;
456     }
457 
458     uint32_t num_samples = (update_period_ms * current_sample_rate) / 1000;
459     context->acc_num_missed_samples += (update_period_ms * current_sample_rate) % 1000;
460 
461     while (context->acc_num_missed_samples >= 1000){
462         num_samples++;
463         context->acc_num_missed_samples -= 1000;
464     }
465     context->time_audio_data_sent = now;
466     context->samples_ready += num_samples;
467 
468     if (context->sbc_ready_to_send) return;
469 
470     a2dp_demo_fill_sbc_audio_buffer(context);
471 
472     if ((context->sbc_storage_count + btstack_sbc_encoder_sbc_buffer_length()) > context->max_media_payload_size){
473         // schedule sending
474         context->sbc_ready_to_send = 1;
475         a2dp_source_stream_endpoint_request_can_send_now(context->a2dp_cid, context->local_seid);
476     }
477 }
478 
479 static void a2dp_demo_timer_start(a2dp_media_sending_context_t * context){
480     context->max_media_payload_size = btstack_min(a2dp_max_media_payload_size(context->a2dp_cid, context->local_seid), SBC_STORAGE_SIZE);
481     context->sbc_storage_count = 0;
482     context->sbc_ready_to_send = 0;
483     context->streaming = 1;
484     btstack_run_loop_remove_timer(&context->audio_timer);
485     btstack_run_loop_set_timer_handler(&context->audio_timer, a2dp_demo_audio_timeout_handler);
486     btstack_run_loop_set_timer_context(&context->audio_timer, context);
487     btstack_run_loop_set_timer(&context->audio_timer, AUDIO_TIMEOUT_MS);
488     btstack_run_loop_add_timer(&context->audio_timer);
489 }
490 
491 static void a2dp_demo_timer_stop(a2dp_media_sending_context_t * context){
492     context->time_audio_data_sent = 0;
493     context->acc_num_missed_samples = 0;
494     context->samples_ready = 0;
495     context->streaming = 1;
496     context->sbc_storage_count = 0;
497     context->sbc_ready_to_send = 0;
498     btstack_run_loop_remove_timer(&context->audio_timer);
499 }
500 
501 static void dump_sbc_configuration(media_codec_configuration_sbc_t * configuration){
502     printf("Received media codec configuration:\n");
503     printf("    - num_channels: %d\n", configuration->num_channels);
504     printf("    - sampling_frequency: %d\n", configuration->sampling_frequency);
505     printf("    - channel_mode: %d\n", configuration->channel_mode);
506     printf("    - block_length: %d\n", configuration->block_length);
507     printf("    - subbands: %d\n", configuration->subbands);
508     printf("    - allocation_method: %d\n", configuration->allocation_method);
509     printf("    - bitpool_value [%d, %d] \n", configuration->min_bitpool_value, configuration->max_bitpool_value);
510 }
511 
512 static void a2dp_source_demo_start_scanning(void){
513     printf("Start scanning...\n");
514     gap_inquiry_start(A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS);
515     scan_active = true;
516 }
517 
518 static void hci_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
519     UNUSED(channel);
520     UNUSED(size);
521     if (packet_type != HCI_EVENT_PACKET) return;
522     uint8_t status;
523     UNUSED(status);
524 
525     bd_addr_t address;
526     uint32_t cod;
527 
528     // Service Class: Rendering | Audio, Major Device Class: Audio
529     const uint32_t bluetooth_speaker_cod = 0x200000 | 0x040000 | 0x000400;
530 
531     switch (hci_event_packet_get_type(packet)){
532 #ifndef HAVE_BTSTACK_STDIN
533         case  BTSTACK_EVENT_STATE:
534             if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) return;
535             a2dp_source_demo_start_scanning();
536             break;
537 #endif
538         case HCI_EVENT_PIN_CODE_REQUEST:
539             printf("Pin code request - using '0000'\n");
540             hci_event_pin_code_request_get_bd_addr(packet, address);
541             gap_pin_code_response(address, "0000");
542             break;
543         case GAP_EVENT_INQUIRY_RESULT:
544             gap_event_inquiry_result_get_bd_addr(packet, address);
545             // print info
546             printf("Device found: %s ",  bd_addr_to_str(address));
547             cod = gap_event_inquiry_result_get_class_of_device(packet);
548             printf("with COD: %06" PRIx32, cod);
549             if (gap_event_inquiry_result_get_rssi_available(packet)){
550                 printf(", rssi %d dBm", (int8_t) gap_event_inquiry_result_get_rssi(packet));
551             }
552             if (gap_event_inquiry_result_get_name_available(packet)){
553                 char name_buffer[240];
554                 int name_len = gap_event_inquiry_result_get_name_len(packet);
555                 memcpy(name_buffer, gap_event_inquiry_result_get_name(packet), name_len);
556                 name_buffer[name_len] = 0;
557                 printf(", name '%s'", name_buffer);
558             }
559             printf("\n");
560             if ((cod & bluetooth_speaker_cod) == bluetooth_speaker_cod){
561                 memcpy(device_addr, address, 6);
562                 printf("Bluetooth speaker detected, trying to connect to %s...\n", bd_addr_to_str(device_addr));
563                 scan_active = false;
564                 gap_inquiry_stop();
565                 a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid);
566             }
567             break;
568         case GAP_EVENT_INQUIRY_COMPLETE:
569             if (scan_active){
570                 printf("No Bluetooth speakers found, scanning again...\n");
571                 gap_inquiry_start(A2DP_SOURCE_DEMO_INQUIRY_DURATION_1280MS);
572             }
573             break;
574         default:
575             break;
576     }
577 }
578 
579 static void a2dp_source_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
580     UNUSED(channel);
581     UNUSED(size);
582     uint8_t status;
583     uint8_t local_seid;
584     bd_addr_t address;
585     uint16_t cid;
586 
587     avdtp_channel_mode_t channel_mode;
588     uint8_t allocation_method;
589 
590     if (packet_type != HCI_EVENT_PACKET) return;
591     if (hci_event_packet_get_type(packet) != HCI_EVENT_A2DP_META) return;
592 
593     switch (hci_event_a2dp_meta_get_subevent_code(packet)){
594         case A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED:
595             a2dp_subevent_signaling_connection_established_get_bd_addr(packet, address);
596             cid = a2dp_subevent_signaling_connection_established_get_a2dp_cid(packet);
597             status = a2dp_subevent_signaling_connection_established_get_status(packet);
598 
599             if (status != ERROR_CODE_SUCCESS){
600                 printf("A2DP Source: Connection failed, status 0x%02x, cid 0x%02x, a2dp_cid 0x%02x \n", status, cid, media_tracker.a2dp_cid);
601                 media_tracker.a2dp_cid = 0;
602                 break;
603             }
604             media_tracker.a2dp_cid = cid;
605             media_tracker.volume = 32;
606 
607             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);
608             break;
609 
610          case A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION:{
611             cid  = avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(packet);
612             if (cid != media_tracker.a2dp_cid) return;
613 
614             media_tracker.remote_seid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet);
615 
616             sbc_configuration.reconfigure = a2dp_subevent_signaling_media_codec_sbc_configuration_get_reconfigure(packet);
617             sbc_configuration.num_channels = a2dp_subevent_signaling_media_codec_sbc_configuration_get_num_channels(packet);
618             sbc_configuration.sampling_frequency = a2dp_subevent_signaling_media_codec_sbc_configuration_get_sampling_frequency(packet);
619             sbc_configuration.block_length = a2dp_subevent_signaling_media_codec_sbc_configuration_get_block_length(packet);
620             sbc_configuration.subbands = a2dp_subevent_signaling_media_codec_sbc_configuration_get_subbands(packet);
621             sbc_configuration.min_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_min_bitpool_value(packet);
622             sbc_configuration.max_bitpool_value = a2dp_subevent_signaling_media_codec_sbc_configuration_get_max_bitpool_value(packet);
623 
624             channel_mode = (avdtp_channel_mode_t) a2dp_subevent_signaling_media_codec_sbc_configuration_get_channel_mode(packet);
625             allocation_method = a2dp_subevent_signaling_media_codec_sbc_configuration_get_allocation_method(packet);
626 
627             printf("A2DP Source: Received SBC codec configuration, sampling frequency %u, a2dp_cid 0x%02x, local seid 0x%02x, remote seid 0x%02x.\n",
628                 sbc_configuration.sampling_frequency, cid,
629                    a2dp_subevent_signaling_media_codec_sbc_configuration_get_local_seid(packet),
630                    a2dp_subevent_signaling_media_codec_sbc_configuration_get_remote_seid(packet));
631 
632             // Adapt Bluetooth spec definition to SBC Encoder expected input
633             sbc_configuration.allocation_method = (btstack_sbc_allocation_method_t)(allocation_method - 1);
634             switch (channel_mode){
635                 case AVDTP_CHANNEL_MODE_JOINT_STEREO:
636                     sbc_configuration.channel_mode = SBC_CHANNEL_MODE_JOINT_STEREO;
637                     break;
638                 case AVDTP_CHANNEL_MODE_STEREO:
639                     sbc_configuration.channel_mode = SBC_CHANNEL_MODE_STEREO;
640                     break;
641                 case AVDTP_CHANNEL_MODE_DUAL_CHANNEL:
642                     sbc_configuration.channel_mode = SBC_CHANNEL_MODE_DUAL_CHANNEL;
643                     break;
644                 case AVDTP_CHANNEL_MODE_MONO:
645                     sbc_configuration.channel_mode = SBC_CHANNEL_MODE_MONO;
646                     break;
647                 default:
648                     btstack_assert(false);
649                     break;
650             }
651             dump_sbc_configuration(&sbc_configuration);
652 
653             btstack_sbc_encoder_init(&sbc_encoder_state, SBC_MODE_STANDARD,
654                 sbc_configuration.block_length, sbc_configuration.subbands,
655                 sbc_configuration.allocation_method, sbc_configuration.sampling_frequency,
656                 sbc_configuration.max_bitpool_value,
657                 sbc_configuration.channel_mode);
658             break;
659         }
660 
661         case A2DP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY:
662             printf("A2DP Source: remote supports delay report, remote seid %d\n",
663                 avdtp_subevent_signaling_delay_reporting_capability_get_remote_seid(packet));
664             break;
665         case A2DP_SUBEVENT_SIGNALING_CAPABILITIES_DONE:
666             printf("A2DP Source: All capabilities reported, remote seid %d\n",
667                 avdtp_subevent_signaling_capabilities_done_get_remote_seid(packet));
668             break;
669 
670         case A2DP_SUBEVENT_SIGNALING_DELAY_REPORT:
671             printf("A2DP Source: Received delay report of %d.%0d ms, local seid %d\n",
672                 avdtp_subevent_signaling_delay_report_get_delay_100us(packet)/10, avdtp_subevent_signaling_delay_report_get_delay_100us(packet)%10,
673                 avdtp_subevent_signaling_delay_report_get_local_seid(packet));
674             break;
675 
676         case A2DP_SUBEVENT_STREAM_ESTABLISHED:
677             a2dp_subevent_stream_established_get_bd_addr(packet, address);
678             status = a2dp_subevent_stream_established_get_status(packet);
679             if (status != ERROR_CODE_SUCCESS){
680                 printf("A2DP Source: Stream failed, status 0x%02x.\n", status);
681                 break;
682             }
683 
684             local_seid = a2dp_subevent_stream_established_get_local_seid(packet);
685             cid = a2dp_subevent_stream_established_get_a2dp_cid(packet);
686 
687             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));
688 
689             a2dp_demo_hexcmod_configure_sample_rate(current_sample_rate);
690             media_tracker.stream_opened = 1;
691             status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
692             break;
693 
694         case A2DP_SUBEVENT_STREAM_RECONFIGURED:
695             status = a2dp_subevent_stream_reconfigured_get_status(packet);
696             local_seid = a2dp_subevent_stream_reconfigured_get_local_seid(packet);
697             cid = a2dp_subevent_stream_reconfigured_get_a2dp_cid(packet);
698 
699             if (status != ERROR_CODE_SUCCESS){
700                 printf("A2DP Source: Stream reconfiguration failed, status 0x%02x\n", status);
701                 break;
702             }
703 
704             printf("A2DP Source: Stream reconfigured a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid);
705             a2dp_demo_hexcmod_configure_sample_rate(new_sample_rate);
706             status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
707             break;
708 
709         case A2DP_SUBEVENT_STREAM_STARTED:
710             local_seid = a2dp_subevent_stream_started_get_local_seid(packet);
711             cid = a2dp_subevent_stream_started_get_a2dp_cid(packet);
712 
713             play_info.status = AVRCP_PLAYBACK_STATUS_PLAYING;
714             if (media_tracker.avrcp_cid){
715                 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t));
716                 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PLAYING);
717             }
718             a2dp_demo_timer_start(&media_tracker);
719             printf("A2DP Source: Stream started, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid);
720             break;
721 
722         case A2DP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW:
723             local_seid = a2dp_subevent_streaming_can_send_media_packet_now_get_local_seid(packet);
724             cid = a2dp_subevent_signaling_media_codec_sbc_configuration_get_a2dp_cid(packet);
725             a2dp_demo_send_media_packet();
726             break;
727 
728         case A2DP_SUBEVENT_STREAM_SUSPENDED:
729             local_seid = a2dp_subevent_stream_suspended_get_local_seid(packet);
730             cid = a2dp_subevent_stream_suspended_get_a2dp_cid(packet);
731 
732             play_info.status = AVRCP_PLAYBACK_STATUS_PAUSED;
733             if (media_tracker.avrcp_cid){
734                 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_PAUSED);
735             }
736             printf("A2DP Source: Stream paused, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid);
737 
738             a2dp_demo_timer_stop(&media_tracker);
739             break;
740 
741         case A2DP_SUBEVENT_STREAM_RELEASED:
742             play_info.status = AVRCP_PLAYBACK_STATUS_STOPPED;
743             cid = a2dp_subevent_stream_released_get_a2dp_cid(packet);
744             local_seid = a2dp_subevent_stream_released_get_local_seid(packet);
745 
746             printf("A2DP Source: Stream released, a2dp_cid 0x%02x, local_seid 0x%02x\n", cid, local_seid);
747 
748             if (cid == media_tracker.a2dp_cid) {
749                 media_tracker.stream_opened = 0;
750                 printf("A2DP Source: Stream released.\n");
751             }
752             if (media_tracker.avrcp_cid){
753                 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t));
754                 avrcp_target_set_playback_status(media_tracker.avrcp_cid, AVRCP_PLAYBACK_STATUS_STOPPED);
755             }
756             a2dp_demo_timer_stop(&media_tracker);
757             break;
758         case A2DP_SUBEVENT_SIGNALING_CONNECTION_RELEASED:
759             cid = a2dp_subevent_signaling_connection_released_get_a2dp_cid(packet);
760             if (cid == media_tracker.a2dp_cid) {
761                 media_tracker.avrcp_cid = 0;
762                 media_tracker.a2dp_cid = 0;
763                 printf("A2DP Source: Signaling released.\n\n");
764             }
765             break;
766         default:
767             break;
768     }
769 }
770 
771 static void avrcp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
772     UNUSED(channel);
773     UNUSED(size);
774     bd_addr_t event_addr;
775     uint16_t local_cid;
776     uint8_t  status = ERROR_CODE_SUCCESS;
777 
778     if (packet_type != HCI_EVENT_PACKET) return;
779     if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return;
780 
781     switch (packet[2]){
782         case AVRCP_SUBEVENT_CONNECTION_ESTABLISHED:
783             local_cid = avrcp_subevent_connection_established_get_avrcp_cid(packet);
784             status = avrcp_subevent_connection_established_get_status(packet);
785             if (status != ERROR_CODE_SUCCESS){
786                 printf("AVRCP: Connection failed, local cid 0x%02x, status 0x%02x\n", local_cid, status);
787                 return;
788             }
789             media_tracker.avrcp_cid = local_cid;
790             avrcp_subevent_connection_established_get_bd_addr(packet, event_addr);
791 
792             printf("AVRCP: Channel to %s successfully opened, avrcp_cid 0x%02x\n", bd_addr_to_str(event_addr), media_tracker.avrcp_cid);
793 
794             avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_PLAYBACK_STATUS_CHANGED);
795             avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_TRACK_CHANGED);
796             avrcp_target_support_event(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_NOW_PLAYING_CONTENT_CHANGED);
797             avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, NULL, sizeof(tracks)/sizeof(avrcp_track_t));
798 
799             printf("Enable Volume Change notification\n");
800             avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_VOLUME_CHANGED);
801             printf("Enable Battery Status Change notification\n");
802             avrcp_controller_enable_notification(media_tracker.avrcp_cid, AVRCP_NOTIFICATION_EVENT_BATT_STATUS_CHANGED);
803             return;
804 
805         case AVRCP_SUBEVENT_CONNECTION_RELEASED:
806             printf("AVRCP Target: Disconnected, avrcp_cid 0x%02x\n", avrcp_subevent_connection_released_get_avrcp_cid(packet));
807             media_tracker.avrcp_cid = 0;
808             return;
809         default:
810             break;
811     }
812 
813     if (status != ERROR_CODE_SUCCESS){
814         printf("Responding to event 0x%02x failed, status 0x%02x\n", packet[2], status);
815     }
816 }
817 
818 static void avrcp_target_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
819     UNUSED(channel);
820     UNUSED(size);
821     uint8_t  status = ERROR_CODE_SUCCESS;
822 
823     if (packet_type != HCI_EVENT_PACKET) return;
824     if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return;
825 
826     bool button_pressed;
827     char const * button_state;
828     avrcp_operation_id_t operation_id;
829 
830     switch (packet[2]){
831         case AVRCP_SUBEVENT_PLAY_STATUS_QUERY:
832             status = avrcp_target_play_status(media_tracker.avrcp_cid, play_info.song_length_ms, play_info.song_position_ms, play_info.status);
833             break;
834         // case AVRCP_SUBEVENT_NOW_PLAYING_INFO_QUERY:
835         //     status = avrcp_target_now_playing_info(avrcp_cid);
836         //     break;
837         case AVRCP_SUBEVENT_OPERATION:
838             operation_id = avrcp_subevent_operation_get_operation_id(packet);
839             button_pressed = avrcp_subevent_operation_get_button_pressed(packet) > 0;
840             button_state = button_pressed ? "PRESS" : "RELEASE";
841 
842             printf("AVRCP Target: operation %s (%s)\n", avrcp_operation2str(operation_id), button_state);
843 
844             if (!button_pressed){
845                 break;
846             }
847             switch (operation_id) {
848                 case AVRCP_OPERATION_ID_PLAY:
849                     status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
850                     break;
851                 case AVRCP_OPERATION_ID_PAUSE:
852                     status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
853                     break;
854                 case AVRCP_OPERATION_ID_STOP:
855                     status = a2dp_source_disconnect(media_tracker.a2dp_cid);
856                     break;
857                 default:
858                     break;
859             }
860             break;
861         default:
862             break;
863     }
864 
865     if (status != ERROR_CODE_SUCCESS){
866         printf("Responding to event 0x%02x failed, status 0x%02x\n", packet[2], status);
867     }
868 }
869 
870 static void avrcp_controller_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
871     UNUSED(channel);
872     UNUSED(size);
873 
874     if (packet_type != HCI_EVENT_PACKET) return;
875     if (hci_event_packet_get_type(packet) != HCI_EVENT_AVRCP_META) return;
876     if (!media_tracker.avrcp_cid) return;
877 
878     switch (packet[2]){
879         case AVRCP_SUBEVENT_NOTIFICATION_VOLUME_CHANGED:
880             printf("AVRCP Controller: Notification Absolute Volume %d %%\n", avrcp_subevent_notification_volume_changed_get_absolute_volume(packet) * 100 / 127);
881             break;
882         case AVRCP_SUBEVENT_NOTIFICATION_EVENT_BATT_STATUS_CHANGED:
883             // see avrcp_battery_status_t
884             printf("AVRCP Controller: Notification Battery Status 0x%02x\n", avrcp_subevent_notification_event_batt_status_changed_get_battery_status(packet));
885             break;
886         case AVRCP_SUBEVENT_NOTIFICATION_STATE:
887             printf("AVRCP Controller: Notification %s - %s\n",
888                 avrcp_event2str(avrcp_subevent_notification_state_get_event_id(packet)),
889                 avrcp_subevent_notification_state_get_enabled(packet) != 0 ? "enabled" : "disabled");
890             break;
891         default:
892             break;
893     }
894 }
895 
896 #ifdef HAVE_BTSTACK_STDIN
897 static void show_usage(void){
898     bd_addr_t      iut_address;
899     gap_local_bd_addr(iut_address);
900     printf("\n--- Bluetooth  A2DP Source/AVRCP Demo %s ---\n", bd_addr_to_str(iut_address));
901     printf("a      - Scan for Bluetooth speaker and connect\n");
902     printf("b      - A2DP Source create connection to addr %s\n", device_addr_string);
903     printf("B      - A2DP Source disconnect\n");
904     printf("c      - AVRCP create connection to addr %s\n", device_addr_string);
905     printf("C      - AVRCP disconnect\n");
906     printf("D      - delete all link keys\n");
907 
908     printf("x      - start streaming sine\n");
909     if (hxcmod_initialized){
910         printf("z      - start streaming '%s'\n", mod_name);
911     }
912     printf("p      - pause streaming\n");
913     printf("w      - reconfigure stream for 44100 Hz\n");
914     printf("e      - reconfigure stream for 48000 Hz\n");
915     printf("t      - volume up\n");
916     printf("T      - volume down\n");
917     printf("v      - volume up (via set absolute volume)\n");
918     printf("V      - volume down (via set absolute volume)\n");
919 
920     printf("---\n");
921 }
922 
923 static void stdin_process(char cmd){
924     uint8_t status = ERROR_CODE_SUCCESS;
925     switch (cmd){
926         case 'a':
927             a2dp_source_demo_start_scanning();
928             break;
929         case 'b':
930             status = a2dp_source_establish_stream(device_addr, &media_tracker.a2dp_cid);
931             printf("%c - Create A2DP Source connection to addr %s, cid 0x%02x.\n", cmd, bd_addr_to_str(device_addr), media_tracker.a2dp_cid);
932             break;
933         case 'B':
934             printf("%c - A2DP Source Disconnect from cid 0x%2x\n", cmd, media_tracker.a2dp_cid);
935             status = a2dp_source_disconnect(media_tracker.a2dp_cid);
936             break;
937         case 'c':
938             printf("%c - Create AVRCP connection to addr %s.\n", cmd, bd_addr_to_str(device_addr));
939             status = avrcp_connect(device_addr, &media_tracker.avrcp_cid);
940             break;
941         case 'C':
942             printf("%c - AVRCP disconnect\n", cmd);
943             status = avrcp_disconnect(media_tracker.avrcp_cid);
944             break;
945         case 'D':
946             printf("Deleting all link keys\n");
947             gap_delete_all_link_keys();
948             break;
949         case '\n':
950         case '\r':
951             break;
952 
953         case 't':
954             printf(" - volume up\n");
955             status = avrcp_controller_volume_up(media_tracker.avrcp_cid);
956             break;
957         case 'T':
958             printf(" - volume down\n");
959             status = avrcp_controller_volume_down(media_tracker.avrcp_cid);
960             break;
961 
962         case 'v':
963             if (media_tracker.volume > 117){
964                 media_tracker.volume = 127;
965             } else {
966                 media_tracker.volume += 10;
967             }
968             printf(" - volume up (via set absolute volume) %d%% (%d)\n",  media_tracker.volume * 100 / 127,  media_tracker.volume);
969             status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume);
970             break;
971         case 'V':
972             if (media_tracker.volume < 10){
973                 media_tracker.volume = 0;
974             } else {
975                 media_tracker.volume -= 10;
976             }
977             printf(" - volume down (via set absolute volume) %d%% (%d)\n",  media_tracker.volume * 100 / 127,  media_tracker.volume);
978             status = avrcp_controller_set_absolute_volume(media_tracker.avrcp_cid, media_tracker.volume);
979             break;
980 
981         case 'x':
982             if (media_tracker.avrcp_cid){
983                 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t));
984             }
985             printf("%c - Play sine.\n", cmd);
986             data_source = STREAM_SINE;
987             if (!media_tracker.stream_opened) break;
988             status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
989             break;
990         case 'z':
991             if (media_tracker.avrcp_cid){
992                 avrcp_target_set_now_playing_info(media_tracker.avrcp_cid, &tracks[data_source], sizeof(tracks)/sizeof(avrcp_track_t));
993             }
994             printf("%c - Play mod.\n", cmd);
995             data_source = STREAM_MOD;
996             if (!media_tracker.stream_opened) break;
997             status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
998             break;
999 
1000         case 'p':
1001             if (!media_tracker.stream_opened) break;
1002             printf("%c - Pause stream.\n", cmd);
1003             status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
1004             break;
1005 
1006         case 'w':
1007             if (!media_tracker.stream_opened) break;
1008             if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){
1009                 printf("Stream cannot be reconfigured while playing, please pause stream first\n");
1010                 break;
1011             }
1012             new_sample_rate = 44100;
1013             if (current_sample_rate == new_sample_rate){
1014                 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate);
1015             } else {
1016                 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate);
1017                 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate);
1018             }
1019             break;
1020 
1021         case 'e':
1022             if (!media_tracker.stream_opened) break;
1023             if (play_info.status == AVRCP_PLAYBACK_STATUS_PLAYING){
1024                 printf("Stream cannot be reconfigured while playing, please pause stream first\n");
1025                 break;
1026             }
1027             new_sample_rate = 48000;
1028             if (current_sample_rate == new_sample_rate){
1029                 printf("%c - Stream already configured for %d Hz.\n", cmd, new_sample_rate);
1030             } else {
1031                 printf("%c - Reconfigure for %d Hz.\n", cmd, new_sample_rate);
1032                 status = a2dp_source_reconfigure_stream_sampling_frequency(media_tracker.a2dp_cid, new_sample_rate);
1033             }
1034             break;
1035 
1036         default:
1037             show_usage();
1038             return;
1039     }
1040     if (status != ERROR_CODE_SUCCESS){
1041         printf("Could not perform command \'%c\', status 0x%02x\n", cmd, status);
1042     }
1043 }
1044 #endif
1045 
1046 
1047 int btstack_main(int argc, const char * argv[]);
1048 int btstack_main(int argc, const char * argv[]){
1049     (void)argc;
1050     (void)argv;
1051 
1052     int err = a2dp_source_and_avrcp_services_init();
1053     if (err) return err;
1054     // turn on!
1055     hci_power_control(HCI_POWER_ON);
1056     return 0;
1057 }
1058 /* EXAMPLE_END */
1059