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 } // namespace | |
39 | |
40 using Packet = ::webrtc::ForwardErrorCorrection::Packet; | |
41 using PacketList = ::webrtc::ForwardErrorCorrection::PacketList; | |
42 using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket; | |
43 | |
44 class UlpfecHeaderReaderWriterTest : public ::testing::Test { | |
45 protected: | |
46 UlpfecHeaderReaderWriterTest() | |
47 : random_(0xabcdef123456), | |
48 media_packet_generator_(kRtpHeaderSize, | |
49 IP_PACKET_SIZE - kRtpHeaderSize - | |
50 kTransportOverhead - | |
danilchap
2016/08/29 12:26:03
swap -kTranposrtOverhead and -kRtpHeaderSize
to ma
brandtr
2016/08/30 07:12:42
Done.
| |
51 kUlpfecMaxHeaderSize, | |
52 kMediaSsrc, | |
53 &random_) {} | |
54 | |
55 // Set the corresponding bits of the packet mask. | |
56 void ClearBit(size_t index); | |
57 void SetBit(size_t index); | |
58 | |
59 // Randomly generate packet mask of specified size. | |
60 void GeneratePacketMask(size_t packet_mask_size); | |
61 | |
62 void WriteReadAndVerifyHeaders(size_t original_packet_mask_size, | |
danilchap
2016/08/29 12:26:03
possible to split this function into WriteRead and
brandtr
2016/08/30 07:12:42
Done.
| |
63 size_t expected_fec_header_size, | |
64 size_t expected_packet_mask_size); | |
65 | |
66 UlpfecHeaderReader reader_; | |
67 UlpfecHeaderWriter writer_; | |
68 | |
69 Random random_; | |
70 test::fec::MediaPacketGenerator media_packet_generator_; | |
71 PacketList* media_packets_; | |
72 uint8_t packet_mask_[kUlpfecMaxPacketMaskSize]; | |
73 }; | |
74 | |
75 void UlpfecHeaderReaderWriterTest::ClearBit(size_t index) { | |
76 packet_mask_[index / 8] &= ~(1 << (7 - index % 8)); | |
77 } | |
78 | |
79 void UlpfecHeaderReaderWriterTest::SetBit(size_t index) { | |
80 packet_mask_[index / 8] |= (1 << (7 - index % 8)); | |
81 } | |
82 | |
83 void UlpfecHeaderReaderWriterTest::GeneratePacketMask(size_t packet_mask_size) { | |
84 RTC_DCHECK_LE(packet_mask_size, kUlpfecMaxPacketMaskSize); | |
85 memset(packet_mask_, 0u, sizeof(packet_mask_)); | |
86 for (size_t i = 0; i < packet_mask_size; ++i) { | |
87 packet_mask_[i] = random_.Rand<uint8_t>(); | |
88 } | |
89 } | |
90 | |
91 void UlpfecHeaderReaderWriterTest::WriteReadAndVerifyHeaders( | |
92 size_t original_packet_mask_size, | |
93 size_t expected_fec_header_size, | |
94 size_t expected_packet_mask_size) { | |
95 // Generate media. | |
96 constexpr size_t kNumMediaPackets = 1; | |
97 PacketList media_packets = | |
98 media_packet_generator_.ConstructMediaPacketsSeqNum(kNumMediaPackets, | |
99 kMediaStartSeqNum); | |
100 | |
101 // Set up FEC packet containers. | |
102 ReceivedFecPacket received_fec_packet; | |
danilchap
2016/08/29 12:26:03
there is no sending or receiving in this function.
brandtr
2016/08/30 07:12:42
Renamed.
| |
103 received_fec_packet.rtp_ssrc = kMediaSsrc; | |
104 received_fec_packet.pkt = rtc::scoped_refptr<Packet>(new Packet()); | |
105 Packet* sent_fec_packet = received_fec_packet.pkt.get(); | |
danilchap
2016/08/29 12:26:03
is it raw_fec_packet? or unparsed_fec_packet
brandtr
2016/08/30 07:12:42
Renamed.
| |
106 sent_fec_packet->length = media_packets.front()->length; | |
107 for (size_t i = 0; i < sent_fec_packet->length; ++i) { | |
108 sent_fec_packet->data[i] = random_.Rand<uint8_t>(); | |
109 } | |
110 | |
111 // Write FEC header. | |
112 writer_.FinalizeFecHeader(media_packets, packet_mask_, | |
113 original_packet_mask_size, sent_fec_packet); | |
114 | |
115 // Read FEC header. | |
116 EXPECT_TRUE(reader_.ReadFecHeader(&received_fec_packet)); | |
117 | |
118 // Verify that written and read FEC headers are consistent. | |
119 EXPECT_EQ(expected_fec_header_size, received_fec_packet.fec_header_size); | |
120 EXPECT_EQ(received_fec_packet.pkt->length - expected_fec_header_size, | |
danilchap
2016/08/29 12:26:03
which variable is tested this line?
received_fec_p
brandtr
2016/08/30 07:12:42
Makes sense! protection_length is the variable tes
| |
121 received_fec_packet.protection_length); | |
122 auto stream_packet_mask_info = | |
123 received_fec_packet.packet_mask_infos[kMediaSsrc]; | |
124 EXPECT_EQ(kMediaStartSeqNum, stream_packet_mask_info.seq_num_base); | |
125 size_t offset = stream_packet_mask_info.offset; | |
danilchap
2016/08/29 12:26:03
may be name local variables mask_offset/mask_size
brandtr
2016/08/30 07:12:42
Done.
| |
126 EXPECT_EQ(kUlpfecPacketMaskOffset, offset); | |
127 size_t size = stream_packet_mask_info.size; | |
128 ASSERT_EQ(expected_packet_mask_size, size); | |
129 EXPECT_EQ(0, | |
130 memcmp(packet_mask_, &received_fec_packet.pkt->data[offset], size)); | |
131 EXPECT_EQ(0, memcmp(&sent_fec_packet->data[expected_fec_header_size], | |
danilchap
2016/08/29 12:26:03
since sent_fec_packet = received_fec_packet.pkt (s
brandtr
2016/08/30 07:12:42
Pretty glaring mistake here! I've changed so I'm m
| |
132 &received_fec_packet.pkt->data[expected_fec_header_size], | |
133 sent_fec_packet->length - expected_fec_header_size)); | |
134 } | |
135 | |
136 TEST_F(UlpfecHeaderReaderWriterTest, CalculateSmallHeaderSize) { | |
137 GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); | |
danilchap
2016/08/29 12:26:03
Does randomness of packet mask itself affects FecH
brandtr
2016/08/30 07:12:42
For Ulpfec, the contents of the packet mask does n
| |
138 EXPECT_EQ(kUlpfecHeaderSizeLBitClear, | |
139 writer_.FecHeaderSize(writer_.MinPacketMaskSize( | |
140 packet_mask_, kUlpfecPacketMaskSizeLBitClear))); | |
141 } | |
142 | |
143 TEST_F(UlpfecHeaderReaderWriterTest, CalculateLargeHeaderSize) { | |
144 GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); | |
145 EXPECT_EQ(kUlpfecHeaderSizeLBitSet, | |
146 writer_.FecHeaderSize(writer_.MinPacketMaskSize( | |
147 packet_mask_, kUlpfecPacketMaskSizeLBitSet))); | |
148 } | |
149 | |
150 TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) { | |
151 GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); | |
152 WriteReadAndVerifyHeaders(kUlpfecPacketMaskSizeLBitClear, | |
153 kUlpfecHeaderSizeLBitClear, | |
154 kUlpfecPacketMaskSizeLBitClear); | |
155 } | |
156 | |
157 TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) { | |
158 GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); | |
159 WriteReadAndVerifyHeaders(kUlpfecPacketMaskSizeLBitSet, | |
160 kUlpfecHeaderSizeLBitSet, | |
161 kUlpfecPacketMaskSizeLBitSet); | |
162 } | |
163 | |
164 } // namespace webrtc | |
OLD | NEW |