Add FlexFEC header formatters. (pt. 5)

webrtc/modules/rtp_rtcp/source/rtp_fec_unittest.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.
  */
 
 #include <algorithm>
 #include <list>
 #include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/random.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
+#include "webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
 #include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
 
 namespace webrtc {
 
 namespace {
 
 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum.
 constexpr size_t kTransportOverhead = 28;
 
 constexpr uint32_t kMediaSsrc = 83542;
+constexpr uint32_t kFlexfecSsrc = 43245;
 
 // Deep copies |src| to |dst|, but only keeps every Nth packet.
 void DeepCopyEveryNthPacket(const ForwardErrorCorrection::PacketList& src,
                             int n,
                             ForwardErrorCorrection::PacketList* dst) {
   RTC_DCHECK_GT(n, 0);
   int i = 0;
   for (const auto& packet : src) {
     if (i % n == 0) {
       dst->emplace_back(new ForwardErrorCorrection::Packet(*packet));
@@ skipping 105 matching lines @@
 bool RtpFecTest<ForwardErrorCorrectionType>::IsRecoveryComplete() {
   // We must have equally many recovered packets as original packets.
   if (recovered_packets_.size() != media_packets_.size()) {
     return false;
   }
 
   // All recovered packets must be identical to the corresponding
   // original packets.
   using PacketPtr = std::unique_ptr<ForwardErrorCorrection::Packet>;
   using RecoveredPacketPtr =
-    std::unique_ptr<ForwardErrorCorrection::RecoveredPacket>;
+      std::unique_ptr<ForwardErrorCorrection::RecoveredPacket>;
   auto cmp = [](const PacketPtr& media_packet,
                 const RecoveredPacketPtr& recovered_packet) {
     if (media_packet->length != recovered_packet->pkt->length) {
       return false;
     }
-    if (memcmp(media_packet->data,
-               recovered_packet->pkt->data,
+    if (memcmp(media_packet->data, recovered_packet->pkt->data,
                media_packet->length) != 0) {
       return false;
     }
     return true;
   };
   return std::equal(media_packets_.cbegin(), media_packets_.cend(),
                     recovered_packets_.cbegin(), cmp);
 }
 
 // Define gTest typed test to loop over both ULPFEC and FlexFEC.
 // Since the tests now are parameterized, we need to access
 // member variables using |this|, thereby enforcing runtime
 // resolution.
 
+class FlexfecForwardErrorCorrection : public ForwardErrorCorrection {
+ public:
+  FlexfecForwardErrorCorrection()
+      : ForwardErrorCorrection(
+            std::unique_ptr<FecHeaderReader>(new FlexfecHeaderReader()),
+            std::unique_ptr<FecHeaderWriter>(new FlexfecHeaderWriter())) {}
+};
+
 class UlpfecForwardErrorCorrection : public ForwardErrorCorrection {
  public:
   UlpfecForwardErrorCorrection()
       : ForwardErrorCorrection(
             std::unique_ptr<FecHeaderReader>(new UlpfecHeaderReader()),
             std::unique_ptr<FecHeaderWriter>(new UlpfecHeaderWriter())) {}
 };
 
-using FecTypes = Types<UlpfecForwardErrorCorrection>;
+using FecTypes =
+    Types<FlexfecForwardErrorCorrection, UlpfecForwardErrorCorrection>;
 TYPED_TEST_CASE(RtpFecTest, FecTypes);
 
 TYPED_TEST(RtpFecTest, FecRecoveryNoLoss) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
   this->media_packets_ =
       this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
@@ skipping 745 matching lines @@
   this->media_loss_mask_[kNumMediaPackets - 1] = 1;
   this->NetworkReceivedPackets(this->media_loss_mask_, this->fec_loss_mask_);
 
   EXPECT_EQ(0, this->fec_.DecodeFec(&this->received_packets_,
                                     &this->recovered_packets_));
 
   // 5 protected packets lost, one FEC packet, cannot get complete recovery.
   EXPECT_FALSE(this->IsRecoveryComplete());
 }
 
+// 'using' directive needed for compiler to be happy.
+using RtpFecTestWithFlexfec = RtpFecTest<FlexfecForwardErrorCorrection>;
+TEST_F(RtpFecTestWithFlexfec,
+       FecRecoveryWithLossAndDifferentMediaAndFlexfecSsrcs) {
+  constexpr int kNumImportantPackets = 0;
+  constexpr bool kUseUnequalProtection = false;
+  constexpr int kNumMediaPackets = 4;
+  constexpr uint8_t kProtectionFactor = 60;
+
+  media_packets_ =
+      media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
+
+  EXPECT_EQ(0, fec_.EncodeFec(media_packets_, kProtectionFactor,
+                              kNumImportantPackets, kUseUnequalProtection,
+                              kFecMaskBursty, &generated_fec_packets_));
+
+  // Expect 1 FEC packet.
+  EXPECT_EQ(1u, generated_fec_packets_.size());
+
+  // 1 media packet lost
+  memset(media_loss_mask_, 0, sizeof(media_loss_mask_));
+  memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_));
+  media_loss_mask_[3] = 1;
+  NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_);
+
+  // Simulate FlexFEC packet received on different SSRC.
+  auto it = received_packets_.begin();
+  it++;
+  it++;
+  it++;  // Now at the FEC packet.
+  (*it)->ssrc = kFlexfecSsrc;
+
+  EXPECT_EQ(0, fec_.DecodeFec(&received_packets_, &recovered_packets_));
+
+  // One packet lost, one FEC packet, expect complete recovery.
+  EXPECT_TRUE(IsRecoveryComplete());
+  recovered_packets_.clear();

[danilchap, 2016/09/20 15:59:14]

is cleanup a part of the test?

[brandtr, 2016/09/21 11:00:43]

Nope, this was an artifact from the times when we used raw pointers and manual
memory management. Removed.

+}
+
 }  // namespace webrtc