Add experiment to disable ulpfec.

webrtc/modules/rtp_rtcp/source/ulpfec_generator.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h"
 
 #include <memory>
+#include <string>
 #include <utility>
 
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/rtc_base/basictypes.h"
 #include "webrtc/rtc_base/checks.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace webrtc {
 
 namespace {
 
 constexpr size_t kRedForFecHeaderLength = 1;
 
 // This controls the maximum amount of excess overhead (actual - target)
 // allowed in order to trigger EncodeFec(), before |params_.max_fec_frames|
 // is reached. Overhead here is defined as relative to number of media packets.
@@ skipping 18 matching lines @@
 // |kMinMediaPackets| + 1 packets are sent to the FEC code.
 constexpr float kMinMediaPacketsAdaptationThreshold = 2.0f;
 
 // At construction time, we don't know the SSRC that is used for the generated
 // FEC packets, but we still need to give it to the ForwardErrorCorrection ctor
 // to be used in the decoding.
 // TODO(brandtr): Get rid of this awkwardness by splitting
 // ForwardErrorCorrection in two objects -- one encoder and one decoder.
 constexpr uint32_t kUnknownSsrc = 0;
 
+const char kDisableUlpfecExperiment[] = "WebRTC-DisableUlpFecExperiment";
+
+bool DisableUlpfecExperimentEnabled() {
+  std::string experiment_string =
+      webrtc::field_trial::FindFullName(kDisableUlpfecExperiment);

[brandtr, 2017/08/22 14:58:08]

You can use this function instead:
https://cs.chromium.org/chromium/src/third_party/webrtc/system_wrappers/inclu...

[stefan-webrtc, 2017/08/23 13:14:11]

Done.

+  // The experiment is enabled iff the field trial string begins with "Enabled".
+  return experiment_string.find("Enabled") == 0;
+}
+
 }  // namespace
 
 RedPacket::RedPacket(size_t length)
     : data_(new uint8_t[length]), length_(length), header_length_(0) {}
 
 void RedPacket::CreateHeader(const uint8_t* rtp_header,
                              size_t header_length,
                              int red_payload_type,
                              int payload_type) {
   RTC_DCHECK_LE(header_length + kRedForFecHeaderLength, length_);
@@ skipping 30 matching lines @@
 size_t RedPacket::length() const {
   return length_;
 }
 
 UlpfecGenerator::UlpfecGenerator()
     : UlpfecGenerator(ForwardErrorCorrection::CreateUlpfec(kUnknownSsrc)) {}
 
 UlpfecGenerator::UlpfecGenerator(std::unique_ptr<ForwardErrorCorrection> fec)
     : fec_(std::move(fec)),
       num_protected_frames_(0),
-      min_num_media_packets_(1) {
+      min_num_media_packets_(1),
+      ulpfec_disabled_(DisableUlpfecExperimentEnabled()) {
   memset(&params_, 0, sizeof(params_));
   memset(&new_params_, 0, sizeof(new_params_));
 }
 
 UlpfecGenerator::~UlpfecGenerator() = default;
 
 std::unique_ptr<RedPacket> UlpfecGenerator::BuildRedPacket(
     const uint8_t* data_buffer,
     size_t payload_length,
     size_t rtp_header_length,
@@ skipping 17 matching lines @@
     min_num_media_packets_ = kMinMediaPackets;
   } else {
     min_num_media_packets_ = 1;
   }
 }
 
 int UlpfecGenerator::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
                                                 size_t payload_length,
                                                 size_t rtp_header_length) {
   RTC_DCHECK(generated_fec_packets_.empty());
+  if (ulpfec_disabled_)

[brandtr, 2017/08/22 14:58:08]

Is it better to disable ULPFEC here, instead of somewhere higher up? E.g, where
ULPFEC is configured:
https://cs.chromium.org/chromium/src/third_party/webrtc/video/video_send_stre...

If disabled there, ProtectionBitrateCalculator et. al will know that sending FEC
is disabled. But it might be harder to test.

[stefan-webrtc, 2017/08/22 15:06:01]

Yes that's true. I'll consider that tomorrow.

[stefan-webrtc, 2017/08/23 13:14:11]

Done.

+    return 0;
   if (media_packets_.empty()) {
     params_ = new_params_;
   }
   bool complete_frame = false;
   const bool marker_bit = (data_buffer[1] & kRtpMarkerBitMask) ? true : false;
   if (media_packets_.size() < kUlpfecMaxMediaPackets) {
     // Our packet masks can only protect up to |kUlpfecMaxMediaPackets| packets.
     std::unique_ptr<ForwardErrorCorrection::Packet> packet(
         new ForwardErrorCorrection::Packet());
     packet->length = payload_length + rtp_header_length;
@@ skipping 92 matching lines @@
   return (num_fec_packets << 8) / media_packets_.size();
 }
 
 void UlpfecGenerator::ResetState() {
   media_packets_.clear();
   generated_fec_packets_.clear();
   num_protected_frames_ = 0;
 }
 
 }  // namespace webrtc