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

Simplify RtpSenderTest.SendFlexfecPackets and move to RtpRtcp-level.

Browse Source 
Bug: webrtc:11340
Change-Id: Ic83217994c447e490a6ac9cf04ceafa3dc009af7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/219461
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34051}
This commit is contained in:
Erik Språng
2021-05-19 11:12:39 +02:00
committed by WebRTC LUCI CQ
parent 3de4067092
commit f6be1b22d6
2 changed files with 56 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
View File

@ -228,6 +228,10 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
transport_.header_extensions_.RegisterByUri(id, uri);
transport_.last_packet_.IdentifyExtensions(transport_.header_extensions_);
}
void ReinintWithFec(VideoFecGenerator* fec_generator) {
fec_generator_ = fec_generator;
CreateModuleImpl();
}
private:
void CreateModuleImpl() {
@ -244,6 +248,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
config.non_sender_rtt_measurement = true;
config.field_trials = &trials_;
config.send_packet_observer = this;
config.fec_generator = fec_generator_;
impl_.reset(new ModuleRtpRtcpImpl2(config));
impl_->SetRemoteSSRC(is_sender_ ? kReceiverSsrc : kSenderSsrc);
@ -253,6 +258,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
TimeController* const time_controller_;
std::map<uint32_t, RtcpPacketTypeCounter> counter_map_;
absl::optional<SentPacket> last_sent_packet_;
VideoFecGenerator* fec_generator_ = nullptr;
};
} // namespace
@ -293,6 +299,23 @@ class RtpRtcpImpl2Test : public ::testing::TestWithParam<TestConfig> {
time_controller_.AdvanceTime(TimeDelta::Millis(milliseconds));
}
void ReinitWithFec(VideoFecGenerator* fec_generator) {
sender_.ReinintWithFec(fec_generator);
EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
sender_.impl_->SetSendingMediaStatus(true);
sender_.impl_->SetSequenceNumber(kSequenceNumber);
sender_.impl_->SetStorePacketsStatus(true, 100);
receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
RTPSenderVideo::Config video_config;
video_config.clock = time_controller_.GetClock();
video_config.rtp_sender = sender_.impl_->RtpSender();
video_config.field_trials = &field_trials_;
video_config.fec_overhead_bytes = fec_generator->MaxPacketOverhead();
video_config.fec_type = fec_generator->GetFecType();
sender_video_ = std::make_unique<RTPSenderVideo>(video_config);
}
GlobalSimulatedTimeController time_controller_;
FieldTrialConfig field_trials_;
RtpRtcpModule sender_;
@ -962,6 +985,39 @@ TEST_P(RtpRtcpImpl2Test, PropagatesSentPacketInfo) {
Field(&RtpRtcpModule::SentPacket::ssrc, Eq(kSenderSsrc)))));
}
TEST_P(RtpRtcpImpl2Test, GeneratesFlexfec) {
constexpr int kFlexfecPayloadType = 118;
constexpr uint32_t kFlexfecSsrc = 17;
const char kNoMid[] = "";
const std::vector<RtpExtension> kNoRtpExtensions;
const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
// Make sure FlexFec sequence numbers start at a different point than media.
const uint16_t fec_start_seq = sender_.impl_->SequenceNumber() + 100;
RtpState start_state;
start_state.sequence_number = fec_start_seq;
FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kSenderSsrc,
kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
&start_state, time_controller_.GetClock());
ReinitWithFec(&flexfec_sender);
// Parameters selected to generate a single FEC packet per media packet.
FecProtectionParams params;
params.fec_rate = 15;
params.max_fec_frames = 1;
params.fec_mask_type = kFecMaskRandom;
sender_.impl_->SetFecProtectionParams(params, params);
// Send a one packet frame, expect one media packet and one FEC packet.
EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
ASSERT_THAT(sender_.transport_.rtp_packets_sent_, Eq(2));
const RtpPacketReceived& fec_packet = sender_.last_packet();
EXPECT_EQ(fec_packet.SequenceNumber(), fec_start_seq);
EXPECT_EQ(fec_packet.Ssrc(), kFlexfecSsrc);
EXPECT_EQ(fec_packet.PayloadType(), kFlexfecPayloadType);
}
INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
RtpRtcpImpl2Test,
::testing::Values(TestConfig{false},

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

@ -739,166 +739,6 @@ TEST_P(RtpSenderTest, KeepsTimestampsOnPayloadPadding) {
Pointee(Property(&RtpPacketToSend::capture_time_ms, start_time)))));
}
TEST_P(RtpSenderTest, SendFlexfecPackets) {
constexpr uint32_t kTimestamp = 1234;
constexpr int kMediaPayloadType = 127;
constexpr VideoCodecType kCodecType = VideoCodecType::kVideoCodecGeneric;
constexpr int kFlexfecPayloadType = 118;
const std::vector<RtpExtension> kNoRtpExtensions;
const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid,
kNoRtpExtensions, kNoRtpExtensionSizes,
nullptr /* rtp_state */, clock_);
// Reset |rtp_sender_| to use FlexFEC.
RtpRtcpInterface::Configuration config;
config.clock = clock_;
config.outgoing_transport = &transport_;
config.paced_sender = &mock_paced_sender_;
config.local_media_ssrc = kSsrc;
config.fec_generator = &flexfec_sender_;
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.field_trials = &field_trials_;
rtp_sender_context_ =
std::make_unique<RtpSenderContext>(config, &time_controller_);
rtp_sender()->SetSequenceNumber(kSeqNum);
rtp_sender_context_->packet_history_.SetStorePacketsStatus(
RtpPacketHistory::StorageMode::kStoreAndCull, 10);
FieldTrialBasedConfig field_trials;
RTPSenderVideo::Config video_config;
video_config.clock = clock_;
video_config.rtp_sender = rtp_sender();
video_config.fec_type = flexfec_sender.GetFecType();
video_config.fec_overhead_bytes = flexfec_sender.MaxPacketOverhead();
video_config.fec_type = flexfec_sender.GetFecType();
video_config.fec_overhead_bytes = flexfec_sender.MaxPacketOverhead();
video_config.field_trials = &field_trials;
RTPSenderVideo rtp_sender_video(video_config);
// Parameters selected to generate a single FEC packet per media packet.
FecProtectionParams params;
params.fec_rate = 15;
params.max_fec_frames = 1;
params.fec_mask_type = kFecMaskRandom;
flexfec_sender.SetProtectionParameters(params, params);
uint16_t flexfec_seq_num;
RTPVideoHeader video_header;
std::unique_ptr<RtpPacketToSend> media_packet;
std::unique_ptr<RtpPacketToSend> fec_packet;
EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
.WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
for (auto& packet : packets) {
if (packet->packet_type() == RtpPacketMediaType::kVideo) {
EXPECT_EQ(packet->Ssrc(), kSsrc);
EXPECT_EQ(packet->SequenceNumber(), kSeqNum);
media_packet = std::move(packet);
// Simulate RtpSenderEgress adding packet to fec generator.
flexfec_sender.AddPacketAndGenerateFec(*media_packet);
auto fec_packets = flexfec_sender.GetFecPackets();
EXPECT_EQ(fec_packets.size(), 1u);
fec_packet = std::move(fec_packets[0]);
EXPECT_EQ(fec_packet->packet_type(),
RtpPacketMediaType::kForwardErrorCorrection);
EXPECT_EQ(fec_packet->Ssrc(), kFlexFecSsrc);
} else {
EXPECT_EQ(packet->packet_type(),
RtpPacketMediaType::kForwardErrorCorrection);
fec_packet = std::move(packet);
EXPECT_EQ(fec_packet->Ssrc(), kFlexFecSsrc);
}
}
});
video_header.frame_type = VideoFrameType::kVideoFrameKey;
EXPECT_TRUE(rtp_sender_video.SendVideo(
kMediaPayloadType, kCodecType, kTimestamp, clock_->TimeInMilliseconds(),
kPayloadData, video_header, kDefaultExpectedRetransmissionTimeMs));
ASSERT_TRUE(media_packet != nullptr);
ASSERT_TRUE(fec_packet != nullptr);
flexfec_seq_num = fec_packet->SequenceNumber();
rtp_sender_context_->InjectPacket(std::move(media_packet), PacedPacketInfo());
rtp_sender_context_->InjectPacket(std::move(fec_packet), PacedPacketInfo());
ASSERT_EQ(2, transport_.packets_sent());
const RtpPacketReceived& sent_media_packet = transport_.sent_packets_[0];
EXPECT_EQ(kMediaPayloadType, sent_media_packet.PayloadType());
EXPECT_EQ(kSeqNum, sent_media_packet.SequenceNumber());
EXPECT_EQ(kSsrc, sent_media_packet.Ssrc());
const RtpPacketReceived& sent_flexfec_packet = transport_.sent_packets_[1];
EXPECT_EQ(kFlexfecPayloadType, sent_flexfec_packet.PayloadType());
EXPECT_EQ(flexfec_seq_num, sent_flexfec_packet.SequenceNumber());
EXPECT_EQ(kFlexFecSsrc, sent_flexfec_packet.Ssrc());
}
TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
constexpr uint32_t kTimestamp = 1234;
constexpr int kMediaPayloadType = 127;
constexpr VideoCodecType kCodecType = VideoCodecType::kVideoCodecGeneric;
constexpr int kFlexfecPayloadType = 118;
const std::vector<RtpExtension> kNoRtpExtensions;
const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexFecSsrc, kSsrc, kNoMid,
kNoRtpExtensions, kNoRtpExtensionSizes,
nullptr /* rtp_state */, clock_);
// Reset |rtp_sender_| to use FlexFEC.
RtpRtcpInterface::Configuration config;
config.clock = clock_;
config.outgoing_transport = &transport_;
config.local_media_ssrc = kSsrc;
config.fec_generator = &flexfec_sender;
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.field_trials = &field_trials_;
rtp_sender_context_ =
std::make_unique<RtpSenderContext>(config, &time_controller_);
rtp_sender()->SetSequenceNumber(kSeqNum);
FieldTrialBasedConfig field_trials;
RTPSenderVideo::Config video_config;
video_config.clock = clock_;
video_config.rtp_sender = rtp_sender();
video_config.fec_type = flexfec_sender.GetFecType();
video_config.fec_overhead_bytes = flexfec_sender_.MaxPacketOverhead();
video_config.field_trials = &field_trials;
RTPSenderVideo rtp_sender_video(video_config);
// Parameters selected to generate a single FEC packet per media packet.
FecProtectionParams params;
params.fec_rate = 15;
params.max_fec_frames = 1;
params.fec_mask_type = kFecMaskRandom;
rtp_egress()->SetFecProtectionParameters(params, params);
EXPECT_CALL(mock_rtc_event_log_,
LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
.Times(2);
RTPVideoHeader video_header;
video_header.frame_type = VideoFrameType::kVideoFrameKey;
EXPECT_TRUE(rtp_sender_video.SendVideo(
kMediaPayloadType, kCodecType, kTimestamp, clock_->TimeInMilliseconds(),
kPayloadData, video_header, kDefaultExpectedRetransmissionTimeMs));
ASSERT_EQ(2, transport_.packets_sent());
const RtpPacketReceived& media_packet = transport_.sent_packets_[0];
EXPECT_EQ(kMediaPayloadType, media_packet.PayloadType());
EXPECT_EQ(kSsrc, media_packet.Ssrc());
const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[1];
EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
EXPECT_EQ(kFlexFecSsrc, flexfec_packet.Ssrc());
}
// Test that the MID header extension is included on sent packets when
// configured.
TEST_P(RtpSenderTestWithoutPacer, MidIncludedOnSentPackets) {