Reland of Only compare sequence numbers from the same SSRC in ForwardErrorCorrection.

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 15 matching lines @@
 
 namespace webrtc {
 
 class FecHeaderReader;
 class FecHeaderWriter;
 
 // Performs codec-independent forward error correction (FEC), based on RFC 5109.
 // Option exists to enable unequal protection (UEP) across packets.
 // This is not to be confused with protection within packets
 // (referred to as uneven level protection (ULP) in RFC 5109).
+// TODO(brandtr): Split this class into a separate encoder
+// and a separate decoder.
 class ForwardErrorCorrection {
  public:
   // TODO(holmer): As a next step all these struct-like packet classes should be
   // refactored into proper classes, and their members should be made private.
   // This will require parts of the functionality in forward_error_correction.cc
   // and receiver_fec.cc to be refactored into the packet classes.
   class Packet {
    public:
     Packet();
     virtual ~Packet();
 
     // Add a reference.
     virtual int32_t AddRef();
 
     // Release a reference. Will delete the object if the reference count
     // reaches zero.
     virtual int32_t Release();
 
     size_t length;                 // Length of packet in bytes.
     uint8_t data[IP_PACKET_SIZE];  // Packet data.
 
    private:
     int32_t ref_count_;  // Counts the number of references to a packet.
   };
 
   // TODO(holmer): Refactor into a proper class.
   class SortablePacket {
    public:
     // Functor which returns true if the sequence number of |first|
-    // is < the sequence number of |second|.
+    // is < the sequence number of |second|. Should only ever be called for
+    // packets belonging to the same SSRC.
     struct LessThan {
       template <typename S, typename T>
       bool operator() (const S& first, const T& second);
     };
 
+    uint32_t ssrc;
     uint16_t seq_num;
   };
 
   // The received list parameter of DecodeFec() references structs of this type.
   //
-  // The ssrc member is needed to ensure that we can restore the SSRC field of
-  // recovered packets. In most situations this could be retrieved from other
-  // media packets, but in the case of an FEC packet protecting a single
-  // missing media packet, we have no other means of obtaining it.
   // TODO(holmer): Refactor into a proper class.
   class ReceivedPacket : public SortablePacket {
    public:
     ReceivedPacket();
     ~ReceivedPacket();
 
-    uint32_t ssrc;  // SSRC of the current frame. Must be set for FEC
-                    // packets, but not required for media packets.
     bool is_fec;    // Set to true if this is an FEC packet and false
                     // otherwise.
     rtc::scoped_refptr<Packet> pkt;  // Pointer to the packet storage.
   };
 
   // The recovered list parameter of DecodeFec() references structs of
   // this type.
   // TODO(holmer): Refactor into a proper class.
   class RecoveredPacket : public SortablePacket {
    public:
     RecoveredPacket();
     ~RecoveredPacket();
 
     bool was_recovered;  // Will be true if this packet was recovered by
                          // the FEC. Otherwise it was a media packet passed in
                          // through the received packet list.
     bool returned;  // True when the packet already has been returned to the
                     // caller through the callback.
     rtc::scoped_refptr<Packet> pkt;  // Pointer to the packet storage.
   };
 
   // Used to link media packets to their protecting FEC packets.
   //
   // TODO(holmer): Refactor into a proper class.
-  class ProtectedPacket : public ForwardErrorCorrection::SortablePacket {
+  class ProtectedPacket : public SortablePacket {
    public:
     ProtectedPacket();
     ~ProtectedPacket();
 
     rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt;
   };
 
   using ProtectedPacketList = std::list<std::unique_ptr<ProtectedPacket>>;
 
   // Used for internal storage of received FEC packets in a list.
   //
   // TODO(holmer): Refactor into a proper class.
-  class ReceivedFecPacket : public ForwardErrorCorrection::SortablePacket {
+  class ReceivedFecPacket : public SortablePacket {
    public:
     ReceivedFecPacket();
     ~ReceivedFecPacket();
 
     // List of media packets that this FEC packet protects.
     ProtectedPacketList protected_packets;
     // RTP header fields.
     uint32_t ssrc;
     // FEC header fields.
     size_t fec_header_size;
     uint32_t protected_ssrc;
     uint16_t seq_num_base;
     size_t packet_mask_offset;  // Relative start of FEC header.
     size_t packet_mask_size;
     size_t protection_length;
     // Raw data.
     rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt;
   };
 
   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();
+  static std::unique_ptr<ForwardErrorCorrection> CreateUlpfec(uint32_t ssrc);
+  static std::unique_ptr<ForwardErrorCorrection> CreateFlexfec(
+      uint32_t ssrc,
+      uint32_t protected_media_ssrc);
 
   // 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 70 matching lines @@
   // Frees all memory allocated by this class.
   void ResetState(RecoveredPacketList* recovered_packets);
 
   // TODO(brandtr): Remove these functions when the Packet classes
   // have been refactored.
   static uint16_t ParseSequenceNumber(uint8_t* packet);
   static uint32_t ParseSsrc(uint8_t* packet);
 
  protected:
   ForwardErrorCorrection(std::unique_ptr<FecHeaderReader> fec_header_reader,
-                         std::unique_ptr<FecHeaderWriter> fec_header_writer);
+                         std::unique_ptr<FecHeaderWriter> fec_header_writer,
+                         uint32_t ssrc,
+                         uint32_t protected_media_ssrc);
 
  private:
   // Analyzes |media_packets| for holes in the sequence and inserts zero columns
   // into the |packet_mask| where those holes are found. Zero columns means that
   // those packets will have no protection.
   // Returns the number of bits used for one row of the new packet mask.
   // Requires that |packet_mask| has at least 6 * |num_fec_packets| bytes
   // allocated.
   int InsertZerosInPacketMasks(const PacketList& media_packets,
                                size_t num_fec_packets);
@@ skipping 67 matching lines @@
   // Get the number of missing media packets which are covered by |fec_packet|.
   // An FEC packet can recover at most one packet, and if zero packets are
   // missing the FEC packet can be discarded. This function returns 2 when two
   // or more packets are missing.
   static int NumCoveredPacketsMissing(const ReceivedFecPacket& fec_packet);
 
   // Discards old packets in |recovered_packets|, which are no longer relevant
   // for recovering lost packets.
   void DiscardOldRecoveredPackets(RecoveredPacketList* recovered_packets);
 
+  // These SSRCs are only used by the decoder.
+  const uint32_t ssrc_;
+  const uint32_t protected_media_ssrc_;
+
   std::unique_ptr<FecHeaderReader> fec_header_reader_;
   std::unique_ptr<FecHeaderWriter> fec_header_writer_;
 
   std::vector<Packet> generated_fec_packets_;
   ReceivedFecPacketList received_fec_packets_;
 
   // Arrays used to avoid dynamically allocating memory when generating
   // the packet masks.
   // (There are never more than |kUlpfecMaxMediaPackets| FEC packets generated.)
   uint8_t packet_masks_[kUlpfecMaxMediaPackets * kUlpfecMaxPacketMaskSize];
@@ skipping 63 matching lines @@
                   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_