Change ForwardErrorCorrection class to accept one received packet at a time.

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 57 matching lines @@
     // 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.
+  // Used for the input to DecodeFec().
   //
   // TODO(holmer): Refactor into a proper class.

[stefan-webrtc, 2017/09/15 13:36:13]

May want to just delete this TODO, it's been there for 6 years.

[nisse-webrtc, 2017/09/18 12:39:06]

Done.

+  // TODO(nisse): Or delete, instead passing |is_fec| and |pkt| as
+  // separate arguments.
   class ReceivedPacket : public SortablePacket {
    public:
     ReceivedPacket();
     ~ReceivedPacket();
 
     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.
   };
 
@@ skipping 43 matching lines @@
     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(uint32_t ssrc);
   static std::unique_ptr<ForwardErrorCorrection> CreateFlexfec(
       uint32_t ssrc,
       uint32_t protected_media_ssrc);
@@ skipping 56 matching lines @@
   //                            ReceivedPacket, belonging to a single
   //                            frame. At output the list will be empty,
   //                            with packets either stored internally,
   //                            or accessible through the recovered list.
   // Output: recovered_packets  List of recovered media packets, of type
   //                            RecoveredPacket, belonging to a single
   //                            frame. The memory available through the
   //                            list will be valid until the next call to
   //                            DecodeFec().
   //
-  // Returns 0 on success, -1 on failure.
-  //
-  int DecodeFec(ReceivedPacketList* received_packets,
-                RecoveredPacketList* recovered_packets);
+  void DecodeFec(const ReceivedPacket& received_packet,
+                 RecoveredPacketList* recovered_packets);
 
   // Get the number of generated FEC packets, given the number of media packets
   // and the protection factor.
   static int NumFecPackets(int num_media_packets, int protection_factor);
 
   // Gets the maximum size of the FEC headers in bytes, which must be
   // accounted for as packet overhead.
   size_t MaxPacketOverhead() const;
 
   // Reset internal states from last frame and clear |recovered_packets|.
@@ skipping 24 matching lines @@
   // 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,
                           uint32_t media_ssrc,
                           uint16_t seq_num_base);
 
-  // Inserts the |received_packets| into the internal received FEC packet list
+  // Inserts the |received_packet| into the internal received FEC packet list
   // or into |recovered_packets|.
-  void InsertPackets(ReceivedPacketList* received_packets,
-                     RecoveredPacketList* recovered_packets);
+  void InsertPacket(const ReceivedPacket& received_packet,
+                    RecoveredPacketList* recovered_packets);
 
   // Inserts the |received_packet| into |recovered_packets|. Deletes duplicates.
   void InsertMediaPacket(RecoveredPacketList* recovered_packets,
-                         ReceivedPacket* received_packet);
+                         const ReceivedPacket& received_packet);
 
   // Assigns pointers to the recovered packet from all FEC packets which cover
   // it.
   // Note: This reduces the complexity when we want to try to recover a packet
   // since we don't have to find the intersection between recovered packets and
   // packets covered by the FEC packet.
   void UpdateCoveringFecPackets(const RecoveredPacket& packet);
 
   // Insert |received_packet| into internal FEC list. Deletes duplicates.
   void InsertFecPacket(const RecoveredPacketList& recovered_packets,
-                       ReceivedPacket* received_packet);
+                       const ReceivedPacket& received_packet);
 
   // Assigns pointers to already recovered packets covered by |fec_packet|.
   static void AssignRecoveredPackets(
       const RecoveredPacketList& recovered_packets,
       ReceivedFecPacket* fec_packet);
 
   // Attempt to recover missing packets, using the internally stored
   // received FEC packets.
   void AttemptRecovery(RecoveredPacketList* recovered_packets);
 
@@ skipping 114 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  // MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_