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

Bug: webrtc:11340
Change-Id: If3493db9fafdd3ad041f78999e304c8714be517f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/186562
Reviewed-by: Sebastian Jansson <[email protected]>
Commit-Queue: Erik Språng <[email protected]>
Cr-Commit-Position: refs/heads/master@{#32349}

Author: Erik Språng

call/rtp_video_sender.cc

@@ -197,7 +197,6 @@ std::vector<RtpStreamSender> CreateRtpStreamSenders(
     FrameEncryptorInterface* frame_encryptor,
     const CryptoOptions& crypto_options,
     rtc::scoped_refptr<FrameTransformerInterface> frame_transformer,
-    bool use_deferred_fec,
     const WebRtcKeyValueConfig& trials) {
   RTC_DCHECK_GT(rtp_config.ssrcs.size(), 0);
 
@@ -245,9 +244,6 @@ std::vector<RtpStreamSender> CreateRtpStreamSenders(
     std::unique_ptr<VideoFecGenerator> fec_generator =
         MaybeCreateFecGenerator(clock, rtp_config, suspended_ssrcs, i, trials);
     configuration.fec_generator = fec_generator.get();
-    if (!use_deferred_fec) {
-      video_config.fec_generator = fec_generator.get();
-    }
 
     configuration.rtx_send_ssrc =
         rtp_config.GetRtxSsrcAssociatedWithMediaSsrc(rtp_config.ssrcs[i]);
@@ -335,9 +331,6 @@ RtpVideoSender::RtpVideoSender(
           field_trials_.Lookup("WebRTC-SendSideBwe-WithOverhead"),
           "Enabled")),
       has_packet_feedback_(TransportSeqNumExtensionConfigured(rtp_config)),
-      use_deferred_fec_(!absl::StartsWith(
-          field_trials_.Lookup("WebRTC-DeferredFecGeneration"),
-          "Disabled")),
       active_(false),
       module_process_thread_(nullptr),
       suspended_ssrcs_(std::move(suspended_ssrcs)),
@@ -356,7 +349,6 @@ RtpVideoSender::RtpVideoSender(
                                           frame_encryptor,
                                           crypto_options,
                                           std::move(frame_transformer),
-                                          use_deferred_fec_,
                                           field_trials_)),
       rtp_config_(rtp_config),
       codec_type_(GetVideoCodecType(rtp_config)),
@@ -844,7 +836,6 @@ int RtpVideoSender::ProtectionRequest(const FecProtectionParams* delta_params,
   *sent_nack_rate_bps = 0;
   *sent_fec_rate_bps = 0;
   for (const RtpStreamSender& stream : rtp_streams_) {
-    if (use_deferred_fec_) {
       stream.rtp_rtcp->SetFecProtectionParams(*delta_params, *key_params);
 
       auto send_bitrate = stream.rtp_rtcp->GetSendRates();
@@ -853,17 +844,6 @@ int RtpVideoSender::ProtectionRequest(const FecProtectionParams* delta_params,
           send_bitrate[RtpPacketMediaType::kForwardErrorCorrection].bps();
       *sent_nack_rate_bps +=
           send_bitrate[RtpPacketMediaType::kRetransmission].bps();
-    } else {
-      if (stream.fec_generator) {
-        stream.fec_generator->SetProtectionParameters(*delta_params,
-                                                      *key_params);
-        *sent_fec_rate_bps += stream.fec_generator->CurrentFecRate().bps();
-      }
-      *sent_video_rate_bps += stream.sender_video->VideoBitrateSent();
-      *sent_nack_rate_bps +=
-          stream.rtp_rtcp->GetSendRates()[RtpPacketMediaType::kRetransmission]
-              .bps<uint32_t>();
-    }
   }
   return 0;
 }

call/rtp_video_sender.h

@@ -172,7 +172,6 @@ class RtpVideoSender : public RtpVideoSenderInterface,
   const FieldTrialBasedConfig field_trials_;
   const bool send_side_bwe_with_overhead_;
   const bool has_packet_feedback_;
-  const bool use_deferred_fec_;
 
   // TODO(holmer): Remove mutex_ once RtpVideoSender runs on the
   // transport task queue.

modules/pacing/pacing_controller_unittest.cc

@@ -2106,10 +2106,7 @@ TEST_P(PacingControllerTest, PaddingTargetAccountsForPaddingRate) {
   AdvanceTimeAndProcess();
 }
 
-TEST_P(PacingControllerTest, SendsDeferredFecPackets) {
-  ScopedFieldTrials trial("WebRTC-DeferredFecGeneration/Enabled/");
-  SetUp();
-
+TEST_P(PacingControllerTest, SendsFecPackets) {
   const uint32_t kSsrc = 12345;
   const uint32_t kFlexSsrc = 54321;
   uint16_t sequence_number = 1234;

modules/rtp_rtcp/source/rtp_sender_egress.cc

@@ -101,11 +101,7 @@ RtpSenderEgress::RtpSenderEgress(const RtpRtcpInterface::Configuration& config,
       is_audio_(config.audio),
 #endif
       need_rtp_packet_infos_(config.need_rtp_packet_infos),
-      fec_generator_(!IsTrialSetTo(config.field_trials,
-                                   "WebRTC-DeferredFecGeneration",
-                                   "Disabled")
-                         ? config.fec_generator
-                         : nullptr),
+      fec_generator_(config.fec_generator),
       transport_feedback_observer_(config.transport_feedback_callback),
       send_side_delay_observer_(config.send_side_delay_observer),
       send_packet_observer_(config.send_packet_observer),
@@ -176,7 +172,7 @@ void RtpSenderEgress::SendPacket(RtpPacketToSend* packet,
   }
 
   if (fec_generator_ && packet->fec_protect_packet()) {
-    // Deferred fec generation is used, add packet to generator.
+    // This packet should be protected by FEC, add it to packet generator.
     RTC_DCHECK(fec_generator_);
     RTC_DCHECK(packet->packet_type() == RtpPacketMediaType::kVideo);
     absl::optional<std::pair<FecProtectionParams, FecProtectionParams>>

modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -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,19 +1780,13 @@ 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),
         rtp_egress()
             ->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