diff --git a/example/a2dp_sink_demo.c b/example/a2dp_sink_demo.c index e3b2bdf2f..869565369 100644 --- a/example/a2dp_sink_demo.c +++ b/example/a2dp_sink_demo.c @@ -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); diff --git a/example/a2dp_source_demo.c b/example/a2dp_source_demo.c index 67c1d3cee..80696cf2d 100644 --- a/example/a2dp_source_demo.c +++ b/example/a2dp_source_demo.c @@ -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(); diff --git a/src/classic/a2dp_sink.c b/src/classic/a2dp_sink.c index 5c29767d3..7a4bdb395 100644 --- a/src/classic/a2dp_sink.c +++ b/src/classic/a2dp_sink.c @@ -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){ diff --git a/src/classic/a2dp_sink.h b/src/classic/a2dp_sink.h index 6cbdeba00..98bb01ca9 100644 --- a/src/classic/a2dp_sink.h +++ b/src/classic/a2dp_sink.h @@ -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); diff --git a/src/classic/a2dp_source.c b/src/classic/a2dp_source.c index 634f97aaa..2728c8c7a 100644 --- a/src/classic/a2dp_source.c +++ b/src/classic/a2dp_source.c @@ -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){ diff --git a/src/classic/a2dp_source.h b/src/classic/a2dp_source.h index 3e81bc6c7..801e53580 100644 --- a/src/classic/a2dp_source.h +++ b/src/classic/a2dp_source.h @@ -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); diff --git a/src/classic/avdtp.c b/src/classic/avdtp.c index c5cca00ba..1639b48cb 100644 --- a/src/classic/avdtp.c +++ b/src/classic/avdtp.c @@ -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; diff --git a/src/classic/avrcp.c b/src/classic/avrcp.c index 9a18fc090..cb1d9e356 100644 --- a/src/classic/avrcp.c +++ b/src/classic/avrcp.c @@ -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; diff --git a/test/avrcp/avrcp_controller_test.c b/test/avrcp/avrcp_controller_test.c index 4dc933545..eb1da7572 100644 --- a/test/avrcp/avrcp_controller_test.c +++ b/test/avrcp/avrcp_controller_test.c @@ -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 diff --git a/test/pts/avdtp_sink_test.c b/test/pts/avdtp_sink_test.c index 592cdc5aa..da1781997 100644 --- a/test/pts/avdtp_sink_test.c +++ b/test/pts/avdtp_sink_test.c @@ -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)); diff --git a/test/pts/avdtp_source_test.c b/test/pts/avdtp_source_test.c index 278b76c31..966e40aa7 100644 --- a/test/pts/avdtp_source_test.c +++ b/test/pts/avdtp_source_test.c @@ -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 diff --git a/test/pts/avrcp_controller_test.c b/test/pts/avrcp_controller_test.c index ee19e716b..ae05d9f24 100644 --- a/test/pts/avrcp_controller_test.c +++ b/test/pts/avrcp_controller_test.c @@ -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));