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 <string.h> | 11 #include <string.h> |
12 | 12 |
13 #include <list> | 13 #include <list> |
14 #include <memory> | 14 #include <memory> |
15 | 15 |
16 #include "webrtc/modules/rtp_rtcp/include/fec_receiver.h" | |
17 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" | 16 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" |
| 17 #include "webrtc/modules/rtp_rtcp/include/ulpfec_receiver.h" |
18 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" | 18 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" |
19 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 19 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
20 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" | 20 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" |
21 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" | 21 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
22 #include "webrtc/test/gmock.h" | 22 #include "webrtc/test/gmock.h" |
23 #include "webrtc/test/gtest.h" | 23 #include "webrtc/test/gtest.h" |
24 | 24 |
25 namespace webrtc { | 25 namespace webrtc { |
26 | 26 |
27 namespace { | 27 namespace { |
28 using ::testing::_; | 28 using ::testing::_; |
29 using ::testing::Args; | 29 using ::testing::Args; |
30 using ::testing::ElementsAreArray; | 30 using ::testing::ElementsAreArray; |
31 using ::testing::Return; | 31 using ::testing::Return; |
32 | 32 |
33 using test::fec::AugmentedPacket; | 33 using test::fec::AugmentedPacket; |
34 using Packet = ForwardErrorCorrection::Packet; | 34 using Packet = ForwardErrorCorrection::Packet; |
35 using test::fec::UlpfecPacketGenerator; | 35 using test::fec::UlpfecPacketGenerator; |
36 | 36 |
37 constexpr int kFecPayloadType = 96; | 37 constexpr int kFecPayloadType = 96; |
38 constexpr uint32_t kMediaSsrc = 835424; | 38 constexpr uint32_t kMediaSsrc = 835424; |
39 } // namespace | 39 } // namespace |
40 | 40 |
41 class ReceiverFecTest : public ::testing::Test { | 41 class UlpfecReceiverTest : public ::testing::Test { |
42 protected: | 42 protected: |
43 ReceiverFecTest() | 43 UlpfecReceiverTest() |
44 : fec_(ForwardErrorCorrection::CreateUlpfec()), | 44 : fec_(ForwardErrorCorrection::CreateUlpfec()), |
45 receiver_fec_(FecReceiver::Create(&rtp_data_callback_)), | 45 receiver_fec_(UlpfecReceiver::Create(&rtp_data_callback_)), |
46 packet_generator_(kMediaSsrc) {} | 46 packet_generator_(kMediaSsrc) {} |
47 | 47 |
48 // Generates |num_fec_packets| FEC packets, given |media_packets|. | 48 // Generates |num_fec_packets| FEC packets, given |media_packets|. |
49 void EncodeFec(const ForwardErrorCorrection::PacketList& media_packets, | 49 void EncodeFec(const ForwardErrorCorrection::PacketList& media_packets, |
50 size_t num_fec_packets, | 50 size_t num_fec_packets, |
51 std::list<ForwardErrorCorrection::Packet*>* fec_packets); | 51 std::list<ForwardErrorCorrection::Packet*>* fec_packets); |
52 | 52 |
53 // Generates |num_media_packets| corresponding to a single frame. | 53 // Generates |num_media_packets| corresponding to a single frame. |
54 void PacketizeFrame(size_t num_media_packets, | 54 void PacketizeFrame(size_t num_media_packets, |
55 size_t frame_offset, | 55 size_t frame_offset, |
(...skipping 14 matching lines...) Expand all Loading... |
70 size_t times); | 70 size_t times); |
71 | 71 |
72 void InjectGarbagePacketLength(size_t fec_garbage_offset); | 72 void InjectGarbagePacketLength(size_t fec_garbage_offset); |
73 | 73 |
74 static void SurvivesMaliciousPacket(const uint8_t* data, | 74 static void SurvivesMaliciousPacket(const uint8_t* data, |
75 size_t length, | 75 size_t length, |
76 uint8_t ulpfec_payload_type); | 76 uint8_t ulpfec_payload_type); |
77 | 77 |
78 MockRtpData rtp_data_callback_; | 78 MockRtpData rtp_data_callback_; |
79 std::unique_ptr<ForwardErrorCorrection> fec_; | 79 std::unique_ptr<ForwardErrorCorrection> fec_; |
80 std::unique_ptr<FecReceiver> receiver_fec_; | 80 std::unique_ptr<UlpfecReceiver> receiver_fec_; |
81 UlpfecPacketGenerator packet_generator_; | 81 UlpfecPacketGenerator packet_generator_; |
82 }; | 82 }; |
83 | 83 |
84 void ReceiverFecTest::EncodeFec( | 84 void UlpfecReceiverTest::EncodeFec( |
85 const ForwardErrorCorrection::PacketList& media_packets, | 85 const ForwardErrorCorrection::PacketList& media_packets, |
86 size_t num_fec_packets, | 86 size_t num_fec_packets, |
87 std::list<ForwardErrorCorrection::Packet*>* fec_packets) { | 87 std::list<ForwardErrorCorrection::Packet*>* fec_packets) { |
88 const uint8_t protection_factor = | 88 const uint8_t protection_factor = |
89 num_fec_packets * 255 / media_packets.size(); | 89 num_fec_packets * 255 / media_packets.size(); |
90 // Unequal protection is turned off, and the number of important | 90 // Unequal protection is turned off, and the number of important |
91 // packets is thus irrelevant. | 91 // packets is thus irrelevant. |
92 constexpr int kNumImportantPackets = 0; | 92 constexpr int kNumImportantPackets = 0; |
93 constexpr bool kUseUnequalProtection = false; | 93 constexpr bool kUseUnequalProtection = false; |
94 constexpr FecMaskType kFecMaskType = kFecMaskBursty; | 94 constexpr FecMaskType kFecMaskType = kFecMaskBursty; |
95 EXPECT_EQ( | 95 EXPECT_EQ( |
96 0, fec_->EncodeFec(media_packets, protection_factor, kNumImportantPackets, | 96 0, fec_->EncodeFec(media_packets, protection_factor, kNumImportantPackets, |
97 kUseUnequalProtection, kFecMaskType, fec_packets)); | 97 kUseUnequalProtection, kFecMaskType, fec_packets)); |
98 ASSERT_EQ(num_fec_packets, fec_packets->size()); | 98 ASSERT_EQ(num_fec_packets, fec_packets->size()); |
99 } | 99 } |
100 | 100 |
101 void ReceiverFecTest::PacketizeFrame( | 101 void UlpfecReceiverTest::PacketizeFrame( |
102 size_t num_media_packets, | 102 size_t num_media_packets, |
103 size_t frame_offset, | 103 size_t frame_offset, |
104 std::list<AugmentedPacket*>* augmented_packets, | 104 std::list<AugmentedPacket*>* augmented_packets, |
105 ForwardErrorCorrection::PacketList* packets) { | 105 ForwardErrorCorrection::PacketList* packets) { |
106 packet_generator_.NewFrame(num_media_packets); | 106 packet_generator_.NewFrame(num_media_packets); |
107 for (size_t i = 0; i < num_media_packets; ++i) { | 107 for (size_t i = 0; i < num_media_packets; ++i) { |
108 std::unique_ptr<AugmentedPacket> next_packet( | 108 std::unique_ptr<AugmentedPacket> next_packet( |
109 packet_generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10)); | 109 packet_generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10)); |
110 augmented_packets->push_back(next_packet.get()); | 110 augmented_packets->push_back(next_packet.get()); |
111 packets->push_back(std::move(next_packet)); | 111 packets->push_back(std::move(next_packet)); |
112 } | 112 } |
113 } | 113 } |
114 | 114 |
115 void ReceiverFecTest::BuildAndAddRedMediaPacket(AugmentedPacket* packet) { | 115 void UlpfecReceiverTest::BuildAndAddRedMediaPacket(AugmentedPacket* packet) { |
116 std::unique_ptr<AugmentedPacket> red_packet( | 116 std::unique_ptr<AugmentedPacket> red_packet( |
117 packet_generator_.BuildMediaRedPacket(*packet)); | 117 packet_generator_.BuildMediaRedPacket(*packet)); |
118 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( | 118 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( |
119 red_packet->header.header, red_packet->data, | 119 red_packet->header.header, red_packet->data, |
120 red_packet->length, kFecPayloadType)); | 120 red_packet->length, kFecPayloadType)); |
121 } | 121 } |
122 | 122 |
123 void ReceiverFecTest::BuildAndAddRedFecPacket(Packet* packet) { | 123 void UlpfecReceiverTest::BuildAndAddRedFecPacket(Packet* packet) { |
124 std::unique_ptr<AugmentedPacket> red_packet( | 124 std::unique_ptr<AugmentedPacket> red_packet( |
125 packet_generator_.BuildUlpfecRedPacket(*packet)); | 125 packet_generator_.BuildUlpfecRedPacket(*packet)); |
126 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( | 126 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( |
127 red_packet->header.header, red_packet->data, | 127 red_packet->header.header, red_packet->data, |
128 red_packet->length, kFecPayloadType)); | 128 red_packet->length, kFecPayloadType)); |
129 } | 129 } |
130 | 130 |
131 void ReceiverFecTest::VerifyReconstructedMediaPacket( | 131 void UlpfecReceiverTest::VerifyReconstructedMediaPacket( |
132 const AugmentedPacket& packet, | 132 const AugmentedPacket& packet, |
133 size_t times) { | 133 size_t times) { |
134 // Verify that the content of the reconstructed packet is equal to the | 134 // Verify that the content of the reconstructed packet is equal to the |
135 // content of |packet|, and that the same content is received |times| number | 135 // content of |packet|, and that the same content is received |times| number |
136 // of times in a row. | 136 // of times in a row. |
137 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet.length)) | 137 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet.length)) |
138 .With(Args<0, 1>(ElementsAreArray(packet.data, packet.length))) | 138 .With(Args<0, 1>(ElementsAreArray(packet.data, packet.length))) |
139 .Times(times) | 139 .Times(times) |
140 .WillRepeatedly(Return(true)); | 140 .WillRepeatedly(Return(true)); |
141 } | 141 } |
142 | 142 |
143 void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { | 143 void UlpfecReceiverTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { |
144 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 144 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
145 .WillRepeatedly(Return(true)); | 145 .WillRepeatedly(Return(true)); |
146 | 146 |
147 const size_t kNumFecPackets = 1; | 147 const size_t kNumFecPackets = 1; |
148 std::list<AugmentedPacket*> augmented_media_packets; | 148 std::list<AugmentedPacket*> augmented_media_packets; |
149 ForwardErrorCorrection::PacketList media_packets; | 149 ForwardErrorCorrection::PacketList media_packets; |
150 PacketizeFrame(2, 0, &augmented_media_packets, &media_packets); | 150 PacketizeFrame(2, 0, &augmented_media_packets, &media_packets); |
151 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 151 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
152 EncodeFec(media_packets, kNumFecPackets, &fec_packets); | 152 EncodeFec(media_packets, kNumFecPackets, &fec_packets); |
153 ByteWriter<uint16_t>::WriteBigEndian( | 153 ByteWriter<uint16_t>::WriteBigEndian( |
154 &fec_packets.front()->data[fec_garbage_offset], 0x4711); | 154 &fec_packets.front()->data[fec_garbage_offset], 0x4711); |
155 | 155 |
156 // Inject first media packet, then first FEC packet, skipping the second media | 156 // Inject first media packet, then first FEC packet, skipping the second media |
157 // packet to cause a recovery from the FEC packet. | 157 // packet to cause a recovery from the FEC packet. |
158 BuildAndAddRedMediaPacket(augmented_media_packets.front()); | 158 BuildAndAddRedMediaPacket(augmented_media_packets.front()); |
159 BuildAndAddRedFecPacket(fec_packets.front()); | 159 BuildAndAddRedFecPacket(fec_packets.front()); |
160 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 160 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
161 | 161 |
162 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); | 162 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); |
163 EXPECT_EQ(2U, counter.num_packets); | 163 EXPECT_EQ(2U, counter.num_packets); |
164 EXPECT_EQ(1U, counter.num_fec_packets); | 164 EXPECT_EQ(1U, counter.num_fec_packets); |
165 EXPECT_EQ(0U, counter.num_recovered_packets); | 165 EXPECT_EQ(0U, counter.num_recovered_packets); |
166 } | 166 } |
167 | 167 |
168 void ReceiverFecTest::SurvivesMaliciousPacket(const uint8_t* data, | 168 void UlpfecReceiverTest::SurvivesMaliciousPacket(const uint8_t* data, |
169 size_t length, | 169 size_t length, |
170 uint8_t ulpfec_payload_type) { | 170 uint8_t ulpfec_payload_type) { |
171 webrtc::RTPHeader header; | 171 RTPHeader header; |
172 std::unique_ptr<webrtc::RtpHeaderParser> parser( | 172 std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); |
173 webrtc::RtpHeaderParser::Create()); | |
174 ASSERT_TRUE(parser->Parse(data, length, &header)); | 173 ASSERT_TRUE(parser->Parse(data, length, &header)); |
175 | 174 |
176 webrtc::NullRtpData null_callback; | 175 NullRtpData null_callback; |
177 std::unique_ptr<webrtc::FecReceiver> receiver_fec( | 176 std::unique_ptr<UlpfecReceiver> receiver_fec( |
178 webrtc::FecReceiver::Create(&null_callback)); | 177 UlpfecReceiver::Create(&null_callback)); |
179 | 178 |
180 receiver_fec->AddReceivedRedPacket(header, data, length, ulpfec_payload_type); | 179 receiver_fec->AddReceivedRedPacket(header, data, length, ulpfec_payload_type); |
181 } | 180 } |
182 | 181 |
183 TEST_F(ReceiverFecTest, TwoMediaOneFec) { | 182 TEST_F(UlpfecReceiverTest, TwoMediaOneFec) { |
184 constexpr size_t kNumFecPackets = 1u; | 183 constexpr size_t kNumFecPackets = 1u; |
185 std::list<AugmentedPacket*> augmented_media_packets; | 184 std::list<AugmentedPacket*> augmented_media_packets; |
186 ForwardErrorCorrection::PacketList media_packets; | 185 ForwardErrorCorrection::PacketList media_packets; |
187 PacketizeFrame(2, 0, &augmented_media_packets, &media_packets); | 186 PacketizeFrame(2, 0, &augmented_media_packets, &media_packets); |
188 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 187 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
189 EncodeFec(media_packets, kNumFecPackets, &fec_packets); | 188 EncodeFec(media_packets, kNumFecPackets, &fec_packets); |
190 | 189 |
191 // Recovery | 190 // Recovery |
192 auto it = augmented_media_packets.begin(); | 191 auto it = augmented_media_packets.begin(); |
193 BuildAndAddRedMediaPacket(*it); | 192 BuildAndAddRedMediaPacket(*it); |
194 VerifyReconstructedMediaPacket(**it, 1); | 193 VerifyReconstructedMediaPacket(**it, 1); |
195 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 194 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
196 // Drop one media packet. | 195 // Drop one media packet. |
197 auto fec_it = fec_packets.begin(); | 196 auto fec_it = fec_packets.begin(); |
198 BuildAndAddRedFecPacket(*fec_it); | 197 BuildAndAddRedFecPacket(*fec_it); |
199 ++it; | 198 ++it; |
200 VerifyReconstructedMediaPacket(**it, 1); | 199 VerifyReconstructedMediaPacket(**it, 1); |
201 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 200 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
202 | 201 |
203 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); | 202 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); |
204 EXPECT_EQ(2u, counter.num_packets); | 203 EXPECT_EQ(2u, counter.num_packets); |
205 EXPECT_EQ(1u, counter.num_fec_packets); | 204 EXPECT_EQ(1u, counter.num_fec_packets); |
206 EXPECT_EQ(1u, counter.num_recovered_packets); | 205 EXPECT_EQ(1u, counter.num_recovered_packets); |
207 } | 206 } |
208 | 207 |
209 TEST_F(ReceiverFecTest, InjectGarbageFecHeaderLengthRecovery) { | 208 TEST_F(UlpfecReceiverTest, InjectGarbageFecHeaderLengthRecovery) { |
210 // Byte offset 8 is the 'length recovery' field of the FEC header. | 209 // Byte offset 8 is the 'length recovery' field of the FEC header. |
211 InjectGarbagePacketLength(8); | 210 InjectGarbagePacketLength(8); |
212 } | 211 } |
213 | 212 |
214 TEST_F(ReceiverFecTest, InjectGarbageFecLevelHeaderProtectionLength) { | 213 TEST_F(UlpfecReceiverTest, InjectGarbageFecLevelHeaderProtectionLength) { |
215 // Byte offset 10 is the 'protection length' field in the first FEC level | 214 // Byte offset 10 is the 'protection length' field in the first FEC level |
216 // header. | 215 // header. |
217 InjectGarbagePacketLength(10); | 216 InjectGarbagePacketLength(10); |
218 } | 217 } |
219 | 218 |
220 TEST_F(ReceiverFecTest, TwoMediaTwoFec) { | 219 TEST_F(UlpfecReceiverTest, TwoMediaTwoFec) { |
221 const size_t kNumFecPackets = 2; | 220 const size_t kNumFecPackets = 2; |
222 std::list<AugmentedPacket*> augmented_media_packets; | 221 std::list<AugmentedPacket*> augmented_media_packets; |
223 ForwardErrorCorrection::PacketList media_packets; | 222 ForwardErrorCorrection::PacketList media_packets; |
224 PacketizeFrame(2, 0, &augmented_media_packets, &media_packets); | 223 PacketizeFrame(2, 0, &augmented_media_packets, &media_packets); |
225 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 224 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
226 EncodeFec(media_packets, kNumFecPackets, &fec_packets); | 225 EncodeFec(media_packets, kNumFecPackets, &fec_packets); |
227 | 226 |
228 // Recovery | 227 // Recovery |
229 // Drop both media packets. | 228 // Drop both media packets. |
230 auto it = augmented_media_packets.begin(); | 229 auto it = augmented_media_packets.begin(); |
231 auto fec_it = fec_packets.begin(); | 230 auto fec_it = fec_packets.begin(); |
232 BuildAndAddRedFecPacket(*fec_it); | 231 BuildAndAddRedFecPacket(*fec_it); |
233 VerifyReconstructedMediaPacket(**it, 1); | 232 VerifyReconstructedMediaPacket(**it, 1); |
234 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 233 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
235 ++fec_it; | 234 ++fec_it; |
236 BuildAndAddRedFecPacket(*fec_it); | 235 BuildAndAddRedFecPacket(*fec_it); |
237 ++it; | 236 ++it; |
238 VerifyReconstructedMediaPacket(**it, 1); | 237 VerifyReconstructedMediaPacket(**it, 1); |
239 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 238 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
240 } | 239 } |
241 | 240 |
242 TEST_F(ReceiverFecTest, TwoFramesOneFec) { | 241 TEST_F(UlpfecReceiverTest, TwoFramesOneFec) { |
243 const size_t kNumFecPackets = 1; | 242 const size_t kNumFecPackets = 1; |
244 std::list<AugmentedPacket*> augmented_media_packets; | 243 std::list<AugmentedPacket*> augmented_media_packets; |
245 ForwardErrorCorrection::PacketList media_packets; | 244 ForwardErrorCorrection::PacketList media_packets; |
246 PacketizeFrame(1, 0, &augmented_media_packets, &media_packets); | 245 PacketizeFrame(1, 0, &augmented_media_packets, &media_packets); |
247 PacketizeFrame(1, 1, &augmented_media_packets, &media_packets); | 246 PacketizeFrame(1, 1, &augmented_media_packets, &media_packets); |
248 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 247 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
249 EncodeFec(media_packets, kNumFecPackets, &fec_packets); | 248 EncodeFec(media_packets, kNumFecPackets, &fec_packets); |
250 | 249 |
251 // Recovery | 250 // Recovery |
252 auto it = augmented_media_packets.begin(); | 251 auto it = augmented_media_packets.begin(); |
253 BuildAndAddRedMediaPacket(augmented_media_packets.front()); | 252 BuildAndAddRedMediaPacket(augmented_media_packets.front()); |
254 VerifyReconstructedMediaPacket(**it, 1); | 253 VerifyReconstructedMediaPacket(**it, 1); |
255 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 254 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
256 // Drop one media packet. | 255 // Drop one media packet. |
257 BuildAndAddRedFecPacket(fec_packets.front()); | 256 BuildAndAddRedFecPacket(fec_packets.front()); |
258 ++it; | 257 ++it; |
259 VerifyReconstructedMediaPacket(**it, 1); | 258 VerifyReconstructedMediaPacket(**it, 1); |
260 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 259 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
261 } | 260 } |
262 | 261 |
263 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) { | 262 TEST_F(UlpfecReceiverTest, OneCompleteOneUnrecoverableFrame) { |
264 const size_t kNumFecPackets = 1; | 263 const size_t kNumFecPackets = 1; |
265 std::list<AugmentedPacket*> augmented_media_packets; | 264 std::list<AugmentedPacket*> augmented_media_packets; |
266 ForwardErrorCorrection::PacketList media_packets; | 265 ForwardErrorCorrection::PacketList media_packets; |
267 PacketizeFrame(1, 0, &augmented_media_packets, &media_packets); | 266 PacketizeFrame(1, 0, &augmented_media_packets, &media_packets); |
268 PacketizeFrame(2, 1, &augmented_media_packets, &media_packets); | 267 PacketizeFrame(2, 1, &augmented_media_packets, &media_packets); |
269 | 268 |
270 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 269 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
271 EncodeFec(media_packets, kNumFecPackets, &fec_packets); | 270 EncodeFec(media_packets, kNumFecPackets, &fec_packets); |
272 | 271 |
273 // Recovery | 272 // Recovery |
274 auto it = augmented_media_packets.begin(); | 273 auto it = augmented_media_packets.begin(); |
275 BuildAndAddRedMediaPacket(*it); // First frame: one packet. | 274 BuildAndAddRedMediaPacket(*it); // First frame: one packet. |
276 VerifyReconstructedMediaPacket(**it, 1); | 275 VerifyReconstructedMediaPacket(**it, 1); |
277 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 276 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
278 ++it; | 277 ++it; |
279 BuildAndAddRedMediaPacket(*it); // First packet of second frame. | 278 BuildAndAddRedMediaPacket(*it); // First packet of second frame. |
280 VerifyReconstructedMediaPacket(**it, 1); | 279 VerifyReconstructedMediaPacket(**it, 1); |
281 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 280 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
282 } | 281 } |
283 | 282 |
284 TEST_F(ReceiverFecTest, MaxFramesOneFec) { | 283 TEST_F(UlpfecReceiverTest, MaxFramesOneFec) { |
285 const size_t kNumFecPackets = 1; | 284 const size_t kNumFecPackets = 1; |
286 const size_t kNumMediaPackets = 48; | 285 const size_t kNumMediaPackets = 48; |
287 std::list<AugmentedPacket*> augmented_media_packets; | 286 std::list<AugmentedPacket*> augmented_media_packets; |
288 ForwardErrorCorrection::PacketList media_packets; | 287 ForwardErrorCorrection::PacketList media_packets; |
289 for (size_t i = 0; i < kNumMediaPackets; ++i) { | 288 for (size_t i = 0; i < kNumMediaPackets; ++i) { |
290 PacketizeFrame(1, i, &augmented_media_packets, &media_packets); | 289 PacketizeFrame(1, i, &augmented_media_packets, &media_packets); |
291 } | 290 } |
292 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 291 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
293 EncodeFec(media_packets, kNumFecPackets, &fec_packets); | 292 EncodeFec(media_packets, kNumFecPackets, &fec_packets); |
294 | 293 |
295 // Recovery | 294 // Recovery |
296 auto it = augmented_media_packets.begin(); | 295 auto it = augmented_media_packets.begin(); |
297 ++it; // Drop first packet. | 296 ++it; // Drop first packet. |
298 for (; it != augmented_media_packets.end(); ++it) { | 297 for (; it != augmented_media_packets.end(); ++it) { |
299 BuildAndAddRedMediaPacket(*it); | 298 BuildAndAddRedMediaPacket(*it); |
300 VerifyReconstructedMediaPacket(**it, 1); | 299 VerifyReconstructedMediaPacket(**it, 1); |
301 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 300 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
302 } | 301 } |
303 BuildAndAddRedFecPacket(fec_packets.front()); | 302 BuildAndAddRedFecPacket(fec_packets.front()); |
304 it = augmented_media_packets.begin(); | 303 it = augmented_media_packets.begin(); |
305 VerifyReconstructedMediaPacket(**it, 1); | 304 VerifyReconstructedMediaPacket(**it, 1); |
306 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 305 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
307 } | 306 } |
308 | 307 |
309 TEST_F(ReceiverFecTest, TooManyFrames) { | 308 TEST_F(UlpfecReceiverTest, TooManyFrames) { |
310 const size_t kNumFecPackets = 1; | 309 const size_t kNumFecPackets = 1; |
311 const size_t kNumMediaPackets = 49; | 310 const size_t kNumMediaPackets = 49; |
312 std::list<AugmentedPacket*> augmented_media_packets; | 311 std::list<AugmentedPacket*> augmented_media_packets; |
313 ForwardErrorCorrection::PacketList media_packets; | 312 ForwardErrorCorrection::PacketList media_packets; |
314 for (size_t i = 0; i < kNumMediaPackets; ++i) { | 313 for (size_t i = 0; i < kNumMediaPackets; ++i) { |
315 PacketizeFrame(1, i, &augmented_media_packets, &media_packets); | 314 PacketizeFrame(1, i, &augmented_media_packets, &media_packets); |
316 } | 315 } |
317 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 316 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
318 EXPECT_EQ(-1, fec_->EncodeFec(media_packets, | 317 EXPECT_EQ(-1, fec_->EncodeFec(media_packets, |
319 kNumFecPackets * 255 / kNumMediaPackets, 0, | 318 kNumFecPackets * 255 / kNumMediaPackets, 0, |
320 false, kFecMaskBursty, &fec_packets)); | 319 false, kFecMaskBursty, &fec_packets)); |
321 } | 320 } |
322 | 321 |
323 TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) { | 322 TEST_F(UlpfecReceiverTest, PacketNotDroppedTooEarly) { |
324 // 1 frame with 2 media packets and one FEC packet. One media packet missing. | 323 // 1 frame with 2 media packets and one FEC packet. One media packet missing. |
325 // Delay the FEC packet. | 324 // Delay the FEC packet. |
326 Packet* delayed_fec = nullptr; | 325 Packet* delayed_fec = nullptr; |
327 const size_t kNumFecPacketsBatch1 = 1; | 326 const size_t kNumFecPacketsBatch1 = 1; |
328 const size_t kNumMediaPacketsBatch1 = 2; | 327 const size_t kNumMediaPacketsBatch1 = 2; |
329 std::list<AugmentedPacket*> augmented_media_packets_batch1; | 328 std::list<AugmentedPacket*> augmented_media_packets_batch1; |
330 ForwardErrorCorrection::PacketList media_packets_batch1; | 329 ForwardErrorCorrection::PacketList media_packets_batch1; |
331 PacketizeFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1, | 330 PacketizeFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1, |
332 &media_packets_batch1); | 331 &media_packets_batch1); |
333 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 332 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
334 EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets); | 333 EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets); |
335 | 334 |
336 BuildAndAddRedMediaPacket(augmented_media_packets_batch1.front()); | 335 BuildAndAddRedMediaPacket(augmented_media_packets_batch1.front()); |
337 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 336 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
338 .Times(1).WillRepeatedly(Return(true)); | 337 .Times(1) |
| 338 .WillRepeatedly(Return(true)); |
339 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 339 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
340 delayed_fec = fec_packets.front(); | 340 delayed_fec = fec_packets.front(); |
341 | 341 |
342 // Fill the FEC decoder. No packets should be dropped. | 342 // Fill the FEC decoder. No packets should be dropped. |
343 const size_t kNumMediaPacketsBatch2 = 46; | 343 const size_t kNumMediaPacketsBatch2 = 46; |
344 std::list<AugmentedPacket*> augmented_media_packets_batch2; | 344 std::list<AugmentedPacket*> augmented_media_packets_batch2; |
345 ForwardErrorCorrection::PacketList media_packets_batch2; | 345 ForwardErrorCorrection::PacketList media_packets_batch2; |
346 for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) { | 346 for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) { |
347 PacketizeFrame(1, i, &augmented_media_packets_batch2, | 347 PacketizeFrame(1, i, &augmented_media_packets_batch2, |
348 &media_packets_batch2); | 348 &media_packets_batch2); |
349 } | 349 } |
350 for (auto it = augmented_media_packets_batch2.begin(); | 350 for (auto it = augmented_media_packets_batch2.begin(); |
351 it != augmented_media_packets_batch2.end(); ++it) { | 351 it != augmented_media_packets_batch2.end(); ++it) { |
352 BuildAndAddRedMediaPacket(*it); | 352 BuildAndAddRedMediaPacket(*it); |
353 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 353 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
354 .Times(1).WillRepeatedly(Return(true)); | 354 .Times(1) |
| 355 .WillRepeatedly(Return(true)); |
355 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 356 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
356 } | 357 } |
357 | 358 |
358 // Add the delayed FEC packet. One packet should be reconstructed. | 359 // Add the delayed FEC packet. One packet should be reconstructed. |
359 BuildAndAddRedFecPacket(delayed_fec); | 360 BuildAndAddRedFecPacket(delayed_fec); |
360 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 361 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
361 .Times(1).WillRepeatedly(Return(true)); | 362 .Times(1) |
| 363 .WillRepeatedly(Return(true)); |
362 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 364 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
363 } | 365 } |
364 | 366 |
365 TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) { | 367 TEST_F(UlpfecReceiverTest, PacketDroppedWhenTooOld) { |
366 // 1 frame with 2 media packets and one FEC packet. One media packet missing. | 368 // 1 frame with 2 media packets and one FEC packet. One media packet missing. |
367 // Delay the FEC packet. | 369 // Delay the FEC packet. |
368 Packet* delayed_fec = nullptr; | 370 Packet* delayed_fec = nullptr; |
369 const size_t kNumFecPacketsBatch1 = 1; | 371 const size_t kNumFecPacketsBatch1 = 1; |
370 const size_t kNumMediaPacketsBatch1 = 2; | 372 const size_t kNumMediaPacketsBatch1 = 2; |
371 std::list<AugmentedPacket*> augmented_media_packets_batch1; | 373 std::list<AugmentedPacket*> augmented_media_packets_batch1; |
372 ForwardErrorCorrection::PacketList media_packets_batch1; | 374 ForwardErrorCorrection::PacketList media_packets_batch1; |
373 PacketizeFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1, | 375 PacketizeFrame(kNumMediaPacketsBatch1, 0, &augmented_media_packets_batch1, |
374 &media_packets_batch1); | 376 &media_packets_batch1); |
375 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 377 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
376 EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets); | 378 EncodeFec(media_packets_batch1, kNumFecPacketsBatch1, &fec_packets); |
377 | 379 |
378 BuildAndAddRedMediaPacket(augmented_media_packets_batch1.front()); | 380 BuildAndAddRedMediaPacket(augmented_media_packets_batch1.front()); |
379 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 381 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
380 .Times(1).WillRepeatedly(Return(true)); | 382 .Times(1) |
| 383 .WillRepeatedly(Return(true)); |
381 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 384 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
382 delayed_fec = fec_packets.front(); | 385 delayed_fec = fec_packets.front(); |
383 | 386 |
384 // Fill the FEC decoder and force the last packet to be dropped. | 387 // Fill the FEC decoder and force the last packet to be dropped. |
385 const size_t kNumMediaPacketsBatch2 = 48; | 388 const size_t kNumMediaPacketsBatch2 = 48; |
386 std::list<AugmentedPacket*> augmented_media_packets_batch2; | 389 std::list<AugmentedPacket*> augmented_media_packets_batch2; |
387 ForwardErrorCorrection::PacketList media_packets_batch2; | 390 ForwardErrorCorrection::PacketList media_packets_batch2; |
388 for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) { | 391 for (size_t i = 0; i < kNumMediaPacketsBatch2; ++i) { |
389 PacketizeFrame(1, i, &augmented_media_packets_batch2, | 392 PacketizeFrame(1, i, &augmented_media_packets_batch2, |
390 &media_packets_batch2); | 393 &media_packets_batch2); |
391 } | 394 } |
392 for (auto it = augmented_media_packets_batch2.begin(); | 395 for (auto it = augmented_media_packets_batch2.begin(); |
393 it != augmented_media_packets_batch2.end(); ++it) { | 396 it != augmented_media_packets_batch2.end(); ++it) { |
394 BuildAndAddRedMediaPacket(*it); | 397 BuildAndAddRedMediaPacket(*it); |
395 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 398 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
396 .Times(1).WillRepeatedly(Return(true)); | 399 .Times(1) |
| 400 .WillRepeatedly(Return(true)); |
397 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 401 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
398 } | 402 } |
399 | 403 |
400 // Add the delayed FEC packet. No packet should be reconstructed since the | 404 // Add the delayed FEC packet. No packet should be reconstructed since the |
401 // first media packet of that frame has been dropped due to being too old. | 405 // first media packet of that frame has been dropped due to being too old. |
402 BuildAndAddRedFecPacket(delayed_fec); | 406 BuildAndAddRedFecPacket(delayed_fec); |
403 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 407 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)).Times(0); |
404 .Times(0); | |
405 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 408 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
406 } | 409 } |
407 | 410 |
408 TEST_F(ReceiverFecTest, OldFecPacketDropped) { | 411 TEST_F(UlpfecReceiverTest, OldFecPacketDropped) { |
409 // 49 frames with 2 media packets and one FEC packet. All media packets | 412 // 49 frames with 2 media packets and one FEC packet. All media packets |
410 // missing. | 413 // missing. |
411 const size_t kNumMediaPackets = 49 * 2; | 414 const size_t kNumMediaPackets = 49 * 2; |
412 std::list<AugmentedPacket*> augmented_media_packets; | 415 std::list<AugmentedPacket*> augmented_media_packets; |
413 ForwardErrorCorrection::PacketList media_packets; | 416 ForwardErrorCorrection::PacketList media_packets; |
414 for (size_t i = 0; i < kNumMediaPackets / 2; ++i) { | 417 for (size_t i = 0; i < kNumMediaPackets / 2; ++i) { |
415 std::list<AugmentedPacket*> frame_augmented_media_packets; | 418 std::list<AugmentedPacket*> frame_augmented_media_packets; |
416 ForwardErrorCorrection::PacketList frame_media_packets; | 419 ForwardErrorCorrection::PacketList frame_media_packets; |
417 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 420 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
418 PacketizeFrame(2, 0, &frame_augmented_media_packets, &frame_media_packets); | 421 PacketizeFrame(2, 0, &frame_augmented_media_packets, &frame_media_packets); |
419 EncodeFec(frame_media_packets, 1, &fec_packets); | 422 EncodeFec(frame_media_packets, 1, &fec_packets); |
420 for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) { | 423 for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) { |
421 // Only FEC packets inserted. No packets recoverable at this time. | 424 // Only FEC packets inserted. No packets recoverable at this time. |
422 BuildAndAddRedFecPacket(*it); | 425 BuildAndAddRedFecPacket(*it); |
423 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 426 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)).Times(0); |
424 .Times(0); | |
425 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 427 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
426 } | 428 } |
427 // Move unique_ptr's to media_packets for lifetime management. | 429 // Move unique_ptr's to media_packets for lifetime management. |
428 media_packets.insert(media_packets.end(), | 430 media_packets.insert(media_packets.end(), |
429 std::make_move_iterator(frame_media_packets.begin()), | 431 std::make_move_iterator(frame_media_packets.begin()), |
430 std::make_move_iterator(frame_media_packets.end())); | 432 std::make_move_iterator(frame_media_packets.end())); |
431 augmented_media_packets.insert(augmented_media_packets.end(), | 433 augmented_media_packets.insert(augmented_media_packets.end(), |
432 frame_augmented_media_packets.begin(), | 434 frame_augmented_media_packets.begin(), |
433 frame_augmented_media_packets.end()); | 435 frame_augmented_media_packets.end()); |
434 } | 436 } |
435 // Insert the oldest media packet. The corresponding FEC packet is too old | 437 // Insert the oldest media packet. The corresponding FEC packet is too old |
436 // and should have been dropped. Only the media packet we inserted will be | 438 // and should have been dropped. Only the media packet we inserted will be |
437 // returned. | 439 // returned. |
438 BuildAndAddRedMediaPacket(augmented_media_packets.front()); | 440 BuildAndAddRedMediaPacket(augmented_media_packets.front()); |
439 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 441 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
440 .Times(1).WillRepeatedly(Return(true)); | 442 .Times(1) |
| 443 .WillRepeatedly(Return(true)); |
441 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 444 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
442 } | 445 } |
443 | 446 |
444 TEST_F(ReceiverFecTest, TruncatedPacketWithFBitSet) { | 447 TEST_F(UlpfecReceiverTest, TruncatedPacketWithFBitSet) { |
445 const uint8_t kTruncatedPacket[] = {0x80, | 448 const uint8_t kTruncatedPacket[] = {0x80, 0x2a, 0x68, 0x71, 0x29, 0xa1, 0x27, |
446 0x2a, | 449 0x3a, 0x29, 0x12, 0x2a, 0x98, 0xe0, 0x29}; |
447 0x68, | |
448 0x71, | |
449 0x29, | |
450 0xa1, | |
451 0x27, | |
452 0x3a, | |
453 0x29, | |
454 0x12, | |
455 0x2a, | |
456 0x98, | |
457 0xe0, | |
458 0x29}; | |
459 | 450 |
460 SurvivesMaliciousPacket(kTruncatedPacket, sizeof(kTruncatedPacket), 100); | 451 SurvivesMaliciousPacket(kTruncatedPacket, sizeof(kTruncatedPacket), 100); |
461 } | 452 } |
462 | 453 |
463 TEST_F(ReceiverFecTest, TruncatedPacketWithFBitSetEndingAfterFirstRedHeader) { | 454 TEST_F(UlpfecReceiverTest, |
464 const uint8_t kPacket[] = {0x89, | 455 TruncatedPacketWithFBitSetEndingAfterFirstRedHeader) { |
465 0x27, | 456 const uint8_t kPacket[] = { |
466 0x3a, | 457 0x89, 0x27, 0x3a, 0x83, 0x27, 0x3a, 0x3a, 0xf3, 0x67, 0xbe, 0x2a, |
467 0x83, | 458 0xa9, 0x27, 0x54, 0x3a, 0x3a, 0x2a, 0x67, 0x3a, 0xf3, 0x67, 0xbe, |
468 0x27, | 459 0x2a, 0x27, 0xe6, 0xf6, 0x03, 0x3e, 0x29, 0x27, 0x21, 0x27, 0x2a, |
469 0x3a, | 460 0x29, 0x21, 0x4b, 0x29, 0x3a, 0x28, 0x29, 0xbf, 0x29, 0x2a, 0x26, |
470 0x3a, | 461 0x29, 0xae, 0x27, 0xa6, 0xf6, 0x00, 0x03, 0x3e}; |
471 0xf3, | |
472 0x67, | |
473 0xbe, | |
474 0x2a, | |
475 0xa9, | |
476 0x27, | |
477 0x54, | |
478 0x3a, | |
479 0x3a, | |
480 0x2a, | |
481 0x67, | |
482 0x3a, | |
483 0xf3, | |
484 0x67, | |
485 0xbe, | |
486 0x2a, | |
487 0x27, | |
488 0xe6, | |
489 0xf6, | |
490 0x03, | |
491 0x3e, | |
492 0x29, | |
493 0x27, | |
494 0x21, | |
495 0x27, | |
496 0x2a, | |
497 0x29, | |
498 0x21, | |
499 0x4b, | |
500 0x29, | |
501 0x3a, | |
502 0x28, | |
503 0x29, | |
504 0xbf, | |
505 0x29, | |
506 0x2a, | |
507 0x26, | |
508 0x29, | |
509 0xae, | |
510 0x27, | |
511 0xa6, | |
512 0xf6, | |
513 0x00, | |
514 0x03, | |
515 0x3e}; | |
516 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100); | 462 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100); |
517 } | 463 } |
518 | 464 |
519 TEST_F(ReceiverFecTest, TruncatedPacketWithoutDataPastFirstBlock) { | 465 TEST_F(UlpfecReceiverTest, TruncatedPacketWithoutDataPastFirstBlock) { |
520 const uint8_t kPacket[] = {0x82, | 466 const uint8_t kPacket[] = { |
521 0x38, | 467 0x82, 0x38, 0x92, 0x38, 0x92, 0x38, 0xde, 0x2a, 0x11, 0xc8, 0xa3, 0xc4, |
522 0x92, | 468 0x82, 0x38, 0x2a, 0x21, 0x2a, 0x28, 0x92, 0x38, 0x92, 0x00, 0x00, 0x0a, |
523 0x38, | 469 0x3a, 0xc8, 0xa3, 0x3a, 0x27, 0xc4, 0x2a, 0x21, 0x2a, 0x28}; |
524 0x92, | |
525 0x38, | |
526 0xde, | |
527 0x2a, | |
528 0x11, | |
529 0xc8, | |
530 0xa3, | |
531 0xc4, | |
532 0x82, | |
533 0x38, | |
534 0x2a, | |
535 0x21, | |
536 0x2a, | |
537 0x28, | |
538 0x92, | |
539 0x38, | |
540 0x92, | |
541 0x00, | |
542 0x00, | |
543 0x0a, | |
544 0x3a, | |
545 0xc8, | |
546 0xa3, | |
547 0x3a, | |
548 0x27, | |
549 0xc4, | |
550 0x2a, | |
551 0x21, | |
552 0x2a, | |
553 0x28}; | |
554 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100); | 470 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100); |
555 } | 471 } |
556 | 472 |
557 } // namespace webrtc | 473 } // namespace webrtc |
OLD | NEW |