1 /*
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
12
13 #include <utility>
14
15 #include "modules/rtp_rtcp/source/byte_io.h"
16 #include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
17 #include "rtc_base/checks.h"
18
19 namespace webrtc {
20
21 namespace {
22
23 // Maximum number of media packets that can be protected in one batch.
24 constexpr size_t kMaxMediaPackets = 48;
25
26 // Maximum number of FEC packets stored inside ForwardErrorCorrection.
27 constexpr size_t kMaxFecPackets = kMaxMediaPackets;
28
29 // FEC Level 0 header size in bytes.
30 constexpr size_t kFecLevel0HeaderSize = 10;
31
32 // FEC Level 1 (ULP) header size in bytes (L bit is set).
33 constexpr size_t kFecLevel1HeaderSizeLBitSet = 2 + kUlpfecPacketMaskSizeLBitSet;
34
35 // FEC Level 1 (ULP) header size in bytes (L bit is cleared).
36 constexpr size_t kFecLevel1HeaderSizeLBitClear =
37 2 + kUlpfecPacketMaskSizeLBitClear;
38
39 constexpr size_t kPacketMaskOffset = kFecLevel0HeaderSize + 2;
40
UlpfecHeaderSize(size_t packet_mask_size)41 size_t UlpfecHeaderSize(size_t packet_mask_size) {
42 RTC_DCHECK_LE(packet_mask_size, kUlpfecPacketMaskSizeLBitSet);
43 if (packet_mask_size <= kUlpfecPacketMaskSizeLBitClear) {
44 return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitClear;
45 } else {
46 return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet;
47 }
48 }
49
50 } // namespace
51
UlpfecHeaderReader()52 UlpfecHeaderReader::UlpfecHeaderReader()
53 : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {}
54
55 UlpfecHeaderReader::~UlpfecHeaderReader() = default;
56
ReadFecHeader(ForwardErrorCorrection::ReceivedFecPacket * fec_packet) const57 bool UlpfecHeaderReader::ReadFecHeader(
58 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const {
59 bool l_bit = (fec_packet->pkt->data[0] & 0x40) != 0u;
60 size_t packet_mask_size =
61 l_bit ? kUlpfecPacketMaskSizeLBitSet : kUlpfecPacketMaskSizeLBitClear;
62 fec_packet->fec_header_size = UlpfecHeaderSize(packet_mask_size);
63 uint16_t seq_num_base =
64 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[2]);
65 fec_packet->protected_ssrc = fec_packet->ssrc; // Due to RED.
66 fec_packet->seq_num_base = seq_num_base;
67 fec_packet->packet_mask_offset = kPacketMaskOffset;
68 fec_packet->packet_mask_size = packet_mask_size;
69 fec_packet->protection_length =
70 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[10]);
71
72 // Store length recovery field in temporary location in header.
73 // This makes the header "compatible" with the corresponding
74 // FlexFEC location of the length recovery field, thus simplifying
75 // the XORing operations.
76 memcpy(&fec_packet->pkt->data[2], &fec_packet->pkt->data[8], 2);
77
78 return true;
79 }
80
UlpfecHeaderWriter()81 UlpfecHeaderWriter::UlpfecHeaderWriter()
82 : FecHeaderWriter(kMaxMediaPackets,
83 kMaxFecPackets,
84 kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet) {}
85
86 UlpfecHeaderWriter::~UlpfecHeaderWriter() = default;
87
88 // TODO(brandtr): Consider updating this implementation (which actually
89 // returns a bound on the sequence number spread), if logic is added to
90 // UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end
91 // in a string of zeroes. (Similar to how it is done in the FlexFEC case.)
MinPacketMaskSize(const uint8_t * packet_mask,size_t packet_mask_size) const92 size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask,
93 size_t packet_mask_size) const {
94 return packet_mask_size;
95 }
96
FecHeaderSize(size_t packet_mask_size) const97 size_t UlpfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const {
98 return UlpfecHeaderSize(packet_mask_size);
99 }
100
FinalizeFecHeader(uint32_t,uint16_t seq_num_base,const uint8_t * packet_mask,size_t packet_mask_size,ForwardErrorCorrection::Packet * fec_packet) const101 void UlpfecHeaderWriter::FinalizeFecHeader(
102 uint32_t /* media_ssrc */,
103 uint16_t seq_num_base,
104 const uint8_t* packet_mask,
105 size_t packet_mask_size,
106 ForwardErrorCorrection::Packet* fec_packet) const {
107 // Set E bit to zero.
108 fec_packet->data[0] &= 0x7f;
109 // Set L bit based on packet mask size. (Note that the packet mask
110 // can only take on two discrete values.)
111 bool l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet);
112 if (l_bit) {
113 fec_packet->data[0] |= 0x40; // Set the L bit.
114 } else {
115 RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear);
116 fec_packet->data[0] &= 0xbf; // Clear the L bit.
117 }
118 // Copy length recovery field from temporary location.
119 memcpy(&fec_packet->data[8], &fec_packet->data[2], 2);
120 // Write sequence number base.
121 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[2], seq_num_base);
122 // Protection length is set to entire packet. (This is not
123 // required in general.)
124 const size_t fec_header_size = FecHeaderSize(packet_mask_size);
125 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[10],
126 fec_packet->length - fec_header_size);
127 // Copy the packet mask.
128 memcpy(&fec_packet->data[12], packet_mask, packet_mask_size);
129 }
130
131 } // namespace webrtc
132