Add FlexFEC header formatters. (pt. 5)

webrtc/modules/rtp_rtcp/source/forward_error_correction.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.
  */
 
@@ skipping 133 matching lines @@
 
   using PacketList = std::list<std::unique_ptr<Packet>>;
   using ReceivedPacketList = std::list<std::unique_ptr<ReceivedPacket>>;
   using RecoveredPacketList = std::list<std::unique_ptr<RecoveredPacket>>;
   using ReceivedFecPacketList = std::list<std::unique_ptr<ReceivedFecPacket>>;
 
   ~ForwardErrorCorrection();
 
   // Creates a ForwardErrorCorrection tailored for a specific FEC scheme.
   static std::unique_ptr<ForwardErrorCorrection> CreateUlpfec();
+  static std::unique_ptr<ForwardErrorCorrection> CreateFlexfec();
 
   // Generates a list of FEC packets from supplied media packets.
   //
   // Input:  media_packets          List of media packets to protect, of type
   //                                Packet. All packets must belong to the
   //                                same frame and the list must not be empty.
   // Input:  protection_factor      FEC protection overhead in the [0, 255]
   //                                domain. To obtain 100% overhead, or an
   //                                equal number of FEC packets as
   //                                media packets, use 255.
@@ skipping 88 matching lines @@
   // allocated.
   int InsertZerosInPacketMasks(const PacketList& media_packets,
                                size_t num_fec_packets);
 
   // Writes FEC payloads and some recovery fields in the FEC headers.
   void GenerateFecPayloads(const PacketList& media_packets,
                            size_t num_fec_packets);
 
   // Writes the FEC header fields that are not written by GenerateFecPayloads.
   // This includes writing the packet masks.
-  void FinalizeFecHeaders(size_t num_fec_packets, uint16_t seq_num_base);
+  void FinalizeFecHeaders(size_t num_fec_packets,
+                          uint32_t ssrc,
+                          uint16_t seq_num_base);
 
   // Inserts the |received_packets| into the internal received FEC packet list
   // or into |recovered_packets|.
   void InsertPackets(ReceivedPacketList* received_packets,
                      RecoveredPacketList* recovered_packets);
 
   // Inserts the |received_packet| into |recovered_packets|. Deletes duplicates.
   void InsertMediaPacket(RecoveredPacketList* recovered_packets,
                          ReceivedPacket* received_packet);
 
@@ skipping 111 matching lines @@
   // given the discrete options of the ULPFEC masks and the bits
   // set in the current packet mask.
   virtual size_t MinPacketMaskSize(const uint8_t* packet_mask,
                                    size_t packet_mask_size) const = 0;
 
   // The header size (in bytes), given the packet mask size.
   virtual size_t FecHeaderSize(size_t packet_mask_size) const = 0;
 
   // Writes FEC header.
   virtual void FinalizeFecHeader(
+      uint32_t ssrc,
       uint16_t seq_num_base,
       const uint8_t* packet_mask,
       size_t packet_mask_size,
       ForwardErrorCorrection::Packet* fec_packet) const = 0;
 
  protected:
   FecHeaderWriter(size_t max_media_packets,
                   size_t max_fec_packets,
                   size_t max_packet_overhead);
 
   const size_t max_media_packets_;
   const size_t max_fec_packets_;
   const size_t max_packet_overhead_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_