Use std::unique_ptr 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.
  */
 
 #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_
 #define WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_
 
 #include <stdint.h>
 
 #include <list>
+#include <memory>
 #include <vector>
 
 #include "webrtc/base/refcount.h"
 #include "webrtc/base/scoped_ref_ptr.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
-// Forward declaration.
-class FecPacket;
-
 // 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).
 class ForwardErrorCorrection {
  public:
   // Maximum number of media packets we can protect
   static constexpr size_t kMaxMediaPackets = 48u;
 
   // TODO(holmer): As a next step all these struct-like packet classes should be
@@ skipping 15 matching lines @@
     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:
-    // True if first is <= than second.
-    static bool LessThan(const SortablePacket* first,
-                         const SortablePacket* second);
+    // Functor which returns true if the sequence number of |first|
+    // is < the sequence number of |second|.
+    struct LessThan {
+      template <typename S, typename T>
+      bool operator() (const S& first, const T& second);

[stefan-webrtc, 2016/08/01 11:29:51]

This should be static, right?

[danilchap, 2016/08/01 13:29:07]

it wouldn't compile:
error: overloaded 'operator()' cannot be a static member function

[stefan-webrtc, 2016/08/01 14:33:23]

Good point. But maybe we can make it a static function instead? Or does it have
to be a functor?

+    };
 
     uint16_t seq_num;
   };
 
   // The received list parameter of #DecodeFec() must reference structs of this
   // type. The last_media_pkt_in_frame is not required to be used for correct
   // recovery, but will reduce delay by allowing #DecodeFec() to pre-emptively
   // determine frame completion. If set, we assume a FEC stream, and the
   // following assumptions must hold:
   //
@@ skipping 31 matching lines @@
     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.
     uint8_t length_recovery[2];  // Two bytes used for recovering the packet
                                  // length with XOR operations.
     rtc::scoped_refptr<Packet> pkt;  // Pointer to the packet storage.
   };
 
-  typedef std::list<Packet*> PacketList;
-  typedef std::list<ReceivedPacket*> ReceivedPacketList;
-  typedef std::list<RecoveredPacket*> RecoveredPacketList;
+  using PacketList = std::list<std::unique_ptr<Packet>>;
+  using ReceivedPacketList = std::list<std::unique_ptr<ReceivedPacket>>;
+  using RecoveredPacketList = std::list<std::unique_ptr<RecoveredPacket>>;
 
   ForwardErrorCorrection();
   virtual ~ForwardErrorCorrection();
 
   /**
    * Generates a list of FEC packets from supplied media packets.
    *
    * \param[in]  mediaPacketList     List of media packets to protect, of type
    *                                 #Packet. All packets must belong to the
    *                                 same frame and the list must not be empty.
@@ skipping 20 matching lines @@
    *                                 packets. If the number of media packets is
    *                                 above 12, the packets masks from the
    *                                 random table will be selected.
    * \param[out] fecPacketList       List of FEC packets, of type #Packet. Must
    *                                 be empty on entry. The memory available
    *                                 through the list will be valid until the
    *                                 next call to GenerateFec().
    *
    * \return 0 on success, -1 on failure.
    */
-  int GenerateFec(const PacketList& media_packet_list,
+  int GenerateFec(const PacketList& media_packets,
                   uint8_t protection_factor, int num_important_packets,
                   bool use_unequal_protection, FecMaskType fec_mask_type,
-                  PacketList* fec_packet_list);
+                  std::list<Packet*>* fec_packets);
 
   /**
    *  Decodes a list of media and FEC packets. It will parse the input received
    *  packet list, storing FEC packets internally and inserting media packets to
    *  the output recovered packet list. The recovered list will be sorted by
    *  ascending sequence number and have duplicates removed. The function
    *  should be called as new packets arrive, with the recovered list being
    *  progressively assembled with each call. The received packet list will be
    *  empty at output.
    *
    *  The user will allocate packets submitted through the received list. The
    *  function will handle allocation of recovered packets and optionally
    *  deleting of all packet memory. The user may delete the recovered list
    *  packets, in which case they must remove deleted packets from the
    *  recovered list.
    *
    * \param[in]  receivedPacketList  List of new received packets, of type
    *                                 #ReceivedPacket, belonging to a single
    *                                 frame. At output the list will be empty,
    *                                 with packets  either stored internally,
    *                                 or accessible through the recovered list.
    * \param[out] recoveredPacketList 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().
    *
    * \return 0 on success, -1 on failure.
    */
-  int DecodeFec(ReceivedPacketList* received_packet_list,
-                RecoveredPacketList* recovered_packet_list);
+  int DecodeFec(ReceivedPacketList* received_packets,
+                RecoveredPacketList* recovered_packets);
 
   // Get the number of FEC packets, given the number of media packets and the
   // protection factor.
   int GetNumberOfFecPackets(int num_media_packets, int protection_factor);
 
   // Gets the size in bytes of the FEC/ULP headers, which must be accounted for
   // as packet overhead.
   // \return Packet overhead in bytes.
   static size_t PacketOverhead();
 
-  // Reset internal states from last frame and clear the recovered_packet_list.
+  // Reset internal states from last frame and clears |recovered_packets|.
   // Frees all memory allocated by this class.
-  void ResetState(RecoveredPacketList* recovered_packet_list);
+  void ResetState(RecoveredPacketList* recovered_packets);
 
  private:
