mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-03-30 07:21:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

avdtp/avrcp: log error on malloc failure

Browse Source
This commit is contained in:
Milanka Ringwald 2017-08-09 16:45:27 +02:00
parent 0fd69bb60e
commit 4567cc17d5
12 changed files with 127 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
example/a2dp_sink_demo.c
View File

@ -163,14 +163,9 @@ static const char * device_addr_string = "54:E4:3A:26:A2:39";
// bt dongle: -u 02-02 static bd_addr_t remote = {0x00, 0x02, 0x72, 0xDC, 0x31, 0xC1};
static uint16_t a2dp_cid = 0;
static uint8_t sdp_avdtp_sink_service_buffer[150];
#ifdef HAVE_BTSTACK_STDIN
static avdtp_sep_t sep;
#endif
static uint8_t sdp_avdtp_sink_service_buffer[150];
static avdtp_media_codec_configuration_sbc_t sbc_configuration;
static uint16_t a2dp_cid = 0;
static uint8_t local_seid = 0;
typedef enum {
@ -830,24 +825,23 @@ static uint8_t media_sbc_codec_configuration[] = {
#ifdef HAVE_BTSTACK_STDIN
static void stdin_process(char cmd){
sep.seid = 1;
uint8_t status = ERROR_CODE_SUCCESS;
switch (cmd){
case 'b':
printf(" - Create AVDTP connection to addr %s.\n", bd_addr_to_str(device_addr));
a2dp_sink_establish_stream(device_addr, local_seid, &a2dp_cid);
status = a2dp_sink_establish_stream(device_addr, local_seid, &a2dp_cid);
break;
case 'B':
printf(" - Disconnect\n");
avdtp_sink_disconnect(a2dp_cid);
status = avdtp_sink_disconnect(a2dp_cid);
break;
case 'c':
printf(" - Create AVRCP connection to addr %s.\n", bd_addr_to_str(device_addr));
avrcp_controller_connect(device_addr, &avrcp_cid);
printf(" assigned avrcp cid 0x%02x\n", avrcp_cid);
status = avrcp_controller_connect(device_addr, &avrcp_cid);
break;
case 'C':
printf(" - Disconnect\n");
avrcp_controller_disconnect(avrcp_cid);
status = avrcp_controller_disconnect(avrcp_cid);
break;
case '\n':
@ -855,96 +849,98 @@ static void stdin_process(char cmd){
break;
case 'O':
printf(" - get play status\n");
avrcp_controller_get_play_status(avrcp_cid);
status = avrcp_controller_get_play_status(avrcp_cid);
break;
case 'j':
printf(" - get now playing info\n");
avrcp_controller_get_now_playing_info(avrcp_cid);
status = avrcp_controller_get_now_playing_info(avrcp_cid);
break;
case 'k':
printf(" - play\n");
avrcp_controller_play(avrcp_cid);
status = avrcp_controller_play(avrcp_cid);
break;
case 'K':
printf(" - stop\n");
avrcp_controller_stop(avrcp_cid);
status = avrcp_controller_stop(avrcp_cid);
break;
case 'L':
printf(" - pause\n");
avrcp_controller_pause(avrcp_cid);
status = avrcp_controller_pause(avrcp_cid);
break;
case 'u':
printf(" - start fast forward\n");
avrcp_controller_start_fast_forward(avrcp_cid);
status = avrcp_controller_start_fast_forward(avrcp_cid);
break;
case 'U':
printf(" - stop fast forward\n");
avrcp_controller_stop_fast_forward(avrcp_cid);
status = avrcp_controller_stop_fast_forward(avrcp_cid);
break;
case 'n':
printf(" - start rewind\n");
avrcp_controller_start_rewind(avrcp_cid);
status = avrcp_controller_start_rewind(avrcp_cid);
break;
case 'N':
printf(" - stop rewind\n");
avrcp_controller_stop_rewind(avrcp_cid);
status = avrcp_controller_stop_rewind(avrcp_cid);
break;
case 'i':
printf(" - forward\n");
avrcp_controller_forward(avrcp_cid);
status = avrcp_controller_forward(avrcp_cid);
break;
case 'I':
printf(" - backward\n");
avrcp_controller_backward(avrcp_cid);
status = avrcp_controller_backward(avrcp_cid);
break;
case 't':
printf(" - volume up\n");
avrcp_controller_volume_up(avrcp_cid);
status = avrcp_controller_volume_up(avrcp_cid);
break;
case 'T':
printf(" - volume down\n");
avrcp_controller_volume_down(avrcp_cid);
status = avrcp_controller_volume_down(avrcp_cid);
break;
case 'p':
printf(" - absolute volume of 50 percent\n");
avrcp_controller_set_absolute_volume(avrcp_cid, 50);
status = avrcp_controller_set_absolute_volume(avrcp_cid, 50);
break;
case 'M':
printf(" - mute\n");
avrcp_controller_mute(avrcp_cid);
status = avrcp_controller_mute(avrcp_cid);
break;
case 'r':
printf(" - skip\n");
avrcp_controller_skip(avrcp_cid);
status = avrcp_controller_skip(avrcp_cid);
break;
case 'q':
printf(" - query repeat and shuffle mode\n");
avrcp_controller_query_shuffle_and_repeat_modes(avrcp_cid);
status = avrcp_controller_query_shuffle_and_repeat_modes(avrcp_cid);
break;
case 'v':
printf(" - repeat single track\n");
avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_SINGLE_TRACK);
status = avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_SINGLE_TRACK);
break;
case 'x':
printf(" - repeat all tracks\n");
avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_ALL_TRACKS);
status = avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_ALL_TRACKS);
break;
case 'X':
printf(" - disable repeat mode\n");
avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_OFF);
status = avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_OFF);
break;
case 'z':
printf(" - shuffle all tracks\n");
avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_ALL_TRACKS);
status = avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_ALL_TRACKS);
break;
case 'Z':
printf(" - disable shuffle mode\n");
avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_OFF);
status = avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_OFF);
break;
default:
show_usage();
break;
return;
}
if (status != ERROR_CODE_SUCCESS){
printf("Could not perform command, status 0x%2x\n", status);
}
}
#endif
@ -966,8 +962,12 @@ int btstack_main(int argc, const char * argv[]){
a2dp_sink_register_packet_handler(&packet_handler);
a2dp_sink_register_media_handler(&handle_l2cap_media_data_packet);
local_seid = a2dp_sink_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration));
avdtp_stream_endpoint_t * local_stream_endpoint = a2dp_sink_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration));
if (!local_stream_endpoint){
printf("A2DP Sink: not enough memory to create local stream endpoint\n");
return 1;
}
local_seid = avdtp_local_seid(local_stream_endpoint);
// Initialize AVRCP COntroller
avrcp_controller_init();
avrcp_controller_register_packet_handler(&avrcp_controller_packet_handler);

