OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
| 3 * |
| 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 |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 |
| 11 #include <vector> |
| 12 |
| 13 #include "webrtc/config.h" |
| 14 #include "webrtc/modules/rtp_rtcp/include/flexfec_sender.h" |
| 15 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| 16 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" |
| 17 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" |
| 18 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
| 19 #include "webrtc/system_wrappers/include/clock.h" |
| 20 #include "webrtc/test/gtest.h" |
| 21 |
| 22 namespace webrtc { |
| 23 |
| 24 namespace { |
| 25 |
| 26 using test::fec::AugmentedPacket; |
| 27 using test::fec::AugmentedPacketGenerator; |
| 28 |
| 29 constexpr int kFlexfecPayloadType = 123; |
| 30 constexpr uint32_t kMediaSsrc = 1234; |
| 31 constexpr uint32_t kFlexfecSsrc = 5678; |
| 32 const std::vector<RtpExtension> kNoRtpHeaderExtensions; |
| 33 // Assume a single protected media SSRC. |
| 34 constexpr size_t kFlexfecMaxHeaderSize = 32; |
| 35 constexpr size_t kPayloadLength = 50; |
| 36 |
| 37 constexpr int64_t kInitialSimulatedClockTime = 1; |
| 38 // These values are deterministically given by the PRNG, due to our fixed seed. |
| 39 // They should be updated if the PRNG implementation changes. |
| 40 constexpr uint16_t kDeterministicSequenceNumber = 28732; |
| 41 constexpr uint32_t kDeterministicTimestamp = 2305613085; |
| 42 |
| 43 std::unique_ptr<RtpPacketToSend> GenerateSingleFlexfecPacket( |
| 44 FlexfecSender* sender) { |
| 45 // Parameters selected to generate a single FEC packet. |
| 46 FecProtectionParams params; |
| 47 params.fec_rate = 15; |
| 48 params.max_fec_frames = 1; |
| 49 params.fec_mask_type = kFecMaskRandom; |
| 50 constexpr size_t kNumPackets = 4; |
| 51 |
| 52 sender->SetFecParameters(params); |
| 53 AugmentedPacketGenerator packet_generator(kMediaSsrc); |
| 54 packet_generator.NewFrame(kNumPackets); |
| 55 for (size_t i = 0; i < kNumPackets; ++i) { |
| 56 std::unique_ptr<AugmentedPacket> packet = |
| 57 packet_generator.NextPacket(i, kPayloadLength); |
| 58 RtpPacketToSend rtp_packet(nullptr); // No header extensions. |
| 59 rtp_packet.Parse(packet->data, packet->length); |
| 60 EXPECT_TRUE(sender->AddRtpPacketAndGenerateFec(rtp_packet)); |
| 61 } |
| 62 EXPECT_TRUE(sender->FecAvailable()); |
| 63 std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets = |
| 64 sender->GetFecPackets(); |
| 65 EXPECT_FALSE(sender->FecAvailable()); |
| 66 EXPECT_EQ(1U, fec_packets.size()); |
| 67 |
| 68 return std::move(fec_packets.front()); |
| 69 } |
| 70 |
| 71 } // namespace |
| 72 |
| 73 TEST(FlexfecSenderTest, NoFecAvailableBeforeMediaAdded) { |
| 74 SimulatedClock clock(kInitialSimulatedClockTime); |
| 75 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 76 kNoRtpHeaderExtensions, &clock); |
| 77 |
| 78 EXPECT_FALSE(sender.FecAvailable()); |
| 79 auto fec_packets = sender.GetFecPackets(); |
| 80 EXPECT_EQ(0U, fec_packets.size()); |
| 81 } |
| 82 |
| 83 TEST(FlexfecSenderTest, ProtectOneFrameWithOneFecPacket) { |
| 84 SimulatedClock clock(kInitialSimulatedClockTime); |
| 85 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 86 kNoRtpHeaderExtensions, &clock); |
| 87 auto fec_packet = GenerateSingleFlexfecPacket(&sender); |
| 88 |
| 89 EXPECT_EQ(kRtpHeaderSize, fec_packet->headers_size()); |
| 90 EXPECT_FALSE(fec_packet->Marker()); |
| 91 EXPECT_EQ(kFlexfecPayloadType, fec_packet->PayloadType()); |
| 92 EXPECT_EQ(kDeterministicSequenceNumber, fec_packet->SequenceNumber()); |
| 93 EXPECT_EQ(kDeterministicTimestamp, fec_packet->Timestamp()); |
| 94 EXPECT_EQ(kFlexfecSsrc, fec_packet->Ssrc()); |
| 95 EXPECT_LE(kPayloadLength, fec_packet->payload_size()); |
| 96 } |
| 97 |
| 98 TEST(FlexfecSenderTest, ProtectTwoFramesWithOneFecPacket) { |
| 99 // FEC parameters selected to generate a single FEC packet per frame. |
| 100 FecProtectionParams params; |
| 101 params.fec_rate = 15; |
| 102 params.max_fec_frames = 2; |
| 103 params.fec_mask_type = kFecMaskRandom; |
| 104 constexpr size_t kNumFrames = 2; |
| 105 constexpr size_t kNumPacketsPerFrame = 2; |
| 106 SimulatedClock clock(kInitialSimulatedClockTime); |
| 107 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 108 kNoRtpHeaderExtensions, &clock); |
| 109 sender.SetFecParameters(params); |
| 110 |
| 111 AugmentedPacketGenerator packet_generator(kMediaSsrc); |
| 112 for (size_t i = 0; i < kNumFrames; ++i) { |
| 113 packet_generator.NewFrame(kNumPacketsPerFrame); |
| 114 for (size_t j = 0; j < kNumPacketsPerFrame; ++j) { |
| 115 std::unique_ptr<AugmentedPacket> packet = |
| 116 packet_generator.NextPacket(i, kPayloadLength); |
| 117 RtpPacketToSend rtp_packet(nullptr); |
| 118 rtp_packet.Parse(packet->data, packet->length); |
| 119 EXPECT_TRUE(sender.AddRtpPacketAndGenerateFec(rtp_packet)); |
| 120 } |
| 121 } |
| 122 EXPECT_TRUE(sender.FecAvailable()); |
| 123 std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets = |
| 124 sender.GetFecPackets(); |
| 125 EXPECT_FALSE(sender.FecAvailable()); |
| 126 ASSERT_EQ(1U, fec_packets.size()); |
| 127 |
| 128 RtpPacketToSend* fec_packet = fec_packets.front().get(); |
| 129 EXPECT_EQ(kRtpHeaderSize, fec_packet->headers_size()); |
| 130 EXPECT_FALSE(fec_packet->Marker()); |
| 131 EXPECT_EQ(kFlexfecPayloadType, fec_packet->PayloadType()); |
| 132 EXPECT_EQ(kDeterministicSequenceNumber, fec_packet->SequenceNumber()); |
| 133 EXPECT_EQ(kDeterministicTimestamp, fec_packet->Timestamp()); |
| 134 EXPECT_EQ(kFlexfecSsrc, fec_packet->Ssrc()); |
| 135 } |
| 136 |
| 137 TEST(FlexfecSenderTest, ProtectTwoFramesWithTwoFecPackets) { |
| 138 // FEC parameters selected to generate a single FEC packet per frame. |
| 139 FecProtectionParams params; |
| 140 params.fec_rate = 30; |
| 141 params.max_fec_frames = 1; |
| 142 params.fec_mask_type = kFecMaskRandom; |
| 143 constexpr size_t kNumFrames = 2; |
| 144 constexpr size_t kNumPacketsPerFrame = 2; |
| 145 SimulatedClock clock(kInitialSimulatedClockTime); |
| 146 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 147 kNoRtpHeaderExtensions, &clock); |
| 148 sender.SetFecParameters(params); |
| 149 |
| 150 AugmentedPacketGenerator packet_generator(kMediaSsrc); |
| 151 for (size_t i = 0; i < kNumFrames; ++i) { |
| 152 packet_generator.NewFrame(kNumPacketsPerFrame); |
| 153 for (size_t j = 0; j < kNumPacketsPerFrame; ++j) { |
| 154 std::unique_ptr<AugmentedPacket> packet = |
| 155 packet_generator.NextPacket(i, kPayloadLength); |
| 156 RtpPacketToSend rtp_packet(nullptr); |
| 157 rtp_packet.Parse(packet->data, packet->length); |
| 158 EXPECT_TRUE(sender.AddRtpPacketAndGenerateFec(rtp_packet)); |
| 159 } |
| 160 EXPECT_TRUE(sender.FecAvailable()); |
| 161 std::vector<std::unique_ptr<RtpPacketToSend>> fec_packets = |
| 162 sender.GetFecPackets(); |
| 163 EXPECT_FALSE(sender.FecAvailable()); |
| 164 ASSERT_EQ(1U, fec_packets.size()); |
| 165 |
| 166 RtpPacketToSend* fec_packet = fec_packets.front().get(); |
| 167 EXPECT_EQ(kRtpHeaderSize, fec_packet->headers_size()); |
| 168 EXPECT_FALSE(fec_packet->Marker()); |
| 169 EXPECT_EQ(kFlexfecPayloadType, fec_packet->PayloadType()); |
| 170 EXPECT_EQ(static_cast<uint16_t>(kDeterministicSequenceNumber + i), |
| 171 fec_packet->SequenceNumber()); |
| 172 EXPECT_EQ(kDeterministicTimestamp, fec_packet->Timestamp()); |
| 173 EXPECT_EQ(kFlexfecSsrc, fec_packet->Ssrc()); |
| 174 } |
| 175 } |
| 176 |
| 177 // In the tests, we only consider RTP header extensions that are useful for BWE. |
| 178 TEST(FlexfecSenderTest, NoRtpHeaderExtensionsForBweByDefault) { |
| 179 const std::vector<RtpExtension> kRtpHeaderExtensions{}; |
| 180 SimulatedClock clock(kInitialSimulatedClockTime); |
| 181 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 182 kRtpHeaderExtensions, &clock); |
| 183 auto fec_packet = GenerateSingleFlexfecPacket(&sender); |
| 184 |
| 185 EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>()); |
| 186 EXPECT_FALSE(fec_packet->HasExtension<TransmissionOffset>()); |
| 187 EXPECT_FALSE(fec_packet->HasExtension<TransportSequenceNumber>()); |
| 188 } |
| 189 |
| 190 TEST(FlexfecSenderTest, RegisterAbsoluteSendTimeRtpHeaderExtension) { |
| 191 const std::vector<RtpExtension> kRtpHeaderExtensions{ |
| 192 {RtpExtension::kAbsSendTimeUri, 1}}; |
| 193 SimulatedClock clock(kInitialSimulatedClockTime); |
| 194 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 195 kRtpHeaderExtensions, &clock); |
| 196 auto fec_packet = GenerateSingleFlexfecPacket(&sender); |
| 197 |
| 198 EXPECT_TRUE(fec_packet->HasExtension<AbsoluteSendTime>()); |
| 199 EXPECT_FALSE(fec_packet->HasExtension<TransmissionOffset>()); |
| 200 EXPECT_FALSE(fec_packet->HasExtension<TransportSequenceNumber>()); |
| 201 } |
| 202 |
| 203 TEST(FlexfecSenderTest, RegisterTransmissionOffsetRtpHeaderExtension) { |
| 204 const std::vector<RtpExtension> kRtpHeaderExtensions{ |
| 205 {RtpExtension::kTimestampOffsetUri, 1}}; |
| 206 SimulatedClock clock(kInitialSimulatedClockTime); |
| 207 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 208 kRtpHeaderExtensions, &clock); |
| 209 auto fec_packet = GenerateSingleFlexfecPacket(&sender); |
| 210 |
| 211 EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>()); |
| 212 EXPECT_TRUE(fec_packet->HasExtension<TransmissionOffset>()); |
| 213 EXPECT_FALSE(fec_packet->HasExtension<TransportSequenceNumber>()); |
| 214 } |
| 215 |
| 216 TEST(FlexfecSenderTest, RegisterTransportSequenceNumberRtpHeaderExtension) { |
| 217 const std::vector<RtpExtension> kRtpHeaderExtensions{ |
| 218 {RtpExtension::kTransportSequenceNumberUri, 1}}; |
| 219 SimulatedClock clock(kInitialSimulatedClockTime); |
| 220 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 221 kRtpHeaderExtensions, &clock); |
| 222 auto fec_packet = GenerateSingleFlexfecPacket(&sender); |
| 223 |
| 224 EXPECT_FALSE(fec_packet->HasExtension<AbsoluteSendTime>()); |
| 225 EXPECT_FALSE(fec_packet->HasExtension<TransmissionOffset>()); |
| 226 EXPECT_TRUE(fec_packet->HasExtension<TransportSequenceNumber>()); |
| 227 } |
| 228 |
| 229 TEST(FlexfecSenderTest, RegisterAllRtpHeaderExtensionsForBwe) { |
| 230 const std::vector<RtpExtension> kRtpHeaderExtensions{ |
| 231 {RtpExtension::kAbsSendTimeUri, 1}, |
| 232 {RtpExtension::kTimestampOffsetUri, 2}, |
| 233 {RtpExtension::kTransportSequenceNumberUri, 3}}; |
| 234 SimulatedClock clock(kInitialSimulatedClockTime); |
| 235 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 236 kRtpHeaderExtensions, &clock); |
| 237 auto fec_packet = GenerateSingleFlexfecPacket(&sender); |
| 238 |
| 239 EXPECT_TRUE(fec_packet->HasExtension<AbsoluteSendTime>()); |
| 240 EXPECT_TRUE(fec_packet->HasExtension<TransmissionOffset>()); |
| 241 EXPECT_TRUE(fec_packet->HasExtension<TransportSequenceNumber>()); |
| 242 } |
| 243 |
| 244 TEST(FlexfecSenderTest, MaxPacketOverhead) { |
| 245 SimulatedClock clock(kInitialSimulatedClockTime); |
| 246 FlexfecSender sender(kFlexfecPayloadType, kFlexfecSsrc, kMediaSsrc, |
| 247 kNoRtpHeaderExtensions, &clock); |
| 248 |
| 249 EXPECT_EQ(kFlexfecMaxHeaderSize, sender.MaxPacketOverhead()); |
| 250 } |
| 251 |
| 252 } // namespace webrtc |
OLD | NEW |