-  typedef std::list<FecPacket*> FecPacketList;
+  // Used to link media packets to their protecting FEC packets.
+  //
+  // TODO(holmer): Refactor into a proper class.
+  class ProtectedPacket : public ForwardErrorCorrection::SortablePacket {
+   public:
+    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 {
+   public:
+    ProtectedPacketList protected_pkt_list;
+    uint32_t ssrc;  // SSRC of the current frame.
+    rtc::scoped_refptr<ForwardErrorCorrection::Packet> pkt;
+  };
+
+  using ReceivedFecPacketList = std::list<std::unique_ptr<ReceivedFecPacket>>;
 
   // 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 InsertZerosInBitMasks(const PacketList& media_packets,
                             uint8_t* packet_mask, int num_mask_bytes,
                             int num_fec_packets);
@@ skipping 12 matching lines @@
   // represent the number of bytes used per row for each mask. |num_fec_packets|
   // represent the number of rows of the masks.
   // The copied bit is shifted out from |old_mask| and is shifted one step to
   // the left in |new_mask|. |new_mask| will contain "xxxx xxn0" after this
   // operation, where x are previously inserted bits and n is the new bit.
   static void CopyColumn(uint8_t* new_mask, int new_mask_bytes,
                          uint8_t* old_mask, int old_mask_bytes,
                          int num_fec_packets, int new_bit_index,
                          int old_bit_index);
 
-  void GenerateFecUlpHeaders(const PacketList& media_packet_list,
+  void GenerateFecUlpHeaders(const PacketList& media_packets,
                              uint8_t* packet_mask, int num_fec_packets,
                              bool l_bit);
 
-  void GenerateFecBitStrings(const PacketList& media_packet_list,
+  void GenerateFecBitStrings(const PacketList& media_packets,
                              uint8_t* packet_mask, int num_fec_packets,
                              bool l_bit);
 
   // Insert received packets into FEC or recovered list.
-  void InsertPackets(ReceivedPacketList* received_packet_list,
-                     RecoveredPacketList* recovered_packet_list);
+  void InsertPackets(ReceivedPacketList* received_packets,
+                     RecoveredPacketList* recovered_packets);
 
   // Insert media packet into recovered packet list. We delete duplicates.
   void InsertMediaPacket(ReceivedPacket* rx_packet,
-                         RecoveredPacketList* recovered_packet_list);
+                         RecoveredPacketList* recovered_packets);
 
   // 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(RecoveredPacket* packet);
 
   // Insert packet into FEC list. We delete duplicates.
   void InsertFecPacket(ReceivedPacket* rx_packet,
-                       const RecoveredPacketList* recovered_packet_list);
+                       const RecoveredPacketList* recovered_packets);
 
   // Assigns pointers to already recovered packets covered by this FEC packet.
   static void AssignRecoveredPackets(
-      FecPacket* fec_packet, const RecoveredPacketList* recovered_packets);
+      ReceivedFecPacket* fec_packet,
+      const RecoveredPacketList* recovered_packets);
 
   // Insert into recovered list in correct position.
   void InsertRecoveredPacket(RecoveredPacket* rec_packet_to_insert,
-                             RecoveredPacketList* recovered_packet_list);
+                             RecoveredPacketList* recovered_packets);
 
   // Attempt to recover missing packets.
-  void AttemptRecover(RecoveredPacketList* recovered_packet_list);
+  void AttemptRecover(RecoveredPacketList* recovered_packets);
 
   // Initializes the packet recovery using the FEC packet.
-  static bool StartPacketRecovery(const FecPacket* fec_packet,
+  static bool StartPacketRecovery(const ReceivedFecPacket* fec_packet,
                                   RecoveredPacket* recovered);
 
   // Performs XOR between |src_packet| and |dst_packet| and stores the result
   // in |dst_packet|.
   static void XorPackets(const Packet* src_packet, RecoveredPacket* dst_packet);
 
   // Finish up the recovery of a packet.
   static bool FinishPacketRecovery(RecoveredPacket* recovered);
 
   // Recover a missing packet.
-  bool RecoverPacket(const FecPacket* fec_packet,
+  bool RecoverPacket(const ReceivedFecPacket* fec_packet,
                      RecoveredPacket* rec_packet_to_insert);
 
   // Get the number of missing media packets which are covered by this
   // 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 FecPacket* fec_packet);
+  static int NumCoveredPacketsMissing(const ReceivedFecPacket* fec_packet);
 
-  static void DiscardFecPacket(FecPacket* fec_packet);
-  static void DiscardOldPackets(RecoveredPacketList* recovered_packet_list);
+  static void DiscardOldRecoveredPackets(
+      RecoveredPacketList* recovered_packets);
   static uint16_t ParseSequenceNumber(uint8_t* packet);
 
   std::vector<Packet> generated_fec_packets_;
-  FecPacketList fec_packet_list_;
+  ReceivedFecPacketList received_fec_packets_;
 
   // Arrays used to avoid dynamically allocating memory when generating
   // the packet masks in the ULPFEC headers.
   // (There are never more than |kMaxMediaPackets| FEC packets generated.)
   uint8_t packet_mask_[kMaxMediaPackets * kMaskSizeLBitSet];
   uint8_t tmp_packet_mask_[kMaxMediaPackets * kMaskSizeLBitSet];
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_FORWARD_ERROR_CORRECTION_H_