zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleans up code related to legacy pre-pacing fec generation.

Browse Source 
Bug: webrtc:11340
Change-Id: If3493db9fafdd3ad041f78999e304c8714be517f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/186562
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32349}
This commit is contained in:
Erik Språng
2020-10-05 14:20:51 +02:00
committed by Commit Bot
parent 0d1b044db8
commit b6477858ac
9 changed files with 27 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -143,10 +143,8 @@ MATCHER_P(SameRtcEventTypeAs, value, "") {
}
struct TestConfig {
TestConfig(bool with_overhead, bool deferred_fec)
: with_overhead(with_overhead), deferred_fec(deferred_fec) {}
explicit TestConfig(bool with_overhead) : with_overhead(with_overhead) {}
bool with_overhead = false;
bool deferred_fec = false;
};
class MockRtpPacketPacer : public RtpPacketSender {
@ -283,12 +281,10 @@ class FieldTrialConfig : public WebRtcKeyValueConfig {
public:
FieldTrialConfig()
: overhead_enabled_(false),
deferred_fec_(false),
max_padding_factor_(1200) {}
~FieldTrialConfig() override {}
void SetOverHeadEnabled(bool enabled) { overhead_enabled_ = enabled; }
void UseDeferredFec(bool enabled) { deferred_fec_ = enabled; }
void SetMaxPaddingFactor(double factor) { max_padding_factor_ = factor; }
std::string Lookup(absl::string_view key) const override {
@ -299,15 +295,12 @@ class FieldTrialConfig : public WebRtcKeyValueConfig {
return ssb.str();
} else if (key == "WebRTC-SendSideBwe-WithOverhead") {
return overhead_enabled_ ? "Enabled" : "Disabled";
} else if (key == "WebRTC-DeferredFecGeneration") {
return deferred_fec_ ? "Enabled" : "Disabled";
}
return "";
}
private:
bool overhead_enabled_;
bool deferred_fec_;
double max_padding_factor_;
};
@ -329,7 +322,6 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
clock_),
kMarkerBit(true) {
field_trials_.SetOverHeadEnabled(GetParam().with_overhead);
field_trials_.UseDeferredFec(GetParam().deferred_fec);
}
void SetUp() override { SetUpRtpSender(true, false, false); }
@ -1339,9 +1331,6 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
RTPSenderVideo::Config video_config;
video_config.clock = clock_;
video_config.rtp_sender = rtp_sender();
if (!GetParam().deferred_fec) {
video_config.fec_generator = &flexfec_sender;
}
video_config.fec_type = flexfec_sender.GetFecType();
video_config.fec_overhead_bytes = flexfec_sender.MaxPacketOverhead();
video_config.fec_type = flexfec_sender.GetFecType();
@ -1369,7 +1358,7 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
EXPECT_EQ(packet->Ssrc(), kSsrc);
EXPECT_EQ(packet->SequenceNumber(), kSeqNum);
media_packet = std::move(packet);
if (GetParam().deferred_fec) {
// Simulate RtpSenderEgress adding packet to fec generator.
flexfec_sender.AddPacketAndGenerateFec(*media_packet);
auto fec_packets = flexfec_sender.GetFecPackets();
@ -1378,7 +1367,6 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
EXPECT_EQ(fec_packet->packet_type(),
RtpPacketMediaType::kForwardErrorCorrection);
EXPECT_EQ(fec_packet->Ssrc(), kFlexFecSsrc);
}
} else {
EXPECT_EQ(packet->packet_type(),
RtpPacketMediaType::kForwardErrorCorrection);
@ -1440,9 +1428,6 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
RTPSenderVideo::Config video_config;
video_config.clock = clock_;
video_config.rtp_sender = rtp_sender();
if (!GetParam().deferred_fec) {
video_config.fec_generator = &flexfec_sender;
}
video_config.fec_type = flexfec_sender.GetFecType();
video_config.fec_overhead_bytes = flexfec_sender_.MaxPacketOverhead();
video_config.field_trials = &field_trials;
@ -1453,11 +1438,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
params.fec_rate = 15;
params.max_fec_frames = 1;
params.fec_mask_type = kFecMaskRandom;
if (GetParam().deferred_fec) {
rtp_egress()->SetFecProtectionParameters(params, params);
} else {
flexfec_sender.SetProtectionParameters(params, params);
}
rtp_egress()->SetFecProtectionParameters(params, params);
EXPECT_CALL(mock_rtc_event_log_,
LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
@ -1768,9 +1749,6 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
RTPSenderVideo::Config video_config;
video_config.clock = clock_;
video_config.rtp_sender = rtp_sender();
if (!GetParam().deferred_fec) {
video_config.fec_generator = &flexfec_sender;
}
video_config.fec_type = flexfec_sender.GetFecType();
video_config.fec_overhead_bytes = flexfec_sender.MaxPacketOverhead();
video_config.field_trials = &field_trials;
@ -1780,11 +1758,7 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
params.fec_rate = 15;
params.max_fec_frames = 1;
params.fec_mask_type = kFecMaskRandom;
if (GetParam().deferred_fec) {
rtp_egress()->SetFecProtectionParameters(params, params);
} else {
flexfec_sender.SetProtectionParameters(params, params);
}
rtp_egress()->SetFecProtectionParameters(params, params);
constexpr size_t kNumMediaPackets = 10;
constexpr size_t kNumFecPackets = kNumMediaPackets;
@ -1806,7 +1780,6 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
constexpr size_t kPacketLength = kRtpHeaderLength + kFlexfecHeaderLength +
kGenericCodecHeaderLength + kPayloadLength;
if (GetParam().deferred_fec) {
EXPECT_NEAR(
kNumFecPackets * kPacketLength * 8 /
(kNumFecPackets * kTimeBetweenPacketsMs / 1000.0f),
@ -1814,11 +1787,6 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
->GetSendRates()[RtpPacketMediaType::kForwardErrorCorrection]
.bps<double>(),
500);
} else {
EXPECT_NEAR(kNumFecPackets * kPacketLength * 8 /
(kNumFecPackets * kTimeBetweenPacketsMs / 1000.0f),
flexfec_sender.CurrentFecRate().bps<double>(), 500);
}
}
TEST_P(RtpSenderTest, BitrateCallbacks) {
@ -1970,9 +1938,6 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) {
video_config.rtp_sender = rtp_sender();
video_config.field_trials = &field_trials_;
video_config.red_payload_type = kRedPayloadType;
if (!GetParam().deferred_fec) {
video_config.fec_generator = &ulpfec_generator;
}
video_config.fec_type = ulpfec_generator.GetFecType();
video_config.fec_overhead_bytes = ulpfec_generator.MaxPacketOverhead();
RTPSenderVideo rtp_sender_video(video_config);
@ -1989,11 +1954,7 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) {
fec_params.fec_mask_type = kFecMaskRandom;
fec_params.fec_rate = 1;
fec_params.max_fec_frames = 1;
if (GetParam().deferred_fec) {
rtp_egress()->SetFecProtectionParameters(fec_params, fec_params);
} else {
ulpfec_generator.SetProtectionParameters(fec_params, fec_params);
}
rtp_egress()->SetFecProtectionParameters(fec_params, fec_params);
video_header.frame_type = VideoFrameType::kVideoFrameDelta;
ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321,
payload, video_header,
@ -2823,11 +2784,6 @@ TEST_P(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
}
TEST_P(RtpSenderTest, DoesntFecProtectRetransmissions) {
if (!GetParam().deferred_fec) {
// This test make sense only for deferred fec generation.
return;
}
// Set up retranmission without RTX, so that a plain copy of the old packet is
// re-sent instead.
const int64_t kRtt = 10;
@ -2864,16 +2820,12 @@ TEST_P(RtpSenderTest, DoesntFecProtectRetransmissions) {
INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
RtpSenderTest,
::testing::Values(TestConfig{false, false},
TestConfig{false, true},
TestConfig{true, false},
TestConfig{false, false}));
::testing::Values(TestConfig{false},
TestConfig{true}));
INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
RtpSenderTestWithoutPacer,
::testing::Values(TestConfig{false, false},
TestConfig{false, true},
TestConfig{true, false},
TestConfig{false, false}));
::testing::Values(TestConfig{false},
TestConfig{true}));
} // namespace webrtc