Add FlexFEC header formatters. (pt. 5)

webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc

+/*
+ *  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/basictypes.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/random.h"
+#include "webrtc/base/scoped_ref_ptr.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/forward_error_correction_internal.h"
+
+namespace webrtc {
+
+namespace {
+
+using Packet = ::webrtc::ForwardErrorCorrection::Packet;
+using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket;
+
+constexpr uint32_t kMediaSsrc = 1254983;
+constexpr uint16_t kMediaStartSeqNum = 825;
+constexpr size_t kMediaPacketLength = 1234;
+constexpr uint32_t kFlexfecSsrc = 52142;
+
+// Assume single-stream protection.
+constexpr size_t kFlexfecHeaderSize0KBitsSet = 20;
+constexpr size_t kFlexfecHeaderSize1KBitsSet = 24;
+constexpr size_t kFlexfecHeaderSize2KBitsSet = 32;

[brandtr, 2016/09/14 11:45:54]

See comment in implementation file.

+constexpr size_t kFlexfecPacketMaskOffset = 18;
+constexpr size_t kFlexfecPacketMaskSize0KBitsSet = 2;
+constexpr size_t kFlexfecPacketMaskSize1KBitsSet = 6;
+constexpr size_t kFlexfecPacketMaskSize2KBitsSet = 14;
+constexpr size_t kFlexfecMaxPacketSize = kFlexfecPacketMaskSize2KBitsSet;
+
+std::unique_ptr<uint8_t[]> GeneratePacketMask(size_t packet_mask_size,
+                                              uint64_t seed) {
+  Random random(seed);
+  std::unique_ptr<uint8_t[]> packet_mask(new uint8_t[kFlexfecMaxPacketSize]);
+  memset(packet_mask.get(), 0, kFlexfecMaxPacketSize);
+  for (size_t i = 0; i < packet_mask_size; ++i) {
+    packet_mask[i] = random.Rand<uint8_t>();
+  }
+  return packet_mask;
+}
+
+void ClearBit(size_t index, uint8_t* packet_mask) {
+  packet_mask[index / 8] &= ~(1 << (7 - index % 8));
+}
+
+void SetBit(size_t index, uint8_t* packet_mask) {
+  packet_mask[index / 8] |= (1 << (7 - index % 8));
+}
+
+rtc::scoped_refptr<Packet> WriteHeader(const uint8_t* packet_mask,
+                                       size_t packet_mask_size) {
+  FlexfecHeaderWriter writer;
+  rtc::scoped_refptr<Packet> written_packet(new Packet());
+  written_packet->length = kMediaPacketLength;
+  for (size_t i = 0; i < written_packet->length; ++i) {
+    written_packet->data[i] = i;  // Actual content doesn't matter.
+  }
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
+                           packet_mask_size, written_packet.get());
+  return written_packet;
+}
+
+std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& written_packet) {
+  FlexfecHeaderReader reader;
+  std::unique_ptr<ReceivedFecPacket> read_packet(new ReceivedFecPacket());
+  read_packet->ssrc = kFlexfecSsrc;
+  read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
+  memcpy(read_packet->pkt->data, written_packet.data, written_packet.length);
+  read_packet->pkt->length = written_packet.length;
+  EXPECT_TRUE(reader.ReadFecHeader(read_packet.get()));
+  return read_packet;
+}
+
+void VerifyHeaders(size_t expected_fec_header_size,
+                   const uint8_t* expected_packet_mask,
+                   size_t expected_packet_mask_size,
+                   const Packet& written_packet,
+                   const ReceivedFecPacket& read_packet) {
+  EXPECT_EQ(kFlexfecSsrc, read_packet.ssrc);
+  EXPECT_EQ(expected_fec_header_size, read_packet.fec_header_size);
+  EXPECT_EQ(kMediaSsrc, read_packet.protected_ssrc);
+  EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base);
+  EXPECT_EQ(kFlexfecPacketMaskOffset, read_packet.packet_mask_offset);
+  ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size);
+  EXPECT_EQ(written_packet.length - expected_fec_header_size,
+            read_packet.protection_length);
+  // Verify that the call to ReadFecHeader did normalize the packet masks.
+  EXPECT_EQ(0, memcmp(expected_packet_mask,
+                      &read_packet.pkt->data[read_packet.packet_mask_offset],
+                      read_packet.packet_mask_size));
+  // Verify that the call to ReadFecHeader did not tamper with the payload.
+  EXPECT_EQ(0, memcmp(&written_packet.data[expected_fec_header_size],
+                      &read_packet.pkt->data[expected_fec_header_size],
+                      written_packet.length - expected_fec_header_size));
+}
+
+}  // namespace
+
+TEST(FlexfecHeaderReaderWriterTest,
+     ContractsShortUlpfecPacketMaskWithBit15Clear) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(15, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSize0KBitsSet, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSize0KBitsSet,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest, ExpandsShortUlpfecPacketMaskWithBit15Set) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(15, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSize1KBitsSet, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSize1KBitsSet,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     ContractsLongUlpfecPacketMaskWithBits46And47Clear) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSize1KBitsSet, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSize1KBitsSet,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     ExpandsLongUlpfecPacketMaskWithBits46And47Clear) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSize2KBitsSet, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSize2KBitsSet,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     ExpandsLongUlpfecPacketMaskWithBit46ClearBit47Set) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSize2KBitsSet, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSize2KBitsSet,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     ExpandsLongUlpfecPacketMaskWithBits46And47Set) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSize2KBitsSet, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSize2KBitsSet,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Clear) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(15, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSize0KBitsSet, packet_mask.get(),
+                kFlexfecPacketMaskSize0KBitsSet, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Set) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(15, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSize1KBitsSet, packet_mask.get(),
+                kFlexfecPacketMaskSize1KBitsSet, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Clear) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSize1KBitsSet, packet_mask.get(),
+                kFlexfecPacketMaskSize1KBitsSet, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderWithMaskBit46SetBit47Clear) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSize2KBitsSet, packet_mask.get(),
+                kFlexfecPacketMaskSize2KBitsSet, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderMaskWithBit46ClearBit47Set) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSize2KBitsSet, packet_mask.get(),
+                kFlexfecPacketMaskSize2KBitsSet, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Set) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSize2KBitsSet, packet_mask.get(),
+                kFlexfecPacketMaskSize2KBitsSet, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     ReadPacketWithoutStreamSpecificHeaderShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 12;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderReaderWriterTest, ReadShortPacketWithKBit0SetShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 18;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderReaderWriterTest, ReadShortPacketWithKBit1SetShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(15, packet_mask.get());  // This expands the packet mask "once".
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 20;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderReaderWriterTest, ReadShortPacketWithKBit2SetShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(47, packet_mask.get());  // This expands the packet mask "twice".
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 24;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+}  // namespace webrtc