Pass Environment into FlexfecSender
To make it available for FEC to use field trials in follow ups Bug: webrtc:355577231 Change-Id: Ie0b7761915696e6ee7453df3d0531b0f7ad30ee1 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/358240 Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Commit-Queue: Danil Chapovalov <danilchap@webrtc.org> Reviewed-by: Åsa Persson <asapersson@webrtc.org> Cr-Commit-Position: refs/heads/main@{#42732}
This commit is contained in:
Xinyu Ma
WebRTC LUCI CQ
parent
3b0424bc41
commit
075349f039
@ -168,9 +168,9 @@ std::unique_ptr<VideoFecGenerator> MaybeCreateFecGenerator(
|
||||
|
||||
RTC_DCHECK_EQ(1U, rtp.flexfec.protected_media_ssrcs.size());
|
||||
return std::make_unique<FlexfecSender>(
|
||||
rtp.flexfec.payload_type, rtp.flexfec.ssrc,
|
||||
env, rtp.flexfec.payload_type, rtp.flexfec.ssrc,
|
||||
rtp.flexfec.protected_media_ssrcs[0], rtp.mid, rtp.extensions,
|
||||
RTPSender::FecExtensionSizes(), rtp_state, &env.clock());
|
||||
RTPSender::FecExtensionSizes(), rtp_state);
|
||||
} else if (rtp.ulpfec.red_payload_type >= 0 &&
|
||||
rtp.ulpfec.ulpfec_payload_type >= 0 &&
|
||||
!ShouldDisableRedAndUlpfec(/*flexfec_enabled=*/false, rtp,
|
||||
|
||||
@ -288,6 +288,7 @@ rtc_library("rtp_rtcp") {
|
||||
"../../api:transport_api",
|
||||
"../../api/audio_codecs:audio_codecs_api",
|
||||
"../../api/crypto:frame_encryptor_interface",
|
||||
"../../api/environment:environment",
|
||||
"../../api/rtc_event_log",
|
||||
"../../api/task_queue:pending_task_safety_flag",
|
||||
"../../api/task_queue:task_queue",
|
||||
@ -677,6 +678,8 @@ if (rtc_include_tests) {
|
||||
"../../api:scoped_refptr",
|
||||
"../../api:time_controller",
|
||||
"../../api:transport_api",
|
||||
"../../api/environment:environment",
|
||||
"../../api/environment:environment_factory",
|
||||
"../../api/rtc_event_log",
|
||||
"../../api/task_queue",
|
||||
"../../api/transport/rtp:dependency_descriptor",
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
|
||||
#include "absl/strings/string_view.h"
|
||||
#include "api/array_view.h"
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/rtp_parameters.h"
|
||||
#include "api/units/timestamp.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
|
||||
@ -30,7 +31,6 @@
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
class Clock;
|
||||
class RtpPacketToSend;
|
||||
|
||||
// Note that this class is not thread safe, and thus requires external
|
||||
@ -38,14 +38,14 @@ class RtpPacketToSend;
|
||||
|
||||
class FlexfecSender : public VideoFecGenerator {
|
||||
public:
|
||||
FlexfecSender(int payload_type,
|
||||
FlexfecSender(const Environment& env,
|
||||
int payload_type,
|
||||
uint32_t ssrc,
|
||||
uint32_t protected_media_ssrc,
|
||||
absl::string_view mid,
|
||||
const std::vector<RtpExtension>& rtp_header_extensions,
|
||||
rtc::ArrayView<const RtpExtensionSize> extension_sizes,
|
||||
const RtpState* rtp_state,
|
||||
Clock* clock);
|
||||
const RtpState* rtp_state);
|
||||
~FlexfecSender();
|
||||
|
||||
FecType GetFecType() const override {
|
||||
@ -76,7 +76,7 @@ class FlexfecSender : public VideoFecGenerator {
|
||||
|
||||
private:
|
||||
// Utility.
|
||||
Clock* const clock_;
|
||||
const Environment env_;
|
||||
Random random_;
|
||||
Timestamp last_generated_packet_ = Timestamp::MinusInfinity();
|
||||
|
||||
|
||||
@ -16,6 +16,7 @@
|
||||
#include <utility>
|
||||
|
||||
#include "absl/strings/string_view.h"
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/units/time_delta.h"
|
||||
#include "api/units/timestamp.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
|
||||
@ -71,16 +72,16 @@ RtpHeaderExtensionMap RegisterSupportedExtensions(
|
||||
} // namespace
|
||||
|
||||
FlexfecSender::FlexfecSender(
|
||||
const Environment& env,
|
||||
int payload_type,
|
||||
uint32_t ssrc,
|
||||
uint32_t protected_media_ssrc,
|
||||
absl::string_view mid,
|
||||
const std::vector<RtpExtension>& rtp_header_extensions,
|
||||
rtc::ArrayView<const RtpExtensionSize> extension_sizes,
|
||||
const RtpState* rtp_state,
|
||||
Clock* clock)
|
||||
: clock_(clock),
|
||||
random_(clock_->TimeInMicroseconds()),
|
||||
const RtpState* rtp_state)
|
||||
: env_(env),
|
||||
random_(env_.clock().TimeInMicroseconds()),
|
||||
payload_type_(payload_type),
|
||||
// Reset RTP state if this is not the first time we are operating.
|
||||
// Otherwise, randomize the initial timestamp offset and RTP sequence
|
||||
@ -94,7 +95,7 @@ FlexfecSender::FlexfecSender(
|
||||
: random_.Rand(1, kMaxInitRtpSeqNumber)),
|
||||
ulpfec_generator_(
|
||||
ForwardErrorCorrection::CreateFlexfec(ssrc, protected_media_ssrc),
|
||||
clock_),
|
||||
&env_.clock()),
|
||||
rtp_header_extension_map_(
|
||||
RegisterSupportedExtensions(rtp_header_extensions)),
|
||||
header_extensions_size_(
|
||||
@ -141,10 +142,10 @@ std::vector<std::unique_ptr<RtpPacketToSend>> FlexfecSender::GetFecPackets() {
|
||||
fec_packet_to_send->SetTimestamp(
|
||||
timestamp_offset_ +
|
||||
static_cast<uint32_t>(kMsToRtpTimestamp *
|
||||
clock_->TimeInMilliseconds()));
|
||||
env_.clock().TimeInMilliseconds()));
|
||||
// Set "capture time" so that the TransmissionOffset header extension
|
||||
// can be set by the RTPSender.
|
||||
fec_packet_to_send->set_capture_time(clock_->CurrentTime());
|
||||
fec_packet_to_send->set_capture_time(env_.clock().CurrentTime());
|
||||
fec_packet_to_send->SetSsrc(ssrc_);
|
||||
// Reserve extensions, if registered. These will be set by the RTPSender.
|
||||
fec_packet_to_send->ReserveExtension<AbsoluteSendTime>();
|
||||
@ -169,7 +170,7 @@ std::vector<std::unique_ptr<RtpPacketToSend>> FlexfecSender::GetFecPackets() {
|
||||
ulpfec_generator_.ResetState();
|
||||
}
|
||||
|
||||
Timestamp now = clock_->CurrentTime();
|
||||
Timestamp now = env_.clock().CurrentTime();
|
||||
if (!fec_packets_to_send.empty() &&
|
||||
now - last_generated_packet_ > kPacketLogInterval) {
|
||||
RTC_LOG(LS_VERBOSE) << "Generated " << fec_packets_to_send.size()
|
||||
@ -191,7 +192,8 @@ size_t FlexfecSender::MaxPacketOverhead() const {
|
||||
|
||||
DataRate FlexfecSender::CurrentFecRate() const {
|
||||
MutexLock lock(&mutex_);
|
||||
return fec_bitrate_.Rate(clock_->CurrentTime()).value_or(DataRate::Zero());
|
||||
return fec_bitrate_.Rate(env_.clock().CurrentTime())
|
||||
.value_or(DataRate::Zero());
|
||||
}
|
||||
|
||||
absl::optional<RtpState> FlexfecSender::GetRtpState() {
|
||||
|
||||
@ -12,6 +12,8 @@
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/environment/environment_factory.h"
|
||||
#include "api/rtp_parameters.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
|
||||
#include "modules/rtp_rtcp/source/fec_test_helper.h"
|
||||
@ -83,27 +85,30 @@ std::unique_ptr<RtpPacketToSend> GenerateSingleFlexfecPacket(
|
||||
|
||||
TEST(FlexfecSenderTest, Ssrc) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
|
||||
EXPECT_EQ(kFlexfecSsrc, sender.FecSsrc());
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, NoFecAvailableBeforeMediaAdded) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
|
||||
EXPECT_TRUE(sender.GetFecPackets().empty());
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, ProtectOneFrameWithOneFecPacket) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
EXPECT_EQ(kRtpHeaderSize, fec_packet->headers_size());
|
||||
@ -116,6 +121,8 @@ TEST(FlexfecSenderTest, ProtectOneFrameWithOneFecPacket) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
// FEC parameters selected to generate a single FEC packet per frame.
|
||||
FecProtectionParams params;
|
||||
params.fec_rate = 15;
|
||||
@ -123,10 +130,9 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) {
|
||||
params.fec_mask_type = kFecMaskRandom;
|
||||
constexpr size_t kNumFrames = 2;
|
||||
constexpr size_t kNumPacketsPerFrame = 2;
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
sender.SetProtectionParameters(params, params);
|
||||
|
||||
AugmentedPacketGenerator packet_generator(kMediaSsrc);
|
||||
@ -155,6 +161,8 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
// FEC parameters selected to generate a single FEC packet per frame.
|
||||
FecProtectionParams params;
|
||||
params.fec_rate = 30;
|
||||
@ -162,10 +170,9 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) {
|
||||
params.fec_mask_type = kFecMaskRandom;
|
||||
constexpr size_t kNumFrames = 2;
|
||||
constexpr size_t kNumPacketsPerFrame = 2;
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
sender.SetProtectionParameters(params, params);
|
||||
|
||||
AugmentedPacketGenerator packet_generator(kMediaSsrc);
|
||||
@ -196,11 +203,12 @@ TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) {
|
||||
|
||||
// In the tests, we only consider RTP header extensions that are useful for BWE.
|
||||
TEST(FlexfecSenderTest, NoRtpHeaderExtensionsForBweByDefault) {
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{};
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{};
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */);
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>());
|
||||
@ -209,12 +217,13 @@ TEST(FlexfecSenderTest, NoRtpHeaderExtensionsForBweByDefault) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{
|
||||
{RtpExtension::kAbsSendTimeUri, 1}};
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */);
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
EXPECT_TRUE(fec_packet->HasExtension<AbsoluteSendTime>());
|
||||
@ -223,12 +232,13 @@ TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{
|
||||
{RtpExtension::kTimestampOffsetUri, 1}};
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */);
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>());
|
||||
@ -237,12 +247,13 @@ TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{
|
||||
{RtpExtension::kTransportSequenceNumberUri, 1}};
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */);
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>());
|
||||
@ -251,14 +262,15 @@ TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{
|
||||
{RtpExtension::kAbsSendTimeUri, 1},
|
||||
{RtpExtension::kTimestampOffsetUri, 2},
|
||||
{RtpExtension::kTransportSequenceNumberUri, 3}};
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */);
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
EXPECT_TRUE(fec_packet->HasExtension<AbsoluteSendTime>());
|
||||
@ -268,19 +280,21 @@ TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) {
|
||||
|
||||
TEST(FlexfecSenderTest, MaxPacketOverhead) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
|
||||
EXPECT_EQ(kFlexfecMaxHeaderSize, sender.MaxPacketOverhead());
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, MaxPacketOverheadWithExtensions) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{
|
||||
{RtpExtension::kAbsSendTimeUri, 1},
|
||||
{RtpExtension::kTimestampOffsetUri, 2},
|
||||
{RtpExtension::kTransportSequenceNumberUri, 3}};
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const size_t kExtensionHeaderLength = 1;
|
||||
const size_t kRtpOneByteHeaderLength = 4;
|
||||
const size_t kExtensionsTotalSize =
|
||||
@ -288,22 +302,23 @@ TEST(FlexfecSenderTest, MaxPacketOverheadWithExtensions) {
|
||||
AbsoluteSendTime::kValueSizeBytes + kExtensionHeaderLength +
|
||||
TransmissionOffset::kValueSizeBytes + kExtensionHeaderLength +
|
||||
TransportSequenceNumber::kValueSizeBytes);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kRtpHeaderExtensions, RTPSender::FecExtensionSizes(),
|
||||
nullptr /* rtp_state */, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kRtpHeaderExtensions,
|
||||
RTPSender::FecExtensionSizes(), nullptr /* rtp_state */);
|
||||
|
||||
EXPECT_EQ(kExtensionsTotalSize + kFlexfecMaxHeaderSize,
|
||||
sender.MaxPacketOverhead());
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, MidIncludedInPacketsWhenSet) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
const std::vector<RtpExtension> kRtpHeaderExtensions{
|
||||
{RtpExtension::kMidUri, 1}};
|
||||
const char kMid[] = "mid";
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kMid,
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kMid,
|
||||
kRtpHeaderExtensions, RTPSender::FecExtensionSizes(),
|
||||
nullptr /* rtp_state */, &clock);
|
||||
nullptr /* rtp_state */);
|
||||
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
|
||||
@ -313,13 +328,14 @@ TEST(FlexfecSenderTest, MidIncludedInPacketsWhenSet) {
|
||||
}
|
||||
|
||||
TEST(FlexfecSenderTest, SetsAndGetsRtpState) {
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
const Environment env = CreateEnvironment(&clock);
|
||||
RtpState initial_rtp_state;
|
||||
initial_rtp_state.sequence_number = 100;
|
||||
initial_rtp_state.start_timestamp = 200;
|
||||
SimulatedClock clock(kInitialSimulatedClockTime);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
&initial_rtp_state, &clock);
|
||||
FlexfecSender sender(env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, &initial_rtp_state);
|
||||
|
||||
auto fec_packet = GenerateSingleFlexfecPacket(&sender);
|
||||
EXPECT_EQ(initial_rtp_state.sequence_number, fec_packet->SequenceNumber());
|
||||
|
||||
@ -17,6 +17,8 @@
|
||||
#include <utility>
|
||||
|
||||
#include "absl/types/optional.h"
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/environment/environment_factory.h"
|
||||
#include "api/field_trials_registry.h"
|
||||
#include "api/units/time_delta.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
|
||||
@ -30,7 +32,6 @@
|
||||
#include "rtc_base/logging.h"
|
||||
#include "rtc_base/rate_limiter.h"
|
||||
#include "rtc_base/strings/string_builder.h"
|
||||
#include "test/explicit_key_value_config.h"
|
||||
#include "test/gmock.h"
|
||||
#include "test/gtest.h"
|
||||
#include "test/rtcp_packet_parser.h"
|
||||
@ -46,8 +47,6 @@ using ::testing::Not;
|
||||
using ::testing::Optional;
|
||||
using ::testing::SizeIs;
|
||||
|
||||
using webrtc::test::ExplicitKeyValueConfig;
|
||||
|
||||
namespace webrtc {
|
||||
namespace {
|
||||
constexpr uint32_t kSenderSsrc = 0x12345;
|
||||
@ -170,21 +169,18 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
|
||||
uint32_t ssrc;
|
||||
};
|
||||
|
||||
RtpRtcpModule(GlobalSimulatedTimeController* time_controller,
|
||||
bool is_sender,
|
||||
const FieldTrialsRegistry& trials)
|
||||
: time_controller_(time_controller),
|
||||
RtpRtcpModule(const Environment& env,
|
||||
GlobalSimulatedTimeController* time_controller,
|
||||
bool is_sender)
|
||||
: env_(env),
|
||||
is_sender_(is_sender),
|
||||
trials_(trials),
|
||||
receive_statistics_(
|
||||
ReceiveStatistics::Create(time_controller->GetClock())),
|
||||
receive_statistics_(ReceiveStatistics::Create(&env.clock())),
|
||||
transport_(kOneWayNetworkDelay, time_controller) {
|
||||
CreateModuleImpl();
|
||||
}
|
||||
|
||||
TimeController* const time_controller_;
|
||||
const Environment env_;
|
||||
const bool is_sender_;
|
||||
const FieldTrialsRegistry& trials_;
|
||||
RtcpPacketTypeCounter packets_sent_;
|
||||
RtcpPacketTypeCounter packets_received_;
|
||||
std::unique_ptr<ReceiveStatistics> receive_statistics_;
|
||||
@ -242,7 +238,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
|
||||
void CreateModuleImpl() {
|
||||
RtpRtcpInterface::Configuration config;
|
||||
config.audio = false;
|
||||
config.clock = time_controller_->GetClock();
|
||||
config.clock = &env_.clock();
|
||||
config.outgoing_transport = &transport_;
|
||||
config.receive_statistics = receive_statistics_.get();
|
||||
config.rtcp_packet_type_counter_observer = this;
|
||||
@ -253,7 +249,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
|
||||
is_sender_ ? absl::make_optional(kRtxSenderSsrc) : absl::nullopt;
|
||||
config.need_rtp_packet_infos = true;
|
||||
config.non_sender_rtt_measurement = true;
|
||||
config.field_trials = &trials_;
|
||||
config.field_trials = &env_.field_trials();
|
||||
config.send_packet_observer = this;
|
||||
config.fec_generator = fec_generator_;
|
||||
impl_.reset(new ModuleRtpRtcpImpl2(config));
|
||||
@ -273,13 +269,14 @@ class RtpRtcpImpl2Test : public ::testing::Test {
|
||||
protected:
|
||||
RtpRtcpImpl2Test()
|
||||
: time_controller_(Timestamp::Micros(133590000000000)),
|
||||
field_trials_(""),
|
||||
sender_(&time_controller_,
|
||||
/*is_sender=*/true,
|
||||
field_trials_),
|
||||
receiver_(&time_controller_,
|
||||
/*is_sender=*/false,
|
||||
field_trials_) {}
|
||||
env_(CreateEnvironment(time_controller_.GetClock(),
|
||||
time_controller_.CreateTaskQueueFactory())),
|
||||
sender_(env_,
|
||||
&time_controller_,
|
||||
/*is_sender=*/true),
|
||||
receiver_(env_,
|
||||
&time_controller_,
|
||||
/*is_sender=*/false) {}
|
||||
|
||||
void SetUp() override {
|
||||
// Send module.
|
||||
@ -291,7 +288,7 @@ class RtpRtcpImpl2Test : public ::testing::Test {
|
||||
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.field_trials = &env_.field_trials();
|
||||
sender_video_ = std::make_unique<RTPSenderVideo>(video_config);
|
||||
|
||||
// Receive module.
|
||||
@ -318,7 +315,7 @@ class RtpRtcpImpl2Test : public ::testing::Test {
|
||||
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.field_trials = &env_.field_trials();
|
||||
video_config.fec_overhead_bytes = fec_generator->MaxPacketOverhead();
|
||||
video_config.fec_type = fec_generator->GetFecType();
|
||||
video_config.red_payload_type = red_payload_type;
|
||||
@ -326,7 +323,7 @@ class RtpRtcpImpl2Test : public ::testing::Test {
|
||||
}
|
||||
|
||||
GlobalSimulatedTimeController time_controller_;
|
||||
test::ExplicitKeyValueConfig field_trials_;
|
||||
const Environment env_;
|
||||
RtpRtcpModule sender_;
|
||||
std::unique_ptr<RTPSenderVideo> sender_video_;
|
||||
RtpRtcpModule receiver_;
|
||||
@ -1008,9 +1005,9 @@ TEST_F(RtpRtcpImpl2Test, GeneratesFlexfec) {
|
||||
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());
|
||||
FlexfecSender flexfec_sender(env_, kFlexfecPayloadType, kFlexfecSsrc,
|
||||
kSenderSsrc, kNoMid, kNoRtpExtensions,
|
||||
kNoRtpExtensionSizes, &start_state);
|
||||
ReinitWithFec(&flexfec_sender, /*red_payload_type=*/absl::nullopt);
|
||||
|
||||
// Parameters selected to generate a single FEC packet per media packet.
|
||||
|
||||
@ -16,6 +16,8 @@
|
||||
#include "absl/types/optional.h"
|
||||
#include "api/array_view.h"
|
||||
#include "api/call/transport.h"
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/environment/environment_factory.h"
|
||||
#include "api/field_trials_registry.h"
|
||||
#include "api/units/data_size.h"
|
||||
#include "api/units/timestamp.h"
|
||||
@ -27,7 +29,6 @@
|
||||
#include "modules/rtp_rtcp/source/rtp_packet_history.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
|
||||
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
|
||||
#include "test/explicit_key_value_config.h"
|
||||
#include "test/gmock.h"
|
||||
#include "test/gtest.h"
|
||||
#include "test/time_controller/simulated_time_controller.h"
|
||||
@ -115,11 +116,11 @@ class RtpSenderEgressTest : public ::testing::Test {
|
||||
protected:
|
||||
RtpSenderEgressTest()
|
||||
: time_controller_(kStartTime),
|
||||
env_(CreateEnvironment(time_controller_.GetClock())),
|
||||
clock_(time_controller_.GetClock()),
|
||||
transport_(&header_extensions_),
|
||||
packet_history_(clock_,
|
||||
RtpPacketHistory::PaddingMode::kRecentLargePacket),
|
||||
trials_(""),
|
||||
sequence_number_(kStartSequenceNumber) {}
|
||||
|
||||
std::unique_ptr<RtpSenderEgress> CreateRtpSenderEgress() {
|
||||
@ -138,7 +139,7 @@ class RtpSenderEgressTest : public ::testing::Test {
|
||||
config.send_packet_observer = &send_packet_observer_;
|
||||
config.rtp_stats_callback = &mock_rtp_stats_callback_;
|
||||
config.populate_network2_timestamp = false;
|
||||
config.field_trials = &trials_;
|
||||
config.field_trials = &env_.field_trials();
|
||||
return config;
|
||||
}
|
||||
|
||||
@ -164,6 +165,7 @@ class RtpSenderEgressTest : public ::testing::Test {
|
||||
}
|
||||
|
||||
GlobalSimulatedTimeController time_controller_;
|
||||
const Environment env_;
|
||||
Clock* const clock_;
|
||||
NiceMock<MockRtcEventLog> mock_rtc_event_log_;
|
||||
NiceMock<MockStreamDataCountersCallback> mock_rtp_stats_callback_;
|
||||
@ -171,7 +173,6 @@ class RtpSenderEgressTest : public ::testing::Test {
|
||||
RtpHeaderExtensionMap header_extensions_;
|
||||
NiceMock<TestTransport> transport_;
|
||||
RtpPacketHistory packet_history_;
|
||||
test::ExplicitKeyValueConfig trials_;
|
||||
uint16_t sequence_number_;
|
||||
};
|
||||
|
||||
@ -837,9 +838,10 @@ TEST_F(RtpSenderEgressTest, SendPacketUpdatesStats) {
|
||||
const size_t kPayloadSize = 1000;
|
||||
|
||||
const rtc::ArrayView<const RtpExtensionSize> kNoRtpHeaderExtensionSizes;
|
||||
FlexfecSender flexfec(kFlexfectPayloadType, kFlexFecSsrc, kSsrc, /*mid=*/"",
|
||||
FlexfecSender flexfec(env_, kFlexfectPayloadType, kFlexFecSsrc, kSsrc,
|
||||
/*mid=*/"",
|
||||
/*header_extensions=*/{}, kNoRtpHeaderExtensionSizes,
|
||||
/*rtp_state=*/nullptr, time_controller_.GetClock());
|
||||
/*rtp_state=*/nullptr);
|
||||
RtpRtcpInterface::Configuration config = DefaultConfig();
|
||||
config.fec_generator = &flexfec;
|
||||
auto sender = std::make_unique<RtpSenderEgress>(config, &packet_history_);
|
||||
|
||||
@ -14,6 +14,8 @@
|
||||
#include <vector>
|
||||
|
||||
#include "absl/strings/string_view.h"
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/environment/environment_factory.h"
|
||||
#include "api/rtc_event_log/rtc_event.h"
|
||||
#include "api/rtp_packet_sender.h"
|
||||
#include "api/units/frequency.h"
|
||||
@ -38,7 +40,6 @@
|
||||
#include "rtc_base/logging.h"
|
||||
#include "rtc_base/rate_limiter.h"
|
||||
#include "rtc_base/strings/string_builder.h"
|
||||
#include "test/explicit_key_value_config.h"
|
||||
#include "test/gmock.h"
|
||||
#include "test/gtest.h"
|
||||
#include "test/mock_transport.h"
|
||||
@ -116,16 +117,16 @@ class RtpSenderTest : public ::testing::Test {
|
||||
protected:
|
||||
RtpSenderTest()
|
||||
: time_controller_(Timestamp::Millis(kStartTime)),
|
||||
clock_(time_controller_.GetClock()),
|
||||
retransmission_rate_limiter_(clock_, 1000),
|
||||
flexfec_sender_(0,
|
||||
env_(CreateEnvironment(time_controller_.GetClock())),
|
||||
retransmission_rate_limiter_(&env_.clock(), 1000),
|
||||
flexfec_sender_(env_,
|
||||
0,
|
||||
kFlexFecSsrc,
|
||||
kSsrc,
|
||||
"",
|
||||
std::vector<RtpExtension>(),
|
||||
std::vector<RtpExtensionSize>(),
|
||||
nullptr,
|
||||
clock_) {}
|
||||
nullptr) {}
|
||||
|
||||
void SetUp() override { SetUpRtpSender(true, false, nullptr); }
|
||||
|
||||
@ -141,13 +142,13 @@ class RtpSenderTest : public ::testing::Test {
|
||||
|
||||
RtpRtcpInterface::Configuration GetDefaultConfig() {
|
||||
RtpRtcpInterface::Configuration config;
|
||||
config.clock = clock_;
|
||||
config.clock = &env_.clock();
|
||||
config.local_media_ssrc = kSsrc;
|
||||
config.rtx_send_ssrc = kRtxSsrc;
|
||||
config.event_log = &mock_rtc_event_log_;
|
||||
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
|
||||
config.paced_sender = &mock_paced_sender_;
|
||||
config.field_trials = &field_trials_;
|
||||
config.field_trials = &env_.field_trials();
|
||||
// Configure rid unconditionally, it has effect only if
|
||||
// corresponding header extension is enabled.
|
||||
config.rid = std::string(kRid);
|
||||
@ -159,7 +160,7 @@ class RtpSenderTest : public ::testing::Test {
|
||||
config.clock, RtpPacketHistory::PaddingMode::kRecentLargePacket);
|
||||
sequencer_.emplace(kSsrc, kRtxSsrc,
|
||||
/*require_marker_before_media_padding=*/!config.audio,
|
||||
clock_);
|
||||
&env_.clock());
|
||||
rtp_sender_ = std::make_unique<RTPSender>(config, packet_history_.get(),
|
||||
config.paced_sender);
|
||||
sequencer_->set_media_sequence_number(kSeqNum);
|
||||
@ -167,7 +168,7 @@ class RtpSenderTest : public ::testing::Test {
|
||||
}
|
||||
|
||||
GlobalSimulatedTimeController time_controller_;
|
||||
Clock* const clock_;
|
||||
const Environment env_;
|
||||
NiceMock<MockRtcEventLog> mock_rtc_event_log_;
|
||||
MockRtpPacketPacer mock_paced_sender_;
|
||||
RateLimiter retransmission_rate_limiter_;
|
||||
@ -177,8 +178,6 @@ class RtpSenderTest : public ::testing::Test {
|
||||
std::unique_ptr<RtpPacketHistory> packet_history_;
|
||||
std::unique_ptr<RTPSender> rtp_sender_;
|
||||
|
||||
const test::ExplicitKeyValueConfig field_trials_{""};
|
||||
|
||||
std::unique_ptr<RtpPacketToSend> BuildRtpPacket(int payload_type,
|
||||
bool marker_bit,
|
||||
uint32_t rtp_timestamp,
|
||||
@ -211,7 +210,7 @@ class RtpSenderTest : public ::testing::Test {
|
||||
// Use maximum allowed size to catch corner cases when packet is dropped
|
||||
// because of lack of capacity for the media packet, or for an rtx packet
|
||||
// containing the media packet.
|
||||
return SendPacket(/*capture_time=*/clock_->CurrentTime(),
|
||||
return SendPacket(/*capture_time=*/env_.clock().CurrentTime(),
|
||||
/*payload_length=*/rtp_sender_->MaxRtpPacketSize() -
|
||||
rtp_sender_->ExpectedPerPacketOverhead());
|
||||
}
|
||||
@ -345,7 +344,7 @@ TEST_F(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) {
|
||||
std::vector<std::unique_ptr<RtpPacketToSend>> packets(1);
|
||||
packets[0] =
|
||||
BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, Timestamp::Zero());
|
||||
Timestamp now = clock_->CurrentTime();
|
||||
Timestamp now = env_.clock().CurrentTime();
|
||||
|
||||
EXPECT_CALL(mock_paced_sender_,
|
||||
EnqueuePackets(ElementsAre(AllOf(
|
||||
@ -358,7 +357,7 @@ TEST_F(RtpSenderTest, SendToNetworkForwardsPacketsToPacer) {
|
||||
TEST_F(RtpSenderTest, ReSendPacketForwardsPacketsToPacer) {
|
||||
packet_history_->SetStorePacketsStatus(
|
||||
RtpPacketHistory::StorageMode::kStoreAndCull, 10);
|
||||
Timestamp now = clock_->CurrentTime();
|
||||
Timestamp now = env_.clock().CurrentTime();
|
||||
auto packet = BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, now);
|
||||
packet->SetSequenceNumber(kSeqNum);
|
||||
packet->set_allow_retransmission(true);
|
||||
@ -380,7 +379,7 @@ TEST_F(RtpSenderTest, SendPadding) {
|
||||
constexpr int kNumPaddingPackets = 4;
|
||||
EXPECT_CALL(mock_paced_sender_, EnqueuePackets);
|
||||
std::unique_ptr<RtpPacketToSend> media_packet =
|
||||
SendPacket(/*capture_time=*/clock_->CurrentTime(),
|
||||
SendPacket(/*capture_time=*/env_.clock().CurrentTime(),
|
||||
/*payload_size=*/100);
|
||||
sequencer_->Sequence(*media_packet);
|
||||
|
||||
@ -413,7 +412,7 @@ TEST_F(RtpSenderTest, SendPadding) {
|
||||
&RtpPacketToSend::Timestamp, Gt(media_packet->Timestamp()))))));
|
||||
|
||||
std::unique_ptr<RtpPacketToSend> next_media_packet =
|
||||
SendPacket(/*capture_time=*/clock_->CurrentTime(),
|
||||
SendPacket(/*capture_time=*/env_.clock().CurrentTime(),
|
||||
/*payload_size=*/100);
|
||||
}
|
||||
|
||||
@ -511,7 +510,7 @@ TEST_F(RtpSenderTest, AllowPaddingAsFirstPacketOnRtxWithAbsSendTime) {
|
||||
TEST_F(RtpSenderTest, UpdatesTimestampsOnPlainRtxPadding) {
|
||||
EnableRtx();
|
||||
// Timestamps as set based on capture time in RtpSenderTest.
|
||||
const Timestamp start_time = clock_->CurrentTime();
|
||||
const Timestamp start_time = env_.clock().CurrentTime();
|
||||
const uint32_t start_timestamp = ToRtpTimestamp(start_time);
|
||||
|
||||
// Start by sending one media packet.
|
||||
@ -544,7 +543,7 @@ TEST_F(RtpSenderTest, KeepsTimestampsOnPayloadPadding) {
|
||||
TransportSequenceNumber::Uri(), kTransportSequenceNumberExtensionId));
|
||||
EnableRtx();
|
||||
// Timestamps as set based on capture time in RtpSenderTest.
|
||||
const Timestamp start_time = clock_->CurrentTime();
|
||||
const Timestamp start_time = env_.clock().CurrentTime();
|
||||
const uint32_t start_timestamp = ToRtpTimestamp(start_time);
|
||||
const size_t kPayloadSize = 200;
|
||||
const size_t kRtxHeaderSize = 2;
|
||||
@ -610,7 +609,7 @@ TEST_F(RtpSenderTest, RidIncludedOnRtxSentPackets) {
|
||||
.WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
|
||||
sequencer_->Sequence(*packets[0]);
|
||||
packet_history_->PutRtpPacket(std::move(packets[0]),
|
||||
clock_->CurrentTime());
|
||||
env_.clock().CurrentTime());
|
||||
});
|
||||
SendGenericPacket();
|
||||
|
||||
@ -681,7 +680,7 @@ TEST_F(RtpSenderTest, MidAndRidIncludedOnFirstRtxPacket) {
|
||||
EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
|
||||
.WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
|
||||
packet_history_->PutRtpPacket(std::move(packets[0]),
|
||||
clock_->CurrentTime());
|
||||
env_.clock().CurrentTime());
|
||||
});
|
||||
auto second_built_packet = SendGenericPacket();
|
||||
|
||||
@ -707,7 +706,7 @@ TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
|
||||
sequencer_->Sequence(*first_built_packet);
|
||||
packet_history_->PutRtpPacket(
|
||||
std::make_unique<RtpPacketToSend>(*first_built_packet),
|
||||
/*send_time=*/clock_->CurrentTime());
|
||||
/*send_time=*/env_.clock().CurrentTime());
|
||||
rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
|
||||
|
||||
// The second packet will include neither since an ack was received.
|
||||
@ -715,7 +714,7 @@ TEST_F(RtpSenderTest, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
|
||||
sequencer_->Sequence(*second_built_packet);
|
||||
packet_history_->PutRtpPacket(
|
||||
std::make_unique<RtpPacketToSend>(*second_built_packet),
|
||||
/*send_time=*/clock_->CurrentTime());
|
||||
/*send_time=*/env_.clock().CurrentTime());
|
||||
|
||||
// The first RTX packet will include MID and RRID.
|
||||
EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
|
||||
@ -753,7 +752,7 @@ TEST_F(RtpSenderTest, MidAndRidAlwaysIncludedOnRtxPacketsWhenConfigured) {
|
||||
.WillRepeatedly(
|
||||
[&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
|
||||
packet_history_->PutRtpPacket(std::move(packets[0]),
|
||||
clock_->CurrentTime());
|
||||
env_.clock().CurrentTime());
|
||||
});
|
||||
auto media_packet1 = SendGenericPacket();
|
||||
rtp_sender_->OnReceivedAckOnSsrc(media_packet1->SequenceNumber());
|
||||
@ -815,7 +814,7 @@ TEST_F(RtpSenderTest, MidAndRridNotIncludedOnRtxPacketsAfterRtpStateRestored) {
|
||||
EXPECT_CALL(mock_paced_sender_, EnqueuePackets(SizeIs(1)))
|
||||
.WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
|
||||
packet_history_->PutRtpPacket(std::move(packets[0]),
|
||||
clock_->CurrentTime());
|
||||
env_.clock().CurrentTime());
|
||||
});
|
||||
auto built_packet = SendGenericPacket();
|
||||
|
||||
@ -837,12 +836,12 @@ TEST_F(RtpSenderTest, RespectsNackBitrateLimit) {
|
||||
for (int32_t i = 0; i < kNumPackets; ++i) {
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, /*marker_bit=*/true, /*rtp_timestamp=*/0,
|
||||
/*capture_time=*/clock_->CurrentTime());
|
||||
/*capture_time=*/env_.clock().CurrentTime());
|
||||
packet->set_allow_retransmission(true);
|
||||
sequencer_->Sequence(*packet);
|
||||
sequence_numbers.push_back(packet->SequenceNumber());
|
||||
packet_history_->PutRtpPacket(std::move(packet),
|
||||
/*send_time=*/clock_->CurrentTime());
|
||||
/*send_time=*/env_.clock().CurrentTime());
|
||||
time_controller_.AdvanceTime(TimeDelta::Millis(1));
|
||||
}
|
||||
|
||||
@ -989,10 +988,10 @@ TEST_F(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
|
||||
|
||||
// Build a media packet and put in the packet history.
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime());
|
||||
BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
|
||||
const uint16_t media_sequence_number = packet->SequenceNumber();
|
||||
packet->set_allow_retransmission(true);
|
||||
packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
|
||||
packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
|
||||
|
||||
// Simulate successful retransmission request.
|
||||
time_controller_.AdvanceTime(TimeDelta::Millis(30));
|
||||
@ -1016,13 +1015,13 @@ TEST_F(RtpSenderTest, MarksRetransmittedPackets) {
|
||||
|
||||
// Build a media packet and put in the packet history.
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime());
|
||||
BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
|
||||
const uint32_t kMediaSsrc = 567;
|
||||
const uint16_t kMediaSequenceNumber = 123;
|
||||
packet->SetSsrc(kMediaSsrc);
|
||||
packet->SetSequenceNumber(kMediaSequenceNumber);
|
||||
packet->set_allow_retransmission(true);
|
||||
packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
|
||||
packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
|
||||
|
||||
// Expect a retransmission packet marked with which packet it is a
|
||||
// retransmit of.
|
||||
@ -1051,11 +1050,11 @@ TEST_F(RtpSenderTest, GeneratedPaddingHasBweExtensions) {
|
||||
|
||||
// Put a packet in the history, in order to facilitate payload padding.
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime());
|
||||
BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
|
||||
packet->set_allow_retransmission(true);
|
||||
packet->SetPayloadSize(kMinPaddingSize);
|
||||
packet->set_packet_type(RtpPacketMediaType::kVideo);
|
||||
packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
|
||||
packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
|
||||
|
||||
// Generate a plain padding packet, check that extensions are registered.
|
||||
std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
|
||||
@ -1093,11 +1092,11 @@ TEST_F(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
|
||||
|
||||
const size_t kPayloadPacketSize = kMinPaddingSize;
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime());
|
||||
BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
|
||||
packet->set_allow_retransmission(true);
|
||||
packet->SetPayloadSize(kPayloadPacketSize);
|
||||
packet->set_packet_type(RtpPacketMediaType::kVideo);
|
||||
packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
|
||||
packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
|
||||
|
||||
// Generated padding has large enough budget that the video packet should be
|
||||
// retransmitted as padding.
|
||||
@ -1142,11 +1141,11 @@ TEST_F(RtpSenderTest, LimitsPayloadPaddingSize) {
|
||||
// Send a dummy video packet so it ends up in the packet history.
|
||||
const size_t kPayloadPacketSize = 1234u;
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime());
|
||||
BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
|
||||
packet->set_allow_retransmission(true);
|
||||
packet->SetPayloadSize(kPayloadPacketSize);
|
||||
packet->set_packet_type(RtpPacketMediaType::kVideo);
|
||||
packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
|
||||
packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
|
||||
|
||||
// Smallest target size that will result in the sent packet being returned as
|
||||
// padding.
|
||||
@ -1182,12 +1181,12 @@ TEST_F(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
|
||||
// Send a dummy video packet so it ends up in the packet history. Since we
|
||||
// are not using RTX, it should never be used as padding.
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, true, 0, clock_->CurrentTime());
|
||||
BuildRtpPacket(kPayload, true, 0, env_.clock().CurrentTime());
|
||||
packet->set_allow_retransmission(true);
|
||||
packet->SetPayloadSize(kPayloadPacketSize);
|
||||
packet->set_packet_type(RtpPacketMediaType::kVideo);
|
||||
sequencer_->Sequence(*packet);
|
||||
packet_history_->PutRtpPacket(std::move(packet), clock_->CurrentTime());
|
||||
packet_history_->PutRtpPacket(std::move(packet), env_.clock().CurrentTime());
|
||||
|
||||
// Payload padding not available without RTX, only generate plain padding on
|
||||
// the media SSRC.
|
||||
@ -1258,7 +1257,7 @@ TEST_F(RtpSenderTest, SetsCaptureTimeOnRtxRetransmissions) {
|
||||
EnableRtx();
|
||||
|
||||
// Put a packet in the packet history, with current time as capture time.
|
||||
const Timestamp start_time = clock_->CurrentTime();
|
||||
const Timestamp start_time = env_.clock().CurrentTime();
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, kMarkerBit, /*rtp_timestamp=*/0,
|
||||
/*capture_time=*/start_time);
|
||||
@ -1283,7 +1282,7 @@ TEST_F(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
|
||||
packet_history_->SetRtt(kRtt);
|
||||
|
||||
// Put a packet in the history.
|
||||
const Timestamp start_time = clock_->CurrentTime();
|
||||
const Timestamp start_time = env_.clock().CurrentTime();
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, kMarkerBit, 0, /*capture_time=*/start_time);
|
||||
packet->set_allow_retransmission(true);
|
||||
@ -1307,7 +1306,7 @@ TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
|
||||
packet_history_->SetRtt(kRtt);
|
||||
|
||||
// Put a fec protected packet in the history.
|
||||
const Timestamp start_time = clock_->CurrentTime();
|
||||
const Timestamp start_time = env_.clock().CurrentTime();
|
||||
std::unique_ptr<RtpPacketToSend> packet =
|
||||
BuildRtpPacket(kPayload, kMarkerBit, 0, start_time);
|
||||
packet->set_allow_retransmission(true);
|
||||
@ -1327,9 +1326,9 @@ TEST_F(RtpSenderTest, DoesntFecProtectRetransmissions) {
|
||||
|
||||
TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) {
|
||||
RTPSenderVideo::Config video_config;
|
||||
video_config.clock = clock_;
|
||||
video_config.clock = &env_.clock();
|
||||
video_config.rtp_sender = rtp_sender_.get();
|
||||
video_config.field_trials = &field_trials_;
|
||||
video_config.field_trials = &env_.field_trials();
|
||||
RTPSenderVideo rtp_sender_video(video_config);
|
||||
|
||||
const uint8_t kPayloadType = 127;
|
||||
@ -1345,7 +1344,7 @@ TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) {
|
||||
.Times(AtLeast(1));
|
||||
RTPVideoHeader video_header;
|
||||
video_header.frame_type = VideoFrameType::kVideoFrameKey;
|
||||
Timestamp capture_time = clock_->CurrentTime();
|
||||
Timestamp capture_time = env_.clock().CurrentTime();
|
||||
EXPECT_TRUE(rtp_sender_video.SendVideo(
|
||||
kPayloadType, kCodecType,
|
||||
capture_time.ms() * kCaptureTimeMsToRtpTimestamp, capture_time,
|
||||
@ -1362,7 +1361,7 @@ TEST_F(RtpSenderTest, MarksPacketsWithKeyframeStatus) {
|
||||
.Times(AtLeast(1));
|
||||
RTPVideoHeader video_header;
|
||||
video_header.frame_type = VideoFrameType::kVideoFrameDelta;
|
||||
Timestamp capture_time = clock_->CurrentTime();
|
||||
Timestamp capture_time = env_.clock().CurrentTime();
|
||||
EXPECT_TRUE(rtp_sender_video.SendVideo(
|
||||
kPayloadType, kCodecType,
|
||||
capture_time.ms() * kCaptureTimeMsToRtpTimestamp, capture_time,
|
||||
|
||||
@ -163,6 +163,8 @@ webrtc_fuzzer_test("flexfec_header_reader_fuzzer") {
|
||||
webrtc_fuzzer_test("flexfec_sender_fuzzer") {
|
||||
sources = [ "flexfec_sender_fuzzer.cc" ]
|
||||
deps = [
|
||||
"../../api/environment",
|
||||
"../../api/environment:environment_factory",
|
||||
"../../modules/rtp_rtcp",
|
||||
"../../modules/rtp_rtcp:rtp_rtcp_format",
|
||||
"../../system_wrappers",
|
||||
|
||||
@ -10,6 +10,8 @@
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "api/environment/environment.h"
|
||||
#include "api/environment/environment_factory.h"
|
||||
#include "modules/rtp_rtcp/include/flexfec_sender.h"
|
||||
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
|
||||
#include "modules/rtp_rtcp/source/byte_io.h"
|
||||
@ -30,14 +32,21 @@ const std::vector<RtpExtensionSize> kNoRtpHeaderExtensionSizes;
|
||||
} // namespace
|
||||
|
||||
void FuzzOneInput(const uint8_t* data, size_t size) {
|
||||
// Create Environment once because creating it for each input noticably
|
||||
// reduces the speed of the fuzzer.
|
||||
static SimulatedClock* const clock = new SimulatedClock(1);
|
||||
static const Environment* const env =
|
||||
new Environment(CreateEnvironment(clock));
|
||||
|
||||
size_t i = 0;
|
||||
if (size < 5 || size > 200) {
|
||||
return;
|
||||
}
|
||||
SimulatedClock clock(1 + data[i++]);
|
||||
FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, kNoMid,
|
||||
kNoRtpHeaderExtensions, kNoRtpHeaderExtensionSizes,
|
||||
nullptr /* rtp_state */, &clock);
|
||||
// Set time to (1 + data[i++]);
|
||||
clock->AdvanceTimeMicroseconds(1 + data[i++] - clock->TimeInMicroseconds());
|
||||
FlexfecSender sender(*env, kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc,
|
||||
kNoMid, kNoRtpHeaderExtensions,
|
||||
kNoRtpHeaderExtensionSizes, nullptr /* rtp_state */);
|
||||
FecProtectionParams params = {
|
||||
data[i++], static_cast<int>(data[i++] % 100),
|
||||
data[i++] <= 127 ? kFecMaskRandom : kFecMaskBursty};
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user