blob: 22af7e7736904bb24d9b83767cbb45bbc973c95f [file] [log] [blame]
/*
* 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 "modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
#include <string.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/scoped_ref_ptr.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 + kUlpfecPacketMaskSizeLBitSet;
// FEC Level 1 (ULP) header size in bytes (L bit is cleared).
constexpr size_t kFecLevel1HeaderSizeLBitClear =
2 + kUlpfecPacketMaskSizeLBitClear;
constexpr size_t kPacketMaskOffset = kFecLevel0HeaderSize + 2;
size_t UlpfecHeaderSize(size_t packet_mask_size) {
RTC_DCHECK_LE(packet_mask_size, kUlpfecPacketMaskSizeLBitSet);
if (packet_mask_size <= 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 = UlpfecHeaderSize(packet_mask_size);
uint16_t seq_num_base =
ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[2]);
fec_packet->protected_ssrc = fec_packet->ssrc; // Due to RED.
fec_packet->seq_num_base = seq_num_base;
fec_packet->packet_mask_offset = kPacketMaskOffset;
fec_packet->packet_mask_size = 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 UlpfecHeaderSize(packet_mask_size);
}
void UlpfecHeaderWriter::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 {
// 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);
// Write sequence number base.
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