mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-02-22 06:41:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

avdtp: rewrite for SM per stream endpoint

Browse Source
This commit is contained in:
Milanka Ringwald 2016-11-15 17:17:19 +01:00
parent e8a8723bc4
commit 7a646ea0f6
8 changed files with 456 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
test/avdtp/avdtp.h
View File

@ -212,15 +212,6 @@ typedef struct{
avdtp_multiplexing_mode_capabilities_t multiplexing_mode;
} avdtp_capabilities_t;
typedef struct {
uint8_t seid; // 0x01 – 0x3E, 6bit
uint8_t in_use; // 1 bit, 0 - not in use, 1 - in use
avdtp_media_type_t media_type; // 4 bit
avdtp_sep_type_t type; // 1 bit, 0 - SRC, 1 - SNK
uint16_t registered_service_categories;
avdtp_capabilities_t capabilities;
} avdtp_sep_t;
typedef enum{
AVDTP_SBC_48000 = 1,
@ -282,6 +273,11 @@ typedef struct {
uint32_t csrc_list[MAX_CSRC_NUM];
} avdtp_media_packet_header_t;
typedef enum {
AVDTP_BASIC_SERVICE_MODE,
AVDTP_MULTIPLEXING_SERVICE_MODE
} avdtp_service_mode_t;
typedef enum {
AVDTP_IDLE,
AVDTP_CONFIGURATION_SUBSTATEMACHINE,
@ -322,10 +318,69 @@ typedef enum {
AVDTP_ACCEPTOR_STREAM_CONFIG_DONE
} avdtp_acceptor_stream_config_state_t;
typedef struct {
uint8_t seid; // 0x01 – 0x3E, 6bit
uint8_t in_use; // 1 bit, 0 - not in use, 1 - in use
avdtp_media_type_t media_type; // 4 bit
avdtp_sep_type_t type; // 1 bit, 0 - SRC, 1 - SNK
uint16_t registered_service_categories;
avdtp_capabilities_t capabilities;
} avdtp_sep_t;
typedef struct avdtp_stream_endpoint {
btstack_linked_item_t item;
avdtp_sep_t sep;
uint16_t l2cap_media_cid;
uint16_t l2cap_reporting_cid;
uint16_t l2cap_recovery_cid;
uint8_t num_l2cap_channels_opened;
avdtp_stream_endpoint_state_t state;
avdtp_initiator_stream_config_state_t initiator_config_state;
avdtp_acceptor_stream_config_state_t acceptor_config_state;
avdtp_signal_identifier_t unknown_signal_identifier;
// store remote seps
avdtp_sep_t remote_seps[MAX_NUM_SEPS];
uint8_t remote_seps_num;
// currently active remote seid
uint8_t remote_sep_index;
// register request for L2cap connection release
uint8_t disconnect;
} avdtp_stream_endpoint_t;
typedef enum {
AVDTP_BASIC_SERVICE_MODE,
AVDTP_MULTIPLEXING_SERVICE_MODE
} avdtp_service_mode_t;
AVDTP_DEVICE_IDLE,
AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED,
AVDTP_DEVICE_CONNECTED,
AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED
} avdtp_device_state_t;
typedef struct {
bd_addr_t remote_addr;
uint16_t l2cap_signaling_cid;
btstack_linked_list_t stream_endpoints;
uint16_t stream_endpoints_id_counter;
avdtp_device_state_t state;
uint8_t disconnect;
uint8_t initiator_transaction_label;
uint8_t acceptor_transaction_label;
uint8_t query_seid;
avdtp_service_mode_t service_mode;
} avdtp_device_t;
#if defined __cplusplus
}

52
test/avdtp/avdtp_acceptor.c
View File

