OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <algorithm> | 11 #include <algorithm> |
12 #include <list> | 12 #include <list> |
13 | 13 |
14 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
15 #include "webrtc/base/random.h" | 15 #include "webrtc/base/random.h" |
16 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 16 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
17 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" | 17 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
18 | 18 |
19 using webrtc::ForwardErrorCorrection; | 19 using webrtc::ForwardErrorCorrection; |
20 | 20 |
21 // Minimum RTP header size in bytes. | 21 // Minimum RTP header size in bytes. |
22 const uint8_t kRtpHeaderSize = 12; | 22 constexpr uint8_t kRtpHeaderSize = 12; |
23 | 23 |
24 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum. | 24 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum. |
25 const uint8_t kTransportOverhead = 28; | 25 constexpr uint8_t kTransportOverhead = 28; |
26 | 26 |
27 // Maximum number of media packets used in the FEC (RFC 5109). | 27 // Maximum number of media packets used in the FEC (RFC 5109). |
28 const uint8_t kMaxNumberMediaPackets = ForwardErrorCorrection::kMaxMediaPackets; | 28 constexpr uint8_t kMaxNumberMediaPackets = |
| 29 ForwardErrorCorrection::kMaxMediaPackets; |
29 | 30 |
30 using PacketList = ForwardErrorCorrection::PacketList; | 31 using PacketList = ForwardErrorCorrection::PacketList; |
31 using ReceivedPacketList = ForwardErrorCorrection::ReceivedPacketList; | 32 using ReceivedPacketList = ForwardErrorCorrection::ReceivedPacketList; |
32 using RecoveredPacketList = ForwardErrorCorrection::RecoveredPacketList; | 33 using RecoveredPacketList = ForwardErrorCorrection::RecoveredPacketList; |
33 | 34 |
34 class RtpFecTest : public ::testing::Test { | 35 class RtpFecTest : public ::testing::Test { |
35 protected: | 36 protected: |
36 RtpFecTest() | 37 RtpFecTest() |
37 : random_(0xfec133700742), | 38 : random_(0xfec133700742), |
38 fec_(new ForwardErrorCorrection()), | |
39 ssrc_(random_.Rand<uint32_t>()), | 39 ssrc_(random_.Rand<uint32_t>()), |
40 fec_seq_num_(0) {} | 40 fec_seq_num_(0) {} |
41 | 41 |
42 webrtc::Random random_; | |
43 ForwardErrorCorrection* fec_; | |
44 int ssrc_; | |
45 uint16_t fec_seq_num_; | |
46 | |
47 PacketList media_packet_list_; | |
48 std::list<ForwardErrorCorrection::Packet*> fec_packet_list_; | |
49 ReceivedPacketList received_packet_list_; | |
50 RecoveredPacketList recovered_packet_list_; | |
51 | |
52 // Media packet "i" is lost if media_loss_mask_[i] = 1, | |
53 // received if media_loss_mask_[i] = 0. | |
54 int media_loss_mask_[kMaxNumberMediaPackets]; | |
55 | |
56 // FEC packet "i" is lost if fec_loss_mask_[i] = 1, | |
57 // received if fec_loss_mask_[i] = 0. | |
58 int fec_loss_mask_[kMaxNumberMediaPackets]; | |
59 | |
60 // Construct the media packet list, up to |num_media_packets| packets. | 42 // Construct the media packet list, up to |num_media_packets| packets. |
61 // Returns the next sequence number after the last media packet. | 43 // Returns the next sequence number after the last media packet. |
62 // (this will be the sequence of the first FEC packet) | 44 // (this will be the sequence of the first FEC packet) |
63 int ConstructMediaPacketsSeqNum(int num_media_packets, int start_seq_num); | 45 int ConstructMediaPacketsSeqNum(int num_media_packets, int start_seq_num); |
64 int ConstructMediaPackets(int num_media_packets); | 46 int ConstructMediaPackets(int num_media_packets); |
65 | 47 |
66 // Deep copies |src| to |dst|, but only keeps every Nth packet. | 48 // Deep copies |src| to |dst|, but only keeps every Nth packet. |
67 void DeepCopyEveryNthPacket(const PacketList& src, int n, PacketList* dst); | 49 void DeepCopyEveryNthPacket(const PacketList& src, int n, PacketList* dst); |
68 | 50 |
69 // Construct the received packet list: a subset of the media and FEC packets. | 51 // Construct |received_packet_list_|: a subset of the media and FEC packets. |
70 void NetworkReceivedPackets(); | 52 // |
| 53 // Media packet "i" is lost if media_loss_mask_[i] = 1, received if |
| 54 // media_loss_mask_[i] = 0. |
| 55 // FEC packet "i" is lost if fec_loss_mask_[i] = 1, received if |
| 56 // fec_loss_mask_[i] = 0. |
| 57 void NetworkReceivedPackets(int* media_loss_mask, int* fec_loss_mask); |
71 | 58 |
72 // Add packet from |packet_list| to list of received packets, using the | 59 // Add packet from |packet_list| to list of received packets, using the |
73 // |loss_mask|. | 60 // |loss_mask|. |
74 // The |packet_list| may be a media packet list (is_fec = false), or a | 61 // The |packet_list| may be a media packet list (is_fec = false), or a |
75 // FEC packet list (is_fec = true). | 62 // FEC packet list (is_fec = true). |
76 template <typename T> | 63 template <typename T> |
77 void ReceivedPackets(const T& packet_list, int* loss_mask, bool is_fec); | 64 void ReceivedPackets(const T& packet_list, int* loss_mask, bool is_fec); |
78 | 65 |
79 // Check for complete recovery after FEC decoding. | 66 // Check for complete recovery after FEC decoding. |
80 bool IsRecoveryComplete(); | 67 bool IsRecoveryComplete(); |
81 | 68 |
82 // Delete the media and FEC packets. | 69 // Delete the media and FEC packets. |
83 void TearDown(); | 70 void TearDown(); |
| 71 |
| 72 webrtc::Random random_; |
| 73 ForwardErrorCorrection fec_; |
| 74 int ssrc_; |
| 75 uint16_t fec_seq_num_; |
| 76 |
| 77 PacketList media_packet_list_; |
| 78 std::list<ForwardErrorCorrection::Packet*> fec_packet_list_; |
| 79 ReceivedPacketList received_packet_list_; |
| 80 RecoveredPacketList recovered_packet_list_; |
| 81 |
| 82 int media_loss_mask_[kMaxNumberMediaPackets]; |
| 83 int fec_loss_mask_[kMaxNumberMediaPackets]; |
84 }; | 84 }; |
85 | 85 |
86 TEST_F(RtpFecTest, FecRecoveryNoLoss) { | 86 TEST_F(RtpFecTest, FecRecoveryNoLoss) { |
87 const int kNumImportantPackets = 0; | 87 constexpr int kNumImportantPackets = 0; |
88 const bool kUseUnequalProtection = false; | 88 constexpr bool kUseUnequalProtection = false; |
89 const int kNumMediaPackets = 4; | 89 constexpr int kNumMediaPackets = 4; |
90 uint8_t kProtectionFactor = 60; | 90 constexpr uint8_t kProtectionFactor = 60; |
91 | 91 |
92 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 92 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
93 | 93 |
94 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 94 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
95 kNumImportantPackets, kUseUnequalProtection, | 95 kNumImportantPackets, kUseUnequalProtection, |
96 webrtc::kFecMaskBursty, &fec_packet_list_)); | 96 webrtc::kFecMaskBursty, &fec_packet_list_)); |
97 | 97 |
98 // Expect 1 FEC packet. | 98 // Expect 1 FEC packet. |
99 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 99 EXPECT_EQ(1u, fec_packet_list_.size()); |
100 | 100 |
101 // No packets lost. | 101 // No packets lost. |
102 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 102 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
103 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 103 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
104 NetworkReceivedPackets(); | 104 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
105 | 105 |
106 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 106 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
107 &recovered_packet_list_)); | |
108 | 107 |
109 // No packets lost, expect complete recovery. | 108 // No packets lost, expect complete recovery. |
110 EXPECT_TRUE(IsRecoveryComplete()); | 109 EXPECT_TRUE(IsRecoveryComplete()); |
111 } | 110 } |
112 | 111 |
113 TEST_F(RtpFecTest, FecRecoveryWithLoss) { | 112 TEST_F(RtpFecTest, FecRecoveryWithLoss) { |
114 const int kNumImportantPackets = 0; | 113 constexpr int kNumImportantPackets = 0; |
115 const bool kUseUnequalProtection = false; | 114 constexpr bool kUseUnequalProtection = false; |
116 const int kNumMediaPackets = 4; | 115 constexpr int kNumMediaPackets = 4; |
117 uint8_t kProtectionFactor = 60; | 116 constexpr uint8_t kProtectionFactor = 60; |
118 | 117 |
119 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 118 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
120 | 119 |
121 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 120 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
122 kNumImportantPackets, kUseUnequalProtection, | 121 kNumImportantPackets, kUseUnequalProtection, |
123 webrtc::kFecMaskBursty, &fec_packet_list_)); | 122 webrtc::kFecMaskBursty, &fec_packet_list_)); |
124 | 123 |
125 // Expect 1 FEC packet. | 124 // Expect 1 FEC packet. |
126 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 125 EXPECT_EQ(1u, fec_packet_list_.size()); |
127 | 126 |
128 // 1 media packet lost | 127 // 1 media packet lost |
129 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 128 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
130 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 129 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
131 media_loss_mask_[3] = 1; | 130 media_loss_mask_[3] = 1; |
132 NetworkReceivedPackets(); | 131 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
133 | 132 |
134 EXPECT_EQ(0, | 133 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
135 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
136 | 134 |
137 // One packet lost, one FEC packet, expect complete recovery. | 135 // One packet lost, one FEC packet, expect complete recovery. |
138 EXPECT_TRUE(IsRecoveryComplete()); | 136 EXPECT_TRUE(IsRecoveryComplete()); |
139 recovered_packet_list_.clear(); | 137 recovered_packet_list_.clear(); |
140 | 138 |
141 // 2 media packets lost. | 139 // 2 media packets lost. |
142 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 140 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
143 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 141 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
144 media_loss_mask_[1] = 1; | 142 media_loss_mask_[1] = 1; |
145 media_loss_mask_[3] = 1; | 143 media_loss_mask_[3] = 1; |
146 NetworkReceivedPackets(); | 144 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
147 | 145 |
148 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 146 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
149 &recovered_packet_list_)); | |
150 | 147 |
151 // 2 packets lost, one FEC packet, cannot get complete recovery. | 148 // 2 packets lost, one FEC packet, cannot get complete recovery. |
152 EXPECT_FALSE(IsRecoveryComplete()); | 149 EXPECT_FALSE(IsRecoveryComplete()); |
153 } | 150 } |
154 | 151 |
155 // Verify that we don't use an old FEC packet for FEC decoding. | 152 // Verify that we don't use an old FEC packet for FEC decoding. |
156 TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) { | 153 TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapTwoFrames) { |
157 const int kNumImportantPackets = 0; | 154 constexpr int kNumImportantPackets = 0; |
158 const bool kUseUnequalProtection = false; | 155 constexpr bool kUseUnequalProtection = false; |
159 uint8_t kProtectionFactor = 20; | 156 constexpr uint8_t kProtectionFactor = 20; |
160 | 157 |
161 // Two frames: first frame (old) with two media packets and 1 FEC packet. | 158 // Two frames: first frame (old) with two media packets and 1 FEC packet. |
162 // Second frame (new) with 3 media packets, and no FEC packets. | 159 // Second frame (new) with 3 media packets, and no FEC packets. |
163 // ---Frame 1---- ----Frame 2------ | 160 // ---Frame 1---- ----Frame 2------ |
164 // #0(media) #1(media) #2(FEC) #65535(media) #0(media) #1(media). | 161 // #0(media) #1(media) #2(FEC) #65535(media) #0(media) #1(media). |
165 // If we lose either packet 0 or 1 of second frame, FEC decoding should not | 162 // If we lose either packet 0 or 1 of second frame, FEC decoding should not |
166 // try to decode using "old" FEC packet #2. | 163 // try to decode using "old" FEC packet #2. |
167 | 164 |
168 // Construct media packets for first frame, starting at sequence number 0. | 165 // Construct media packets for first frame, starting at sequence number 0. |
169 fec_seq_num_ = ConstructMediaPacketsSeqNum(2, 0); | 166 fec_seq_num_ = ConstructMediaPacketsSeqNum(2, 0); |
170 | 167 |
171 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 168 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
172 kNumImportantPackets, kUseUnequalProtection, | 169 kNumImportantPackets, kUseUnequalProtection, |
173 webrtc::kFecMaskBursty, &fec_packet_list_)); | 170 webrtc::kFecMaskBursty, &fec_packet_list_)); |
174 // Expect 1 FEC packet. | 171 // Expect 1 FEC packet. |
175 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 172 EXPECT_EQ(1u, fec_packet_list_.size()); |
176 // Add FEC packet (seq#2) of this first frame to received list (i.e., assume | 173 // Add FEC packet (seq#2) of this first frame to received list (i.e., assume |
177 // the two media packet were lost). | 174 // the two media packet were lost). |
178 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 175 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
179 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); | 176 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); |
180 | 177 |
181 // Construct media packets for second frame, with sequence number wrap. | 178 // Construct media packets for second frame, with sequence number wrap. |
182 media_packet_list_.clear(); | 179 media_packet_list_.clear(); |
183 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65535); | 180 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65535); |
184 | 181 |
185 // Expect 3 media packets for this frame. | 182 // Expect 3 media packets for this frame. |
186 EXPECT_EQ(3, static_cast<int>(media_packet_list_.size())); | 183 EXPECT_EQ(3u, media_packet_list_.size()); |
187 | 184 |
188 // Second media packet lost (seq#0). | 185 // Second media packet lost (seq#0). |
189 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 186 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
190 media_loss_mask_[1] = 1; | 187 media_loss_mask_[1] = 1; |
191 // Add packets #65535, and #1 to received list. | 188 // Add packets #65535, and #1 to received list. |
192 ReceivedPackets(media_packet_list_, media_loss_mask_, false); | 189 ReceivedPackets(media_packet_list_, media_loss_mask_, false); |
193 | 190 |
194 EXPECT_EQ(0, | 191 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
195 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
196 | 192 |
197 // Expect that no decoding is done to get missing packet (seq#0) of second | 193 // Expect that no decoding is done to get missing packet (seq#0) of second |
198 // frame, using old FEC packet (seq#2) from first (old) frame. So number of | 194 // frame, using old FEC packet (seq#2) from first (old) frame. So number of |
199 // recovered packets is 2, and not equal to number of media packets (=3). | 195 // recovered packets is 2, and not equal to number of media packets (=3). |
200 EXPECT_EQ(2, static_cast<int>(recovered_packet_list_.size())); | 196 EXPECT_EQ(2u, recovered_packet_list_.size()); |
201 EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size()); | 197 EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size()); |
202 } | 198 } |
203 | 199 |
204 // Verify we can still recovery frame if sequence number wrap occurs within | 200 // Verify we can still recover frame if sequence number wrap occurs within |
205 // the frame and FEC packet following wrap is received after media packets. | 201 // the frame and FEC packet following wrap is received after media packets. |
206 TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) { | 202 TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameRecovery) { |
207 const int kNumImportantPackets = 0; | 203 constexpr int kNumImportantPackets = 0; |
208 const bool kUseUnequalProtection = false; | 204 constexpr bool kUseUnequalProtection = false; |
209 uint8_t kProtectionFactor = 20; | 205 constexpr uint8_t kProtectionFactor = 20; |
210 | 206 |
211 // One frame, with sequence number wrap in media packets. | 207 // One frame, with sequence number wrap in media packets. |
212 // -----Frame 1---- | 208 // -----Frame 1---- |
213 // #65534(media) #65535(media) #0(media) #1(FEC). | 209 // #65534(media) #65535(media) #0(media) #1(FEC). |
214 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65534); | 210 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65534); |
215 | 211 |
216 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 212 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
217 kNumImportantPackets, kUseUnequalProtection, | 213 kNumImportantPackets, kUseUnequalProtection, |
218 webrtc::kFecMaskBursty, &fec_packet_list_)); | 214 webrtc::kFecMaskBursty, &fec_packet_list_)); |
219 | 215 |
220 // Expect 1 FEC packet. | 216 // Expect 1 FEC packet. |
221 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 217 EXPECT_EQ(1u, fec_packet_list_.size()); |
222 | 218 |
223 // Lose one media packet (seq# 65535). | 219 // Lose one media packet (seq# 65535). |
224 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 220 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
225 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 221 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
226 media_loss_mask_[1] = 1; | 222 media_loss_mask_[1] = 1; |
227 ReceivedPackets(media_packet_list_, media_loss_mask_, false); | 223 ReceivedPackets(media_packet_list_, media_loss_mask_, false); |
228 // Add FEC packet to received list following the media packets. | 224 // Add FEC packet to received list following the media packets. |
229 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); | 225 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); |
230 | 226 |
231 EXPECT_EQ(0, | 227 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
232 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
233 | 228 |
234 // Expect 3 media packets in recovered list, and complete recovery. | 229 // Expect 3 media packets in recovered list, and complete recovery. |
235 // Wrap-around won't remove FEC packet, as it follows the wrap. | 230 // Wrap-around won't remove FEC packet, as it follows the wrap. |
236 EXPECT_EQ(3, static_cast<int>(recovered_packet_list_.size())); | 231 EXPECT_EQ(3u, recovered_packet_list_.size()); |
237 EXPECT_TRUE(IsRecoveryComplete()); | 232 EXPECT_TRUE(IsRecoveryComplete()); |
238 } | 233 } |
239 | 234 |
240 // Sequence number wrap occurs within the FEC packets for the frame. | 235 // Sequence number wrap occurs within the FEC packets for the frame. |
241 // In this case we will discard FEC packet and full recovery is not expected. | 236 // In this case we will discard FEC packet and full recovery is not expected. |
242 // Same problem will occur if wrap is within media packets but FEC packet is | 237 // Same problem will occur if wrap is within media packets but FEC packet is |
243 // received before the media packets. This may be improved if timing information | 238 // received before the media packets. This may be improved if timing information |
244 // is used to detect old FEC packets. | 239 // is used to detect old FEC packets. |
245 // TODO(marpan): Update test if wrap-around handling changes in FEC decoding. | 240 // TODO(marpan): Update test if wrap-around handling changes in FEC decoding. |
246 TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) { | 241 TEST_F(RtpFecTest, FecRecoveryWithSeqNumGapOneFrameNoRecovery) { |
247 const int kNumImportantPackets = 0; | 242 constexpr int kNumImportantPackets = 0; |
248 const bool kUseUnequalProtection = false; | 243 constexpr bool kUseUnequalProtection = false; |
249 uint8_t kProtectionFactor = 200; | 244 constexpr uint8_t kProtectionFactor = 200; |
250 | 245 |
251 // 1 frame: 3 media packets and 2 FEC packets. | 246 // 1 frame: 3 media packets and 2 FEC packets. |
252 // Sequence number wrap in FEC packets. | 247 // Sequence number wrap in FEC packets. |
253 // -----Frame 1---- | 248 // -----Frame 1---- |
254 // #65532(media) #65533(media) #65534(media) #65535(FEC) #0(FEC). | 249 // #65532(media) #65533(media) #65534(media) #65535(FEC) #0(FEC). |
255 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65532); | 250 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 65532); |
256 | 251 |
257 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 252 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
258 kNumImportantPackets, kUseUnequalProtection, | 253 kNumImportantPackets, kUseUnequalProtection, |
259 webrtc::kFecMaskBursty, &fec_packet_list_)); | 254 webrtc::kFecMaskBursty, &fec_packet_list_)); |
260 | 255 |
261 // Expect 2 FEC packets. | 256 // Expect 2 FEC packets. |
262 EXPECT_EQ(2, static_cast<int>(fec_packet_list_.size())); | 257 EXPECT_EQ(2u, fec_packet_list_.size()); |
263 | 258 |
264 // Lose the last two media packets (seq# 65533, 65534). | 259 // Lose the last two media packets (seq# 65533, 65534). |
265 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 260 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
266 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 261 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
267 media_loss_mask_[1] = 1; | 262 media_loss_mask_[1] = 1; |
268 media_loss_mask_[2] = 1; | 263 media_loss_mask_[2] = 1; |
269 ReceivedPackets(media_packet_list_, media_loss_mask_, false); | 264 ReceivedPackets(media_packet_list_, media_loss_mask_, false); |
270 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); | 265 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); |
271 | 266 |
272 EXPECT_EQ(0, | 267 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
273 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
274 | 268 |
275 // The two FEC packets are received and should allow for complete recovery, | 269 // The two FEC packets are received and should allow for complete recovery, |
276 // but because of the wrap the second FEC packet will be discarded, and only | 270 // but because of the wrap the second FEC packet will be discarded, and only |
277 // one media packet is recoverable. So exepct 2 media packets on recovered | 271 // one media packet is recoverable. So exepct 2 media packets on recovered |
278 // list and no complete recovery. | 272 // list and no complete recovery. |
279 EXPECT_EQ(2, static_cast<int>(recovered_packet_list_.size())); | 273 EXPECT_EQ(2u, recovered_packet_list_.size()); |
280 EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size()); | 274 EXPECT_TRUE(recovered_packet_list_.size() != media_packet_list_.size()); |
281 EXPECT_FALSE(IsRecoveryComplete()); | 275 EXPECT_FALSE(IsRecoveryComplete()); |
282 } | 276 } |
283 | 277 |
284 // Verify we can still recovery frame if FEC is received before media packets. | 278 // Verify we can still recover frame if media packets are reordered. |
285 TEST_F(RtpFecTest, FecRecoveryWithFecOutOfOrder) { | 279 TEST_F(RtpFecTest, FecRecoveryWithMediaOutOfOrder) { |
286 const int kNumImportantPackets = 0; | 280 constexpr int kNumImportantPackets = 0; |
287 const bool kUseUnequalProtection = false; | 281 constexpr bool kUseUnequalProtection = false; |
288 uint8_t kProtectionFactor = 20; | 282 constexpr uint8_t kProtectionFactor = 20; |
289 | 283 |
290 // One frame: 3 media packets, 1 FEC packet. | 284 // One frame: 3 media packets, 1 FEC packet. |
291 // -----Frame 1---- | 285 // -----Frame 1---- |
292 // #0(media) #1(media) #2(media) #3(FEC). | 286 // #0(media) #1(media) #2(media) #3(FEC). |
293 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0); | 287 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0); |
294 | 288 |
295 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 289 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
296 kNumImportantPackets, kUseUnequalProtection, | 290 kNumImportantPackets, kUseUnequalProtection, |
297 webrtc::kFecMaskBursty, &fec_packet_list_)); | 291 webrtc::kFecMaskBursty, &fec_packet_list_)); |
298 | 292 |
299 // Expect 1 FEC packet. | 293 // Expect 1 FEC packet. |
300 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 294 EXPECT_EQ(1u, fec_packet_list_.size()); |
301 | 295 |
302 // Lose one media packet (seq# 1). | 296 // Lose one media packet (seq# 1). |
303 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 297 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
| 298 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
| 299 media_loss_mask_[1] = 1; |
| 300 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
| 301 |
| 302 // Reorder received media packets. |
| 303 auto it0 = received_packet_list_.begin(); |
| 304 auto it2 = received_packet_list_.begin(); |
| 305 it2++; |
| 306 std::swap(*it0, *it2); |
| 307 |
| 308 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
| 309 |
| 310 // Expect 3 media packets in recovered list, and complete recovery. |
| 311 EXPECT_EQ(3u, recovered_packet_list_.size()); |
| 312 EXPECT_TRUE(IsRecoveryComplete()); |
| 313 } |
| 314 |
| 315 // Verify we can still recover frame if FEC is received before media packets. |
| 316 TEST_F(RtpFecTest, FecRecoveryWithFecOutOfOrder) { |
| 317 constexpr int kNumImportantPackets = 0; |
| 318 constexpr bool kUseUnequalProtection = false; |
| 319 constexpr uint8_t kProtectionFactor = 20; |
| 320 |
| 321 // One frame: 3 media packets, 1 FEC packet. |
| 322 // -----Frame 1---- |
| 323 // #0(media) #1(media) #2(media) #3(FEC). |
| 324 fec_seq_num_ = ConstructMediaPacketsSeqNum(3, 0); |
| 325 |
| 326 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
| 327 kNumImportantPackets, kUseUnequalProtection, |
| 328 webrtc::kFecMaskBursty, &fec_packet_list_)); |
| 329 |
| 330 // Expect 1 FEC packet. |
| 331 EXPECT_EQ(1u, fec_packet_list_.size()); |
| 332 |
| 333 // Lose one media packet (seq# 1). |
| 334 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
304 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 335 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
305 media_loss_mask_[1] = 1; | 336 media_loss_mask_[1] = 1; |
306 // Add FEC packet to received list before the media packets. | 337 // Add FEC packet to received list before the media packets. |
307 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); | 338 ReceivedPackets(fec_packet_list_, fec_loss_mask_, true); |
308 // Add media packets to received list. | 339 // Add media packets to received list. |
309 ReceivedPackets(media_packet_list_, media_loss_mask_, false); | 340 ReceivedPackets(media_packet_list_, media_loss_mask_, false); |
310 | 341 |
311 EXPECT_EQ(0, | 342 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
312 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
313 | 343 |
314 // Expect 3 media packets in recovered list, and complete recovery. | 344 // Expect 3 media packets in recovered list, and complete recovery. |
315 EXPECT_EQ(3, static_cast<int>(recovered_packet_list_.size())); | 345 EXPECT_EQ(3u, recovered_packet_list_.size()); |
316 EXPECT_TRUE(IsRecoveryComplete()); | 346 EXPECT_TRUE(IsRecoveryComplete()); |
317 } | 347 } |
318 | 348 |
319 // Test 50% protection with random mask type: Two cases are considered: | 349 // Test 50% protection with random mask type: Two cases are considered: |
320 // a 50% non-consecutive loss which can be fully recovered, and a 50% | 350 // a 50% non-consecutive loss which can be fully recovered, and a 50% |
321 // consecutive loss which cannot be fully recovered. | 351 // consecutive loss which cannot be fully recovered. |
322 TEST_F(RtpFecTest, FecRecoveryWithLoss50percRandomMask) { | 352 TEST_F(RtpFecTest, FecRecoveryWithLoss50percRandomMask) { |
323 const int kNumImportantPackets = 0; | 353 constexpr int kNumImportantPackets = 0; |
324 const bool kUseUnequalProtection = false; | 354 constexpr bool kUseUnequalProtection = false; |
325 const int kNumMediaPackets = 4; | 355 constexpr int kNumMediaPackets = 4; |
326 const uint8_t kProtectionFactor = 255; | 356 constexpr uint8_t kProtectionFactor = 255; |
327 | 357 |
328 // Packet Mask for (4,4,0) code, from random mask table. | 358 // Packet Mask for (4,4,0) code, from random mask table. |
329 // (kNumMediaPackets = 4; num_fec_packets = 4, kNumImportantPackets = 0) | 359 // (kNumMediaPackets = 4; num_fec_packets = 4, kNumImportantPackets = 0) |
330 | 360 |
331 // media#0 media#1 media#2 media#3 | 361 // media#0 media#1 media#2 media#3 |
332 // fec#0: 1 1 0 0 | 362 // fec#0: 1 1 0 0 |
333 // fec#1: 1 0 1 0 | 363 // fec#1: 1 0 1 0 |
334 // fec#2: 0 0 1 1 | 364 // fec#2: 0 0 1 1 |
335 // fec#3: 0 1 0 1 | 365 // fec#3: 0 1 0 1 |
336 // | 366 // |
337 | 367 |
338 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 368 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
339 | 369 |
340 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 370 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
341 kNumImportantPackets, kUseUnequalProtection, | 371 kNumImportantPackets, kUseUnequalProtection, |
342 webrtc::kFecMaskRandom, &fec_packet_list_)); | 372 webrtc::kFecMaskRandom, &fec_packet_list_)); |
343 | 373 |
344 // Expect 4 FEC packets. | 374 // Expect 4 FEC packets. |
345 EXPECT_EQ(4, static_cast<int>(fec_packet_list_.size())); | 375 EXPECT_EQ(4u, fec_packet_list_.size()); |
346 | 376 |
347 // 4 packets lost: 3 media packets (0, 2, 3), and one FEC packet (0) lost. | 377 // 4 packets lost: 3 media packets (0, 2, 3), and one FEC packet (0) lost. |
348 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 378 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
349 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 379 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
350 fec_loss_mask_[0] = 1; | 380 fec_loss_mask_[0] = 1; |
351 media_loss_mask_[0] = 1; | 381 media_loss_mask_[0] = 1; |
352 media_loss_mask_[2] = 1; | 382 media_loss_mask_[2] = 1; |
353 media_loss_mask_[3] = 1; | 383 media_loss_mask_[3] = 1; |
354 NetworkReceivedPackets(); | 384 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
355 | 385 |
356 EXPECT_EQ(0, | 386 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
357 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
358 | 387 |
359 // With media packet#1 and FEC packets #1, #2, #3, expect complete recovery. | 388 // With media packet#1 and FEC packets #1, #2, #3, expect complete recovery. |
360 EXPECT_TRUE(IsRecoveryComplete()); | 389 EXPECT_TRUE(IsRecoveryComplete()); |
361 recovered_packet_list_.clear(); | 390 recovered_packet_list_.clear(); |
362 | 391 |
363 // 4 consecutive packets lost: media packets 0, 1, 2, 3. | 392 // 4 consecutive packets lost: media packets 0, 1, 2, 3. |
364 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 393 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
365 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 394 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
366 media_loss_mask_[0] = 1; | 395 media_loss_mask_[0] = 1; |
367 media_loss_mask_[1] = 1; | 396 media_loss_mask_[1] = 1; |
368 media_loss_mask_[2] = 1; | 397 media_loss_mask_[2] = 1; |
369 media_loss_mask_[3] = 1; | 398 media_loss_mask_[3] = 1; |
370 NetworkReceivedPackets(); | 399 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
371 | 400 |
372 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 401 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
373 &recovered_packet_list_)); | |
374 | 402 |
375 // Cannot get complete recovery for this loss configuration with random mask. | 403 // Cannot get complete recovery for this loss configuration with random mask. |
376 EXPECT_FALSE(IsRecoveryComplete()); | 404 EXPECT_FALSE(IsRecoveryComplete()); |
377 } | 405 } |
378 | 406 |
379 // Test 50% protection with bursty type: Three cases are considered: | 407 // Test 50% protection with bursty type: Three cases are considered: |
380 // two 50% consecutive losses which can be fully recovered, and one | 408 // two 50% consecutive losses which can be fully recovered, and one |
381 // non-consecutive which cannot be fully recovered. | 409 // non-consecutive which cannot be fully recovered. |
382 TEST_F(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) { | 410 TEST_F(RtpFecTest, FecRecoveryWithLoss50percBurstyMask) { |
383 const int kNumImportantPackets = 0; | 411 constexpr int kNumImportantPackets = 0; |
384 const bool kUseUnequalProtection = false; | 412 constexpr bool kUseUnequalProtection = false; |
385 const int kNumMediaPackets = 4; | 413 constexpr int kNumMediaPackets = 4; |
386 const uint8_t kProtectionFactor = 255; | 414 constexpr uint8_t kProtectionFactor = 255; |
387 | 415 |
388 // Packet Mask for (4,4,0) code, from bursty mask table. | 416 // Packet Mask for (4,4,0) code, from bursty mask table. |
389 // (kNumMediaPackets = 4; num_fec_packets = 4, kNumImportantPackets = 0) | 417 // (kNumMediaPackets = 4; num_fec_packets = 4, kNumImportantPackets = 0) |
390 | 418 |
391 // media#0 media#1 media#2 media#3 | 419 // media#0 media#1 media#2 media#3 |
392 // fec#0: 1 0 0 0 | 420 // fec#0: 1 0 0 0 |
393 // fec#1: 1 1 0 0 | 421 // fec#1: 1 1 0 0 |
394 // fec#2: 0 1 1 0 | 422 // fec#2: 0 1 1 0 |
395 // fec#3: 0 0 1 1 | 423 // fec#3: 0 0 1 1 |
396 // | 424 // |
397 | 425 |
398 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 426 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
399 | 427 |
400 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 428 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
401 kNumImportantPackets, kUseUnequalProtection, | 429 kNumImportantPackets, kUseUnequalProtection, |
402 webrtc::kFecMaskBursty, &fec_packet_list_)); | 430 webrtc::kFecMaskBursty, &fec_packet_list_)); |
403 | 431 |
404 // Expect 4 FEC packets. | 432 // Expect 4 FEC packets. |
405 EXPECT_EQ(4, static_cast<int>(fec_packet_list_.size())); | 433 EXPECT_EQ(4u, fec_packet_list_.size()); |
406 | 434 |
407 // 4 consecutive packets lost: media packets 0,1,2,3. | 435 // 4 consecutive packets lost: media packets 0,1,2,3. |
408 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 436 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
409 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 437 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
410 media_loss_mask_[0] = 1; | 438 media_loss_mask_[0] = 1; |
411 media_loss_mask_[1] = 1; | 439 media_loss_mask_[1] = 1; |
412 media_loss_mask_[2] = 1; | 440 media_loss_mask_[2] = 1; |
413 media_loss_mask_[3] = 1; | 441 media_loss_mask_[3] = 1; |
414 NetworkReceivedPackets(); | 442 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
415 | 443 |
416 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 444 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
417 &recovered_packet_list_)); | |
418 | 445 |
419 // Expect complete recovery for consecutive packet loss <= 50%. | 446 // Expect complete recovery for consecutive packet loss <= 50%. |
420 EXPECT_TRUE(IsRecoveryComplete()); | 447 EXPECT_TRUE(IsRecoveryComplete()); |
421 recovered_packet_list_.clear(); | 448 recovered_packet_list_.clear(); |
422 | 449 |
423 // 4 consecutive packets lost: media packets 1,2, 3, and FEC packet 0. | 450 // 4 consecutive packets lost: media packets 1,2, 3, and FEC packet 0. |
424 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 451 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
425 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 452 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
426 fec_loss_mask_[0] = 1; | 453 fec_loss_mask_[0] = 1; |
427 media_loss_mask_[1] = 1; | 454 media_loss_mask_[1] = 1; |
428 media_loss_mask_[2] = 1; | 455 media_loss_mask_[2] = 1; |
429 media_loss_mask_[3] = 1; | 456 media_loss_mask_[3] = 1; |
430 NetworkReceivedPackets(); | 457 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
431 | 458 |
432 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 459 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
433 &recovered_packet_list_)); | |
434 | 460 |
435 // Expect complete recovery for consecutive packet loss <= 50%. | 461 // Expect complete recovery for consecutive packet loss <= 50%. |
436 EXPECT_TRUE(IsRecoveryComplete()); | 462 EXPECT_TRUE(IsRecoveryComplete()); |
437 recovered_packet_list_.clear(); | 463 recovered_packet_list_.clear(); |
438 | 464 |
439 // 4 packets lost (non-consecutive loss): media packets 0, 3, and FEC# 0, 3. | 465 // 4 packets lost (non-consecutive loss): media packets 0, 3, and FEC# 0, 3. |
440 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 466 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
441 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 467 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
442 fec_loss_mask_[0] = 1; | 468 fec_loss_mask_[0] = 1; |
443 fec_loss_mask_[3] = 1; | 469 fec_loss_mask_[3] = 1; |
444 media_loss_mask_[0] = 1; | 470 media_loss_mask_[0] = 1; |
445 media_loss_mask_[3] = 1; | 471 media_loss_mask_[3] = 1; |
446 NetworkReceivedPackets(); | 472 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
447 | 473 |
448 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 474 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
449 &recovered_packet_list_)); | |
450 | 475 |
451 // Cannot get complete recovery for this loss configuration. | 476 // Cannot get complete recovery for this loss configuration. |
452 EXPECT_FALSE(IsRecoveryComplete()); | 477 EXPECT_FALSE(IsRecoveryComplete()); |
453 } | 478 } |
454 | 479 |
455 TEST_F(RtpFecTest, FecRecoveryNoLossUep) { | 480 TEST_F(RtpFecTest, FecRecoveryNoLossUep) { |
456 const int kNumImportantPackets = 2; | 481 constexpr int kNumImportantPackets = 2; |
457 const bool kUseUnequalProtection = true; | 482 constexpr bool kUseUnequalProtection = true; |
458 const int kNumMediaPackets = 4; | 483 constexpr int kNumMediaPackets = 4; |
459 const uint8_t kProtectionFactor = 60; | 484 constexpr uint8_t kProtectionFactor = 60; |
460 | 485 |
461 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 486 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
462 | 487 |
463 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 488 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
464 kNumImportantPackets, kUseUnequalProtection, | 489 kNumImportantPackets, kUseUnequalProtection, |
465 webrtc::kFecMaskBursty, &fec_packet_list_)); | 490 webrtc::kFecMaskBursty, &fec_packet_list_)); |
466 | 491 |
467 // Expect 1 FEC packet. | 492 // Expect 1 FEC packet. |
468 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 493 EXPECT_EQ(1u, fec_packet_list_.size()); |
469 | 494 |
470 // No packets lost. | 495 // No packets lost. |
471 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 496 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
472 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 497 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
473 NetworkReceivedPackets(); | 498 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
474 | 499 |
475 EXPECT_EQ(0, | 500 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
476 fec_->DecodeFec(&received_packet_list_, &recovered_packet_list_)); | |
477 | 501 |
478 // No packets lost, expect complete recovery. | 502 // No packets lost, expect complete recovery. |
479 EXPECT_TRUE(IsRecoveryComplete()); | 503 EXPECT_TRUE(IsRecoveryComplete()); |
480 } | 504 } |
481 | 505 |
482 TEST_F(RtpFecTest, FecRecoveryWithLossUep) { | 506 TEST_F(RtpFecTest, FecRecoveryWithLossUep) { |
483 const int kNumImportantPackets = 2; | 507 constexpr int kNumImportantPackets = 2; |
484 const bool kUseUnequalProtection = true; | 508 constexpr bool kUseUnequalProtection = true; |
485 const int kNumMediaPackets = 4; | 509 constexpr int kNumMediaPackets = 4; |
486 const uint8_t kProtectionFactor = 60; | 510 constexpr uint8_t kProtectionFactor = 60; |
487 | 511 |
488 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 512 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
489 | 513 |
490 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 514 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
491 kNumImportantPackets, kUseUnequalProtection, | 515 kNumImportantPackets, kUseUnequalProtection, |
492 webrtc::kFecMaskBursty, &fec_packet_list_)); | 516 webrtc::kFecMaskBursty, &fec_packet_list_)); |
493 | 517 |
494 // Expect 1 FEC packet. | 518 // Expect 1 FEC packet. |
495 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 519 EXPECT_EQ(1u, fec_packet_list_.size()); |
496 | 520 |
497 // 1 media packet lost. | 521 // 1 media packet lost. |
498 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 522 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
499 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 523 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
500 media_loss_mask_[3] = 1; | 524 media_loss_mask_[3] = 1; |
501 NetworkReceivedPackets(); | 525 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
502 | 526 |
503 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 527 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
504 &recovered_packet_list_)); | |
505 | 528 |
506 // One packet lost, one FEC packet, expect complete recovery. | 529 // One packet lost, one FEC packet, expect complete recovery. |
507 EXPECT_TRUE(IsRecoveryComplete()); | 530 EXPECT_TRUE(IsRecoveryComplete()); |
508 recovered_packet_list_.clear(); | 531 recovered_packet_list_.clear(); |
509 | 532 |
510 // 2 media packets lost. | 533 // 2 media packets lost. |
511 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 534 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
512 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 535 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
513 media_loss_mask_[1] = 1; | 536 media_loss_mask_[1] = 1; |
514 media_loss_mask_[3] = 1; | 537 media_loss_mask_[3] = 1; |
515 NetworkReceivedPackets(); | 538 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
516 | 539 |
517 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 540 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
518 &recovered_packet_list_)); | |
519 | 541 |
520 // 2 packets lost, one FEC packet, cannot get complete recovery. | 542 // 2 packets lost, one FEC packet, cannot get complete recovery. |
521 EXPECT_FALSE(IsRecoveryComplete()); | 543 EXPECT_FALSE(IsRecoveryComplete()); |
522 } | 544 } |
523 | 545 |
524 // Test 50% protection with random mask type for UEP on. | 546 // Test 50% protection with random mask type for UEP on. |
525 TEST_F(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) { | 547 TEST_F(RtpFecTest, FecRecoveryWithLoss50percUepRandomMask) { |
526 const int kNumImportantPackets = 1; | 548 constexpr int kNumImportantPackets = 1; |
527 const bool kUseUnequalProtection = true; | 549 constexpr bool kUseUnequalProtection = true; |
528 const int kNumMediaPackets = 4; | 550 constexpr int kNumMediaPackets = 4; |
529 const uint8_t kProtectionFactor = 255; | 551 constexpr uint8_t kProtectionFactor = 255; |
530 | 552 |
531 // Packet Mask for (4,4,1) code, from random mask table. | 553 // Packet Mask for (4,4,1) code, from random mask table. |
532 // (kNumMediaPackets = 4; num_fec_packets = 4, kNumImportantPackets = 1) | 554 // (kNumMediaPackets = 4; num_fec_packets = 4, kNumImportantPackets = 1) |
533 | 555 |
534 // media#0 media#1 media#2 media#3 | 556 // media#0 media#1 media#2 media#3 |
535 // fec#0: 1 0 0 0 | 557 // fec#0: 1 0 0 0 |
536 // fec#1: 1 1 0 0 | 558 // fec#1: 1 1 0 0 |
537 // fec#2: 1 0 1 1 | 559 // fec#2: 1 0 1 1 |
538 // fec#3: 0 1 1 0 | 560 // fec#3: 0 1 1 0 |
539 // | 561 // |
540 | 562 |
541 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 563 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
542 | 564 |
543 EXPECT_EQ(0, fec_->GenerateFec(media_packet_list_, kProtectionFactor, | 565 EXPECT_EQ(0, fec_.GenerateFec(media_packet_list_, kProtectionFactor, |
544 kNumImportantPackets, kUseUnequalProtection, | 566 kNumImportantPackets, kUseUnequalProtection, |
545 webrtc::kFecMaskRandom, &fec_packet_list_)); | 567 webrtc::kFecMaskRandom, &fec_packet_list_)); |
546 | 568 |
547 // Expect 4 FEC packets. | 569 // Expect 4 FEC packets. |
548 EXPECT_EQ(4, static_cast<int>(fec_packet_list_.size())); | 570 EXPECT_EQ(4u, fec_packet_list_.size()); |
549 | 571 |
550 // 4 packets lost: 3 media packets and FEC packet#1 lost. | 572 // 4 packets lost: 3 media packets and FEC packet#1 lost. |
551 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 573 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
552 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 574 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
553 fec_loss_mask_[1] = 1; | 575 fec_loss_mask_[1] = 1; |
554 media_loss_mask_[0] = 1; | 576 media_loss_mask_[0] = 1; |
555 media_loss_mask_[2] = 1; | 577 media_loss_mask_[2] = 1; |
556 media_loss_mask_[3] = 1; | 578 media_loss_mask_[3] = 1; |
557 NetworkReceivedPackets(); | 579 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
558 | 580 |
559 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 581 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
560 &recovered_packet_list_)); | |
561 | 582 |
562 // With media packet#3 and FEC packets #0, #1, #3, expect complete recovery. | 583 // With media packet#3 and FEC packets #0, #1, #3, expect complete recovery. |
563 EXPECT_TRUE(IsRecoveryComplete()); | 584 EXPECT_TRUE(IsRecoveryComplete()); |
564 recovered_packet_list_.clear(); | 585 recovered_packet_list_.clear(); |
565 | 586 |
566 // 5 packets lost: 4 media packets and one FEC packet#2 lost. | 587 // 5 packets lost: 4 media packets and one FEC packet#2 lost. |
567 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 588 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
568 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 589 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
569 fec_loss_mask_[2] = 1; | 590 fec_loss_mask_[2] = 1; |
570 media_loss_mask_[0] = 1; | 591 media_loss_mask_[0] = 1; |
571 media_loss_mask_[1] = 1; | 592 media_loss_mask_[1] = 1; |
572 media_loss_mask_[2] = 1; | 593 media_loss_mask_[2] = 1; |
573 media_loss_mask_[3] = 1; | 594 media_loss_mask_[3] = 1; |
574 NetworkReceivedPackets(); | 595 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
575 | 596 |
576 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 597 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
577 &recovered_packet_list_)); | |
578 | 598 |
579 // Cannot get complete recovery for this loss configuration. | 599 // Cannot get complete recovery for this loss configuration. |
580 EXPECT_FALSE(IsRecoveryComplete()); | 600 EXPECT_FALSE(IsRecoveryComplete()); |
581 } | 601 } |
582 | 602 |
583 TEST_F(RtpFecTest, FecRecoveryNonConsecutivePackets) { | 603 TEST_F(RtpFecTest, FecRecoveryNonConsecutivePackets) { |
584 const int kNumImportantPackets = 0; | 604 constexpr int kNumImportantPackets = 0; |
585 const bool kUseUnequalProtection = false; | 605 constexpr bool kUseUnequalProtection = false; |
586 const int kNumMediaPackets = 5; | 606 constexpr int kNumMediaPackets = 5; |
587 uint8_t kProtectionFactor = 60; | 607 constexpr uint8_t kProtectionFactor = 60; |
588 | 608 |
589 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 609 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
590 | 610 |
591 // Create a new temporary packet list for generating FEC packets. | 611 // Create a new temporary packet list for generating FEC packets. |
592 // This list should have every other packet removed. | 612 // This list should have every other packet removed. |
593 PacketList protected_media_packets; | 613 PacketList protected_media_packets; |
594 DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); | 614 DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); |
595 | 615 |
596 EXPECT_EQ(0, fec_->GenerateFec(protected_media_packets, kProtectionFactor, | 616 EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor, |
597 kNumImportantPackets, kUseUnequalProtection, | 617 kNumImportantPackets, kUseUnequalProtection, |
598 webrtc::kFecMaskBursty, &fec_packet_list_)); | 618 webrtc::kFecMaskBursty, &fec_packet_list_)); |
599 | 619 |
600 // Expect 1 FEC packet. | 620 // Expect 1 FEC packet. |
601 EXPECT_EQ(1, static_cast<int>(fec_packet_list_.size())); | 621 EXPECT_EQ(1u, fec_packet_list_.size()); |
602 | 622 |
603 // 1 protected media packet lost | 623 // 1 protected media packet lost |
604 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 624 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
605 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 625 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
606 media_loss_mask_[2] = 1; | 626 media_loss_mask_[2] = 1; |
607 NetworkReceivedPackets(); | 627 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
608 | 628 |
609 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 629 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
610 &recovered_packet_list_)); | |
611 | 630 |
612 // One packet lost, one FEC packet, expect complete recovery. | 631 // One packet lost, one FEC packet, expect complete recovery. |
613 EXPECT_TRUE(IsRecoveryComplete()); | 632 EXPECT_TRUE(IsRecoveryComplete()); |
614 recovered_packet_list_.clear(); | 633 recovered_packet_list_.clear(); |
615 | 634 |
616 // Unprotected packet lost. | 635 // Unprotected packet lost. |
617 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 636 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
618 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 637 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
619 media_loss_mask_[1] = 1; | 638 media_loss_mask_[1] = 1; |
620 NetworkReceivedPackets(); | 639 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
621 | 640 |
622 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 641 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
623 &recovered_packet_list_)); | |
624 | 642 |
625 // Unprotected packet lost. Recovery not possible. | 643 // Unprotected packet lost. Recovery not possible. |
626 EXPECT_FALSE(IsRecoveryComplete()); | 644 EXPECT_FALSE(IsRecoveryComplete()); |
627 recovered_packet_list_.clear(); | 645 recovered_packet_list_.clear(); |
628 | 646 |
629 // 2 media packets lost. | 647 // 2 media packets lost. |
630 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 648 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
631 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 649 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
632 media_loss_mask_[0] = 1; | 650 media_loss_mask_[0] = 1; |
633 media_loss_mask_[2] = 1; | 651 media_loss_mask_[2] = 1; |
634 NetworkReceivedPackets(); | 652 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
635 | 653 |
636 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 654 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
637 &recovered_packet_list_)); | |
638 | 655 |
639 // 2 protected packets lost, one FEC packet, cannot get complete recovery. | 656 // 2 protected packets lost, one FEC packet, cannot get complete recovery. |
640 EXPECT_FALSE(IsRecoveryComplete()); | 657 EXPECT_FALSE(IsRecoveryComplete()); |
641 } | 658 } |
642 | 659 |
643 TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) { | 660 TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsExtension) { |
644 const int kNumImportantPackets = 0; | 661 constexpr int kNumImportantPackets = 0; |
645 const bool kUseUnequalProtection = false; | 662 constexpr bool kUseUnequalProtection = false; |
646 const int kNumMediaPackets = 21; | 663 constexpr int kNumMediaPackets = 21; |
647 uint8_t kProtectionFactor = 127; | 664 uint8_t kProtectionFactor = 127; |
648 | 665 |
649 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); | 666 fec_seq_num_ = ConstructMediaPackets(kNumMediaPackets); |
650 | 667 |
651 // Create a new temporary packet list for generating FEC packets. | 668 // Create a new temporary packet list for generating FEC packets. |
652 // This list should have every other packet removed. | 669 // This list should have every other packet removed. |
653 PacketList protected_media_packets; | 670 PacketList protected_media_packets; |
654 DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); | 671 DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); |
655 | 672 |
656 // Zero column insertion will have to extend the size of the packet | 673 // Zero column insertion will have to extend the size of the packet |
657 // mask since the number of actual packets are 21, while the number | 674 // mask since the number of actual packets are 21, while the number |
658 // of protected packets are 11. | 675 // of protected packets are 11. |
659 EXPECT_EQ(0, fec_->GenerateFec(protected_media_packets, kProtectionFactor, | 676 EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor, |
660 kNumImportantPackets, kUseUnequalProtection, | 677 kNumImportantPackets, kUseUnequalProtection, |
661 webrtc::kFecMaskBursty, &fec_packet_list_)); | 678 webrtc::kFecMaskBursty, &fec_packet_list_)); |
662 | 679 |
663 // Expect 5 FEC packet. | 680 // Expect 5 FEC packet. |
664 EXPECT_EQ(5, static_cast<int>(fec_packet_list_.size())); | 681 EXPECT_EQ(5u, fec_packet_list_.size()); |
665 | 682 |
666 // Last protected media packet lost | 683 // Last protected media packet lost |
667 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 684 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
668 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 685 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
669 media_loss_mask_[kNumMediaPackets - 1] = 1; | 686 media_loss_mask_[kNumMediaPackets - 1] = 1; |
670 NetworkReceivedPackets(); | 687 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
671 | 688 |
672 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 689 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
673 &recovered_packet_list_)); | |
674 | 690 |
675 // One packet lost, one FEC packet, expect complete recovery. | 691 // One packet lost, one FEC packet, expect complete recovery. |
676 EXPECT_TRUE(IsRecoveryComplete()); | 692 EXPECT_TRUE(IsRecoveryComplete()); |
677 recovered_packet_list_.clear(); | 693 recovered_packet_list_.clear(); |
678 | 694 |
679 // Last unprotected packet lost. | 695 // Last unprotected packet lost. |
680 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 696 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
681 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 697 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
682 media_loss_mask_[kNumMediaPackets - 2] = 1; | 698 media_loss_mask_[kNumMediaPackets - 2] = 1; |
683 NetworkReceivedPackets(); | 699 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
684 | 700 |
685 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 701 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
686 &recovered_packet_list_)); | |
687 | 702 |
688 // Unprotected packet lost. Recovery not possible. | 703 // Unprotected packet lost. Recovery not possible. |
689 EXPECT_FALSE(IsRecoveryComplete()); | 704 EXPECT_FALSE(IsRecoveryComplete()); |
690 recovered_packet_list_.clear(); | 705 recovered_packet_list_.clear(); |
691 | 706 |
692 // 6 media packets lost. | 707 // 6 media packets lost. |
693 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 708 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
694 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 709 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
695 media_loss_mask_[kNumMediaPackets - 11] = 1; | 710 media_loss_mask_[kNumMediaPackets - 11] = 1; |
696 media_loss_mask_[kNumMediaPackets - 9] = 1; | 711 media_loss_mask_[kNumMediaPackets - 9] = 1; |
697 media_loss_mask_[kNumMediaPackets - 7] = 1; | 712 media_loss_mask_[kNumMediaPackets - 7] = 1; |
698 media_loss_mask_[kNumMediaPackets - 5] = 1; | 713 media_loss_mask_[kNumMediaPackets - 5] = 1; |
699 media_loss_mask_[kNumMediaPackets - 3] = 1; | 714 media_loss_mask_[kNumMediaPackets - 3] = 1; |
700 media_loss_mask_[kNumMediaPackets - 1] = 1; | 715 media_loss_mask_[kNumMediaPackets - 1] = 1; |
701 NetworkReceivedPackets(); | 716 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
702 | 717 |
703 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 718 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
704 &recovered_packet_list_)); | |
705 | 719 |
706 // 5 protected packets lost, one FEC packet, cannot get complete recovery. | 720 // 5 protected packets lost, one FEC packet, cannot get complete recovery. |
707 EXPECT_FALSE(IsRecoveryComplete()); | 721 EXPECT_FALSE(IsRecoveryComplete()); |
708 } | 722 } |
709 | 723 |
710 TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) { | 724 TEST_F(RtpFecTest, FecRecoveryNonConsecutivePacketsWrap) { |
711 const int kNumImportantPackets = 0; | 725 constexpr int kNumImportantPackets = 0; |
712 const bool kUseUnequalProtection = false; | 726 constexpr bool kUseUnequalProtection = false; |
713 const int kNumMediaPackets = 21; | 727 constexpr int kNumMediaPackets = 21; |
714 uint8_t kProtectionFactor = 127; | 728 uint8_t kProtectionFactor = 127; |
715 | 729 |
716 fec_seq_num_ = ConstructMediaPacketsSeqNum(kNumMediaPackets, 0xFFFF - 5); | 730 fec_seq_num_ = ConstructMediaPacketsSeqNum(kNumMediaPackets, 0xFFFF - 5); |
717 | 731 |
718 // Create a new temporary packet list for generating FEC packets. | 732 // Create a new temporary packet list for generating FEC packets. |
719 // This list should have every other packet removed. | 733 // This list should have every other packet removed. |
720 PacketList protected_media_packets; | 734 PacketList protected_media_packets; |
721 DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); | 735 DeepCopyEveryNthPacket(media_packet_list_, 2, &protected_media_packets); |
722 | 736 |
723 // Zero column insertion will have to extend the size of the packet | 737 // Zero column insertion will have to extend the size of the packet |
724 // mask since the number of actual packets are 21, while the number | 738 // mask since the number of actual packets are 21, while the number |
725 // of protected packets are 11. | 739 // of protected packets are 11. |
726 EXPECT_EQ(0, fec_->GenerateFec(protected_media_packets, kProtectionFactor, | 740 EXPECT_EQ(0, fec_.GenerateFec(protected_media_packets, kProtectionFactor, |
727 kNumImportantPackets, kUseUnequalProtection, | 741 kNumImportantPackets, kUseUnequalProtection, |
728 webrtc::kFecMaskBursty, &fec_packet_list_)); | 742 webrtc::kFecMaskBursty, &fec_packet_list_)); |
729 | 743 |
730 // Expect 5 FEC packet. | 744 // Expect 5 FEC packet. |
731 EXPECT_EQ(5, static_cast<int>(fec_packet_list_.size())); | 745 EXPECT_EQ(5u, fec_packet_list_.size()); |
732 | 746 |
733 // Last protected media packet lost | 747 // Last protected media packet lost |
734 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 748 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
735 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 749 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
736 media_loss_mask_[kNumMediaPackets - 1] = 1; | 750 media_loss_mask_[kNumMediaPackets - 1] = 1; |
737 NetworkReceivedPackets(); | 751 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
738 | 752 |
739 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 753 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
740 &recovered_packet_list_)); | |
741 | 754 |
742 // One packet lost, one FEC packet, expect complete recovery. | 755 // One packet lost, one FEC packet, expect complete recovery. |
743 EXPECT_TRUE(IsRecoveryComplete()); | 756 EXPECT_TRUE(IsRecoveryComplete()); |
744 recovered_packet_list_.clear(); | 757 recovered_packet_list_.clear(); |
745 | 758 |
746 // Last unprotected packet lost. | 759 // Last unprotected packet lost. |
747 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 760 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
748 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 761 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
749 media_loss_mask_[kNumMediaPackets - 2] = 1; | 762 media_loss_mask_[kNumMediaPackets - 2] = 1; |
750 NetworkReceivedPackets(); | 763 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
751 | 764 |
752 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 765 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
753 &recovered_packet_list_)); | |
754 | 766 |
755 // Unprotected packet lost. Recovery not possible. | 767 // Unprotected packet lost. Recovery not possible. |
756 EXPECT_FALSE(IsRecoveryComplete()); | 768 EXPECT_FALSE(IsRecoveryComplete()); |
757 recovered_packet_list_.clear(); | 769 recovered_packet_list_.clear(); |
758 | 770 |
759 // 6 media packets lost. | 771 // 6 media packets lost. |
760 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); | 772 memset(media_loss_mask_, 0, sizeof(media_loss_mask_)); |
761 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); | 773 memset(fec_loss_mask_, 0, sizeof(fec_loss_mask_)); |
762 media_loss_mask_[kNumMediaPackets - 11] = 1; | 774 media_loss_mask_[kNumMediaPackets - 11] = 1; |
763 media_loss_mask_[kNumMediaPackets - 9] = 1; | 775 media_loss_mask_[kNumMediaPackets - 9] = 1; |
764 media_loss_mask_[kNumMediaPackets - 7] = 1; | 776 media_loss_mask_[kNumMediaPackets - 7] = 1; |
765 media_loss_mask_[kNumMediaPackets - 5] = 1; | 777 media_loss_mask_[kNumMediaPackets - 5] = 1; |
766 media_loss_mask_[kNumMediaPackets - 3] = 1; | 778 media_loss_mask_[kNumMediaPackets - 3] = 1; |
767 media_loss_mask_[kNumMediaPackets - 1] = 1; | 779 media_loss_mask_[kNumMediaPackets - 1] = 1; |
768 NetworkReceivedPackets(); | 780 NetworkReceivedPackets(media_loss_mask_, fec_loss_mask_); |
769 | 781 |
770 EXPECT_EQ(0, fec_->DecodeFec(&received_packet_list_, | 782 EXPECT_EQ(0, fec_.DecodeFec(&received_packet_list_, &recovered_packet_list_)); |
771 &recovered_packet_list_)); | |
772 | 783 |
773 // 5 protected packets lost, one FEC packet, cannot get complete recovery. | 784 // 5 protected packets lost, one FEC packet, cannot get complete recovery. |
774 EXPECT_FALSE(IsRecoveryComplete()); | 785 EXPECT_FALSE(IsRecoveryComplete()); |
775 } | 786 } |
776 | 787 |
777 void RtpFecTest::TearDown() { | 788 void RtpFecTest::TearDown() { |
778 fec_->ResetState(&recovered_packet_list_); | 789 fec_.ResetState(&recovered_packet_list_); |
779 delete fec_; | |
780 recovered_packet_list_.clear(); | 790 recovered_packet_list_.clear(); |
781 media_packet_list_.clear(); | 791 media_packet_list_.clear(); |
782 EXPECT_TRUE(media_packet_list_.empty()); | 792 EXPECT_TRUE(media_packet_list_.empty()); |
783 } | 793 } |
784 | 794 |
785 bool RtpFecTest::IsRecoveryComplete() { | 795 bool RtpFecTest::IsRecoveryComplete() { |
786 // We must have equally many recovered packets as original packets. | 796 // We must have equally many recovered packets as original packets. |
787 if (recovered_packet_list_.size() != media_packet_list_.size()) { | 797 if (recovered_packet_list_.size() != media_packet_list_.size()) { |
788 return false; | 798 return false; |
789 } | 799 } |
(...skipping 12 matching lines...) Expand all Loading... |
802 recovered_packet->pkt->data, | 812 recovered_packet->pkt->data, |
803 media_packet->length) != 0) { | 813 media_packet->length) != 0) { |
804 return false; | 814 return false; |
805 } | 815 } |
806 return true; | 816 return true; |
807 }; | 817 }; |
808 return std::equal(media_packet_list_.cbegin(), media_packet_list_.cend(), | 818 return std::equal(media_packet_list_.cbegin(), media_packet_list_.cend(), |
809 recovered_packet_list_.cbegin(), cmp); | 819 recovered_packet_list_.cbegin(), cmp); |
810 } | 820 } |
811 | 821 |
812 void RtpFecTest::NetworkReceivedPackets() { | 822 void RtpFecTest::NetworkReceivedPackets(int* media_loss_mask, |
813 const bool kFecPacket = true; | 823 int* fec_loss_mask) { |
814 ReceivedPackets(media_packet_list_, media_loss_mask_, !kFecPacket); | 824 constexpr bool kFecPacket = true; |
815 ReceivedPackets(fec_packet_list_, fec_loss_mask_, kFecPacket); | 825 ReceivedPackets(media_packet_list_, media_loss_mask, !kFecPacket); |
| 826 ReceivedPackets(fec_packet_list_, fec_loss_mask, kFecPacket); |
816 } | 827 } |
817 | 828 |
818 template <typename T> | 829 template <typename T> |
819 void RtpFecTest::ReceivedPackets(const T& packet_list, int* loss_mask, | 830 void RtpFecTest::ReceivedPackets(const T& packet_list, int* loss_mask, |
820 bool is_fec) { | 831 bool is_fec) { |
821 int seq_num = fec_seq_num_; | 832 int seq_num = fec_seq_num_; |
822 int packet_idx = 0; | 833 int packet_idx = 0; |
823 | 834 |
824 for (const auto& packet : packet_list) { | 835 for (const auto& packet : packet_list) { |
825 if (loss_mask[packet_idx] == 0) { | 836 if (loss_mask[packet_idx] == 0) { |
(...skipping 29 matching lines...) Expand all Loading... |
855 | 866 |
856 int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets, | 867 int RtpFecTest::ConstructMediaPacketsSeqNum(int num_media_packets, |
857 int start_seq_num) { | 868 int start_seq_num) { |
858 RTC_DCHECK_GT(num_media_packets, 0); | 869 RTC_DCHECK_GT(num_media_packets, 0); |
859 int sequence_number = start_seq_num; | 870 int sequence_number = start_seq_num; |
860 int time_stamp = random_.Rand<int>(); | 871 int time_stamp = random_.Rand<int>(); |
861 | 872 |
862 for (int i = 0; i < num_media_packets; ++i) { | 873 for (int i = 0; i < num_media_packets; ++i) { |
863 std::unique_ptr<ForwardErrorCorrection::Packet> media_packet( | 874 std::unique_ptr<ForwardErrorCorrection::Packet> media_packet( |
864 new ForwardErrorCorrection::Packet()); | 875 new ForwardErrorCorrection::Packet()); |
865 const uint32_t kMinPacketSize = kRtpHeaderSize; | 876 constexpr uint32_t kMinPacketSize = kRtpHeaderSize; |
866 const uint32_t kMaxPacketSize = IP_PACKET_SIZE - kRtpHeaderSize - | 877 const uint32_t kMaxPacketSize = IP_PACKET_SIZE - kRtpHeaderSize - |
867 kTransportOverhead - | 878 kTransportOverhead - |
868 ForwardErrorCorrection::PacketOverhead(); | 879 ForwardErrorCorrection::PacketOverhead(); |
869 media_packet->length = random_.Rand(kMinPacketSize, kMaxPacketSize); | 880 media_packet->length = random_.Rand(kMinPacketSize, kMaxPacketSize); |
870 | 881 |
871 // Generate random values for the first 2 bytes | 882 // Generate random values for the first 2 bytes |
872 media_packet->data[0] = random_.Rand<uint8_t>(); | 883 media_packet->data[0] = random_.Rand<uint8_t>(); |
873 media_packet->data[1] = random_.Rand<uint8_t>(); | 884 media_packet->data[1] = random_.Rand<uint8_t>(); |
874 | 885 |
875 // The first two bits are assumed to be 10 by the FEC encoder. | 886 // The first two bits are assumed to be 10 by the FEC encoder. |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
914 PacketList* dst) { | 925 PacketList* dst) { |
915 RTC_DCHECK_GT(n, 0); | 926 RTC_DCHECK_GT(n, 0); |
916 int i = 0; | 927 int i = 0; |
917 for (const auto& packet : src) { | 928 for (const auto& packet : src) { |
918 if (i % n == 0) { | 929 if (i % n == 0) { |
919 dst->emplace_back(new ForwardErrorCorrection::Packet(*packet)); | 930 dst->emplace_back(new ForwardErrorCorrection::Packet(*packet)); |
920 } | 931 } |
921 ++i; | 932 ++i; |
922 } | 933 } |
923 } | 934 } |
OLD | NEW |