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 <utility> |
14 #include <vector> | 14 #include <vector> |
15 | 15 |
16 #include "webrtc/base/basictypes.h" | 16 #include "webrtc/base/basictypes.h" |
17 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 17 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
18 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" | 18 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" |
19 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" | 19 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
20 #include "webrtc/modules/rtp_rtcp/source/producer_fec.h" | 20 #include "webrtc/modules/rtp_rtcp/source/ulpfec_generator.h" |
21 #include "webrtc/test/gtest.h" | 21 #include "webrtc/test/gtest.h" |
22 | 22 |
23 namespace webrtc { | 23 namespace webrtc { |
24 | 24 |
25 namespace { | 25 namespace { |
26 using test::fec::AugmentedPacket; | 26 using test::fec::AugmentedPacket; |
27 using test::fec::AugmentedPacketGenerator; | 27 using test::fec::AugmentedPacketGenerator; |
28 | 28 |
29 constexpr int kFecPayloadType = 96; | 29 constexpr int kFecPayloadType = 96; |
30 constexpr int kRedPayloadType = 97; | 30 constexpr int kRedPayloadType = 97; |
(...skipping 12 matching lines...) Expand all Loading... |
43 // Marker bit not set. | 43 // Marker bit not set. |
44 EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80); | 44 EXPECT_EQ(marker_bit ? 0x80 : 0, data[1] & 0x80); |
45 EXPECT_EQ(red_payload_type, data[1] & 0x7F); | 45 EXPECT_EQ(red_payload_type, data[1] & 0x7F); |
46 EXPECT_EQ(seq_num, (data[2] << 8) + data[3]); | 46 EXPECT_EQ(seq_num, (data[2] << 8) + data[3]); |
47 uint32_t parsed_timestamp = | 47 uint32_t parsed_timestamp = |
48 (data[4] << 24) + (data[5] << 16) + (data[6] << 8) + data[7]; | 48 (data[4] << 24) + (data[5] << 16) + (data[6] << 8) + data[7]; |
49 EXPECT_EQ(timestamp, parsed_timestamp); | 49 EXPECT_EQ(timestamp, parsed_timestamp); |
50 EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]); | 50 EXPECT_EQ(static_cast<uint8_t>(fec_payload_type), data[kRtpHeaderSize]); |
51 } | 51 } |
52 | 52 |
53 class ProducerFecTest : public ::testing::Test { | 53 class UlpfecGeneratorTest : public ::testing::Test { |
54 protected: | 54 protected: |
55 ProducerFecTest() : packet_generator_(kMediaSsrc) {} | 55 UlpfecGeneratorTest() : packet_generator_(kMediaSsrc) {} |
56 | 56 |
57 ProducerFec producer_; | 57 UlpfecGenerator ulpfec_generator_; |
58 AugmentedPacketGenerator packet_generator_; | 58 AugmentedPacketGenerator packet_generator_; |
59 }; | 59 }; |
60 | 60 |
61 // 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 |
62 // 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 |
63 // 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, |
64 // 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. |
65 TEST_F(ProducerFecTest, NoEmptyFecWithSeqNumGaps) { | 65 TEST_F(UlpfecGeneratorTest, NoEmptyFecWithSeqNumGaps) { |
66 struct Packet { | 66 struct Packet { |
67 size_t header_size; | 67 size_t header_size; |
68 size_t payload_size; | 68 size_t payload_size; |
69 uint16_t seq_num; | 69 uint16_t seq_num; |
70 bool marker_bit; | 70 bool marker_bit; |
71 }; | 71 }; |
72 std::vector<Packet> protected_packets; | 72 std::vector<Packet> protected_packets; |
73 protected_packets.push_back({15, 3, 41, 0}); | 73 protected_packets.push_back({15, 3, 41, 0}); |
74 protected_packets.push_back({14, 1, 43, 0}); | 74 protected_packets.push_back({14, 1, 43, 0}); |
75 protected_packets.push_back({19, 0, 48, 0}); | 75 protected_packets.push_back({19, 0, 48, 0}); |
76 protected_packets.push_back({19, 0, 50, 0}); | 76 protected_packets.push_back({19, 0, 50, 0}); |
77 protected_packets.push_back({14, 3, 51, 0}); | 77 protected_packets.push_back({14, 3, 51, 0}); |
78 protected_packets.push_back({13, 8, 52, 0}); | 78 protected_packets.push_back({13, 8, 52, 0}); |
79 protected_packets.push_back({19, 2, 53, 0}); | 79 protected_packets.push_back({19, 2, 53, 0}); |
80 protected_packets.push_back({12, 3, 54, 0}); | 80 protected_packets.push_back({12, 3, 54, 0}); |
81 protected_packets.push_back({21, 0, 55, 0}); | 81 protected_packets.push_back({21, 0, 55, 0}); |
82 protected_packets.push_back({13, 3, 57, 1}); | 82 protected_packets.push_back({13, 3, 57, 1}); |
83 FecProtectionParams params = {117, 3, kFecMaskBursty}; | 83 FecProtectionParams params = {117, 3, kFecMaskBursty}; |
84 producer_.SetFecParameters(¶ms); | 84 ulpfec_generator_.SetFecParameters(¶ms); |
85 uint8_t packet[28] = {0}; | 85 uint8_t packet[28] = {0}; |
86 for (Packet p : protected_packets) { | 86 for (Packet p : protected_packets) { |
87 if (p.marker_bit) { | 87 if (p.marker_bit) { |
88 packet[1] |= 0x80; | 88 packet[1] |= 0x80; |
89 } else { | 89 } else { |
90 packet[1] &= ~0x80; | 90 packet[1] &= ~0x80; |
91 } | 91 } |
92 ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num); | 92 ByteWriter<uint16_t>::WriteBigEndian(&packet[2], p.seq_num); |
93 producer_.AddRtpPacketAndGenerateFec(packet, p.payload_size, p.header_size); | 93 ulpfec_generator_.AddRtpPacketAndGenerateFec(packet, p.payload_size, |
94 size_t num_fec_packets = producer_.NumAvailableFecPackets(); | 94 p.header_size); |
| 95 size_t num_fec_packets = ulpfec_generator_.NumAvailableFecPackets(); |
95 if (num_fec_packets > 0) { | 96 if (num_fec_packets > 0) { |
96 std::vector<std::unique_ptr<RedPacket>> fec_packets = | 97 std::vector<std::unique_ptr<RedPacket>> fec_packets = |
97 producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, 100, | 98 ulpfec_generator_.GetUlpfecPacketsAsRed( |
98 p.header_size); | 99 kRedPayloadType, kFecPayloadType, 100, p.header_size); |
99 EXPECT_EQ(num_fec_packets, fec_packets.size()); | 100 EXPECT_EQ(num_fec_packets, fec_packets.size()); |
100 } | 101 } |
101 } | 102 } |
102 } | 103 } |
103 | 104 |
104 TEST_F(ProducerFecTest, OneFrameFec) { | 105 TEST_F(UlpfecGeneratorTest, OneFrameFec) { |
105 // The number of media packets (|kNumPackets|), number of frames (one for | 106 // The number of media packets (|kNumPackets|), number of frames (one for |
106 // this test), and the protection factor (|params->fec_rate|) are set to make | 107 // this test), and the protection factor (|params->fec_rate|) are set to make |
107 // sure the conditions for generating FEC are satisfied. This means: | 108 // sure the conditions for generating FEC are satisfied. This means: |
108 // (1) protection factor is high enough so that actual overhead over 1 frame | 109 // (1) protection factor is high enough so that actual overhead over 1 frame |
109 // of packets is within |kMaxExcessOverhead|, and (2) the total number of | 110 // of packets is within |kMaxExcessOverhead|, and (2) the total number of |
110 // media packets for 1 frame is at least |minimum_media_packets_fec_|. | 111 // media packets for 1 frame is at least |minimum_media_packets_fec_|. |
111 constexpr size_t kNumPackets = 4; | 112 constexpr size_t kNumPackets = 4; |
112 FecProtectionParams params = {15, 3, kFecMaskRandom}; | 113 FecProtectionParams params = {15, 3, kFecMaskRandom}; |
113 packet_generator_.NewFrame(kNumPackets); | 114 packet_generator_.NewFrame(kNumPackets); |
114 producer_.SetFecParameters(¶ms); // Expecting one FEC packet. | 115 ulpfec_generator_.SetFecParameters(¶ms); // Expecting one FEC packet. |
115 uint32_t last_timestamp = 0; | 116 uint32_t last_timestamp = 0; |
116 for (size_t i = 0; i < kNumPackets; ++i) { | 117 for (size_t i = 0; i < kNumPackets; ++i) { |
117 std::unique_ptr<AugmentedPacket> packet = | 118 std::unique_ptr<AugmentedPacket> packet = |
118 packet_generator_.NextPacket(i, 10); | 119 packet_generator_.NextPacket(i, 10); |
119 EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( | 120 EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec( |
120 packet->data, packet->length, kRtpHeaderSize)); | 121 packet->data, packet->length, kRtpHeaderSize)); |
121 last_timestamp = packet->header.header.timestamp; | 122 last_timestamp = packet->header.header.timestamp; |
122 } | 123 } |
123 EXPECT_TRUE(producer_.FecAvailable()); | 124 EXPECT_TRUE(ulpfec_generator_.FecAvailable()); |
124 uint16_t seq_num = packet_generator_.NextPacketSeqNum(); | 125 uint16_t seq_num = packet_generator_.NextPacketSeqNum(); |
125 std::vector<std::unique_ptr<RedPacket>> red_packets = | 126 std::vector<std::unique_ptr<RedPacket>> red_packets = |
126 producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, | 127 ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, |
127 kRtpHeaderSize); | 128 seq_num, kRtpHeaderSize); |
128 EXPECT_FALSE(producer_.FecAvailable()); | 129 EXPECT_FALSE(ulpfec_generator_.FecAvailable()); |
129 ASSERT_EQ(1u, red_packets.size()); | 130 ASSERT_EQ(1u, red_packets.size()); |
130 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, | 131 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, |
131 red_packets.front().get(), false); | 132 red_packets.front().get(), false); |
132 } | 133 } |
133 | 134 |
134 TEST_F(ProducerFecTest, TwoFrameFec) { | 135 TEST_F(UlpfecGeneratorTest, TwoFrameFec) { |
135 // The number of media packets/frame (|kNumPackets|), the number of frames | 136 // The number of media packets/frame (|kNumPackets|), the number of frames |
136 // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to | 137 // (|kNumFrames|), and the protection factor (|params->fec_rate|) are set to |
137 // make sure the conditions for generating FEC are satisfied. This means: | 138 // make sure the conditions for generating FEC are satisfied. This means: |
138 // (1) protection factor is high enough so that actual overhead over | 139 // (1) protection factor is high enough so that actual overhead over |
139 // |kNumFrames| is within |kMaxExcessOverhead|, and (2) the total number of | 140 // |kNumFrames| is within |kMaxExcessOverhead|, and (2) the total number of |
140 // media packets for |kNumFrames| frames is at least | 141 // media packets for |kNumFrames| frames is at least |
141 // |minimum_media_packets_fec_|. | 142 // |minimum_media_packets_fec_|. |
142 constexpr size_t kNumPackets = 2; | 143 constexpr size_t kNumPackets = 2; |
143 constexpr size_t kNumFrames = 2; | 144 constexpr size_t kNumFrames = 2; |
144 | 145 |
145 FecProtectionParams params = {15, 3, kFecMaskRandom}; | 146 FecProtectionParams params = {15, 3, kFecMaskRandom}; |
146 producer_.SetFecParameters(¶ms); // Expecting one FEC packet. | 147 ulpfec_generator_.SetFecParameters(¶ms); // Expecting one FEC packet. |
147 uint32_t last_timestamp = 0; | 148 uint32_t last_timestamp = 0; |
148 for (size_t i = 0; i < kNumFrames; ++i) { | 149 for (size_t i = 0; i < kNumFrames; ++i) { |
149 packet_generator_.NewFrame(kNumPackets); | 150 packet_generator_.NewFrame(kNumPackets); |
150 for (size_t j = 0; j < kNumPackets; ++j) { | 151 for (size_t j = 0; j < kNumPackets; ++j) { |
151 std::unique_ptr<AugmentedPacket> packet = | 152 std::unique_ptr<AugmentedPacket> packet = |
152 packet_generator_.NextPacket(i * kNumPackets + j, 10); | 153 packet_generator_.NextPacket(i * kNumPackets + j, 10); |
153 EXPECT_EQ(0, producer_.AddRtpPacketAndGenerateFec( | 154 EXPECT_EQ(0, ulpfec_generator_.AddRtpPacketAndGenerateFec( |
154 packet->data, packet->length, kRtpHeaderSize)); | 155 packet->data, packet->length, kRtpHeaderSize)); |
155 last_timestamp = packet->header.header.timestamp; | 156 last_timestamp = packet->header.header.timestamp; |
156 } | 157 } |
157 } | 158 } |
158 EXPECT_TRUE(producer_.FecAvailable()); | 159 EXPECT_TRUE(ulpfec_generator_.FecAvailable()); |
159 uint16_t seq_num = packet_generator_.NextPacketSeqNum(); | 160 uint16_t seq_num = packet_generator_.NextPacketSeqNum(); |
160 std::vector<std::unique_ptr<RedPacket>> red_packets = | 161 std::vector<std::unique_ptr<RedPacket>> red_packets = |
161 producer_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, seq_num, | 162 ulpfec_generator_.GetUlpfecPacketsAsRed(kRedPayloadType, kFecPayloadType, |
162 kRtpHeaderSize); | 163 seq_num, kRtpHeaderSize); |
163 EXPECT_FALSE(producer_.FecAvailable()); | 164 EXPECT_FALSE(ulpfec_generator_.FecAvailable()); |
164 ASSERT_EQ(1u, red_packets.size()); | 165 ASSERT_EQ(1u, red_packets.size()); |
165 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, | 166 VerifyHeader(seq_num, last_timestamp, kRedPayloadType, kFecPayloadType, |
166 red_packets.front().get(), false); | 167 red_packets.front().get(), false); |
167 } | 168 } |
168 | 169 |
169 TEST_F(ProducerFecTest, BuildRedPacket) { | 170 TEST_F(UlpfecGeneratorTest, BuildRedPacket) { |
170 packet_generator_.NewFrame(1); | 171 packet_generator_.NewFrame(1); |
171 std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10); | 172 std::unique_ptr<AugmentedPacket> packet = packet_generator_.NextPacket(0, 10); |
172 std::unique_ptr<RedPacket> red_packet = | 173 std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket( |
173 ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, | 174 packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize, |
174 kRtpHeaderSize, kRedPayloadType); | 175 kRedPayloadType); |
175 EXPECT_EQ(packet->length + 1, red_packet->length()); | 176 EXPECT_EQ(packet->length + 1, red_packet->length()); |
176 VerifyHeader(packet->header.header.sequenceNumber, | 177 VerifyHeader(packet->header.header.sequenceNumber, |
177 packet->header.header.timestamp, kRedPayloadType, | 178 packet->header.header.timestamp, kRedPayloadType, |
178 packet->header.header.payloadType, red_packet.get(), | 179 packet->header.header.payloadType, red_packet.get(), |
179 true); // Marker bit set. | 180 true); // Marker bit set. |
180 for (int i = 0; i < 10; ++i) { | 181 for (int i = 0; i < 10; ++i) { |
181 EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]); | 182 EXPECT_EQ(i, red_packet->data()[kRtpHeaderSize + 1 + i]); |
182 } | 183 } |
183 } | 184 } |
184 | 185 |
185 TEST_F(ProducerFecTest, BuildRedPacketWithEmptyPayload) { | 186 TEST_F(UlpfecGeneratorTest, BuildRedPacketWithEmptyPayload) { |
186 constexpr size_t kNumFrames = 1; | 187 constexpr size_t kNumFrames = 1; |
187 constexpr size_t kPayloadLength = 0; | 188 constexpr size_t kPayloadLength = 0; |
188 constexpr size_t kRedForFecHeaderLength = 1; | 189 constexpr size_t kRedForFecHeaderLength = 1; |
189 | 190 |
190 packet_generator_.NewFrame(kNumFrames); | 191 packet_generator_.NewFrame(kNumFrames); |
191 std::unique_ptr<AugmentedPacket> packet( | 192 std::unique_ptr<AugmentedPacket> packet( |
192 packet_generator_.NextPacket(0, kPayloadLength)); | 193 packet_generator_.NextPacket(0, kPayloadLength)); |
193 std::unique_ptr<RedPacket> red_packet = | 194 std::unique_ptr<RedPacket> red_packet = UlpfecGenerator::BuildRedPacket( |
194 ProducerFec::BuildRedPacket(packet->data, packet->length - kRtpHeaderSize, | 195 packet->data, packet->length - kRtpHeaderSize, kRtpHeaderSize, |
195 kRtpHeaderSize, kRedPayloadType); | 196 kRedPayloadType); |
196 EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length()); | 197 EXPECT_EQ(packet->length + kRedForFecHeaderLength, red_packet->length()); |
197 VerifyHeader(packet->header.header.sequenceNumber, | 198 VerifyHeader(packet->header.header.sequenceNumber, |
198 packet->header.header.timestamp, kRedPayloadType, | 199 packet->header.header.timestamp, kRedPayloadType, |
199 packet->header.header.payloadType, red_packet.get(), | 200 packet->header.header.payloadType, red_packet.get(), |
200 true); // Marker bit set. | 201 true); // Marker bit set. |
201 } | 202 } |
202 | 203 |
203 } // namespace webrtc | 204 } // namespace webrtc |
OLD | NEW |