OLD | NEW |
---|---|
(Empty) | |
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 <string.h> | |
12 | |
13 #include <memory> | |
14 #include <utility> | |
15 | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 #include "webrtc/base/basictypes.h" | |
18 #include "webrtc/base/checks.h" | |
19 #include "webrtc/base/random.h" | |
20 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" | |
21 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" | |
22 #include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h" | |
23 | |
24 namespace webrtc { | |
25 | |
26 namespace { | |
27 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum. | |
28 constexpr size_t kTransportOverhead = 28; | |
29 | |
30 // ULPFEC header: largest packet mask. | |
31 constexpr size_t kUlpfecMaxHeaderSize = 18; | |
32 | |
33 constexpr uint32_t kMediaSsrc = 1254983; | |
34 } // namespace | |
35 | |
36 class FecPacketizationTest : public ::testing::Test { | |
37 protected: | |
38 FecPacketizationTest(std::unique_ptr<FecHeaderReader> fec_header_reader, | |
39 std::unique_ptr<FecHeaderWriter> fec_header_writer, | |
40 size_t min_packet_size, | |
41 size_t max_packet_size) | |
42 : fec_header_reader_(std::move(fec_header_reader)), | |
43 fec_header_writer_(std::move(fec_header_writer)), | |
44 random_(0xabcdef123456), | |
45 media_packet_generator_(min_packet_size, | |
46 max_packet_size, | |
47 kMediaSsrc, | |
48 &random_), | |
49 packet_mask_() {} | |
danilchap
2016/08/24 16:41:27
needed?
brandtr
2016/08/25 13:23:07
Nope, gone.
| |
50 | |
51 // Set the corresponding bits of the ULPFEC packet mask. | |
52 void Bit15Clear(); | |
danilchap
2016/08/24 16:41:26
May be have just two functions instead:
void Clear
brandtr
2016/08/25 13:23:07
Nice, thanks!
| |
53 void Bit15Set(); | |
54 void Bit46ClearBit47Clear(); | |
55 void Bit46SetBit47Clear(); | |
56 void Bit46ClearBit47Set(); | |
57 void Bit46SetBit47Set(); | |
58 | |
59 // Randomly generate ULPFEC packet mask of specified size. | |
60 void GenerateUlpfecPacketMask(size_t packet_mask_size); | |
danilchap
2016/08/24 16:41:27
Name of this function hints it is ulp specific. Ma
brandtr
2016/08/25 13:23:07
It sounds like it is Ulpfec specific, but it's not
| |
61 | |
62 void ReadWriteAndVerifyHeaders(size_t ulpfec_packet_mask_size, | |
danilchap
2016/08/24 16:41:27
Parameter name hints it is ulp specific.
brandtr
2016/08/25 13:23:07
Same thing here. ulpfec_packet_mask_size correspon
| |
63 size_t expected_fec_header_size, | |
64 size_t expected_packet_mask_size); | |
65 | |
66 virtual void MaybeSetFecSsrcToMediaSsrc( | |
67 uint32_t media_ssrc, | |
68 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) = 0; | |
69 | |
70 virtual size_t ExpectedPacketMaskOffset() = 0; | |
71 | |
72 std::unique_ptr<FecHeaderReader> fec_header_reader_; | |
73 std::unique_ptr<FecHeaderWriter> fec_header_writer_; | |
74 | |
75 Random random_; | |
76 test::fec::MediaPacketGenerator media_packet_generator_; | |
77 ForwardErrorCorrection::PacketList* media_packets_; | |
78 uint8_t packet_mask_[14]; // Only filled with ULPFEC packet mask (6 bytes), | |
danilchap
2016/08/24 16:41:26
may be add constant kMaxPacketMaskSize instead of
brandtr
2016/08/25 13:23:07
Done.
| |
79 // but needs to be 14 bytes in order to do | |
80 // memcmp with parsed FlexFEC mask. | |
81 }; | |
82 | |
83 class UlpfecPacketizationTest : public FecPacketizationTest { | |
84 protected: | |
85 UlpfecPacketizationTest() | |
86 : FecPacketizationTest( | |
87 std::unique_ptr<FecHeaderReader>(new UlpfecHeaderReader()), | |
88 std::unique_ptr<FecHeaderWriter>(new UlpfecHeaderWriter()), | |
89 kRtpHeaderSize, | |
90 IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead - | |
91 kUlpfecMaxHeaderSize) {} | |
92 | |
93 void MaybeSetFecSsrcToMediaSsrc( | |
94 uint32_t media_ssrc, | |
95 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) { | |
danilchap
2016/08/24 16:41:26
override
brandtr
2016/08/25 13:23:07
Hm, seems that the compiler does not warn about mi
| |
96 fec_packet->rtp_ssrc = media_ssrc; | |
97 } | |
98 | |
99 size_t ExpectedPacketMaskOffset() { return 12u; } | |
danilchap
2016/08/24 16:41:26
add override
(otherwise it raise question why you
brandtr
2016/08/25 13:23:07
Done.
| |
100 }; | |
101 | |
102 // Verifies that the header size is correctly calculated. | |
103 TEST_F(UlpfecPacketizationTest, HeaderSizeTest) { | |
danilchap
2016/08/24 16:41:27
using 'Test' in Test name feels unnecessary (there
danilchap
2016/08/24 16:41:27
put tests below helper functions.
It is also ok to
brandtr
2016/08/25 13:23:07
Good point! Renamed.
brandtr
2016/08/25 13:23:07
Moved helper functions.
I don't like the clutter
| |
104 constexpr size_t kShortMask = kUlpfecPacketMaskSizeLBitClear; | |
105 GenerateUlpfecPacketMask(kShortMask); | |
106 EXPECT_EQ(14u, fec_header_writer_->FecHeaderSize( | |
danilchap
2016/08/24 16:41:26
why 14 is a correct value? May be name the constan
brandtr
2016/08/25 13:23:07
Done.
| |
107 fec_header_writer_->MinPacketMaskSize(packet_mask_, | |
108 kShortMask))); | |
109 | |
danilchap
2016/08/24 16:41:26
Theese are two separate tests,
each with own setup
brandtr
2016/08/25 13:23:07
Done.
| |
110 constexpr size_t kLongMask = kUlpfecPacketMaskSizeLBitSet; | |
111 GenerateUlpfecPacketMask(kLongMask); | |
112 EXPECT_EQ( | |
113 18u, fec_header_writer_->FecHeaderSize( | |
danilchap
2016/08/24 16:41:26
may be kUlpfecMaxHeaderSize insteaf of 18?
brandtr
2016/08/25 13:23:07
Done.
| |
114 fec_header_writer_->MinPacketMaskSize(packet_mask_, kLongMask))); | |
115 } | |
116 | |
117 // Verifies that the reading and writing operations are consistent. | |
118 TEST_F(UlpfecPacketizationTest, ReaderWriterTest) { | |
danilchap
2016/08/24 16:41:27
Same, omit 'Test' in test name, but put more descr
brandtr
2016/08/25 13:23:07
Done.
| |
119 SCOPED_TRACE(""); // To get call site line number, if failing. | |
120 | |
121 constexpr size_t kShortMask = kUlpfecPacketMaskSizeLBitClear; | |
122 GenerateUlpfecPacketMask(kShortMask); | |
123 ReadWriteAndVerifyHeaders(kShortMask, 14u, 2u); | |
124 | |
125 constexpr size_t kLongMask = kUlpfecPacketMaskSizeLBitSet; | |
126 GenerateUlpfecPacketMask(kLongMask); | |
127 ReadWriteAndVerifyHeaders(kLongMask, 18u, 6u); | |
128 } | |
129 | |
130 void FecPacketizationTest::Bit15Clear() { | |
131 packet_mask_[1] &= 0xfe; | |
132 } | |
133 | |
134 void FecPacketizationTest::Bit15Set() { | |
135 packet_mask_[1] |= 0x01; | |
136 } | |
137 | |
138 void FecPacketizationTest::Bit46ClearBit47Clear() { | |
139 packet_mask_[5] &= 0xfc; | |
140 } | |
141 | |
142 void FecPacketizationTest::Bit46SetBit47Clear() { | |
143 Bit46ClearBit47Clear(); | |
144 packet_mask_[5] ^= 0x02; | |
145 } | |
146 | |
147 void FecPacketizationTest::Bit46ClearBit47Set() { | |
148 Bit46ClearBit47Clear(); | |
149 packet_mask_[5] ^= 0x01; | |
150 } | |
151 | |
152 void FecPacketizationTest::Bit46SetBit47Set() { | |
153 packet_mask_[5] |= 0x03; | |
154 } | |
155 | |
156 void FecPacketizationTest::GenerateUlpfecPacketMask(size_t packet_mask_size) { | |
157 RTC_DCHECK_LE(packet_mask_size, 6u); | |
158 memset(packet_mask_, 0u, 14); | |
159 for (size_t i = 0; i < packet_mask_size; ++i) { | |
160 packet_mask_[i] = random_.Rand<uint8_t>(); | |
161 } | |
162 } | |
163 | |
164 void FecPacketizationTest::ReadWriteAndVerifyHeaders( | |
165 size_t ulpfec_packet_mask_size, | |
166 size_t expected_fec_header_size, | |
167 size_t expected_packet_mask_size) { | |
168 // Generate media. | |
169 constexpr int kNumMediaPackets = 1; | |
170 ForwardErrorCorrection::PacketList media_packets = | |
171 media_packet_generator_.ConstructMediaPackets(kNumMediaPackets); | |
172 uint16_t media_seq_num = | |
173 media_packet_generator_.GetFecSeqNum() - kNumMediaPackets; | |
174 | |
175 // Set up FEC packet containers. | |
176 ForwardErrorCorrection::Packet* sent_fec_packet = | |
177 new ForwardErrorCorrection::Packet(); // deleted by scoped_refptr in | |
danilchap
2016/08/24 16:41:26
Remove the comment and make the type scoped_refptr
brandtr
2016/08/25 13:23:07
Good idea!! This isn't the way it's done in the cu
| |
178 // |received_fec_packet| | |
179 sent_fec_packet->length = media_packets.front()->length; | |
180 for (size_t i = 0; i < sent_fec_packet->length; ++i) { | |
181 sent_fec_packet->data[i] = random_.Rand<uint8_t>(); | |
182 } | |
183 ForwardErrorCorrection::ReceivedFecPacket received_fec_packet; | |
184 received_fec_packet.pkt = sent_fec_packet; | |
185 | |
186 // Write FEC header. | |
187 fec_header_writer_->FinalizeFecHeader( | |
188 media_packets, packet_mask_, ulpfec_packet_mask_size, sent_fec_packet); | |
189 | |
190 // Read FEC header. | |
191 MaybeSetFecSsrcToMediaSsrc(kMediaSsrc, &received_fec_packet); | |
192 EXPECT_TRUE(fec_header_reader_->ReadFecHeader(&received_fec_packet)); | |
193 | |
194 // Verify that written and read FEC headers are consistent. | |
195 EXPECT_EQ(expected_fec_header_size, received_fec_packet.fec_header_size); | |
196 EXPECT_EQ(received_fec_packet.pkt->length - expected_fec_header_size, | |
197 received_fec_packet.protection_length); | |
198 auto stream_packet_mask_info = | |
199 received_fec_packet.packet_mask_infos[kMediaSsrc]; | |
200 EXPECT_EQ(media_seq_num, stream_packet_mask_info.seq_num_base); | |
201 size_t offset = stream_packet_mask_info.offset; | |
202 EXPECT_EQ(ExpectedPacketMaskOffset(), offset); | |
203 size_t size = stream_packet_mask_info.size; | |
204 ASSERT_EQ(expected_packet_mask_size, size); | |
205 EXPECT_EQ(0, | |
206 memcmp(packet_mask_, &received_fec_packet.pkt->data[offset], size)); | |
207 EXPECT_EQ(0, memcmp(&sent_fec_packet->data[expected_fec_header_size], | |
208 &received_fec_packet.pkt->data[expected_fec_header_size], | |
209 sent_fec_packet->length - expected_fec_header_size)); | |
210 } | |
211 | |
212 } // namespace webrtc | |
OLD | NEW |