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 |
(...skipping 14 matching lines...) Expand all Loading... | |
25 using ::testing::_; | 25 using ::testing::_; |
26 using ::testing::Args; | 26 using ::testing::Args; |
27 using ::testing::ElementsAreArray; | 27 using ::testing::ElementsAreArray; |
28 using ::testing::Return; | 28 using ::testing::Return; |
29 using Packet = webrtc::ForwardErrorCorrection::Packet; | 29 using Packet = webrtc::ForwardErrorCorrection::Packet; |
30 | 30 |
31 namespace webrtc { | 31 namespace webrtc { |
32 | 32 |
33 class ReceiverFecTest : public ::testing::Test { | 33 class ReceiverFecTest : public ::testing::Test { |
34 protected: | 34 protected: |
35 virtual void SetUp() { | 35 ReceiverFecTest() |
36 fec_.reset(new ForwardErrorCorrection()); | 36 : rtp_data_callback_(), |
danilchap
2016/08/22 13:00:41
it's cleaner to omit default constructions of memb
brandtr
2016/08/23 08:19:10
Done, see https://codereview.webrtc.org/2267393002
| |
37 receiver_fec_.reset(FecReceiver::Create(&rtp_data_callback_)); | 37 fec_(ForwardErrorCorrection::CreateUlpfec()), |
38 generator_.reset(new FrameGenerator()); | 38 receiver_fec_(FecReceiver::Create(&rtp_data_callback_)), |
39 } | 39 generator_() {} |
40 | 40 |
41 void GenerateFec(ForwardErrorCorrection::PacketList* media_packets, | 41 void EncodeFec(ForwardErrorCorrection::PacketList* media_packets, |
42 std::list<ForwardErrorCorrection::Packet*>* fec_packets, | 42 std::list<ForwardErrorCorrection::Packet*>* fec_packets, |
43 unsigned int num_fec_packets) { | 43 unsigned int num_fec_packets) { |
44 uint8_t protection_factor = num_fec_packets * 255 / media_packets->size(); | 44 uint8_t protection_factor = num_fec_packets * 255 / media_packets->size(); |
45 EXPECT_EQ(0, fec_->GenerateFec(*media_packets, protection_factor, | 45 EXPECT_EQ(0, fec_.EncodeFec(*media_packets, protection_factor, 0, false, |
46 0, false, kFecMaskBursty, fec_packets)); | 46 kFecMaskBursty, fec_packets)); |
47 ASSERT_EQ(num_fec_packets, fec_packets->size()); | 47 ASSERT_EQ(num_fec_packets, fec_packets->size()); |
48 } | 48 } |
49 | 49 |
50 void GenerateFrame(int num_media_packets, | 50 void GenerateFrame(int num_media_packets, |
51 int frame_offset, | 51 int frame_offset, |
52 std::list<test::RawRtpPacket*>* media_rtp_packets, | 52 std::list<test::fec::RawRtpPacket*>* media_rtp_packets, |
53 ForwardErrorCorrection::PacketList* media_packets) { | 53 ForwardErrorCorrection::PacketList* media_packets) { |
54 generator_->NewFrame(num_media_packets); | 54 generator_.NewFrame(num_media_packets); |
55 for (int i = 0; i < num_media_packets; ++i) { | 55 for (int i = 0; i < num_media_packets; ++i) { |
56 std::unique_ptr<test::RawRtpPacket> next_packet( | 56 std::unique_ptr<test::fec::RawRtpPacket> next_packet( |
57 generator_->NextPacket(frame_offset + i, kRtpHeaderSize + 10)); | 57 generator_.NextPacket(frame_offset + i, kRtpHeaderSize + 10)); |
58 media_rtp_packets->push_back(next_packet.get()); | 58 media_rtp_packets->push_back(next_packet.get()); |
59 media_packets->push_back(std::move(next_packet)); | 59 media_packets->push_back(std::move(next_packet)); |
60 } | 60 } |
61 } | 61 } |
62 | 62 |
63 void VerifyReconstructedMediaPacket(const test::RawRtpPacket* packet, | 63 void VerifyReconstructedMediaPacket(const test::fec::RawRtpPacket* packet, |
64 int times) { | 64 int times) { |
65 // Verify that the content of the reconstructed packet is equal to the | 65 // Verify that the content of the reconstructed packet is equal to the |
66 // content of |packet|, and that the same content is received |times| number | 66 // content of |packet|, and that the same content is received |times| number |
67 // of times in a row. | 67 // of times in a row. |
68 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet->length)) | 68 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, packet->length)) |
69 .With(Args<0, 1>(ElementsAreArray(packet->data, | 69 .With(Args<0, 1>(ElementsAreArray(packet->data, |
70 packet->length))) | 70 packet->length))) |
71 .Times(times).WillRepeatedly(Return(true)); | 71 .Times(times).WillRepeatedly(Return(true)); |
72 } | 72 } |
73 | 73 |
74 void BuildAndAddRedMediaPacket(test::RawRtpPacket* packet) { | 74 void BuildAndAddRedMediaPacket(test::fec::RawRtpPacket* packet) { |
75 std::unique_ptr<test::RawRtpPacket> red_packet( | 75 std::unique_ptr<test::fec::RawRtpPacket> red_packet( |
76 generator_->BuildMediaRedPacket(packet)); | 76 generator_.BuildMediaRedPacket(packet)); |
77 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( | 77 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( |
78 red_packet->header.header, red_packet->data, | 78 red_packet->header.header, red_packet->data, |
79 red_packet->length, kFecPayloadType)); | 79 red_packet->length, test::fec::kFecPayloadType)); |
80 } | 80 } |
81 | 81 |
82 void BuildAndAddRedFecPacket(Packet* packet) { | 82 void BuildAndAddRedFecPacket(Packet* packet) { |
83 std::unique_ptr<test::RawRtpPacket> red_packet( | 83 std::unique_ptr<test::fec::RawRtpPacket> red_packet( |
84 generator_->BuildFecRedPacket(packet)); | 84 generator_.BuildFecRedPacket(packet)); |
85 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( | 85 EXPECT_EQ(0, receiver_fec_->AddReceivedRedPacket( |
86 red_packet->header.header, red_packet->data, | 86 red_packet->header.header, red_packet->data, |
87 red_packet->length, kFecPayloadType)); | 87 red_packet->length, test::fec::kFecPayloadType)); |
88 } | 88 } |
89 | 89 |
90 void InjectGarbagePacketLength(size_t fec_garbage_offset); | 90 void InjectGarbagePacketLength(size_t fec_garbage_offset); |
91 static void SurvivesMaliciousPacket(const uint8_t* data, | 91 static void SurvivesMaliciousPacket(const uint8_t* data, |
92 size_t length, | 92 size_t length, |
93 uint8_t ulpfec_payload_type); | 93 uint8_t ulpfec_payload_type); |
94 | 94 |
95 MockRtpData rtp_data_callback_; | 95 MockRtpData rtp_data_callback_; |
96 std::unique_ptr<ForwardErrorCorrection> fec_; | 96 ForwardErrorCorrection fec_; |
97 std::unique_ptr<FecReceiver> receiver_fec_; | 97 std::unique_ptr<FecReceiver> receiver_fec_; |
98 std::unique_ptr<FrameGenerator> generator_; | 98 test::fec::FrameGenerator generator_; |
99 }; | 99 }; |
100 | 100 |
101 TEST_F(ReceiverFecTest, TwoMediaOneFec) { | 101 TEST_F(ReceiverFecTest, TwoMediaOneFec) { |
102 const unsigned int kNumFecPackets = 1u; | 102 const unsigned int kNumFecPackets = 1u; |
103 std::list<test::RawRtpPacket*> media_rtp_packets; | 103 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
104 ForwardErrorCorrection::PacketList media_packets; | 104 ForwardErrorCorrection::PacketList media_packets; |
105 GenerateFrame(2, 0, &media_rtp_packets, &media_packets); | 105 GenerateFrame(2, 0, &media_rtp_packets, &media_packets); |
106 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 106 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
107 GenerateFec(&media_packets, &fec_packets, kNumFecPackets); | 107 EncodeFec(&media_packets, &fec_packets, kNumFecPackets); |
108 | 108 |
109 // Recovery | 109 // Recovery |
110 auto it = media_rtp_packets.begin(); | 110 auto it = media_rtp_packets.begin(); |
111 BuildAndAddRedMediaPacket(*it); | 111 BuildAndAddRedMediaPacket(*it); |
112 VerifyReconstructedMediaPacket(*it, 1); | 112 VerifyReconstructedMediaPacket(*it, 1); |
113 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 113 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
114 // Drop one media packet. | 114 // Drop one media packet. |
115 auto fec_it = fec_packets.begin(); | 115 auto fec_it = fec_packets.begin(); |
116 BuildAndAddRedFecPacket(*fec_it); | 116 BuildAndAddRedFecPacket(*fec_it); |
117 ++it; | 117 ++it; |
118 VerifyReconstructedMediaPacket(*it, 1); | 118 VerifyReconstructedMediaPacket(*it, 1); |
119 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 119 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
120 | 120 |
121 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); | 121 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); |
122 EXPECT_EQ(2U, counter.num_packets); | 122 EXPECT_EQ(2U, counter.num_packets); |
123 EXPECT_EQ(1U, counter.num_fec_packets); | 123 EXPECT_EQ(1U, counter.num_fec_packets); |
124 EXPECT_EQ(1U, counter.num_recovered_packets); | 124 EXPECT_EQ(1U, counter.num_recovered_packets); |
125 } | 125 } |
126 | 126 |
127 void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { | 127 void ReceiverFecTest::InjectGarbagePacketLength(size_t fec_garbage_offset) { |
128 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 128 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
129 .WillRepeatedly(Return(true)); | 129 .WillRepeatedly(Return(true)); |
130 | 130 |
131 const unsigned int kNumFecPackets = 1u; | 131 const unsigned int kNumFecPackets = 1u; |
132 std::list<test::RawRtpPacket*> media_rtp_packets; | 132 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
133 ForwardErrorCorrection::PacketList media_packets; | 133 ForwardErrorCorrection::PacketList media_packets; |
134 GenerateFrame(2, 0, &media_rtp_packets, &media_packets); | 134 GenerateFrame(2, 0, &media_rtp_packets, &media_packets); |
135 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 135 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
136 GenerateFec(&media_packets, &fec_packets, kNumFecPackets); | 136 EncodeFec(&media_packets, &fec_packets, kNumFecPackets); |
137 ByteWriter<uint16_t>::WriteBigEndian( | 137 ByteWriter<uint16_t>::WriteBigEndian( |
138 &fec_packets.front()->data[fec_garbage_offset], 0x4711); | 138 &fec_packets.front()->data[fec_garbage_offset], 0x4711); |
139 | 139 |
140 // Inject first media packet, then first FEC packet, skipping the second media | 140 // Inject first media packet, then first FEC packet, skipping the second media |
141 // packet to cause a recovery from the FEC packet. | 141 // packet to cause a recovery from the FEC packet. |
142 BuildAndAddRedMediaPacket(media_rtp_packets.front()); | 142 BuildAndAddRedMediaPacket(media_rtp_packets.front()); |
143 BuildAndAddRedFecPacket(fec_packets.front()); | 143 BuildAndAddRedFecPacket(fec_packets.front()); |
144 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 144 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
145 | 145 |
146 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); | 146 FecPacketCounter counter = receiver_fec_->GetPacketCounter(); |
147 EXPECT_EQ(2u, counter.num_packets); | 147 EXPECT_EQ(2u, counter.num_packets); |
148 EXPECT_EQ(1u, counter.num_fec_packets); | 148 EXPECT_EQ(1u, counter.num_fec_packets); |
149 EXPECT_EQ(0u, counter.num_recovered_packets); | 149 EXPECT_EQ(0u, counter.num_recovered_packets); |
150 } | 150 } |
151 | 151 |
152 TEST_F(ReceiverFecTest, InjectGarbageFecHeaderLengthRecovery) { | 152 TEST_F(ReceiverFecTest, InjectGarbageFecHeaderLengthRecovery) { |
153 // Byte offset 8 is the 'length recovery' field of the FEC header. | 153 // Byte offset 8 is the 'length recovery' field of the FEC header. |
154 InjectGarbagePacketLength(8); | 154 InjectGarbagePacketLength(8); |
155 } | 155 } |
156 | 156 |
157 TEST_F(ReceiverFecTest, InjectGarbageFecLevelHeaderProtectionLength) { | 157 TEST_F(ReceiverFecTest, InjectGarbageFecLevelHeaderProtectionLength) { |
158 // Byte offset 10 is the 'protection length' field in the first FEC level | 158 // Byte offset 10 is the 'protection length' field in the first FEC level |
159 // header. | 159 // header. |
160 InjectGarbagePacketLength(10); | 160 InjectGarbagePacketLength(10); |
161 } | 161 } |
162 | 162 |
163 TEST_F(ReceiverFecTest, TwoMediaTwoFec) { | 163 TEST_F(ReceiverFecTest, TwoMediaTwoFec) { |
164 const unsigned int kNumFecPackets = 2u; | 164 const unsigned int kNumFecPackets = 2u; |
165 std::list<test::RawRtpPacket*> media_rtp_packets; | 165 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
166 ForwardErrorCorrection::PacketList media_packets; | 166 ForwardErrorCorrection::PacketList media_packets; |
167 GenerateFrame(2, 0, &media_rtp_packets, &media_packets); | 167 GenerateFrame(2, 0, &media_rtp_packets, &media_packets); |
168 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 168 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
169 GenerateFec(&media_packets, &fec_packets, kNumFecPackets); | 169 EncodeFec(&media_packets, &fec_packets, kNumFecPackets); |
170 | 170 |
171 // Recovery | 171 // Recovery |
172 // Drop both media packets. | 172 // Drop both media packets. |
173 auto it = media_rtp_packets.begin(); | 173 auto it = media_rtp_packets.begin(); |
174 auto fec_it = fec_packets.begin(); | 174 auto fec_it = fec_packets.begin(); |
175 BuildAndAddRedFecPacket(*fec_it); | 175 BuildAndAddRedFecPacket(*fec_it); |
176 VerifyReconstructedMediaPacket(*it, 1); | 176 VerifyReconstructedMediaPacket(*it, 1); |
177 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 177 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
178 ++fec_it; | 178 ++fec_it; |
179 BuildAndAddRedFecPacket(*fec_it); | 179 BuildAndAddRedFecPacket(*fec_it); |
180 ++it; | 180 ++it; |
181 VerifyReconstructedMediaPacket(*it, 1); | 181 VerifyReconstructedMediaPacket(*it, 1); |
182 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 182 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
183 } | 183 } |
184 | 184 |
185 TEST_F(ReceiverFecTest, TwoFramesOneFec) { | 185 TEST_F(ReceiverFecTest, TwoFramesOneFec) { |
186 const unsigned int kNumFecPackets = 1u; | 186 const unsigned int kNumFecPackets = 1u; |
187 std::list<test::RawRtpPacket*> media_rtp_packets; | 187 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
188 ForwardErrorCorrection::PacketList media_packets; | 188 ForwardErrorCorrection::PacketList media_packets; |
189 GenerateFrame(1, 0, &media_rtp_packets, &media_packets); | 189 GenerateFrame(1, 0, &media_rtp_packets, &media_packets); |
190 GenerateFrame(1, 1, &media_rtp_packets, &media_packets); | 190 GenerateFrame(1, 1, &media_rtp_packets, &media_packets); |
191 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 191 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
192 GenerateFec(&media_packets, &fec_packets, kNumFecPackets); | 192 EncodeFec(&media_packets, &fec_packets, kNumFecPackets); |
193 | 193 |
194 // Recovery | 194 // Recovery |
195 auto it = media_rtp_packets.begin(); | 195 auto it = media_rtp_packets.begin(); |
196 BuildAndAddRedMediaPacket(media_rtp_packets.front()); | 196 BuildAndAddRedMediaPacket(media_rtp_packets.front()); |
197 VerifyReconstructedMediaPacket(*it, 1); | 197 VerifyReconstructedMediaPacket(*it, 1); |
198 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 198 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
199 // Drop one media packet. | 199 // Drop one media packet. |
200 BuildAndAddRedFecPacket(fec_packets.front()); | 200 BuildAndAddRedFecPacket(fec_packets.front()); |
201 ++it; | 201 ++it; |
202 VerifyReconstructedMediaPacket(*it, 1); | 202 VerifyReconstructedMediaPacket(*it, 1); |
203 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 203 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
204 } | 204 } |
205 | 205 |
206 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) { | 206 TEST_F(ReceiverFecTest, OneCompleteOneUnrecoverableFrame) { |
207 const unsigned int kNumFecPackets = 1u; | 207 const unsigned int kNumFecPackets = 1u; |
208 std::list<test::RawRtpPacket*> media_rtp_packets; | 208 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
209 ForwardErrorCorrection::PacketList media_packets; | 209 ForwardErrorCorrection::PacketList media_packets; |
210 GenerateFrame(1, 0, &media_rtp_packets, &media_packets); | 210 GenerateFrame(1, 0, &media_rtp_packets, &media_packets); |
211 GenerateFrame(2, 1, &media_rtp_packets, &media_packets); | 211 GenerateFrame(2, 1, &media_rtp_packets, &media_packets); |
212 | 212 |
213 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 213 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
214 GenerateFec(&media_packets, &fec_packets, kNumFecPackets); | 214 EncodeFec(&media_packets, &fec_packets, kNumFecPackets); |
215 | 215 |
216 // Recovery | 216 // Recovery |
217 auto it = media_rtp_packets.begin(); | 217 auto it = media_rtp_packets.begin(); |
218 BuildAndAddRedMediaPacket(*it); // First frame: one packet. | 218 BuildAndAddRedMediaPacket(*it); // First frame: one packet. |
219 VerifyReconstructedMediaPacket(*it, 1); | 219 VerifyReconstructedMediaPacket(*it, 1); |
220 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 220 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
221 ++it; | 221 ++it; |
222 BuildAndAddRedMediaPacket(*it); // First packet of second frame. | 222 BuildAndAddRedMediaPacket(*it); // First packet of second frame. |
223 VerifyReconstructedMediaPacket(*it, 1); | 223 VerifyReconstructedMediaPacket(*it, 1); |
224 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 224 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
225 } | 225 } |
226 | 226 |
227 TEST_F(ReceiverFecTest, MaxFramesOneFec) { | 227 TEST_F(ReceiverFecTest, MaxFramesOneFec) { |
228 const unsigned int kNumFecPackets = 1u; | 228 const unsigned int kNumFecPackets = 1u; |
229 const unsigned int kNumMediaPackets = 48u; | 229 const unsigned int kNumMediaPackets = 48u; |
230 std::list<test::RawRtpPacket*> media_rtp_packets; | 230 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
231 ForwardErrorCorrection::PacketList media_packets; | 231 ForwardErrorCorrection::PacketList media_packets; |
232 for (unsigned int i = 0; i < kNumMediaPackets; ++i) { | 232 for (unsigned int i = 0; i < kNumMediaPackets; ++i) { |
233 GenerateFrame(1, i, &media_rtp_packets, &media_packets); | 233 GenerateFrame(1, i, &media_rtp_packets, &media_packets); |
234 } | 234 } |
235 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 235 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
236 GenerateFec(&media_packets, &fec_packets, kNumFecPackets); | 236 EncodeFec(&media_packets, &fec_packets, kNumFecPackets); |
237 | 237 |
238 // Recovery | 238 // Recovery |
239 auto it = media_rtp_packets.begin(); | 239 auto it = media_rtp_packets.begin(); |
240 ++it; // Drop first packet. | 240 ++it; // Drop first packet. |
241 for (; it != media_rtp_packets.end(); ++it) { | 241 for (; it != media_rtp_packets.end(); ++it) { |
242 BuildAndAddRedMediaPacket(*it); | 242 BuildAndAddRedMediaPacket(*it); |
243 VerifyReconstructedMediaPacket(*it, 1); | 243 VerifyReconstructedMediaPacket(*it, 1); |
244 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 244 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
245 } | 245 } |
246 BuildAndAddRedFecPacket(fec_packets.front()); | 246 BuildAndAddRedFecPacket(fec_packets.front()); |
247 it = media_rtp_packets.begin(); | 247 it = media_rtp_packets.begin(); |
248 VerifyReconstructedMediaPacket(*it, 1); | 248 VerifyReconstructedMediaPacket(*it, 1); |
249 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 249 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
250 } | 250 } |
251 | 251 |
252 TEST_F(ReceiverFecTest, TooManyFrames) { | 252 TEST_F(ReceiverFecTest, TooManyFrames) { |
253 const unsigned int kNumFecPackets = 1u; | 253 const unsigned int kNumFecPackets = 1u; |
254 const unsigned int kNumMediaPackets = 49u; | 254 const unsigned int kNumMediaPackets = 49u; |
255 std::list<test::RawRtpPacket*> media_rtp_packets; | 255 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
256 ForwardErrorCorrection::PacketList media_packets; | 256 ForwardErrorCorrection::PacketList media_packets; |
257 for (unsigned int i = 0; i < kNumMediaPackets; ++i) { | 257 for (unsigned int i = 0; i < kNumMediaPackets; ++i) { |
258 GenerateFrame(1, i, &media_rtp_packets, &media_packets); | 258 GenerateFrame(1, i, &media_rtp_packets, &media_packets); |
259 } | 259 } |
260 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 260 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
261 EXPECT_EQ(-1, fec_->GenerateFec(media_packets, | 261 EXPECT_EQ( |
262 kNumFecPackets * 255 / kNumMediaPackets, 0, | 262 -1, fec_.EncodeFec(media_packets, kNumFecPackets * 255 / kNumMediaPackets, |
263 false, kFecMaskBursty, &fec_packets)); | 263 0, false, kFecMaskBursty, &fec_packets)); |
264 } | 264 } |
265 | 265 |
266 TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) { | 266 TEST_F(ReceiverFecTest, PacketNotDroppedTooEarly) { |
267 // 1 frame with 2 media packets and one FEC packet. One media packet missing. | 267 // 1 frame with 2 media packets and one FEC packet. One media packet missing. |
268 // Delay the FEC packet. | 268 // Delay the FEC packet. |
269 Packet* delayed_fec = NULL; | 269 Packet* delayed_fec = NULL; |
270 const unsigned int kNumFecPacketsBatch1 = 1u; | 270 const unsigned int kNumFecPacketsBatch1 = 1u; |
271 const unsigned int kNumMediaPacketsBatch1 = 2u; | 271 const unsigned int kNumMediaPacketsBatch1 = 2u; |
272 std::list<test::RawRtpPacket*> media_rtp_packets_batch1; | 272 std::list<test::fec::RawRtpPacket*> media_rtp_packets_batch1; |
273 ForwardErrorCorrection::PacketList media_packets_batch1; | 273 ForwardErrorCorrection::PacketList media_packets_batch1; |
274 GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1, | 274 GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1, |
275 &media_packets_batch1); | 275 &media_packets_batch1); |
276 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 276 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
277 GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); | 277 EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); |
278 | 278 |
279 BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front()); | 279 BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front()); |
280 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 280 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
281 .Times(1).WillRepeatedly(Return(true)); | 281 .Times(1).WillRepeatedly(Return(true)); |
282 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 282 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
283 delayed_fec = fec_packets.front(); | 283 delayed_fec = fec_packets.front(); |
284 | 284 |
285 // Fill the FEC decoder. No packets should be dropped. | 285 // Fill the FEC decoder. No packets should be dropped. |
286 const unsigned int kNumMediaPacketsBatch2 = 46u; | 286 const unsigned int kNumMediaPacketsBatch2 = 46u; |
287 std::list<test::RawRtpPacket*> media_rtp_packets_batch2; | 287 std::list<test::fec::RawRtpPacket*> media_rtp_packets_batch2; |
288 ForwardErrorCorrection::PacketList media_packets_batch2; | 288 ForwardErrorCorrection::PacketList media_packets_batch2; |
289 for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) { | 289 for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) { |
290 GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2); | 290 GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2); |
291 } | 291 } |
292 for (auto it = media_rtp_packets_batch2.begin(); | 292 for (auto it = media_rtp_packets_batch2.begin(); |
293 it != media_rtp_packets_batch2.end(); ++it) { | 293 it != media_rtp_packets_batch2.end(); ++it) { |
294 BuildAndAddRedMediaPacket(*it); | 294 BuildAndAddRedMediaPacket(*it); |
295 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 295 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
296 .Times(1).WillRepeatedly(Return(true)); | 296 .Times(1).WillRepeatedly(Return(true)); |
297 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 297 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
298 } | 298 } |
299 | 299 |
300 // Add the delayed FEC packet. One packet should be reconstructed. | 300 // Add the delayed FEC packet. One packet should be reconstructed. |
301 BuildAndAddRedFecPacket(delayed_fec); | 301 BuildAndAddRedFecPacket(delayed_fec); |
302 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 302 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
303 .Times(1).WillRepeatedly(Return(true)); | 303 .Times(1).WillRepeatedly(Return(true)); |
304 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 304 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
305 } | 305 } |
306 | 306 |
307 TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) { | 307 TEST_F(ReceiverFecTest, PacketDroppedWhenTooOld) { |
308 // 1 frame with 2 media packets and one FEC packet. One media packet missing. | 308 // 1 frame with 2 media packets and one FEC packet. One media packet missing. |
309 // Delay the FEC packet. | 309 // Delay the FEC packet. |
310 Packet* delayed_fec = NULL; | 310 Packet* delayed_fec = NULL; |
311 const unsigned int kNumFecPacketsBatch1 = 1u; | 311 const unsigned int kNumFecPacketsBatch1 = 1u; |
312 const unsigned int kNumMediaPacketsBatch1 = 2u; | 312 const unsigned int kNumMediaPacketsBatch1 = 2u; |
313 std::list<test::RawRtpPacket*> media_rtp_packets_batch1; | 313 std::list<test::fec::RawRtpPacket*> media_rtp_packets_batch1; |
314 ForwardErrorCorrection::PacketList media_packets_batch1; | 314 ForwardErrorCorrection::PacketList media_packets_batch1; |
315 GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1, | 315 GenerateFrame(kNumMediaPacketsBatch1, 0, &media_rtp_packets_batch1, |
316 &media_packets_batch1); | 316 &media_packets_batch1); |
317 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 317 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
318 GenerateFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); | 318 EncodeFec(&media_packets_batch1, &fec_packets, kNumFecPacketsBatch1); |
319 | 319 |
320 BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front()); | 320 BuildAndAddRedMediaPacket(media_rtp_packets_batch1.front()); |
321 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 321 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
322 .Times(1).WillRepeatedly(Return(true)); | 322 .Times(1).WillRepeatedly(Return(true)); |
323 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 323 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
324 delayed_fec = fec_packets.front(); | 324 delayed_fec = fec_packets.front(); |
325 | 325 |
326 // Fill the FEC decoder and force the last packet to be dropped. | 326 // Fill the FEC decoder and force the last packet to be dropped. |
327 const unsigned int kNumMediaPacketsBatch2 = 48u; | 327 const unsigned int kNumMediaPacketsBatch2 = 48u; |
328 std::list<test::RawRtpPacket*> media_rtp_packets_batch2; | 328 std::list<test::fec::RawRtpPacket*> media_rtp_packets_batch2; |
329 ForwardErrorCorrection::PacketList media_packets_batch2; | 329 ForwardErrorCorrection::PacketList media_packets_batch2; |
330 for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) { | 330 for (unsigned int i = 0; i < kNumMediaPacketsBatch2; ++i) { |
331 GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2); | 331 GenerateFrame(1, i, &media_rtp_packets_batch2, &media_packets_batch2); |
332 } | 332 } |
333 for (auto it = media_rtp_packets_batch2.begin(); | 333 for (auto it = media_rtp_packets_batch2.begin(); |
334 it != media_rtp_packets_batch2.end(); ++it) { | 334 it != media_rtp_packets_batch2.end(); ++it) { |
335 BuildAndAddRedMediaPacket(*it); | 335 BuildAndAddRedMediaPacket(*it); |
336 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 336 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
337 .Times(1).WillRepeatedly(Return(true)); | 337 .Times(1).WillRepeatedly(Return(true)); |
338 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 338 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
339 } | 339 } |
340 | 340 |
341 // Add the delayed FEC packet. No packet should be reconstructed since the | 341 // Add the delayed FEC packet. No packet should be reconstructed since the |
342 // first media packet of that frame has been dropped due to being too old. | 342 // first media packet of that frame has been dropped due to being too old. |
343 BuildAndAddRedFecPacket(delayed_fec); | 343 BuildAndAddRedFecPacket(delayed_fec); |
344 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 344 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
345 .Times(0); | 345 .Times(0); |
346 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 346 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
347 } | 347 } |
348 | 348 |
349 TEST_F(ReceiverFecTest, OldFecPacketDropped) { | 349 TEST_F(ReceiverFecTest, OldFecPacketDropped) { |
350 // 49 frames with 2 media packets and one FEC packet. All media packets | 350 // 49 frames with 2 media packets and one FEC packet. All media packets |
351 // missing. | 351 // missing. |
352 const unsigned int kNumMediaPackets = 49 * 2; | 352 const unsigned int kNumMediaPackets = 49 * 2; |
353 std::list<test::RawRtpPacket*> media_rtp_packets; | 353 std::list<test::fec::RawRtpPacket*> media_rtp_packets; |
354 ForwardErrorCorrection::PacketList media_packets; | 354 ForwardErrorCorrection::PacketList media_packets; |
355 for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) { | 355 for (unsigned int i = 0; i < kNumMediaPackets / 2; ++i) { |
356 std::list<test::RawRtpPacket*> frame_media_rtp_packets; | 356 std::list<test::fec::RawRtpPacket*> frame_media_rtp_packets; |
357 ForwardErrorCorrection::PacketList frame_media_packets; | 357 ForwardErrorCorrection::PacketList frame_media_packets; |
358 std::list<ForwardErrorCorrection::Packet*> fec_packets; | 358 std::list<ForwardErrorCorrection::Packet*> fec_packets; |
359 GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets); | 359 GenerateFrame(2, 0, &frame_media_rtp_packets, &frame_media_packets); |
360 GenerateFec(&frame_media_packets, &fec_packets, 1); | 360 EncodeFec(&frame_media_packets, &fec_packets, 1); |
361 for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) { | 361 for (auto it = fec_packets.begin(); it != fec_packets.end(); ++it) { |
362 // Only FEC packets inserted. No packets recoverable at this time. | 362 // Only FEC packets inserted. No packets recoverable at this time. |
363 BuildAndAddRedFecPacket(*it); | 363 BuildAndAddRedFecPacket(*it); |
364 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) | 364 EXPECT_CALL(rtp_data_callback_, OnRecoveredPacket(_, _)) |
365 .Times(0); | 365 .Times(0); |
366 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); | 366 EXPECT_EQ(0, receiver_fec_->ProcessReceivedFec()); |
367 } | 367 } |
368 // Move unique_ptr's to media_packets for lifetime management. | 368 // Move unique_ptr's to media_packets for lifetime management. |
369 media_packets.insert(media_packets.end(), | 369 media_packets.insert(media_packets.end(), |
370 std::make_move_iterator(frame_media_packets.begin()), | 370 std::make_move_iterator(frame_media_packets.begin()), |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
504 0x27, | 504 0x27, |
505 0xc4, | 505 0xc4, |
506 0x2a, | 506 0x2a, |
507 0x21, | 507 0x21, |
508 0x2a, | 508 0x2a, |
509 0x28}; | 509 0x28}; |
510 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100); | 510 SurvivesMaliciousPacket(kPacket, sizeof(kPacket), 100); |
511 } | 511 } |
512 | 512 |
513 } // namespace webrtc | 513 } // namespace webrtc |
OLD | NEW |