admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[PCLF] Remove deprecated APIs

Browse Source 
Bug: b/213863770
Change-Id: I69c0a9983831b7d59e24dc800a5f0d198cb40747
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/251820
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36017}
This commit is contained in:
Artem Titov 2022-02-16 13:44:25 +01:00 committed by WebRTC LUCI CQ
parent e6106102f8
commit df2b264ac0
7 changed files with 16 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
api/test/peerconnection_quality_test_fixture.h
View File

@ -446,21 +446,6 @@ class PeerConnectionE2EQualityTestFixture {
// If set to true peers will be able to use Flex FEC, otherwise they won't
// be able to negotiate it even if it's enabled on per peer level.
bool enable_flex_fec_support = false;
// TODO(titovartem): delete this field.
// Deprecated. Use `PeerConfigurer::SetUseUlpFEC`.
bool use_ulp_fec = false;
// TODO(titovartem): delete this field.
// Deprecated. Use `PeerConfigurer::SetUseFlexFEC`.
bool use_flex_fec = false;
// TODO(titovartem): delete this field.
// Deprecated. Use `PeerConfigurer::SetVideoEncoderBitrateMultiplier`.
// Specifies how much video encoder target bitrate should be different than
// target bitrate, provided by WebRTC stack. Must be greater then 0. Can be
// used to emulate overshooting of video encoders. This multiplier will
// be applied for all video encoder on both sides for all layers. Bitrate
// estimated by WebRTC stack will be multiplied on this multiplier and then
// provided into VideoEncoder::SetRates(...).
double video_encoder_bitrate_multiplier = 1.0;
// If true will set conference mode in SDP media section for all video
// tracks for all peers.
bool use_conference_mode = false;

136
test/pc/e2e/peer_configurer.cc
View File

@ -178,141 +178,5 @@ void PeerParamsPreprocessor::ValidateParams(const PeerConfigurerImpl& peer) {
}
}
void SetDefaultValuesForMissingParams(
RunParams* run_params,
std::vector<std::unique_ptr<PeerConfigurerImpl>>* peers) {
DefaultNamesProvider peer_names_provider("peer_", kDefaultNames);
for (size_t i = 0; i < peers->size(); ++i) {
auto* peer = peers->at(i).get();
auto* p = peer->params();
peer_names_provider.MaybeSetName(p->name);
DefaultNamesProvider video_stream_names_provider(
*p->name + "_auto_video_stream_label_");
for (VideoConfig& video_config : p->video_configs) {
video_stream_names_provider.MaybeSetName(video_config.stream_label);
}
if (p->audio_config) {
DefaultNamesProvider audio_stream_names_provider(
*p->name + "_auto_audio_stream_label_");
audio_stream_names_provider.MaybeSetName(p->audio_config->stream_label);
}
if (p->video_codecs.empty()) {
p->video_codecs.push_back(
PeerConnectionE2EQualityTestFixture::VideoCodecConfig(
cricket::kVp8CodecName));
}
}
}
void ValidateParams(
const RunParams& run_params,
const std::vector<std::unique_ptr<PeerConfigurerImpl>>& peers) {
RTC_CHECK_GT(run_params.video_encoder_bitrate_multiplier, 0.0);
std::set<std::string> peer_names;
std::set<std::string> video_labels;
std::set<std::string> audio_labels;
std::set<std::string> video_sync_groups;
std::set<std::string> audio_sync_groups;
int media_streams_count = 0;
for (size_t i = 0; i < peers.size(); ++i) {
Params* p = peers[i]->params();
// Each peer should at least support 1 video codec.
RTC_CHECK_GE(p->video_codecs.size(), 1);
{
RTC_CHECK(p->name);
bool inserted = peer_names.insert(p->name.value()).second;
RTC_CHECK(inserted) << "Duplicate name=" << p->name.value();
}
if (p->audio_config) {
media_streams_count++;
}
media_streams_count += p->video_configs.size();
// Validate that all video stream labels are unique and sync groups are
// valid.
for (const VideoConfig& video_config : p->video_configs) {
RTC_CHECK(video_config.stream_label);
bool inserted =
video_labels.insert(video_config.stream_label.value()).second;
RTC_CHECK(inserted) << "Duplicate video_config.stream_label="
<< video_config.stream_label.value();
if (video_config.input_dump_file_name.has_value()) {
RTC_CHECK_GT(video_config.input_dump_sampling_modulo, 0)
<< "video_config.input_dump_sampling_modulo must be greater than 0";
}
if (video_config.output_dump_file_name.has_value()) {
RTC_CHECK_GT(video_config.output_dump_sampling_modulo, 0)
<< "video_config.input_dump_sampling_modulo must be greater than 0";
}
// TODO(bugs.webrtc.org/4762): remove this check after synchronization of
// more than two streams is supported.
if (video_config.sync_group.has_value()) {
bool sync_group_inserted =
video_sync_groups.insert(video_config.sync_group.value()).second;
RTC_CHECK(sync_group_inserted)
<< "Sync group shouldn't consist of more than two streams (one "
"video and one audio). Duplicate video_config.sync_group="
<< video_config.sync_group.value();
}
if (video_config.simulcast_config) {
if (video_config.simulcast_config->target_spatial_index) {
RTC_CHECK_GE(*video_config.simulcast_config->target_spatial_index, 0);
RTC_CHECK_LT(*video_config.simulcast_config->target_spatial_index,
video_config.simulcast_config->simulcast_streams_count);
}
RTC_CHECK(!video_config.max_encode_bitrate_bps)
<< "Setting max encode bitrate is not implemented for simulcast.";
RTC_CHECK(!video_config.min_encode_bitrate_bps)
<< "Setting min encode bitrate is not implemented for simulcast.";
if (p->video_codecs[0].name == cricket::kVp8CodecName &&
!video_config.simulcast_config->encoding_params.empty()) {
RTC_CHECK_EQ(video_config.simulcast_config->simulcast_streams_count,
video_config.simulcast_config->encoding_params.size())
<< "|encoding_params| have to be specified for each simulcast "
<< "stream in |simulcast_config|.";
}
}
}
if (p->audio_config) {
bool inserted =
audio_labels.insert(p->audio_config->stream_label.value()).second;
RTC_CHECK(inserted) << "Duplicate audio_config.stream_label="
<< p->audio_config->stream_label.value();
// TODO(bugs.webrtc.org/4762): remove this check after synchronization of
// more than two streams is supported.
if (p->audio_config->sync_group.has_value()) {
bool sync_group_inserted =
audio_sync_groups.insert(p->audio_config->sync_group.value())
.second;
RTC_CHECK(sync_group_inserted)
<< "Sync group shouldn't consist of more than two streams (one "
"video and one audio). Duplicate audio_config.sync_group="
<< p->audio_config->sync_group.value();
}
// Check that if mode input file name specified only if mode is kFile.
if (p->audio_config.value().mode == AudioConfig::Mode::kGenerated) {
RTC_CHECK(!p->audio_config.value().input_file_name);
}
if (p->audio_config.value().mode == AudioConfig::Mode::kFile) {
RTC_CHECK(p->audio_config.value().input_file_name);
RTC_CHECK(
test::FileExists(p->audio_config.value().input_file_name.value()))
<< p->audio_config.value().input_file_name.value()
<< " doesn't exist";
}
}
}
RTC_CHECK_GT(media_streams_count, 0) << "No media in the call.";
}
} // namespace webrtc_pc_e2e
} // namespace webrtc

