mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-04-17 11:42:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

avdtp: use avdtp cid instead con handle

Browse Source
This commit is contained in:
Milanka Ringwald 2017-04-12 14:12:50 +02:00
parent 57f317a13d
commit f9bca1f39e
13 changed files with 286 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/btstack_defines.h
View File

@ -1233,7 +1233,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H11
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param signal_identifier
* @param status 0 == OK
*/
@ -1242,7 +1242,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H1
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param signal_identifier
*/
#define AVDTP_SUBEVENT_SIGNALING_REJECT 0x02
@ -1250,7 +1250,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H1
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param signal_identifier
*/
#define AVDTP_SUBEVENT_SIGNALING_GENERAL_REJECT 0x03
@ -1258,7 +1258,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1HB1
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param bd_addr
* @param status 0 == OK
*/
@ -1267,14 +1267,14 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H
* @param subevent_code
* @param con_handle
* @param avdtp_cid
*/
#define AVDTP_SUBEVENT_SIGNALING_CONNECTION_RELEASED 0x05
/**
* @format 1H1111
* @param subevent_code
* @param handle
* @param avdtp_cid
* @param seid 0x01 – 0x3E
* @param in_use 0-not in use, 1-in use
* @param media_type 0-audio, 1-video, 2-multimedia
@ -1285,7 +1285,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H11111111
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param media_type
* @param sampling_frequency_bitmap
* @param channel_mode_bitmap
@ -1300,7 +1300,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H12LV
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param media_type
* @param media_codec_type
* @param media_codec_information_len
@ -1311,7 +1311,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H1121111111
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param reconfigure
* @param media_type
* @param sampling_frequency
@ -1328,7 +1328,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H112LV
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param reconfigure
* @param media_type
* @param media_codec_type
@ -1340,7 +1340,7 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H1
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param status 0 == OK
*/
#define AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED 0x0B
@ -1348,14 +1348,14 @@ typedef uint8_t sm_key_t[16];
/**
* @format 1H
* @param subevent_code
* @param con_handle
* @param avdtp_cid
*/
#define AVDTP_SUBEVENT_STREAMING_CONNECTION_RELEASED 0x0C
/**
* @format 1H12
* @param subevent_code
* @param con_handle
* @param avdtp_cid
* @param seid
* @param sequence_number
*/

78
src/btstack_event.h
View File

