Add FlexfecSender.

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.
  */
 
@@ skipping 76 matching lines @@
 
 uint8_t* RedPacket::data() const {
   return data_.get();
 }
 
 size_t RedPacket::length() const {
   return length_;
 }
 
 UlpfecGenerator::UlpfecGenerator()
-    : fec_(ForwardErrorCorrection::CreateUlpfec()),
+    : UlpfecGenerator(ForwardErrorCorrection::CreateUlpfec()) {}
+
+UlpfecGenerator::UlpfecGenerator(std::unique_ptr<ForwardErrorCorrection> fec)

[stefan-webrtc, 2016/11/02 13:02:42]

This is a bit weird. Why not have a single constructor and initialize like this:
fec_(ForwardErrorCorrection::CreateUlpfec())?

[brandtr, 2016/11/02 14:04:37]

Yes, it's a bit weird. With your suggestion however, the "normal user" of
UlpfecGenerator (i.e. RTPSenderVideo when it's sending RED+ULPFEC) will have to
be aware that UlpfecGenerator under the hood supports multiple FEC header
formatting routines. With this setup, the "normal user" will use the default
constructor, whereas the "friend user" (i.e., FlexfecSenderImpl) will use the
other constructor. (Note that the single-argument constructor is private.)

I don't see a need to make this a more general solution, where UlpfecGenerator
and FlexfecSenderImpl inherit from some common parent, for two reasons: 1) it's
our intention to completely change the interface of FlexfecSender when we move
it to PacedSender, and 2) eventually UlpfecGenerator will be deprecated.

[stefan-webrtc, 2016/11/03 13:42:40]

I see, you do need both constructors? I thought this second constructor was only
used from the first constructor, but if it's used elsewhere I understand.

+    : fec_(std::move(fec)),
       num_protected_frames_(0),
       min_num_media_packets_(1) {
   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,
@@ skipping 25 matching lines @@
 int UlpfecGenerator::AddRtpPacketAndGenerateFec(const uint8_t* data_buffer,
                                                 size_t payload_length,
                                                 size_t rtp_header_length) {
   RTC_DCHECK(generated_fec_packets_.empty());
   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) {
-    // Generic FEC can only protect up to |kUlpfecMaxMediaPackets| packets.
+    // 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;
     memcpy(packet->data, data_buffer, packet->length);
     media_packets_.push_back(std::move(packet));
   }
   if (marker_bit) {
     ++num_protected_frames_;
     complete_frame = true;
   }
@@ skipping 85 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