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 <string.h>
14
15 #include <memory>
16 #include <utility>
17
18 #include "api/scoped_refptr.h"
19 #include "modules/rtp_rtcp/source/byte_io.h"
20 #include "modules/rtp_rtcp/source/forward_error_correction.h"
21 #include "modules/rtp_rtcp/source/forward_error_correction_internal.h"
22 #include "rtc_base/checks.h"
23 #include "rtc_base/random.h"
24 #include "test/gtest.h"
25
26 namespace webrtc {
27
28 namespace {
29
30 using Packet = ForwardErrorCorrection::Packet;
31 using ReceivedFecPacket = ForwardErrorCorrection::ReceivedFecPacket;
32
33 constexpr uint32_t kMediaSsrc = 1254983;
34 constexpr uint16_t kMediaStartSeqNum = 825;
35 constexpr size_t kMediaPacketLength = 1234;
36
37 constexpr size_t kUlpfecHeaderSizeLBitClear = 14;
38 constexpr size_t kUlpfecHeaderSizeLBitSet = 18;
39 constexpr size_t kUlpfecPacketMaskOffset = 12;
40
GeneratePacketMask(size_t packet_mask_size,uint64_t seed)41 std::unique_ptr<uint8_t[]> GeneratePacketMask(size_t packet_mask_size,
42 uint64_t seed) {
43 Random random(seed);
44 std::unique_ptr<uint8_t[]> packet_mask(new uint8_t[packet_mask_size]);
45 for (size_t i = 0; i < packet_mask_size; ++i) {
46 packet_mask[i] = random.Rand<uint8_t>();
47 }
48 return packet_mask;
49 }
50
WriteHeader(const uint8_t * packet_mask,size_t packet_mask_size)51 std::unique_ptr<Packet> WriteHeader(const uint8_t* packet_mask,
52 size_t packet_mask_size) {
53 UlpfecHeaderWriter writer;
54 std::unique_ptr<Packet> written_packet(new Packet());
55 written_packet->data.SetSize(kMediaPacketLength);
56 uint8_t* data = written_packet->data.MutableData();
57 for (size_t i = 0; i < written_packet->data.size(); ++i) {
58 data[i] = i; // Actual content doesn't matter.
59 }
60 writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
61 packet_mask_size, written_packet.get());
62 return written_packet;
63 }
64
ReadHeader(const Packet & written_packet)65 std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& written_packet) {
66 UlpfecHeaderReader reader;
67 std::unique_ptr<ReceivedFecPacket> read_packet(new ReceivedFecPacket());
68 read_packet->ssrc = kMediaSsrc;
69 read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
70 read_packet->pkt->data = written_packet.data;
71 EXPECT_TRUE(reader.ReadFecHeader(read_packet.get()));
72 return read_packet;
73 }
74
VerifyHeaders(size_t expected_fec_header_size,const uint8_t * expected_packet_mask,size_t expected_packet_mask_size,const Packet & written_packet,const ReceivedFecPacket & read_packet)75 void VerifyHeaders(size_t expected_fec_header_size,
76 const uint8_t* expected_packet_mask,
77 size_t expected_packet_mask_size,
78 const Packet& written_packet,
79 const ReceivedFecPacket& read_packet) {
80 EXPECT_EQ(kMediaSsrc, read_packet.ssrc);
81 EXPECT_EQ(expected_fec_header_size, read_packet.fec_header_size);
82 EXPECT_EQ(kMediaSsrc, read_packet.protected_ssrc);
83 EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base);
84 EXPECT_EQ(kUlpfecPacketMaskOffset, read_packet.packet_mask_offset);
85 ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size);
86 EXPECT_EQ(written_packet.data.size() - expected_fec_header_size,
87 read_packet.protection_length);
88 EXPECT_EQ(0, memcmp(expected_packet_mask,
89 read_packet.pkt->data.MutableData() +
90 read_packet.packet_mask_offset,
91 read_packet.packet_mask_size));
92 // Verify that the call to ReadFecHeader did not tamper with the payload.
93 EXPECT_EQ(0, memcmp(written_packet.data.data() + expected_fec_header_size,
94 read_packet.pkt->data.cdata() + expected_fec_header_size,
95 written_packet.data.size() - expected_fec_header_size));
96 }
97
98 } // namespace
99
TEST(UlpfecHeaderReaderTest,ReadsSmallHeader)100 TEST(UlpfecHeaderReaderTest, ReadsSmallHeader) {
101 const uint8_t packet[] = {
102 0x00, 0x12, 0xab, 0xcd, // L bit clear, "random" payload type and SN base
103 0x12, 0x34, 0x56, 0x78, // "random" TS recovery
104 0xab, 0xcd, 0x11, 0x22, // "random" length recovery and protection length
105 0x33, 0x44, // "random" packet mask
106 0x00, 0x00, 0x00, 0x00 // payload
107 };
108 const size_t packet_length = sizeof(packet);
109 ReceivedFecPacket read_packet;
110 read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
111 read_packet.pkt->data.SetData(packet, packet_length);
112
113 UlpfecHeaderReader reader;
114 EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
115
116 EXPECT_EQ(14U, read_packet.fec_header_size);
117 EXPECT_EQ(0xabcdU, read_packet.seq_num_base);
118 EXPECT_EQ(12U, read_packet.packet_mask_offset);
119 EXPECT_EQ(2U, read_packet.packet_mask_size);
120 EXPECT_EQ(0x1122U, read_packet.protection_length);
121 }
122
TEST(UlpfecHeaderReaderTest,ReadsLargeHeader)123 TEST(UlpfecHeaderReaderTest, ReadsLargeHeader) {
124 const uint8_t packet[] = {
125 0x40, 0x12, 0xab, 0xcd, // L bit set, "random" payload type and SN base
126 0x12, 0x34, 0x56, 0x78, // "random" TS recovery
127 0xab, 0xcd, 0x11, 0x22, // "random" length recovery and protection length
128 0x33, 0x44, 0x55, 0x66, // "random" packet mask
129 0x77, 0x88, //
130 0x00, 0x00, 0x00, 0x00 // payload
131 };
132 const size_t packet_length = sizeof(packet);
133 ReceivedFecPacket read_packet;
134 read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
135 read_packet.pkt->data.SetData(packet, packet_length);
136
137 UlpfecHeaderReader reader;
138 EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
139
140 EXPECT_EQ(18U, read_packet.fec_header_size);
141 EXPECT_EQ(0xabcdU, read_packet.seq_num_base);
142 EXPECT_EQ(12U, read_packet.packet_mask_offset);
143 EXPECT_EQ(6U, read_packet.packet_mask_size);
144 EXPECT_EQ(0x1122U, read_packet.protection_length);
145 }
146
TEST(UlpfecHeaderWriterTest,FinalizesSmallHeader)147 TEST(UlpfecHeaderWriterTest, FinalizesSmallHeader) {
148 const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
149 auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
150 Packet written_packet;
151 written_packet.data.SetSize(kMediaPacketLength);
152 uint8_t* data = written_packet.data.MutableData();
153 for (size_t i = 0; i < written_packet.data.size(); ++i) {
154 data[i] = i;
155 }
156
157 UlpfecHeaderWriter writer;
158 writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask.get(),
159 packet_mask_size, &written_packet);
160
161 const uint8_t* packet = written_packet.data.cdata();
162 EXPECT_EQ(0x00, packet[0] & 0x80); // E bit.
163 EXPECT_EQ(0x00, packet[0] & 0x40); // L bit.
164 EXPECT_EQ(kMediaStartSeqNum, ByteReader<uint16_t>::ReadBigEndian(packet + 2));
165 EXPECT_EQ(
166 static_cast<uint16_t>(kMediaPacketLength - kUlpfecHeaderSizeLBitClear),
167 ByteReader<uint16_t>::ReadBigEndian(packet + 10));
168 EXPECT_EQ(0, memcmp(packet + kUlpfecPacketMaskOffset, packet_mask.get(),
169 packet_mask_size));
170 }
171
TEST(UlpfecHeaderWriterTest,FinalizesLargeHeader)172 TEST(UlpfecHeaderWriterTest, FinalizesLargeHeader) {
173 const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
174 auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
175 Packet written_packet;
176 written_packet.data.SetSize(kMediaPacketLength);
177 uint8_t* data = written_packet.data.MutableData();
178 for (size_t i = 0; i < written_packet.data.size(); ++i) {
179 data[i] = i;
180 }
181
182 UlpfecHeaderWriter writer;
183 writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask.get(),
184 packet_mask_size, &written_packet);
185
186 const uint8_t* packet = written_packet.data.cdata();
187 EXPECT_EQ(0x00, packet[0] & 0x80); // E bit.
188 EXPECT_EQ(0x40, packet[0] & 0x40); // L bit.
189 EXPECT_EQ(kMediaStartSeqNum, ByteReader<uint16_t>::ReadBigEndian(packet + 2));
190 EXPECT_EQ(
191 static_cast<uint16_t>(kMediaPacketLength - kUlpfecHeaderSizeLBitSet),
192 ByteReader<uint16_t>::ReadBigEndian(packet + 10));
193 EXPECT_EQ(0, memcmp(packet + kUlpfecPacketMaskOffset, packet_mask.get(),
194 packet_mask_size));
195 }
196
TEST(UlpfecHeaderWriterTest,CalculateSmallHeaderSize)197 TEST(UlpfecHeaderWriterTest, CalculateSmallHeaderSize) {
198 const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
199 auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
200
201 UlpfecHeaderWriter writer;
202 size_t min_packet_mask_size =
203 writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
204
205 EXPECT_EQ(kUlpfecPacketMaskSizeLBitClear, min_packet_mask_size);
206 EXPECT_EQ(kUlpfecHeaderSizeLBitClear,
207 writer.FecHeaderSize(min_packet_mask_size));
208 }
209
TEST(UlpfecHeaderWriterTest,CalculateLargeHeaderSize)210 TEST(UlpfecHeaderWriterTest, CalculateLargeHeaderSize) {
211 const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
212 auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
213
214 UlpfecHeaderWriter writer;
215 size_t min_packet_mask_size =
216 writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
217
218 EXPECT_EQ(kUlpfecPacketMaskSizeLBitSet, min_packet_mask_size);
219 EXPECT_EQ(kUlpfecHeaderSizeLBitSet,
220 writer.FecHeaderSize(min_packet_mask_size));
221 }
222
TEST(UlpfecHeaderReaderWriterTest,WriteAndReadSmallHeader)223 TEST(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) {
224 const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
225 auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
226
227 auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
228 auto read_packet = ReadHeader(*written_packet);
229
230 VerifyHeaders(kUlpfecHeaderSizeLBitClear, packet_mask.get(), packet_mask_size,
231 *written_packet, *read_packet);
232 }
233
TEST(UlpfecHeaderReaderWriterTest,WriteAndReadLargeHeader)234 TEST(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) {
235 const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
236 auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
237
238 auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
239 auto read_packet = ReadHeader(*written_packet);
240
241 VerifyHeaders(kUlpfecHeaderSizeLBitSet, packet_mask.get(), packet_mask_size,
242 *written_packet, *read_packet);
243 }
244
245 } // namespace webrtc
246