Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/source/fec_header_reader_writer_unittest.cc

+/*

[danilchap, 2016/08/22 13:00:41]

make unittest filename match source file it is testing, i.e. rename this into
flexfec_header_reader_writer_unittest.cc

[brandtr, 2016/08/23 08:19:10]

This file tests the Ulpfec stuff too though. I could split it in two files, but
then I would need a third file for the shared class FecPacketizationTest, or
duplicate some code. What is the best solution here?

(Also note that ForwardErrorCorrection is unit tested in rtp_fec_unittests.cc. I
plan to rename this file when I rename ForwardErrorCorrection!)

+ *  Copyright (c) 2016 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 <string.h>
+
+#include <memory>
+#include <utility>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/random.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;
+
+// ULPFEC header: largest packet mask.
+constexpr size_t kUlpfecMaxHeaderSize = 18;
+
+// FlexFEC header: single protected SSRC with largest packet mask.
+constexpr size_t kFlexfecMaxHeaderSize = 32;
+}  // namespace
+
+class FecPacketizationTest : public ::testing::Test {
+ protected:
+  FecPacketizationTest(std::unique_ptr<FecHeaderReader> fec_header_reader,
+                       std::unique_ptr<FecHeaderWriter> fec_header_writer,
+                       size_t min_packet_size,
+                       size_t max_packet_size)
+      : fec_header_reader_(std::move(fec_header_reader)),
+        fec_header_writer_(std::move(fec_header_writer)),
+        random_(0xabcdef123456),
+        media_packet_generator_(min_packet_size,
+                                max_packet_size,
+                                &random_),
+        packet_mask_() {}
+
+  // Set the corresponding bits of the ULPFEC packet mask.
+  void Bit15Clear();
+  void Bit15Set();
+  void Bit46ClearBit47Clear();
+  void Bit46SetBit47Clear();
+  void Bit46ClearBit47Set();
+  void Bit46SetBit47Set();
+
+  // Randomly generate ULPFEC packet mask of specified size.
+  void GenerateUlpfecPacketMask(size_t packet_mask_size);
+
+  void ReadWriteAndVerifyHeaders(size_t ulpfec_packet_mask_size,
+                                 size_t expected_fec_header_size,
+                                 size_t expected_packet_mask_size);
+
+  virtual void MaybeSetFecSsrcToMediaSsrc(
+      uint32_t media_ssrc,
+      ForwardErrorCorrection::ReceivedFecPacket* fec_packet) = 0;
+
+  virtual size_t ExpectedPacketMaskOffset() = 0;
+
+  std::unique_ptr<FecHeaderReader> fec_header_reader_;
+  std::unique_ptr<FecHeaderWriter> fec_header_writer_;
+
+  Random random_;
+  test::fec::MediaPacketGenerator media_packet_generator_;
+  ForwardErrorCorrection::PacketList* media_packets_;
+  uint8_t packet_mask_[14];  // Only filled with ULPFEC packet mask (6 bytes),
+                             // but needs to be 14 bytes in order to do
+                             // memcmp with parsed FlexFEC mask.
+};
+
+class UlpfecPacketizationTest : public FecPacketizationTest {
+ protected:
+  UlpfecPacketizationTest()
+      : FecPacketizationTest(
+            std::unique_ptr<FecHeaderReader>(new UlpfecHeaderReader()),
+            std::unique_ptr<FecHeaderWriter>(new UlpfecHeaderWriter()),
+            kRtpHeaderSize,
+            IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead -
+                kUlpfecMaxHeaderSize) {}
+
+  void MaybeSetFecSsrcToMediaSsrc(
+      uint32_t media_ssrc,
+      ForwardErrorCorrection::ReceivedFecPacket* fec_packet) {
+    fec_packet->rtp_ssrc = media_ssrc;
+  }
+
+  size_t ExpectedPacketMaskOffset() { return 12u; }
+};
+
+class FlexfecPacketizationTest : public FecPacketizationTest {
+ protected:
+  FlexfecPacketizationTest()
+      : FecPacketizationTest(
+            std::unique_ptr<FecHeaderReader>(new FlexfecHeaderReader()),
+            std::unique_ptr<FecHeaderWriter>(new FlexfecHeaderWriter()),
+            kRtpHeaderSize,
+            IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead -
+                kFlexfecMaxHeaderSize) {}
+
+  void MaybeSetFecSsrcToMediaSsrc(
+      uint32_t media_ssrc,
+      ForwardErrorCorrection::ReceivedFecPacket* fec_packet) {}
+
+  size_t ExpectedPacketMaskOffset() { return 18u; }
+};
+
+// Verifies that the header size is correctly calculated.
+TEST_F(UlpfecPacketizationTest, HeaderSizeTest) {
+  constexpr size_t kShortMask = kUlpfecPacketMaskSizeLBitClear;
+  GenerateUlpfecPacketMask(kShortMask);
+  EXPECT_EQ(14u, fec_header_writer_->FecHeaderSize(
+                     fec_header_writer_->MinPacketMaskSize(packet_mask_,
+                                                           kShortMask)));
+
+  constexpr size_t kLongMask = kUlpfecPacketMaskSizeLBitSet;
+  GenerateUlpfecPacketMask(kLongMask);
+  EXPECT_EQ(
+      18u, fec_header_writer_->FecHeaderSize(
+               fec_header_writer_->MinPacketMaskSize(packet_mask_, kLongMask)));
+}
+
+// Verifies that the reading and writing operations are consistent.
+TEST_F(UlpfecPacketizationTest, ReaderWriterTest) {
+  SCOPED_TRACE("");  // To get call site line number, if failing.
+
+  constexpr size_t kShortMask = kUlpfecPacketMaskSizeLBitClear;
+  GenerateUlpfecPacketMask(kShortMask);
+  ReadWriteAndVerifyHeaders(kShortMask, 14u, 2u);
+
+  constexpr size_t kLongMask = kUlpfecPacketMaskSizeLBitSet;
+  GenerateUlpfecPacketMask(kLongMask);
+  ReadWriteAndVerifyHeaders(kLongMask, 18u, 6u);
+}
+
+// Verifies that a correct FlexFEC packet mask size is
+// calculated, given an ULPFEC packet mask size.
+TEST_F(FlexfecPacketizationTest, HeaderSizeExpansionTest) {
+  constexpr size_t kShortMask = kUlpfecPacketMaskSizeLBitClear;
+  GenerateUlpfecPacketMask(kShortMask);
+  Bit15Clear();
+  EXPECT_EQ(20u, fec_header_writer_->FecHeaderSize(
+                     fec_header_writer_->MinPacketMaskSize(packet_mask_,
+                                                           kShortMask)));
+  GenerateUlpfecPacketMask(kShortMask);
+  Bit15Set();
+  EXPECT_EQ(24u, fec_header_writer_->FecHeaderSize(
+                     fec_header_writer_->MinPacketMaskSize(packet_mask_,
+                                                           kShortMask)));
+
+  constexpr size_t kLongMask = kUlpfecPacketMaskSizeLBitSet;
+  GenerateUlpfecPacketMask(kLongMask);
+  Bit46ClearBit47Clear();
+  EXPECT_EQ(
+      24u, fec_header_writer_->FecHeaderSize(
+               fec_header_writer_->MinPacketMaskSize(packet_mask_, kLongMask)));
+  GenerateUlpfecPacketMask(kLongMask);
+  Bit46SetBit47Clear();
+  EXPECT_EQ(
+      32u, fec_header_writer_->FecHeaderSize(
+               fec_header_writer_->MinPacketMaskSize(packet_mask_, kLongMask)));
+  GenerateUlpfecPacketMask(kLongMask);
+  Bit46ClearBit47Set();
+  EXPECT_EQ(
+      32u, fec_header_writer_->FecHeaderSize(
+               fec_header_writer_->MinPacketMaskSize(packet_mask_, kLongMask)));
+  GenerateUlpfecPacketMask(kLongMask);
+  Bit46SetBit47Set();
+  EXPECT_EQ(
+      32u, fec_header_writer_->FecHeaderSize(
+               fec_header_writer_->MinPacketMaskSize(packet_mask_, kLongMask)));
+}
+
+// Verifies that the reading and writing operations are consistent.
+TEST_F(FlexfecPacketizationTest, ReaderWriterTest) {
+  SCOPED_TRACE("");  // To get call site line number, if failing.
+
+  constexpr size_t kShortMask = kUlpfecPacketMaskSizeLBitClear;
+  GenerateUlpfecPacketMask(kShortMask);
+  Bit15Clear();
+  ReadWriteAndVerifyHeaders(kShortMask, 20u, 2u);
+  Bit15Set();
+  ReadWriteAndVerifyHeaders(kShortMask, 24u, 6u);
+
+  constexpr size_t kLongMask = kUlpfecPacketMaskSizeLBitSet;
+  GenerateUlpfecPacketMask(kLongMask);
+  Bit46ClearBit47Clear();
+  ReadWriteAndVerifyHeaders(kLongMask, 24u, 6u);
+  Bit46SetBit47Clear();
+  ReadWriteAndVerifyHeaders(kLongMask, 32u, 14u);
+  Bit46ClearBit47Set();
+  ReadWriteAndVerifyHeaders(kLongMask, 32u, 14u);
+  Bit46SetBit47Set();
+  ReadWriteAndVerifyHeaders(kLongMask, 32u, 14u);
+}
+
+void FecPacketizationTest::Bit15Clear() {
+  packet_mask_[1] &= 0xfe;
+}
+
+void FecPacketizationTest::Bit15Set() {
+  packet_mask_[1] |= 0x01;
+}
+
+void FecPacketizationTest::Bit46ClearBit47Clear() {
+  packet_mask_[5] &= 0xfc;
+}
+
+void FecPacketizationTest::Bit46SetBit47Clear() {
+  Bit46ClearBit47Clear();
+  packet_mask_[5] ^= 0x02;
+}
+
+void FecPacketizationTest::Bit46ClearBit47Set() {
+  Bit46ClearBit47Clear();
+  packet_mask_[5] ^= 0x01;
+}
+
+void FecPacketizationTest::Bit46SetBit47Set() {
+  packet_mask_[5] |= 0x03;
+}
+
+void FecPacketizationTest::GenerateUlpfecPacketMask(size_t packet_mask_size) {
+  RTC_DCHECK_LE(packet_mask_size, 6u);
+  memset(packet_mask_, 0u, 14);
+  for (size_t i = 0; i < packet_mask_size; ++i) {
+    packet_mask_[i] = random_.Rand<uint8_t>();
+  }
+}
+
+void FecPacketizationTest::ReadWriteAndVerifyHeaders(
+    size_t ulpfec_packet_mask_size,
+    size_t expected_fec_header_size,
+    size_t expected_packet_mask_size) {
+  // Generate media.
+  constexpr int kNumMediaPackets = 1;
+  media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
+  ForwardErrorCorrection::PacketList* media_packets =
+      media_packet_generator_.GetMediaPackets();
+  uint32_t media_ssrc = media_packet_generator_.GetSsrc();
+  uint16_t media_seq_num =
+      media_packet_generator_.GetFecSeqNum() - kNumMediaPackets;
+
+  // Set up FEC packet containers.
+  ForwardErrorCorrection::Packet* sent_fec_packet =
+      new ForwardErrorCorrection::Packet();  // deleted by scoped_refptr in
+                                             // |received_fec_packet|
+  sent_fec_packet->length = media_packets->front()->length;
+  for (size_t i = 0; i < sent_fec_packet->length; ++i) {
+    sent_fec_packet->data[i] = random_.Rand<uint8_t>();
+  }
+  ForwardErrorCorrection::ReceivedFecPacket received_fec_packet;
+  received_fec_packet.pkt = sent_fec_packet;
+
+  // Write FEC header.
+  fec_header_writer_->FinalizeFecHeader(
+      *media_packets, packet_mask_, ulpfec_packet_mask_size, sent_fec_packet);
+
+  // Read FEC header.
+  MaybeSetFecSsrcToMediaSsrc(media_ssrc, &received_fec_packet);
+  EXPECT_TRUE(fec_header_reader_->ReadFecHeader(&received_fec_packet));
+
+  // Verify that written and read FEC headers are consistent.
+  EXPECT_EQ(expected_fec_header_size, received_fec_packet.fec_header_size);
+  EXPECT_EQ(received_fec_packet.pkt->length - expected_fec_header_size,
+            received_fec_packet.protection_length);
+  auto packet_mask_info = received_fec_packet.packet_mask_info[media_ssrc];
+  uint16_t seq_num_base = std::get<0>(packet_mask_info);
+  EXPECT_EQ(media_seq_num, seq_num_base);
+  size_t packet_mask_offset = std::get<1>(packet_mask_info);
+  EXPECT_EQ(ExpectedPacketMaskOffset(), packet_mask_offset);
+  size_t packet_mask_size = std::get<2>(packet_mask_info);
+  ASSERT_EQ(expected_packet_mask_size, packet_mask_size);
+  EXPECT_EQ(0, memcmp(packet_mask_,
+                      &received_fec_packet.pkt->data[packet_mask_offset],
+                      packet_mask_size));
+  EXPECT_EQ(0, memcmp(&sent_fec_packet->data[expected_fec_header_size],
+                      &received_fec_packet.pkt->data[expected_fec_header_size],
+                      sent_fec_packet->length - expected_fec_header_size));
+}
+
+}  // namespace webrtc