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