Index: webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc |
diff --git a/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc b/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..d007862c66b50748bbe8738289f6d451c8018476 |
--- /dev/null |
+++ b/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.cc |
@@ -0,0 +1,135 @@ |
+/* |
+ * 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/ulpfec_header_reader_writer.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 webrtc { |
+ |
+namespace { |
+ |
+// Maximum number of media packets that can be protected in one batch. |
+constexpr size_t kMaxMediaPackets = 48; |
+ |
+// Maximum number of FEC packets stored inside ForwardErrorCorrection. |
+constexpr size_t kMaxFecPackets = kMaxMediaPackets; |
+ |
+// FEC Level 0 header size in bytes. |
+constexpr size_t kFecLevel0HeaderSize = 10; |
+ |
+// FEC Level 1 (ULP) header size in bytes (L bit is set). |
+constexpr size_t kFecLevel1HeaderSizeLBitSet = |
+ 2 + webrtc::kUlpfecPacketMaskSizeLBitSet; |
danilchap
2016/08/24 10:42:40
do you need namespace here?
brandtr
2016/08/24 11:34:24
Nope, that was from before. Thanks!
|
+ |
+// FEC Level 1 (ULP) header size in bytes (L bit is cleared). |
+constexpr size_t kFecLevel1HeaderSizeLBitClear = |
+ 2 + webrtc::kUlpfecPacketMaskSizeLBitClear; |
+ |
+size_t FecHeaderSizeImpl(size_t packet_mask_size) { |
+ RTC_DCHECK_LE(packet_mask_size, webrtc::kUlpfecPacketMaskSizeLBitSet); |
+ if (packet_mask_size <= webrtc::kUlpfecPacketMaskSizeLBitClear) { |
+ return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitClear; |
+ } else { |
+ return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet; |
+ } |
+} |
+ |
+} // namespace |
+ |
+UlpfecHeaderReader::UlpfecHeaderReader() |
+ : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {} |
+ |
+UlpfecHeaderReader::~UlpfecHeaderReader() = default; |
+ |
+bool UlpfecHeaderReader::ReadFecHeader( |
+ ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { |
+ bool l_bit = (fec_packet->pkt->data[0] & 0x40) != 0u; |
+ size_t packet_mask_size = |
+ l_bit ? kUlpfecPacketMaskSizeLBitSet : kUlpfecPacketMaskSizeLBitClear; |
+ fec_packet->fec_header_size = FecHeaderSizeImpl(packet_mask_size); |
+ uint16_t seq_num_base = |
+ ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[2]); |
+ const size_t kPacketMaskOffset = kFecLevel0HeaderSize + 2; |
+ fec_packet->packet_mask_info[fec_packet->rtp_ssrc] = |
+ std::make_tuple(seq_num_base, kPacketMaskOffset, packet_mask_size); |
+ fec_packet->protection_length = |
+ ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[10]); |
+ |
+ // Store length recovery field in temporary location in header. |
+ // This makes the header "compatible" with the corresponding |
+ // FlexFEC location of the length recovery field, thus simplifying |
+ // the XORing operations. |
+ memcpy(&fec_packet->pkt->data[2], &fec_packet->pkt->data[8], 2); |
+ |
+ return true; |
+} |
+ |
+UlpfecHeaderWriter::UlpfecHeaderWriter() |
+ : FecHeaderWriter(kMaxMediaPackets, |
+ kMaxFecPackets, |
+ kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet) {} |
+ |
+UlpfecHeaderWriter::~UlpfecHeaderWriter() = default; |
+ |
+// TODO(brandtr): Consider updating this implementation (which actually |
+// returns a bound on the sequence number spread), if logic is added to |
+// UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end |
+// in a string of zeroes. (Similar to how it is done in the FlexFEC case.) |
+size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask, |
+ size_t packet_mask_size) const { |
+ return packet_mask_size; |
+} |
+ |
+size_t UlpfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const { |
+ return FecHeaderSizeImpl(packet_mask_size); |
+} |
+ |
+void UlpfecHeaderWriter::FinalizeFecHeader( |
+ const ForwardErrorCorrection::PacketList& media_packets, |
+ const uint8_t* packet_mask, |
+ size_t packet_mask_size, |
+ ForwardErrorCorrection::Packet* fec_packet) const { |
+ // Set E bit to zero. |
+ fec_packet->data[0] &= 0x7f; |
+ // Set L bit based on packet mask size. (Note that the packet mask |
+ // can only take on two discrete values.) |
+ bool l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet); |
+ if (l_bit) { |
+ fec_packet->data[0] |= 0x40; // Set the L bit. |
+ } else { |
+ RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear); |
+ fec_packet->data[0] &= 0xbf; // Clear the L bit. |
+ } |
+ // Copy length recovery field from temporary location. |
+ memcpy(&fec_packet->data[8], &fec_packet->data[2], 2); |
+ // Sequence number from first media packet used as SN base |
+ // for all FEC packets. (This is not required in general.) |
+ RTC_DCHECK(!media_packets.empty()); |
+ ForwardErrorCorrection::Packet* first_media_packet = |
+ media_packets.front().get(); |
+ RTC_DCHECK(first_media_packet); |
+ uint16_t seq_num_base = |
+ ForwardErrorCorrection::ParseSequenceNumber(first_media_packet->data); |
+ ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[2], seq_num_base); |
+ // Protection length is set to entire packet. (This is not |
+ // required in general.) |
+ const size_t fec_header_size = FecHeaderSize(packet_mask_size); |
+ ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[10], |
+ fec_packet->length - fec_header_size); |
+ // Copy the packet mask. |
+ memcpy(&fec_packet->data[12], packet_mask, packet_mask_size); |
+} |
+ |
+} // namespace webrtc |