mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-03-10 19:13:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

avdtp: rename struct

Browse Source
This commit is contained in:
Milanka Ringwald 2016-11-10 15:20:01 +01:00
parent ec2c446c4d
commit 0e826a1761
10 changed files with 243 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/btstack_memory.c
View File

@ -477,40 +477,40 @@ void btstack_memory_service_record_item_free(service_record_item_t *service_reco
// MARK: avdtp_sink_connection_t // MARK: avdtp_stream_endpoint_t
#if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVDTP_SINK_CONNECTIONS) #if !defined(HAVE_MALLOC) && !defined(MAX_NR_AVDTP_STREAM_ENDPOINTS)
#if defined(MAX_NO_AVDTP_SINK_CONNECTIONS) #if defined(MAX_NO_AVDTP_STREAM_ENDPOINTS)
#error "Deprecated MAX_NO_AVDTP_SINK_CONNECTIONS defined instead of MAX_NR_AVDTP_SINK_CONNECTIONS. Please update your btstack_config.h to use MAX_NR_AVDTP_SINK_CONNECTIONS." #error "Deprecated MAX_NO_AVDTP_STREAM_ENDPOINTS defined instead of MAX_NR_AVDTP_STREAM_ENDPOINTS. Please update your btstack_config.h to use MAX_NR_AVDTP_STREAM_ENDPOINTS."
#else #else
#define MAX_NR_AVDTP_SINK_CONNECTIONS 0 #define MAX_NR_AVDTP_STREAM_ENDPOINTS 0
#endif #endif
#endif #endif
#ifdef MAX_NR_AVDTP_SINK_CONNECTIONS #ifdef MAX_NR_AVDTP_STREAM_ENDPOINTS
#if MAX_NR_AVDTP_SINK_CONNECTIONS > 0 #if MAX_NR_AVDTP_STREAM_ENDPOINTS > 0
static avdtp_sink_connection_t avdtp_sink_connection_storage[MAX_NR_AVDTP_SINK_CONNECTIONS]; static avdtp_stream_endpoint_t avdtp_stream_endpoint_storage[MAX_NR_AVDTP_STREAM_ENDPOINTS];
static btstack_memory_pool_t avdtp_sink_connection_pool; static btstack_memory_pool_t avdtp_stream_endpoint_pool;
avdtp_sink_connection_t * btstack_memory_avdtp_sink_connection_get(void){ avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){
return (avdtp_sink_connection_t *) btstack_memory_pool_get(&avdtp_sink_connection_pool); return (avdtp_stream_endpoint_t *) btstack_memory_pool_get(&avdtp_stream_endpoint_pool);
} }
void btstack_memory_avdtp_sink_connection_free(avdtp_sink_connection_t *avdtp_sink_connection){ void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){
btstack_memory_pool_free(&avdtp_sink_connection_pool, avdtp_sink_connection); btstack_memory_pool_free(&avdtp_stream_endpoint_pool, avdtp_stream_endpoint);
} }
#else #else
avdtp_sink_connection_t * btstack_memory_avdtp_sink_connection_get(void){ avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){
return NULL; return NULL;
} }
void btstack_memory_avdtp_sink_connection_free(avdtp_sink_connection_t *avdtp_sink_connection){ void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){
// silence compiler warning about unused parameter in a portable way // silence compiler warning about unused parameter in a portable way
(void) avdtp_sink_connection; (void) avdtp_stream_endpoint;
}; };
#endif #endif
#elif defined(HAVE_MALLOC) #elif defined(HAVE_MALLOC)
avdtp_sink_connection_t * btstack_memory_avdtp_sink_connection_get(void){ avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){
return (avdtp_sink_connection_t*) malloc(sizeof(avdtp_sink_connection_t)); return (avdtp_stream_endpoint_t*) malloc(sizeof(avdtp_stream_endpoint_t));
} }
void btstack_memory_avdtp_sink_connection_free(avdtp_sink_connection_t *avdtp_sink_connection){ void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){
free(avdtp_sink_connection); free(avdtp_stream_endpoint);
} }
#endif #endif
@ -667,8 +667,8 @@ void btstack_memory_init(void){
#if MAX_NR_SERVICE_RECORD_ITEMS > 0 #if MAX_NR_SERVICE_RECORD_ITEMS > 0
btstack_memory_pool_create(&service_record_item_pool, service_record_item_storage, MAX_NR_SERVICE_RECORD_ITEMS, sizeof(service_record_item_t)); btstack_memory_pool_create(&service_record_item_pool, service_record_item_storage, MAX_NR_SERVICE_RECORD_ITEMS, sizeof(service_record_item_t));
#endif #endif
#if MAX_NR_AVDTP_SINK_CONNECTIONS > 0 #if MAX_NR_AVDTP_STREAM_ENDPOINTS > 0
btstack_memory_pool_create(&avdtp_sink_connection_pool, avdtp_sink_connection_storage, MAX_NR_AVDTP_SINK_CONNECTIONS, sizeof(avdtp_sink_connection_t)); btstack_memory_pool_create(&avdtp_stream_endpoint_pool, avdtp_stream_endpoint_storage, MAX_NR_AVDTP_STREAM_ENDPOINTS, sizeof(avdtp_stream_endpoint_t));
#endif #endif
#ifdef ENABLE_BLE #ifdef ENABLE_BLE
#if MAX_NR_GATT_CLIENTS > 0 #if MAX_NR_GATT_CLIENTS > 0

6
src/btstack_memory.h
View File

@ -118,9 +118,9 @@ void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection);
service_record_item_t * btstack_memory_service_record_item_get(void); service_record_item_t * btstack_memory_service_record_item_get(void);
void btstack_memory_service_record_item_free(service_record_item_t *service_record_item); void btstack_memory_service_record_item_free(service_record_item_t *service_record_item);
// avdtp_sink_connection // avdtp_stream_endpoint
avdtp_sink_connection_t * btstack_memory_avdtp_sink_connection_get(void); avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void);
void btstack_memory_avdtp_sink_connection_free(avdtp_sink_connection_t *avdtp_sink_connection); void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint);
#ifdef ENABLE_BLE #ifdef ENABLE_BLE
// gatt_client, whitelist_entry, sm_lookup_entry // gatt_client, whitelist_entry, sm_lookup_entry

64
test/avdtp/avdtp_acceptor.c
View File

