Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc

Index: webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
diff --git a/webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc b/webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..684856021c84f75db54ccb2931a25b0c99fb0380
--- /dev/null
+++ b/webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.cc
@@ -0,0 +1,273 @@
+/*
+ *  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 "webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.h"
+
+#include <string.h>
+
+#include <utility>
+
+#include "webrtc/base/checks.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
+
+namespace {
+
+// Maximum number of media packets that can be protected in one batch.
+constexpr size_t kMaxMediaPackets = 48;  // Since we are reusing ULPFEC masks.
+
+// Maximum number of FEC packets stored inside ForwardErrorCorrection.
+constexpr size_t kMaxFecPackets = kMaxMediaPackets;
+
+// Size (in bytes) of packet masks, given number of K bits set.
+constexpr size_t kFlexfecPacketMaskSize0K = 2;
+constexpr size_t kFlexfecPacketMaskSize1K = 6;
+constexpr size_t kFlexfecPacketMaskSize2K = 14;
+
+// Size (in bytes) of part of header which is not packet mask specific.
+constexpr size_t kBaseHeaderSize = 12;
+
+// Size (in bytes) of part of header which is packet mask specific,
+// given number of K-bits set.
+constexpr size_t kAuxHeaderSize0K = 6 + kFlexfecPacketMaskSize0K;
+constexpr size_t kAuxHeaderSize1K = 6 + kFlexfecPacketMaskSize1K;
+constexpr size_t kAuxHeaderSize2K = 6 + kFlexfecPacketMaskSize2K;
+
+// Here we count the K-bits as belonging to the packet mask.
+// This can be used in conjunction with FlexfecHeaderWriter::MinPacketMaskSize,
+// which calculates a bound on the needed packet mask size including K-bits,
+// given a packet mask without K-bits.
+size_t FecHeaderSize(size_t packet_mask_size) {
+  RTC_DCHECK_LE(packet_mask_size, kFlexfecPacketMaskSize2K);
+  if (packet_mask_size <= kFlexfecPacketMaskSize0K) {
+    return kBaseHeaderSize + kAuxHeaderSize0K;
+  } else if (packet_mask_size <= kFlexfecPacketMaskSize1K) {
+    return kBaseHeaderSize + kAuxHeaderSize1K;
+  } else {
+    return kBaseHeaderSize + kAuxHeaderSize2K;
+  }
+}
+
+}  // namespace
+
+namespace webrtc {
+
+FlexfecHeaderReader::FlexfecHeaderReader()
+    : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {}
+
+FlexfecHeaderReader::~FlexfecHeaderReader() = default;
+
+// TODO(brandtr): Update this function when we support flexible masks,
+// retransmissions, and/or several protected SSRCs.
+bool FlexfecHeaderReader::ReadFecHeader(
+    ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const {
+  bool f_bit = (fec_packet->pkt->data[0] & 0x80) != 0u;
+  if (f_bit) {
+    return false;
+  }
+  bool r_bit = (fec_packet->pkt->data[0] & 0x40) != 0u;
+  if (r_bit) {
+    return false;
+  }
+  uint8_t ssrc_count =
+      ByteReader<uint8_t>::ReadBigEndian(&fec_packet->pkt->data[8]);
+  if (ssrc_count != 1u) {
+    return false;
+  }
+  uint32_t ssrc =
+      ByteReader<uint32_t>::ReadBigEndian(&fec_packet->pkt->data[12]);
+  uint16_t seq_num_base =
+      ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[16]);
+
+  // Read packet mask and pack it tight by removing the interleaved K bits.
+  // This destroys the FlexFEC standards compliance of the packet masks,
+  // but makes it compatible with the ULPFEC masks.
+  //
+  // We treat the mask parts as unsigned integers with host order endianness
+  // in order to simplify the bit shifting between bytes.
+  bool k_bit0 = false, k_bit1 = false, k_bit2 = false;
+  uint16_t mask_part0 =
+      ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[18]);
+  k_bit0 = (mask_part0 & (1 << 15)) != 0u;  // Read K-bit 0.
+  mask_part0 <<= 1;                         // Shift away K-bit 0.
+  ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->pkt->data[18], mask_part0);
+  if (!k_bit0) {
+    uint32_t mask_part1 =
+        ByteReader<uint32_t>::ReadBigEndian(&fec_packet->pkt->data[20]);
+    k_bit1 = (mask_part1 & (1 << 31)) != 0u;      // Read K-bit 1.
+    bool bit15 = (mask_part1 & (1 << 30)) != 0u;  // Read bit 15.
+    if (bit15) {
+      fec_packet->pkt->data[19] |= 0x01;  // Set bit 15.
+    }
+    mask_part1 <<= 2;  // Shift away K-bit 1 and bit 15.
+    ByteWriter<uint32_t>::WriteBigEndian(&fec_packet->pkt->data[20],
+                                         mask_part1);
+    if (!k_bit1) {
+      uint64_t mask_part2 =
+          ByteReader<uint64_t>::ReadBigEndian(&fec_packet->pkt->data[24]);
+      uint64_t one = 1;  // Ensures enough bits available for the bit shifts.
+      k_bit2 = (mask_part2 & (one << 63)) != 0u;  // Read K-bit 2.
+      if (!k_bit2) {
+        // Malformed header.
+        return false;
+      }
+      bool bit46 = (mask_part2 & (one << 62)) != 0u;  // Read bit 46.
+      bool bit47 = (mask_part2 & (one << 61)) != 0u;  // Read bit 47.
+      if (bit46) {
+        fec_packet->pkt->data[23] |= 0x01;  // Set bit 46.
+      }
+      if (bit47) {
+        fec_packet->pkt->data[23] |= 0x02;  // Set bit 47.
+      }
+      mask_part2 <<= 3;  // Shift away K-bit 2, bit 46, and bit 47.
+      ByteWriter<uint64_t>::WriteBigEndian(&fec_packet->pkt->data[24],
+                                           mask_part2);
+    }
+  }
+
+  // Store "ULPFECized" packet mask info.
+  size_t packet_mask_size;
+  if (k_bit0) {
+    packet_mask_size = kFlexfecPacketMaskSize0K;
+  } else if (k_bit1) {
+    packet_mask_size = kFlexfecPacketMaskSize1K;
+  } else {
+    packet_mask_size = kFlexfecPacketMaskSize2K;
+  }
+  fec_packet->fec_header_size = FecHeaderSize(packet_mask_size);
+
+  const size_t kPacketMaskOffset = kBaseHeaderSize + 6;
+  fec_packet->packet_mask_info[ssrc] =
+      std::make_tuple(seq_num_base, kPacketMaskOffset, packet_mask_size);
+
+  // In FlexFEC, all media packets are protected in their entirety.
+  fec_packet->protection_length =
+      fec_packet->pkt->length - fec_packet->fec_header_size;
+
+  return true;
+}
+
+FlexfecHeaderWriter::FlexfecHeaderWriter()
+    : FecHeaderWriter(kMaxMediaPackets,
+                      kMaxFecPackets,
+                      kBaseHeaderSize + kAuxHeaderSize2K) {}
+
+FlexfecHeaderWriter::~FlexfecHeaderWriter() = default;
+
+size_t FlexfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask,
+                                              size_t packet_mask_size) const {
+  bool ulpfec_l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet);
+  if (ulpfec_l_bit) {
+    // The packet mask is 48 bits long.
+    bool bit46 = (packet_mask[5] & 0x01) != 0u;
+    bool bit47 = (packet_mask[5] & 0x02) != 0u;
+    if (bit46 || bit47) {
+      return kFlexfecPacketMaskSize2K;
+    } else {
+      return kFlexfecPacketMaskSize1K;
+    }
+  } else {
+    RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear);
+    // The packet mask is 16 bits long.
+    bool bit15 = (packet_mask[1] & 0x01) != 0u;
+    if (bit15) {
+      return kFlexfecPacketMaskSize1K;
+    } else {
+      return kFlexfecPacketMaskSize0K;
+    }
+  }
+}
+
+size_t FlexfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const {
+  return ::FecHeaderSize(packet_mask_size);
+}
+
+// This function adapts the precomputed ULPFEC packet masks to the
+// FlexFEC header standard. Note that the header size is computed by
+// FecHeaderSize(), so in this function we can be sure that we are
+// writing in space that is intended for the header.
+//
+// TODO(brandtr): Update this function when we support offset-based masks,
+// retransmissions, and protecting multiple SSRCs.
+void FlexfecHeaderWriter::FinalizeFecHeader(
+    const ForwardErrorCorrection::PacketList& media_packets,
+    const uint8_t* packet_mask,
+    size_t packet_mask_size,
+    ForwardErrorCorrection::Packet* fec_packet) const {
+  fec_packet->data[0] &= 0x7f;  // Clear F bit.
+  fec_packet->data[0] &= 0xbf;  // Clear R bit.
+  // Write SSRC count.
+  ByteWriter<uint8_t>::WriteBigEndian(&fec_packet->data[8], 1u);
+  RTC_DCHECK(!media_packets.empty());
+  ForwardErrorCorrection::Packet* first_media_packet =
+      media_packets.front().get();
+  RTC_DCHECK(first_media_packet);
+  // TODO(brandtr): Get rid of these 'Parse' function calls,
+  // when the Packet class has been refactored.
+  uint32_t ssrc_base =
+      ForwardErrorCorrection::ParseSsrc(first_media_packet->data);
+  ByteWriter<uint32_t>::WriteBigEndian(&fec_packet->data[12], ssrc_base);
+  uint16_t seq_num_base =
+      ForwardErrorCorrection::ParseSequenceNumber(first_media_packet->data);
+  ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[16], seq_num_base);
+  // Adapt ULPFEC packet mask to FlexFEC header.
+  //
+  // We treat the mask parts as unsigned integers with host order endianness
+  // in order to simplify the bit shifting between bytes.
+  bool ulpfec_l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet);
+  if (ulpfec_l_bit) {
+    // The packet mask is 48 bits long.
+    uint16_t tmp_mask_part0 =
+        ByteReader<uint16_t>::ReadBigEndian(&packet_mask[0]);
+    uint32_t tmp_mask_part1 =
+        ByteReader<uint32_t>::ReadBigEndian(&packet_mask[2]);
+
+    tmp_mask_part0 >>= 1;  // Shift, thus clearing K-bit 0.
+    ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[18], tmp_mask_part0);
+    tmp_mask_part1 >>= 2;  // Shift, thus clearing K-bit 1 and bit 15.
+    ByteWriter<uint32_t>::WriteBigEndian(&fec_packet->data[20], tmp_mask_part1);
+    bool bit15 = (packet_mask[1] & 0x01) != 0u;
+    if (bit15) {
+      fec_packet->data[20] |= 0x40;  // Set bit 15.
+    }
+    bool bit46 = (packet_mask[5] & 0x01) != 0u;
+    bool bit47 = (packet_mask[5] & 0x02) != 0u;
+    if (!bit46 && !bit47) {
+      fec_packet->data[20] |= 0x80;  // Set K-bit 1.
+    } else {
+      memset(&fec_packet->data[24], 0u, 8);  // Clear all trailing bits.
+      fec_packet->data[24] |= 0x80;          // Set K-bit 2.
+      if (bit46) {
+        fec_packet->data[24] |= 0x40;  // Set bit 46.
+      }
+      if (bit47) {
+        fec_packet->data[24] |= 0x20;  // Set bit 47.
+      }
+    }
+  } else {
+    RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear);
+    // The packet mask is 16 bits long.
+    uint16_t tmp_mask_part0 =
+        ByteReader<uint16_t>::ReadBigEndian(&packet_mask[0]);
+
+    tmp_mask_part0 >>= 1;  // Shift, thus clearing K-bit 0.
+    ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[18], tmp_mask_part0);
+    bool bit15 = (packet_mask[1] & 0x01) != 0u;
+    if (!bit15) {
+      fec_packet->data[18] |= 0x80;  // Set K-bit 0.
+    } else {
+      memset(&fec_packet->data[20], 0u, 4);  // Clear all trailing bits.
+      fec_packet->data[20] |= 0x80;          // Set K-bit 1.
+      fec_packet->data[20] |= 0x40;          // Set bit 15.
+    }
+  }
+}
+
+}  // namespace webrtc