18
test/pc/e2e/peer_configurer.h
View File

@ -280,24 +280,6 @@ class PeerParamsPreprocessor {
int media_streams_count = 0;
};
// TODO(titovartem): delete this method.
// Deprecated. Use `PeerParamsPreprocessor`.
// Set missing params to default values if it is required:
// * Generate video stream labels if some of them are missing
// * Generate audio stream labels if some of them are missing
// * Set video source generation mode if it is not specified
// * Video codecs under test
void SetDefaultValuesForMissingParams(
PeerConnectionE2EQualityTestFixture::RunParams* run_params,
std::vector<std::unique_ptr<PeerConfigurerImpl>>* peers);
// TODO(titovartem): delete this method.
// Deprecated. Use `PeerParamsPreprocessor`.
// Validate peer's parameters, also ensure uniqueness of all video stream
// labels.
void ValidateParams(
const PeerConnectionE2EQualityTestFixture::RunParams& run_params,
const std::vector<std::unique_ptr<PeerConfigurerImpl>>& peers);
} // namespace webrtc_pc_e2e
} // namespace webrtc

7
test/pc/e2e/peer_connection_quality_test.cc
View File

@ -181,8 +181,11 @@ PeerConnectionE2EQualityTest::PeerHandle* PeerConnectionE2EQualityTest::AddPeer(
}
void PeerConnectionE2EQualityTest::Run(RunParams run_params) {
SetDefaultValuesForMissingParams(&run_params, &peer_configurations_);
ValidateParams(run_params, peer_configurations_);
webrtc::webrtc_pc_e2e::PeerParamsPreprocessor params_preprocessor;
for (auto& peer_configuration : peer_configurations_) {
params_preprocessor.SetDefaultValuesForMissingParams(*peer_configuration);
params_preprocessor.ValidateParams(*peer_configuration);
}
ValidateP2PSimulcastParams(peer_configurations_);
RTC_CHECK_EQ(peer_configurations_.size(), 2)
<< "Only peer to peer calls are allowed, please add 2 peers";

16
test/pc/e2e/test_peer_factory.cc
View File

@ -302,20 +302,6 @@ std::unique_ptr<TestPeer> TestPeerFactory::CreateTestPeer(
absl::optional<RemotePeerAudioConfig> remote_audio_config,
absl::optional<PeerConnectionE2EQualityTestFixture::EchoEmulationConfig>
echo_emulation_config) {
double bitrate_multiplier =
configurer->params()->video_encoder_bitrate_multiplier;
return CreateTestPeer(std::move(configurer), std::move(observer),
remote_audio_config, bitrate_multiplier,
echo_emulation_config);
}
std::unique_ptr<TestPeer> TestPeerFactory::CreateTestPeer(
std::unique_ptr<PeerConfigurerImpl> configurer,
std::unique_ptr<MockPeerConnectionObserver> observer,
absl::optional<RemotePeerAudioConfig> remote_audio_config,
double bitrate_multiplier,
absl::optional<PeerConnectionE2EQualityTestFixture::EchoEmulationConfig>
echo_emulation_config) {
std::unique_ptr<InjectableComponents> components =
configurer->ReleaseComponents();
std::unique_ptr<Params> params = configurer->ReleaseParams();
@ -339,7 +325,7 @@ std::unique_ptr<TestPeer> TestPeerFactory::CreateTestPeer(
params->audio_config, remote_audio_config, echo_emulation_config,
components->pcf_dependencies->task_queue_factory.get());
WrapVideoEncoderFactory(
params->name.value(), bitrate_multiplier,
params->name.value(), params->video_encoder_bitrate_multiplier,
CalculateRequiredSpatialIndexPerStream(params->video_configs),
components->pcf_dependencies.get(), video_analyzer_helper_);
WrapVideoDecoderFactory(params->name.value(),

8
test/pc/e2e/test_peer_factory.h
View File

@ -72,14 +72,6 @@ class TestPeerFactory {
absl::optional<RemotePeerAudioConfig> remote_audio_config,
absl::optional<PeerConnectionE2EQualityTestFixture::EchoEmulationConfig>
echo_emulation_config);
// Deprecated. Use the one above.
std::unique_ptr<TestPeer> CreateTestPeer(
std::unique_ptr<PeerConfigurerImpl> configurer,
std::unique_ptr<MockPeerConnectionObserver> observer,
absl::optional<RemotePeerAudioConfig> remote_audio_config,
double bitrate_multiplier,
absl::optional<PeerConnectionE2EQualityTestFixture::EchoEmulationConfig>
echo_emulation_config);
private:
rtc::Thread* signaling_thread_;

32
video/pc_full_stack_tests.cc
View File

@ -558,10 +558,7 @@ TEST(PCFullStackTest, Pc_Foreman_Cif_Net_Delay_0_0_Plr_0_H264) {
[](PeerConfigurer* bob) {
bob->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
});
RunParams run_params(TimeDelta::Seconds(kTestDurationSec));
run_params.use_flex_fec = false;
run_params.use_ulp_fec = false;
fixture->Run(std::move(run_params));
fixture->Run(RunParams(TimeDelta::Seconds(kTestDurationSec)));
}
TEST(PCFullStackTest, Pc_Foreman_Cif_30kbps_Net_Delay_0_0_Plr_0_H264) {
@ -589,10 +586,7 @@ TEST(PCFullStackTest, Pc_Foreman_Cif_30kbps_Net_Delay_0_0_Plr_0_H264) {
[](PeerConfigurer* bob) {
bob->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
});
RunParams run_params(TimeDelta::Seconds(kTestDurationSec));
run_params.use_flex_fec = false;
run_params.use_ulp_fec = false;
fixture->Run(std::move(run_params));
fixture->Run(RunParams(TimeDelta::Seconds(kTestDurationSec)));
}
TEST(PCGenericDescriptorTest,
@ -617,10 +611,7 @@ TEST(PCGenericDescriptorTest,
[](PeerConfigurer* bob) {
bob->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
});
RunParams run_params(TimeDelta::Seconds(kTestDurationSec));
run_params.use_flex_fec = false;
run_params.use_ulp_fec = false;
fixture->Run(std::move(run_params));
fixture->Run(RunParams(TimeDelta::Seconds(kTestDurationSec)));
}
TEST(PCFullStackTest, Pc_Foreman_Cif_Delay_50_0_Plr_5_H264_Sps_Pps_Idr) {
@ -647,10 +638,7 @@ TEST(PCFullStackTest, Pc_Foreman_Cif_Delay_50_0_Plr_5_H264_Sps_Pps_Idr) {
[](PeerConfigurer* bob) {
bob->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
});
RunParams run_params(TimeDelta::Seconds(kTestDurationSec));
run_params.use_flex_fec = false;
run_params.use_ulp_fec = false;
fixture->Run(std::move(run_params));
fixture->Run(RunParams(TimeDelta::Seconds(kTestDurationSec)));
}
TEST(PCFullStackTest, Pc_Foreman_Cif_Delay_50_0_Plr_5_H264_Flexfec) {
@ -670,13 +658,14 @@ TEST(PCFullStackTest, Pc_Foreman_Cif_Delay_50_0_Plr_5_H264_Flexfec) {
video, ClipNameToClipPath("foreman_cif"));
alice->AddVideoConfig(std::move(video), std::move(frame_generator));
alice->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
alice->SetUseFlexFEC(true);
},
[](PeerConfigurer* bob) {
bob->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
bob->SetUseFlexFEC(true);
});
RunParams run_params(TimeDelta::Seconds(kTestDurationSec));
run_params.use_flex_fec = true;
run_params.use_ulp_fec = false;
run_params.enable_flex_fec_support = true;
fixture->Run(std::move(run_params));
}
@ -699,14 +688,13 @@ TEST(PCFullStackTest, DISABLED_Pc_Foreman_Cif_Delay_50_0_Plr_5_H264_Ulpfec) {
video, ClipNameToClipPath("foreman_cif"));
alice->AddVideoConfig(std::move(video), std::move(frame_generator));
alice->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
alice->SetUseUlpFEC(true);
},
[](PeerConfigurer* bob) {
bob->SetVideoCodecs({VideoCodecConfig(cricket::kH264CodecName)});
bob->SetUseUlpFEC(true);
});
RunParams run_params(TimeDelta::Seconds(kTestDurationSec));
run_params.use_flex_fec = false;
run_params.use_ulp_fec = true;
fixture->Run(std::move(run_params));
fixture->Run(RunParams(TimeDelta::Seconds(kTestDurationSec)));
}
#endif // defined(WEBRTC_USE_H264)