Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/test/testFec/test_fec.cc

 /*
  *  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 89 matching lines @@
   const int kNumFecMaskTypes = sizeof(kMaskTypes) / sizeof(*kMaskTypes);
 
   // Maximum number of media packets allowed for the mask type.
   const uint16_t kMaxMediaPackets[] = {
       kMaxNumberMediaPackets,
       sizeof(kPacketMaskBurstyTbl) / sizeof(*kPacketMaskBurstyTbl)};
 
   ASSERT_EQ(12, kMaxMediaPackets[1]) << "Max media packets for bursty mode not "
                                      << "equal to 12.";
 
-  ForwardErrorCorrection fec;
+  ForwardErrorCorrection fec = ForwardErrorCorrection::CreateUlpfec();
   ForwardErrorCorrection::PacketList media_packet_list;
   std::list<ForwardErrorCorrection::Packet*> fec_packet_list;
   ForwardErrorCorrection::ReceivedPacketList to_decode_list;
   ForwardErrorCorrection::ReceivedPacketList received_packet_list;
   ForwardErrorCorrection::RecoveredPacketList recovered_packet_list;
   std::list<uint8_t*> fec_mask_list;
 
   // Running over only one loss rate to limit execution time.
   const float loss_rate[] = {0.5f};
   const uint32_t loss_rate_size = sizeof(loss_rate) / sizeof(*loss_rate);
@@ skipping 110 matching lines @@
             // Reset the sequence number here for each FEC code/mask tested
             // below, to avoid sequence number wrap-around. In actual decoding,
             // old FEC packets in list are dropped if sequence number wrap
             // around is detected. This case is currently not handled below.
             seq_num = 0;
             for (uint32_t i = 0; i < num_media_packets; ++i) {
               std::unique_ptr<ForwardErrorCorrection::Packet> media_packet(
                   new ForwardErrorCorrection::Packet());
               const uint32_t kMinPacketSize = 12;
               const uint32_t kMaxPacketSize = static_cast<uint32_t>(
-                  IP_PACKET_SIZE - 12 - 28 -
-                  ForwardErrorCorrection::PacketOverhead());
+                  IP_PACKET_SIZE - 12 - 28 - fec.MaxPacketOverhead());
               media_packet->length = random.Rand(kMinPacketSize,
                                                  kMaxPacketSize);
 
               // Generate random values for the first 2 bytes.
               media_packet->data[0] = random.Rand<uint8_t>();
               media_packet->data[1] = random.Rand<uint8_t>();
 
               // The first two bits are assumed to be 10 by the
               // FEC encoder. In fact the FEC decoder will set the
               // two first bits to 10 regardless of what they
@@ skipping 18 matching lines @@
                                                    ssrc);
               // Generate random values for payload
               for (size_t j = 12; j < media_packet->length; ++j) {
                 media_packet->data[j] = random.Rand<uint8_t>();
               }
               media_packet_list.push_back(std::move(media_packet));
               seq_num++;
             }
             media_packet_list.back()->data[1] |= 0x80;
 
-            ASSERT_EQ(0, fec.GenerateFec(media_packet_list, protection_factor,
-                                         num_imp_packets, kUseUnequalProtection,
-                                         fec_mask_type, &fec_packet_list))
-                << "GenerateFec() failed";
+            ASSERT_EQ(0, fec.EncodeFec(media_packet_list, protection_factor,
+                                       num_imp_packets, kUseUnequalProtection,
+                                       fec_mask_type, &fec_packet_list))
+                << "EncodeFec() failed";
 
             ASSERT_EQ(num_fec_packets, fec_packet_list.size())
                 << "We requested " << num_fec_packets << " FEC packets, but "
-                << "GenerateFec() produced " << fec_packet_list.size();
+                << "EncodeFec() produced " << fec_packet_list.size();
 
             memset(media_loss_mask, 0, sizeof(media_loss_mask));
             uint32_t media_packet_idx = 0;
             for (const auto& media_packet : media_packet_list) {
               // We want a value between 0 and 1.
               const float loss_random_variable = random.Rand<float>();
 
               if (loss_random_variable >= loss_rate[loss_rate_idx]) {
                 media_loss_mask[media_packet_idx] = 1;
                 std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>
@@ skipping 87 matching lines @@
                              num_packets_to_decode, reorder_rate,
                              duplicate_rate, &random);
 
               if (fec_packet_received == false) {
                 for (const auto& received_packet : to_decode_list) {
                   if (received_packet->is_fec) {
                     fec_packet_received = true;
                   }
                 }
               }
-              ASSERT_EQ(0, fec.DecodeFec(&to_decode_list,
-                                         &recovered_packet_list))
+              ASSERT_EQ(0,
+                        fec.DecodeFec(&to_decode_list, &recovered_packet_list))
                   << "DecodeFec() failed";
               ASSERT_TRUE(to_decode_list.empty())
                   << "Received packet list is not empty.";
             }
             media_packet_idx = 0;
             for (const auto& media_packet : media_packet_list) {
               if (media_loss_mask[media_packet_idx] == 1) {
                 // Should have recovered this packet.
                 auto recovered_packet_list_it = recovered_packet_list.cbegin();
 
@@ skipping 40 matching lines @@
   }    // loop over mask types
 
   // Have DecodeFec clear the recovered packet list.
   fec.ResetState(&recovered_packet_list);
   ASSERT_TRUE(recovered_packet_list.empty())
       << "Recovered packet list is not empty";
 }
 
 }  // namespace test
 }  // namespace webrtc