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/base/scoped_ref_ptr.h" | |
21 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" | |
22 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" | |
23 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" | |
24 #include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h" | |
25 | |
26 namespace webrtc { | |
27 | |
28 namespace { | |
29 constexpr uint32_t kMediaSsrc = 1254983; | |
30 constexpr uint16_t kMediaStartSeqNum = 825; | |
31 | |
32 constexpr size_t kTransportOverhead = 28; | |
33 | |
34 constexpr size_t kUlpfecHeaderSizeLBitClear = 14; | |
35 constexpr size_t kUlpfecHeaderSizeLBitSet = 18; | |
36 constexpr size_t kUlpfecMaxHeaderSize = kUlpfecHeaderSizeLBitSet; | |
37 constexpr size_t kUlpfecPacketMaskOffset = 12; | |
38 | |
39 constexpr size_t kMaxRtpPayloadSize = | |
40 IP_PACKET_SIZE - kTransportOverhead - kRtpHeaderSize - kUlpfecMaxHeaderSize; | |
41 } // namespace | |
42 | |
43 using Packet = ::webrtc::ForwardErrorCorrection::Packet; | |
44 using PacketList = ::webrtc::ForwardErrorCorrection::PacketList; | |
45 using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket; | |
46 | |
47 class UlpfecHeaderReaderWriterTest : public ::testing::Test { | |
48 protected: | |
49 UlpfecHeaderReaderWriterTest() | |
50 : random_(0xabcdef123456), | |
51 media_packet_generator_(kRtpHeaderSize, | |
52 kMaxRtpPayloadSize, | |
53 kMediaSsrc, | |
54 &random_) {} | |
55 | |
56 // Set the corresponding bits of the packet mask. | |
57 void ClearBit(size_t index); | |
danilchap
2016/08/30 12:29:01
Will these two helpers be used for ulpfec?
brandtr
2016/08/30 14:14:24
Nope, removed!
| |
58 void SetBit(size_t index); | |
59 | |
60 // Randomly generate packet mask of specified size. | |
61 void GeneratePacketMask(size_t packet_mask_size); | |
62 | |
63 std::pair<std::unique_ptr<Packet>, std::unique_ptr<ReceivedFecPacket>> | |
64 WriteAndReadHeaders(size_t original_packet_mask_size); | |
65 | |
66 void VerifyHeaders(std::pair<std::unique_ptr<Packet>, | |
danilchap
2016/08/30 12:29:01
to follow EXPECT macros style might be better to p
brandtr
2016/08/30 14:14:24
Done.
| |
67 std::unique_ptr<ReceivedFecPacket>> packets, | |
68 size_t expected_fec_header_size, | |
69 size_t expected_packet_mask_size); | |
70 | |
71 UlpfecHeaderReader reader_; | |
72 UlpfecHeaderWriter writer_; | |
73 | |
74 Random random_; | |
75 test::fec::MediaPacketGenerator media_packet_generator_; | |
76 PacketList* media_packets_; | |
danilchap
2016/08/30 12:29:01
looks unused
brandtr
2016/08/30 14:14:24
Removed.
| |
77 uint8_t packet_mask_[kUlpfecMaxPacketMaskSize]; | |
78 }; | |
79 | |
80 void UlpfecHeaderReaderWriterTest::ClearBit(size_t index) { | |
81 packet_mask_[index / 8] &= ~(1 << (7 - index % 8)); | |
82 } | |
83 | |
84 void UlpfecHeaderReaderWriterTest::SetBit(size_t index) { | |
85 packet_mask_[index / 8] |= (1 << (7 - index % 8)); | |
86 } | |
87 | |
88 void UlpfecHeaderReaderWriterTest::GeneratePacketMask(size_t packet_mask_size) { | |
89 RTC_DCHECK_LE(packet_mask_size, kUlpfecMaxPacketMaskSize); | |
90 memset(packet_mask_, 0u, sizeof(packet_mask_)); | |
91 for (size_t i = 0; i < packet_mask_size; ++i) { | |
92 packet_mask_[i] = random_.Rand<uint8_t>(); | |
93 } | |
94 } | |
95 | |
96 std::pair<std::unique_ptr<Packet>, std::unique_ptr<ReceivedFecPacket>> | |
97 UlpfecHeaderReaderWriterTest::WriteAndReadHeaders( | |
98 size_t original_packet_mask_size) { | |
99 // Generate media. | |
100 constexpr size_t kNumMediaPackets = 1; | |
101 PacketList media_packets = | |
102 media_packet_generator_.ConstructMediaPacketsSeqNum(kNumMediaPackets, | |
103 kMediaStartSeqNum); | |
104 | |
105 // Write FEC header. | |
106 std::unique_ptr<Packet> packet_to_write(new Packet()); | |
107 packet_to_write->length = media_packets.front()->length; | |
danilchap
2016/08/30 12:29:01
looks like length and seq_no is all your need from
brandtr
2016/08/30 14:14:24
Done.
| |
108 for (size_t i = 0; i < packet_to_write->length; ++i) { | |
109 packet_to_write->data[i] = random_.Rand<uint8_t>(); | |
110 } | |
111 const uint16_t seq_num_base = ForwardErrorCorrection::ParseSequenceNumber( | |
danilchap
2016/08/30 12:29:01
is it kMediaStartSeqNum?
brandtr
2016/08/30 14:14:24
Yep, changed.
| |
112 media_packets.front().get()->data); | |
113 writer_.FinalizeFecHeader(seq_num_base, packet_mask_, | |
danilchap
2016/08/30 12:29:01
in another comment you wrote that XorHeaders shoul
brandtr
2016/08/30 14:14:24
It's not super-easy, since XorHeaders are in Forwa
| |
114 original_packet_mask_size, packet_to_write.get()); | |
115 | |
116 // Read FEC header. | |
117 std::unique_ptr<ReceivedFecPacket> packet_to_read(new ReceivedFecPacket()); | |
118 packet_to_read->ssrc = kMediaSsrc; | |
119 packet_to_read->protected_ssrc = kMediaSsrc; | |
120 packet_to_read->pkt = rtc::scoped_refptr<Packet>(new Packet()); | |
121 memcpy(packet_to_read->pkt->data, packet_to_write->data, | |
122 packet_to_write->length); | |
123 packet_to_read->pkt->length = packet_to_write->length; | |
124 EXPECT_TRUE(reader_.ReadFecHeader(packet_to_read.get())); | |
125 | |
126 return std::make_pair(std::move(packet_to_write), std::move(packet_to_read)); | |
127 } | |
128 | |
129 void UlpfecHeaderReaderWriterTest::VerifyHeaders( | |
130 std::pair<std::unique_ptr<Packet>, std::unique_ptr<ReceivedFecPacket>> | |
danilchap
2016/08/30 12:29:01
probably cleaner to take two parameters instead of
brandtr
2016/08/30 14:14:24
Done.
| |
131 packets, | |
132 size_t expected_fec_header_size, | |
133 size_t expected_packet_mask_size) { | |
134 Packet* packet_to_write = packets.first.get(); | |
135 ReceivedFecPacket* packet_to_read = packets.second.get(); | |
136 | |
137 // Verify that written and read FEC headers are consistent. | |
138 EXPECT_EQ(expected_fec_header_size, packet_to_read->fec_header_size); | |
139 EXPECT_EQ(packet_to_write->length - expected_fec_header_size, | |
140 packet_to_read->protection_length); | |
141 ReceivedFecPacket::StreamPacketMaskInfo stream_packet_mask_info = | |
142 packet_to_read->packet_mask_infos[kMediaSsrc]; | |
143 EXPECT_EQ(kMediaStartSeqNum, stream_packet_mask_info.seq_num_base); | |
144 size_t packet_mask_offset = stream_packet_mask_info.offset; | |
145 EXPECT_EQ(kUlpfecPacketMaskOffset, packet_mask_offset); | |
146 size_t size = stream_packet_mask_info.size; | |
147 ASSERT_EQ(expected_packet_mask_size, size); | |
148 EXPECT_EQ(0, memcmp(packet_mask_, | |
149 &packet_to_read->pkt->data[packet_mask_offset], size)); | |
150 EXPECT_EQ(0, memcmp(&packet_to_write->data[expected_fec_header_size], | |
danilchap
2016/08/30 12:29:01
What functionality of HeaderReaderWriter is tested
brandtr
2016/08/30 14:14:24
This memcmp is to check that the ReadFecHeader fun
| |
151 &packet_to_read->pkt->data[expected_fec_header_size], | |
152 packet_to_write->length - expected_fec_header_size)); | |
153 } | |
154 | |
155 TEST_F(UlpfecHeaderReaderWriterTest, CalculateSmallHeaderSize) { | |
156 GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); | |
157 EXPECT_EQ(kUlpfecHeaderSizeLBitClear, | |
158 writer_.FecHeaderSize(writer_.MinPacketMaskSize( | |
159 packet_mask_, kUlpfecPacketMaskSizeLBitClear))); | |
160 } | |
161 | |
162 TEST_F(UlpfecHeaderReaderWriterTest, CalculateLargeHeaderSize) { | |
163 GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); | |
164 EXPECT_EQ(kUlpfecHeaderSizeLBitSet, | |
165 writer_.FecHeaderSize(writer_.MinPacketMaskSize( | |
166 packet_mask_, kUlpfecPacketMaskSizeLBitSet))); | |
167 } | |
168 | |
169 TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) { | |
170 GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); | |
171 VerifyHeaders(WriteAndReadHeaders(kUlpfecPacketMaskSizeLBitClear), | |
danilchap
2016/08/30 12:29:01
for clearer separation of run and verify phases i
brandtr
2016/08/30 14:14:24
Done.
| |
172 kUlpfecHeaderSizeLBitClear, kUlpfecPacketMaskSizeLBitClear); | |
173 } | |
174 | |
175 TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) { | |
176 GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); | |
177 VerifyHeaders(WriteAndReadHeaders(kUlpfecPacketMaskSizeLBitSet), | |
178 kUlpfecHeaderSizeLBitSet, kUlpfecPacketMaskSizeLBitSet); | |
179 } | |
180 | |
181 } // namespace webrtc | |
OLD | NEW |