@ -215,15 +215,15 @@ int avdtp_acceptor_send_accept_response(uint16_t cid, avdtp_signal_identifier_t
return l2cap_send(cid, command, sizeof(command)); return l2cap_send(cid, command, sizeof(command));
} }
void avdtp_acceptor_stream_config_subsm_init(avdtp_sink_connection_t * connection){ void avdtp_acceptor_stream_config_subsm_init(avdtp_stream_endpoint_t * stream_endpoint){
connection->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
} }
int avdtp_acceptor_stream_config_subsm_is_done(avdtp_sink_connection_t * connection){ int avdtp_acceptor_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream_endpoint){
return connection->acceptor_config_state == AVDTP_ACCEPTOR_STREAM_CONFIG_DONE; return stream_endpoint->acceptor_config_state == AVDTP_ACCEPTOR_STREAM_CONFIG_DONE;
} }
int avdtp_acceptor_stream_config_subsm(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size){ int avdtp_acceptor_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
int request_to_send = 1; int request_to_send = 1;
avdtp_signaling_packet_header_t signaling_header; avdtp_signaling_packet_header_t signaling_header;
avdtp_read_signaling_header(&signaling_header, packet, size); avdtp_read_signaling_header(&signaling_header, packet, size);
@ -234,47 +234,47 @@ int avdtp_acceptor_stream_config_subsm(avdtp_sink_connection_t * connection, uin
int i = 2; int i = 2;
avdtp_sep_t sep; avdtp_sep_t sep;
connection->acceptor_transaction_label = signaling_header.transaction_label; stream_endpoint->acceptor_transaction_label = signaling_header.transaction_label;
switch (connection->acceptor_config_state){ switch (stream_endpoint->acceptor_config_state){
case AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE: case AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE:
switch (signaling_header.signal_identifier){ switch (signaling_header.signal_identifier){
case AVDTP_SI_DISCOVER: case AVDTP_SI_DISCOVER:
printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS\n"); printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS\n");
connection->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS;
break; break;
case AVDTP_SI_GET_ALL_CAPABILITIES: case AVDTP_SI_GET_ALL_CAPABILITIES:
printf(" ACP -> AVDTP_SI_GET_ALL_CAPABILITIES\n"); printf(" ACP -> AVDTP_SI_GET_ALL_CAPABILITIES\n");
connection->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES;
break; break;
case AVDTP_SI_GET_CAPABILITIES: case AVDTP_SI_GET_CAPABILITIES:
printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES\n"); printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES\n");
connection->query_seid = packet[2] >> 2; stream_endpoint->query_seid = packet[2] >> 2;
connection->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES;
break; break;
case AVDTP_SI_SET_CONFIGURATION: case AVDTP_SI_SET_CONFIGURATION:
printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION\n"); printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION\n");
connection->query_seid = packet[2] >> 2; stream_endpoint->query_seid = packet[2] >> 2;
sep.seid = packet[3] >> 2; sep.seid = packet[3] >> 2;
// find or add sep // find or add sep
for (i=0; i<connection->remote_seps_num; i++){ for (i=0; i < stream_endpoint->remote_seps_num; i++){
if (connection->remote_seps[i].seid == sep.seid){ if (stream_endpoint->remote_seps[i].seid == sep.seid){
connection->remote_sep_index = i; stream_endpoint->remote_sep_index = i;
} }
} }
sep.registered_service_categories = avdtp_unpack_service_capabilities(&sep.capabilities, packet+4, size-4); sep.registered_service_categories = avdtp_unpack_service_capabilities(&sep.capabilities, packet+4, size-4);
connection->remote_seps[connection->remote_sep_index] = sep; stream_endpoint->remote_seps[stream_endpoint->remote_sep_index] = sep;
connection->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION;
break; break;
default: default:
printf(" ACP -> NOT IMPLEMENTED, Reject signal_identifier %02x\n", signaling_header.signal_identifier); printf(" ACP -> NOT IMPLEMENTED, Reject signal_identifier %02x\n", signaling_header.signal_identifier);
connection->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD;
connection->unknown_signal_identifier = signaling_header.signal_identifier; stream_endpoint->unknown_signal_identifier = signaling_header.signal_identifier;
request_to_send = 1; request_to_send = 1;
break; break;
} }
l2cap_request_can_send_now_event(connection->l2cap_signaling_cid); l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
break; break;
case AVDTP_ACCEPTOR_STREAM_CONFIG_DONE: case AVDTP_ACCEPTOR_STREAM_CONFIG_DONE:
request_to_send = 0; request_to_send = 0;
@ -294,32 +294,32 @@ static int avdtp_acceptor_send_response_reject(uint16_t cid, avdtp_signal_ident
return l2cap_send(cid, command, sizeof(command)); return l2cap_send(cid, command, sizeof(command));
} }
int avdtp_acceptor_stream_config_subsm_run_for_connection(avdtp_sink_connection_t *connection, avdtp_sep_t * local_seps, uint8_t local_seps_num){ int avdtp_acceptor_stream_config_subsm_run_for_connection(avdtp_stream_endpoint_t * stream_endpoint, avdtp_sep_t * local_seps, uint8_t local_seps_num){
int sent = 1; int sent = 1;
switch (connection->acceptor_config_state){ switch (stream_endpoint->acceptor_config_state){
case AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS: case AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS:
printf(" AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n"); printf(" AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n");
connection->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_seps_response(connection->l2cap_signaling_cid, connection->acceptor_transaction_label, local_seps, local_seps_num); avdtp_acceptor_send_seps_response(stream_endpoint->l2cap_signaling_cid, stream_endpoint->acceptor_transaction_label, local_seps, local_seps_num);
break; break;
case AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES: case AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES:
printf(" AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n"); printf(" AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n");
connection->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_capabilities_response(connection->l2cap_signaling_cid, connection->acceptor_transaction_label, local_seps[connection->query_seid]); avdtp_acceptor_send_capabilities_response(stream_endpoint->l2cap_signaling_cid, stream_endpoint->acceptor_transaction_label, local_seps[stream_endpoint->query_seid]);
break; break;
case AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES: case AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES:
printf(" AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n"); printf(" AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n");
connection->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_all_capabilities_response(connection->l2cap_signaling_cid, connection->acceptor_transaction_label, local_seps[connection->query_seid]); avdtp_acceptor_send_all_capabilities_response(stream_endpoint->l2cap_signaling_cid, stream_endpoint->acceptor_transaction_label, local_seps[stream_endpoint->query_seid]);
break; break;
case AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD: case AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD:
connection->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_response_reject(connection->l2cap_signaling_cid, connection->unknown_signal_identifier, connection->acceptor_transaction_label); avdtp_acceptor_send_response_reject(stream_endpoint->l2cap_signaling_cid, stream_endpoint->unknown_signal_identifier, stream_endpoint->acceptor_transaction_label);
break; break;
case AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION: case AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION:
printf(" AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION -> AVDTP_ACCEPTOR_STREAM_CONFIG_DONE\n"); printf(" AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION -> AVDTP_ACCEPTOR_STREAM_CONFIG_DONE\n");
connection->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_DONE; stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_DONE;
avdtp_acceptor_send_accept_response(connection->l2cap_signaling_cid, AVDTP_SI_SET_CONFIGURATION, connection->acceptor_transaction_label); avdtp_acceptor_send_accept_response(stream_endpoint->l2cap_signaling_cid, AVDTP_SI_SET_CONFIGURATION, stream_endpoint->acceptor_transaction_label);
break; break;
default: default:
printf(" ACP -> run NOT IMPLEMENTED\n"); printf(" ACP -> run NOT IMPLEMENTED\n");

8
test/avdtp/avdtp_acceptor.h
View File

@ -51,10 +51,10 @@
extern "C" { extern "C" {
#endif #endif
void avdtp_acceptor_stream_config_subsm_init(avdtp_sink_connection_t * connection); void avdtp_acceptor_stream_config_subsm_init(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_acceptor_stream_config_subsm_is_done(avdtp_sink_connection_t * connection); int avdtp_acceptor_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_acceptor_stream_config_subsm(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size); int avdtp_acceptor_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size);
int avdtp_acceptor_stream_config_subsm_run_for_connection(avdtp_sink_connection_t *connection, avdtp_sep_t * local_seps, uint8_t local_seps_num); int avdtp_acceptor_stream_config_subsm_run_for_connection(avdtp_stream_endpoint_t * stream_endpoint, avdtp_sep_t * local_seps, uint8_t local_seps_num);
int avdtp_acceptor_send_accept_response(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label); int avdtp_acceptor_send_accept_response(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label);
#if defined __cplusplus #if defined __cplusplus

42
test/avdtp/avdtp_initiator.c
View File

@ -70,17 +70,17 @@ static int avdtp_initiator_send_get_capabilities_cmd(uint16_t cid, uint8_t trans
return l2cap_send(cid, command, sizeof(command)); return l2cap_send(cid, command, sizeof(command));
} }
void avdtp_initiator_stream_config_subsm_init(avdtp_sink_connection_t * connection){ void avdtp_initiator_stream_config_subsm_init(avdtp_stream_endpoint_t * stream_endpoint){
connection->initiator_config_state = AVDTP_INITIATOR_STREAM_CONFIG_IDLE; stream_endpoint->initiator_config_state = AVDTP_INITIATOR_STREAM_CONFIG_IDLE;
} }
int avdtp_initiator_stream_config_subsm_is_done(avdtp_sink_connection_t * connection){ int avdtp_initiator_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream_endpoint){
return connection->initiator_config_state == AVDTP_INITIATOR_STREAM_CONFIG_DONE; return stream_endpoint->initiator_config_state == AVDTP_INITIATOR_STREAM_CONFIG_DONE;
} }
int avdtp_initiator_stream_config_subsm(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size){ int avdtp_initiator_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
return 0; return 0;
if (avdtp_initiator_stream_config_subsm_run_for_connection(connection)) return 1; if (avdtp_initiator_stream_config_subsm_run_for_connection(stream_endpoint)) return 1;
int i; int i;
int responded = 1; int responded = 1;
avdtp_sep_t sep; avdtp_sep_t sep;
@ -88,12 +88,12 @@ int avdtp_initiator_stream_config_subsm(avdtp_sink_connection_t * connection, ui
avdtp_signaling_packet_header_t signaling_header; avdtp_signaling_packet_header_t signaling_header;
avdtp_read_signaling_header(&signaling_header, packet, size); avdtp_read_signaling_header(&signaling_header, packet, size);
switch (connection->initiator_config_state){ switch (stream_endpoint->initiator_config_state){
case AVDTP_INITIATOR_W4_SEPS_DISCOVERED: case AVDTP_INITIATOR_W4_SEPS_DISCOVERED:
printf(" AVDTP_INITIATOR_W4_SEPS_DISCOVERED -> AVDTP_INITIATOR_W2_GET_CAPABILITIES\n"); printf(" AVDTP_INITIATOR_W4_SEPS_DISCOVERED -> AVDTP_INITIATOR_W2_GET_CAPABILITIES\n");
if (signaling_header.transaction_label != connection->initiator_transaction_label){ if (signaling_header.transaction_label != stream_endpoint->initiator_transaction_label){
printf("unexpected transaction label, got %d, expected %d\n", signaling_header.transaction_label, connection->initiator_transaction_label); printf("unexpected transaction label, got %d, expected %d\n", signaling_header.transaction_label, stream_endpoint->initiator_transaction_label);
return 0; return 0;
} }
if (signaling_header.signal_identifier != AVDTP_SI_DISCOVER) { if (signaling_header.signal_identifier != AVDTP_SI_DISCOVER) {
@ -117,13 +117,13 @@ int avdtp_initiator_stream_config_subsm(avdtp_sink_connection_t * connection, ui
sep.in_use = (packet[i] >> 1) & 0x01; sep.in_use = (packet[i] >> 1) & 0x01;
sep.media_type = (avdtp_media_type_t)(packet[i+1] >> 4); sep.media_type = (avdtp_media_type_t)(packet[i+1] >> 4);
sep.type = (avdtp_sep_type_t)((packet[i+1] >> 3) & 0x01); sep.type = (avdtp_sep_type_t)((packet[i+1] >> 3) & 0x01);
connection->remote_seps[connection->remote_seps_num++] = sep; stream_endpoint->remote_seps[stream_endpoint->remote_seps_num++] = sep;
// printf("found sep: seid %u, in_use %d, media type %d, sep type %d (1-SNK)\n", // printf("found sep: seid %u, in_use %d, media type %d, sep type %d (1-SNK)\n",
// sep.seid, sep.in_use, sep.media_type, sep.type); // sep.seid, sep.in_use, sep.media_type, sep.type);
} }
connection->initiator_config_state = AVDTP_INITIATOR_W2_GET_CAPABILITIES; stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W2_GET_CAPABILITIES;
connection->initiator_transaction_label++; stream_endpoint->initiator_transaction_label++;
l2cap_request_can_send_now_event(connection->l2cap_signaling_cid); l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
responded = 1; responded = 1;
break; break;
case AVDTP_INITIATOR_W4_CAPABILITIES: case AVDTP_INITIATOR_W4_CAPABILITIES:
@ -143,25 +143,25 @@ int avdtp_initiator_stream_config_subsm(avdtp_sink_connection_t * connection, ui
return responded; return responded;
} }
int avdtp_initiator_stream_config_subsm_run_for_connection(avdtp_sink_connection_t *connection){ int avdtp_initiator_stream_config_subsm_run_for_connection(avdtp_stream_endpoint_t * stream_endpoint){
return 0; return 0;
int sent = 1; int sent = 1;
switch (connection->initiator_config_state){ switch (stream_endpoint->initiator_config_state){
case AVDTP_INITIATOR_STREAM_CONFIG_IDLE: case AVDTP_INITIATOR_STREAM_CONFIG_IDLE:
case AVDTP_INITIATOR_W2_DISCOVER_SEPS: case AVDTP_INITIATOR_W2_DISCOVER_SEPS:
printf(" AVDTP_INITIATOR_STREAM_CONFIG_IDLE | AVDTP_INITIATOR_W2_DISCOVER_SEPS -> AVDTP_INITIATOR_W4_SEPS_DISCOVERED\n"); printf(" AVDTP_INITIATOR_STREAM_CONFIG_IDLE | AVDTP_INITIATOR_W2_DISCOVER_SEPS -> AVDTP_INITIATOR_W4_SEPS_DISCOVERED\n");
connection->initiator_config_state = AVDTP_INITIATOR_W4_SEPS_DISCOVERED; stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_SEPS_DISCOVERED;
avdtp_initiator_send_signaling_cmd(connection->l2cap_signaling_cid, AVDTP_SI_DISCOVER, connection->initiator_transaction_label); avdtp_initiator_send_signaling_cmd(stream_endpoint->l2cap_signaling_cid, AVDTP_SI_DISCOVER, stream_endpoint->initiator_transaction_label);
break; break;
case AVDTP_INITIATOR_W2_GET_CAPABILITIES: case AVDTP_INITIATOR_W2_GET_CAPABILITIES:
printf(" AVDTP_INITIATOR_W2_GET_CAPABILITIES -> AVDTP_INITIATOR_W4_CAPABILITIES\n"); printf(" AVDTP_INITIATOR_W2_GET_CAPABILITIES -> AVDTP_INITIATOR_W4_CAPABILITIES\n");
connection->initiator_config_state = AVDTP_INITIATOR_W4_CAPABILITIES; stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_CAPABILITIES;
avdtp_initiator_send_get_capabilities_cmd(connection->l2cap_signaling_cid, connection->initiator_transaction_label, connection->query_seid); avdtp_initiator_send_get_capabilities_cmd(stream_endpoint->l2cap_signaling_cid, stream_endpoint->initiator_transaction_label, stream_endpoint->query_seid);
break; break;
case AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES: case AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES:
printf(" AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES -> AVDTP_INITIATOR_W4_ALL_CAPABILITIES\n"); printf(" AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES -> AVDTP_INITIATOR_W4_ALL_CAPABILITIES\n");
connection->initiator_config_state = AVDTP_INITIATOR_W4_ALL_CAPABILITIES; stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ALL_CAPABILITIES;
avdtp_initiator_send_get_all_capabilities_cmd(connection->l2cap_signaling_cid, connection->initiator_transaction_label, connection->query_seid); avdtp_initiator_send_get_all_capabilities_cmd(stream_endpoint->l2cap_signaling_cid, stream_endpoint->initiator_transaction_label, stream_endpoint->query_seid);
break; break;
default: default:
sent = 0; sent = 0;

8
test/avdtp/avdtp_initiator.h
View File

@ -51,10 +51,10 @@
extern "C" { extern "C" {
#endif #endif
void avdtp_initiator_stream_config_subsm_init(avdtp_sink_connection_t * connection); void avdtp_initiator_stream_config_subsm_init(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_initiator_stream_config_subsm_is_done(avdtp_sink_connection_t * connection); int avdtp_initiator_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_initiator_stream_config_subsm(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size); int avdtp_initiator_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size);
int avdtp_initiator_stream_config_subsm_run_for_connection(avdtp_sink_connection_t *connection); int avdtp_initiator_stream_config_subsm_run_for_connection(avdtp_stream_endpoint_t * stream_endpoint);
#if defined __cplusplus #if defined __cplusplus
} }

298
test/avdtp/avdtp_sink.c
View File

@ -52,16 +52,16 @@
static const char * default_avdtp_sink_service_name = "BTstack AVDTP Sink Service"; static const char * default_avdtp_sink_service_name = "BTstack AVDTP Sink Service";
static const char * default_avdtp_sink_service_provider_name = "BTstack AVDTP Sink Service Provider"; static const char * default_avdtp_sink_service_provider_name = "BTstack AVDTP Sink Service Provider";
static btstack_linked_list_t avdtp_sink_connections = NULL; static btstack_linked_list_t avdtp_stream_endpoints = NULL;
static avdtp_sep_t local_seps[MAX_NUM_SEPS]; static avdtp_sep_t local_seps[MAX_NUM_SEPS];
static uint8_t local_seps_num = 0; static uint8_t local_seps_num = 0;
static btstack_packet_handler_t avdtp_sink_callback; static btstack_packet_handler_t avdtp_sink_callback;
static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size); static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size);
static void avdtp_sink_run_for_connection(avdtp_sink_connection_t *connection); static void avdtp_sink_run_for_connection(avdtp_stream_endpoint_t * stream_endpoint);
static void (*handle_media_data)(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size); static void (*handle_media_data)(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size);
void a2dp_sink_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t supported_features, const char * service_name, const char * service_provider_name){ void a2dp_sink_create_sdp_record(uint8_t * service, uint32_t service_record_handle, uint16_t supported_features, const char * service_name, const char * service_provider_name){
uint8_t* attribute; uint8_t* attribute;
@ -142,7 +142,7 @@ void a2dp_sink_create_sdp_record(uint8_t * service, uint32_t service_record_han
de_add_number(service, DE_UINT, DE_SIZE_16, supported_features); de_add_number(service, DE_UINT, DE_SIZE_16, supported_features);
} }
uint8_t avdtp_sink_register_stream_end_point(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type){ uint8_t avdtp_sink_register_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type){
if (local_seps_num >= MAX_NUM_SEPS){ if (local_seps_num >= MAX_NUM_SEPS){
log_error("avdtp_sink_register_sep: excedeed max sep number %d", MAX_NUM_SEPS); log_error("avdtp_sink_register_sep: excedeed max sep number %d", MAX_NUM_SEPS);
return 255; return 255;
@ -255,52 +255,52 @@ void avdtp_sink_register_multiplexing_category(uint8_t seid, uint8_t fragmentati
// } // }
static avdtp_sink_connection_t * create_avdtp_sink_connection_context(bd_addr_t bd_addr){ static avdtp_stream_endpoint_t * create_avdtp_stream_endpoint_context(bd_addr_t bd_addr){
avdtp_sink_connection_t * connection = btstack_memory_avdtp_sink_connection_get(); avdtp_stream_endpoint_t * stream_endpoint = btstack_memory_avdtp_stream_endpoint_get();
if (!connection) return NULL; if (!stream_endpoint) return NULL;
printf(" create_avdtp_sink_connection_context %p\n", connection); printf(" create_avdtp_stream_endpoint_context %p\n", stream_endpoint);
memset(connection,0, sizeof(avdtp_sink_connection_t)); memset(stream_endpoint,0, sizeof(avdtp_stream_endpoint_t));
memcpy(connection->remote_addr, bd_addr, 6); memcpy(stream_endpoint->remote_addr, bd_addr, 6);
btstack_linked_list_add(&avdtp_sink_connections, (btstack_linked_item_t*)connection); btstack_linked_list_add(&avdtp_stream_endpoints, (btstack_linked_item_t*)stream_endpoint);
return connection; return stream_endpoint;
} }
static avdtp_sink_connection_t * get_avdtp_sink_connection_context_for_bd_addr(bd_addr_t bd_addr){ static avdtp_stream_endpoint_t * get_avdtp_sink_connection_context_for_bd_addr(bd_addr_t bd_addr){
btstack_linked_list_iterator_t it; btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink_connections); btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){ while (btstack_linked_list_iterator_has_next(&it)){
avdtp_sink_connection_t * connection = (avdtp_sink_connection_t *)btstack_linked_list_iterator_next(&it); avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (memcmp(connection->remote_addr, bd_addr, 6) == 0) { if (memcmp(stream_endpoint->remote_addr, bd_addr, 6) == 0) {
return connection; return stream_endpoint;
} }
} }
return NULL; return NULL;
} }
static avdtp_sink_connection_t * get_avdtp_sink_connection_context_for_l2cap_cid(uint16_t l2cap_cid){ static avdtp_stream_endpoint_t * get_avdtp_sink_connection_context_for_l2cap_cid(uint16_t l2cap_cid){
btstack_linked_list_iterator_t it; btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink_connections); btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){ while (btstack_linked_list_iterator_has_next(&it)){
avdtp_sink_connection_t * connection = (avdtp_sink_connection_t *)btstack_linked_list_iterator_next(&it); avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (connection->l2cap_signaling_cid == l2cap_cid){ if (stream_endpoint->l2cap_signaling_cid == l2cap_cid){
return connection; return stream_endpoint;
} }
if (connection->l2cap_media_cid == l2cap_cid){ if (stream_endpoint->l2cap_media_cid == l2cap_cid){
return connection; return stream_endpoint;
} }
if (connection->l2cap_reporting_cid == l2cap_cid){ if (stream_endpoint->l2cap_reporting_cid == l2cap_cid){
return connection; return stream_endpoint;
} }
} }
return NULL; return NULL;
} }
static void avdtp_sink_remove_connection_context(avdtp_sink_connection_t * connection){ static void avdtp_sink_remove_connection_context(avdtp_stream_endpoint_t * stream_endpoint){
btstack_linked_list_remove(&avdtp_sink_connections, (btstack_linked_item_t*) connection); btstack_linked_list_remove(&avdtp_stream_endpoints, (btstack_linked_item_t*) stream_endpoint);
} }
static void handle_l2cap_signaling_data_packet(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size){ static void handle_l2cap_signaling_data_packet(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
if (size < 2) { if (size < 2) {
log_error("l2cap data packet too small"); log_error("l2cap data packet too small");
return; return;
@ -312,32 +312,32 @@ static void handle_l2cap_signaling_data_packet(avdtp_sink_connection_t * connect
// printf("SIGNALING HEADER: tr_label %d, packet_type %d, msg_type %d, signal_identifier %02x\n", // printf("SIGNALING HEADER: tr_label %d, packet_type %d, msg_type %d, signal_identifier %02x\n",
// signaling_header.transaction_label, signaling_header.packet_type, signaling_header.message_type, signaling_header.signal_identifier); // signaling_header.transaction_label, signaling_header.packet_type, signaling_header.message_type, signaling_header.signal_identifier);
if (connection->avdtp_state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){ if (stream_endpoint->avdtp_state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){
if (avdtp_initiator_stream_config_subsm_is_done(connection) || avdtp_acceptor_stream_config_subsm_is_done(connection)){ if (avdtp_initiator_stream_config_subsm_is_done(stream_endpoint) || avdtp_acceptor_stream_config_subsm_is_done(stream_endpoint)){
printf("AVDTP_CONFIGURATION_SUBSTATEMACHINE -> AVDTP_CONFIGURED\n"); printf("AVDTP_CONFIGURATION_SUBSTATEMACHINE -> AVDTP_CONFIGURED\n");
connection->avdtp_state = AVDTP_CONFIGURED; stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
} }
} }
switch (connection->avdtp_state){ switch (stream_endpoint->avdtp_state){
case AVDTP_CONFIGURATION_SUBSTATEMACHINE: case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
if (signaling_header.message_type == AVDTP_CMD_MSG){ if (signaling_header.message_type == AVDTP_CMD_MSG){
avdtp_acceptor_stream_config_subsm(connection, packet, size); avdtp_acceptor_stream_config_subsm(stream_endpoint, packet, size);
break; break;
} }
avdtp_initiator_stream_config_subsm(connection, packet, size); avdtp_initiator_stream_config_subsm(stream_endpoint, packet, size);
break; break;
case AVDTP_CONFIGURED: case AVDTP_CONFIGURED:
switch (signaling_header.signal_identifier){ switch (signaling_header.signal_identifier){
case AVDTP_SI_OPEN: case AVDTP_SI_OPEN:
printf("AVDTP_CONFIGURED -> AVDTP_W2_ANSWER_OPEN_STREAM %d\n", signaling_header.transaction_label); printf("AVDTP_CONFIGURED -> AVDTP_W2_ANSWER_OPEN_STREAM %d\n", signaling_header.transaction_label);
connection->active_seid = packet[2] >> 2; stream_endpoint->active_seid = packet[2] >> 2;
connection->avdtp_state = AVDTP_W2_ANSWER_OPEN_STREAM; stream_endpoint->avdtp_state = AVDTP_W2_ANSWER_OPEN_STREAM;
connection->acceptor_transaction_label = signaling_header.transaction_label; stream_endpoint->acceptor_transaction_label = signaling_header.transaction_label;
l2cap_request_can_send_now_event(connection->l2cap_signaling_cid); l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
break; break;
default: default:
printf("AVDTP_CONFIGURED -> NOT IMPLEMENTED signal_identifier %d, state %d\n", signaling_header.signal_identifier, connection->avdtp_state); printf("AVDTP_CONFIGURED -> NOT IMPLEMENTED signal_identifier %d, state %d\n", signaling_header.signal_identifier, stream_endpoint->avdtp_state);
break; break;
} }
break; break;
@ -345,10 +345,10 @@ static void handle_l2cap_signaling_data_packet(avdtp_sink_connection_t * connect
switch (signaling_header.signal_identifier){ switch (signaling_header.signal_identifier){
case AVDTP_SI_START: case AVDTP_SI_START:
printf("AVDTP_OPEN -> AVDTP_W2_ANSWER_START_SINGLE_STREAM\n"); printf("AVDTP_OPEN -> AVDTP_W2_ANSWER_START_SINGLE_STREAM\n");
connection->active_seid = packet[2] >> 2; stream_endpoint->active_seid = packet[2] >> 2;
connection->avdtp_state = AVDTP_W2_ANSWER_START_SINGLE_STREAM; stream_endpoint->avdtp_state = AVDTP_W2_ANSWER_START_SINGLE_STREAM;
connection->acceptor_transaction_label = signaling_header.transaction_label; stream_endpoint->acceptor_transaction_label = signaling_header.transaction_label;
l2cap_request_can_send_now_event(connection->l2cap_signaling_cid); l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
break; break;
default: default:
printf("AVDTP_OPEN -> NOT IMPLEMENTED signal_identifier %d\n", signaling_header.signal_identifier); printf("AVDTP_OPEN -> NOT IMPLEMENTED signal_identifier %d\n", signaling_header.signal_identifier);
@ -356,7 +356,7 @@ static void handle_l2cap_signaling_data_packet(avdtp_sink_connection_t * connect
} }
break; break;
default: default:
printf("handle_l2cap_signaling_data_packet: state %d -> NOT IMPLEMENTED signal_identifier %d\n", connection->avdtp_state, signaling_header.signal_identifier); printf("handle_l2cap_signaling_data_packet: state %d -> NOT IMPLEMENTED signal_identifier %d\n", stream_endpoint->avdtp_state, signaling_header.signal_identifier);
// printf_hexdump( packet, size ); // printf_hexdump( packet, size );
break; break;
} }
@ -368,24 +368,24 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
uint16_t psm; uint16_t psm;
uint16_t remote_cid; uint16_t remote_cid;
uint16_t local_cid; uint16_t local_cid;
avdtp_sink_connection_t * connection = NULL; avdtp_stream_endpoint_t * stream_endpoint = NULL;
switch (packet_type) { switch (packet_type) {
case L2CAP_DATA_PACKET: case L2CAP_DATA_PACKET:
connection = get_avdtp_sink_connection_context_for_l2cap_cid(channel); stream_endpoint = get_avdtp_sink_connection_context_for_l2cap_cid(channel);
if (!connection){ if (!stream_endpoint){
log_error("avdtp packet handler L2CAP_DATA_PACKET: connection for local cid 0x%02x not found", channel); log_error("avdtp packet handler L2CAP_DATA_PACKET: connection for local cid 0x%02x not found", channel);
break; break;
} }
if (channel == connection->l2cap_signaling_cid){ if (channel == stream_endpoint->l2cap_signaling_cid){
handle_l2cap_signaling_data_packet(connection, packet, size); handle_l2cap_signaling_data_packet(stream_endpoint, packet, size);
} else if (channel == connection->l2cap_media_cid){ } else if (channel == stream_endpoint->l2cap_media_cid){
(*handle_media_data)(connection, packet, size); (*handle_media_data)(stream_endpoint, packet, size);
} else if (channel == connection->l2cap_reporting_cid){ } else if (channel == stream_endpoint->l2cap_reporting_cid){
// TODO // TODO
printf("L2CAP_DATA_PACKET for reporting: NOT IMPLEMENTED\n"); printf("L2CAP_DATA_PACKET for reporting: NOT IMPLEMENTED\n");
} else if (channel == connection->l2cap_recovery_cid){ } else if (channel == stream_endpoint->l2cap_recovery_cid){
// TODO // TODO
printf("L2CAP_DATA_PACKET for recovery: NOT IMPLEMENTED\n"); printf("L2CAP_DATA_PACKET for recovery: NOT IMPLEMENTED\n");
} else { } else {
@ -397,15 +397,15 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
switch (hci_event_packet_get_type(packet)) { switch (hci_event_packet_get_type(packet)) {
case L2CAP_EVENT_INCOMING_CONNECTION: case L2CAP_EVENT_INCOMING_CONNECTION:
l2cap_event_incoming_connection_get_address(packet, event_addr); l2cap_event_incoming_connection_get_address(packet, event_addr);
connection = get_avdtp_sink_connection_context_for_bd_addr(event_addr); stream_endpoint = get_avdtp_sink_connection_context_for_bd_addr(event_addr);
if (!connection){ if (!stream_endpoint){
connection = create_avdtp_sink_connection_context(event_addr); stream_endpoint = create_avdtp_stream_endpoint_context(event_addr);
if (!connection) { if (!stream_endpoint) {
log_error("avdtp packet handler L2CAP_EVENT_INCOMING_CONNECTION: connection for bd address %s not found", bd_addr_to_str(event_addr)); log_error("avdtp packet handler L2CAP_EVENT_INCOMING_CONNECTION: stream_endpoint for bd address %s not found", bd_addr_to_str(event_addr));
break; break;
} }
} }
printf("L2CAP_EVENT_INCOMING_CONNECTION state %d\n", connection->avdtp_state); printf("L2CAP_EVENT_INCOMING_CONNECTION state %d\n", stream_endpoint->avdtp_state);
con_handle = l2cap_event_incoming_connection_get_handle(packet); con_handle = l2cap_event_incoming_connection_get_handle(packet);
psm = l2cap_event_incoming_connection_get_psm(packet); psm = l2cap_event_incoming_connection_get_psm(packet);
@ -422,30 +422,30 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// 3. reporting // 3. reporting
// 4. recovery // 4. recovery
if (connection->l2cap_signaling_cid == 0){ if (stream_endpoint->l2cap_signaling_cid == 0){
// if (connection->avdtp_state != AVDTP_IDLE) break; // if (stream_endpoint->avdtp_state != AVDTP_IDLE) break;
printf("incoming %d: AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED\n", connection->avdtp_state); printf("incoming %d: AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED\n", stream_endpoint->avdtp_state);
connection->l2cap_signaling_cid = local_cid; stream_endpoint->l2cap_signaling_cid = local_cid;
connection->avdtp_state = AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED; stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED;
l2cap_accept_connection(local_cid); l2cap_accept_connection(local_cid);
return; return;
} }
if (connection->l2cap_media_cid == 0){ if (stream_endpoint->l2cap_media_cid == 0){
// if (connection->avdtp_state != AVDTP_W2_ANSWER_OPEN_STREAM) break; // if (stream_endpoint->avdtp_state != AVDTP_W2_ANSWER_OPEN_STREAM) break;
printf("incoming %d: AVDTP_W2_ANSWER_OPEN_STREAM\n", connection->avdtp_state); printf("incoming %d: AVDTP_W2_ANSWER_OPEN_STREAM\n", stream_endpoint->avdtp_state);
connection->l2cap_media_cid = local_cid; stream_endpoint->l2cap_media_cid = local_cid;
connection->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED; stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED;
l2cap_accept_connection(local_cid); l2cap_accept_connection(local_cid);
return; return;
} }
if (connection->l2cap_reporting_cid == 0){ if (stream_endpoint->l2cap_reporting_cid == 0){
connection->l2cap_reporting_cid = local_cid; stream_endpoint->l2cap_reporting_cid = local_cid;
printf("TODO enable reporting, set state\n"); printf("TODO enable reporting, set state\n");
return; return;
} }
if (connection->l2cap_recovery_cid == 0){ if (stream_endpoint->l2cap_recovery_cid == 0){
connection->l2cap_recovery_cid = local_cid; stream_endpoint->l2cap_recovery_cid = local_cid;
printf("TODO enable recovery, set state\n"); printf("TODO enable recovery, set state\n");
return; return;
} }
@ -454,9 +454,9 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case L2CAP_EVENT_CHANNEL_OPENED: case L2CAP_EVENT_CHANNEL_OPENED:
// inform about new l2cap connection // inform about new l2cap connection
l2cap_event_channel_opened_get_address(packet, event_addr); l2cap_event_channel_opened_get_address(packet, event_addr);
connection = get_avdtp_sink_connection_context_for_bd_addr(event_addr); stream_endpoint = get_avdtp_sink_connection_context_for_bd_addr(event_addr);
if (!connection){ if (!stream_endpoint){
log_error("avdtp sink: L2CAP_EVENT_CHANNEL_OPENED: connection for bd addr %s cannot be found", bd_addr_to_str(event_addr)); log_error("avdtp sink: L2CAP_EVENT_CHANNEL_OPENED: stream_endpoint for bd addr %s cannot be found", bd_addr_to_str(event_addr));
return; return;
} }
@ -476,7 +476,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
printf("L2CAP_EVENT_CHANNEL_OPENED: Channel successfully opened: %s, handle 0x%02x, psm 0x%02x, local cid 0x%02x, remote cid 0x%02x, context %p\n", printf("L2CAP_EVENT_CHANNEL_OPENED: Channel successfully opened: %s, handle 0x%02x, psm 0x%02x, local cid 0x%02x, remote cid 0x%02x, context %p\n",
bd_addr_to_str(event_addr), con_handle, psm, local_cid, l2cap_event_channel_opened_get_remote_cid(packet), bd_addr_to_str(event_addr), con_handle, psm, local_cid, l2cap_event_channel_opened_get_remote_cid(packet),
connection); stream_endpoint);
if (psm != PSM_AVDTP) break; if (psm != PSM_AVDTP) break;
@ -487,36 +487,36 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// 3. reporting // 3. reporting
// 4. recovery // 4. recovery
if (connection->l2cap_signaling_cid == 0 || connection->l2cap_signaling_cid == local_cid){ if (stream_endpoint->l2cap_signaling_cid == 0 || stream_endpoint->l2cap_signaling_cid == local_cid){
if (connection->avdtp_state != AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED) break; if (stream_endpoint->avdtp_state != AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED) break;
printf("AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED -> AVDTP_CONFIGURATION_SUBSTATEMACHINE\n"); printf("AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED -> AVDTP_CONFIGURATION_SUBSTATEMACHINE\n");
connection->avdtp_state = AVDTP_CONFIGURATION_SUBSTATEMACHINE; stream_endpoint->avdtp_state = AVDTP_CONFIGURATION_SUBSTATEMACHINE;
avdtp_initiator_stream_config_subsm_init(connection); avdtp_initiator_stream_config_subsm_init(stream_endpoint);
avdtp_acceptor_stream_config_subsm_init(connection); avdtp_acceptor_stream_config_subsm_init(stream_endpoint);
connection->l2cap_signaling_cid = local_cid; stream_endpoint->l2cap_signaling_cid = local_cid;
connection->initiator_transaction_label++; stream_endpoint->initiator_transaction_label++;
l2cap_request_can_send_now_event(connection->l2cap_signaling_cid); l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
break; break;
} }
if (connection->l2cap_media_cid == 0 || connection->l2cap_media_cid == local_cid){ if (stream_endpoint->l2cap_media_cid == 0 || stream_endpoint->l2cap_media_cid == local_cid){
printf("l2cap opened %d: L2CAP_EVENT_CHANNEL_OPENED: Media \n", connection->avdtp_state); printf("l2cap opened %d: L2CAP_EVENT_CHANNEL_OPENED: Media \n", stream_endpoint->avdtp_state);
if (connection->avdtp_state != AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED) break; if (stream_endpoint->avdtp_state != AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED) break;
connection->l2cap_media_cid = local_cid; stream_endpoint->l2cap_media_cid = local_cid;
connection->avdtp_state = AVDTP_OPEN; stream_endpoint->avdtp_state = AVDTP_OPEN;
break; break;
} }
if (connection->l2cap_reporting_cid == 0 || connection->l2cap_reporting_cid == local_cid){ if (stream_endpoint->l2cap_reporting_cid == 0 || stream_endpoint->l2cap_reporting_cid == local_cid){
printf("TODO enable reporting, set state\n"); printf("TODO enable reporting, set state\n");
connection->l2cap_reporting_cid = local_cid; stream_endpoint->l2cap_reporting_cid = local_cid;
break; break;
} }
if (connection->l2cap_recovery_cid == 0 || connection->l2cap_recovery_cid == local_cid){ if (stream_endpoint->l2cap_recovery_cid == 0 || stream_endpoint->l2cap_recovery_cid == local_cid){
printf("TODO enable recovery, set state\n"); printf("TODO enable recovery, set state\n");
connection->l2cap_recovery_cid = local_cid; stream_endpoint->l2cap_recovery_cid = local_cid;
break; break;
} }
break; break;
@ -524,32 +524,32 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case L2CAP_EVENT_CHANNEL_CLOSED: case L2CAP_EVENT_CHANNEL_CLOSED:
// data: event (8), len(8), channel (16) // data: event (8), len(8), channel (16)
local_cid = l2cap_event_channel_closed_get_local_cid(packet); local_cid = l2cap_event_channel_closed_get_local_cid(packet);
connection = get_avdtp_sink_connection_context_for_l2cap_cid(local_cid); stream_endpoint = get_avdtp_sink_connection_context_for_l2cap_cid(local_cid);
if (!connection) return; if (!stream_endpoint) return;
if (connection->l2cap_recovery_cid == local_cid){ if (stream_endpoint->l2cap_recovery_cid == local_cid){
log_info("L2CAP_EVENT_CHANNEL_CLOSED recovery cid 0x%0x", local_cid); log_info("L2CAP_EVENT_CHANNEL_CLOSED recovery cid 0x%0x", local_cid);
connection->l2cap_recovery_cid = 0; stream_endpoint->l2cap_recovery_cid = 0;
break; break;
} }
if (connection->l2cap_reporting_cid == local_cid){ if (stream_endpoint->l2cap_reporting_cid == local_cid){
log_info("L2CAP_EVENT_CHANNEL_CLOSED reporting cid 0x%0x", local_cid); log_info("L2CAP_EVENT_CHANNEL_CLOSED reporting cid 0x%0x", local_cid);
connection->l2cap_reporting_cid = 0; stream_endpoint->l2cap_reporting_cid = 0;
break; break;
} }
if (connection->l2cap_media_cid == local_cid){ if (stream_endpoint->l2cap_media_cid == local_cid){
log_info("L2CAP_EVENT_CHANNEL_CLOSED media cid 0x%0x", local_cid); log_info("L2CAP_EVENT_CHANNEL_CLOSED media cid 0x%0x", local_cid);
connection->avdtp_state = AVDTP_CONFIGURED; stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
connection->l2cap_media_cid = 0; stream_endpoint->l2cap_media_cid = 0;
break; break;
} }
if (connection->l2cap_signaling_cid == local_cid){ if (stream_endpoint->l2cap_signaling_cid == local_cid){
log_info("L2CAP_EVENT_CHANNEL_CLOSED signaling cid 0x%0x", local_cid); log_info("L2CAP_EVENT_CHANNEL_CLOSED signaling cid 0x%0x", local_cid);
connection->avdtp_state = AVDTP_IDLE; stream_endpoint->avdtp_state = AVDTP_IDLE;
avdtp_sink_remove_connection_context(connection); avdtp_sink_remove_connection_context(stream_endpoint);
break; break;
} }
break; break;
@ -568,7 +568,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// other packet type // other packet type
break; break;
} }
avdtp_sink_run_for_connection(connection); avdtp_sink_run_for_connection(stream_endpoint);
} }
// TODO: find out which security level is needed, and replace LEVEL_0 in avdtp_sink_init // TODO: find out which security level is needed, and replace LEVEL_0 in avdtp_sink_init
@ -576,7 +576,7 @@ void avdtp_sink_init(void){
l2cap_register_service(&packet_handler, PSM_AVDTP, 0xffff, LEVEL_0); l2cap_register_service(&packet_handler, PSM_AVDTP, 0xffff, LEVEL_0);
} }
void avdtp_sink_register_media_handler(void (*callback)(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size)){ void avdtp_sink_register_media_handler(void (*callback)(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size)){
if (callback == NULL){ if (callback == NULL){
log_error("avdtp_sink_register_media_handler called with NULL callback"); log_error("avdtp_sink_register_media_handler called with NULL callback");
return; return;
@ -593,91 +593,91 @@ void avdtp_sink_register_packet_handler(btstack_packet_handler_t callback){
} }
static void avdtp_sink_run_for_connection(avdtp_sink_connection_t *connection){ static void avdtp_sink_run_for_connection(avdtp_stream_endpoint_t * stream_endpoint){
if (!connection) return; if (!stream_endpoint) return;
if (connection->release_l2cap_connection){ if (stream_endpoint->release_l2cap_connection){
if (connection->avdtp_state > AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED || if (stream_endpoint->avdtp_state > AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED ||
connection->avdtp_state < AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED){ stream_endpoint->avdtp_state < AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED){
connection->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED; stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED;
l2cap_disconnect(connection->l2cap_media_cid, 0); l2cap_disconnect(stream_endpoint->l2cap_media_cid, 0);
return; return;
} }
if (connection->avdtp_state > AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED || if (stream_endpoint->avdtp_state > AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED ||
connection->avdtp_state < AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED){ stream_endpoint->avdtp_state < AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED){
connection->release_l2cap_connection = 0; stream_endpoint->release_l2cap_connection = 0;
connection->avdtp_state = AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED; stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED;
l2cap_disconnect(connection->l2cap_signaling_cid, 0); l2cap_disconnect(stream_endpoint->l2cap_signaling_cid, 0);
return; return;
} }
} }
if (!l2cap_can_send_packet_now(connection->l2cap_signaling_cid)) { if (!l2cap_can_send_packet_now(stream_endpoint->l2cap_signaling_cid)) {
log_info("avdtp_sink_run_for_connection: request cannot send for 0x%02x", connection->l2cap_signaling_cid); log_info("avdtp_sink_run_for_connection: request cannot send for 0x%02x", stream_endpoint->l2cap_signaling_cid);
return; return;
} }
if (connection->avdtp_state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){ if (stream_endpoint->avdtp_state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){
if (avdtp_initiator_stream_config_subsm_is_done(connection) || avdtp_acceptor_stream_config_subsm_is_done(connection)){ if (avdtp_initiator_stream_config_subsm_is_done(stream_endpoint) || avdtp_acceptor_stream_config_subsm_is_done(stream_endpoint)){
printf("AVDTP_CONFIGURATION_SUBSTATEMACHINE -> AVDTP_CONFIGURED\n"); printf("AVDTP_CONFIGURATION_SUBSTATEMACHINE -> AVDTP_CONFIGURED\n");
connection->avdtp_state = AVDTP_CONFIGURED; stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
} }
} }
printf(" --> avdtp_sink_run_for_connection state %d\n", connection->avdtp_state); printf(" --> avdtp_sink_run_for_connection state %d\n", stream_endpoint->avdtp_state);
switch (connection->avdtp_state){ switch (stream_endpoint->avdtp_state){
case AVDTP_CONFIGURATION_SUBSTATEMACHINE: case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
if (!avdtp_initiator_stream_config_subsm_run_for_connection(connection)) { if (!avdtp_initiator_stream_config_subsm_run_for_connection(stream_endpoint)) {
avdtp_acceptor_stream_config_subsm_run_for_connection(connection, local_seps, local_seps_num); avdtp_acceptor_stream_config_subsm_run_for_connection(stream_endpoint, local_seps, local_seps_num);
} }
break; break;
case AVDTP_W2_ANSWER_OPEN_STREAM: case AVDTP_W2_ANSWER_OPEN_STREAM:
printf("AVDTP_W2_ANSWER_OPEN_STREAM -> AVDTP_OPEN\n"); printf("AVDTP_W2_ANSWER_OPEN_STREAM -> AVDTP_OPEN\n");
connection->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED; stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED;
avdtp_acceptor_send_accept_response(connection->l2cap_signaling_cid, AVDTP_SI_OPEN, connection->acceptor_transaction_label); avdtp_acceptor_send_accept_response(stream_endpoint->l2cap_signaling_cid, AVDTP_SI_OPEN, stream_endpoint->acceptor_transaction_label);
break; break;
case AVDTP_W2_ANSWER_START_SINGLE_STREAM: case AVDTP_W2_ANSWER_START_SINGLE_STREAM:
printf("AVDTP_W2_ANSWER_START_SINGLE_STREAM -> AVDTP_W4_STREAMING_CONNECTION_OPEN\n"); printf("AVDTP_W2_ANSWER_START_SINGLE_STREAM -> AVDTP_W4_STREAMING_CONNECTION_OPEN\n");
connection->avdtp_state = AVDTP_W4_STREAMING_CONNECTION_OPEN; stream_endpoint->avdtp_state = AVDTP_W4_STREAMING_CONNECTION_OPEN;
avdtp_acceptor_send_accept_response(connection->l2cap_signaling_cid, AVDTP_SI_START, connection->acceptor_transaction_label); avdtp_acceptor_send_accept_response(stream_endpoint->l2cap_signaling_cid, AVDTP_SI_START, stream_endpoint->acceptor_transaction_label);
break; break;
default: default:
printf("avdtp_sink_run_for_connection: state %d -> NOT IMPLEMENTED\n", connection->avdtp_state); printf("avdtp_sink_run_for_connection: state %d -> NOT IMPLEMENTED\n", stream_endpoint->avdtp_state);
break; break;
} }
} }
void avdtp_sink_connect(bd_addr_t bd_addr){ void avdtp_sink_connect(bd_addr_t bd_addr){
avdtp_sink_connection_t * connection = get_avdtp_sink_connection_context_for_bd_addr(bd_addr); avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_sink_connection_context_for_bd_addr(bd_addr);
if (connection) { if (stream_endpoint) {
log_error("avdtp_sink_connect: connection for bd address %s not found", bd_addr_to_str(bd_addr)); log_error("avdtp_sink_connect: stream_endpoint for bd address %s not found", bd_addr_to_str(bd_addr));
return; return;
} }
connection = create_avdtp_sink_connection_context(bd_addr); stream_endpoint = create_avdtp_stream_endpoint_context(bd_addr);
if (!connection){ if (!stream_endpoint){
log_error("avdtp_sink_connect: cannot create connection for bd address %s", bd_addr_to_str(bd_addr)); log_error("avdtp_sink_connect: cannot create stream_endpoint for bd address %s", bd_addr_to_str(bd_addr));
return; return;
} }
connection->avdtp_state = AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED; stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED;
l2cap_create_channel(packet_handler, connection->remote_addr, PSM_AVDTP, 0xffff, NULL); l2cap_create_channel(packet_handler, stream_endpoint->remote_addr, PSM_AVDTP, 0xffff, NULL);
} }
void avdtp_sink_disconnect(uint16_t l2cap_cid){ void avdtp_sink_disconnect(uint16_t l2cap_cid){
avdtp_sink_connection_t * connection = get_avdtp_sink_connection_context_for_l2cap_cid(l2cap_cid); avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_sink_connection_context_for_l2cap_cid(l2cap_cid);
if (!connection) { if (!stream_endpoint) {
log_error("avdtp_sink_disconnect: Connection with l2cap_cid %d not found", l2cap_cid); log_error("avdtp_sink_disconnect: Connection with l2cap_cid %d not found", l2cap_cid);
return; return;
} }
if (connection->avdtp_state == AVDTP_IDLE) return; if (stream_endpoint->avdtp_state == AVDTP_IDLE) return;
if (connection->avdtp_state == AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED) return; if (stream_endpoint->avdtp_state == AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED) return;
connection->release_l2cap_connection = 1; stream_endpoint->release_l2cap_connection = 1;
avdtp_sink_run_for_connection(connection); avdtp_sink_run_for_connection(stream_endpoint);
} }

14
test/avdtp/avdtp_sink.h
View File

@ -61,20 +61,17 @@ typedef enum {
AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED, AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED,
AVDTP_CONFIGURATION_SUBSTATEMACHINE, AVDTP_CONFIGURATION_SUBSTATEMACHINE,
AVDTP_CONFIGURED, AVDTP_CONFIGURED,
AVDTP_W2_ANSWER_OPEN_STREAM, AVDTP_W2_ANSWER_OPEN_STREAM,
AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED, AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED,
AVDTP_OPEN, // 5 AVDTP_OPEN, // 5
AVDTP_W2_ANSWER_START_SINGLE_STREAM, AVDTP_W2_ANSWER_START_SINGLE_STREAM,
AVDTP_W4_STREAMING_CONNECTION_OPEN, AVDTP_W4_STREAMING_CONNECTION_OPEN,
AVDTP_STREAMING, // 8 AVDTP_STREAMING, // 8
AVDTP_CLOSING, AVDTP_CLOSING,
AVDTP_ABORTING, AVDTP_ABORTING,
AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED, AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED,
AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED
} avdtp_state_t; } avdtp_seid_state_t;
typedef enum { typedef enum {
AVDTP_INITIATOR_STREAM_CONFIG_IDLE, AVDTP_INITIATOR_STREAM_CONFIG_IDLE,
@ -113,7 +110,7 @@ typedef struct avdtp_sink_connection {
uint8_t num_l2cap_channels_opened; uint8_t num_l2cap_channels_opened;
avdtp_state_t avdtp_state; avdtp_seid_state_t avdtp_state;
avdtp_initiator_stream_config_state_t initiator_config_state; avdtp_initiator_stream_config_state_t initiator_config_state;
avdtp_acceptor_stream_config_state_t acceptor_config_state; avdtp_acceptor_stream_config_state_t acceptor_config_state;
@ -134,7 +131,7 @@ typedef struct avdtp_sink_connection {
// register request for L2cap connection release // register request for L2cap connection release
uint8_t release_l2cap_connection; uint8_t release_l2cap_connection;
} avdtp_sink_connection_t; } avdtp_stream_endpoint_t;
/* API_START */ /* API_START */
@ -155,7 +152,7 @@ void a2dp_sink_create_sdp_record(uint8_t * service, uint32_t service_record_han
void avdtp_sink_init(void); void avdtp_sink_init(void);
// returns sep_id // returns sep_id
uint8_t avdtp_sink_register_stream_end_point(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type); uint8_t avdtp_sink_register_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type);
void avdtp_sink_register_media_transport_category(uint8_t seid); void avdtp_sink_register_media_transport_category(uint8_t seid);
void avdtp_sink_register_reporting_category(uint8_t seid); void avdtp_sink_register_reporting_category(uint8_t seid);
@ -179,8 +176,7 @@ void avdtp_sink_register_packet_handler(btstack_packet_handler_t callback);
*/ */
void avdtp_sink_connect(bd_addr_t bd_addr); void avdtp_sink_connect(bd_addr_t bd_addr);
// TODO: per connectio? void avdtp_sink_register_media_handler(void (*callback)(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size));
void avdtp_sink_register_media_handler(void (*callback)(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size));
/** /**
* @brief Disconnect from device with connection handle. * @brief Disconnect from device with connection handle.
* @param l2cap_cid * @param l2cap_cid

4
test/avdtp/avdtp_test.c
View File

@ -146,7 +146,7 @@ uint16_t local_cid = 0;
static btstack_packet_callback_registration_t hci_event_callback_registration; static btstack_packet_callback_registration_t hci_event_callback_registration;
static void handle_l2cap_media_data_packet(avdtp_sink_connection_t * connection, uint8_t *packet, uint16_t size){ static void handle_l2cap_media_data_packet(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
int pos = 0; int pos = 0;
avdtp_media_packet_header_t media_header; avdtp_media_packet_header_t media_header;
@ -320,7 +320,7 @@ int btstack_main(int argc, const char * argv[]){
avdtp_sink_init(); avdtp_sink_init();
avdtp_sink_register_packet_handler(&packet_handler); avdtp_sink_register_packet_handler(&packet_handler);
uint8_t seid = avdtp_sink_register_stream_end_point(AVDTP_SINK, AVDTP_AUDIO); uint8_t seid = avdtp_sink_register_stream_endpoint(AVDTP_SINK, AVDTP_AUDIO);
avdtp_sink_register_media_transport_category(seid); avdtp_sink_register_media_transport_category(seid);
avdtp_sink_register_media_codec_category(seid, AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_info, sizeof(media_sbc_codec_info)); avdtp_sink_register_media_codec_category(seid, AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_info, sizeof(media_sbc_codec_info));

2
tool/btstack_memory_generator.py
View File

@ -178,7 +178,7 @@ list_of_structs = [
["bnep_service", "bnep_channel"], ["bnep_service", "bnep_channel"],
["hfp_connection"], ["hfp_connection"],
["service_record_item"], ["service_record_item"],
["avdtp_sink_connection"] ["avdtp_stream_endpoint"]
] ]
list_of_le_structs = [["gatt_client", "whitelist_entry", "sm_lookup_entry"]] list_of_le_structs = [["gatt_client", "whitelist_entry", "sm_lookup_entry"]]