28
example/a2dp_source_demo.c
View File

@ -451,23 +451,23 @@ static void show_usage(void){
}
static void stdin_process(char cmd){
uint8_t status = ERROR_CODE_SUCCESS;
switch (cmd){
case 'b':
printf(" - Create AVDTP Source connection to addr %s.\n", bd_addr_to_str(device_addr));
a2dp_source_establish_stream(device_addr, media_tracker.local_seid, &media_tracker.a2dp_cid);
status = a2dp_source_establish_stream(device_addr, media_tracker.local_seid, &media_tracker.a2dp_cid);
break;
case 'B':
printf(" - AVDTP Source Disconnect\n");
a2dp_source_disconnect(media_tracker.a2dp_cid);
status = a2dp_source_disconnect(media_tracker.a2dp_cid);
break;
case 'c':
printf(" - Create AVRCP Target connection to addr %s.\n", bd_addr_to_str(device_addr));
avrcp_target_connect(device_addr, &avrcp_cid);
printf(" assigned avrcp cid 0x%02x\n", avrcp_cid);
status = avrcp_target_connect(device_addr, &avrcp_cid);
break;
case 'C':
printf(" - AVRCP Target disconnect\n");
avrcp_target_disconnect(avrcp_cid);
status = avrcp_target_disconnect(avrcp_cid);
break;
case '\n':
@ -477,21 +477,24 @@ static void stdin_process(char cmd){
case 'x':
printf("Playing sine.\n");
data_source = STREAM_SINE;
a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
break;
case 'z':
printf("Playing mod.\n");
data_source = STREAM_MOD;
a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
status = a2dp_source_start_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
break;
case 'p':
printf("Pause stream.\n");
a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
status = a2dp_source_pause_stream(media_tracker.a2dp_cid, media_tracker.local_seid);
break;
default:
show_usage();
break;
return;
}
if (status != ERROR_CODE_SUCCESS){
printf("Could not perform command, status 0x%2x\n", status);
}
}
#endif
@ -507,7 +510,12 @@ int btstack_main(int argc, const char * argv[]){
a2dp_source_init();
a2dp_source_register_packet_handler(&packet_handler);
media_tracker.local_seid = a2dp_source_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration));
avdtp_stream_endpoint_t * local_stream_endpoint = a2dp_source_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration));
if (!local_stream_endpoint){
printf("A2DP source demo: not enough memory to create local stream endpoint\n");
return 1;
}
media_tracker.local_seid = avdtp_local_seid(local_stream_endpoint);
// Initialize AVRCP Target
avrcp_target_init();

