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