rtp_format_unittest.cc (9421B)
1 /* 2 * Copyright (c) 2018 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 "modules/rtp_rtcp/source/rtp_format.h" 12 13 #include <vector> 14 15 #include "absl/algorithm/container.h" 16 #include "test/gmock.h" 17 #include "test/gtest.h" 18 19 namespace webrtc { 20 namespace { 21 22 using ::testing::Each; 23 using ::testing::ElementsAre; 24 using ::testing::Gt; 25 using ::testing::IsEmpty; 26 using ::testing::Le; 27 using ::testing::Not; 28 using ::testing::SizeIs; 29 30 // Calculate difference between largest and smallest packets respecting sizes 31 // adjustement provided by limits, 32 // i.e. last packet expected to be smaller than 'average' by reduction_len. 33 int EffectivePacketsSizeDifference( 34 std::vector<int> sizes, 35 const RtpPacketizer::PayloadSizeLimits& limits) { 36 // Account for larger last packet header. 37 sizes.back() += limits.last_packet_reduction_len; 38 39 auto minmax = absl::c_minmax_element(sizes); 40 // MAX-MIN 41 return *minmax.second - *minmax.first; 42 } 43 44 int Sum(const std::vector<int>& sizes) { 45 return absl::c_accumulate(sizes, 0); 46 } 47 48 TEST(RtpPacketizerSplitAboutEqually, AllPacketsAreEqualSumToPayloadLen) { 49 RtpPacketizer::PayloadSizeLimits limits; 50 limits.max_payload_len = 5; 51 limits.last_packet_reduction_len = 2; 52 53 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(13, limits); 54 55 EXPECT_THAT(Sum(payload_sizes), 13); 56 } 57 58 TEST(RtpPacketizerSplitAboutEqually, AllPacketsAreEqualRespectsMaxPayloadSize) { 59 RtpPacketizer::PayloadSizeLimits limits; 60 limits.max_payload_len = 5; 61 limits.last_packet_reduction_len = 2; 62 63 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(13, limits); 64 65 EXPECT_THAT(payload_sizes, Each(Le(limits.max_payload_len))); 66 } 67 68 TEST(RtpPacketizerSplitAboutEqually, 69 AllPacketsAreEqualRespectsFirstPacketReduction) { 70 RtpPacketizer::PayloadSizeLimits limits; 71 limits.max_payload_len = 5; 72 limits.first_packet_reduction_len = 2; 73 74 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(13, limits); 75 76 ASSERT_THAT(payload_sizes, Not(IsEmpty())); 77 EXPECT_EQ(payload_sizes.front() + limits.first_packet_reduction_len, 78 limits.max_payload_len); 79 } 80 81 TEST(RtpPacketizerSplitAboutEqually, 82 AllPacketsAreEqualRespectsLastPacketReductionLength) { 83 RtpPacketizer::PayloadSizeLimits limits; 84 limits.max_payload_len = 5; 85 limits.last_packet_reduction_len = 2; 86 87 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(13, limits); 88 89 ASSERT_THAT(payload_sizes, Not(IsEmpty())); 90 EXPECT_LE(payload_sizes.back() + limits.last_packet_reduction_len, 91 limits.max_payload_len); 92 } 93 94 TEST(RtpPacketizerSplitAboutEqually, AllPacketsAreEqualInSize) { 95 RtpPacketizer::PayloadSizeLimits limits; 96 limits.max_payload_len = 5; 97 limits.last_packet_reduction_len = 2; 98 99 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(13, limits); 100 101 EXPECT_EQ(EffectivePacketsSizeDifference(payload_sizes, limits), 0); 102 } 103 104 TEST(RtpPacketizerSplitAboutEqually, 105 AllPacketsAreEqualGeneratesMinimumNumberOfPackets) { 106 RtpPacketizer::PayloadSizeLimits limits; 107 limits.max_payload_len = 5; 108 limits.last_packet_reduction_len = 2; 109 110 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(13, limits); 111 // Computed by hand. 3 packets would have exactly capacity 3*5-2=13 112 // (max length - for each packet minus last packet reduction). 113 EXPECT_THAT(payload_sizes, SizeIs(3)); 114 } 115 116 TEST(RtpPacketizerSplitAboutEqually, SomePacketsAreSmallerSumToPayloadLen) { 117 RtpPacketizer::PayloadSizeLimits limits; 118 limits.max_payload_len = 7; 119 limits.last_packet_reduction_len = 5; 120 121 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(28, limits); 122 123 EXPECT_THAT(Sum(payload_sizes), 28); 124 } 125 126 TEST(RtpPacketizerSplitAboutEqually, 127 SomePacketsAreSmallerRespectsMaxPayloadSize) { 128 RtpPacketizer::PayloadSizeLimits limits; 129 limits.max_payload_len = 7; 130 limits.last_packet_reduction_len = 5; 131 132 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(28, limits); 133 134 EXPECT_THAT(payload_sizes, Each(Le(limits.max_payload_len))); 135 } 136 137 TEST(RtpPacketizerSplitAboutEqually, 138 SomePacketsAreSmallerRespectsFirstPacketReduction) { 139 RtpPacketizer::PayloadSizeLimits limits; 140 limits.max_payload_len = 7; 141 limits.first_packet_reduction_len = 5; 142 143 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(28, limits); 144 145 EXPECT_LE(payload_sizes.front() + limits.first_packet_reduction_len, 146 limits.max_payload_len); 147 } 148 149 TEST(RtpPacketizerSplitAboutEqually, 150 SomePacketsAreSmallerRespectsLastPacketReductionLength) { 151 RtpPacketizer::PayloadSizeLimits limits; 152 limits.max_payload_len = 7; 153 limits.last_packet_reduction_len = 5; 154 155 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(28, limits); 156 157 EXPECT_LE(payload_sizes.back(), 158 limits.max_payload_len - limits.last_packet_reduction_len); 159 } 160 161 TEST(RtpPacketizerSplitAboutEqually, 162 SomePacketsAreSmallerPacketsAlmostEqualInSize) { 163 RtpPacketizer::PayloadSizeLimits limits; 164 limits.max_payload_len = 7; 165 limits.last_packet_reduction_len = 5; 166 167 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(28, limits); 168 169 EXPECT_LE(EffectivePacketsSizeDifference(payload_sizes, limits), 1); 170 } 171 172 TEST(RtpPacketizerSplitAboutEqually, 173 SomePacketsAreSmallerGeneratesMinimumNumberOfPackets) { 174 RtpPacketizer::PayloadSizeLimits limits; 175 limits.max_payload_len = 7; 176 limits.last_packet_reduction_len = 5; 177 178 std::vector<int> payload_sizes = RtpPacketizer::SplitAboutEqually(24, limits); 179 // Computed by hand. 4 packets would have capacity 4*7-5=23 (max length - 180 // for each packet minus last packet reduction). 181 // 5 packets is enough for kPayloadSize. 182 EXPECT_THAT(payload_sizes, SizeIs(5)); 183 } 184 185 TEST(RtpPacketizerSplitAboutEqually, GivesNonZeroPayloadLengthEachPacket) { 186 RtpPacketizer::PayloadSizeLimits limits; 187 limits.max_payload_len = 600; 188 limits.first_packet_reduction_len = 500; 189 limits.last_packet_reduction_len = 550; 190 191 // Naive implementation would split 1450 payload + 1050 reduction bytes into 5 192 // packets 500 bytes each, thus leaving first packet zero bytes and even less 193 // to last packet. 194 std::vector<int> payload_sizes = 195 RtpPacketizer::SplitAboutEqually(1450, limits); 196 197 EXPECT_EQ(Sum(payload_sizes), 1450); 198 EXPECT_THAT(payload_sizes, Each(Gt(0))); 199 } 200 201 TEST(RtpPacketizerSplitAboutEqually, 202 IgnoresFirstAndLastPacketReductionWhenPayloadFitsIntoSinglePacket) { 203 RtpPacketizer::PayloadSizeLimits limits; 204 limits.max_payload_len = 30; 205 limits.first_packet_reduction_len = 29; 206 limits.last_packet_reduction_len = 29; 207 limits.single_packet_reduction_len = 10; 208 209 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), ElementsAre(20)); 210 } 211 212 TEST(RtpPacketizerSplitAboutEqually, 213 OnePacketWhenExtraSpaceIsEnoughForSinglePacketReduction) { 214 RtpPacketizer::PayloadSizeLimits limits; 215 limits.max_payload_len = 30; 216 limits.single_packet_reduction_len = 10; 217 218 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), ElementsAre(20)); 219 } 220 221 TEST(RtpPacketizerSplitAboutEqually, 222 TwoPacketsWhenExtraSpaceIsTooSmallForSinglePacketReduction) { 223 RtpPacketizer::PayloadSizeLimits limits; 224 limits.max_payload_len = 29; 225 limits.first_packet_reduction_len = 3; 226 limits.last_packet_reduction_len = 1; 227 limits.single_packet_reduction_len = 10; 228 229 // First packet needs two more extra bytes compared to last one, 230 // so should have two less payload bytes. 231 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), ElementsAre(9, 11)); 232 } 233 234 TEST(RtpPacketizerSplitAboutEqually, RejectsZeroMaxPayloadLen) { 235 RtpPacketizer::PayloadSizeLimits limits; 236 limits.max_payload_len = 0; 237 238 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), IsEmpty()); 239 } 240 241 TEST(RtpPacketizerSplitAboutEqually, RejectsZeroFirstPacketLen) { 242 RtpPacketizer::PayloadSizeLimits limits; 243 limits.max_payload_len = 5; 244 limits.first_packet_reduction_len = 5; 245 246 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), IsEmpty()); 247 } 248 249 TEST(RtpPacketizerSplitAboutEqually, RejectsZeroLastPacketLen) { 250 RtpPacketizer::PayloadSizeLimits limits; 251 limits.max_payload_len = 5; 252 limits.last_packet_reduction_len = 5; 253 254 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(20, limits), IsEmpty()); 255 } 256 257 TEST(RtpPacketizerSplitAboutEqually, CantPutSinglePayloadByteInTwoPackets) { 258 RtpPacketizer::PayloadSizeLimits limits; 259 limits.max_payload_len = 10; 260 limits.single_packet_reduction_len = 10; 261 262 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(1, limits), IsEmpty()); 263 } 264 265 TEST(RtpPacketizerSplitAboutEqually, CanPutTwoPayloadBytesInTwoPackets) { 266 RtpPacketizer::PayloadSizeLimits limits; 267 limits.max_payload_len = 10; 268 limits.single_packet_reduction_len = 10; 269 270 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(2, limits), ElementsAre(1, 1)); 271 } 272 273 TEST(RtpPacketizerSplitAboutEqually, CanPutSinglePayloadByteInOnePacket) { 274 RtpPacketizer::PayloadSizeLimits limits; 275 limits.max_payload_len = 11; 276 limits.single_packet_reduction_len = 10; 277 278 EXPECT_THAT(RtpPacketizer::SplitAboutEqually(1, limits), ElementsAre(1)); 279 } 280 281 } // namespace 282 } // namespace webrtc