@ -150,16 +150,20 @@ static uint16_t avdtp_unpack_service_capabilities(avdtp_capabilities_t * caps, u
}
return registered_service_categories;
}
static int avdtp_acceptor_send_seps_response(uint16_t cid, uint8_t transaction_label, avdtp_sep_t * seps, int seps_num){
static int avdtp_acceptor_send_seps_response(uint16_t cid, uint8_t transaction_label, avdtp_stream_endpoint_t * stream_endpoints){
uint8_t command[2+2*MAX_NUM_SEPS];
int pos = 0;
command[pos++] = avdtp_header(transaction_label, AVDTP_SINGLE_PACKET, AVDTP_RESPONSE_ACCEPT_MSG);
command[pos++] = (uint8_t)AVDTP_SI_DISCOVER;
int i = 0;
for (i=0; i<seps_num; i++){
command[pos++] = (seps[i].seid << 2) | (seps[i].in_use<<1);
command[pos++] = (seps[i].media_type << 4) | (seps[i].type << 3);
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
command[pos++] = (stream_endpoint->sep.seid << 2) | (stream_endpoint->sep.in_use<<1);
command[pos++] = (stream_endpoint->sep.media_type << 4) | (stream_endpoint->sep.type << 3);
}
printf("avdtp_acceptor_send_seps_response\n");
return l2cap_send(cid, command, pos);
}
@ -223,19 +227,20 @@ int avdtp_acceptor_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream
return stream_endpoint->acceptor_config_state == AVDTP_ACCEPTOR_STREAM_CONFIG_DONE;
}
int avdtp_acceptor_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
int request_to_send = 1;
int avdtp_acceptor_stream_config_subsm(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
avdtp_signaling_packet_header_t signaling_header;
avdtp_read_signaling_header(&signaling_header, packet, size);
// 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);
printf("acceptor sm: state %d, si %d\n", stream_endpoint->acceptor_config_state, signaling_header.signal_identifier);
int i = 2;
avdtp_sep_t sep;
stream_endpoint->acceptor_transaction_label = signaling_header.transaction_label;
device->acceptor_transaction_label = signaling_header.transaction_label;
int request_to_send = 1;
switch (stream_endpoint->acceptor_config_state){
case AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE:
switch (signaling_header.signal_identifier){
@ -249,12 +254,12 @@ int avdtp_acceptor_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint
break;
case AVDTP_SI_GET_CAPABILITIES:
printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES\n");
stream_endpoint->query_seid = packet[2] >> 2;
device->query_seid = packet[2] >> 2;
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES;
break;
case AVDTP_SI_SET_CONFIGURATION:
printf(" ACP -> AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION\n");
stream_endpoint->query_seid = packet[2] >> 2;
device->query_seid = packet[2] >> 2;
sep.seid = packet[3] >> 2;
// find or add sep
for (i=0; i < stream_endpoint->remote_seps_num; i++){
@ -271,16 +276,15 @@ int avdtp_acceptor_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint
printf(" ACP -> NOT IMPLEMENTED, Reject signal_identifier %02x\n", signaling_header.signal_identifier);
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD;
stream_endpoint->unknown_signal_identifier = signaling_header.signal_identifier;
request_to_send = 1;
break;
}
l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
l2cap_request_can_send_now_event(device->l2cap_signaling_cid);
break;
case AVDTP_ACCEPTOR_STREAM_CONFIG_DONE:
request_to_send = 0;
printf(" ACP: AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION\n");
break;
default:
request_to_send = 0;
printf(" ACP -> subsm NOT IMPLEMENTED\n");
break;
}
@ -294,37 +298,41 @@ static int avdtp_acceptor_send_response_reject(uint16_t cid, avdtp_signal_ident
return l2cap_send(cid, command, sizeof(command));
}
int avdtp_acceptor_stream_config_subsm_run(avdtp_stream_endpoint_t * stream_endpoint, avdtp_sep_t * local_seps, uint8_t local_seps_num){
int avdtp_acceptor_stream_config_subsm_run(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint){
int sent = 1;
// printf("acceptor run: state %d\n", stream_endpoint->acceptor_config_state);
switch (stream_endpoint->acceptor_config_state){
case AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS:
printf(" AVDTP_ACCEPTOR_W2_ANSWER_DISCOVER_SEPS -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n");
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_seps_response(stream_endpoint->l2cap_signaling_cid, stream_endpoint->acceptor_transaction_label, local_seps, local_seps_num);
avdtp_acceptor_send_seps_response(device->l2cap_signaling_cid, device->acceptor_transaction_label, (avdtp_stream_endpoint_t *)&device->stream_endpoints);
break;
case AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES:
if (device->query_seid != stream_endpoint->sep.seid) return 0;
printf(" AVDTP_ACCEPTOR_W2_ANSWER_GET_CAPABILITIES -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n");
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_capabilities_response(stream_endpoint->l2cap_signaling_cid, stream_endpoint->acceptor_transaction_label, local_seps[stream_endpoint->query_seid]);
avdtp_acceptor_send_capabilities_response(device->l2cap_signaling_cid, device->acceptor_transaction_label, stream_endpoint->sep);
break;
case AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES:
if (device->query_seid != stream_endpoint->sep.seid) return 0;
printf(" AVDTP_ACCEPTOR_W2_ANSWER_GET_ALL_CAPABILITIES -> AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE\n");
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_all_capabilities_response(stream_endpoint->l2cap_signaling_cid, stream_endpoint->acceptor_transaction_label, local_seps[stream_endpoint->query_seid]);
avdtp_acceptor_send_all_capabilities_response(device->l2cap_signaling_cid, device->acceptor_transaction_label, stream_endpoint->sep);
break;
case AVDTP_ACCEPTOR_W2_REJECT_UNKNOWN_CMD:
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE;
avdtp_acceptor_send_response_reject(stream_endpoint->l2cap_signaling_cid, stream_endpoint->unknown_signal_identifier, stream_endpoint->acceptor_transaction_label);
avdtp_acceptor_send_response_reject(device->l2cap_signaling_cid, stream_endpoint->unknown_signal_identifier, device->acceptor_transaction_label);
break;
case AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION:
printf(" AVDTP_ACCEPTOR_W2_ANSWER_SET_CONFIGURATION -> AVDTP_ACCEPTOR_STREAM_CONFIG_DONE\n");
stream_endpoint->acceptor_config_state = AVDTP_ACCEPTOR_STREAM_CONFIG_DONE;
avdtp_acceptor_send_accept_response(stream_endpoint->l2cap_signaling_cid, AVDTP_SI_SET_CONFIGURATION, stream_endpoint->acceptor_transaction_label);
avdtp_acceptor_send_accept_response(device->l2cap_signaling_cid, AVDTP_SI_SET_CONFIGURATION, device->acceptor_transaction_label);
break;
case AVDTP_ACCEPTOR_STREAM_CONFIG_IDLE:
break;
default:
printf(" ACP -> run NOT IMPLEMENTED\n");
sent = 0;
break;
return 0;
}
return sent;
}

4
test/avdtp/avdtp_acceptor.h
View File

@ -53,8 +53,8 @@ extern "C" {
void avdtp_acceptor_stream_config_subsm_init(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_acceptor_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream_endpoint);
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(avdtp_stream_endpoint_t * stream_endpoint, avdtp_sep_t * local_seps, uint8_t local_seps_num);
int avdtp_acceptor_stream_config_subsm(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size);
int avdtp_acceptor_stream_config_subsm_run(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_acceptor_send_accept_response(uint16_t cid, avdtp_signal_identifier_t identifier, uint8_t transaction_label);
#if defined __cplusplus

20
test/avdtp/avdtp_initiator.c
View File

@ -78,9 +78,9 @@ int avdtp_initiator_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream
return stream_endpoint->initiator_config_state == AVDTP_INITIATOR_STREAM_CONFIG_DONE;
}
int avdtp_initiator_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
int avdtp_initiator_stream_config_subsm(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
return 0;
if (avdtp_initiator_stream_config_subsm_run(stream_endpoint)) return 1;
if (avdtp_initiator_stream_config_subsm_run(device, stream_endpoint)) return 1;
int i;
int responded = 1;
avdtp_sep_t sep;
@ -92,8 +92,8 @@ int avdtp_initiator_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoin
case AVDTP_INITIATOR_W4_SEPS_DISCOVERED:
printf(" AVDTP_INITIATOR_W4_SEPS_DISCOVERED -> AVDTP_INITIATOR_W2_GET_CAPABILITIES\n");
if (signaling_header.transaction_label != stream_endpoint->initiator_transaction_label){
printf("unexpected transaction label, got %d, expected %d\n", signaling_header.transaction_label, stream_endpoint->initiator_transaction_label);
if (signaling_header.transaction_label != device->initiator_transaction_label){
printf("unexpected transaction label, got %d, expected %d\n", signaling_header.transaction_label, device->initiator_transaction_label);
return 0;
}
if (signaling_header.signal_identifier != AVDTP_SI_DISCOVER) {
@ -122,8 +122,8 @@ int avdtp_initiator_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoin
// sep.seid, sep.in_use, sep.media_type, sep.type);
}
stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W2_GET_CAPABILITIES;
stream_endpoint->initiator_transaction_label++;
l2cap_request_can_send_now_event(stream_endpoint->l2cap_signaling_cid);
device->initiator_transaction_label++;
l2cap_request_can_send_now_event(device->l2cap_signaling_cid);
responded = 1;
break;
case AVDTP_INITIATOR_W4_CAPABILITIES:
@ -143,7 +143,7 @@ int avdtp_initiator_stream_config_subsm(avdtp_stream_endpoint_t * stream_endpoin
return responded;
}
int avdtp_initiator_stream_config_subsm_run(avdtp_stream_endpoint_t * stream_endpoint){
int avdtp_initiator_stream_config_subsm_run(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint){
return 0;
int sent = 1;
switch (stream_endpoint->initiator_config_state){
@ -151,17 +151,17 @@ int avdtp_initiator_stream_config_subsm_run(avdtp_stream_endpoint_t * stream_end
case AVDTP_INITIATOR_W2_DISCOVER_SEPS:
printf(" AVDTP_INITIATOR_STREAM_CONFIG_IDLE | AVDTP_INITIATOR_W2_DISCOVER_SEPS -> AVDTP_INITIATOR_W4_SEPS_DISCOVERED\n");
stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_SEPS_DISCOVERED;
avdtp_initiator_send_signaling_cmd(stream_endpoint->l2cap_signaling_cid, AVDTP_SI_DISCOVER, stream_endpoint->initiator_transaction_label);
avdtp_initiator_send_signaling_cmd(device->l2cap_signaling_cid, AVDTP_SI_DISCOVER, device->initiator_transaction_label);
break;
case AVDTP_INITIATOR_W2_GET_CAPABILITIES:
printf(" AVDTP_INITIATOR_W2_GET_CAPABILITIES -> AVDTP_INITIATOR_W4_CAPABILITIES\n");
stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_CAPABILITIES;
avdtp_initiator_send_get_capabilities_cmd(stream_endpoint->l2cap_signaling_cid, stream_endpoint->initiator_transaction_label, stream_endpoint->query_seid);
avdtp_initiator_send_get_capabilities_cmd(device->l2cap_signaling_cid, device->initiator_transaction_label, device->query_seid);
break;
case AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES:
printf(" AVDTP_INITIATOR_W2_GET_ALL_CAPABILITIES -> AVDTP_INITIATOR_W4_ALL_CAPABILITIES\n");
stream_endpoint->initiator_config_state = AVDTP_INITIATOR_W4_ALL_CAPABILITIES;
avdtp_initiator_send_get_all_capabilities_cmd(stream_endpoint->l2cap_signaling_cid, stream_endpoint->initiator_transaction_label, stream_endpoint->query_seid);
avdtp_initiator_send_get_all_capabilities_cmd(device->l2cap_signaling_cid, device->initiator_transaction_label, device->query_seid);
break;
default:
sent = 0;

4
test/avdtp/avdtp_initiator.h
View File

@ -53,8 +53,8 @@ extern "C" {
void avdtp_initiator_stream_config_subsm_init(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_initiator_stream_config_subsm_is_done(avdtp_stream_endpoint_t * stream_endpoint);
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(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_initiator_stream_config_subsm(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size);
int avdtp_initiator_stream_config_subsm_run(avdtp_device_t * device, avdtp_stream_endpoint_t * stream_endpoint);
#if defined __cplusplus
}

488
test/avdtp/avdtp_sink.c
View File

@ -52,34 +52,13 @@
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";
typedef enum {
AVDTP_DEVICE_IDLE,
AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED,
AVDTP_DEVICE_CONNECTED,
AVDTP_W4_L2CAP_FOR_SIGNALING_DISCONNECTED
} avdtp_device_state_t;
typedef struct {
bd_addr_t remote_addr;
uint16_t l2cap_signaling_cid;
btstack_linked_list_t avdtp_stream_endpoints;
avdtp_device_state_t state;
avdtp_sep_t seps[MAX_NUM_SEPS];
uint8_t seps_num;
uint8_t disconnect;
avdtp_service_mode_t service_mode;
} avdtp_device_t;
static avdtp_device_t avdtp_sink;
static void avdtp_state_init(avdtp_device_t * device){
device->avdtp_stream_endpoints = NULL;
device->seps_num = 0;
device->stream_endpoints = NULL;
device->service_mode = AVDTP_BASIC_SERVICE_MODE;
device->state = AVDTP_DEVICE_IDLE;
device->stream_endpoints_id_counter = 0;
device->disconnect = 0;
}
@ -168,112 +147,125 @@ 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);
}
uint8_t avdtp_sink_register_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type){
if (avdtp_sink.seps_num >= MAX_NUM_SEPS){
log_error("avdtp_sink_register_sep: excedeed max sep number %d", MAX_NUM_SEPS);
return 255;
static avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_seid(uint16_t seid){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->sep.seid == seid){
return stream_endpoint;
}
}
uint8_t seid = avdtp_sink.seps_num;
avdtp_sep_t entry = {
seid,
0,
media_type,
sep_type
};
return NULL;
}
avdtp_sink.seps[avdtp_sink.seps_num] = entry;
avdtp_sink.seps_num++;
return seid;
uint8_t avdtp_sink_register_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type){
avdtp_stream_endpoint_t * stream_endpoint = btstack_memory_avdtp_stream_endpoint_get();
avdtp_sink.stream_endpoints_id_counter++;
stream_endpoint->sep.seid = avdtp_sink.stream_endpoints_id_counter;
stream_endpoint->sep.in_use = 0;
stream_endpoint->sep.media_type = media_type;
stream_endpoint->sep.type = sep_type;
btstack_linked_list_add(&avdtp_sink.stream_endpoints, (btstack_linked_item_t *) stream_endpoint);
return stream_endpoint->sep.seid;
}
void avdtp_sink_register_media_transport_category(uint8_t seid){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_MEDIA_TRANSPORT, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
printf("registered services AVDTP_MEDIA_TRANSPORT(%d) %02x\n", AVDTP_MEDIA_TRANSPORT, avdtp_sink.seps[seid].registered_service_categories);
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_MEDIA_TRANSPORT, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
printf("registered services AVDTP_MEDIA_TRANSPORT(%d) %02x\n", AVDTP_MEDIA_TRANSPORT, stream_endpoint->sep.registered_service_categories);
}
void avdtp_sink_register_reporting_category(uint8_t seid){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_REPORTING, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_REPORTING, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
}
void avdtp_sink_register_delay_reporting_category(uint8_t seid){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_DELAY_REPORTING, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_DELAY_REPORTING, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
}
void avdtp_sink_register_recovery_category(uint8_t seid, uint8_t maximum_recovery_window_size, uint8_t maximum_number_media_packets){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_RECOVERY, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
avdtp_sink.seps[seid].capabilities.recovery.recovery_type = 0x01; // 0x01 = RFC2733
avdtp_sink.seps[seid].capabilities.recovery.maximum_recovery_window_size = maximum_recovery_window_size;
avdtp_sink.seps[seid].capabilities.recovery.maximum_number_media_packets = maximum_number_media_packets;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_RECOVERY, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
stream_endpoint->sep.capabilities.recovery.recovery_type = 0x01; // 0x01 = RFC2733
stream_endpoint->sep.capabilities.recovery.maximum_recovery_window_size = maximum_recovery_window_size;
stream_endpoint->sep.capabilities.recovery.maximum_number_media_packets = maximum_number_media_packets;
}
void avdtp_sink_register_content_protection_category(uint8_t seid, uint8_t cp_type_lsb, uint8_t cp_type_msb, const uint8_t * cp_type_value, uint8_t cp_type_value_len){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_CONTENT_PROTECTION, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
avdtp_sink.seps[seid].capabilities.content_protection.cp_type_lsb = cp_type_lsb;
avdtp_sink.seps[seid].capabilities.content_protection.cp_type_msb = cp_type_msb;
avdtp_sink.seps[seid].capabilities.content_protection.cp_type_value = cp_type_value;
avdtp_sink.seps[seid].capabilities.content_protection.cp_type_value_len = cp_type_value_len;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_CONTENT_PROTECTION, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
stream_endpoint->sep.capabilities.content_protection.cp_type_lsb = cp_type_lsb;
stream_endpoint->sep.capabilities.content_protection.cp_type_msb = cp_type_msb;
stream_endpoint->sep.capabilities.content_protection.cp_type_value = cp_type_value;
stream_endpoint->sep.capabilities.content_protection.cp_type_value_len = cp_type_value_len;
}
void avdtp_sink_register_header_compression_category(uint8_t seid, uint8_t back_ch, uint8_t media, uint8_t recovery){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_HEADER_COMPRESSION, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
avdtp_sink.seps[seid].capabilities.header_compression.back_ch = back_ch;
avdtp_sink.seps[seid].capabilities.header_compression.media = media;
avdtp_sink.seps[seid].capabilities.header_compression.recovery = recovery;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_HEADER_COMPRESSION, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
stream_endpoint->sep.capabilities.header_compression.back_ch = back_ch;
stream_endpoint->sep.capabilities.header_compression.media = media;
stream_endpoint->sep.capabilities.header_compression.recovery = recovery;
}
void avdtp_sink_register_media_codec_category(uint8_t seid, avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type, const uint8_t * media_codec_info, uint16_t media_codec_info_len){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_MEDIA_CODEC, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
printf("registered services AVDTP_MEDIA_CODEC(%d) %02x\n", AVDTP_MEDIA_CODEC, avdtp_sink.seps[seid].registered_service_categories);
avdtp_sink.seps[seid].capabilities.media_codec.media_type = media_type;
avdtp_sink.seps[seid].capabilities.media_codec.media_codec_type = media_codec_type;
avdtp_sink.seps[seid].capabilities.media_codec.media_codec_information = media_codec_info;
avdtp_sink.seps[seid].capabilities.media_codec.media_codec_information_len = media_codec_info_len;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_MEDIA_CODEC, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
printf("registered services AVDTP_MEDIA_CODEC(%d) %02x\n", AVDTP_MEDIA_CODEC, stream_endpoint->sep.registered_service_categories);
stream_endpoint->sep.capabilities.media_codec.media_type = media_type;
stream_endpoint->sep.capabilities.media_codec.media_codec_type = media_codec_type;
stream_endpoint->sep.capabilities.media_codec.media_codec_information = media_codec_info;
stream_endpoint->sep.capabilities.media_codec.media_codec_information_len = media_codec_info_len;
}
void avdtp_sink_register_multiplexing_category(uint8_t seid, uint8_t fragmentation){
if (seid >= avdtp_sink.seps_num){
log_error("invalid stream end point identifier");
avdtp_stream_endpoint_t * stream_endpoint = get_avdtp_stream_endpoint_for_seid(seid);
if (!stream_endpoint){
log_error("avdtp_sink_register_media_transport_category: stream endpoint with seid %d is not registered", seid);
return;
}
uint16_t bitmap = store_bit16(avdtp_sink.seps[seid].registered_service_categories, AVDTP_MULTIPLEXING, 1);
avdtp_sink.seps[seid].registered_service_categories = bitmap;
avdtp_sink.seps[seid].capabilities.multiplexing_mode.fragmentation = fragmentation;
uint16_t bitmap = store_bit16(stream_endpoint->sep.registered_service_categories, AVDTP_MULTIPLEXING, 1);
stream_endpoint->sep.registered_service_categories = bitmap;
stream_endpoint->sep.capabilities.multiplexing_mode.fragmentation = fragmentation;
}
// // media, reporting. recovery
@ -283,7 +275,7 @@ void avdtp_sink_register_multiplexing_category(uint8_t seid, uint8_t fragmentati
static avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_l2cap_cid(uint16_t l2cap_cid){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.avdtp_stream_endpoints);
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->l2cap_media_cid == l2cap_cid){
@ -297,11 +289,10 @@ static avdtp_stream_endpoint_t * get_avdtp_stream_endpoint_for_l2cap_cid(uint16_
}
static void avdtp_sink_remove_connection_context(avdtp_stream_endpoint_t * stream_endpoint){
btstack_linked_list_remove(&avdtp_sink.avdtp_stream_endpoints, (btstack_linked_item_t*) stream_endpoint);
btstack_linked_list_remove(&avdtp_sink.stream_endpoints, (btstack_linked_item_t*) stream_endpoint);
}
static void handle_l2cap_signaling_data_packet(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
static void handle_l2cap_signaling_data_packet(uint8_t *packet, uint16_t size){
if (size < 2) {
log_error("l2cap data packet too small");
return;
@ -313,53 +304,69 @@ static void handle_l2cap_signaling_data_packet(avdtp_stream_endpoint_t * stream_
// 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);
if (stream_endpoint->avdtp_state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){
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");
stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
int request_to_send = 0;
while (btstack_linked_list_iterator_has_next(&it) && !request_to_send){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){
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");
stream_endpoint->state = AVDTP_CONFIGURED;
}
}
}
switch (stream_endpoint->avdtp_state){
case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
if (signaling_header.message_type == AVDTP_CMD_MSG){
avdtp_acceptor_stream_config_subsm(stream_endpoint, packet, size);
request_to_send = 1;
switch (stream_endpoint->state){
case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
if (signaling_header.message_type == AVDTP_CMD_MSG){
request_to_send = avdtp_acceptor_stream_config_subsm(&avdtp_sink, stream_endpoint, packet, size);
break;
}
request_to_send = avdtp_initiator_stream_config_subsm(&avdtp_sink, stream_endpoint, packet, size);
break;
}
avdtp_initiator_stream_config_subsm(stream_endpoint, packet, size);
break;
case AVDTP_CONFIGURED:
switch (signaling_header.signal_identifier){
case AVDTP_SI_OPEN:
printf("AVDTP_CONFIGURED -> AVDTP_W2_ANSWER_OPEN_STREAM %d\n", signaling_header.transaction_label);
stream_endpoint->active_seid = packet[2] >> 2;
stream_endpoint->avdtp_state = AVDTP_W2_ANSWER_OPEN_STREAM;
stream_endpoint->acceptor_transaction_label = signaling_header.transaction_label;
l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
break;
default:
printf("AVDTP_CONFIGURED -> NOT IMPLEMENTED signal_identifier %d, state %d\n", signaling_header.signal_identifier, stream_endpoint->avdtp_state);
break;
}
break;
case AVDTP_OPEN:
switch (signaling_header.signal_identifier){
case AVDTP_SI_START:
printf("AVDTP_OPEN -> AVDTP_W2_ANSWER_START_SINGLE_STREAM\n");
stream_endpoint->active_seid = packet[2] >> 2;
stream_endpoint->avdtp_state = AVDTP_W2_ANSWER_START_SINGLE_STREAM;
stream_endpoint->acceptor_transaction_label = signaling_header.transaction_label;
l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
break;
default:
printf("AVDTP_OPEN -> NOT IMPLEMENTED signal_identifier %d\n", signaling_header.signal_identifier);
break;
}
break;
default:
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 );
break;
case AVDTP_CONFIGURED:
switch (signaling_header.signal_identifier){
case AVDTP_SI_OPEN:
printf("AVDTP_CONFIGURED -> AVDTP_W2_ANSWER_OPEN_STREAM %d\n", signaling_header.transaction_label);
if (stream_endpoint->sep.seid != packet[2] >> 2) return;
stream_endpoint->state = AVDTP_W2_ANSWER_OPEN_STREAM;
avdtp_sink.acceptor_transaction_label = signaling_header.transaction_label;
l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
break;
default:
request_to_send = 0;
printf("AVDTP_CONFIGURED -> NOT IMPLEMENTED signal_identifier %d, state %d\n", signaling_header.signal_identifier, stream_endpoint->state);
break;
}
break;
case AVDTP_OPEN:
switch (signaling_header.signal_identifier){
case AVDTP_SI_START:
printf("AVDTP_OPEN -> AVDTP_W2_ANSWER_START_SINGLE_STREAM\n");
if (stream_endpoint->sep.seid != packet[2] >> 2) return;
stream_endpoint->sep.in_use = 1;
stream_endpoint->state = AVDTP_W2_ANSWER_START_SINGLE_STREAM;
avdtp_sink.acceptor_transaction_label = signaling_header.transaction_label;
l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
break;
default:
request_to_send = 0;
printf("AVDTP_OPEN -> NOT IMPLEMENTED signal_identifier %d\n", signaling_header.signal_identifier);
break;
}
break;
default:
request_to_send = 0;
printf("handle_l2cap_signaling_data_packet: state %d -> NOT IMPLEMENTED signal_identifier %d\n", stream_endpoint->state, signaling_header.signal_identifier);
// printf_hexdump( packet, size );
break;
}
}
if (request_to_send){
printf("request_to_send cid %02x\n", avdtp_sink.l2cap_signaling_cid);
l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
}
}
@ -370,11 +377,11 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
uint16_t remote_cid;
uint16_t local_cid;
avdtp_stream_endpoint_t * stream_endpoint = NULL;
switch (packet_type) {
case L2CAP_DATA_PACKET:
if (channel == avdtp_sink.l2cap_signaling_cid){
handle_l2cap_signaling_data_packet(stream_endpoint, packet, size);
handle_l2cap_signaling_data_packet(packet, size);
break;
}
stream_endpoint = get_avdtp_stream_endpoint_for_l2cap_cid(channel);
@ -432,26 +439,37 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// 3. reporting
// 4. recovery
if (avdtp_sink.l2cap_signaling_cid == 0){
avdtp_sink.state = AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED;
l2cap_accept_connection(local_cid);
return;
}
// if (stream_endpoint->l2cap_media_cid == 0){
// // if (stream_endpoint->avdtp_state != AVDTP_W2_ANSWER_OPEN_STREAM) break;
// printf("incoming %d: AVDTP_W2_ANSWER_OPEN_STREAM\n", stream_endpoint->avdtp_state);
// stream_endpoint->l2cap_media_cid = local_cid;
// stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED;
// l2cap_accept_connection(local_cid);
// return;
// }
// if (stream_endpoint->l2cap_reporting_cid == 0){
// stream_endpoint->l2cap_reporting_cid = local_cid;
// printf("TODO enable reporting, set state\n");
// return;
// }
stream_endpoint = get_avdtp_stream_endpoint_for_l2cap_cid(local_cid);
if (!stream_endpoint){
log_error("avdtp sink: L2CAP_EVENT_CHANNEL_OPENED, no stream endpoint is associated with cid %02x", local_cid);
return;
}
if (stream_endpoint->l2cap_media_cid == 0){
// if (stream_endpoint->state != AVDTP_W2_ANSWER_OPEN_STREAM) break;
printf("incoming %d: AVDTP_W2_ANSWER_OPEN_STREAM\n", stream_endpoint->state);
stream_endpoint->state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED;
l2cap_accept_connection(local_cid);
return;
}
// if (stream_endpoint->l2cap_recovery_cid == 0){
// stream_endpoint->l2cap_recovery_cid = local_cid;
// printf("TODO enable recovery, set state\n");
// return;
// }
if (stream_endpoint->l2cap_reporting_cid == 0){
stream_endpoint->l2cap_reporting_cid = local_cid;
printf("TODO enable reporting, set state\n");
return;
}
if (stream_endpoint->l2cap_recovery_cid == 0){
stream_endpoint->l2cap_recovery_cid = local_cid;
printf("TODO enable recovery, set state\n");
return;
}
break;
case L2CAP_EVENT_CHANNEL_OPENED:
@ -472,9 +490,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
con_handle = l2cap_event_channel_opened_get_handle(packet);
local_cid = l2cap_event_channel_opened_get_local_cid(packet);
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),
stream_endpoint);
printf("L2CAP_EVENT_CHANNEL_OPENED: Channel successfully opened: %s, handle 0x%02x, psm 0x%02x, local cid 0x%02x, remote cid 0x%02x\n",
bd_addr_to_str(event_addr), con_handle, psm, local_cid, l2cap_event_channel_opened_get_remote_cid(packet));
if (psm != PSM_AVDTP) break;
@ -486,44 +503,46 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
// 4. recovery
if (avdtp_sink.state == AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED){
avdtp_sink.state = AVDTP_DEVICE_CONNECTED;
printf("AVDTP_DEVICE_CONNECTED, signaling %02x\n", local_cid);
avdtp_sink.l2cap_signaling_cid = local_cid;
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
stream_endpoint->state = AVDTP_CONFIGURATION_SUBSTATEMACHINE;
avdtp_initiator_stream_config_subsm_init(stream_endpoint);
avdtp_acceptor_stream_config_subsm_init(stream_endpoint);
}
avdtp_sink.initiator_transaction_label++;
l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
break;
}
// if (avdtp_sink.l2cap_signaling_cid == 0 || avdtp_sink.l2cap_signaling_cid == local_cid){
// if (stream_endpoint->avdtp_state != AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED) break;
// printf("AVDTP_W4_L2CAP_FOR_SIGNALING_CONNECTED -> AVDTP_CONFIGURATION_SUBSTATEMACHINE\n");
// stream_endpoint->avdtp_state = AVDTP_CONFIGURATION_SUBSTATEMACHINE;
// avdtp_initiator_stream_config_subsm_init(stream_endpoint);
// avdtp_acceptor_stream_config_subsm_init(stream_endpoint);
// avdtp_sink.l2cap_signaling_cid = local_cid;
// stream_endpoint->initiator_transaction_label++;
// l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
// break;
// }
stream_endpoint = get_avdtp_stream_endpoint_for_l2cap_cid(local_cid);
if (!stream_endpoint){
printf("L2CAP_EVENT_CHANNEL_OPENED, no stream endpoint is associated with cid %02x\n", local_cid);
return;
}
if (stream_endpoint->l2cap_media_cid == 0 || stream_endpoint->l2cap_media_cid == local_cid){
printf("L2CAP_EVENT_CHANNEL_OPENED Media, state %d \n", stream_endpoint->state);
if (stream_endpoint->state != AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED) break;
stream_endpoint->l2cap_media_cid = local_cid;
stream_endpoint->state = AVDTP_OPEN;
break;
}
// if (stream_endpoint->l2cap_media_cid == 0 || stream_endpoint->l2cap_media_cid == local_cid){
// printf("l2cap opened %d: L2CAP_EVENT_CHANNEL_OPENED: Media \n", stream_endpoint->avdtp_state);
// if (stream_endpoint->avdtp_state != AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED) break;
// stream_endpoint->l2cap_media_cid = local_cid;
// stream_endpoint->avdtp_state = AVDTP_OPEN;
// break;
// }
if (stream_endpoint->l2cap_reporting_cid == 0 || stream_endpoint->l2cap_reporting_cid == local_cid){
printf("L2CAP_EVENT_CHANNEL_OPENED reporting, state %d \n", stream_endpoint->state);
stream_endpoint->l2cap_reporting_cid = local_cid;
break;
}
// if (stream_endpoint->l2cap_reporting_cid == 0 || stream_endpoint->l2cap_reporting_cid == local_cid){
// printf("TODO enable reporting, set state\n");
// stream_endpoint->l2cap_reporting_cid = local_cid;
// break;
// }
// if (stream_endpoint->l2cap_recovery_cid == 0 || stream_endpoint->l2cap_recovery_cid == local_cid){
// printf("TODO enable recovery, set state\n");
// stream_endpoint->l2cap_recovery_cid = local_cid;
// break;
// }
if (stream_endpoint->l2cap_recovery_cid == 0 || stream_endpoint->l2cap_recovery_cid == local_cid){
printf("L2CAP_EVENT_CHANNEL_OPENED recovery, state %d \n", stream_endpoint->state);
stream_endpoint->l2cap_recovery_cid = local_cid;
break;
}
break;
case L2CAP_EVENT_CHANNEL_CLOSED:
@ -546,14 +565,14 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
if (stream_endpoint->l2cap_media_cid == local_cid){
log_info("L2CAP_EVENT_CHANNEL_CLOSED media cid 0x%0x", local_cid);
stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
stream_endpoint->state = AVDTP_CONFIGURED;
stream_endpoint->l2cap_media_cid = 0;
break;
}
if (avdtp_sink.l2cap_signaling_cid == local_cid){
log_info("L2CAP_EVENT_CHANNEL_CLOSED signaling cid 0x%0x", local_cid);
stream_endpoint->avdtp_state = AVDTP_IDLE;
stream_endpoint->state = AVDTP_IDLE;
avdtp_sink_remove_connection_context(stream_endpoint);
break;
}
@ -574,6 +593,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
break;
}
avdtp_sink_run();
}
// TODO: find out which security level is needed, and replace LEVEL_0 in avdtp_sink_init
@ -598,15 +618,52 @@ void avdtp_sink_register_packet_handler(btstack_packet_handler_t callback){
avdtp_sink_callback = callback;
}
static void avdtp_sink_run_for_stream_endpoint(avdtp_stream_endpoint_t * stream_endpoint){
if (stream_endpoint->state < AVDTP_OPEN){
if (stream_endpoint->state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){
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");
stream_endpoint->state = AVDTP_CONFIGURED;
}
}
// signaling
if (!l2cap_can_send_packet_now(avdtp_sink.l2cap_signaling_cid)) {
//printf("avdtp_sink_run: request cannot send for 0x%02x\n", avdtp_sink.l2cap_signaling_cid);
return;
}
switch (stream_endpoint->state){
case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
if (!avdtp_acceptor_stream_config_subsm_run(&avdtp_sink, stream_endpoint)) {
if (!avdtp_initiator_stream_config_subsm_run(&avdtp_sink, stream_endpoint)) break;
}
return;
case AVDTP_W2_ANSWER_OPEN_STREAM:
printf("AVDTP_W2_ANSWER_OPEN_STREAM -> AVDTP_OPEN\n");
stream_endpoint->state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED;
avdtp_acceptor_send_accept_response(avdtp_sink.l2cap_signaling_cid, AVDTP_SI_OPEN, avdtp_sink.acceptor_transaction_label);
break;
case AVDTP_W2_ANSWER_START_SINGLE_STREAM:
printf("AVDTP_W2_ANSWER_START_SINGLE_STREAM -> AVDTP_W4_STREAMING_CONNECTION_OPEN\n");
stream_endpoint->state = AVDTP_W4_STREAMING_CONNECTION_OPEN;
avdtp_acceptor_send_accept_response(avdtp_sink.l2cap_signaling_cid, AVDTP_SI_START, avdtp_sink.acceptor_transaction_label);
break;
default:
printf("avdtp_sink_run: state %d -> NOT IMPLEMENTED\n", stream_endpoint->state);
break;
}
}
}
static void avdtp_sink_run(void){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.avdtp_stream_endpoints);
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->disconnect){
switch (stream_endpoint->avdtp_state){
switch (stream_endpoint->state){
case AVDTP_IDLE:
case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
case AVDTP_CONFIGURED:
@ -615,13 +672,13 @@ static void avdtp_sink_run(void){
break;
case AVDTP_W2_ANSWER_OPEN_STREAM:
stream_endpoint->disconnect = 0;
stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
stream_endpoint->state = AVDTP_CONFIGURED;
break;
case AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED:
break;
default:
stream_endpoint->disconnect = 0;
stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED;
stream_endpoint->state = AVDTP_W4_L2CAP_FOR_MEDIA_DISCONNECTED;
l2cap_disconnect(stream_endpoint->l2cap_media_cid, 0);
return;
}
@ -635,42 +692,11 @@ static void avdtp_sink_run(void){
return;
}
if (!l2cap_can_send_packet_now(avdtp_sink.l2cap_signaling_cid)) {
log_info("avdtp_sink_run: request cannot send for 0x%02x", avdtp_sink.l2cap_signaling_cid);
return;
}
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.avdtp_stream_endpoints);
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
if (stream_endpoint->avdtp_state == AVDTP_CONFIGURATION_SUBSTATEMACHINE){
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");
stream_endpoint->avdtp_state = AVDTP_CONFIGURED;
}
}
switch (stream_endpoint->avdtp_state){
case AVDTP_CONFIGURATION_SUBSTATEMACHINE:
if (!avdtp_initiator_stream_config_subsm_run(stream_endpoint)) {
avdtp_acceptor_stream_config_subsm_run(stream_endpoint, avdtp_sink.seps, avdtp_sink.seps_num);
}
break;
case AVDTP_W2_ANSWER_OPEN_STREAM:
printf("AVDTP_W2_ANSWER_OPEN_STREAM -> AVDTP_OPEN\n");
stream_endpoint->avdtp_state = AVDTP_W4_L2CAP_FOR_MEDIA_CONNECTED;
avdtp_acceptor_send_accept_response(avdtp_sink.l2cap_signaling_cid, AVDTP_SI_OPEN, stream_endpoint->acceptor_transaction_label);
break;
case AVDTP_W2_ANSWER_START_SINGLE_STREAM:
printf("AVDTP_W2_ANSWER_START_SINGLE_STREAM -> AVDTP_W4_STREAMING_CONNECTION_OPEN\n");
stream_endpoint->avdtp_state = AVDTP_W4_STREAMING_CONNECTION_OPEN;
avdtp_acceptor_send_accept_response(avdtp_sink.l2cap_signaling_cid, AVDTP_SI_START, stream_endpoint->acceptor_transaction_label);
break;
default:
printf("avdtp_sink_run: state %d -> NOT IMPLEMENTED\n", stream_endpoint->avdtp_state);
break;
}
avdtp_sink_run_for_stream_endpoint(stream_endpoint);
// l2cap_request_can_send_now_event(avdtp_sink.l2cap_signaling_cid);
}
}
@ -688,10 +714,10 @@ void avdtp_sink_disconnect(uint16_t con_handle){
avdtp_sink.disconnect = 1;
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.avdtp_stream_endpoints);
btstack_linked_list_iterator_init(&it, (btstack_linked_list_t *) &avdtp_sink.stream_endpoints);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_stream_endpoint_t * stream_endpoint = (avdtp_stream_endpoint_t *)btstack_linked_list_iterator_next(&it);
stream_endpoint->disconnect = stream_endpoint->avdtp_state != AVDTP_IDLE;
stream_endpoint->disconnect = stream_endpoint->state != AVDTP_IDLE;
}
avdtp_sink_run();
}

32
test/avdtp/avdtp_sink.h
View File

@ -54,38 +54,6 @@
extern "C" {
#endif
typedef struct avdtp_stream_endpoint {
btstack_linked_item_t item;
uint16_t l2cap_media_cid;
uint16_t l2cap_reporting_cid;
uint16_t l2cap_recovery_cid;
uint8_t num_l2cap_channels_opened;
avdtp_stream_endpoint_state_t avdtp_state;
avdtp_initiator_stream_config_state_t initiator_config_state;
avdtp_acceptor_stream_config_state_t acceptor_config_state;
uint8_t initiator_transaction_label;
uint8_t acceptor_transaction_label;
avdtp_signal_identifier_t unknown_signal_identifier;
// store remote seps
avdtp_sep_t remote_seps[MAX_NUM_SEPS];
uint8_t remote_seps_num;
// currently active seid - stream opened
uint8_t active_seid;
uint8_t query_seid;
// currently active remote seid
uint8_t remote_sep_index;
// register request for L2cap connection release
uint8_t disconnect;
} avdtp_stream_endpoint_t;
/* API_START */
/**
* @brief AVDTP Sink service record.

165
test/avdtp/avdtp_test.c
View File

@ -142,9 +142,94 @@ static char * sbc_filename = "avdtp_sink.sbc";
static bd_addr_t remote = {0x04, 0x0C, 0xCE, 0xE4, 0x85, 0xD3};
static uint8_t sdp_avdtp_sink_service_buffer[150];
uint16_t local_cid = 0;
static btstack_packet_callback_registration_t hci_event_callback_registration;
static int media_initialized = 0;
static int init_media_processing(void){
if (media_initialized) return 0;
#ifdef STORE_SBC_TO_WAV_FILE
btstack_sbc_decoder_init(&state, mode, handle_pcm_data, NULL);
wav_writer_open(wav_filename, NUM_CHANNELS, SAMPLE_RATE);
#endif
#ifdef STORE_SBC_TO_SBC_FILE
sbc_file = fopen(sbc_filename, "wb");
#endif
#ifdef HAVE_PORTAUDIO
PaError err;
PaStreamParameters outputParameters;
/* -- initialize PortAudio -- */
err = Pa_Initialize();
if (err != paNoError){
printf("Error initializing portaudio: \"%s\"\n", Pa_GetErrorText(err));
return err;
}
/* -- setup input and output -- */
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
outputParameters.channelCount = NUM_CHANNELS;
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultHighOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
/* -- setup stream -- */
err = Pa_OpenStream(
&stream,
NULL, /* &inputParameters */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback, /* use callback */
NULL );
if (err != paNoError){
printf("Error initializing portaudio: \"%s\"\n", Pa_GetErrorText(err));
return err;
}
memset(ring_buffer_storage, 0, sizeof(ring_buffer_storage));
btstack_ring_buffer_init(&ring_buffer, ring_buffer_storage, sizeof(ring_buffer_storage));
pa_stream_started = 0;
#endif
media_initialized = 1;
return 0;
}
static void close_media_processing(void){
if (!media_initialized) return;
media_initialized = 0;
#ifdef STORE_SBC_TO_WAV_FILE
printf(" Close wav writer.\n");
wav_writer_close();
int total_frames_nr = state.good_frames_nr + state.bad_frames_nr + state.zero_frames_nr;
printf(" Decoding done. Processed totaly %d frames:\n - %d good\n - %d bad\n - %d zero frames\n", total_frames_nr, state.good_frames_nr, state.bad_frames_nr, state.zero_frames_nr);
printf(" Written %d frames to wav file: %s\n\n", frame_count, wav_filename);
#endif
#ifdef STORE_SBC_TO_SBC_FILE
fclose(sbc_file);
#endif
#ifdef HAVE_PORTAUDIO
PaError err = Pa_StopStream(stream);
if (err != paNoError){
printf("Error stopping the stream: \"%s\"\n", Pa_GetErrorText(err));
return;
}
pa_stream_started = 0;
err = Pa_CloseStream(stream);
if (err != paNoError){
printf("Error closing the stream: \"%s\"\n", Pa_GetErrorText(err));
return;
}
err = Pa_Terminate();
if (err != paNoError){
printf("Error terminating portaudio: \"%s\"\n", Pa_GetErrorText(err));
return;
}
#endif
}
static void handle_l2cap_media_data_packet(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size){
int pos = 0;
@ -187,6 +272,7 @@ static void handle_l2cap_media_data_packet(avdtp_stream_endpoint_t * stream_endp
// printf("SBC HEADER: num_frames %u, fragmented %u, start %u, stop %u\n", sbc_header.num_frames, sbc_header.fragmentation, sbc_header.starting_packet, sbc_header.last_packet);
// printf_hexdump( packet+pos, size-pos );
init_media_processing();
#ifdef STORE_SBC_TO_WAV_FILE
btstack_sbc_decoder_process_data(&state, 0, packet+pos, size-pos);
#endif
@ -225,37 +311,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case HCI_EVENT_DISCONNECTION_COMPLETE:
// connection closed -> quit tes app
printf("\n --- avdtp_test: HCI_EVENT_DISCONNECTION_COMPLETE ---\n");
#ifdef STORE_SBC_TO_WAV_FILE
printf(" Close wav writer.\n");
wav_writer_close();
int total_frames_nr = state.good_frames_nr + state.bad_frames_nr + state.zero_frames_nr;
printf(" Decoding done. Processed totaly %d frames:\n - %d good\n - %d bad\n - %d zero frames\n", total_frames_nr, state.good_frames_nr, state.bad_frames_nr, state.zero_frames_nr);
printf(" Written %d frames to wav file: %s\n\n", frame_count, wav_filename);
#endif
#ifdef STORE_SBC_TO_SBC_FILE
fclose(sbc_file);
#endif
#ifdef HAVE_PORTAUDIO
PaError err = Pa_StopStream(stream);
if (err != paNoError){
printf("Error stopping the stream: \"%s\"\n", Pa_GetErrorText(err));
return;
}
pa_stream_started = 0;
err = Pa_CloseStream(stream);
if (err != paNoError){
printf("Error closing the stream: \"%s\"\n", Pa_GetErrorText(err));
return;
}
err = Pa_Terminate();
if (err != paNoError){
printf("Error terminating portaudio: \"%s\"\n", Pa_GetErrorText(err));
return;
}
#endif
close_media_processing();
// exit(0);
break;
@ -338,51 +394,6 @@ int btstack_main(int argc, const char * argv[]){
gap_set_local_name("BTstack AVDTP Test");
gap_discoverable_control(1);
gap_set_class_of_device(0x200408);
#ifdef STORE_SBC_TO_WAV_FILE
btstack_sbc_decoder_init(&state, mode, handle_pcm_data, NULL);
wav_writer_open(wav_filename, NUM_CHANNELS, SAMPLE_RATE);
#endif
#ifdef STORE_SBC_TO_SBC_FILE
sbc_file = fopen(sbc_filename, "wb");
#endif
#ifdef HAVE_PORTAUDIO
PaError err;
PaStreamParameters outputParameters;
/* -- initialize PortAudio -- */
err = Pa_Initialize();
if (err != paNoError){
printf("Error initializing portaudio: \"%s\"\n", Pa_GetErrorText(err));
return err;
}
/* -- setup input and output -- */
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
outputParameters.channelCount = NUM_CHANNELS;
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultHighOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
/* -- setup stream -- */
err = Pa_OpenStream(
&stream,
NULL, /* &inputParameters */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback, /* use callback */
NULL );
if (err != paNoError){
printf("Error initializing portaudio: \"%s\"\n", Pa_GetErrorText(err));
return err;
}
memset(ring_buffer_storage, 0, sizeof(ring_buffer_storage));
btstack_ring_buffer_init(&ring_buffer, ring_buffer_storage, sizeof(ring_buffer_storage));
pa_stream_started = 0;
#endif
// turn on!
hci_power_control(HCI_POWER_ON);