Add FlexfecSender.

webrtc/modules/rtp_rtcp/source/producer_fec.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_
 
 #include <list>
 #include <memory>
 #include <vector>
 
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 
 namespace webrtc {
 
+class FlexfecSenderImpl;
+
 class RedPacket {
  public:
   explicit RedPacket(size_t length);
 
   void CreateHeader(const uint8_t* rtp_header,
                     size_t header_length,
                     int red_payload_type,
                     int payload_type);
   void SetSeqNum(int seq_num);
   void AssignPayload(const uint8_t* payload, size_t length);
   void ClearMarkerBit();
   uint8_t* data() const;
   size_t length() const;
 
  private:
   std::unique_ptr<uint8_t[]> data_;
   size_t length_;
   size_t header_length_;
 };
 
 class ProducerFec {
+  friend class FlexfecSenderImpl;

[danilchap, 2016/10/20 15:12:58]

do you plan to remove this friendship later, after renaming class to
UlpfecSender?
e.g. by moving commong part of ProducerFec and FlexfecSender into a different
(base or helper) class.

[brandtr, 2016/10/24 12:52:08]

Yes, this friendship will be removed in the future. But this will happen when
FlexfecSender is connected to PacedSender, together with the corresponding API
change. So there will never be a base class that both ProducerFec and
FlexfecSender derives from. In fact, ULPFEC will eventually be deprecated, and
ProducerFec will be removed.

Btw, is it appropriate to place this friend line at the top of the class
declaration, or should it be placed somewhere else?

+
  public:
   ProducerFec();
   ~ProducerFec();
 
   static std::unique_ptr<RedPacket> BuildRedPacket(const uint8_t* data_buffer,
                                                    size_t payload_length,
                                                    size_t rtp_header_length,
                                                    int red_payload_type);
 
   void SetFecParameters(const FecProtectionParams* params);
@@ skipping 14 matching lines @@
   size_t MaxPacketOverhead() const;
 
   // Returns generated FEC packets with RED headers added.
   std::vector<std::unique_ptr<RedPacket>> GetUlpfecPacketsAsRed(
       int red_payload_type,
       int ulpfec_payload_type,
       uint16_t first_seq_num,
       size_t rtp_header_length);
 
  private:
+  explicit ProducerFec(std::unique_ptr<ForwardErrorCorrection> fec);
+
   // Overhead is defined as relative to the number of media packets, and not
   // relative to total number of packets. This definition is inherited from the
   // protection factor produced by video_coding module and how the FEC
   // generation is implemented.
   int Overhead() const;
 
   // Returns true if the excess overhead (actual - target) for the FEC is below
   // the amount |kMaxExcessOverhead|. This effects the lower protection level
   // cases and low number of media packets/frame. The target overhead is given
   // by |params_.fec_rate|, and is only achievable in the limit of large number
@@ skipping 13 matching lines @@
   std::list<ForwardErrorCorrection::Packet*> generated_fec_packets_;
   int num_protected_frames_;
   int min_num_media_packets_;
   FecProtectionParams params_;
   FecProtectionParams new_params_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_PRODUCER_FEC_H_