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 <list> | 11 #include <list> |
12 #include <memory> | 12 #include <memory> |
| 13 #include <utility> |
13 #include <vector> | 14 #include <vector> |
14 | 15 |
15 #include "webrtc/base/basictypes.h" | 16 #include "webrtc/base/basictypes.h" |
16 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 17 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
17 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" | 18 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" |
18 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" | 19 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
19 #include "webrtc/modules/rtp_rtcp/source/producer_fec.h" | 20 #include "webrtc/modules/rtp_rtcp/source/producer_fec.h" |
20 #include "webrtc/test/gtest.h" | 21 #include "webrtc/test/gtest.h" |
21 | 22 |
22 namespace webrtc { | 23 namespace webrtc { |
23 | 24 |
24 namespace { | 25 namespace { |
25 using test::fec::RawRtpPacket; | 26 using test::fec::AugmentedPacket; |
26 using test::fec::UlpfecPacketGenerator; | 27 using test::fec::AugmentedPacketGenerator; |
27 | 28 |
28 constexpr int kFecPayloadType = 96; | 29 constexpr int kFecPayloadType = 96; |
29 constexpr int kRedPayloadType = 97; | 30 constexpr int kRedPayloadType = 97; |
| 31 constexpr uint32_t kMediaSsrc = 835424; |
30 } // namespace | 32 } // namespace |
31 | 33 |
32 void VerifyHeader(uint16_t seq_num, | 34 void VerifyHeader(uint16_t seq_num, |
33 uint32_t timestamp, | 35 uint32_t timestamp, |
34 int red_payload_type, | 36 int red_payload_type, |
35 int fec_payload_type, | 37 int fec_payload_type, |
36 RedPacket* packet, | 38 RedPacket* packet, |
37 bool marker_bit) { | 39 bool marker_bit) { |
38 EXPECT_GT(packet->length(), kRtpHeaderSize); | 40 EXPECT_GT(packet->length(), kRtpHeaderSize); |
39 EXPECT_TRUE(packet->data() != NULL); | 41 EXPECT_TRUE(packet->data() != NULL); |
40 uint8_t* data = packet->data(); | 42 uint8_t* data = packet->data(); |
41 // Marker bit not set. | 43 // Marker bit not set. |
42 EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80); | 44 EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80); |
43 EXPECT_EQ(red_payload_type, data[1] & 0x7F); | 45 EXPECT_EQ(red_payload_type, data[1] & 0x7F); |
44 EXPECT_EQ(seq_num, (data[2] << 8) + data[3]); | 46 EXPECT_EQ(seq_num, (data[2] << 8) + data[3]); |
45 uint32_t parsed_timestamp = | 47 uint32_t parsed_timestamp = |
46 (data[4] << 24) + (data[5] << 16) + (data[6] << 8) + data[7]; | 48 (data[4] << 24) + (data[5] << 16) + (data[6] << 8) + data[7]; |
47 EXPECT_EQ(timestamp, parsed_timestamp); | 49 EXPECT_EQ(timestamp, parsed_timestamp); |
48 EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]); | 50 EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]); |
49 } | 51 } |
50 | 52 |
51 class ProducerFecTest : public ::testing::Test { | 53 class ProducerFecTest : public ::testing::Test { |
52 protected: | 54 protected: |
| 55 ProducerFecTest() : packet_generator_(kMediaSsrc) {} |
| 56 |
53 ProducerFec producer_; | 57 ProducerFec producer_; |
54 UlpfecPacketGenerator generator_; | 58 AugmentedPacketGenerator packet_generator_; |
55 }; | 59 }; |
56 | 60 |
57 // Verifies bug found via fuzzing, where a gap in the packet sequence caused us | 61 // Verifies bug found via fuzzing, where a gap in the packet sequence caused us |
58 // to move past the end of the current FEC packet mask byte without moving to | 62 // to move past the end of the current FEC packet mask byte without moving to |
59 // the next byte. That likely caused us to repeatedly read from the same byte, | 63 // the next byte. That likely caused us to repeatedly read from the same byte, |
60 // and if that byte didn't protect packets we would generate empty FEC. | 64 // and if that byte didn't protect packets we would generate empty FEC. |
61 TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { | 65 TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { |
62 struct Packet { | 66 struct Packet { |
63 size_t header_size; | 67 size_t header_size; |
64 size_t payload_size; | 68 size_t payload_size; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
99 | 103 |
100 TEST_F(ProducerFecTest, OneFrameFec) { | 104 TEST_F(ProducerFecTest, OneFrameFec) { |
101 // The number of media packets (|kNumPackets|), number of frames (one for | 105 // The number of media packets (|kNumPackets|), number of frames (one for |
102 // this test), and the protection factor (|params->fec_rate|) are set to make | 106 // this test), and the protection factor (|params->fec_rate|) are set to make |
103 // sure the conditions for generating FEC are satisfied. This means: | 107 // sure the conditions for generating FEC are satisfied. This means: |
104 // (1) protection factor is high enough so that actual overhead over 1 frame | 108 // (1) protection factor is high enough so that actual overhead over 1 frame |
105 // of packets is within |kMaxExcessOverhead|, and (2) the total number of | 109 // of packets is within |kMaxExcessOverhead|, and (2) the total number of |
106 // media packets for 1 frame is at least |minimum_media_packets_fec_|. | 110 // media packets for 1 frame is at least |minimum_media_packets_fec_|. |
107 constexpr size_t kNumPackets = 4; | 111 constexpr size_t kNumPackets = 4; |
108 FecProtectionParams params = {15, 3, kFecMaskRandom}; | 112 FecProtectionParams params = {15, 3, kFecMaskRandom}; |
109 std::list<RawRtpPacket*> rtp_packets; | 113 packet_generator_.NewFrame(kNumPackets); |
110 generator_.NewFrame(kNumPackets); | |
111 producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet. | 114 producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet. |
112 uint32_t last_timestamp = 0; | 115 uint32_t last_timestamp = 0; |
113 for (size_t i = 0; i < kNumPackets; ++i) { | 116 for (size_t i = 0; i < kNumPackets; ++i) { |
114 RawRtpPacket* rtp_packet = generator_.NextPacket(i, 10); | 117 std::unique_ptr<AugmentedPacket> packet = |
115 rtp_packets.push_back(rtp_packet); | 118 packet_generator_.NextPacket(i, 10); |
116 EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( | 119 EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( |
117 rtp_packet->data, rtp_packet->length, kRtpHeaderSize)); | 120 packet->data, packet->length, kRtpHeaderSize)); |
118 last_timestamp = rtp_packet->header.header.timestamp; | 121 last_timestamp = packet->header.header.timestamp; |
119 } | 122 } |
120 EXPECT_TRUE(producer_.FecAvailable()); | 123 EXPECT_TRUE(producer_.FecAvailable()); |
121 uint16_t seq_num = generator_.NextSeqNum(); | 124 uint16_t seq_num = packet_generator_.NextPacketSeqNum(); |
122 std::vector<std::unique_ptr<RedPacket>> packets = | 125 std::vector<std::unique_ptr<RedPacket>> red_packets = |
123 producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, | 126 producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, |
124 kRtpHeaderSize); | 127 kRtpHeaderSize); |
125 EXPECT_FALSE(producer_.FecAvailable()); | 128 EXPECT_FALSE(producer_.FecAvailable()); |
126 ASSERT_EQ(1u, packets.size()); | 129 ASSERT_EQ(1u, red_packets.size()); |
127 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, | 130 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, |
128 packets.front().get(), false); | 131 red_packets.front().get(), false); |
129 while (!rtp_packets.empty()) { | |
130 delete rtp_packets.front(); | |
131 rtp_packets.pop_front(); | |
132 } | |
133 } | 132 } |
134 | 133 |
135 TEST_F(ProducerFecTest, TwoFrameFec) { | 134 TEST_F(ProducerFecTest, TwoFrameFec) { |
136 // The number of media packets/frame (|kNumPackets|), the number of frames | 135 // The number of media packets/frame (|kNumPackets|), the number of frames |
137 // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to | 136 // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to |
138 // make sure the conditions for generating FEC are satisfied. This means: | 137 // make sure the conditions for generating FEC are satisfied. This means: |
139 // (1) protection factor is high enough so that actual overhead over | 138 // (1) protection factor is high enough so that actual overhead over |
140 // |kNumFrames| is within |kMaxExcessOverhead|, and (2) the total number of | 139 // |kNumFrames| is within |kMaxExcessOverhead|, and (2) the total number of |
141 // media packets for |kNumFrames| frames is at least | 140 // media packets for |kNumFrames| frames is at least |
142 // |minimum_media_packets_fec_|. | 141 // |minimum_media_packets_fec_|. |
143 constexpr size_t kNumPackets = 2; | 142 constexpr size_t kNumPackets = 2; |
144 constexpr size_t kNumFrames = 2; | 143 constexpr size_t kNumFrames = 2; |
145 | 144 |
146 FecProtectionParams params = {15, 3, kFecMaskRandom}; | 145 FecProtectionParams params = {15, 3, kFecMaskRandom}; |
147 std::list<RawRtpPacket*> rtp_packets; | |
148 producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet. | 146 producer_.SetFecParameters(¶ms, 0); // Expecting one FEC packet. |
149 uint32_t last_timestamp = 0; | 147 uint32_t last_timestamp = 0; |
150 for (size_t i = 0; i < kNumFrames; ++i) { | 148 for (size_t i = 0; i < kNumFrames; ++i) { |
151 generator_.NewFrame(kNumPackets); | 149 packet_generator_.NewFrame(kNumPackets); |
152 for (size_t j = 0; j < kNumPackets; ++j) { | 150 for (size_t j = 0; j < kNumPackets; ++j) { |
153 RawRtpPacket* rtp_packet = generator_.NextPacket(i * kNumPackets + j, 10); | 151 std::unique_ptr<AugmentedPacket> packet = |
154 rtp_packets.push_back(rtp_packet); | 152 packet_generator_.NextPacket(i * kNumPackets + j, 10); |
155 EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( | 153 EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( |
156 rtp_packet->data, rtp_packet->length, kRtpHeaderSize)); | 154 packet->data, packet->length, kRtpHeaderSize)); |
157 last_timestamp = rtp_packet->header.header.timestamp; | 155 last_timestamp = packet->header.header.timestamp; |
158 } | 156 } |
159 } | 157 } |
160 EXPECT_TRUE(producer_.FecAvailable()); | 158 EXPECT_TRUE(producer_.FecAvailable()); |
161 uint16_t seq_num = generator_.NextSeqNum(); | 159 uint16_t seq_num = packet_generator_.NextPacketSeqNum(); |
162 std::vector<std::unique_ptr<RedPacket>> packets = | 160 std::vector<std::unique_ptr<RedPacket>> red_packets = |
163 producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, | 161 producer_.GetFecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, |
164 kRtpHeaderSize); | 162 kRtpHeaderSize); |
165 EXPECT_FALSE(producer_.FecAvailable()); | 163 EXPECT_FALSE(producer_.FecAvailable()); |
166 ASSERT_EQ(1u, packets.size()); | 164 ASSERT_EQ(1u, red_packets.size()); |
167 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, | 165 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, |
168 packets.front().get(), false); | 166 red_packets.front().get(), false); |
169 while (!rtp_packets.empty()) { | |
170 delete rtp_packets.front(); | |
171 rtp_packets.pop_front(); | |
172 } | |
173 } | 167 } |
174 | 168 |
175 TEST_F(ProducerFecTest, BuildRedPacket) { | 169 TEST_F(ProducerFecTest, BuildRedPacket) { |
176 generator_.NewFrame(1); | 170 packet_generator_.NewFrame(1); |
177 RawRtpPacket* packet = generator_.NextPacket(0, 10); | 171 std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10); |
178 std::unique_ptr<RedPacket> red_packet = | 172 std::unique_ptr<RedPacket> red_packet = |
179 ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, | 173 ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, |
180 kRtpHeaderSize, kRedPayloadType); | 174 kRtpHeaderSize, kRedPayloadType); |
181 EXPECT_EQ(packet->length + 1, red_packet->length()); | 175 EXPECT_EQ(packet->length + 1, red_packet->length()); |
182 VerifyHeader(packet->header.header.sequenceNumber, | 176 VerifyHeader(packet->header.header.sequenceNumber, |
183 packet->header.header.timestamp, kRedPayloadType, | 177 packet->header.header.timestamp, kRedPayloadType, |
184 packet->header.header.payloadType, red_packet.get(), | 178 packet->header.header.payloadType, red_packet.get(), |
185 true); // Marker bit set. | 179 true); // Marker bit set. |
186 for (int i = 0; i < 10; ++i) { | 180 for (int i = 0; i < 10; ++i) { |
187 EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]); | 181 EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]); |
188 } | 182 } |
189 delete packet; | |
190 } | 183 } |
191 | 184 |
192 TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) { | 185 TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) { |
193 constexpr size_t kNumFrames = 1; | 186 constexpr size_t kNumFrames = 1; |
194 constexpr size_t kPayloadLength = 0; | 187 constexpr size_t kPayloadLength = 0; |
195 constexpr size_t kRedForFecHeaderLength = 1; | 188 constexpr size_t kRedForFecHeaderLength = 1; |
196 | 189 |
197 generator_.NewFrame(kNumFrames); | 190 packet_generator_.NewFrame(kNumFrames); |
198 std::unique_ptr<RawRtpPacket> packet( | 191 std::unique_ptr<AugmentedPacket> packet( |
199 generator_.NextPacket(0, kPayloadLength)); | 192 packet_generator_.NextPacket(0, kPayloadLength)); |
200 std::unique_ptr<RedPacket> red_packet = | 193 std::unique_ptr<RedPacket> red_packet = |
201 ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, | 194 ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, |
202 kRtpHeaderSize, kRedPayloadType); | 195 kRtpHeaderSize, kRedPayloadType); |
203 EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length()); | 196 EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length()); |
204 VerifyHeader(packet->header.header.sequenceNumber, | 197 VerifyHeader(packet->header.header.sequenceNumber, |
205 packet->header.header.timestamp, kRedPayloadType, | 198 packet->header.header.timestamp, kRedPayloadType, |
206 packet->header.header.payloadType, red_packet.get(), | 199 packet->header.header.payloadType, red_packet.get(), |
207 true); // Marker bit set. | 200 true); // Marker bit set. |
208 } | 201 } |
209 | 202 |
210 } // namespace webrtc | 203 } // namespace webrtc |
OLD | NEW |