| /****************************************************************************** |
| * |
| * Copyright 2021 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #include "bta_closure_api.h" |
| #include "bta_bap_uclient_api.h" |
| #include "btif_common.h" |
| #include "btif_storage.h" |
| #include "osi/include/thread.h" |
| #include "btif_bap_codec_utils.h" |
| |
| #include "osi/include/properties.h" |
| |
| extern void do_in_bta_thread(const base::Location& from_here, |
| const base::Closure& task); |
| #include <base/bind.h> |
| #include <base/callback.h> |
| #include <base/location.h> |
| #include <base/logging.h> |
| #include <hardware/bluetooth.h> |
| #include <hardware/bt_pacs_client.h> |
| #include <hardware/bt_bap_uclient.h> |
| #include "btif_bap_config.h" |
| |
| using base::Bind; |
| using base::Unretained; |
| using bluetooth::bap::ucast::UcastClient; |
| using bluetooth::bap::pacs::CodecConfig; |
| using bluetooth::bap::pacs::ConnectionState; |
| using bluetooth::bap::ucast::UcastClientCallbacks; |
| using bluetooth::bap::ucast::UcastClientInterface; |
| using bluetooth::bap::ucast::StreamConnect; |
| using bluetooth::bap::ucast::StreamType; |
| using bluetooth::bap::ucast::StreamStateInfo; |
| using bluetooth::bap::ucast::StreamConfigInfo; |
| using bluetooth::bap::ucast::StreamReconfig; |
| |
| using bluetooth::bap::pacs::CodecIndex; |
| using bluetooth::bap::pacs::CodecPriority; |
| using bluetooth::bap::pacs::CodecSampleRate; |
| using bluetooth::bap::pacs::CodecFrameDuration; |
| using bluetooth::bap::pacs::CodecChannelMode; |
| using bluetooth::bap::ucast::CodecQosConfig; |
| using bluetooth::bap::ucast::CISConfig; |
| using bluetooth::bap::ucast::CONTENT_TYPE_MEDIA; |
| using bluetooth::bap::ucast::CONTENT_TYPE_CONVERSATIONAL; |
| using bluetooth::bap::ucast::CONTENT_TYPE_GAME; |
| using bluetooth::bap::ucast::CONTENT_TYPE_LIVE; |
| using bluetooth::bap::ucast::CONTENT_TYPE_UNSPECIFIED; |
| using bluetooth::bap::ucast::ASE_DIRECTION_SRC; |
| using bluetooth::bap::ucast::ASE_DIRECTION_SINK; |
| using bluetooth::bap::ucast::StreamReconfigType; |
| using bluetooth::bap::ucast::ASCSConfig; |
| |
| static thread_t *test_thread; |
| static UcastClientInterface* sUcastClientInterface = nullptr; |
| static RawAddress bap_bd_addr; |
| |
| extern bluetooth::bap::pacs::PacsClientInterface* btif_pacs_client_get_interface(); |
| |
| class UcastClientCallbacksImpl : public UcastClientCallbacks { |
| public: |
| ~UcastClientCallbacksImpl() = default; |
| void OnStreamState(const RawAddress &address, |
| std::vector<StreamStateInfo> streams_state_info) override { |
| for (auto it = streams_state_info.begin(); |
| it != streams_state_info.end(); it++) { |
| LOG(WARNING) << __func__ << " stream type " << (it->stream_type.type); |
| LOG(WARNING) << __func__ << " stream dir " << loghex(it->stream_type.direction); |
| LOG(WARNING) << __func__ << " stream state " << static_cast<int> (it->stream_state); |
| } |
| } |
| void OnStreamConfig(const RawAddress &address, |
| std::vector<StreamConfigInfo> streams_config_info) override { |
| LOG(WARNING) << __func__; |
| for (auto it = streams_config_info.begin(); |
| it != streams_config_info.end(); it++) { |
| LOG(WARNING) << __func__ << " stream type " << (it->stream_type.type); |
| LOG(WARNING) << __func__ << " stream dir " << loghex(it->stream_type.direction); |
| LOG(WARNING) << __func__ << " location " << static_cast<int> (it->audio_location); |
| btif_bap_add_record(address, REC_TYPE_CONFIGURATION, |
| it->stream_type.type, |
| static_cast<CodecDirection> (it->stream_type.direction), |
| &it->codec_config); |
| |
| std::vector<CodecConfig> acm_pac_records; |
| |
| btif_bap_get_records(address, |
| REC_TYPE_CAPABILITY, |
| CONTENT_TYPE_MEDIA | |
| CONTENT_TYPE_UNSPECIFIED, |
| static_cast<CodecDirection> |
| (it->stream_type.direction), |
| &acm_pac_records); |
| |
| LOG(WARNING) << __func__ << " acm len to be 3" << (acm_pac_records.size()); |
| |
| std::vector<CodecConfig> config_pac_records; |
| btif_bap_get_records(address, |
| REC_TYPE_CONFIGURATION, |
| CONTENT_TYPE_MEDIA, |
| static_cast<CodecDirection> |
| (it->stream_type.direction), |
| &config_pac_records); |
| |
| LOG(WARNING) << __func__ << " configs len to be 1" << (config_pac_records.size()); |
| |
| btif_bap_remove_record_by_context (address, REC_TYPE_CONFIGURATION, |
| it->stream_type.type, |
| static_cast<CodecDirection> |
| (it->stream_type.direction)); |
| |
| config_pac_records.clear(); |
| btif_bap_get_records(address, |
| REC_TYPE_CONFIGURATION, |
| CONTENT_TYPE_MEDIA, |
| static_cast<CodecDirection> |
| (it->stream_type.direction), |
| &config_pac_records); |
| |
| LOG(WARNING) << __func__ << " configs len to be 0" << (config_pac_records.size()); |
| |
| #if 0 |
| btif_bap_remove_record_by_context (address, REC_TYPE_CAPABILITY, |
| CONTENT_TYPE_MEDIA | |
| CONTENT_TYPE_UNSPECIFIED, |
| static_cast<CodecDirection> |
| (it->stream_type.direction)); |
| |
| acm_pac_records.clear(); |
| btif_bap_get_records(address, |
| REC_TYPE_CAPABILITY, |
| CONTENT_TYPE_MEDIA | |
| CONTENT_TYPE_UNSPECIFIED, |
| static_cast<CodecDirection> |
| (it->stream_type.direction), |
| &acm_pac_records); |
| |
| LOG(WARNING) << __func__ << " acm len to be 0" << (acm_pac_records.size()); |
| #endif |
| } |
| } |
| void OnStreamAvailable(const RawAddress &address, |
| uint16_t src_audio_contexts, |
| uint16_t sink_audio_contexts) override { |
| LOG(WARNING) << __func__; |
| } |
| }; |
| |
| static UcastClientCallbacksImpl sUcastClientCallbacks; |
| |
| static void event_test_bap_uclient(UNUSED_ATTR void* context) { |
| LOG(INFO) << __func__ << " start " ; |
| sUcastClientInterface = bluetooth::bap::ucast::btif_bap_uclient_get_interface(); |
| sUcastClientInterface->Init(&sUcastClientCallbacks); |
| sleep(1); |
| |
| StreamConnect conn_info; |
| CodecQosConfig codec_qos_config; |
| codec_qos_config.codec_config.codec_type = CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config.codec_config, 100); |
| codec_qos_config.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| CISConfig cis_config_1 = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| CISConfig cis_config_2 = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| codec_qos_config.qos_config.cis_configs.push_back(cis_config_1); |
| codec_qos_config.qos_config.cis_configs.push_back(cis_config_2); |
| |
| ASCSConfig ascs_config = { |
| .cig_id = 1, |
| .cis_id = 0, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| codec_qos_config.qos_config.ascs_configs.push_back(ascs_config); |
| conn_info.stream_type.type = 0x0004; // media |
| conn_info.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info.stream_type.audio_context = |
| CONTENT_TYPE_MEDIA; |
| conn_info.codec_qos_config_pair.push_back(codec_qos_config); |
| std::vector<StreamConnect> streams; |
| streams.push_back(conn_info); |
| |
| ASCSConfig ascs_config_2 = { |
| .cig_id = 1, |
| .cis_id = 1, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| codec_qos_config.qos_config.ascs_configs.clear(); |
| codec_qos_config.qos_config.ascs_configs.push_back(ascs_config_2); |
| StreamConnect conn_info_2; |
| conn_info_2.stream_type.type = 0x0004; // media |
| conn_info_2.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info_2.stream_type.audio_context = |
| CONTENT_TYPE_MEDIA; |
| conn_info_2.codec_qos_config_pair.push_back(codec_qos_config); |
| std::vector<StreamConnect> streams_2; |
| streams_2.push_back(conn_info_2); |
| |
| // reconfig information |
| std::vector<StreamReconfig> reconf_streams; |
| codec_qos_config.qos_config.ascs_configs[0].cis_id = 1; |
| UpdateFrameDuration(&codec_qos_config.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_7_5)); |
| |
| codec_qos_config.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x4C, 0x1D, 0x00}, |
| .sdu_interval_s_to_m = {0x4C, 0x1D, 0x00} |
| }; |
| |
| StreamReconfig reconf_info; |
| reconf_info.stream_type.type = 0x0004; // media |
| reconf_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_info.codec_qos_config_pair.push_back(codec_qos_config); |
| reconf_streams.push_back(reconf_info); |
| |
| std::vector<StreamReconfig> reconf_qos_streams; |
| StreamReconfig reconf_qos_info; |
| reconf_qos_info.stream_type.type = 0x0004; // media |
| reconf_qos_info.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_qos_info.stream_type.direction = ASE_DIRECTION_SINK; |
| codec_qos_config.qos_config.cis_configs.clear(); |
| |
| cis_config_1.rtn_m_to_s = 1; |
| cis_config_1.rtn_s_to_m = 1; |
| cis_config_2.rtn_m_to_s = 1; |
| cis_config_2.rtn_s_to_m = 1; |
| codec_qos_config.qos_config.cis_configs.push_back(cis_config_1); |
| codec_qos_config.qos_config.cis_configs.push_back(cis_config_2); |
| reconf_qos_info.codec_qos_config_pair.push_back(codec_qos_config); |
| reconf_qos_streams.push_back(reconf_qos_info); |
| |
| StreamType type_1 = { .type = 0x0004, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| RawAddress bap_bd_addr_2; |
| RawAddress::FromString("00:02:5B:00:FF:01", bap_bd_addr_2); |
| |
| std::vector<StreamType> start_streams; |
| start_streams.push_back(type_1); |
| |
| char bap_test[150] = "generic"; |
| |
| property_get("persist.vendor.service.bt.bap.test", bap_test, "generic"); |
| |
| LOG(INFO) << __func__ << " property" << bap_test; |
| |
| if(!strcmp(bap_test, "generic")) { |
| LOG(INFO) << __func__ << " going for generic test case"; |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, streams_2); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream start 1 "; |
| //sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| LOG(INFO) << __func__ << " going for stream start 2"; |
| //sUcastClientInterface->Start( bap_bd_addr_2, start_streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect 1 "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| LOG(INFO) << __func__ << "going for stream disconnect 2 "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, start_streams); |
| |
| } else if(!strcmp(bap_test, "stereo_recording_stereo_dual_cis")) { |
| LOG(INFO) << __func__ << " going for rxonly test case"; |
| LOG(INFO) << __func__ << " going for connect"; |
| StreamConnect conn_info_media_recording; |
| |
| CodecQosConfig codec_qos_config_media_rx_1; |
| CodecQosConfig codec_qos_config_media_rx_2; |
| |
| CISConfig cis_config_1_media_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 0, |
| .max_sdu_s_to_m = 100, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_2_media_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 0, |
| .max_sdu_s_to_m = 100, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_1_media_rx_2 = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 0, |
| .max_sdu_s_to_m = 200, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| ASCSConfig ascs_config_1 = { |
| .cig_id = 1, |
| .cis_id = 0, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_2 = { |
| .cig_id = 1, |
| .cis_id = 1, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| codec_qos_config_media_rx_1.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_media_rx_1.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_media_rx_1.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_media_rx_1.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_media_rx_1.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_media_rx_1.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_media_rx_1.codec_config, 100); |
| |
| |
| codec_qos_config_media_rx_2 = codec_qos_config_media_rx_1; |
| UpdateOctsPerFrame(&codec_qos_config_media_rx_2.codec_config, 200); |
| |
| codec_qos_config_media_rx_1.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_rx_1.qos_config.cis_configs.push_back(cis_config_1_media_rx); |
| codec_qos_config_media_rx_1.qos_config.cis_configs.push_back(cis_config_2_media_rx); |
| |
| codec_qos_config_media_rx_1.qos_config.ascs_configs.push_back(ascs_config_1); |
| codec_qos_config_media_rx_1.qos_config.ascs_configs.push_back(ascs_config_2); |
| |
| codec_qos_config_media_rx_2.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 1, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_rx_2.qos_config.cis_configs.push_back(cis_config_1_media_rx_2); |
| |
| codec_qos_config_media_rx_2.qos_config.ascs_configs.push_back(ascs_config_1); |
| |
| StreamType type_media_rx = { .type = CONTENT_TYPE_MEDIA, |
| .audio_context = CONTENT_TYPE_LIVE, |
| .direction = ASE_DIRECTION_SRC |
| }; |
| |
| conn_info_media_recording.stream_type.type = CONTENT_TYPE_MEDIA; |
| conn_info_media_recording.stream_type.audio_context = CONTENT_TYPE_LIVE; |
| conn_info_media_recording.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_media_recording.codec_qos_config_pair.push_back(codec_qos_config_media_rx_1); |
| conn_info_media_recording.codec_qos_config_pair.push_back(codec_qos_config_media_rx_2); |
| |
| std::vector<StreamConnect> media_rx_streams; |
| media_rx_streams.push_back(conn_info_media_recording); |
| |
| std::vector<StreamType> streams; |
| streams.push_back(type_media_rx); |
| |
| |
| sUcastClientInterface->Connect( bap_bd_addr, true, media_rx_streams); |
| |
| sleep(15); |
| |
| LOG(INFO) << __func__ << " going for stream start 1 "; |
| sUcastClientInterface->Start( bap_bd_addr, streams); |
| |
| sleep(10); |
| |
| sUcastClientInterface->Stop( bap_bd_addr, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect 1 "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, streams); |
| |
| } else if(!strcmp(bap_test, "dual_streams_media_tx_voice_rx")) { |
| StreamConnect conn_info_media; |
| StreamConnect conn_info_gaming; |
| |
| // reconfig information |
| CodecQosConfig codec_qos_config_media_tx_1; |
| CodecQosConfig codec_qos_config_gaming_tx; |
| CodecQosConfig codec_qos_config_gaming_tx_rx; |
| |
| CISConfig cis_config_1_media_tx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 155, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_2_media_tx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 155, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_1_gaming_tx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_2_gaming_tx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_1_gaming_tx_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| CISConfig cis_config_2_gaming_tx_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| ASCSConfig ascs_config = { |
| .cig_id = 1, |
| .cis_id = 0, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_1.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_media_tx_1.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_media_tx_1.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_media_tx_1.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_media_tx_1.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_media_tx_1.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_media_tx_1.codec_config, 155); |
| codec_qos_config_media_tx_1.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_1.qos_config.cis_configs.push_back(cis_config_1_media_tx); |
| codec_qos_config_media_tx_1.qos_config.cis_configs.push_back(cis_config_2_media_tx); |
| |
| codec_qos_config_media_tx_1.qos_config.ascs_configs.push_back(ascs_config); |
| codec_qos_config_gaming_tx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_tx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_tx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_gaming_tx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_tx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_tx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx.codec_config, 100); |
| codec_qos_config_gaming_tx.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx.qos_config.cis_configs.push_back(cis_config_1_gaming_tx); |
| codec_qos_config_gaming_tx.qos_config.cis_configs.push_back(cis_config_2_gaming_tx); |
| |
| codec_qos_config_gaming_tx.qos_config.ascs_configs.push_back(ascs_config); |
| codec_qos_config_gaming_tx_rx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_tx_rx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_tx_rx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_16000; |
| codec_qos_config_gaming_tx_rx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_tx_rx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_tx_rx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx_rx.codec_config, 40); |
| codec_qos_config_gaming_tx_rx.qos_config.cig_config = { |
| .cig_id = 2, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx_rx.qos_config.cis_configs.push_back(cis_config_1_gaming_tx_rx); |
| codec_qos_config_gaming_tx_rx.qos_config.cis_configs.push_back(cis_config_2_gaming_tx_rx); |
| ASCSConfig ascs_config_gaming = { |
| .cig_id = 2, |
| .cis_id = 0, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| codec_qos_config_gaming_tx_rx.qos_config.ascs_configs.push_back(ascs_config_gaming); |
| conn_info_media.stream_type.type = CONTENT_TYPE_MEDIA; |
| conn_info_media.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| conn_info_media.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info_media.codec_qos_config_pair.push_back(codec_qos_config_media_tx_1); |
| |
| conn_info_gaming.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_gaming.stream_type.audio_context = |
| CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_gaming.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_gaming.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx_rx); |
| |
| std::vector<StreamConnect> dual_streams; |
| dual_streams.push_back(conn_info_media); |
| dual_streams.push_back(conn_info_gaming); |
| |
| StreamType type_media = { .type = CONTENT_TYPE_MEDIA, |
| .audio_context = CONTENT_TYPE_MEDIA, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| StreamType type_voice = { .type = CONTENT_TYPE_CONVERSATIONAL, |
| .audio_context = CONTENT_TYPE_CONVERSATIONAL, |
| .direction = ASE_DIRECTION_SRC |
| }; |
| |
| std::vector<StreamType> media_streams; |
| media_streams.push_back(type_media); |
| std::vector<StreamType> voice_streams; |
| voice_streams.push_back(type_voice); |
| |
| LOG(INFO) << __func__ << " going for generic test case"; |
| LOG(INFO) << __func__ << " going for connect with media tx and gaming rx"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, dual_streams); |
| |
| //sUcastClientInterface->Connect( bap_bd_addr_2, true, streams_2); |
| |
| sleep(10); |
| |
| std::vector<StreamReconfig> reconf_streams; |
| |
| StreamReconfig reconf_gaming_tx_info; |
| reconf_gaming_tx_info.stream_type.type = CONTENT_TYPE_MEDIA; // media |
| reconf_gaming_tx_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; // media |
| reconf_gaming_tx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_info.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx); |
| |
| StreamReconfig reconf_gaming_tx_rx_info; |
| reconf_gaming_tx_rx_info.stream_type.type = CONTENT_TYPE_MEDIA; // media |
| reconf_gaming_tx_rx_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; // media |
| reconf_gaming_tx_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_rx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_rx_info.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx_rx); |
| |
| StreamReconfig reconf_media_info; |
| reconf_media_info.stream_type.type = CONTENT_TYPE_MEDIA; // media |
| reconf_media_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; // media |
| reconf_media_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_media_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_media_info.codec_qos_config_pair.push_back(codec_qos_config_media_tx_1); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream start 1 "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| |
| // switch to Gaming tx |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| |
| // switch to media tx |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| |
| // switch to Gaming tx & rx |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr, voice_streams); |
| |
| // switch to Gaming tx (2nd time) (4th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr, voice_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_gaming_tx_info.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| |
| |
| // switch to Gaming tx & rx (2nd time) (5th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_gaming_tx_rx_info.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_streams.push_back(reconf_gaming_tx_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr, voice_streams); |
| |
| // switch to media tx (6th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr, voice_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect 1 "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, media_streams); |
| sUcastClientInterface->Disconnect( bap_bd_addr, voice_streams); |
| //LOG(INFO) << __func__ << "going for stream disconnect 2 "; |
| //sUcastClientInterface->Disconnect( bap_bd_addr_2, start_streams); |
| |
| } else if(!strcmp(bap_test, "tri_streams_media_tx_voice_tx_voice_rx")) { |
| StreamConnect conn_info_media; |
| StreamConnect conn_info_gaming; |
| StreamConnect conn_info_voice_tx; |
| StreamConnect conn_info_voice_rx; |
| |
| // reconfig information |
| CodecQosConfig codec_qos_config_media_tx_1; |
| CodecQosConfig codec_qos_config_gaming_tx; |
| CodecQosConfig codec_qos_config_gaming_tx_rx; |
| CodecQosConfig codec_qos_config_gaming_rx; |
| CodecQosConfig codec_qos_config_voice_tx_rx; |
| |
| CodecQosConfig codec_qos_config_media_tx_2; |
| CodecQosConfig codec_qos_config_gaming_tx_2; |
| CodecQosConfig codec_qos_config_gaming_tx_rx_2; |
| CodecQosConfig codec_qos_config_gaming_rx_2; |
| CodecQosConfig codec_qos_config_voice_tx_rx_2; |
| |
| CISConfig cis_config_1_media_tx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 155, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_2_media_tx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 155, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_1_gaming_tx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_2_gaming_tx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_1_gaming_tx_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| CISConfig cis_config_2_gaming_tx_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_1_voice_tx_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 40, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| CISConfig cis_config_2_voice_tx_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 40, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| ASCSConfig ascs_config = { |
| .cig_id = 1, |
| .cis_id = 0, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_gaming = { |
| .cig_id = 2, |
| .cis_id = 0, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_voice = { |
| .cig_id = 3, |
| .cis_id = 0, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_2 = { |
| .cig_id = 1, |
| .cis_id = 1, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_gaming_2 = { |
| .cig_id = 2, |
| .cis_id = 1, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_voice_2 = { |
| .cig_id = 3, |
| .cis_id = 1, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_1.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_media_tx_1.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_media_tx_1.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_media_tx_1.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_media_tx_1.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_media_tx_1.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_media_tx_1.codec_config, 155); |
| codec_qos_config_media_tx_1.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_1.qos_config.cis_configs.push_back(cis_config_1_media_tx); |
| codec_qos_config_media_tx_1.qos_config.cis_configs.push_back(cis_config_2_media_tx); |
| |
| codec_qos_config_media_tx_1.qos_config.ascs_configs.push_back(ascs_config); |
| |
| codec_qos_config_media_tx_2 = codec_qos_config_media_tx_1; |
| codec_qos_config_media_tx_2.qos_config.ascs_configs.clear(); |
| codec_qos_config_media_tx_2.qos_config.ascs_configs.push_back(ascs_config_2); |
| |
| codec_qos_config_gaming_tx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_tx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_tx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_gaming_tx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_tx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_tx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx.codec_config, 100); |
| codec_qos_config_gaming_tx.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx.qos_config.cis_configs.push_back(cis_config_1_gaming_tx); |
| codec_qos_config_gaming_tx.qos_config.cis_configs.push_back(cis_config_2_gaming_tx); |
| |
| codec_qos_config_gaming_tx.qos_config.ascs_configs.push_back(ascs_config); |
| |
| |
| codec_qos_config_gaming_tx_2 = codec_qos_config_gaming_tx; |
| codec_qos_config_gaming_tx_2.qos_config.ascs_configs.clear(); |
| codec_qos_config_gaming_tx_2.qos_config.ascs_configs.push_back(ascs_config_2); |
| |
| codec_qos_config_gaming_tx_rx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_tx_rx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_tx_rx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_gaming_tx_rx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_tx_rx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_tx_rx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx_rx.codec_config, 100); |
| codec_qos_config_gaming_tx_rx.qos_config.cig_config = { |
| .cig_id = 2, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx_rx.qos_config.cis_configs.push_back(cis_config_1_gaming_tx_rx); |
| codec_qos_config_gaming_tx_rx.qos_config.cis_configs.push_back(cis_config_2_gaming_tx_rx); |
| |
| codec_qos_config_gaming_tx_rx.qos_config.ascs_configs.push_back(ascs_config_gaming); |
| |
| codec_qos_config_gaming_tx_rx_2 = codec_qos_config_gaming_tx_rx; |
| codec_qos_config_gaming_tx_rx_2.qos_config.ascs_configs.clear(); |
| codec_qos_config_gaming_tx_rx_2.qos_config.ascs_configs.push_back(ascs_config_gaming_2); |
| |
| |
| codec_qos_config_gaming_rx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_rx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_rx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_16000; |
| codec_qos_config_gaming_rx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_rx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_rx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_rx.codec_config, 40); |
| codec_qos_config_gaming_rx.qos_config.cig_config = { |
| .cig_id = 2, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_rx.qos_config.cis_configs.push_back(cis_config_1_gaming_tx_rx); |
| codec_qos_config_gaming_rx.qos_config.cis_configs.push_back(cis_config_2_gaming_tx_rx); |
| |
| codec_qos_config_gaming_rx.qos_config.ascs_configs.push_back(ascs_config_gaming); |
| |
| codec_qos_config_gaming_rx_2 = codec_qos_config_gaming_rx; |
| codec_qos_config_gaming_rx_2.qos_config.ascs_configs.clear(); |
| codec_qos_config_gaming_rx_2.qos_config.ascs_configs.push_back(ascs_config_gaming_2); |
| |
| |
| // voice tx rx |
| codec_qos_config_voice_tx_rx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_voice_tx_rx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_voice_tx_rx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_16000; |
| codec_qos_config_voice_tx_rx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_voice_tx_rx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_voice_tx_rx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_voice_tx_rx.codec_config, 40); |
| codec_qos_config_voice_tx_rx.qos_config.cig_config = { |
| .cig_id = 3, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_voice_tx_rx.qos_config.cis_configs.push_back(cis_config_1_voice_tx_rx); |
| codec_qos_config_voice_tx_rx.qos_config.cis_configs.push_back(cis_config_2_voice_tx_rx); |
| |
| codec_qos_config_voice_tx_rx.qos_config.ascs_configs.push_back(ascs_config_voice); |
| |
| codec_qos_config_voice_tx_rx_2 = codec_qos_config_voice_tx_rx; |
| codec_qos_config_voice_tx_rx_2.qos_config.ascs_configs.clear(); |
| codec_qos_config_voice_tx_rx_2.qos_config.ascs_configs.push_back(ascs_config_voice_2); |
| |
| conn_info_media.stream_type.type = CONTENT_TYPE_MEDIA; |
| conn_info_media.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| conn_info_media.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info_media.codec_qos_config_pair.push_back(codec_qos_config_media_tx_1); |
| |
| conn_info_gaming.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_gaming.stream_type.audio_context = |
| CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_gaming.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_gaming.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx_rx); |
| |
| conn_info_voice_tx.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_tx.stream_type.audio_context = |
| CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_tx.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info_voice_tx.codec_qos_config_pair.push_back(codec_qos_config_voice_tx_rx); |
| |
| conn_info_voice_rx.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_rx.stream_type.audio_context = |
| CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_rx.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_voice_rx.codec_qos_config_pair.push_back(codec_qos_config_voice_tx_rx); |
| |
| std::vector<StreamConnect> tri_streams; |
| tri_streams.push_back(conn_info_media); |
| tri_streams.push_back(conn_info_voice_tx); |
| tri_streams.push_back(conn_info_voice_rx); |
| |
| conn_info_media.codec_qos_config_pair.clear(); |
| conn_info_media.codec_qos_config_pair.push_back(codec_qos_config_media_tx_2); |
| |
| conn_info_voice_tx.codec_qos_config_pair.clear(); |
| conn_info_voice_tx.codec_qos_config_pair.push_back(codec_qos_config_voice_tx_rx_2); |
| |
| conn_info_voice_rx.codec_qos_config_pair.clear(); |
| conn_info_voice_rx.codec_qos_config_pair.push_back(codec_qos_config_voice_tx_rx_2); |
| |
| std::vector<StreamConnect> tri_streams_2; |
| tri_streams_2.push_back(conn_info_media); |
| tri_streams_2.push_back(conn_info_voice_tx); |
| tri_streams_2.push_back(conn_info_voice_rx); |
| |
| StreamType type_media = { .type = CONTENT_TYPE_MEDIA, |
| .audio_context = CONTENT_TYPE_MEDIA, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| StreamType type_voice_tx = { .type = CONTENT_TYPE_CONVERSATIONAL, |
| .audio_context = CONTENT_TYPE_CONVERSATIONAL, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| StreamType type_voice_rx = { .type = CONTENT_TYPE_CONVERSATIONAL, |
| .audio_context = CONTENT_TYPE_CONVERSATIONAL, |
| .direction = ASE_DIRECTION_SRC |
| }; |
| |
| |
| std::vector<StreamType> media_streams; |
| media_streams.push_back(type_media); |
| |
| std::vector<StreamType> gaming_tx_streams; |
| gaming_tx_streams.push_back(type_media); |
| |
| std::vector<StreamType> gaming_rx_streams; |
| gaming_rx_streams.push_back(type_voice_rx); |
| |
| std::vector<StreamType> voice_streams; |
| voice_streams.push_back(type_voice_tx); |
| voice_streams.push_back(type_voice_rx); |
| |
| std::vector<StreamType> all_three_streams; |
| all_three_streams.push_back(type_media); |
| all_three_streams.push_back(type_voice_tx); |
| all_three_streams.push_back(type_voice_rx); |
| |
| #if 0 |
| LOG(INFO) << __func__ << " going for generic test case"; |
| LOG(INFO) << __func__ << " going for connect with media tx and voice tx& rx"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, tri_streams); |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, tri_streams_2); |
| sleep(15); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect all 3 streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, all_three_streams); |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_three_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for connect all 3 streams"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, tri_streams); |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, tri_streams_2); |
| |
| sleep(15); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect all 3 streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, all_three_streams); |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_three_streams); |
| |
| sleep(5); |
| #endif |
| |
| LOG(INFO) << __func__ << " going for connect all 3 streams"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, tri_streams); |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, tri_streams_2); |
| |
| std::vector<StreamReconfig> reconf_streams; |
| std::vector<StreamReconfig> reconf_streams_2; |
| |
| StreamReconfig reconf_gaming_tx_info; |
| reconf_gaming_tx_info.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_gaming_tx); |
| |
| StreamReconfig reconf_gaming_tx_info_2; |
| reconf_gaming_tx_info_2.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_info_2.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_info_2.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_info_2.codec_qos_config_pair. |
| push_back(codec_qos_config_gaming_tx_2); |
| |
| StreamReconfig reconf_gaming_tx_rx_info; |
| reconf_gaming_tx_rx_info.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_rx_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_rx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_rx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_gaming_tx_rx); |
| |
| StreamReconfig reconf_gaming_tx_rx_info_2; |
| reconf_gaming_tx_rx_info_2.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_rx_info_2.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_rx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_rx_info_2.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_rx_info_2.codec_qos_config_pair. |
| push_back(codec_qos_config_gaming_tx_rx_2); |
| |
| StreamReconfig reconf_gaming_rx_info; |
| reconf_gaming_rx_info.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_gaming_rx_info.stream_type.audio_context = |
| CONTENT_TYPE_CONVERSATIONAL; |
| reconf_gaming_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_rx_info.stream_type.direction = ASE_DIRECTION_SRC; |
| reconf_gaming_rx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_gaming_rx); |
| |
| StreamReconfig reconf_gaming_rx_info_2; |
| reconf_gaming_rx_info_2.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_gaming_rx_info_2.stream_type.audio_context = |
| CONTENT_TYPE_CONVERSATIONAL; |
| reconf_gaming_rx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_rx_info_2.stream_type.direction = ASE_DIRECTION_SRC; |
| reconf_gaming_rx_info_2.codec_qos_config_pair. |
| push_back(codec_qos_config_gaming_rx_2); |
| |
| StreamReconfig reconf_media_info; |
| reconf_media_info.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_media_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_media_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_media_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_media_info.codec_qos_config_pair.push_back(codec_qos_config_media_tx_1); |
| |
| StreamReconfig reconf_media_info_2; |
| reconf_media_info_2.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_media_info_2.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_media_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_media_info_2.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_media_info_2.codec_qos_config_pair.push_back(codec_qos_config_media_tx_2); |
| |
| |
| StreamReconfig reconf_voice_tx_info; |
| reconf_voice_tx_info.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_tx_info.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_tx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_voice_tx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_voice_tx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_voice_tx_rx); |
| |
| StreamReconfig reconf_voice_tx_info_2; |
| reconf_voice_tx_info_2.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_tx_info_2.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_tx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_voice_tx_info_2.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_voice_tx_info_2.codec_qos_config_pair. |
| push_back(codec_qos_config_voice_tx_rx_2); |
| |
| StreamReconfig reconf_voice_rx_info; |
| reconf_voice_rx_info.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_rx_info.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_voice_rx_info.stream_type.direction = ASE_DIRECTION_SRC; |
| reconf_voice_rx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_voice_tx_rx); |
| |
| StreamReconfig reconf_voice_rx_info_2; |
| reconf_voice_rx_info_2.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_rx_info_2.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_rx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_voice_rx_info_2.stream_type.direction = ASE_DIRECTION_SRC; |
| reconf_voice_rx_info_2.codec_qos_config_pair. |
| push_back(codec_qos_config_voice_tx_rx_2); |
| |
| sleep(15); |
| LOG(INFO) << __func__ << " going for stream start 1 "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // switch to Gaming tx |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_gaming_tx_info_2); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // switch to media tx |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_media_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // switch to Gaming tx & rx |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_rx_info); |
| reconf_streams.push_back(reconf_gaming_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_gaming_tx_rx_info_2); |
| reconf_streams_2.push_back(reconf_gaming_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, gaming_tx_streams); |
| sUcastClientInterface->Start( bap_bd_addr, gaming_rx_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_tx_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_rx_streams); |
| |
| // switch to Gaming tx (2nd time) (4th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, gaming_tx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr, gaming_rx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_tx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_rx_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_gaming_tx_info.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_gaming_tx_info_2.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_streams_2.push_back(reconf_gaming_tx_info_2); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // switch to Gaming tx & rx (2nd time) (5th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_gaming_tx_rx_info.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_streams.push_back(reconf_gaming_tx_rx_info); |
| reconf_streams.push_back(reconf_gaming_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_gaming_tx_rx_info_2.reconf_type = StreamReconfigType::QOS_CONFIG; |
| reconf_streams_2.push_back(reconf_gaming_tx_rx_info_2); |
| reconf_streams_2.push_back(reconf_gaming_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, gaming_tx_streams); |
| sUcastClientInterface->Start( bap_bd_addr, gaming_rx_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_tx_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_rx_streams); |
| |
| // switch to media tx (6th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, gaming_tx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr, gaming_rx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_tx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_rx_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_media_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // switch to voice tx & Rx (7th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_voice_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| // switch to gaming tx (8th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_gaming_tx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_gaming_tx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_streams_2.push_back(reconf_gaming_tx_info_2); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| |
| // switch to voice tx & Rx (9th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_voice_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| // switch to Gaming tx & rx (10th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_gaming_tx_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_streams.push_back(reconf_gaming_tx_rx_info); |
| reconf_streams.push_back(reconf_gaming_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_gaming_tx_rx_info_2.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_streams_2.push_back(reconf_gaming_tx_rx_info_2); |
| reconf_streams_2.push_back(reconf_gaming_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, gaming_tx_streams); |
| sUcastClientInterface->Start( bap_bd_addr, gaming_rx_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_tx_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_rx_streams); |
| |
| |
| // switch to voice tx & Rx (11th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, gaming_tx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr, gaming_rx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_tx_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_rx_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_voice_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| // switch to media tx (12th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_media_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, media_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // switch to voice tx & Rx (13th) |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream stop 1 "; |
| sUcastClientInterface->Stop( bap_bd_addr, media_streams); |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| // reconfig the first stream |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| reconf_streams_2.clear(); |
| reconf_streams_2.push_back(reconf_voice_rx_info_2); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams_2); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream reconfgured .start "; |
| sUcastClientInterface->Start( bap_bd_addr, voice_streams); |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect 1 "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, all_three_streams); |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_three_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for connect all 3 streams"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, tri_streams); |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, tri_streams_2); |
| |
| sleep(15); |
| LOG(INFO) << __func__ << "going for stream disconnect all 3 streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr, all_three_streams); |
| |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_three_streams); |
| |
| sleep(5); |
| |
| } else if(!strcmp(bap_test, "stereo_headset_dual_cis")) { |
| StreamConnect conn_info_media; |
| StreamConnect conn_info_gaming; |
| StreamConnect conn_info_voice_tx; |
| StreamConnect conn_info_voice_rx; |
| StreamConnect conn_info_media_recording; |
| |
| // reconfig information |
| CodecQosConfig codec_qos_config_media_tx_1; |
| CodecQosConfig codec_qos_config_media_tx_2; |
| CodecQosConfig codec_qos_config_gaming_tx_1; |
| CodecQosConfig codec_qos_config_gaming_tx_2; |
| CodecQosConfig codec_qos_config_gaming_tx_rx; |
| CodecQosConfig codec_qos_config_voice_tx_rx; |
| CodecQosConfig codec_qos_config_voice_tx_rx_2; |
| CodecQosConfig codec_qos_config_media_rx_1; |
| CodecQosConfig codec_qos_config_media_rx_2; |
| |
| CISConfig cis_config_1_media_tx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 155, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_2_media_tx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 155, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_1_media_tx_2 = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 310, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| |
| CISConfig cis_config_1_gaming_tx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_2_gaming_tx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_1_gaming_tx_2 = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 200, |
| .max_sdu_s_to_m = 0, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| |
| CISConfig cis_config_1_gaming_tx_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| CISConfig cis_config_2_gaming_tx_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 100, |
| .max_sdu_s_to_m = 40, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_1_voice_tx_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 80, |
| .max_sdu_s_to_m = 80, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| CISConfig cis_config_2_voice_tx_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 80, |
| .max_sdu_s_to_m = 80, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x02, |
| .rtn_s_to_m = 0x02 |
| }; |
| |
| CISConfig cis_config_1_media_rx = { |
| .cis_id = 0, |
| .max_sdu_m_to_s = 0, |
| .max_sdu_s_to_m = 100, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| |
| CISConfig cis_config_2_media_rx = { |
| .cis_id = 1, |
| .max_sdu_m_to_s = 0, |
| .max_sdu_s_to_m = 100, |
| .phy_m_to_s = 0x02, |
| .phy_s_to_m = 0x02, |
| .rtn_m_to_s = 0x05, |
| .rtn_s_to_m = 0x05 |
| }; |
| ASCSConfig ascs_config_1 = { |
| .cig_id = 1, |
| .cis_id = 0, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_2 = { |
| .cig_id = 1, |
| .cis_id = 1, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_gaming_1 = { |
| .cig_id = 1, |
| .cis_id = 0, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_gaming_2 = { |
| .cig_id = 1, |
| .cis_id = 1, |
| .bi_directional = true, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_voice_1 = { |
| .cig_id = 3, |
| .cis_id = 0, |
| .bi_directional = true, |
| .presentation_delay = {0x40, 0x9C, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_voice_2 = { |
| .cig_id = 3, |
| .cis_id = 1, |
| .bi_directional = true, |
| .presentation_delay = {0x40, 0x9C, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_media_rx_1 = { |
| .cig_id = 4, |
| .cis_id = 0, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| ASCSConfig ascs_config_media_rx_2 = { |
| .cig_id = 4, |
| .cis_id = 1, |
| .bi_directional = false, |
| .presentation_delay = {0x20, 0x4E, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_1.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_media_tx_1.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_media_tx_1.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_media_tx_1.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_media_tx_1.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_media_tx_1.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_media_tx_1.codec_config, 155); |
| |
| codec_qos_config_media_tx_2 = codec_qos_config_media_tx_1; |
| UpdateOctsPerFrame(&codec_qos_config_media_tx_2.codec_config, 310); |
| |
| codec_qos_config_media_tx_1.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_1.qos_config.cis_configs.push_back(cis_config_1_media_tx); |
| codec_qos_config_media_tx_1.qos_config.cis_configs.push_back(cis_config_2_media_tx); |
| |
| codec_qos_config_media_tx_1.qos_config.ascs_configs.push_back(ascs_config_1); |
| codec_qos_config_media_tx_1.qos_config.ascs_configs.push_back(ascs_config_2); |
| |
| codec_qos_config_media_tx_2.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 1, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_tx_2.qos_config.cis_configs.push_back(cis_config_1_media_tx_2); |
| |
| codec_qos_config_media_tx_2.qos_config.ascs_configs.push_back(ascs_config_1); |
| |
| codec_qos_config_gaming_tx_1.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_tx_1.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_tx_1.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_gaming_tx_1.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_tx_1.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_tx_1.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx_1.codec_config, 100); |
| |
| codec_qos_config_gaming_tx_2 = codec_qos_config_gaming_tx_1; |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx_2.codec_config, 200); |
| |
| codec_qos_config_gaming_tx_1.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx_1.qos_config.cis_configs.push_back(cis_config_1_gaming_tx); |
| codec_qos_config_gaming_tx_1.qos_config.cis_configs.push_back(cis_config_2_gaming_tx); |
| |
| codec_qos_config_gaming_tx_1.qos_config.ascs_configs.push_back(ascs_config_gaming_1); |
| codec_qos_config_gaming_tx_1.qos_config.ascs_configs.push_back(ascs_config_gaming_2); |
| |
| codec_qos_config_gaming_tx_2.qos_config.cig_config = { |
| .cig_id = 1, |
| .cis_count = 1, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx_2.qos_config.cis_configs.push_back(cis_config_1_gaming_tx_2); |
| |
| codec_qos_config_gaming_tx_2.qos_config.ascs_configs.push_back(ascs_config_gaming_1); |
| |
| codec_qos_config_gaming_tx_rx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_gaming_tx_rx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_gaming_tx_rx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_16000; |
| codec_qos_config_gaming_tx_rx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_gaming_tx_rx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_gaming_tx_rx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_gaming_tx_rx.codec_config, 40); |
| codec_qos_config_gaming_tx_rx.qos_config.cig_config = { |
| .cig_id = 2, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_gaming_tx_rx.qos_config.cis_configs.push_back(cis_config_1_gaming_tx_rx); |
| codec_qos_config_gaming_tx_rx.qos_config.cis_configs.push_back(cis_config_2_gaming_tx_rx); |
| |
| codec_qos_config_gaming_tx_rx.qos_config.ascs_configs.push_back(ascs_config_gaming_1); |
| |
| // voice tx rx |
| codec_qos_config_voice_tx_rx.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_voice_tx_rx.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_voice_tx_rx.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_32000; |
| codec_qos_config_voice_tx_rx.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_voice_tx_rx.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_voice_tx_rx.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_voice_tx_rx.codec_config, 80); |
| codec_qos_config_voice_tx_rx.qos_config.cig_config = { |
| .cig_id = 3, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_voice_tx_rx.qos_config.cis_configs.push_back(cis_config_1_voice_tx_rx); |
| codec_qos_config_voice_tx_rx.qos_config.cis_configs.push_back(cis_config_2_voice_tx_rx); |
| |
| codec_qos_config_voice_tx_rx.qos_config.ascs_configs.push_back(ascs_config_voice_1); |
| codec_qos_config_voice_tx_rx.qos_config.ascs_configs.push_back(ascs_config_voice_2); |
| |
| |
| codec_qos_config_media_rx_1.codec_config.codec_type = |
| CodecIndex::CODEC_INDEX_SOURCE_LC3; |
| codec_qos_config_media_rx_1.codec_config.codec_priority = |
| CodecPriority::CODEC_PRIORITY_DEFAULT; |
| codec_qos_config_media_rx_1.codec_config.sample_rate = |
| CodecSampleRate::CODEC_SAMPLE_RATE_48000; |
| codec_qos_config_media_rx_1.codec_config.channel_mode = |
| CodecChannelMode::CODEC_CHANNEL_MODE_MONO; |
| //Frame_Duration |
| UpdateFrameDuration(&codec_qos_config_media_rx_1.codec_config, |
| static_cast<uint8_t>(CodecFrameDuration::FRAME_DUR_10)); |
| // LC3_Blocks_Per_SDU |
| UpdateLc3BlocksPerSdu(&codec_qos_config_media_rx_1.codec_config, 1); |
| UpdateOctsPerFrame(&codec_qos_config_media_rx_1.codec_config, 100); |
| |
| codec_qos_config_media_rx_1.qos_config.cig_config = { |
| .cig_id = 4, |
| .cis_count = 2, |
| .packing = 0x01, // interleaved |
| .framing = 0x00, // unframed |
| .max_tport_latency_m_to_s = 0x000a, |
| .max_tport_latency_s_to_m = 0x000a, |
| .sdu_interval_m_to_s = {0x10, 0x27, 0x00}, |
| .sdu_interval_s_to_m = {0x10, 0x27, 0x00} |
| }; |
| |
| codec_qos_config_media_rx_1.qos_config.cis_configs.push_back(cis_config_1_media_rx); |
| codec_qos_config_media_rx_1.qos_config.cis_configs.push_back(cis_config_2_media_rx); |
| |
| codec_qos_config_media_rx_1.qos_config.ascs_configs.push_back(ascs_config_media_rx_1); |
| codec_qos_config_media_rx_1.qos_config.ascs_configs.push_back(ascs_config_media_rx_2); |
| |
| conn_info_media.stream_type.type = CONTENT_TYPE_MEDIA; |
| conn_info_media.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| conn_info_media.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info_media.codec_qos_config_pair.push_back(codec_qos_config_media_tx_1); |
| conn_info_media.codec_qos_config_pair.push_back(codec_qos_config_media_tx_2); |
| |
| conn_info_gaming.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_gaming.stream_type.audio_context = CONTENT_TYPE_GAME; |
| conn_info_gaming.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_gaming.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx_1); |
| |
| conn_info_voice_tx.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_tx.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_tx.stream_type.direction = ASE_DIRECTION_SINK; |
| conn_info_voice_tx.codec_qos_config_pair.push_back(codec_qos_config_voice_tx_rx); |
| |
| conn_info_voice_rx.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_rx.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| conn_info_voice_rx.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_voice_rx.codec_qos_config_pair.push_back(codec_qos_config_voice_tx_rx); |
| |
| conn_info_media_recording.stream_type.type = CONTENT_TYPE_MEDIA; |
| conn_info_media_recording.stream_type.audio_context = CONTENT_TYPE_LIVE; |
| conn_info_media_recording.stream_type.direction = ASE_DIRECTION_SRC; |
| conn_info_media_recording.codec_qos_config_pair.push_back(codec_qos_config_media_rx_1); |
| |
| std::vector<StreamConnect> four_streams; |
| four_streams.push_back(conn_info_media); |
| four_streams.push_back(conn_info_media_recording); |
| four_streams.push_back(conn_info_voice_tx); |
| four_streams.push_back(conn_info_voice_rx); |
| |
| std::vector<StreamConnect> voice_conn_streams; |
| voice_conn_streams.push_back(conn_info_voice_tx); |
| voice_conn_streams.push_back(conn_info_voice_rx); |
| |
| std::vector<StreamConnect> media_conn_streams; |
| media_conn_streams.push_back(conn_info_media); |
| |
| StreamType type_media = { .type = CONTENT_TYPE_MEDIA, |
| .audio_context = CONTENT_TYPE_MEDIA, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| StreamType type_gaming_tx = { .type = CONTENT_TYPE_MEDIA, |
| .audio_context = CONTENT_TYPE_GAME, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| StreamType type_voice_tx = { .type = CONTENT_TYPE_CONVERSATIONAL, |
| .audio_context = CONTENT_TYPE_CONVERSATIONAL, |
| .direction = ASE_DIRECTION_SINK |
| }; |
| |
| StreamType type_voice_rx = { .type = CONTENT_TYPE_CONVERSATIONAL, |
| .audio_context = CONTENT_TYPE_CONVERSATIONAL, |
| .direction = ASE_DIRECTION_SRC |
| }; |
| |
| StreamType type_media_rx = { .type = CONTENT_TYPE_MEDIA, |
| .audio_context = CONTENT_TYPE_LIVE, |
| .direction = ASE_DIRECTION_SRC |
| }; |
| |
| std::vector<StreamType> media_streams; |
| media_streams.push_back(type_media); |
| |
| std::vector<StreamType> gaming_tx_streams; |
| gaming_tx_streams.push_back(type_gaming_tx); |
| |
| std::vector<StreamType> media_rx_streams; |
| media_rx_streams.push_back(type_media_rx); |
| |
| std::vector<StreamType> voice_streams; |
| voice_streams.push_back(type_voice_tx); |
| voice_streams.push_back(type_voice_rx); |
| |
| std::vector<StreamType> all_four_streams; |
| all_four_streams.push_back(type_media); |
| all_four_streams.push_back(type_voice_tx); |
| all_four_streams.push_back(type_voice_rx); |
| all_four_streams.push_back(type_media_rx); |
| |
| std::vector<StreamReconfig> reconf_streams; |
| |
| StreamReconfig reconf_media_info; |
| reconf_media_info.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_media_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_media_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_media_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_media_info.codec_qos_config_pair.push_back(codec_qos_config_media_tx_1); |
| reconf_media_info.codec_qos_config_pair.push_back(codec_qos_config_media_tx_2); |
| |
| StreamReconfig reconf_gaming_tx_info; |
| reconf_gaming_tx_info.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_info.stream_type.audio_context = CONTENT_TYPE_MEDIA; |
| reconf_gaming_tx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_gaming_tx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_gaming_tx_info.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx_1); |
| reconf_gaming_tx_info.codec_qos_config_pair.push_back(codec_qos_config_gaming_tx_2); |
| |
| StreamReconfig reconf_voice_tx_info; |
| reconf_voice_tx_info.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_tx_info.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_tx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_voice_tx_info.stream_type.direction = ASE_DIRECTION_SINK; |
| reconf_voice_tx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_voice_tx_rx); |
| |
| StreamReconfig reconf_voice_rx_info; |
| reconf_voice_rx_info.stream_type.type = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_rx_info.stream_type.audio_context = CONTENT_TYPE_CONVERSATIONAL; |
| reconf_voice_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_voice_rx_info.stream_type.direction = ASE_DIRECTION_SRC; |
| reconf_voice_rx_info.codec_qos_config_pair. |
| push_back(codec_qos_config_voice_tx_rx); |
| |
| StreamReconfig reconf_media_rx_info; |
| reconf_media_rx_info.stream_type.type = CONTENT_TYPE_MEDIA; |
| reconf_media_rx_info.stream_type.audio_context = CONTENT_TYPE_LIVE; |
| reconf_media_rx_info.reconf_type = StreamReconfigType::CODEC_CONFIG; |
| reconf_media_rx_info.stream_type.direction = ASE_DIRECTION_SRC; |
| reconf_media_rx_info.codec_qos_config_pair.push_back(codec_qos_config_media_rx_1); |
| |
| LOG(INFO) << __func__ << " going for generic test case"; |
| LOG(INFO) << __func__ << " going for connect with voice tx and rx"; |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| |
| sleep(15); |
| |
| #if 0 |
| // Recording to music switch (12) |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for music stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << "going for music stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| //sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for connect with voice tx and rx"; |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| |
| sleep(15); |
| |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for music stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| //sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| |
| LOG(INFO) << __func__ << " going for connect with voice tx and rx"; |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| |
| sleep(15); |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_tx_info); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| // Call Tx Rx to Gaming switch (4) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| sleep(5); |
| |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| // Call Tx Rx to Gaming switch (4) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| //sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| |
| LOG(INFO) << __func__ << " going for connect with voice tx and rx"; |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| sleep(15); |
| |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_tx_info); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| //sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| |
| sleep(1); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| |
| sleep(15); |
| |
| #endif |
| #if 1 |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_tx_info); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| //usleep(200000); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| // Call Tx Rx to Gaming switch (4) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| // Call Tx Rx to Gaming switch (4) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| //usleep(200000); |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| sUcastClientInterface->Connect( bap_bd_addr_2, true, four_streams); |
| #endif |
| |
| sleep(15); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| |
| // Music streaming |
| LOG(INFO) << __func__ << "going for media stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // music to gaming Tx switch (1) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for gaming stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_tx_streams); |
| |
| // Gaming Tx to music switch (2) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_tx_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for gaming stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| // music to Call Tx Rx switch (3) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_tx_info); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| // Call Tx Rx to Gaming switch (4) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for gaming stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_tx_streams); |
| |
| |
| // Gaming to Cal Audio switch (5) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_tx_streams); |
| |
| sleep(5); |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_tx_info); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| |
| // Cal Audio to music switch (6) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for music stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| |
| // music to Recording switch (7) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_rx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for recording stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_rx_streams); |
| |
| |
| // Recording to Gaming switch (8) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_rx_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_gaming_tx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for gaming stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, gaming_tx_streams); |
| |
| |
| // Gaming to Recording switch (9) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, gaming_tx_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_rx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for recording stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_rx_streams); |
| |
| |
| // Recording to Call Audio switch (10) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_rx_streams); |
| |
| sleep(5); |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_voice_tx_info); |
| reconf_streams.push_back(reconf_voice_rx_info); |
| LOG(INFO) << __func__ << " going for voice stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for voice stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, voice_streams); |
| |
| |
| // Call Audio to Recording switch (11) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, voice_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_rx_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for recording stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_rx_streams); |
| |
| |
| // Recording to music switch (12) |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_rx_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| reconf_streams.clear(); |
| reconf_streams.push_back(reconf_media_info); |
| sUcastClientInterface->Reconfigure( bap_bd_addr_2, reconf_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for music stream start "; |
| sUcastClientInterface->Start( bap_bd_addr_2, media_streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << "going for media stream stop "; |
| sUcastClientInterface->Stop( bap_bd_addr_2, media_streams); |
| |
| //sleep(5); |
| LOG(INFO) << __func__ << "going for stream disconnect voice streams "; |
| sUcastClientInterface->Disconnect( bap_bd_addr_2, all_four_streams); |
| |
| sleep(10); |
| |
| } else if(!strcmp(bap_test, "connect")) { |
| LOG(INFO) << __func__ << " going for connect test case"; |
| |
| for ( uint8_t i = 0; i < 5; i++) { |
| LOG(INFO) << __func__ << " iteration " << loghex(i); |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| usleep( i* 1000 * 1000); |
| LOG(INFO) << __func__ << " going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| } |
| } else if(!strcmp(bap_test, "release_in_streaming")) { |
| LOG(INFO) << __func__ << " going for release_in_streaming test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| |
| |
| } else if(!strcmp(bap_test, "release_in_enabling")) { |
| LOG(INFO) << __func__ << " going for release_in_enabling test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| usleep(150 *1000); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| |
| |
| } else if(!strcmp(bap_test, "release_in_disabling")) { |
| LOG(INFO) << __func__ << " going for release_in_disabling test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream stop"; |
| sUcastClientInterface->Stop( bap_bd_addr, start_streams); |
| |
| usleep(100 * 1000); |
| LOG(INFO) << __func__ << "going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| |
| } else if(!strcmp(bap_test, "disable_in_enabling")) { |
| LOG(INFO) << __func__ << " going for disable_in_enabling test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| usleep(200 * 1000); |
| LOG(INFO) << __func__ << "going for stream stop"; |
| sUcastClientInterface->Stop( bap_bd_addr, start_streams); |
| |
| } else if(!strcmp(bap_test, "disable_in_streaming")) { |
| LOG(INFO) << __func__ << " going for disable_in_streaming test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << "going for stream stop"; |
| sUcastClientInterface->Stop( bap_bd_addr, start_streams); |
| |
| } else if(!strcmp(bap_test, "release_in_codec_configured")) { |
| LOG(INFO) << __func__ << " going for release_in_codec_configured test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| usleep(2600 * 1000); |
| LOG(INFO) << __func__ << "going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| |
| } else if(!strcmp(bap_test, "release_in_qos_configured")) { |
| LOG(INFO) << __func__ << " going for release_in_qos_configured test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << "going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| |
| } else if(!strcmp(bap_test, "enable_in_qos_configured")) { |
| LOG(INFO) << __func__ << " going for enable_in_qos_configured test case"; |
| |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(10); |
| |
| LOG(INFO) << __func__ << "going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| } else if(!strcmp(bap_test, "start")) { |
| LOG(INFO) << __func__ << " going for start test case"; |
| |
| LOG(INFO) << __func__ << " going for stop while starting test case"; |
| |
| |
| for ( uint8_t i = 0; i < 5; i++) { |
| LOG(INFO) << __func__ << " iteration " << loghex(i); |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(5); |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| usleep( i* 200 * 1000); |
| LOG(INFO) << __func__ << " going for stream stop"; |
| sUcastClientInterface->Stop( bap_bd_addr, start_streams); |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| } |
| |
| LOG(INFO) << __func__ << " going for disconnect while starting test case"; |
| |
| for ( uint8_t i = 0; i < 5; i++) { |
| LOG(INFO) << __func__ << " iteration " << loghex(i); |
| LOG(INFO) << __func__ << " going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| usleep( i* 200 * 1000); |
| LOG(INFO) << __func__ << " going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| sleep(5); |
| } |
| |
| } else if(!strcmp(bap_test, "stop")) { |
| LOG(INFO) << __func__ << " going for stop test case"; |
| LOG(INFO) << __func__ << " going for connect"; |
| |
| for ( uint8_t i = 0; i < 5; i++) { |
| LOG(INFO) << __func__ << " iteration " << loghex(i); |
| LOG(INFO) << __func__ << " going for disconnect while stopping"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream stop"; |
| sUcastClientInterface->Stop( bap_bd_addr, start_streams); |
| usleep( i* 200 * 1000); |
| |
| LOG(INFO) << __func__ << " going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| } |
| |
| } else if(!strcmp(bap_test, "stop")) { |
| LOG(INFO) << __func__ << " going for stop test case"; |
| LOG(INFO) << __func__ << " going for connect"; |
| |
| for ( uint8_t i = 0; i < 5; i++) { |
| LOG(INFO) << __func__ << " iteration " << loghex(i); |
| LOG(INFO) << __func__ << " going for disconnect while stopping"; |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream start"; |
| sUcastClientInterface->Start( bap_bd_addr, start_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream stop"; |
| sUcastClientInterface->Stop( bap_bd_addr, start_streams); |
| usleep( i* 200 * 1000); |
| |
| LOG(INFO) << __func__ << " going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| } |
| } else if(!strcmp(bap_test, "reconfigure")) { |
| LOG(INFO) << __func__ << " going for reconfigure test case"; |
| LOG(INFO) << __func__ << " going for connect"; |
| |
| sUcastClientInterface->Connect( bap_bd_addr, true, streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream codec reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream qos reconfig"; |
| sUcastClientInterface->Reconfigure( bap_bd_addr, reconf_qos_streams); |
| |
| sleep(5); |
| |
| LOG(INFO) << __func__ << " going for stream disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr, start_streams); |
| |
| } |
| |
| LOG(INFO) << __func__ << " Test completed"; |
| #if 0 |
| sleep(2); |
| LOG(INFO) << __func__ << "going for connect"; |
| sUcastClientInterface->Connect( bap_bd_addr); |
| sleep(7); |
| LOG(INFO) << __func__ << "going for discovery"; |
| sUcastClientInterface->StartDiscovery( bap_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for getAudiocontexts"; |
| sUcastClientInterface->GetAvailableAudioContexts( bap_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for disconnect"; |
| sUcastClientInterface->Disconnect( bap_bd_addr); |
| sleep(1); |
| sUcastClientInterface->Cleanup(); |
| sleep(1); |
| sUcastClientInterface->Init(&sUcastClientCallbacks); |
| sleep(1); |
| LOG(INFO) << __func__ << "going for connect 2 "; |
| sUcastClientInterface->Connect( bap_bd_addr); |
| sleep(7); |
| LOG(INFO) << __func__ << "going for discovery 2"; |
| sUcastClientInterface->StartDiscovery( bap_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for getAudiocontexts 2"; |
| sUcastClientInterface->GetAvailableAudioContexts( bap_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for disconnect 2"; |
| sUcastClientInterface->Disconnect( bap_bd_addr); |
| sleep(1); |
| sUcastClientInterface->Cleanup(); |
| #endif |
| } |
| |
| bool test_bap_uclient () { |
| RawAddress::FromString("00:02:5b:00:ff:00", bap_bd_addr); |
| test_thread = thread_new("test_bap_uclient"); |
| LOG(INFO) << __func__ << "going for test setup"; |
| thread_post(test_thread, event_test_bap_uclient, NULL); |
| return true; |
| } |
| |
| // PACS related test code |
| using bluetooth::bap::pacs::PacsClientInterface; |
| using bluetooth::bap::pacs::PacsClientCallbacks; |
| |
| static PacsClientInterface* sPacsClientInterface = nullptr; |
| static uint16_t pacs_client_id = 0; |
| static RawAddress pac_bd_addr; |
| |
| class PacsClientCallbacksImpl : public PacsClientCallbacks { |
| public: |
| ~PacsClientCallbacksImpl() = default; |
| void OnInitialized(int status, |
| int client_id) override { |
| LOG(WARNING) << __func__ << client_id; |
| pacs_client_id = client_id; |
| } |
| void OnConnectionState(const RawAddress& bd_addr, |
| ConnectionState state) override { |
| LOG(WARNING) << __func__; |
| if(state == ConnectionState::CONNECTED) { |
| LOG(WARNING) << __func__ << "connected"; |
| } else if(state == ConnectionState::DISCONNECTED) { |
| LOG(WARNING) << __func__ << "Disconnected"; |
| } |
| |
| } |
| void OnAudioContextAvailable(const RawAddress& bd_addr, |
| uint32_t available_contexts) override { |
| LOG(INFO) << __func__; |
| } |
| void OnSearchComplete(int status, const RawAddress& address, |
| std::vector<bluetooth::bap::pacs::CodecConfig> sink_pac_records, |
| std::vector<bluetooth::bap::pacs::CodecConfig> src_pac_records, |
| uint32_t sink_locations, |
| uint32_t src_locations, |
| uint32_t available_contexts, |
| uint32_t supported_contexts) override { |
| LOG(WARNING) << __func__; |
| } |
| }; |
| |
| static PacsClientCallbacksImpl sPacsClientCallbacks; |
| |
| static void event_test_pacs(UNUSED_ATTR void* context) { |
| sPacsClientInterface = btif_pacs_client_get_interface(); |
| sPacsClientInterface->Init(&sPacsClientCallbacks); |
| sleep(1); |
| LOG(INFO) << __func__ << "going for connect"; |
| sPacsClientInterface->Connect(pacs_client_id, pac_bd_addr); |
| sleep(7); |
| LOG(INFO) << __func__ << "going for discovery"; |
| sPacsClientInterface->StartDiscovery(pacs_client_id, pac_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for getAudiocontexts"; |
| sPacsClientInterface->GetAvailableAudioContexts(pacs_client_id, pac_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for disconnect"; |
| sPacsClientInterface->Disconnect(pacs_client_id, pac_bd_addr); |
| |
| sleep(2); |
| LOG(INFO) << __func__ << "going for connect"; |
| sPacsClientInterface->Connect(pacs_client_id, pac_bd_addr); |
| sleep(7); |
| LOG(INFO) << __func__ << "going for discovery"; |
| sPacsClientInterface->StartDiscovery(pacs_client_id, pac_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for getAudiocontexts"; |
| sPacsClientInterface->GetAvailableAudioContexts(pacs_client_id, pac_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for disconnect"; |
| sPacsClientInterface->Disconnect(pacs_client_id, pac_bd_addr); |
| |
| sleep(1); |
| sPacsClientInterface->Cleanup(pacs_client_id); |
| |
| sleep(1); |
| |
| sPacsClientInterface->Init(&sPacsClientCallbacks); |
| sleep(1); |
| LOG(INFO) << __func__ << "going for connect 2 "; |
| sPacsClientInterface->Connect(pacs_client_id, pac_bd_addr); |
| sleep(7); |
| LOG(INFO) << __func__ << "going for discovery 2"; |
| sPacsClientInterface->StartDiscovery(pacs_client_id, pac_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for getAudiocontexts 2"; |
| sPacsClientInterface->GetAvailableAudioContexts(pacs_client_id, pac_bd_addr); |
| sleep(2); |
| LOG(INFO) << __func__ << "going for disconnect 2"; |
| sPacsClientInterface->Disconnect(pacs_client_id, pac_bd_addr); |
| |
| sleep(1); |
| sPacsClientInterface->Cleanup(pacs_client_id); |
| |
| } |
| |
| bool test_pacs (RawAddress& bd_addr) { |
| |
| test_thread = thread_new("test_pacs"); |
| pac_bd_addr = bd_addr; |
| thread_post(test_thread, event_test_pacs, NULL); |
| return true; |
| } |