7
src/classic/a2dp_sink.c
View File

@ -172,17 +172,20 @@ void a2dp_sink_init(void){
l2cap_register_service(&packet_handler, BLUETOOTH_PROTOCOL_AVDTP, 0xffff, LEVEL_0);
}
uint8_t a2dp_sink_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
avdtp_stream_endpoint_t * a2dp_sink_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
uint8_t * codec_capabilities, uint16_t codec_capabilities_len,
uint8_t * media_codec_info, uint16_t media_codec_info_len){
avdtp_stream_endpoint_t * local_stream_endpoint = avdtp_sink_create_stream_endpoint(AVDTP_SINK, media_type);
if (!local_stream_endpoint){
return NULL;
}
avdtp_sink_register_media_transport_category(avdtp_stream_endpoint_seid(local_stream_endpoint));
avdtp_sink_register_media_codec_category(avdtp_stream_endpoint_seid(local_stream_endpoint), media_type, media_codec_type,
codec_capabilities, codec_capabilities_len);
local_stream_endpoint->remote_configuration.media_codec.media_codec_information = media_codec_info;
local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = media_codec_info_len;
return local_stream_endpoint->sep.seid;
return local_stream_endpoint;
}
uint8_t a2dp_sink_establish_stream(bd_addr_t bd_addr, uint8_t local_seid, uint16_t * avdtp_cid){

2
src/classic/a2dp_sink.h
View File

@ -69,7 +69,7 @@ void a2dp_sink_create_sdp_record(uint8_t * service, uint32_t service_record_hand
*/
void a2dp_sink_init(void);
uint8_t a2dp_sink_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
avdtp_stream_endpoint_t * a2dp_sink_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
uint8_t * codec_capabilities, uint16_t codec_capabilities_len,
uint8_t * codec_configuration, uint16_t codec_configuration_len);

7
src/classic/a2dp_source.c
View File

@ -439,17 +439,20 @@ void a2dp_source_init(void){
l2cap_register_service(&packet_handler, BLUETOOTH_PROTOCOL_AVDTP, 0xffff, LEVEL_0);
}
uint8_t a2dp_source_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
avdtp_stream_endpoint_t * a2dp_source_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
uint8_t * codec_capabilities, uint16_t codec_capabilities_len,
uint8_t * media_codec_info, uint16_t media_codec_info_len){
avdtp_stream_endpoint_t * local_stream_endpoint = avdtp_source_create_stream_endpoint(AVDTP_SOURCE, media_type);
if (!local_stream_endpoint){
return NULL;
}
avdtp_source_register_media_transport_category(avdtp_stream_endpoint_seid(local_stream_endpoint));
avdtp_source_register_media_codec_category(avdtp_stream_endpoint_seid(local_stream_endpoint), media_type, media_codec_type,
codec_capabilities, codec_capabilities_len);
local_stream_endpoint->remote_configuration.media_codec.media_codec_information = media_codec_info;
local_stream_endpoint->remote_configuration.media_codec.media_codec_information_len = media_codec_info_len;
return local_stream_endpoint->sep.seid;
return local_stream_endpoint;
}
uint8_t a2dp_source_establish_stream(bd_addr_t remote_addr, uint8_t loc_seid, uint16_t * avdtp_cid){

2
src/classic/a2dp_source.h
View File

@ -68,7 +68,7 @@ void a2dp_source_init(void);
void a2dp_source_register_packet_handler(btstack_packet_handler_t callback);
uint8_t a2dp_source_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
avdtp_stream_endpoint_t * a2dp_source_create_stream_endpoint(avdtp_media_type_t media_type, avdtp_media_codec_type_t media_codec_type,
uint8_t * codec_capabilities, uint16_t codec_capabilities_len,
uint8_t * codec_configuration, uint16_t codec_configuration_len);

14
src/classic/avdtp.c
View File

@ -95,10 +95,14 @@ uint8_t avdtp_connect(bd_addr_t remote, avdtp_sep_type_t query_role, avdtp_conte
avdtp_connection_t * connection = avdtp_connection_for_bd_addr(remote, avdtp_context);
if (!connection){
connection = avdtp_create_connection(remote, avdtp_context);
if (!connection){
log_error("avdtp: not enough memory to create connection");
return BTSTACK_MEMORY_ALLOC_FAILED;
}
}
if (connection->state != AVDTP_SIGNALING_CONNECTION_IDLE){
log_error("avdtp_connect: sink in wrong state,");
return BTSTACK_MEMORY_ALLOC_FAILED;
return AVDTP_CONNECTION_IN_WRONG_STATE;
}
if (!avdtp_cid) return L2CAP_LOCAL_CID_DOES_NOT_EXIST;
@ -242,6 +246,10 @@ void avdtp_handle_can_send_now(avdtp_connection_t * connection, uint16_t l2cap_c
avdtp_connection_t * avdtp_create_connection(bd_addr_t remote_addr, avdtp_context_t * context){
avdtp_connection_t * connection = btstack_memory_avdtp_connection_get();
if (!connection){
log_error("avdtp: not enough memory to create connection");
return NULL;
}
memset(connection, 0, sizeof(avdtp_connection_t));
connection->state = AVDTP_SIGNALING_CONNECTION_IDLE;
connection->initiator_transaction_label = avdtp_get_next_initiator_transaction_label(context);
@ -253,6 +261,10 @@ avdtp_connection_t * avdtp_create_connection(bd_addr_t remote_addr, avdtp_contex
avdtp_stream_endpoint_t * avdtp_create_stream_endpoint(avdtp_sep_type_t sep_type, avdtp_media_type_t media_type, avdtp_context_t * context){
avdtp_stream_endpoint_t * stream_endpoint = btstack_memory_avdtp_stream_endpoint_get();
if (!stream_endpoint){
log_error("avdtp: not enough memory to create stream endpoint");
return NULL;
}
memset(stream_endpoint, 0, sizeof(avdtp_stream_endpoint_t));
stream_endpoint->sep.seid = avdtp_get_next_local_seid(context);
stream_endpoint->sep.media_type = media_type;

4
src/classic/avrcp.c
View File

@ -368,6 +368,10 @@ static uint16_t avdtp_get_next_avrcp_cid(void){
static avrcp_connection_t * avrcp_create_connection(bd_addr_t remote_addr, avrcp_context_t * context){
avrcp_connection_t * connection = btstack_memory_avrcp_connection_get();
if (!connection){
log_error("avrcp: not enough memory to create connection");
return NULL;
}
memset(connection, 0, sizeof(avrcp_connection_t));
connection->state = AVCTP_CONNECTION_IDLE;
connection->transaction_label = 0xFF;

54
test/avrcp/avrcp_controller_test.c
View File

@ -222,106 +222,110 @@ static void show_usage(void){
}
static void stdin_process(char cmd){
uint8_t status = ERROR_CODE_SUCCESS;
switch (cmd){
case 'c':
printf(" - Create AVRCP connection to addr %s.\n", bd_addr_to_str(device_addr));
avrcp_controller_connect(device_addr, &avrcp_cid);
status = avrcp_controller_connect(device_addr, &avrcp_cid);
break;
case 'B':
printf(" - Disconnect\n");
avrcp_controller_disconnect(avrcp_cid);
status = avrcp_controller_disconnect(avrcp_cid);
break;
case 'i':
printf(" - get play status\n");
avrcp_controller_get_play_status(avrcp_cid);
status = avrcp_controller_get_play_status(avrcp_cid);
break;
case 'j':
printf(" - get now playing info\n");
avrcp_controller_get_now_playing_info(avrcp_cid);
status = avrcp_controller_get_now_playing_info(avrcp_cid);
break;
case 'k':
printf(" - play\n");
avrcp_controller_play(avrcp_cid);
status = avrcp_controller_play(avrcp_cid);
break;
case 'K':
printf(" - stop\n");
avrcp_controller_stop(avrcp_cid);
status = avrcp_controller_stop(avrcp_cid);
break;
case 'L':
printf(" - pause\n");
avrcp_controller_pause(avrcp_cid);
status = avrcp_controller_pause(avrcp_cid);
break;
case 'm':
printf(" - start fast forward\n");
avrcp_controller_start_fast_forward(avrcp_cid);
status = avrcp_controller_start_fast_forward(avrcp_cid);
break;
case 'M':
printf(" - stop fast forward\n");
avrcp_controller_stop_fast_forward(avrcp_cid);
status = avrcp_controller_stop_fast_forward(avrcp_cid);
break;
case 'n':
printf(" - start rewind\n");
avrcp_controller_start_rewind(avrcp_cid);
status = avrcp_controller_start_rewind(avrcp_cid);
break;
case 'N':
printf(" - stop rewind\n");
avrcp_controller_stop_rewind(avrcp_cid);
status = avrcp_controller_stop_rewind(avrcp_cid);
break;
case 'o':
printf(" - forward\n");
avrcp_controller_forward(avrcp_cid);
status = avrcp_controller_forward(avrcp_cid);
break;
case 'O':
printf(" - backward\n");
avrcp_controller_backward(avrcp_cid);
status = avrcp_controller_backward(avrcp_cid);
break;
case 'p':
printf(" - volume up\n");
avrcp_controller_volume_up(avrcp_cid);
status = avrcp_controller_volume_up(avrcp_cid);
break;
case 'P':
printf(" - volume down\n");
avrcp_controller_volume_down(avrcp_cid);
status = avrcp_controller_volume_down(avrcp_cid);
break;
case 'r':
printf(" - absolute volume of 50 percent\n");
avrcp_controller_set_absolute_volume(avrcp_cid, 50);
status = avrcp_controller_set_absolute_volume(avrcp_cid, 50);
break;
case 's':
printf(" - mute\n");
avrcp_controller_mute(avrcp_cid);
status = avrcp_controller_mute(avrcp_cid);
break;
case 't':
printf(" - skip\n");
avrcp_controller_skip(avrcp_cid);
status = avrcp_controller_skip(avrcp_cid);
break;
case 'u':
printf(" - query repeat and shuffle mode\n");
avrcp_controller_query_shuffle_and_repeat_modes(avrcp_cid);
status = avrcp_controller_query_shuffle_and_repeat_modes(avrcp_cid);
break;
case 'v':
printf(" - repeat single track\n");
avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_SINGLE_TRACK);
status = avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_SINGLE_TRACK);
break;
case 'x':
printf(" - repeat all tracks\n");
avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_ALL_TRACKS);
status = avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_ALL_TRACKS);
break;
case 'X':
printf(" - disable repeat mode\n");
avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_OFF);
status = avrcp_controller_set_repeat_mode(avrcp_cid, AVRCP_REPEAT_MODE_OFF);
break;
case 'z':
printf(" - shuffle all tracks\n");
avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_ALL_TRACKS);
status = avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_ALL_TRACKS);
break;
case 'Z':
printf(" - disable shuffle mode\n");
avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_OFF);
status = avrcp_controller_set_shuffle_mode(avrcp_cid, AVRCP_SHUFFLE_MODE_OFF);
break;
default:
show_usage();
break;
return;
}
if (status != ERROR_CODE_SUCCESS){
printf("Could not perform command, status 0x%02x\n", status);
}
}
#endif

