Only compare sequence numbers from the same SSRC in ForwardErrorCorrection.

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 60 matching lines @@
       memcpy(duplicate_packet->pkt->data, received_packet->pkt->data,
              received_packet->pkt->length);
       duplicate_packet->pkt->length = received_packet->pkt->length;
 
       to_decode_list->push_back(std::move(duplicate_packet));
       random_variable = random->Rand<float>();
     }
   }
 }
 
-// Too slow to finish before timeout on iOS. See webrtc:4755.
-#if defined(WEBRTC_IOS)
-#define MAYBE_FecTest DISABLED_FecTest
-#else
-#define MAYBE_FecTest FecTest
-#endif
-TEST(FecTest, MAYBE_FecTest) {
+void RunTest(bool use_flexfec) {
   // TODO(marpan): Split this function into subroutines/helper functions.
   enum { kMaxNumberMediaPackets = 48 };
   enum { kMaxNumberFecPackets = 48 };
 
   const uint32_t kNumMaskBytesL0 = 2;
   const uint32_t kNumMaskBytesL1 = 6;
 
   // FOR UEP
   const bool kUseUnequalProtection = true;
 
   // FEC mask types.
   const FecMaskType kMaskTypes[] = {kFecMaskRandom, kFecMaskBursty};
   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.";
 
-  std::unique_ptr<ForwardErrorCorrection> fec =
-      ForwardErrorCorrection::CreateUlpfec();
+  std::unique_ptr<ForwardErrorCorrection> fec;
+  if (use_flexfec) {
+    fec = ForwardErrorCorrection::CreateFlexfec();
+  } else {
+    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);
   const float reorder_rate = 0.1f;
   const float duplicate_rate = 0.1f;
 
   uint8_t media_loss_mask[kMaxNumberMediaPackets];
   uint8_t fec_loss_mask[kMaxNumberFecPackets];
   uint8_t fec_packet_masks[kMaxNumberFecPackets][kMaxNumberMediaPackets];
 
   // Seed the random number generator, storing the seed to file in order to
   // reproduce past results.
   const unsigned int random_seed = static_cast<unsigned int>(time(nullptr));
   Random random(random_seed);
   std::string filename = webrtc::test::OutputPath() + "randomSeedLog.txt";
   FILE* random_seed_file = fopen(filename.c_str(), "a");
   fprintf(random_seed_file, "%u\n", random_seed);
   fclose(random_seed_file);
   random_seed_file = nullptr;
 
   uint16_t seq_num = 0;
   uint32_t timestamp = random.Rand<uint32_t>();
-  const uint32_t ssrc = random.Rand(1u, 0xfffffffe);
+  const uint32_t media_ssrc = random.Rand(1u, 0xfffffffe);
+  uint32_t fec_ssrc;
+  uint16_t fec_seq_num_offset;
+  if (use_flexfec) {
+    fec_ssrc = random.Rand(1u, 0xfffffffe);
+    fec_seq_num_offset = random.Rand<uint16_t>();
+  } else {
+    fec_ssrc = media_ssrc;
+    fec_seq_num_offset = 0;
+  }
 
   // Loop over the mask types: random and bursty.
   for (int mask_type_idx = 0; mask_type_idx < kNumFecMaskTypes;
        ++mask_type_idx) {
     for (uint32_t loss_rate_idx = 0; loss_rate_idx < loss_rate_size;
          ++loss_rate_idx) {
       printf("Loss rate: %.2f, Mask type %d \n", loss_rate[loss_rate_idx],
              mask_type_idx);
 
       const uint32_t packet_mask_max = kMaxMediaPackets[mask_type_idx];
@@ skipping 109 matching lines @@
               // the marker bit set followed by the last packet of
               // the frame for which the marker bit is set.
               // Only push one (fake) frame to the FEC.
               media_packet->data[1] &= 0x7f;
 
               ByteWriter<uint16_t>::WriteBigEndian(&media_packet->data[2],
                                                    seq_num);
               ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[4],
                                                    timestamp);
               ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8],
-                                                   ssrc);
+                                                   media_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->EncodeFec(media_packet_list, protection_factor,
@@ skipping 13 matching lines @@
 
               if (loss_random_variable >= loss_rate[loss_rate_idx]) {
                 media_loss_mask[media_packet_idx] = 1;
                 std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>
                     received_packet(
                         new ForwardErrorCorrection::ReceivedPacket());
                 received_packet->pkt = new ForwardErrorCorrection::Packet();
                 received_packet->pkt->length = media_packet->length;
                 memcpy(received_packet->pkt->data, media_packet->data,
                        media_packet->length);
+                received_packet->ssrc = media_ssrc;
                 received_packet->seq_num =
                     ByteReader<uint16_t>::ReadBigEndian(&media_packet->data[2]);
                 received_packet->is_fec = false;
                 received_packet_list.push_back(std::move(received_packet));
               }
               media_packet_idx++;
             }
 
             memset(fec_loss_mask, 0, sizeof(fec_loss_mask));
             uint32_t fec_packet_idx = 0;
             for (auto* fec_packet : fec_packet_list) {
               const float loss_random_variable = random.Rand<float>();
               if (loss_random_variable >= loss_rate[loss_rate_idx]) {
                 fec_loss_mask[fec_packet_idx] = 1;
                 std::unique_ptr<ForwardErrorCorrection::ReceivedPacket>
                     received_packet(
                         new ForwardErrorCorrection::ReceivedPacket());
                 received_packet->pkt = new ForwardErrorCorrection::Packet();
                 received_packet->pkt->length = fec_packet->length;
                 memcpy(received_packet->pkt->data, fec_packet->data,
                        fec_packet->length);
-                received_packet->seq_num = seq_num;
+                received_packet->seq_num = fec_seq_num_offset + seq_num;
                 received_packet->is_fec = true;
-                received_packet->ssrc = ssrc;
+                received_packet->ssrc = fec_ssrc;
                 received_packet_list.push_back(std::move(received_packet));
 
                 fec_mask_list.push_back(fec_packet_masks[fec_packet_idx]);
               }
               ++fec_packet_idx;
               ++seq_num;
             }
 
 #ifdef VERBOSE_OUTPUT
             printf("Media loss mask:\n");
@@ skipping 107 matching lines @@
       }      // loop over num_media_packets
     }  // loop over loss rates
   }    // 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";
 }
 
+// Too slow to finish before timeout on iOS. See webrtc:4755.
+#if defined(WEBRTC_IOS)
+#define MAYBE_UlpecTest DISABLED_UlpecTest
+#define MAYBE_FlexfecTest DISABLED_FlexfecTest
+#else
+#define MAYBE_UlpecTest UlpecTest
+#define MAYBE_FlexfecTest FlexfecTest
+#endif
+TEST(FecTest, MAYBE_UlpecTest) {
+  RunTest(false);
+}
+
+TEST(FecTest, MAYBE_FlexfecTest) {
+  RunTest(true);
+}
+
 }  // namespace test
 }  // namespace webrtc