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