5
test/pts/avdtp_sink_test.c
View File

@ -599,6 +599,11 @@ int btstack_main(int argc, const char * argv[]){
avdtp_sink_register_packet_handler(&packet_handler);
local_stream_endpoint = avdtp_sink_create_stream_endpoint(AVDTP_SINK, AVDTP_AUDIO);
if (!local_stream_endpoint) {
printf("AVDTP Sink: not enough memory to create local_stream_endpoint\n");
return 1;
}
avdtp_sink_register_media_transport_category(local_stream_endpoint->sep.seid);
avdtp_sink_register_media_codec_category(local_stream_endpoint->sep.seid, AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities));

3
test/pts/avdtp_source_test.c
View File

@ -678,7 +678,8 @@ int btstack_main(int argc, const char * argv[]){
avdtp_source_init(&a2dp_source_context);
avdtp_source_register_packet_handler(&packet_handler);
media_tracker.local_seid = a2dp_source_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, (uint8_t *)media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), (uint8_t *)media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration));
avdtp_stream_endpoint_t * local_stream_endpoint = a2dp_source_create_stream_endpoint(AVDTP_AUDIO, AVDTP_CODEC_SBC, (uint8_t *)media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities), (uint8_t *)media_sbc_codec_configuration, sizeof(media_sbc_codec_configuration));
media_tracker.local_seid = avdtp_local_seid(local_stream_endpoint);
media_tracker.remote_seid = 1;
// Initialize SDP

5
test/pts/avrcp_controller_test.c
View File

@ -514,6 +514,11 @@ int btstack_main(int argc, const char * argv[]){
avdtp_sink_register_packet_handler(&packet_handler);
local_stream_endpoint = avdtp_sink_create_stream_endpoint(AVDTP_SINK, AVDTP_AUDIO);
if (!local_stream_endpoint) {
printf("AVRCP Controller/AVDTP Sink: not enough memory to create local_stream_endpoint\n");
return 1;
}
local_stream_endpoint->sep.seid = 1;
avdtp_sink_register_media_transport_category(local_stream_endpoint->sep.seid);
avdtp_sink_register_media_codec_category(local_stream_endpoint->sep.seid, AVDTP_AUDIO, AVDTP_CODEC_SBC, media_sbc_codec_capabilities, sizeof(media_sbc_codec_capabilities));