@ -3872,12 +3872,12 @@ static inline hci_con_handle_t ancs_subevent_client_disconnected_get_handle(cons
#endif
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_ACCEPT
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_ACCEPT
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_accept_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_accept_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -3900,12 +3900,12 @@ static inline uint8_t avdtp_subevent_signaling_accept_get_status(const uint8_t *
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_REJECT
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_REJECT
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_reject_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_reject_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -3919,12 +3919,12 @@ static inline uint8_t avdtp_subevent_signaling_reject_get_signal_identifier(cons
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_GENERAL_REJECT
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_GENERAL_REJECT
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_general_reject_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_general_reject_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -3938,12 +3938,12 @@ static inline uint8_t avdtp_subevent_signaling_general_reject_get_signal_identif
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_connection_established_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_connection_established_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -3966,22 +3966,22 @@ static inline uint8_t avdtp_subevent_signaling_connection_established_get_status
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_CONNECTION_RELEASED
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_CONNECTION_RELEASED
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_connection_released_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_connection_released_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
* @brief Get field handle from event AVDTP_SUBEVENT_SIGNALING_SEP_FOUND
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_SEP_FOUND
* @param event packet
* @return handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_sep_found_get_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_sep_found_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -4022,12 +4022,12 @@ static inline uint8_t avdtp_subevent_signaling_sep_found_get_sep_type(const uint
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CAPABILITY
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CAPABILITY
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_sbc_capability_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_sbc_capability_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -4104,12 +4104,12 @@ static inline uint8_t avdtp_subevent_signaling_media_codec_sbc_capability_get_ma
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CAPABILITY
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CAPABILITY
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_other_capability_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_other_capability_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -4150,12 +4150,12 @@ static inline const uint8_t * avdtp_subevent_signaling_media_codec_other_capabil
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_sbc_configuration_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_sbc_configuration_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -4250,12 +4250,12 @@ static inline uint8_t avdtp_subevent_signaling_media_codec_sbc_configuration_get
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CONFIGURATION
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CONFIGURATION
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_other_configuration_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_signaling_media_codec_other_configuration_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -4305,12 +4305,12 @@ static inline const uint8_t * avdtp_subevent_signaling_media_codec_other_configu
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_streaming_connection_established_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_streaming_connection_established_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
@ -4324,22 +4324,22 @@ static inline uint8_t avdtp_subevent_streaming_connection_established_get_status
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_STREAMING_CONNECTION_RELEASED
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_STREAMING_CONNECTION_RELEASED
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_streaming_connection_released_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_streaming_connection_released_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**
* @brief Get field con_handle from event AVDTP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW
* @brief Get field avdtp_cid from event AVDTP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW
* @param event packet
* @return con_handle
* @return avdtp_cid
* @note: btstack_type H
*/
static inline hci_con_handle_t avdtp_subevent_streaming_can_send_media_packet_now_get_con_handle(const uint8_t * event){
static inline hci_con_handle_t avdtp_subevent_streaming_can_send_media_packet_now_get_avdtp_cid(const uint8_t * event){
return little_endian_read_16(event, 3);
}
/**

84
src/classic/avdtp.c
View File

@ -378,7 +378,7 @@ void avdtp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet
connection->query_seid = 0;
connection->state = AVDTP_SIGNALING_CONNECTION_OPENED;
printf(" -> AVDTP_SIGNALING_CONNECTION_OPENED, connection %p\n", connection);
avdtp_signaling_emit_connection_established(context->avdtp_callback, con_handle, event_addr, 0);
avdtp_signaling_emit_connection_established(context->avdtp_callback, connection->l2cap_signaling_cid, event_addr, 0);
break;
}
@ -442,8 +442,8 @@ void avdtp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet
}
}
void avdtp_disconnect(uint16_t con_handle, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_disconnect(uint16_t avdtp_cid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection) return;
if (connection->state == AVDTP_SIGNALING_CONNECTION_IDLE) return;
if (connection->state == AVDTP_SIGNALING_CONNECTION_W4_L2CAP_DISCONNECTED) return;
@ -452,10 +452,10 @@ void avdtp_disconnect(uint16_t con_handle, avdtp_context_t * context){
avdtp_request_can_send_now_self(connection, connection->l2cap_signaling_cid);
}
void avdtp_open_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_open_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_media_connect: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_media_connect: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (avdtp_find_remote_sep(connection, acp_seid) == 0xFF){
@ -485,10 +485,10 @@ void avdtp_open_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid,
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
void avdtp_start_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_start_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_start_stream: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_start_stream: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (avdtp_find_remote_sep(connection, acp_seid) == 0xFF){
@ -515,10 +515,10 @@ void avdtp_start_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid,
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
void avdtp_stop_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_stop_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_stop_stream: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_stop_stream: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (avdtp_find_remote_sep(connection, acp_seid) == 0xFF){
@ -552,10 +552,10 @@ void avdtp_stop_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid,
}
}
void avdtp_abort_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_abort_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_abort_stream: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_abort_stream: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (avdtp_find_remote_sep(connection, acp_seid) == 0xFF){
@ -591,10 +591,10 @@ void avdtp_abort_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid,
}
}
void avdtp_discover_stream_endpoints(uint16_t con_handle, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_discover_stream_endpoints(uint16_t avdtp_cid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_discover_stream_endpoints: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_discover_stream_endpoints: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
@ -612,10 +612,10 @@ void avdtp_discover_stream_endpoints(uint16_t con_handle, avdtp_context_t * cont
}
void avdtp_get_capabilities(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_get_capabilities(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_get_capabilities: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_get_capabilities: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
@ -627,10 +627,10 @@ void avdtp_get_capabilities(uint16_t con_handle, uint8_t acp_seid, avdtp_context
}
void avdtp_get_all_capabilities(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_get_all_capabilities(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_get_all_capabilities: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_get_all_capabilities: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
@ -641,10 +641,10 @@ void avdtp_get_all_capabilities(uint16_t con_handle, uint8_t acp_seid, avdtp_con
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
void avdtp_get_configuration(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_get_configuration(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_get_configuration: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_get_configuration: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
@ -655,10 +655,10 @@ void avdtp_get_configuration(uint16_t con_handle, uint8_t acp_seid, avdtp_contex
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
void avdtp_set_configuration(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_set_configuration(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
log_error("avdtp_set_configuration: no connection for handle 0x%02x found\n", con_handle);
log_error("avdtp_set_configuration: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
@ -680,10 +680,10 @@ void avdtp_set_configuration(uint16_t con_handle, uint8_t int_seid, uint8_t acp_
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
void avdtp_reconfigure(uint16_t con_handle, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_reconfigure(uint16_t avdtp_cid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_reconfigure: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_reconfigure: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
//TODO: if opened only app capabilities, enable reconfigure for not opened
@ -702,10 +702,10 @@ void avdtp_reconfigure(uint16_t con_handle, uint8_t acp_seid, uint16_t configure
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
void avdtp_suspend(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
void avdtp_suspend(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_suspend: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_suspend: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return;
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_OPENED) return;
@ -720,19 +720,19 @@ void avdtp_suspend(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * cont
avdtp_request_can_send_now_initiator(connection, connection->l2cap_signaling_cid);
}
uint8_t avdtp_remote_seps_num(uint16_t con_handle, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
uint8_t avdtp_remote_seps_num(uint16_t avdtp_cid, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_suspend: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_suspend: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return 0;
}
return connection->remote_seps_num;
}
avdtp_sep_t * avdtp_remote_sep(uint16_t con_handle, uint8_t index, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_con_handle(con_handle, context);
avdtp_sep_t * avdtp_remote_sep(uint16_t avdtp_cid, uint8_t index, avdtp_context_t * context){
avdtp_connection_t * connection = avdtp_connection_for_l2cap_signaling_cid(avdtp_cid, context);
if (!connection){
printf("avdtp_suspend: no connection for handle 0x%02x found\n", con_handle);
printf("avdtp_suspend: no connection for signaling cid 0x%02x found\n", avdtp_cid);
return NULL;
}
return &connection->remote_seps[index];

29
src/classic/avdtp.h
View File

@ -390,6 +390,7 @@ typedef struct {
bd_addr_t remote_addr;
hci_con_handle_t con_handle;
uint16_t l2cap_signaling_cid;
avdtp_service_mode_t service_mode;
@ -476,21 +477,21 @@ void avdtp_packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet
avdtp_connection_t * avdtp_create_connection(bd_addr_t remote_addr, avdtp_context_t * context);
avdtp_stream_endpoint_t * avdtp_create_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type, avdtp_context_t * context);
void avdtp_disconnect(uint16_t con_handle, avdtp_context_t * context);
void avdtp_open_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_start_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_stop_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_abort_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_disconnect(uint16_t avdtp_cid, avdtp_context_t * context);
void avdtp_open_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_start_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_stop_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_abort_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_discover_stream_endpoints(uint16_t con_handle, avdtp_context_t * context);
void avdtp_get_capabilities(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_get_all_capabilities(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_get_configuration(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_set_configuration(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context);
void avdtp_reconfigure(uint16_t con_handle, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context);
void avdtp_suspend(uint16_t con_handle, uint8_t acp_seid, avdtp_context_t * context);
uint8_t avdtp_remote_seps_num(uint16_t con_handle, avdtp_context_t * context);
avdtp_sep_t * avdtp_remote_sep(uint16_t con_handle, uint8_t index, avdtp_context_t * context);
void avdtp_discover_stream_endpoints(uint16_t avdtp_cid, avdtp_context_t * context);
void avdtp_get_capabilities(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_get_all_capabilities(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_get_configuration(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context);
void avdtp_set_configuration(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context);
void avdtp_reconfigure(uint16_t avdtp_cid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration, avdtp_context_t * context);
void avdtp_suspend(uint16_t avdtp_cid, uint8_t acp_seid, avdtp_context_t * context);
uint8_t avdtp_remote_seps_num(uint16_t avdtp_cid, avdtp_context_t * context);
avdtp_sep_t * avdtp_remote_sep(uint16_t avdtp_cid, uint8_t index, avdtp_context_t * context);
#if defined __cplusplus
}

16
src/classic/avdtp_initiator.c
View File

@ -120,7 +120,7 @@ void avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_
if (avdtp_find_remote_sep(connection, sep.seid) == 0xFF){
connection->remote_seps[connection->remote_seps_num++] = sep;
}
avdtp_signaling_emit_sep(context->avdtp_callback, connection->con_handle, sep);
avdtp_signaling_emit_sep(context->avdtp_callback, connection->l2cap_signaling_cid, sep);
}
break;
}
@ -132,10 +132,10 @@ void avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_
if (get_bit16(sep.registered_service_categories, AVDTP_MEDIA_CODEC)){
switch (sep.capabilities.media_codec.media_codec_type){
case AVDTP_CODEC_SBC:
avdtp_signaling_emit_media_codec_sbc_capability(context->avdtp_callback, connection->con_handle, sep.capabilities.media_codec);
avdtp_signaling_emit_media_codec_sbc_capability(context->avdtp_callback, connection->l2cap_signaling_cid, sep.capabilities.media_codec);
break;
default:
avdtp_signaling_emit_media_codec_other_capability(context->avdtp_callback, connection->con_handle, sep.capabilities.media_codec);
avdtp_signaling_emit_media_codec_other_capability(context->avdtp_callback, connection->l2cap_signaling_cid, sep.capabilities.media_codec);
break;
}
}
@ -147,10 +147,10 @@ void avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_
if (get_bit16(sep.configured_service_categories, AVDTP_MEDIA_CODEC)){
switch (sep.configuration.media_codec.media_codec_type){
case AVDTP_CODEC_SBC:
avdtp_signaling_emit_media_codec_sbc_configuration(context->avdtp_callback, connection->con_handle, sep.configuration.media_codec);
avdtp_signaling_emit_media_codec_sbc_configuration(context->avdtp_callback, connection->l2cap_signaling_cid, sep.configuration.media_codec);
break;
default:
avdtp_signaling_emit_media_codec_other_configuration(context->avdtp_callback, connection->con_handle, sep.configuration.media_codec);
avdtp_signaling_emit_media_codec_other_configuration(context->avdtp_callback, connection->l2cap_signaling_cid, sep.configuration.media_codec);
break;
}
}
@ -233,11 +233,11 @@ void avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_
break;
case AVDTP_RESPONSE_REJECT_MSG:
printf(" AVDTP_RESPONSE_REJECT_MSG signal %d\n", connection->signaling_packet.signal_identifier);
avdtp_signaling_emit_reject(context->avdtp_callback, connection->con_handle, connection->signaling_packet.signal_identifier);
avdtp_signaling_emit_reject(context->avdtp_callback, connection->l2cap_signaling_cid, connection->signaling_packet.signal_identifier);
return;
case AVDTP_GENERAL_REJECT_MSG:
printf(" AVDTP_GENERAL_REJECT_MSG signal %d\n", connection->signaling_packet.signal_identifier);
avdtp_signaling_emit_general_reject(context->avdtp_callback, connection->con_handle, connection->signaling_packet.signal_identifier);
avdtp_signaling_emit_general_reject(context->avdtp_callback, connection->l2cap_signaling_cid, connection->signaling_packet.signal_identifier);
return;
default:
break;
@ -246,7 +246,7 @@ void avdtp_initiator_stream_config_subsm(avdtp_connection_t * connection, uint8_
connection->initiator_transaction_label++;
connection->int_seid = 0;
connection->acp_seid = 0;
avdtp_signaling_emit_accept(context->avdtp_callback, connection->con_handle, connection->signaling_packet.signal_identifier, status);
avdtp_signaling_emit_accept(context->avdtp_callback, connection->l2cap_signaling_cid, connection->signaling_packet.signal_identifier, status);
}
void avdtp_initiator_stream_config_subsm_run(avdtp_connection_t * connection, avdtp_context_t * context){

48
src/classic/avdtp_sink.c
View File

@ -233,50 +233,50 @@ void avdtp_sink_connect(bd_addr_t bd_addr){
l2cap_create_channel(packet_handler, connection->remote_addr, BLUETOOTH_PROTOCOL_AVDTP, 0xffff, NULL);
}
void avdtp_sink_disconnect(uint16_t con_handle){
avdtp_disconnect(con_handle, &avdtp_sink_context);
void avdtp_sink_disconnect(uint16_t avdtp_cid){
avdtp_disconnect(avdtp_cid, &avdtp_sink_context);
}
void avdtp_sink_open_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid){
avdtp_open_stream(con_handle, int_seid, acp_seid, &avdtp_sink_context);
void avdtp_sink_open_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid){
avdtp_open_stream(avdtp_cid, int_seid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_start_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid){
avdtp_start_stream(con_handle, int_seid, acp_seid, &avdtp_sink_context);
void avdtp_sink_start_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid){
avdtp_start_stream(avdtp_cid, int_seid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_stop_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid){
avdtp_stop_stream(con_handle, int_seid, acp_seid, &avdtp_sink_context);
void avdtp_sink_stop_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid){
avdtp_stop_stream(avdtp_cid, int_seid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_abort_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid){
avdtp_abort_stream(con_handle, int_seid, acp_seid, &avdtp_sink_context);
void avdtp_sink_abort_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid){
avdtp_abort_stream(avdtp_cid, int_seid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_discover_stream_endpoints(uint16_t con_handle){
avdtp_discover_stream_endpoints(con_handle, &avdtp_sink_context);
void avdtp_sink_discover_stream_endpoints(uint16_t avdtp_cid){
avdtp_discover_stream_endpoints(avdtp_cid, &avdtp_sink_context);
}
void avdtp_sink_get_capabilities(uint16_t con_handle, uint8_t acp_seid){
avdtp_get_capabilities(con_handle, acp_seid, &avdtp_sink_context);
void avdtp_sink_get_capabilities(uint16_t avdtp_cid, uint8_t acp_seid){
avdtp_get_capabilities(avdtp_cid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_get_all_capabilities(uint16_t con_handle, uint8_t acp_seid){
avdtp_get_all_capabilities(con_handle, acp_seid, &avdtp_sink_context);
void avdtp_sink_get_all_capabilities(uint16_t avdtp_cid, uint8_t acp_seid){
avdtp_get_all_capabilities(avdtp_cid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_get_configuration(uint16_t con_handle, uint8_t acp_seid){
avdtp_get_configuration(con_handle, acp_seid, &avdtp_sink_context);
void avdtp_sink_get_configuration(uint16_t avdtp_cid, uint8_t acp_seid){
avdtp_get_configuration(avdtp_cid, acp_seid, &avdtp_sink_context);
}
void avdtp_sink_set_configuration(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration){
avdtp_set_configuration(con_handle, int_seid, acp_seid, configured_services_bitmap, configuration, &avdtp_sink_context);
void avdtp_sink_set_configuration(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration){
avdtp_set_configuration(avdtp_cid, int_seid, acp_seid, configured_services_bitmap, configuration, &avdtp_sink_context);
}
void avdtp_sink_reconfigure(uint16_t con_handle, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration){
avdtp_reconfigure(con_handle, acp_seid, configured_services_bitmap, configuration, &avdtp_sink_context);
void avdtp_sink_reconfigure(uint16_t avdtp_cid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration){
avdtp_reconfigure(avdtp_cid, acp_seid, configured_services_bitmap, configuration, &avdtp_sink_context);
}
void avdtp_sink_suspend(uint16_t con_handle, uint8_t acp_seid){
avdtp_suspend(con_handle, acp_seid, &avdtp_sink_context);
void avdtp_sink_suspend(uint16_t avdtp_cid, uint8_t acp_seid){
avdtp_suspend(avdtp_cid, acp_seid, &avdtp_sink_context);
}

50
src/classic/avdtp_sink.h
View File

@ -63,7 +63,7 @@ extern "C" {
* @param service_name
* @param 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);
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);
/**
* @brief Set up AVDTP Sink device.
@ -98,82 +98,82 @@ void avdtp_sink_connect(bd_addr_t bd_addr);
void avdtp_sink_register_media_handler(void (*callback)(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size));
/**
* @brief Disconnect from device with connection handle.
* @param con_handle
* @param avdtp_cid
*/
void avdtp_sink_disconnect(uint16_t con_handle);
void avdtp_sink_disconnect(uint16_t avdtp_cid);
/**
* @brief Discover stream endpoints
* @param con_handle
* @param avdtp_cid
*/
void avdtp_sink_discover_stream_endpoints(uint16_t con_handle);
void avdtp_sink_discover_stream_endpoints(uint16_t avdtp_cid);
/**
* @brief Get capabilities
* @param con_handle
* @param avdtp_cid
*/
void avdtp_sink_get_capabilities(uint16_t con_handle, uint8_t acp_seid);
void avdtp_sink_get_capabilities(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Get all capabilities
* @param con_handle
* @param avdtp_cid
*/
void avdtp_sink_get_all_capabilities(uint16_t con_handle, uint8_t acp_seid);
void avdtp_sink_get_all_capabilities(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Set configuration
* @param con_handle
* @param avdtp_cid
*/
void avdtp_sink_set_configuration(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
void avdtp_sink_set_configuration(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
/**
* @brief Reconfigure stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_sink_reconfigure(uint16_t con_handle, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
void avdtp_sink_reconfigure(uint16_t avdtp_cid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
/**
* @brief Get configuration
* @param con_handle
* @param avdtp_cid
*/
void avdtp_sink_get_configuration(uint16_t con_handle, uint8_t acp_seid);
void avdtp_sink_get_configuration(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Suspend stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_sink_suspend(uint16_t con_handle, uint8_t acp_seid);
void avdtp_sink_suspend(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Open stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_sink_open_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_sink_open_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/**
* @brief Start stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_sink_start_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_sink_start_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/**
* @brief Start stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_sink_abort_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_sink_abort_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/**
* @brief Start stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_sink_stop_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_sink_stop_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/* API_END */

18
src/classic/avdtp_source.c
View File

@ -263,19 +263,17 @@ void avdtp_source_init(void){
l2cap_register_service(&packet_handler, BLUETOOTH_PROTOCOL_AVDTP, 0xffff, LEVEL_0);
}
int avdtp_source_streaming_endpoint_ready(uint16_t con_handle){
avdtp_stream_endpoint_t * stream_endpoint = avdtp_stream_endpoint_for_l2cap_cid(con_handle, &avdtp_source_context);
int avdtp_source_stream_endpoint_ready(avdtp_stream_endpoint_t * stream_endpoint){
if (!stream_endpoint) {
printf("no stream_endpoint found for 0x%02x", con_handle);
printf("no stream_endpoint");
return 0;
}
return (stream_endpoint->state == AVDTP_STREAM_ENDPOINT_STREAMING || stream_endpoint->state == AVDTP_STREAM_ENDPOINT_STREAMING_W2_SEND);
}
void avdtp_source_request_can_send_now(uint16_t con_handle){
avdtp_stream_endpoint_t * stream_endpoint = avdtp_stream_endpoint_for_l2cap_cid(con_handle, &avdtp_source_context);
void avdtp_source_stream_endpoint_request_can_send_now(avdtp_stream_endpoint_t * stream_endpoint){
if (!stream_endpoint) {
printf("no stream_endpoint found for 0x%02x", con_handle);
printf("no stream_endpoint");
return;
}
stream_endpoint->state = AVDTP_STREAM_ENDPOINT_STREAMING_W2_SEND;
@ -365,10 +363,10 @@ void avdtp_source_stream_send_media_payload(uint16_t l2cap_media_cid, btstack_ri
l2cap_send_prepared(l2cap_media_cid, offset);
}
uint8_t avdtp_source_remote_seps_num(uint16_t con_handle){
return avdtp_remote_seps_num(con_handle, &avdtp_source_context);
uint8_t avdtp_source_remote_seps_num(uint16_t avdtp_cid){
return avdtp_remote_seps_num(avdtp_cid, &avdtp_source_context);
}
avdtp_sep_t * avdtp_source_remote_sep(uint16_t con_handle, uint8_t index){
return avdtp_remote_sep(con_handle, index, &avdtp_source_context);
avdtp_sep_t * avdtp_source_remote_sep(uint16_t avdtp_cid, uint8_t index){
return avdtp_remote_sep(avdtp_cid, index, &avdtp_source_context);
}

56
src/classic/avdtp_source.h
View File

@ -86,91 +86,91 @@ void avdtp_source_connect(bd_addr_t bd_addr);
void avdtp_source_register_media_handler(void (*callback)(avdtp_stream_endpoint_t * stream_endpoint, uint8_t *packet, uint16_t size));
/**
* @brief Disconnect from device with connection handle.
* @param con_handle
* @param avdtp_cid
*/
void avdtp_source_disconnect(uint16_t con_handle);
void avdtp_source_disconnect(uint16_t avdtp_cid);
/**
* @brief Discover stream endpoints
* @param con_handle
* @param avdtp_cid
*/
void avdtp_source_discover_stream_endpoints(uint16_t con_handle);
void avdtp_source_discover_stream_endpoints(uint16_t avdtp_cid);
/**
* @brief Get capabilities
* @param con_handle
* @param avdtp_cid
*/
void avdtp_source_get_capabilities(uint16_t con_handle, uint8_t acp_seid);
void avdtp_source_get_capabilities(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Get all capabilities
* @param con_handle
* @param avdtp_cid
*/
void avdtp_source_get_all_capabilities(uint16_t con_handle, uint8_t acp_seid);
void avdtp_source_get_all_capabilities(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Set configuration
* @param con_handle
* @param avdtp_cid
*/
void avdtp_source_set_configuration(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
void avdtp_source_set_configuration(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
/**
* @brief Reconfigure stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_source_reconfigure(uint16_t con_handle, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
void avdtp_source_reconfigure(uint16_t avdtp_cid, uint8_t acp_seid, uint16_t configured_services_bitmap, avdtp_capabilities_t configuration);
/**
* @brief Get configuration
* @param con_handle
* @param avdtp_cid
*/
void avdtp_source_get_configuration(uint16_t con_handle, uint8_t acp_seid);
void avdtp_source_get_configuration(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Suspend stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_source_suspend(uint16_t con_handle, uint8_t acp_seid);
void avdtp_source_suspend(uint16_t avdtp_cid, uint8_t acp_seid);
/**
* @brief Open stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_source_open_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_source_open_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/**
* @brief Start stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_source_start_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_source_start_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/**
* @brief Start stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_source_abort_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_source_abort_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
/**
* @brief Start stream
* @param con_handle
* @param avdtp_cid
* @param seid
*/
void avdtp_source_stop_stream(uint16_t con_handle, uint8_t int_seid, uint8_t acp_seid);
void avdtp_source_stop_stream(uint16_t avdtp_cid, uint8_t int_seid, uint8_t acp_seid);
avdtp_stream_endpoint_t * avdtp_source_create_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type);
int avdtp_source_streaming_endpoint_ready(uint16_t con_handle);
void avdtp_source_request_can_send_now(uint16_t con_handle);
void avdtp_source_stream_endpoint_request_can_send_now(avdtp_stream_endpoint_t * stream_endpoint);
int avdtp_source_stream_endpoint_ready(avdtp_stream_endpoint_t * stream_endpoint);
void avdtp_source_stream_send_media_payload(uint16_t l2cap_media_cid, btstack_ring_buffer_t * sbc_ring_buffer, uint8_t marker);
uint8_t avdtp_source_remote_seps_num(uint16_t con_handle);
avdtp_sep_t * avdtp_source_remote_sep(uint16_t con_handle, uint8_t index);
uint8_t avdtp_source_remote_seps_num(uint16_t avdtp_cid);
avdtp_sep_t * avdtp_source_remote_sep(uint16_t avdtp_cid, uint8_t index);
/* API_END */
#if defined __cplusplus

71
src/classic/avdtp_util.c
View File

@ -86,17 +86,6 @@ avdtp_connection_t * avdtp_connection_for_bd_addr(bd_addr_t addr, avdtp_context_
return NULL;
}
avdtp_connection_t * avdtp_connection_for_con_handle(hci_con_handle_t con_handle, avdtp_context_t * context){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, &context->connections);
while (btstack_linked_list_iterator_has_next(&it)){
avdtp_connection_t * connection = (avdtp_connection_t *)btstack_linked_list_iterator_next(&it);
if (connection->con_handle != con_handle) continue;
return connection;
}
return NULL;
}
avdtp_connection_t * avdtp_connection_for_l2cap_signaling_cid(uint16_t l2cap_cid, avdtp_context_t * context){
btstack_linked_list_iterator_t it;
btstack_linked_list_iterator_init(&it, &context->connections);
@ -509,14 +498,14 @@ int avdtp_signaling_create_fragment(uint16_t cid, avdtp_signaling_packet_t * sig
}
void avdtp_signaling_emit_connection_established(btstack_packet_handler_t callback, uint16_t con_handle, bd_addr_t addr, uint8_t status){
void avdtp_signaling_emit_connection_established(btstack_packet_handler_t callback, uint16_t avdtp_cid, bd_addr_t addr, uint8_t status){
if (!callback) return;
uint8_t event[12];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
reverse_bd_addr(addr,&event[pos]);
pos += 6;
@ -524,14 +513,14 @@ void avdtp_signaling_emit_connection_established(btstack_packet_handler_t callba
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_streaming_emit_can_send_media_packet_now(btstack_packet_handler_t callback, uint16_t con_handle, uint8_t seid, uint16_t sequence_number){
void avdtp_streaming_emit_can_send_media_packet_now(btstack_packet_handler_t callback, uint16_t avdtp_cid, uint8_t seid, uint16_t sequence_number){
if (!callback) return;
uint8_t event[8];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = seid;
little_endian_store_16(event, pos, sequence_number);
@ -539,27 +528,27 @@ void avdtp_streaming_emit_can_send_media_packet_now(btstack_packet_handler_t cal
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_streaming_emit_connection_established(btstack_packet_handler_t callback, uint16_t con_handle, uint8_t status){
void avdtp_streaming_emit_connection_established(btstack_packet_handler_t callback, uint16_t avdtp_cid, uint8_t status){
if (!callback) return;
uint8_t event[6];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = status;
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_sep(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_sep_t sep){
void avdtp_signaling_emit_sep(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_sep_t sep){
if (!callback) return;
uint8_t event[9];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_SEP_FOUND;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = sep.seid;
event[pos++] = sep.in_use;
@ -568,54 +557,54 @@ void avdtp_signaling_emit_sep(btstack_packet_handler_t callback, uint16_t con_ha
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_accept(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_signal_identifier_t identifier, uint8_t status){
void avdtp_signaling_emit_accept(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_signal_identifier_t identifier, uint8_t status){
if (!callback) return;
uint8_t event[7];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_ACCEPT;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = identifier;
event[pos++] = status;
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_reject(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_signal_identifier_t identifier){
void avdtp_signaling_emit_reject(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_signal_identifier_t identifier){
if (!callback) return;
uint8_t event[6];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_REJECT;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = identifier;
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_general_reject(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_signal_identifier_t identifier){
void avdtp_signaling_emit_general_reject(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_signal_identifier_t identifier){
if (!callback) return;
uint8_t event[6];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_GENERAL_REJECT;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = identifier;
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_media_codec_sbc_capability(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec){
void avdtp_signaling_emit_media_codec_sbc_capability(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec){
if (!callback) return;
uint8_t event[13];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CAPABILITY;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = media_codec.media_type;
event[pos++] = media_codec.media_codec_information[0] >> 4;
@ -628,14 +617,14 @@ void avdtp_signaling_emit_media_codec_sbc_capability(btstack_packet_handler_t ca
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_media_codec_other_capability(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec){
void avdtp_signaling_emit_media_codec_other_capability(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec){
if (!callback) return;
uint8_t event[109];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CAPABILITY;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = media_codec.media_type;
little_endian_store_16(event, pos, media_codec.media_codec_type);
@ -650,7 +639,7 @@ void avdtp_signaling_emit_media_codec_other_capability(btstack_packet_handler_t
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
static inline void avdtp_signaling_emit_media_codec_sbc(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec, uint8_t reconfigure){
static inline void avdtp_signaling_emit_media_codec_sbc(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec, uint8_t reconfigure){
if (!callback) return;
uint8_t event[14+2];
int pos = 0;
@ -658,7 +647,7 @@ static inline void avdtp_signaling_emit_media_codec_sbc(btstack_packet_handler_t
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_SBC_CONFIGURATION;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = reconfigure;
@ -728,23 +717,23 @@ static inline void avdtp_signaling_emit_media_codec_sbc(btstack_packet_handler_t
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_media_codec_sbc_configuration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec){
void avdtp_signaling_emit_media_codec_sbc_configuration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec){
if (!callback) return;
avdtp_signaling_emit_media_codec_sbc(callback, con_handle, media_codec, 0);
avdtp_signaling_emit_media_codec_sbc(callback, avdtp_cid, media_codec, 0);
}
void avdtp_signaling_emit_media_codec_sbc_reconfiguration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec){
void avdtp_signaling_emit_media_codec_sbc_reconfiguration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec){
if (!callback) return;
avdtp_signaling_emit_media_codec_sbc(callback, con_handle, media_codec, 1);
avdtp_signaling_emit_media_codec_sbc(callback, avdtp_cid, media_codec, 1);
}
static inline void avdtp_signaling_emit_media_codec_other(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec, uint8_t reconfigure){
static inline void avdtp_signaling_emit_media_codec_other(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec, uint8_t reconfigure){
uint8_t event[110];
int pos = 0;
event[pos++] = HCI_EVENT_AVDTP_META;
event[pos++] = sizeof(event) - 2;
event[pos++] = AVDTP_SUBEVENT_SIGNALING_MEDIA_CODEC_OTHER_CONFIGURATION;
little_endian_store_16(event, pos, con_handle);
little_endian_store_16(event, pos, avdtp_cid);
pos += 2;
event[pos++] = reconfigure;
@ -763,14 +752,14 @@ static inline void avdtp_signaling_emit_media_codec_other(btstack_packet_handler
(*callback)(HCI_EVENT_PACKET, 0, event, sizeof(event));
}
void avdtp_signaling_emit_media_codec_other_configuration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec){
void avdtp_signaling_emit_media_codec_other_configuration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec){
if (!callback) return;
avdtp_signaling_emit_media_codec_other(callback, con_handle, media_codec, 0);
avdtp_signaling_emit_media_codec_other(callback, avdtp_cid, media_codec, 0);
}
void avdtp_signaling_emit_media_codec_other_reconfiguration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec){
void avdtp_signaling_emit_media_codec_other_reconfiguration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec){
if (!callback) return;
avdtp_signaling_emit_media_codec_other(callback, con_handle, media_codec, 1);
avdtp_signaling_emit_media_codec_other(callback, avdtp_cid, media_codec, 1);
}

27
src/classic/avdtp_util.h
View File

@ -53,7 +53,6 @@ extern "C" {
#endif
avdtp_connection_t * avdtp_connection_for_bd_addr(bd_addr_t addr, avdtp_context_t * context);
avdtp_connection_t * avdtp_connection_for_con_handle(hci_con_handle_t con_handle, avdtp_context_t * context);
avdtp_connection_t * avdtp_connection_for_l2cap_signaling_cid(uint16_t l2cap_cid, avdtp_context_t * context);
avdtp_stream_endpoint_t * avdtp_stream_endpoint_for_l2cap_cid(uint16_t l2cap_cid, avdtp_context_t * context);
avdtp_stream_endpoint_t * avdtp_stream_endpoint_with_seid(uint8_t seid, avdtp_context_t * context);
@ -72,20 +71,20 @@ uint16_t avdtp_unpack_service_capabilities(avdtp_connection_t * connection, avdt
void avdtp_prepare_capabilities(avdtp_signaling_packet_t * signaling_packet, uint8_t transaction_label, uint16_t registered_service_categories, avdtp_capabilities_t configuration, uint8_t identifier);
int avdtp_signaling_create_fragment(uint16_t cid, avdtp_signaling_packet_t * signaling_packet, uint8_t * out_buffer);
void avdtp_signaling_emit_connection_established(btstack_packet_handler_t callback, uint16_t con_handle, bd_addr_t addr, uint8_t status);
void avdtp_streaming_emit_connection_established(btstack_packet_handler_t callback, uint16_t con_handle, uint8_t status);
void avdtp_signaling_emit_sep(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_sep_t sep);
void avdtp_signaling_emit_accept(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_signal_identifier_t identifier, uint8_t status);
void avdtp_signaling_emit_general_reject(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_signal_identifier_t identifier);
void avdtp_signaling_emit_reject(btstack_packet_handler_t callback, uint16_t con_handle, avdtp_signal_identifier_t identifier);
void avdtp_streaming_emit_can_send_media_packet_now(btstack_packet_handler_t callback, uint16_t con_handle, uint8_t seid, uint16_t sequence_number);
void avdtp_signaling_emit_connection_established(btstack_packet_handler_t callback, uint16_t avdtp_cid, bd_addr_t addr, uint8_t status);
void avdtp_streaming_emit_connection_established(btstack_packet_handler_t callback, uint16_t avdtp_cid, uint8_t status);
void avdtp_signaling_emit_sep(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_sep_t sep);
void avdtp_signaling_emit_accept(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_signal_identifier_t identifier, uint8_t status);
void avdtp_signaling_emit_general_reject(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_signal_identifier_t identifier);
void avdtp_signaling_emit_reject(btstack_packet_handler_t callback, uint16_t avdtp_cid, avdtp_signal_identifier_t identifier);
void avdtp_streaming_emit_can_send_media_packet_now(btstack_packet_handler_t callback, uint16_t avdtp_cid, uint8_t seid, uint16_t sequence_number);
void avdtp_signaling_emit_media_codec_sbc_capability(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_other_capability(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_sbc_configuration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_other_configuration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_sbc_reconfiguration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_other_reconfiguration(btstack_packet_handler_t callback, uint16_t con_handle, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_sbc_capability(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_other_capability(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_sbc_configuration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_other_configuration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_sbc_reconfiguration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec);
void avdtp_signaling_emit_media_codec_other_reconfiguration(btstack_packet_handler_t callback, uint16_t avdtp_cid, adtvp_media_codec_capabilities_t media_codec);
void avdtp_request_can_send_now_acceptor(avdtp_connection_t * connection, uint16_t l2cap_cid);
void avdtp_request_can_send_now_initiator(avdtp_connection_t * connection, uint16_t l2cap_cid);

30
test/avdtp/avdtp_sink_test.c
View File

@ -139,7 +139,7 @@ static bd_addr_t remote = {0x00, 0x1B, 0xDC, 0x08, 0x0A, 0xA5};
// bt dongle: -u 02-02 static bd_addr_t remote = {0x00, 0x02, 0x72, 0xDC, 0x31, 0xC1};
static uint16_t con_handle = 0;
static uint16_t avdtp_cid = 0;
static uint8_t sdp_avdtp_sink_service_buffer[150];
static avdtp_sep_t sep;
@ -442,8 +442,8 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case HCI_EVENT_AVDTP_META:
switch (packet[2]){
case AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED:
con_handle = avdtp_subevent_signaling_connection_established_get_con_handle(packet);
printf("\n --- avdtp_test: AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED, con handle 0x%02x ---\n", con_handle);
avdtp_cid = avdtp_subevent_signaling_connection_established_get_avdtp_cid(packet);
printf("\n --- avdtp_test: AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED, cid 0x%02x ---\n", avdtp_cid);
break;
case AVDTP_SUBEVENT_SIGNALING_SEP_FOUND:
if (app_state != AVDTP_APPLICATION_W2_DISCOVER_SEPS) return;
@ -562,23 +562,23 @@ static void stdin_process(btstack_data_source_t *ds, btstack_data_source_callbac
break;
case 'C':
printf("Disconnect not implemented\n");
avdtp_sink_disconnect(con_handle);
avdtp_sink_disconnect(avdtp_cid);
break;
case 'd':
app_state = AVDTP_APPLICATION_W2_DISCOVER_SEPS;
avdtp_sink_discover_stream_endpoints(con_handle);
avdtp_sink_discover_stream_endpoints(avdtp_cid);
break;
case 'g':
app_state = AVDTP_APPLICATION_W2_GET_CAPABILITIES;
avdtp_sink_get_capabilities(con_handle, sep.seid);
avdtp_sink_get_capabilities(avdtp_cid, sep.seid);
break;
case 'a':
app_state = AVDTP_APPLICATION_W2_GET_ALL_CAPABILITIES;
avdtp_sink_get_all_capabilities(con_handle, sep.seid);
avdtp_sink_get_all_capabilities(avdtp_cid, sep.seid);
break;
case 'f':
app_state = AVDTP_APPLICATION_W2_GET_CONFIGURATION;
avdtp_sink_get_configuration(con_handle, sep.seid);
avdtp_sink_get_configuration(avdtp_cid, sep.seid);
break;
case 's':
app_state = AVDTP_APPLICATION_W2_SET_CONFIGURATION;
@ -587,7 +587,7 @@ static void stdin_process(btstack_data_source_t *ds, btstack_data_source_callbac
remote_configuration.media_codec.media_codec_type = AVDTP_CODEC_SBC;
remote_configuration.media_codec.media_codec_information_len = sizeof(media_sbc_codec_configuration);
remote_configuration.media_codec.media_codec_information = media_sbc_codec_configuration;
avdtp_sink_set_configuration(con_handle, local_stream_endpoint->sep.seid, sep.seid, remote_configuration_bitmap, remote_configuration);
avdtp_sink_set_configuration(avdtp_cid, local_stream_endpoint->sep.seid, sep.seid, remote_configuration_bitmap, remote_configuration);
break;
case 'R':
app_state = AVDTP_APPLICATION_W2_RECONFIGURE_WITH_SEID;
@ -596,27 +596,27 @@ static void stdin_process(btstack_data_source_t *ds, btstack_data_source_callbac
remote_configuration.media_codec.media_codec_type = AVDTP_CODEC_SBC;
remote_configuration.media_codec.media_codec_information_len = sizeof(media_sbc_codec_reconfiguration);
remote_configuration.media_codec.media_codec_information = media_sbc_codec_reconfiguration;
avdtp_sink_reconfigure(con_handle, sep.seid, remote_configuration_bitmap, remote_configuration);
avdtp_sink_reconfigure(avdtp_cid, sep.seid, remote_configuration_bitmap, remote_configuration);
break;
case 'o':
app_state = AVDTP_APPLICATION_W2_OPEN_STREAM_WITH_SEID;
avdtp_sink_open_stream(con_handle, local_stream_endpoint->sep.seid, sep.seid);
avdtp_sink_open_stream(avdtp_cid, local_stream_endpoint->sep.seid, sep.seid);
break;
case 'm':
app_state = AVDTP_APPLICATION_W2_START_STREAM_WITH_SEID;
avdtp_sink_start_stream(con_handle, local_stream_endpoint->sep.seid, sep.seid);
avdtp_sink_start_stream(avdtp_cid, local_stream_endpoint->sep.seid, sep.seid);
break;
case 'A':
app_state = AVDTP_APPLICATION_W2_ABORT_STREAM_WITH_SEID;
avdtp_sink_abort_stream(con_handle, local_stream_endpoint->sep.seid, sep.seid);
avdtp_sink_abort_stream(avdtp_cid, local_stream_endpoint->sep.seid, sep.seid);
break;
case 'S':
app_state = AVDTP_APPLICATION_W2_STOP_STREAM_WITH_SEID;
avdtp_sink_stop_stream(con_handle, local_stream_endpoint->sep.seid, sep.seid);
avdtp_sink_stop_stream(avdtp_cid, local_stream_endpoint->sep.seid, sep.seid);
break;
case 'P':
app_state = AVDTP_APPLICATION_W2_SUSPEND_STREAM_WITH_SEID;
avdtp_sink_suspend(con_handle, sep.seid);
avdtp_sink_suspend(avdtp_cid, sep.seid);
break;
case '\n':

52
test/avdtp/avdtp_source_demo.c
View File

@ -126,8 +126,8 @@ static bd_addr_t remote = {0x00, 0x21, 0x3c, 0xac, 0xf7, 0x38};
// bt dongle: -u 02-04-01
// static bd_addr_t remote = {0x00, 0x15, 0x83, 0x5F, 0x9D, 0x46};
static uint16_t con_handle = 0;
static uint16_t media_con_handle = 0;
static uint16_t avdtp_cid = 0;
static uint8_t sdp_avdtp_source_service_buffer[150];
static adtvp_media_codec_information_sbc_t sbc_capability;
@ -288,7 +288,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case HCI_EVENT_AVDTP_META:
switch (packet[2]){
case AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED:
con_handle = avdtp_subevent_signaling_connection_established_get_con_handle(packet);
avdtp_cid = avdtp_subevent_signaling_connection_established_get_avdtp_cid(packet);
status = avdtp_subevent_signaling_connection_established_get_status(packet);
if (status != 0){
printf(" --- avdtp source --- AVDTP_SUBEVENT_SIGNALING_CONNECTION could not be established, status %d ---\n", status);
@ -297,18 +297,17 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
active_remote_sep = NULL;
next_remote_sep_index_to_query = -1;
app_state = AVDTP_APPLICATION_CONNECTED;
printf(" --- avdtp source --- AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED, con handle 0x%02x ---\n", con_handle);
printf(" --- avdtp source --- AVDTP_SUBEVENT_SIGNALING_CONNECTION_ESTABLISHED, avdtp cid 0x%02x ---\n", avdtp_cid);
break;
case AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED:
media_con_handle = avdtp_subevent_streaming_connection_established_get_con_handle(packet);
status = avdtp_subevent_streaming_connection_established_get_status(packet);
if (status != 0){
printf(" --- avdtp source --- AVDTP_SUBEVENT_STREAMING_CONNECTION could not be established, status %d ---\n", status);
break;
}
app_state = AVDTP_APPLICATION_STREAMING_OPENED;
printf(" --- avdtp source --- AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED, con handle 0x%02x ---\n", media_con_handle);
printf(" --- avdtp source --- AVDTP_SUBEVENT_STREAMING_CONNECTION_ESTABLISHED ---\n");
break;
case AVDTP_SUBEVENT_SIGNALING_SEP_FOUND:
@ -342,7 +341,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
avdtp_choose_sbc_configuration_from_sbc_codec_information(&sbc_capability, media_sbc_codec_configuration);
app_state = AVDTP_APPLICATION_W2_SET_CONFIGURATION;
active_remote_sep = avdtp_source_remote_sep(con_handle, next_remote_sep_index_to_query);
active_remote_sep = avdtp_source_remote_sep(avdtp_cid, next_remote_sep_index_to_query);
remote_configuration_bitmap = store_bit16(remote_configuration_bitmap, AVDTP_MEDIA_CODEC, 1);
remote_configuration.media_codec.media_type = AVDTP_AUDIO;
remote_configuration.media_codec.media_codec_type = AVDTP_CODEC_SBC;
@ -381,15 +380,15 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case AVDTP_APPLICATION_W2_DISCOVER_SEPS:
app_state = AVDTP_APPLICATION_W2_GET_ALL_CAPABILITIES;
next_remote_sep_index_to_query = 0;
printf(" --- avdtp source --- Query get caps for seid %d\n", avdtp_source_remote_sep(con_handle, next_remote_sep_index_to_query)->seid);
avdtp_source_get_capabilities(con_handle, avdtp_source_remote_sep(con_handle, next_remote_sep_index_to_query)->seid);
printf(" --- avdtp source --- Query get caps for seid %d\n", avdtp_source_remote_sep(avdtp_cid, next_remote_sep_index_to_query)->seid);
avdtp_source_get_capabilities(avdtp_cid, avdtp_source_remote_sep(avdtp_cid, next_remote_sep_index_to_query)->seid);
break;
case AVDTP_APPLICATION_W2_GET_CAPABILITIES:
case AVDTP_APPLICATION_W2_GET_ALL_CAPABILITIES:
if (next_remote_sep_index_to_query < avdtp_source_remote_seps_num(con_handle) - 1){
if (next_remote_sep_index_to_query < avdtp_source_remote_seps_num(avdtp_cid) - 1){
next_remote_sep_index_to_query++;
printf(" --- avdtp source --- Query get caps for seid %d\n", avdtp_source_remote_sep(con_handle, next_remote_sep_index_to_query)->seid);
avdtp_source_get_capabilities(con_handle, avdtp_source_remote_sep(con_handle, next_remote_sep_index_to_query)->seid);
printf(" --- avdtp source --- Query get caps for seid %d\n", avdtp_source_remote_sep(avdtp_cid, next_remote_sep_index_to_query)->seid);
avdtp_source_get_capabilities(avdtp_cid, avdtp_source_remote_sep(avdtp_cid, next_remote_sep_index_to_query)->seid);
} else {
printf(" --- avdtp source --- Cannot query get caps, index %d\n", next_remote_sep_index_to_query);
app_state = AVDTP_APPLICATION_IDLE;
@ -397,11 +396,11 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
break;
case AVDTP_APPLICATION_W2_SET_CONFIGURATION:
app_state = AVDTP_APPLICATION_W2_GET_CONFIGURATION;
avdtp_source_set_configuration(con_handle, local_stream_endpoint->sep.seid, active_remote_sep->seid, remote_configuration_bitmap, remote_configuration);
avdtp_source_set_configuration(avdtp_cid, local_stream_endpoint->sep.seid, active_remote_sep->seid, remote_configuration_bitmap, remote_configuration);
break;
case AVDTP_APPLICATION_W2_GET_CONFIGURATION:
app_state = AVDTP_APPLICATION_W2_OPEN_STREAM_WITH_SEID;
avdtp_source_get_configuration(con_handle, active_remote_sep->seid);
avdtp_source_get_configuration(avdtp_cid, active_remote_sep->seid);
break;
case AVDTP_APPLICATION_W2_OPEN_STREAM_WITH_SEID:
app_state = AVDTP_APPLICATION_W4_OPEN_STREAM_WITH_SEID;
@ -409,7 +408,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
sbc_configuration.block_length, sbc_configuration.subbands,
sbc_configuration.allocation_method, sbc_configuration.sampling_frequency,
sbc_configuration.max_bitpool_value);
avdtp_source_open_stream(con_handle, local_stream_endpoint->sep.seid, active_remote_sep->seid);
avdtp_source_open_stream(avdtp_cid, local_stream_endpoint->sep.seid, active_remote_sep->seid);
break;
case AVDTP_APPLICATION_STREAMING_OPENED:
switch (signal_identifier){
@ -444,7 +443,7 @@ static void packet_handler(uint8_t packet_type, uint16_t channel, uint8_t *packe
case AVDTP_SUBEVENT_STREAMING_CAN_SEND_MEDIA_PACKET_NOW: {
avdtp_source_stream_send_media_payload(local_stream_endpoint->l2cap_media_cid, &streaming_context.sbc_ring_buffer, 0);
if (btstack_ring_buffer_bytes_available(&streaming_context.sbc_ring_buffer)){
avdtp_source_request_can_send_now(local_stream_endpoint->l2cap_media_cid);
avdtp_source_stream_endpoint_request_can_send_now(local_stream_endpoint);
}
break;
}
@ -584,7 +583,7 @@ static void avdtp_fill_audio_ring_buffer_timeout_handler(btstack_timer_source_t
int total_num_bytes_read = fill_sbc_ring_buffer();
// schedule sending
if (total_num_bytes_read != 0){
avdtp_source_request_can_send_now(media_con_handle);
avdtp_source_stream_endpoint_request_can_send_now(local_stream_endpoint);
}
}
@ -601,12 +600,12 @@ static void avdtp_fill_audio_ring_buffer_timer_stop(void){
}
static void avdtp_source_stream_data_start(void){
if (!avdtp_source_streaming_endpoint_ready(media_con_handle)) return;
if (!avdtp_source_stream_endpoint_ready(local_stream_endpoint)) return;
avdtp_fill_audio_ring_buffer_timer_start();
}
static void avdtp_source_stream_data_stop(){
if (!avdtp_source_streaming_endpoint_ready(media_con_handle)) return;
if (!avdtp_source_stream_endpoint_ready(local_stream_endpoint)) return;
avdtp_fill_audio_ring_buffer_timer_stop();
}
@ -624,11 +623,12 @@ static void stdin_process(btstack_data_source_t *ds, btstack_data_source_callbac
break;
case 'C':
printf("Disconnect not implemented\n");
avdtp_source_disconnect(con_handle);
avdtp_source_disconnect(avdtp_cid);
break;
case 'd':
app_state = AVDTP_APPLICATION_W2_DISCOVER_SEPS;
avdtp_source_discover_stream_endpoints(con_handle);
printf("Discover stream endpoints, cid 0x%02x \n", avdtp_cid);
avdtp_source_discover_stream_endpoints(avdtp_cid);
break;
default:
if (!active_remote_sep){
@ -641,23 +641,23 @@ static void stdin_process(btstack_data_source_t *ds, btstack_data_source_callbac
switch (cmd){
case 'f':
app_state = AVDTP_APPLICATION_W2_GET_CONFIGURATION;
avdtp_source_get_configuration(con_handle, active_remote_sep->seid);
avdtp_source_get_configuration(avdtp_cid, active_remote_sep->seid);
break;
case 'm':
app_state = AVDTP_APPLICATION_W2_START_STREAM_WITH_SEID;
avdtp_source_start_stream(con_handle, local_stream_endpoint->sep.seid, active_remote_sep->seid);
avdtp_source_start_stream(avdtp_cid, local_stream_endpoint->sep.seid, active_remote_sep->seid);
break;
case 'A':
app_state = AVDTP_APPLICATION_W2_ABORT_STREAM_WITH_SEID;
avdtp_source_abort_stream(con_handle, local_stream_endpoint->sep.seid, active_remote_sep->seid);
avdtp_source_abort_stream(avdtp_cid, local_stream_endpoint->sep.seid, active_remote_sep->seid);
break;
case 'S':
app_state = AVDTP_APPLICATION_W2_STOP_STREAM_WITH_SEID;
avdtp_source_stop_stream(con_handle, local_stream_endpoint->sep.seid, active_remote_sep->seid);
avdtp_source_stop_stream(avdtp_cid, local_stream_endpoint->sep.seid, active_remote_sep->seid);
break;
case 'P':
app_state = AVDTP_APPLICATION_W2_SUSPEND_STREAM_WITH_SEID;
avdtp_source_suspend(con_handle, active_remote_sep->seid);
avdtp_source_suspend(avdtp_cid, active_remote_sep->seid);
break;
case 'x':
printf("Start streaming sine.\n");