xref: /btstack/src/classic/a2dp_source.c (revision fdd7f115a2c6bd5aa3c172737c304c681fe4110d)
1 
2 /*
3  * Copyright (C) 2016 BlueKitchen GmbH
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. Neither the name of the copyright holders nor the names of
15  *    contributors may be used to endorse or promote products derived
16  *    from this software without specific prior written permission.
17  * 4. Any redistribution, use, or modification is done solely for
18  *    personal benefit and not for any commercial purpose or for
19  *    monetary gain.
20  *
21  * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
25  * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
28  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
31  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  * Please inquire about commercial licensing options at
35  * [email protected]
36  *
37  */
38 
39 /**
40  * Supported use cases:
41  * - single incoming connection: sep discovery starts and stream will get setup if remote sink sep with SBC is found
42  * - single outgoing connection: see above
43  * - outgoing and incoming connection to same device:
44  *    - if outgoing is triggered first, incoming will get ignored.
45  *    - if incoming starts first, start ougoing will fail, but incoming will succeed.
46  * - outgoing and incoming connections to different devices:
47  *    - if outgoing is first, incoming gets ignored.
48  *    - if incoming starts first SEP discovery will get stopped and outgoing will succeed.
49  */
50 
51 #define BTSTACK_FILE__ "a2dp_source.c"
52 
53 #include <stdint.h>
54 #include <string.h>
55 
56 #include "bluetooth_psm.h"
57 #include "bluetooth_sdp.h"
58 #include "btstack_debug.h"
59 #include "btstack_event.h"
60 #include "classic/a2dp_source.h"
61 #include "classic/avdtp_source.h"
62 #include "classic/avdtp_util.h"
63 #include "classic/sdp_util.h"
64 #include "l2cap.h"
65 
66 #define AVDTP_MAX_SEP_NUM 10
67 #define A2DP_SET_CONFIG_DELAY_MS 150
68 
69 static const char * default_a2dp_source_service_name = "BTstack A2DP Source Service";
70 static const char * default_a2dp_source_service_provider_name = "BTstack A2DP Source Service Provider";
71 
72 static btstack_packet_handler_t a2dp_source_packet_handler_user;
73 
74 // config process - singletons using sep_discovery_cid is used as mutex
75 static uint16_t                 sep_discovery_cid;
76 static uint16_t                 sep_discovery_count;
77 static uint16_t                 sep_discovery_index;
78 static avdtp_sep_t              sep_discovery_seps[AVDTP_MAX_SEP_NUM];
79 static btstack_timer_source_t   a2dp_source_set_config_timer;
80 
81 static void a2dp_source_packet_handler_internal(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
82 static void a2dp_discover_seps_with_next_waiting_connection(void);
83 
84 static void a2dp_source_streaming_emit_connection_failed(avdtp_connection_t *connection, uint8_t status) {
85     uint8_t event[14];
86     int pos = 0;
87     event[pos++] = HCI_EVENT_A2DP_META;
88     event[pos++] = sizeof(event) - 2;
89     event[pos++] = A2DP_SUBEVENT_STREAM_ESTABLISHED;
90     little_endian_store_16(event, pos, connection->avdtp_cid);
91     pos += 2;
92     reverse_bd_addr(connection->remote_addr, &event[pos]);
93     pos += 6;
94     event[pos++] = 0;
95     event[pos++] = 0;
96     event[pos++] = status;
97 
98     (*a2dp_source_packet_handler_user)(HCI_EVENT_PACKET, 0, event, sizeof(event));
99 }
100 
101 void a2dp_source_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t supported_features, const char * service_name, const char * service_provider_name){
102     uint8_t* attribute;
103     de_create_sequence(service);
104 
105     // 0x0000 "Service Record Handle"
106     de_add_number(service, DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_RECORD_HANDLE);
107     de_add_number(service, DE_UINT, DE_SIZE_32, service_record_handle);
108 
109     // 0x0001 "Service Class ID List"
110     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_SERVICE_CLASS_ID_LIST);
111     attribute = de_push_sequence(service);
112     {
113         de_add_number(attribute, DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_AUDIO_SOURCE);
114     }
115     de_pop_sequence(service, attribute);
116 
117     // 0x0004 "Protocol Descriptor List"
118     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PROTOCOL_DESCRIPTOR_LIST);
119     attribute = de_push_sequence(service);
120     {
121         uint8_t* l2cpProtocol = de_push_sequence(attribute);
122         {
123             de_add_number(l2cpProtocol,  DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_L2CAP);
124             de_add_number(l2cpProtocol,  DE_UINT, DE_SIZE_16, BLUETOOTH_PSM_AVDTP);
125         }
126         de_pop_sequence(attribute, l2cpProtocol);
127 
128         uint8_t* avProtocol = de_push_sequence(attribute);
129         {
130             de_add_number(avProtocol,  DE_UUID, DE_SIZE_16, BLUETOOTH_PROTOCOL_AVDTP);  // avProtocol_service
131             de_add_number(avProtocol,  DE_UINT, DE_SIZE_16,  0x0103);  // version
132         }
133         de_pop_sequence(attribute, avProtocol);
134     }
135     de_pop_sequence(service, attribute);
136 
137     // 0x0005 "Public Browse Group"
138     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BROWSE_GROUP_LIST); // public browse group
139     attribute = de_push_sequence(service);
140     {
141         de_add_number(attribute,  DE_UUID, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_PUBLIC_BROWSE_ROOT);
142     }
143     de_pop_sequence(service, attribute);
144 
145     // 0x0009 "Bluetooth Profile Descriptor List"
146     de_add_number(service,  DE_UINT, DE_SIZE_16, BLUETOOTH_ATTRIBUTE_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
147     attribute = de_push_sequence(service);
148     {
149         uint8_t *a2dProfile = de_push_sequence(attribute);
150         {
151             de_add_number(a2dProfile,  DE_UUID, DE_SIZE_16, BLUETOOTH_SERVICE_CLASS_ADVANCED_AUDIO_DISTRIBUTION);
152             de_add_number(a2dProfile,  DE_UINT, DE_SIZE_16, 0x0103);
153         }
154         de_pop_sequence(attribute, a2dProfile);
155     }
156     de_pop_sequence(service, attribute);
157 
158 
159     // 0x0100 "Service Name"
160     de_add_number(service,  DE_UINT, DE_SIZE_16, 0x0100);
161     if (service_name){
162         de_add_data(service,  DE_STRING, strlen(service_name), (uint8_t *) service_name);
163     } else {
164         de_add_data(service,  DE_STRING, strlen(default_a2dp_source_service_name), (uint8_t *) default_a2dp_source_service_name);
165     }
166 
167     // 0x0100 "Provider Name"
168     de_add_number(service,  DE_UINT, DE_SIZE_16, 0x0102);
169     if (service_provider_name){
170         de_add_data(service,  DE_STRING, strlen(service_provider_name), (uint8_t *) service_provider_name);
171     } else {
172         de_add_data(service,  DE_STRING, strlen(default_a2dp_source_service_provider_name), (uint8_t *) default_a2dp_source_service_provider_name);
173     }
174 
175     // 0x0311 "Supported Features"
176     de_add_number(service, DE_UINT, DE_SIZE_16, 0x0311);
177     de_add_number(service, DE_UINT, DE_SIZE_16, supported_features);
178 }
179 
180 static void a2dp_signaling_emit_reconfigured(uint16_t cid, uint8_t local_seid, uint8_t status){
181     uint8_t event[7];
182     int pos = 0;
183     event[pos++] = HCI_EVENT_A2DP_META;
184     event[pos++] = sizeof(event) - 2;
185     event[pos++] = A2DP_SUBEVENT_STREAM_RECONFIGURED;
186     little_endian_store_16(event, pos, cid);
187     pos += 2;
188     event[pos++] = local_seid;
189     event[pos++] = status;
190     (*a2dp_source_packet_handler_user)(HCI_EVENT_PACKET, 0, event, sizeof(event));
191 }
192 
193 static void a2dp_source_set_config_timer_handler(btstack_timer_source_t * timer){
194     uint16_t avdtp_cid = (uint16_t)(uintptr_t) btstack_run_loop_get_timer_context(timer);
195 	avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
196 	btstack_run_loop_set_timer_context(&a2dp_source_set_config_timer, NULL);
197 
198     if (connection == NULL) {
199         log_info("a2dp_discover_seps_with_next_waiting_connection");
200         a2dp_discover_seps_with_next_waiting_connection();
201         return;
202     }
203 
204     if (connection->a2dp_source_stream_endpoint_configured) return;
205     avdtp_source_discover_stream_endpoints(avdtp_cid);
206 }
207 
208 static void a2dp_source_set_config_timer_start(uint16_t avdtp_cid){
209     log_info("a2dp_source_set_config_timer_start cid 0%02x", avdtp_cid);
210     btstack_run_loop_remove_timer(&a2dp_source_set_config_timer);
211     btstack_run_loop_set_timer_handler(&a2dp_source_set_config_timer,a2dp_source_set_config_timer_handler);
212     btstack_run_loop_set_timer(&a2dp_source_set_config_timer, A2DP_SET_CONFIG_DELAY_MS);
213     btstack_run_loop_set_timer_context(&a2dp_source_set_config_timer, (void *)(uintptr_t)avdtp_cid);
214     btstack_run_loop_add_timer(&a2dp_source_set_config_timer);
215 }
216 
217 static void a2dp_source_set_config_timer_stop(void){
218     log_info("a2dp_source_set_config_timer_stop");
219     btstack_run_loop_remove_timer(&a2dp_source_set_config_timer);
220 	btstack_run_loop_set_timer_context(&a2dp_source_set_config_timer, NULL);
221 }
222 
223 // Discover seps, both incoming and outgoing
224 static void a2dp_start_discovering_seps(avdtp_connection_t * connection){
225     connection->a2dp_source_state = A2DP_DISCOVER_SEPS;
226     connection->a2dp_source_discover_seps = false;
227 
228     sep_discovery_index = 0;
229     sep_discovery_count = 0;
230     memset(sep_discovery_seps, 0, sizeof(avdtp_sep_t) * AVDTP_MAX_SEP_NUM);
231     sep_discovery_cid = connection->avdtp_cid;
232 
233     // if we initiated the connection, start config right away, else wait a bit to give remote a chance to do it first
234     if (connection->a2dp_source_outgoing_active){
235         log_info("discover seps");
236         avdtp_source_discover_stream_endpoints(connection->avdtp_cid);
237     } else {
238         log_info("wait a bit, then discover seps");
239         a2dp_source_set_config_timer_start(connection->avdtp_cid);
240     }
241 }
242 
243 static void a2dp_discover_seps_with_next_waiting_connection(void){
244     btstack_assert(sep_discovery_cid == 0);
245     btstack_linked_list_iterator_t it;
246     btstack_linked_list_iterator_init(&it, avdtp_get_connections());
247     while (btstack_linked_list_iterator_has_next(&it)){
248         avdtp_connection_t * next_connection = (avdtp_connection_t *)btstack_linked_list_iterator_next(&it);
249         if (!next_connection->a2dp_source_discover_seps) continue;
250         a2dp_start_discovering_seps(next_connection);
251     }
252 }
253 
254 static void a2dp_source_ready_for_sep_discovery(avdtp_connection_t * connection){
255     // start discover seps now if:
256     // - outgoing active: signaling for outgoing connection
257     // - outgoing not active: incoming connection and no sep discover ongoing
258 
259     // sep discovery active?
260     if (sep_discovery_cid == 0){
261         a2dp_start_discovering_seps(connection);
262     } else {
263         // post-pone sep discovery
264         connection->a2dp_source_discover_seps = true;
265     }
266 }
267 
268 static void a2dp_handle_received_configuration(const uint8_t *packet, uint8_t local_seid) {
269     uint16_t cid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(packet);
270     avdtp_connection_t *avdtp_connection = avdtp_get_connection_for_avdtp_cid(cid);
271     btstack_assert(avdtp_connection != NULL);
272     avdtp_connection->a2dp_source_local_stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
273     // bail out if local seid invalid
274     if (!avdtp_connection->a2dp_source_local_stream_endpoint) return;
275 
276     // stop timer
277     if (sep_discovery_cid == cid) {
278         a2dp_source_set_config_timer_stop();
279         sep_discovery_cid = 0;
280     }
281 
282     avdtp_connection->a2dp_source_stream_endpoint_configured = true;
283 
284     switch (avdtp_connection->a2dp_source_state) {
285         case A2DP_W4_SET_CONFIGURATION:
286             // outgoing: discovery and config of remote sink sep successful, trigger stream open
287             avdtp_connection->a2dp_source_state = A2DP_W2_OPEN_STREAM_WITH_SEID;
288             break;
289         case A2DP_W4_GET_CONFIGURATION:
290             // incoming: wait for stream open
291             avdtp_connection->a2dp_source_state = A2DP_W4_OPEN_STREAM_WITH_SEID;
292             break;
293         default:
294             // wait for configuration after sending reconfigure - keep state
295             break;
296     }
297 }
298 
299 static void a2dp_source_set_config(avdtp_connection_t * connection){
300     uint8_t remote_seid = connection->a2dp_source_local_stream_endpoint->set_config_remote_seid;
301     log_info("A2DP initiate set configuration locally and wait for response ... local seid 0x%02x, remote seid 0x%02x", avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), remote_seid);
302     connection->a2dp_source_state = A2DP_W4_SET_CONFIGURATION;
303     avdtp_source_set_configuration(connection->avdtp_cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), remote_seid, connection->a2dp_source_local_stream_endpoint->remote_configuration_bitmap, connection->a2dp_source_local_stream_endpoint->remote_configuration);
304 }
305 
306 static void a2dp_source_packet_handler_internal(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
307     UNUSED(channel);
308     UNUSED(size);
309 
310     uint16_t cid;
311     avdtp_connection_t * connection;
312 
313     uint8_t signal_identifier;
314     uint8_t status;
315     uint8_t local_seid;
316     uint8_t remote_seid;
317 
318     if (packet_type != HCI_EVENT_PACKET) return;
319     if (hci_event_packet_get_type(packet) != HCI_EVENT_AVDTP_META) return;
320 
321     switch (packet[2]){
322         case AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED:
323             cid = avdtp_subevent_signaling_connection_established_get_avdtp_cid(packet);
324             connection = avdtp_get_connection_for_avdtp_cid(cid);
325             btstack_assert(connection != NULL);
326 
327             status = avdtp_subevent_signaling_connection_established_get_status(packet);
328             if (status != ERROR_CODE_SUCCESS){
329                 // notify about connection error only if we're initiator
330                 if (connection->a2dp_source_outgoing_active){
331                     log_info("A2DP source signaling connection failed status 0x%02x", status);
332                     connection->a2dp_source_outgoing_active = false;
333                     a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED);
334                 }
335                 break;
336             }
337             log_info("A2DP source signaling connection established avdtp_cid 0x%02x", cid);
338             connection->a2dp_source_state = A2DP_CONNECTED;
339 
340             // notify app
341             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED);
342 
343             // continue
344             a2dp_source_ready_for_sep_discovery(connection);
345             break;
346 
347         case AVDTP_SUBEVENT_SIGNALING_SEP_FOUND:
348             cid = avdtp_subevent_signaling_sep_found_get_avdtp_cid(packet);
349             connection = avdtp_get_connection_for_avdtp_cid(cid);
350             btstack_assert(connection != NULL);
351 
352             if (connection->a2dp_source_state == A2DP_DISCOVER_SEPS) {
353                 avdtp_sep_t sep;
354                 memset(&sep, 0, sizeof(avdtp_sep_t));
355                 sep.seid       = avdtp_subevent_signaling_sep_found_get_remote_seid(packet);;
356                 sep.in_use     = avdtp_subevent_signaling_sep_found_get_in_use(packet);
357                 sep.media_type = (avdtp_media_type_t) avdtp_subevent_signaling_sep_found_get_media_type(packet);
358                 sep.type       = (avdtp_sep_type_t) avdtp_subevent_signaling_sep_found_get_sep_type(packet);
359                 log_info("A2DP Found sep: remote seid 0x%02x, in_use %d, media type %d, sep type %s, index %d",
360                          sep.seid, sep.in_use, sep.media_type, sep.type == AVDTP_SOURCE ? "source" : "sink",
361                          sep_discovery_count);
362                 if ((sep.type == AVDTP_SINK) && (sep.in_use == false)) {
363                     sep_discovery_seps[sep_discovery_count++] = sep;
364                 }
365             }
366             break;
367 
368         case AVDTP_SUBEVENT_SIGNALING_SEP_DICOVERY_DONE:
369             cid = avdtp_subevent_signaling_sep_dicovery_done_get_avdtp_cid(packet);
370             connection = avdtp_get_connection_for_avdtp_cid(cid);
371             btstack_assert(connection != NULL);
372 
373             if (connection->a2dp_source_state != A2DP_DISCOVER_SEPS) break;
374 
375             if (sep_discovery_count > 0){
376                 connection->a2dp_source_state = A2DP_GET_CAPABILITIES;
377                 sep_discovery_index = 0;
378                 connection->a2dp_source_have_config = false;
379             } else {
380                 if (connection->a2dp_source_outgoing_active){
381                     connection->a2dp_source_outgoing_active = false;
382                     connection = avdtp_get_connection_for_avdtp_cid(cid);
383                     btstack_assert(connection != NULL);
384                     a2dp_source_streaming_emit_connection_failed(connection, ERROR_CODE_CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND);
385                 }
386 
387                 // continue
388                 connection->a2dp_source_state = A2DP_CONNECTED;
389                 sep_discovery_cid = 0;
390                 a2dp_discover_seps_with_next_waiting_connection();
391             }
392             break;
393 
394         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CAPABILITY:
395             cid = avdtp_subevent_signaling_media_codec_sbc_capability_get_avdtp_cid(packet);
396             connection = avdtp_get_connection_for_avdtp_cid(cid);
397             btstack_assert(connection != NULL);
398 
399             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
400 
401             // forward codec capability
402             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CAPABILITY);
403 
404 #ifndef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
405             // select SEP if none configured yet
406             if (connection->a2dp_source_have_config == false){
407                 // find SBC stream endpoint
408                 avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_source_stream_endpoint_for_media_codec(AVDTP_CODEC_SBC);
409                 if (stream_endpoint != NULL){
410                     // choose SBC config params
411                     avdtp_configuration_sbc_t configuration;
412                     configuration.sampling_frequency = avdtp_choose_sbc_sampling_frequency(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_sampling_frequency_bitmap(packet));
413                     configuration.channel_mode       = avdtp_choose_sbc_channel_mode(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_channel_mode_bitmap(packet));
414                     configuration.block_length       = avdtp_choose_sbc_block_length(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_block_length_bitmap(packet));
415                     configuration.subbands           = avdtp_choose_sbc_subbands(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_subbands_bitmap(packet));
416                     configuration.allocation_method  = avdtp_choose_sbc_allocation_method(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_allocation_method_bitmap(packet));
417                     configuration.max_bitpool_value  = avdtp_choose_sbc_max_bitpool_value(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_max_bitpool_value(packet));
418                     configuration.min_bitpool_value  = avdtp_choose_sbc_min_bitpool_value(stream_endpoint, avdtp_subevent_signaling_media_codec_sbc_capability_get_min_bitpool_value(packet));
419 
420                     // and pre-select this endpoint
421                     stream_endpoint->sep.in_use = 1;
422                     local_seid = avdtp_stream_endpoint_seid(stream_endpoint);
423                     remote_seid = avdtp_subevent_signaling_media_codec_sbc_capability_get_remote_seid(packet);
424                     a2dp_source_set_config_sbc(cid, local_seid, remote_seid, &configuration);
425                 }
426             }
427 #endif
428             break;
429 
430         // forward codec capability
431         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AUDIO_CAPABILITY:
432             cid = avdtp_subevent_signaling_media_codec_mpeg_audio_capability_get_avdtp_cid(packet);
433             connection = avdtp_get_connection_for_avdtp_cid(cid);
434             btstack_assert(connection != NULL);
435 
436             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
437             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AUDIO_CAPABILITY);
438             break;
439         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AAC_CAPABILITY:
440             cid = avdtp_subevent_signaling_media_codec_mpeg_aac_capability_get_avdtp_cid(packet);
441             connection = avdtp_get_connection_for_avdtp_cid(cid);
442             btstack_assert(connection != NULL);
443 
444             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
445             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AAC_CAPABILITY);
446             break;
447         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_ATRAC_CAPABILITY:
448             cid = avdtp_subevent_signaling_media_codec_atrac_capability_get_avdtp_cid(packet);
449             connection = avdtp_get_connection_for_avdtp_cid(cid);
450             btstack_assert(connection != NULL);
451 
452             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
453             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_ATRAC_CAPABILITY);
454             break;
455         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CAPABILITY:
456             cid = avdtp_subevent_signaling_media_codec_other_capability_get_avdtp_cid(packet);
457             connection = avdtp_get_connection_for_avdtp_cid(cid);
458             btstack_assert(connection != NULL);
459 
460             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
461             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CAPABILITY);
462             break;
463 
464         // not forwarded
465         case AVDTP_SUBEVENT_SIGNALING_MEDIA_TRANSPORT_CAPABILITY:
466         case AVDTP_SUBEVENT_SIGNALING_REPORTING_CAPABILITY:
467         case AVDTP_SUBEVENT_SIGNALING_RECOVERY_CAPABILITY:
468         case AVDTP_SUBEVENT_SIGNALING_CONTENT_PROTECTION_CAPABILITY:
469         case AVDTP_SUBEVENT_SIGNALING_HEADER_COMPRESSION_CAPABILITY:
470         case AVDTP_SUBEVENT_SIGNALING_MULTIPLEXING_CAPABILITY:
471             break;
472 
473         case AVDTP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY:
474             cid = avdtp_subevent_signaling_delay_reporting_capability_get_avdtp_cid(packet);
475             connection = avdtp_get_connection_for_avdtp_cid(cid);
476             btstack_assert(connection != NULL);
477             log_info("received AVDTP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY, cid 0x%02x, state %d", cid, connection->a2dp_source_state);
478 
479             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
480 
481             // store delay reporting capability
482             sep_discovery_seps[sep_discovery_index].registered_service_categories |= 1 << AVDTP_DELAY_REPORTING;
483 
484             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_DELAY_REPORTING_CAPABILITY);
485             break;
486 
487         case AVDTP_SUBEVENT_SIGNALING_CAPABILITIES_DONE:
488             cid = avdtp_subevent_signaling_capabilities_done_get_avdtp_cid(packet);
489             connection = avdtp_get_connection_for_avdtp_cid(cid);
490             btstack_assert(connection != NULL);
491 
492             if (connection->a2dp_source_state != A2DP_GET_CAPABILITIES) break;
493 
494             // forward capabilities done for endpoint
495             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_CAPABILITIES_DONE);
496 
497             // endpoint was not suitable, check next one
498             sep_discovery_index++;
499             if (sep_discovery_index >= sep_discovery_count){
500 
501                 // emit 'all capabilities for all seps reported'
502                 uint8_t event[6];
503                 uint8_t pos = 0;
504                 event[pos++] = HCI_EVENT_A2DP_META;
505                 event[pos++] = sizeof(event) - 2;
506                 event[pos++] = A2DP_SUBEVENT_SIGNALING_CAPABILITIES_COMPLETE;
507                 little_endian_store_16(event, pos, cid);
508                 (*a2dp_source_packet_handler_user)(HCI_EVENT_PACKET, 0, event, sizeof(event));
509 
510                 // do we have a valid config?
511                 if (connection->a2dp_source_have_config){
512                     connection->a2dp_source_state = A2DP_SET_CONFIGURATION;
513                     connection->a2dp_source_have_config = false;
514                     break;
515                 }
516 
517 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
518                 connection->a2dp_source_state = A2DP_DISCOVERY_DONE;
519                 // TODO call a2dp_discover_seps_with_next_waiting_connection?
520                 break;
521 #else
522                 // we didn't find a suitable SBC stream endpoint, sorry.
523                 if (connection->a2dp_source_outgoing_active){
524                     connection->a2dp_source_outgoing_active = false;
525                     connection = avdtp_get_connection_for_avdtp_cid(cid);
526                     btstack_assert(connection != NULL);
527                     a2dp_source_streaming_emit_connection_failed(connection, ERROR_CODE_CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND);
528                 }
529                 connection->a2dp_source_state = A2DP_CONNECTED;
530                 sep_discovery_cid = 0;
531                 a2dp_discover_seps_with_next_waiting_connection();
532 #endif
533             }
534             break;
535 
536         case AVDTP_SUBEVENT_SIGNALING_DELAY_REPORT:
537             cid = avdtp_subevent_signaling_delay_report_get_avdtp_cid(packet);
538             connection = avdtp_get_connection_for_avdtp_cid(cid);
539             btstack_assert(connection != NULL);
540 
541             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_DELAY_REPORT);
542             break;
543 
544             // forward codec configuration
545         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION:
546             local_seid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_local_seid(packet);
547             a2dp_handle_received_configuration(packet, local_seid);
548             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION);
549             break;
550         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AUDIO_CONFIGURATION:
551             local_seid = avdtp_subevent_signaling_media_codec_mpeg_audio_configuration_get_local_seid(packet);
552             a2dp_handle_received_configuration(packet, local_seid);
553             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AUDIO_CONFIGURATION);
554             break;
555         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AAC_CONFIGURATION:
556             local_seid = avdtp_subevent_signaling_media_codec_mpeg_aac_configuration_get_local_seid(packet);
557             a2dp_handle_received_configuration(packet, local_seid);
558             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_MPEG_AAC_CONFIGURATION);
559             break;
560         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_ATRAC_CONFIGURATION:
561             local_seid = avdtp_subevent_signaling_media_codec_atrac_configuration_get_local_seid(packet);
562             a2dp_handle_received_configuration(packet, local_seid);
563             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_ATRAC_CONFIGURATION);
564             break;
565         case AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CONFIGURATION:
566             local_seid = avdtp_subevent_signaling_media_codec_sbc_configuration_get_local_seid(packet);
567             a2dp_handle_received_configuration(packet, local_seid);
568             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CONFIGURATION);
569             break;
570 
571         case AVDTP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW:
572             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW);
573             break;
574 
575         case AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED:
576             cid = avdtp_subevent_streaming_connection_established_get_avdtp_cid(packet);
577             connection = avdtp_get_connection_for_avdtp_cid(cid);
578             btstack_assert(connection != NULL);
579 
580             if (connection->a2dp_source_state != A2DP_W4_OPEN_STREAM_WITH_SEID) break;
581 
582             connection->a2dp_source_outgoing_active = false;
583             status = avdtp_subevent_streaming_connection_established_get_status(packet);
584             if (status != ERROR_CODE_SUCCESS){
585                 log_info("A2DP source streaming connection could not be established, avdtp_cid 0x%02x, status 0x%02x ---", cid, status);
586                 a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_STREAM_ESTABLISHED);
587                 break;
588             }
589 
590             log_info("A2DP source streaming connection established --- avdtp_cid 0x%02x, local seid 0x%02x, remote seid 0x%02x", cid,
591                 avdtp_subevent_streaming_connection_established_get_local_seid(packet),
592                 avdtp_subevent_streaming_connection_established_get_remote_seid(packet));
593             connection->a2dp_source_state = A2DP_STREAMING_OPENED;
594             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_STREAM_ESTABLISHED);
595             break;
596 
597         case AVDTP_SUBEVENT_SIGNALING_ACCEPT:
598             cid = avdtp_subevent_signaling_accept_get_avdtp_cid(packet);
599             connection = avdtp_get_connection_for_avdtp_cid(cid);
600             btstack_assert(connection != NULL);
601 
602 			// reset discovery timer while remote is active for current cid
603 			if ((avdtp_subevent_signaling_accept_get_is_initiator(packet) == 0) && (cid == sep_discovery_cid)){
604 				log_info("Reset discovery timer");
605 				a2dp_source_set_config_timer_start(sep_discovery_cid);
606 				break;
607 			}
608 
609             signal_identifier = avdtp_subevent_signaling_accept_get_signal_identifier(packet);
610 
611             log_info("A2DP cmd %s accepted, global state %d, cid 0x%02x", avdtp_si2str(signal_identifier), connection->a2dp_source_state, cid);
612 
613             switch (connection->a2dp_source_state){
614                 case A2DP_GET_CAPABILITIES:
615                     remote_seid = sep_discovery_seps[sep_discovery_index].seid;
616                     log_info("A2DP get capabilities for remote seid 0x%02x", remote_seid);
617                     avdtp_source_get_all_capabilities(cid, remote_seid);
618                     return;
619 
620                 case A2DP_SET_CONFIGURATION:
621                     a2dp_source_set_config(connection);
622                     return;
623 
624                 case A2DP_W2_OPEN_STREAM_WITH_SEID:
625                     log_info("A2DP open stream ... local seid 0x%02x, active remote seid 0x%02x", avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), connection->a2dp_source_local_stream_endpoint->remote_sep.seid);
626                     connection->a2dp_source_state = A2DP_W4_OPEN_STREAM_WITH_SEID;
627                     avdtp_source_open_stream(cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), connection->a2dp_source_local_stream_endpoint->remote_sep.seid);
628                     break;
629 
630                 case A2DP_W2_RECONFIGURE_WITH_SEID:
631                     log_info("A2DP reconfigured ... local seid 0x%02x, active remote seid 0x%02x", avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), connection->a2dp_source_local_stream_endpoint->remote_sep.seid);
632                     a2dp_signaling_emit_reconfigured(cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), ERROR_CODE_SUCCESS);
633                     connection->a2dp_source_state = A2DP_STREAMING_OPENED;
634                     break;
635 
636                 case A2DP_STREAMING_OPENED:
637                     switch (signal_identifier){
638                         case  AVDTP_SI_START:
639                             a2dp_emit_stream_event(a2dp_source_packet_handler_user, cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), A2DP_SUBEVENT_STREAM_STARTED);
640                             break;
641                         case AVDTP_SI_SUSPEND:
642                             a2dp_emit_stream_event(a2dp_source_packet_handler_user, cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), A2DP_SUBEVENT_STREAM_SUSPENDED);
643                             break;
644                         case AVDTP_SI_ABORT:
645                         case AVDTP_SI_CLOSE:
646                             a2dp_emit_stream_event(a2dp_source_packet_handler_user, cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), A2DP_SUBEVENT_STREAM_STOPPED);
647                             break;
648                         default:
649                             break;
650                     }
651                     break;
652 
653                 default:
654                     break;
655             }
656             break;
657 
658         case AVDTP_SUBEVENT_SIGNALING_REJECT:
659             cid = avdtp_subevent_signaling_reject_get_avdtp_cid(packet);
660             connection = avdtp_get_connection_for_avdtp_cid(cid);
661             btstack_assert(connection != NULL);
662 
663             if (avdtp_subevent_signaling_reject_get_is_initiator(packet) == 0) break;
664 
665             switch (connection->a2dp_source_state) {
666                 case A2DP_W2_RECONFIGURE_WITH_SEID:
667                     log_info("A2DP reconfigure failed ... local seid 0x%02x, active remote seid 0x%02x", avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), connection->a2dp_source_local_stream_endpoint->remote_sep.seid);
668                     a2dp_signaling_emit_reconfigured(cid, avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint), ERROR_CODE_UNSPECIFIED_ERROR);
669                     connection->a2dp_source_state = A2DP_STREAMING_OPENED;
670                     break;
671                 default:
672                     connection->a2dp_source_state = A2DP_CONNECTED;
673                     break;
674             }
675 
676             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_COMMAND_REJECTED);
677             break;
678 
679         case AVDTP_SUBEVENT_SIGNALING_GENERAL_REJECT:
680             cid = avdtp_subevent_signaling_general_reject_get_avdtp_cid(packet);
681             connection = avdtp_get_connection_for_avdtp_cid(cid);
682             btstack_assert(connection != NULL);
683 
684             if (avdtp_subevent_signaling_general_reject_get_is_initiator(packet) == 0) break;
685 
686             connection->a2dp_source_state = A2DP_CONNECTED;
687             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_COMMAND_REJECTED);
688             break;
689 
690         case AVDTP_SUBEVENT_STREAMING_CONNECTION_RELEASED:
691             cid = avdtp_subevent_streaming_connection_released_get_avdtp_cid(packet);
692             connection = avdtp_get_connection_for_avdtp_cid(cid);
693             btstack_assert(connection != NULL);
694 
695             connection->a2dp_source_state = A2DP_CONFIGURED;
696             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_STREAM_RELEASED);
697             break;
698 
699         case AVDTP_SUBEVENT_SIGNALING_CONNECTION_RELEASED:
700             cid = avdtp_subevent_signaling_connection_released_get_avdtp_cid(packet);
701             connection = avdtp_get_connection_for_avdtp_cid(cid);
702             btstack_assert(connection != NULL);
703 
704             // connect/release are passed on to app
705             if (sep_discovery_cid == cid){
706                 a2dp_source_set_config_timer_stop();
707                 connection->a2dp_source_stream_endpoint_configured = false;
708                 connection->a2dp_source_local_stream_endpoint = NULL;
709 
710                 connection->a2dp_source_state = A2DP_IDLE;
711                 sep_discovery_cid = 0;
712             }
713             a2dp_replace_subevent_id_and_emit_cmd(a2dp_source_packet_handler_user, packet, size, A2DP_SUBEVENT_SIGNALING_CONNECTION_RELEASED);
714             break;
715 
716         default:
717             break;
718     }
719 }
720 void a2dp_source_register_packet_handler(btstack_packet_handler_t callback){
721     btstack_assert(callback != NULL);
722 
723     avdtp_source_register_packet_handler(&a2dp_source_packet_handler_internal);
724     a2dp_source_packet_handler_user = callback;
725 }
726 
727 void a2dp_source_init(void){
728     avdtp_source_init();
729 }
730 
731 void a2dp_source_deinit(void){
732     avdtp_source_deinit();
733     sep_discovery_count = 0;
734 }
735 
736 avdtp_stream_endpoint_t * a2dp_source_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
737                                                              const uint8_t *codec_capabilities, uint16_t codec_capabilities_len,
738                                                              uint8_t * codec_configuration, uint16_t codec_configuration_len){
739     avdtp_stream_endpoint_t * stream_endpoint = avdtp_source_create_stream_endpoint(AVDTP_SOURCE, media_type);
740     if (!stream_endpoint){
741         return NULL;
742     }
743     avdtp_source_register_media_transport_category(avdtp_stream_endpoint_seid(stream_endpoint));
744     avdtp_source_register_media_codec_category(avdtp_stream_endpoint_seid(stream_endpoint), media_type, media_codec_type,
745                                                codec_capabilities, codec_capabilities_len);
746 	avdtp_source_register_delay_reporting_category(avdtp_stream_endpoint_seid(stream_endpoint));
747 
748 	// store user codec configuration buffer
749 	stream_endpoint->media_codec_type = media_codec_type;
750 	stream_endpoint->media_codec_configuration_info = codec_configuration;
751     stream_endpoint->media_codec_configuration_len  = codec_configuration_len;
752 
753     return stream_endpoint;
754 }
755 
756 void a2dp_source_finalize_stream_endpoint(avdtp_stream_endpoint_t * stream_endpoint){
757     avdtp_source_finalize_stream_endpoint(stream_endpoint);
758 }
759 
760 uint8_t a2dp_source_establish_stream(bd_addr_t remote_addr, uint16_t *avdtp_cid) {
761 
762     uint16_t outgoing_cid;
763 
764     avdtp_connection_t * connection = avdtp_get_connection_for_bd_addr(remote_addr);
765     if (connection == NULL){
766         uint8_t status = avdtp_source_connect(remote_addr, &outgoing_cid);
767         if (status != ERROR_CODE_SUCCESS) {
768             // if there's already a connection for for remote addr, avdtp_source_connect fails,
769             // but the stream will get set-up nevertheless
770             return status;
771         }
772         connection = avdtp_get_connection_for_avdtp_cid(outgoing_cid);
773         btstack_assert(connection != NULL);
774 
775         // setup state
776         connection->a2dp_source_outgoing_active = true;
777         connection->a2dp_source_state = A2DP_W4_CONNECTED;
778         *avdtp_cid = outgoing_cid;
779 
780     } else {
781         if (connection->a2dp_source_outgoing_active || connection->a2dp_source_stream_endpoint_configured) {
782             return ERROR_CODE_COMMAND_DISALLOWED;
783         }
784 
785         // check state
786         switch (connection->a2dp_source_state){
787             case A2DP_IDLE:
788             case A2DP_CONNECTED:
789                 // restart process e.g. if there no suitable stream endpoints or they had been in use
790                 connection->a2dp_source_outgoing_active = true;
791                 *avdtp_cid = connection->avdtp_cid;
792                 a2dp_source_ready_for_sep_discovery(connection);
793                 break;
794             default:
795                 return ERROR_CODE_COMMAND_DISALLOWED;
796         }
797     }
798     return ERROR_CODE_SUCCESS;
799 }
800 
801 uint8_t a2dp_source_disconnect(uint16_t avdtp_cid){
802     return avdtp_disconnect(avdtp_cid);
803 }
804 
805 
806 uint8_t a2dp_source_start_stream(uint16_t avdtp_cid, uint8_t local_seid){
807     return avdtp_start_stream(avdtp_cid, local_seid);
808 }
809 
810 uint8_t a2dp_source_pause_stream(uint16_t avdtp_cid, uint8_t local_seid){
811     return avdtp_suspend_stream(avdtp_cid, local_seid);
812 }
813 
814 void a2dp_source_stream_endpoint_request_can_send_now(uint16_t avdtp_cid, uint8_t local_seid){
815     avdtp_source_stream_endpoint_request_can_send_now(avdtp_cid, local_seid);
816 }
817 
818 int a2dp_max_media_payload_size(uint16_t avdtp_cid, uint8_t local_seid){
819     return avdtp_max_media_payload_size(avdtp_cid, local_seid);
820 }
821 
822 int a2dp_source_stream_send_media_payload(uint16_t avdtp_cid, uint8_t local_seid, uint8_t * storage, int num_bytes_to_copy, uint8_t num_frames, uint8_t marker){
823     return avdtp_source_stream_send_media_payload(avdtp_cid, local_seid, storage, num_bytes_to_copy, num_frames, marker);
824 }
825 
826 uint8_t a2dp_source_stream_send_media_payload_rtp(uint16_t a2dp_cid, uint8_t local_seid, uint8_t marker, uint8_t * payload, uint16_t payload_size){
827     return avdtp_source_stream_send_media_payload_rtp(a2dp_cid, local_seid, marker, payload, payload_size);
828 }
829 
830 uint8_t	a2dp_source_stream_send_media_packet(uint16_t a2dp_cid, uint8_t local_seid, const uint8_t * packet, uint16_t size){
831     return avdtp_source_stream_send_media_packet(a2dp_cid, local_seid, packet, size);
832 }
833 
834 static uint8_t a2dp_source_config_init(avdtp_connection_t *connection, uint8_t local_seid, uint8_t remote_seid,
835                                        avdtp_media_codec_type_t codec_type) {
836 
837     // check state
838     switch (connection->a2dp_source_state){
839         case A2DP_DISCOVERY_DONE:
840         case A2DP_GET_CAPABILITIES:
841             break;
842         default:
843             return ERROR_CODE_COMMAND_DISALLOWED;
844     }
845 
846     // lookup local stream endpoint
847     avdtp_stream_endpoint_t * stream_endpoint = avdtp_get_stream_endpoint_for_seid(local_seid);
848     if (stream_endpoint == NULL){
849         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
850     }
851 
852     // lookup remote stream endpoint
853     avdtp_sep_t * remote_sep = NULL;
854     uint8_t i;
855     for (i=0; i < sep_discovery_count; i++){
856         if (sep_discovery_seps[i].seid == remote_seid){
857             remote_sep = &sep_discovery_seps[i];
858         }
859     }
860     if (remote_sep == NULL){
861         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
862     }
863 
864     // set media configuration
865     stream_endpoint->remote_configuration_bitmap = store_bit16(stream_endpoint->remote_configuration_bitmap, AVDTP_MEDIA_CODEC, 1);
866     stream_endpoint->remote_configuration.media_codec.media_type = AVDTP_AUDIO;
867     stream_endpoint->remote_configuration.media_codec.media_codec_type = codec_type;
868     // remote seid to use
869     stream_endpoint->set_config_remote_seid = remote_seid;
870     // enable delay reporting if supported
871     if (remote_sep->registered_service_categories & (1<<AVDTP_DELAY_REPORTING)){
872         stream_endpoint->remote_configuration_bitmap = store_bit16(stream_endpoint->remote_configuration_bitmap, AVDTP_DELAY_REPORTING, 1);
873     }
874 
875     // suitable Sink stream endpoint found, configure it
876     connection->a2dp_source_local_stream_endpoint = stream_endpoint;
877     connection->a2dp_source_have_config = true;
878 
879 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
880     // continue outgoing configuration
881     if (connection->a2dp_source_state == A2DP_DISCOVERY_DONE){
882         connection->a2dp_source_state = A2DP_SET_CONFIGURATION;
883     }
884 #endif
885 
886     return ERROR_CODE_SUCCESS;
887 }
888 
889 uint8_t a2dp_source_set_config_sbc(uint16_t a2dp_cid, uint8_t local_seid, uint8_t remote_seid, const avdtp_configuration_sbc_t * configuration){
890     avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(a2dp_cid);
891     if (connection == NULL){
892         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
893     }
894 
895     uint8_t status = a2dp_source_config_init(connection, local_seid, remote_seid, AVDTP_CODEC_SBC);
896     if (status != 0) {
897         return status;
898     }
899     // set config in reserved buffer
900     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information = (uint8_t *) connection->a2dp_source_local_stream_endpoint->media_codec_info;
901     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = 4;
902     avdtp_config_sbc_store(connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information, configuration);
903 
904 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
905     a2dp_source_set_config(connection);
906 #endif
907 
908     return ERROR_CODE_SUCCESS;
909 }
910 
911 uint8_t a2dp_source_set_config_mpeg_audio(uint16_t a2dp_cid, uint8_t local_seid, uint8_t remote_seid, const avdtp_configuration_mpeg_audio_t * configuration){
912     avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(a2dp_cid);
913     if (connection == NULL){
914         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
915     }
916 
917     uint8_t status = a2dp_source_config_init(connection, local_seid, remote_seid, AVDTP_CODEC_MPEG_1_2_AUDIO);
918     if (status != 0) {
919         return status;
920     }
921 
922     // set config in reserved buffer
923     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information = (uint8_t *)connection->a2dp_source_local_stream_endpoint->media_codec_info;
924     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = 4;
925     avdtp_config_mpeg_audio_store( connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information, configuration);
926 
927 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
928     a2dp_source_set_config(connection);
929 #endif
930 
931     return ERROR_CODE_SUCCESS;
932 }
933 
934 uint8_t a2dp_source_set_config_mpeg_aac(uint16_t a2dp_cid,  uint8_t local_seid,  uint8_t remote_seid, const avdtp_configuration_mpeg_aac_t * configuration){
935     avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(a2dp_cid);
936     if (connection == NULL){
937         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
938     }
939 
940     uint8_t status = a2dp_source_config_init(connection, local_seid, remote_seid, AVDTP_CODEC_MPEG_2_4_AAC);
941     if (status != 0) {
942         return status;
943     }
944     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information = (uint8_t *) connection->a2dp_source_local_stream_endpoint->media_codec_info;
945     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = 6;
946     avdtp_config_mpeg_aac_store( connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information, configuration);
947 
948 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
949     a2dp_source_set_config(connection);
950 #endif
951 
952     return ERROR_CODE_SUCCESS;
953 }
954 
955 uint8_t a2dp_source_set_config_atrac(uint16_t a2dp_cid, uint8_t local_seid, uint8_t remote_seid, const avdtp_configuration_atrac_t * configuration){
956     avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(a2dp_cid);
957     if (connection == NULL){
958         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
959     }
960 
961     uint8_t status = a2dp_source_config_init(connection, local_seid, remote_seid, AVDTP_CODEC_ATRAC_FAMILY);
962     if (status != 0) {
963         return status;
964     }
965 
966     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information = (uint8_t *) connection->a2dp_source_local_stream_endpoint->media_codec_info;
967     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = 7;
968     avdtp_config_atrac_store( connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information, configuration);
969 
970 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
971     a2dp_source_set_config(connection);
972 #endif
973 
974     return ERROR_CODE_SUCCESS;
975 }
976 
977 uint8_t a2dp_source_set_config_other(uint16_t a2dp_cid,  uint8_t local_seid, uint8_t remote_seid,
978                                      const uint8_t * media_codec_information, uint8_t media_codec_information_len){
979     avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(a2dp_cid);
980     if (connection == NULL){
981         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
982     }
983 
984     uint8_t status = a2dp_source_config_init(connection, local_seid, remote_seid, AVDTP_CODEC_NON_A2DP);
985     if (status != 0) {
986         return status;
987     }
988 
989     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information = (uint8_t *) media_codec_information;
990     connection->a2dp_source_local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = media_codec_information_len;
991 
992 #ifdef ENABLE_A2DP_SOURCE_EXPLICIT_CONFIG
993     a2dp_source_set_config(connection);
994 #endif
995 
996     return status;
997 }
998 
999 uint8_t a2dp_source_reconfigure_stream_sampling_frequency(uint16_t avdtp_cid, uint32_t sampling_frequency){
1000     avdtp_connection_t * connection = avdtp_get_connection_for_avdtp_cid(avdtp_cid);
1001     if (connection == NULL){
1002         return ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER;
1003     }
1004 
1005     if (connection->a2dp_source_state != A2DP_STREAMING_OPENED) {
1006         return ERROR_CODE_COMMAND_DISALLOWED;
1007     }
1008 
1009     btstack_assert(connection->a2dp_source_local_stream_endpoint != NULL);
1010 
1011     log_info("Reconfigure avdtp_cid 0x%02x", avdtp_cid);
1012 
1013     avdtp_media_codec_type_t codec_type = connection->a2dp_source_local_stream_endpoint->sep.capabilities.media_codec.media_codec_type;
1014     uint8_t codec_info_len;
1015     switch (codec_type){
1016         case AVDTP_CODEC_SBC:
1017             codec_info_len = 4;
1018             (void)memcpy(connection->a2dp_source_local_stream_endpoint->media_codec_info, connection->a2dp_source_local_stream_endpoint->remote_sep.configuration.media_codec.media_codec_information, codec_info_len);
1019             avdtp_config_sbc_set_sampling_frequency(connection->a2dp_source_local_stream_endpoint->media_codec_info, sampling_frequency);
1020             break;
1021         case AVDTP_CODEC_MPEG_1_2_AUDIO:
1022             codec_info_len = 4;
1023             (void)memcpy(connection->a2dp_source_local_stream_endpoint->media_codec_info, connection->a2dp_source_local_stream_endpoint->remote_sep.configuration.media_codec.media_codec_information, codec_info_len);
1024             avdtp_config_mpeg_audio_set_sampling_frequency(connection->a2dp_source_local_stream_endpoint->media_codec_info, sampling_frequency);
1025             break;
1026         case AVDTP_CODEC_MPEG_2_4_AAC:
1027             codec_info_len = 6;
1028             (void)memcpy(connection->a2dp_source_local_stream_endpoint->media_codec_info, connection->a2dp_source_local_stream_endpoint->remote_sep.configuration.media_codec.media_codec_information, codec_info_len);
1029             avdtp_config_mpeg_aac_set_sampling_frequency(connection->a2dp_source_local_stream_endpoint->media_codec_info, sampling_frequency);
1030             break;
1031         case AVDTP_CODEC_ATRAC_FAMILY:
1032             codec_info_len = 7;
1033             (void)memcpy(connection->a2dp_source_local_stream_endpoint->media_codec_info, connection->a2dp_source_local_stream_endpoint->remote_sep.configuration.media_codec.media_codec_information, codec_info_len);
1034             avdtp_config_atrac_set_sampling_frequency(connection->a2dp_source_local_stream_endpoint->media_codec_info, sampling_frequency);
1035             break;
1036         default:
1037             return ERROR_CODE_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE;
1038     }
1039 
1040     avdtp_capabilities_t new_configuration;
1041     new_configuration.media_codec.media_type = AVDTP_AUDIO;
1042     new_configuration.media_codec.media_codec_type = codec_type;
1043     new_configuration.media_codec.media_codec_information_len = codec_info_len;
1044     new_configuration.media_codec.media_codec_information = connection->a2dp_source_local_stream_endpoint->media_codec_info;
1045 
1046     // start reconfigure
1047     connection->a2dp_source_state = A2DP_W2_RECONFIGURE_WITH_SEID;
1048 
1049     return avdtp_source_reconfigure(
1050             avdtp_cid,
1051             avdtp_stream_endpoint_seid(connection->a2dp_source_local_stream_endpoint),
1052             connection->a2dp_source_local_stream_endpoint->remote_sep.seid,
1053             1 << AVDTP_MEDIA_CODEC,
1054             new_configuration
1055     );
1056 }
1057