admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial copy of flexfec_header_reader_writer.

Browse Source 
Create a copy of flexfec_header_reader_writer for changing the implementation according to updated RFC. The fork is needed, since the updated RFC is incompatible with flexfec-03.
In the updated RFC, we receive the list and the number of protected ssrcs from the RTP header (from it's CSRCs , and CSRC count fields).
This Change is only a copy of the existing files. This will make it easier to understand the changes to the implementation in the next change sets.

Bug: webrtc:15002
Change-Id: I31bf5eca0d8f3cb23b4caabb477897eeb0ca6d96
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/303240
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Commit-Queue: Rasmus Brandt <brandtr@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40103}
This commit is contained in:
Yosef Twaik 2023-05-04 18:27:43 +03:00 committed by WebRTC LUCI CQ
parent 718601a1f8
commit b4015689b8
4 changed files with 485 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
modules/rtp_rtcp/BUILD.gn
View File

@ -172,6 +172,8 @@ rtc_library("rtp_rtcp") {
"source/fec_private_tables_random.h",
"source/flexfec_header_reader_writer.cc",
"source/flexfec_header_reader_writer.h",
"source/flexfec_header_reader_writer2.cc",
"source/flexfec_header_reader_writer2.h",
"source/flexfec_receiver.cc",
"source/flexfec_sender.cc",
"source/forward_error_correction.cc",
@ -552,6 +554,7 @@ if (rtc_include_tests) {
"source/byte_io_unittest.cc",
"source/capture_clock_offset_updater_unittest.cc",
"source/fec_private_tables_bursty_unittest.cc",
"source/flexfec_header_reader_writer2_unittest.cc",
"source/flexfec_header_reader_writer_unittest.cc",
"source/flexfec_receiver_unittest.cc",
"source/flexfec_sender_unittest.cc",

319
modules/rtp_rtcp/source/flexfec_header_reader_writer2.cc Normal file
View File

@ -0,0 +1,319 @@
/*
* Copyright (c) 2023 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 "modules/rtp_rtcp/source/flexfec_header_reader_writer2.h"
#include <string.h>
#include "api/scoped_refptr.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
namespace webrtc {
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 media packets tracked by FEC decoder.
// Maintain a sufficiently larger tracking window than `kMaxMediaPackets`
// to account for packet reordering in pacer/ network.
constexpr size_t kMaxTrackedMediaPackets = 4 * kMaxMediaPackets;
// 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 kFlexfecPacketMaskSizes[] = {2, 6, 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 stream specific.
constexpr size_t kStreamSpecificHeaderSize = 6;
// Size (in bytes) of header, given the single stream packet mask size, i.e.
// the number of K-bits set.
constexpr size_t kHeaderSizes[] = {
kBaseHeaderSize + kStreamSpecificHeaderSize + kFlexfecPacketMaskSizes[0],
kBaseHeaderSize + kStreamSpecificHeaderSize + kFlexfecPacketMaskSizes[1],
kBaseHeaderSize + kStreamSpecificHeaderSize + kFlexfecPacketMaskSizes[2]};
// We currently only support single-stream protection.
// TODO(brandtr): Update this when we support multistream protection.
constexpr uint8_t kSsrcCount = 1;
// There are three reserved bytes that MUST be set to zero in the header.
constexpr uint32_t kReservedBits = 0;
// TODO(brandtr): Update this when we support multistream protection.
constexpr size_t kPacketMaskOffset =
kBaseHeaderSize + kStreamSpecificHeaderSize;
// 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 FlexfecHeaderSize(size_t packet_mask_size) {
RTC_DCHECK_LE(packet_mask_size, kFlexfecPacketMaskSizes[2]);
if (packet_mask_size <= kFlexfecPacketMaskSizes[0]) {
return kHeaderSizes[0];
} else if (packet_mask_size <= kFlexfecPacketMaskSizes[1]) {
return kHeaderSizes[1];
}
return kHeaderSizes[2];
}
} // namespace
FlexfecHeaderReader2::FlexfecHeaderReader2()
: FecHeaderReader(kMaxTrackedMediaPackets, kMaxFecPackets) {}
FlexfecHeaderReader2::~FlexfecHeaderReader2() = default;
// TODO(brandtr): Update this function when we support flexible masks,
// retransmissions, and/or several protected SSRCs.
bool FlexfecHeaderReader2::ReadFecHeader(
ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const {
if (fec_packet->pkt->data.size() <=
kBaseHeaderSize + kStreamSpecificHeaderSize) {
RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
return false;
}
uint8_t* const data = fec_packet->pkt->data.MutableData();
bool r_bit = (data[0] & 0x80) != 0;
if (r_bit) {
RTC_LOG(LS_INFO)
<< "FlexFEC packet with retransmission bit set. We do not yet "
"support this, thus discarding the packet.";
return false;
}
bool f_bit = (data[0] & 0x40) != 0;
if (f_bit) {
RTC_LOG(LS_INFO)
<< "FlexFEC packet with inflexible generator matrix. We do "
"not yet support this, thus discarding packet.";
return false;
}
uint8_t ssrc_count = ByteReader<uint8_t>::ReadBigEndian(&data[8]);
if (ssrc_count != 1) {
RTC_LOG(LS_INFO)
<< "FlexFEC packet protecting multiple media SSRCs. We do not "
"yet support this, thus discarding packet.";
return false;
}
uint32_t protected_ssrc = ByteReader<uint32_t>::ReadBigEndian(&data[12]);
uint16_t seq_num_base = ByteReader<uint16_t>::ReadBigEndian(&data[16]);
// Parse the FlexFEC packet mask and remove the interleaved K-bits.
// (See FEC header schematic in flexfec_header_reader_writer.h.)
// We store the packed packet mask in-band, which "destroys" the standards
// compliance of the header. That is fine though, since the code that
// reads from the header (from this point and onwards) is aware of this.
// TODO(brandtr): When the FEC packet classes have been refactored, store
// the packed packet masks out-of-band, thus leaving the FlexFEC header as is.
//
// We treat the mask parts as unsigned integers with host order endianness
// in order to simplify the bit shifting between bytes.
if (fec_packet->pkt->data.size() < kHeaderSizes[0]) {
RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
return false;
}
uint8_t* const packet_mask = data + kPacketMaskOffset;
bool k_bit0 = (packet_mask[0] & 0x80) != 0;
uint16_t mask_part0 = ByteReader<uint16_t>::ReadBigEndian(&packet_mask[0]);
// Shift away K-bit 0, implicitly clearing the last bit.
mask_part0 <<= 1;
ByteWriter<uint16_t>::WriteBigEndian(&packet_mask[0], mask_part0);
size_t packet_mask_size;
if (k_bit0) {
// The first K-bit is set, and the packet mask is thus only 2 bytes long.
// We have now read the entire FEC header, and the rest of the packet
// is payload.
packet_mask_size = kFlexfecPacketMaskSizes[0];
} else {
if (fec_packet->pkt->data.size() < kHeaderSizes[1]) {
return false;
}
bool k_bit1 = (packet_mask[2] & 0x80) != 0;
// We have already shifted the first two bytes of the packet mask one step
// to the left, thus removing K-bit 0. We will now shift the next four bytes
// of the packet mask two steps to the left. (One step for the removed
// K-bit 0, and one step for the to be removed K-bit 1).
uint8_t bit15 = (packet_mask[2] >> 6) & 0x01;
packet_mask[1] |= bit15;
uint32_t mask_part1 = ByteReader<uint32_t>::ReadBigEndian(&packet_mask[2]);
// Shift away K-bit 1 and bit 15, implicitly clearing the last two bits.
mask_part1 <<= 2;
ByteWriter<uint32_t>::WriteBigEndian(&packet_mask[2], mask_part1);
if (k_bit1) {
// The first K-bit is clear, but the second K-bit is set. The packet
// mask is thus 6 bytes long. We have now read the entire FEC header,
// and the rest of the packet is payload.
packet_mask_size = kFlexfecPacketMaskSizes[1];
} else {
if (fec_packet->pkt->data.size() < kHeaderSizes[2]) {
RTC_LOG(LS_WARNING) << "Discarding truncated FlexFEC packet.";
return false;
}
bool k_bit2 = (packet_mask[6] & 0x80) != 0;
if (k_bit2) {
// The first and second K-bits are clear, but the third K-bit is set.
// The packet mask is thus 14 bytes long. We have now read the entire
// FEC header, and the rest of the packet is payload.
packet_mask_size = kFlexfecPacketMaskSizes[2];
} else {
RTC_LOG(LS_WARNING)
<< "Discarding FlexFEC packet with malformed header.";
return false;
}
// At this point, K-bits 0 and 1 have been removed, and the front-most
// part of the FlexFEC packet mask has been packed accordingly. We will
// now shift the remaning part of the packet mask three steps to the left.
// This corresponds to the (in total) three K-bits, which have been
// removed.
uint8_t tail_bits = (packet_mask[6] >> 5) & 0x03;
packet_mask[5] |= tail_bits;
uint64_t mask_part2 =
ByteReader<uint64_t>::ReadBigEndian(&packet_mask[6]);
// Shift away K-bit 2, bit 46, and bit 47, implicitly clearing the last
// three bits.
mask_part2 <<= 3;
ByteWriter<uint64_t>::WriteBigEndian(&packet_mask[6], mask_part2);
}
}
// Store "ULPFECized" packet mask info.
fec_packet->fec_header_size = FlexfecHeaderSize(packet_mask_size);
fec_packet->protected_streams = {{.ssrc = protected_ssrc,
.seq_num_base = seq_num_base,
.packet_mask_offset = kPacketMaskOffset,
.packet_mask_size = packet_mask_size}};
// In FlexFEC, all media packets are protected in their entirety.
fec_packet->protection_length =
fec_packet->pkt->data.size() - fec_packet->fec_header_size;
return true;
}
FlexfecHeaderWriter2::FlexfecHeaderWriter2()
: FecHeaderWriter(kMaxMediaPackets, kMaxFecPackets, kHeaderSizes[2]) {}
FlexfecHeaderWriter2::~FlexfecHeaderWriter2() = default;
size_t FlexfecHeaderWriter2::MinPacketMaskSize(const uint8_t* packet_mask,
size_t packet_mask_size) const {
if (packet_mask_size == kUlpfecPacketMaskSizeLBitClear &&
(packet_mask[1] & 0x01) == 0) {
// Packet mask is 16 bits long, with bit 15 clear.
// It can be used as is.
return kFlexfecPacketMaskSizes[0];
} else if (packet_mask_size == kUlpfecPacketMaskSizeLBitClear) {
// Packet mask is 16 bits long, with bit 15 set.
// We must expand the packet mask with zeros in the FlexFEC header.
return kFlexfecPacketMaskSizes[1];
} else if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet &&
(packet_mask[5] & 0x03) == 0) {
// Packet mask is 48 bits long, with bits 46 and 47 clear.
// It can be used as is.
return kFlexfecPacketMaskSizes[1];
} else if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) {
// Packet mask is 48 bits long, with at least one of bits 46 and 47 set.
// We must expand it with zeros.
return kFlexfecPacketMaskSizes[2];
}
RTC_DCHECK_NOTREACHED() << "Incorrect packet mask size: " << packet_mask_size
<< ".";
return kFlexfecPacketMaskSizes[2];
}
size_t FlexfecHeaderWriter2::FecHeaderSize(size_t packet_mask_size) const {
return FlexfecHeaderSize(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 FlexfecHeaderWriter2::FinalizeFecHeader(
uint32_t media_ssrc,
uint16_t seq_num_base,
const uint8_t* packet_mask,
size_t packet_mask_size,
ForwardErrorCorrection::Packet* fec_packet) const {
uint8_t* data = fec_packet->data.MutableData();
data[0] &= 0x7f; // Clear R bit.
data[0] &= 0xbf; // Clear F bit.
ByteWriter<uint8_t>::WriteBigEndian(&data[8], kSsrcCount);
ByteWriter<uint32_t, 3>::WriteBigEndian(&data[9], kReservedBits);
ByteWriter<uint32_t>::WriteBigEndian(&data[12], media_ssrc);
ByteWriter<uint16_t>::WriteBigEndian(&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.
uint8_t* const written_packet_mask = data + kPacketMaskOffset;
if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) {
// 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(&written_packet_mask[0],
tmp_mask_part0);
tmp_mask_part1 >>= 2; // Shift, thus clearing K-bit 1 and bit 15.
ByteWriter<uint32_t>::WriteBigEndian(&written_packet_mask[2],
tmp_mask_part1);
bool bit15 = (packet_mask[1] & 0x01) != 0;
if (bit15)
written_packet_mask[2] |= 0x40; // Set bit 15.
bool bit46 = (packet_mask[5] & 0x02) != 0;
bool bit47 = (packet_mask[5] & 0x01) != 0;
if (!bit46 && !bit47) {
written_packet_mask[2] |= 0x80; // Set K-bit 1.
} else {
memset(&written_packet_mask[6], 0, 8); // Clear all trailing bits.
written_packet_mask[6] |= 0x80; // Set K-bit 2.
if (bit46)
written_packet_mask[6] |= 0x40; // Set bit 46.
if (bit47)
written_packet_mask[6] |= 0x20; // Set bit 47.
}
} else if (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(&written_packet_mask[0],
tmp_mask_part0);
bool bit15 = (packet_mask[1] & 0x01) != 0;
if (!bit15) {
written_packet_mask[0] |= 0x80; // Set K-bit 0.
} else {
memset(&written_packet_mask[2], 0U, 4); // Clear all trailing bits.
written_packet_mask[2] |= 0x80; // Set K-bit 1.
written_packet_mask[2] |= 0x40; // Set bit 15.
}
} else {
RTC_DCHECK_NOTREACHED()
<< "Incorrect packet mask size: " << packet_mask_size << ".";
}
}
} // namespace webrtc

88
modules/rtp_rtcp/source/flexfec_header_reader_writer2.h Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright (c) 2023 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.
*/
#ifndef MODULES_RTP_RTCP_SOURCE_FLEXFEC_HEADER_READER_WRITER2_H_
#define MODULES_RTP_RTCP_SOURCE_FLEXFEC_HEADER_READER_WRITER2_H_
#include <stddef.h>
#include <stdint.h>
#include "modules/rtp_rtcp/source/forward_error_correction.h"
namespace webrtc {
// FlexFEC header, minimum 20 bytes.
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 0 |R|F|P|X| CC |M| PT recovery | length recovery |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 4 | TS recovery |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 8 | SSRCCount | reserved |
// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
// 12 | SSRC_i |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 16 | SN base_i |k| Mask [0-14] |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 20 |k| Mask [15-45] (optional) |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 24 |k| |
// +-+ Mask [46-108] (optional) |
// 28 | |
// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
// : ... next in SSRC_i ... :
//
//
// FlexFEC header in 'inflexible' mode (F = 1), 20 bytes.
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 0 |0|1|P|X| CC |M| PT recovery | length recovery |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 4 | TS recovery |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 8 | SSRCCount | reserved |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 12 | SSRC_i |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// 16 | SN base_i | M (columns) | N (rows) |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
class FlexfecHeaderReader2 : public FecHeaderReader {
public:
FlexfecHeaderReader2();
~FlexfecHeaderReader2() override;
bool ReadFecHeader(
ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const override;
};
class FlexfecHeaderWriter2 : public FecHeaderWriter {
public:
FlexfecHeaderWriter2();
~FlexfecHeaderWriter2() override;
size_t MinPacketMaskSize(const uint8_t* packet_mask,
size_t packet_mask_size) const override;
size_t FecHeaderSize(size_t packet_mask_row_size) const override;
void FinalizeFecHeader(
uint32_t media_ssrc,
uint16_t seq_num_base,
const uint8_t* packet_mask,
size_t packet_mask_size,
ForwardErrorCorrection::Packet* fec_packet) const override;
};
} // namespace webrtc
#endif // MODULES_RTP_RTCP_SOURCE_FLEXFEC_HEADER_READER_WRITER2_H_

75
modules/rtp_rtcp/source/flexfec_header_reader_writer2_unittest.cc Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (c) 2023 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 "modules/rtp_rtcp/source/flexfec_header_reader_writer2.h"
#include "test/gtest.h"
namespace webrtc {
// TODO(bugs.webrtc.org/15002): reimplement all tests after changes
// to parser, and add tests for multi stream cases.
TEST(FlexfecHeaderReader2Test, ReadsHeaderWithKBit0Set) {}
TEST(FlexfecHeaderReader2Test, ReadsHeaderWithKBit1Set) {}
TEST(FlexfecHeaderReader2Test, ReadsHeaderWithKBit2Set) {}
TEST(FlexfecHeaderReader2Test,
ReadPacketWithoutStreamSpecificHeaderShouldFail) {}
TEST(FlexfecHeaderReader2Test, ReadShortPacketWithKBit0SetShouldFail) {}
TEST(FlexfecHeaderReader2Test, ReadShortPacketWithKBit1SetShouldFail) {}
TEST(FlexfecHeaderReader2Test, ReadShortPacketWithKBit2SetShouldFail) {}
TEST(FlexfecHeaderWriter2Test, FinalizesHeaderWithKBit0Set) {}
TEST(FlexfecHeaderWriter2Test, FinalizesHeaderWithKBit1Set) {}
TEST(FlexfecHeaderWriter2Test, FinalizesHeaderWithKBit2Set) {}
TEST(FlexfecHeaderWriter2Test, ContractsShortUlpfecPacketMaskWithBit15Clear) {}
TEST(FlexfecHeaderWriter2Test, ExpandsShortUlpfecPacketMaskWithBit15Set) {}
TEST(FlexfecHeaderWriter2Test,
ContractsLongUlpfecPacketMaskWithBit46ClearBit47Clear) {}
TEST(FlexfecHeaderWriter2Test,
ExpandsLongUlpfecPacketMaskWithBit46SetBit47Clear) {}
TEST(FlexfecHeaderWriter2Test,
ExpandsLongUlpfecPacketMaskWithBit46ClearBit47Set) {}
TEST(FlexfecHeaderWriter2Test,
ExpandsLongUlpfecPacketMaskWithBit46SetBit47Set) {}
TEST(FlexfecHeaderReaderWriter2Test,
WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Clear) {}
TEST(FlexfecHeaderReaderWriter2Test,
WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Set) {}
TEST(FlexfecHeaderReaderWriter2Test,
WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Clear) {}
TEST(FlexfecHeaderReaderWriter2Test,
WriteAndReadLargeUlpfecPacketHeaderWithMaskBit46SetBit47Clear) {}
TEST(FlexfecHeaderReaderWriter2Test,
WriteAndReadLargeUlpfecPacketHeaderMaskWithBit46ClearBit47Set) {}
TEST(FlexfecHeaderReaderWriter2Test,
WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Set) {}
} // namespace webrtc